Example usage for org.eclipse.jface.viewers ICheckStateListener ICheckStateListener

List of usage examples for org.eclipse.jface.viewers ICheckStateListener ICheckStateListener

  1. HOME
  2. Java
  3. org.eclipse.jface
  4. org.eclipse.jface.viewers.*
  5. ICheckStateListener
  6. ICheckStateListener

Introduction

In this page you can find the example usage for org.eclipse.jface.viewers ICheckStateListener ICheckStateListener.

Prototype

ICheckStateListener

Source Link

Usage

From source file:ar.com.fluxit.jqa.wizard.page.AllocationDefinitionWizardPage.java

License:Open Source License

@Override
ICheckStateListener getCheckStateListener() {
    return new ICheckStateListener() {

        @Override//  w w w.j  a  v  a2  s  .  c o  m
        public void checkStateChanged(CheckStateChangedEvent event) {
            ((LayerDescriptor) event.getElement()).setAllocable(event.getChecked());
        }
    };
}

From source file:ar.com.fluxit.jqa.wizard.page.ApisDefinitionWizardPage.java

License:Open Source License

@Override
public void createControl(Composite parent) {
    Composite container = new Composite(parent, SWT.NULL);
    GridLayout layout = new GridLayout();
    layout.numColumns = 1;/*from   ww  w  .  j ava 2s  .  c o  m*/
    container.setLayout(layout);

    layersTable = CheckboxTableViewer.newCheckList(container,
            SWT.SINGLE | SWT.BORDER | SWT.V_SCROLL | SWT.H_SCROLL);
    layersTable.getTable().setLayoutData(new GridData(GridData.FILL_BOTH));
    layersTable.setContentProvider(ArrayContentProvider.getInstance());
    layersTable.getTable().setHeaderVisible(true);
    layersTable.getTable().setLinesVisible(true);

    TableViewerColumn selectionColumn = new TableViewerColumn(layersTable, SWT.NONE);
    selectionColumn.getColumn().setWidth(23);
    selectionColumn.getColumn().setText("Has API");
    selectionColumn.setLabelProvider(new ColumnLabelProvider() {

        @Override
        public String getText(Object element) {
            return "";
        }

    });
    layersTable.setCheckStateProvider(new ICheckStateProvider() {

        @Override
        public boolean isChecked(Object element) {
            return ((Layer) element).isHasApi();
        }

        @Override
        public boolean isGrayed(Object element) {
            return false;
        }
    });
    layersTable.addCheckStateListener(new ICheckStateListener() {

        @Override
        public void checkStateChanged(CheckStateChangedEvent event) {
            ((Layer) event.getElement()).setHasApi(event.getChecked());
        }
    });

    TableViewerColumn layerColumn = new TableViewerColumn(layersTable, SWT.NONE);
    layerColumn.getColumn().setText("Layer");
    layerColumn.getColumn().setWidth(300);
    layerColumn.setLabelProvider(new ColumnLabelProvider() {
        @Override
        public String getText(Object element) {
            Layer layer = (Layer) element;
            return layer.getName();
        }
    });
    layersTable.setInput(getWizard().getLayers());
    layersTable.getTable().setColumnOrder(new int[] { 1, 0 });
    setControl(container);
    ((WizardDialog) getContainer()).addPageChangedListener(this);
}

From source file:at.medevit.elexis.inbox.ui.part.InboxView.java

License:Open Source License

@Override
public void createPartControl(Composite parent) {
    Composite composite = new Composite(parent, SWT.NONE);
    composite.setLayout(new GridLayout(1, false));

    Composite filterComposite = new Composite(composite, SWT.NONE);
    GridData data = new GridData(GridData.FILL_HORIZONTAL);
    filterComposite.setLayoutData(data);
    filterComposite.setLayout(new GridLayout(2, false));

    filterText = new Text(filterComposite, SWT.SEARCH);
    filterText.setMessage("Filter");
    data = new GridData(GridData.FILL_HORIZONTAL);
    filterText.setLayoutData(data);//from  www  . j  a va 2s  .  c om
    filterText.addModifyListener(new ModifyListener() {
        public void modifyText(ModifyEvent e) {
            if (filterText.getText().length() > 1) {
                filter.setSearchText(filterText.getText());
                viewer.refresh();
            } else {
                filter.setSearchText("");
                viewer.refresh();
            }
        }
    });

    ToolBarManager menuManager = new ToolBarManager(SWT.FLAT | SWT.HORIZONTAL | SWT.WRAP);
    menuManager.createControl(filterComposite);

    viewer = new CheckboxTreeViewer(composite, SWT.MULTI | SWT.H_SCROLL | SWT.V_SCROLL | SWT.BORDER);
    GridData gd = new GridData(SWT.FILL, SWT.FILL, true, true, 1, 1);
    viewer.getControl().setLayoutData(gd);

    ViewerFilter[] filters = new ViewerFilter[1];
    filters[0] = filter;
    viewer.setFilters(filters);

    contentProvider = new InboxElementContentProvider();
    viewer.setContentProvider(contentProvider);

    viewer.setLabelProvider(new InboxElementLabelProvider());

    viewer.addCheckStateListener(new ICheckStateListener() {

        public void checkStateChanged(CheckStateChangedEvent event) {
            if (event.getElement() instanceof PatientInboxElements) {
                PatientInboxElements patientInbox = (PatientInboxElements) event.getElement();
                for (InboxElement inboxElement : patientInbox.getElements()) {
                    if (!filter.isActive() || filter.isSelect(inboxElement)) {
                        State newState = toggleInboxElementState(inboxElement);
                        if (newState == State.NEW) {
                            viewer.setChecked(inboxElement, false);
                        } else {
                            viewer.setChecked(inboxElement, true);
                        }
                        contentProvider.refreshElement(inboxElement);
                    }
                }
                contentProvider.refreshElement(patientInbox);
            } else if (event.getElement() instanceof InboxElement) {
                InboxElement inboxElement = (InboxElement) event.getElement();
                if (!filter.isActive() || filter.isSelect(inboxElement)) {
                    toggleInboxElementState(inboxElement);
                    contentProvider.refreshElement(inboxElement);
                }
            }
            viewer.refresh(false);
        }
    });

    viewer.addDoubleClickListener(new IDoubleClickListener() {
        @Override
        public void doubleClick(DoubleClickEvent event) {
            StructuredSelection selection = (StructuredSelection) viewer.getSelection();
            if (!selection.isEmpty()) {
                Object selectedObj = selection.getFirstElement();
                if (selectedObj instanceof InboxElement) {
                    InboxElementUiExtension extension = new InboxElementUiExtension();
                    extension.fireDoubleClicked((InboxElement) selectedObj);
                }
            }
        }
    });

    viewer.addSelectionChangedListener(new ISelectionChangedListener() {
        @Override
        public void selectionChanged(SelectionChangedEvent event) {
            ISelection selection = event.getSelection();
            if (selection instanceof StructuredSelection && !selection.isEmpty()) {
                if (setAutoSelectPatient) {
                    Object selectedElement = ((StructuredSelection) selection).getFirstElement();
                    if (selectedElement instanceof InboxElement) {
                        ElexisEventDispatcher.fireSelectionEvent(((InboxElement) selectedElement).getPatient());
                    } else if (selectedElement instanceof PatientInboxElements) {
                        ElexisEventDispatcher
                                .fireSelectionEvent(((PatientInboxElements) selectedElement).getPatient());
                    }
                }
            }
        }
    });

    final Transfer[] dropTransferTypes = new Transfer[] { FileTransfer.getInstance() };
    viewer.addDropSupport(DND.DROP_COPY, dropTransferTypes, new DropTargetAdapter() {

        @Override
        public void dragEnter(DropTargetEvent event) {
            event.detail = DND.DROP_COPY;
        }

        @Override
        public void drop(DropTargetEvent event) {
            if (dropTransferTypes[0].isSupportedType(event.currentDataType)) {
                String[] files = (String[]) event.data;
                Patient patient = null;

                if (event.item != null) {
                    Object data = event.item.getData();
                    if (data instanceof InboxElement) {
                        patient = ((InboxElement) data).getPatient();
                    } else if (data instanceof PatientInboxElements) {
                        patient = ((PatientInboxElements) data).getPatient();
                    }
                }

                if (patient == null) {
                    // fallback
                    patient = ElexisEventDispatcher.getSelectedPatient();
                }
                if (patient != null) {
                    if (files != null) {
                        for (String file : files) {
                            try {
                                InboxServiceComponent.getService().createInboxElement(patient,
                                        ElexisEventDispatcher.getSelectedMandator(), file, true);
                            } catch (Exception e) {
                                LoggerFactory.getLogger(InboxView.class).warn("drop error", e);
                            }
                        }
                    }

                    viewer.refresh();
                } else {
                    MessageDialog.openWarning(Display.getCurrent().getActiveShell(), "Warnung",
                            "Bitte whlen Sie zuerst einen Patienten aus.");
                }

            }
        }

    });

    addFilterActions(menuManager);

    InboxServiceComponent.getService().addUpdateListener(new IInboxUpdateListener() {
        public void update(final InboxElement element) {
            Display.getDefault().asyncExec(new Runnable() {
                public void run() {
                    contentProvider.refreshElement(element);
                    viewer.refresh();
                }
            });
        }
    });

    reload();

    MenuManager ctxtMenuManager = new MenuManager();
    Menu menu = ctxtMenuManager.createContextMenu(viewer.getTree());
    viewer.getTree().setMenu(menu);
    getSite().registerContextMenu(ctxtMenuManager, viewer);

    ElexisEventDispatcher.getInstance().addListeners(mandantChanged);
    getSite().setSelectionProvider(viewer);

    setAutoSelectPatientState(CoreHub.userCfg.get(Preferences.INBOX_PATIENT_AUTOSELECT, false));
}

From source file:au.gov.ansto.bragg.kakadu.ui.instrument.InstrumentDataSourceComposite.java

License:Open Source License

private void initListeners() {
    fileTableTreeViewer.addCheckStateListener(new ICheckStateListener() {
        public void checkStateChanged(CheckStateChangedEvent event) {
            //transfer events from view to model
            Object element = event.getElement();
            if (element instanceof DefaultMutableTreeNode) {
                DefaultMutableTreeNode treeNode = (DefaultMutableTreeNode) element;
                Object userObject = treeNode.getUserObject();
                if (userObject instanceof SelectableDataItem) {
                    SelectableDataItem selectableDataItem = (SelectableDataItem) userObject;
                    selectableDataItem.setSelected(event.getChecked());
                } else if (userObject instanceof DataSourceFile) {
                    ((DataSourceFile) userObject).setSelected(event.getChecked());
                }/*ww w  .  j av a 2  s  .  co m*/
            }
        }
    });
    fileTableTreeViewer.addSelectionChangedListener(new ISelectionChangedListener() {
        public void selectionChanged(SelectionChangedEvent event) {
            removeFileAction.setEnabled(!event.getSelection().isEmpty());
            //            toolItemRemoveFile.setEnabled(!event.getSelection().isEmpty());
        }
    });

    //      toolItemAddFile.addSelectionListener(new SelectionListener() {
    //         public void widgetDefaultSelected(SelectionEvent arg0) {
    //         }
    //         public void widgetSelected(SelectionEvent arg0) {
    //            
    //            String[] selectedFiles = Util.selectFilesFromShell(parentComposite.getShell(),
    //                              "*.hdf", "HDF data file");
    //            for (String selectedFileName : selectedFiles) {
    ////               txtSelectedFile.setText(selectedFileName);
    ////               DataSourceManager.setFileName(selectedFileName);
    //               
    //               addFile(selectedFileName);
    //               
    //               adjustColumnSize();
    //            }
    //         }
    //      });
    //      
    //      toolItemAddDirectory.addSelectionListener(new SelectionListener() {
    //         public void widgetDefaultSelected(SelectionEvent arg0) {
    //         }
    //         public void widgetSelected(SelectionEvent arg0) {
    //            
    //            String selectedDirectory = Util.selectDirectoryFromShell(parentComposite.getShell());
    //            addDirectory(selectedDirectory);
    //         }
    //      });
    //      
    //      toolItemRemoveFile.addSelectionListener(new SelectionListener() {
    //         public void widgetDefaultSelected(SelectionEvent arg0) {
    //         }
    //         public void widgetSelected(SelectionEvent arg0) {
    //            removeSelectedFile();
    //         }
    //      });
    //      
    //      toolItemRemoveAll.addSelectionListener(new SelectionListener() {
    //         public void widgetDefaultSelected(SelectionEvent arg0) {
    //         }
    //         public void widgetSelected(SelectionEvent arg0) {
    //            removeAll();
    //            toolItemRemoveAll.setEnabled(false);
    //         }
    //      });
    //      
    //      toolItemSelectAll.addSelectionListener(new SelectionListener() {
    //         public void widgetDefaultSelected(SelectionEvent arg0) {
    //         }
    //         public void widgetSelected(SelectionEvent arg0) {
    //            fileTableTreeViewer.setAllChecked(true);
    //         }
    //      });
    //      
    //      toolItemUnselectAll.addSelectionListener(new SelectionListener() {
    //         public void widgetDefaultSelected(SelectionEvent arg0) {
    //         }
    //         public void widgetSelected(SelectionEvent arg0) {
    //            fileTableTreeViewer.setAllChecked(false);
    //         }
    //      });

    dataListener = new DataListener<DataSourceFile>() {
        public void dataAdded(DataSourceFile addedData) {
            updateButtons();
        }

        public void dataRemoved(DataSourceFile removedData) {
            updateButtons();
        }

        public void dataUpdated(DataSourceFile updatedData) {
            updateButtons();
        }

        public void allDataRemoved(DataSourceFile removedData) {
            // TODO Auto-generated method stub
            updateButtons();
        }
    };
    DataSourceManager.getInstance().addDataListener(dataListener);
}

From source file:au.gov.ansto.bragg.kakadu.ui.views.DataSourceComposite.java

License:Open Source License

private void initListeners() {
    fileTableTreeViewer.addCheckStateListener(new ICheckStateListener() {
        public void checkStateChanged(CheckStateChangedEvent event) {
            //transfer events from view to model
            Object element = event.getElement();
            if (element instanceof DefaultMutableTreeNode) {
                DefaultMutableTreeNode treeNode = (DefaultMutableTreeNode) element;
                Object userObject = treeNode.getUserObject();
                if (userObject instanceof SelectableDataItem) {
                    SelectableDataItem selectableDataItem = (SelectableDataItem) userObject;
                    selectableDataItem.setSelected(event.getChecked());
                }//from w w w .ja  va2  s .c o  m
            }
        }
    });
    fileTableTreeViewer.addSelectionChangedListener(new ISelectionChangedListener() {
        public void selectionChanged(SelectionChangedEvent event) {
            removeFileAction.setEnabled(!event.getSelection().isEmpty());
            //            toolItemRemoveFile.setEnabled(!event.getSelection().isEmpty());
        }
    });

    //      toolItemAddFile.addSelectionListener(new SelectionListener() {
    //         public void widgetDefaultSelected(SelectionEvent arg0) {
    //         }
    //         public void widgetSelected(SelectionEvent arg0) {
    //            
    //            String[] selectedFiles = Util.selectFilesFromShell(parentComposite.getShell(),
    //                              "*.hdf", "HDF data file");
    //            for (String selectedFileName : selectedFiles) {
    ////               txtSelectedFile.setText(selectedFileName);
    ////               DataSourceManager.setFileName(selectedFileName);
    //               
    //               addFile(selectedFileName);
    //               
    //               adjustColumnSize();
    //            }
    //         }
    //      });
    //      
    //      toolItemAddDirectory.addSelectionListener(new SelectionListener() {
    //         public void widgetDefaultSelected(SelectionEvent arg0) {
    //         }
    //         public void widgetSelected(SelectionEvent arg0) {
    //            
    //            String selectedDirectory = Util.selectDirectoryFromShell(parentComposite.getShell());
    //            addDirectory(selectedDirectory);
    //         }
    //      });
    //      
    //      toolItemRemoveFile.addSelectionListener(new SelectionListener() {
    //         public void widgetDefaultSelected(SelectionEvent arg0) {
    //         }
    //         public void widgetSelected(SelectionEvent arg0) {
    //            removeSelectedFile();
    //         }
    //      });
    //      
    //      toolItemRemoveAll.addSelectionListener(new SelectionListener() {
    //         public void widgetDefaultSelected(SelectionEvent arg0) {
    //         }
    //         public void widgetSelected(SelectionEvent arg0) {
    //            removeAll();
    //            toolItemRemoveAll.setEnabled(false);
    //         }
    //      });
    //      
    //      toolItemSelectAll.addSelectionListener(new SelectionListener() {
    //         public void widgetDefaultSelected(SelectionEvent arg0) {
    //         }
    //         public void widgetSelected(SelectionEvent arg0) {
    //            fileTableTreeViewer.setAllChecked(true);
    //         }
    //      });
    //      
    //      toolItemUnselectAll.addSelectionListener(new SelectionListener() {
    //         public void widgetDefaultSelected(SelectionEvent arg0) {
    //         }
    //         public void widgetSelected(SelectionEvent arg0) {
    //            fileTableTreeViewer.setAllChecked(false);
    //         }
    //      });

    DataSourceManager.getInstance().addDataListener(new DataListener<DataSourceFile>() {
        public void dataAdded(DataSourceFile addedData) {
            updateButtons();
        }

        public void dataRemoved(DataSourceFile removedData) {
            updateButtons();
        }

        public void dataUpdated(DataSourceFile updatedData) {
            updateButtons();
        }

        public void allDataRemoved(DataSourceFile removedData) {
            // TODO Auto-generated method stub
            updateButtons();
        }
    });
}

From source file:au.gov.ansto.bragg.quokka.ui.internal.DataSourceComposite.java

License:Open Source License

private void initListeners() {
    fileTableTreeViewer.addCheckStateListener(new ICheckStateListener() {
        public void checkStateChanged(CheckStateChangedEvent event) {
            //transfer events from view to model
            Object element = event.getElement();
            if (element instanceof DefaultMutableTreeNode) {
                DefaultMutableTreeNode treeNode = (DefaultMutableTreeNode) element;
                Object userObject = treeNode.getUserObject();
                if (userObject instanceof SelectableDataItem) {
                    SelectableDataItem selectableDataItem = (SelectableDataItem) userObject;
                    selectableDataItem.setSelected(event.getChecked());
                }//w ww. j  av  a 2 s  .com
            }
        }
    });
    fileTableTreeViewer.addSelectionChangedListener(new ISelectionChangedListener() {
        public void selectionChanged(SelectionChangedEvent event) {
            removeFileAction.setEnabled(!event.getSelection().isEmpty());
            //            toolItemRemoveFile.setEnabled(!event.getSelection().isEmpty());
        }
    });

    DataSourceManager.getInstance().addDataListener(new DataListener<DataSourceFile>() {
        public void dataAdded(DataSourceFile addedData) {
            updateButtons();
        }

        public void dataRemoved(DataSourceFile removedData) {
            updateButtons();
        }

        public void dataUpdated(DataSourceFile updatedData) {
            updateButtons();
        }

        public void allDataRemoved(DataSourceFile removedData) {
            updateButtons();
        }
    });
}

From source file:au.gov.ga.earthsci.application.parts.layer.LayerTreePart.java

License:Apache License

@PostConstruct
public void init(Composite parent, EMenuService menuService) {
    LayerOpacityToolControl.setPartContext(context);

    viewer = new CheckboxTreeViewer(parent, SWT.MULTI);
    viewer.getTree().setBackgroundImage(ImageRegistry.getInstance().get(ImageRegistry.ICON_TRANSPARENT));
    context.set(TreeViewer.class, viewer);

    clipboard = new Clipboard(shell.getDisplay());
    context.set(Clipboard.class, clipboard);

    IListProperty childrenProperty = new MultiListProperty(
            new IListProperty[] { BeanProperties.list("children") }); //$NON-NLS-1$

    ObservableListTreeContentProvider contentProvider = new ObservableListTreeContentProvider(
            childrenProperty.listFactory(), null);
    viewer.setContentProvider(contentProvider);

    //TreeViewerEditor.create(viewer, new SecondClickColumnViewerEditorActivationStrategy(viewer), ColumnViewerEditor.DEFAULT);

    IObservableSet knownElements = contentProvider.getKnownElements();
    IObservableMap enabledMap = BeanProperties.value("enabled").observeDetail(knownElements); //$NON-NLS-1$
    IObservableMap opacityMap = BeanProperties.value("opacity").observeDetail(knownElements); //$NON-NLS-1$
    IObservableMap nameMap = BeanProperties.value("name").observeDetail(knownElements); //$NON-NLS-1$
    IObservableMap labelMap = BeanProperties.value("label").observeDetail(knownElements); //$NON-NLS-1$
    IObservableMap statusMap = BeanProperties.value("status").observeDetail(knownElements); //$NON-NLS-1$
    IObservableMap anyChildrenEnabledMap = BeanProperties.value("anyChildrenEnabled") //$NON-NLS-1$
            .observeDetail(knownElements);
    IObservableMap allChildrenEnabledMap = BeanProperties.value("allChildrenEnabled") //$NON-NLS-1$
            .observeDetail(knownElements);
    IObservableMap childrenMap = BeanProperties.value("children").observeDetail(knownElements); //$NON-NLS-1$
    IObservableMap expandedMap = BeanProperties.value("expanded").observeDetail(knownElements); //$NON-NLS-1$

    IObservableMap[] labelAttributeMaps = new IObservableMap[] { enabledMap, opacityMap, nameMap, labelMap,
            anyChildrenEnabledMap, allChildrenEnabledMap, statusMap };

    labelProvider = new LayerTreeLabelProvider(labelAttributeMaps);
    viewer.setLabelProvider(labelProvider);
    viewer.setCheckStateProvider(new LayerTreeCheckStateProvider());

    viewer.setInput(model.getRootNode());
    viewer.setExpandedElements(getExpandedNodes());

    IMapChangeListener childrenListener = new IMapChangeListener() {
        @Override// w  w  w . j a  v  a2  s.c  o m
        public void handleMapChange(MapChangeEvent event) {
            //for any children added, expand the nodes
            Set<?> addedKeys = event.diff.getAddedKeys();
            for (Object o : addedKeys) {
                if (o instanceof ILayerTreeNode) {
                    ((ILayerTreeNode) o).getParent().getValue().setExpanded(true);
                }
            }
        }
    };
    IMapChangeListener expandedListener = new IMapChangeListener() {
        @Override
        public void handleMapChange(MapChangeEvent event) {
            //ensure the expanded elements are kept in sync with the model
            viewer.getTree().getDisplay().asyncExec(new Runnable() {
                @Override
                public void run() {
                    if (!viewer.getTree().isDisposed()) {
                        viewer.setExpandedElements(getExpandedNodes());
                    }
                }
            });
        }
    };
    childrenMap.addMapChangeListener(childrenListener);
    childrenMap.addMapChangeListener(expandedListener);
    expandedMap.addMapChangeListener(expandedListener);

    viewer.addCheckStateListener(new ICheckStateListener() {
        @Override
        public void checkStateChanged(CheckStateChangedEvent event) {
            Object element = event.getElement();
            if (element instanceof ILayerTreeNode) {
                ILayerTreeNode node = (ILayerTreeNode) element;
                node.enableChildren(event.getChecked());
            }
        }
    });

    viewer.addSelectionChangedListener(new ISelectionChangedListener() {
        @Override
        public void selectionChanged(SelectionChangedEvent event) {
            IStructuredSelection selection = (IStructuredSelection) viewer.getSelection();
            List<?> list = selection.toList();
            ILayerTreeNode[] array = list.toArray(new ILayerTreeNode[list.size()]);
            selectionService.setSelection(array.length == 1 ? array[0] : array);
        }
    });

    viewer.addTreeListener(new ITreeViewerListener() {
        @Override
        public void treeExpanded(TreeExpansionEvent event) {
            ILayerTreeNode layerNode = (ILayerTreeNode) event.getElement();
            layerNode.setExpanded(true);
        }

        @Override
        public void treeCollapsed(TreeExpansionEvent event) {
            ILayerTreeNode layerNode = (ILayerTreeNode) event.getElement();
            layerNode.setExpanded(false);
        }
    });

    viewer.getTree().addMouseListener(new MouseAdapter() {
        @Override
        public void mouseDoubleClick(MouseEvent e) {
            ViewerCell cell = viewer.getCell(new Point(e.x, e.y));
            if (cell == null)
                return;

            ILayerTreeNode layer = (ILayerTreeNode) cell.getElement();
            selectLayer(layer);
        }

        @Override
        public void mouseDown(MouseEvent e) {
            ViewerCell cell = viewer.getCell(new Point(e.x, e.y));
            if (cell == null) {
                viewer.setSelection(StructuredSelection.EMPTY);
            }
        }
    });

    viewer.getTree().addTraverseListener(new TraverseListener() {
        @Override
        public void keyTraversed(TraverseEvent e) {
            if (e.detail == SWT.TRAVERSE_RETURN) {
                IStructuredSelection selection = (IStructuredSelection) viewer.getSelection();
                if (selection.size() == 1) {
                    ILayerTreeNode layer = (ILayerTreeNode) selection.getFirstElement();
                    selectLayer(layer);
                }
            }
        }
    });

    viewer.setCellEditors(new CellEditor[] { new TextCellEditor(viewer.getTree(), SWT.BORDER) });
    viewer.setColumnProperties(new String[] { "layer" }); //$NON-NLS-1$

    viewer.setCellModifier(new ICellModifier() {
        @Override
        public void modify(Object element, String property, Object value) {
            if (element instanceof Item) {
                element = ((Item) element).getData();
            }
            ((ILayerTreeNode) element).setLabel((String) value);
        }

        @Override
        public Object getValue(Object element, String property) {
            if (element instanceof Item) {
                element = ((Item) element).getData();
            }
            return ((ILayerTreeNode) element).getLabelOrName();
        }

        @Override
        public boolean canModify(Object element, String property) {
            return true;
        }
    });

    ColumnViewerEditorActivationStrategy activationStrategy = new ColumnViewerEditorActivationStrategy(viewer) {
        @Override
        protected boolean isEditorActivationEvent(ColumnViewerEditorActivationEvent event) {
            return event.eventType == ColumnViewerEditorActivationEvent.PROGRAMMATIC;
        }
    };
    TreeViewerEditor.create(viewer, activationStrategy, ColumnViewerEditor.KEYBOARD_ACTIVATION);

    //add drag and drop support
    int ops = DND.DROP_COPY | DND.DROP_MOVE;
    viewer.addDragSupport(ops, new Transfer[] { LayerTransfer.getInstance() },
            new LayerTreeDragSourceListener(viewer));
    viewer.addDropSupport(ops, new Transfer[] { LayerTransfer.getInstance(), FileTransfer.getInstance() },
            new LayerTreeDropAdapter(viewer, model, context));

    //add context menu
    menuService.registerContextMenu(viewer.getTree(), "au.gov.ga.earthsci.application.layertree.popupmenu"); //$NON-NLS-1$
}

From source file:au.gov.ga.earthsci.discovery.ui.preferences.DiscoveryServicesPreferencePage.java

License:Apache License

@Override
protected Control createContents(Composite parent) {
    Composite composite = new Composite(parent, SWT.NONE);
    GridData gd = new GridData(SWT.FILL, SWT.FILL, true, true);
    composite.setLayoutData(gd);//from w  ww. ja  v  a 2  s.c  o m

    GridLayout layout = new GridLayout();
    layout.numColumns = 2;
    layout.marginWidth = convertHorizontalDLUsToPixels(IDialogConstants.HORIZONTAL_MARGIN);
    layout.marginHeight = convertVerticalDLUsToPixels(IDialogConstants.VERTICAL_MARGIN);
    layout.horizontalSpacing = convertHorizontalDLUsToPixels(IDialogConstants.HORIZONTAL_SPACING);
    layout.verticalSpacing = convertVerticalDLUsToPixels(IDialogConstants.VERTICAL_SPACING);
    composite.setLayout(layout);

    table = new Table(composite,
            SWT.CHECK | SWT.MULTI | SWT.FULL_SELECTION | SWT.H_SCROLL | SWT.V_SCROLL | SWT.BORDER);
    GridData data = new GridData(SWT.FILL, SWT.FILL, true, true);
    data.widthHint = convertWidthInCharsToPixels(ILayoutConstants.DEFAULT_TABLE_WIDTH);
    data.heightHint = convertHeightInCharsToPixels(ILayoutConstants.DEFAULT_TABLE_HEIGHT);
    table.setLayoutData(data);

    viewer = new CheckboxTableViewer(table);

    // Key listener for delete
    table.addKeyListener(new KeyAdapter() {
        @Override
        public void keyPressed(KeyEvent e) {
            if (e.keyCode == SWT.DEL) {
                removeSelected();
            }
        }
    });
    setTableColumns();

    viewer.setComparator(comparator);
    viewer.setContentProvider(new ArrayContentProvider());
    viewer.setLabelProvider(new DiscoveryServiceLabelProvider());

    stagingSet.clear();
    stagingSet.addAll(DiscoveryServiceManager.getServices());
    viewer.setInput(stagingSet);

    viewer.setCellModifier(new ICellModifier() {
        @Override
        public boolean canModify(Object element, String property) {
            return element instanceof IDiscoveryService;
        }

        @Override
        public Object getValue(Object element, String property) {
            String name = ((IDiscoveryService) element).getName();
            return name != null ? name : ""; //$NON-NLS-1$
        }

        @Override
        public void modify(Object element, String prop, Object value) {
            if (value != null && value.toString().length() >= 0) {
                IDiscoveryService service;
                if (element instanceof Item) {
                    service = (IDiscoveryService) ((Item) element).getData();
                } else if (element instanceof IDiscoveryService) {
                    service = (IDiscoveryService) element;
                } else {
                    return;
                }
                if (!value.toString().equals(service.getName())) {
                    Map<IDiscoveryServiceProperty<?>, Object> propertyValues = new HashMap<IDiscoveryServiceProperty<?>, Object>();
                    IDiscoveryServiceProperty<?>[] properties = service.getProvider().getProperties();
                    if (properties != null) {
                        for (IDiscoveryServiceProperty<?> property : properties) {
                            propertyValues.put(property, property.getValue(service));
                        }
                    }

                    IDiscoveryService replacement = service.getProvider().createService(value.toString(),
                            service.getServiceURL(), propertyValues);
                    replacement.setEnabled(service.isEnabled());
                    stagingSet.remove(service);
                    stagingSet.add(replacement);
                    viewer.refresh();
                }
            }
        }
    });
    viewer.setColumnProperties(new String[] { "name" }); //$NON-NLS-1$
    viewer.setCellEditors(new CellEditor[] { new TextCellEditor(table) });

    viewer.setCheckStateProvider(new ICheckStateProvider() {
        @Override
        public boolean isChecked(Object element) {
            return ((IDiscoveryService) element).isEnabled();
        }

        @Override
        public boolean isGrayed(Object element) {
            return false;
        }
    });

    viewer.addCheckStateListener(new ICheckStateListener() {
        @Override
        public void checkStateChanged(CheckStateChangedEvent event) {
            IDiscoveryService service = (IDiscoveryService) event.getElement();
            if (!originalEnablement.containsKey(service)) {
                originalEnablement.put(service, service.isEnabled());
            }
            service.setEnabled(event.getChecked());
            viewer.refresh();
            validateButtons();
        }
    });

    viewer.addSelectionChangedListener(new ISelectionChangedListener() {
        @Override
        public void selectionChanged(SelectionChangedEvent event) {
            validateButtons();
        }
    });

    Composite verticalButtonBar = createVerticalButtonBar(composite);
    data = new GridData(SWT.FILL, SWT.FILL, false, false);
    data.verticalAlignment = SWT.TOP;
    data.verticalIndent = 0;
    verticalButtonBar.setLayoutData(data);
    validateButtons();

    return composite;
}

From source file:au.gov.ga.earthsci.layer.ui.LayerTreePart.java

License:Apache License

protected void createStructureViewer(Composite parent, EMenuService menuService, CTabItem tabItem) {
    structureViewer = new CheckboxTreeViewer(parent, SWT.MULTI);
    tabItem.setControl(structureViewer.getControl());
    structureViewer.getTree()/*from   ww  w.j av a 2  s  .c o  m*/
            .setBackgroundImage(ImageRegistry.getInstance().get(ImageRegistry.ICON_TRANSPARENT));
    context.set(TreeViewer.class, structureViewer);

    clipboard = new Clipboard(parent.getDisplay());
    context.set(Clipboard.class, clipboard);

    //create a property change listener for updating the labels whenever a property
    //changes on an ILayerTreeNode instance
    final PropertyChangeListener anyChangeListener = new PropertyChangeListener() {
        @Override
        public void propertyChange(final PropertyChangeEvent evt) {
            updateElementLabel(evt.getSource());
        }
    };
    //create a property change listener that ensures the expanded state of the tree
    //is kept in sync with the value of the expanded property for each node
    final PropertyChangeListener expandedChangeListener = new PropertyChangeListener() {
        @Override
        public void propertyChange(PropertyChangeEvent evt) {
            syncExpandedNodes();
        }
    };

    //setup the label provider
    labelProvider = new LayerTreeLabelProvider();

    //create a bean list property associated with ILayerTreeNode's children property
    IBeanListProperty<ILayerTreeNode, ILayerTreeNode> childrenProperty = BeanProperties
            .list(ILayerTreeNode.class, "children", ILayerTreeNode.class); //$NON-NLS-1$
    //setup a factory for creating observables observing ILayerTreeNodes
    IObservableFactory<ILayerTreeNode, IObservableList<ILayerTreeNode>> observableFactory = childrenProperty
            .listFactory();

    //listen for any changes (additions/removals) to any of the children in the tree
    observableListTreeSupport = new ObservableListTreeSupport<ILayerTreeNode>(observableFactory);
    observableListTreeSupport.addListener(new ITreeChangeListener<ILayerTreeNode>() {
        @Override
        public void elementAdded(ILayerTreeNode element) {
            element.addPropertyChangeListener(anyChangeListener);
            element.addPropertyChangeListener("expanded", expandedChangeListener); //$NON-NLS-1$
        }

        @Override
        public void elementRemoved(ILayerTreeNode element) {
            element.removePropertyChangeListener(anyChangeListener);
            element.removePropertyChangeListener("expanded", expandedChangeListener); //$NON-NLS-1$
        }
    });

    //create a content provider that listens for changes to any children in the tree
    ObservableListTreeContentProvider<ILayerTreeNode> contentProvider = new ObservableListTreeContentProvider<ILayerTreeNode>(
            observableFactory, null);

    //set the viewer's providers
    structureViewer.setContentProvider(contentProvider);
    structureViewer.setLabelProvider(labelProvider);
    structureViewer.setCheckStateProvider(new LayerTreeCheckStateProvider());

    //set the viewer and listener inputs
    structureViewer.setInput(model.getRootNode());
    observableListTreeSupport.setInput(model.getRootNode());

    //Listen for any additions to the tree, and expand added node's parent, so that
    //added nodes are always visible. This is done after the input is set up, so that
    //we don't expand all the nodes that are already in the tree.
    observableListTreeSupport.addListener(new TreeChangeAdapter<ILayerTreeNode>() {
        @Override
        public void elementAdded(ILayerTreeNode element) {
            //for any children added, expand the nodes
            if (!element.isRoot()) {
                element.getParent().setExpanded(true);
            }

            //if the nodes were already expanded, the expanded property change event
            //is not fired, so we need to sync the expanded state anyway
            syncExpandedNodes();

            //when a layer is added, we should activate this part and select the added element
            activateAndSelectElement(element);
        }
    });

    //expand any nodes that should be expanded after unpersisting
    syncExpandedNodes();

    //enable/disable any nodes that are checked/unchecked
    structureViewer.addCheckStateListener(new ICheckStateListener() {
        @Override
        public void checkStateChanged(CheckStateChangedEvent event) {
            Object element = event.getElement();
            if (element instanceof ILayerTreeNode) {
                ILayerTreeNode node = (ILayerTreeNode) element;
                node.enableChildren(event.getChecked());
            }
        }
    });

    //setup the selection tracking
    structureViewer.addSelectionChangedListener(new ISelectionChangedListener() {
        @Override
        public void selectionChanged(SelectionChangedEvent event) {
            IStructuredSelection selection = (IStructuredSelection) structureViewer.getSelection();
            List<?> list = selection.toList();
            ILayerTreeNode[] array = list.toArray(new ILayerTreeNode[list.size()]);
            settingSelection = true;
            selectionService.setSelection(array.length == 1 ? array[0] : array);
            settingSelection = false;
        }
    });
    structureViewer.getTree().addSelectionListener(new SelectionAdapter() {
        @Override
        public void widgetDefaultSelected(SelectionEvent e) {
            IStructuredSelection selection = (IStructuredSelection) structureViewer.getSelection();
            ILayerTreeNode firstElement = (ILayerTreeNode) selection.getFirstElement();
            if (firstElement != null) {
                selectLayer(firstElement);
            }
        }
    });

    //setup tree expansion/collapse listening
    structureViewer.addTreeListener(new ITreeViewerListener() {
        @Override
        public void treeExpanded(TreeExpansionEvent event) {
            ILayerTreeNode layerNode = (ILayerTreeNode) event.getElement();
            layerNode.setExpanded(true);
        }

        @Override
        public void treeCollapsed(TreeExpansionEvent event) {
            ILayerTreeNode layerNode = (ILayerTreeNode) event.getElement();
            layerNode.setExpanded(false);
        }
    });

    //make tree cells unselectable by selecting outside
    structureViewer.getTree().addMouseListener(new MouseAdapter() {
        @Override
        public void mouseDown(MouseEvent e) {
            ViewerCell cell = structureViewer.getCell(new Point(e.x, e.y));
            if (cell == null) {
                structureViewer.setSelection(StructuredSelection.EMPTY);
            }
        }
    });

    //setup cell editing
    structureViewer
            .setCellEditors(new CellEditor[] { new TextCellEditor(structureViewer.getTree(), SWT.BORDER) });
    structureViewer.setColumnProperties(new String[] { "layer" }); //$NON-NLS-1$
    structureViewer.setCellModifier(new ICellModifier() {
        @Override
        public void modify(Object element, String property, Object value) {
            if (element instanceof Item) {
                element = ((Item) element).getData();
            }
            ((ILayerTreeNode) element).setLabel((String) value);
        }

        @Override
        public Object getValue(Object element, String property) {
            if (element instanceof Item) {
                element = ((Item) element).getData();
            }
            return ((ILayerTreeNode) element).getLabelOrName();
        }

        @Override
        public boolean canModify(Object element, String property) {
            return true;
        }
    });

    ColumnViewerEditorActivationStrategy activationStrategy = new ColumnViewerEditorActivationStrategy(
            structureViewer) {
        @Override
        protected boolean isEditorActivationEvent(ColumnViewerEditorActivationEvent event) {
            return event.eventType == ColumnViewerEditorActivationEvent.PROGRAMMATIC;
        }
    };
    TreeViewerEditor.create(structureViewer, activationStrategy, ColumnViewerEditor.KEYBOARD_ACTIVATION);

    //add drag and drop support
    int ops = DND.DROP_COPY | DND.DROP_MOVE;
    structureViewer.addDragSupport(ops,
            new Transfer[] { LocalLayerTransfer.getInstance(), LayerTransfer.getInstance() },
            new LayerTreeDragSourceListener(structureViewer));
    structureViewer
            .addDropSupport(ops,
                    new Transfer[] { LocalLayerTransfer.getInstance(), LayerTransfer.getInstance(),
                            FileTransfer.getInstance() },
                    new LayerTreeDropAdapter(structureViewer, model, context));

    //add context menu
    menuService.registerContextMenu(structureViewer.getTree(),
            "au.gov.ga.earthsci.application.layertree.popupmenu"); //$NON-NLS-1$
}

From source file:ca.uvic.chisel.javasketch.ui.internal.wizards.ExportTraceWizardPage1.java

License:Open Source License

/**
 * @param page//w ww .j  av  a2s  .  com
 * @return
 */
private Control createTraceArea(Composite page) {
    Group traceGroup = new Group(page, SWT.NONE);
    traceGroup.setLayout(new GridLayout());
    traceGroup.setText("Threads To Export");
    threadViewer = new CheckboxTreeViewer(traceGroup);
    threadViewer.setContentProvider(new ITreeContentProvider() {

        @Override
        public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
        }

        @Override
        public void dispose() {
        }

        @Override
        public Object[] getElements(Object inputElement) {
            return getChildren(inputElement);
        }

        @Override
        public boolean hasChildren(Object element) {
            return (element instanceof ExportTraceWizardPage1 || element instanceof ITrace);
        }

        @Override
        public Object getParent(Object element) {
            if (element instanceof ITrace) {
                return ExportTraceWizardPage1.this;
            } else if (element instanceof IThread) {
                return ((IThread) element).getTrace();
            }
            return null;
        }

        @Override
        public Object[] getChildren(Object parentElement) {
            if (parentElement instanceof ExportTraceWizardPage1) {
                IProgramSketch[] sketches = SketchPlugin.getDefault().getStoredSketches();
                ITrace[] traces = new ITrace[sketches.length];
                for (int i = 0; i < sketches.length; i++) {
                    traces[i] = sketches[i].getTraceData();
                }
                return traces;
            } else if (parentElement instanceof ITrace) {
                return ((ITrace) parentElement).getThreads().toArray();
            }
            return new Object[0];
        }
    });
    threadViewer.setLabelProvider(new WorkbenchLabelProvider());
    threadViewer.setInput(this);
    threadViewer.addCheckStateListener(new ICheckStateListener() {

        @Override
        public void checkStateChanged(CheckStateChangedEvent event) {
            boolean checked = event.getChecked();
            ITraceModel element = (ITraceModel) event.getElement();
            updateCheckedState(checked, element);

        }

    });
    threadViewer.setSorter(new ViewerSorter() {
        /* (non-Javadoc)
         * @see org.eclipse.jface.viewers.ViewerComparator#compare(org.eclipse.jface.viewers.Viewer, java.lang.Object, java.lang.Object)
         */
        @Override
        public int compare(Viewer viewer, Object e1, Object e2) {
            TreeViewer tv = (TreeViewer) viewer;
            String s1 = ((ILabelProvider) tv.getLabelProvider()).getText(e1);
            String s2 = ((ILabelProvider) tv.getLabelProvider()).getText(e2);
            return s1.compareTo(s2);
        }
    });
    threadViewer.getControl().setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));
    //set the trace
    ITrace trace = ((ExportTraceWizard) getWizard()).getTrace();
    if (trace == null) {
        String traceID = getDialogSettings().get("trace");
        //try to get it from saved information
        String[] threads = getDialogSettings().getArray("threads");
        if (traceID != null) {
            IProgramSketch sketch = SketchPlugin.getDefault().getSketch(traceID);
            if (sketch != null) {
                trace = sketch.getTraceData();
                if (trace != null) {
                    this.trace = trace;
                    if (threads != null && threads.length > 0) {
                        for (int i = 0; i < threads.length; i++) {
                            ITraceModelProxy proxy = trace.getElement(threads[i]);
                            ITraceModel element = proxy.getElement();
                            if (element != null) {
                                threadViewer.setChecked(element, true);
                                updateCheckedState(true, element);
                            }
                        }

                    } else {
                        threadViewer.setChecked(trace, true);
                        updateCheckedState(true, trace);
                    }
                }
            }

        }
    } else {
        this.trace = trace;
        threadViewer.setChecked(trace, true);
        updateCheckedState(true, trace);
    }
    return traceGroup;
}