Mercurial Mercurial > jdk-sandbox / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
jdk/src/solaris/classes/sun/awt/X11/XMSelection.java
changeset 3938 ef327bd847c0
parent 439 3488710b02f8
child 5506 202f599c92aa
equal deleted inserted replaced
3934:487e1aa949c4 3938:ef327bd847c0 
    30    */
 
    30    */
 
    31 
    31 
    32 package sun.awt.X11;
 
    32 package sun.awt.X11;
 
    33 
    33 
    34 import java.util.*;
 
    34 import java.util.*;
 
    35 import java.util.logging.*;
 
    35 import sun.util.logging.PlatformLogger;
 
    36 
       
    37 
    36 
    38 public class  XMSelection {
 
    37 public class  XMSelection {
 
    39 
    38 
    40     /*
 
    39     /*
 
    41      * A method for a subsytem to express its interest in a certain
 
    40      * A method for a subsytem to express its interest in a certain
 
    54      * array is ScreenCount(awt_display).  The array is "owned" by this
 
    53      * array is ScreenCount(awt_display).  The array is "owned" by this
 
    55      * module and should be considered by the caller as read-only.
 
    54      * module and should be considered by the caller as read-only.
 
    56      */
 
    55      */
 
    57 
    56 
    58 
    57 
    59     private static Logger log = Logger.getLogger("sun.awt.X11.XMSelection");
 
    58     private static PlatformLogger log = PlatformLogger.getLogger("sun.awt.X11.XMSelection");
 
    60     /* Name of the selection */
 
    59     /* Name of the selection */
 
    61     String selectionName;
 
    60     String selectionName;
 
    62 
    61 
    63     /* list of listeners to be called for events */
 
    62     /* list of listeners to be called for events */
 
    64     Vector listeners;
 
    63     Vector listeners;
 
   127         XToolkit.awtLock();
 
   126         XToolkit.awtLock();
 
   128         try {
 
   127         try {
 
   129             long display = XToolkit.getDisplay();
 
   128             long display = XToolkit.getDisplay();
 
   130             synchronized(this) {
 
   129             synchronized(this) {
 
   131                 setOwner(owner, screen);
 
   130                 setOwner(owner, screen);
 
   132                 if (log.isLoggable(Level.FINE)) log.fine("New Selection Owner for screen " + screen + " = " + owner );
 
   131                 if (log.isLoggable(PlatformLogger.FINE)) log.fine("New Selection Owner for screen " + screen + " = " + owner );
 
   133                 XlibWrapper.XSelectInput(display, owner, XConstants.StructureNotifyMask | eventMask);
 
   132                 XlibWrapper.XSelectInput(display, owner, XConstants.StructureNotifyMask | eventMask);
 
   134                 XToolkit.addEventDispatcher(owner,
 
   133                 XToolkit.addEventDispatcher(owner,
 
   135                         new XEventDispatcher() {
 
   134                         new XEventDispatcher() {
 
   136                             public void dispatchEvent(XEvent ev) {
 
   135                             public void dispatchEvent(XEvent ev) {
 
   137                                 dispatchSelectionEvent(ev, screen);
 
   136                                 dispatchSelectionEvent(ev, screen);
 
   147     void selectPerScreen(final int screen, long extra_mask) {
 
   146     void selectPerScreen(final int screen, long extra_mask) {
 
   148         XToolkit.awtLock();
 
   147         XToolkit.awtLock();
 
   149         try {
 
   148         try {
 
   150             try {
 
   149             try {
 
   151                 long display = XToolkit.getDisplay();
 
   150                 long display = XToolkit.getDisplay();
 
   152                 if (log.isLoggable(Level.FINE)) log.fine("Grabbing XServer");
 
   151                 if (log.isLoggable(PlatformLogger.FINE)) log.fine("Grabbing XServer");
 
   153                 XlibWrapper.XGrabServer(display);
 
   152                 XlibWrapper.XGrabServer(display);
 
   154 
   153 
   155                 synchronized(this) {
 
   154                 synchronized(this) {
 
   156                     String selection_name = getName()+"_S"+screen;
 
   155                     String selection_name = getName()+"_S"+screen;
 
   157                     if (log.isLoggable(Level.FINE)) log.fine("Screen = " + screen + " selection name = " + selection_name);
 
   156                     if (log.isLoggable(PlatformLogger.FINE)) log.fine("Screen = " + screen + " selection name = " + selection_name);
 
   158                     XAtom atom = XAtom.get(selection_name);
 
   157                     XAtom atom = XAtom.get(selection_name);
 
   159                     selectionMap.put(Long.valueOf(atom.getAtom()),this); // add mapping from atom to the instance of XMSelection
 
   158                     selectionMap.put(Long.valueOf(atom.getAtom()),this); // add mapping from atom to the instance of XMSelection
 
   160                     setAtom(atom,screen);
 
   159                     setAtom(atom,screen);
 
   161                     long owner = XlibWrapper.XGetSelectionOwner(display, atom.getAtom());
 
   160                     long owner = XlibWrapper.XGetSelectionOwner(display, atom.getAtom());
 
   162                     if (owner != 0) {
 
   161                     if (owner != 0) {
 
   163                         setOwner(owner, screen);
 
   162                         setOwner(owner, screen);
 
   164                         if (log.isLoggable(Level.FINE)) log.fine("Selection Owner for screen " + screen + " = " + owner );
 
   163                         if (log.isLoggable(PlatformLogger.FINE)) log.fine("Selection Owner for screen " + screen + " = " + owner );
 
   165                         XlibWrapper.XSelectInput(display, owner, XConstants.StructureNotifyMask | extra_mask);
 
   164                         XlibWrapper.XSelectInput(display, owner, XConstants.StructureNotifyMask | extra_mask);
 
   166                         XToolkit.addEventDispatcher(owner,
 
   165                         XToolkit.addEventDispatcher(owner,
 
   167                                 new XEventDispatcher() {
 
   166                                 new XEventDispatcher() {
 
   168                                         public void dispatchEvent(XEvent ev) {
 
   167                                         public void dispatchEvent(XEvent ev) {
 
   169                                             dispatchSelectionEvent(ev, screen);
 
   168                                             dispatchSelectionEvent(ev, screen);
 
   174             }
 
   173             }
 
   175             catch (Exception e) {
 
   174             catch (Exception e) {
 
   176                 e.printStackTrace();
 
   175                 e.printStackTrace();
 
   177             }
 
   176             }
 
   178             finally {
 
   177             finally {
 
   179                 if (log.isLoggable(Level.FINE)) log.fine("UnGrabbing XServer");
 
   178                 if (log.isLoggable(PlatformLogger.FINE)) log.fine("UnGrabbing XServer");
 
   180                 XlibWrapper.XUngrabServer(XToolkit.getDisplay());
 
   179                 XlibWrapper.XUngrabServer(XToolkit.getDisplay());
 
   181             }
 
   180             }
 
   182         } finally {
 
   181         } finally {
 
   183             XToolkit.awtUnlock();
 
   182             XToolkit.awtUnlock();
 
   184         }
 
   183         }
 
   186 
   185 
   187 
   186 
   188     static boolean processClientMessage(XEvent xev, int screen) {
 
   187     static boolean processClientMessage(XEvent xev, int screen) {
 
   189         XClientMessageEvent xce = xev.get_xclient();
 
   188         XClientMessageEvent xce = xev.get_xclient();
 
   190         if (xce.get_message_type() == XA_MANAGER.getAtom()) {
 
   189         if (xce.get_message_type() == XA_MANAGER.getAtom()) {
 
   191             if (log.isLoggable(Level.FINE)) log.fine("client messags = " + xce);
 
   190             if (log.isLoggable(PlatformLogger.FINE)) log.fine("client messags = " + xce);
 
   192             long timestamp = xce.get_data(0);
 
   191             long timestamp = xce.get_data(0);
 
   193             long atom = xce.get_data(1);
 
   192             long atom = xce.get_data(1);
 
   194             long owner = xce.get_data(2);
 
   193             long owner = xce.get_data(2);
 
   195             long data = xce.get_data(3);
 
   194             long data = xce.get_data(3);
 
   196 
   195 
   293         return selectionName;
 
   292         return selectionName;
 
   294     }
 
   293     }
 
   295 
   294 
   296 
   295 
   297     synchronized void dispatchSelectionChanged( XPropertyEvent ev, int screen) {
 
   296     synchronized void dispatchSelectionChanged( XPropertyEvent ev, int screen) {
 
   298         if (log.isLoggable(Level.FINE)) log.fine("Selection Changed : Screen = " + screen + "Event =" + ev);
 
   297         if (log.isLoggable(PlatformLogger.FINE)) log.fine("Selection Changed : Screen = " + screen + "Event =" + ev);
 
   299         if (listeners != null) {
 
   298         if (listeners != null) {
 
   300             Iterator iter = listeners.iterator();
 
   299             Iterator iter = listeners.iterator();
 
   301             while (iter.hasNext()) {
 
   300             while (iter.hasNext()) {
 
   302                 XMSelectionListener disp = (XMSelectionListener) iter.next();
 
   301                 XMSelectionListener disp = (XMSelectionListener) iter.next();
 
   303                 disp.selectionChanged(screen, this, ev.get_window(), ev);
 
   302                 disp.selectionChanged(screen, this, ev.get_window(), ev);
 
   304             }
 
   303             }
 
   305         }
 
   304         }
 
   306     }
 
   305     }
 
   307 
   306 
   308     synchronized void dispatchOwnerDeath(XDestroyWindowEvent de, int screen) {
 
   307     synchronized void dispatchOwnerDeath(XDestroyWindowEvent de, int screen) {
 
   309         if (log.isLoggable(Level.FINE)) log.fine("Owner dead : Screen = " + screen + "Event =" + de);
 
   308         if (log.isLoggable(PlatformLogger.FINE)) log.fine("Owner dead : Screen = " + screen + "Event =" + de);
 
   310         if (listeners != null) {
 
   309         if (listeners != null) {
 
   311             Iterator iter = listeners.iterator();
 
   310             Iterator iter = listeners.iterator();
 
   312             while (iter.hasNext()) {
 
   311             while (iter.hasNext()) {
 
   313                 XMSelectionListener disp = (XMSelectionListener) iter.next();
 
   312                 XMSelectionListener disp = (XMSelectionListener) iter.next();
 
   314                 disp.ownerDeath(screen, this, de.get_window());
 
   313                 disp.ownerDeath(screen, this, de.get_window());
 
   316             }
 
   315             }
 
   317         }
 
   316         }
 
   318     }
 
   317     }
 
   319 
   318 
   320     void dispatchSelectionEvent(XEvent xev, int screen) {
 
   319     void dispatchSelectionEvent(XEvent xev, int screen) {
 
   321         if (log.isLoggable(Level.FINE)) log.fine("Event =" + xev);
 
   320         if (log.isLoggable(PlatformLogger.FINE)) log.fine("Event =" + xev);
 
   322         if (xev.get_type() == XConstants.DestroyNotify) {
 
   321         if (xev.get_type() == XConstants.DestroyNotify) {
 
   323             XDestroyWindowEvent de = xev.get_xdestroywindow();
 
   322             XDestroyWindowEvent de = xev.get_xdestroywindow();
 
   324             dispatchOwnerDeath( de, screen);
 
   323             dispatchOwnerDeath( de, screen);
 
   325         }
 
   324         }
 
   326         else if (xev.get_type() == XConstants.PropertyNotify)  {
 
   325         else if (xev.get_type() == XConstants.PropertyNotify)  {
jdk-sandbox