コード例 #1
0
  private void updateParentState(Object child, boolean baseChildState) {
    if (child == null) return;
    if (child instanceof IAdaptable) {
      IResource resource = (IResource) ((IAdaptable) child).getAdapter(IResource.class);
      if (resource != null && !resource.isAccessible()) return;
    }
    Object parent = fTreeContentProvider.getParent(child);
    if (parent == null) return;

    boolean allSameState = true;
    Object[] children = null;
    children = fTreeContentProvider.getChildren(parent);

    for (int i = children.length - 1; i >= 0; i--) {
      if (fTree.getChecked(children[i]) != baseChildState || fTree.getGrayed(children[i])) {
        allSameState = false;
        break;
      }
    }

    fTree.setGrayed(parent, !allSameState);
    fTree.setChecked(parent, !allSameState || baseChildState);

    updateParentState(parent, baseChildState);
  }
コード例 #2
0
 /*
  * Extends this method to update check box states.
  */
 protected void doUpdateItem(Item item, Object element) {
   super.doUpdateItem(item, element);
   if (!item.isDisposed() && checkStateProvider != null) {
     setChecked(element, checkStateProvider.isChecked(element));
     setGrayed(element, checkStateProvider.isGrayed(element));
   }
 }
コード例 #3
0
 protected void forceExistingChecked(CheckStateChangedEvent event) {
   if (fExisting != null) {
     Object elem = event.getElement();
     if (fExisting.contains(elem)) {
       fViewer.setChecked(elem, true);
     }
   }
 }
コード例 #4
0
 /** Updates the check states of process tree viewer. */
 private void updateCheckedStates() {
   ITreeContentProvider cp = (ITreeContentProvider) processViewer.getContentProvider();
   if (config != null) {
     Object[] plugins = null;
     if (ConfigFreeProcessPublishUtil.getInstance().isSameMethodConfiguration(config)) {
       // For config free process publish
       plugins = cp.getChildren(LibraryService.getInstance().getCurrentMethodLibrary());
     } else {
       plugins = cp.getChildren(config);
     }
     for (int i = 0; i < plugins.length; i++) {
       Object[] uiFolders = cp.getChildren(plugins[i]);
       int totalUIFolders = uiFolders.length;
       int checkedUIFolders = 0;
       for (int j = 0; j < uiFolders.length; j++) {
         Object[] processes = cp.getChildren(uiFolders[j]);
         int totalProcesses = processes.length;
         int checkedProcesses = 0;
         for (int k = 0; k < processes.length; k++) {
           if (processViewer.getChecked(processes[k])) {
             checkedProcesses++;
           }
         }
         if (checkedProcesses == 0) {
           processViewer.setGrayChecked(uiFolders[j], false);
         } else if (checkedProcesses == totalProcesses) {
           processViewer.setGrayed(uiFolders[j], false);
           processViewer.setChecked(uiFolders[j], true);
         } else {
           processViewer.setGrayChecked(uiFolders[j], true);
         }
         if (processViewer.getChecked(uiFolders[j])) {
           checkedUIFolders++;
         }
       }
       if (checkedUIFolders == totalUIFolders) {
         processViewer.setGrayed(plugins[i], false);
         processViewer.setChecked(plugins[i], true);
       } else if (checkedUIFolders == 0) {
         processViewer.setGrayChecked(plugins[i], false);
       } else {
         processViewer.setGrayChecked(plugins[i], true);
       }
     }
   }
 }
コード例 #5
0
 /**
  * Iterates through the passed elements which are being realized for the first time and check each
  * one in the tree viewer as appropriate
  *
  * @param elements
  */
 protected void checkNewTreeElements(Object[] elements) {
   for (int i = 0; i < elements.length; ++i) {
     Object currentElement = elements[i];
     boolean checked = fCheckedStateStore.containsKey(currentElement);
     fTreeViewer.setChecked(currentElement, checked);
     fTreeViewer.setGrayed(
         currentElement, checked && !fWhiteCheckedTreeItems.contains(currentElement));
   }
 }
コード例 #6
0
 protected void newFolderButtonPressed() {
   Object createdFolder = createFolder(fSelectedContainer);
   if (createdFolder != null) {
     CheckboxTreeViewer treeViewer = fViewer;
     treeViewer.refresh(fSelectedContainer);
     treeViewer.reveal(createdFolder);
     treeViewer.setChecked(createdFolder, true);
     treeViewer.setSelection(new StructuredSelection(createdFolder));
     updateOKStatus();
   }
 }
コード例 #7
0
  /** Selects the referenced base processes in the process tree viewer. */
  private void selectBaseProcesses() {
    // Get the referenced base processes.
    List<Process> processes = getSelectedProcesses();
    List<Process> baseProcesses = new ArrayList<Process>();
    for (Iterator it = processes.iterator(); it.hasNext(); ) {
      ConfigurationHelper.getBaseProcesses((Activity) it.next(), config, baseProcesses);
    }

    // Update the process tree viewer.
    for (Iterator it = baseProcesses.iterator(); it.hasNext(); ) {
      Object element = it.next();
      processViewer.setChecked(element, true);
    }
  }
コード例 #8
0
 public static void setSubtreeChecked(
     final DebugTreeItem dti,
     final boolean checked,
     final ArrayList<IErlModule> traceModules,
     final CheckboxTreeViewer checkboxTreeViewer) {
   final List<DebugTreeItem> children = dti.getChildren();
   if (children == null || children.size() == 0) {
     traceOrNotTrace(dti, checked, traceModules);
     return;
   }
   for (final DebugTreeItem i : children) {
     checkboxTreeViewer.setChecked(i, checked);
     setSubtreeChecked(i, checked, traceModules, checkboxTreeViewer);
   }
 }
コード例 #9
0
  /* (non-Javadoc)
   * Method declared on StructuredViewer.
   */
  protected void handleDoubleSelect(SelectionEvent event) {

    if (lastClickedItem != null) {
      TreeItem item = lastClickedItem;
      Object data = item.getData();
      if (data != null) {
        boolean state = item.getChecked();
        setChecked(data, !state);
        fireCheckStateChanged(new CheckStateChangedEvent(this, data, !state));
      }
      lastClickedItem = null;
    } else {
      super.handleDoubleSelect(event);
    }
  }
コード例 #10
0
  private void setSubtreeChecked(Object parent, boolean state, boolean checkExpandedState) {
    if (!(parent instanceof IAdaptable)) return;
    IContainer container = (IContainer) ((IAdaptable) parent).getAdapter(IContainer.class);
    if ((!fTree.getExpandedState(parent) && checkExpandedState)
        || (container != null && !container.isAccessible())) return;

    Object[] children = fTreeContentProvider.getChildren(parent);
    for (int i = children.length - 1; i >= 0; i--) {
      Object element = children[i];
      if (state) {
        fTree.setChecked(element, true);
        fTree.setGrayed(element, false);
      } else fTree.setGrayChecked(element, false);
      if (isExpandable(element)) setSubtreeChecked(element, state, true);
    }
  }
コード例 #11
0
  /**
   * Sets the checked state of self and all ancestors appropriately
   *
   * @param treeElement
   */
  protected void updateHierarchy(Object treeElement) {

    boolean whiteChecked = determineShouldBeWhiteChecked(treeElement);
    boolean shouldBeAtLeastGray = determineShouldBeAtLeastGrayChecked(treeElement);

    fTreeViewer.setChecked(treeElement, whiteChecked || shouldBeAtLeastGray);
    setWhiteChecked(treeElement, whiteChecked);
    if (whiteChecked) fTreeViewer.setGrayed(treeElement, false);
    else fTreeViewer.setGrayed(treeElement, shouldBeAtLeastGray);

    // proceed up the tree element hierarchy
    Object parent = fTreeContentProvider.getParent(treeElement);
    if (parent != null) {
      updateHierarchy(parent);
    }
  }
コード例 #12
0
ファイル: EventTreeDialog.java プロジェクト: eclipse/ptp
  private void checkGray(ArrayList<ETItem> all, Set<Integer> grey) {
    boolean isGrey = false;
    Event test = null;
    for (int i = 0; i < all.size(); i++) {
      test = (Event) all.get(i);
      isGrey = (!test.checked) && grey.contains(new Integer(test.index));
      if (isGrey) {
        treeV.setGrayChecked(test, true); // grey.contains(new
        // Integer(((Event)all.get(i)).index)));
      } else {

        treeV.setGrayed(test, false);
        if (!test.checked) {
          treeV.setChecked(test, false);
        }
      }
      // if(isGrey)treeV.setChecked(all.get(i),isGrey);
    }
  }
コード例 #13
0
  public void updateTreeCheckboxesForAncestor(Object element) {
    ICheckboxTreeContentProvider contentProvider = contentProvider();

    if (element != null) {
      treeViewer.setChecked(element, contentProvider.isChecked(element));
    }

    if (element == null) {
      TreeItem[] items = treeViewer.getTree().getItems();

      for (int i = 0, count = items.length; i < count; i++) {
        updateTreeCheckboxesForItem(items[i]);
      }
    } else {
      TreeItem item = ((TreeViewerAccess) treeViewer).itemForElement(element);

      updateTreeCheckboxesForItem(item);
    }
  }
コード例 #14
0
  public void testGetCheckedElements() {
    CheckboxTreeViewer ctv = (CheckboxTreeViewer) fViewer;

    TestElement[] children = fRootElement.getChildren();

    List checked = new ArrayList((children.length + 1) / 2);

    for (int i = 0; i < children.length; i += 2) {
      ctv.setChecked(children[i], true);
      checked.add(children[i]);
    }

    Object[] actuallyChecked = ctv.getCheckedElements();

    for (int i = 0; i < actuallyChecked.length; i++) {
      assertTrue(
          "getCheckedElements should include all checked elements",
          checked.remove(actuallyChecked[i]));
    }

    assertTrue("getCheckedElements should not include any unchecked elements", checked.isEmpty());
  }
コード例 #15
0
  /**
   * Sets the checked state of the passed tree element appropriately, and do so recursively to all
   * of its child tree elements as well
   *
   * @param treeElement
   * @param state
   */
  protected void setTreeChecked(Object treeElement, boolean state) {

    if (treeElement.equals(fCurrentTreeSelection)) {
      fListViewer.setAllChecked(state);
    }

    if (state) {
      Object[] listItems = getListElements(treeElement);
      List<Object> listItemsChecked = new ArrayList<Object>();
      for (int i = 0; i < listItems.length; ++i) listItemsChecked.add(listItems[i]);

      fCheckedStateStore.put(treeElement, listItemsChecked);
    } else fCheckedStateStore.remove(treeElement);

    setWhiteChecked(treeElement, state);
    fTreeViewer.setChecked(treeElement, state);
    fTreeViewer.setGrayed(treeElement, false);

    // now logically check/uncheck all children as well
    Object[] children = getTreeChildren(treeElement);
    for (int i = 0; i < children.length; ++i) {
      setTreeChecked(children[i], state);
    }
  }
コード例 #16
0
  @Override
  protected Control createExtendedContentArea(Composite parent) {
    Composite composite = new Composite(parent, SWT.NONE);
    GridLayoutFactory.fillDefaults().applyTo(composite);
    GridDataFactory.fillDefaults().align(SWT.FILL, SWT.CENTER).grab(true, false).applyTo(composite);

    Label label = new Label(composite, SWT.NONE);
    label.setText("Select the connections to be searched for opening pages:");

    CheckboxTreeViewer dataManagerTreeViewers = new CheckboxTreeViewer(composite, SWT.BORDER);
    GridDataFactory.fillDefaults()
        .align(SWT.FILL, SWT.CENTER)
        .grab(true, false)
        .applyTo(dataManagerTreeViewers.getControl());
    dataManagerTreeViewers.setContentProvider(
        new ITreeContentProvider() {

          public Object[] getChildren(Object parentElement) {
            // TODO Auto-generated method stub
            return null;
          }

          public Object getParent(Object element) {
            // TODO Auto-generated method stub
            return null;
          }

          public boolean hasChildren(Object element) {
            // TODO Auto-generated method stub
            return false;
          }

          public Object[] getElements(Object inputElement) {
            return DataManagerRegistry.getDefault().getDataManagers().toArray();
          }

          public void dispose() {
            // TODO Auto-generated method stub

          }

          public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
            // TODO Auto-generated method stub

          }
        });
    dataManagerTreeViewers.setLabelProvider(new WorkbenchLabelProvider());
    dataManagerTreeViewers.setInput(this);

    for (DataManager dataManager : targetDataManagers)
      dataManagerTreeViewers.setChecked(dataManager, true);

    dataManagerTreeViewers.addCheckStateListener(
        new ICheckStateListener() {
          public void checkStateChanged(CheckStateChangedEvent event) {
            if (event.getChecked()) targetDataManagers.add((DataManager) event.getElement());
            else targetDataManagers.remove(event.getElement());
          }
        });

    return composite;
  }
コード例 #17
0
 private void setGrayChecked(
     final CheckboxTreeViewer checkboxTreeViewer, final boolean grayed, final boolean checked) {
   checkboxTreeViewer.setGrayed(this, grayed);
   checkboxTreeViewer.setChecked(this, checked);
 }
コード例 #18
0
ファイル: EventTreeDialog.java プロジェクト: eclipse/ptp
  private void doCheck(ETItem element, boolean checked) {
    if (element instanceof EventTree
        || element instanceof Component
        || element instanceof EventSet) {
      final ETItem eti = element;
      ETItem toCheck = null;
      eti.setCheck(checked);
      for (int i = 0; i < eti.children.size(); i++) {
        toCheck = eti.children.get(i);
        if (treeV.getGrayed(toCheck) || (treeV.getChecked(toCheck) == checked)) {
          continue;
        }
        treeV.setChecked(toCheck, checked);
        doCheck(toCheck, checked);
      }

    } else {
      if (element instanceof Modifier) {
        if (!treeV.getGrayed(element)) {
          (element).checked = checked; // event.getChecked();
        }
      } else {
        if (element instanceof Event) {
          if (!treeV.getGrayed(element)) {
            final Event e = (Event) element;
            e.setCheck(checked); // event.getChecked());

            final Component c = (Component) e.parent.parent;
            // ((ETItem)element).checked=event.getChecked();

            final Set<Integer>[] av = cSelect.getAvailable(c.index, c.eNames);

            if (av == null) {
              return;
            }

            Set<Integer> grey = new HashSet<Integer>(((EventSet) c.children.get(0)).fullSet);

            // Object[]test=((EventSet)c.children.get(0)).fullSet.toArray();
            // for(int i=0;i<test.length;i++)
            // {
            // System.out.println("All: "+test[i]);
            // }
            //
            // test=av[0].toArray();
            // for(int i=0;i<test.length;i++)
            // {
            // System.out.println("Av: "+test[i]);
            // }

            grey.removeAll(av[0]);

            // test=grey.toArray();
            // for(int i=0;i<test.length;i++)
            // {
            // System.out.println("Grey: "+test[i]);
            // }

            // boolean isGrey;
            ArrayList<ETItem> all = ((EventSet) c.children.get(0)).children;

            checkGray(all, grey);

            // for(int i=0;i<all.size();i++){
            // isGrey=!((Event)all.get(i)).checked&&grey.contains(new
            // Integer(((Event)all.get(i)).index));
            // treeV.setGrayed(all.get(i), isGrey);
            // //System.out.println(all.get(i).label+" "+
            // isGrey);//grey.contains(new
            // Integer(((Event)all.get(i)).index)));
            // }

            grey = new HashSet<Integer>(((EventSet) c.children.get(1)).fullSet);
            grey.removeAll(av[1]);

            all = ((EventSet) c.children.get(1)).children;
            checkGray(all, grey);

            // treeV.setChecked(element, checked);

            // for(int i=0;i<all.size();i++){
            // isGrey=(!((Event)all.get(i)).checked)&&grey.contains(new
            // Integer(((Event)all.get(i)).index));
            // treeV.setGrayed(all.get(i),isGrey);//
            // grey.contains(new
            // Integer(((Event)all.get(i)).index)));
            // if(isGrey)treeV.setChecked(all.get(i),isGrey);
            // }

          } else {
            treeV.setChecked(element, true);
          }
          // treeV.refresh();
        }
      }
    }
  }