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

/**
 * @see org.eclipse.gef.EditPartFactory#createEditPart(EditPart, Object)
 */
@Override
public EditPart createEditPart(EditPart parentEditPart, Object model) {
  if (model instanceof UserLibraryTreeNode) {
    return new UserLibraryTreeNodeEditPart((PaletteContainer) model);
  }
  if (model instanceof PaletteContainer) {
    if (parentEditPart instanceof UserLibraryTreeNodeEditPart) {
      return new UserLibraryTreeNodeEditPart((PaletteContainer) model);
    } else {
      return new PaletteTreeNodeEditPart((PaletteContainer) model);
    }
  }
  if (model instanceof PaletteEntry) {
    return new PaletteEntryEditPart((PaletteEntry) model);
  }
  return null;
}

@Override
public int compare(PaletteEntry o1, PaletteEntry o2) {
  if (o1 instanceof PaletteTreeNode) {
    if (o2 instanceof PaletteTreeNode) {
      int result = ((PaletteTreeNode) o1).getPriority().compareTo(((PaletteTreeNode) o2).getPriority());
      if (result != 0) {
        return result;
      }
    } else {
      return 1;
    }
  } else if (o2 instanceof PaletteTreeNode) {
    return -1;
  }
  return o1.getLabel().compareTo(o2.getLabel());
}

public Map<String, List<PaletteEntry>> getPaletteEntries() {
    Map<String, List<PaletteEntry>> map = new HashMap<String, List<PaletteEntry>>();
    for (IComponentFactory f : nodeFactory) {
        IPaletteContributor ipc = f.getPaletteEntries();
        if (ipc != null) {
            Map<String, List<PaletteEntry>> paletteEntries = ipc.getPaletteEntries();
            if (paletteEntries != null) {
                for (String key : paletteEntries.keySet()) {
                    List<PaletteEntry> ol = map.get(key);
                    if (ol == null)
                        map.put(key, paletteEntries.get(key));
                    else
                        ol.addAll(paletteEntries.get(key));
                }
            }
        }
    }
    return map;
}

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;
    }

/**
 * Get the tool tip text for this palette edit part.
 * 
 * @return the tool tip text.
 */
protected String getToolTipText() {
    String text = null;
    PaletteEntry entry = (PaletteEntry) getModel();
    String desc = entry.getDescription();
    boolean needName = nameNeededInToolTip();
    if (desc == null || desc.trim().equals(entry.getLabel())
            || desc.trim().equals("")) { //$NON-NLS-1$
        if (needName)
            text = entry.getLabel();
    } else {
        if (needName)
            text = entry.getLabel()
                    + " " //$NON-NLS-1$
                    + PaletteMessages.NAME_DESCRIPTION_SEPARATOR
                    + " " + desc; //$NON-NLS-1$
        else
            text = desc;
    }
    if (text != null && text.trim().equals(""))//$NON-NLS-1$
        return null;
    return text;
}

/**
 * @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;
}

/**
 * @see ScrollingGraphicalViewer#reveal(EditPart)
 */
public void reveal(EditPart part) {
    // If the given part is a drawer, we don't need to expand it. Hence,
    // when invoking
    // findContainingDrawer(), we use part.getParent()
    DrawerEditPart drawer = findContainingDrawer(part.getParent());
    if (drawer != null && !drawer.isExpanded())
        drawer.setExpanded(true);
    // if the part is inside a stack, set it to be the top level item of the
    // stack.
    if (part.getParent() != null
            && part.getParent() instanceof PaletteStackEditPart)
        ((PaletteStack) part.getParent().getModel())
                .setActiveEntry((PaletteEntry) part.getModel());
    super.reveal(part);
}

/**
 * @see org.eclipse.gef.ui.palette.customize.EntryPage#createControl(Composite,
 *      PaletteEntry)
 */
public void createControl(Composite parent, PaletteEntry entry) {
    this.entry = entry;

    panel = new Composite(parent, SWT.NONE);
    panel.setFont(parent.getFont());
    GridLayout gridLayout = new GridLayout(1, false);
    gridLayout.marginWidth = 0;
    gridLayout.marginHeight = 0;
    panel.setLayout(gridLayout);
    Control[] tablist = new Control[3];

    createLabel(panel, SWT.NONE, PaletteMessages.NAME_LABEL);
    tablist[0] = createNameText(panel);

    createLabel(panel, SWT.NONE, PaletteMessages.DESCRIPTION_LABEL);
    tablist[1] = createDescText(panel);

    tablist[2] = createHiddenCheckBox(panel);

    panel.setTabList(tablist);
}

/**
 * Creates the <code>Text</code> where the description of the entry is to be
 * displayed.
 * 
 * @param panel
 *            The Composite in which the <code>Text</code> is to be created
 * @return The newly created <code>Text</code>
 */
protected Text createDescText(Composite panel) {
    String desc = entry.getDescription();
    Text description = createText(panel, SWT.MULTI | SWT.WRAP | SWT.BORDER
            | SWT.V_SCROLL, desc);
    GridData data = new GridData(GridData.FILL_HORIZONTAL);
    data.widthHint = 150;
    data.heightHint = description.computeTrim(0, 0, 10, FigureUtilities
            .getFontMetrics(description.getFont()).getHeight() * 2).height;
    description.setLayoutData(data);
    if (getPermission() >= PaletteEntry.PERMISSION_LIMITED_MODIFICATION) {
        description.addModifyListener(new ModifyListener() {
            public void modifyText(ModifyEvent e) {
                handleDescriptionChanged(((Text) e.getSource()).getText());
            }
        });
    }
    return description;
}

/**
 * Creates the <code>Button</code> (CheckBox) for indicating the hidden
 * status of the entry. It initializes it with the current hidden state of
 * entry.
 * 
 * @param panel
 *            The Composite in which the Button is to be created
 * @return The newly created Button
 */
protected Button createHiddenCheckBox(Composite panel) {
    Button hidden = new Button(panel, SWT.CHECK);
    hidden.setFont(panel.getFont());
    hidden.setText(PaletteMessages.HIDDEN_LABEL);
    hidden.setSelection(!entry.isVisible());

    if (getPermission() == PaletteEntry.PERMISSION_NO_MODIFICATION) {
        hidden.setEnabled(false);
    } else {
        hidden.addSelectionListener(new SelectionAdapter() {
            public void widgetSelected(SelectionEvent e) {
                handleHiddenSelected(((Button) e.getSource())
                        .getSelection());
            }
        });
    }

    return hidden;
}

/**
 * Creates a <code>Text</code>. This method is mainly a result of
 * code-factoring.
 * 
 * @param panel
 *            The Composite in which the Text is to be created
 * @param style
 *            The stylebits for the Text
 * @param text
 *            The text to be displayed in the Text
 * @return a text widget with griddata constraint
 */
protected Text createText(Composite panel, int style, String text) {
    if (getEntry() instanceof PaletteSeparator
            || getPermission() < PaletteEntry.PERMISSION_LIMITED_MODIFICATION) {
        style = style | SWT.READ_ONLY;
    }

    Text textBox = new Text(panel, style);
    textBox.setFont(panel.getFont());
    if (text != null)
        textBox.setText(text);
    GridData data = new GridData(GridData.FILL_HORIZONTAL);
    data.widthHint = 200;
    textBox.setLayoutData(data);
    return textBox;
}

/**
 * @see org.eclipse.gef.ui.palette.customize.EntryPage#createControl(Composite,
 *      PaletteEntry)
 */
public void createControl(Composite parent, PaletteEntry entry) {
    super.createControl(parent, entry);

    openDrawerOption = createOpenDrawerInitiallyOption(getComposite());
    pinDrawerOption = createPinDrawerInitiallyOption(getComposite());

    Control[] oldTablist = getComposite().getTabList();
    if (!contains(oldTablist, openDrawerOption)) {
        // This means that the super class must've set a specific tab order
        // on this
        // composite. We need to add the two newly created controls to this
        // tab order.
        Control[] newTablist = new Control[oldTablist.length + 2];
        System.arraycopy(oldTablist, 0, newTablist, 0, oldTablist.length);
        newTablist[newTablist.length - 2] = openDrawerOption;
        newTablist[newTablist.length - 1] = pinDrawerOption;
        getComposite().setTabList(newTablist);
    }
}

/**
 * Creates the button that provides the option to pin a drawer open at
 * start-up.
 * 
 * @param panel
 *            The parent Composite
 * @return The button for the new option
 */
protected Button createOpenDrawerInitiallyOption(Composite panel) {
    Button b = new Button(panel, SWT.CHECK);
    b.setFont(panel.getFont());
    b.setText(PaletteMessages.EXPAND_DRAWER_AT_STARTUP_LABEL);
    b.setSelection(getDrawer().isInitiallyOpen());
    if (getPermission() >= PaletteEntry.PERMISSION_LIMITED_MODIFICATION) {
        b.addSelectionListener(new SelectionAdapter() {
            public void widgetSelected(SelectionEvent e) {
                handleOpenSelected(((Button) e.getSource()).getSelection());
            }
        });
    } else {
        b.setEnabled(false);
    }

    return b;
}

/**
 * Creates the button that provides the option to have a drawer open at
 * start-up.
 * 
 * @param panel
 *            The parent Composite
 * @return The button for the new option
 */
protected Button createPinDrawerInitiallyOption(Composite panel) {
    Button pinOption = new Button(panel, SWT.CHECK);
    pinOption.setFont(panel.getFont());
    pinOption.setText(PaletteMessages.DRAWER_PIN_AT_STARTUP);
    GridData data = new GridData();
    data.horizontalIndent = 15;
    pinOption.setLayoutData(data);
    pinOption.setEnabled(openDrawerOption.getSelection()
            && openDrawerOption.isEnabled());
    pinOption.setSelection(getDrawer().isInitiallyPinned());
    if (getPermission() >= PaletteEntry.PERMISSION_LIMITED_MODIFICATION) {
        pinOption.addSelectionListener(new SelectionAdapter() {
            public void widgetSelected(SelectionEvent e) {
                handlePinSelected(((Button) e.getSource()).getSelection());
            }
        });
    }
    return pinOption;
}

/**
 * This method is invoked whenever there is any change in the model. It
 * updates the viewer with the changes that were made to the model.
 * Sub-classes may override this method to change or extend its
 * functionality.
 * 
 * @param evt
 *            The {@link PropertyChangeEvent} that was fired from the model
 */
protected void handlePropertyChanged(PropertyChangeEvent evt) {
    PaletteEntry entry = ((PaletteEntry) evt.getSource());
    String property = evt.getPropertyName();
    if (property.equals(PaletteEntry.PROPERTY_LABEL)
            || property.equals(PaletteEntry.PROPERTY_SMALL_ICON)) {
        viewer.update(entry, null);
    } else if (property.equals(PaletteEntry.PROPERTY_VISIBLE)) {
        viewer.refresh(entry);
    } else if (property.equals(PaletteContainer.PROPERTY_CHILDREN)) {
        viewer.refresh(entry);
        List oldChildren = (List) evt.getOldValue();
        for (Iterator iter = oldChildren.iterator(); iter.hasNext();) {
            PaletteEntry child = (PaletteEntry) iter.next();
            traverseModel(child, false);
        }
        traverseModel(entry, true);
    }
}

/**
 * Returns the <code>EntryPage</code> for the given
 * <code>PaletteEntry</code>. The <code>EntryPage</code> is retrieved from
 * the customizer. If the given entry is <code>null</code>,
 * <code>null</code> will be returned. If the customizer returns
 * <code>null</code> for the valid entry, a default page will be created and
 * returned.
 * 
 * @param entry
 *            The PaletteEntry whose properties need to be displayed
 * @return The EntryPage with the properties of the given PaletteEntry
 */
protected EntryPage getEntryPage(PaletteEntry entry) {
    if (entry == null) {
        return null;
    }

    if (entriesToPages.containsKey(entry)) {
        return (EntryPage) entriesToPages.get(entry);
    }

    EntryPage page = getCustomizer().getPropertiesPage(entry);
    if (page == null) {
        page = new DefaultEntryPage();
    }
    page.createControl(propertiesPanelContainer, entry);
    page.setPageContainer(this);
    entriesToPages.put(entry, page);

    return page;
}

/**
 * This is the method that is called everytime the selection in the outline
 * (treeviewer) changes.
 */
protected void handleOutlineSelectionChanged() {
    PaletteEntry entry = getSelectedPaletteEntry();

    if (activeEntry == entry) {
        return;
    }

    if (errorMessage != null) {
        MessageDialog dialog = new MessageDialog(getShell(),
                PaletteMessages.ERROR,
                null,
                PaletteMessages.ABORT_PAGE_FLIPPING_MESSAGE
                        + "\n" + errorMessage, //$NON-NLS-1$
                MessageDialog.ERROR,
                new String[] { IDialogConstants.OK_LABEL }, 0);
        dialog.open();
        treeviewer.addPostSelectionChangedListener(pageFlippingPreventer);
    } else {
        setActiveEntry(entry);
    }
    updateActions();
}

public void update() {
    boolean enabled = false;
    PaletteEntry entry = getSelectedPaletteEntry();
    if (entry == null) {
        entry = getPaletteRoot();
    }
    // Enable or disable the FactoryWrapperActions
    for (Iterator iter = factories.iterator(); iter.hasNext();) {
        FactoryWrapperAction action = (FactoryWrapperAction) iter
                .next();
        action.setEnabled(action.canCreate(entry));
        enabled = enabled || action.isEnabled();
    }

    // Enable this action IFF at least one of the new actions is enabled
    setEnabled(enabled);
}

/**
 * @see org.eclipse.gef.editparts.AbstractEditPart#refreshVisuals()
 */
protected void refreshVisuals() {
    DetailedLabelFigure fig = (DetailedLabelFigure) getFigure();
    PaletteEntry entry = getPaletteEntry();
    fig.setName(entry.getLabel());
    fig.setDescription(entry.getDescription());
    if (getPreferenceSource().useLargeIcons())
        setImageDescriptor(entry.getLargeIcon());
    else
        setImageDescriptor(entry.getSmallIcon());
    int layoutMode = getLayoutSetting();
    fig.setLayoutMode(layoutMode);
    if (layoutMode == PaletteViewerPreferences.LAYOUT_COLUMNS) {
        fig.setBorder(ToolEntryEditPart.ICON_BORDER);
    } else if (layoutMode == PaletteViewerPreferences.LAYOUT_LIST
            || layoutMode == PaletteViewerPreferences.LAYOUT_DETAILS) {
        fig.setBorder(ToolEntryEditPart.LIST_BORDER);
    } else if (layoutMode == PaletteViewerPreferences.LAYOUT_ICONS
            && !isToolbarItem()) {
        fig.setBorder(ToolEntryEditPart.ICON_BORDER);
    } else {
        fig.setBorder(null);
    }
    super.refreshVisuals();
}

/**
 * @see org.eclipse.gef.editparts.AbstractEditPart#refreshVisuals()
 */
protected void refreshVisuals() {
    PaletteEntry entry = getPaletteEntry();

    customLabel.setName(entry.getLabel());
    customLabel.setDescription(entry.getDescription());
    if (getPreferenceSource().useLargeIcons())
        setImageDescriptor(entry.getLargeIcon());
    else
        setImageDescriptor(entry.getSmallIcon());
    int layoutMode = getLayoutSetting();
    customLabel.setLayoutMode(layoutMode);
    if (layoutMode == PaletteViewerPreferences.LAYOUT_COLUMNS) {
        customLabel.setBorder(ICON_BORDER);
    } else if (layoutMode == PaletteViewerPreferences.LAYOUT_LIST
            || layoutMode == PaletteViewerPreferences.LAYOUT_DETAILS) {
        customLabel.setBorder(LIST_BORDER);
    } else if (layoutMode == PaletteViewerPreferences.LAYOUT_ICONS
            && !isToolbarItem()) {
        customLabel.setBorder(ICON_BORDER);
    } else {
        customLabel.setBorder(null);
    }

    super.refreshVisuals();
}

@SuppressWarnings("unchecked")
private <T extends PaletteEntry> T findByLabel(final PaletteContainer thePaletteContainer, final String theLabel) {
    final String[] path = theLabel.split("/");
    PaletteEntry nextEntry = thePaletteContainer;
    NEXT_SEGMENT: for (final String segment : path) {
        if (nextEntry instanceof PaletteContainer) {
            for (final Object o : ((PaletteContainer) nextEntry).getChildren()) {
                final PaletteEntry paletteEntry = (PaletteEntry) o;
                if (segment.equals(paletteEntry.getLabel())) {
                    nextEntry = paletteEntry;
                    continue NEXT_SEGMENT;
                }
            }
            return null;
        } else {
            return null;
        }
    }
    return (T) nextEntry;
}

private PaletteContainer createFieldDrawer() {
    List<PaletteEntry> entries = new ArrayList<PaletteEntry>();
    String group = "表单控件";
    PaletteDrawer drawer = new PaletteDrawer(group,
            ImageDescriptor.createFromFile(TaskFigure.class,
                    "icons/home.png"));

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

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

    drawer.addAll(entries);
    drawer.setInitialState(2);
    return drawer;
}

@SuppressWarnings("unchecked")
private static <T extends PaletteEntry> T findByLabel(final PaletteContainer thePaletteContainer, final String theLabel) {
    final String[] path = theLabel.split("/");
    PaletteEntry nextEntry = thePaletteContainer;
    NEXT_SEGMENT: for (final String segment : path) {
        if (nextEntry instanceof PaletteContainer) {
            for (final Object o : ((PaletteContainer) nextEntry).getChildren()) {
                final PaletteEntry paletteEntry = (PaletteEntry) o;
                if (ObjectUtils.equals(segment, paletteEntry.getLabel())) {
                    nextEntry = paletteEntry;
                    continue NEXT_SEGMENT;
                }
            }
            return null;
        } else {
            return null;
        }
    }
    return (T) nextEntry;
}

public void dispose() {
    for (Iterator iterator = getChildren().iterator(); iterator.hasNext();) {
        PaletteEntry elem = (PaletteEntry) iterator.next();
        if (elem instanceof PaletteDrawer) {
            PaletteDrawer drawer = (PaletteDrawer) elem;
            Vector v2 = new Vector();
            v2.addAll(drawer.getChildren());

            for (Iterator iterator2 = v2.iterator(); iterator2.hasNext();) {
                PaletteEntry elem2 = (PaletteEntry) iterator2.next();
                if (elem2 instanceof URNElementCreationEntry) {
                    URNElementCreationEntry entry = (URNElementCreationEntry) elem2;
                    entry.setFactory(null);
                }
                elem2.setParent(null);
            }
        }
    }
    setChildren(new Vector());
    parent = null;
    keyboardMapping.clear();
    keyboardMapping = null;
}

@Override
public IContentProposal[] getProposals(String contents, int position) {

    proposalList.clear();
    List<PaletteContainer> paletteEntry = paletteRoot.getChildren();
    for (PaletteContainer paletteContainer : paletteEntry) {
        List<PaletteEntry> paletteDrawersList = paletteContainer.getChildren();
        for (PaletteEntry paletteDrawer : paletteDrawersList) {

            if (StringUtils.containsIgnoreCase(
                    paletteDrawer.getParent().getLabel() + " : " + paletteDrawer.getLabel(), contents)) {
                String componentName = ((Class) ((CombinedTemplateCreationEntry) paletteDrawer).getTemplate())
                        .getSimpleName();
                componentDetails = new ComponentDetails();
                Component component = XMLConfigUtil.INSTANCE.getComponent(componentName);
                componentDetails.setName(componentName);
                componentDetails.setCategoryAndPalletteName(
                        paletteDrawer.getParent().getLabel() + " : " + paletteDrawer.getLabel());
                componentDetails.setDescription(component.getDescription());
                componentDetails.setDescriptor(paletteDrawer.getSmallIcon());
                proposalList.add(new ComponentContentProposal(componentDetails));
            }
        }
    }

    componentDetails = new ComponentDetails();
    componentDetails.setName(COMMENT_BOX);
    componentDetails.setCategoryAndPalletteName(COMMENT_BOX);
    componentDetails.setDescription(COMMENT_BOX);
    componentDetails.setDescriptor(getCommentBoxImageDisDescriptor());
    proposalList.add(new ComponentContentProposal(componentDetails));
    return proposalList.toArray(new IContentProposal[0]);
}

@Override
protected Image getImage() {
  PaletteEntry entry = (PaletteEntry) getModel();
  ImageDescriptor smallIcon = entry.getSmallIcon();
  if (smallIcon != null) {
    return ExtendedImageRegistry.INSTANCE.getImage(smallIcon);
  } else {
    return GraphitiUi.getImageService().getImageForId(TriqDiagramTypeProvider.ID, getDefaultImageID());
  }
}

@Override
protected Command getCreateCommand(CreateRequest request) {
  PaletteEntry child = (PaletteEntry) request.getNewObject();

  UserLibraryCreateCommand cmd = new UserLibraryCreateCommand();
  cmd.setChild(child);
  cmd.setParent((PaletteTreeNodeEditPart) getHost());
  return cmd;
}

@Override
@SuppressWarnings({ "rawtypes", "unchecked" })
protected List getModelChildren() {
  List children = new ArrayList();
  PaletteEntry entry = (PaletteEntry) getModel();
  if (entry instanceof PaletteContainer) {
    PaletteContainer pc = (PaletteContainer) entry;
    children.addAll(pc.getChildren());
  }
  return children;
}

@Override
public void run() {
  PaletteTreeNode entry = (PaletteTreeNode) selectedNode.getModel();
  String libraryName = selectedNode.getFullTreePath('.');

  AddFolderToUserLibraryDialog dialog = new AddFolderToUserLibraryDialog(getTreeControl().getShell());
  dialog.setBlockOnOpen(true);
  int dialogReturnCode = dialog.open();
  if (Dialog.OK == dialogReturnCode) {
    Map<String, String> properties = new HashMap<>();
    String folderName = dialog.folderName;
    properties.put("displayName", folderName);
    properties.put("libraryName", libraryName);

    Event event = new Event(LibraryManager.ADD_EVENT_TOPIC, properties);
    try {
      // Sending events is nice to decouple UI handling from the underlying library management,
      // but we don't get any indication about success/failure.
      // So we may need to replace this by direct method calls.
      TriqEditorPlugin.getDefault().getEventAdminService().sendEvent(event);
      PaletteTreeNode folderTreeNode = new PaletteTreeNode(folderName);
      folderTreeNode.setUserModificationPermission(PaletteEntry.PERMISSION_FULL_MODIFICATION);
      selectedNode.addChild(folderTreeNode);
      entry.add(folderTreeNode);
    } catch (NullPointerException e) {
      StatusManager.getManager().handle(new Status(IStatus.ERROR, TriqEditorPlugin.getID(),
          "Event bus not available, impossible to trigger a folder addition event for the user library."), StatusManager.BLOCK);
    }
  }
}

@Override
public void run() {
  PaletteEntry entry = (PaletteEntry) selectedNode.getModel();
  String modelName = entry.getLabel();
  String modelClass = entry.getDescription();
  String elementType = "CompositeActor";

  Map<String, String> properties = new HashMap<>();
  properties.put("displayName", modelName);
  properties.put("class", modelClass);
  properties.put("type", elementType);
  String parentTreePath = selectedNode.getParentTreePath('.');
  properties.put("libraryName", parentTreePath);

  Event event = new Event(LibraryManager.DELETE_EVENT_TOPIC, properties);
  try {
    // Sending events is nice to decouple UI handling from the underlying library management,
    // but we don't get any indication about success/failure.
    // So we may need to replace this by direct method calls.
    TriqEditorPlugin.getDefault().getEventAdminService().sendEvent(event);
    // The palette's model consists of 2 layers : palette entry editparts that have palette entries as model.
    // And way down there's still the Ptolemy UserLibrary as well.
    // Getting all models synchronized via listeners would be the cleanest, but couldn't get it to work.
    // (org.eclipse.gef.editparts.AbstractEditPart.refreshChildren() always caused errors in reorderChild()
    // because of a null parent somewhere. Too complex for me to understand...)
    // So we do all the deletes ourselves in here...
    ((PaletteTreeNodeEditPart) selectedNode.getParent()).removeChild(selectedNode);
    PaletteContainer container = entry.getParent();
    if (container != null) {
      container.remove(entry);
    }
    getTreeViewer().refresh(selectedNode.getParent());
  } catch (NullPointerException e) {
    StatusManager.getManager().handle(
        new Status(IStatus.ERROR, TriqEditorPlugin.getID(), "Event bus not available, impossible to trigger a delete event for the user library."),
        StatusManager.BLOCK);
  }
}

/**
 * checks if the given entry is a PaletteEntry and is a (deep) child of this user library node.
 * 
 * @param entry
 * @return true if the given entry is in this user library subtree
 */
public boolean isMember(Object entry) {
  if (!(entry instanceof PaletteEntry)) {
    return false;
  } else {
    PaletteEntry pe = (PaletteEntry) entry;
    boolean result = false;
    PaletteContainer parent = pe.getParent();
    while (!result && parent != null) {
      result = (this == parent);
      parent = parent.getParent();
    }
    return result;
  }
}

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);
}

private static void getEntries4Key(PaletteDrawer drawer, List<String> ignore, String id,
        Map<String, List<PaletteEntry>> map) {
    List<PaletteEntry> plist = map.get(id);
    if (plist != null)
        for (PaletteEntry entry : plist) {
            if (ignore != null && ignore.contains(entry.getType()))
                continue;
            drawer.add(entry);
        }
}

/**
 * @see org.eclipse.gef.editparts.AbstractGraphicalEditPart#activate()
 */
public void activate() {
    super.activate();
    PaletteEntry model = (PaletteEntry) getModel();
    model.addPropertyChangeListener(this);
    traverseChildren(model, true);
}

/**
 * @see org.eclipse.gef.editparts.AbstractGraphicalEditPart#deactivate()
 */
public void deactivate() {
    PaletteEntry model = (PaletteEntry) getModel();
    model.removePropertyChangeListener(this);
    traverseChildren(model, false);
    if (image != null) {
        image.dispose();
        image = null;
    }
    super.deactivate();
}

/**
 * @see org.eclipse.gef.editparts.AbstractEditPart#getModelChildren()
 */
public List getModelChildren() {
    List modelChildren;
    if (getModel() instanceof PaletteContainer)
        modelChildren = new ArrayList(
                ((PaletteContainer) getModel()).getChildren());
    else
        return Collections.EMPTY_LIST;

    PaletteEntry prevVisibleEntry = null;
    for (Iterator iter = modelChildren.iterator(); iter.hasNext();) {
        PaletteEntry entry = (PaletteEntry) iter.next();
        if (!entry.isVisible())
            // not visible
            iter.remove();
        else if (entry instanceof PaletteSeparator
                && prevVisibleEntry == null)
            // first visible item in a group is a separator, don't need it
            iter.remove();
        else if (entry instanceof PaletteSeparator
                && prevVisibleEntry instanceof PaletteSeparator)
            // previous visible entry was a separator, don't need it
            iter.remove();
        else
            prevVisibleEntry = entry;
    }
    // check to see if last visible entry was a separator, and thus should
    // be hidden
    if (prevVisibleEntry instanceof PaletteSeparator)
        modelChildren.remove(prevVisibleEntry);

    return modelChildren;
}

/**
 * @see java.beans.PropertyChangeListener#propertyChange(PropertyChangeEvent)
 */
public void propertyChange(PropertyChangeEvent evt) {
    String property = evt.getPropertyName();
    if (property.equals(PaletteContainer.PROPERTY_CHILDREN)) {
        traverseChildren((List) evt.getOldValue(), false);
        refreshChildren();
        traverseChildren((List) evt.getNewValue(), true);
    } else if (property.equals(PaletteEntry.PROPERTY_LABEL)
            || property.equals(PaletteEntry.PROPERTY_SMALL_ICON)
            || property.equals(PaletteEntry.PROPERTY_LARGE_ICON)
            || property.equals(PaletteEntry.PROPERTY_DESCRIPTION))
        refreshVisuals();
}

private void traverseChildren(List children, boolean add) {
    for (Iterator iter = children.iterator(); iter.hasNext();) {
        PaletteEntry entry = (PaletteEntry) iter.next();
        if (add) {
            entry.addPropertyChangeListener(childListener);
        } else {
            entry.removePropertyChangeListener(childListener);
        }
    }
}

/**
 * Creates the Text where the name of the entry is to be displayed.
 * 
 * @param panel
 *            The Composite in which the Text is to be created
 * @return Text - The newly created Text
 */
protected Text createNameText(Composite panel) {
    Text name = createText(panel, SWT.SINGLE | SWT.BORDER, entry.getLabel());
    if (getPermission() >= PaletteEntry.PERMISSION_LIMITED_MODIFICATION) {
        name.addModifyListener(new ModifyListener() {
            public void modifyText(ModifyEvent e) {
                handleNameChanged(((Text) e.getSource()).getText());
            }
        });
    }
    name.setVisible(true);
    return name;
}