* Copyright (c) 2005, 2007 IBM Corporation and others.

* All rights reserved. This program and the accompanying materials

* are made available under the terms of the Eclipse Public License v1.0

* which accompanies this distribution, and is available at

* http://www.eclipse.org/legal/epl-v10.html

*

* Contributors:

*     IBM Corporation - initial API and implementation

*******************************************************************************/

* <p>

* A preference page that is capable of displaying and editing the bindings

* between commands and user input events. These are typically things like

* keyboard shortcuts.

* </p>

* <p>

* This preference page has four general types of methods. Create methods are

* called when the page is first made visible. They are responsible for creating

* all of the widgets, and laying them out within the preference page. Fill

* methods populate the contents of the widgets that contain collections of data

* from which items can be selected. The select methods respond to selection

* events from the user, such as a button press or a table selection. The update

* methods update the contents of various widgets based on the current state of

* the user interface. For example, the command name label will always try to

* match the current select in the binding table.

* </p>

*

* @since 3.2

*/

    IWorkbenchPreferencePage {

  private static boolean DEBUG = Policy.DEBUG_KEY_BINDINGS;

  private static final String TRACING_COMPONENT = "NewKeysPref"; //$NON-NLS-1$

  /**

   * @since 3.3

   *

   */

  private final class ResortColumn extends SelectionAdapter {

    private final BindingComparator comparator;

    private final TreeColumn treeColumn;

    private final Tree tree;

    private final int column;

    /**

     * @param comparator

     * @param commandNameColumn

     * @param tree

     */

    private ResortColumn(BindingComparator comparator,

        TreeColumn treeColumn, Tree tree, int column) {

      this.comparator = comparator;

      this.treeColumn = treeColumn;

      this.tree = tree;

      this.column = column;

    }

    public void widgetSelected(SelectionEvent e) {

      if (comparator.getSortColumn() == column) {

        comparator.setAscending(!comparator.isAscending());

      }

      tree.setSortColumn(treeColumn);

      comparator.setSortColumn(column);

      tree.setSortDirection(comparator.isAscending() ? SWT.UP : SWT.DOWN);

      try {

        filteredTree.getViewer().getTree().setRedraw(false);

        filteredTree.getViewer().refresh();

      } finally {

        filteredTree.getViewer().getTree().setRedraw(true);

      }

    }

  }

  private class ObservableSetContentProvider implements ITreeContentProvider {

    private class KnownElementsSet extends ObservableSet {

      KnownElementsSet(Set wrappedSet) {

        super(SWTObservables.getRealm(Display.getDefault()),

            wrappedSet, Object.class);

      }

      void doFireDiff(Set added, Set removed) {

        fireSetChange(Diffs.createSetDiff(added, removed));

      }

      void doFireStale(boolean isStale) {

        if (isStale) {

          fireStale();

        } else {

          fireChange();

        }

      }

    }

    private IObservableSet readableSet;

    private Viewer viewer;

    /**

     * This readableSet returns the same elements as the input readableSet.

     * However, it only fires events AFTER the elements have been added or

     * removed from the viewer.

     */

    private KnownElementsSet knownElements;

    private ISetChangeListener listener = new ISetChangeListener() {

      public void handleSetChange(SetChangeEvent event) {

        boolean wasStale = knownElements.isStale();

        if (isDisposed()) {

          return;

        }

        doDiff(event.diff.getAdditions(), event.diff.getRemovals(),

            true);

        if (!wasStale && event.getObservableSet().isStale()) {

          knownElements.doFireStale(true);

        }

      }

    };

    private IStaleListener staleListener = new IStaleListener() {

      public void handleStale(StaleEvent event) {

        knownElements.doFireStale(event.getObservable().isStale());

      }

    };

    /**

     *

     */

    public ObservableSetContentProvider() {

      readableSet = new ObservableSet(SWTObservables.getRealm(Display

          .getDefault()), Collections.EMPTY_SET, Object.class) {

      };

      knownElements = new KnownElementsSet(readableSet);

    }

    public void dispose() {

      setInput(null);

    }

    private void doDiff(Set added, Set removed, boolean updateViewer) {

      knownElements.doFireDiff(added, Collections.EMPTY_SET);

      if (updateViewer) {

        if (added.size() > 20 || removed.size() > 20) {

          viewer.refresh();

        } else {

          Object[] toAdd = added.toArray();

          if (viewer instanceof TreeViewer) {

            TreeViewer tv = (TreeViewer) viewer;

            tv.add(model, toAdd);

          } else if (viewer instanceof AbstractListViewer) {

            AbstractListViewer lv = (AbstractListViewer) viewer;

            lv.add(toAdd);

          }

          Object[] toRemove = removed.toArray();

          if (viewer instanceof TreeViewer) {

            TreeViewer tv = (TreeViewer) viewer;

            tv.remove(toRemove);

          } else if (viewer instanceof AbstractListViewer) {

            AbstractListViewer lv = (AbstractListViewer) viewer;

            lv.remove(toRemove);

          }

        }

      }

      knownElements.doFireDiff(Collections.EMPTY_SET, removed);

    }

    public Object[] getElements(Object inputElement) {

      return readableSet.toArray();

    }

    /**

     * Returns the readableSet of elements known to this content provider.

     * Items are added to this readableSet before being added to the viewer,

     * and they are removed after being removed from the viewer. The

     * readableSet is always updated after the viewer. This is intended for

     * use by label providers, as it will always return the items that need

     * labels.

     *

     * @return readableSet of items that will need labels

     */

    public IObservableSet getKnownElements() {

      return knownElements;

    }

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

      this.viewer = viewer;

      if (newInput != null && !(newInput instanceof IObservableSet)) {

        throw new IllegalArgumentException(

            "This content provider only works with input of type IReadableSet"); //$NON-NLS-1$

      }

      setInput((IObservableSet) newInput);

    }

    private boolean isDisposed() {

      return viewer.getControl() == null

          || viewer.getControl().isDisposed();

    }

    private void setInput(IObservableSet newSet) {

      boolean updateViewer = true;

      if (newSet == null) {

        newSet = new ObservableSet(SWTObservables.getRealm(Display

            .getDefault()), Collections.EMPTY_SET, Object.class) {

        };

        // don't update the viewer - its input is null

        updateViewer = false;

      }

      boolean wasStale = false;

      if (readableSet != null) {

        wasStale = readableSet.isStale();

        readableSet.removeSetChangeListener(listener);

        readableSet.removeStaleListener(staleListener);

      }

      HashSet additions = new HashSet();

      HashSet removals = new HashSet();

      additions.addAll(newSet);

      additions.removeAll(readableSet);

      removals.addAll(readableSet);

      removals.removeAll(newSet);

      readableSet = newSet;

      doDiff(additions, removals, updateViewer);

      if (readableSet != null) {

        readableSet.addSetChangeListener(listener);

        readableSet.addStaleListener(staleListener);

      }

      boolean isStale = (readableSet != null && readableSet.isStale());

      if (isStale != wasStale) {

        knownElements.doFireStale(isStale);

      }

    }

    /*

     * (non-Javadoc)

     *

     * @see org.eclipse.jface.viewers.ITreeContentProvider#getChildren(java.lang.Object)

     */

    public Object[] getChildren(Object parentElement) {

      // TODO Auto-generated method stub

      return null;

    }

    /*

     * (non-Javadoc)

     *

     * @see org.eclipse.jface.viewers.ITreeContentProvider#getParent(java.lang.Object)

     */

    public Object getParent(Object element) {

      // TODO Auto-generated method stub

      return null;

    }

    /*

     * (non-Javadoc)

     *

     * @see org.eclipse.jface.viewers.ITreeContentProvider#hasChildren(java.lang.Object)

     */

    public boolean hasChildren(Object element) {

      // TODO Auto-generated method stub

      return false;

    }

  }

  /**

   * A FilteredTree that provides a combo which is used to organize and

   * display elements in the tree according to the selected criteria.

   *

   */

  protected class CategoryFilterTree extends FilteredTree {

    private CategoryPatternFilter filter;

    /**

     * Constructor for PatternFilteredTree.

     *

     * @param parent

     * @param treeStyle

     * @param filter

     */

    protected CategoryFilterTree(Composite parent, int treeStyle,

        CategoryPatternFilter filter) {

      super(parent, treeStyle, filter);

      this.filter = filter;

    }

    public void filterCategories(boolean b) {

      filter.filterCategories(b);

      textChanged();

    }

    public boolean isFilteringCategories() {

      return filter.isFilteringCategories();

    }

  }

  /**

   * A label provider that simply extracts the command name and the formatted

   * trigger sequence from a given binding, and matches them to the correct

   * column.

   */

  private final class BindingLabelProvider extends LabelProvider implements

      ITableLabelProvider {

    /**

     * The index of the column containing the command name.

     */

    private static final int COLUMN_COMMAND = 0;

    /**

     * The index of the column containing the trigger sequence.

     */

    private static final int COLUMN_TRIGGER_SEQUENCE = 1;

    /**

     * The index of the column containing the trigger sequence.

     */

    private static final int COLUMN_WHEN = 2;

    /**

     * The index of the column containing the Category.

     */

    private static final int COLUMN_CATEGORY = 3;

    /**

     * The index of the column with the image for User binding

     */

    private static final int COLUMN_USER = 4;

    /**

     * A resource manager for this preference page.

     */

    private final LocalResourceManager localResourceManager = new LocalResourceManager(

        JFaceResources.getResources());

    public final void dispose() {

      super.dispose();

      localResourceManager.dispose();

    }

    public final Image getColumnImage(final Object element,

        final int columnIndex) {

      final Object value = element;

      if (value instanceof Binding) {

        switch (columnIndex) {

        case COLUMN_COMMAND:

          final ParameterizedCommand parameterizedCommand = ((Binding) value)

              .getParameterizedCommand();

          if (parameterizedCommand != null) {

            final String commandId = parameterizedCommand.getId();

            final ImageDescriptor imageDescriptor = commandImageService

                .getImageDescriptor(commandId);

            if (imageDescriptor == null) {

              return null;

            }

            try {

              return localResourceManager

                  .createImage(imageDescriptor);

            } catch (final DeviceResourceException e) {

              final String message = "Problem retrieving image for a command '" //$NON-NLS-1$

                  + commandId + '\'';

              final IStatus status = new Status(IStatus.ERROR,

                  WorkbenchPlugin.PI_WORKBENCH, 0, message, e);

              WorkbenchPlugin.log(message, status);

            }

          }

          return null;

        case COLUMN_USER:

          if (((Binding) value).getType() == Binding.USER)

            return ImageFactory.getImage("change"); //$NON-NLS-1$

          return ImageFactory.getImage("blank"); //$NON-NLS-1$

        }

      } else if (value instanceof ParameterizedCommand) {

        switch (columnIndex) {

        case COLUMN_COMMAND:

          final ParameterizedCommand parameterizedCommand = (ParameterizedCommand) value;

          final String commandId = parameterizedCommand.getId();

          final ImageDescriptor imageDescriptor = commandImageService

              .getImageDescriptor(commandId);

          if (imageDescriptor == null) {

            return null;

          }

          try {

            return localResourceManager

                .createImage(imageDescriptor);

          } catch (final DeviceResourceException e) {

            final String message = "Problem retrieving image for a command '" //$NON-NLS-1$

                + commandId + '\'';

            final IStatus status = new Status(IStatus.ERROR,

                WorkbenchPlugin.PI_WORKBENCH, 0, message, e);

            WorkbenchPlugin.log(message, status);

          }

          return null;

        case COLUMN_USER:

          return ImageFactory.getImage("blank"); //$NON-NLS-1$

        }

      } else if ((value instanceof Category) || (value instanceof String)) {

        switch (columnIndex) {

        case COLUMN_COMMAND:

          final URL url = BundleUtility.find(PlatformUI.PLUGIN_ID,

              ICON_GROUP_OF_BINDINGS);

          final ImageDescriptor imageDescriptor = ImageDescriptor

              .createFromURL(url);

          try {

            return localResourceManager

                .createImage(imageDescriptor);

          } catch (final DeviceResourceException e) {

            final String message = "Problem retrieving image for groups of bindings: '" //$NON-NLS-1$

                + ICON_GROUP_OF_BINDINGS + '\'';

            final IStatus status = new Status(IStatus.ERROR,

                WorkbenchPlugin.PI_WORKBENCH, 0, message, e);

            WorkbenchPlugin.log(message, status);

          }

        }

      }

      return null;

    }

    private boolean checkConflict(Binding binding) {

      Collection matches = (Collection) localChangeManager

          .getActiveBindingsDisregardingContext().get(

              binding.getTriggerSequence());

      if (matches != null) {

        Iterator i = matches.iterator();

        while (i.hasNext()) {

          Binding b = (Binding) i.next();

          if (binding != b

              && b.getContextId().equals(binding.getContextId())

              && b.getSchemeId().equals(binding.getSchemeId())) {

            return true;

          }

        }

      }

      return false;

    }

    public final String getColumnText(final Object element,

        final int columnIndex) {

      final Object value = element;

      if (value instanceof Binding) {

        final Binding binding = (Binding) value;

        switch (columnIndex) {

        case COLUMN_COMMAND:

          try {

            return binding.getParameterizedCommand().getName();

          } catch (final NotDefinedException e) {

            return NewKeysPreferenceMessages.Undefined_Command;

          }

        case COLUMN_TRIGGER_SEQUENCE:

          if (checkConflict(binding)) {

            return "*" + binding.getTriggerSequence().format(); //$NON-NLS-1$

          }

          return binding.getTriggerSequence().format();

        case COLUMN_WHEN:

          try {

            return contextService

                .getContext(binding.getContextId()).getName();

          } catch (NotDefinedException e1) {

            return NewKeysPreferenceMessages.Undefined_Context;

          }

        case COLUMN_CATEGORY:

          try {

            return binding.getParameterizedCommand().getCommand()

                .getCategory().getName();

          } catch (NotDefinedException e) {

            return NewKeysPreferenceMessages.Unavailable_Category;

          }

        default:

          return null;

        }

      } else if (value instanceof Category) {

        if (columnIndex == COLUMN_COMMAND) {

          try {

            return ((Category) value).getName();

          } catch (final NotDefinedException e) {

            return NewKeysPreferenceMessages.Unavailable_Category;

          }

        }

        return null;

      } else if (value instanceof String) {

        // This is a context.

        if (columnIndex == COLUMN_COMMAND) {

          try {

            return contextService.getContext((String) value)

                .getName();

          } catch (final NotDefinedException e) {

            return NewKeysPreferenceMessages.Undefined_Context;

          }

        }

        return null;

      } else if (value instanceof ParameterizedCommand) {

        if (columnIndex == COLUMN_COMMAND) {

          try {

            return ((ParameterizedCommand) value).getName();

          } catch (final NotDefinedException e) {

            return NewKeysPreferenceMessages.Undefined_Command;

          }

        }

        if (columnIndex == COLUMN_TRIGGER_SEQUENCE)

          return ""; //$NON-NLS-1$

        if (columnIndex == COLUMN_WHEN)

          return ""; //$NON-NLS-1$

        if (columnIndex == COLUMN_CATEGORY) {

          try {

            return ((ParameterizedCommand) value).getCommand()

                .getCategory().getName();

          } catch (NotDefinedException e) {

            return NewKeysPreferenceMessages.Unavailable_Category;

          }

        }

        return null;

      }

      return null;

    }

    /*

     * (non-Javadoc)

     *

     * @see org.eclipse.jface.viewers.LabelProvider#getText(java.lang.Object)

     */

    public String getText(Object element) {

      String rc = getColumnText(element, 0);

      if (rc == null) {

        super.getText(element);

      }

      StringBuffer buf = new StringBuffer(rc);

      for (int i = 1; i < COLUMN_USER; i++) {

        String text = getColumnText(element, i);

        if (text != null) {

          buf.append(' ');

          buf.append(text);

        }

      }

      return buf.toString();

    }

  }

   * Sorts the bindings in the filtered tree based on the current grouping.

   */

  private final class BindingComparator extends ViewerComparator {

    private int sortColumn = 0;

    private int lastSortColumn = 0;

    private boolean ascending = true;

    public final int category(final Object element) {

      switch (grouping) {

      case GROUPING_CATEGORY:

        // TODO This has to be done with something other than the hash.

        try {

          final ParameterizedCommand command = (element instanceof ParameterizedCommand) ? (ParameterizedCommand) element

              : ((Binding) element).getParameterizedCommand();

          return command.getCommand().getCategory().hashCode();

        } catch (final NotDefinedException e) {

          return 0;

        }

      case GROUPING_CONTEXT:

        // TODO This has to be done with something other than the hash.

        if (element instanceof Binding) {

          return ((Binding) element).getContextId().hashCode();

        }

      case GROUPING_NONE:

      default:

        return 0;

      }

    }

    public final int compare(final Viewer viewer, final Object a,

        final Object b) {

      int result = compareColumn(viewer, a, b, sortColumn);

      if (result == 0 && sortColumn != lastSortColumn) {

        result = compareColumn(viewer, a, b, lastSortColumn);

      }

      return ascending ? result : (-1) * result;

    }

   

    private int compareColumn(final Viewer viewer, final Object a, final Object b,

        final int columnNumber) {

      if (columnNumber == BindingLabelProvider.COLUMN_USER) {

        return sortUser(viewer, a, b);

      }

      IBaseLabelProvider baseLabel = ((TreeViewer)viewer).getLabelProvider();

      if (baseLabel instanceof ITableLabelProvider) {

        ITableLabelProvider tableProvider = (ITableLabelProvider) baseLabel;

        String e1p = tableProvider.getColumnText(a, columnNumber);

        String e2p = tableProvider.getColumnText(b, columnNumber);

        if (e1p != null && e2p != null) {

          return getComparator().compare(e1p, e2p);

        }

      }

      return 0;

    }

   

    private int sortUser(final Viewer viewer, final Object a, final Object b) {

      int typeA = (a instanceof Binding?((Binding)a).getType():Binding.SYSTEM);

      int typeB = (b instanceof Binding?((Binding)b).getType():Binding.SYSTEM);

      int result = typeA - typeB;

      return result;

    }

    /**

     * @return Returns the sortColumn.

     */

    public int getSortColumn() {

      return sortColumn;

    }

    /**

     * @param sortColumn

     *            The sortColumn to set.

     */

    public void setSortColumn(int sortColumn) {

      lastSortColumn = this.sortColumn;

      if (lastSortColumn != sortColumn) {

        ascending = true;

      }

      this.sortColumn = sortColumn;

    }

    /**

     * @return Returns the ascending.

     */

    public boolean isAscending() {

      return ascending;

    }

    /**

     * @param ascending

     *            The ascending to set.

     */

    public void setAscending(boolean ascending) {

      this.ascending = ascending;

    }

  }

  /**

   * The constant value for <code>grouping</code> when the bindings should

   * be grouped by category.

   */

  private static final int GROUPING_CATEGORY = 0;

  /**

   * The constant value for <code>grouping</code> when the bindings should

   * be grouped by context.

   */

  private static final int GROUPING_CONTEXT = 1;

  /**

   * The constant value for <code>grouping</code> when the bindings should

   * not be grouped (i.e., they should be displayed in a flat list).

   */

  private static final int GROUPING_NONE = 2;

  /**

   * The path at which the icon for "groups of bindings" is located.

   */

  private static final String ICON_GROUP_OF_BINDINGS = "$nl$/icons/full/obj16/keygroups_obj.gif"; //$NON-NLS-1$

  private static final String CONTEXT_ID_ACTION_SETS = "org.eclipse.ui.contexts.actionSet"; //$NON-NLS-1$

  private static final String CONTEXT_ID_INTERNAL = ".internal."; //$NON-NLS-1$