return componentDirection;
  }

  public void setComponentDirection(Direction componentDirection) {
    if (componentDirection != this.componentDirection) {
      this.componentDirection = componentDirection;
      getDirectionLayout().setDirection(componentDirection == Direction.UP ? Direction.RIGHT : componentDirection == Direction.LEFT ? Direction.DOWN : componentDirection == Direction.DOWN
                                                                                                                                                       ?
                                                                                                                                                       Direction.RIGHT
                                                                                                                                                       :
                                                                                                                                                       Direction.DOWN);
      if (scrollEnabled) {
        scrollButtonBox.setVertical(componentDirection.isHorizontal());
        ((ScrollableBox) componentContainer).setVertical(componentDirection.isHorizontal());
      }
    }
  }

  public void setTopComponent(DraggableComponent topComponent) {
    if (topComponent != this.topComponent) {
      this.topComponent = topComponent;

      sortComponentList(!descendingSortOrder);
    }
  }

  public ScrollButtonBox getScrollButtonBox() {
    return scrollButtonBox;
  }

  public JComponent getOuterParentArea() {
    return outerParentArea;
  }

  public void setOuterParentArea(JComponent outerParentArea) {
    this.outerParentArea = outerParentArea;
  }

  public void dragDraggableComponent(DraggableComponent component, Point p) {
    if (draggableComponentList.contains(component)) {
      component.drag(SwingUtilities.convertPoint(this, p, component.getComponent()));
    }

    //component.drag(SwingUtilities.convertPoint(this, p, component.getComponent()));
  }

  public Dimension getMaximumSize() {
    if (scrollEnabled)
      return getPreferredSize();

    if (componentDirection == Direction.LEFT || componentDirection == Direction.RIGHT)
      return new Dimension((int) getPreferredSize().getWidth(), (int) super.getMaximumSize().getHeight());

    return new Dimension((int) super.getMaximumSize().getWidth(), (int) getPreferredSize().getHeight());

  }

  public Dimension getInnerSize() {
    boolean mustSort = this.mustSort;
    this.mustSort = false;
    Dimension d = scrollEnabled ? componentBox.getPreferredSize() : componentBox.getSize();
    this.mustSort = mustSort;
    return d;
  }

  public void scrollToVisible(final DraggableComponent c) {
    SwingUtilities.invokeLater(new Runnable() {
      public void run() {
        if (scrollEnabled) {
          ((ScrollableBox) componentContainer).ensureVisible(layoutOrderList.indexOf(c.getComponent()));
        }
      }
    });
  }

  // Prevents focus problems when adding/removing focused component while sorting when spacing < 0
  private void setIgnoreAddRemoveNotify(boolean ignore) {
    for (int i = 0; i < draggableComponentList.size(); i++)
      ((DraggableComponent) draggableComponentList.get(i)).setIgnoreAddNotify(ignore);
  }

  private void doSort() {
    if (mustSort && getComponentSpacing() < 0) {
      setIgnoreAddRemoveNotify(true);

      mustSort = false;
      Component c;
      Component tc = topComponent != null ? topComponent.getComponent() : null;

      //componentBoxEnabled = false;

      //long millis = System.currentTimeMillis();

      int index = 0;
      if (tc != null) {
        if (componentBox.getComponent(0) != tc) {
          componentBox.remove(tc);
          componentBox.add(tc, index);
        }
        index++;
      }

      int switc = 0;
      int size = layoutOrderList.size();
      for (int i = 0; i < size; i++) {
        c = (Component) layoutOrderList.get(doReverseSort ? size - i - 1 : i);
        if (c != tc) {
          if (componentBox.getComponent(index) != c) {
            switc++;
            componentBox.remove(c);
            componentBox.add(c, index);
          }
          index++;
        }
      }

      setIgnoreAddRemoveNotify(false);

      /*System.out.print("  Box:   ");
      for (int i = 0; i < componentBox.getComponentCount(); i++)
        System.out.print(componentBox.getComponent(i) + "  ");
      System.out.println();
      System.out.print("  Order: ");
      for (int i = 0; i < layoutOrderList.size(); i++)
        System.out.print(layoutOrderList.get(i) + "  ");*/
      //System.out.println();
/*			long millis = System.currentTimeMillis();
			componentBox.removeAll();

			if (tc != null)
				componentBox.add(tc);

			int size = layoutOrderList.size();
			for (int i = 0; i < size; i++) {
				c = (Component) layoutOrderList.get(doReverseSort ? size - i - 1 : i);
				if (c != tc)
					componentBox.add(c);
			}*/

      //componentBoxEnabled = true;

      //System.out.println("Sorting " + scount++ + "  time: " + (System.currentTimeMillis() - millis) + "  Sorted: " + switc);
    }
  }

  private void sortComponentList(boolean reverseSort) {
    this.doReverseSort = reverseSort;
    mustSort = true;
  }

  private int getComponentIndexAtPoint(Point p) {
    JComponent c = null;
    Point p2 = SwingUtilities.convertPoint(this, p, componentBox);
    Point p3 = SwingUtilities.convertPoint(componentBox, p, outerParentArea);
    if (outerParentArea.contains(p3))
      c = (JComponent) ComponentUtil.getChildAtLine(componentBox,
                                                    p2,
                                                    getDirectionLayout().getDirection().isHorizontal());

    return layoutOrderList.indexOf(c);
  }

  private void doSelectComponent(DraggableComponent component) {
    if (selectedComponent != null) {
      DraggableComponent oldSelected = selectedComponent;
      selectedComponent = component;
      ensureSelectedVisible();
      fireSelectedEvent(selectedComponent, oldSelected);
    }
    else {
      selectedComponent = component;
      ensureSelectedVisible();
      fireSelectedEvent(selectedComponent, null);
    }
  }

  private int findSelectableComponentIndex(int index) {
    int selectIndex = -1;
    int k;
    for (int i = 0; i < layoutOrderList.size(); i++) {
      if ((findDraggableComponent((Component) layoutOrderList.get(i))).isEnabled() && i != index) {
        k = selectIndex;
        selectIndex = i;
        if (k < index && selectIndex > index)
          return selectIndex;
        else if (k > index && selectIndex > index)
          return k;
      }
    }

    return selectIndex;
  }

  private DraggableComponent findDraggableComponent(Component c) {
    for (int i = 0; i < draggableComponentList.size(); i++)
      if (((DraggableComponent) draggableComponentList.get(i)).getComponent() == c)
        return (DraggableComponent) draggableComponentList.get(i);

    return null;
  }

  private DirectionLayout getDirectionLayout() {
    return (DirectionLayout) componentBox.getLayout();
  }

  private void initialize() {
    if (componentContainer != null)
      remove(componentContainer);

    DirectionLayout layout = getDirectionLayout();
    layout.setCompressing(!scrollEnabled);

    if (scrollEnabled) {
      if (useDefaultScrollButtons)
        scrollButtonBox = new ScrollButtonBox(componentDirection.isHorizontal(), iconSize);
      else
        scrollButtonBox = new ScrollButtonBox(componentDirection.isHorizontal(), null, null, null, null);

      final ScrollableBox scrollableBox = new ScrollableBox(componentBox,
                                                            componentDirection.isHorizontal(),
                                                            scrollOffset);
      scrollableBox.setLayoutOrderList(layoutOrderList);
      scrollButtonBox.addListener(new ScrollButtonBoxListener() {
        public void scrollButton1() {
          scrollableBox.scrollLeft(1);
        }

        public void scrollButton2() {
          scrollableBox.scrollRight(1);
        }
      });

      scrollableBox.addComponentListener(new ComponentAdapter() {
        public void componentResized(ComponentEvent e) {
          scrollButtonBox.setButton1Enabled(!scrollableBox.isLeftEnd());
          scrollButtonBox.setButton2Enabled(!scrollableBox.isRightEnd());
        }
      });

      scrollButtonBox.setButton1Enabled(!scrollableBox.isLeftEnd());
      scrollButtonBox.setButton2Enabled(!scrollableBox.isRightEnd());

      scrollableBox.addScrollableBoxListener(new ScrollableBoxListener() {
        public void scrolledLeft(ScrollableBox box) {
          scrollButtonBox.setButton1Enabled(!box.isLeftEnd());
          scrollButtonBox.setButton2Enabled(true);
        }

        public void scrolledRight(ScrollableBox box) {
          scrollButtonBox.setButton1Enabled(true);
          scrollButtonBox.setButton2Enabled(!box.isRightEnd());
        }

        public void changed(ScrollableBox box) {
          fireChangedEvent();
        }
      });
      componentContainer = scrollableBox;
    }
    else {
      scrollButtonBox = null;
      componentContainer = componentBox;
    }

    componentContainer.setAlignmentY(0);
    add(componentContainer, BorderLayout.CENTER);

    revalidate();
  }

  private void ensureSelectedVisible() {
    SwingUtilities.invokeLater(new Runnable() {
      public void run() {
        if (scrollEnabled && ensureSelectedVisible && selectedComponent != null) {
          //componentContainer.validate();
          ((ScrollableBox) componentContainer).ensureVisible(layoutOrderList.indexOf(selectedComponent.getComponent()));
        }
      }
    });
  }

  private void fireDraggedEvent(DraggableComponentEvent e) {
    if (listeners != null) {
      DraggableComponentBoxEvent event = new DraggableComponentBoxEvent(this,
                                                                        e.getSource(),
                                                                        e,
                                                                        SwingUtilities.convertPoint(
                                                                            e.getSource().getComponent(),
                                                                            e.getMouseEvent().getPoint(),
                                                                            this));
      Object[] l = listeners.toArray();
      for (int i = 0; i < l.length; i++)
        ((DraggableComponentBoxListener) l[i]).componentDragged(event);
    }
  }

  private void fireDroppedEvent(DraggableComponentEvent e) {
    if (listeners != null) {
      DraggableComponentBoxEvent event = new DraggableComponentBoxEvent(this,
                                                                        e.getSource(),
                                                                        e,
                                                                        SwingUtilities.convertPoint(
                                                                            e.getSource().getComponent(),
                                                                            e.getMouseEvent().getPoint(),
                                                                            this));
      Object[] l = listeners.toArray();
      for (int i = 0; i < l.length; i++)
        ((DraggableComponentBoxListener) l[i]).componentDropped(event);
    }
  }

  private void fireNotDroppedEvent(DraggableComponentEvent e) {
    if (listeners != null) {
      DraggableComponentBoxEvent event = new DraggableComponentBoxEvent(this, e.getSource(), e);
      Object[] l = listeners.toArray();
      for (int i = 0; i < l.length; i++)
        ((DraggableComponentBoxListener) l[i]).componentDragAborted(event);
    }
  }

  private void fireSelectedEvent(DraggableComponent component, DraggableComponent oldDraggableComponent) {
    if (listeners != null) {
      DraggableComponentBoxEvent event = new DraggableComponentBoxEvent(this, component, oldDraggableComponent);
      Object[] l = listeners.toArray();
      for (int i = 0; i < l.length; i++)
        ((DraggableComponentBoxListener) l[i]).componentSelected(event);
    }
  }

  private void fireAddedEvent(DraggableComponent component) {
    if (listeners != null) {
      DraggableComponentBoxEvent event = new DraggableComponentBoxEvent(this, component);
      Object[] l = listeners.toArray();
      for (int i = 0; i < l.length; i++)
        ((DraggableComponentBoxListener) l[i]).componentAdded(event);
    }
  }

  private void fireRemovedEvent(DraggableComponent component) {
    if (listeners != null) {
      DraggableComponentBoxEvent event = new DraggableComponentBoxEvent(this, component);
      Object[] l = listeners.toArray();
      for (int i = 0; i < l.length; i++)
        ((DraggableComponentBoxListener) l[i]).componentRemoved(event);
    }
  }

  private void fireChangedEvent(DraggableComponentEvent e) {
    if (listeners != null) {
      DraggableComponentBoxEvent event = new DraggableComponentBoxEvent(this, e.getSource(), e);
      Object[] l = listeners.toArray();
      for (int i = 0; i < l.length; i++)
        ((DraggableComponentBoxListener) l[i]).changed(event);
    }
  }

  private void fireChangedEvent() {
    if (listeners != null) {
      DraggableComponentBoxEvent event = new DraggableComponentBoxEvent(this);
      Object[] l = listeners.toArray();
      for (int i = 0; i < l.length; i++)
        ((DraggableComponentBoxListener) l[i]).changed(event);
    }
  }
}