zoukankan      html  css  js  c++  java
  • AWTEvent

      1 package java.awt;
      2 import java.util.EventObject;
      3 import java.awt.event.*;
      4 import java.awt.peer.ComponentPeer;
      5 import java.awt.peer.LightweightPeer;
      6 import java.lang.reflect.Field;
      7 import sun.awt.AWTAccessor;
      8 public abstract class AWTEvent extends EventObject 
      9 {
     10     private byte bdata[];
     11     protected int id;
     12     protected boolean consumed = false;
     13     transient boolean focusManagerIsDispatching = false;
     14     transient boolean isPosted;
     15     private transient boolean isSystemGenerated;
     16     public final static long COMPONENT_EVENT_MASK = 0x01;
     17     public final static long CONTAINER_EVENT_MASK = 0x02;
     18     public final static long FOCUS_EVENT_MASK = 0x04;
     19     public final static long KEY_EVENT_MASK = 0x08;
     20     public final static long MOUSE_EVENT_MASK = 0x10;
     21     public final static long MOUSE_MOTION_EVENT_MASK = 0x20;
     22     public final static long WINDOW_EVENT_MASK = 0x40;
     23     public final static long ACTION_EVENT_MASK = 0x80;
     24     public final static long ADJUSTMENT_EVENT_MASK = 0x100;
     25     public final static long ITEM_EVENT_MASK = 0x200;
     26     public final static long TEXT_EVENT_MASK = 0x400;
     27     public final static long INPUT_METHOD_EVENT_MASK = 0x800;
     28     final static long INPUT_METHODS_ENABLED_MASK = 0x1000;
     29     public final static long PAINT_EVENT_MASK = 0x2000;
     30     public final static long INVOCATION_EVENT_MASK = 0x4000;
     31     public final static long HIERARCHY_EVENT_MASK = 0x8000;
     32     public final static long HIERARCHY_BOUNDS_EVENT_MASK = 0x10000;
     33     public final static long MOUSE_WHEEL_EVENT_MASK = 0x20000;
     34     public final static long WINDOW_STATE_EVENT_MASK = 0x40000;
     35     public final static long WINDOW_FOCUS_EVENT_MASK = 0x80000;
     36     public final static int RESERVED_ID_MAX = 1999;
     37     private static Field inputEvent_CanAccessSystemClipboard_Field = null;
     38     private static final long serialVersionUID = -1825314779160409405L;
     39     
     40     static 
     41     {
     42           Toolkit.loadLibraries();
     43         if (!GraphicsEnvironment.isHeadless()) initIDs();
     44         AWTAccessor.setAWTEventAccessor
     45         (
     46             new AWTAccessor.AWTEventAccessor() 
     47             {
     48                 public void setSystemGenerated(AWTEvent ev) 
     49                 {
     50                     ev.isSystemGenerated = true;
     51                 }
     52                 public boolean isSystemGenerated(AWTEvent ev) 
     53                 {
     54                     return ev.isSystemGenerated;
     55                 }
     56             }
     57           );
     58     }
     59     
     60     
     61     private static synchronized Field get_InputEvent_CanAccessSystemClipboard() 
     62     { 
     63         if (inputEvent_CanAccessSystemClipboard_Field == null) 
     64         { 
     65             inputEvent_CanAccessSystemClipboard_Field =(Field)java.security.AccessController.doPrivileged
     66                                                        (
     67                                                                                                 new java.security.PrivilegedAction() 
     68                                                                                                 {
     69                                                                                                 public Object run() 
     70                                                                                                 {
     71                                                                                                     Field field = null;
     72                                                                                                     try 
     73                                                                                                     {
     74                                                                                                         field = InputEvent.class.
     75                                                                                                             getDeclaredField("canAccessSystemClipboard");
     76                                                                                                         field.setAccessible(true);
     77                                                                                                         return field;
     78                                                                                                     } 
     79                                                                                                     catch (SecurityException e) 
     80                                                                                                     {
     81                                                                                                     } 
     82                                                                                                     catch (NoSuchFieldException e) 
     83                                                                                                     {
     84                                                                                                     }
     85                                                                                                     return null;
     86                                                                                                 }
     87                                                                                                  }
     88                                                                                              );
     89         }
     90         return inputEvent_CanAccessSystemClipboard_Field;
     91     }
     92     
     93     
     94     private static native void initIDs();
     95     
     96     
     97     public AWTEvent(Event event) 
     98     {
     99         this(event.target, event.id);
    100     }
    101     
    102     
    103     public AWTEvent(Object source, int id) 
    104     {
    105         super(source);
    106           this.id = id;
    107         switch(id) 
    108         {
    109           case ActionEvent.ACTION_PERFORMED:
    110           case ItemEvent.ITEM_STATE_CHANGED:
    111           case AdjustmentEvent.ADJUSTMENT_VALUE_CHANGED:
    112           case TextEvent.TEXT_VALUE_CHANGED:
    113           consumed = true;
    114           break;
    115           default:
    116         }
    117     }
    118     
    119     
    120     public int getID() 
    121     {
    122         return id;
    123     }
    124     
    125     
    126     public String toString() 
    127     {
    128         String srcName = null;
    129         if (source instanceof Component) 
    130         {
    131             srcName = ((Component)source).getName();
    132         } 
    133         else if (source instanceof MenuComponent) 
    134         {
    135             srcName = ((MenuComponent)source).getName();
    136         }
    137           return getClass().getName() + "[" + paramString() + "] on " +(srcName != null? srcName : source);
    138     }
    139     
    140     
    141     public String paramString() 
    142     {
    143         return "";
    144     }
    145     
    146     
    147     protected void consume() 
    148     {
    149         switch(id) 
    150         {
    151           case KeyEvent.KEY_PRESSED:
    152           case KeyEvent.KEY_RELEASED:
    153           case MouseEvent.MOUSE_PRESSED:
    154           case MouseEvent.MOUSE_RELEASED:
    155           case MouseEvent.MOUSE_MOVED:
    156           case MouseEvent.MOUSE_DRAGGED:
    157           case MouseEvent.MOUSE_ENTERED:
    158           case MouseEvent.MOUSE_EXITED:
    159           case MouseEvent.MOUSE_WHEEL:
    160           case InputMethodEvent.INPUT_METHOD_TEXT_CHANGED:
    161           case InputMethodEvent.CARET_POSITION_CHANGED:
    162           consumed = true;
    163           break;
    164           default:
    165         }
    166     }
    167     
    168     
    169     protected boolean isConsumed() 
    170     {
    171         return consumed;
    172     }
    173     
    174     
    175     Event convertToOld() 
    176     {
    177         Object src = getSource();
    178         int newid = id;
    179         switch(id) 
    180         {
    181           case KeyEvent.KEY_PRESSED:
    182           case KeyEvent.KEY_RELEASED:
    183           KeyEvent ke = (KeyEvent)this;
    184           if (ke.isActionKey()) 
    185           {
    186               newid = (id == KeyEvent.KEY_PRESSED?Event.KEY_ACTION : Event.KEY_ACTION_RELEASE);
    187           }
    188           int keyCode = ke.getKeyCode();
    189           if (keyCode == KeyEvent.VK_SHIFT ||keyCode == KeyEvent.VK_CONTROL ||keyCode == KeyEvent.VK_ALT) 
    190           {
    191               return null;
    192           }
    193           return new Event(src, ke.getWhen(), newid, 0, 0,Event.getOldEventKey(ke),(ke.getModifiers() & ~InputEvent.BUTTON1_MASK));
    194           case MouseEvent.MOUSE_PRESSED:
    195           case MouseEvent.MOUSE_RELEASED:
    196           case MouseEvent.MOUSE_MOVED:
    197           case MouseEvent.MOUSE_DRAGGED:
    198           case MouseEvent.MOUSE_ENTERED:
    199           case MouseEvent.MOUSE_EXITED:
    200           MouseEvent me = (MouseEvent)this;
    201           Event olde = new Event(src, me.getWhen(), newid,me.getX(), me.getY(), 0,(me.getModifiers() & ~InputEvent.BUTTON1_MASK));
    202           olde.clickCount = me.getClickCount();
    203               return olde;
    204           case FocusEvent.FOCUS_GAINED:
    205               return new Event(src, Event.GOT_FOCUS, null);
    206           case FocusEvent.FOCUS_LOST:
    207               return new Event(src, Event.LOST_FOCUS, null);
    208           case WindowEvent.WINDOW_CLOSING:
    209           case WindowEvent.WINDOW_ICONIFIED:
    210           case WindowEvent.WINDOW_DEICONIFIED:
    211               return new Event(src, newid, null);
    212           case ComponentEvent.COMPONENT_MOVED:
    213                   if (src instanceof Frame || src instanceof Dialog) 
    214                   {
    215                         Point p = ((Component)src).getLocation();
    216                         return new Event(src, 0, Event.WINDOW_MOVED, p.x, p.y, 0, 0);
    217                   }
    218                   break;
    219           case ActionEvent.ACTION_PERFORMED:
    220                   ActionEvent ae = (ActionEvent)this;
    221                   String cmd;
    222                   if (src instanceof Button) 
    223                   {
    224                       cmd = ((Button)src).getLabel();
    225                   } 
    226                   else if (src instanceof MenuItem) 
    227                   {
    228                       cmd = ((MenuItem)src).getLabel();
    229                   } 
    230                   else 
    231                   {
    232                       cmd = ae.getActionCommand();
    233                   }
    234                   return new Event(src, 0, newid, 0, 0, 0, ae.getModifiers(), cmd);
    235                   case ItemEvent.ITEM_STATE_CHANGED:
    236                   ItemEvent ie = (ItemEvent)this;
    237                   Object arg;
    238                   if (src instanceof List) 
    239                   {
    240                       newid = (ie.getStateChange() == ItemEvent.SELECTED?Event.LIST_SELECT : Event.LIST_DESELECT);
    241                       arg = ie.getItem();
    242                   } 
    243                   else 
    244                   {
    245                       newid = Event.ACTION_EVENT;
    246                       if (src instanceof Choice) 
    247                       {
    248                           arg = ie.getItem();
    249                       } 
    250                       else 
    251                       {
    252                           arg = Boolean.valueOf(ie.getStateChange() == ItemEvent.SELECTED);
    253                       }
    254                   }
    255                   return new Event(src, newid, arg);
    256           case AdjustmentEvent.ADJUSTMENT_VALUE_CHANGED:
    257               AdjustmentEvent aje = (AdjustmentEvent)this;
    258               switch(aje.getAdjustmentType()) 
    259               {
    260                 case AdjustmentEvent.UNIT_INCREMENT:
    261                   newid = Event.SCROLL_LINE_DOWN;
    262                   break;
    263                 case AdjustmentEvent.UNIT_DECREMENT:
    264                   newid = Event.SCROLL_LINE_UP;
    265                   break;
    266                 case AdjustmentEvent.BLOCK_INCREMENT:
    267                   newid = Event.SCROLL_PAGE_DOWN;
    268                   break;
    269                 case AdjustmentEvent.BLOCK_DECREMENT:
    270                   newid = Event.SCROLL_PAGE_UP;
    271                   break;
    272                 case AdjustmentEvent.TRACK:
    273                                   if (aje.getValueIsAdjusting()) 
    274                                   {
    275                                       newid = Event.SCROLL_ABSOLUTE;
    276                                   }
    277                                   else 
    278                                   {
    279                                       newid = Event.SCROLL_END;
    280                                   }
    281                               break;
    282                 default:
    283                   return null;
    284               }
    285               return new Event(src, newid, Integer.valueOf(aje.getValue()));
    286           default:
    287         }
    288         return null;
    289     }
    290     
    291     
    292     void copyPrivateDataInto(AWTEvent that) 
    293     {
    294         that.bdata = this.bdata;
    295       if (this instanceof InputEvent && that instanceof InputEvent) 
    296       {
    297           Field field = get_InputEvent_CanAccessSystemClipboard();
    298           if (field != null) 
    299           { 
    300               try 
    301               {
    302                   boolean b = field.getBoolean(this);
    303                   field.setBoolean(that, b);
    304               } 
    305               catch(IllegalAccessException e) 
    306               {
    307               } 
    308           }
    309       }
    310       that.isSystemGenerated = this.isSystemGenerated;
    311     }
    312     
    313     
    314     void dispatched() 
    315     {
    316         if (this instanceof InputEvent) 
    317         {
    318             Field field = get_InputEvent_CanAccessSystemClipboard();
    319             if (field != null) 
    320             { 
    321                 try 
    322                 {
    323                     field.setBoolean(this, false);
    324                 } 
    325                 catch(IllegalAccessException e) 
    326                 {
    327                 } 
    328             }
    329         }
    330     }            
    331 }

    package java.awt;
    import java.util.EventObject;
    import java.awt.event.*;
    import java.awt.peer.ComponentPeer;
    import java.awt.peer.LightweightPeer;
    import java.lang.reflect.Field;
    import sun.awt.AWTAccessor;
    public abstract class AWTEvent extends EventObject
    {
        private byte bdata[];
        protected int id;
        protected boolean consumed = false;
        transient boolean focusManagerIsDispatching = false;
        transient boolean isPosted;
        private transient boolean isSystemGenerated;
        public final static long COMPONENT_EVENT_MASK = 0x01;
        public final static long CONTAINER_EVENT_MASK = 0x02;
        public final static long FOCUS_EVENT_MASK = 0x04;
        public final static long KEY_EVENT_MASK = 0x08;
        public final static long MOUSE_EVENT_MASK = 0x10;
        public final static long MOUSE_MOTION_EVENT_MASK = 0x20;
        public final static long WINDOW_EVENT_MASK = 0x40;
        public final static long ACTION_EVENT_MASK = 0x80;
        public final static long ADJUSTMENT_EVENT_MASK = 0x100;
        public final static long ITEM_EVENT_MASK = 0x200;
        public final static long TEXT_EVENT_MASK = 0x400;
        public final static long INPUT_METHOD_EVENT_MASK = 0x800;
        final static long INPUT_METHODS_ENABLED_MASK = 0x1000;
        public final static long PAINT_EVENT_MASK = 0x2000;
        public final static long INVOCATION_EVENT_MASK = 0x4000;
        public final static long HIERARCHY_EVENT_MASK = 0x8000;
        public final static long HIERARCHY_BOUNDS_EVENT_MASK = 0x10000;
        public final static long MOUSE_WHEEL_EVENT_MASK = 0x20000;
        public final static long WINDOW_STATE_EVENT_MASK = 0x40000;
        public final static long WINDOW_FOCUS_EVENT_MASK = 0x80000;
        public final static int RESERVED_ID_MAX = 1999;
        private static Field inputEvent_CanAccessSystemClipboard_Field = null;
        private static final long serialVersionUID = -1825314779160409405L;
        
        static
        {
              Toolkit.loadLibraries();
            if (!GraphicsEnvironment.isHeadless()) initIDs();
            AWTAccessor.setAWTEventAccessor
            (
                new AWTAccessor.AWTEventAccessor()
                {
                    public void setSystemGenerated(AWTEvent ev)
                    {
                        ev.isSystemGenerated = true;
                    }
                    public boolean isSystemGenerated(AWTEvent ev)
                    {
                        return ev.isSystemGenerated;
                    }
                }
              );
        }
        
        
        private static synchronized Field get_InputEvent_CanAccessSystemClipboard()
        {
            if (inputEvent_CanAccessSystemClipboard_Field == null)
            {
                inputEvent_CanAccessSystemClipboard_Field =(Field)java.security.AccessController.doPrivileged
                                                           (
                                                                                                    new java.security.PrivilegedAction()
                                                                                                    {
                                                                                                    public Object run()
                                                                                                    {
                                                                                                        Field field = null;
                                                                                                        try
                                                                                                        {
                                                                                                            field = InputEvent.class.
                                                                                                                getDeclaredField("canAccessSystemClipboard");
                                                                                                            field.setAccessible(true);
                                                                                                            return field;
                                                                                                        }
                                                                                                        catch (SecurityException e)
                                                                                                        {
                                                                                                        }
                                                                                                        catch (NoSuchFieldException e)
                                                                                                        {
                                                                                                        }
                                                                                                        return null;
                                                                                                    }
                                                                                                     }
                                                                                                 );
            }
            return inputEvent_CanAccessSystemClipboard_Field;
        }
        
        
        private static native void initIDs();
        
        
        public AWTEvent(Event event)
        {
            this(event.target, event.id);
        }
        
        
        public AWTEvent(Object source, int id)
        {
            super(source);
              this.id = id;
            switch(id)
            {
              case ActionEvent.ACTION_PERFORMED:
              case ItemEvent.ITEM_STATE_CHANGED:
              case AdjustmentEvent.ADJUSTMENT_VALUE_CHANGED:
              case TextEvent.TEXT_VALUE_CHANGED:
              consumed = true;
              break;
              default:
            }
        }
        
        
        public int getID()
        {
            return id;
        }
        
        
        public String toString()
        {
            String srcName = null;
            if (source instanceof Component)
            {
                srcName = ((Component)source).getName();
            }
            else if (source instanceof MenuComponent)
            {
                srcName = ((MenuComponent)source).getName();
            }
              return getClass().getName() + "[" + paramString() + "] on " +(srcName != null? srcName : source);
        }
        
        
        public String paramString()
        {
            return "";
        }
        
        
        protected void consume()
        {
            switch(id)
            {
              case KeyEvent.KEY_PRESSED:
              case KeyEvent.KEY_RELEASED:
              case MouseEvent.MOUSE_PRESSED:
              case MouseEvent.MOUSE_RELEASED:
              case MouseEvent.MOUSE_MOVED:
              case MouseEvent.MOUSE_DRAGGED:
              case MouseEvent.MOUSE_ENTERED:
              case MouseEvent.MOUSE_EXITED:
              case MouseEvent.MOUSE_WHEEL:
              case InputMethodEvent.INPUT_METHOD_TEXT_CHANGED:
              case InputMethodEvent.CARET_POSITION_CHANGED:
              consumed = true;
              break;
              default:
            }
        }
        
        
        protected boolean isConsumed()
        {
            return consumed;
        }
        
        
        Event convertToOld()
        {
            Object src = getSource();
            int newid = id;
            switch(id)
            {
              case KeyEvent.KEY_PRESSED:
              case KeyEvent.KEY_RELEASED:
              KeyEvent ke = (KeyEvent)this;
              if (ke.isActionKey())
              {
                  newid = (id == KeyEvent.KEY_PRESSED?Event.KEY_ACTION : Event.KEY_ACTION_RELEASE);
              }
              int keyCode = ke.getKeyCode();
              if (keyCode == KeyEvent.VK_SHIFT ||keyCode == KeyEvent.VK_CONTROL ||keyCode == KeyEvent.VK_ALT)
              {
                  return null;
              }
              return new Event(src, ke.getWhen(), newid, 0, 0,Event.getOldEventKey(ke),(ke.getModifiers() & ~InputEvent.BUTTON1_MASK));
              case MouseEvent.MOUSE_PRESSED:
              case MouseEvent.MOUSE_RELEASED:
              case MouseEvent.MOUSE_MOVED:
              case MouseEvent.MOUSE_DRAGGED:
              case MouseEvent.MOUSE_ENTERED:
              case MouseEvent.MOUSE_EXITED:
              MouseEvent me = (MouseEvent)this;
              Event olde = new Event(src, me.getWhen(), newid,me.getX(), me.getY(), 0,(me.getModifiers() & ~InputEvent.BUTTON1_MASK));
              olde.clickCount = me.getClickCount();
                  return olde;
              case FocusEvent.FOCUS_GAINED:
                  return new Event(src, Event.GOT_FOCUS, null);
              case FocusEvent.FOCUS_LOST:
                  return new Event(src, Event.LOST_FOCUS, null);
              case WindowEvent.WINDOW_CLOSING:
              case WindowEvent.WINDOW_ICONIFIED:
              case WindowEvent.WINDOW_DEICONIFIED:
                  return new Event(src, newid, null);
              case ComponentEvent.COMPONENT_MOVED:
                      if (src instanceof Frame || src instanceof Dialog)
                      {
                            Point p = ((Component)src).getLocation();
                            return new Event(src, 0, Event.WINDOW_MOVED, p.x, p.y, 0, 0);
                      }
                      break;
              case ActionEvent.ACTION_PERFORMED:
                      ActionEvent ae = (ActionEvent)this;
                      String cmd;
                      if (src instanceof Button)
                      {
                          cmd = ((Button)src).getLabel();
                      }
                      else if (src instanceof MenuItem)
                      {
                          cmd = ((MenuItem)src).getLabel();
                      }
                      else
                      {
                          cmd = ae.getActionCommand();
                      }
                      return new Event(src, 0, newid, 0, 0, 0, ae.getModifiers(), cmd);
                      case ItemEvent.ITEM_STATE_CHANGED:
                      ItemEvent ie = (ItemEvent)this;
                      Object arg;
                      if (src instanceof List)
                      {
                          newid = (ie.getStateChange() == ItemEvent.SELECTED?Event.LIST_SELECT : Event.LIST_DESELECT);
                          arg = ie.getItem();
                      }
                      else
                      {
                          newid = Event.ACTION_EVENT;
                          if (src instanceof Choice)
                          {
                              arg = ie.getItem();
                          }
                          else
                          {
                              arg = Boolean.valueOf(ie.getStateChange() == ItemEvent.SELECTED);
                          }
                      }
                      return new Event(src, newid, arg);
              case AdjustmentEvent.ADJUSTMENT_VALUE_CHANGED:
                  AdjustmentEvent aje = (AdjustmentEvent)this;
                  switch(aje.getAdjustmentType())
                  {
                    case AdjustmentEvent.UNIT_INCREMENT:
                      newid = Event.SCROLL_LINE_DOWN;
                      break;
                    case AdjustmentEvent.UNIT_DECREMENT:
                      newid = Event.SCROLL_LINE_UP;
                      break;
                    case AdjustmentEvent.BLOCK_INCREMENT:
                      newid = Event.SCROLL_PAGE_DOWN;
                      break;
                    case AdjustmentEvent.BLOCK_DECREMENT:
                      newid = Event.SCROLL_PAGE_UP;
                      break;
                    case AdjustmentEvent.TRACK:
                                      if (aje.getValueIsAdjusting())
                                      {
                                          newid = Event.SCROLL_ABSOLUTE;
                                      }
                                      else
                                      {
                                          newid = Event.SCROLL_END;
                                      }
                                  break;
                    default:
                      return null;
                  }
                  return new Event(src, newid, Integer.valueOf(aje.getValue()));
              default:
            }
            return null;
        }
        
        
        void copyPrivateDataInto(AWTEvent that)
        {
            that.bdata = this.bdata;
          if (this instanceof InputEvent && that instanceof InputEvent)
          {
              Field field = get_InputEvent_CanAccessSystemClipboard();
              if (field != null)
              {
                  try
                  {
                      boolean b = field.getBoolean(this);
                      field.setBoolean(that, b);
                  }
                  catch(IllegalAccessException e)
                  {
                  }
              }
          }
          that.isSystemGenerated = this.isSystemGenerated;
        }
        
        
        void dispatched()
        {
            if (this instanceof InputEvent)
            {
                Field field = get_InputEvent_CanAccessSystemClipboard();
                if (field != null)
                {
                    try
                    {
                        field.setBoolean(this, false);
                    }
                    catch(IllegalAccessException e)
                    {
                    }
                }
            }
        }            
    }

  • 相关阅读:
    SSO 单点登录
    CPU运行原理及对线程的影响01
    表单设计器
    Session 身份验证
    cookie 身份验证及跨域
    WebService 身份验证01_SoapHeader及 iis windows 集成身份验证
    WebService 代理类型
    WebService
    网络协议的理解 http、udp、tcp 等
    Container
  • 原文地址:https://www.cnblogs.com/datougui/p/2646910.html
Copyright © 2011-2022 走看看