Example usage for org.eclipse.jface.viewers TreeViewer setSelection

List of usage examples for org.eclipse.jface.viewers TreeViewer setSelection

Introduction

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

Prototype

@Override
    protected void setSelection(List<Item> items) 

Source Link

Usage

From source file:org.eclipse.oomph.setup.doc.user.wizard.CaptureSetupWizard.java

License:Open Source License

protected void postProcessProductPage(WizardDialog wizardDialog) {
    getViewerControl(wizardDialog, "productViewer").setFocus();

    ResourceSet resourceSet = getResourceSet(wizardDialog);
    ProductVersion luna = (ProductVersion) resourceSet.getEObject(URI.createURI(
            "index:/org.eclipse.setup#//@productCatalogs[name='org.eclipse.products']/@products[name='epp.package.standard']/@versions[name='luna']"),
            false);/* w w w .j a  v  a  2s.  c o m*/

    TreeViewer productViewer = getViewer(wizardDialog, "productViewer");
    productViewer.setSelection(new StructuredSelection(luna.getProduct()));

    AccessUtil.busyWait(10);

    ComboViewer versionComboViewer = getViewer(wizardDialog, "versionComboViewer");
    versionComboViewer.setSelection(new StructuredSelection(luna));

    ComboViewer poolComboViewer = getViewer(wizardDialog, "poolComboViewer");
    poolComboViewer.getCombo().select(0);

    Link link = getWidget(wizardDialog, "version");
    link.setText("<a>1.0.0 Build 1234</a>");
    link.getParent().layout(true);
}

From source file:org.eclipse.oomph.setup.doc.user.wizard.CaptureSetupWizard.java

License:Open Source License

protected void postProcessProjectPage(WizardDialog wizardDialog) {
    ResourceSet resourceSet = getResourceSet(wizardDialog);
    ProjectCatalog projectCatalog = (ProjectCatalog) resourceSet
            .getResource(URI.createURI("index:/org.eclipse.projects.setup"), false).getContents().get(0);

    TreeViewer projectViewer = getViewer(wizardDialog, "projectViewer");
    projectViewer.getControl().setFocus();

    for (Iterator<Project> it = projectCatalog.getProjects().iterator(); it.hasNext();) {
        Project project = it.next();//  w w  w. ja  va2 s  . c om
        String label = project.getLabel();
        if (!"Oomph".equals(label)) {
            if (!"<User>".equals(label)) {
                it.remove();
            }
        } else {
            projectViewer.setSelection(new StructuredSelection(project));
        }
    }

    ReflectUtil.invokeMethod(ReflectUtil.getMethod(projectViewer, "fireDoubleClick", DoubleClickEvent.class),
            projectViewer, (Object) null);
}

From source file:org.eclipse.oomph.setup.doc.user.wizard.CaptureSetupWizard.java

License:Open Source License

protected void postProcessConfirmationPage(WizardDialog wizardDialog, boolean all) {
    AccessUtil.busyWait(100);//w w  w  .j  a  v a2 s . c  o  m

    CheckboxTreeViewer taskViewer = getViewer(wizardDialog, "viewer");
    taskViewer.getControl().setFocus();

    if (all) {
        Button showAll = getWidget(wizardDialog, "showAllTasks");
        showAll.setSelection(true);
        showAll.notifyListeners(SWT.Selection, new Event());
    }

    Button overwrite = getWidget(wizardDialog, "overwrite");
    if (overwrite != null) {
        overwrite.setSelection(true);
        overwrite.notifyListeners(SWT.Selection, new Event());
        AccessUtil.busyWait(10);
    }

    {
        ITreeContentProvider provider = (ITreeContentProvider) taskViewer.getContentProvider();
        Object[] children = provider.getChildren(taskViewer.getInput());
        for (Object object : provider.getChildren(children[0])) {
            if (object instanceof P2Task) {
                taskViewer.setSelection(new StructuredSelection(object));
                break;
            }
        }
    }

    AccessUtil.busyWait(10);

    TreeViewer childrenViewer = getViewer(wizardDialog, "childrenViewer");
    childrenViewer.getControl().setFocus();

    {
        ITreeContentProvider provider = (ITreeContentProvider) childrenViewer.getContentProvider();
        Object[] children = provider.getChildren(childrenViewer.getInput());
        childrenViewer.setSelection(new StructuredSelection(children[0]));
    }

    SashForm hsash = getWidget(wizardDialog, "hsash");
    hsash.setWeights(new int[] { 12, 9 });

    SashForm vsash = getWidget(wizardDialog, "vsash");
    vsash.setWeights(new int[] { 2, 1 });

    AccessUtil.busyWait(10);
}

From source file:org.eclipse.oomph.setup.presentation.SetupEditor.java

License:Open Source License

/**
 * This deals with how we want selection in the outliner to affect the other views.
 * <!-- begin-user-doc -->/*from   ww  w .j av a 2  s.  co  m*/
 * <!-- end-user-doc -->
 * @generated NOT
 */
public void handleContentOutlineSelection(ISelection selection) {
    if (contentOutlinePage != null && selectionViewer != null && !selection.isEmpty()
            && selection instanceof IStructuredSelection) {
        Iterator<?> selectedElements = ((IStructuredSelection) selection).iterator();
        if (selectedElements.hasNext()) {
            Object selectedElement = selectedElements.next();

            ArrayList<Object> selectionList = new ArrayList<Object>();
            selectionList.addAll(contentOutlinePage.getOriginals(selectedElement));
            while (selectedElements.hasNext()) {
                selectionList.addAll(contentOutlinePage.getOriginals(selectedElements.next()));
            }

            TreeViewer oldSectionViewer = selectionViewer;
            selectionViewer = null;
            oldSectionViewer.setSelection(new StructuredSelection(selectionList));
            selectionViewer = oldSectionViewer;
        }
    }
}

From source file:org.eclipse.oomph.setup.ui.actions.AbstractContainerAction.java

License:Open Source License

protected final void expandItem(final EObject object) {
    if (selectionProvider instanceof IViewerProvider) {
        IViewerProvider viewerProvider = (IViewerProvider) selectionProvider;
        final Viewer viewer = viewerProvider.getViewer();
        if (viewer instanceof TreeViewer) {
            UIUtil.getDisplay().asyncExec(new Runnable() {
                public void run() {
                    TreeViewer treeViewer = (TreeViewer) viewer;
                    expand(treeViewer, object);

                    IStructuredSelection selection = (IStructuredSelection) treeViewer.getSelection();

                    @SuppressWarnings("unchecked")
                    List<Object> list = selection.toList();
                    list = new ArrayList<Object>(list);
                    list.add(object);/* www .j  av  a2  s .co  m*/

                    treeViewer.setSelection(new StructuredSelection(list));
                }

                private void expand(TreeViewer treeViewer, EObject object) {
                    treeViewer.setExpandedState(object, true);

                    EObject eContainer = object.eContainer();
                    if (eContainer != null) {
                        expand(treeViewer, eContainer);
                    }
                }
            });
        }
    }
}

From source file:org.eclipse.pde.emfforms.editor.actions.RemoveAction.java

License:Open Source License

@Override
public void run() {
    TreeViewer treeViewer = masterDetail.getTreeViewer();

    EObject elementToSelectAfterDeletion = computeElementToSelectAfterDeletion(treeViewer);

    getDeleteAction().run();// w w  w.j  a  v a 2  s. co  m

    treeViewer.refresh();
    if (elementToSelectAfterDeletion != null) {
        treeViewer.setSelection(new StructuredSelection(elementToSelectAfterDeletion));
        treeViewer.getTree().setFocus();
    }
}

From source file:org.eclipse.rcptt.ui.tags.SelectTagDialog.java

License:Open Source License

@Override
protected Control createDialogArea(final Composite parent) {
    final Composite panel = (Composite) super.createDialogArea(parent);

    final SearchControl searchControl = new SearchControl(panel);
    searchControl.setInitialText(Messages.SelectTagDialog_InitialTagName);
    GridDataFactory.fillDefaults().grab(true, false).applyTo(searchControl);
    final TreeViewer tagsViewer = new TreeViewer(panel, SWT.BORDER | SWT.MULTI);
    tagsViewer.getControl().setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));
    searchControl.setSearchResultControl(tagsViewer.getControl());
    searchControl.getFilterControl().addModifyListener(new ModifyListener() {
        public void modifyText(ModifyEvent e) {
            String value = searchControl.getFilterString();
            if (!searchControl.getInitialText().equals(value)) {
                tagName = value;/*from  w ww.  jav a 2s  .c  o  m*/
            } else {
                tagName = null;
            }
            tagsViewer.refresh();
            validate();
        }
    });

    tagsViewer.setFilters(new ViewerFilter[] { new TreeViewerWildcardFilter(tagsViewer) {
        protected boolean isIgnoredElement(Object parentElement, Object element) {
            return false;
        }

        @Override
        protected String getFilterText() {
            String value = searchControl.getFilterString();
            if (!searchControl.getInitialText().equals(value)) {
                return value;
            }
            return ""; //$NON-NLS-1$
        }

        @Override
        protected String getElementText(Object parentElement, Object element) {
            return ((Tag) element).getValue();
        }

    } });

    final ObservableListTreeContentProvider contentProvider = new ObservableListTreeContentProvider(
            new IObservableFactory() {

                public IObservable createObservable(final Object target) {
                    if (target instanceof IObservable) {
                        return (IObservable) target;
                    } else if (target instanceof Tag) {
                        final Tag tag = (Tag) target;
                        ObservableList list = new WritableList();
                        synchronized (tag) {
                            EList<Tag> tags = tag.getTags();
                            for (Tag childTag : tags) {
                                synchronized (childTag) {
                                    if (childTag.getTags().size() > 0
                                            || !disabledTags.contains(childTag.getPath())) {
                                        list.add(childTag);
                                    }
                                }
                            }
                        }
                        return list;
                    } else {
                        return null;
                    }
                }
            }, null);

    tagsViewer.setContentProvider(contentProvider);

    allTags = new WritableList();
    TagsRegistry tagRegistry = Q7UIPlugin.getDefault().getTags();
    synchronized (tagRegistry) {
        EList<Tag> tags = tagRegistry.getTags();
        for (Tag childTag : tags) {
            synchronized (childTag) {
                if (childTag.getTags().size() > 0 || !disabledTags.contains(childTag.getPath())) {
                    allTags.add(childTag);
                }
            }
        }
    }
    tagsViewer.setInput(allTags);
    tagsViewer.setLabelProvider(new DelegatingStyledCellLabelProvider(new TagLabels()));
    tagsViewer.addSelectionChangedListener(new ISelectionChangedListener() {

        public void selectionChanged(final SelectionChangedEvent event) {
            final IStructuredSelection iss = (IStructuredSelection) event.getSelection();
            result.clear();

            boolean changed = false;
            for (final Object o : iss.toList()) {
                final Tag tag = (Tag) o;
                if (!disabledTags.contains(tag.getPath())) {
                    result.add(tag);
                } else {
                    changed = true;
                }
            }

            if (changed) {
                tagsViewer.setSelection(new StructuredSelection(result));
            }
            validate();
        }
    });
    tagsViewer.addDoubleClickListener(new IDoubleClickListener() {

        public void doubleClick(final DoubleClickEvent event) {
            setReturnCode(OK);
            result.clear();
            result.add((Tag) ((IStructuredSelection) event.getSelection()).getFirstElement());
            close();
        }
    });
    validate();

    PlatformUI.getWorkbench().getHelpSystem().setHelp(panel, IQ7HelpContextIds.TAGS);
    return panel;
}

From source file:org.eclipse.sapphire.ui.form.editors.masterdetails.MasterDetailsEditorPage.java

License:Open Source License

private FilteredTree createContentOutline(final Composite parent, final MasterDetailsContentOutline outline,
        final boolean addBorders) {
    final int treeStyle = (addBorders ? SWT.BORDER : SWT.NONE) | SWT.MULTI;

    final ContentOutlineFilteredTree filteredTree = new ContentOutlineFilteredTree(parent, treeStyle, outline);
    final TreeViewer treeViewer = filteredTree.getViewer();
    final Tree tree = treeViewer.getTree();

    final ITreeContentProvider contentProvider = new ITreeContentProvider() {
        private final Listener listener = new Listener() {
            @Override/*from   ww w  .java 2 s .  c o m*/
            public void handle(final org.eclipse.sapphire.Event event) {
                if (event instanceof PartEvent) {
                    final SapphirePart part = ((PartEvent) event).part();

                    if (part instanceof MasterDetailsContentNode) {
                        final MasterDetailsContentNode node = (MasterDetailsContentNode) part;

                        if (event instanceof PartVisibilityEvent) {
                            final MasterDetailsContentNode parent = node.getParentNode();

                            if (parent == outline.getRoot()) {
                                treeViewer.refresh();
                            } else {
                                treeViewer.refresh(parent);
                            }
                        } else {
                            if (node.visible()) {
                                if (event instanceof LabelChangedEvent || event instanceof ImageChangedEvent) {
                                    Display.getCurrent().asyncExec(new TreeViewerUpdateJob(treeViewer, node));
                                } else if (event instanceof NodeListEvent) {
                                    treeViewer.refresh(node);
                                }
                            }
                        }
                    }
                }
            }
        };

        private void attach(final List<MasterDetailsContentNode> nodes) {
            for (MasterDetailsContentNode node : nodes) {
                node.attach(this.listener);
            }
        }

        private void detach(final List<MasterDetailsContentNode> nodes) {
            for (MasterDetailsContentNode node : nodes) {
                node.detach(this.listener);
                detach(node.nodes());
            }
        }

        public Object[] getElements(final Object inputElement) {
            final MasterDetailsContentNodeList nodes = outline.getRoot().nodes();
            attach(nodes);
            return nodes.visible().toArray();
        }

        public Object[] getChildren(final Object parentElement) {
            final MasterDetailsContentNodeList nodes = ((MasterDetailsContentNode) parentElement).nodes();
            attach(nodes);
            return nodes.visible().toArray();
        }

        public Object getParent(final Object element) {
            return ((MasterDetailsContentNode) element).getParentNode();
        }

        public boolean hasChildren(final Object parentElement) {
            final MasterDetailsContentNodeList nodes = ((MasterDetailsContentNode) parentElement).nodes();
            attach(nodes);
            return !nodes.visible().isEmpty();
        }

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

        public void dispose() {
            detach(outline.getRoot().nodes());
        }
    };

    final LabelProvider labelProvider = new LabelProvider() {
        private final Map<ImageDescriptor, Image> images = new HashMap<ImageDescriptor, Image>();

        @Override
        public String getText(final Object element) {
            return ((MasterDetailsContentNode) element).getLabel();
        }

        @Override
        public Image getImage(final Object element) {
            return getImage((MasterDetailsContentNode) element);
        }

        private Image getImage(final MasterDetailsContentNode node) {
            final ImageDescriptor imageDescriptor = node.getImage();
            Image image = this.images.get(imageDescriptor);

            if (image == null) {
                image = imageDescriptor.createImage();
                this.images.put(imageDescriptor, image);
            }

            return image;
        }

        @Override
        public void dispose() {
            for (Image image : this.images.values()) {
                image.dispose();
            }
        }
    };

    new SapphireToolTip(tree) {
        protected Object getToolTipArea(final Event event) {
            return treeViewer.getCell(new Point(event.x, event.y));
        }

        protected boolean shouldCreateToolTip(Event event) {
            if (!super.shouldCreateToolTip(event)) {
                return false;
            }

            setShift(new Point(0, 20));
            tree.setToolTipText("");

            boolean res = false;

            final MasterDetailsContentNode node = getNode(event);

            if (node != null) {
                res = !node.validation().ok();
            }

            return res;
        }

        private MasterDetailsContentNode getNode(final Event event) {
            final TreeItem item = tree.getItem(new Point(event.x, event.y));

            if (item == null) {
                return null;
            } else {
                return (MasterDetailsContentNode) item.getData();
            }
        }

        protected void afterHideToolTip(Event event) {
            super.afterHideToolTip(event);
            // Clear the restored value else this could be a source of a leak
            if (event != null && event.widget != treeViewer.getControl()) {
                treeViewer.getControl().setFocus();
            }
        }

        @Override
        protected void createContent(final Event event, final Composite parent) {
            final MasterDetailsContentNode node = getNode(event);

            parent.setLayout(glayout(1));

            SapphireFormText text = new SapphireFormText(parent, SWT.NO_FOCUS);
            text.setLayoutData(gdfill());

            final org.eclipse.sapphire.modeling.Status validation = node.validation();
            final List<org.eclipse.sapphire.modeling.Status> items = gather(validation);

            final StringBuffer buffer = new StringBuffer();
            buffer.append("<form>");

            final int count = items.size();
            int i = 0;

            for (org.eclipse.sapphire.modeling.Status item : items) {
                final String imageKey = (item.severity() == org.eclipse.sapphire.modeling.Status.Severity.ERROR
                        ? "error"
                        : "warning");
                buffer.append("<li style=\"image\" value=\"" + imageKey + "\">" + escapeForXml(item.message())
                        + "</li>");

                i++;

                if (count > 10 && i == 9) {
                    break;
                }
            }

            if (count > 10) {
                final String msg = NLS.bind(Resources.problemsOverflowMessage, numberToString(count - 9));
                final String imageKey = (validation
                        .severity() == org.eclipse.sapphire.modeling.Status.Severity.ERROR ? "error"
                                : "warning");
                buffer.append("<br/><li style=\"image\" value=\"" + imageKey + "\">" + msg + "</li>");
            }

            buffer.append("</form>");

            text.setText(buffer.toString(), true, false);
            text.setImage("error", ImageData.createFromClassLoader(SwtResourceCache.class, "Error.png"));
            text.setImage("warning", ImageData.createFromClassLoader(SwtResourceCache.class, "Warning.png"));
        }

        private String numberToString(final int number) {
            switch (number) {
            case 2:
                return Resources.two;
            case 3:
                return Resources.three;
            case 4:
                return Resources.four;
            case 5:
                return Resources.five;
            case 6:
                return Resources.six;
            case 7:
                return Resources.seven;
            case 8:
                return Resources.eight;
            case 9:
                return Resources.nine;
            default:
                return String.valueOf(number);
            }
        }

        private List<org.eclipse.sapphire.modeling.Status> gather(
                final org.eclipse.sapphire.modeling.Status status) {
            final List<org.eclipse.sapphire.modeling.Status> items = new ArrayList<org.eclipse.sapphire.modeling.Status>();
            gather(status, items);
            return items;
        }

        private void gather(final org.eclipse.sapphire.modeling.Status status,
                final List<org.eclipse.sapphire.modeling.Status> items) {
            if (status.children().isEmpty()) {
                items.add(status);
            } else {
                for (org.eclipse.sapphire.modeling.Status child : status.children()) {
                    gather(child, items);
                }
            }
        }
    };

    treeViewer.setContentProvider(contentProvider);
    treeViewer.setLabelProvider(labelProvider);
    treeViewer.setInput(new Object());

    final MutableReference<Boolean> ignoreSelectionChange = new MutableReference<Boolean>(false);
    final MutableReference<Boolean> ignoreExpandedStateChange = new MutableReference<Boolean>(false);

    final Listener contentTreeListener = new Listener() {
        @Override
        public void handle(final org.eclipse.sapphire.Event event) {
            if (event instanceof MasterDetailsContentOutline.SelectionChangedEvent) {
                if (ignoreSelectionChange.get() == true) {
                    return;
                }

                final MasterDetailsContentOutline.SelectionChangedEvent evt = (MasterDetailsContentOutline.SelectionChangedEvent) event;
                final List<MasterDetailsContentNode> selection = evt.selection();

                final IStructuredSelection sel;

                if (selection.isEmpty()) {
                    sel = StructuredSelection.EMPTY;
                } else {
                    sel = new StructuredSelection(selection);
                }

                if (!treeViewer.getSelection().equals(sel)) {
                    for (MasterDetailsContentNode node : selection) {
                        treeViewer.reveal(node);
                    }

                    treeViewer.setSelection(sel);
                }
            } else if (event instanceof MasterDetailsContentOutline.NodeExpandedStateChangedEvent) {
                if (ignoreExpandedStateChange.get() == true) {
                    return;
                }

                final MasterDetailsContentOutline.NodeExpandedStateChangedEvent evt = (MasterDetailsContentOutline.NodeExpandedStateChangedEvent) event;
                final MasterDetailsContentNode node = evt.node();

                final boolean expandedState = node.isExpanded();

                if (treeViewer.getExpandedState(node) != expandedState) {
                    treeViewer.setExpandedState(node, expandedState);
                }
            } else if (event instanceof MasterDetailsContentOutline.FilterChangedEvent) {
                final MasterDetailsContentOutline.FilterChangedEvent evt = (MasterDetailsContentOutline.FilterChangedEvent) event;
                filteredTree.changeFilterText(evt.filter());
            }
        }
    };

    outline.attach(contentTreeListener);

    treeViewer.addSelectionChangedListener(new ISelectionChangedListener() {
        public void selectionChanged(final SelectionChangedEvent event) {
            ignoreSelectionChange.set(true);

            try {
                final IStructuredSelection selection = (IStructuredSelection) event.getSelection();
                final List<MasterDetailsContentNode> nodes = new ArrayList<MasterDetailsContentNode>();

                for (Iterator<?> itr = selection.iterator(); itr.hasNext();) {
                    nodes.add((MasterDetailsContentNode) itr.next());
                }

                outline.setSelectedNodes(nodes);
            } finally {
                ignoreSelectionChange.set(false);
            }
        }
    });

    treeViewer.addTreeListener(new ITreeViewerListener() {
        public void treeExpanded(final TreeExpansionEvent event) {
            ignoreExpandedStateChange.set(true);

            try {
                final MasterDetailsContentNode node = (MasterDetailsContentNode) event.getElement();
                node.setExpanded(true);
            } finally {
                ignoreExpandedStateChange.set(false);
            }
        }

        public void treeCollapsed(final TreeExpansionEvent event) {
            ignoreExpandedStateChange.set(true);

            try {
                final MasterDetailsContentNode node = (MasterDetailsContentNode) event.getElement();
                node.setExpanded(false);
            } finally {
                ignoreExpandedStateChange.set(false);
            }
        }
    });

    final ContentOutlineActionSupport actionSupport = new ContentOutlineActionSupport(outline, tree);

    treeViewer.setExpandedElements(outline.getExpandedNodes().toArray());
    contentTreeListener
            .handle(new MasterDetailsContentOutline.SelectionChangedEvent(outline.getSelectedNodes()));

    filteredTree.changeFilterText(outline.getFilterText());

    final ModelElementsTransfer transfer = new ModelElementsTransfer(
            getModelElement().type().getModelElementClass().getClassLoader());
    final Transfer[] transfers = new Transfer[] { transfer };

    final DragSource dragSource = new DragSource(tree, DND.DROP_MOVE);
    dragSource.setTransfer(transfers);

    final List<Element> dragElements = new ArrayList<Element>();

    dragSource.addDragListener(new DragSourceListener() {
        public void dragStart(final DragSourceEvent event) {
            final TreeItem[] selection = tree.getSelection();
            final String filter = outline().getFilterText();

            if ((filter == null || filter.length() == 0) && draggable(selection)) {
                event.doit = true;

                for (TreeItem item : selection) {
                    final MasterDetailsContentNode node = (MasterDetailsContentNode) item.getData();
                    dragElements.add(node.getModelElement());
                }
            } else {
                event.doit = false;
            }
        }

        protected boolean draggable(final TreeItem[] selection) {
            if (selection.length > 0) {
                for (TreeItem item : selection) {
                    final MasterDetailsContentNode node = (MasterDetailsContentNode) item.getData();

                    if (!draggable(node)) {
                        return false;
                    }
                }

                return true;
            }

            return false;
        }

        protected boolean draggable(final MasterDetailsContentNode node) {
            final Element element = node.getModelElement();

            if (element.parent().definition() instanceof ListProperty && node.controls(element)) {
                return true;
            }

            return false;
        }

        public void dragSetData(final DragSourceEvent event) {
            event.data = dragElements;
        }

        public void dragFinished(final DragSourceEvent event) {
            if (event.detail == DND.DROP_MOVE) {
                // When drop target is the same editor as drag source, the drop handler takes care of removing
                // elements from their original location. The following block of code accounts for the case when 
                // dropping into another editor.

                boolean droppedIntoAnotherEditor = false;

                for (Element dragElement : dragElements) {
                    if (!dragElement.disposed()) {
                        droppedIntoAnotherEditor = true;
                        break;
                    }
                }

                if (droppedIntoAnotherEditor) {
                    final TreeItem[] selection = tree.getSelection();
                    final List<MasterDetailsContentNode> dragNodes = new ArrayList<MasterDetailsContentNode>();

                    for (TreeItem item : selection) {
                        dragNodes.add((MasterDetailsContentNode) item.getData());
                    }

                    final MasterDetailsContentNode parentNode = dragNodes.get(0).getParentNode();

                    MasterDetailsContentNode selectionPostDelete = findSelectionPostDelete(
                            parentNode.nodes().visible(), dragNodes);

                    if (selectionPostDelete == null) {
                        selectionPostDelete = parentNode;
                    }

                    try {
                        outline.listeners().suspend(MasterDetailsContentOutline.SelectionChangedEvent.class);

                        for (Element dragElement : dragElements) {
                            final ElementList<?> dragElementContainer = (ElementList<?>) dragElement.parent();
                            dragElementContainer.remove(dragElement);
                        }
                    } catch (Exception e) {
                        // Log this exception unless the cause is EditFailedException. These exception
                        // are the result of the user declining a particular action that is necessary
                        // before the edit can happen (such as making a file writable).

                        final EditFailedException editFailedException = EditFailedException.findAsCause(e);

                        if (editFailedException == null) {
                            SapphireUiFrameworkPlugin.log(e);
                        }
                    } finally {
                        outline.listeners().resume(MasterDetailsContentOutline.SelectionChangedEvent.class);
                    }

                    parentNode.getContentTree().setSelectedNode(selectionPostDelete);
                }
            }

            dragElements.clear();
        }
    });

    final DropTarget target = new DropTarget(tree, DND.DROP_MOVE);
    target.setTransfer(transfers);

    target.addDropListener(new DropTargetAdapter() {
        public void dragOver(final DropTargetEvent event) {
            if (event.item != null) {
                final TreeItem dragOverItem = (TreeItem) event.item;
                final MasterDetailsContentNode dragOverNode = (MasterDetailsContentNode) dragOverItem.getData();
                final MasterDetailsContentNode parentNode = dragOverNode.getParentNode();
                final List<MasterDetailsContentNode> siblingNodes = parentNode.nodes().visible();

                final Point pt = dragOverItem.getDisplay().map(null, tree, event.x, event.y);
                final Rectangle bounds = dragOverItem.getBounds();

                MasterDetailsContentNode precedingNode = null;
                MasterDetailsContentNode trailingNode = null;

                if (pt.y < bounds.y + bounds.height / 2) {
                    precedingNode = findPrecedingItem(siblingNodes, dragOverNode);
                    trailingNode = dragOverNode;

                    event.feedback = DND.FEEDBACK_INSERT_BEFORE;
                } else {
                    precedingNode = dragOverNode;
                    trailingNode = findTrailingItem(siblingNodes, dragOverNode);

                    event.feedback = DND.FEEDBACK_INSERT_AFTER;
                }

                boolean ok = false;

                if (precedingNode != null) {
                    final Element precedingElement = precedingNode.getModelElement();

                    if (precedingElement.parent().definition() instanceof ListProperty
                            && precedingNode.controls(precedingElement)) {
                        ok = true;
                    }
                }

                if (!ok && trailingNode != null) {
                    final Element trailingElement = trailingNode.getModelElement();

                    if (trailingElement.parent().definition() instanceof ListProperty
                            && trailingNode.controls(trailingElement)) {
                        ok = true;
                    }
                }

                if (!ok) {
                    event.feedback = DND.FEEDBACK_NONE;
                }
            }

            event.feedback |= DND.FEEDBACK_SCROLL;
        }

        @SuppressWarnings("unchecked")

        public void drop(final DropTargetEvent event) {
            if (event.data == null || event.item == null) {
                event.detail = DND.DROP_NONE;
                return;
            }

            // Determine where something was dropped.

            final List<Element> droppedElements = (List<Element>) event.data;
            final TreeItem dropTargetItem = (TreeItem) event.item;
            final MasterDetailsContentNode dropTargetNode = (MasterDetailsContentNode) dropTargetItem.getData();
            final MasterDetailsContentNode parentNode = dropTargetNode.getParentNode();
            final List<MasterDetailsContentNode> siblingNodes = parentNode.nodes().visible();

            final Point pt = tree.getDisplay().map(null, tree, event.x, event.y);
            final Rectangle bounds = dropTargetItem.getBounds();

            MasterDetailsContentNode precedingNode = null;
            MasterDetailsContentNode trailingNode = null;

            if (pt.y < bounds.y + bounds.height / 2) {
                precedingNode = findPrecedingItem(siblingNodes, dropTargetNode);
                trailingNode = dropTargetNode;
            } else {
                precedingNode = dropTargetNode;
                trailingNode = findTrailingItem(siblingNodes, dropTargetNode);
            }

            // Determine whether the drop was valid from model standpoint and figure out
            // where in the model the dropped elements are to be inserted.

            ElementList<?> list = null;
            int position = -1;

            if (precedingNode != null) {
                final Element precedingElement = precedingNode.getModelElement();

                if (precedingElement.parent().definition() instanceof ListProperty
                        && !precedingElement.parent().definition().isReadOnly()
                        && precedingNode.controls(precedingElement)) {
                    list = (ElementList<?>) precedingElement.parent();

                    final Set<ElementType> possibleListElementTypes = list.definition()
                            .service(PossibleTypesService.class).types();

                    for (Element droppedElement : droppedElements) {
                        if (!possibleListElementTypes.contains(droppedElement.type())) {
                            list = null;
                            break;
                        }
                    }

                    if (list != null) {
                        position = list.indexOf(precedingElement) + 1;
                    }
                }
            }

            if (list == null && trailingNode != null) {
                final Element trailingElement = trailingNode.getModelElement();

                if (trailingElement.parent().definition() instanceof ListProperty
                        && !trailingElement.parent().definition().isReadOnly()
                        && trailingNode.controls(trailingElement)) {
                    list = (ElementList<?>) trailingElement.parent();

                    final Set<ElementType> possibleListElementTypes = list.definition()
                            .service(PossibleTypesService.class).types();

                    for (Element droppedElement : droppedElements) {
                        if (!possibleListElementTypes.contains(droppedElement.type())) {
                            list = null;
                            break;
                        }
                    }

                    if (list != null) {
                        position = list.indexOf(trailingElement);
                    }
                }
            }

            if (list == null) {
                for (PropertyDef dropTargetChildProperty : dropTargetNode.getChildNodeFactoryProperties()) {
                    if (dropTargetChildProperty instanceof ListProperty
                            && !dropTargetChildProperty.isReadOnly()) {
                        final ListProperty dropTargetChildListProperty = (ListProperty) dropTargetChildProperty;

                        boolean compatible = true;

                        final Set<ElementType> possibleListElementTypes = dropTargetChildListProperty
                                .service(PossibleTypesService.class).types();

                        for (Element droppedElement : droppedElements) {
                            if (!possibleListElementTypes.contains(droppedElement.type())) {
                                compatible = false;
                                break;
                            }
                        }

                        if (compatible) {
                            list = dropTargetNode.getLocalModelElement().property(dropTargetChildListProperty);
                            position = list.size();
                        }
                    }
                }
            }

            if (list == null) {
                event.detail = DND.DROP_NONE;
                return;
            }

            // Perform the removal and insertion into the new location.

            try {
                outline.listeners().suspend(MasterDetailsContentOutline.SelectionChangedEvent.class);

                for (Element dragElement : dragElements) {
                    final ElementList<?> dragElementContainer = (ElementList<?>) dragElement.parent();

                    if (dragElementContainer == list && dragElementContainer.indexOf(dragElement) < position) {
                        position--;
                    }

                    dragElementContainer.remove(dragElement);
                }

                final List<MasterDetailsContentNode> newSelection = new ArrayList<MasterDetailsContentNode>();

                for (Element droppedElement : droppedElements) {
                    final Element insertedElement = list.insert(droppedElement.type(), position);
                    insertedElement.copy(droppedElement);

                    newSelection.add(parentNode.findNode(insertedElement));

                    position++;
                }

                parentNode.getContentTree().setSelectedNodes(newSelection);
            } catch (Exception e) {
                // Log this exception unless the cause is EditFailedException. These exception
                // are the result of the user declining a particular action that is necessary
                // before the edit can happen (such as making a file writable).

                final EditFailedException editFailedException = EditFailedException.findAsCause(e);

                if (editFailedException == null) {
                    SapphireUiFrameworkPlugin.log(e);
                }

                event.detail = DND.DROP_NONE;
            } finally {
                outline.listeners().resume(MasterDetailsContentOutline.SelectionChangedEvent.class);
            }
        }
    });

    tree.addDisposeListener(new DisposeListener() {
        public void widgetDisposed(final DisposeEvent event) {
            outline.detach(contentTreeListener);
            actionSupport.dispose();
        }
    });

    return filteredTree;
}

From source file:org.eclipse.sapphire.ui.forms.swt.MasterDetailsEditorPage.java

License:Open Source License

private FilteredTree createContentOutline(final Composite parent, final MasterDetailsContentOutline outline,
        final boolean addBorders) {
    final int treeStyle = (addBorders ? SWT.BORDER : SWT.NONE) | SWT.MULTI;

    final ContentOutlineFilteredTree filteredTree = new ContentOutlineFilteredTree(parent, treeStyle, outline);
    final TreeViewer treeViewer = filteredTree.getViewer();
    final Tree tree = treeViewer.getTree();

    final ITreeContentProvider contentProvider = new ITreeContentProvider() {
        private final Listener listener = new Listener() {
            @Override// ww  w.  ja  va2s .co m
            public void handle(final org.eclipse.sapphire.Event event) {
                if (event instanceof PartEvent) {
                    final SapphirePart part = ((PartEvent) event).part();

                    if (part instanceof MasterDetailsContentNodePart) {
                        final MasterDetailsContentNodePart node = (MasterDetailsContentNodePart) part;

                        if (event instanceof PartVisibilityEvent) {
                            final MasterDetailsContentNodePart parent = node.getParentNode();

                            if (parent == outline.getRoot()) {
                                treeViewer.refresh();
                            } else {
                                treeViewer.refresh(parent);
                            }
                        } else {
                            if (node.visible()) {
                                if (event instanceof LabelChangedEvent || event instanceof ImageChangedEvent
                                        || event instanceof DecorationEvent) {
                                    Display.getCurrent().asyncExec(new TreeViewerUpdateJob(treeViewer, node));
                                } else if (event instanceof NodeListEvent) {
                                    treeViewer.refresh(node);
                                }
                            }
                        }
                    }
                }
            }
        };

        private void attach(final List<MasterDetailsContentNodePart> nodes) {
            for (MasterDetailsContentNodePart node : nodes) {
                node.attach(this.listener);
            }
        }

        private void detach(final List<MasterDetailsContentNodePart> nodes) {
            for (MasterDetailsContentNodePart node : nodes) {
                node.detach(this.listener);
                detach(node.nodes());
            }
        }

        public Object[] getElements(final Object inputElement) {
            final MasterDetailsContentNodeList nodes = outline.getRoot().nodes();
            attach(nodes);
            return nodes.visible().toArray();
        }

        public Object[] getChildren(final Object parentElement) {
            final MasterDetailsContentNodeList nodes = ((MasterDetailsContentNodePart) parentElement).nodes();
            attach(nodes);
            return nodes.visible().toArray();
        }

        public Object getParent(final Object element) {
            return ((MasterDetailsContentNodePart) element).getParentNode();
        }

        public boolean hasChildren(final Object parentElement) {
            final MasterDetailsContentNodeList nodes = ((MasterDetailsContentNodePart) parentElement).nodes();
            attach(nodes);
            return !nodes.visible().isEmpty();
        }

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

        public void dispose() {
            detach(outline.getRoot().nodes());
        }
    };

    final StyledCellLabelProvider labelProvider = new StyledCellLabelProvider() {
        private final Map<ImageDescriptor, Image> images = new HashMap<ImageDescriptor, Image>();
        private final Map<org.eclipse.sapphire.Color, Color> colors = new HashMap<org.eclipse.sapphire.Color, Color>();

        public void update(final ViewerCell cell) {
            final MasterDetailsContentNodePart node = (MasterDetailsContentNodePart) cell.getElement();

            final StyledString styledString = new StyledString(node.getLabel());

            for (final TextDecoration decoration : node.decorations()) {
                String text = decoration.text();

                if (text != null) {
                    text = text.trim();

                    if (text.length() > 0) {
                        final Color color = color(decoration.color());

                        styledString.append(" " + text, new Styler() {
                            @Override
                            public void applyStyles(final TextStyle style) {
                                style.foreground = color;
                            }
                        });
                    }
                }
            }

            cell.setText(styledString.toString());
            cell.setStyleRanges(styledString.getStyleRanges());
            cell.setImage(image(node.getImage()));

            super.update(cell);
        }

        private Color color(final org.eclipse.sapphire.Color c) {
            Color color = this.colors.get(c);

            if (color == null) {
                color = new Color(tree.getDisplay(), c.red(), c.green(), c.blue());
                this.colors.put(c, color);
            }

            return color;
        }

        private Image image(final ImageDescriptor imageDescriptor) {
            Image image = this.images.get(imageDescriptor);

            if (image == null) {
                image = imageDescriptor.createImage();
                this.images.put(imageDescriptor, image);
            }

            return image;
        }

        @Override
        public void dispose() {
            for (final Image image : this.images.values()) {
                image.dispose();
            }
        }
    };

    new SapphireToolTip(tree) {
        protected Object getToolTipArea(final Event event) {
            return treeViewer.getCell(new Point(event.x, event.y));
        }

        protected boolean shouldCreateToolTip(Event event) {
            if (!super.shouldCreateToolTip(event)) {
                return false;
            }

            setShift(new Point(0, 20));
            tree.setToolTipText("");

            boolean res = false;

            final MasterDetailsContentNodePart node = getNode(event);

            if (node != null) {
                res = !node.validation().ok();
            }

            return res;
        }

        private MasterDetailsContentNodePart getNode(final Event event) {
            final TreeItem item = tree.getItem(new Point(event.x, event.y));

            if (item == null) {
                return null;
            } else {
                return (MasterDetailsContentNodePart) item.getData();
            }
        }

        protected void afterHideToolTip(Event event) {
            super.afterHideToolTip(event);
            // Clear the restored value else this could be a source of a leak
            if (event != null && event.widget != treeViewer.getControl()) {
                treeViewer.getControl().setFocus();
            }
        }

        @Override
        protected void createContent(final Event event, final Composite parent) {
            final MasterDetailsContentNodePart node = getNode(event);

            parent.setLayout(glayout(1));

            SapphireFormText text = new SapphireFormText(parent, SWT.NO_FOCUS);
            text.setLayoutData(gdfill());

            final org.eclipse.sapphire.modeling.Status validation = node.validation();
            final List<org.eclipse.sapphire.modeling.Status> items = gather(validation);

            final StringBuffer buffer = new StringBuffer();
            buffer.append("<form>");

            final int count = items.size();
            int i = 0;

            for (org.eclipse.sapphire.modeling.Status item : items) {
                final String imageKey = (item.severity() == org.eclipse.sapphire.modeling.Status.Severity.ERROR
                        ? "error"
                        : "warning");
                buffer.append("<li style=\"image\" value=\"" + imageKey + "\">" + escapeForXml(item.message())
                        + "</li>");

                i++;

                if (count > 10 && i == 9) {
                    break;
                }
            }

            if (count > 10) {
                final String msg = problemsOverflowMessage.format(numberToString(count - 9));
                final String imageKey = (validation
                        .severity() == org.eclipse.sapphire.modeling.Status.Severity.ERROR ? "error"
                                : "warning");
                buffer.append("<br/><li style=\"image\" value=\"" + imageKey + "\">" + msg + "</li>");
            }

            buffer.append("</form>");

            text.setText(buffer.toString(), true, false);
            text.setImage("error",
                    ImageData.readFromClassLoader(SwtResourceCache.class, "Error.png").required());
            text.setImage("warning",
                    ImageData.readFromClassLoader(SwtResourceCache.class, "Warning.png").required());
        }

        private String numberToString(final int number) {
            switch (number) {
            case 2:
                return two.text();
            case 3:
                return three.text();
            case 4:
                return four.text();
            case 5:
                return five.text();
            case 6:
                return six.text();
            case 7:
                return seven.text();
            case 8:
                return eight.text();
            case 9:
                return nine.text();
            default:
                return String.valueOf(number);
            }
        }

        private List<org.eclipse.sapphire.modeling.Status> gather(
                final org.eclipse.sapphire.modeling.Status status) {
            final List<org.eclipse.sapphire.modeling.Status> items = new ArrayList<org.eclipse.sapphire.modeling.Status>();
            gather(status, items);
            return items;
        }

        private void gather(final org.eclipse.sapphire.modeling.Status status,
                final List<org.eclipse.sapphire.modeling.Status> items) {
            if (status.children().isEmpty()) {
                items.add(status);
            } else {
                for (org.eclipse.sapphire.modeling.Status child : status.children()) {
                    gather(child, items);
                }
            }
        }
    };

    treeViewer.setContentProvider(contentProvider);
    treeViewer.setLabelProvider(labelProvider);
    treeViewer.setInput(new Object());

    final MutableReference<Boolean> ignoreSelectionChange = new MutableReference<Boolean>(false);
    final MutableReference<Boolean> ignoreExpandedStateChange = new MutableReference<Boolean>(false);

    final Listener contentTreeListener = new Listener() {
        @Override
        public void handle(final org.eclipse.sapphire.Event event) {
            if (event instanceof MasterDetailsContentOutline.SelectionChangedEvent) {
                if (ignoreSelectionChange.get() == true) {
                    return;
                }

                final MasterDetailsContentOutline.SelectionChangedEvent evt = (MasterDetailsContentOutline.SelectionChangedEvent) event;
                final List<MasterDetailsContentNodePart> selection = evt.selection();

                final IStructuredSelection sel;

                if (selection.isEmpty()) {
                    sel = StructuredSelection.EMPTY;
                } else {
                    sel = new StructuredSelection(selection);
                }

                if (!treeViewer.getSelection().equals(sel)) {
                    for (MasterDetailsContentNodePart node : selection) {
                        treeViewer.reveal(node);
                    }

                    treeViewer.setSelection(sel);
                }
            } else if (event instanceof MasterDetailsContentOutline.NodeExpandedStateChangedEvent) {
                if (ignoreExpandedStateChange.get() == true) {
                    return;
                }

                final MasterDetailsContentOutline.NodeExpandedStateChangedEvent evt = (MasterDetailsContentOutline.NodeExpandedStateChangedEvent) event;
                final MasterDetailsContentNodePart node = evt.node();

                final boolean expandedState = node.isExpanded();

                if (treeViewer.getExpandedState(node) != expandedState) {
                    treeViewer.setExpandedState(node, expandedState);
                }
            } else if (event instanceof MasterDetailsContentOutline.FilterChangedEvent) {
                final MasterDetailsContentOutline.FilterChangedEvent evt = (MasterDetailsContentOutline.FilterChangedEvent) event;
                filteredTree.changeFilterText(evt.filter());
            }
        }
    };

    outline.attach(contentTreeListener);

    treeViewer.addSelectionChangedListener(new ISelectionChangedListener() {
        public void selectionChanged(final SelectionChangedEvent event) {
            ignoreSelectionChange.set(true);

            try {
                final IStructuredSelection selection = (IStructuredSelection) event.getSelection();
                final List<MasterDetailsContentNodePart> nodes = new ArrayList<MasterDetailsContentNodePart>();

                for (Iterator<?> itr = selection.iterator(); itr.hasNext();) {
                    nodes.add((MasterDetailsContentNodePart) itr.next());
                }

                outline.setSelectedNodes(nodes);
            } finally {
                ignoreSelectionChange.set(false);
            }
        }
    });

    treeViewer.addDoubleClickListener(new IDoubleClickListener() {
        public void doubleClick(DoubleClickEvent event) {
            IStructuredSelection thisSelection = (IStructuredSelection) event.getSelection();
            if (thisSelection.size() == 1) {
                MasterDetailsContentNodePart selectedNode = (MasterDetailsContentNodePart) thisSelection
                        .getFirstElement();
                selectedNode.setExpanded(!selectedNode.isExpanded());
            }
        }
    });

    treeViewer.addTreeListener(new ITreeViewerListener() {
        public void treeExpanded(final TreeExpansionEvent event) {
            ignoreExpandedStateChange.set(true);

            try {
                final MasterDetailsContentNodePart node = (MasterDetailsContentNodePart) event.getElement();
                node.setExpanded(true);
            } finally {
                ignoreExpandedStateChange.set(false);
            }
        }

        public void treeCollapsed(final TreeExpansionEvent event) {
            ignoreExpandedStateChange.set(true);

            try {
                final MasterDetailsContentNodePart node = (MasterDetailsContentNodePart) event.getElement();
                node.setExpanded(false);
            } finally {
                ignoreExpandedStateChange.set(false);
            }
        }
    });

    final ContentOutlineActionSupport actionSupport = new ContentOutlineActionSupport(outline, tree);

    treeViewer.setExpandedElements(outline.getExpandedNodes().toArray());
    contentTreeListener
            .handle(new MasterDetailsContentOutline.SelectionChangedEvent(outline.getSelectedNodes()));

    filteredTree.changeFilterText(outline.getFilterText());

    final ElementsTransfer transfer = new ElementsTransfer(
            getModelElement().type().getModelElementClass().getClassLoader());
    final Transfer[] transfers = new Transfer[] { transfer };

    final DragSource dragSource = new DragSource(tree, DND.DROP_COPY | DND.DROP_MOVE);
    dragSource.setTransfer(transfers);

    final List<Element> dragElements = new ArrayList<Element>();

    dragSource.addDragListener(new DragSourceListener() {
        public void dragStart(final DragSourceEvent event) {
            final TreeItem[] selection = tree.getSelection();
            final String filter = outline().getFilterText();

            if ((filter == null || filter.length() == 0) && draggable(selection)) {
                event.doit = true;

                for (TreeItem item : selection) {
                    final MasterDetailsContentNodePart node = (MasterDetailsContentNodePart) item.getData();
                    dragElements.add(node.getModelElement());
                }
            } else {
                event.doit = false;
            }
        }

        protected boolean draggable(final TreeItem[] selection) {
            if (selection.length > 0) {
                for (TreeItem item : selection) {
                    final MasterDetailsContentNodePart node = (MasterDetailsContentNodePart) item.getData();

                    if (!draggable(node)) {
                        return false;
                    }
                }

                return true;
            }

            return false;
        }

        protected boolean draggable(final MasterDetailsContentNodePart node) {
            final Element element = node.getModelElement();

            if (element.parent() instanceof ElementList && node.controls(element)) {
                return true;
            }

            return false;
        }

        public void dragSetData(final DragSourceEvent event) {
            event.data = dragElements;
        }

        public void dragFinished(final DragSourceEvent event) {
            if (event.detail == DND.DROP_MOVE) {
                // When drop target is the same editor as drag source, the drop handler takes care of removing
                // elements from their original location. The following block of code accounts for the case when 
                // dropping into another editor.

                boolean droppedIntoAnotherEditor = false;

                for (Element dragElement : dragElements) {
                    if (!dragElement.disposed()) {
                        droppedIntoAnotherEditor = true;
                        break;
                    }
                }

                if (droppedIntoAnotherEditor) {
                    final TreeItem[] selection = tree.getSelection();
                    final List<MasterDetailsContentNodePart> dragNodes = new ArrayList<MasterDetailsContentNodePart>();

                    for (TreeItem item : selection) {
                        dragNodes.add((MasterDetailsContentNodePart) item.getData());
                    }

                    final MasterDetailsContentNodePart parentNode = dragNodes.get(0).getParentNode();

                    MasterDetailsContentNodePart selectionPostDelete = findSelectionPostDelete(
                            parentNode.nodes().visible(), dragNodes);

                    if (selectionPostDelete == null) {
                        selectionPostDelete = parentNode;
                    }

                    final Disposable suspension = outline.listeners().queue()
                            .suspend(SelectionChangedEventFilter.INSTANCE);

                    try {
                        for (Element dragElement : dragElements) {
                            final ElementList<?> dragElementContainer = (ElementList<?>) dragElement.parent();
                            dragElementContainer.remove(dragElement);
                        }
                    } catch (Exception e) {
                        // Log this exception unless the cause is EditFailedException. These exception
                        // are the result of the user declining a particular action that is necessary
                        // before the edit can happen (such as making a file writable).

                        final EditFailedException editFailedException = EditFailedException.findAsCause(e);

                        if (editFailedException == null) {
                            Sapphire.service(LoggingService.class).log(e);
                        }
                    } finally {
                        suspension.dispose();
                        outline.listeners().queue().process();
                    }

                    parentNode.getContentTree().setSelectedNode(selectionPostDelete);
                }
            }

            dragElements.clear();
        }
    });

    final DropTarget target = new DropTarget(tree, DND.DROP_COPY | DND.DROP_MOVE);
    target.setTransfer(transfers);

    target.addDropListener(new DropTargetAdapter() {
        public void dragOver(final DropTargetEvent event) {
            if (event.item != null) {
                final TreeItem dragOverItem = (TreeItem) event.item;
                final MasterDetailsContentNodePart dragOverNode = (MasterDetailsContentNodePart) dragOverItem
                        .getData();
                final MasterDetailsContentNodePart parentNode = dragOverNode.getParentNode();
                final List<MasterDetailsContentNodePart> siblingNodes = parentNode.nodes().visible();

                final Point pt = dragOverItem.getDisplay().map(null, tree, event.x, event.y);
                final Rectangle bounds = dragOverItem.getBounds();

                boolean dragOverNodeAcceptedDrop = false;

                if (pt.y > bounds.y + bounds.height / 3
                        && pt.y < bounds.y + bounds.height - bounds.height / 3) {
                    for (final PropertyDef dragOverTargetChildProperty : dragOverNode
                            .getChildNodeFactoryProperties()) {
                        if (dragOverTargetChildProperty instanceof ListProperty
                                && !dragOverTargetChildProperty.isReadOnly()) {
                            dragOverNodeAcceptedDrop = true;
                            event.feedback = DND.FEEDBACK_SELECT;

                            break;
                        }
                    }
                }

                if (!dragOverNodeAcceptedDrop) {
                    MasterDetailsContentNodePart precedingNode = null;
                    MasterDetailsContentNodePart trailingNode = null;

                    if (pt.y < bounds.y + bounds.height / 2) {
                        precedingNode = findPrecedingItem(siblingNodes, dragOverNode);
                        trailingNode = dragOverNode;

                        event.feedback = DND.FEEDBACK_INSERT_BEFORE;
                    } else {
                        precedingNode = dragOverNode;
                        trailingNode = findTrailingItem(siblingNodes, dragOverNode);

                        event.feedback = DND.FEEDBACK_INSERT_AFTER;
                    }

                    boolean ok = false;

                    if (precedingNode != null) {
                        final Element precedingElement = precedingNode.getModelElement();

                        if (precedingElement.parent() instanceof ElementList
                                && precedingNode.controls(precedingElement)) {
                            ok = true;
                        }
                    }

                    if (!ok && trailingNode != null) {
                        final Element trailingElement = trailingNode.getModelElement();

                        if (trailingElement.parent() instanceof ElementList
                                && trailingNode.controls(trailingElement)) {
                            ok = true;
                        }
                    }

                    if (!ok) {
                        event.feedback = DND.FEEDBACK_NONE;
                    }
                }
            }

            event.feedback |= DND.FEEDBACK_SCROLL;
        }

        @SuppressWarnings("unchecked")

        public void drop(final DropTargetEvent event) {
            if (event.data == null || event.item == null) {
                event.detail = DND.DROP_NONE;
                return;
            }

            // Determine where something was dropped.

            final List<ElementData> droppedElements = (List<ElementData>) event.data;
            final TreeItem dropTargetItem = (TreeItem) event.item;
            final MasterDetailsContentNodePart dropTargetNode = (MasterDetailsContentNodePart) dropTargetItem
                    .getData();
            final MasterDetailsContentNodePart parentNode = dropTargetNode.getParentNode();
            final List<MasterDetailsContentNodePart> siblingNodes = parentNode.nodes().visible();

            final Point pt = tree.getDisplay().map(null, tree, event.x, event.y);
            final Rectangle bounds = dropTargetItem.getBounds();

            MasterDetailsContentNodePart precedingNode = null;
            MasterDetailsContentNodePart trailingNode = null;

            boolean dropTargetNodeAcceptedDrop = false;

            if (pt.y > bounds.y + bounds.height / 3 && pt.y < bounds.y + bounds.height - bounds.height / 3) {
                for (final PropertyDef dropTargetChildProperty : dropTargetNode
                        .getChildNodeFactoryProperties()) {
                    if (dropTargetChildProperty instanceof ListProperty
                            && !dropTargetChildProperty.isReadOnly()) {
                        dropTargetNodeAcceptedDrop = true;
                        break;
                    }
                }
            }

            if (!dropTargetNodeAcceptedDrop) {
                if (pt.y < bounds.y + bounds.height / 2) {
                    precedingNode = findPrecedingItem(siblingNodes, dropTargetNode);
                    trailingNode = dropTargetNode;
                } else {
                    precedingNode = dropTargetNode;
                    trailingNode = findTrailingItem(siblingNodes, dropTargetNode);
                }
            }

            // Determine whether the drop was valid from model standpoint and figure out
            // where in the model the dropped elements are to be inserted.

            ElementList<?> list = null;
            int position = -1;

            if (precedingNode != null) {
                final Element precedingElement = precedingNode.getModelElement();

                if (precedingElement.parent() instanceof ElementList
                        && !precedingElement.parent().definition().isReadOnly()
                        && precedingNode.controls(precedingElement)) {
                    list = (ElementList<?>) precedingElement.parent();

                    final Set<ElementType> possibleListElementTypes = list.definition()
                            .service(PossibleTypesService.class).types();

                    for (final ElementData droppedElement : droppedElements) {
                        if (!possibleListElementTypes.contains(droppedElement.type())) {
                            list = null;
                            break;
                        }
                    }

                    if (list != null) {
                        position = list.indexOf(precedingElement) + 1;
                    }
                }
            }

            if (list == null && trailingNode != null) {
                final Element trailingElement = trailingNode.getModelElement();

                if (trailingElement.parent() instanceof ElementList
                        && !trailingElement.parent().definition().isReadOnly()
                        && trailingNode.controls(trailingElement)) {
                    list = (ElementList<?>) trailingElement.parent();

                    final Set<ElementType> possibleListElementTypes = list.definition()
                            .service(PossibleTypesService.class).types();

                    for (final ElementData droppedElement : droppedElements) {
                        if (!possibleListElementTypes.contains(droppedElement.type())) {
                            list = null;
                            break;
                        }
                    }

                    if (list != null) {
                        position = list.indexOf(trailingElement);
                    }
                }
            }

            if (list == null) {
                for (PropertyDef dropTargetChildProperty : dropTargetNode.getChildNodeFactoryProperties()) {
                    if (dropTargetChildProperty instanceof ListProperty
                            && !dropTargetChildProperty.isReadOnly()) {
                        final ListProperty dropTargetChildListProperty = (ListProperty) dropTargetChildProperty;

                        boolean compatible = true;

                        final Set<ElementType> possibleListElementTypes = dropTargetChildListProperty
                                .service(PossibleTypesService.class).types();

                        for (final ElementData droppedElement : droppedElements) {
                            if (!possibleListElementTypes.contains(droppedElement.type())) {
                                compatible = false;
                                break;
                            }
                        }

                        if (compatible) {
                            list = dropTargetNode.getLocalModelElement().property(dropTargetChildListProperty);
                            position = list.size();
                        }
                    }
                }
            }

            if (list == null) {
                event.detail = DND.DROP_NONE;
                return;
            }

            // Prevent a drop within a drag element.

            for (Property p = list; p != null; p = p.element().parent()) {
                for (final Element dragElement : dragElements) {
                    if (p.element() == dragElement) {
                        event.detail = DND.DROP_NONE;
                        return;
                    }
                }
            }

            // Perform the removal and insertion into the new location.

            final Disposable suspension = outline.listeners().queue()
                    .suspend(SelectionChangedEventFilter.INSTANCE);

            try {
                if (event.detail == DND.DROP_MOVE) {
                    for (Element dragElement : dragElements) {
                        final ElementList<?> dragElementContainer = (ElementList<?>) dragElement.parent();

                        if (dragElementContainer == list
                                && dragElementContainer.indexOf(dragElement) < position) {
                            position--;
                        }

                        dragElementContainer.remove(dragElement);
                    }
                }

                final List<MasterDetailsContentNodePart> newSelection = new ArrayList<MasterDetailsContentNodePart>();

                for (final ElementData droppedElement : droppedElements) {
                    final Element insertedElement = list.insert(droppedElement.type(), position);
                    insertedElement.copy(droppedElement);

                    newSelection.add(parentNode.findNode(insertedElement));

                    position++;
                }

                parentNode.getContentTree().setSelectedNodes(newSelection);
            } catch (Exception e) {
                // Log this exception unless the cause is EditFailedException. These exception
                // are the result of the user declining a particular action that is necessary
                // before the edit can happen (such as making a file writable).

                final EditFailedException editFailedException = EditFailedException.findAsCause(e);

                if (editFailedException == null) {
                    Sapphire.service(LoggingService.class).log(e);
                }

                event.detail = DND.DROP_NONE;
            } finally {
                suspension.dispose();
                outline.listeners().queue().process();
            }
        }
    });

    tree.addDisposeListener(new DisposeListener() {
        public void widgetDisposed(final DisposeEvent event) {
            outline.detach(contentTreeListener);
            actionSupport.dispose();
        }
    });

    return filteredTree;
}

From source file:org.eclipse.sapphire.ui.renderers.swt.EclipseWorkspacePathPropertyEditorRenderer.java

License:Open Source License

@Override
protected void createContents(final Composite parent) {
    final PropertyEditorPart part = getPart();
    final Value<?> value = (Value<?>) part.property();

    final Text textField = (Text) super.createContents(parent, true);

    final Composite drillDownParent = createMainComposite(parent, new CreateMainCompositeDelegate(part) {
        @Override/* w  w w. ja va2s  .c  o  m*/
        public boolean getShowLabel() {
            return false;
        }
    });

    drillDownParent.setLayout(glayout(1, 9, 0, 0, 0));

    final DrillDownComposite drillDown = new DrillDownComposite(drillDownParent, SWT.BORDER);
    drillDown.setLayoutData(gdfill());

    final TreeViewer treeViewer = new TreeViewer(drillDown, SWT.NONE);
    final Tree tree = treeViewer.getTree();
    drillDown.setChildTree(treeViewer);

    treeViewer.setContentProvider(new WorkbenchContentProvider());
    treeViewer.setLabelProvider(WorkbenchLabelProvider.getDecoratingWorkbenchLabelProvider());
    treeViewer.setSorter(new ViewerSorter());

    final ValidFileSystemResourceType validFileSystemResourceTypeAnnotation = value.definition()
            .getAnnotation(ValidFileSystemResourceType.class);

    if (validFileSystemResourceTypeAnnotation != null) {
        if (validFileSystemResourceTypeAnnotation.value() == FileSystemResourceType.FOLDER) {
            treeViewer.addFilter(new ContainersOnlyViewerFilter());
        }

        final FileExtensionsService fileExtensionsService = value.service(FileExtensionsService.class);

        if (fileExtensionsService != null) {
            final ExtensionBasedViewerFilter filter = new ExtensionBasedViewerFilter(
                    fileExtensionsService.extensions());

            treeViewer.addFilter(filter);

            final Listener listener = new Listener() {
                @Override
                public void handle(final Event event) {
                    filter.change(fileExtensionsService.extensions());
                    treeViewer.refresh();
                }
            };

            fileExtensionsService.attach(listener);

            tree.addDisposeListener(new DisposeListener() {
                public void widgetDisposed(final DisposeEvent event) {
                    fileExtensionsService.detach(listener);
                }
            });
        }
    }

    treeViewer.addDoubleClickListener(new IDoubleClickListener() {
        public void doubleClick(final DoubleClickEvent event) {
            final IStructuredSelection selection = (IStructuredSelection) event.getSelection();

            if (selection != null) {
                final Object item = selection.getFirstElement();

                if (treeViewer.getExpandedState(item)) {
                    treeViewer.collapseToLevel(item, 1);
                } else {
                    treeViewer.expandToLevel(item, 1);
                }
            }
        }
    });

    treeViewer.setInput(ResourcesPlugin.getWorkspace());

    this.decorator.addEditorControl(drillDown);
    this.decorator.addEditorControl(tree);

    final String val = value.text();

    if (val != null) {
        final IWorkspaceRoot root = ResourcesPlugin.getWorkspace().getRoot();

        IPath path = new Path(val);
        IResource resource = root.findMember(val);

        while (resource == null) {
            path = path.removeLastSegments(1);
            resource = root.findMember(path);
        }

        if (resource instanceof IFile
                && validFileSystemResourceTypeAnnotation.value() == FileSystemResourceType.FOLDER) {
            resource = resource.getParent();
        }

        treeViewer.setSelection(new StructuredSelection(resource));
    }

    treeViewer.addSelectionChangedListener(new ISelectionChangedListener() {
        public void selectionChanged(final SelectionChangedEvent event) {
            final IStructuredSelection selection = (IStructuredSelection) event.getSelection();
            String path = MiscUtil.EMPTY_STRING;

            if (selection != null && !selection.isEmpty()) {
                final IResource resource = (IResource) selection.getFirstElement();
                path = resource.getFullPath().toPortableString();

                if (path.startsWith("/") && path.length() > 1) {
                    path = path.substring(1);
                }
            }

            textField.setText(path);
        }
    });

    textField.setData(DATA_BINDING, this.binding);

    addControl(tree);
}