Spec-Zone .ru
спецификации, руководства, описания, API
Содержание документации

Перетащите и Подсистема Отбрасывания для Java 2 Платформы Standard Edition 5.0

У этого документа есть эти разделы:

1.0 Требования

Эта спецификация определяет API для средств перетаскивания и отбрасывания для Java 2 Платформы.

Основные требования, чтобы эта спецификация адресовалась:

  1. Условие независимого от платформы перетаскивает и отбрасывает средство для клиентов GUI Java, реализованных через классы Swing и AWT.
  2. Интеграция с зависимой платформой перетаскивает и отбрасывает средства, разрешая клиентам Java быть в состоянии участвовать в работе DnD с собственным использованием приложений:
  3. Поддержка 100%-ой чистой реализации JavaOS/Java.
  4. Усиливает существующее java.awt.datatransfer.* пакет, чтобы включить передаче данных, описанных расширяемой системой типа данных, основанной на стандарте MIME.
  5. Не устраняет использование функций "доступности" где доступный.
  6. Расширяемый, чтобы поддерживать разнообразные устройства ввода данных.

Спецификация происходит из предыдущей упомянутой выше работы, но включает существенные различия от той исходной работы в результате появления модели событий JavaBeans, легкий вес (Swing) компоненты, и понимание увеличения межплатформенных проблем интеграции и функциональной совместимости.

2.0 API

Следующие разделы покрывают перетаскивание и отбрасывают API.

2.1 Краткий обзор

Перетащите и отбрасывание является жестом непосредственного управления, найденным во многих системах графического интерфейса пользователя, который обеспечивает механизм, чтобы передать информацию между двумя объектами, логически связанными с элементами представления в GUI. Обычно управляемый физическим жестом человеческого пользователя, использующего соответствующее устройство ввода данных, перетащите, и отбрасывание предоставляет обоим механизм, чтобы позволить непрерывной обратной связи относительно возможного исхода любой последующей передачи данных пользователю во время навигации по элементам представления в GUI, и средствах предусмотреть любое последующее согласование данных и передачу.

Типичное перетаскивает и отбрасывает работу, может анализироваться в следующие состояния (не полностью последовательно):

Остаток от этого документа детализирует предложенные изменения API, чтобы поддерживать эту модель.

2.2 Перетащите Распознавание Жеста

Жест (ы), который может инициировать перетаскивание и отбросить работу, изменяется, не только на платформу, но также и на Component, и для каждого устройства. Поэтому механизм требуется, чтобы инкапсулировать эти зависимости, таким образом делая задачу автора a Component это хочет инициировать намного более простую работу перетаскивания и отбрасывания.

2.2.1 DragGestureRecognizer

DragGestureRecognizer абстрактный class для всего device/platform/Component определенный перетаскивают и отбрасывают устройства распознавания жеста, и определяется как:

public abstract DragGestureRecognizer {
    protected DragGestureRecognizer(
        DragSource  ds,
        Component c,
        int  srcActions,
        DragGestureListener dgl
    );
    public Component getComponent();
    public void      setComponent(Component c);
    public int  getSourceActions();
    public void setSourceActions(int actions);
    public java.awt.InputEvent getTriggerEvent();
    public void resetRecognizer();
    public void addDragGestureListener(
        DragGestureListener dgl
    ) throws TooManyListenerExceptions;
    public void removeDragGestureListener(
       DragGestureListener dgl
    );
    protected abstract void registerListeners();
    protected abstract void unregisterListeners();
    protected void fireDragGestureRecognized(
       int dragAction
    );
    protected void appendEvent(InputEvent awtie);
}

Соответствующие конкретные подклассы DragGestureRecognizer поскольку деталь может быть получена во множестве путей; от a DragSource экземпляр, от Toolkit, или другими средствами. Конкретные подклассы реализации получаются через стандартные API, определяя a Class ссылка на краткий обзор DragGestureRecognizer суперкласс, экземпляр конкретного подкласса этого фактического параметра инстанцируют и возвращается просителю.

Однажды a DragGestureRecognizer экземпляр связывается с a Component и a DragSource это регистрирует свой собственный определенный набор EventListeners' с целью Component чтобы следить за развитием соответствующих событий, поставляемых этому Component обнаружить жест инициирования. (Используя registerListeners и unregisterListeners добавить/удалить их контроль EventListeners').

Отметьте это a DragGestureRecognizer может бросить любого IllegalStateException или IllegalArgumentException если любой Component или DragSource определенный или не в корректном состоянии для, или не является взаимодействующим с, это DragGestureRecognizer.

Когда бетон DragGestureRecognizer экземпляр обнаруживает перетащенный инициируемый пользовательский жест на Component это связывается с, это запустит a DragGestureEvent к DragGestureListener зарегистрированный на его одноадресном источнике события для DragGestureListener события. Это DragGestureListener ответственно за порождение связанного DragSource запустить работу перетаскивания и отбрасывания (если соответствующий).

Реализация обеспечивает (по крайней мере), абстрактный подкласс для того, чтобы он распознал жесты устройства мыши MouseDragGestureRecognizer. Другие абстрактные подклассы могут быть обеспечены платформой, чтобы поддерживать другие устройства ввода данных или определенный Компонент семантика class. Конкретные суперклассы этого MouseDragGestureRecognizer это инкапсулирует платформу зависимая мышь, базируемые жесты доступны от Toolkit объект через createDragGestureRecognizer(Class adgrc, DragSource ds, Component c, int sa, DragGestureListener dgl) метод. Это Toolkit API обеспечивает платформу зависимые конкретные реализации, которые расширяют определенные независимые от платформы абстрактные определения (классы).

MouseDragGestureRecognizer абстрактный class определяется как:

public abstract   MouseDragGestureRecognizer
       extends    DragGestureRecognizer
          implements MouseListener, MouseMotionListener {

    public MouseDragGestureRecognizer(
        DragSource  ds,
        Component   c,
        int  sa,
        DragGestureListener dsl
    );   
    //...
}

DragGestureListener определяется как:

public interface DragGestureListener extends EventListener {
    void dragGestureRecognized(DragGestureEvent dge);
}

Обычно dragGestureRecognized() метод будет просто, через DragGestureEvent's API удобства startDrag, запустите перетаскивание и отбросьте работу на связанном DragSource.

Отметьте это на Component (class или экземпляр), поведение, которое может произвести жест инициирования, обычно реализовывалось бы в этом DragGestureListener метод, или в DragGestureRecognizer разделите на подклассы где необходимо или возможный.

DragGestureEvent определяется как:

publc class DragGestureEvent extends EventObject {
        public DragGestureEvent(DragGestureRecognizer dgr,
             int  dragAction,
             java.util.List  events
     );
    public DragGestureRecognizer getSourceAsDragGestureRecognizer();
    public Component  getComponent();
    public DragSource getDragSource();
    public java.util.Iterator iterator();
    public Object[] toArray();
    public Object[] toArray(Object[] array);
    public int getDragAction();
    public startDrag(Cursor             dragCursor,
                     Transferable       t,
                     DragSourceListener dsl
    );
    public startDrag(Cursor             dragCursor,
                     Image              dragImage,
                     Point              imageOffset,
                     Transferable       t,
                     DragSourceListener dsl
    );
    //...
}

DragGestureEvent инкапсулирует всю информацию относительно природы жеста, который был только что распознан, включая:

2.3 Перетащите Источник

DragSource объект, ответственный за инициирование работы перетаскивания и отбрасывания:

2.3.1 Определение DragSource

DragSource и связанные постоянные интерфейсы определяются следующим образом:

DnDConstants class определяет операции, которые могут быть применены к предмету передачи:

public final class java.awt.dnd.DnDConstants {
     public static int ACTION_NONE = 0x0;
     public static int ACTION_COPY = 0x1;
     public static int ACTION_MOVE = 0x2;
     public static int ACTION_COPY_OR_MOVE= ACTION_COPY | ACTION_MOVE;
     public static int ACTION_REFERENCE = 0x40000000;
}

public class java.awt.dnd.DragSource {
     public static Cursor     DefaultCopyDrop;
     public static Cursor     DefaultMoveDrop;
     public static Cursor     DefaultLinkDrop;
     public static Cursor     DefaultCopyNoDrop;
     public static Cursor     DefaultMoveNoDrop;
     public static Cursor     DefaultLinkNoDrop;
     public static DragSource getDefaultDragSource();
     public static boolean isDragImageSupported();
     public void startDrag(DragGestureEvent trigger,
                        Cursor             dragCursor,
                        Image              dragImage,
                        Point              dragImageOffset,
                        Transferable       transferable,
                        DragSourceListener dsl,
                        FlavorMap          fm)
                  throws InvalidDnDOperationException;
     protected DragSourceContext  createDragSourceContext(
                        DragSourceContextPeer dscp,
                        DragGestureEvent      trigger,
                        Cursor                dragCursor,
                        Image                 dragImage,
                        Point                 dragImageOffset,
                        Transferable          transferable,
                        DragSourceListener    dsl
      );
      public FlavorMap getFlavorMap();
      public DragGestureRecongizer createDragGestureRecognizer(
              Class               abstractRecognizerClass,
              Component           c,
              int                 srcActions,
              DragGestureListener dgl
     );
     public DragGestureRecongizer createDefaultDragGestureRecognizer(
              Component           c,
              int                 srcActions,
              DragGestureListener dgl
     );
     //...
}

DragSource может использоваться во многих сценариях:

Объект управления, получу a DragSource экземпляр до жеста пользователя, производя связанное Component, чтобы обработать работу. После того, как полученный a DragGestureRecognizer должен быть получен и использоваться, чтобы связаться DragSource с a Component.

Начальная интерпретация жеста пользователя, и последующий запуск перетащить работы являются ответственностью реализации Component, это обычно реализуется a DragGestureRecognizer.

Когда жест происходит, DragSource's startDrag метод должен быть вызван, чтобы вызвать обработку навигационных жестов пользователя, и поставка перетаскивают и отбрасывают уведомления о протоколе. A DragSource только разрешу, чтобы сингл перетащил и отбросил работу, чтобы быть текущим в любой момент, и должен отклонить дальше startDrag запросы, бросая IllegalDnDOperationException до тех пор, пока существующая работа полна.

Чтобы запустить перетащить работу вызывающая сторона startDrag метод должен обеспечить следующие параметры:

Как указано выше, основная роль startDrag метод должен инициировать Перетаскивание от имени пользователя. Чтобы выполнить это, startDrag метод должен создать a DragSourceContext экземпляр, чтобы отследить работу непосредственно, и что еще более важно это должно инициировать работу непосредственно в базовой реализации платформы. Чтобы выполнить это, DragSource должен сначала получить a DragSourceContextPeer от базовой системы (обычно через вызов java.awt.Toolkit.createDragSourceContextPeer метод), и впоследствии связываются, это недавно создало DragSourceContextPeer (который обеспечивает независимый от платформы интерфейс для базовых системных возможностей) с a DragSourceContext.The startDrag метод вызывает createDragSourceContext метод, чтобы инстанцировать соответствующего DragSourceContext и партнер DragSourceContextPeer с этим.

Если система перетаскивания и отбрасывания неспособна инициировать перетащить работу по некоторым причинам startDrag метод должен бросить a java.awt.dnd.InvalidDnDOperationException сигнализировать такое условие. Обычно это исключение выдается, когда базовая система платформы или не в состоянии, чтобы инициировать перетаскивание, или определенные параметры недопустимы.

Отметьте, что во время перетаскивания ни одного набор операций источник, представленный в начале перетащить работы, не может измениться для продолжительности работы, другими словами работы () и является постоянным для продолжительности работы относительно DragSource.

getFlavorMap метод используется базовой системой, чтобы получить a FlavorMap возразите, чтобы отобразиться DataFlavors представленный Transferable к именам типов данных базовой платформы DnD. [см. позже для деталей FlavorMap]

"Частное" FlavorMap может быть обеспечен для startDrag() метод DragSource, или нуль, когда "значение по умолчанию" FlavorMap для этого DragSource class или экземпляр используются.

2.3.2 Определение DragSourceContext

В результате a DragSource's startDrag метод, успешно вызываемый экземпляр DragSourceContext class создается. Этот экземпляр ответственен за отслеживание состояния работы от имени DragSource и диспетчеризация изменений состояния к DragSourceListener.

DragSourceContext class определяется следующим образом:

public class DragSourceContext implements DragSourceListener {
        public DragSourceContext(
                DragSourceContextPeer dscp,
                DragGestureEvent  trigger,
                Cursor  dragCursor,
                Image  dragImage,
                Point  dragOffset,
                Transferable  transferable,
                DragSourceListener  dsl
        );
        public DragSource  getDragSource();
        public Component  getComponent();
        public DragGestureEvent getTrigger();
        public Image     getDragImage();
        public Point     getDragImageOffset();
        public void transferablesFlavorsChanged();
        public int getSourceActions();
        public Cursor getCursor();
        pbulic void   setCursor(Cursor Cursor)
                    throws InvalidDnDOperationException;
        public void addDragSourceListener(DragSourceListener dsl)
                    throws TooManyListenersException;
        public void removeDragSourceListener(DragSourceListener dsl);
        protected updateCurrentCursor(int dropOperation,
                                   int targetActions,
                                   int status
        );
        // values for status parameter above.
        protected static final int DEFAULT = 0;
        protected static final int ENTER   = 1;
        protected static final int OVER    = 2;
        protected static final int CHANGED = 3;

        //...
}

Отметьте что DragSourceContext непосредственно реализации DragSourceListener, это должно позволить коллегу платформы, DragSourceContextPeer экземпляр, создаваемый DragSource, уведомлять DragSourceContext из изменений в состоянии в продолжающейся операции, и таким образом позволяет DragSourceContext вставлять себя между платформой и DragSourceListener если инициатором работы.

Конечный автомат, который платформа представляет относительно источника, или инициатора работы Перетаскивания и Отбрасывания, детализируется ниже:

Следующий контекст описывает эту графику

Уведомления об изменениях в состоянии относительно инициатора во время работы перетаскивания и отбрасывания, как иллюстрировано выше, поставляются от DragSourceContextPeer, к соответствующему DragSourceContext, который делегирует уведомления через одноадресную передачу совместимый JavaBeans EventListener подынтерфейс, к произвольному объекту, который реализует DragSourceListener зарегистрированный в DragSource через startDrag.

Основная ответственность DragSourceListener должен контролировать продвижение навигации пользователя во время работы перетаскивания и отбрасывания и обеспечить, "Перетаскивают - По" обратной связи эффектов пользователю. Обычно это выполняется через изменения к, "Перетаскивают Курсор".

Каждый перетащить работу имеет 2 логических состояния курсора (Перетащите Курсоры), связанный с этим:

Состояние Cursor может быть изменен, вызывая setCursor метод DragSourceContext.

2.3.3 Определение DragSourceListener

DragSourceListener интерфейс определяется следующим образом:

public interface java.awt.dnd.DragSourceListener
        extends java.util.EventListener {
        void dragEnter  (DragSourceDragEvent dsde);
        void dragOver   (DragSourceDragEvent dsde);
        void dropActionChanged (DragSourceDragEvent dsde);
        void dragExit   (DragSourceEvent     dse);
        void dragDropEnd  (DragSourceDropEvent dsde);
}

Поскольку перетащить работа прогрессирует, DragSourceListener's dragEnter, dragOver, и dragExit методы должны быть вызваны в результате навигации пользователем логического, "Перетаскивают" расположение курсора, пересекающее геометрию GUI Component(s) со связанным DropTarget(s). [См. ниже для деталей DropTarget's взаимодействия протокола].

DragSourceListener's dragEnter метод вызывается, когда следующие условия являются истиной:

DropTarget's зарегистрированный DropTargetListener dragEnter метод вызывается и возвращается успешно.

Зарегистрированный DropTargetListener вызывает DropTargetDragEvent's acceptDrag метод, чтобы принять перетаскивание основанного на опросе потенциала источника отбрасывает действия и доступные типы данных (DataFlavors).

DragSourceListener's dragOver метод вызывается, когда следующие условия являются истиной:

DragSourceListener's dragExit метод вызывается, когда одно из следующих условий является истиной:

DragSourceListener's dropActionChanged() метод вызывается, когда состояние устройства () ввода данных, обычно кнопки мыши или модификаторы клавиатуры, что пользователь взаимодействует, чтобы выполнить перетащить работу, изменения.

dragDropEnd() метод вызывается, чтобы показать, что работа завершается. getDropSuccess метод DragSourceDropEvent может использоваться, чтобы определить состояние завершения. getDropAction метод возвращает работу что DropTarget выбранный (через DropTargetDropEvent acceptDrop параметр), чтобы примениться к работе отбрасывания.

Как только этот метод полон ток DragSourceContext и связанные ресурсы недопустимы.

2.3.4 Определение DragSourceEvent

DragSourceEvent class является корнем Event class для всех событий, имеющих отношение DragSource, и определяется следующим образом:

public class   java.awt.dnd.DragSourceEvent extends java.util.EventObject {
        public DragSourceEvent(DragSourceContext dsc);
        public DragSourceContext getDragSourceContext();
        //...
};

Экземпляр этого события передают к DragSourceListener dragExit метод.

2.3.5 Определение DragSourceDragEvent

DragSourceDragEvent class определяется следующим образом:


public class java.awt.dnd.DragSourceDragEvent extends DragSourceEvent {
        public int getTargetActions();
        public int getUserAction();
        public int getGestureModifiers();
        public int getGestureModifiersEx();
        public int getDropAction();
}

Экземпляр вышеупомянутого class передают к a DragSourceListener's dragEnter, dragOver, и dragGestureChanged методы.

getDragSourceContext метод возвращается DragSourceContext связанный с током перетаскивают и отбрасывают работу.

getUserAction метод возвращает действие, которое в настоящий момент выбирается жестом пользователя.

getTargetActions метод возвращает действие отбрасывания, выбранное текущей целью отбрасывания, если это действие отбрасывания поддерживается перетащить источником или DnDConstants.ACTION_NONE если это действие отбрасывания не поддерживается перетащить источником.

Логическое пересечение этих двух результатов и набор действий отбрасывания, поддерживаемых перетащить источником, определяют фактический эффект отбрасывания и возвращаются через getDropAction.

getGestureModifiers метод возвращает текущее состояние модификаторов устройства ввода данных, обычно кнопки мыши и модификаторы клавиатуры, связанные жестом пользователя.

getGestureModifiersEx метод возвращает текущее состояние устройства ввода данных расширенные модификаторы, связанные жестом пользователя.

2.3.6 Определение DragSourceDropEvent

DragSourceDropEvent class определяется следующим образом:

public public class java.awt.dnd.DragSourceDropEvent
                        extends java.util.EventObject {
       public DragSourceDropEvent(DragSourceContext dsc);
       public DragSourceDropEvent(DragSourceContext dsc,
                                int  action, 
                                boolean success);
       public boolean getDropSuccess();
       public int getDropAction();
}

Экземпляр вышеупомянутого class передают к a DragSourceListener's dragDropEnd метод. Это событие инкапсулирует состояние завершения работы перетаскивания и отбрасывания для DragSource.

Если отбрасывание происходит, то участие DropTarget будет сигнализировать успех или провал передачи данных через DropTargetContext's dropComplete метод, это состояние делается доступным для инициатора через getDropSuccess метод. Работа, что место назначения DropTarget выбранный, чтобы выполнить на предмет перетаскивания (проходил мимо DropTarget's acceptDrop метод), возвращается через getDropAction метод.

Если перетащить работа была прервана по любой причине до появления отбрасывания, например если стороны пользователя жест снаружи a DropTarget, или если DropTarget вызывает rejectDrop, getDropSuccess метод возвратит false, иначе истина.

2.4 Цель отбрасывания

2.4.1 java.awt. Компонентные дополнения для DropTarget (de) регистрация.

java.awt.Component У class есть два дополнительных метода, добавленные, чтобы разрешить (скидка) ассоциацию с a DropTarget. В особенности:

public class java.awt.Component /* ... */ {
        //...
        public synchronized void setDropTarget(DropTarget dt);
        public synchronized DropTarget getDropTarget(DropTarget df);
        //...
}

Связать a DropTarget с a Component можно вызвать также; DropTarget.setCompononent или Component.setDropTarget методы. Таким образом соответствующие реализации обоих методов обязаны принимать меры против взаимных рекурсивных вызовов.

Разъединять a DropTarget с a Component можно вызвать также; DropTarget.setCompononent(null) или Component.setDropTarget(null) методы.

Совместимые реализации обоих методов метода set в DropTarget и Component должен быть реализован друг с точки зрения друга, чтобы гарантировать надлежащее обслуживание состояния друг друга.

setDropTarget броски метода IllegalArgumentException если DropTarget фактический параметр не является подходящим для использования с этим class / экземпляр Component. Это может также бросить UnsupportedOperationException если, например, Component не поддерживает внешнюю установку a DropTarget.

2.4.2 Определение DropTarget

A DropTarget инкапсулирует всю специфичную для платформы обработку протокола Перетаскивания и Отбрасывания относительно роли получателя или места назначения работы.

Сингл DropTarget экземпляр может обычно связываться с любым произвольным экземпляром java.awt.Component. Установление такого отношения экспортирует связанное Components геометрия к клиентскому рабочему столу, как являющемуся восприимчивым, чтобы перетащить и отбросить операции, когда координаты логического курсора пересекает ту видимую геометрию.

DropTarget class определяется следующим образом:

public class java.awt.dnd.DropTarget
       implements DropTargetListener, Serializable {

        public DropTarget(Component          c,
                       int                actions,
                       DropTargetListener dsl,
                       boolean            isActive,
                       FlavorMap          fm
        );
        public DropTarget();
        public DropTarget(Component c);
        public DropTarget(Component c, DropTargetListener dsl);
        public Component getComponent();
        public void      setComponent(Component c);
        public DropTargetContext getDropTargetContext();
        public void addDropTargetListener(DropTargetListener dte)
                  throws TooManyListenersException;
        public void removeDropTargetListener(DropTargetListener dte);
        public void setActive(boolean active);
        public boolean isActive();
        public FlavorMap getFlavorMap();
        public void      setFlavorMap(FlavorMap fm);
        public void setDefaultActions(int actions);
        public int  getDefaultActions();
        protected DropTargetContext createDropTargetContext();
        public void addNotify(ComponentPeer cp);
        public void removeNotify(ComponentPeer cp);
        // ...
}

setComponent броски метода IllegalArgumentException если Component фактический параметр не является подходящим для использования с этим class / экземпляр DropTarget, и может также бросить UnsupportedOperationException если Component определенный отвергает внешнюю установку a DropTarget.

addDropTargetListener и removeDropTargetListener методы позволяют одноадресную передачу DropTargetListener быть измененным.

setActive и isActive методы позволяют DropTarget быть сделанным активным или иначе и для его текущего состояния, которое будет определено.

getFlavorMap методы используются, чтобы получить FlavorMap связанный с этим DropTarget в целях отобразить любые имена зависимого типа платформы к их независимому от платформы соответствию DataFlavors.

setFlavorMap метод позволяет новое FlavorMap быть присвоенным DropTarget, параметр нуля вызывает "значение по умолчанию" FlavorMap быть установленным для DropTarget.

createDropTargetContext метод только вызывается, чтобы предоставить базовой платформе зависимая коллега инстанцирование нового DropTargetContext поскольку Перетащить работа первоначально встречается Component связанный с DropTarget. Если нет DropTargetContext в настоящий момент связывается с a DropTarget, разрешенный побочный эффект вызова getDropTargetContext должен инстанцировать нового DropTargetContext.

addNotify и removeNotify от методов только вызывают Component уведомлять DropTarget из Component's (скидка) ассоциация с ComponentPeer.

Отметьте что DropTarget непосредственно реализации DropTargetListener, это должно позволить коллегу платформы, DropTargetContextPeer экземпляр, создаваемый платформой, чтобы уведомить DropTarget из изменений в состоянии в продолжающейся операции, и таким образом позволяет DropTarget вставлять себя между платформой и DropTargetListener зарегистрированный в DropTarget.

2.4.3 Определение DropTargetContext

Как логический курсор, связанный с продолжающимся, перетаскивают и отбрасывают работу, сначала пересекает видимую геометрию a Component со связанным DropTarget, DropTargetContext связанный с DropTarget интерфейс, через который, доступ к, и управление состоянием протокола получателя достигается от DropTargetListener.

A DropTargetContext создается a DropTarget, через это createDropTargetContext метод, как побочный эффект звонка a DropTarget's getDropTargetContext метод, если не <> DropTargetContext в настоящий момент существует для этого DropTarget.

DropTargetContext интерфейс определяется следующим образом:

public class DropTargetContext {
        public DropTarget getDropTarget();
        public Component getComponent();
        public void  dropComplete(boolean success)
                                throws InvalidDnDOperationException;
        public void acceptDrag(int dropAction);
        public void rejectDrag();
        public void acceptDrop(int dropAction);
        public void rejectDrop();
        public void addNotify(DropTargetContextPeer dtcp);
        public void removeNotify();
        protected Transferable createTransferableProxy(Transferable t,
                   boolean isLocal
        );
        protected void setTargetActions(int actions);
        protected int  getTargetActions();
        protected DataFlavor[] getCurrentDataFlavors();
        protected List getCurrentDataFlavorsAsList();
        protected boolean isDataFlavorSupported(DataFlavor df);
        protected Transferable getTransferable();
        // ...
}

Большая часть доступа и способов управления защищаются, так как открытый доступ к их состоянию обычно достигается, вызывая через деталь DropTargetEvent подкласс, который делегирует запрос к DropTargetContext.

getDropTarget() возврат метода DropTarget это создало это DropTargetContext.

getComponent метод возвращается Component связанный с DropTarget это создало это DropTargetContext.

acceptDrag метод делегируется от подобного метода на DropTargetDragEvent и вызывается от одного из DropTargetListener's методы; dragEnter(), dragOver или dropActionChanged показать, что получатель готовится принять отбрасывание с определенной работой, который обычно является в настоящий момент выбранным действием пользователя.

rejectDrag метод делегируется от подобного метода на DropTargetDragEvent и вызывается от одного из DropTargetListener's методы; dragEnter, dragOver или dropActionChanged показать, что получатель неспособен принять отбрасывание с в настоящий момент выбранным действием пользователя.

acceptDrop метод делегируется от подобного метода на DropTargetDropEvent и вызывается от DropTargetListener's drop метод, чтобы показать, что получатель готовится принять отбрасывание с определенной работой, который обычно является в настоящий момент выбранным действием пользователя.

rejectDrop метод делегируется от подобного метода на DropTargetDropEvent и вызывается от DropTargetListener's drop метод, чтобы показать, что получатель неспособен принять отбрасывание с в настоящий момент выбранным действием пользователя. Это завершает работу перетаскивания и отбрасывания без передачи данных.

dropComplete метод сигнализирует к возникновению DragSource то, что DropTargetListener завершил передачу (и), которые включают предмет перетаскивания и отбрасывают работу и что работа полна. Успех (или отказ) передачи () и последующего приложения определенной работы сообщается значением фактического параметра.

getDataFlavors метод возвращает массив DataFlavors доступный от DragSource.

getTransferable метод возвращает a Transferable (не обязательно тот DragSource зарегистрированный, это может быть прокси, и конечно должно быть в случае меж-JVM) позволять передачам данных произойти через getTransferData метод. Отметьте, что это недопустимо, чтобы вызвать getTransferable без первого вызова acceptDrop.

addNotify и removeNotify методы исключительно вызывает базовая платформа DropTargetContextPeer чтобы уведомить DropTargetContext то, что работа перетаскивания и отбрасывания происходит/прекращается на DropTargetContext и связанный DropTarget.

createTransferableProxy метод включает a DropTargetContext реализация, чтобы вставить a Transferable между DropTargetListener и Transferable если вызывающей стороной, которая обычно является базовой платформой DropTargetContextPeer.

2.4.4 Определение DropTargetListener

Обеспечение соответствующего "Перетаскивает - под" семантикой обратной связи, и обработкой любого последующего Отбрасывания, включается через DropTargetListener asssociated с a DropTarget.

DropTargetListener решает, что соответствующие "Перетаскивают - под" обратной связью и ее ответом на DragSource относительно преемственности отбрасывания, осматривая источники, предложенные действия, доступные типы данных и данные непосредственно.

Деталь DropTargetListener экземпляр может быть связан с a DropTarget через addDropTargetListener и удаленный через removeDropTargetListener методы.

public interface java.awt.dnd.DropTargetListener
        extends java.util.EventListener {
        void dragEnter            (DropTargetDragEvent dtde);
        void dragOver             (DropTargetDragEvent dtde);
        void dropActionChanged    (DropTargetDragEvent dtde);
        void dragExit             (DropTargetDragEvent dtde);
        void drop                 (DropTargetDropEvent dtde);
}

Следующий контекст описывает эту графику.

dragEnter метод DropTargetListener вызывается, когда горячая точка логического "Перетаскивает" Курсор, пересекает видимую часть DropTarget's связанный Component's геометрия. DropTargetListener, по получении этого уведомления, опрошу операции или действия, и типы данных (DataFlavors) и данные непосредственно как предоставлено DragSource чтобы определить надлежащие меры и "Перетаскивают - под" обратной связью, чтобы ответить вызовом также acceptDrag или rejectDrag.

dragOver метод DropTargetListener вызывается, в то время как горячая точка логического "Перетаскивает" Курсор в движении, продолжает пересекать видимую часть DropTarget's связанный Component's геометрия. DropTargetListener, по получении этого уведомления, опрошу работу "действия" типы данных и данных непосредственно как предоставлено DragSource чтобы определить соответствующие "действия" и "Перетаскивают - под" обратной связью, чтобы ответить вызовом также acceptDrag или rejectDrag.

dragExit метод DropTargetListener вызывается, когда горячая точка логического "Перетаскивает" Курсор, прекращает пересекать видимую часть DropTarget's связанный Component's геометрия, или сразу до a drop уведомление. DropTargetListener, по получении этого уведомления, отменю, любой "Перетаскивает - под" эффектами обратной связи, которые оно ранее применило. Отметьте что DropTargetContext связанный с DropTarget лишается законной силы как побочный эффект.

drop метод DropTargetListener вызывается в результате пользователя, завершающего их перетащить жест, пересекаясь. DropTargetListener, по получении этого уведомления, выполню работу, определенную возвращаемым значением getSourceActions метод на DropTargetDropEvent объект, на Transferable объект, возвращенный из getTransferable метод, и впоследствии вызывает dropComplete метод связанного DropTargetContext сигнализировать успех, или иначе, работы.

2.4.5 Определения DropTargetDragEvent и DropTargetDropEvent

DropTargetEvent и DropTargetDragEvent определяются следующим образом:

public abstract class java.awt.dnd.DropTargetEvent
          extends java.util.EventObject {

        public DropTargetContext getDropTargetContext();
        //...
}

A DropTargetEvent передается к DropTargetListener's dragExit метод.

public class   java.awt.dnd.DropTargetDragEvent
                         extends java.awt.dnd.DropTargetEvent {
        public Transferable getTransferable();
        public Point  getLocation();
        public int   getSourceActions();
        public getDropAction();
        public DataFlavor[] getCurrentDataFlavors();
        public List  getCurrentDataFlavorsAsList();
        public boolean isDataFlavorSupported();
        public void acceptDrag(int operation);
        public void rejectDrag();
        //...
}

A DropTargetDragEvent передается к DropTargetListener's dragEnter, dragOver и dropActionChanged методы.

getLocation возврат метода текущие координаты, относительно связанного Component's источник, горячей точки логического "Перетаскивают" курсор.

getSourceActions метод возвращает текущие "действия", или операции (ACTION_MOVE, ACTION_COPY, или ACTION_REFERENCE) DragSource партнеры с током перетаскивают и отбрасывают жест.

Возвращаемое значение getDropAction метод является действием, которое выбирается жестом пользователя.

getCurrentDataFlavors, getCurrentDataFlavorsAsList и isDataFlavorSupported методы обеспечиваются для получателя, чтобы опросить список типов, доступных из источника.

getTransferable метод обеспечивается для получателя, чтобы опросить доступные данные из источника. Отметьте это getTransferable на DropTargetDragEvent экземпляр нужно только вызвать в пределах соответствующего DropTargetListener's метод, и все необходимые данные должны быть получены от возвращенного Transferable перед тем методом возвраты.

DropTargetDropEvent определяется следующим образом:

public class java.awt.dnd.DropTargetDropEvent
          extends java.awt.dnd.DropTargetEvent {

        public Point      getLocation();
        public int getSourceActions();
        public int getDropAction();
        public void acceptDrop(int dropAction);
        public void rejectDrop();       
        public boolean isLocalTransfer();
        public DataFlavor[] getCurrentDataFlavors();
        public List  getCurrentDataFlavorsAsList();
        public boolean isDataFlavorSupported(DataFlavor df);
        public Transferable getTransferable();
        public void dropComplete(boolean success);
        //...
}

A DropTargetDropEvent передается к DropTargetListener's drop метод, поскольку отбрасывание происходит. DropTargetDropEvent обеспечивает DropTargetListener с доступом к данным, связанным с работой, через Transferable возвращенный из getTransferable метод.

Возвращаемое значение getSourceActions метод определяется, чтобы быть действием (ями), определенным источником в это время, в котором произошло отбрасывание.

Возвращаемое значение getDropAction метод является действием, которое выбирается жестом пользователя.

Возвращаемое значение getLocation метод определяется, чтобы быть расположением, в котором произошло отбрасывание.

getCurrentDataFlavors, getCurrentDataFlavorsAsList, и isDataFlavorSupported, методы обеспечиваются для получателя, чтобы опросить список типов, доступных из источника для последующей передачи через getTransferData метод Transferable.

Типичная реализация drop метод осмотрит действия и DataFlavors', доступные, чтобы определить, может ли успешный обмен произойти или нет.

Когда обмен может произойти, a DropTargetListener.drop реализация должна вызвать acceptDrop с выбранной работой как фактический параметр, до любого вызова getTransferable. Вызов getTransferable до acceptDrop приведу к InvalidDnDOperationException.

rejectDrop буду вызван, чтобы отклонить работу отбрасывания. После того, как названный никаким дальнейшим взаимодействием может произойти между этими двумя участниками, поэтому это типично, чтобы возвратиться из drop метод сразу после вызова этого.

isLocalTransfer метод должен возвратить true, если источник перетаскивания и отбросит работу, находится в пределах той же самой физической JVM как получатель drop уведомление, и ложь иначе.

Это различие является существенным получателю, когда оно получает ссылки на объект назад от вызова Transferable.getTransferData в локальном случае, так как в этом случае ссылка на объект, которую это получает, является той же самой ссылкой на объект, сохраненной источником (то есть это не копия, прокси или отличный объект), таким образом, получатель должен обработать такую совместно используемую ссылку на объект по-другому в локальном случае следующим образом:

dropComplete метод сигнализирует, что конец связанного перетаскивает и отбрасывает работу, и указывает на успех (или отказ) передач, выполняемых получателем. Вызов этого метода приводит к DragSourceListener's dragDropEnd метод, вызываемый с соответствующим состоянием, доступным от, это DragSourceDropEvent. Отказ вызвать этот метод приведет к перетаскиванию и отбросит работу, бывшую не в состоянии завершаться должным образом.

2.4.6 Автопрокрутка Поддержки

Многие GUI Components представляют "область просмотра" с возможностью прокрутки по (потенциально) большому набору данных. Во время работы перетаскивания и отбрасывания это является требуемым, чтобы быть в состоянии "автопрокрутить" такие "области просмотра", чтобы позволить пользователю перемещаться по такому набору данных, прокручивая, чтобы определить местоположение определенного элемента (первоначально не видимый через "область просмотра"), что они хотят отбросить предмет работы на.

Components, которые с возможностью прокрутки, обеспечивают, перетаскивают "автопрокрутку" поддержки их DropTarget реализовывая следующий интерфейс:

public interface Autoscroll {
        Insets getAutoscrollInsets();
        void autoScrollContent(Point cursorLocn);
}

Реализация DropTarget буду периодически вызывать autoscroll метод его связанного Component (если есть), передавая текущую логическую позицию курсора в Component координаты, когда следующие условия встречаются:

Если любое из вышеупомянутых условий прекращает быть допустимым, автопрокрутка должна завершиться, пока следующее условие инициирования не происходит.

Оба начальная задержка до автопрокрутки открытия, интервала между автопрокруткой уведомлений, и пиксельным значением гистерезиса внешне конфигурируема и может быть запрошена от Toolkit.getDesktopProperty метод.

2.5 Фаза Передачи данных

В случае, где допустимое отбрасывание происходит, DropTargetListener's drop метод ответственен за обязательство передачи данных, связанных жестом. DropTargetDropEvent обеспечивает средство получить a Transferable объект, которые представляют тот объект (ы) данных, который будет передан.

От drop метод, DropTargetListener будет первоначально также rejectDrop (сразу возвращающийся после того) или acceptDrop определение выбранной работы от возвращенных getSourceActions.

Последующий за acceptDrop, но не прежде, getTransferable может быть вызван, и любые передачи данных, выполняемые через возвращенный Transferable's getTransferData метод. Наконец, как только место назначения отбрасывания завершило передачу (и) объектов из источника, из которого это должно сигнализировать успех, или непосредственный отказ, передачи () через вызов DropTargetContext.dropComplete.

После возврата из DropTargetContext.dropComplete метод Transferable и DragSourceContext экземпляры, как больше гарантируют, не будут допустимы, и все ссылки на них должны быть отброшены получателем, чтобы позволить им быть впоследствии собранными "мусор".

При использовании работы ACTION_REFERENCE источник и место назначения должны заботиться, чтобы согласовать объект и связанную семантику передачи. Обычно в передачах внутри-JVM живую ссылку на объект передали бы между источником и местом назначения, но в случае передач меж-JVM, или передачи между собственным и приложениями Java, живые ссылки на объект не имеют смысла, таким образом, некоторым другим 'ссылочным' типом нужно обменяться, такие как URI например. Оба DragSource и DropTarget может обнаружить, если передача является внутри-JVM или нет.

2.5.1 FlavorMap и SystemFlavorMap

Все целевые платформы DnD представляют свои типы данных передачи, используя подобный механизм, однако представления действительно отличаются. Платформа Java использует типы MIME, инкапсулировавшие в пределах a DataFlavor представлять его типы данных. К сожалению, чтобы разрешить передачу данных между Java и платформой собственные приложения, существование этих имен платформы должно быть представлено, таким образом механизм требуется, чтобы создать расширяемое (независимое от платформы) отображение между этими именами зависимого типа платформы, их представлениями, и базируемым MIME Java DataFlavors.

Реализация обеспечит механизм, чтобы внешне определить отображение между платформой собственные типы данных (строки) и типами MIME (строки), используемые, чтобы создать DataFlavors. Это внешнее отображение будет использоваться базовой платформой определенный код реализации, чтобы представить соответствующее DataFlavors (Типы MIME), экспортируемый источником, месту назначения, через базовую платформу механизмы DnD.

Оба DragSource и DropTarget классы обеспечивают доступ для базовой системы, чтобы отобразить платформу зависимые имена к и от DataFlavors.

public interface java.awt.datatransfer.FlavorMap {
        java.util.Map getNativesForFlavors(DataFlavor[] dfs);
        java.util.Map getFlavorsForNatives(String[] natives);
}

getNativesForFlavors метод берет массив DataFlavors и возвраты a Map объект, содержащий нуль или больше ключей типа DataFlavor, от фактического параметра dfs, с присваиваемыми значениями типа String, которые соответствуют имени зависимого типа платформы для того типа MIME.

getFlavorsForNatives метод берет массив String типы и возвраты a Map объект, содержащий нуль или больше ключей типа String, от фактических уроженцев параметра, с присваиваемыми значениями типа DataFlavor, которые соответствуют независимому от платформы типу для того имени зависимого типа платформы.

Map объект, возвращенный обоими методами, может быть изменчив, но не обязан быть.

Если НУЛЬ передают к любому из этих методов, они должны возвратить свою текущую карту всех ключей и оценивают известный реализации во время вызова.

Например на Win32 Имя Формата Буфера обмена для простого текста является "CF_TEXT" (фактически, это - целое число 1), и на Мотиве это - Atom X11 под названием "СТРОКА", тип MIME, который можно использовать, чтобы представить, это было бы "текстом/плоскостью; charset=us-ascii". Поэтому переносимая платформа FlavorMap отобразился бы между этими именами; CF_TEXT на win32 и СТРОКА на Motif/X11.

Как правило, как реализовано в SystemFlavorMap эти отображения сохранены во внешнем персистентном формате конфигурации (файл свойств или URL) и загружаются из платформы, чтобы сконфигурировать FlavorMap соответственно для данной платформы.

SystemFlavorMap class обеспечивается, чтобы реализовать простое, платформа конфигурируемый механизм для того, чтобы определить набор в масштабе всей системы общих отображений, и определяется следующим образом:

public class  java.awt.datatransfer.SystemFlavorMap implements FlavorMap, FlavorTable {
        public static FlavorMap getSystemFlavorMap(); 
        public synchronized Map getNativesForFlavors(DataFlavor[] dfs); 
        public synchronized Map getFlavorsForNatives(String[] natives); 
        public static String encodeDataFlavor(DataFlavor flav); 
        public static String encodeJavaMIMEType(String mimeType);
        public static boolean isJavaMIMEType(String mimeStr); 
        public static String decodeJavaMIMEType(String nat);
        public static DataFlavor decodeDataFlavor(String nat); 
        //...
}

SystemFlavorMap class обеспечивает простую реализацию, используя файл свойств (см. java.awt.Properties), персистентной платформы FlavorMap. Используя значение свойства AWT "AWT.flavorMapFileURL" (см. Toolkit.getProperty) или расположение файла по умолчанию System.getProperty("java.home") + File.separator + "lib" + File.separator + "flavormap.properties", этот class создает соответствующее Maps от свойств, найденных там.

Кроме того, class обеспечивает несколько статических функций удобства, используемых, чтобы закодировать и декодировать Java MimeTypes к и с платформы зависимое пространство имен. Синтаксис файла свойств:

{<platform_type_name> ‘=' <IETF_MIME_RFC_conformant_specification> <сш>} *

Реализации по умолчанию DragSource и DropTarget возвратитесь SystemFlavorMap от их getFlavorMap метод, если им не предоставили реализацию переопределения.

2.5.2 Передача Данных через границу JVM

Так как одна из основных целей этого API состоит в том, чтобы позволить, перетаскивают и отбрасывание данных между Java и собственными приложениями, у этого есть некоторые существенные последствия на метод и механизм фактического кодирования данных и обмена, когда данные передают через границу виртуальной машины Java.

Так как один из участников такого обмена может быть собственным приложением, и таким образом не имеет никакого знания системы типов Java, система перетаскивания и отбрасывания не может просто обмениваться ссылкой на объект Java, так как у другого участника не может быть никакого знания, или возможность управлять таким типом.

Когда любой обмен происходит, он может только сделать так, независимо от реализации участников, если и только если оба участника согласовываются относительно знакомого типа данных и кодирования. Таким образом печально бремя обмена рождается главным образом участниками непосредственно.

Что это означает, на практике то, что для "собственных" форматов данных, таких как зависимое от платформы изображение, документ, или другие "Типы контента" кодирование и декодирование их связанного внешнего формата данных являются ответственностью источника и местом назначения передачи.

Система перетаскивания и отбрасывания должна представить внешнее представление таких "собственных" типов данных через границу виртуальной машины Java как инкапсулирующийся в пределах a java.io.InputStream или подкласс этого.

Это означает что любой DataFlavor с представлением class, который расширяется java.io.InputStream может быть передан, и будет представлен для передачи, через границу виртуальной машины Java.

Чтобы реализовать обмен таким собственным типом данных, разработчик определил бы a DataFlavor с MIME "Тип контента", который описывает природу "собственного" типа данных с представлением class, который расширяет a java.io.InputStream class, который кодирует данные, инкапсулировавшие в поток байтов.

В особенности такой InputStream подклассы должны реализовать следующую семантику:

Условие этого метода (или наследование реализации суперклассов) включает системе перетаскивания и отбрасывания (связанный с DragSource) автоматически извлечь закодированный поток инкапсулировавших данных от Transferable, таким образом включая передаче данных через границу JVM как простой поток байтов просителю детали DataFlavor.

2.5.3 Передача списков файлов через границу JVM.

Типичным предметом передачи Перетаскивания и Отбрасывания является список одной или более платформ зависимые имена файлов. Чтобы ослабить задачу программирования разработчиков или создание или потребление таких списков, система перетаскивания и отбрасывания обрабатывает их как особый случай.

Если a DataFlavor определяется с MIME "Тип контента" application/x-java-file-list;class=java.util.List система перетаскивания и отбрасывания будет ожидать, что элементы списка будут гомогенным списком объектов типа java.io.File. Таким образом источник, поддерживая передачу списка файлов, должен создать такой List из File объекты, когда такой DataFlavor требуется, и получатель должен ожидать такой List из File объекты, если это запрашивает такое допустимое DataFlavor из его источника. Этот особый случай обеспечивает простой механизм для передачи списков файлов между источником и целью.

2.5.4 Передача java.rmi. Удаленные ссылки через границу JVM.

Возможно Перетащить и Отбросить ссылки на объект между JVM при использовании средств механизма RMI. Система Перетаскивания и Отбрасывания автоматически устроит передачу любой ссылки на объект, которая придерживается этих требований:

Если эти условия соблюдают, то если соответствующее DataFlavor требуется, тогда объект, возвращенный просителю (если это будет в JVM различия из источника), то будет ссылка RMI на экземпляр Remote возразите подынтерфейсу, определенному как представление class DataFlavor.

3.0 Проблемы

3.0.1 Каковы импликации различных механизмов протокола платформы?

Из-за ограничений определенной базовой платформы перетаскивают и отбрасывают и реализации оконной системы, взаимодействие перетащить работы, и семантика поставки события к AWT Components зависимая платформа. Поэтому во время перетащить работы a DragSource может обработать События Оконной системы платформы, имеющие отношение, это перетаскивает исключая нормальную обработку событий.

Из-за взаимодействий между однопоточным центром проекта платформы собственные системы DnD, и собственными реализациями диспетчеризации события оконной системы в AWT, "обратными вызовами" в DropTargetListener и DragSourceListener произойдет или на, или синхронизировался с системным событием AWT, диспетчеризируют поток. Это поведение чрезвычайно нежелательно для соображений безопасности, но является реализацией, не архитектурной функцией, и неизбежно.

3.0.2 Inter/Intra VM передачи?

Чтобы включить внутри-JVM Перетаскивают и Передачи Отбрасывания существующее DataFlavor class будет расширен, чтобы позволить этому представить тип "живой" ссылки на объект, в противоположность Сериализированному (персистентному) представлению одного. Такие объекты могут быть переданы между источником и местом назначения в пределах той же самой JVM и ClassLoader контекст.

Тип контента MIME должен быть application/x-java-local-objectref.

3.0.3 Время жизни Передаваемого (s)?

Transferable объекты, их связанное DataFlavors', и объекты, которые инкапсулируют базовые данные, определенные как операнд (ы) перетаскивания, и отбрасывают работу, не должны остаться допустимыми до, по крайней мере, DragSourceListener связанный с DragSource управляя работой, получает a dragDropEnd. Время жизни предмета (ов) работы, переданной между источником и целью, является реализацией, определенной кроме того момент времени.

3.0.4 Импликации семантики ACTION_MOVE на исходных объектах, представленных через Передаваемый?

"Источник" успешного Перетаскивает и Отбрасывание (ACTION_MOVE), работа обязана удалять/оставлять все ссылки на объект (ы), которые являются предметом Transferable сразу после того, как передача была успешно завершена. Это прежде возвращается из DragSourceListener.dragDropEnd уведомление.

3.0.5 Семантика работы ACTION_REFERENCE.

В результате существенного ввода от разработчиков к более ранней версии спецификации дополнительный тег работы/действия; ACTION_REFERENCE был добавлен, чтобы включать существующую платформу, Перетаскивают и семантика "Ссылки" Отбрасывания.

Считается, что Ссылка, или Ссылка, семантика уже достаточно плохо определяется для собственной платформы, Перетаскивают и Отбрасывание, чтобы представить это чрезвычайно бесполезный даже между собственными приложениями, таким образом между собственными и независимыми от платформы приложениями Java, которые это не рекомендуется.

Для Java к использованию Java необходимое семантическое; в пределах той же самой JVM /ClassLoader, определяется так, что, место назначения должно получить ссылку на объект Java на предмет (ы) передачи. Между JVM Java или ClassLoaders, семантическое является определенной реализацией, но могло быть реализовано посредством передачи или URL от источника до места назначения или RMI Remote ссылка.

Приложение A: определение DropTargetPeer

Хотя не нормативная часть этой спецификации это определение включается для ясности:

public interface DropTargetPeer {
        void addDropTarget(DropTarget dt);
        void removeDropTarget(DropTarget dt);
}

Приложение B: определение DragSourceContextPeer

Хотя не нормативная часть этой спецификации это определение включается для ясности:

public interface DragSourceContextPeer {
    void startDrag(DragSourceContext dsc,
                   Cursor            c,
                   Image             di,
                   Point             ioff
    ) throws InvalidDnDOperationException; 
    Cursor getCursor();
    void   setCursor(Cursor c) throws InvalidDnDOperationException;
    void transferablesFlavorsChanged();
}

Приложение C: определение DropTargetContextPeer

Хотя не нормативная часть этой спецификации это определение включается для ясности:

public interface DropTargetContextPeer {
    int  getTargetActions();
    void setTargetActions(int actions); 
    DropTarget getDropTarget(); 
    DataFlavor[] getTransferDataFlavors(); 
    Transferable getTransferable() throws InvalidDnDOperationException;
    boolean isTransferableJVMLocal();
    void acceptDrag(int dragAction);
    void rejectDrag(); 
    void acceptDrop(int dropAction);
    void rejectDrop();
    void dropComplete(boolean success);
}
Oracle и/или его филиалы Авторское право © 1993, 2012, Oracle и/или его филиалы. Все права защищены.
Свяжитесь с Нами