widget gwt - bouton à bascule mutuellement exclusif

Question

Je veux un hybride d'un ToggleButton et RadioButton. Je veux la partie "mutuellement exclusive" de RadioButton, ainsi que l'apparence et le comportement de ToggleButton (états haut et bas). Existe-t-il déjà?

Answer 1

J'ai ADAPTÉ années kirushik solution et créé un widget "ToggleButtonPanel" simple qui prend un nombre arbitraire de ToggleButtons (et éventuellement d'autres widgets que vous souhaitez ajouter) et un panneau de votre choix (par défaut à VerticalPanel) et rend les boutons mutuellement exclusifs.

Ce qui est bien, c'est que le panneau lui-même déclenche ClickEvents lorsque les boutons sont cliqués. De cette façon, vous pouvez ajouter un seul clickHandler à la ToggleGroupPanel puis déterminer quel bouton a été cliqué à l'aide event.getSource()

import java.util.ArrayList; 
import java.util.Iterator; 
import java.util.List; 

import com.google.gwt.event.dom.client.ClickEvent; 
import com.google.gwt.event.dom.client.ClickHandler; 
import com.google.gwt.event.dom.client.HasClickHandlers; 
import com.google.gwt.event.shared.HandlerRegistration; 
import com.google.gwt.user.client.ui.Composite; 
import com.google.gwt.user.client.ui.HasWidgets; 
import com.google.gwt.user.client.ui.Panel; 
import com.google.gwt.user.client.ui.ToggleButton; 
import com.google.gwt.user.client.ui.VerticalPanel; 
import com.google.gwt.user.client.ui.Widget; 

public class ToggleButtonPanel extends Composite implements HasWidgets, HasClickHandlers{ 

    public ToggleButtonPanel() { 
     this(new VerticalPanel()); 
    } 

    public ToggleButtonPanel(Panel panel){ 
     this.panel = panel; 
     initWidget(panel); 
    } 

    @Override 
    public void add(Widget w) { 
     if(w instanceof ToggleButton){ 
      ToggleButton button = (ToggleButton) w; 
      button.addClickHandler(handler); 
     } 
     panel.add(w); 
    } 

    @Override 
    public void clear() { 
     panel.clear(); 
    } 

    @Override 
    public Iterator<Widget> iterator() { 
     return panel.iterator(); 
    } 

    @Override 
    public boolean remove(Widget w) { 
     return panel.remove(w); 
    } 

    @Override 
    public void setWidth(String width) { 
     panel.setWidth(width); 
    }; 

    @Override 
    public void setHeight(String height) { 
     panel.setHeight(height); 
    } 

    private final Panel panel; 
    private ClickHandler handler = new ClickHandler(){ 
     @Override 
     public void onClick(ClickEvent event) { 
      Iterator<Widget> itr = panel.iterator(); 
      while(itr.hasNext()){ 
       Widget w = itr.next(); 
       if(w instanceof ToggleButton){ 
        ToggleButton button = (ToggleButton) w; 
        button.setDown(false); 
        if(event.getSource().equals(button)) { 
         button.setDown(true); 
        } 
       } 
      } 

      for(ClickHandler h : handlers){ 
       h.onClick(event); 
      } 
     } 
    }; 

    private List<ClickHandler> handlers = new ArrayList<ClickHandler>(); 
    @Override 
    public HandlerRegistration addClickHandler(final ClickHandler handler) { 
     handlers.add(handler); 
     return new HandlerRegistration() { 

      @Override 
      public void removeHandler() { 
       handlers.remove(handler); 
      } 
     }; 
    } 

} 

Answer 2

gwt-ext toggleButtons

« Cet exemple illustre les boutons à bascule. Lorsque vous cliquez dessus, ces boutons à bascule leur état « pressé ».

Gras, Italique et Souligné boutons à bascule fonctionnent indépendamment par rapport à leur état de bascule alors que la icône d'alignement de texte Les boutons appartiennent au même groupe de bascules et donc lorsque l'un d'eux est cliqué, le bouton précédemment pressé revient à son état normal. "

Answer 3

Voici ma variante pure GWT:

class ThreeStateMachine extends FlowPanel{ 
     // This is the main part - it will unset all the buttons in parent widget 
     // and then set only clicked one. 
     // One mutual handler works faster and is generally better for code reuse 
     private final ClickHandler toggleToThis = new ClickHandler() { 
       @Override 
       public void onClick(ClickEvent clickEvent) { 
        for(Widget b: ThreeStateMachine.this.getChildren()){ 
         ((ToggleButton)b).setDown(false); 
        } 
        ((ToggleButton)clickEvent.getSource()).setDown(true); 
       } 
      }; 

     private ThreeStateMachine() { // Create out widget and populat it with buttons 
      super(); 

      ToggleButton b = new ToggleButton("one"); 
      b.setDown(true); 
      b.addClickHandler(toggleToThis); 
      this.add(b); 

      b = new ToggleButton("two"); 
      b.addClickHandler(toggleToThis); 
      this.add(b); 

      b = new ToggleButton("three"); 
      b.addClickHandler(toggleToThis); 
      this.add(b); 
     } 
    } 

Sûrement, ont besoin one'll styles CSS pour GWT-ToggleButton avec des variantes (-up-vol stationnaire, etc.)

Answer 4

J'ai quelque chose qui est à la fois pas dans une bibliothèque d'extension, et non dépendant d'un panneau comme les autres réponses. Définissez cette classe qui gère les boutons. Nous ajoutons un nouvel écouteur de clic aux boutons, qui s'ajoute à tout gestionnaire de clics que vous avez joint dans la classe "Contenu de l'interface graphique". Je ne peux pas copier et coller ceci, donc j'espère que c'est syntaxiquement correct.

public class MutuallyExclusiveToggleButtonCollection { 

     List<ToggleButton> m_toggleButtons = new ArrayList<ToggleButton>(); 

     public void add(ToggleButton button) { 
      m_toggleButtons.add(button); 
      button.addClickListener(new ExclusiveButtonClickHandler()); 
    } 

    private class ExclusiveButtonClickHandler impelments ClickHandler { 
     public void onClick(ClickEvent event) { 
      for(ToggleButton button : m_toggleButtons) { 
      boolean isSource = event.getSource().equals(button); 
      button.setIsDown(isSource);  
     } 

    } 

    } 

Answer 5

Enregistrez un ClickHandler supplémentaire sur tous les ToggleButtons. Par exemple, ToggleButtons home, tree, summary, detail.

public class Abc extends Composite implements ClickHandler { 
     ToggleButton home, tree, summary, detail 
     public Abc() { 
      // all your UiBinder initializations... blah, blah.... 
      home.addClickHandler(this); 
      tree.addClickHandler(this); 
      summary.addClickHandler(this); 
      detail.addClickHandler(this); 
     } 
     @Override 
     public void onClick(ClickEvent p_event) { 
      Object v_source = p_event.getSource();   
      home.setDown(home==v_source); 
      tree.setDown(tree==v_source); 
      summary.setDown(summary==v_source); 
      detail.setDown(detail==v_source); 
     } 
} 

Bien sûr, il vous suffit d'ajouter tous les autres code et inscrivez-vous boilerplate ClickHandlers supplémentaires pour chaque ToggleButton.

Answer 6

suis tombé sur le même besoin, Heres une autre solution qui élimine le gestionnaire séparé et fonctionne bien dans UIBinder avec une telle déclaration:

<my:RadioToggleButton buttonGroup="btnGroup" text="Button 1" /> 

Voici la classe étendue:

import java.util.HashMap; 

import com.google.gwt.event.dom.client.ClickEvent; 
import com.google.gwt.event.dom.client.ClickHandler; 
import com.google.gwt.uibinder.client.UiConstructor; 
import com.google.gwt.user.client.ui.ToggleButton; 

public class RadioToggleButton extends ToggleButton 
{ 
    private static HashMap<String,ButtonGroup> buttonGroups = new HashMap<>(); 
    private ButtonGroup buttonGroup; 

    public @UiConstructor RadioToggleButton(String buttonGroupName) 
    { 
     buttonGroup = buttonGroups.get(buttonGroupName); 
     if(buttonGroup == null){ 
      buttonGroups.put(buttonGroupName, buttonGroup = new ButtonGroup()); 
     } 
     buttonGroup.addButton(this); 
    } 

    @Override 
    public void setDown(boolean isDown) 
    { 
     if(isDown){ 
      RadioToggleButton btn = buttonGroup.pressedBtn; 
      if(btn != null){ 
       btn.setDown(false); 
      } 
      buttonGroup.pressedBtn = this; 
     } 
     super.setDown(isDown); 
    } 

    private class ButtonGroup implements ClickHandler 
    { 
     RadioToggleButton pressedBtn = null; 

     public void addButton(ToggleButton button) 
     { 
      button.addClickHandler(this); 
     } 

     @Override 
     public void onClick(ClickEvent event) 
     { 
      Object obj = event.getSource(); 
      if(pressedBtn != null){ 
       pressedBtn.setDown(false); 
      } 
      pressedBtn = (RadioToggleButton)obj; 
      pressedBtn.setDown(true); 
     } 
    } 
}