old-autovect-branch/libjava/gnu/awt/xlib/XFramePeer.java

   1 /* Copyright (C) 2000, 2002, 2003  Free Software Foundation
   2
   3    This file is part of libgcj.
   4
   5 This software is copyrighted work licensed under the terms of the
   6 Libgcj License.  Please consult the file "LIBGCJ_LICENSE" for
   7 details.  */
   8
   9 package gnu.awt.xlib;
  10
  11 import java.awt.*;
  12 import java.awt.peer.*;
  13 import java.awt.image.*;
  14 import gnu.gcj.xlib.WMSizeHints;
  15 import gnu.gcj.xlib.WindowAttributes;
  16 import gnu.gcj.xlib.Display;
  17 import gnu.gcj.xlib.Visual;
  18 import gnu.gcj.xlib.Screen;
  19 import gnu.gcj.xlib.XConfigureEvent;
  20
  21 /** FIXME: a lot of the code here should be moved down to XWindowPeer. */
  22
  23 public class XFramePeer extends XCanvasPeer implements FramePeer
  24 {
  25   private boolean processingConfigureNotify = false;
  26
  27   public XFramePeer(Frame frame)
  28   {
  29     super(frame);
  30
  31     // Set some defaults for a toplevel component:
  32     if (frame.getFont() == null)
  33       frame.setFont(new Font("helvetica", Font.PLAIN, 12));
  34
  35     if (frame.getBackground() == null)
  36       frame.setBackground(Color.lightGray);
  37
  38     if (frame.getForeground() == null)
  39       frame.setForeground(Color.black);
  40   }
  41
  42   /** Find parent window for toplevel window, ie. root window of
  43       selected screen. Bounds are not changed. */
  44   gnu.gcj.xlib.Window locateParentWindow(Rectangle bounds)
  45   {
  46     Screen screen = config.getVisual().getScreen();
  47     return screen.getRootWindow();
  48   }
  49
  50   void initWindowProperties()
  51   {
  52     Frame frame = (Frame) component;
  53     setResizable(frame.isResizable());
  54     String title = frame.getTitle();
  55     if (!title.equals("")) setTitle(title);
  56   }
  57
  58   long getBasicEventMask()
  59   {
  60     return super.getBasicEventMask() |
  61       WindowAttributes.MASK_STRUCTURE_NOTIFY;
  62   }
  63
  64   void configureNotify(XConfigureEvent configEvent)
  65   {
  66     processingConfigureNotify = true; // to avoid setBounds flood
  67     component.setBounds(configEvent.getBounds());
  68     processingConfigureNotify = false;
  69   }
  70
  71   /* Overridden to ignore request to set bounds if the request occurs
  72      while processing an XConfigureNotify event, in which case the X
  73      window already has the desired bounds.
  74      That's what java.awt.Window.setBoundsCallback is for, but it's
  75      package-private, and using our own flag eliminates the need to
  76      circumvent java security.
  77   */
  78   public void setBounds(int x, int y, int width, int height)
  79   {
  80     if (!processingConfigureNotify)
  81       super.setBounds(x, y, width, height);
  82   }
  83
  84   // Implementing ContainerPeer:
  85
  86   static final Insets INSETS_0_PROTOTYPE = new Insets(0, 0, 0, 0);
  87
  88   public Insets getInsets()
  89   {
  90     return (Insets) INSETS_0_PROTOTYPE.clone();
  91   }
  92
  93   public Insets insets ()
  94   {
  95     return getInsets ();
  96   }
  97
  98   public void beginValidate()
  99   {
 100   }
 101
 102   public void endValidate()
 103   {
 104     // reassert sizing hints
 105     Frame frame = (Frame) component;
 106     setResizable(frame.isResizable());
 107   }
 108
 109
 110   // Implementing WindowPeer:
 111
 112   public void toBack()
 113   {
 114     window.toBack ();
 115   }
 116
 117   public void toFront()
 118   {
 119     window.toFront ();
 120   }
 121
 122
 123   // Implementing FramePeer:
 124
 125   public void setIconImage(Image image)
 126   {
 127     throw new UnsupportedOperationException("not implemented yet");
 128   }
 129
 130   public void setMenuBar(MenuBar mb)
 131   {
 132     throw new UnsupportedOperationException("not implemented yet");
 133   }
 134
 135
 136   public void setTitle(String title)
 137   {
 138     synchronized (window.getDisplay())
 139       {
 140         // Oh, what a nice implementation :-)
 141         window.setProperty("WM_NAME", "STRING", title);
 142
 143         ensureFlush();
 144       }
 145   }
 146
 147   public void setResizable(boolean resizable)
 148   {
 149     Frame frame = (Frame) component;
 150
 151     WMSizeHints sizeHints = new WMSizeHints();
 152     if (resizable)
 153       {
 154         Dimension minSize = frame.getMinimumSize();
 155         sizeHints.setMinSize(minSize.width, minSize.height);
 156
 157         Dimension maxSize = frame.getMaximumSize();
 158
 159         if ((maxSize.width < Short.MAX_VALUE) ||
 160             (maxSize.height < Short.MAX_VALUE))
 161           {
 162             maxSize.width  = Math.min(maxSize.width,  Short.MAX_VALUE);
 163             maxSize.height = Math.min(maxSize.height, Short.MAX_VALUE);
 164             sizeHints.setMaxSize(maxSize.width, maxSize.height);
 165           }
 166       }
 167     else
 168       {
 169         // lock resizing to current bounds
 170         Dimension size = frame.getSize();
 171         sizeHints.setMinSize(size.width, size.height);
 172         sizeHints.setMaxSize(size.width, size.height);
 173       }
 174     sizeHints.applyNormalHints(window);
 175   }
 176
 177   public int getState ()
 178   {
 179     return 0;
 180   }
 181
 182   public void setState (int state)
 183   {
 184   }
 185
 186   public void setMaximizedBounds (Rectangle r)
 187   {
 188   }
 189
 190   public void beginLayout () { }
 191   public void endLayout () { }
 192   public boolean isPaintPending () { return false; }
 193
 194   /**
 195    * @since 1.5
 196    */
 197   public void setBoundsPrivate (int x, int y, int width, int height)
 198   {
 199   }
 200
 201   /**
 202    * @since 1.5
 203    */
 204   public void updateAlwaysOnTop()
 205   {
 206   }
 207
 208   /**
 209    * @since 1.5
 210    */
 211   public boolean requestWindowFocus ()
 212   {
 213     return false;
 214   }
 215 }