home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 1995 November / PCWK1195.iso / inne / win95 / sieciowe / hotja32.lzh / hotjava / classsrc / awt / window.java < prev    next >
Text File  |  1995-08-11  |  12KB  |  459 lines
  1. /*
  2.  * @(#)Window.java    1.69 95/05/13 Sami Shaio
  3.  *
  4.  * Copyright (c) 1994 Sun Microsystems, Inc. All Rights Reserved.
  5.  *
  6.  * Permission to use, copy, modify, and distribute this software
  7.  * and its documentation for NON-COMMERCIAL purposes and without
  8.  * fee is hereby granted provided that this copyright notice
  9.  * appears in all copies. Please refer to the file "copyright.html"
  10.  * for further important copyright and licensing information.
  11.  *
  12.  * SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF
  13.  * THE SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
  14.  * TO THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
  15.  * PARTICULAR PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR
  16.  * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
  17.  * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES.
  18.  */
  19. package awt;
  20.  
  21. import java.io.*;
  22. import java.lang.*;
  23. import java.util.*;
  24.  
  25. /**
  26.  * Window is a general purpose canvas that can contain other windows.
  27.  *
  28.  * @version 1.69 13 May 1995
  29.  * @author Sami Shaio
  30.  */
  31. public class Window extends Container implements Scrollbarable {
  32.     Scrollbar    managed[] = new Scrollbar[2];
  33.     Vector    childWindows;
  34.     public String title;
  35.  
  36.     static Window    getWindow(Container c) {
  37.     while (! (c instanceof Window)) {
  38.         c = c.parent;
  39.     }
  40.     return (Window)c;
  41.     }
  42.  
  43.     /** Background color for this window */
  44.     public Color background;
  45.  
  46.     /** Foreground color for this window */
  47.     public Color foreground;
  48.  
  49.     /** Default graphics object for this window. */
  50.     public Graphics    graphics;
  51.  
  52.     /* Special WSGraphics object for some awt_WServer native methods. */
  53.     private WSGraphics    wsgraphics;
  54.  
  55.     Window() {
  56.     super(null,null);
  57.     }
  58.  
  59.     /**
  60.      * Create a window that is a child of another window.
  61.      */
  62.     public Window(Container w, String name,
  63.           Color bg, int wd, int ht) {
  64.     super(w, name);
  65.     background = bg;
  66.     foreground = Color.black;
  67.     if (w instanceof Frame) {
  68.         wServer = ((Frame)w).wServer;
  69.         wServer.windowCreateInFrame(this, (Frame)w,
  70.                     false, background, wd, ht);
  71.     } else {
  72.         Window win = Window.getWindow(w);
  73.         wServer = win.wServer;
  74.         wServer.windowCreate(this, win, false, background, wd, ht);
  75.     }
  76.     childWindows = new Vector(5, 10);
  77.     setLayout(FlowLayout.defaultLayout);
  78.     wsgraphics = new WSGraphics(this);
  79.     graphics = (Graphics) wsgraphics;
  80.     }
  81.  
  82.     /** Backward compatibility with alpha1. Takes a Window as a parent
  83.          instead of a container. */
  84.     public Window(Window w, String name,
  85.           Color bg, int wd, int ht) {
  86.     this((Container)w, name, bg, wd, ht);
  87.     }
  88.  
  89.    /** Backward compatibility with alpha1. Takes a Frame as a parent
  90.          instead of a container. */
  91.     public Window(Frame w, String name,
  92.           Color bg, int wd, int ht) {
  93.     this((Container)w, name, bg, wd, ht);
  94.     }
  95.  
  96.     /** Disposes of this window and all the components it contains. */
  97.     public void dispose() {
  98.     if (managed[Scrollbar.VERTICAL] != null) {
  99.         managed[Scrollbar.VERTICAL].dispose();
  100.     }
  101.     if (managed[Scrollbar.HORIZONTAL] != null) {
  102.         managed[Scrollbar.HORIZONTAL].dispose();
  103.     }
  104.     graphics.dispose();
  105.     if (graphics != wsgraphics)
  106.         wsgraphics.dispose();
  107.     wServer.windowDispose(this);
  108.     super.dispose();
  109.     }
  110.  
  111.     /** Shows this window. */
  112.     public void map() {
  113.     wServer.windowShow(this);
  114.     super.map();
  115.     }
  116.  
  117.     /** Hides this window. */
  118.     public void unMap() {
  119.     wServer.windowHide(this);
  120.     super.unMap();
  121.     }
  122.  
  123.     /** Override this method to repaint the window when needed. */
  124.     public void paint() {
  125.     }
  126.  
  127.     /** Override this method to repaint only a portion of the window. */
  128.     public void expose(int x, int y, int w, int h) {
  129.     paint();
  130.     }
  131.  
  132.     
  133.     public void gotFocus() {
  134.     }
  135.  
  136.     
  137.     public void lostFocus() {
  138.     }
  139.  
  140.  
  141.     /** Callback for exposing a region of a window. Unless, you don't
  142.      * want this callback to set the clipping region you should only
  143.      * override expose, not handleExpose.
  144.      * @see Window#expose
  145.      */
  146.     public synchronized void handleExpose(int x, int y, int w, int h) {
  147.     // Should this use the wsgraphics object?
  148.     graphics.clipRect(x, y, w, h);
  149.     expose(x, y, w, h);
  150.     graphics.clearClip();
  151.     }
  152.  
  153.     /** Callback to override to take some action when the window is
  154.      * resized.
  155.      */
  156.     public void handleResize() {
  157.     }
  158.  
  159.     /** Returns the menubar object useable for this window. */
  160.     public MenuBar getMenuBar() {
  161.     return getFrame().menuBar;
  162.     }
  163.  
  164.  
  165.     /** Returns the top-level window that contains this window. */
  166.     public Frame getFrame() {
  167.     Component c = this;
  168.  
  169.     for (;;) {
  170.         if (c == null) {
  171.         return null;
  172.         }
  173.         if (c instanceof Frame) {
  174.         return (Frame)c;
  175.         }
  176.         c = c.parent;
  177.     }
  178.     }
  179.  
  180.     public void handleMouseDown(int x, int y, int modifiers) {
  181.     mouseDown(new Event(Event.MOUSE_DOWN,
  182.                 this,
  183.                 x, y,
  184.                 false, 0, modifiers));
  185.     }
  186.     public void handleMouseUp(int x, int y, int modifiers) {
  187.     mouseUp(new Event(Event.MOUSE_UP,
  188.               this,
  189.               x, y,
  190.               false, 0, modifiers));
  191.     }
  192.     public void handleMouseDrag(int x, int y, int modifiers) {
  193.     mouseDrag(new Event(Event.MOUSE_DRAG,
  194.                 this,
  195.                 x, y,
  196.                 false, 0, modifiers));
  197.     }
  198.     public void handleMouseMoved(int x, int y, int modifiers) {
  199.     mouseMoved(new Event(Event.MOUSE_MOTION,
  200.                  this,
  201.                  x, y,
  202.                  false, 0, modifiers));
  203.     }
  204.     public void handleMouseEnter(int x, int y) {
  205.     mouseEnter(new Event(Event.MOUSE_ENTER,
  206.                  this,
  207.                  x, y,
  208.                  false, 0));
  209.     }
  210.     public void handleMouseLeave(int x, int y) {
  211.     mouseLeave(new Event(Event.MOUSE_LEAVE,
  212.                  this,
  213.                  x, y,
  214.                  false, 0));
  215.     }
  216.  
  217.     public void handleKeyPress(int k, int isAscii, int modifiers) {
  218.     handleKeyPress((char)k, (isAscii == 0) ? false : true, modifiers);
  219.     }
  220.  
  221.     public void handleKeyPress(char k, boolean isAscii, int modifiers) {
  222.     keyPressed(new Event(Event.KEY_PRESS,
  223.                  this,
  224.                  -1,-1,
  225.                  isAscii, k, modifiers));
  226.     }
  227.  
  228.     /** Override this method to take some action when the mouse is
  229.      * dragged with a button down over the window.
  230.      */
  231.     public void mouseDrag(Event e) {
  232.     parent.handleEvent(e);
  233.     }
  234.     /**
  235.      * Override this method to take some action when the mouse is
  236.      * moved over the window without any buttons pressed. This will only
  237.      * be activated if enablePointerMotionEvents has been called on this
  238.      * window.
  239.      */
  240.     public void mouseMoved(Event e) {
  241.     parent.handleEvent(e);
  242.     }
  243.  
  244.     /** Override this method to take some action when the mouse is
  245.      * pressed over this window.
  246.      */
  247.     public void mouseDown(Event e) {
  248.     parent.handleEvent(e);
  249.     }
  250.  
  251.     /** Override this method to take some action when the mouse button
  252.      * is released.
  253.      */
  254.     public void mouseUp(Event e) {
  255.     parent.handleEvent(e);
  256.     }
  257.  
  258.     /** Override this method to take some action when the mouse enters
  259.      * this window.
  260.      */
  261.     public void mouseEnter(Event e) {
  262.     parent.handleEvent(e);
  263.     }
  264.  
  265.     /**
  266.      * Override this method to take some action when the mouse leaves
  267.      * this window.
  268.      */
  269.     public void mouseLeave(Event e) {
  270.     parent.handleEvent(e);
  271.     }
  272.  
  273.     /** Override this method to take some action when a key is pressed
  274.      * in this window.
  275.      */
  276.     public void keyPressed(Event e) {
  277.     parent.handleEvent(e);
  278.     }
  279.  
  280.     /** Moves this window. */
  281.     public void move(int px, int py) {
  282.     x = px;
  283.     y = py;
  284.     wServer.windowMoveTo(this, x, y);
  285.     }
  286.  
  287.     /** Reshapes this window. */
  288.     public void reshape(int x, int y, int w, int h) {
  289.     super.reshape(x, y, w, h);
  290.     wServer.windowReshape(this, x, y, w, h);
  291.     layout();
  292.     }
  293.  
  294.     /** Enables notification of mouse motion without any buttons presed.*/
  295.     public void enablePointerMotionEvents() {
  296.     wServer.windowEnablePointerMotionEvents(this);
  297.     }
  298.     /** Disables notification of mouse motion without any buttons presed.*/
  299.     public void disablePointerMotionEvents() {
  300.     wServer.windowDisablePointerMotionEvents(this);
  301.     }
  302.  
  303.     /** Sets the thickness of the margin in this window. */
  304.     public void setMargin(int margin) {
  305.     wServer.windowSetMargin(this, margin);
  306.     }
  307.  
  308.     //
  309.     // Scrolling methods
  310.     //
  311.  
  312.     public void lineUp() {
  313.     }
  314.     public void lineDown() {
  315.     }
  316.     public void pageUp() {
  317.     }
  318.     public void pageDown() {
  319.     }
  320.     public void dragAbsolute(int value) {
  321.     }
  322.     public boolean scrollVertically(int dy) {
  323.     return false;
  324.     }
  325.     public boolean scrollHorizontally(int dx) {
  326.     return false;
  327.     }
  328.  
  329.     public synchronized void scrollWindow(int dx, int dy) {
  330.     wServer.windowScrollWindow(this, dx, dy);
  331.     }
  332.  
  333.     public void copyArea(int X, int Y, int W, int H, int dx, int dy) {
  334.     graphics.copyArea(X, Y, W, H, dx, dy);
  335.     }
  336.  
  337.     public void drawImage(Image I, int X, int Y) {
  338.         graphics.drawImage(I, X, Y);
  339.     }
  340.  
  341.     /**
  342.      * Creates an image of the specified width and height. The contents
  343.      * of the image are undefined and should be explicitly set before
  344.      * drawing the image.
  345.      */
  346.     public Image createImage(int w, int h) {
  347.     Image im = new Image(this);
  348.     wServer.offscreenImageCreate(im, w, h);
  349.  
  350.     return im;
  351.     }
  352.  
  353.     /**
  354.      * Creates an image from a DIBitmap.
  355.      */
  356.     public Image createImage(DIBitmap dib) {
  357.     if (dib == null)
  358.         return null;
  359.     Image    im = new Image(this);
  360.     wServer.imageCreate(im, dib);
  361.  
  362.     return im;
  363.     }
  364.  
  365.     public Image createImage(DIBitmap dib, int w, int h) {
  366.         if (dib == null)
  367.         return null;
  368.     Image im = new Image(this);
  369.     if (w <= 0)
  370.         w = dib.width;
  371.     if (h <= 0)
  372.         h = dib.height;
  373.     if (w == dib.width && h == dib.height)
  374.         wServer.imageCreate(im, dib);
  375.     else
  376.         wServer.scaledImageCreate(im, dib, 0, 0, dib.width, dib.height,
  377.                       w, h);
  378.  
  379.     return im;
  380.     }
  381.  
  382.     public DIBitmap retrieveDIBitmap(Image im) {
  383.     if (im == null)
  384.         return null;
  385.     DIBitmap dib = new DIBitmap(im.width, im.height);
  386.     wServer.bitmapRetrieve(im, dib);
  387.  
  388.     return dib;
  389.     }
  390.  
  391.     public void disposeImage(Image i) {
  392.     wServer.imageDispose(i);
  393.     }
  394.  
  395.     public Font getFont(String name, int style, int size) {
  396.     return wServer.fonts.getFont(name, style, size);
  397.     }
  398.  
  399.     public void setFont(Font f) {
  400.     graphics.setFont(f);
  401.     }
  402.  
  403.     public FontMetrics getFontMetrics(Font f) {
  404.     return wServer.getFontMetrics(this, f);
  405.     }
  406.  
  407.     public void setForeground(Color c) {
  408.     foreground = c;
  409.     graphics.setForeground(c);
  410.     }
  411.  
  412.     public void setBackground(Color c) {
  413.     background = c;
  414.     graphics.setBackground(c);
  415.     }
  416.  
  417.     public void clipRect(int X, int Y, int W, int H) {
  418.     graphics.clipRect(X, Y, W, H);
  419.     }
  420.  
  421.     public void clearClip() {
  422.     graphics.clearClip();
  423.     }
  424.     
  425.     public void clearRect(int X, int Y, int W, int H) {
  426.     graphics.clearRect(X, Y, W, H);
  427.     }
  428.     public void fillRect(int X, int Y, int W, int H) {
  429.     graphics.fillRect(X, Y, W, H);
  430.     }
  431.     public void drawRect(int X, int Y, int W, int H) {
  432.     graphics.drawRect(X, Y, W, H);
  433.     }
  434.     public void drawString(String str, int x, int y) {
  435.     graphics.drawString(str, x, y);
  436.     }
  437.     public void drawChars(char buf[], int offset, int length, int x, int y) {
  438.     graphics.drawChars(buf, offset, length, x, y);
  439.     }
  440.     public void drawBytes(byte buf[], int offset, int length, int x, int y) {
  441.     graphics.drawBytes(buf, offset, length, x, y);
  442.     }
  443.  
  444.     /** @see GenericGraphics#drawLine */
  445.     public void drawLine(int x1, int y1, int x2, int y2) {
  446.     graphics.drawLine(x1, y1, x2, y2);
  447.     }
  448.     
  449.     /** @see GenericGraphics#paint3DRect */
  450.     public void paint3DRect(int x, int y, int w, int h,
  451.                 boolean fill, boolean raised) {
  452.     graphics.paint3DRect(x, y, w, h, fill, raised);
  453.     }
  454.  
  455.     public void update() {
  456.     wServer.sync();
  457.     }
  458. }
  459.