src/solaris/classes/sun/awt/X11/XMSelection.java

Print this page
rev 9717 : 8039642: Fix raw and unchecked warnings in sun.awt.*
Reviewed-by:


  43      * If owner changes, the ownerChanged of the XMSelectionListener
  44      * will be called with the screen
  45      * number and the new owning window when onwership is established, or
  46      * None if the owner is gone.
  47      *
  48      * Events in extra_mask are selected for on owning windows (exsiting
  49      * ones and on new owners when established) and otherEvent of the
  50      * XMWSelectionListener will be called with the screen number and an event.
  51      *
  52      * The function returns an array of current owners.  The size of the
  53      * array is ScreenCount(awt_display).  The array is "owned" by this
  54      * module and should be considered by the caller as read-only.
  55      */
  56 
  57 
  58     private static PlatformLogger log = PlatformLogger.getLogger("sun.awt.X11.XMSelection");
  59     /* Name of the selection */
  60     String selectionName;
  61 
  62     /* list of listeners to be called for events */
  63     Vector listeners;
  64 
  65     /* X atom array (one per screen) for this selection */
  66     XAtom atoms[];
  67 
  68     /* Window ids of selection owners */
  69     long owners[];
  70 
  71     /* event mask to set */
  72     long eventMask;
  73 
  74     static int numScreens;
  75 
  76     static XAtom XA_MANAGER;
  77 
  78     static HashMap selectionMap;
  79 
  80     static {
  81         long display = XToolkit.getDisplay();
  82         XToolkit.awtLock();
  83         try {
  84             numScreens = XlibWrapper.ScreenCount(display);
  85         } finally {
  86             XToolkit.awtUnlock();
  87         }
  88         XA_MANAGER = XAtom.get("MANAGER");
  89         for (int screen = 0; screen < numScreens ; screen ++) {
  90             initScreen(display,screen);
  91         }
  92 
  93         selectionMap = new HashMap();
  94     }
  95 
  96     static void initScreen(long display, final int screen) {
  97         XToolkit.awtLock();
  98         try {
  99             long root = XlibWrapper.RootWindow(display,screen);
 100             XlibWrapper.XSelectInput(display, root, XConstants.StructureNotifyMask);
 101             XToolkit.addEventDispatcher(root,
 102                     new XEventDispatcher() {
 103                         public void dispatchEvent(XEvent ev) {
 104                                 processRootEvent(ev, screen);
 105                             }
 106                         });
 107 
 108         } finally {
 109             XToolkit.awtUnlock();
 110         }
 111     }
 112 
 113 


 210                 sel.resetOwner(owner,screen);
 211                 sel.dispatchOwnerChangedEvent(xev,screen,owner,data, timestamp);
 212             }
 213         }
 214         return false;
 215     }
 216 
 217     static  boolean processRootEvent(XEvent xev, int screen) {
 218         switch (xev.get_type()) {
 219             case XConstants.ClientMessage: {
 220                 return processClientMessage(xev, screen);
 221             }
 222         }
 223 
 224         return false;
 225 
 226     }
 227 
 228 
 229     static XMSelection getInstance(long selection) {
 230         return (XMSelection) selectionMap.get(Long.valueOf(selection));
 231     }
 232 
 233 
 234     /*
 235      * Default constructor specifies PropertyChangeMask as well
 236      */
 237 
 238     public XMSelection (String selname) {
 239         this(selname, XConstants.PropertyChangeMask);
 240     }
 241 
 242 
 243    /*
 244     * Some users may not need to know about selection changes,
 245     * just owner ship changes, They would specify a zero extra mask.
 246     */
 247 
 248     public XMSelection (String selname, long extraMask) {
 249 
 250         synchronized (this) {
 251             selectionName = selname;
 252             atoms = new XAtom[getNumberOfScreens()];
 253             owners = new long[getNumberOfScreens()];
 254         }
 255         select(extraMask);
 256     }
 257 
 258 
 259 
 260     public synchronized void addSelectionListener(XMSelectionListener listener) {
 261         if (listeners == null) {
 262             listeners = new Vector();
 263         }
 264         listeners.add(listener);
 265     }
 266 
 267     public synchronized void removeSelectionListener(XMSelectionListener listener) {
 268         if (listeners != null) {
 269             listeners.remove(listener);
 270         }
 271     }
 272 
 273     synchronized Collection getListeners() {
 274         return listeners;
 275     }
 276 
 277     synchronized XAtom getAtom(int screen) {
 278         if (atoms != null) {
 279             return atoms[screen];
 280         }
 281         return null;
 282     }
 283 
 284     synchronized void setAtom(XAtom a, int screen) {
 285         if (atoms != null) {
 286             atoms[screen] = a;
 287         }
 288     }
 289 
 290     synchronized long getOwner(int screen) {
 291         if (owners != null) {
 292             return owners[screen];
 293         }
 294         return 0;
 295     }
 296 
 297     synchronized void setOwner(long owner, int screen) {
 298         if (owners != null) {
 299             owners[screen] = owner;
 300         }
 301     }
 302 
 303     synchronized String getName() {
 304         return selectionName;
 305     }
 306 
 307 
 308     synchronized void dispatchSelectionChanged( XPropertyEvent ev, int screen) {
 309         if (log.isLoggable(PlatformLogger.Level.FINE)) {
 310             log.fine("Selection Changed : Screen = " + screen + "Event =" + ev);
 311         }
 312         if (listeners != null) {
 313             Iterator iter = listeners.iterator();
 314             while (iter.hasNext()) {
 315                 XMSelectionListener disp = (XMSelectionListener) iter.next();
 316                 disp.selectionChanged(screen, this, ev.get_window(), ev);
 317             }
 318         }
 319     }
 320 
 321     synchronized void dispatchOwnerDeath(XDestroyWindowEvent de, int screen) {
 322         if (log.isLoggable(PlatformLogger.Level.FINE)) {
 323             log.fine("Owner dead : Screen = " + screen + "Event =" + de);
 324         }
 325         if (listeners != null) {
 326             Iterator iter = listeners.iterator();
 327             while (iter.hasNext()) {
 328                 XMSelectionListener disp = (XMSelectionListener) iter.next();
 329                 disp.ownerDeath(screen, this, de.get_window());
 330 
 331             }
 332         }
 333     }
 334 
 335     void dispatchSelectionEvent(XEvent xev, int screen) {
 336         if (log.isLoggable(PlatformLogger.Level.FINE)) {
 337             log.fine("Event =" + xev);
 338         }
 339         if (xev.get_type() == XConstants.DestroyNotify) {
 340             XDestroyWindowEvent de = xev.get_xdestroywindow();
 341             dispatchOwnerDeath( de, screen);
 342         }
 343         else if (xev.get_type() == XConstants.PropertyNotify)  {
 344             XPropertyEvent xpe = xev.get_xproperty();
 345             dispatchSelectionChanged( xpe, screen);
 346         }
 347     }
 348 
 349 
 350     synchronized void dispatchOwnerChangedEvent(XEvent ev, int screen, long owner, long data, long timestamp) {
 351         if (listeners != null) {
 352             Iterator iter = listeners.iterator();
 353             while (iter.hasNext()) {
 354                 XMSelectionListener disp = (XMSelectionListener) iter.next();
 355                 disp.ownerChanged(screen,this, owner, data, timestamp);
 356             }
 357         }
 358     }
 359 
 360 
 361 }


  43      * If owner changes, the ownerChanged of the XMSelectionListener
  44      * will be called with the screen
  45      * number and the new owning window when onwership is established, or
  46      * None if the owner is gone.
  47      *
  48      * Events in extra_mask are selected for on owning windows (exsiting
  49      * ones and on new owners when established) and otherEvent of the
  50      * XMWSelectionListener will be called with the screen number and an event.
  51      *
  52      * The function returns an array of current owners.  The size of the
  53      * array is ScreenCount(awt_display).  The array is "owned" by this
  54      * module and should be considered by the caller as read-only.
  55      */
  56 
  57 
  58     private static PlatformLogger log = PlatformLogger.getLogger("sun.awt.X11.XMSelection");
  59     /* Name of the selection */
  60     String selectionName;
  61 
  62     /* list of listeners to be called for events */
  63     Vector<XMSelectionListener> listeners;
  64 
  65     /* X atom array (one per screen) for this selection */
  66     XAtom atoms[];
  67 
  68     /* Window ids of selection owners */
  69     long owners[];
  70 
  71     /* event mask to set */
  72     long eventMask;
  73 
  74     static int numScreens;
  75 
  76     static XAtom XA_MANAGER;
  77 
  78     static HashMap<Long, XMSelection> selectionMap;
  79 
  80     static {
  81         long display = XToolkit.getDisplay();
  82         XToolkit.awtLock();
  83         try {
  84             numScreens = XlibWrapper.ScreenCount(display);
  85         } finally {
  86             XToolkit.awtUnlock();
  87         }
  88         XA_MANAGER = XAtom.get("MANAGER");
  89         for (int screen = 0; screen < numScreens ; screen ++) {
  90             initScreen(display,screen);
  91         }
  92 
  93         selectionMap = new HashMap<>();
  94     }
  95 
  96     static void initScreen(long display, final int screen) {
  97         XToolkit.awtLock();
  98         try {
  99             long root = XlibWrapper.RootWindow(display,screen);
 100             XlibWrapper.XSelectInput(display, root, XConstants.StructureNotifyMask);
 101             XToolkit.addEventDispatcher(root,
 102                     new XEventDispatcher() {
 103                         public void dispatchEvent(XEvent ev) {
 104                                 processRootEvent(ev, screen);
 105                             }
 106                         });
 107 
 108         } finally {
 109             XToolkit.awtUnlock();
 110         }
 111     }
 112 
 113 


 210                 sel.resetOwner(owner,screen);
 211                 sel.dispatchOwnerChangedEvent(xev,screen,owner,data, timestamp);
 212             }
 213         }
 214         return false;
 215     }
 216 
 217     static  boolean processRootEvent(XEvent xev, int screen) {
 218         switch (xev.get_type()) {
 219             case XConstants.ClientMessage: {
 220                 return processClientMessage(xev, screen);
 221             }
 222         }
 223 
 224         return false;
 225 
 226     }
 227 
 228 
 229     static XMSelection getInstance(long selection) {
 230         return selectionMap.get(Long.valueOf(selection));
 231     }
 232 
 233 
 234     /*
 235      * Default constructor specifies PropertyChangeMask as well
 236      */
 237 
 238     public XMSelection (String selname) {
 239         this(selname, XConstants.PropertyChangeMask);
 240     }
 241 
 242 
 243    /*
 244     * Some users may not need to know about selection changes,
 245     * just owner ship changes, They would specify a zero extra mask.
 246     */
 247 
 248     public XMSelection (String selname, long extraMask) {
 249 
 250         synchronized (this) {
 251             selectionName = selname;
 252             atoms = new XAtom[getNumberOfScreens()];
 253             owners = new long[getNumberOfScreens()];
 254         }
 255         select(extraMask);
 256     }
 257 
 258 
 259 
 260     public synchronized void addSelectionListener(XMSelectionListener listener) {
 261         if (listeners == null) {
 262             listeners = new Vector<>();
 263         }
 264         listeners.add(listener);
 265     }
 266 
 267     public synchronized void removeSelectionListener(XMSelectionListener listener) {
 268         if (listeners != null) {
 269             listeners.remove(listener);
 270         }
 271     }
 272 
 273     synchronized Collection<XMSelectionListener> getListeners() {
 274         return listeners;
 275     }
 276 
 277     synchronized XAtom getAtom(int screen) {
 278         if (atoms != null) {
 279             return atoms[screen];
 280         }
 281         return null;
 282     }
 283 
 284     synchronized void setAtom(XAtom a, int screen) {
 285         if (atoms != null) {
 286             atoms[screen] = a;
 287         }
 288     }
 289 
 290     synchronized long getOwner(int screen) {
 291         if (owners != null) {
 292             return owners[screen];
 293         }
 294         return 0;
 295     }
 296 
 297     synchronized void setOwner(long owner, int screen) {
 298         if (owners != null) {
 299             owners[screen] = owner;
 300         }
 301     }
 302 
 303     synchronized String getName() {
 304         return selectionName;
 305     }
 306 
 307 
 308     synchronized void dispatchSelectionChanged( XPropertyEvent ev, int screen) {
 309         if (log.isLoggable(PlatformLogger.Level.FINE)) {
 310             log.fine("Selection Changed : Screen = " + screen + "Event =" + ev);
 311         }
 312         if (listeners != null) {
 313             Iterator<XMSelectionListener> iter = listeners.iterator();
 314             while (iter.hasNext()) {
 315                 XMSelectionListener disp = iter.next();
 316                 disp.selectionChanged(screen, this, ev.get_window(), ev);
 317             }
 318         }
 319     }
 320 
 321     synchronized void dispatchOwnerDeath(XDestroyWindowEvent de, int screen) {
 322         if (log.isLoggable(PlatformLogger.Level.FINE)) {
 323             log.fine("Owner dead : Screen = " + screen + "Event =" + de);
 324         }
 325         if (listeners != null) {
 326             Iterator<XMSelectionListener> iter = listeners.iterator();
 327             while (iter.hasNext()) {
 328                 XMSelectionListener disp = iter.next();
 329                 disp.ownerDeath(screen, this, de.get_window());
 330 
 331             }
 332         }
 333     }
 334 
 335     void dispatchSelectionEvent(XEvent xev, int screen) {
 336         if (log.isLoggable(PlatformLogger.Level.FINE)) {
 337             log.fine("Event =" + xev);
 338         }
 339         if (xev.get_type() == XConstants.DestroyNotify) {
 340             XDestroyWindowEvent de = xev.get_xdestroywindow();
 341             dispatchOwnerDeath( de, screen);
 342         }
 343         else if (xev.get_type() == XConstants.PropertyNotify)  {
 344             XPropertyEvent xpe = xev.get_xproperty();
 345             dispatchSelectionChanged( xpe, screen);
 346         }
 347     }
 348 
 349 
 350     synchronized void dispatchOwnerChangedEvent(XEvent ev, int screen, long owner, long data, long timestamp) {
 351         if (listeners != null) {
 352             Iterator<XMSelectionListener> iter = listeners.iterator();
 353             while (iter.hasNext()) {
 354                 XMSelectionListener disp = iter.next();
 355                 disp.ownerChanged(screen,this, owner, data, timestamp);
 356             }
 357         }
 358     }
 359 
 360 
 361 }