1 /*

     2  * Copyright (c) 1995, 2011, 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 sun.awt.motif;

    27 

    28 import java.awt.*;

    29 import java.awt.im.InputMethodHighlight;

    30 import java.awt.im.spi.InputMethodDescriptor;

    31 import java.awt.image.*;

    32 import java.awt.peer.*;

    33 import java.awt.datatransfer.Clipboard;

    34 import java.awt.event.*;

    35 import java.lang.reflect.*;

    36 import java.lang.Math;

    37 import java.io.*;

    38 import java.security.AccessController;

    39 import java.security.PrivilegedAction;

    40 import java.security.PrivilegedActionException;

    41 import java.security.PrivilegedExceptionAction;

    42 

    43 import java.util.Properties;

    44 import java.util.Map;

    45 import java.util.Iterator;

    46 

    47 import sun.awt.AppContext;

    48 import sun.awt.AWTAutoShutdown;

    49 import sun.awt.SunToolkit;

    50 import sun.awt.UNIXToolkit;

    51 import sun.awt.GlobalCursorManager;

    52 import sun.awt.datatransfer.DataTransferer;

    53 

    54 import java.awt.dnd.DragSource;

    55 import java.awt.dnd.DragGestureListener;

    56 import java.awt.dnd.DragGestureEvent;

    57 import java.awt.dnd.DragGestureRecognizer;

    58 import java.awt.dnd.MouseDragGestureRecognizer;

    59 import java.awt.dnd.InvalidDnDOperationException;

    60 import java.awt.dnd.peer.DragSourceContextPeer;

    61 

    62 //import sun.awt.motif.MInputMethod;

    63 import sun.awt.X11FontManager;

    64 import sun.awt.X11GraphicsConfig;

    65 import sun.awt.X11GraphicsEnvironment;

    66 import sun.awt.XSettings;

    67 

    68 //import sun.awt.motif.MDragSourceContextPeer;

    69 

    70 import sun.print.PrintJob2D;

    71 

    72 import sun.misc.PerformanceLogger;

    73 import sun.misc.Unsafe;

    74 

    75 import sun.security.action.GetBooleanAction;

    76 import sun.util.logging.PlatformLogger;

    77 

    78 public class MToolkit extends UNIXToolkit implements Runnable {

    79 

    80     private static final PlatformLogger log = PlatformLogger.getLogger("sun.awt.motif.MToolkit");

    81 

    82     // the system clipboard - CLIPBOARD selection

    83     //X11Clipboard clipboard;

    84     // the system selection - PRIMARY selection

    85     //X11Clipboard selection;

    86 

    87     // Dynamic Layout Resize client code setting

    88     protected static boolean dynamicLayoutSetting = false;

    89 

    90     /**

    91      * True when the x settings have been loaded.

    92      */

    93     private boolean loadedXSettings;

    94 

    95     /**

    96      * XSETTINGS for the default screen.

    97      * <p>

    98      * <strong>XXX:</strong> see <code>MToolkit.parseXSettings</code>

    99      * and <code>awt_xsettings_update</code> in

   100      * <samp>awt_MToolkit.c</samp>

   101      */

   102     private XSettings xs;

   103 

   104     /*

   105      * Note: The MToolkit object depends on the static initializer

   106      * of X11GraphicsEnvironment to initialize the connection to

   107      * the X11 server.

   108      */

   109     static final X11GraphicsConfig config;

   110 

   111     private static final boolean motifdnd;

   112 

   113     static {

   114         if (GraphicsEnvironment.isHeadless()) {

   115             config = null;

   116         } else {

   117             config = (X11GraphicsConfig) (GraphicsEnvironment.

   118                              getLocalGraphicsEnvironment().

   119                              getDefaultScreenDevice().

   120                              getDefaultConfiguration());

   121         }

   122 

   123         motifdnd = ((Boolean)java.security.AccessController.doPrivileged(

   124             new GetBooleanAction("awt.dnd.motifdnd"))).booleanValue();

   125     }

   126 

   127     //public static final String DATA_TRANSFERER_CLASS_NAME = "sun.awt.motif.MDataTransferer";

   128 

   129     public MToolkit() {

   130         super();

   131         if (PerformanceLogger.loggingEnabled()) {

   132             PerformanceLogger.setTime("MToolkit construction");

   133         }

   134         if (!GraphicsEnvironment.isHeadless()) {

   135             String mainClassName = null;

   136 

   137             StackTraceElement trace[] = (new Throwable()).getStackTrace();

   138             int bottom = trace.length - 1;

   139             if (bottom >= 0) {

   140                 mainClassName = trace[bottom].getClassName();

   141             }

   142             if (mainClassName == null || mainClassName.equals("")) {

   143                 mainClassName = "AWT";

   144             }

   145 

   146             init(mainClassName);

   147             //SunToolkit.setDataTransfererClassName(DATA_TRANSFERER_CLASS_NAME);

   148 

   149             Thread toolkitThread = new Thread(this, "AWT-Motif");

   150             toolkitThread.setPriority(Thread.NORM_PRIORITY + 1);

   151             toolkitThread.setDaemon(true);

   152 

   153             PrivilegedAction<Void> a = new PrivilegedAction<Void>() {

   154                 public Void run() {

   155                     ThreadGroup mainTG = Thread.currentThread().getThreadGroup();

   156                     ThreadGroup parentTG = mainTG.getParent();

   157 

   158                     while (parentTG != null) {

   159                         mainTG = parentTG;

   160                         parentTG = mainTG.getParent();

   161                     }

   162                     Thread shutdownThread = new Thread(mainTG, new Runnable() {

   163                             public void run() {

   164                                 shutdown();

   165                             }

   166                         }, "Shutdown-Thread");

   167                     shutdownThread.setContextClassLoader(null);

   168                     Runtime.getRuntime().addShutdownHook(shutdownThread);

   169                     return null;

   170                 }

   171             };

   172             AccessController.doPrivileged(a);

   173 

   174             /*

   175              * Fix for 4701990.

   176              * AWTAutoShutdown state must be changed before the toolkit thread

   177              * starts to avoid race condition.

   178              */

   179             AWTAutoShutdown.notifyToolkitThreadBusy();

   180 

   181             toolkitThread.start();

   182         }

   183     }

   184 

   185     public native void init(String mainClassName);

   186     public native void run();

   187     private native void shutdown();

   188 

   189     /*

   190      * Create peer objects.

   191      */

   192 

   193     public ButtonPeer createButton(Button target) {

   194         //ButtonPeer peer = new MButtonPeer(target);

   195         //targetCreatedPeer(target, peer);

   196         //return peer;

   197         return null;

   198     }

   199 

   200     public TextFieldPeer createTextField(TextField target) {

   201         //TextFieldPeer peer = new MTextFieldPeer(target);

   202         //targetCreatedPeer(target, peer);

   203         //return peer;

   204         return null;

   205     }

   206 

   207     public LabelPeer createLabel(Label target) {

   208         //LabelPeer peer = new MLabelPeer(target);

   209         //targetCreatedPeer(target, peer);

   210         //return peer;

   211         return null;

   212     }

   213 

   214     public ListPeer createList(List target) {

   215         //ListPeer peer = new MListPeer(target);

   216         //targetCreatedPeer(target, peer);

   217         //return peer;

   218         return null;

   219     }

   220 

   221     public CheckboxPeer createCheckbox(Checkbox target) {

   222         //CheckboxPeer peer = new MCheckboxPeer(target);

   223         //targetCreatedPeer(target, peer);

   224         //return peer;

   225         return null;

   226     }

   227 

   228     public ScrollbarPeer createScrollbar(Scrollbar target) {

   229         //ScrollbarPeer peer = new MScrollbarPeer(target);

   230         //targetCreatedPeer(target, peer);

   231         //return peer;

   232         return null;

   233     }

   234 

   235     public ScrollPanePeer createScrollPane(ScrollPane target) {

   236         //ScrollPanePeer peer = new MScrollPanePeer(target);

   237         //targetCreatedPeer(target, peer);

   238         //return peer;

   239         return null;

   240     }

   241 

   242     public TextAreaPeer createTextArea(TextArea target) {

   243         //TextAreaPeer peer = new MTextAreaPeer(target);

   244         //targetCreatedPeer(target, peer);

   245         //return peer;

   246         return null;

   247     }

   248 

   249     public ChoicePeer createChoice(Choice target) {

   250         //ChoicePeer peer = new MChoicePeer(target);

   251         //targetCreatedPeer(target, peer);

   252         //return peer;

   253         return null;

   254     }

   255 

   256     public FramePeer  createFrame(Frame target) {

   257         //FramePeer peer = new MFramePeer(target);

   258         //targetCreatedPeer(target, peer);

   259         //return peer;

   260         return null;

   261     }

   262 

   263     public CanvasPeer createCanvas(Canvas target) {

   264         //CanvasPeer peer = (isXEmbedServerRequested() ? new MEmbedCanvasPeer(target) : new MCanvasPeer(target));

   265         //targetCreatedPeer(target, peer);

   266         //return peer;

   267         return null;

   268     }

   269 

   270     public PanelPeer createPanel(Panel target) {

   271         //PanelPeer peer = new MPanelPeer(target);

   272         //targetCreatedPeer(target, peer);

   273         //return peer;

   274         return null;

   275     }

   276 

   277     public WindowPeer createWindow(Window target) {

   278         //WindowPeer peer = new MWindowPeer(target);

   279         //targetCreatedPeer(target, peer);

   280         //return peer;

   281         return null;

   282     }

   283 

   284     public DialogPeer createDialog(Dialog target) {

   285         //DialogPeer peer = new MDialogPeer(target);

   286         //targetCreatedPeer(target, peer);

   287         //return peer;

   288         return null;

   289     }

   290 

   291     public FileDialogPeer createFileDialog(FileDialog target) {

   292         //FileDialogPeer peer = new MFileDialogPeer(target);

   293         //targetCreatedPeer(target, peer);

   294         //return peer;

   295         return null;

   296     }

   297 

   298     public MenuBarPeer createMenuBar(MenuBar target) {

   299         //MenuBarPeer peer = new MMenuBarPeer(target);

   300         //targetCreatedPeer(target, peer);

   301         //return peer;

   302         return null;

   303     }

   304 

   305     public MenuPeer createMenu(Menu target) {

   306         //MenuPeer peer = new MMenuPeer(target);

   307         //targetCreatedPeer(target, peer);

   308         //return peer;

   309         return null;

   310     }

   311 

   312     public PopupMenuPeer createPopupMenu(PopupMenu target) {

   313         //PopupMenuPeer peer = new MPopupMenuPeer(target);

   314         //targetCreatedPeer(target, peer);

   315         //return peer;

   316         return null;

   317     }

   318 

   319     public MenuItemPeer createMenuItem(MenuItem target) {

   320         //MenuItemPeer peer = new MMenuItemPeer(target);

   321         //targetCreatedPeer(target, peer);

   322         //return peer;

   323         return null;

   324     }

   325 

   326     public CheckboxMenuItemPeer createCheckboxMenuItem(CheckboxMenuItem target) {

   327         //CheckboxMenuItemPeer peer = new MCheckboxMenuItemPeer(target);

   328         //targetCreatedPeer(target, peer);

   329         //return peer;

   330         return null;

   331     }

   332 

   333     public KeyboardFocusManagerPeer createKeyboardFocusManagerPeer(KeyboardFocusManager manager) {

   334         return null;

   335     }

   336 

   337     //public MEmbeddedFramePeer createEmbeddedFrame(MEmbeddedFrame target)

   338     //{

   339         //MEmbeddedFramePeer peer = new MEmbeddedFramePeer(target);

   340         //targetCreatedPeer(target, peer);

   341         //return peer;

   342     //    return null;

   343     //}

   344 

   345 

   346     public FontPeer getFontPeer(String name, int style){

   347         return new MFontPeer(name, style);

   348     }

   349 

   350     /*

   351      * On X, support for dynamic layout on resizing is governed by the

   352      * window manager.  If the window manager supports it, it happens

   353      * automatically.  The setter method for this property is

   354      * irrelevant on X.

   355      */

   356     public void setDynamicLayout(boolean b) {

   357         dynamicLayoutSetting = b;

   358     }

   359 

   360     protected boolean isDynamicLayoutSet() {

   361         return dynamicLayoutSetting;

   362     }

   363 

   364     /* Called from isDynamicLayoutActive() and from

   365      * lazilyLoadDynamicLayoutSupportedProperty()

   366      */

   367     protected native boolean isDynamicLayoutSupportedNative();

   368 

   369     public boolean isDynamicLayoutActive() {

   370         return isDynamicLayoutSupportedNative();

   371     }

   372 

   373     public native boolean isFrameStateSupported(int state);

   374 

   375     public TrayIconPeer createTrayIcon(TrayIcon target) throws HeadlessException {

   376         return null;

   377     }

   378 

   379     public SystemTrayPeer createSystemTray(SystemTray target) throws HeadlessException {

   380         return null;

   381     }

   382 

   383     public boolean isTraySupported() {

   384         return false;

   385     }

   386 

   387     static native ColorModel makeColorModel();

   388     static ColorModel screenmodel;

   389 

   390     static ColorModel getStaticColorModel() {

   391         if (screenmodel == null) {

   392             screenmodel = config.getColorModel ();

   393         }

   394         return screenmodel;

   395     }

   396 

   397     public ColorModel getColorModel() {

   398         return getStaticColorModel();

   399     }

   400 

   401     public native int getScreenResolution();

   402 

   403     public Insets getScreenInsets(GraphicsConfiguration gc) {

   404         return new Insets(0,0,0,0);

   405     }

   406 

   407     protected native int getScreenWidth();

   408     protected native int getScreenHeight();

   409 

   410     public FontMetrics getFontMetrics(Font font) {

   411         /*

   412         // REMIND: platform font flag should be obsolete soon

   413         if (!RasterOutputManager.usesPlatformFont()) {

   414             return super.getFontMetrics(font);

   415         } else {

   416             return X11FontMetrics.getFontMetrics(font);

   417         }

   418         */

   419         return super.getFontMetrics(font);

   420     }

   421 

   422     public PrintJob getPrintJob(final Frame frame, final String doctitle,

   423                                 final Properties props) {

   424 

   425         if (GraphicsEnvironment.isHeadless()) {

   426             throw new IllegalArgumentException();

   427         }

   428 

   429         PrintJob2D printJob = new PrintJob2D(frame, doctitle, props);

   430 

   431         if (printJob.printDialog() == false) {

   432             printJob = null;

   433         }

   434 

   435         return printJob;

   436     }

   437 

   438     public PrintJob getPrintJob(final Frame frame, final String doctitle,

   439                                 final JobAttributes jobAttributes,

   440                                 final PageAttributes pageAttributes) {

   441 

   442 

   443         if (GraphicsEnvironment.isHeadless()) {

   444             throw new IllegalArgumentException();

   445         }

   446 

   447         PrintJob2D printJob = new PrintJob2D(frame, doctitle,

   448                                              jobAttributes, pageAttributes);

   449 

   450         if (printJob.printDialog() == false) {

   451             printJob = null;

   452         }

   453 

   454         return printJob;

   455     }

   456 

   457     public native void beep();

   458 

   459     public  Clipboard getSystemClipboard() {

   460         //SecurityManager security = System.getSecurityManager();

   461         //if (security != null) {

   462         //  security.checkSystemClipboardAccess();

   463         //}

   464         //synchronized (this) {

   465         //    if (clipboard == null) {

   466         //        clipboard = new X11Clipboard("System", "CLIPBOARD");

   467         //    }

   468         //}

   469         //return clipboard;

   470         return null;

   471     }

   472 

   473     public Clipboard getSystemSelection() {

   474         //SecurityManager security = System.getSecurityManager();

   475         //if (security != null) {

   476         //    security.checkSystemClipboardAccess();

   477         //}

   478         //synchronized (this) {

   479         //    if (selection == null) {

   480         //        selection = new X11Clipboard("Selection", "PRIMARY");

   481         //    }

   482         //}

   483         //return selection;

   484         return null;

   485     }

   486 

   487     public boolean getLockingKeyState(int key) {

   488         if (! (key == KeyEvent.VK_CAPS_LOCK || key == KeyEvent.VK_NUM_LOCK ||

   489                key == KeyEvent.VK_SCROLL_LOCK || key == KeyEvent.VK_KANA_LOCK)) {

   490             throw new IllegalArgumentException("invalid key for Toolkit.getLockingKeyState");

   491         }

   492         return getLockingKeyStateNative(key);

   493     }

   494 

   495     public native boolean getLockingKeyStateNative(int key);

   496 

   497     public native void loadSystemColors(int[] systemColors);

   498 

   499     /**

   500      * Give native peers the ability to query the native container

   501      * given a native component (e.g. the direct parent may be lightweight).

   502      */

   503     public static Container getNativeContainer(Component c) {

   504         return Toolkit.getNativeContainer(c);

   505     }

   506 

   507     protected static final Object targetToPeer(Object target) {

   508         return SunToolkit.targetToPeer(target);

   509     }

   510 

   511     protected static final void targetDisposedPeer(Object target, Object peer) {

   512         SunToolkit.targetDisposedPeer(target, peer);

   513     }

   514 

   515     public DragSourceContextPeer createDragSourceContextPeer(DragGestureEvent dge) throws InvalidDnDOperationException {

   516         //if (MToolkit.useMotifDnD()) {

   517         //    return MDragSourceContextPeer.createDragSourceContextPeer(dge);

   518         //} else {

   519         //    return X11DragSourceContextPeer.createDragSourceContextPeer(dge);

   520         //}

   521         return null;

   522     }

   523 

   524     public <T extends DragGestureRecognizer> T

   525         createDragGestureRecognizer(Class<T> abstractRecognizerClass,

   526                                     DragSource ds, Component c, int srcActions,

   527                                     DragGestureListener dgl)

   528     {

   529         //if (MouseDragGestureRecognizer.class.equals(abstractRecognizerClass))

   530         //    return (T)new MMouseDragGestureRecognizer(ds, c, srcActions, dgl);

   531         //else

   532             return null;

   533     }

   534 

   535     /**

   536      * Returns a new input method adapter descriptor for native input methods.

   537      */

   538     public InputMethodDescriptor getInputMethodAdapterDescriptor() throws AWTException {

   539         return null; // return new MInputMethodDescriptor();

   540     }

   541 

   542     /**

   543      * Returns a style map for the input method highlight.

   544      */

   545     public Map mapInputMethodHighlight(InputMethodHighlight highlight) {

   546         return null; //return MInputMethod.mapInputMethodHighlight(highlight);

   547     }

   548 

   549     /**

   550      * Returns a new custom cursor.

   551      */

   552     public Cursor createCustomCursor(Image cursor, Point hotSpot, String name)

   553         throws IndexOutOfBoundsException {

   554         return null; //return new MCustomCursor(cursor, hotSpot, name);

   555     }

   556 

   557     /**

   558      * Returns the supported cursor size

   559      */

   560     public Dimension getBestCursorSize(int preferredWidth, int preferredHeight) {

   561         return null; //MCustomCursor.getBestCursorSize(

   562             //java.lang.Math.max(1,preferredWidth), java.lang.Math.max(1,preferredHeight));

   563     }

   564 

   565     public int getMaximumCursorColors() {

   566         return 2;  // Black and white.

   567     }

   568 

   569     private final static String prefix  = "DnD.Cursor.";

   570     private final static String postfix = ".32x32";

   571     private static final String dndPrefix  = "DnD.";

   572 

   573     protected Object lazilyLoadDesktopProperty(String name) {

   574         if (name.startsWith(prefix)) {

   575             String cursorName = name.substring(prefix.length(), name.length()) + postfix;

   576 

   577             try {

   578                 return Cursor.getSystemCustomCursor(cursorName);

   579             } catch (AWTException awte) {

   580                 System.err.println("cannot load system cursor: " + cursorName);

   581 

   582                 return null;

   583             }

   584         }

   585 

   586         if (name.equals("awt.dynamicLayoutSupported")) {

   587             return lazilyLoadDynamicLayoutSupportedProperty(name);

   588         }

   589 

   590         if (!loadedXSettings &&

   591             (name.startsWith("gnome.") ||

   592              name.equals(SunToolkit.DESKTOPFONTHINTS) ||

   593              name.startsWith(dndPrefix))) {

   594             loadedXSettings = true;

   595             if (!GraphicsEnvironment.isHeadless()) {

   596                 loadXSettings();

   597                 desktopProperties.put(SunToolkit.DESKTOPFONTHINTS,

   598                                       SunToolkit.getDesktopFontHints());

   599                 return desktopProperties.get(name);

   600             }

   601         }

   602 

   603         return super.lazilyLoadDesktopProperty(name);

   604     }

   605 

   606     /*

   607      * Called from lazilyLoadDesktopProperty because we may not know if

   608      * the user has quit the previous window manager and started another.

   609      */

   610     protected Boolean lazilyLoadDynamicLayoutSupportedProperty(String name) {

   611         boolean nativeDynamic = isDynamicLayoutSupportedNative();

   612 

   613         if (log.isLoggable(PlatformLogger.FINER)) {

   614             log.finer("nativeDynamic == " + nativeDynamic);

   615         }

   616 

   617         return Boolean.valueOf(nativeDynamic);

   618     }

   619 

   620     private native int getMulticlickTime();

   621 

   622     protected void initializeDesktopProperties() {

   623         desktopProperties.put("DnD.Autoscroll.initialDelay",     Integer.valueOf(50));

   624         desktopProperties.put("DnD.Autoscroll.interval",         Integer.valueOf(50));

   625         desktopProperties.put("DnD.Autoscroll.cursorHysteresis", Integer.valueOf(5));

   626 

   627         /* As of 1.4, no wheel mice are supported on Solaris

   628          * however, they are on Linux, and there isn't a way to detect them,

   629          * so we leave this property unset to indicate we're not sure if there's

   630          * a wheel mouse or not.

   631          */

   632         //desktopProperties.put("awt.wheelMousePresent", Boolean.valueOf(false));

   633 

   634         // We don't want to call getMultilclickTime() if we're headless

   635         if (!GraphicsEnvironment.isHeadless()) {

   636             desktopProperties.put("awt.multiClickInterval",

   637                                   Integer.valueOf(getMulticlickTime()));

   638             desktopProperties.put("awt.mouse.numButtons",

   639                                   Integer.valueOf(getNumberOfButtons()));

   640         }

   641     }

   642 

   643     public RobotPeer createRobot(Robot target, GraphicsDevice screen) {

   644         /* 'target' is unused for now... */

   645         //return new MRobotPeer(screen.getDefaultConfiguration());

   646         return null;

   647     }

   648 

   649     static boolean useMotifDnD() {

   650         return motifdnd;

   651     }

   652 

   653     //

   654     // The following support Gnome's equivalent of desktop properties.

   655     // A writeup of this can be found at:

   656     // http://www.freedesktop.org/standards/xsettings/xsettings.html

   657     //

   658 

   659     /**

   660      * Triggers a callback to parseXSettings with the x settings values

   661      * from the window server. Note that this will NOT call

   662      * parseXSettings if we are not running on a GNOME desktop.

   663      */

   664     private native void loadXSettings();

   665 

   666     /**

   667      * Callback from the native side indicating some, or all, of the

   668      * desktop properties have changed and need to be reloaded.

   669      * <code>data</code> is the byte array directly from the x server and

   670      * may be in little endian format.

   671      * <p>

   672      * NB: This could be called from any thread if triggered by

   673      * <code>loadXSettings</code>.  It is called from the toolkit

   674      * thread if triggered by an XSETTINGS change.

   675      */

   676     private void parseXSettings(int screen_XXX_ignored, byte[] data) {

   677         // XXX: notyet: map screen -> per screen XSettings object

   678         // for now native code only calls us for default screen

   679         // see awt_MToolkit.c awt_xsettings_update().

   680         if (xs == null) {

   681             xs = new XSettings();

   682         }

   683 

   684         Map updatedSettings = xs.update(data);

   685         if (updatedSettings == null || updatedSettings.isEmpty()) {

   686             return;

   687         }

   688 

   689         Iterator i = updatedSettings.entrySet().iterator();

   690         while (i.hasNext()) {

   691             Map.Entry e = (Map.Entry)i.next();

   692             String name = (String)e.getKey();

   693 

   694             name = "gnome." + name;

   695             setDesktopProperty(name, e.getValue());

   696 

   697             // XXX: we probably want to do something smarter.  In

   698             // particular, "Net" properties are of interest to the

   699             // "core" AWT itself.  E.g.

   700             //

   701             // Net/DndDragThreshold -> ???

   702             // Net/DoubleClickTime  -> awt.multiClickInterval

   703         }

   704 

   705         setDesktopProperty(SunToolkit.DESKTOPFONTHINTS,

   706                            SunToolkit.getDesktopFontHints());

   707 

   708         Integer dragThreshold = null;

   709         synchronized (this) {

   710             dragThreshold = (Integer)desktopProperties.get("gnome.Net/DndDragThreshold");

   711         }

   712         if (dragThreshold != null) {

   713             setDesktopProperty("DnD.gestureMotionThreshold", dragThreshold);

   714         }

   715     }

   716 

   717     protected boolean needsXEmbedImpl() {

   718         return true;

   719     }

   720 

   721     public boolean isModalityTypeSupported(Dialog.ModalityType modalityType) {

   722         return (modalityType == Dialog.ModalityType.MODELESS) ||

   723                (modalityType == Dialog.ModalityType.APPLICATION_MODAL);

   724     }

   725 

   726     public boolean isModalExclusionTypeSupported(Dialog.ModalExclusionType exclusionType) {

   727         return (exclusionType == Dialog.ModalExclusionType.NO_EXCLUDE);

   728     }

   729 

   730     private native boolean isSyncUpdated();

   731     private native boolean isSyncFailed();

   732     private native int getEventNumber();

   733     private native void updateSyncSelection();

   734     private static final long WORKAROUND_SLEEP = 100;

   735 

   736     /**

   737      * @inheritDoc

   738      */

   739     protected boolean syncNativeQueue(final long timeout) {

   740         awtLock();

   741         try {

   742             long event_number = getEventNumber();

   743             updateSyncSelection();

   744 

   745             // Wait for selection notify for oops on win

   746             long start = System.currentTimeMillis();

   747             while (!isSyncUpdated() && !isSyncFailed()) {

   748                 try {

   749                     awtLockWait(timeout);

   750                 } catch (InterruptedException e) {

   751                     throw new RuntimeException(e);

   752                 }

   753                 // This "while" is a protection from spurious

   754                 // wake-ups.  However, we shouldn't wait for too long

   755                 if (((System.currentTimeMillis() - start) > timeout) && (timeout >= 0)) {

   756                     throw new OperationTimedOut();

   757                 }

   758             }

   759             if (isSyncFailed() && getEventNumber() - event_number == 1) {

   760                 awtUnlock();

   761                 try {

   762                     Thread.sleep(WORKAROUND_SLEEP);

   763                 } catch (InterruptedException ie) {

   764                     throw new RuntimeException(ie);

   765                 } finally {

   766                     awtLock();

   767                 }

   768             }

   769             return getEventNumber() - event_number > 2;

   770         } finally {

   771             awtUnlock();

   772         }

   773     }

   774 

   775     public  void grab(Window w) {

   776         WindowPeer peer = (WindowPeer)w.getPeer();

   777         if (peer != null) {

   778             nativeGrab(peer);

   779         }

   780     }

   781 

   782     public void ungrab(Window w) {

   783         WindowPeer peer = (WindowPeer)w.getPeer();

   784         if (peer != null) {

   785             nativeUnGrab(peer);

   786         }

   787     }

   788     private native void nativeGrab(WindowPeer peer);

   789     private native void nativeUnGrab(WindowPeer peer);

   790 

   791 

   792     public boolean isDesktopSupported(){

   793         return false;

   794     }

   795 

   796     public DesktopPeer createDesktopPeer(Desktop target)

   797     throws HeadlessException{

   798         throw new UnsupportedOperationException();

   799     }

   800 

   801     public final static int

   802         UNDETERMINED_WM = 1,

   803         NO_WM = 2,

   804         OTHER_WM = 3,

   805         OPENLOOK_WM = 4,

   806         MOTIF_WM = 5,

   807         CDE_WM = 6,

   808         ENLIGHTEN_WM = 7,

   809         KDE2_WM = 8,

   810         SAWFISH_WM = 9,

   811         ICE_WM = 10,

   812         METACITY_WM = 11,

   813         COMPIZ_WM = 12,

   814         LG3D_WM = 13;

   815 

   816     public static int getWMID() {

   817         String wmName = getWMName();

   818 

   819         if ("NO_WM".equals(wmName)) {

   820             return NO_WM;

   821         } else if ("OTHER_WM".equals(wmName)) {

   822             return OTHER_WM;

   823         } else if ("ENLIGHTEN_WM".equals(wmName)) {

   824             return ENLIGHTEN_WM;

   825         } else if ("KDE2_WM".equals(wmName)) {

   826             return KDE2_WM;

   827         } else if ("SAWFISH_WM".equals(wmName)) {

   828             return SAWFISH_WM;

   829         } else if ("ICE_WM".equals(wmName)) {

   830             return ICE_WM;

   831         } else if ("METACITY_WM".equals(wmName)) {

   832             return METACITY_WM;

   833         } else if ("OPENLOOK_WM".equals(wmName)) {

   834             return OPENLOOK_WM;

   835         } else if ("MOTIF_WM".equals(wmName)) {

   836             return MOTIF_WM;

   837         } else if ("CDE_WM".equals(wmName)) {

   838             return CDE_WM;

   839         } else if ("COMPIZ_WM".equals(wmName)) {

   840             return COMPIZ_WM;

   841         } else if ("LG3D_WM".equals(wmName)) {

   842             return LG3D_WM;

   843         }

   844         return UNDETERMINED_WM;

   845     }

   846 

   847     private static native String getWMName();

   848 

   849 } // class MToolkit