History

My first initial commit with all of mine experimental changes.

Dmitry Kabak (userdima committed 13 years ago

Commit d37b88d1 parent 3f5b46618352 files · +2598093 −-8690Browse files

Showing the changes to java/pkg/java/awt/dnd/DropTarget.java (1 of 18352 files). Show all

Unified · Split

java/pkg/java/awt/dnd/DropTarget.java+858−0
@@ -0,0 +1,858 @@
1+/*
2+ * Copyright (c) 1997, 2008, Oracle and/or its affiliates. All rights reserved.
3+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4+ *
5+ * This code is free software; you can redistribute it and/or modify it
6+ * under the terms of the GNU General Public License version 2 only, as
7+ * published by the Free Software Foundation. Oracle designates this
8+ * particular file as subject to the "Classpath" exception as provided
9+ * by Oracle in the LICENSE file that accompanied this code.
10+ *
11+ * This code is distributed in the hope that it will be useful, but WITHOUT
12+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14+ * version 2 for more details (a copy is included in the LICENSE file that
15+ * accompanied this code).
16+ *
17+ * You should have received a copy of the GNU General Public License version
18+ * 2 along with this work; if not, write to the Free Software Foundation,
19+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20+ *
21+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22+ * or visit www.oracle.com if you need additional information or have any
23+ * questions.
24+ */
25+
26+package java.awt.dnd;
27+
28+import java.util.TooManyListenersException;
29+
30+import java.io.IOException;
31+import java.io.ObjectInputStream;
32+import java.io.ObjectOutputStream;
33+import java.io.Serializable;
34+
35+import java.awt.Component;
36+import java.awt.Dimension;
37+import java.awt.GraphicsEnvironment;
38+import java.awt.HeadlessException;
39+import java.awt.Insets;
40+import java.awt.Point;
41+import java.awt.Rectangle;
42+import java.awt.Toolkit;
43+import java.awt.event.ActionEvent;
44+import java.awt.event.ActionListener;
45+import java.awt.datatransfer.FlavorMap;
46+import java.awt.datatransfer.SystemFlavorMap;
47+import javax.swing.Timer;
48+import java.awt.peer.ComponentPeer;
49+import java.awt.peer.LightweightPeer;
50+import java.awt.dnd.peer.DropTargetPeer;
51+
52+
53+/**
54+ * The <code>DropTarget</code> is associated
55+ * with a <code>Component</code> when that <code>Component</code>
56+ * wishes
57+ * to accept drops during Drag and Drop operations.
58+ * <P>
59+ * Each
60+ * <code>DropTarget</code> is associated with a <code>FlavorMap</code>.
61+ * The default <code>FlavorMap</code> hereafter designates the
62+ * <code>FlavorMap</code> returned by <code>SystemFlavorMap.getDefaultFlavorMap()</code>.
63+ *
64+ * @since 1.2
65+ */
66+
67+public class DropTarget implements DropTargetListener, Serializable {
68+
69+ private static final long serialVersionUID = -6283860791671019047L;
70+
71+ /**
72+ * Creates a new DropTarget given the <code>Component</code>
73+ * to associate itself with, an <code>int</code> representing
74+ * the default acceptable action(s) to
75+ * support, a <code>DropTargetListener</code>
76+ * to handle event processing, a <code>boolean</code> indicating
77+ * if the <code>DropTarget</code> is currently accepting drops, and
78+ * a <code>FlavorMap</code> to use (or null for the default <CODE>FlavorMap</CODE>).
79+ * <P>
80+ * The Component will receive drops only if it is enabled.
81+ * @param c The <code>Component</code> with which this <code>DropTarget</code> is associated
82+ * @param ops The default acceptable actions for this <code>DropTarget</code>
83+ * @param dtl The <code>DropTargetListener</code> for this <code>DropTarget</code>
84+ * @param act Is the <code>DropTarget</code> accepting drops.
85+ * @param fm The <code>FlavorMap</code> to use, or null for the default <CODE>FlavorMap</CODE>
86+ * @exception HeadlessException if GraphicsEnvironment.isHeadless()
87+ * returns true
88+ * @see java.awt.GraphicsEnvironment#isHeadless
89+ */
90+ public DropTarget(Component c, int ops, DropTargetListener dtl,
91+ boolean act, FlavorMap fm)
92+ throws HeadlessException
93+ {
94+ if (GraphicsEnvironment.isHeadless()) {
95+ throw new HeadlessException();
96+ }
97+
98+ component = c;
99+
100+ setDefaultActions(ops);
101+
102+ if (dtl != null) try {
103+ addDropTargetListener(dtl);
104+ } catch (TooManyListenersException tmle) {
105+ // do nothing!
106+ }
107+
108+ if (c != null) {
109+ c.setDropTarget(this);
110+ setActive(act);
111+ }
112+
113+ if (fm != null) {
114+ flavorMap = fm;
115+ } else {
116+ flavorMap = SystemFlavorMap.getDefaultFlavorMap();
117+ }
118+ }
119+
120+ /**
121+ * Creates a <code>DropTarget</code> given the <code>Component</code>
122+ * to associate itself with, an <code>int</code> representing
123+ * the default acceptable action(s)
124+ * to support, a <code>DropTargetListener</code>
125+ * to handle event processing, and a <code>boolean</code> indicating
126+ * if the <code>DropTarget</code> is currently accepting drops.
127+ * <P>
128+ * The Component will receive drops only if it is enabled.
129+ * @param c The <code>Component</code> with which this <code>DropTarget</code> is associated
130+ * @param ops The default acceptable actions for this <code>DropTarget</code>
131+ * @param dtl The <code>DropTargetListener</code> for this <code>DropTarget</code>
132+ * @param act Is the <code>DropTarget</code> accepting drops.
133+ * @exception HeadlessException if GraphicsEnvironment.isHeadless()
134+ * returns true
135+ * @see java.awt.GraphicsEnvironment#isHeadless
136+ */
137+ public DropTarget(Component c, int ops, DropTargetListener dtl,
138+ boolean act)
139+ throws HeadlessException
140+ {
141+ this(c, ops, dtl, act, null);
142+ }
143+
144+ /**
145+ * Creates a <code>DropTarget</code>.
146+ * @exception HeadlessException if GraphicsEnvironment.isHeadless()
147+ * returns true
148+ * @see java.awt.GraphicsEnvironment#isHeadless
149+ */
150+ public DropTarget() throws HeadlessException {
151+ this(null, DnDConstants.ACTION_COPY_OR_MOVE, null, true, null);
152+ }
153+
154+ /**
155+ * Creates a <code>DropTarget</code> given the <code>Component</code>
156+ * to associate itself with, and the <code>DropTargetListener</code>
157+ * to handle event processing.
158+ * <P>
159+ * The Component will receive drops only if it is enabled.
160+ * @param c The <code>Component</code> with which this <code>DropTarget</code> is associated
161+ * @param dtl The <code>DropTargetListener</code> for this <code>DropTarget</code>
162+ * @exception HeadlessException if GraphicsEnvironment.isHeadless()
163+ * returns true
164+ * @see java.awt.GraphicsEnvironment#isHeadless
165+ */
166+ public DropTarget(Component c, DropTargetListener dtl)
167+ throws HeadlessException
168+ {
169+ this(c, DnDConstants.ACTION_COPY_OR_MOVE, dtl, true, null);
170+ }
171+
172+ /**
173+ * Creates a <code>DropTarget</code> given the <code>Component</code>
174+ * to associate itself with, an <code>int</code> representing
175+ * the default acceptable action(s) to support, and a
176+ * <code>DropTargetListener</code> to handle event processing.
177+ * <P>
178+ * The Component will receive drops only if it is enabled.
179+ * @param c The <code>Component</code> with which this <code>DropTarget</code> is associated
180+ * @param ops The default acceptable actions for this <code>DropTarget</code>
181+ * @param dtl The <code>DropTargetListener</code> for this <code>DropTarget</code>
182+ * @exception HeadlessException if GraphicsEnvironment.isHeadless()
183+ * returns true
184+ * @see java.awt.GraphicsEnvironment#isHeadless
185+ */
186+ public DropTarget(Component c, int ops, DropTargetListener dtl)
187+ throws HeadlessException
188+ {
189+ this(c, ops, dtl, true);
190+ }
191+
192+ /**
193+ * Note: this interface is required to permit the safe association
194+ * of a DropTarget with a Component in one of two ways, either:
195+ * <code> component.setDropTarget(droptarget); </code>
196+ * or <code> droptarget.setComponent(component); </code>
197+ * <P>
198+ * The Component will receive drops only if it is enabled.
199+ * @param c The new <code>Component</code> this <code>DropTarget</code>
200+ * is to be associated with.<P>
201+ */
202+
203+ public synchronized void setComponent(Component c) {
204+ if (component == c || component != null && component.equals(c))
205+ return;
206+
207+ Component old;
208+ ComponentPeer oldPeer = null;
209+
210+ if ((old = component) != null) {
211+ clearAutoscroll();
212+
213+ component = null;
214+
215+ if (componentPeer != null) {
216+ oldPeer = componentPeer;
217+ removeNotify(componentPeer);
218+ }
219+
220+ old.setDropTarget(null);
221+
222+ }
223+
224+ if ((component = c) != null) try {
225+ c.setDropTarget(this);
226+ } catch (Exception e) { // undo the change
227+ if (old != null) {
228+ old.setDropTarget(this);
229+ addNotify(oldPeer);
230+ }
231+ }
232+ }
233+
234+ /**
235+ * Gets the <code>Component</code> associated
236+ * with this <code>DropTarget</code>.
237+ * <P>
238+ * @return the current <code>Component</code>
239+ */
240+
241+ public synchronized Component getComponent() {
242+ return component;
243+ }
244+
245+ /**
246+ * Sets the default acceptable actions for this <code>DropTarget</code>
247+ * <P>
248+ * @param ops the default actions
249+ * <P>
250+ * @see java.awt.dnd.DnDConstants
251+ */
252+
253+ public void setDefaultActions(int ops) {
254+ getDropTargetContext().setTargetActions(ops & (DnDConstants.ACTION_COPY_OR_MOVE | DnDConstants.ACTION_REFERENCE));
255+ }
256+
257+ /*
258+ * Called by DropTargetContext.setTargetActions()
259+ * with appropriate synchronization.
260+ */
261+ void doSetDefaultActions(int ops) {
262+ actions = ops;
263+ }
264+
265+ /**
266+ * Gets an <code>int</code> representing the
267+ * current action(s) supported by this <code>DropTarget</code>.
268+ * <P>
269+ * @return the current default actions
270+ */
271+
272+ public int getDefaultActions() {
273+ return actions;
274+ }
275+
276+ /**
277+ * Sets the DropTarget active if <code>true</code>,
278+ * inactive if <code>false</code>.
279+ * <P>
280+ * @param isActive sets the <code>DropTarget</code> (in)active.
281+ */
282+
283+ public synchronized void setActive(boolean isActive) {
284+ if (isActive != active) {
285+ active = isActive;
286+ }
287+
288+ if (!active) clearAutoscroll();
289+ }
290+
291+ /**
292+ * Reports whether or not
293+ * this <code>DropTarget</code>
294+ * is currently active (ready to accept drops).
295+ * <P>
296+ * @return <CODE>true</CODE> if active, <CODE>false</CODE> if not
297+ */
298+
299+ public boolean isActive() {
300+ return active;
301+ }
302+
303+ /**
304+ * Adds a new <code>DropTargetListener</code> (UNICAST SOURCE).
305+ * <P>
306+ * @param dtl The new <code>DropTargetListener</code>
307+ * <P>
308+ * @throws <code>TooManyListenersException</code> if a
309+ * <code>DropTargetListener</code> is already added to this
310+ * <code>DropTarget</code>.
311+ */
312+
313+ public synchronized void addDropTargetListener(DropTargetListener dtl) throws TooManyListenersException {
314+ if (dtl == null) return;
315+
316+ if (equals(dtl)) throw new IllegalArgumentException("DropTarget may not be its own Listener");
317+
318+ if (dtListener == null)
319+ dtListener = dtl;
320+ else
321+ throw new TooManyListenersException();
322+ }
323+
324+ /**
325+ * Removes the current <code>DropTargetListener</code> (UNICAST SOURCE).
326+ * <P>
327+ * @param dtl the DropTargetListener to deregister.
328+ */
329+
330+ public synchronized void removeDropTargetListener(DropTargetListener dtl) {
331+ if (dtl != null && dtListener != null) {
332+ if(dtListener.equals(dtl))
333+ dtListener = null;
334+ else
335+ throw new IllegalArgumentException("listener mismatch");
336+ }
337+ }
338+
339+ /**
340+ * Calls <code>dragEnter</code> on the registered
341+ * <code>DropTargetListener</code> and passes it
342+ * the specified <code>DropTargetDragEvent</code>.
343+ * Has no effect if this <code>DropTarget</code>
344+ * is not active.
345+ *
346+ * @param dtde the <code>DropTargetDragEvent</code>
347+ *
348+ * @throws NullPointerException if this <code>DropTarget</code>
349+ * is active and <code>dtde</code> is <code>null</code>
350+ *
351+ * @see #isActive
352+ */
353+ public synchronized void dragEnter(DropTargetDragEvent dtde) {
354+ if (!active) return;
355+
356+ if (dtListener != null) {
357+ dtListener.dragEnter(dtde);
358+ } else
359+ dtde.getDropTargetContext().setTargetActions(DnDConstants.ACTION_NONE);
360+
361+ initializeAutoscrolling(dtde.getLocation());
362+ }
363+
364+ /**
365+ * Calls <code>dragOver</code> on the registered
366+ * <code>DropTargetListener</code> and passes it
367+ * the specified <code>DropTargetDragEvent</code>.
368+ * Has no effect if this <code>DropTarget</code>
369+ * is not active.
370+ *
371+ * @param dtde the <code>DropTargetDragEvent</code>
372+ *
373+ * @throws NullPointerException if this <code>DropTarget</code>
374+ * is active and <code>dtde</code> is <code>null</code>
375+ *
376+ * @see #isActive
377+ */
378+ public synchronized void dragOver(DropTargetDragEvent dtde) {
379+ if (!active) return;
380+
381+ if (dtListener != null && active) dtListener.dragOver(dtde);
382+
383+ updateAutoscroll(dtde.getLocation());
384+ }
385+
386+ /**
387+ * Calls <code>dropActionChanged</code> on the registered
388+ * <code>DropTargetListener</code> and passes it
389+ * the specified <code>DropTargetDragEvent</code>.
390+ * Has no effect if this <code>DropTarget</code>
391+ * is not active.
392+ *
393+ * @param dtde the <code>DropTargetDragEvent</code>
394+ *
395+ * @throws NullPointerException if this <code>DropTarget</code>
396+ * is active and <code>dtde</code> is <code>null</code>
397+ *
398+ * @see #isActive
399+ */
400+ public synchronized void dropActionChanged(DropTargetDragEvent dtde) {
401+ if (!active) return;
402+
403+ if (dtListener != null) dtListener.dropActionChanged(dtde);
404+
405+ updateAutoscroll(dtde.getLocation());
406+ }
407+
408+ /**
409+ * Calls <code>dragExit</code> on the registered
410+ * <code>DropTargetListener</code> and passes it
411+ * the specified <code>DropTargetEvent</code>.
412+ * Has no effect if this <code>DropTarget</code>
413+ * is not active.
414+ * <p>
415+ * This method itself does not throw any exception
416+ * for null parameter but for exceptions thrown by
417+ * the respective method of the listener.
418+ *
419+ * @param dte the <code>DropTargetEvent</code>
420+ *
421+ * @see #isActive
422+ */
423+ public synchronized void dragExit(DropTargetEvent dte) {
424+ if (!active) return;
425+
426+ if (dtListener != null && active) dtListener.dragExit(dte);
427+
428+ clearAutoscroll();
429+ }
430+
431+ /**
432+ * Calls <code>drop</code> on the registered
433+ * <code>DropTargetListener</code> and passes it
434+ * the specified <code>DropTargetDropEvent</code>
435+ * if this <code>DropTarget</code> is active.
436+ *
437+ * @param dtde the <code>DropTargetDropEvent</code>
438+ *
439+ * @throws NullPointerException if <code>dtde</code> is null
440+ * and at least one of the following is true: this
441+ * <code>DropTarget</code> is not active, or there is
442+ * no a <code>DropTargetListener</code> registered.
443+ *
444+ * @see #isActive
445+ */
446+ public synchronized void drop(DropTargetDropEvent dtde) {
447+ clearAutoscroll();
448+
449+ if (dtListener != null && active)
450+ dtListener.drop(dtde);
451+ else { // we should'nt get here ...
452+ dtde.rejectDrop();
453+ }
454+ }
455+
456+ /**
457+ * Gets the <code>FlavorMap</code>
458+ * associated with this <code>DropTarget</code>.
459+ * If no <code>FlavorMap</code> has been set for this
460+ * <code>DropTarget</code>, it is associated with the default
461+ * <code>FlavorMap</code>.
462+ * <P>
463+ * @return the FlavorMap for this DropTarget
464+ */
465+
466+ public FlavorMap getFlavorMap() { return flavorMap; }
467+
468+ /**
469+ * Sets the <code>FlavorMap</code> associated
470+ * with this <code>DropTarget</code>.
471+ * <P>
472+ * @param fm the new <code>FlavorMap</code>, or null to
473+ * associate the default FlavorMap with this DropTarget.
474+ */
475+
476+ public void setFlavorMap(FlavorMap fm) {
477+ flavorMap = fm == null ? SystemFlavorMap.getDefaultFlavorMap() : fm;
478+ }
479+
480+ /**
481+ * Notify the DropTarget that it has been associated with a Component
482+ *
483+ **********************************************************************
484+ * This method is usually called from java.awt.Component.addNotify() of
485+ * the Component associated with this DropTarget to notify the DropTarget
486+ * that a ComponentPeer has been associated with that Component.
487+ *
488+ * Calling this method, other than to notify this DropTarget of the
489+ * association of the ComponentPeer with the Component may result in
490+ * a malfunction of the DnD system.
491+ **********************************************************************
492+ * <P>
493+ * @param peer The Peer of the Component we are associated with!
494+ *
495+ */
496+
497+ public void addNotify(ComponentPeer peer) {
498+ if (peer == componentPeer) return;
499+
500+ componentPeer = peer;
501+
502+ for (Component c = component;
503+ c != null && peer instanceof LightweightPeer; c = c.getParent()) {
504+ peer = c.getPeer();
505+ }
506+
507+ if (peer instanceof DropTargetPeer) {
508+ nativePeer = peer;
509+ ((DropTargetPeer)peer).addDropTarget(this);
510+ } else {
511+ nativePeer = null;
512+ }
513+ }
514+
515+ /**
516+ * Notify the DropTarget that it has been disassociated from a Component
517+ *
518+ **********************************************************************
519+ * This method is usually called from java.awt.Component.removeNotify() of
520+ * the Component associated with this DropTarget to notify the DropTarget
521+ * that a ComponentPeer has been disassociated with that Component.
522+ *
523+ * Calling this method, other than to notify this DropTarget of the
524+ * disassociation of the ComponentPeer from the Component may result in
525+ * a malfunction of the DnD system.
526+ **********************************************************************
527+ * <P>
528+ * @param peer The Peer of the Component we are being disassociated from!
529+ */
530+
531+ public void removeNotify(ComponentPeer peer) {
532+ if (nativePeer != null)
533+ ((DropTargetPeer)nativePeer).removeDropTarget(this);
534+
535+ componentPeer = nativePeer = null;
536+ }
537+
538+ /**
539+ * Gets the <code>DropTargetContext</code> associated
540+ * with this <code>DropTarget</code>.
541+ * <P>
542+ * @return the <code>DropTargetContext</code> associated with this <code>DropTarget</code>.
543+ */
544+
545+ public DropTargetContext getDropTargetContext() {
546+ return dropTargetContext;
547+ }
548+
549+ /**
550+ * Creates the DropTargetContext associated with this DropTarget.
551+ * Subclasses may override this method to instantiate their own
552+ * DropTargetContext subclass.
553+ *
554+ * This call is typically *only* called by the platform's
555+ * DropTargetContextPeer as a drag operation encounters this
556+ * DropTarget. Accessing the Context while no Drag is current
557+ * has undefined results.
558+ */
559+
560+ protected DropTargetContext createDropTargetContext() {
561+ return new DropTargetContext(this);
562+ }
563+
564+ /**
565+ * Serializes this <code>DropTarget</code>. Performs default serialization,
566+ * and then writes out this object's <code>DropTargetListener</code> if and
567+ * only if it can be serialized. If not, <code>null</code> is written
568+ * instead.
569+ *
570+ * @serialData The default serializable fields, in alphabetical order,
571+ * followed by either a <code>DropTargetListener</code>
572+ * instance, or <code>null</code>.
573+ * @since 1.4
574+ */
575+ private void writeObject(ObjectOutputStream s) throws IOException {
576+ s.defaultWriteObject();
577+
578+ s.writeObject(SerializationTester.test(dtListener)
579+ ? dtListener : null);
580+ }
581+
582+ /**
583+ * Deserializes this <code>DropTarget</code>. This method first performs
584+ * default deserialization for all non-<code>transient</code> fields. An
585+ * attempt is then made to deserialize this object's
586+ * <code>DropTargetListener</code> as well. This is first attempted by
587+ * deserializing the field <code>dtListener</code>, because, in releases
588+ * prior to 1.4, a non-<code>transient</code> field of this name stored the
589+ * <code>DropTargetListener</code>. If this fails, the next object in the
590+ * stream is used instead.
591+ *
592+ * @since 1.4
593+ */
594+ private void readObject(ObjectInputStream s)
595+ throws ClassNotFoundException, IOException
596+ {
597+ ObjectInputStream.GetField f = s.readFields();
598+
599+ try {
600+ dropTargetContext =
601+ (DropTargetContext)f.get("dropTargetContext", null);
602+ } catch (IllegalArgumentException e) {
603+ // Pre-1.4 support. 'dropTargetContext' was previoulsy transient
604+ }
605+ if (dropTargetContext == null) {
606+ dropTargetContext = createDropTargetContext();
607+ }
608+
609+ component = (Component)f.get("component", null);
610+ actions = f.get("actions", DnDConstants.ACTION_COPY_OR_MOVE);
611+ active = f.get("active", true);
612+
613+ // Pre-1.4 support. 'dtListener' was previously non-transient
614+ try {
615+ dtListener = (DropTargetListener)f.get("dtListener", null);
616+ } catch (IllegalArgumentException e) {
617+ // 1.4-compatible byte stream. 'dtListener' was written explicitly
618+ dtListener = (DropTargetListener)s.readObject();
619+ }
620+ }
621+
622+ /*********************************************************************/
623+
624+ /**
625+ * this protected nested class implements autoscrolling
626+ */
627+
628+ protected static class DropTargetAutoScroller implements ActionListener {
629+
630+ /**
631+ * construct a DropTargetAutoScroller
632+ * <P>
633+ * @param c the <code>Component</code>
634+ * @param p the <code>Point</code>
635+ */
636+
637+ protected DropTargetAutoScroller(Component c, Point p) {
638+ super();
639+
640+ component = c;
641+ autoScroll = (Autoscroll)component;
642+
643+ Toolkit t = Toolkit.getDefaultToolkit();
644+
645+ Integer initial = Integer.valueOf(100);
646+ Integer interval = Integer.valueOf(100);
647+
648+ try {
649+ initial = (Integer)t.getDesktopProperty("DnD.Autoscroll.initialDelay");
650+ } catch (Exception e) {
651+ // ignore
652+ }
653+
654+ try {
655+ interval = (Integer)t.getDesktopProperty("DnD.Autoscroll.interval");
656+ } catch (Exception e) {
657+ // ignore
658+ }
659+
660+ timer = new Timer(interval.intValue(), this);
661+
662+ timer.setCoalesce(true);
663+ timer.setInitialDelay(initial.intValue());
664+
665+ locn = p;
666+ prev = p;
667+
668+ try {
669+ hysteresis = ((Integer)t.getDesktopProperty("DnD.Autoscroll.cursorHysteresis")).intValue();
670+ } catch (Exception e) {
671+ // ignore
672+ }
673+
674+ timer.start();
675+ }
676+
677+ /**
678+ * update the geometry of the autoscroll region
679+ */
680+
681+ private void updateRegion() {
682+ Insets i = autoScroll.getAutoscrollInsets();
683+ Dimension size = component.getSize();
684+
685+ if (size.width != outer.width || size.height != outer.height)
686+ outer.reshape(0, 0, size.width, size.height);
687+
688+ if (inner.x != i.left || inner.y != i.top)
689+ inner.setLocation(i.left, i.top);
690+
691+ int newWidth = size.width - (i.left + i.right);
692+ int newHeight = size.height - (i.top + i.bottom);
693+
694+ if (newWidth != inner.width || newHeight != inner.height)
695+ inner.setSize(newWidth, newHeight);
696+
697+ }
698+
699+ /**
700+ * cause autoscroll to occur
701+ * <P>
702+ * @param newLocn the <code>Point</code>
703+ */
704+
705+ protected synchronized void updateLocation(Point newLocn) {
706+ prev = locn;
707+ locn = newLocn;
708+
709+ if (Math.abs(locn.x - prev.x) > hysteresis ||
710+ Math.abs(locn.y - prev.y) > hysteresis) {
711+ if (timer.isRunning()) timer.stop();
712+ } else {
713+ if (!timer.isRunning()) timer.start();
714+ }
715+ }
716+
717+ /**
718+ * cause autoscrolling to stop
719+ */
720+
721+ protected void stop() { timer.stop(); }
722+
723+ /**
724+ * cause autoscroll to occur
725+ * <P>
726+ * @param e the <code>ActionEvent</code>
727+ */
728+
729+ public synchronized void actionPerformed(ActionEvent e) {
730+ updateRegion();
731+
732+ if (outer.contains(locn) && !inner.contains(locn))
733+ autoScroll.autoscroll(locn);
734+ }
735+
736+ /*
737+ * fields
738+ */
739+
740+ private Component component;
741+ private Autoscroll autoScroll;
742+
743+ private Timer timer;
744+
745+ private Point locn;
746+ private Point prev;
747+
748+ private Rectangle outer = new Rectangle();
749+ private Rectangle inner = new Rectangle();
750+
751+ private int hysteresis = 10;
752+ }
753+
754+ /*********************************************************************/
755+
756+ /**
757+ * create an embedded autoscroller
758+ * <P>
759+ * @param c the <code>Component</code>
760+ * @param p the <code>Point</code>
761+ */
762+
763+ protected DropTargetAutoScroller createDropTargetAutoScroller(Component c, Point p) {
764+ return new DropTargetAutoScroller(c, p);
765+ }
766+
767+ /**
768+ * initialize autoscrolling
769+ * <P>
770+ * @param p the <code>Point</code>
771+ */
772+
773+ protected void initializeAutoscrolling(Point p) {
774+ if (component == null || !(component instanceof Autoscroll)) return;
775+
776+ autoScroller = createDropTargetAutoScroller(component, p);
777+ }
778+
779+ /**
780+ * update autoscrolling with current cursor locn
781+ * <P>
782+ * @param dragCursorLocn the <code>Point</code>
783+ */
784+
785+ protected void updateAutoscroll(Point dragCursorLocn) {
786+ if (autoScroller != null) autoScroller.updateLocation(dragCursorLocn);
787+ }
788+
789+ /**
790+ * clear autoscrolling
791+ */
792+
793+ protected void clearAutoscroll() {
794+ if (autoScroller != null) {
795+ autoScroller.stop();
796+ autoScroller = null;
797+ }
798+ }
799+
800+ /**
801+ * The DropTargetContext associated with this DropTarget.
802+ *
803+ * @serial
804+ */
805+ private DropTargetContext dropTargetContext = createDropTargetContext();
806+
807+ /**
808+ * The Component associated with this DropTarget.
809+ *
810+ * @serial
811+ */
812+ private Component component;
813+
814+ /*
815+ * That Component's Peer
816+ */
817+ private transient ComponentPeer componentPeer;
818+
819+ /*
820+ * That Component's "native" Peer
821+ */
822+ private transient ComponentPeer nativePeer;
823+
824+
825+ /**
826+ * Default permissible actions supported by this DropTarget.
827+ *
828+ * @see #setDefaultActions
829+ * @see #getDefaultActions
830+ * @serial
831+ */
832+ int actions = DnDConstants.ACTION_COPY_OR_MOVE;
833+
834+ /**
835+ * <code>true</code> if the DropTarget is accepting Drag & Drop operations.
836+ *
837+ * @serial
838+ */
839+ boolean active = true;
840+
841+ /*
842+ * the auto scrolling object
843+ */
844+
845+ private transient DropTargetAutoScroller autoScroller;
846+
847+ /*
848+ * The delegate
849+ */
850+
851+ private transient DropTargetListener dtListener;
852+
853+ /*
854+ * The FlavorMap
855+ */
856+
857+ private transient FlavorMap flavorMap;
858+}

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t