}

  /**
   * @deprecated use {@link #setEditorFactory(PropertyEditorFactory)}
   * @param registry
   */
  public void setEditorRegistry(PropertyEditorRegistry registry) {
    table.setEditorFactory(registry);
  }

  /**
   * @deprecated use {@link #getEditorFactory()}
   */
  public PropertyEditorRegistry getEditorRegistry() {
    return (PropertyEditorRegistry)table.getEditorFactory();
  }

  public void setRendererFactory(PropertyRendererFactory factory) {
    table.setRendererFactory(factory);
  }

  public PropertyRendererFactory getRendererFactory() {
    return table.getRendererFactory();
  }
  
  /**
   * @deprecated use {@link #setRendererFactory(PropertyRendererFactory)}
   * @param registry
   */
  public void setRendererRegistry(PropertyRendererRegistry registry) {
    table.setRendererRegistry(registry);
  }

  /**
   * @deprecated use {@link #getRendererFactory()}
   */
  public PropertyRendererRegistry getRendererRegistry() {
    return table.getRendererRegistry();
  }

  /**
   * Sets sorting of categories enabled or disabled.
   * 
   * @param value true to enable sorting
   */
  public void setSortingCategories(boolean value) {
    model.setSortingCategories(value);
    sortButton.setSelected(isSorting());
  }

  /**
   * Is sorting of categories enabled.
   * 
   * @return true if category sorting is enabled
   */
  public boolean isSortingCategories() {
    return model.isSortingCategories();
  }

  /**
   * Sets sorting of properties enabled or disabled.
   * 
   * @param value true to enable sorting
   */
  public void setSortingProperties(boolean value) {
    model.setSortingProperties(value);
    sortButton.setSelected(isSorting());
  }

  /**
   * Is sorting of properties enabled.
   * 
   * @return true if property sorting is enabled
   */
  public boolean isSortingProperties() {
    return model.isSortingProperties();
  }

  /**
   * Sets sorting properties and categories enabled or disabled.
   * 
   * @param value true to enable sorting
   */
  public void setSorting(boolean value) {
    model.setSortingCategories(value);
    model.setSortingProperties(value);
    sortButton.setSelected(value);
  }
  
  /**
   * @return true if properties or categories are sorted.
   */
  public boolean isSorting() {
    return model.isSortingCategories() || model.isSortingProperties();
  }
  
  /**
   * Sets the Comparator to be used with categories. Categories are
   * treated as String-objects.
   * 
   * @param comp java.util.Comparator used to compare categories
   */
  public void setCategorySortingComparator(Comparator comp) {
    model.setCategorySortingComparator(comp);
  }

  /**
   * Sets the Comparator to be used with Property-objects.
   * 
   * @param comp java.util.Comparator used to compare Property-objects
   */
  public void setPropertySortingComparator(Comparator comp) {
    model.setPropertySortingComparator(comp);
  }
  
  /**
   * Set wether or not toggle states are restored when new properties are
   * applied.
   *
   * @param value true to enable
   */
  public void setRestoreToggleStates(boolean value) {
    model.setRestoreToggleStates(value);
  }
  
  /**
   * @return true is toggle state restore is enabled
   */
  public boolean isRestoreToggleStates() {
    return model.isRestoreToggleStates();
  }

  private void buildUI() {
    LookAndFeelTweaks.setBorderLayout(this);
    LookAndFeelTweaks.setBorder(this);

    actionPanel = new JPanel(new FlowLayout(FlowLayout.LEADING, 2, 0));
    actionPanel.setBorder(BorderFactory.createEmptyBorder(2, 0, 2, 0));
    actionPanel.setOpaque(false);
    add("North", actionPanel);

    sortButton = new JToggleButton(new ToggleSortingAction());
    sortButton.setUI(new BlueishButtonUI());
    sortButton.setText(null);
    sortButton.setOpaque(false);
    actionPanel.add(sortButton);

    asCategoryButton = new JToggleButton(new ToggleModeAction());
    asCategoryButton.setUI(new BlueishButtonUI());
    asCategoryButton.setText(null);
    asCategoryButton.setOpaque(false);
    actionPanel.add(asCategoryButton);

    descriptionButton = new JToggleButton(new ToggleDescriptionAction());
    descriptionButton.setUI(new BlueishButtonUI());
    descriptionButton.setText(null);
    descriptionButton.setOpaque(false);
    actionPanel.add(descriptionButton);

    split = new JSplitPane(JSplitPane.VERTICAL_SPLIT);
    split.setBorder(null);
    split.setResizeWeight(1.0);
    split.setContinuousLayout(true);
    add("Center", split);
    
    tableScroll = new JScrollPane();
    tableScroll.setBorder(BorderFactory.createEmptyBorder());
    split.setTopComponent(tableScroll);

    descriptionPanel = new JEditorPane("text/html", "<html>");
    descriptionPanel.setBorder(BorderFactory.createEmptyBorder());
    descriptionPanel.setEditable(false);
    descriptionPanel.setBackground(UIManager.getColor("Panel.background"));
    LookAndFeelTweaks.htmlize(descriptionPanel);

    selectionListener = new SelectionListener();

    descriptionScrollPane = new JScrollPane(descriptionPanel);
    descriptionScrollPane.setBorder(LookAndFeelTweaks.addMargin(BorderFactory
      .createLineBorder(UIManager.getColor("controlDkShadow"))));
    descriptionScrollPane.getViewport().setBackground(
      descriptionPanel.getBackground());
    descriptionScrollPane.setMinimumSize(new Dimension(50, 50));
    split.setBottomComponent(descriptionScrollPane);
    
    // by default description is not visible, toolbar is visible.
    setDescriptionVisible(false);
    setToolBarVisible(true);
  }

  class SelectionListener implements ListSelectionListener {

    public void valueChanged(ListSelectionEvent e) {
      int row = table.getSelectedRow();
      Property prop = null;
      if (row >= 0 && table.getRowCount() > row)
        prop = model.getPropertySheetElement(row).getProperty();
      if (prop != null) {
        descriptionPanel.setText("<html>"
            + "<b>"
            + (prop.getDisplayName() == null?"":prop.getDisplayName())
            + "</b><br>"
            + (prop.getShortDescription() == null?"":prop
                .getShortDescription()));
      } else {
        descriptionPanel.setText("<html>");
      }

      //position it at the top
      descriptionPanel.setCaretPosition(0);
    }
  }

  class ToggleModeAction extends AbstractAction {

    public ToggleModeAction() {
      super("toggle", IconPool.shared().get(
          PropertySheet.class.getResource("icons/category.gif")));
      putValue(Action.SHORT_DESCRIPTION, ResourceManager.get(
          PropertySheet.class).getString(
          "PropertySheetPanel.category.shortDescription"));
    }

    public void actionPerformed(ActionEvent e) {
      if (asCategoryButton.isSelected()) {
        model.setMode(PropertySheet.VIEW_AS_CATEGORIES);
      } else {
        model.setMode(PropertySheet.VIEW_AS_FLAT_LIST);
      }
    }
  }

  class ToggleDescriptionAction extends AbstractAction {

    public ToggleDescriptionAction() {
      super("toggleDescription", IconPool.shared().get(
          PropertySheet.class.getResource("icons/description.gif")));
      putValue(Action.SHORT_DESCRIPTION, ResourceManager.get(
          PropertySheet.class).getString(
          "PropertySheetPanel.description.shortDescription"));
    }

    public void actionPerformed(ActionEvent e) {
      setDescriptionVisible(descriptionButton.isSelected());
    }
  }

  class ToggleSortingAction extends AbstractAction {

    public ToggleSortingAction() {
      super("toggleSorting", IconPool.shared().get(
          PropertySheet.class.getResource("icons/sort.gif")));
      putValue(Action.SHORT_DESCRIPTION, ResourceManager.get(
          PropertySheet.class).getString(
          "PropertySheetPanel.sort.shortDescription"));
    }

    public void actionPerformed(ActionEvent e) {
      setSorting(sortButton.isSelected());
    }
  }

}