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

/**
 * This method saves the various settings in this dialog, so that they can
 * be restored later on if "Cancel" is pressed.
 * 
 * @see #restoreSettings()
 */
protected void cacheSettings() {
    settings.put(CACHE_LAYOUT, new Integer(prefs.getLayoutSetting()));
    settings.put(CACHE_COLLAPSE,
            new Integer(prefs.getAutoCollapseSetting()));
    settings.put(CACHE_FONT, prefs.getFontData());
    settings.put(
            CACHE_DETAILS_ICON_SIZE,
            new Boolean(prefs
                    .useLargeIcons(PaletteViewerPreferences.LAYOUT_DETAILS)));
    settings.put(
            CACHE_ICONS_ICON_SIZE,
            new Boolean(prefs
                    .useLargeIcons(PaletteViewerPreferences.LAYOUT_ICONS)));
    settings.put(
            CACHE_COLUMNS_ICON_SIZE,
            new Boolean(prefs
                    .useLargeIcons(PaletteViewerPreferences.LAYOUT_COLUMNS)));
    settings.put(
            CACHE_LIST_ICON_SIZE,
            new Boolean(prefs
                    .useLargeIcons(PaletteViewerPreferences.LAYOUT_LIST)));
}

/**
 * This method is called when any one of the "Layout" radio buttons is
 * clicked. It changes the setting in the
 * {@link org.eclipse.gef.ui.palette.PaletteViewerPreferences} object.
 * 
 * @param newSetting
 *            The flag for the new setting
 */
protected void handleLayoutSettingChanged(int newSetting) {
    prefs.setLayoutSetting(newSetting);
    switch (newSetting) {
    case PaletteViewerPreferences.LAYOUT_COLUMNS:
        showLayoutOptionsPage(columnsPanel);
        break;
    case PaletteViewerPreferences.LAYOUT_LIST:
        showLayoutOptionsPage(listPanel);
        break;
    case PaletteViewerPreferences.LAYOUT_ICONS:
        showLayoutOptionsPage(iconsPanel);
        break;
    case PaletteViewerPreferences.LAYOUT_DETAILS:
        showLayoutOptionsPage(detailsPanel);
        break;
    default:
        break;
    }
}

/**
 * Restores the cached settings, thus undoing any changes made since the
 * last caching of settings.
 * 
 * @see #cacheSettings()
 */
protected void restoreSettings() {
    prefs.setFontData((FontData) settings.get(CACHE_FONT));
    prefs.setAutoCollapseSetting(((Integer) settings.get(CACHE_COLLAPSE))
            .intValue());
    prefs.setLayoutSetting(((Integer) settings.get(CACHE_LAYOUT))
            .intValue());
    prefs.setUseLargeIcons(PaletteViewerPreferences.LAYOUT_DETAILS,
            ((Boolean) settings.get(CACHE_DETAILS_ICON_SIZE))
                    .booleanValue());
    prefs.setUseLargeIcons(PaletteViewerPreferences.LAYOUT_ICONS,
            ((Boolean) settings.get(CACHE_ICONS_ICON_SIZE)).booleanValue());
    prefs.setUseLargeIcons(PaletteViewerPreferences.LAYOUT_LIST,
            ((Boolean) settings.get(CACHE_LIST_ICON_SIZE)).booleanValue());
    prefs.setUseLargeIcons(PaletteViewerPreferences.LAYOUT_COLUMNS,
            ((Boolean) settings.get(CACHE_COLUMNS_ICON_SIZE))
                    .booleanValue());
}

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

private void handleExpandStateChanged() {
    if (isExpanded()) {
        if (expandablePane.getParent() != this) {
            add(expandablePane);

            if (layoutMode == PaletteViewerPreferences.LAYOUT_LIST
                    || layoutMode == PaletteViewerPreferences.LAYOUT_DETAILS) {
                headerFigure.add(pinFigure);
            } else {
                add(pinFigure);
            }
        }
    } else {
        if (expandablePane.getParent() == this) {
            remove(expandablePane);
            pinFigure.getParent().remove(pinFigure);
        }
    }
}

/**
 * @see org.eclipse.gef.editparts.AbstractEditPart#refreshVisuals()
 */
protected void refreshVisuals() {
    getDrawerFigure().setToolTip(createToolTip());

    ImageDescriptor img = getDrawer().getSmallIcon();
    if (img == null && getDrawer().showDefaultIcon()) {
        img = InternalImages.DESC_FOLDER_OPEN;
    }
    setImageDescriptor(img);

    getDrawerFigure().setTitle(getPaletteEntry().getLabel());
    getDrawerFigure().setLayoutMode(getLayoutSetting());

    boolean showPin = getPreferenceSource().getAutoCollapseSetting() == PaletteViewerPreferences.COLLAPSE_AS_NEEDED;
    getDrawerFigure().showPin(showPin);

    Color background = getDrawer().getDrawerType().equals(
            PaletteTemplateEntry.PALETTE_TYPE_TEMPLATE) ? PaletteColorUtil.WIDGET_LIST_BACKGROUND
            : null;
    getDrawerFigure().getScrollpane().setBackgroundColor(background);
}

private void updateFont(int layout) {
    boolean layoutChanged = (layoutMode != layout);
    boolean fontChanged = (cachedFont == null || cachedFont != getFont());

    cachedFont = getFont();
    if (layoutChanged || fontChanged) {
        if (boldFont != null) {
            FONTCACHE.checkIn(boldFont);
            boldFont = null;
        }
        if (layout == PaletteViewerPreferences.LAYOUT_DETAILS
                && cachedFont != null)
            boldFont = FONTCACHE.checkOut(cachedFont);
        nameText.setFont(boldFont);
    }
}

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

static Rectangle getSelectionRectangle(int layoutMode,
        DetailedLabelFigure labelFigure) {
    Rectangle rect = Rectangle.SINGLETON;
    rect.setBounds(labelFigure.getBounds());
    if (layoutMode == PaletteViewerPreferences.LAYOUT_LIST
            || layoutMode == PaletteViewerPreferences.LAYOUT_DETAILS) {

        rect.x += PinnablePaletteStackFigure.ARROW_WIDTH;
        rect.width -= PinnablePaletteStackFigure.ARROW_WIDTH;
        int newWidth = labelFigure.getPreferredSize().width + 17;
        if (newWidth < rect.width) {
            rect.width = newWidth;
        }
        rect.crop(LIST_HIGHLIGHT_INSETS);
    } else {
        rect.width -= PinnablePaletteStackFigure.ARROW_WIDTH;
        rect.crop(ICON_HIGHLIGHT_INSETS);
    }
    return rect;
}

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

/**
 * This method will be invoked whenever any <code>Button</code> created
 * using {@link #createButton(Composite, int, String, int, ImageDescriptor)}
 * or {@link Dialog#createButton(Composite, int, String, boolean)} is
 * selected.
 * 
 * @see Dialog#buttonPressed(int)
 */
protected void buttonPressed(int buttonId) {
    Button b = getButton(buttonId);

    if (FONT_CHANGE_ID == buttonId) {
        handleChangeFontPressed();
    } else if (COLLAPSE_ALWAYS_ID == buttonId) {
        handleAutoCollapseSettingChanged(PaletteViewerPreferences.COLLAPSE_ALWAYS);
    } else if (COLLAPSE_NEVER_ID == buttonId) {
        handleAutoCollapseSettingChanged(PaletteViewerPreferences.COLLAPSE_NEVER);
    } else if (COLLAPSE_NEEDED_ID == buttonId) {
        handleAutoCollapseSettingChanged(PaletteViewerPreferences.COLLAPSE_AS_NEEDED);
    } else if (LAYOUT_COLUMNS_VIEW_ID == buttonId) {
        handleLayoutSettingChanged(PaletteViewerPreferences.LAYOUT_COLUMNS);
    } else if (LAYOUT_ICONS_VIEW_ID == buttonId) {
        handleLayoutSettingChanged(PaletteViewerPreferences.LAYOUT_ICONS);
    } else if (LAYOUT_LIST_VIEW_ID == buttonId) {
        handleLayoutSettingChanged(PaletteViewerPreferences.LAYOUT_LIST);
    } else if (LAYOUT_DETAILS_VIEW_ID == buttonId) {
        handleLayoutSettingChanged(PaletteViewerPreferences.LAYOUT_DETAILS);
    } else if (LAYOUT_DETAILS_ICON_SIZE_ID == buttonId) {
        handleIconSizeChanged(b.getSelection());
    } else if (LAYOUT_COLUMNS_ICON_SIZE_ID == buttonId) {
        handleIconSizeChanged(b.getSelection());
    } else if (LAYOUT_ICONS_ICON_SIZE_ID == buttonId) {
        handleIconSizeChanged(b.getSelection());
    } else if (LAYOUT_LIST_ICON_SIZE_ID == buttonId) {
        handleIconSizeChanged(b.getSelection());
    } else if (DEFAULT_FONT_ID == buttonId) {
        handleDefaultFontRequested();
    } else {
        super.buttonPressed(buttonId);
    }
}

/**
 * Creates and initializes (i.e. loads the current settings from
 * PaletteViewerPreferences) the options for details layout.
 * 
 * @param parent
 *            the parent composite
 * @return the newly created Control
 */
protected Control createDetailsOptions(Composite parent) {
    Control contents = createOptionsPage(parent,
            PaletteMessages.SETTINGS_OPTIONS_DETAILS,
            LAYOUT_DETAILS_ICON_SIZE_ID);
    getButton(LAYOUT_DETAILS_ICON_SIZE_ID).setSelection(
            prefs.useLargeIcons(PaletteViewerPreferences.LAYOUT_DETAILS));
    return contents;
}

/**
 * Creates and initializes (i.e. loads the current settings from
 * PaletteViewerPreferences) the options for icons layout.
 * 
 * @param parent
 *            the parent composite
 * @return the newly created Control
 */
protected Control createIconsOnlyOptions(Composite parent) {
    Control contents = createOptionsPage(parent,
            PaletteMessages.SETTINGS_OPTIONS_ICONS_ONLY,
            LAYOUT_ICONS_ICON_SIZE_ID);
    getButton(LAYOUT_ICONS_ICON_SIZE_ID).setSelection(
            prefs.useLargeIcons(PaletteViewerPreferences.LAYOUT_ICONS));
    return contents;
}

/**
 * @see org.eclipse.gef.ui.palette.editparts.PaletteEditPart#getToolTipText()
 */
protected String getToolTipText() {
    String result = null;
    if (getLayoutSetting() != PaletteViewerPreferences.LAYOUT_DETAILS) {
        result = super.getToolTipText();
    }
    return result;
}

/**
 * @see org.eclipse.gef.ui.palette.editparts.PaletteEditPart#getToolTipText()
 */
protected String getToolTipText() {
    String result = null;
    if (getLayoutSetting() != PaletteViewerPreferences.LAYOUT_DETAILS) {
        result = super.getToolTipText();
    }
    return result;
}

private void initializePaletteViewerPreferences(IPreferenceStore store)
{
    //This should be done just once.
    if(!store.getBoolean(PREFERENCE_PALETTE_VIEWER_PREFS_INIT)) {
        String[] properties = {
                PaletteViewerPreferences.PREFERENCE_LAYOUT,
                PaletteViewerPreferences.PREFERENCE_AUTO_COLLAPSE,
                PaletteViewerPreferences.PREFERENCE_COLUMNS_ICON_SIZE,
                PaletteViewerPreferences.PREFERENCE_LIST_ICON_SIZE,
                PaletteViewerPreferences.PREFERENCE_ICONS_ICON_SIZE,
                PaletteViewerPreferences.PREFERENCE_DETAILS_ICON_SIZE,
                PaletteViewerPreferences.PREFERENCE_FONT
            };
        Bundle bundle = Platform.getBundle(GEF_BUNDLE_ID);
        if(bundle != null) {
            IPreferencesService preferencesService = Platform.getPreferencesService();
            IScopeContext[] contexts = {new InstanceScope()};
            for (int i = 0; i < properties.length; i++) {
                if(!store.contains(properties[i])) {
                    String val = preferencesService.getString(GEF_BUNDLE_ID, properties[i], "", contexts); //$NON-NLS-1$
                    if(!Common.isEmpty(val)) {
                        store.setValue(properties[i], val);
                    }
                }
            }
        }
        store.setValue(PREFERENCE_PALETTE_VIEWER_PREFS_INIT,true);
    }
}

/**
 * Creates and initializes (i.e., loads the current value from the
 * PaletteViewerPreferences) the part of the dialog where the options to
 * close drawers will be displayed.
 * 
 * @param container
 *            The parent composite
 * @return The newly created Control which has the drawer collapse options
 */
protected Control createDrawerCollapseOptions(Composite container) {
    Composite composite = new Composite(container, SWT.NONE);
    composite.setFont(container.getFont());
    GridLayout layout = new GridLayout(1, false);
    composite.setLayout(layout);

    Label label = new Label(composite, SWT.NONE);
    label.setFont(composite.getFont());
    label.setText(PaletteMessages.COLLAPSE_OPTIONS_TITLE);
    GridData data = new GridData();
    label.setLayoutData(data);

    Button b = createButton(composite, COLLAPSE_ALWAYS_ID,
            PaletteMessages.COLLAPSE_ALWAYS_LABEL, SWT.RADIO, null);
    ((GridData) b.getLayoutData()).horizontalIndent = 5;

    b = createButton(composite, COLLAPSE_NEEDED_ID,
            PaletteMessages.COLLAPSE_AS_NEEDED_LABEL, SWT.RADIO, null);
    ((GridData) b.getLayoutData()).horizontalIndent = 5;

    b = createButton(composite, COLLAPSE_NEVER_ID,
            PaletteMessages.COLLAPSE_NEVER_LABEL, SWT.RADIO, null);
    ((GridData) b.getLayoutData()).horizontalIndent = 5;

    // Load auto - collapse settings
    b = null;
    int collapse = prefs.getAutoCollapseSetting();
    switch (collapse) {
    case PaletteViewerPreferences.COLLAPSE_ALWAYS:
        b = getButton(COLLAPSE_ALWAYS_ID);
        break;
    case PaletteViewerPreferences.COLLAPSE_AS_NEEDED:
        b = getButton(COLLAPSE_NEEDED_ID);
        break;
    case PaletteViewerPreferences.COLLAPSE_NEVER:
        b = getButton(COLLAPSE_NEVER_ID);
    }
    b.setSelection(true);

    return composite;
}

/**
 * Creates and initializes (i.e. loads the current settings from
 * PaletteViewerPreferences) the options for columns layout.
 * 
 * @param parent
 *            the parent composite
 * @return the newly created Control
 */
protected Control createColumnsOptions(Composite parent) {
    Composite contents = (Composite) createOptionsPage(parent,
            PaletteMessages.SETTINGS_OPTIONS_COLUMNS,
            LAYOUT_COLUMNS_ICON_SIZE_ID);
    getButton(LAYOUT_COLUMNS_ICON_SIZE_ID).setSelection(
            prefs.useLargeIcons(PaletteViewerPreferences.LAYOUT_COLUMNS));

    // final Button button = createButton(contents, -1,
    // PaletteMessages.SETTINGS_LAYOUT_COLUMNS_OVERRIDE_WIDTH, SWT.CHECK,
    // null);
    // ((GridData)button.getLayoutData()).horizontalSpan = 2;
    //
    // Composite container = new Composite(contents, SWT.NONE);
    // container.setFont(contents.getFont());
    // GridLayout layout = new GridLayout(2, false);
    // container.setLayout(layout);
    // GridData data = new GridData(GridData.FILL_HORIZONTAL |
    // GridData.VERTICAL_ALIGN_FILL);
    // data.horizontalSpan = 2;
    // container.setLayoutData(data);
    //
    // final Label label = new Label(container, SWT.NONE);
    // label.setFont(container.getFont());
    // label.setText(PaletteMessages.SETTINGS_LAYOUT_COLUMNS_WIDTH);
    // data = new GridData(GridData.HORIZONTAL_ALIGN_BEGINNING
    // | GridData.VERTICAL_ALIGN_BEGINNING);
    // label.setLayoutData(data);
    // label.setEnabled(false);
    //
    // final Text box = new Text(container, SWT.SINGLE | SWT.BORDER);
    // box.setFont(container.getFont());
    // // box.setText("30");
    // box.setEnabled(false);
    // data = new GridData(GridData.FILL_HORIZONTAL |
    // GridData.VERTICAL_ALIGN_BEGINNING);
    // data.widthHint = 50;
    // box.setLayoutData(data);
    //
    // button.addSelectionListener(new SelectionListener() {
    // public void widgetSelected(SelectionEvent e) {
    // label.setEnabled(!label.isEnabled());
    // box.setEnabled(!box.isEnabled());
    // }
    // public void widgetDefaultSelected(SelectionEvent e) {
    // }
    // });

    return contents;
}

/**
 * Creates the part of the dialog that displays the various options for the
 * selected layout.
 * 
 * @param parent
 *            the parent composite
 * @return the newly created Control
 */
protected Control createLayoutOptions(Composite parent) {
    Composite composite = new Composite(parent, SWT.NONE);
    composite.setFont(parent.getFont());
    GridLayout layout = new GridLayout(1, false);
    layout.marginWidth = 0;
    layout.marginHeight = 0;
    composite.setLayout(layout);

    Label label = new Label(composite, SWT.NONE);
    label.setFont(composite.getFont());
    label.setText(PaletteMessages.SETTINGS_LAYOUT_TITLE);
    GridData data = new GridData();
    label.setLayoutData(data);

    Button b = null;
    int[] modes = prefs.getSupportedLayoutModes();
    for (int i = 0; i < modes.length; i++) {
        switch (modes[i]) {
        case PaletteViewerPreferences.LAYOUT_COLUMNS:
            b = createButton(composite, LAYOUT_COLUMNS_VIEW_ID,
                    PaletteMessages.SETTINGS_COLUMNS_VIEW_LABEL, SWT.RADIO,
                    null);
            ((GridData) b.getLayoutData()).horizontalIndent = 5;
            break;
        case PaletteViewerPreferences.LAYOUT_LIST:
            b = createButton(composite, LAYOUT_LIST_VIEW_ID,
                    PaletteMessages.SETTINGS_LIST_VIEW_LABEL, SWT.RADIO,
                    null);
            ((GridData) b.getLayoutData()).horizontalIndent = 5;
            break;
        case PaletteViewerPreferences.LAYOUT_ICONS:
            b = createButton(composite, LAYOUT_ICONS_VIEW_ID,
                    PaletteMessages.SETTINGS_ICONS_VIEW_LABEL, SWT.RADIO,
                    null);
            ((GridData) b.getLayoutData()).horizontalIndent = 5;
            break;
        case PaletteViewerPreferences.LAYOUT_DETAILS:
            b = createButton(composite, LAYOUT_DETAILS_VIEW_ID,
                    PaletteMessages.SETTINGS_DETAILS_VIEW_LABEL, SWT.RADIO,
                    null);
            ((GridData) b.getLayoutData()).horizontalIndent = 5;
            break;
        }
    }

    // Load layout settings
    int layoutSetting = prefs.getLayoutSetting();
    switch (layoutSetting) {
    case PaletteViewerPreferences.LAYOUT_COLUMNS:
        b = getButton(LAYOUT_COLUMNS_VIEW_ID);
        break;
    case PaletteViewerPreferences.LAYOUT_ICONS:
        b = getButton(LAYOUT_ICONS_VIEW_ID);
        break;
    case PaletteViewerPreferences.LAYOUT_LIST:
        b = getButton(LAYOUT_LIST_VIEW_ID);
        break;
    case PaletteViewerPreferences.LAYOUT_DETAILS:
        b = getButton(LAYOUT_DETAILS_VIEW_ID);
        break;
    }
    b.setSelection(true);
    b.setFocus();

    return composite;
}

public void handleStateChanged(ChangeEvent event) {
    Clickable clickable = (Clickable) event.getSource();
    if (event.getPropertyName() == ButtonModel.MOUSEOVER_PROPERTY
            && getActiveFigure() instanceof ToolEntryToggle) {
        ((ToolEntryToggle) getActiveFigure())
                .setShowHoverFeedback(clickable.getModel()
                        .isMouseOver());
    }
    if (event.getPropertyName() == ButtonModel.SELECTED_PROPERTY) {

        Animation.markBegin();
        handleExpandStateChanged();
        Animation.run(150);

        // Now collapse other stacks when they are not pinned open or in
        // the
        // case of columns and icons layout mode (where only one stack
        // can
        // be expanded at a time for layout reasons).
        if (isExpanded()) {
            boolean collapseOtherStacks = (layoutMode == PaletteViewerPreferences.LAYOUT_COLUMNS || layoutMode == PaletteViewerPreferences.LAYOUT_ICONS);

            for (Iterator iterator = getParent().getChildren()
                    .iterator(); iterator.hasNext();) {
                Object childFigure = iterator.next();
                if (childFigure instanceof PinnablePaletteStackFigure
                        && childFigure != PinnablePaletteStackFigure.this) {

                    if (collapseOtherStacks
                            || (((PinnablePaletteStackFigure) childFigure)
                                    .isExpanded() && !((PinnablePaletteStackFigure) childFigure)
                                    .isPinnedOpen())) {

                        ((PinnablePaletteStackFigure) childFigure)
                                .setExpanded(false);
                    }
                }
            }
        }
    }
}

public void setLayoutMode(int newLayoutMode) {
    if (this.layoutMode == newLayoutMode) {
        return;
    }

    this.layoutMode = newLayoutMode;

    // Only one stack can be expanded in icons and layout mode, therefore
    // for
    // consistency let's always collapse stacks when changing the layout
    // modes.
    setExpanded(false);

    if (newLayoutMode == PaletteViewerPreferences.LAYOUT_LIST
            || newLayoutMode == PaletteViewerPreferences.LAYOUT_DETAILS) {

        headerFigure.setLayoutManager(new HeaderListLayout());

        expandablePane.setLayoutManager(new ToolbarLayout());
        expandablePane.setBorder(new MarginBorder(1, 0, 1, 0));
        setLayoutManager(new ToolbarLayout());

    } else {
        headerFigure.setLayoutManager(new HeaderIconLayout());
        if (activeToolFigure != null) {
            headerFigure.setConstraint(activeToolFigure,
                    BorderLayout.CENTER);
        }

        setLayoutManager(new PaletteStackIconLayout());

        // account for space used by pin figure
        expandablePane.setBorder(new MarginBorder(18, 0, 0, 0));

        if (layoutMode == PaletteViewerPreferences.LAYOUT_COLUMNS) {
            expandablePane.setLayoutManager(new ColumnsLayout());
        } else { // LAYOUT_ICONS
            FlowLayout fl = new FlowLayout();
            fl.setMinorSpacing(0);
            fl.setMajorSpacing(0);
            expandablePane.setLayoutManager(fl);
        }
    }
}

protected int getLayoutSetting() {
    return PaletteViewerPreferences.LAYOUT_ICONS;
}

/**
 * @param layoutMode
 *            the palette layout (any of the
 *            PaletteViewerPreferences.LAYOUT_XXXX options)
 */
public void setLayoutMode(int layoutMode) {
    updateFont(layoutMode);

    if (layoutMode == this.layoutMode)
        return;

    this.layoutMode = layoutMode;

    add(page);
    if (descText.getParent() == page)
        page.remove(descText);

    BorderLayout layout = (BorderLayout) getLayoutManager();
    if (layoutMode == PaletteViewerPreferences.LAYOUT_COLUMNS) {
        page.setHorizontalAligment(PositionConstants.CENTER);
        layout.setConstraint(image, BorderLayout.TOP);
        layout.setConstraint(page, BorderLayout.CENTER);
    } else if (layoutMode == PaletteViewerPreferences.LAYOUT_ICONS) {
        layout.setConstraint(image, BorderLayout.CENTER);
        remove(page);
    } else if (layoutMode == PaletteViewerPreferences.LAYOUT_LIST) {
        page.setHorizontalAligment(PositionConstants.LEFT);
        layout.setConstraint(image, BorderLayout.LEFT);
        layout.setConstraint(page, BorderLayout.CENTER);
    } else if (layoutMode == PaletteViewerPreferences.LAYOUT_DETAILS) {
        /*
         * Fix for Bug# 39130 Earlier, descText was only being added to the
         * page if the description was not an empty String. Now, it's always
         * added. This fixes the case mentioned in 39130. The undesirable
         * side-effect is that the descText will be added to the page even
         * when it's empty. However, that shouldn't affect anything because
         * the descText will be empty (even in the case where the
         * description is not empty, but is equal to the name -- see
         * setDescription()).
         */
        page.add(descText);
        page.setHorizontalAligment(PositionConstants.LEFT);
        layout.setConstraint(image, BorderLayout.LEFT);
        layout.setConstraint(page, BorderLayout.CENTER);
    }
}

/**
 * Constructor
 * 
 * @param parentShell
 *            The parent shell, or <code>null</code> to create a top - level
 *            shell
 * @param prefs
 *            The PaletteViewerPreferences object that can provide access to
 *            and allow modification of the palette's settings. It cannot be
 *            <code>null</code>.
 */
public PaletteSettingsDialog(Shell parentShell,
        PaletteViewerPreferences prefs) {
    super(parentShell);
    this.prefs = prefs;
    setShellStyle(getShellStyle() | SWT.RESIZE | SWT.MAX);
}

/**
 * Creates and initializes (i.e. loads the current settings from
 * PaletteViewerPreferences) the options for list layout.
 * 
 * @param parent
 *            the parent composite
 * @return the newly created Control
 */
protected Control createListOptions(Composite parent) {
    Control composite = createOptionsPage(parent,
            PaletteMessages.SETTINGS_OPTIONS_LIST, LAYOUT_LIST_ICON_SIZE_ID);
    getButton(LAYOUT_LIST_ICON_SIZE_ID).setSelection(
            prefs.useLargeIcons(PaletteViewerPreferences.LAYOUT_LIST));
    return composite;
}

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

/**
 * Determine if the name is needed in the tool tip.
 * 
 * @return <code>true</code> if the name is needed in the tool tip.
 * @since 3.2
 */
protected boolean nameNeededInToolTip() {
    return getLayoutSetting() == PaletteViewerPreferences.LAYOUT_ICONS;
}

/**
 * Constructor for a PaletteAnimator
 * 
 * @param prefs
 *            The palette PaletteViewerPreferencesPreferences
 */
public PaletteAnimator(PaletteViewerPreferences prefs) {
    this.prefs = prefs;
}