home *** CD-ROM | disk | FTP | other *** search
/ S283 Planetary Science &n…he Search for Life DVD 2 / DVD-ROM.iso / install / jre1_3 / lib / rt.jar / java / awt / Window.class (.txt) < prev    next >
Encoding:
Java Class File  |  1979-12-31  |  12.0 KB  |  600 lines
  1. package java.awt;
  2.  
  3. import java.awt.event.InputEvent;
  4. import java.awt.event.KeyEvent;
  5. import java.awt.event.WindowEvent;
  6. import java.awt.event.WindowListener;
  7. import java.awt.im.InputContext;
  8. import java.awt.peer.WindowPeer;
  9. import java.io.IOException;
  10. import java.io.ObjectInputStream;
  11. import java.io.ObjectOutputStream;
  12. import java.io.OptionalDataException;
  13. import java.lang.ref.WeakReference;
  14. import java.lang.reflect.InvocationTargetException;
  15. import java.security.AccessController;
  16. import java.util.EventListener;
  17. import java.util.Locale;
  18. import java.util.ResourceBundle;
  19. import java.util.Vector;
  20. import javax.accessibility.Accessible;
  21. import javax.accessibility.AccessibleContext;
  22. import sun.awt.DebugHelper;
  23. import sun.security.action.GetPropertyAction;
  24.  
  25. public class Window extends Container implements Accessible {
  26.    String warningString;
  27.    boolean nativeActive;
  28.    static final int OPENED = 1;
  29.    int state;
  30.    transient Vector ownedWindowList;
  31.    private transient WeakReference weakThis;
  32.    transient WindowListener windowListener;
  33.    private transient boolean active;
  34.    transient InputContext inputContext;
  35.    private transient Object inputContextLock;
  36.    private FocusManager focusMgr;
  37.    private static final String base = "win";
  38.    private static int nameCounter = 0;
  39.    private static final long serialVersionUID = 4497834738069338734L;
  40.    private static final DebugHelper dbg;
  41.    private int windowSerializedDataVersion;
  42.    // $FF: synthetic field
  43.    static Class class$java$awt$Container;
  44.    // $FF: synthetic field
  45.    static Class class$java$awt$event$WindowListener;
  46.  
  47.    private static native void initIDs();
  48.  
  49.    Window(GraphicsConfiguration var1) {
  50.       this.ownedWindowList = new Vector();
  51.       this.active = false;
  52.       this.inputContextLock = new Object();
  53.       this.windowSerializedDataVersion = 1;
  54.       this.setWarningString();
  55.       super.cursor = Cursor.getPredefinedCursor(0);
  56.       this.focusMgr = new FocusManager(this);
  57.       super.visible = false;
  58.       if (var1 == null) {
  59.          super.graphicsConfig = GraphicsEnvironment.getLocalGraphicsEnvironment().getDefaultScreenDevice().getDefaultConfiguration();
  60.       } else {
  61.          super.graphicsConfig = var1;
  62.       }
  63.  
  64.       if (super.graphicsConfig.getDevice().getType() != 0) {
  65.          throw new IllegalArgumentException("not a screen device");
  66.       } else {
  67.          ((Container)this).setLayout(new BorderLayout());
  68.          Rectangle var2 = super.graphicsConfig.getBounds();
  69.          int var3 = ((Component)this).getX() + var2.x;
  70.          int var4 = ((Component)this).getY() + var2.y;
  71.          ((Component)this).setLocation(var3, var4);
  72.       }
  73.    }
  74.  
  75.    Window() {
  76.       this((GraphicsConfiguration)null);
  77.    }
  78.  
  79.    public Window(Frame var1) {
  80.       this(var1 == null ? (GraphicsConfiguration)null : ((Window)var1).getGraphicsConfiguration());
  81.       this.ownedInit(var1);
  82.    }
  83.  
  84.    public Window(Window var1) {
  85.       this(var1 == null ? (GraphicsConfiguration)null : var1.getGraphicsConfiguration());
  86.       this.ownedInit(var1);
  87.    }
  88.  
  89.    public Window(Window var1, GraphicsConfiguration var2) {
  90.       this(var2);
  91.       this.ownedInit(var1);
  92.    }
  93.  
  94.    private void ownedInit(Window var1) {
  95.       if (var1 == null) {
  96.          throw new IllegalArgumentException("null owner window");
  97.       } else {
  98.          super.parent = var1;
  99.          this.weakThis = new WeakReference(this);
  100.          var1.addOwnedWindow(this.weakThis);
  101.       }
  102.    }
  103.  
  104.    protected void finalize() throws Throwable {
  105.       if (super.parent != null) {
  106.          ((Window)super.parent).removeOwnedWindow(this.weakThis);
  107.       }
  108.  
  109.       super.finalize();
  110.    }
  111.  
  112.    String constructComponentName() {
  113.       Class var1 = this.getClass();
  114.       synchronized(var1) {
  115.          String var2 = "win" + nameCounter++;
  116.          return var2;
  117.       }
  118.    }
  119.  
  120.    public void addNotify() {
  121.       Object var1 = ((Component)this).getTreeLock();
  122.       synchronized(var1) {
  123.          Container var2 = super.parent;
  124.          if (var2 != null && ((Component)var2).getPeer() == null) {
  125.             var2.addNotify();
  126.          }
  127.  
  128.          if (super.peer == null) {
  129.             super.peer = this.getToolkit().createWindow(this);
  130.          }
  131.  
  132.          super.addNotify();
  133.       }
  134.    }
  135.  
  136.    public void pack() {
  137.       Container var1 = super.parent;
  138.       if (var1 != null && ((Component)var1).getPeer() == null) {
  139.          var1.addNotify();
  140.       }
  141.  
  142.       if (super.peer == null) {
  143.          this.addNotify();
  144.       }
  145.  
  146.       ((Component)this).setSize(((Container)this).getPreferredSize());
  147.       super.isPacked = true;
  148.       ((Container)this).validate();
  149.    }
  150.  
  151.    public void show() {
  152.       if (super.peer == null) {
  153.          this.addNotify();
  154.       }
  155.  
  156.       ((Container)this).validate();
  157.       if (super.visible) {
  158.          this.toFront();
  159.       } else {
  160.          super.show();
  161.       }
  162.  
  163.       if ((this.state & 1) == 0) {
  164.          this.postWindowEvent(200);
  165.          this.state |= 1;
  166.       }
  167.  
  168.    }
  169.  
  170.    synchronized void postWindowEvent(int var1) {
  171.       WindowEvent var2 = new WindowEvent(this, var1);
  172.       Toolkit.getEventQueue().postEvent(var2);
  173.    }
  174.  
  175.    public void hide() {
  176.       Vector var1 = this.ownedWindowList;
  177.       synchronized(var1) {
  178.          for(int var2 = 0; var2 < this.ownedWindowList.size(); ++var2) {
  179.             Window var3 = (Window)((WeakReference)this.ownedWindowList.elementAt(var2)).get();
  180.             if (var3 != null) {
  181.                var3.hide();
  182.             }
  183.          }
  184.       }
  185.  
  186.       super.hide();
  187.    }
  188.  
  189.    public void dispose() {
  190.       1.DisposeAction var1 = new 1.DisposeAction(this);
  191.       if (EventQueue.isDispatchThread()) {
  192.          var1.run();
  193.       } else {
  194.          try {
  195.             EventQueue.invokeAndWait(var1);
  196.          } catch (InterruptedException var4) {
  197.             System.err.println("Disposal was interrupted:");
  198.             ((Throwable)var4).printStackTrace();
  199.          } catch (InvocationTargetException var5) {
  200.             System.err.println("Exception during disposal:");
  201.             var5.printStackTrace();
  202.          }
  203.       }
  204.  
  205.       this.postWindowEvent(202);
  206.    }
  207.  
  208.    void adjustListeningChildren(long var1, int var3) {
  209.       if (var3 != 0) {
  210.          if ((var1 & 32768L) != 0L) {
  211.             super.listeningChildren += var3;
  212.          }
  213.  
  214.          if ((var1 & 65536L) != 0L) {
  215.             super.listeningBoundsChildren += var3;
  216.          }
  217.  
  218.       }
  219.    }
  220.  
  221.    public void toFront() {
  222.       WindowPeer var1 = (WindowPeer)super.peer;
  223.       if (var1 != null) {
  224.          var1.toFront();
  225.       }
  226.  
  227.    }
  228.  
  229.    public void toBack() {
  230.       WindowPeer var1 = (WindowPeer)super.peer;
  231.       if (var1 != null) {
  232.          var1.toBack();
  233.       }
  234.  
  235.    }
  236.  
  237.    public Toolkit getToolkit() {
  238.       return Toolkit.getDefaultToolkit();
  239.    }
  240.  
  241.    public final String getWarningString() {
  242.       return this.warningString;
  243.    }
  244.  
  245.    private void setWarningString() {
  246.       this.warningString = null;
  247.       SecurityManager var1 = System.getSecurityManager();
  248.       if (var1 != null && !var1.checkTopLevelWindow(this)) {
  249.          this.warningString = (String)AccessController.doPrivileged(new GetPropertyAction("awt.appletWarning", "Java Applet Window"));
  250.       }
  251.  
  252.    }
  253.  
  254.    public Locale getLocale() {
  255.       return super.locale == null ? Locale.getDefault() : super.locale;
  256.    }
  257.  
  258.    public InputContext getInputContext() {
  259.       if (this.inputContext == null) {
  260.          Object var1 = this.inputContextLock;
  261.          synchronized(var1) {
  262.             if (this.inputContext == null) {
  263.                this.inputContext = InputContext.getInstance();
  264.             }
  265.          }
  266.       }
  267.  
  268.       return this.inputContext;
  269.    }
  270.  
  271.    public void setCursor(Cursor var1) {
  272.       if (var1 == null) {
  273.          var1 = Cursor.getPredefinedCursor(0);
  274.       }
  275.  
  276.       super.setCursor(var1);
  277.    }
  278.  
  279.    public Window getOwner() {
  280.       return (Window)super.parent;
  281.    }
  282.  
  283.    public Window[] getOwnedWindows() {
  284.       Vector var2 = this.ownedWindowList;
  285.       synchronized(var2) {
  286.          int var3 = this.ownedWindowList.size();
  287.          int var4 = 0;
  288.          Window[] var5 = new Window[var3];
  289.  
  290.          for(int var6 = 0; var6 < var3; ++var6) {
  291.             var5[var4] = (Window)((WeakReference)this.ownedWindowList.elementAt(var6)).get();
  292.             if (var5[var4] != null) {
  293.                ++var4;
  294.             }
  295.          }
  296.  
  297.          Window[] var1;
  298.          if (var3 != var4) {
  299.             var1 = new Window[var4];
  300.             System.arraycopy(var5, 0, var1, 0, var4);
  301.          } else {
  302.             var1 = var5;
  303.          }
  304.  
  305.          return var1;
  306.       }
  307.    }
  308.  
  309.    public synchronized void addWindowListener(WindowListener var1) {
  310.       if (var1 != null) {
  311.          this.windowListener = AWTEventMulticaster.add(this.windowListener, var1);
  312.          super.newEventsOnly = true;
  313.       }
  314.    }
  315.  
  316.    public synchronized void removeWindowListener(WindowListener var1) {
  317.       if (var1 != null) {
  318.          this.windowListener = AWTEventMulticaster.remove(this.windowListener, var1);
  319.       }
  320.    }
  321.  
  322.    public EventListener[] getListeners(Class var1) {
  323.       Object var2 = null;
  324.       if (var1 == (class$java$awt$event$WindowListener == null ? (class$java$awt$event$WindowListener = class$("java.awt.event.WindowListener")) : class$java$awt$event$WindowListener)) {
  325.          WindowListener var3 = this.windowListener;
  326.          return AWTEventMulticaster.getListeners(var3, var1);
  327.       } else {
  328.          return super.getListeners(var1);
  329.       }
  330.    }
  331.  
  332.    boolean eventEnabled(AWTEvent var1) {
  333.       switch (var1.id) {
  334.          case 200:
  335.          case 201:
  336.          case 202:
  337.          case 203:
  338.          case 204:
  339.          case 205:
  340.          case 206:
  341.             if ((super.eventMask & 64L) == 0L && this.windowListener == null) {
  342.                return false;
  343.             }
  344.  
  345.             return true;
  346.          default:
  347.             return super.eventEnabled(var1);
  348.       }
  349.    }
  350.  
  351.    boolean isActive() {
  352.       return this.active;
  353.    }
  354.  
  355.    protected void processEvent(AWTEvent var1) {
  356.       if (var1 instanceof WindowEvent) {
  357.          this.processWindowEvent((WindowEvent)var1);
  358.       } else {
  359.          super.processEvent(var1);
  360.       }
  361.    }
  362.  
  363.    protected void processWindowEvent(WindowEvent var1) {
  364.       if (this.windowListener != null) {
  365.          switch (((AWTEvent)var1).getID()) {
  366.             case 200:
  367.                this.windowListener.windowOpened(var1);
  368.                break;
  369.             case 201:
  370.                this.windowListener.windowClosing(var1);
  371.                break;
  372.             case 202:
  373.                this.windowListener.windowClosed(var1);
  374.                break;
  375.             case 203:
  376.                this.windowListener.windowIconified(var1);
  377.                break;
  378.             case 204:
  379.                this.windowListener.windowDeiconified(var1);
  380.                break;
  381.             case 205:
  382.                this.windowListener.windowActivated(var1);
  383.                break;
  384.             case 206:
  385.                this.windowListener.windowDeactivated(var1);
  386.          }
  387.       }
  388.  
  389.    }
  390.  
  391.    void preProcessKeyEvent(KeyEvent var1) {
  392.       if (var1.isActionKey() && var1.getKeyCode() == 112 && ((InputEvent)var1).isControlDown() && ((InputEvent)var1).isShiftDown() && ((AWTEvent)var1).getID() == 401) {
  393.          ((Container)this).list(System.out, 0);
  394.       }
  395.  
  396.    }
  397.  
  398.    void postProcessKeyEvent(KeyEvent var1) {
  399.       WindowPeer var2 = (WindowPeer)super.peer;
  400.       if (var2 != null) {
  401.          switch (var2.handleFocusTraversalEvent(var1)) {
  402.             case 0:
  403.             default:
  404.                break;
  405.             case 1:
  406.                ((InputEvent)var1).consume();
  407.                break;
  408.             case 2:
  409.                if (this.focusMgr.focusNext()) {
  410.                   ((InputEvent)var1).consume();
  411.                }
  412.                break;
  413.             case 3:
  414.                if (this.focusMgr.focusPrevious()) {
  415.                   ((InputEvent)var1).consume();
  416.                }
  417.          }
  418.  
  419.       }
  420.    }
  421.  
  422.    void setFocusOwner(Component var1) {
  423.       this.focusMgr.setFocusOwner(var1);
  424.    }
  425.  
  426.    void transferFocus(Component var1) {
  427.       this.nextFocus(var1);
  428.    }
  429.  
  430.    public Component getFocusOwner() {
  431.       return !this.active && !this.nativeActive ? null : this.focusMgr.getFocusOwner();
  432.    }
  433.  
  434.    void nextFocus(Component var1) {
  435.       this.focusMgr.focusNext(var1);
  436.    }
  437.  
  438.    void dispatchEventImpl(AWTEvent var1) {
  439.       switch (var1.getID()) {
  440.          case 101:
  441.             ((Container)this).invalidate();
  442.             ((Container)this).validate();
  443.             ((Component)this).repaint();
  444.             break;
  445.          case 205:
  446.             this.active = true;
  447.             break;
  448.          case 206:
  449.             this.active = false;
  450.             break;
  451.          case 1004:
  452.             this.setFocusOwner(this);
  453.       }
  454.  
  455.       super.dispatchEventImpl(var1);
  456.    }
  457.  
  458.    public boolean postEvent(Event var1) {
  459.       if (((Component)this).handleEvent(var1)) {
  460.          var1.consume();
  461.          return true;
  462.       } else {
  463.          return false;
  464.       }
  465.    }
  466.  
  467.    public boolean isShowing() {
  468.       return super.visible;
  469.    }
  470.  
  471.    public void applyResourceBundle(ResourceBundle var1) {
  472.       ((Container)this).applyOrientation(ComponentOrientation.getOrientation(var1));
  473.    }
  474.  
  475.    public void applyResourceBundle(String var1) {
  476.       this.applyResourceBundle(ResourceBundle.getBundle(var1));
  477.    }
  478.  
  479.    void addOwnedWindow(WeakReference var1) {
  480.       if (var1 != null) {
  481.          Vector var2 = this.ownedWindowList;
  482.          synchronized(var2) {
  483.             if (!this.ownedWindowList.contains(var1)) {
  484.                this.ownedWindowList.addElement(var1);
  485.             }
  486.          }
  487.       }
  488.  
  489.    }
  490.  
  491.    void removeOwnedWindow(WeakReference var1) {
  492.       if (var1 != null) {
  493.          this.ownedWindowList.removeElement(var1);
  494.       }
  495.  
  496.    }
  497.  
  498.    void connectOwnedWindow(Window var1) {
  499.       WeakReference var2 = new WeakReference(var1);
  500.       var1.weakThis = var2;
  501.       var1.parent = this;
  502.       this.addOwnedWindow(var2);
  503.    }
  504.  
  505.    private void writeObject(ObjectOutputStream var1) throws IOException {
  506.       var1.defaultWriteObject();
  507.       AWTEventMulticaster.save(var1, "windowL", this.windowListener);
  508.       var1.writeObject((Object)null);
  509.       Vector var2 = this.ownedWindowList;
  510.       synchronized(var2) {
  511.          for(int var3 = 0; var3 < this.ownedWindowList.size(); ++var3) {
  512.             Window var4 = (Window)((WeakReference)this.ownedWindowList.elementAt(var3)).get();
  513.             if (var4 != null) {
  514.                var1.writeObject("ownedL");
  515.                var1.writeObject(var4);
  516.             }
  517.          }
  518.       }
  519.  
  520.       var1.writeObject((Object)null);
  521.    }
  522.  
  523.    private void readObject(ObjectInputStream var1) throws ClassNotFoundException, IOException {
  524.       var1.defaultReadObject();
  525.       this.ownedWindowList = new Vector();
  526.  
  527.       Object var2;
  528.       while(null != (var2 = var1.readObject())) {
  529.          String var3 = ((String)var2).intern();
  530.          if ("windowL" == var3) {
  531.             this.addWindowListener((WindowListener)var1.readObject());
  532.          } else {
  533.             var1.readObject();
  534.          }
  535.       }
  536.  
  537.       try {
  538.          while(null != (var2 = var1.readObject())) {
  539.             String var6 = ((String)var2).intern();
  540.             if ("ownedL" == var6) {
  541.                this.connectOwnedWindow((Window)var1.readObject());
  542.             } else {
  543.                var1.readObject();
  544.             }
  545.          }
  546.       } catch (OptionalDataException var4) {
  547.       }
  548.  
  549.       this.setWarningString();
  550.       this.inputContextLock = new Object();
  551.    }
  552.  
  553.    public AccessibleContext getAccessibleContext() {
  554.       if (super.accessibleContext == null) {
  555.          super.accessibleContext = new AccessibleAWTWindow(this);
  556.       }
  557.  
  558.       return super.accessibleContext;
  559.    }
  560.  
  561.    public GraphicsConfiguration getGraphicsConfiguration() {
  562.       Object var1 = ((Component)this).getTreeLock();
  563.       synchronized(var1) {
  564.          if (super.graphicsConfig == null) {
  565.             super.graphicsConfig = GraphicsEnvironment.getLocalGraphicsEnvironment().getDefaultScreenDevice().getDefaultConfiguration();
  566.          }
  567.  
  568.          GraphicsConfiguration var2 = super.graphicsConfig;
  569.          return var2;
  570.       }
  571.    }
  572.  
  573.    void resetGC() {
  574.       Object var1 = ((Component)this).getTreeLock();
  575.       synchronized(var1) {
  576.          super.graphicsConfig = GraphicsEnvironment.getLocalGraphicsEnvironment().getDefaultScreenDevice().getDefaultConfiguration();
  577.       }
  578.    }
  579.  
  580.    // $FF: synthetic method
  581.    static Class class$(String var0) {
  582.       try {
  583.          return Class.forName(var0);
  584.       } catch (ClassNotFoundException var2) {
  585.          throw new NoClassDefFoundError(((Throwable)var2).getMessage());
  586.       }
  587.    }
  588.  
  589.    // $FF: synthetic method
  590.    static Object access$000(Window var0) {
  591.       return var0.inputContextLock;
  592.    }
  593.  
  594.    static {
  595.       dbg = DebugHelper.create(class$java$awt$Container == null ? (class$java$awt$Container = class$("java.awt.Container")) : class$java$awt$Container);
  596.       Toolkit.loadLibraries();
  597.       initIDs();
  598.    }
  599. }
  600.