draggablecomponent.java

修正了jdk1.6中对托盘事件产生异常的bug.

/*
 * Copyright (C) 2004 NNL Technology AB
 * Visit www.infonode.net for information about InfoNode(R) 
 * products and how to contact NNL Technology AB.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, 
 * MA 02111-1307, USA.
 */


// $Id: DraggableComponent.java,v 1.31 2005/12/04 13:46:03 jesper Exp $

package net.infonode.gui.draggable;

import net.infonode.gui.ComponentUtil;
import net.infonode.gui.EventUtil;

import javax.swing.*;
import javax.swing.event.MouseInputAdapter;
import javax.swing.event.MouseInputListener;
import java.awt.*;
import java.awt.event.ComponentAdapter;
import java.awt.event.ComponentEvent;
import java.awt.event.KeyEvent;
import java.awt.event.MouseEvent;
import java.util.ArrayList;

public class DraggableComponent {
  private static long MAX_EVENT_DELAY = 50;
  private JComponent component;
  private JComponent[] eventComponents;

  private boolean reorderEnabled = true;
  private boolean enabled = true;
  private boolean reorderRestoreOnDrag;
  private boolean detectOuterAreaAsLine = true;
  private boolean enableInsideDrag;
  private boolean selectOnMousePress;

  private boolean mousePressed;
  private boolean dragEventFired;
  private boolean dragStarted;

  private boolean ignoreAddNotify = false;

  private int dragIndex;
  private int dragFromIndex;
  private int abortDragKeyCode = KeyEvent.VK_ESCAPE;

  private ArrayList layoutOrderList;

  private ArrayList listeners;
  private JComponent outerParentArea;

  private KeyEventDispatcher abortDragKeyDispatcher = new KeyEventDispatcher() {
    public boolean dispatchKeyEvent(KeyEvent e) {
      if (mousePressed && e.getKeyCode() == abortDragKeyCode) {
        if (e.getID() == KeyEvent.KEY_PRESSED)
          dragCompleted(null);
        return true;
      }
      return false;
    }
  };

  private MouseInputListener mouseInputListener = new MouseInputAdapter() {
    public void mousePressed(MouseEvent e) {
      //if (MouseEventCoalesceManager.getInstance().isPressedAllowed(e))
      pressed(e);
    }

    public void mouseReleased(MouseEvent e) {
      //if (MouseEventCoalesceManager.getInstance().isReleasedAllowed(e))
      released(e);
    }

    public void mouseDragged(MouseEvent e) {
      //if (MouseEventCoalesceManager.getInstance().isDraggedAllowed(e))
      dragged(e);
    }
  };

  public DraggableComponent(JComponent component) {
    this(component, component);
  }

  public DraggableComponent(JComponent component, JComponent eventComponent) {
    this(component, new JComponent[]{eventComponent});
  }

  public DraggableComponent(JComponent component, JComponent[] eventComponents) {
    this.component = component;
    component.addComponentListener(new ComponentAdapter() {

      public void componentResized(ComponentEvent e) {
        fireChangedEvent(DraggableComponentEvent.TYPE_UNDEFINED);
      }

      /*public void componentMoved(ComponentEvent e) {
        fireChangedEvent(DraggableComponentEvent.TYPE_MOVED);
      }*/
    });
    setEventComponents(eventComponents);
  }

  public void addListener(DraggableComponentListener l) {
    if (listeners == null)
      listeners = new ArrayList(2);

    listeners.add(l);
  }

  public void removeListener(DraggableComponentListener l) {
    if (listeners != null) {
      listeners.remove(l);

      if (listeners.size() == 0)
        listeners = null;
    }
  }

  public JComponent getComponent() {
    return component;
  }

  public JComponent[] getEventComponents() {
    return eventComponents;
  }

  public void setEventComponents(JComponent[] eventComponents) {
    if (this.eventComponents != null) {
      for (int i = 0; i < this.eventComponents.length; i++) {
        this.eventComponents[i].removeMouseListener(mouseInputListener);
        this.eventComponents[i].removeMouseMotionListener(mouseInputListener);
      }
    }

    this.eventComponents = eventComponents;

    if (this.eventComponents != null) {
      for (int i = 0; i < this.eventComponents.length; i++) {
        this.eventComponents[i].addMouseListener(mouseInputListener);
        this.eventComponents[i].addMouseMotionListener(mouseInputListener);
      }
    }
  }

  public int getAbortDragKeyCode() {
    return abortDragKeyCode;
  }

  public void setAbortDragKeyCode(int abortDragKeyCode) {
    this.abortDragKeyCode = abortDragKeyCode;
  }

  public boolean isEnabled() {
    return enabled;
  }

  public void setEnabled(boolean enabled) {
    if (this.enabled != enabled) {
      this.enabled = enabled;
      fireChangedEvent(enabled ? DraggableComponentEvent.TYPE_ENABLED : DraggableComponentEvent.TYPE_DISABLED);
    }
  }

  public boolean isReorderEnabled() {
    return reorderEnabled;
  }

  public void setReorderEnabled(boolean reorderEnabled) {
    this.reorderEnabled = reorderEnabled;
  }

  public boolean isReorderRestoreOnDrag() {
    return reorderRestoreOnDrag;
  }

  public void setReorderRestoreOnDrag(boolean reorderRestoreOnDrag) {
    this.reorderRestoreOnDrag = reorderRestoreOnDrag;
  }

  public boolean isDetectOuterAreaAsLine() {
    return detectOuterAreaAsLine;
  }

  public void setDetectOuterAreaAsLine(boolean detectOuterAreaAsLine) {
    this.detectOuterAreaAsLine = detectOuterAreaAsLine;
  }

  public boolean isEnableInsideDrag() {
    return enableInsideDrag;
  }

  public void setEnableInsideDrag(boolean enableInsideDrag) {
    this.enableInsideDrag = enableInsideDrag;
  }

  public boolean isSelectOnMousePress() {
    return selectOnMousePress;
  }

  public void setSelectOnMousePress(boolean selectOnMousePress) {
    this.selectOnMousePress = selectOnMousePress;
  }

  public void drag(Point p) {
    if (enabled) {
      dragIndex = getComponentIndex(component);
      dragFromIndex = dragIndex;
      doDrag(p);
    }
  }

  public void abortDrag() {
    if (dragStarted)
      dragCompleted(null);
  }

  public void setLayoutOrderList(ArrayList layoutOrderList) {
    this.layoutOrderList = layoutOrderList;
  }

  public void select() {
    if (enabled)
      fireSelectedEvent();
  }

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

  public boolean isIgnoreAddNotify() {
    return ignoreAddNotify;
  }

  public void setIgnoreAddNotify(boolean ignoreAddNotify) {
    this.ignoreAddNotify = ignoreAddNotify;
  }

  private void pressed(MouseEvent e) {
    if (enabled && e.getButton() == MouseEvent.BUTTON1) {
      if (selectOnMousePress && !e.isShiftDown())
        select();
      dragStarted = false;
      KeyboardFocusManager.getCurrentKeyboardFocusManager().addKeyEventDispatcher(abortDragKeyDispatcher);
      mousePressed = true;
      dragIndex = getComponentIndex(component);
      dragFromIndex = dragIndex;

      fireChangedEvent(DraggableComponentEvent.TYPE_PRESSED);
    }
  }

  private void released(MouseEvent e) {
    if (mousePressed) {
      if (e.getButton() == MouseEvent.BUTTON1)
        dragCompleted(e);
      else {
        dragCompleted(null);
        e.consume();
      }
    }
  }

  private void dragged(MouseEvent e) {