Java 类org.eclipse.gef.ui.palette.PaletteViewer 实例源码

@Override
protected PaletteViewerProvider createPaletteViewerProvider() {
    final ELTGraphicalEditor editor = this;
    return new PaletteViewerProvider(getEditDomain()) {

        @Override
        protected void configurePaletteViewer(final PaletteViewer viewer) {
            super.configurePaletteViewer(viewer);

            paletteEditPartFactory = new CustomPaletteEditPartFactory(palatteTextColor,viewer.getControl().getBackground());
            viewer.setEditPartFactory(paletteEditPartFactory);


            // create a drag source listener for this palette viewer
            // together with an appropriate transfer drop target listener,
            // this will enable
            // model element creation by dragging a
            // CombinatedTemplateCreationEntries
            // from the palette into the editor
            // @see ShapesEditor#createTransferDropTargetListener()

            viewer.addDragSourceListener(new TemplateTransferDragSourceListener(viewer));
            PaletteContainerListener paletteContainerListener = new PaletteContainerListener(viewer, getGraphicalViewer());
            viewer.getControl().addMouseListener(paletteContainerListener);
            viewer.getControl().addMouseTrackListener(paletteContainerListener);
            viewer.getControl().addMouseMoveListener(paletteContainerListener);
            setDefaultToolUndoRedoStatus();
        }

        @Override
        public PaletteViewer createPaletteViewer(Composite parent) {
            CustomPaletteViewer pViewer = new CustomPaletteViewer();
            CustomFigureCanvas figureCanvas=new CustomFigureCanvas(parent,pViewer.getLightweightSys(),pViewer, getPalettesRoot(),editor);
            pViewer.setFigureCanvas(figureCanvas);
            configurePaletteViewer(pViewer);
            hookPaletteViewer(pViewer);
            return pViewer;
        }
    };
}

protected PaletteViewerProvider createPaletteViewerProvider() {
    PaletteViewerProvider paletteViewerProvider = new PaletteViewerProvider(getEditDomain()) {
        public PaletteViewer createPaletteViewer(Composite parent) {
            PaletteViewer paletteViewer = super.createPaletteViewer(parent);
            paletteViewer.getPaletteViewerPreferences().setUseLargeIcons(PaletteViewerPreferences.LAYOUT_LIST, !PALETTE_USE_ICON16);
            return paletteViewer;
        }

        protected void configurePaletteViewer(PaletteViewer viewer) {
            super.configurePaletteViewer(viewer);
            viewer.addDragSourceListener(new TemplateTransferDragSourceListener(viewer));
        }
    };
    return paletteViewerProvider;
}

protected PaletteViewerProvider createPaletteViewerProvider() {
    return new PaletteViewerProvider(getEditDomain()) {
        protected void configurePaletteViewer(PaletteViewer viewer) {
            super.configurePaletteViewer(viewer);
            viewer.addDragSourceListener(new TemplateTransferDragSourceListener(
                    viewer));
        }

    };
}

@Override
public PaletteViewer createPaletteViewer(Composite parent) {
  PaletteTreeViewer pViewer = new PaletteTreeViewer();
  pViewer.createTreeControl(parent);
  configurePaletteViewer(pViewer);
  hookPaletteViewer(pViewer);
  return pViewer;
}

private void handlePaletteToolChanged() {
    PaletteViewer paletteViewer = getPaletteViewer();
    if (paletteViewer != null) {
        ToolEntry entry = paletteViewer.getActiveTool();
        if (entry != null)
            setActiveTool(entry.createTool());
        else
            setActiveTool(getDefaultTool());
    }
}

/**
 * Loads the default Tool. If a palette has been provided and that palette
 * has a default, then that tool is loaded. If not, the EditDomain's default
 * tool is loaded. By default, this is the
 * {@link org.eclipse.gef.tools.SelectionTool}.
 */
public void loadDefaultTool() {
    setActiveTool(null);
    PaletteViewer paletteViewer = getPaletteViewer();
    if (paletteRoot != null && paletteViewer != null) {
        if (paletteRoot.getDefaultEntry() != null) {
            paletteViewer.setActiveTool(paletteRoot.getDefaultEntry());
            return;
        } else
            paletteViewer.setActiveTool(null);
    }
    setActiveTool(getDefaultTool());
}

/**
 * Sets the <code>PaletteViewer</code> for this EditDomain
 * 
 * @param palette
 *            the PaletteViewer
 */
public void setPaletteViewer(PaletteViewer palette) {
    if (palette == paletteViewer)
        return;
    if (paletteViewer != null)
        paletteViewer.removePaletteListener(paletteListener);
    paletteViewer = palette;
    if (paletteViewer != null) {
        palette.addPaletteListener(paletteListener);
        if (paletteRoot != null) {
            paletteViewer.setPaletteRoot(paletteRoot);
            loadDefaultTool();
        }
    }
}

/**
 * Creates the palette on the given composite.
 * 
 * @param parent
 *            the composite
 */
protected void createPaletteViewer(Composite parent) {
    PaletteViewer viewer = new PaletteViewer();
    setPaletteViewer(viewer);
    viewer.createControl(parent);
    configurePaletteViewer();
    hookPaletteViewer();
    initializePaletteViewer();
}

public void activeToolChanged(PaletteViewer palette, ToolEntry tool) {
    if (getStack().getChildren().contains(tool)) {
        if (!arrowFigure.getModel().isSelected())
            arrowFigure.getModel().setSelected(true);
        if (!getStack().getActiveEntry().equals(tool))
            getStack().setActiveEntry(tool);
    } else
        arrowFigure.getModel().setSelected(false);
}

public void activeToolChanged(PaletteViewer palette, ToolEntry tool) {
    if (!getStackFigure().isPinnedOpen()
            && getStack().getChildren().contains(tool)) {
        if (!getStack().getActiveEntry().equals(tool)) {
            getStack().setActiveEntry(tool);
        }
    }
    if (!getStackFigure().isPinnedOpen()) {
        getStackFigure().setExpanded(false);
    }
}

/**
 * @see org.eclipse.gef.editparts.AbstractGraphicalEditPart#registerVisuals()
 */
@SuppressWarnings("unchecked")
protected void registerVisuals() {
    super.registerVisuals();
    controller = new PaletteAnimator(
            ((PaletteViewer) getViewer()).getPaletteViewerPreferences());
    getViewer().getEditPartRegistry().put(PaletteAnimator.class, controller);
    ToolbarLayout layout = new PaletteToolbarLayout();
    getFigure().setLayoutManager(layout);
    getFigure().addLayoutListener(controller);
}

private Tool findThePaletteTool(final EditPartViewer theEditPartViewer, final String toolPath) {
    final EditDomain theDomain = theEditPartViewer.getEditDomain();
    final PaletteViewer thePaletteViewer = theDomain.getPaletteViewer();
    final ToolEntry toolEntry = findByLabel(thePaletteViewer.getPaletteRoot(), toolPath);
    thePaletteViewer.setActiveTool(toolEntry);

    final Tool theTool = toolEntry.createTool();
    theTool.setViewer(theEditPartViewer);
    theTool.setEditDomain(theDomain);

    return theTool;
}

/**
 * Creates a PaletteViewer on the given Composite
 * 
 * @param parent
 *            the control for the PaletteViewer
 * @return the newly created PaletteViewer
 */
public PaletteViewer createPaletteViewer(Composite parent) {
  PaletteViewer pViewer = new PaletteViewer();
  pViewer.enableVerticalScrollbar(true);
  pViewer.createControl(parent);
  configurePaletteViewer(pViewer);
  hookPaletteViewer(pViewer);
  return pViewer;
}

public static Tool findThePaletteTool(final EditPart theEditPart, final String toolPath) {
    final EditPartViewer theEditPartViewer = theEditPart.getViewer();
    final PaletteViewer thePaletteViewer = theEditPartViewer.getEditDomain().getPaletteViewer();
    final ToolEntry toolEntry = findByLabel(thePaletteViewer.getPaletteRoot(), toolPath);
    thePaletteViewer.setActiveTool(toolEntry);

    final Tool theTool = toolEntry.createTool();
    theTool.setViewer(theEditPartViewer);
    theTool.setEditDomain(theEditPartViewer.getEditDomain());

    return theTool;
}

public static void selectTool(IWorkbenchPart part, String tool) {
    if (part instanceof UCMNavMultiPageEditor) {
        UCMNavMultiPageEditor nav = (UCMNavMultiPageEditor) part;

        if (nav.getCurrentPage() != null) {
            PaletteViewer viewer = nav.getCurrentPage().getEditDomain().getPaletteViewer();
            if (viewer != null) {
                PaletteRoot root = viewer.getPaletteRoot();
                if (root != null && root instanceof UcmPaletteRoot) {
                    viewer.setActiveTool(((UcmPaletteRoot) root).getAssociatedTool(tool));
                }
            }
        }
    }
}

public void configurePaletteViewer(PaletteViewer viewer) {
    super.configurePaletteViewer(viewer);
    // create a drag source listener for this palette viewer
    // together with an appropriate transfer drop target listener, this will enable
    // model element creation by dragging a CombinatedTemplateCreationEntries
    // from the palette into the editor
    // @see ShapesEditor#createTransferDropTargetListener()
    list = new UrnDragSourceListener(viewer);
    viewer.addDragSourceListener(list);
}

protected PaletteViewerProvider createPaletteViewerProvider() {
    return new PaletteViewerProvider(getEditDomain()) {
        protected void configurePaletteViewer(PaletteViewer viewer) {
            super.configurePaletteViewer(viewer);
            // create a drag source listener for this palette viewer
            // together with an appropriate transfer drop target listener,
            // this will enable
            // model element creation by dragging a
            // CombinatedTemplateCreationEntries
            // from the palette into the editor
            // @see ShapesEditor#createTransferDropTargetListener()
            viewer.addDragSourceListener(new TemplateTransferDragSourceListener(viewer));
        }
    };
}

protected PaletteViewerProvider createPaletteViewerProvider() {
    return new PaletteViewerProvider(getEditDomain()) {
        protected void configurePaletteViewer(PaletteViewer viewer) {
            super.configurePaletteViewer(viewer);
            // create a drag source listener for this palette viewer
            // together with an appropriate transfer drop target listener,
            // this will enable
            // model element creation by dragging a
            // CombinatedTemplateCreationEntries
            // from the palette into the editor
            // @see ShapesEditor#createTransferDropTargetListener()
            viewer.addDragSourceListener(new TemplateTransferDragSourceListener(viewer));
        }
    };
}

@Override
protected void configurePaletteViewer(PaletteViewer viewer) {
  super.configurePaletteViewer(viewer);
  viewer.getKeyHandler().setParent(getPaletteKeyHandler());
  viewer.addDragSourceListener(new TemplateTransferDragSourceListener(viewer));
}

public void activeToolChanged(PaletteViewer viewer, ToolEntry tool) {
    handlePaletteToolChanged();
}

/**
 * @return the PaletteViewer created and displayed by this page
 */
public PaletteViewer getPaletteViewer() {
    return viewer;
}

private PaletteViewer getPaletteViewer() {
    return (PaletteViewer) getCurrentViewer();
}

/**
 * @return the PaletteViewer created and displayed by this page
 */
public PaletteViewer getPaletteViewer() {
    return viewer;
}

/**
 * @return the PaletteViewer created and displayed by this page
 */
public PaletteViewer getPaletteViewer( )
{
    return viewer;
}

/**
     * create controls and apply configurations.
     */
    public void createPartControl(Composite parent) {
        viewer = new PaletteViewer();
        viewer.createControl(parent);

        PaletteRoot root = new PaletteRoot();

        String[] category = getCategories();
        for(int i=0;i<category.length;i++){
            PaletteDrawer group = new PaletteDrawer(category[i]);
            IPaletteItem[] items = getPaletteItems(category[i]);
            for(int j=0;j<items.length;j++){
                HTMLPaletteEntry entry = new HTMLPaletteEntry(items[j].getLabel(),null,items[j].getImageDescriptor());
                tools.put(entry,items[j]);
                group.add(entry);
            }
            root.add(group);
        }

        viewer.setPaletteRoot(root);

        viewer.getControl().addMouseListener(new MouseAdapter(){
            @Override
            public void mouseDoubleClick(MouseEvent e) {

//              IWorkbenchPage page = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage(); 
//              IEditorPart editorPart = page.getActiveEditor();
//              if(editorPart!=null){
//                  editorPart.setFocus();
//              }
                if (e.button == 1) {
                    EditPart part = PaletteView.this.viewer.findObjectAt(new Point(e.x, e.y));
                    IPaletteItem item = null;
                    if (part != null) {
                        if (part.getModel() instanceof HTMLPaletteEntry)
                            item = tools.get(part.getModel());
                    }
                    if (item != null)
                        insert(item);
                }

            }
        });

    }

public void unconfigurePaletteViewer(PaletteViewer viewer) {
    viewer.removeDragSourceListener((TransferDragSourceListener) list);
    list = null;
}

/**
 * Creates a new SetActivePaletteToolAction with the given entry to set, as
 * well as a label, icon, and isChecked to be used in a menu.
 * 
 * @param viewer
 *            the PaletteViewer
 * @param label
 *            the label to show in the menu for this entry.
 * @param icon
 *            the icon to show in the menu for this entry.
 * @param isChecked
 *            whether or not this is the current active entry.
 * @param entry
 *            the entry to set if this action is invoked.
 */
public SetActivePaletteToolAction(PaletteViewer viewer, String label,
        ImageDescriptor icon, boolean isChecked, ToolEntry entry) {
    super(label, icon);
    this.viewer = viewer;
    this.entry = entry;
    setChecked(isChecked);
}

/**
 * Instantiates a new palette container listener.
 * 
 * @param viewer
 *            the viewer
 * @param graphicalViewer
 *            the graphical viewer
 */
public PaletteContainerListener(PaletteViewer viewer, GraphicalViewer graphicalViewer) {
    this.graphicalViewer = graphicalViewer;
    this.viewer = viewer;
}

/**
 * A new tool was activated in the palette.
 * 
 * @param palette
 *            the source of the change
 * @param tool
 *            the new tool that was activated
 */
void activeToolChanged(PaletteViewer palette, ToolEntry tool);

/**
 * Returns the palette viewer currently associated with this domain.
 * 
 * @since 1.0
 * @return The current palette viewer
 */
public PaletteViewer getPaletteViewer() {
    return paletteViewer;
}

/**
 * Get the palette viewer for this palette edit part.
 * 
 * @return the palette viewer.
 */
protected PaletteViewer getPaletteViewer() {
    return (PaletteViewer) getViewer();
}

/**
 * Get the palette viewer preferences for this palette edit part.
 * 
 * @return the palette viewer preferences.
 */
protected PaletteViewerPreferences getPreferenceSource() {
    return ((PaletteViewer) getViewer()).getPaletteViewerPreferences();
}

/**
 * Constructs a key handler for the specified palette viewer.
 * 
 * @param viewer
 *            the palette viewer
 */
public PaletteViewerKeyHandler(PaletteViewer viewer) {
    super(viewer);
}

/**
 * Returns the PaletteViewer.
 * 
 * @return the palette viewer
 */
protected PaletteViewer getPaletteViewer() {
    return paletteViewer;
}

/**
 * Sets the palette viewer
 * 
 * @param paletteViewer
 *            the palette viewer
 */
protected void setPaletteViewer(PaletteViewer paletteViewer) {
    this.paletteViewer = paletteViewer;
}