Java 类org.eclipse.gef.palette.PaletteRoot 实例源码

@Override
protected PaletteRoot getPaletteRoot() {
    PaletteRoot root = new PaletteRoot();
    PaletteDrawer manipGroup = new PaletteDrawer("Definitions");
    manipGroup.add(new CreationToolEntry("Add Module Type", "Add Module Type", new ModuleTypeCreationFactory(), null, null));
    manipGroup.add(new CreationToolEntry("Add Module Implementation", "Add Module Implementation", new ModuleImplementationCreationFactory(), null, null));
    manipGroup.add(new CreationToolEntry("Add Module Instance", "Add Module Instance", new ModuleInstanceCreationFactory(), null, null));
    manipGroup.add(new CreationToolEntry("Add Module Instance Property", "Add Module Instance Property", new ModuleInstancePropertyCreationFactory(), null, null));
    manipGroup.add(new CreationToolEntry("Add Module Operation", "Add Module Operation", new ModuleOperationCreationFactory(), null, null));
    manipGroup.add(new CreationToolEntry("Add Module Operation Parameter", "Add Module Operation Parameter", new ModuleOperationParameterCreationFactory(), null, null));
    manipGroup.add(new CreationToolEntry("Add Trigger Instance", "Add Trigger Instance", new TriggerInstanceNodeCreationFactory(), null, null));
    manipGroup.add(new CreationToolEntry("Add Dynamic Trigger Instance", "Add Dynamic Trigger Instance", new DynamicTriggerInstanceNodeCreationFactory(), null, null));
    manipGroup.add(new ConnectionCreationToolEntry("Add Wire", "Add Wire", new LinkCreationFactory(), null, null));
    root.add(manipGroup);
    return root;
}

/**
 * Creation of content assist
 * @param event
 * @param viewer
 * @param paletteRoot
 */
public void showComponentCreationOnCanvas(KeyEvent event, GraphicalViewer viewer, PaletteRoot paletteRoot) {
    this.graphicViewer = viewer;
    this.graphicControl = viewer.getControl();
    this.triggerChar = event.character;
    this.paletteRoot = paletteRoot;
    Point cursorRelativePosition = calculatePosition();
    if (cursorRelativePosition == null) {
        return;
    }

    disposeAssistText();

    createAssistText(cursorRelativePosition);

    initializeListneres();

    activateAssist(triggerChar);

}

private void refreshThePaletteBasedOnSearchString(final PaletteRoot paletteRoot,
        final ELTGraphicalEditor editor, final Map<String, PaletteDrawer> categoryPaletteContainer,
        final Text text, final List<Component> componentsConfig, final Composite container) {
    text.addVerifyListener(new VerifyListener() {
        @Override
        public void verifyText(VerifyEvent e) {
            boolean matchFound = false;
            final List<Component> matchingComponents = new ArrayList<>();
            paletteRoot.getChildren().clear();
            String currentText = ((Text) e.widget).getText();
            createPaletteContainers(paletteRoot, categoryPaletteContainer, editor);
            String searchedString = (currentText.substring(0, e.start) + e.text + currentText.substring(e.end))
                    .toUpperCase();
                if (StringUtils.isEmpty(searchedString)) {
                    showAllContainers(paletteRoot, editor, categoryPaletteContainer, componentsConfig);
                } else {
                    showOpenPaletteContainers(paletteRoot.getChildren());
                    matchFound = checkSearchedComponentFoundInPalette(editor, categoryPaletteContainer, componentsConfig,
                             matchingComponents, searchedString);
                    showMessageWhenComponentNotFound(container, matchFound);
                    showMatchingContainers(paletteRoot, categoryPaletteContainer, matchingComponents);
                }
        }
    });
}

private void showMatchingContainers(PaletteRoot paletteRoot,
        Map<String, PaletteDrawer> categoryPaletteContainer, List<Component> matchingComponents) {
    List<PaletteContainer> children = paletteRoot.getChildren();
    for (PaletteContainer paletteContainer : children) {
        paletteContainer.setVisible(false);

    }
    for (Component component : matchingComponents) {
        for (int i = 0; i < children.size(); i++) {
            if (children.get(i).equals(categoryPaletteContainer.get(component.getCategory().name()))) {
                children.get(i).setVisible(true);
            }
        }
    }

}

/**
 * createShapesDrawer
 * 
 * @return PaletteContainer
 */
private static PaletteRoot createShapesDrawer(DiagramType diagramType) {

    switch (diagramType.getValue()) {
        case DiagramType.CLASS_DIAGRAM_VALUE:
            return classDiagramPaletteDrawer();

        case DiagramType.USE_CASE_DIAGRAM_VALUE:
            return useCaseDiagramPaletteDrawer();

        case DiagramType.ACTIVITY_DIAGRAM_VALUE:
            return activityDiagramPaletteDrawer();

        case DiagramType.COMPONENT_DIAGRAM_VALUE:
            return componentDiagramPaletteDrawer();

        default:
            return null;
    }
}

public static PaletteDrawer createElements(PaletteRoot paletteRoot, List<String> ignore, PaletteGroup p,
            Map<String, List<PaletteEntry>> map) {
        PaletteDrawer drawer = createGroup(paletteRoot, ignore, p.getName(), p.getImage());

        // drawer.add(createJDEntry(MCallout.getIconDescriptor(), MCallout.class));

        drawer.add(createJDEntry(MTextField.getIconDescriptor(), MTextField.class));
        drawer.add(createJDEntry(MStaticText.getIconDescriptor(), MStaticText.class));
        drawer.add(createJDEntry(MImage.getIconDescriptor(), MImage.class));
        drawer.add(createJDEntry(MBreak.getIconDescriptor(), MBreak.class));
        drawer.add(createJDEntry(MRectangle.getIconDescriptor(), MRectangle.class));
        drawer.add(createJDEntry(MEllipse.getIconDescriptor(), MEllipse.class));
        drawer.add(createJDEntry(MLine.getIconDescriptor(), MLine.class));
//      drawer.add(createJDEntry(MGenericElement.getIconDescriptor(), MGenericElement.class));

        drawer.add(createJDEntry(MFrame.getIconDescriptor(), MFrame.class));
        drawer.add(createJDEntry(MSubreport.getIconDescriptor(), MSubreport.class));

        getEntries4Key(drawer, ignore, p.getId(), map);
        return drawer;
    }

/**
 * @see org.eclipse.gef.EditPartFactory#createEditPart(EditPart, Object)
 */
public EditPart createEditPart(EditPart parentEditPart, Object model) {
    if (model instanceof PaletteRoot)
        return createMainPaletteEditPart(parentEditPart, model);
    if (model instanceof PaletteStack)
        return createStackEditPart(parentEditPart, model);
    if (model instanceof PaletteContainer) {
        Object type = ((PaletteContainer) model).getType();
        if (PaletteDrawer.PALETTE_TYPE_DRAWER.equals(type))
            return createDrawerEditPart(parentEditPart, model);
        if (PaletteGroup.PALETTE_TYPE_GROUP.equals(type)
                || PaletteContainer.PALETTE_TYPE_UNKNOWN.equals(type))
            return createGroupEditPart(parentEditPart, model);
        if (PaletteToolbar.PALETTE_TYPE_TOOLBAR_GROUP.equals(type))
            return createToolbarEditPart(parentEditPart, model);
    }
    if (model instanceof PaletteTemplateEntry)
        return createTemplateEditPart(parentEditPart, model);
    if (model instanceof PaletteSeparator)
        return createSeparatorEditPart(parentEditPart, model);
    if (model instanceof PaletteEntry)
        return createEntryEditPart(parentEditPart, model);
    return null;
}

/**
 * {@inheritDoc} In this method the {@link ORMGraphicalEditorPalette} of
 * this editor is registered by the changeNotifier as well.
 */
@Override
protected PaletteRoot getPaletteRoot() {
    ORMGraphicalEditorPalette tmp = new ORMGraphicalEditorPalette();

    changeNotifier.register(tmp); // register the palette for editor changes
    if (getEditorType() == EditorType.ROLES) { // if we show only roles
        tmp.setRoleEntriesVisibility(true); // show only palette entries
                                            // belonging to roles
    } else {
        // compartments
        tmp.setRoleEntriesVisibility(false); // show only palette entries
                                                // belonging to compartment
    }

    return tmp;
}

/**
 * Creates the palette and returns the palette
 * 
 * @return the editor palette
 */
public static PaletteRoot createPalette( )
{
    PaletteRoot root = BasePaletteFactory.createPalette( );
    root.addAll( createCategories( ) );
    root.add( createAutoTextDrawer( ) );

    IExtension extension = new IExtension.Stub( ) {

        public String getExtendsionIdentify( )
        {
            return GuiExtensionManager.PALETTE_MASTERPAGE;
        }
    };
    GuiExtensionManager.doExtension( extension, root );
    return root;
}

/**
 * Creates the palette and returns the palette
 * 
 * @return the editor palette
 */
public static PaletteRoot createPalette( )
{
    PaletteRoot root = BasePaletteFactory.createPalette( );
    root.addAll( createCategories( ) );

    IExtension extension = new IExtension.Stub( ) {

        public String getExtendsionIdentify( )
        {
            return GuiExtensionManager.PALETTE_DESIGNER;
        }
    };
    GuiExtensionManager.doExtension( extension, root );

    root.add( createQuickTools( ) );

    return root;
}

/**
 * @see org.eclipse.core.runtime.IAdaptable#getAdapter(java.lang.Class)
 */
public Object getAdapter( Class type )
{
    if ( type == PalettePage.class )
    {
        if ( splitter == null )
        {
            page = createPalettePage( );
            return page;
        }
        return createPalettePage( );
    }

    if ( type == PaletteRoot.class )
    {
        return getPaletteRoot( );
    }

    if ( type == ZoomManager.class )
    {
        return getGraphicalViewer( ).getProperty( ZoomManager.class.toString( ) );
    }
    return super.getAdapter( type );
}

/**
 * Returns the default <code>PaletteRoot</code> for this editor and all its pages.
 * 
 * @return the default <code>PaletteRoot</code>
 */
public PaletteRoot getPaletteRoot() {
    if (metadata == null) {
        metadata = UrncoreFactory.eINSTANCE.createMetadata();
        metadata.setName("Model Type"); //$NON-NLS-1$
        metadata.setValue("Feature Model"); //$NON-NLS-1$
    }
    if (null == paletteRoot) {
        boolean isFeatureModel = false;
        for (int i = 0; i < parent.getModel().getMetadata().size(); i++)
        {
            Metadata m = (Metadata) parent.getModel().getMetadata().get(i);
            if ((m.getName().equals("Model Type")) && (m.getValue().equals("Feature Model"))) {
                isFeatureModel = true;
                break;
            }
            System.out.println(m.getName() + " " + m.getValue());
        }
        if (isFeatureModel) {
            paletteRoot = new FmdPaletteRoot(parent);
        } else {
            paletteRoot = new GrlPaletteRoot(parent);
        }
    }
    return paletteRoot;
}

/**
 * @generated NOT
 */
protected PaletteRoot createPaletteRoot(PaletteRoot existingPaletteRoot) {

    PaletteRoot root = createPaletteRootGen(existingPaletteRoot);
    ModelRel modelRel = (ModelRel) this.getDiagram().getElement();
    if (!modelRel.isInstancesLevel()) {
        for (Object paletteContainer : root.getChildren()) {
            for (Object paletteEntry : ((PaletteContainer) paletteContainer)
                    .getChildren()) {
                if (paletteEntry instanceof ToolEntry
                        && !(paletteEntry instanceof PanningSelectionToolEntry || paletteEntry instanceof PaletteToolEntry)) {
                    ((ToolEntry) paletteEntry)
                            .setLabel(((ToolEntry) paletteEntry).getLabel() + " " + modelRel.getLevel().toString().charAt(0) + modelRel.getLevel().toString().toLowerCase().substring(1));
                    ((ToolEntry) paletteEntry)
                            .setDescription(((ToolEntry) paletteEntry)
                                    .getDescription() + " " + modelRel.getLevel().toString().charAt(0) + modelRel.getLevel().toString().toLowerCase().substring(1));
                }
            }
        }
    }

    return root;
}

@Override
protected PaletteRoot getPaletteRoot() {
    PaletteRoot root = new PaletteRoot();
    PaletteDrawer manipGroup = new PaletteDrawer("Definitions");
    manipGroup.add(new CreationToolEntry("Add Computing Platform", "Add Computing Platform Definition", new LogicalComputingPlatformCreationFactory(), null, null));
    manipGroup.add(new CreationToolEntry("Add Computing Node", "Add Computing Node Definition", new LogicalComputingCreationFactory(), null, null));
    manipGroup.add(new CreationToolEntry("Add Logical Processor", "Add Logical Processor Definition", new LogicalProcessorsCreationFactory(), null, null));
    root.add(manipGroup);
    return root;
}

@Override
protected PaletteRoot getPaletteRoot() {
    PaletteRoot root = new PaletteRoot();
    PaletteDrawer manipGroup = new PaletteDrawer("Definitions");
    manipGroup.add(new CreationToolEntry("Add Composite Property", "Add Composite Property", new CompositePropertyNodeCreationFactory(), null, null));
    root.add(manipGroup);
    return root;
}

@Override
protected PaletteRoot getPaletteRoot() {
    PaletteRoot root = new PaletteRoot();
    PaletteDrawer manipGroup = new PaletteDrawer("Definitions");
    manipGroup.add(new CreationToolEntry("Add Platform Configuration", "Add Platform Configuration", new PlatformConfigurationCreationFactory(), null, null));
    manipGroup.add(new CreationToolEntry("Add Computing Node Configuration", "Add Computing Node Configuration", new ComputingNodeConfigurationCreationFactory(), null, null));
    manipGroup.add(new CreationToolEntry("Add Protection Domain", "Add Protection Domain", new ProtectionDomainCreationFactory(), null, null));
    manipGroup.add(new CreationToolEntry("Add Module Instance", "Add Module Instance", new DeployedModuleInstanceCreationFactory(), null, null));
    manipGroup.add(new CreationToolEntry("Add Trigger Instance", "Add Trigger Instance", new DeployedTriggerInstanceCreationFactory(), null, null));
    root.add(manipGroup);
    return root;
}

@Override
protected PaletteRoot getPaletteRoot() {
    PaletteRoot root = new PaletteRoot();
    PaletteDrawer manipGroup = new PaletteDrawer("Definitions");
    manipGroup.add(new CreationToolEntry("Add Composite Property", "Add Composite Property", new CompositePropertyNodeCreationFactory(), null, null));
    manipGroup.add(new CreationToolEntry("Add Component", "Add Component Definition", new ComponentNodeCreationFactory(), null, null));
    manipGroup.add(new ConnectionCreationToolEntry("Add Wire", "Add Wire Definition", new LinkCreationFactory(), null, null));
    root.add(manipGroup);
    return root;
}

@Override
  protected EditPart createMainPaletteEditPart(EditPart parentEditPart, Object model) {
return new SliderPaletteEditPart((PaletteRoot) model) {
    @Override
    public IFigure createFigure() {
        paletteTextFigure = super.createFigure();
        paletteTextFigure.setForegroundColor(palatteTextColor);
        paletteTextFigure.setBackgroundColor(palatteBackgroundColor);
        return paletteTextFigure;
    }
};
  }

public CustomFigureCanvas(int style, Composite parent, LightweightSystem lws, CustomPaletteViewer toolViewer, PaletteRoot paletteRoot,ELTGraphicalEditor editor) {
    super(style | APPLY_STYLES, parent, lws);
        containerForSearchTextBox = toolViewer.creatSearchTextBox(this, paletteRoot,editor);
    if (containerForSearchTextBox != null && toolViewer != null) {
        org.eclipse.swt.graphics.Point bounds = containerForSearchTextBox.computeSize(SWT.DEFAULT, SWT.DEFAULT);
        if (containerHeight < bounds.y) {
            containerHeight = bounds.y;

        }
    }

    customLayoutViewPort();
}

/**
 * create searchTextBox and show components according to text entered in search box
 * @param parent
 * @param paletteRoot
 * @param editor
 * @return Control
 */
public Control creatSearchTextBox(Composite parent, final PaletteRoot paletteRoot, final ELTGraphicalEditor editor) {
    final Map<String, PaletteDrawer> categoryPaletteContainer = new HashMap<>();
    Composite container = createCompositeForSearchTextBox(parent);
    final Text text = createSearchTextBox(container,SWT.BORDER);
    try {
        final List<Component> componentsConfig = XMLConfigUtil.INSTANCE.getComponentConfig();
        refreshThePaletteBasedOnSearchString(paletteRoot, editor, categoryPaletteContainer, text,
                componentsConfig, container);

    } catch (RuntimeException|SAXException|IOException exception) {
        LOGGER.error(exception.getMessage(),exception);
    }
    return container;
}

private void showAllContainers(final PaletteRoot paletteRoot, final ELTGraphicalEditor editor,
        final Map<String, PaletteDrawer> categoryPaletteContainer, final List<Component> componentsConfig) {
    for (Component componentConfig : componentsConfig) {
        if (Constants.UNKNOWN_COMPONENT.equalsIgnoreCase(componentConfig.getName()))
            continue;
        CombinedTemplateCreationEntry component = getComponentToAddInContainer(editor, componentConfig);

        categoryPaletteContainer.get(componentConfig.getCategory().name()).add(component);
        showClosedPaletteContainersWhenSearchTextBoxIsEmpty(paletteRoot.getChildren());
    }
    if (label != null) {
        label.dispose();
    }
}

private void createPaletteContainers(PaletteRoot paletteRoot, Map<String, PaletteDrawer> categoryPaletteContainer,
        ELTGraphicalEditor eLEtlGraphicalEditor) {
    for (CategoryType category : CategoryType.values()) {
        if (Constants.UNKNOWN_COMPONENT_CATEGORY.equalsIgnoreCase(category.name()))
            continue;
        PaletteDrawer paletteDrawer = eLEtlGraphicalEditor.createPaletteContainer(category.name());
        eLEtlGraphicalEditor.addContainerToPalette(paletteRoot, paletteDrawer);
        categoryPaletteContainer.put(category.name(), paletteDrawer);
    }
}

@Override
protected PaletteRoot getPaletteRoot() {
    PaletteRoot palette = new PaletteRoot();
    paletteRoot = palette;
    createToolsGroup(palette);
    try {
        createShapesDrawer(palette);
    } catch (RuntimeException | SAXException |IOException e) {
        logger.error(e.getMessage(),e);
    } 
    return palette;
}

private void createShapesDrawer(PaletteRoot palette) throws RuntimeException, SAXException, IOException {
    Map<String, PaletteDrawer> categoryPaletteConatiner = new HashMap<>();
    for (CategoryType category : CategoryType.values()) {
        if(category.name().equalsIgnoreCase(Constants.UNKNOWN_COMPONENT_CATEGORY)){
            continue;
        }               
        PaletteDrawer p = createPaletteContainer(category.name());
        addContainerToPalette(palette, p);
        categoryPaletteConatiner.put(category.name(), p);
    }
    List<Component> componentsConfig = XMLConfigUtil.INSTANCE.getComponentConfig();

    //To show the components in sorted order in palette
    Collections.sort(componentsConfig, new Comparator<Component>() {
        public int compare(Component component1, Component component2) {
            return  component1.getNameInPalette().compareToIgnoreCase(component2.getNameInPalette());           
        };
    });

    for (Component componentConfig : componentsConfig) {
        Class<?> clazz = DynamicClassProcessor.INSTANCE.createClass(componentConfig);

        if(componentConfig.getName().equalsIgnoreCase(Constants.UNKNOWN_COMPONENT)){
            continue;
        }

        CombinedTemplateCreationEntry component = new CombinedTemplateCreationEntry(
                componentConfig.getNameInPalette(), null, clazz,
                new SimpleFactory(clazz),
                ImageDescriptor.createFromURL(
                        prepareIconPathURL(componentConfig.getPaletteIconPath())),
                        ImageDescriptor.createFromURL(
                                prepareIconPathURL(componentConfig.getPaletteIconPath())));
        categoryPaletteConatiner.get(componentConfig.getCategory().name()).add(component);
    }

}

private void createToolsGroup(PaletteRoot palette) {
    PaletteToolbar toolbar = new PaletteToolbar("Tools");

    // Add a selection tool to the group
    //      ToolEntry tool = new PanningSelectionToolEntry();
    //      toolbar.add(tool);
    //      palette.setDefaultEntry(tool);

    palette.add(toolbar);
}

/**
 * Because we have to pass in the platform from the diagram...
 * 
 * @return
 */
private PaletteRoot createPlatformPalette() {
    if (PALETTE_ROOT == null) {
        PALETTE_ROOT = GUIEditorPaletteFactory.createPalette(diagram);
    }
    return PALETTE_ROOT;
}

/**
 * createPalette
 * 
 * @return PaletteRoot
 */
public static PaletteRoot createPalette(DiagramType diagramType) {

    PaletteRoot palette = new PaletteRoot();
    palette = createShapesDrawer(diagramType);
    palette.add(0, createToolsGroup(diagramType));
    // palette.add(createShapesDrawer(diagramType));

    return palette;
}

/**
 * createPalette
 * 
 * @return PaletteRoot
 */
public static PaletteRoot createPalette(DiagramType diagramType) {

    PaletteRoot palette = new PaletteRoot();
    palette = createShapesDrawer(diagramType);
    palette.add(0, createToolsGroup(diagramType));
    // palette.add(createShapesDrawer(diagramType));

    return palette;
}

/**
 * createShapesDrawer
 * 
 * @return PaletteContainer
 */
private static PaletteRoot createShapesDrawer(DiagramType diagramType) {

    switch (diagramType.getValue()) {
        case DiagramType.SEQUENCE_DIAGRAM_VALUE:
            return sequenceDiagramPaletteDrawer();
        default:
            return null;
    }
}

public void createPaletteEntries(PaletteRoot root) {
    PaletteContainer container = createToolsCategory(root);
    createTransitionEntry(container);
    createStateEntry(container);
    createCompositeStateEntry(container);
    createOrthogonalStateEntry(container);
    createRegionEntry(container);
    createInitialStateEntry(container);
    createShallowHistoryEntry(container);
    createDeepHistoryEntry(container);
    createFinalStateEntry(container);
    createExitEntry(container);
    createChoiceEntry(container);
    createSynchronizationEntry(container);
}

public void contributeToPalette(IEditorPart editor, Object content, PaletteRoot root,
        @SuppressWarnings("rawtypes") Map predefinedEntries) {
    IFile adapter = (IFile) editor.getEditorInput().getAdapter(IFile.class);
    String domainID = DomainRegistry
            .determineDomainID(URI.createPlatformResourceURI(adapter.getFullPath().toOSString(), true));
    Injector editorInjector = DomainRegistry.getDomain(domainID).getInjector(IDomain.FEATURE_EDITOR);
    ISCTPaletteFactory factory = editorInjector.getInstance(ISCTPaletteFactory.class);
    factory.createPaletteEntries(root);
}

public static PaletteDrawer createContainers(PaletteRoot paletteRoot, List<String> ignore, PaletteGroup p,
        Map<String, List<PaletteEntry>> map) {
    PaletteDrawer drawer = createGroup(paletteRoot, ignore, p.getName(), p.getImage());

    drawer.add(createJDEntry(MFrame.getIconDescriptor(), MFrame.class));
    drawer.add(createJDEntry(MSubreport.getIconDescriptor(), MSubreport.class));

    getEntries4Key(drawer, ignore, p.getId(), map);
    return drawer;
}

/**
 * Creates a new JDPalette object.
 * 
 * @param paletteRoot
 *          the palette root
 */
public static void createFields(PaletteRoot paletteRoot, List<String> ignore, PaletteGroup p,
        Map<String, List<PaletteEntry>> map) {
    PaletteDrawer drawer = createGroup(paletteRoot, ignore, p.getName(), p.getImage());

    drawer.add(createJDEntry(MPageNumber.getIconDescriptor(), MPageNumber.class));
    drawer.add(createJDEntry(MTotalPages.getIconDescriptor(), MTotalPages.class));
    drawer.add(createJDEntry(MDate.getIconDescriptor(), MDate.class));
    drawer.add(createJDEntry(MTime.getIconDescriptor(), MTime.class));
    drawer.add(createJDEntry(MPercentage.getIconDescriptor(), MPercentage.class));
    drawer.add(createJDEntry(MPageXofY.getIconDescriptor(), MPageXofY.class));

    getEntries4Key(drawer, ignore, p.getId(), map);
}

/**
 * Creates a new JDPalette object.
 * 
 * @param paletteRoot
 *          the palette root
 */
public static void createToolBar(PaletteRoot paletteRoot) {
    PaletteToolbar paletteToolbar = new PaletteToolbar("toolbar"); //$NON-NLS-1$
    paletteToolbar.add(new SelectionToolEntry());
    paletteToolbar.add(new JDMarqueeToolEntry());
    paletteRoot.add(paletteToolbar);
}

/**
 * Sets the root for this palette.
 * 
 * @param root
 *            the PaletteRoot for this palette
 */
public void setPaletteRoot(PaletteRoot root) {
    if (root == paletteRoot)
        return;
    paletteRoot = root;
    if (paletteRoot != null) {
        EditPart palette = getEditPartFactory().createEditPart(
                getRootEditPart(), root);
        getRootEditPart().setContents(palette);
    }
}

/**
 * @see PaletteEntryFactory#determineContainerForNewEntry(PaletteEntry)
 */
protected PaletteContainer determineContainerForNewEntry(
        PaletteEntry selected) {
    if (selected instanceof PaletteRoot)
        return (PaletteContainer) selected;
    PaletteContainer current = selected.getParent();
    while (!(current instanceof PaletteRoot))
        current = current.getParent();
    return current;
}

/**
 * Opens the Customizer Dialog for the palette
 * 
 * @see org.eclipse.jface.action.IAction#run()
 */
public void run() {
    PaletteCustomizerDialog dialog = paletteViewer.getCustomizerDialog();
    List list = paletteViewer.getSelectedEditParts();
    if (!list.isEmpty()) {
        PaletteEntry selection = (PaletteEntry) ((EditPart) list.get(0))
                .getModel();
        if (!(selection instanceof PaletteRoot)) {
            dialog.setDefaultSelection(selection);
        }
    }
    dialog.open();
}

private List<PaletteEntry> createCategories(PaletteRoot root, String type) {
    List<PaletteEntry> categories = new ArrayList<PaletteEntry>();
    categories.add(createControlGroup(root));
    if (type.equalsIgnoreCase(ConfigManager.COMPONENT_TYPE_FIELD)) {
        categories.add(createFieldDrawer());
    } else if (type.equalsIgnoreCase(ConfigManager.COMPONENT_TYPE_PROCESS)) {
        categories.add(createTaskDrawer(root));
    }
    return categories;
}

private PaletteContainer createTaskDrawer(PaletteRoot root) {
    String group = "流程组件";

    List<PaletteEntry> entries = new ArrayList<PaletteEntry>();
    PaletteDrawer drawer = new PaletteDrawer(group,
            ImageDescriptor.createFromFile(TaskFigure.class,
                    "icons/home.png"));

    ConnectionCreationToolEntry connectionToolEntry = new ConnectionCreationToolEntry(
            "transition", "创建连接", new ModelCreationFactory(null,
                    Transition.class), ImageDescriptor.createFromFile(
                    TaskFigure.class, "icons/flow_sequence.png"),
            ImageDescriptor.createFromFile(TaskFigure.class,
                    "icons/flow_sequence.png"));

    drawer.add(connectionToolEntry);

    List<Component> listComp = ConfigManager.getComponents();

    for (int i = 0; i < listComp.size(); i++) {
        Component comp = (Component) listComp.get(i);
        if (!validate(ConfigManager.COMPONENT_TYPE_PROCESS, comp)) {
            continue;
        }
        PaletteEntry paletteEntry = createCombinedEntry(comp);
        if (paletteEntry == null) {
            continue;
        }
        entries.add(paletteEntry);
    }

    drawer.addAll(entries);
    return drawer;
}

@Override
protected PaletteRoot getPaletteRoot() {
    try {
        PaletteFactory factory = new PaletteFactory();
        PaletteRoot root = factory
                .getPaletteRoot(ConfigManager.COMPONENT_TYPE_PROCESS);
        return root;
    } catch (Exception e) {
        e.printStackTrace();
        return null;
    }

}