< prev index next >

src/share/classes/java/awt/Container.java

Print this page




  38 import java.io.ObjectInputStream;
  39 import java.io.ObjectOutputStream;
  40 import java.io.ObjectStreamField;
  41 import java.io.PrintStream;
  42 import java.io.PrintWriter;
  43 
  44 import java.lang.ref.WeakReference;
  45 import java.security.AccessController;
  46 
  47 import java.util.ArrayList;
  48 import java.util.EventListener;
  49 import java.util.HashSet;
  50 import java.util.Set;
  51 
  52 import javax.accessibility.*;
  53 
  54 import sun.util.logging.PlatformLogger;
  55 
  56 import sun.awt.AppContext;
  57 import sun.awt.AWTAccessor;

  58 import sun.awt.CausedFocusEvent;
  59 import sun.awt.PeerEvent;
  60 import sun.awt.SunToolkit;
  61 
  62 import sun.awt.dnd.SunDropTargetEvent;
  63 
  64 import sun.java2d.pipe.Region;
  65 
  66 import sun.security.action.GetBooleanAction;
  67 
  68 /**
  69  * A generic Abstract Window Toolkit(AWT) container object is a component
  70  * that can contain other AWT components.
  71  * <p>
  72  * Components added to a container are tracked in a list.  The order
  73  * of the list will define the components' front-to-back stacking order
  74  * within the container.  If no index is specified when adding a
  75  * component to a container, it will be added to the end of the list
  76  * (and hence to the bottom of the stacking order).
  77  * <p>


4752             }
4753             if ((c == null) || ((Window)c).isModalBlocked()) {
4754                 return;
4755             }
4756 
4757             //
4758             // create an internal 'dragged-over' event indicating
4759             // we are being dragged over from another hw component
4760             //
4761             me = new MouseEvent(nativeContainer,
4762                                LWD_MOUSE_DRAGGED_OVER,
4763                                srcEvent.getWhen(),
4764                                srcEvent.getModifiersEx() | srcEvent.getModifiers(),
4765                                srcEvent.getX(),
4766                                srcEvent.getY(),
4767                                srcEvent.getXOnScreen(),
4768                                srcEvent.getYOnScreen(),
4769                                srcEvent.getClickCount(),
4770                                srcEvent.isPopupTrigger(),
4771                                srcEvent.getButton());



4772             ((AWTEvent)srcEvent).copyPrivateDataInto(me);
4773             // translate coordinates to this native container
4774             final Point ptSrcOrigin = srcComponent.getLocationOnScreen();
4775 
4776             if (AppContext.getAppContext() != nativeContainer.appContext) {
4777                 final MouseEvent mouseEvent = me;
4778                 Runnable r = new Runnable() {
4779                         public void run() {
4780                             if (!nativeContainer.isShowing() ) {
4781                                 return;
4782                             }
4783 
4784                             Point       ptDstOrigin = nativeContainer.getLocationOnScreen();
4785                             mouseEvent.translatePoint(ptSrcOrigin.x - ptDstOrigin.x,
4786                                               ptSrcOrigin.y - ptDstOrigin.y );
4787                             Component targetOver =
4788                                 nativeContainer.getMouseEventTarget(mouseEvent.getX(),
4789                                                                     mouseEvent.getY(),
4790                                                                     Container.INCLUDE_SELF);
4791                             trackMouseEnterExit(targetOver, mouseEvent);


4852                                        e.getYOnScreen(),
4853                                        e.getClickCount(),
4854                                        e.isPopupTrigger(),
4855                                        ((MouseWheelEvent)e).getScrollType(),
4856                                        ((MouseWheelEvent)e).getScrollAmount(),
4857                                        ((MouseWheelEvent)e).getWheelRotation(),
4858                                        ((MouseWheelEvent)e).getPreciseWheelRotation());
4859             }
4860             else {
4861                 retargeted = new MouseEvent(target,
4862                                             id,
4863                                             e.getWhen(),
4864                                             e.getModifiersEx() | e.getModifiers(),
4865                                             x,
4866                                             y,
4867                                             e.getXOnScreen(),
4868                                             e.getYOnScreen(),
4869                                             e.getClickCount(),
4870                                             e.isPopupTrigger(),
4871                                             e.getButton());



4872             }
4873 
4874             ((AWTEvent)e).copyPrivateDataInto(retargeted);
4875 
4876             if (target == nativeContainer) {
4877                 // avoid recursively calling LightweightDispatcher...
4878                 ((Container)target).dispatchEventToSelf(retargeted);
4879             } else {
4880                 assert AppContext.getAppContext() == target.appContext;
4881 
4882                 if (nativeContainer.modalComp != null) {
4883                     if (((Container)nativeContainer.modalComp).isAncestorOf(target)) {
4884                         target.dispatchEvent(retargeted);
4885                     } else {
4886                         e.consume();
4887                     }
4888                 } else {
4889                     target.dispatchEvent(retargeted);
4890                 }
4891             }




  38 import java.io.ObjectInputStream;
  39 import java.io.ObjectOutputStream;
  40 import java.io.ObjectStreamField;
  41 import java.io.PrintStream;
  42 import java.io.PrintWriter;
  43 
  44 import java.lang.ref.WeakReference;
  45 import java.security.AccessController;
  46 
  47 import java.util.ArrayList;
  48 import java.util.EventListener;
  49 import java.util.HashSet;
  50 import java.util.Set;
  51 
  52 import javax.accessibility.*;
  53 
  54 import sun.util.logging.PlatformLogger;
  55 
  56 import sun.awt.AppContext;
  57 import sun.awt.AWTAccessor;
  58 import sun.awt.AWTAccessor.MouseEventAccessor;
  59 import sun.awt.CausedFocusEvent;
  60 import sun.awt.PeerEvent;
  61 import sun.awt.SunToolkit;
  62 
  63 import sun.awt.dnd.SunDropTargetEvent;
  64 
  65 import sun.java2d.pipe.Region;
  66 
  67 import sun.security.action.GetBooleanAction;
  68 
  69 /**
  70  * A generic Abstract Window Toolkit(AWT) container object is a component
  71  * that can contain other AWT components.
  72  * <p>
  73  * Components added to a container are tracked in a list.  The order
  74  * of the list will define the components' front-to-back stacking order
  75  * within the container.  If no index is specified when adding a
  76  * component to a container, it will be added to the end of the list
  77  * (and hence to the bottom of the stacking order).
  78  * <p>


4753             }
4754             if ((c == null) || ((Window)c).isModalBlocked()) {
4755                 return;
4756             }
4757 
4758             //
4759             // create an internal 'dragged-over' event indicating
4760             // we are being dragged over from another hw component
4761             //
4762             me = new MouseEvent(nativeContainer,
4763                                LWD_MOUSE_DRAGGED_OVER,
4764                                srcEvent.getWhen(),
4765                                srcEvent.getModifiersEx() | srcEvent.getModifiers(),
4766                                srcEvent.getX(),
4767                                srcEvent.getY(),
4768                                srcEvent.getXOnScreen(),
4769                                srcEvent.getYOnScreen(),
4770                                srcEvent.getClickCount(),
4771                                srcEvent.isPopupTrigger(),
4772                                srcEvent.getButton());
4773             MouseEventAccessor meAccessor = AWTAccessor.getMouseEventAccessor();
4774             meAccessor.setCausedByTouchEvent(me,
4775                 meAccessor.isCausedByTouchEvent(srcEvent));
4776             ((AWTEvent)srcEvent).copyPrivateDataInto(me);
4777             // translate coordinates to this native container
4778             final Point ptSrcOrigin = srcComponent.getLocationOnScreen();
4779 
4780             if (AppContext.getAppContext() != nativeContainer.appContext) {
4781                 final MouseEvent mouseEvent = me;
4782                 Runnable r = new Runnable() {
4783                         public void run() {
4784                             if (!nativeContainer.isShowing() ) {
4785                                 return;
4786                             }
4787 
4788                             Point       ptDstOrigin = nativeContainer.getLocationOnScreen();
4789                             mouseEvent.translatePoint(ptSrcOrigin.x - ptDstOrigin.x,
4790                                               ptSrcOrigin.y - ptDstOrigin.y );
4791                             Component targetOver =
4792                                 nativeContainer.getMouseEventTarget(mouseEvent.getX(),
4793                                                                     mouseEvent.getY(),
4794                                                                     Container.INCLUDE_SELF);
4795                             trackMouseEnterExit(targetOver, mouseEvent);


4856                                        e.getYOnScreen(),
4857                                        e.getClickCount(),
4858                                        e.isPopupTrigger(),
4859                                        ((MouseWheelEvent)e).getScrollType(),
4860                                        ((MouseWheelEvent)e).getScrollAmount(),
4861                                        ((MouseWheelEvent)e).getWheelRotation(),
4862                                        ((MouseWheelEvent)e).getPreciseWheelRotation());
4863             }
4864             else {
4865                 retargeted = new MouseEvent(target,
4866                                             id,
4867                                             e.getWhen(),
4868                                             e.getModifiersEx() | e.getModifiers(),
4869                                             x,
4870                                             y,
4871                                             e.getXOnScreen(),
4872                                             e.getYOnScreen(),
4873                                             e.getClickCount(),
4874                                             e.isPopupTrigger(),
4875                                             e.getButton());
4876                 MouseEventAccessor meAccessor = AWTAccessor.getMouseEventAccessor();
4877                 meAccessor.setCausedByTouchEvent(retargeted,
4878                     meAccessor.isCausedByTouchEvent(e));
4879             }
4880 
4881             ((AWTEvent)e).copyPrivateDataInto(retargeted);
4882 
4883             if (target == nativeContainer) {
4884                 // avoid recursively calling LightweightDispatcher...
4885                 ((Container)target).dispatchEventToSelf(retargeted);
4886             } else {
4887                 assert AppContext.getAppContext() == target.appContext;
4888 
4889                 if (nativeContainer.modalComp != null) {
4890                     if (((Container)nativeContainer.modalComp).isAncestorOf(target)) {
4891                         target.dispatchEvent(retargeted);
4892                     } else {
4893                         e.consume();
4894                     }
4895                 } else {
4896                     target.dispatchEvent(retargeted);
4897                 }
4898             }


< prev index next >