home *** CD-ROM | disk | FTP | other *** search
/ Sky at Night 2007 June / SAN CD 6-2007 CD-ROM 25.iso / pc / Software / AstroGrav_Win / Java / jre1.6.0 / lib / rt.jar / java / awt / Window.class (.txt) < prev    next >
Encoding:
Java Class File  |  2006-11-29  |  25.5 KB  |  1,398 lines
  1. package java.awt;
  2.  
  3. import java.applet.Applet;
  4. import java.awt.Dialog.ModalExclusionType;
  5. import java.awt.event.KeyEvent;
  6. import java.awt.event.MouseWheelEvent;
  7. import java.awt.event.WindowEvent;
  8. import java.awt.event.WindowFocusListener;
  9. import java.awt.event.WindowListener;
  10. import java.awt.event.WindowStateListener;
  11. import java.awt.im.InputContext;
  12. import java.awt.image.BufferStrategy;
  13. import java.awt.peer.WindowPeer;
  14. import java.beans.PropertyChangeListener;
  15. import java.io.IOException;
  16. import java.io.ObjectInputStream;
  17. import java.io.ObjectOutputStream;
  18. import java.io.OptionalDataException;
  19. import java.io.Serializable;
  20. import java.lang.ref.WeakReference;
  21. import java.lang.reflect.InvocationTargetException;
  22. import java.security.AccessController;
  23. import java.util.ArrayList;
  24. import java.util.Arrays;
  25. import java.util.EventListener;
  26. import java.util.List;
  27. import java.util.Locale;
  28. import java.util.ResourceBundle;
  29. import java.util.Set;
  30. import java.util.Vector;
  31. import java.util.concurrent.atomic.AtomicBoolean;
  32. import javax.accessibility.Accessible;
  33. import javax.accessibility.AccessibleContext;
  34. import sun.awt.AppContext;
  35. import sun.awt.DebugHelper;
  36. import sun.awt.SunToolkit;
  37. import sun.awt.CausedFocusEvent.Cause;
  38. import sun.java2d.Disposer;
  39. import sun.security.action.GetPropertyAction;
  40. import sun.security.util.SecurityConstants;
  41.  
  42. public class Window extends Container implements Accessible {
  43.    String warningString;
  44.    transient List<Image> icons;
  45.    private transient Component temporaryLostComponent;
  46.    static boolean systemSyncLWRequests = false;
  47.    boolean syncLWRequests;
  48.    transient boolean beforeFirstShow;
  49.    static final int OPENED = 1;
  50.    int state;
  51.    private boolean alwaysOnTop;
  52.    static Vector<Window> allWindows = new Vector();
  53.    transient Vector<WeakReference<Window>> ownedWindowList;
  54.    private transient WeakReference<Window> weakThis;
  55.    transient boolean showWithParent;
  56.    transient Dialog modalBlocker;
  57.    Dialog.ModalExclusionType modalExclusionType;
  58.    transient WindowListener windowListener;
  59.    transient WindowStateListener windowStateListener;
  60.    transient WindowFocusListener windowFocusListener;
  61.    transient InputContext inputContext;
  62.    private transient Object inputContextLock;
  63.    private FocusManager focusMgr;
  64.    private boolean focusableWindowState;
  65.    transient boolean isInShow;
  66.    private static final String base = "win";
  67.    private static int nameCounter = 0;
  68.    private static final long serialVersionUID = 4497834738069338734L;
  69.    private static final DebugHelper dbg = DebugHelper.create(Window.class);
  70.    private static final boolean locationByPlatformProp;
  71.    transient boolean isTrayIconWindow;
  72.    transient Object anchor;
  73.    private static final AtomicBoolean beforeFirstWindowShown;
  74.    private int windowSerializedDataVersion;
  75.    private boolean locationByPlatform;
  76.  
  77.    private static native void initIDs();
  78.  
  79.    Window(GraphicsConfiguration var1) {
  80.       this.syncLWRequests = false;
  81.       this.beforeFirstShow = true;
  82.       this.ownedWindowList = new Vector();
  83.       this.inputContextLock = new Object();
  84.       this.focusableWindowState = true;
  85.       this.isInShow = false;
  86.       this.isTrayIconWindow = false;
  87.       this.anchor = new Object();
  88.       this.windowSerializedDataVersion = 2;
  89.       this.locationByPlatform = locationByPlatformProp;
  90.       this.init(var1);
  91.    }
  92.  
  93.    private void init(GraphicsConfiguration var1) {
  94.       GraphicsEnvironment.checkHeadless();
  95.       this.syncLWRequests = systemSyncLWRequests;
  96.       this.weakThis = new WeakReference(this);
  97.       this.addToWindowList();
  98.       this.setWarningString();
  99.       this.cursor = Cursor.getPredefinedCursor(0);
  100.       this.visible = false;
  101.       if (var1 == null) {
  102.          this.graphicsConfig = GraphicsEnvironment.getLocalGraphicsEnvironment().getDefaultScreenDevice().getDefaultConfiguration();
  103.       } else {
  104.          this.graphicsConfig = var1;
  105.       }
  106.  
  107.       if (this.graphicsConfig.getDevice().getType() != 0) {
  108.          throw new IllegalArgumentException("not a screen device");
  109.       } else {
  110.          this.setLayout(new BorderLayout());
  111.          Rectangle var2 = this.graphicsConfig.getBounds();
  112.          Insets var3 = this.getToolkit().getScreenInsets(this.graphicsConfig);
  113.          int var4 = this.getX() + var2.x + var3.left;
  114.          int var5 = this.getY() + var2.y + var3.top;
  115.          if (var4 != this.x || var5 != this.y) {
  116.             this.setLocation(var4, var5);
  117.             this.setLocationByPlatform(locationByPlatformProp);
  118.          }
  119.  
  120.          this.modalExclusionType = ModalExclusionType.NO_EXCLUDE;
  121.          Disposer.addRecord(this.anchor, new WindowDisposerRecord(this.appContext, this));
  122.       }
  123.    }
  124.  
  125.    Window() throws HeadlessException {
  126.       this.syncLWRequests = false;
  127.       this.beforeFirstShow = true;
  128.       this.ownedWindowList = new Vector();
  129.       this.inputContextLock = new Object();
  130.       this.focusableWindowState = true;
  131.       this.isInShow = false;
  132.       this.isTrayIconWindow = false;
  133.       this.anchor = new Object();
  134.       this.windowSerializedDataVersion = 2;
  135.       this.locationByPlatform = locationByPlatformProp;
  136.       GraphicsEnvironment.checkHeadless();
  137.       this.init((GraphicsConfiguration)null);
  138.    }
  139.  
  140.    public Window(Frame var1) {
  141.       this(var1 == null ? (GraphicsConfiguration)null : var1.getGraphicsConfiguration());
  142.       this.ownedInit(var1);
  143.    }
  144.  
  145.    public Window(Window var1) {
  146.       this(var1 == null ? (GraphicsConfiguration)null : var1.getGraphicsConfiguration());
  147.       this.ownedInit(var1);
  148.    }
  149.  
  150.    public Window(Window var1, GraphicsConfiguration var2) {
  151.       this(var2);
  152.       this.ownedInit(var1);
  153.    }
  154.  
  155.    private void ownedInit(Window var1) {
  156.       this.parent = var1;
  157.       if (var1 != null) {
  158.          var1.addOwnedWindow(this.weakThis);
  159.       }
  160.  
  161.    }
  162.  
  163.    String constructComponentName() {
  164.       synchronized(this.getClass()) {
  165.          return "win" + nameCounter++;
  166.       }
  167.    }
  168.  
  169.    public List<Image> getIconImages() {
  170.       List var1 = this.icons;
  171.       return var1 != null && var1.size() != 0 ? new ArrayList(var1) : new ArrayList();
  172.    }
  173.  
  174.    public synchronized void setIconImages(List<? extends Image> var1) {
  175.       this.icons = var1 == null ? new ArrayList() : new ArrayList(var1);
  176.       WindowPeer var2 = (WindowPeer)this.peer;
  177.       if (var2 != null) {
  178.          var2.updateIconImages();
  179.       }
  180.  
  181.       this.firePropertyChange("iconImage", (Object)null, (Object)null);
  182.    }
  183.  
  184.    public void setIconImage(Image var1) {
  185.       ArrayList var2 = new ArrayList();
  186.       if (var1 != null) {
  187.          var2.add(var1);
  188.       }
  189.  
  190.       this.setIconImages(var2);
  191.    }
  192.  
  193.    public void addNotify() {
  194.       synchronized(this.getTreeLock()) {
  195.          Container var2 = this.parent;
  196.          if (var2 != null && var2.getPeer() == null) {
  197.             var2.addNotify();
  198.          }
  199.  
  200.          if (this.peer == null) {
  201.             this.peer = this.getToolkit().createWindow(this);
  202.          }
  203.  
  204.          allWindows.add(this);
  205.          super.addNotify();
  206.       }
  207.    }
  208.  
  209.    public void removeNotify() {
  210.       synchronized(this.getTreeLock()) {
  211.          allWindows.remove(this);
  212.          super.removeNotify();
  213.       }
  214.    }
  215.  
  216.    public void pack() {
  217.       Container var1 = this.parent;
  218.       if (var1 != null && var1.getPeer() == null) {
  219.          var1.addNotify();
  220.       }
  221.  
  222.       if (this.peer == null) {
  223.          this.addNotify();
  224.       }
  225.  
  226.       Dimension var2 = this.getPreferredSize();
  227.       if (this.peer != null) {
  228.          this.setClientSize(var2.width, var2.height);
  229.       }
  230.  
  231.       if (this.beforeFirstShow) {
  232.          this.isPacked = true;
  233.       }
  234.  
  235.       this.validate();
  236.    }
  237.  
  238.    public void setMinimumSize(Dimension var1) {
  239.       synchronized(this.getTreeLock()) {
  240.          super.setMinimumSize(var1);
  241.          Dimension var3 = this.getSize();
  242.          if (this.isMinimumSizeSet() && (var3.width < var1.width || var3.height < var1.height)) {
  243.             int var4 = Math.max(this.width, var1.width);
  244.             int var5 = Math.max(this.height, var1.height);
  245.             this.setSize(var4, var5);
  246.          }
  247.  
  248.          if (this.peer != null) {
  249.             ((WindowPeer)this.peer).updateMinimumSize();
  250.          }
  251.  
  252.       }
  253.    }
  254.  
  255.    public void setSize(Dimension var1) {
  256.       super.setSize(var1);
  257.    }
  258.  
  259.    public void setSize(int var1, int var2) {
  260.       super.setSize(var1, var2);
  261.    }
  262.  
  263.    /** @deprecated */
  264.    @Deprecated
  265.    public void reshape(int var1, int var2, int var3, int var4) {
  266.       if (this.isMinimumSizeSet()) {
  267.          Dimension var5 = this.getMinimumSize();
  268.          if (var3 < var5.width) {
  269.             var3 = var5.width;
  270.          }
  271.  
  272.          if (var4 < var5.height) {
  273.             var4 = var5.height;
  274.          }
  275.       }
  276.  
  277.       super.reshape(var1, var2, var3, var4);
  278.    }
  279.  
  280.    void setClientSize(int var1, int var2) {
  281.       synchronized(this.getTreeLock()) {
  282.          this.setBoundsOp(4);
  283.          this.setBounds(this.x, this.y, var1, var2);
  284.       }
  285.    }
  286.  
  287.    public void setVisible(boolean var1) {
  288.       super.setVisible(var1);
  289.    }
  290.  
  291.    /** @deprecated */
  292.    @Deprecated
  293.    public void show() {
  294.       if (this.peer == null) {
  295.          this.addNotify();
  296.       }
  297.  
  298.       this.validate();
  299.       this.isInShow = true;
  300.       if (this.visible) {
  301.          this.toFront();
  302.       } else {
  303.          this.beforeFirstShow = false;
  304.          if (beforeFirstWindowShown.getAndSet(false)) {
  305.             SunToolkit.closeSplashScreen();
  306.          }
  307.  
  308.          Dialog.checkShouldBeBlocked(this);
  309.          super.show();
  310.          this.locationByPlatform = false;
  311.  
  312.          for(int var1 = 0; var1 < this.ownedWindowList.size(); ++var1) {
  313.             Window var2 = (Window)((WeakReference)this.ownedWindowList.elementAt(var1)).get();
  314.             if (var2 != null && var2.showWithParent) {
  315.                var2.show();
  316.                var2.showWithParent = false;
  317.             }
  318.          }
  319.  
  320.          if (!this.isModalBlocked()) {
  321.             this.updateChildrenBlocking();
  322.          }
  323.  
  324.          if (this instanceof Frame || this instanceof Dialog) {
  325.             updateChildFocusableWindowState(this);
  326.          }
  327.       }
  328.  
  329.       this.isInShow = false;
  330.       if ((this.state & 1) == 0) {
  331.          this.postWindowEvent(200);
  332.          this.state |= 1;
  333.       }
  334.  
  335.    }
  336.  
  337.    static void updateChildFocusableWindowState(Window var0) {
  338.       if (var0.getPeer() != null && var0.isShowing()) {
  339.          ((WindowPeer)var0.getPeer()).updateFocusableWindowState();
  340.       }
  341.  
  342.       for(int var1 = 0; var1 < var0.ownedWindowList.size(); ++var1) {
  343.          Window var2 = (Window)((WeakReference)var0.ownedWindowList.elementAt(var1)).get();
  344.          if (var2 != null) {
  345.             updateChildFocusableWindowState(var2);
  346.          }
  347.       }
  348.  
  349.    }
  350.  
  351.    synchronized void postWindowEvent(int var1) {
  352.       if (this.windowListener != null || (this.eventMask & 64L) != 0L || Toolkit.enabledOnToolkit(64L)) {
  353.          WindowEvent var2 = new WindowEvent(this, var1);
  354.          Toolkit.getEventQueue().postEvent(var2);
  355.       }
  356.  
  357.    }
  358.  
  359.    /** @deprecated */
  360.    @Deprecated
  361.    public void hide() {
  362.       synchronized(this.ownedWindowList) {
  363.          for(int var2 = 0; var2 < this.ownedWindowList.size(); ++var2) {
  364.             Window var3 = (Window)((WeakReference)this.ownedWindowList.elementAt(var2)).get();
  365.             if (var3 != null && var3.visible) {
  366.                var3.hide();
  367.                var3.showWithParent = true;
  368.             }
  369.          }
  370.       }
  371.  
  372.       if (this.isModalBlocked()) {
  373.          this.modalBlocker.unblockWindow(this);
  374.       }
  375.  
  376.       super.hide();
  377.    }
  378.  
  379.    final void clearMostRecentFocusOwnerOnHide() {
  380.    }
  381.  
  382.    public void dispose() {
  383.       this.doDispose();
  384.    }
  385.  
  386.    void disposeImpl() {
  387.       this.dispose();
  388.       if (this.getPeer() != null) {
  389.          this.doDispose();
  390.       }
  391.  
  392.    }
  393.  
  394.    void doDispose() {
  395.       1DisposeAction var1 = new 1DisposeAction(this);
  396.       if (EventQueue.isDispatchThread()) {
  397.          var1.run();
  398.       } else {
  399.          try {
  400.             EventQueue.invokeAndWait(var1);
  401.          } catch (InterruptedException var3) {
  402.             System.err.println("Disposal was interrupted:");
  403.             var3.printStackTrace();
  404.          } catch (InvocationTargetException var4) {
  405.             System.err.println("Exception during disposal:");
  406.             var4.printStackTrace();
  407.          }
  408.       }
  409.  
  410.       this.postWindowEvent(202);
  411.    }
  412.  
  413.    void adjustListeningChildrenOnParent(long var1, int var3) {
  414.    }
  415.  
  416.    void adjustDecendantsOnParent(int var1) {
  417.    }
  418.  
  419.    public void toFront() {
  420.       this.toFront_NoClientCode();
  421.    }
  422.  
  423.    final void toFront_NoClientCode() {
  424.       if (this.visible) {
  425.          WindowPeer var1 = (WindowPeer)this.peer;
  426.          if (var1 != null) {
  427.             var1.toFront();
  428.          }
  429.  
  430.          if (this.isModalBlocked()) {
  431.             this.modalBlocker.toFront_NoClientCode();
  432.          }
  433.       }
  434.  
  435.    }
  436.  
  437.    public void toBack() {
  438.       this.toBack_NoClientCode();
  439.    }
  440.  
  441.    final void toBack_NoClientCode() {
  442.       if (this.isAlwaysOnTop()) {
  443.          try {
  444.             this.setAlwaysOnTop(false);
  445.          } catch (SecurityException var2) {
  446.          }
  447.       }
  448.  
  449.       if (this.visible) {
  450.          WindowPeer var1 = (WindowPeer)this.peer;
  451.          if (var1 != null) {
  452.             var1.toBack();
  453.          }
  454.       }
  455.  
  456.    }
  457.  
  458.    public Toolkit getToolkit() {
  459.       return Toolkit.getDefaultToolkit();
  460.    }
  461.  
  462.    public final String getWarningString() {
  463.       return this.warningString;
  464.    }
  465.  
  466.    private void setWarningString() {
  467.       this.warningString = null;
  468.       SecurityManager var1 = System.getSecurityManager();
  469.       if (var1 != null && !var1.checkTopLevelWindow(this)) {
  470.          this.warningString = (String)AccessController.doPrivileged(new GetPropertyAction("awt.appletWarning", "Java Applet Window"));
  471.       }
  472.  
  473.    }
  474.  
  475.    public Locale getLocale() {
  476.       return this.locale == null ? Locale.getDefault() : this.locale;
  477.    }
  478.  
  479.    public InputContext getInputContext() {
  480.       if (this.inputContext == null) {
  481.          synchronized(this.inputContextLock) {
  482.             if (this.inputContext == null) {
  483.                this.inputContext = InputContext.getInstance();
  484.             }
  485.          }
  486.       }
  487.  
  488.       return this.inputContext;
  489.    }
  490.  
  491.    public void setCursor(Cursor var1) {
  492.       if (var1 == null) {
  493.          var1 = Cursor.getPredefinedCursor(0);
  494.       }
  495.  
  496.       super.setCursor(var1);
  497.    }
  498.  
  499.    public Window getOwner() {
  500.       return (Window)this.parent;
  501.    }
  502.  
  503.    public Window[] getOwnedWindows() {
  504.       synchronized(this.ownedWindowList) {
  505.          int var3 = this.ownedWindowList.size();
  506.          int var4 = 0;
  507.          Window[] var5 = new Window[var3];
  508.  
  509.          for(int var6 = 0; var6 < var3; ++var6) {
  510.             var5[var4] = (Window)((WeakReference)this.ownedWindowList.elementAt(var6)).get();
  511.             if (var5[var4] != null) {
  512.                ++var4;
  513.             }
  514.          }
  515.  
  516.          Window[] var1;
  517.          if (var3 != var4) {
  518.             var1 = (Window[])Arrays.copyOf(var5, var4);
  519.          } else {
  520.             var1 = var5;
  521.          }
  522.  
  523.          return var1;
  524.       }
  525.    }
  526.  
  527.    boolean isModalBlocked() {
  528.       return this.modalBlocker != null;
  529.    }
  530.  
  531.    void setModalBlocked(Dialog var1, boolean var2) {
  532.       this.modalBlocker = var2 ? var1 : null;
  533.       WindowPeer var3 = (WindowPeer)this.peer;
  534.       if (var3 != null) {
  535.          var3.setModalBlocked(var1, var2);
  536.       }
  537.  
  538.    }
  539.  
  540.    Dialog getModalBlocker() {
  541.       return this.modalBlocker;
  542.    }
  543.  
  544.    static Vector<Window> getAllWindows() {
  545.       synchronized(allWindows) {
  546.          Vector var1 = new Vector();
  547.          var1.addAll(allWindows);
  548.          return var1;
  549.       }
  550.    }
  551.  
  552.    static Vector<Window> getAllUnblockedWindows() {
  553.       synchronized(allWindows) {
  554.          Vector var1 = new Vector();
  555.  
  556.          for(int var2 = 0; var2 < allWindows.size(); ++var2) {
  557.             Window var3 = (Window)allWindows.get(var2);
  558.             if (!var3.isModalBlocked()) {
  559.                var1.add(var3);
  560.             }
  561.          }
  562.  
  563.          return var1;
  564.       }
  565.    }
  566.  
  567.    private static Window[] getWindows(AppContext var0) {
  568.       synchronized(Window.class) {
  569.          Vector var3 = (Vector)var0.get(Window.class);
  570.          Window[] var2;
  571.          if (var3 != null) {
  572.             int var4 = var3.size();
  573.             int var5 = 0;
  574.             Window[] var6 = new Window[var4];
  575.  
  576.             for(int var7 = 0; var7 < var4; ++var7) {
  577.                Window var8 = (Window)((WeakReference)var3.get(var7)).get();
  578.                if (var8 != null) {
  579.                   var6[var5++] = var8;
  580.                }
  581.             }
  582.  
  583.             if (var4 != var5) {
  584.                var2 = (Window[])Arrays.copyOf(var6, var5);
  585.             } else {
  586.                var2 = var6;
  587.             }
  588.          } else {
  589.             var2 = new Window[0];
  590.          }
  591.  
  592.          return var2;
  593.       }
  594.    }
  595.  
  596.    public static Window[] getWindows() {
  597.       return getWindows(AppContext.getAppContext());
  598.    }
  599.  
  600.    public static Window[] getOwnerlessWindows() {
  601.       Window[] var0 = getWindows();
  602.       int var1 = 0;
  603.  
  604.       for(Window var5 : var0) {
  605.          if (var5.getOwner() == null) {
  606.             ++var1;
  607.          }
  608.       }
  609.  
  610.       Window[] var8 = new Window[var1];
  611.       int var9 = 0;
  612.  
  613.       for(Window var7 : var0) {
  614.          if (var7.getOwner() == null) {
  615.             var8[var9++] = var7;
  616.          }
  617.       }
  618.  
  619.       return var8;
  620.    }
  621.  
  622.    Window getDocumentRoot() {
  623.       synchronized(this.getTreeLock()) {
  624.          Window var2;
  625.          for(var2 = this; var2.getOwner() != null; var2 = var2.getOwner()) {
  626.          }
  627.  
  628.          return var2;
  629.       }
  630.    }
  631.  
  632.    public void setModalExclusionType(Dialog.ModalExclusionType var1) {
  633.       if (var1 == null) {
  634.          var1 = ModalExclusionType.NO_EXCLUDE;
  635.       }
  636.  
  637.       if (this.modalExclusionType != var1) {
  638.          if (!Toolkit.getDefaultToolkit().isModalExclusionTypeSupported(var1)) {
  639.             var1 = ModalExclusionType.NO_EXCLUDE;
  640.          }
  641.  
  642.          if (var1 == ModalExclusionType.TOOLKIT_EXCLUDE) {
  643.             SecurityManager var2 = System.getSecurityManager();
  644.             if (var2 != null) {
  645.                var2.checkPermission(SecurityConstants.TOOLKIT_MODALITY_PERMISSION);
  646.             }
  647.          }
  648.  
  649.          this.modalExclusionType = var1;
  650.       }
  651.    }
  652.  
  653.    public Dialog.ModalExclusionType getModalExclusionType() {
  654.       return this.modalExclusionType;
  655.    }
  656.  
  657.    boolean isModalExcluded(Dialog.ModalExclusionType var1) {
  658.       if (this.modalExclusionType != null && this.modalExclusionType.compareTo(var1) >= 0) {
  659.          return true;
  660.       } else {
  661.          Window var2 = this.getOwner();
  662.          return var2 != null && var2.isModalExcluded(var1);
  663.       }
  664.    }
  665.  
  666.    void updateChildrenBlocking() {
  667.       Vector var1 = new Vector();
  668.       Window[] var2 = this.getOwnedWindows();
  669.  
  670.       for(int var3 = 0; var3 < var2.length; ++var3) {
  671.          var1.add(var2[var3]);
  672.       }
  673.  
  674.       for(int var7 = 0; var7 < var1.size(); ++var7) {
  675.          Window var4 = (Window)var1.get(var7);
  676.          if (var4.isVisible()) {
  677.             if (var4.isModalBlocked()) {
  678.                Dialog var5 = var4.getModalBlocker();
  679.                var5.unblockWindow(var4);
  680.             }
  681.  
  682.             Dialog.checkShouldBeBlocked(var4);
  683.             Window[] var8 = var4.getOwnedWindows();
  684.  
  685.             for(int var6 = 0; var6 < var8.length; ++var6) {
  686.                var1.add(var8[var6]);
  687.             }
  688.          }
  689.       }
  690.  
  691.    }
  692.  
  693.    public synchronized void addWindowListener(WindowListener var1) {
  694.       if (var1 != null) {
  695.          this.newEventsOnly = true;
  696.          this.windowListener = AWTEventMulticaster.add(this.windowListener, var1);
  697.       }
  698.    }
  699.  
  700.    public synchronized void addWindowStateListener(WindowStateListener var1) {
  701.       if (var1 != null) {
  702.          this.windowStateListener = AWTEventMulticaster.add(this.windowStateListener, var1);
  703.          this.newEventsOnly = true;
  704.       }
  705.    }
  706.  
  707.    public synchronized void addWindowFocusListener(WindowFocusListener var1) {
  708.       if (var1 != null) {
  709.          this.windowFocusListener = AWTEventMulticaster.add(this.windowFocusListener, var1);
  710.          this.newEventsOnly = true;
  711.       }
  712.    }
  713.  
  714.    public synchronized void removeWindowListener(WindowListener var1) {
  715.       if (var1 != null) {
  716.          this.windowListener = AWTEventMulticaster.remove(this.windowListener, var1);
  717.       }
  718.    }
  719.  
  720.    public synchronized void removeWindowStateListener(WindowStateListener var1) {
  721.       if (var1 != null) {
  722.          this.windowStateListener = AWTEventMulticaster.remove(this.windowStateListener, var1);
  723.       }
  724.    }
  725.  
  726.    public synchronized void removeWindowFocusListener(WindowFocusListener var1) {
  727.       if (var1 != null) {
  728.          this.windowFocusListener = AWTEventMulticaster.remove(this.windowFocusListener, var1);
  729.       }
  730.    }
  731.  
  732.    public synchronized WindowListener[] getWindowListeners() {
  733.       return (WindowListener[])this.getListeners(WindowListener.class);
  734.    }
  735.  
  736.    public synchronized WindowFocusListener[] getWindowFocusListeners() {
  737.       return (WindowFocusListener[])this.getListeners(WindowFocusListener.class);
  738.    }
  739.  
  740.    public synchronized WindowStateListener[] getWindowStateListeners() {
  741.       return (WindowStateListener[])this.getListeners(WindowStateListener.class);
  742.    }
  743.  
  744.    public <T extends EventListener> T[] getListeners(Class<T> var1) {
  745.       Object var2 = null;
  746.       if (var1 == WindowFocusListener.class) {
  747.          var2 = this.windowFocusListener;
  748.       } else if (var1 == WindowStateListener.class) {
  749.          var2 = this.windowStateListener;
  750.       } else {
  751.          if (var1 != WindowListener.class) {
  752.             return (T[])super.getListeners(var1);
  753.          }
  754.  
  755.          var2 = this.windowListener;
  756.       }
  757.  
  758.       return (T[])AWTEventMulticaster.getListeners((EventListener)var2, var1);
  759.    }
  760.  
  761.    boolean eventEnabled(AWTEvent var1) {
  762.       switch (var1.id) {
  763.          case 200:
  764.          case 201:
  765.          case 202:
  766.          case 203:
  767.          case 204:
  768.          case 205:
  769.          case 206:
  770.             if ((this.eventMask & 64L) == 0L && this.windowListener == null) {
  771.                return false;
  772.             }
  773.  
  774.             return true;
  775.          case 207:
  776.          case 208:
  777.             if ((this.eventMask & 524288L) == 0L && this.windowFocusListener == null) {
  778.                return false;
  779.             }
  780.  
  781.             return true;
  782.          case 209:
  783.             if ((this.eventMask & 262144L) == 0L && this.windowStateListener == null) {
  784.                return false;
  785.             }
  786.  
  787.             return true;
  788.          default:
  789.             return super.eventEnabled(var1);
  790.       }
  791.    }
  792.  
  793.    protected void processEvent(AWTEvent var1) {
  794.       if (var1 instanceof WindowEvent) {
  795.          switch (var1.getID()) {
  796.             case 200:
  797.             case 201:
  798.             case 202:
  799.             case 203:
  800.             case 204:
  801.             case 205:
  802.             case 206:
  803.                this.processWindowEvent((WindowEvent)var1);
  804.                break;
  805.             case 207:
  806.             case 208:
  807.                this.processWindowFocusEvent((WindowEvent)var1);
  808.                break;
  809.             case 209:
  810.                this.processWindowStateEvent((WindowEvent)var1);
  811.          }
  812.  
  813.       } else {
  814.          super.processEvent(var1);
  815.       }
  816.    }
  817.  
  818.    protected void processWindowEvent(WindowEvent var1) {
  819.       WindowListener var2 = this.windowListener;
  820.       if (var2 != null) {
  821.          switch (var1.getID()) {
  822.             case 200:
  823.                var2.windowOpened(var1);
  824.                break;
  825.             case 201:
  826.                var2.windowClosing(var1);
  827.                break;
  828.             case 202:
  829.                var2.windowClosed(var1);
  830.                break;
  831.             case 203:
  832.                var2.windowIconified(var1);
  833.                break;
  834.             case 204:
  835.                var2.windowDeiconified(var1);
  836.                break;
  837.             case 205:
  838.                var2.windowActivated(var1);
  839.                break;
  840.             case 206:
  841.                var2.windowDeactivated(var1);
  842.          }
  843.       }
  844.  
  845.    }
  846.  
  847.    protected void processWindowFocusEvent(WindowEvent var1) {
  848.       WindowFocusListener var2 = this.windowFocusListener;
  849.       if (var2 != null) {
  850.          switch (var1.getID()) {
  851.             case 207:
  852.                var2.windowGainedFocus(var1);
  853.                break;
  854.             case 208:
  855.                var2.windowLostFocus(var1);
  856.          }
  857.       }
  858.  
  859.    }
  860.  
  861.    protected void processWindowStateEvent(WindowEvent var1) {
  862.       WindowStateListener var2 = this.windowStateListener;
  863.       if (var2 != null) {
  864.          switch (var1.getID()) {
  865.             case 209:
  866.                var2.windowStateChanged(var1);
  867.          }
  868.       }
  869.  
  870.    }
  871.  
  872.    void preProcessKeyEvent(KeyEvent var1) {
  873.       if (var1.isActionKey() && var1.getKeyCode() == 112 && var1.isControlDown() && var1.isShiftDown() && var1.getID() == 401) {
  874.          this.list(System.out, 0);
  875.       }
  876.  
  877.    }
  878.  
  879.    void postProcessKeyEvent(KeyEvent var1) {
  880.    }
  881.  
  882.    public final void setAlwaysOnTop(boolean var1) throws SecurityException {
  883.       SecurityManager var2 = System.getSecurityManager();
  884.       if (var2 != null) {
  885.          var2.checkPermission(SecurityConstants.SET_WINDOW_ALWAYS_ON_TOP_PERMISSION);
  886.       }
  887.  
  888.       boolean var3;
  889.       synchronized(this) {
  890.          var3 = this.alwaysOnTop;
  891.          this.alwaysOnTop = var1;
  892.       }
  893.  
  894.       if (var3 != var1) {
  895.          if (this.isAlwaysOnTopSupported()) {
  896.             WindowPeer var4 = (WindowPeer)this.peer;
  897.             synchronized(this.getTreeLock()) {
  898.                if (var4 != null) {
  899.                   var4.setAlwaysOnTop(var1);
  900.                }
  901.             }
  902.          }
  903.  
  904.          this.firePropertyChange("alwaysOnTop", var3, var1);
  905.       }
  906.  
  907.    }
  908.  
  909.    public boolean isAlwaysOnTopSupported() {
  910.       return Toolkit.getDefaultToolkit().isAlwaysOnTopSupported();
  911.    }
  912.  
  913.    public final boolean isAlwaysOnTop() {
  914.       return this.alwaysOnTop;
  915.    }
  916.  
  917.    public Component getFocusOwner() {
  918.       return this.isFocused() ? KeyboardFocusManager.getCurrentKeyboardFocusManager().getFocusOwner() : null;
  919.    }
  920.  
  921.    public Component getMostRecentFocusOwner() {
  922.       if (this.isFocused()) {
  923.          return this.getFocusOwner();
  924.       } else {
  925.          Component var1 = KeyboardFocusManager.getMostRecentFocusOwner(this);
  926.          if (var1 != null) {
  927.             return var1;
  928.          } else {
  929.             return this.isFocusableWindow() ? this.getFocusTraversalPolicy().getInitialComponent(this) : null;
  930.          }
  931.       }
  932.    }
  933.  
  934.    public boolean isActive() {
  935.       return KeyboardFocusManager.getCurrentKeyboardFocusManager().getActiveWindow() == this;
  936.    }
  937.  
  938.    public boolean isFocused() {
  939.       return KeyboardFocusManager.getCurrentKeyboardFocusManager().getGlobalFocusedWindow() == this;
  940.    }
  941.  
  942.    public Set<AWTKeyStroke> getFocusTraversalKeys(int var1) {
  943.       if (var1 >= 0 && var1 < 4) {
  944.          Set var2 = this.focusTraversalKeys != null ? this.focusTraversalKeys[var1] : null;
  945.          return var2 != null ? var2 : KeyboardFocusManager.getCurrentKeyboardFocusManager().getDefaultFocusTraversalKeys(var1);
  946.       } else {
  947.          throw new IllegalArgumentException("invalid focus traversal key identifier");
  948.       }
  949.    }
  950.  
  951.    public final void setFocusCycleRoot(boolean var1) {
  952.    }
  953.  
  954.    public final boolean isFocusCycleRoot() {
  955.       return true;
  956.    }
  957.  
  958.    public final Container getFocusCycleRootAncestor() {
  959.       return null;
  960.    }
  961.  
  962.    public final boolean isFocusableWindow() {
  963.       if (!this.getFocusableWindowState()) {
  964.          return false;
  965.       } else if (!(this instanceof Frame) && !(this instanceof Dialog)) {
  966.          if (this.getFocusTraversalPolicy().getDefaultComponent(this) == null) {
  967.             return false;
  968.          } else {
  969.             for(Window var1 = this.getOwner(); var1 != null; var1 = var1.getOwner()) {
  970.                if (var1 instanceof Frame || var1 instanceof Dialog) {
  971.                   return var1.isShowing();
  972.                }
  973.             }
  974.  
  975.             return false;
  976.          }
  977.       } else {
  978.          return true;
  979.       }
  980.    }
  981.  
  982.    public boolean getFocusableWindowState() {
  983.       return this.focusableWindowState;
  984.    }
  985.  
  986.    public void setFocusableWindowState(boolean var1) {
  987.       boolean var2;
  988.       synchronized(this) {
  989.          var2 = this.focusableWindowState;
  990.          this.focusableWindowState = var1;
  991.       }
  992.  
  993.       WindowPeer var3 = (WindowPeer)this.peer;
  994.       if (var3 != null) {
  995.          var3.updateFocusableWindowState();
  996.       }
  997.  
  998.       this.firePropertyChange("focusableWindowState", var2, var1);
  999.       if (var2 && !var1 && this.isFocused()) {
  1000.          for(Window var4 = this.getOwner(); var4 != null; var4 = var4.getOwner()) {
  1001.             Component var5 = KeyboardFocusManager.getMostRecentFocusOwner(var4);
  1002.             if (var5 != null && var5.requestFocus(false, Cause.ACTIVATION)) {
  1003.                return;
  1004.             }
  1005.          }
  1006.  
  1007.          KeyboardFocusManager.getCurrentKeyboardFocusManager().clearGlobalFocusOwner();
  1008.       }
  1009.  
  1010.    }
  1011.  
  1012.    public void addPropertyChangeListener(PropertyChangeListener var1) {
  1013.       super.addPropertyChangeListener(var1);
  1014.    }
  1015.  
  1016.    public void addPropertyChangeListener(String var1, PropertyChangeListener var2) {
  1017.       super.addPropertyChangeListener(var1, var2);
  1018.    }
  1019.  
  1020.    void dispatchEventImpl(AWTEvent var1) {
  1021.       if (var1.getID() == 101) {
  1022.          this.invalidate();
  1023.          this.validate();
  1024.       }
  1025.  
  1026.       super.dispatchEventImpl(var1);
  1027.    }
  1028.  
  1029.    /** @deprecated */
  1030.    @Deprecated
  1031.    public boolean postEvent(Event var1) {
  1032.       if (this.handleEvent(var1)) {
  1033.          var1.consume();
  1034.          return true;
  1035.       } else {
  1036.          return false;
  1037.       }
  1038.    }
  1039.  
  1040.    public boolean isShowing() {
  1041.       return this.visible;
  1042.    }
  1043.  
  1044.    /** @deprecated */
  1045.    @Deprecated
  1046.    public void applyResourceBundle(ResourceBundle var1) {
  1047.       this.applyComponentOrientation(ComponentOrientation.getOrientation(var1));
  1048.    }
  1049.  
  1050.    /** @deprecated */
  1051.    @Deprecated
  1052.    public void applyResourceBundle(String var1) {
  1053.       this.applyResourceBundle(ResourceBundle.getBundle(var1));
  1054.    }
  1055.  
  1056.    void addOwnedWindow(WeakReference var1) {
  1057.       if (var1 != null) {
  1058.          synchronized(this.ownedWindowList) {
  1059.             if (!this.ownedWindowList.contains(var1)) {
  1060.                this.ownedWindowList.addElement(var1);
  1061.             }
  1062.          }
  1063.       }
  1064.  
  1065.    }
  1066.  
  1067.    void removeOwnedWindow(WeakReference var1) {
  1068.       if (var1 != null) {
  1069.          this.ownedWindowList.removeElement(var1);
  1070.       }
  1071.  
  1072.    }
  1073.  
  1074.    void connectOwnedWindow(Window var1) {
  1075.       var1.parent = this;
  1076.       this.addOwnedWindow(var1.weakThis);
  1077.    }
  1078.  
  1079.    private void addToWindowList() {
  1080.       synchronized(Window.class) {
  1081.          Vector var2 = (Vector)this.appContext.get(Window.class);
  1082.          if (var2 == null) {
  1083.             var2 = new Vector();
  1084.             this.appContext.put(Window.class, var2);
  1085.          }
  1086.  
  1087.          var2.add(this.weakThis);
  1088.       }
  1089.    }
  1090.  
  1091.    private static void removeFromWindowList(AppContext var0, WeakReference var1) {
  1092.       synchronized(Window.class) {
  1093.          Vector var3 = (Vector)var0.get(Window.class);
  1094.          if (var3 != null) {
  1095.             var3.remove(var1);
  1096.          }
  1097.  
  1098.       }
  1099.    }
  1100.  
  1101.    private void removeFromWindowList() {
  1102.       removeFromWindowList(this.appContext, this.weakThis);
  1103.    }
  1104.  
  1105.    private void writeObject(ObjectOutputStream var1) throws IOException {
  1106.       synchronized(this) {
  1107.          this.focusMgr = new FocusManager();
  1108.          this.focusMgr.focusRoot = this;
  1109.          this.focusMgr.focusOwner = this.getMostRecentFocusOwner();
  1110.          var1.defaultWriteObject();
  1111.          this.focusMgr = null;
  1112.          AWTEventMulticaster.save(var1, "windowL", this.windowListener);
  1113.          AWTEventMulticaster.save(var1, "windowFocusL", this.windowFocusListener);
  1114.          AWTEventMulticaster.save(var1, "windowStateL", this.windowStateListener);
  1115.       }
  1116.  
  1117.       var1.writeObject((Object)null);
  1118.       synchronized(this.ownedWindowList) {
  1119.          for(int var3 = 0; var3 < this.ownedWindowList.size(); ++var3) {
  1120.             Window var4 = (Window)((WeakReference)this.ownedWindowList.elementAt(var3)).get();
  1121.             if (var4 != null) {
  1122.                var1.writeObject("ownedL");
  1123.                var1.writeObject(var4);
  1124.             }
  1125.          }
  1126.       }
  1127.  
  1128.       var1.writeObject((Object)null);
  1129.       if (this.icons != null) {
  1130.          for(Image var8 : this.icons) {
  1131.             if (var8 instanceof Serializable) {
  1132.                var1.writeObject(var8);
  1133.             }
  1134.          }
  1135.       }
  1136.  
  1137.       var1.writeObject((Object)null);
  1138.    }
  1139.  
  1140.    private void initDeserializedWindow() {
  1141.       this.setWarningString();
  1142.       this.inputContextLock = new Object();
  1143.       this.visible = false;
  1144.       this.weakThis = new WeakReference(this);
  1145.       this.anchor = new Object();
  1146.       Disposer.addRecord(this.anchor, new WindowDisposerRecord(this.appContext, this));
  1147.       this.addToWindowList();
  1148.    }
  1149.  
  1150.    private void deserializeResources(ObjectInputStream var1) throws ClassNotFoundException, IOException, HeadlessException {
  1151.       this.ownedWindowList = new Vector();
  1152.       if (this.windowSerializedDataVersion < 2) {
  1153.          if (this.focusMgr != null && this.focusMgr.focusOwner != null) {
  1154.             KeyboardFocusManager.setMostRecentFocusOwner(this, this.focusMgr.focusOwner);
  1155.          }
  1156.  
  1157.          this.focusableWindowState = true;
  1158.       }
  1159.  
  1160.       Object var2;
  1161.       while(null != (var2 = var1.readObject())) {
  1162.          String var3 = ((String)var2).intern();
  1163.          if ("windowL" == var3) {
  1164.             this.addWindowListener((WindowListener)var1.readObject());
  1165.          } else if ("windowFocusL" == var3) {
  1166.             this.addWindowFocusListener((WindowFocusListener)var1.readObject());
  1167.          } else if ("windowStateL" == var3) {
  1168.             this.addWindowStateListener((WindowStateListener)var1.readObject());
  1169.          } else {
  1170.             var1.readObject();
  1171.          }
  1172.       }
  1173.  
  1174.       try {
  1175.          while(null != (var2 = var1.readObject())) {
  1176.             String var6 = ((String)var2).intern();
  1177.             if ("ownedL" == var6) {
  1178.                this.connectOwnedWindow((Window)var1.readObject());
  1179.             } else {
  1180.                var1.readObject();
  1181.             }
  1182.          }
  1183.  
  1184.          Object var7 = var1.readObject();
  1185.  
  1186.          for(this.icons = new ArrayList(); var7 != null; var7 = var1.readObject()) {
  1187.             if (var7 instanceof Image) {
  1188.                this.icons.add((Image)var7);
  1189.             }
  1190.          }
  1191.       } catch (OptionalDataException var4) {
  1192.       }
  1193.  
  1194.    }
  1195.  
  1196.    private void readObject(ObjectInputStream var1) throws ClassNotFoundException, IOException, HeadlessException {
  1197.       GraphicsEnvironment.checkHeadless();
  1198.       this.initDeserializedWindow();
  1199.       ObjectInputStream.GetField var2 = var1.readFields();
  1200.       this.syncLWRequests = var2.get("syncLWRequests", systemSyncLWRequests);
  1201.       this.state = var2.get("state", 0);
  1202.       this.focusableWindowState = var2.get("focusableWindowState", true);
  1203.       this.windowSerializedDataVersion = var2.get("windowSerializedDataVersion", 1);
  1204.       this.locationByPlatform = var2.get("locationByPlatform", locationByPlatformProp);
  1205.       this.focusMgr = (FocusManager)var2.get("focusMgr", (Object)null);
  1206.       Dialog.ModalExclusionType var3 = (Dialog.ModalExclusionType)var2.get("modalExclusionType", ModalExclusionType.NO_EXCLUDE);
  1207.       this.setModalExclusionType(var3);
  1208.       boolean var4 = var2.get("alwaysOnTop", false);
  1209.       if (var4) {
  1210.          this.setAlwaysOnTop(var4);
  1211.       }
  1212.  
  1213.       this.deserializeResources(var1);
  1214.    }
  1215.  
  1216.    public AccessibleContext getAccessibleContext() {
  1217.       if (this.accessibleContext == null) {
  1218.          this.accessibleContext = new AccessibleAWTWindow(this);
  1219.       }
  1220.  
  1221.       return this.accessibleContext;
  1222.    }
  1223.  
  1224.    public GraphicsConfiguration getGraphicsConfiguration() {
  1225.       synchronized(this.getTreeLock()) {
  1226.          if (this.graphicsConfig == null && !GraphicsEnvironment.isHeadless()) {
  1227.             this.graphicsConfig = GraphicsEnvironment.getLocalGraphicsEnvironment().getDefaultScreenDevice().getDefaultConfiguration();
  1228.          }
  1229.  
  1230.          return this.graphicsConfig;
  1231.       }
  1232.    }
  1233.  
  1234.    void resetGC() {
  1235.       if (!GraphicsEnvironment.isHeadless()) {
  1236.          this.setGCFromPeer();
  1237.          if (this.graphicsConfig == null) {
  1238.             this.graphicsConfig = GraphicsEnvironment.getLocalGraphicsEnvironment().getDefaultScreenDevice().getDefaultConfiguration();
  1239.          }
  1240.  
  1241.          DebugHelper var10000 = dbg;
  1242.       }
  1243.  
  1244.    }
  1245.  
  1246.    public void setLocationRelativeTo(Component var1) {
  1247.       Container var2 = null;
  1248.       if (var1 != null) {
  1249.          if (!(var1 instanceof Window) && !(var1 instanceof Applet)) {
  1250.             for(Container var3 = var1.getParent(); var3 != null; var3 = var3.getParent()) {
  1251.                if (var3 instanceof Window || var3 instanceof Applet) {
  1252.                   var2 = var3;
  1253.                   break;
  1254.                }
  1255.             }
  1256.          } else {
  1257.             var2 = (Container)var1;
  1258.          }
  1259.       }
  1260.  
  1261.       if ((var1 == null || var1.isShowing()) && var2 != null && var2.isShowing()) {
  1262.          Dimension var10 = var1.getSize();
  1263.          Point var11 = var1.getLocationOnScreen();
  1264.          Rectangle var5 = this.getBounds();
  1265.          int var6 = var11.x + (var10.width - var5.width >> 1);
  1266.          int var7 = var11.y + (var10.height - var5.height >> 1);
  1267.          Rectangle var8 = var2.getGraphicsConfiguration().getBounds();
  1268.          if (var7 + var5.height > var8.y + var8.height) {
  1269.             var7 = var8.y + var8.height - var5.height;
  1270.             if (var11.x - var8.x + var10.width / 2 < var8.width / 2) {
  1271.                var6 = var11.x + var10.width;
  1272.             } else {
  1273.                var6 = var11.x - var5.width;
  1274.             }
  1275.          }
  1276.  
  1277.          if (var6 + var5.width > var8.x + var8.width) {
  1278.             var6 = var8.x + var8.width - var5.width;
  1279.          }
  1280.  
  1281.          if (var6 < var8.x) {
  1282.             var6 = var8.x;
  1283.          }
  1284.  
  1285.          if (var7 < var8.y) {
  1286.             var7 = var8.y;
  1287.          }
  1288.  
  1289.          this.setLocation(var6, var7);
  1290.       } else {
  1291.          Dimension var9 = this.getSize();
  1292.          Point var4 = GraphicsEnvironment.getLocalGraphicsEnvironment().getCenterPoint();
  1293.          this.setLocation(var4.x - var9.width / 2, var4.y - var9.height / 2);
  1294.       }
  1295.  
  1296.    }
  1297.  
  1298.    void deliverMouseWheelToAncestor(MouseWheelEvent var1) {
  1299.    }
  1300.  
  1301.    boolean dispatchMouseWheelToAncestor(MouseWheelEvent var1) {
  1302.       return false;
  1303.    }
  1304.  
  1305.    public void createBufferStrategy(int var1) {
  1306.       super.createBufferStrategy(var1);
  1307.    }
  1308.  
  1309.    public void createBufferStrategy(int var1, BufferCapabilities var2) throws AWTException {
  1310.       super.createBufferStrategy(var1, var2);
  1311.    }
  1312.  
  1313.    public BufferStrategy getBufferStrategy() {
  1314.       return super.getBufferStrategy();
  1315.    }
  1316.  
  1317.    Component getTemporaryLostComponent() {
  1318.       return this.temporaryLostComponent;
  1319.    }
  1320.  
  1321.    Component setTemporaryLostComponent(Component var1) {
  1322.       Component var2 = this.temporaryLostComponent;
  1323.       if (var1 != null && (!var1.isDisplayable() || !var1.isVisible() || !var1.isEnabled() || !var1.isFocusable())) {
  1324.          this.temporaryLostComponent = null;
  1325.       } else {
  1326.          this.temporaryLostComponent = var1;
  1327.       }
  1328.  
  1329.       return var2;
  1330.    }
  1331.  
  1332.    boolean canContainFocusOwner(Component var1) {
  1333.       return super.canContainFocusOwner(var1) && this.isFocusableWindow();
  1334.    }
  1335.  
  1336.    public void setLocationByPlatform(boolean var1) {
  1337.       synchronized(this.getTreeLock()) {
  1338.          if (var1 && this.isShowing()) {
  1339.             throw new IllegalComponentStateException("The window is showing on screen.");
  1340.          } else {
  1341.             this.locationByPlatform = var1;
  1342.          }
  1343.       }
  1344.    }
  1345.  
  1346.    public boolean isLocationByPlatform() {
  1347.       synchronized(this.getTreeLock()) {
  1348.          return this.locationByPlatform;
  1349.       }
  1350.    }
  1351.  
  1352.    public void setBounds(int var1, int var2, int var3, int var4) {
  1353.       synchronized(this.getTreeLock()) {
  1354.          if (this.getBoundsOp() == 1 || this.getBoundsOp() == 3) {
  1355.             this.locationByPlatform = false;
  1356.          }
  1357.  
  1358.          super.setBounds(var1, var2, var3, var4);
  1359.       }
  1360.    }
  1361.  
  1362.    public void setBounds(Rectangle var1) {
  1363.       this.setBounds(var1.x, var1.y, var1.width, var1.height);
  1364.    }
  1365.  
  1366.    boolean isRecursivelyVisible() {
  1367.       return this.visible;
  1368.    }
  1369.  
  1370.    // $FF: synthetic method
  1371.    static WeakReference access$000(Window var0) {
  1372.       return var0.weakThis;
  1373.    }
  1374.  
  1375.    // $FF: synthetic method
  1376.    static void access$100(AppContext var0, WeakReference var1) {
  1377.       removeFromWindowList(var0, var1);
  1378.    }
  1379.  
  1380.    // $FF: synthetic method
  1381.    static Object access$200(Window var0) {
  1382.       return var0.inputContextLock;
  1383.    }
  1384.  
  1385.    static {
  1386.       Toolkit.loadLibraries();
  1387.       if (!GraphicsEnvironment.isHeadless()) {
  1388.          initIDs();
  1389.       }
  1390.  
  1391.       String var0 = (String)AccessController.doPrivileged(new GetPropertyAction("java.awt.syncLWRequests"));
  1392.       systemSyncLWRequests = var0 != null && var0.equals("true");
  1393.       var0 = (String)AccessController.doPrivileged(new GetPropertyAction("java.awt.Window.locationByPlatform"));
  1394.       locationByPlatformProp = var0 != null && var0.equals("true");
  1395.       beforeFirstWindowShown = new AtomicBoolean(true);
  1396.    }
  1397. }
  1398.