Ignore:
Timestamp:
Dec 21, 2012, 10:37:13 AM (13 years ago)
Author:
dmik
Message:

trunk: Merged in openjdk6 b27 from branches/vendor/oracle.

Location:
trunk/openjdk
Files:
1 deleted
23 edited

Legend:

Unmodified
Added
Removed
  • trunk/openjdk

  • trunk/openjdk/jdk/src/solaris/classes/java/io/UnixFileSystem.java

    r278 r406  
    11/*
    2  * Copyright (c) 1998, 2005, Oracle and/or its affiliates. All rights reserved.
     2 * Copyright (c) 1998, 2012, Oracle and/or its affiliates. All rights reserved.
    33 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    44 *
     
    254254    /* -- File operations -- */
    255255
    256     public native boolean createFileExclusively(String path)
     256    public native boolean createFileExclusively(String path, boolean restrictive)
    257257        throws IOException;
    258258    public boolean delete(File f) {
  • trunk/openjdk/jdk/src/solaris/classes/sun/awt/X11/XCheckboxMenuItemPeer.java

    r278 r406  
    3030import java.awt.event.*;
    3131
    32 import java.lang.reflect.Field;
    33 import sun.awt.SunToolkit;
     32import sun.awt.AWTAccessor;
    3433
    3534class XCheckboxMenuItemPeer extends XMenuItemPeer implements CheckboxMenuItemPeer {
    36 
    37     /************************************************
    38      *
    39      * Data members
    40      *
    41      ************************************************/
    42 
    43     /*
    44      * CheckboxMenuItem's fields
    45      */
    46     private final static Field f_state;
    47     static {
    48         f_state = SunToolkit.getField(CheckboxMenuItem.class, "state");
    49     }
    5035
    5136    /************************************************
     
    7560     ************************************************/
    7661    boolean getTargetState() {
    77         MenuItem target = getTarget();
    78         if (target == null) {
    79             return false;
    80         }
    81         try {
    82             return f_state.getBoolean(target);
    83         } catch (IllegalAccessException e) {
    84             e.printStackTrace();
    85         }
    86         return false;
     62        return AWTAccessor.getCheckboxMenuItemAccessor()
     63                   .getState((CheckboxMenuItem)getTarget());
    8764    }
    8865
  • trunk/openjdk/jdk/src/solaris/classes/sun/awt/X11/XComponentPeer.java

    r278 r406  
    3232import java.awt.Container;
    3333import java.awt.Cursor;
    34 import java.awt.DefaultKeyboardFocusManager;
    3534import java.awt.Dimension;
    36 import java.awt.Event;
    3735import java.awt.Font;
    3836import java.awt.FontMetrics;
     
    4139import java.awt.Insets;
    4240import java.awt.KeyboardFocusManager;
    43 import java.awt.MenuBar;
    44 import java.awt.Point;
    4541import java.awt.Rectangle;
    4642import java.awt.SystemColor;
     
    6157import java.awt.image.ImageProducer;
    6258import java.awt.image.VolatileImage;
    63 import java.awt.peer.CanvasPeer;
    6459import java.awt.peer.ComponentPeer;
    6560import java.awt.peer.ContainerPeer;
    6661import java.awt.peer.LightweightPeer;
    67 import java.awt.peer.PanelPeer;
    68 import java.awt.peer.WindowPeer;
    6962import java.lang.reflect.*;
    7063import java.security.*;
     
    398391    }
    399392
    400     static Method requestFocusWithCause;
    401 
    402393    static void callRequestFocus(Component target, CausedFocusEvent.Cause cause) {
    403         if (requestFocusWithCause == null) {
    404             requestFocusWithCause = SunToolkit.getMethod(Component.class, "requestFocus", new Class[] {CausedFocusEvent.Cause.class});
    405         }
    406         if (requestFocusWithCause != null) {
    407             try {
    408                 requestFocusWithCause.invoke(target, new Object[] {cause});
    409             } catch (Exception e) {
    410                 e.printStackTrace();
    411             }
    412         }
     394        AWTAccessor.getComponentAccessor().requestFocus(target, cause);
    413395    }
    414396
  • trunk/openjdk/jdk/src/solaris/classes/sun/awt/X11/XEmbedCanvasPeer.java

    r278 r406  
    3030import java.awt.dnd.DropTargetListener;
    3131import java.awt.event.*;
    32 import java.awt.image.ColorModel;
    33 import java.awt.image.ImageObserver;
    34 import java.awt.image.ImageProducer;
    35 import java.awt.image.VolatileImage;
    36 import java.awt.peer.*;
    3732import sun.awt.*;
    38 import sun.awt.motif.X11FontMetrics;
    39 import java.lang.reflect.*;
    4033import java.util.logging.*;
    4134import java.util.*;
     
    456449    }
    457450
    458     static Field bdataField;
    459451    static byte[] getBData(KeyEvent e) {
    460         try {
    461             if (bdataField == null) {
    462                 bdataField = SunToolkit.getField(java.awt.AWTEvent.class, "bdata");
    463             }
    464             return (byte[])bdataField.get(e);
    465         } catch (IllegalAccessException ex) {
    466             return null;
    467         }
     452        return AWTAccessor.getAWTEventAccessor().getBData(e);
    468453    }
    469454
  • trunk/openjdk/jdk/src/solaris/classes/sun/awt/X11/XEmbeddingContainer.java

    r278 r406  
    2929import java.util.HashMap;
    3030import java.awt.event.KeyEvent;
    31 import java.lang.reflect.*;
    32 import sun.awt.SunToolkit;
     31import sun.awt.AWTAccessor;
    3332
    3433public class XEmbeddingContainer extends XEmbedHelper implements XEventDispatcher {
     
    128127    }
    129128
    130     static Field bdata;
    131     byte[] getBData(KeyEvent e) {
    132         try {
    133             if (bdata == null) {
    134                 bdata = SunToolkit.getField(java.awt.AWTEvent.class, "bdata");
    135             }
    136             return (byte[])bdata.get(e);
    137         } catch (IllegalAccessException ex) {
    138             return null;
    139         }
    140     }
    141 
    142129    void forwardKeyEvent(long child, KeyEvent e) {
    143         byte[] bdata = getBData(e);
     130        byte[] bdata = AWTAccessor.getAWTEventAccessor().getBData(e);
    144131        long data = Native.toData(bdata);
    145132        if (data == 0) {
  • trunk/openjdk/jdk/src/solaris/classes/sun/awt/X11/XGlobalCursorManager.java

    r278 r406  
    3030import java.awt.peer.LightweightPeer;
    3131import java.lang.ref.WeakReference;
    32 import java.lang.reflect.Field;
    33 import java.lang.reflect.Method;
    3432import sun.awt.ComponentAccessor;
    3533
    3634import sun.awt.GlobalCursorManager;
    37 import sun.awt.SunToolkit;
     35import sun.awt.AWTAccessor;
    3836
    3937public final class XGlobalCursorManager extends GlobalCursorManager {
    40 
    41     private static Field  field_pData;
    42     private static Field  field_type;
    43     private static Class  cursorClass;
    44     private static Method method_setPData;
    45     static {
    46         cursorClass = java.awt.Cursor.class;
    47         field_pData = SunToolkit.getField(cursorClass, "pData");
    48         field_type  = SunToolkit.getField(cursorClass, "type");
    49         method_setPData = SunToolkit.getMethod(cursorClass, "setPData", new Class[] {long.class});
    50         if (field_pData == null || field_type == null || method_setPData == null) {
    51             System.out.println("Unable to initialize XGlobalCursorManager: ");
    52             Thread.dumpStack();
    53 
    54         }
    55     }
    56 
    5738
    5839    // cached nativeContainer
     
    217198        int type = 0;
    218199        try {
    219             pData = field_pData.getLong(c);
    220             type = field_type.getInt(c);
     200            pData = AWTAccessor.getCursorAccessor().getPData(c);
     201            type = AWTAccessor.getCursorAccessor().getType(c);
    221202        }
    222203        catch (Exception e)
     
    288269    static void setPData(Cursor c, long pData) {
    289270        try {
    290             method_setPData.invoke(c, pData);
     271            AWTAccessor.getCursorAccessor().setPData(c, pData);
    291272        }
    292273        catch (Exception e)
  • trunk/openjdk/jdk/src/solaris/classes/sun/awt/X11/XKeyboardFocusManagerPeer.java

    r278 r406  
    3333import java.awt.peer.KeyboardFocusManagerPeer;
    3434
    35 import java.lang.reflect.InvocationTargetException;
    36 import java.lang.reflect.Method;
    37 
    3835import java.util.logging.Level;
    3936import java.util.logging.Logger;
    4037
    4138import sun.awt.CausedFocusEvent;
    42 import sun.awt.SunToolkit;
     39import sun.awt.AWTAccessor;
    4340
    4441public class XKeyboardFocusManagerPeer implements KeyboardFocusManagerPeer {
     
    131128    }
    132129
    133     static Method shouldNativelyFocusHeavyweightMethod;
    134 
    135130    static int shouldNativelyFocusHeavyweight(Component heavyweight,
    136131         Component descendant, boolean temporary,
    137132         boolean focusedWindowChangeAllowed, long time, CausedFocusEvent.Cause cause)
    138133    {
    139         if (shouldNativelyFocusHeavyweightMethod == null) {
    140             Class[] arg_types =
    141                 new Class[] { Component.class,
    142                               Component.class,
    143                               Boolean.TYPE,
    144                               Boolean.TYPE,
    145                               Long.TYPE,
    146                               CausedFocusEvent.Cause.class
    147             };
    148 
    149             shouldNativelyFocusHeavyweightMethod =
    150                 SunToolkit.getMethod(KeyboardFocusManager.class,
    151                                    "shouldNativelyFocusHeavyweight",
    152                                    arg_types);
    153         }
    154         Object[] args = new Object[] { heavyweight,
    155                                        descendant,
    156                                        Boolean.valueOf(temporary),
    157                                        Boolean.valueOf(focusedWindowChangeAllowed),
    158                                        Long.valueOf(time), cause};
    159 
    160         int result = XComponentPeer.SNFH_FAILURE;
    161         if (shouldNativelyFocusHeavyweightMethod != null) {
    162             try {
    163                 result = ((Integer) shouldNativelyFocusHeavyweightMethod.invoke(null, args)).intValue();
    164             }
    165             catch (IllegalAccessException e) {
    166                 assert false;
    167             }
    168             catch (InvocationTargetException e) {
    169                 assert false;
    170             }
    171         }
    172 
    173         return result;
     134         return AWTAccessor.getKeyboardFocusManagerAccessor()
     135                 .shouldNativelyFocusHeavyweight(heavyweight,
     136                                                 descendant,
     137                                                 temporary,
     138                                                 focusedWindowChangeAllowed,
     139                                                 time,
     140                                                 cause);
    174141    }
    175142}
  • trunk/openjdk/jdk/src/solaris/classes/sun/awt/X11/XMenuBarPeer.java

    r278 r406  
    2929import java.awt.event.*;
    3030
    31 import java.lang.reflect.Field;
    3231import java.util.Vector;
    3332import java.util.logging.*;
    34 import sun.awt.SunToolkit;
     33import sun.awt.AWTAccessor;
    3534
    3635public class XMenuBarPeer extends XBaseMenuWindow implements MenuBarPeer {
     
    6766    private final static int BAR_ITEM_MARGIN_TOP = 2;
    6867    private final static int BAR_ITEM_MARGIN_BOTTOM = 2;
    69 
    70     //fields
    71     private static Field f_helpMenu;
    72     private static Field f_menus;
    73 
    74     static {
    75         f_helpMenu = SunToolkit.getField(MenuBar.class, "helpMenu");
    76         f_menus = SunToolkit.getField(MenuBar.class, "menus");
    77     }
    7868
    7969    /************************************************
     
    205195    void postInit(XCreateWindowParams params) {
    206196        super.postInit(params);
    207         Vector targetMenuVector = null;
    208         Menu targetHelpMenu = null;
    209         try {
    210             // Get menus from the target.
    211             targetMenuVector = (Vector)f_menus.get(menuBarTarget);
    212             targetHelpMenu = (Menu)f_helpMenu.get(menuBarTarget);
    213             reloadItems(targetMenuVector);
    214         } catch (IllegalAccessException iae) {
    215             iae.printStackTrace();
    216         }
    217         if (targetHelpMenu != null) {
    218             addHelpMenu(targetHelpMenu);
    219         }
     197        // Get menus from the target.
     198        Vector targetMenuVector = AWTAccessor.getMenuBarAccessor()
     199                                      .getMenus(menuBarTarget);
     200        Menu targetHelpMenu = AWTAccessor.getMenuBarAccessor()
     201                                  .getHelpMenu(menuBarTarget);
     202        reloadItems(targetMenuVector);
    220203        xSetVisible(true);
    221204        toFront();
  • trunk/openjdk/jdk/src/solaris/classes/sun/awt/X11/XMenuItemPeer.java

    r278 r406  
    2929import java.awt.event.*;
    3030
    31 import java.util.logging.*;
    32 
    33 import java.lang.reflect.Field;
    34 import java.lang.reflect.Method;
    35 import java.lang.reflect.InvocationTargetException;
    36 import sun.awt.SunToolkit;
     31import sun.awt.AWTAccessor;
    3732
    3833public class XMenuItemPeer implements MenuItemPeer {
     
    8479    private final static int SEPARATOR_HEIGHT = 5;
    8580
    86     /*
    87      * MenuItem's fields & methods
    88      */
    89     private final static Field f_enabled;
    90     private final static Field f_label;
    91     private final static Field f_shortcut;
    92     private final static Method m_getFont;
    93     private final static Method m_isItemEnabled;
    94     private final static Method m_getActionCommand;
    95     static {
    96         f_enabled = SunToolkit.getField(MenuItem.class, "enabled");
    97         f_label = SunToolkit.getField(MenuItem.class, "label");
    98         f_shortcut = SunToolkit.getField(MenuItem.class, "shortcut");
    99 
    100         m_getFont = SunToolkit.getMethod(MenuComponent.class, "getFont_NoClientCode", null);
    101         m_getActionCommand = SunToolkit.getMethod(MenuItem.class, "getActionCommandImpl", null);
    102         m_isItemEnabled = SunToolkit.getMethod(MenuItem.class, "isItemEnabled", null);
    103     }
    10481    /************************************************
    10582     *
     
    219196            return XWindow.defaultFont;
    220197        }
    221         try {
    222             return (Font)m_getFont.invoke(target, new Object[0]);
    223         } catch (IllegalAccessException e) {
    224             e.printStackTrace();
    225         } catch (InvocationTargetException e) {
    226             e.printStackTrace();
    227         }
    228         return XWindow.defaultFont;
     198        return AWTAccessor.getMenuComponentAccessor().getFont_NoClientCode(target);
    229199    }
    230200
     
    233203            return "";
    234204        }
    235         try {
    236             String label = (String)f_label.get(target);
    237             return (label == null) ? "" : label;
    238         } catch (IllegalAccessException e) {
    239             e.printStackTrace();
    240         }
    241         return "";
     205        String label = AWTAccessor.getMenuItemAccessor().getLabel(target);
     206        return (label == null) ? "" : label;
    242207    }
    243208
     
    246211            return false;
    247212        }
    248         try {
    249             return f_enabled.getBoolean(target);
    250         } catch (IllegalAccessException e) {
    251             e.printStackTrace();
    252         }
    253         return false;
     213        return AWTAccessor.getMenuItemAccessor().isEnabled(target);
    254214    }
    255215
     
    263223            return false;
    264224        }
    265         try {
    266             return ((Boolean)m_isItemEnabled.invoke(target, new Object[0])).booleanValue();
    267         } catch (IllegalAccessException e) {
    268             e.printStackTrace();
    269         } catch (InvocationTargetException e) {
    270             e.printStackTrace();
    271         }
    272         return false;
     225        return AWTAccessor.getMenuItemAccessor().isItemEnabled(target);
    273226    }
    274227
     
    277230            return "";
    278231        }
    279         try {
    280             return (String) m_getActionCommand.invoke(target,(Object[]) null);
    281         } catch (IllegalAccessException e) {
    282             e.printStackTrace();
    283         } catch (InvocationTargetException e) {
    284             e.printStackTrace();
    285         }
    286         return "";
     232        return AWTAccessor.getMenuItemAccessor().getActionCommandImpl(target);
    287233    }
    288234
     
    291237            return null;
    292238        }
    293         try {
    294             return (MenuShortcut)f_shortcut.get(target);
    295         } catch (IllegalAccessException e) {
    296             e.printStackTrace();
    297         }
    298         return null;
     239        return AWTAccessor.getMenuItemAccessor().getShortcut(target);
    299240    }
    300241
  • trunk/openjdk/jdk/src/solaris/classes/sun/awt/X11/XMenuPeer.java

    r278 r406  
    2828import java.awt.peer.*;
    2929
    30 import java.lang.reflect.Field;
    3130import java.util.Vector;
    3231import java.util.logging.*;
    33 import sun.awt.SunToolkit;
     32import sun.awt.AWTAccessor;
    3433
    3534public class XMenuPeer extends XMenuItemPeer implements MenuPeer {
     
    4645     */
    4746    XMenuWindow menuWindow;
    48 
    49 
    50     /*
    51      * Menu's fields & methods
    52      */
    53     private final static Field f_items;
    54 
    55     static {
    56         f_items = SunToolkit.getField(Menu.class, "items");
    57     }
    5847
    5948    /************************************************
     
    154143     ************************************************/
    155144    Vector getTargetItems() {
    156         try {
    157             return (Vector)f_items.get(getTarget());
    158         } catch (IllegalAccessException iae) {
    159             iae.printStackTrace();
    160             return null;
    161         }
     145        return AWTAccessor.getMenuAccessor().getItems((Menu)getTarget());
    162146    }
    163147
  • trunk/openjdk/jdk/src/solaris/classes/sun/awt/X11/XPopupMenuPeer.java

    r278 r406  
    2929import java.awt.event.*;
    3030
    31 import java.lang.reflect.Field;
    32 import java.lang.reflect.Method;
    33 import java.lang.reflect.InvocationTargetException;
    34 
    3531import java.util.Vector;
     32import sun.awt.AWTAccessor;
    3633import java.util.logging.*;
    37 
    38 import sun.awt.SunToolkit;
    3934
    4035public class XPopupMenuPeer extends XMenuWindow implements PopupMenuPeer {
     
    6661    private final static int CAPTION_MARGIN_TOP = 4;
    6762    private final static int CAPTION_SEPARATOR_HEIGHT = 6;
    68 
    69     /*
    70      * Menu's fields & methods
    71      */
    72     //Fix for 6184485: Popup menu is not disabled on XToolkit even when calling setEnabled (false)
    73     private final static Field f_enabled;
    74     //Fix for 6267144: PIT: Popup menu label is not shown, XToolkit
    75     private final static Field f_label;
    76     private final static Method m_getFont;
    77     private final static Field f_items;
    78 
    79     static {
    80         f_enabled = SunToolkit.getField(MenuItem.class, "enabled");
    81         f_label = SunToolkit.getField(MenuItem.class, "label");
    82         f_items = SunToolkit.getField(Menu.class, "items");
    83         m_getFont = SunToolkit.getMethod(MenuComponent.class, "getFont_NoClientCode", null);
    84     }
    85 
    8663
    8764    /************************************************
     
    190167            return XWindow.defaultFont;
    191168        }
    192         try {
    193             return (Font)m_getFont.invoke(popupMenuTarget, new Object[0]);
    194         } catch (IllegalAccessException e) {
    195             e.printStackTrace();
    196         } catch (InvocationTargetException e) {
    197             e.printStackTrace();
    198         }
    199         return XWindow.defaultFont;
    200     }
    201 
     169        return AWTAccessor.getMenuComponentAccessor()
     170                   .getFont_NoClientCode(popupMenuTarget);
     171    }
     172
     173    //Fix for 6267144: PIT: Popup menu label is not shown, XToolkit
    202174    String getTargetLabel() {
    203175        if (target == null) {
    204176            return "";
    205177        }
    206         try {
    207             String label = (String)f_label.get(popupMenuTarget);
    208             return (label == null) ? "" : label;
    209         } catch (IllegalAccessException e) {
    210             e.printStackTrace();
    211         }
    212         return "";
     178        return AWTAccessor.getMenuItemAccessor().getLabel(popupMenuTarget);
    213179    }
    214180
     
    218184            return false;
    219185        }
    220         try {
    221             return f_enabled.getBoolean(popupMenuTarget);
    222         } catch (IllegalAccessException e) {
    223             e.printStackTrace();
    224         }
    225         return false;
     186        return AWTAccessor.getMenuItemAccessor().isEnabled(popupMenuTarget);
    226187    }
    227188
    228189    Vector getMenuTargetItems() {
    229         try {
    230             return (Vector)f_items.get(popupMenuTarget);
    231         } catch (IllegalAccessException iae) {
    232             iae.printStackTrace();
     190        if (popupMenuTarget == null) {
    233191            return null;
    234192        }
     193        return AWTAccessor.getMenuAccessor().getItems(popupMenuTarget);
    235194    }
    236195
  • trunk/openjdk/jdk/src/solaris/classes/sun/awt/X11/XScrollPanePeer.java

    r278 r406  
    2929import java.awt.event.*;
    3030import java.awt.peer.*;
    31 import java.lang.reflect.*;
    32 import sun.awt.SunToolkit;
     31
     32import sun.awt.AWTAccessor;
    3333
    3434class XScrollPanePeer extends XComponentPeer implements ScrollPanePeer, XScrollbarClient {
     
    4242    public final static int     HORIZONTAL = 1 << 1;
    4343
    44     private static Method m_setValue;
    4544    static {
    46         m_setValue = SunToolkit.getMethod(ScrollPaneAdjustable.class, "setTypedValue", new Class[] {Integer.TYPE, Integer.TYPE});
    4745        SCROLLBAR = XToolkit.getUIDefaults().getInt("ScrollBar.defaultWidth");
    4846    }
     
    317315
    318316    void setAdjustableValue(ScrollPaneAdjustable adj, int value, int type) {
    319         try {
    320             m_setValue.invoke(adj, new Object[] {Integer.valueOf(value), Integer.valueOf(type)});
    321         } catch (IllegalAccessException iae) {
    322             adj.setValue(value);
    323         } catch (IllegalArgumentException iae2) {
    324             adj.setValue(value);
    325         } catch (InvocationTargetException ite) {
    326             adj.setValue(value);
    327             ite.getCause().printStackTrace();
    328         }
     317        AWTAccessor.getScrollPaneAdjustableAccessor().setTypedValue(adj, value,
     318                                                                    type);
    329319    }
    330320
  • trunk/openjdk/jdk/src/solaris/classes/sun/awt/X11/XTextAreaPeer.java

    r278 r406  
    6262import sun.awt.CausedFocusEvent;
    6363import sun.awt.ComponentAccessor;
     64import sun.awt.AWTAccessor;
    6465
    6566
     
    986987        public void setTransferHandler(TransferHandler newHandler) {
    987988            TransferHandler oldHandler = (TransferHandler)
    988                 getClientProperty(XTextTransferHelper.getTransferHandlerKey());
    989             putClientProperty(XTextTransferHelper.getTransferHandlerKey(),
     989                getClientProperty(AWTAccessor.getClientPropertyKeyAccessor()
     990                                      .getJComponent_TRANSFER_HANDLER());
     991            putClientProperty(AWTAccessor.getClientPropertyKeyAccessor()
     992                                  .getJComponent_TRANSFER_HANDLER(),
    990993                              newHandler);
    991994
  • trunk/openjdk/jdk/src/solaris/classes/sun/awt/X11/XTextFieldPeer.java

    r278 r406  
    5656import sun.awt.CausedFocusEvent;
    5757import sun.awt.ComponentAccessor;
     58import sun.awt.AWTAccessor;
    5859
    5960public class XTextFieldPeer extends XComponentPeer implements TextFieldPeer {
     
    715716        public void setTransferHandler(TransferHandler newHandler) {
    716717            TransferHandler oldHandler = (TransferHandler)
    717                 getClientProperty(XTextTransferHelper.getTransferHandlerKey());
    718             putClientProperty(XTextTransferHelper.getTransferHandlerKey(),
     718                getClientProperty(AWTAccessor.getClientPropertyKeyAccessor()
     719                                      .getJComponent_TRANSFER_HANDLER());
     720            putClientProperty(AWTAccessor.getClientPropertyKeyAccessor()
     721                                  .getJComponent_TRANSFER_HANDLER(),
    719722                              newHandler);
    720723
  • trunk/openjdk/jdk/src/solaris/classes/sun/awt/X11/XToolkit.java

    r278 r406  
    5050import sun.print.PrintJob2D;
    5151import sun.security.action.GetBooleanAction;
    52 import java.lang.reflect.*;
     52import sun.security.action.GetPropertyAction;
    5353
    5454public class XToolkit extends UNIXToolkit implements Runnable, XConstants {
     
    103103    static long awt_defaultFg; // Pixel
    104104    private static XMouseInfoPeer xPeer;
    105     private static Method m_removeSourceEvents;
    106105
    107106    static {
     
    121120            setBackingStoreType();
    122121        }
    123         m_removeSourceEvents = SunToolkit.getMethod(EventQueue.class, "removeSourceEvents", new Class[] {Object.class, Boolean.TYPE}) ;
    124 
    125         noisyAwtHandler = AccessController.doPrivileged(new GetBooleanAction("sun.awt.noisyerrorhandler"));
     122
     123        noisyAwtHandler = AccessController.doPrivileged(
     124                new GetBooleanAction("sun.awt.noisyerrorhandler"));
    126125    }
    127126
     
    204203    static void initSecurityWarning() {
    205204        // Enable warning only for internal builds
    206         String runtime = getSystemProperty("java.runtime.version");
     205        String runtime = AccessController.doPrivileged(
     206                new GetPropertyAction("java.runtime.version"));
    207207        securityWarningEnabled = (runtime != null && runtime.contains("internal"));
    208208    }
     
    11251125            awtUnlock();
    11261126        }
    1127     }
    1128 
    1129     static String getSystemProperty(final String name) {
    1130         return (String)AccessController.doPrivileged(new PrivilegedAction() {
    1131                 public Object run() {
    1132                     return System.getProperty(name);
    1133                 }
    1134             });
    11351127    }
    11361128
     
    18951887
    18961888    static void removeSourceEvents(EventQueue queue, Object source, boolean removeAllEvents) {
    1897         try {
    1898             m_removeSourceEvents.invoke(queue, source, removeAllEvents);
    1899         }
    1900         catch (IllegalAccessException e)
    1901         {
    1902             e.printStackTrace();
    1903         }
    1904         catch (InvocationTargetException e) {
    1905             e.printStackTrace();
    1906         }
     1889        AWTAccessor.getEventQueueAccessor().removeSourceEvents(queue, source, removeAllEvents);
    19071890    }
    19081891
     
    19381921
    19391922    private static void setBackingStoreType() {
    1940         String prop = (String)AccessController.doPrivileged(
    1941                 new sun.security.action.GetPropertyAction("sun.awt.backingStore"));
     1923        String prop = AccessController.doPrivileged(
     1924                new GetPropertyAction("sun.awt.backingStore"));
    19421925
    19431926        if (prop == null) {
  • trunk/openjdk/jdk/src/solaris/classes/sun/awt/X11/XWindow.java

    r278 r406  
    3434
    3535import java.lang.reflect.Field;
    36 import java.lang.reflect.Method;
    3736
    3837import java.util.logging.Level;
     
    109108    private native static void initIDs();
    110109
    111     private static Field isPostedField;
    112110    static {
    113111        initIDs();
     
    362360    }
    363361
    364     static Method m_sendMessage;
    365362    static void sendEvent(final AWTEvent e) {
    366         if (isPostedField == null) {
    367             isPostedField = SunToolkit.getField(AWTEvent.class, "isPosted");
    368         }
    369363        PeerEvent pe = new PeerEvent(Toolkit.getDefaultToolkit(), new Runnable() {
    370364                public void run() {
    371                     try {
    372                         isPostedField.setBoolean(e, true);
    373                     } catch (IllegalArgumentException e) {
    374                         assert(false);
    375                     } catch (IllegalAccessException e) {
    376                         assert(false);
    377                     }
     365                    AWTAccessor.getAWTEventAccessor().setPosted(e);
    378366                    ((Component)e.getSource()).dispatchEvent(e);
    379367                }
     
    12511239
    12521240
    1253     static Field bdata;
    12541241    static void setBData(KeyEvent e, byte[] data) {
    1255         try {
    1256             if (bdata == null) {
    1257                 bdata = SunToolkit.getField(java.awt.AWTEvent.class, "bdata");
    1258             }
    1259             bdata.set(e, data);
    1260         } catch (IllegalAccessException ex) {
    1261             assert false;
    1262         }
     1242        AWTAccessor.getAWTEventAccessor().setBData(e, data);
    12631243    }
    12641244
  • trunk/openjdk/jdk/src/solaris/classes/sun/awt/X11/XlibWrapper.java

    r278 r406  
    2727
    2828import java.security.AccessController;
    29 import java.security.PrivilegedAction;
     29import sun.security.action.GetPropertyAction;
    3030import sun.misc.*;
    3131
     
    563563
    564564    static {
    565         String dataModelProp = (String)AccessController.doPrivileged(
    566             new PrivilegedAction() {
    567                     public Object run() {
    568                         return System.getProperty("sun.arch.data.model");
    569                     }
    570                 });
     565        String dataModelProp = AccessController.doPrivileged(new GetPropertyAction("sun.arch.data.model"));
    571566        try {
    572567            dataModel = Integer.parseInt(dataModelProp);
     
    611606
    612607    private static boolean getBuildInternal() {
    613         String javaVersion = XToolkit.getSystemProperty("java.version");
     608        String javaVersion = AccessController.doPrivileged(new GetPropertyAction("java.version"));
    614609        return javaVersion != null && javaVersion.contains("internal");
    615610    }
  • trunk/openjdk/jdk/src/solaris/classes/sun/awt/motif/MComponentPeer.java

    r278 r406  
    401401
    402402    static void callRequestFocusInWindow(Component target, CausedFocusEvent.Cause cause) {
    403         if (requestFocusWithCause == null) {
    404             requestFocusWithCause = SunToolkit.getMethod(Component.class, "requestFocusInWindow", new Class[] {CausedFocusEvent.Cause.class});
    405         }
    406         if (requestFocusWithCause != null) {
    407             try {
    408                 requestFocusWithCause.invoke(target, new Object[] {cause});
    409             } catch (Exception e) {
    410                 e.printStackTrace();
    411             }
    412         }
     403        AWTAccessor.getComponentAccessor().requestFocusInWindow(target, cause);
    413404    }
    414405
  • trunk/openjdk/jdk/src/solaris/classes/sun/print/UnixPrintJob.java

    r278 r406  
    11/*
    2  * Copyright (c) 2000, 2004, Oracle and/or its affiliates. All rights reserved.
     2 * Copyright (c) 2000, 2012, Oracle and/or its affiliates. All rights reserved.
    33 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    44 *
     
    938938                     * removed when the VM exits.
    939939                     */
    940                     spoolFile = File.createTempFile("javaprint", ".ps", null);
     940                    spoolFile = sun.misc.IOUtils.createTempFile("javaprint", ".ps", null);
    941941                    spoolFile.deleteOnExit();
    942942                }
  • trunk/openjdk/jdk/src/solaris/classes/sun/print/UnixPrintServiceLookup.java

    r278 r406  
    11/*
    2  * Copyright (c) 2000, 2006, Oracle and/or its affiliates. All rights reserved.
     2 * Copyright (c) 2000, 2012, Oracle and/or its affiliates. All rights reserved.
    33 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    44 *
     
    713713                        Process proc;
    714714                        BufferedReader bufferedReader = null;
    715                         File f = File.createTempFile("prn","xc");
     715                        File f = sun.misc.IOUtils.createTempFile("prn","xc");
    716716                        cmd[2] = cmd[2]+">"+f.getAbsolutePath();
    717717
  • trunk/openjdk/jdk/src/solaris/native/java/io/UnixFileSystem_md.c

    r278 r406  
    11/*
    2  * Copyright (c) 1998, 2006, Oracle and/or its affiliates. All rights reserved.
     2 * Copyright (c) 1998, 2012, Oracle and/or its affiliates. All rights reserved.
    33 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    44 *
     
    311311JNIEXPORT jboolean JNICALL
    312312Java_java_io_UnixFileSystem_createFileExclusively(JNIEnv *env, jclass cls,
    313                                                   jstring pathname)
     313                                                  jstring pathname,
     314                                                  jboolean restrictive)
    314315{
    315316    jboolean rv = JNI_FALSE;
     
    320321            fd = JVM_EEXIST;    /* The root directory always exists */
    321322        } else {
    322             fd = JVM_Open(path, JVM_O_RDWR | JVM_O_CREAT | JVM_O_EXCL, 0666);
     323            jint mode = (restrictive == JNI_TRUE) ? 0600 : 0666;
     324            fd = JVM_Open(path, JVM_O_RDWR | JVM_O_CREAT | JVM_O_EXCL, mode);
    323325        }
    324326        if (fd < 0) {
  • trunk/openjdk/jdk/src/solaris/native/java/net/net_util_md.c

    r278 r406  
    11/*
    2  * Copyright (c) 1997, 2007, Oracle and/or its affiliates. All rights reserved.
     2 * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved.
    33 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    44 *
     
    6565
    6666/*
    67  * EXCLBIND socket options only on Solaris 8 & 9.
     67 * EXCLBIND socket options only on Solaris
    6868 */
    6969#if defined(__solaris__) && !defined(TCP_EXCLBIND)
     
    7878static int tcp_max_buf;
    7979static int udp_max_buf;
     80static int useExclBind = 0;
    8081
    8182/*
     
    646647
    647648#endif
     649
     650void parseExclusiveBindProperty(JNIEnv *env) {
     651#ifdef __solaris__
     652    jstring s, flagSet;
     653    jclass iCls;
     654    jmethodID mid;
     655
     656    s = (*env)->NewStringUTF(env, "sun.net.useExclusiveBind");
     657    CHECK_NULL(s);
     658    iCls = (*env)->FindClass(env, "java/lang/System");
     659    CHECK_NULL(iCls);
     660    mid = (*env)->GetStaticMethodID(env, iCls, "getProperty",
     661                "(Ljava/lang/String;)Ljava/lang/String;");
     662    CHECK_NULL(mid);
     663    flagSet = (*env)->CallStaticObjectMethod(env, iCls, mid, s);
     664    if (flagSet != NULL) {
     665        useExclBind = 1;
     666    }
     667#endif
     668}
    648669
    649670/* In the case of an IPv4 Inetaddress this method will return an
     
    12231244 * caught.
    12241245 *
    1225  * On Solaris 8/9 with IPv6 enabled we must use an exclusive
    1226  * bind to guaranteed a unique port number across the IPv4 and
     1246 * On Solaris with IPv6 enabled we must use an exclusive
     1247 * bind to guarantee a unique port number across the IPv4 and
    12271248 * IPv6 port spaces.
    12281249 *
     
    12541275#if defined(__solaris__) && defined(AF_INET6)
    12551276    /*
    1256      * Solaris 8/9 have seperate IPv4 and IPv6 port spaces so we
     1277     * Solaris has separate IPv4 and IPv6 port spaces so we
    12571278     * use an exclusive bind when SO_REUSEADDR is not used to
    12581279     * give the illusion of a unified port space.
    1259      * This also avoid problems with IPv6 sockets connecting
     1280     * This also avoids problems with IPv6 sockets connecting
    12601281     * to IPv4 mapped addresses whereby the socket conversion
    12611282     * results in a late bind that fails because the
     
    12661287
    12671288        len = sizeof(arg);
    1268         if (getsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (char *)&arg,
    1269                        &len) == 0) {
    1270             if (arg == 0) {
     1289        if (useExclBind || getsockopt(fd, SOL_SOCKET, SO_REUSEADDR,
     1290                       (char *)&arg, &len) == 0) {
     1291            if (useExclBind || arg == 0) {
    12711292                /*
    1272                  * SO_REUSEADDR is disabled so enable TCP_EXCLBIND or
     1293                 * SO_REUSEADDR is disabled or sun.net.useExclusiveBind
     1294                 * property is true so enable TCP_EXCLBIND or
    12731295                 * UDP_EXCLBIND
    12741296                 */
Note: See TracChangeset for help on using the changeset viewer.