libjava/javax/swing/plaf/basic/BasicSplitPaneDivider.java

   1 /* BasicSplitPaneDivider.java
   2    Copyright (C) 2003 Free Software Foundation, Inc.
   3
   4 This file is part of GNU Classpath.
   5
   6 GNU Classpath is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 GNU Classpath is distributed in the hope that it will be useful, but
  12 WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU Classpath; see the file COPYING.  If not, write to the
  18 Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  19 02111-1307 USA.
  20
  21 Linking this library statically or dynamically with other modules is
  22 making a combined work based on this library.  Thus, the terms and
  23 conditions of the GNU General Public License cover the whole
  24 combination.
  25
  26 As a special exception, the copyright holders of this library give you
  27 permission to link this library with independent modules to produce an
  28 executable, regardless of the license terms of these independent
  29 modules, and to copy and distribute the resulting executable under
  30 terms of your choice, provided that you also meet, for each linked
  31 independent module, the terms and conditions of the license of that
  32 module.  An independent module is a module which is not derived from
  33 or based on this library.  If you modify this library, you may extend
  34 this exception to your version of the library, but you are not
  35 obligated to do so.  If you do not wish to do so, delete this
  36 exception statement from your version. */
  37
  38
  39 package javax.swing.plaf.basic;
  40
  41 import java.awt.Component;
  42 import java.awt.Container;
  43 import java.awt.Dimension;
  44 import java.awt.Graphics;
  45 import java.awt.Insets;
  46 import java.awt.event.MouseAdapter;
  47 import java.awt.event.MouseEvent;
  48 import java.awt.event.MouseMotionListener;
  49 import java.beans.PropertyChangeEvent;
  50 import java.beans.PropertyChangeListener;
  51 import javax.swing.JButton;
  52 import javax.swing.JSplitPane;
  53 import javax.swing.border.Border;
  54
  55
  56 /**
  57  * The divider that separates the two parts of a JSplitPane in the
  58  * Basic look and feel.
  59  *
  60  * <p>Implementation status: We do not have a real implementation yet.
  61  * Currently, it is mostly a stub to allow compiling other parts of
  62  * the javax.swing.plaf.basic package, although some parts are already
  63  * functional.
  64  *
  65  * @author Sascha Brawer (brawer@dandelis.ch)
  66  */
  67 public class BasicSplitPaneDivider
  68   extends Container
  69   implements PropertyChangeListener
  70 {
  71   /**
  72    * Determined using the <code>serialver</code> tool
  73    * of Apple/Sun JDK 1.3.1 on MacOS X 10.1.5.
  74    */
  75   static final long serialVersionUID = 1463404307042803342L;
  76
  77
  78   /**
  79    * The width and height of the little buttons for showing and
  80    * hiding parts of a JSplitPane in a single mouse click.
  81    */
  82   protected static final int ONE_TOUCH_SIZE = 6;
  83
  84
  85   // FIXME: Javadoc.
  86   protected static final int ONE_TOUCH_OFFSET = 2;
  87
  88
  89   /**
  90    * An object that performs the tasks associated with an ongoing drag
  91    * operation, or <code>null</code> if the user is currently not
  92    * dragging the divider.
  93    */
  94   protected DragController dragger;
  95
  96
  97   /**
  98    * The delegate object that is responsible for the UI of the
  99    * <code>JSplitPane</code> that contains this divider.
 100    */
 101   protected BasicSplitPaneUI splitPaneUI;
 102
 103
 104   /**
 105    * The thickness of the divider in pixels.
 106    */
 107   protected int dividerSize;
 108
 109
 110   /**
 111    * A divider that is used for layout purposes.
 112    */
 113   protected Component hiddenDivider;
 114
 115
 116   /**
 117    * The JSplitPane containing this divider.
 118    */
 119   protected JSplitPane splitPane;
 120
 121
 122   /**
 123    * The listener for handling mouse events from both the divider
 124    * and the containing <code>JSplitPane</code>.
 125    *
 126    * <p>The reason for also handling MouseEvents from the containing
 127    * <code>JSplitPane</code> is that users should be able to start
 128    * a drag gesture from inside the JSplitPane, but slightly outisde
 129    * the divider.
 130    */
 131   protected MouseHandler mouseHandler = new MouseHandler();
 132
 133
 134   /**
 135    * The current orientation of the containing <code>JSplitPane</code>,
 136    * which is either {@link javax.swing.JSplitPane#HORIZONTAL_SPLIT}
 137    * or {@link javax.swing.JSplitPane#VERTICAL_SPLIT}.
 138    */
 139   protected int orientation;
 140
 141
 142   /**
 143    * The button for showing and hiding the left (or top) component
 144    * of the <code>JSplitPane</code>.
 145    */
 146   protected JButton leftButton;
 147
 148
 149   /**
 150    * The button for showing and hiding the right (or bottom) component
 151    * of the <code>JSplitPane</code>.
 152    */
 153   protected JButton rightButton;
 154
 155
 156   /**
 157    * The border of this divider. Typically, this will be an instance of
 158    * {@link javax.swing.plaf.basic.BasicBorders.SplitPaneDividerBorder}.
 159    *
 160    * @see #getBorder()
 161    * @see #setBorder(javax.swing.border.Border)
 162    */
 163   private Border border;
 164
 165
 166   /**
 167    * Constructs a new divider.
 168    *
 169    * @param ui the UI delegate of the enclosing
 170    *           <code>JSplitPane</code>.
 171    */
 172   public BasicSplitPaneDivider(BasicSplitPaneUI ui)
 173   {
 174     setBasicSplitPaneUI(ui);
 175   }
 176
 177
 178   /**
 179    * Sets the delegate object that is responsible for the UI of the
 180    * {@link javax.swing.JSplitPane} containing this divider.
 181    *
 182    * @param newUI the UI delegate, or <code>null</code> to release
 183    *        the connection to the current delegate.
 184    */
 185   public void setBasicSplitPaneUI(BasicSplitPaneUI newUI)
 186   {
 187     /* Remove the connection to the existing JSplitPane. */
 188     if (splitPane != null)
 189     {
 190       splitPane.removePropertyChangeListener(this);
 191       splitPane.removeMouseListener(mouseHandler);
 192       splitPane.removeMouseMotionListener(mouseHandler);
 193       splitPane = null;
 194     }
 195
 196     /* Establish the connection to the new JSplitPane. */
 197     splitPaneUI = newUI;
 198     if (splitPaneUI != null)
 199       splitPane = newUI.getSplitPane();
 200     if (splitPane != null)
 201     {
 202       splitPane.addPropertyChangeListener(this);
 203       splitPane.addMouseListener(mouseHandler);
 204       splitPane.addMouseMotionListener(mouseHandler);
 205       orientation = splitPane.getOrientation();
 206     }
 207   }
 208
 209
 210   /**
 211    * Returns the delegate object that is responsible for the UI of the
 212    * {@link javax.swing.JSplitPane} containing this divider.
 213    */
 214   public BasicSplitPaneUI getBasicSplitPaneUI()
 215   {
 216     return splitPaneUI;
 217   }
 218
 219
 220   /**
 221    * Sets the thickness of the divider.
 222    *
 223    * @param newSize the new width or height in pixels.
 224    */
 225   public void setDividerSize(int newSize)
 226   {
 227     this.dividerSize = newSize;
 228   }
 229
 230
 231   /**
 232    * Retrieves the thickness of the divider.
 233    */
 234   public int getDividerSize()
 235   {
 236     return dividerSize;
 237   }
 238
 239
 240   /**
 241    * Sets the border of this divider.
 242    *
 243    * @param border the new border. Typically, this will be an instance of
 244    * {@link javax.swing.plaf.basic.BasicBorders.SplitPaneDividerBorder}.
 245    *
 246    * @since 1.3
 247    */
 248   public void setBorder(Border border)
 249   {
 250     Border oldValue = this.border;
 251     this.border = border;
 252     firePropertyChange("border", oldValue, border);
 253   }
 254
 255
 256   /**
 257    * Retrieves the border of this divider.
 258    *
 259    * @return the current border, or <code>null</code> if no border
 260    *         has been set.
 261    *
 262    * @since 1.3
 263    */
 264   public Border getBorder()
 265   {
 266     return border;
 267   }
 268
 269
 270   /**
 271    * Retrieves the insets of the divider. If a border has been
 272    * installed on the divider, the result of calling its
 273    * <code>getBorderInsets</code> method is returned. Otherwise,
 274    * the inherited implementation will be invoked.
 275    *
 276    * @see javax.swing.border.Border#getBorderInsets(java.awt.Component)
 277    */
 278   public Insets getInsets()
 279   {
 280     if (border != null)
 281       return border.getBorderInsets(this);
 282     else
 283       return super.getInsets();
 284   }
 285
 286
 287   /**
 288    * Returns the preferred size of this divider, which is
 289    * <code>dividerSize</code> by <code>dividerSize</code>
 290    * pixels.
 291    */
 292   public Dimension getPreferredSize()
 293   {
 294     return new Dimension(dividerSize, dividerSize);
 295   }
 296
 297
 298   /**
 299    * Returns the minimal size of this divider, which is
 300    * <code>dividerSize</code> by <code>dividerSize</code>
 301    * pixels.
 302    */
 303   public Dimension getMinimumSize()
 304   {
 305     return getPreferredSize();
 306   }
 307
 308
 309   /**
 310    * Processes events from the <code>JSplitPane</code> that contains
 311    * this divider.
 312    */
 313   public void propertyChange(PropertyChangeEvent e)
 314   {
 315     // FIXME: Not yet implemented.
 316   }
 317
 318
 319   /**
 320    * Paints the divider by painting its border.
 321    */
 322   public void paint(Graphics g)
 323   {
 324     Dimension dividerSize;
 325
 326     super.paint(g);
 327     if (border != null)
 328     {
 329       dividerSize = getSize();
 330       border.paintBorder(this, g, 0, 0, dividerSize.width, dividerSize.height);
 331       //System.out.println(dividerSize);
 332       //g.setColor(java.awt.Color.white);
 333       //g.drawRect(0, 0, 5, 5);
 334     }
 335   }
 336
 337
 338   /**
 339    * Reacts to changes of the <code>oneToughExpandable</code>
 340    * property of the containing <code>JSplitPane</code>.
 341    */
 342   protected void oneTouchExpandableChanged()
 343   {
 344     // FIXME: Not yet implemented.
 345   }
 346
 347
 348   /**
 349    * Creates a button for showing and hiding the left (or top)
 350    * part of a <code>JSplitPane</code>.
 351    */
 352   protected JButton createLeftOneTouchButton()
 353   {
 354     return new OneTouchButton(/* left */ true);
 355   }
 356
 357
 358   /**
 359    * Creates a button for showing and hiding the right (or bottom)
 360    * part of a <code>JSplitPane</code>.
 361    */
 362   protected JButton createRightOneTouchButton()
 363   {
 364     return new OneTouchButton(/* left */ false);
 365   }
 366
 367
 368   /**
 369    * Prepares the divider for dragging by calling the
 370    * <code>startDragging</code> method of the UI delegate of the
 371    * enclosing <code>JSplitPane</code>.
 372    *
 373    * @see BasicSplitPaneUI#startDragging()
 374    */
 375   protected void prepareForDragging()
 376   {
 377     if (splitPaneUI != null)
 378       splitPaneUI.startDragging();
 379   }
 380
 381
 382   /**
 383    * Drags the divider to a given location by calling the
 384    * <code>dragDividerTo</code> method of the UI delegate of the
 385    * enclosing <code>JSplitPane</code>.
 386    *
 387    * @param location the new location of the divider.
 388    *
 389    * @see BasicSplitPaneUI#dragDividerTo(int location)
 390    */
 391   protected void dragDividerTo(int location)
 392   {
 393     if (splitPaneUI != null)
 394       splitPaneUI.dragDividerTo(location);
 395   }
 396
 397
 398   /**
 399    * Finishes a dragging gesture by calling the
 400    * <code>finishDraggingTo</code> method of the UI delegate of the
 401    * enclosing <code>JSplitPane</code>.
 402    *
 403    * @param location the new, final location of the divider.
 404    *
 405    * @see BasicSplitPaneUI#finishDraggingTo(int location)
 406    */
 407   protected void finishDraggingTo(int location)
 408   {
 409     if (splitPaneUI != null)
 410       splitPaneUI.finishDraggingTo(location);
 411   }
 412
 413
 414   /**
 415    * The listener for handling mouse events from both the divider
 416    * and the containing <code>JSplitPane</code>.
 417    *
 418    * <p>The reason for also handling MouseEvents from the containing
 419    * <code>JSplitPane</code> is that users should be able to start
 420    * a drag gesture from inside the JSplitPane, but slightly outisde
 421    * the divider.
 422    *
 423    * @author Sascha Brawer (brawer@dandelis.ch)
 424    */
 425   protected class MouseHandler
 426     extends MouseAdapter
 427     implements MouseMotionListener
 428   {
 429
 430     public void mousePressed(MouseEvent e)
 431     {
 432       // FIXME: Not yet implemented.
 433     }
 434
 435
 436     public void mouseReleased(MouseEvent e)
 437     {
 438       // FIXME: Not yet implemented.
 439     }
 440
 441
 442     /**
 443      * Repeatedly invoked when the user is dragging the mouse cursor
 444      * while having pressed a mouse button.
 445      */
 446     public void mouseDragged(MouseEvent e)
 447     {
 448       // FIXME: Not yet implemented.
 449     }
 450
 451
 452     /**
 453      * Repeatedly invoked when the user is dragging the mouse cursor
 454      * without having pressed a mouse button.
 455      */
 456     public void mouseMoved(MouseEvent e)
 457     {
 458       // FIXME: Not yet implemented.
 459     }
 460   }
 461
 462
 463   /**
 464    * A small button for showing and hiding parts of a
 465    * <code>JSplitPane</code> with a single mouse click.
 466    *
 467    * @author Sascha Brawer (brawer@dandelis.ch)
 468    */
 469   private static class OneTouchButton
 470     extends JButton
 471   {
 472     OneTouchButton(boolean left)
 473     {
 474       // FIXME: Set various properties of the button.
 475       // Make  sure it looks identical to the small
 476       // buttons of the Sun reference implementation.
 477       // The size should also be the same.
 478       if (left)
 479         setText("<");
 480       else
 481         setText(">");
 482
 483       Dimension butSize = new Dimension(ONE_TOUCH_SIZE, ONE_TOUCH_SIZE);
 484       setMinimumSize(butSize);
 485       setMaximumSize(butSize);
 486       setPreferredSize(butSize);
 487
 488       setBorderPainted(false);
 489     }
 490   }
 491
 492
 493   /**
 494    * Performs the tasks associated with an ongoing drag
 495    * operation.
 496    *
 497    * @author Sascha Brawer (brawer@dandelis.ch)
 498    */
 499   protected class DragController
 500   {
 501     // FIXME: Not yet implemented.
 502     protected DragController(MouseEvent e)
 503     {
 504     }
 505
 506     protected boolean isValid()
 507     {
 508       // FIXME: Not yet implemented.
 509       return true;
 510     }
 511
 512     protected int positionForMouseEvent(MouseEvent e)
 513     {
 514       return 0;
 515     }
 516
 517     protected int getNeededLocation(int x, int y)
 518     {
 519       return 0;
 520     }
 521
 522     protected void continueDrag(int newX, int newY)
 523     {
 524     }
 525
 526     protected void completeDrag(int x, int y)
 527     {
 528     }
 529
 530     protected void completeDrag(MouseEvent e)
 531     {
 532     }
 533   }
 534 }