Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package org.pentaho.ui.xul.jface.tags;
  
  import java.util.HashMap;
  import java.util.List;
  import java.util.Map;
  
 import  org.eclipse.jface.action.IContributionItem;
 import  org.eclipse.swt.SWT;
 import  org.eclipse.swt.events.SelectionAdapter;
 import  org.eclipse.swt.events.SelectionEvent;
 import  org.eclipse.swt.events.ModifyListener;
 import  org.eclipse.swt.events.ModifyEvent;
 import  org.eclipse.swt.widgets.Combo;
 import  org.eclipse.swt.widgets.Composite;
 
 //TODO: Move creation of combobox to late initialization to support switching from editable to non-editable.
 public class JfaceMenuList<T> extends AbstractSwtXulContainer implements XulMenuList<T> {
 
   private Combo combobox;
 
 
   private static final Log logger = LogFactory.getLog(JfaceMenuList.class);
 
   private String binding;
 
   private Object previousSelectedItem = null;
   private String previousValue;
   
   private JfaceMenupopup popup;
   
   private JfaceMenuitem selectedItem = null;
   private List elements = null;
 
   private boolean editable = false;
   
   private String command;
 
   private XulComponent parent;
 
   public JfaceMenuList(Element selfXulComponent parentXulDomContainer domContainerString tagName) {
     super("menulist");
     this. = domContainer;
     this. = parent;
     setEditable("true".equals(self.getAttributeValue("editable")));
     setupCombobox();
   }
 
 
   private void setupCombobox(){
     int style = SWT.DROP_DOWN;
     if (!style |= SWT.READ_ONLY;
      = new Combo((Composite).getManagedObject(), style);
 
 
     .addSelectionListener(new SelectionAdapter() {
       public void widgetSelected(SelectionEvent e) {
         fireSelectedEvents();
       }
     });
     
     .addModifyListener(new ModifyListener(){
       public void modifyText(ModifyEvent modifyEvent) {
         fireModifiedEvents();
       }
     });
   }
   
 
   @Override
   public void addChild(Element ele) {
     super.addChild(ele);
     if(!(ele instanceof XulMenupopup)) return;
      = (JfaceMenupopupele;
     int index = -1;
     int selectedIndex = index;
     forXulComponent child : .getChildNodes() ) {
       index++;
       if(!(child instanceof JfaceMenuitem)) {
         continue;
       }
       if(((JfaceMenuitemchild).isSelected()) {
         .select(index);
         selectedIndex = index;
      }
    }
    setSelectedIndex(selectedIndex);
  }
  public void layout() {
    JfaceMenuitem selectedItem;
    int i = 0;
    int index = -1;
    .removeAll();
    for (XulComponent item : .getChildNodes()) {
      JfaceMenuitem mItem = (JfaceMenuitemitem;
      if(mItem.isVisible()){
        .add(mItem.getLabel());
      }
      if (mItem.isSelected()) {
        .select(i);
        index = i;
      }
      i++;
    }
    if (index == -1) {
      if (getEditable()) {
        setValue();
      }
      else {
        setSelectedIndex(0);
      }
    }
    this..update();
  }
  /*
   * Swaps out the managed list.  Effectively replaces the SwingMenupopup child component.
   * (non-Javadoc)
   * @see org.pentaho.ui.xul.components.XulMenuList#replaceAll(java.util.List)
   */
  public void replaceAllItems(Collection<T> tees) {
    setElements(tees);
  }
  public void setOncommand(final String command) {
    this. = command;
  }
  public Collection<T> getElements() {
    List<T> elements = null;
    if (this. == null) {
      if ( == null) {
        elements = null;
      }
      else {
        elements = (List<T>).getChildNodes();
      }
    }
    else {
      elements = this.;
    }
    return elements;
  }
  public String getBinding() {
    return ;
  }
  public void setBinding(String binding) {
    this. = binding;
  }
  private String extractLabel(T t) {
    String attribute = getBinding();
    if (StringUtils.isEmpty(attribute)) {
      return t.toString();
    } else {
      String getter = "get" + (String.valueOf(attribute.charAt(0)).toUpperCase()) + attribute.substring(1);
      try {
        return new Expression(tgetternull).getValue().toString();
      } catch (Exception e) {
        throw new RuntimeException(e);
      }
    }
  }
  public void setElements(Collection<T> tees) {
    XulMenuitem menuitem;
    List<XulComponentmenuItems = .getChildNodes();
     = (List<T>)tees;
    int index = 0;
    int itemCount = menuItems.size();
    //loop over new elements
    for (T t : tees) {
      //obtain an item
      if (index < itemCount) {
        //item exists, reuse it
        menuitem = (XulMenuitemmenuItems.get(index);
        menuitem.setVisible(true);
      }
      else {
        //item doesn't exist, create one
        menuitem = .createNewMenuitemAtPos(index);
      }
      index++;
      //update item
      menuitem.setLabel(extractLabel(t));
    }
    //hide remaining existing items
    for (; index < itemCountindex++) menuItems.get(index).setVisible(false);
    layout();
  }
  public String getSelectedItem() {
    int idx = .getSelectionIndex();
    return (idx > -1 && idx < this..getItemCount())? this..getItem(idx) : null;
  }
  public void setSelectedItem(T t) {
    int index;
    List<T> elements = (List<T>)getElements();
    if(t == null){
      index = -1;
    }
    else 
    if (elements == null) {
      index = .indexOf(t.toString());
    }
    else {
      index = elements.indexOf(t);
    }
    setSelectedIndex(index);
  }
  public int getSelectedIndex() {
    int selectedIndex;
    Collection elements = getElements();
    if (elements == null || elements.size() == 0) {
      selectedIndex = -1;
    }
    else {
      selectedIndex = this..getSelectionIndex();
    }
    return selectedIndex;
  }
  public void setSelectedIndex(int idx) {
    if(idx == -1){
      .clearSelection();
    } else {
      .select(idx);
    }
  }
  
  public void removeChild(Element ele) {
    String selected = this.getSelectedItem();
    super.removeChild(ele);
    if (selected == nullreturn;
    Collection<T> elist = getElements();
    for( T t : elist ) {
      if (selected.equals(t.toString())) setSelectedItem(t);
    }
  }
  private void fireSelectedEvents(){
    int idx = getSelectedIndex();
    Collection elements = getElements();
    
    if(idx >= 0){
      Object newSelectedItem = (elements == null)? null : elements.toArray()[idx];
      .firePropertyChange("selectedItem"newSelectedItem);
      this. = newSelectedItem;
    }
    
    .firePropertyChange("selectedIndex"null.getSelectionIndex());
    if(JfaceMenuList.this. != null
        && getDocument() != null){    //make sure we're on the dom tree (initialized)
      invoke(JfaceMenuList.this.new Object[] {});
    }
  }
  
  private void fireModifiedEvents(){
    String newValue = getValue();
    .firePropertyChange("value"newValue);
     = newValue;
  }
  public void setEditable(boolean editable) {
    this. = editable;
  }
  public boolean getEditable() {
    return ;
  }
  public String getValue() {
    return .getText();
  }
  public void setValue(String value) {
    if (value == nullvalue = "";
    .setText(value);
  }
  public void setDisabled(boolean disabled) {
    super.setDisabled(disabled);
    .setEnabled(!disabled);
  }
  
  
New to GrepCode? Check out our FAQ X