
2004-05-25 David Jee <djee@redhat.com> * java/awt/Container.java (remove): Set component's parent to null only after we removed the component from its parent's layout manager. 2004-05-25 David Jee <djee@redhat.com> * gnu/java/awt/peer/gtk/GtkComponentPeer.java (GtkComponentPeer): Set bounds regardless of whether awtComponent is valid. * gnu/java/awt/peer/gtk/GtkListPeer.java (getSize): Change native method declaration. (minimumSize): Pass visible row count into getSize(). (preferredSize): Likewise. * jni/gtk-peer/gnu_java_awt_peer_gtk_GtkListPeer.c (Java_gnu_java_awt_peer_gtk_GtkListPeer_getSize): Use scroll window's natural size. Use visible row count to determine the final height value to return. 2004-05-21 Graydon Hoare <graydon@redhat.com> * gnu/java/awt/peer/gtk/GdkGraphics2D.java (setClip): Minor correction to order of operations. * javax/swing/JScrollPane.java: Extend sketchy implementation. * javax/swing/ScrollPaneLayout.java: Likewise. * javax/swing/JViewPort.java: Likewise. * javax/swing/ViewportLayout.java: Likewise. * javax/swing/JComponent.java: Rewrite. * javax/swing/RepaintManager.java: Likewise. * javax/swing/JLayeredPane.java: Change validate() to revalidate(). * javax/swing/JList.java (setSelectedIndices): (getSelectedIndices): (getSelectedValues): New functions. (getPreferredScrollableViewportSize): Return preferred size. (getScrollableUnitIncrement): (getScrollableBlockIncrement): Initial implementations. * javax/swing/JRootPane.java: Clean up slightly. (getUI): (setUI): (updateUI): (getUIClassID): (isValidateRoot): Add overrides from JComponent. * javax/swing/JScrollBar.java: Set default orientation to VERTICAL. * javax/swing/UIManager.java (getDimension): Return the dimension. * javax/swing/plaf/basic/BasicButtonUI.java: Set component opaque. * javax/swing/plaf/basic/BasicLabelUI.java: Likewise. * javax/swing/plaf/basic/BasicMenuItemUI.java: Likewise. * javax/swing/plaf/basic/BasicProgressBarUI.java: Likewise. * javax/swing/plaf/basic/BasicSeparatorUI.java: Likewise. * javax/swing/plaf/basic/BasicSliderUI.java: Likewise. * javax/swing/plaf/basic/BasicTabbedPaneUI.java: Likewise. * javax/swing/plaf/basic/BasicRootPaneUI.java: Likewise, and set background. * javax/swing/plaf/basic/BasicListUI.java: Likewise, and improve a bit. * javax/swing/plaf/basic/BasicScrollBarUI.java: Likewise, and adjust calculations. * javax/swing/plaf/basic/BasicViewportUI.java: Likewise, and improve a bit. * javax/swing/plaf/basic/BasicLookAndFeel.java (Button.margin): Shrink. * jni/gtk-peer/gnu_java_awt_peer_gtk_GdkGlyphVector.c: Hack to set horizontal always, workaround pango. * jni/gtk-peer/gtkcairopeer.h: Change to match pattern API. * jni/gtk-peer/gnu_java_awt_peer_gtk_GdkGraphics2D.c: Synchronize more often, check cairo status after ops, handle changes to cairo pattern API, check for disposal. 2004-05-21 Olga Rodimina <rodimina@redhat.com> * javax/swing/plaf/basic/BasicMenuItemUI.java: (BasicMenuItemUI): Create propertyChangeListener. (getPath):Implemented. (installListeners): Add propertyChangeListener to menuItem. (uninstallListeners): Remove propertyChangeListener from menuItem. (update): Implemented. * javax/swing/plaf/basic/BasicMenuUI.MouseInputHandler: (mouseEntered): Take insets of popup menu into account when calculating position of popup menu. 2004-05-18 Olga Rodimina <rodimina@redhat.com> * Makefile.am: Added new file. * Makefile.in: Regenerate. * javax/swing/JMenuBar.java: Started implementation. * javax/swing/JPopupMenu.java: (setVisible): Fixed location of lightweight/mediumweight popup menu. (show): Fixed location of PopupMenu. * javax/swing/plaf/basic/BasicMenuBarUI.java: New file. UI Delegate for JMenuBar. * javax/swing/plaf/basic/BasicMenuUI.MouseInputHandler: (mouseEntered): Corrected position of the submenu. 2004-05-18 Thomas Fitzsimmons <fitzsim@redhat.com> * jni/gtk-peer/gnu_java_awt_peer_gtk_GtkMenuPeer.c: Remove calls to _gtk_accel_group_attach. * jni/gtk-peer/gnu_java_awt_peer_gtk_GtkPopupMenuPeer.c: Likewise. * gnu/java/awt/peer/gtk/GtkButtonPeer.java: Give gtkSetFont package access. Don't override setFont. * gnu/java/awt/peer/gtk/GtkCheckboxPeer.java: Likewise. * gnu/java/awt/peer/gtk/GtkComponentPeer.java: Give gtkWidgetRequestFocus package access. * gnu/java/awt/peer/gtk/GtkLabelPeer.java: Don't override setFont. * gnu/java/awt/peer/gtk/GtkListPeer.java: Override gtkSetFont. Give gtkWidgetRequestFocus package access. * gnu/java/awt/peer/gtk/GtkTextAreaPeer.java: Give gtkWidgetRequestFocus package access. Don't override setFont. * gnu/java/awt/peer/gtk/GtkTextFieldPeer.java: Don't override setFont. * jni/gtk-peer/gnu_java_awt_peer_gtk_GtkButtonPeer.c (gtkSetLabel): Move call to gtk_bin_get_child into GDK critical region. (gtkSetFont): Likewise. * jni/gtk-peer/gnu_java_awt_peer_gtk_GtkListPeer.c (gtkSetFont): Implement. * jni/gtk-peer/gnu_java_awt_peer_gtk_GtkTextAreaPeer.c (gtkSetFont): Whitespace fix. * jni/gtk-peer/gnu_java_awt_peer_gtk_GtkComponentPeer.c (gtkWidgetSetUsize): Remove method. 2004-05-18 David Jee <djee@redhat.com> * java/awt/image/MemoryImageSource.java (newPixels(int,int,int,int,boolean)): Set only the specified rectangle of pixels. (newPixels(byte[],ColorModel,int,int)): Implement. (newPixels(int[],ColorModel,int,int)): Implement. 2004-05-18 Olga Rodimina <rodimina@redhat.com> * Makefile.am: Added new file. * Makefile.in: Regenerate. * javax/swing/JMenu.java: Started implementation. * javax/swing/JPopupMenu.java: (insert): If specified index is -1, then add component at the end. (isPopupTrigger): Reimplemented. (JPopupMenu.LightWeightPopup): setBounds of the lightWeightPopup before adding it to the layeredPane. (javax/swing/plaf/basic/BasicIconFactory.java): (getMenuArrowIcon): Implemented. * javax/swing/plaf/basic/BasicMenuItemUI.java: (getPreferredSize): Add size of the arrow icon if this menu item is instance of JMenu. (paintMenuItem): Paint arrow icon if this menu item is a submenu. * javax/swing/plaf/basic/BasicMenuUI.java: New File. UI Delegate for JMenu. 2004-05-17 Thomas Fitzsimmons <fitzsim@redhat.com> * gnu/java/awt/peer/gtk/GtkComponentPeer.java (postKeyEvent): Post KEY_TYPED events. * jni/gtk-peer/gnu_java_awt_peer_gtk_GtkEvents.c (generates_key_typed_event): Remove function. 2004-05-17 Olga Rodimina <rodimina@redhat.com> * javax/swing/JRootPane.java (JRootPane.RootLayout): Reimplemented to set bounds of contentPane and menuBar. (setJMenuBar): Add menu bar to the layered pane. (createLayeredPane): Set layout of layeredPane to null. * javax/swing/JLayeredPane.java: (addImpl): Calculate index of the component in the layeredPane according to the specified position within the layer. 2004-05-17 David Jee <djee@redhat.com> * gnu/java/awt/peer/gtk/GtkImagePainter.java (setPixels): Change color model to the default model after converting pixels. * java/awt/image/MemoryImageSource.java (newPixels): Set only the specified rectangle of pixels. 2004-05-13 Thomas Fitzsimmons <fitzsim@redhat.com> * libgcj.spec.in (lib): Add -l-java-awt -l-java-applet -l-java-beans -l-javax-accessibility -l-javax-swing. * java/awt/AWTEvent.java (toString): Print source's name rather than the source itself. 2004-05-12 Thomas Fitzsimmons <fitzsim@redhat.com> * gnu/java/awt/peer/gtk/GtkToolkit.java (loadSystemColors): Make native. * jni/gtk-peer/gnu_java_awt_peer_gtk_GtkToolkit.c (gdk_color_to_java_color): New function. * jni/gtk-peer/gtkpeer.h: Add SystemColor defines. 2004-05-12 David Jee <djee@redhat.com> * java/awt/image/RGBImageFilter.java: Initialize origmodel as null. (makeColor): Fix pixel component order. (filterRGBPixels): Fix pixel iteration. (setPixels): Add extra checks for index color model. Convert pixels to default color model if necessary. (convertColorModelToDefault): New override method for byte pixels. (convertColorModelToDefault): For int pixels, fix pixel iteration. (makeColorbyDefaultCM): New override method for byte pixels. (makeColorbyDefaultCM): For int pixel, add color model as argument. (makeColor): Fix pixel component order. 2004-05-11 Kim Ho <kho@redhat.com> * javax/swing/Box.java: Comment out more parts of Box.Filler. 2004-05-11 Kim Ho <kho@redhat.com> * javax/swing/Box.java: Remove reference to AccessibleAWTComponent so it compiles again. 2004-05-10 Thomas Fitzsimmons <fitzsim@redhat.com> * gnu/java/awt/peer/gtk/GtkListPeer.java, jni/gtk-peer/gnu_java_awt_peer_gtk_GtkListPeer.c: Update implementation of list peer to use GtkTreeView instead of deprecated GtkCList. 2004-05-07 Thomas Fitzsimmons <fitzsim@redhat.com> * gnu/java/awt/peer/gtk/GtkComponentPeer.java (gtkWidgetDispatchKeyEvent): Remove keyChar parameter. (handleEvent): Remove keyChar argument to gtkWidgetDispatchKeyEvent calls. * jni/gtk-peer/gnu_java_awt_peer_gtk_GtkComponentPeer.c: Fix compiler warnings. * jni/gtk-peer/gnu_java_awt_peer_gtk_GtkEvents.c: Likewise. * jni/gtk-peer/gnu_java_awt_peer_gtk_GtkMenuPeer.c: Likewise. * jni/gtk-peer/gnu_java_awt_peer_gtk_GtkTextComponentPeer.c: Likewise. 2004-05-06 Thomas Fitzsimmons <fitzsim@redhat.com> * gnu/java/awt/peer/gtk/GtkComponentPeer.java (gtkWidgetRequestFocus): Mark protected. (GtkComponentPeer): Only set the peer's bounds if its component is valid. * java/awt/Component.java (static): Set the default keyboard focus manager. (requestFocus(), requestFocus(boolean), requestFocusInWindow(), requestFocusInWindow(temporary)): Don't request focus if the component is not showing. Get tree lock before traversing component hierarchy. * java/awt/DefaultKeyboardFocusManager.java (dispatchEvent): Only set the global focus owner if it is not a Window. (processKeyEvent): Consume keystrokes associated with the focus traversal keystroke. (focusPreviousComponent, focusNextComponent, upFocusCycle, downFocusCycle): Call requestFocusInWindow instead of requestFocus. * java/awt/EventDispatchThread.java (run): Move setting of default keyboard focus manager to Component.java. * jni/gtk-peer/gnu_java_awt_peer_gtk_GtkComponentPeer.c (awt_keycode_to_keysym): New function. (gtkWidgetDispatchKeyEvent): Finish implementation. * jni/gtk-peer/gnu_java_awt_peer_gtk_GtkEvents.c (pre_event_handler): Add FIXME comment. * gnu/java/awt/peer/gtk/GtkTextAreaPeer.java, jni/gtk-peer/gnu_java_awt_peer_gtk_GtkTextAreaPeer.c (gtkWidgetRequestFocus): New method. * java/awt/TextArea.java (TextArea): Set focus traversal keys to disable Tab and Shift-Tab keystrokes. (addNotify, appendText, insertText, replaceText): Simplify peer retrieval code. * jni/gtk-peer/gnu_java_awt_peer_gtk_GtkTextComponentPeer.c (connectSignals): Remove connections to "commit" signals. Remove C++-style comments. * gnu/java/awt/peer/gtk/GtkButtonPeer.java, jni/gtk-peer/gnu_java_awt_peer_gtk_GtkButtonPeer.c (handleEvent): Activate GTK button when the space bar key is pressed. (gtkActivate): New method. 2004-05-06 David Jee <djee@redhat.com> * java/awt/image/CropImageFilter.java (setPixels): Implement for byte array pixels. * java/awt/image/ReplicateScaleFilter.java (setPixels): Implement for byte array pixels. (replicatePixels): Overload for byte array pixels. 2004-05-06 Kim Ho <kho@redhat.com> * javax/swing/Box.java: (getAccessibleContext): Return an instance of the correct class. 2004-05-05 David Jee <djee@redhat.com> * gnu/java/awt/peer/gtk/GdkGraphics.java (drawImage): When component is null, use SystemColor.window as the default bgcolor. * gnu/java/awt/peer/gtk/GtkImage.java (setPixels): We can avoid iterating through the pixel rows only when height is 1. * java/awt/Image.java (getScaledInstance): Partially implement. * java/awt/image/CropImageFilter.java (setProperties): Fix "filter" property. (setPixels): Implement. * java/awt/image/ReplicateScaleFilter.java (setDimensions): Use scaled dimensions. (setPixels): Implement. (replicatePixels): New method. 2004-05-05 David Jee <djee@redhat.com> * gnu/java/awt/peer/gtk/GtkImagePainter.java (convertPixels): If either pixels or model is null, return null. * jni/gtk-peer/gnu_java_awt_peer_gtk_GtkImagePainter.c (Java_gnu_java_awt_peer_gtk_GtkImagePainter_drawPixels): If jpixels is null, do nothing and return. 2004-05-03 Kim Ho <kho@redhat.com> * gnu/java/awt/peer/gtk/GtkDialogPeer.java: (getGraphics): Like GtkFramePeer, the Graphics object needs to be translate to account for window decorations. (postMouseEvent): New method. Account for translation. (postExposeEvent): ditto. * javax/swing/Box.java: Stubbed. * javax/swing/JDialog.java: Ran through jalopy to fix indentation. (JDialog): Call SwingUtilities' getOwnerFrame for null owners. (setLayout): Check isRootPaneCheckingEnabled * javax/swing/JOptionPane.java: Re-implemented. * javax/swing/SwingUtilities.java: (getOwnerFrame): Static method to grab a default owner frame for Dialogs that don't specify owners. * javax/swing/event/SwingPropertyChangeSupport.java: (firePropertyChange): Fix early exit condition. * javax/swing/plaf/basic/BasicLabelUI.java: (paint): Avoid painting text if it is null or empty. * javax/swing/plaf/basic/BasicOptionPaneUI.java: Implement. 2004-05-03 Olga Rodimina <rodimina@redhat.com> * Makefile.am: Added new file. * Makefile.in: Regenerate. * javax/swing/JPopupMenu.java: Started implementation. * javax/swing/JWindow.java (JWindow): call super() if parent for window is not specified. * javax/swing/plaf/basic/BasicPopupMenuUI.java: New File. UI Delegate for JPopupMenu. 2004-04-30 Olga Rodimina <rodimina@redhat.com> * javax/swing/JApplet.java: Indicated that JApplet implements RootPaneContainer and made method of this interface public. * javax/swing/JFrame.java: Ditto. * javax/swing/JWindow.java: Ditto. 2004-04-29 Thomas Fitzsimmons <fitzsim@redhat.com> * jni/gtk-peer/gnu_java_awt_peer_gtk_GtkWindowPeer.c (nativeSetBounds): Call gdk_window_move in addition to gtk_window_move. * java/applet/Applet.java (preferredSize): Call parent's preferredSize if the applet stub is null. (minimumSize): Likewise for parent's minimumSize. 2004-04-27 Olga Rodimina <rodimina@redhat.com> * javax/swing/JMenuItem.java (createActionPropertyChangeListener): Implemented. (processMouseEvent): Ditto. (fireMenuDragMouseEntered): Ditto. (fireMenuDragMouseExited): Ditto. (fireMenuDragMouseDragged): Ditto. (fireMenuDragMouseReleased): Ditto. (menuSelectionChanged): Ditto. (getSubElements): Ditto. (getComponent): Ditto. (addMenuDragMouseListener): Ditto. (removeMenuDragMouseListener):Ditto. (addMenuKeyListener): Ditto. (removeMenuKeyListener): Ditto. * javax/swing/plaf/basic/BasicMenuItemUI.java (doClick): Imlemented. * javax/swing/plaf/basic/BasicMenuItemUI.MouseInputHandler: Don't handle mouse events here. Pass them to MenuSelectionManager. 2004-04-26 Olga Rodimina <rodimina@redhat.com> Used correct version of jalopy configuration file to fix style in the files below. 2004-04-26 Olga Rodimina <rodimina@redhat.com> * javax/swing/JCheckBoxMenuItem.java: Fixed style and removed unnecessary comments. * javax/swing/JMenuItem.java: Ditto. * javax/swing/JRadioButtonMenuItem.java: Ditto. * javax/swing/plaf/basic/BasicCheckBoxMenuItemUI.java: Ditto. * javax/swing/plaf/basic/BasicMenuItemUI.java: Ditto. * javax/swing/plaf/basic/BasicRadioButtonMenuItemUI.java: Ditto. 2004-04-23 Thomas Fitzsimmons <fitzsim@redhat.com> * gnu_java_awt_peer_gtk_GtkWindowPeer.c: Change FIXME comment to C-style. * gnu_java_awt_peer_gtk_GtkWindowPeer.c: Add FIXME comment. * java/awt/ContainerOrderFocusTraversalPolicy.java (getComponentAfter): Start from current component and work up the component hierarchy until an acceptable component is found. Synchronize on tree lock. (getComponentBefore): Likewise. 2004-04-22 Thomas Fitzsimmons <fitzsim@redhat.com> * gnu/java/awt/peer/gtk/GtkComponentPeer.java: Remove focus-related debugging messages. * java/awt/DefaultKeyboardFocusManager.java: Likewise. * java/awt/EventDispatchThread.java: Likewise. * java/awt/KeyboardFocusManager.java: Likewise. * java/awt/Window.java: Likewise. * jni/gtk-peer/gnu_java_awt_peer_gtk_GtkComponentPeer.c: Likewise. * jni/gtk-peer/gnu_java_awt_peer_gtk_GtkEvents.c: Likewise. * jni/gtk-peer/gnu_java_awt_peer_gtk_GtkComponentPeer.c: Change new C++-style comments to C-style comments. * jni/gtk-peer/gnu_java_awt_peer_gtk_GtkEvents.c: Likewise. * gnu/java/awt/peer/gtk/GtkComponentPeer.java, jni/gtk-peer/gnu_java_awt_peer_gtk_GtkComponentPeer.c (handleEvent): Dispatch key press and key release events to backing widget. (requestFocus): Post a FOCUS_GAINED event to the event queue. (gtkWidgetRequestFocus): New method. (gtkWidgetDispatchKeyEvent): Likewise. * java/awt/Component.java (requestFocus, requestFocus(boolean), requestFocusInWindow, requestFocusInWindow(boolean), getFocusCycleRootAncestor, nextFocus, transferFocus, transferFocusBackward, transferFocusUpCycle, hasFocus, isFocusOwner): Implement and document focus-handling methods. (setFocusTraversalKeys): Inherit focus traversal keys when keystrokes argument is null. Fix focus-handling documentation throughout class. * java/awt/Container.java (setFocusTraversalKeys, getFocusTraversalKeys, areFocusTraversalKeysSet, isFocusCycleRoot, setFocusTraversalPolicy, getFocusTraversalPolicy, isFocusTraversalPolicySet, setFocusCycleRoot, isFocusCycleRoot, transferFocusDownCycle): Implement and document focus-handling methods. (transferFocusBackward): Remove method. (readObject, writeObject): Implement and document serialization methods. * java/awt/ContainerOrderFocusTraversalPolicy.java: Implement and document. * java/awt/DefaultFocusTraversalPolicy.java: Implement and document. * java/awt/DefaultKeyboardFocusManager.java: Implement and partially document. * java/awt/EventDispatchThread.java (run): Set default keyboard focus manager. Attempt to dispatch each event to the keyboard focus manager before normal dispatch. * java/awt/KeyboardFocusManager.java: Implement and partially document. * java/awt/Window.java (Window): Set focusCycleRoot to true. (show): Focus initial component when window is shown for the first time. * jni/gtk-peer/gnu_java_awt_peer_gtk_GtkEvents.c (pre_event_handler): Replace complex key press and key release logic with simple callbacks into GtkComponentPeer. * jni/gtk-peer/gtkpeer.h: Fix FOCUS_GAINED/FOCUS_LOST reversal. 2004-04-21 Olga Rodimina <rodimina@redhat.com> * javax/swing/MenuSelectionManager.java (componentForPoint): Added new method. (defaultManager): New Method. Implemented. (getSelectedPath): Ditto. (isComponentPartOfCurrentMenu): Ditto. (processKeyEvent): Added new method. (processMouseEvent): New Method. Implemented. (setSelectedPath): Ditto. (getPath): Ditto. 2004-04-19 Kim Ho <kho@redhat.com> * java/awt/Container.java: (remove): Set the component's parent to null. (getComponentAt): Implement. * javax/swing/JComponent.java: (JComponent): Initialize defaultLocale (getDefaultLocale): Implement. (setDefaultLocale): ditto. * javax/swing/JSlider.java: (JSlider): Fix calculation of value. * javax/swing/JSplitPane.java: Implement. * javax/swing/plaf/basic/BasicLookAndFeel.java: Change SplitPane's default divider size. * javax/swing/plaf/basic/BasicScrollBarUI.java: (paint): Remove unused code. * javax/swing/plaf/basic/BasicSplitPaneDivider.java: Added comments and ran through jalopy. (setBasicSplitPaneUI): Get reference to hidden divider and set up one touch buttons if necessary. (setBorder): Fire propertyChangeEvent only if borders are different. (getPreferredSize): Defer to layout manager. (propertyChange): Implement. (oneTouchExpandableChanged): ditto. (createLeftOneTouchButton): Use BasicArrowButton. (createRightOneTouchButton): ditto. (moveDividerTo): New method. Moves the divider to a set location based on the last divider location. (BasicSplitPaneDivider::MouseHandler): Implement. (BasicSplitPaneDivider::OneTouchButton): Removed. (BasicSplitPaneDivider::DragController): Implement. (BasicSplitPaneDivider::VerticalDragController): ditto. (BasicSplitPaneDivider::DividerLayout): ditto. * javax/swing/plaf/basic/BasicSplitPaneUI.java: Reimplement. * javax/swing/plaf/basic/BasicTabbedPaneUI.java: (calculateLayoutInfo): Don't show component if it's null. (paintTab): Fix title paint logic. From-SVN: r82314
1520 lines
41 KiB
Java
1520 lines
41 KiB
Java
/* BasicSplitPaneUI.java
|
|
Copyright (C) 2003, 2004 Free Software Foundation, Inc.
|
|
|
|
This file is part of GNU Classpath.
|
|
|
|
GNU Classpath is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 2, or (at your option)
|
|
any later version.
|
|
|
|
GNU Classpath is distributed in the hope that it will be useful, but
|
|
WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with GNU Classpath; see the file COPYING. If not, write to the
|
|
Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
|
|
02111-1307 USA.
|
|
|
|
Linking this library statically or dynamically with other modules is
|
|
making a combined work based on this library. Thus, the terms and
|
|
conditions of the GNU General Public License cover the whole
|
|
combination.
|
|
|
|
As a special exception, the copyright holders of this library give you
|
|
permission to link this library with independent modules to produce an
|
|
executable, regardless of the license terms of these independent
|
|
modules, and to copy and distribute the resulting executable under
|
|
terms of your choice, provided that you also meet, for each linked
|
|
independent module, the terms and conditions of the license of that
|
|
module. An independent module is a module which is not derived from
|
|
or based on this library. If you modify this library, you may extend
|
|
this exception to your version of the library, but you are not
|
|
obligated to do so. If you do not wish to do so, delete this
|
|
exception statement from your version. */
|
|
|
|
package javax.swing.plaf.basic;
|
|
|
|
import java.awt.Canvas;
|
|
import java.awt.Color;
|
|
import java.awt.Component;
|
|
import java.awt.Container;
|
|
import java.awt.Dimension;
|
|
import java.awt.Graphics;
|
|
import java.awt.Insets;
|
|
import java.awt.LayoutManager2;
|
|
import java.awt.Point;
|
|
import java.awt.event.ActionEvent;
|
|
import java.awt.event.ActionListener;
|
|
import java.awt.event.FocusAdapter;
|
|
import java.awt.event.FocusEvent;
|
|
import java.awt.event.FocusListener;
|
|
import java.awt.event.MouseEvent;
|
|
import java.beans.PropertyChangeEvent;
|
|
import java.beans.PropertyChangeListener;
|
|
import javax.swing.JButton;
|
|
import javax.swing.JComponent;
|
|
import javax.swing.JSplitPane;
|
|
import javax.swing.KeyStroke;
|
|
import javax.swing.UIDefaults;
|
|
import javax.swing.UIManager;
|
|
import javax.swing.plaf.ComponentUI;
|
|
import javax.swing.plaf.SplitPaneUI;
|
|
|
|
|
|
/**
|
|
* This is the Basic Look and Feel implementation of the SplitPaneUI class.
|
|
*/
|
|
public class BasicSplitPaneUI extends SplitPaneUI
|
|
{
|
|
/**
|
|
* This Layout Manager controls the position and size of the components when
|
|
* the JSplitPane's orientation is HORIZONTAL_SPLIT.
|
|
*/
|
|
protected class BasicHorizontalLayoutManager implements LayoutManager2
|
|
{
|
|
// 3 components at a time.
|
|
// LEFT/TOP = 0
|
|
// RIGHT/BOTTOM = 1
|
|
// DIVIDER = 2
|
|
|
|
/**
|
|
* This array contains the components in the JSplitPane. The left/top
|
|
* component is at index 0, the right/bottom is at 1, and the divider is
|
|
* at 2.
|
|
*/
|
|
protected Component[] components = new Component[3];
|
|
|
|
// These are the _current_ widths of the associated component.
|
|
|
|
/**
|
|
* This array contains the current width (for HORIZONTAL_SPLIT) or height
|
|
* (for VERTICAL_SPLIT) of the components. The indices are the same as
|
|
* for components.
|
|
*/
|
|
protected int[] sizes = new int[3];
|
|
|
|
/**
|
|
* This method adds the component given to the JSplitPane. The position of
|
|
* the component is given by the constraints object.
|
|
*
|
|
* @param comp The Component to add.
|
|
* @param constraints The constraints that bind the object.
|
|
*/
|
|
public void addLayoutComponent(Component comp, Object constraints)
|
|
{
|
|
addLayoutComponent((String) constraints, comp);
|
|
}
|
|
|
|
/**
|
|
* This method is called to add a Component to the JSplitPane. The
|
|
* placement string determines where the Component will be placed. The
|
|
* string should be one of LEFT, RIGHT, TOP, BOTTOM or null (signals that
|
|
* the component is the divider).
|
|
*
|
|
* @param place The placement of the Component.
|
|
* @param component The Component to add.
|
|
*
|
|
* @throws IllegalArgumentException DOCUMENT ME!
|
|
*/
|
|
public void addLayoutComponent(String place, Component component)
|
|
{
|
|
int i = 0;
|
|
if (place == null)
|
|
i = 2;
|
|
else if (place.equals(JSplitPane.TOP) || place.equals(JSplitPane.LEFT))
|
|
i = 0;
|
|
else if (place.equals(JSplitPane.BOTTOM)
|
|
|| place.equals(JSplitPane.RIGHT))
|
|
i = 1;
|
|
else
|
|
throw new IllegalArgumentException("Illegal placement in JSplitPane");
|
|
components[i] = component;
|
|
resetSizeAt(i);
|
|
layoutContainer(splitPane);
|
|
splitPane.repaint();
|
|
}
|
|
|
|
/**
|
|
* This method returns the width of the JSplitPane minus the insets.
|
|
*
|
|
* @param containerSize The Dimensions of the JSplitPane.
|
|
* @param insets The Insets of the JSplitPane.
|
|
*
|
|
* @return The width of the JSplitPane minus the insets.
|
|
*/
|
|
protected int getAvailableSize(Dimension containerSize, Insets insets)
|
|
{
|
|
return containerSize.width - insets.left - insets.right;
|
|
}
|
|
|
|
/**
|
|
* This method returns the given insets left value. If the given inset is
|
|
* null, then 0 is returned.
|
|
*
|
|
* @param insets The Insets to use with the JSplitPane.
|
|
*
|
|
* @return The inset's left value.
|
|
*/
|
|
protected int getInitialLocation(Insets insets)
|
|
{
|
|
if (insets != null)
|
|
return insets.left;
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* This specifies how a component is aligned with respect to other
|
|
* components in the x fdirection.
|
|
*
|
|
* @param target The container.
|
|
*
|
|
* @return The component's alignment.
|
|
*/
|
|
public float getLayoutAlignmentX(Container target)
|
|
{
|
|
return target.getAlignmentX();
|
|
}
|
|
|
|
/**
|
|
* This specifies how a component is aligned with respect to other
|
|
* components in the y direction.
|
|
*
|
|
* @param target The container.
|
|
*
|
|
* @return The component's alignment.
|
|
*/
|
|
public float getLayoutAlignmentY(Container target)
|
|
{
|
|
return target.getAlignmentY();
|
|
}
|
|
|
|
/**
|
|
* This method returns the preferred width of the component.
|
|
*
|
|
* @param c The component to measure.
|
|
*
|
|
* @return The preferred width of the component.
|
|
*/
|
|
protected int getPreferredSizeOfComponent(Component c)
|
|
{
|
|
Dimension dims = c.getPreferredSize();
|
|
if (dims != null)
|
|
return dims.width;
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* This method returns the current width of the component.
|
|
*
|
|
* @param c The component to measure.
|
|
*
|
|
* @return The width of the component.
|
|
*/
|
|
protected int getSizeOfComponent(Component c)
|
|
{
|
|
return c.getWidth();
|
|
}
|
|
|
|
/**
|
|
* This method returns the sizes array.
|
|
*
|
|
* @return The sizes array.
|
|
*/
|
|
protected int[] getSizes()
|
|
{
|
|
return sizes;
|
|
}
|
|
|
|
/**
|
|
* This method invalidates the layout. It does nothing.
|
|
*
|
|
* @param c The container to invalidate.
|
|
*/
|
|
public void invalidateLayout(Container c)
|
|
{
|
|
// DO NOTHING
|
|
}
|
|
|
|
/**
|
|
* This method lays out the components in the container.
|
|
*
|
|
* @param container The container to lay out.
|
|
*/
|
|
public void layoutContainer(Container container)
|
|
{
|
|
if (container instanceof JSplitPane)
|
|
{
|
|
JSplitPane split = (JSplitPane) container;
|
|
distributeExtraSpace();
|
|
Insets insets = split.getInsets();
|
|
int width = getInitialLocation(insets);
|
|
Dimension dims = split.getSize();
|
|
for (int i = 0; i < components.length; i += 2)
|
|
{
|
|
if (components[i] == null)
|
|
continue;
|
|
setComponentToSize(components[i], sizes[i], width, insets, dims);
|
|
width += sizes[i];
|
|
}
|
|
if (components[1] != null)
|
|
{
|
|
setComponentToSize(components[1], sizes[1], width, insets, dims);
|
|
width += sizes[1];
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* This method returns the maximum size for the container given the
|
|
* components. It returns a new Dimension object that has width and
|
|
* height equal to Integer.MAX_VALUE.
|
|
*
|
|
* @param target The container to measure.
|
|
*
|
|
* @return The maximum size.
|
|
*/
|
|
public Dimension maximumLayoutSize(Container target)
|
|
{
|
|
return new Dimension(Integer.MAX_VALUE, Integer.MAX_VALUE);
|
|
}
|
|
|
|
/**
|
|
* This method returns the container's minimum size. The minimum width is
|
|
* the sum of all the component's minimum widths. The minimum height is
|
|
* the maximum of all the components' minimum heights.
|
|
*
|
|
* @param target The container to measure.
|
|
*
|
|
* @return The minimum size.
|
|
*/
|
|
public Dimension minimumLayoutSize(Container target)
|
|
{
|
|
if (target instanceof JSplitPane)
|
|
{
|
|
JSplitPane split = (JSplitPane) target;
|
|
Insets insets = target.getInsets();
|
|
|
|
int height = 0;
|
|
int width = 0;
|
|
for (int i = 0; i < components.length; i++)
|
|
{
|
|
if (components[i] == null)
|
|
continue;
|
|
Dimension dims = components[i].getMinimumSize();
|
|
if (dims != null)
|
|
{
|
|
width += dims.width;
|
|
height = Math.max(height, dims.height);
|
|
}
|
|
}
|
|
return new Dimension(width, height);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* This method returns the container's preferred size. The preferred width
|
|
* is the sum of all the component's preferred widths. The preferred
|
|
* height is the maximum of all the components' preferred heights.
|
|
*
|
|
* @param target The container to measure.
|
|
*
|
|
* @return The preferred size.
|
|
*/
|
|
public Dimension preferredLayoutSize(Container target)
|
|
{
|
|
if (target instanceof JSplitPane)
|
|
{
|
|
JSplitPane split = (JSplitPane) target;
|
|
Insets insets = target.getInsets();
|
|
|
|
int height = 0;
|
|
int width = 0;
|
|
for (int i = 0; i < components.length; i++)
|
|
{
|
|
if (components[i] == null)
|
|
continue;
|
|
Dimension dims = components[i].getPreferredSize();
|
|
if (dims != null)
|
|
{
|
|
width += dims.width;
|
|
if (! (components[i] instanceof BasicSplitPaneDivider))
|
|
height = Math.max(height, dims.height);
|
|
}
|
|
}
|
|
return new Dimension(500, 500); //width, height);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* This method removes the component from the layout.
|
|
*
|
|
* @param component The component to remove from the layout.
|
|
*/
|
|
public void removeLayoutComponent(Component component)
|
|
{
|
|
for (int i = 0; i < components.length; i++)
|
|
{
|
|
if (component == components[i])
|
|
{
|
|
components[i] = null;
|
|
sizes[i] = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* This method resets the size of Component to the preferred size.
|
|
*
|
|
* @param index The index of the component to reset.
|
|
*/
|
|
protected void resetSizeAt(int index)
|
|
{
|
|
if (components[index] != null)
|
|
sizes[index] = getPreferredSizeOfComponent(components[index]);
|
|
}
|
|
|
|
/**
|
|
* This method resets the sizes of all the components.
|
|
*/
|
|
public void resetToPreferredSizes()
|
|
{
|
|
for (int i = 0; i < components.length; i++)
|
|
resetSizeAt(i);
|
|
}
|
|
|
|
/**
|
|
* This methods sets the bounds of the given component. The width is the
|
|
* size. The height is the container size minus the top and bottom
|
|
* inset. The x coordinate is the location given. The y coordinate is
|
|
* the top inset.
|
|
*
|
|
* @param c The component to set.
|
|
* @param size The width of the component.
|
|
* @param location The x coordinate.
|
|
* @param insets The insets to use.
|
|
* @param containerSize The height of the container.
|
|
*/
|
|
protected void setComponentToSize(Component c, int size, int location,
|
|
Insets insets, Dimension containerSize)
|
|
{
|
|
int w = size;
|
|
int h = containerSize.height - insets.top - insets.bottom;
|
|
int x = location;
|
|
int y = insets.top;
|
|
c.setBounds(x, y, w, h);
|
|
}
|
|
|
|
/**
|
|
* This method stores the given int array as the new sizes array.
|
|
*
|
|
* @param newSizes The array to use as sizes.
|
|
*/
|
|
protected void setSizes(int[] newSizes)
|
|
{
|
|
sizes = newSizes;
|
|
}
|
|
|
|
/**
|
|
* This method determines the size of each component. It should be called
|
|
* when a new Layout Manager is created for an existing JSplitPane.
|
|
*/
|
|
protected void updateComponents()
|
|
{
|
|
Component left = splitPane.getLeftComponent();
|
|
Component right = splitPane.getRightComponent();
|
|
|
|
if (left != null)
|
|
{
|
|
components[0] = left;
|
|
resetSizeAt(0);
|
|
}
|
|
if (right != null)
|
|
{
|
|
components[1] = right;
|
|
resetSizeAt(1);
|
|
}
|
|
components[2] = divider;
|
|
resetSizeAt(2);
|
|
}
|
|
|
|
/**
|
|
* This method resizes the left and right components to fit inside the
|
|
* JSplitPane when there is extra space.
|
|
*/
|
|
void distributeExtraSpace()
|
|
{
|
|
int availSize = getAvailableSize(splitPane.getSize(),
|
|
splitPane.getInsets());
|
|
int[] newSizes = new int[3];
|
|
double weight = splitPane.getResizeWeight();
|
|
|
|
int oldLen = sizes[0] + sizes[1];
|
|
|
|
// dividers don't change size.
|
|
availSize -= sizes[2] + oldLen;
|
|
|
|
int rightAlloc = (int) (availSize * (1 - weight));
|
|
int leftAlloc = availSize - rightAlloc;
|
|
|
|
sizes[0] += leftAlloc;
|
|
sizes[1] += rightAlloc;
|
|
}
|
|
|
|
/**
|
|
* This method returns the minimum width of the component at the given
|
|
* index.
|
|
*
|
|
* @param index The index to check.
|
|
*
|
|
* @return The minimum width.
|
|
*/
|
|
int minimumSizeOfComponent(int index)
|
|
{
|
|
Dimension dims = components[index].getMinimumSize();
|
|
if (dims != null)
|
|
return dims.width;
|
|
else
|
|
return 0;
|
|
}
|
|
} //end BasicHorizontalLayoutManager
|
|
|
|
/**
|
|
* This class is the Layout Manager for the JSplitPane when the orientation
|
|
* is VERTICAL_SPLIT.
|
|
*/
|
|
protected class BasicVerticalLayoutManager
|
|
extends BasicHorizontalLayoutManager
|
|
{
|
|
/**
|
|
* This method returns the height of the container minus the top and
|
|
* bottom inset.
|
|
*
|
|
* @param containerSize The size of the container.
|
|
* @param insets The insets of the container.
|
|
*
|
|
* @return The height minus top and bottom inset.
|
|
*/
|
|
protected int getAvailableSize(Dimension containerSize, Insets insets)
|
|
{
|
|
return containerSize.height - insets.top - insets.bottom;
|
|
}
|
|
|
|
/**
|
|
* This method returns the top inset.
|
|
*
|
|
* @param insets The Insets to use.
|
|
*
|
|
* @return The top inset.
|
|
*/
|
|
protected int getInitialLocation(Insets insets)
|
|
{
|
|
return insets.top;
|
|
}
|
|
|
|
/**
|
|
* This method returns the preferred height of the component.
|
|
*
|
|
* @param c The component to measure.
|
|
*
|
|
* @return The preferred height of the component.
|
|
*/
|
|
protected int getPreferredSizeOfComponent(Component c)
|
|
{
|
|
Dimension dims = c.getPreferredSize();
|
|
if (dims != null)
|
|
return dims.height;
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* This method returns the current height of the component.
|
|
*
|
|
* @param c The component to measure.
|
|
*
|
|
* @return The current height of the component.
|
|
*/
|
|
protected int getSizeOfComponent(Component c)
|
|
{
|
|
return c.getHeight();
|
|
}
|
|
|
|
/**
|
|
* This method returns the minimum layout size. The minimum height is the
|
|
* sum of all the components' minimum heights. The minimum width is the
|
|
* maximum of all the components' minimum widths.
|
|
*
|
|
* @param container The container to measure.
|
|
*
|
|
* @return The minimum size.
|
|
*/
|
|
public Dimension minimumLayoutSize(Container container)
|
|
{
|
|
if (container instanceof JSplitPane)
|
|
{
|
|
JSplitPane split = (JSplitPane) container;
|
|
Insets insets = container.getInsets();
|
|
|
|
int height = 0;
|
|
int width = 0;
|
|
for (int i = 0; i < components.length; i++)
|
|
{
|
|
if (components[i] == null)
|
|
continue;
|
|
Dimension dims = components[i].getMinimumSize();
|
|
if (dims != null)
|
|
{
|
|
height += dims.height;
|
|
width = Math.max(width, dims.width);
|
|
}
|
|
}
|
|
return new Dimension(width, height);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* This method returns the preferred layout size. The preferred height is
|
|
* the sum of all the components' preferred heights. The preferred width
|
|
* is the maximum of all the components' preferred widths.
|
|
*
|
|
* @param container The container to measure.
|
|
*
|
|
* @return The preferred size.
|
|
*/
|
|
public Dimension preferredLayoutSize(Container container)
|
|
{
|
|
if (container instanceof JSplitPane)
|
|
{
|
|
JSplitPane split = (JSplitPane) container;
|
|
Insets insets = container.getInsets();
|
|
|
|
int height = 0;
|
|
int width = 0;
|
|
for (int i = 0; i < components.length; i++)
|
|
{
|
|
if (components[i] == null)
|
|
continue;
|
|
Dimension dims = components[i].getPreferredSize();
|
|
if (dims != null)
|
|
{
|
|
height += dims.height;
|
|
width = Math.max(width, dims.width);
|
|
}
|
|
}
|
|
return new Dimension(500, 500); //width, height);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* This method sets the bounds of the given component. The y coordinate is
|
|
* the location given. The x coordinate is the left inset. The height is
|
|
* the size given. The width is the container size minus the left and
|
|
* right inset.
|
|
*
|
|
* @param c The component to set bounds for.
|
|
* @param size The height.
|
|
* @param location The y coordinate.
|
|
* @param insets The insets to use.
|
|
* @param containerSize The container's size.
|
|
*/
|
|
protected void setComponentToSize(Component c, int size, int location,
|
|
Insets insets, Dimension containerSize)
|
|
{
|
|
int y = location;
|
|
int x = insets.left;
|
|
int h = size;
|
|
int w = containerSize.width - insets.left - insets.right;
|
|
|
|
c.setBounds(x, y, w, h);
|
|
}
|
|
|
|
/**
|
|
* This method returns the minimum height of the component at the given
|
|
* index.
|
|
*
|
|
* @param index The index of the component to check.
|
|
*
|
|
* @return The minimum height of the given component.
|
|
*/
|
|
int minimumSizeOfComponent(int index)
|
|
{
|
|
Dimension dims = components[index].getMinimumSize();
|
|
if (dims != null)
|
|
return dims.height;
|
|
else
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* This class handles FocusEvents from the JComponent.
|
|
*/
|
|
protected class FocusHandler extends FocusAdapter
|
|
{
|
|
/**
|
|
* This method is called when the JSplitPane gains focus.
|
|
*
|
|
* @param ev The FocusEvent.
|
|
*/
|
|
public void focusGained(FocusEvent ev)
|
|
{
|
|
// FIXME: implement.
|
|
}
|
|
|
|
/**
|
|
* This method is called when the JSplitPane loses focus.
|
|
*
|
|
* @param ev The FocusEvent.
|
|
*/
|
|
public void focusLost(FocusEvent ev)
|
|
{
|
|
// FIXME: implement.
|
|
}
|
|
}
|
|
|
|
/**
|
|
* This is a deprecated class. It is supposed to be used for handling down
|
|
* and right key presses.
|
|
*/
|
|
protected class KeyboardDownRightHandler implements ActionListener
|
|
{
|
|
/**
|
|
* This method is called when the down or right keys are pressed.
|
|
*
|
|
* @param ev The ActionEvent
|
|
*/
|
|
public void actionPerformed(ActionEvent ev)
|
|
{
|
|
// FIXME: implement.
|
|
}
|
|
}
|
|
|
|
/**
|
|
* This is a deprecated class. It is supposed to be used for handling end
|
|
* key presses.
|
|
*/
|
|
protected class KeyboardEndHandler implements ActionListener
|
|
{
|
|
/**
|
|
* This method is called when the end key is pressed.
|
|
*
|
|
* @param ev The ActionEvent.
|
|
*/
|
|
public void actionPerformed(ActionEvent ev)
|
|
{
|
|
// FIXME: implement.
|
|
}
|
|
}
|
|
|
|
/**
|
|
* This is a deprecated class. It is supposed to be used for handling home
|
|
* key presses.
|
|
*/
|
|
protected class KeyboardHomeHandler implements ActionListener
|
|
{
|
|
/**
|
|
* This method is called when the home key is pressed.
|
|
*
|
|
* @param ev The ActionEvent.
|
|
*/
|
|
public void actionPerformed(ActionEvent ev)
|
|
{
|
|
// FIXME: implement.
|
|
}
|
|
}
|
|
|
|
/**
|
|
* This is a deprecated class. It is supposed to be used for handling resize
|
|
* toggles.
|
|
*/
|
|
protected class KeyboardResizeToggleHandler implements ActionListener
|
|
{
|
|
/**
|
|
* This method is called when a resize is toggled.
|
|
*
|
|
* @param ev The ActionEvent.
|
|
*/
|
|
public void actionPerformed(ActionEvent ev)
|
|
{
|
|
// FIXME: implement.
|
|
}
|
|
}
|
|
|
|
/**
|
|
* This is a deprecated class. It is supposed to be used for handler up and
|
|
* left key presses.
|
|
*/
|
|
protected class KeyboardUpLeftHandler implements ActionListener
|
|
{
|
|
/**
|
|
* This method is called when the left or up keys are pressed.
|
|
*
|
|
* @param ev The ActionEvent.
|
|
*/
|
|
public void actionPerformed(ActionEvent ev)
|
|
{
|
|
// FIXME: implement.
|
|
}
|
|
}
|
|
|
|
/**
|
|
* This helper class handles PropertyChangeEvents from the JSplitPane. When
|
|
* a property changes, this will update the UI accordingly.
|
|
*/
|
|
protected class PropertyHandler implements PropertyChangeListener
|
|
{
|
|
/**
|
|
* This method is called whenever one of the JSplitPane's properties
|
|
* change.
|
|
*
|
|
* @param e DOCUMENT ME!
|
|
*/
|
|
public void propertyChange(PropertyChangeEvent e)
|
|
{
|
|
if (e.getPropertyName().equals(JSplitPane.DIVIDER_SIZE_PROPERTY))
|
|
{
|
|
int newSize = splitPane.getDividerSize();
|
|
int[] tmpSizes = layoutManager.getSizes();
|
|
dividerSize = tmpSizes[2];
|
|
Component left = splitPane.getLeftComponent();
|
|
Component right = splitPane.getRightComponent();
|
|
int newSpace = newSize - tmpSizes[2];
|
|
|
|
tmpSizes[2] = newSize;
|
|
|
|
tmpSizes[0] += newSpace / 2;
|
|
tmpSizes[1] += newSpace / 2;
|
|
|
|
layoutManager.setSizes(tmpSizes);
|
|
}
|
|
else if (e.getPropertyName().equals(JSplitPane.ORIENTATION_PROPERTY))
|
|
{
|
|
int max = layoutManager.getAvailableSize(splitPane.getSize(),
|
|
splitPane.getInsets());
|
|
int dividerLoc = getDividerLocation(splitPane);
|
|
double prop = ((double) dividerLoc) / max;
|
|
|
|
resetLayoutManager();
|
|
if (prop <= 1 && prop >= 0)
|
|
splitPane.setDividerLocation(prop);
|
|
}
|
|
layoutManager.layoutContainer(splitPane);
|
|
splitPane.repaint();
|
|
// Don't have to deal with continuous_layout - only
|
|
// necessary in dragging modes (and it's checked
|
|
// every time you drag there)
|
|
// Don't have to deal with resize_weight (as there
|
|
// will be no extra space associated with this
|
|
// event - the changes to the weighting will
|
|
// be taken into account the next time the
|
|
// sizes change.)
|
|
// Don't have to deal with divider_location
|
|
// The method in JSplitPane calls our setDividerLocation
|
|
// so we'll know about those anyway.
|
|
// Don't have to deal with last_divider_location
|
|
// Although I'm not sure why, it doesn't seem to
|
|
// have any effect on Sun's JSplitPane.
|
|
// one_touch_expandable changes are dealt with
|
|
// by our divider.
|
|
}
|
|
}
|
|
|
|
/** The location of the divider when dragging began. */
|
|
protected int beginDragDividerLocation;
|
|
|
|
/** The size of the divider while dragging. */
|
|
protected int dividerSize;
|
|
|
|
/** The location where the last drag location ended. */
|
|
transient int lastDragLocation = -1;
|
|
|
|
/** The distance the divider is moved when moved by keyboard actions. */
|
|
protected static int KEYBOARD_DIVIDER_MOVE_OFFSET;
|
|
|
|
/** The divider that divides this JSplitPane. */
|
|
protected BasicSplitPaneDivider divider;
|
|
|
|
/** The listener that listens for PropertyChangeEvents from the JSplitPane. */
|
|
protected PropertyChangeListener propertyChangeListener;
|
|
|
|
/** The JSplitPane's focus handler. */
|
|
protected FocusListener focusListener;
|
|
|
|
/** Deprecated. The handler for down and right key presses. */
|
|
protected ActionListener keyboardDownRightListener;
|
|
|
|
/** Deprecated. The handler for end key presses. */
|
|
protected ActionListener keyboardEndListener;
|
|
|
|
/** Deprecated. The handler for home key presses. */
|
|
protected ActionListener keyboardHomeListener;
|
|
|
|
/** Deprecated. The handler for toggling resizes. */
|
|
protected ActionListener keyboardResizeToggleListener;
|
|
|
|
/** Deprecated. The handler for up and left key presses. */
|
|
protected ActionListener keyboardUpLeftListener;
|
|
|
|
/** The JSplitPane's current layout manager. */
|
|
protected BasicHorizontalLayoutManager layoutManager;
|
|
|
|
/** Deprecated. The divider resize toggle key. */
|
|
protected KeyStroke dividerResizeToggleKey;
|
|
|
|
/** Deprecated. The down key. */
|
|
protected KeyStroke downKey;
|
|
|
|
/** Deprecated. The end key. */
|
|
protected KeyStroke endKey;
|
|
|
|
/** Deprecated. The home key. */
|
|
protected KeyStroke homeKey;
|
|
|
|
/** Deprecated. The left key. */
|
|
protected KeyStroke leftKey;
|
|
|
|
/** Deprecated. The right key. */
|
|
protected KeyStroke rightKey;
|
|
|
|
/** Deprecated. The up key. */
|
|
protected KeyStroke upKey;
|
|
|
|
/** Set to true when dragging heavy weight components. */
|
|
protected boolean draggingHW;
|
|
|
|
/**
|
|
* The constraints object used when adding the non-continuous divider to the
|
|
* JSplitPane.
|
|
*/
|
|
protected static String NON_CONTINUOUS_DIVIDER;
|
|
|
|
/** The dark divider used when dragging in non-continuous layout mode. */
|
|
protected Component nonContinuousLayoutDivider;
|
|
|
|
/** The JSplitPane that this UI draws. */
|
|
protected JSplitPane splitPane;
|
|
|
|
/**
|
|
* Creates a new BasicSplitPaneUI object.
|
|
*/
|
|
public BasicSplitPaneUI()
|
|
{
|
|
}
|
|
|
|
/**
|
|
* This method creates a new BasicSplitPaneUI for the given JComponent.
|
|
*
|
|
* @param x The JComponent to create a UI for.
|
|
*
|
|
* @return A new BasicSplitPaneUI.
|
|
*/
|
|
public static ComponentUI createUI(JComponent x)
|
|
{
|
|
return new BasicSplitPaneUI();
|
|
}
|
|
|
|
/**
|
|
* This method installs the BasicSplitPaneUI for the given JComponent.
|
|
*
|
|
* @param c The JComponent to install the UI for.
|
|
*/
|
|
public void installUI(JComponent c)
|
|
{
|
|
if (c instanceof JSplitPane)
|
|
{
|
|
splitPane = (JSplitPane) c;
|
|
installDefaults();
|
|
installListeners();
|
|
installKeyboardActions();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* This method uninstalls the BasicSplitPaneUI for the given JComponent.
|
|
*
|
|
* @param c The JComponent to uninstall the UI for.
|
|
*/
|
|
public void uninstallUI(JComponent c)
|
|
{
|
|
uninstallKeyboardActions();
|
|
uninstallListeners();
|
|
uninstallDefaults();
|
|
|
|
splitPane = null;
|
|
}
|
|
|
|
/**
|
|
* This method installs the defaults given by the Look and Feel.
|
|
*/
|
|
protected void installDefaults()
|
|
{
|
|
resetLayoutManager();
|
|
divider = createDefaultDivider();
|
|
nonContinuousLayoutDivider = createDefaultNonContinuousLayoutDivider();
|
|
splitPane.add(divider, JSplitPane.DIVIDER);
|
|
|
|
// There is no need to add the nonContinuousLayoutDivider
|
|
UIDefaults defaults = UIManager.getLookAndFeelDefaults();
|
|
splitPane.setBackground(defaults.getColor("SplitPane.background"));
|
|
splitPane.setBorder(defaults.getBorder("SplitPane.border"));
|
|
splitPane.setDividerSize(defaults.getInt("SplitPane.dividerSize"));
|
|
}
|
|
|
|
/**
|
|
* This method uninstalls the defaults and nulls any objects created during
|
|
* install.
|
|
*/
|
|
protected void uninstallDefaults()
|
|
{
|
|
layoutManager = null;
|
|
splitPane.remove(divider);
|
|
divider = null;
|
|
nonContinuousLayoutDivider = null;
|
|
|
|
splitPane.setBackground(null);
|
|
splitPane.setBorder(null);
|
|
}
|
|
|
|
/**
|
|
* This method installs the listeners needed for this UI to function.
|
|
*/
|
|
protected void installListeners()
|
|
{
|
|
propertyChangeListener = createPropertyChangeListener();
|
|
focusListener = createFocusListener();
|
|
|
|
splitPane.addPropertyChangeListener(propertyChangeListener);
|
|
splitPane.addFocusListener(focusListener);
|
|
}
|
|
|
|
/**
|
|
* This method uninstalls all listeners registered for the UI.
|
|
*/
|
|
protected void uninstallListeners()
|
|
{
|
|
splitPane.removePropertyChangeListener(propertyChangeListener);
|
|
splitPane.removeFocusListener(focusListener);
|
|
|
|
focusListener = null;
|
|
propertyChangeListener = null;
|
|
}
|
|
|
|
/**
|
|
* This method installs the keyboard actions for the JSplitPane.
|
|
*/
|
|
protected void installKeyboardActions()
|
|
{
|
|
// FIXME: implement.
|
|
}
|
|
|
|
/**
|
|
* This method reverses the work done in installKeyboardActions.
|
|
*/
|
|
protected void uninstallKeyboardActions()
|
|
{
|
|
// FIXME: implement.
|
|
}
|
|
|
|
/**
|
|
* This method creates a new PropertyChangeListener.
|
|
*
|
|
* @return A new PropertyChangeListener.
|
|
*/
|
|
protected PropertyChangeListener createPropertyChangeListener()
|
|
{
|
|
return new PropertyHandler();
|
|
}
|
|
|
|
/**
|
|
* This method creates a new FocusListener.
|
|
*
|
|
* @return A new FocusListener.
|
|
*/
|
|
protected FocusListener createFocusListener()
|
|
{
|
|
return new FocusHandler();
|
|
}
|
|
|
|
/**
|
|
* Deprecated. This method creates a new ActionListener for up and left key
|
|
* presses.
|
|
*
|
|
* @return A new ActionListener for up and left keys.
|
|
*/
|
|
protected ActionListener createKeyboardUpLeftListener()
|
|
{
|
|
return new KeyboardUpLeftHandler();
|
|
}
|
|
|
|
/**
|
|
* Deprecated. This method creates a new ActionListener for down and right
|
|
* key presses.
|
|
*
|
|
* @return A new ActionListener for down and right keys.
|
|
*/
|
|
protected ActionListener createKeyboardDownRightListener()
|
|
{
|
|
return new KeyboardDownRightHandler();
|
|
}
|
|
|
|
/**
|
|
* Deprecated. This method creates a new ActionListener for home key
|
|
* presses.
|
|
*
|
|
* @return A new ActionListener for home keys.
|
|
*/
|
|
protected ActionListener createKeyboardHomeListener()
|
|
{
|
|
return new KeyboardHomeHandler();
|
|
}
|
|
|
|
/**
|
|
* Deprecated. This method creates a new ActionListener for end key presses.
|
|
*
|
|
* @return A new ActionListener for end keys.
|
|
*/
|
|
protected ActionListener createKeyboardEndListener()
|
|
{
|
|
return new KeyboardEndHandler();
|
|
}
|
|
|
|
/**
|
|
* Depcreated. This method creates a new ActionListener for resize toggle
|
|
* key events.
|
|
*
|
|
* @return A new ActionListener for resize toggle keys.
|
|
*/
|
|
protected ActionListener createKeyboardResizeToggleListener()
|
|
{
|
|
return new KeyboardResizeToggleHandler();
|
|
}
|
|
|
|
/**
|
|
* This method returns the orientation of the JSplitPane.
|
|
*
|
|
* @return The orientation of the JSplitPane.
|
|
*/
|
|
public int getOrientation()
|
|
{
|
|
return splitPane.getOrientation();
|
|
}
|
|
|
|
/**
|
|
* This method sets the orientation of the JSplitPane.
|
|
*
|
|
* @param orientation The new orientation of the JSplitPane.
|
|
*/
|
|
public void setOrientation(int orientation)
|
|
{
|
|
splitPane.setOrientation(orientation);
|
|
}
|
|
|
|
/**
|
|
* This method returns true if the JSplitPane is using continuous layout.
|
|
*
|
|
* @return True if the JSplitPane is using continuous layout.
|
|
*/
|
|
public boolean isContinuousLayout()
|
|
{
|
|
return splitPane.isContinuousLayout();
|
|
}
|
|
|
|
/**
|
|
* This method sets the continuous layout property of the JSplitPane.
|
|
*
|
|
* @param b True if the JsplitPane is to use continuous layout.
|
|
*/
|
|
public void setContinuousLayout(boolean b)
|
|
{
|
|
splitPane.setContinuousLayout(b);
|
|
}
|
|
|
|
/**
|
|
* This method returns the last location the divider was dragged to.
|
|
*
|
|
* @return The last location the divider was dragged to.
|
|
*/
|
|
public int getLastDragLocation()
|
|
{
|
|
return lastDragLocation;
|
|
}
|
|
|
|
/**
|
|
* This method sets the last location the divider was dragged to.
|
|
*
|
|
* @param l The last location the divider was dragged to.
|
|
*/
|
|
public void setLastDragLocation(int l)
|
|
{
|
|
lastDragLocation = l;
|
|
}
|
|
|
|
/**
|
|
* This method returns the BasicSplitPaneDivider that divides this
|
|
* JSplitPane.
|
|
*
|
|
* @return The divider for the JSplitPane.
|
|
*/
|
|
public BasicSplitPaneDivider getDivider()
|
|
{
|
|
return divider;
|
|
}
|
|
|
|
/**
|
|
* This method creates a nonContinuousLayoutDivider for use with the
|
|
* JSplitPane in nonContinousLayout mode. The default divider is a gray
|
|
* Canvas.
|
|
*
|
|
* @return The default nonContinousLayoutDivider.
|
|
*/
|
|
protected Component createDefaultNonContinuousLayoutDivider()
|
|
{
|
|
if (nonContinuousLayoutDivider == null)
|
|
{
|
|
nonContinuousLayoutDivider = new Canvas();
|
|
nonContinuousLayoutDivider.setBackground(Color.DARK_GRAY);
|
|
}
|
|
return nonContinuousLayoutDivider;
|
|
}
|
|
|
|
/**
|
|
* This method sets the component to use as the nonContinuousLayoutDivider.
|
|
*
|
|
* @param newDivider The component to use as the nonContinuousLayoutDivider.
|
|
*/
|
|
protected void setNonContinuousLayoutDivider(Component newDivider)
|
|
{
|
|
setNonContinuousLayoutDivider(newDivider, true);
|
|
}
|
|
|
|
/**
|
|
* This method sets the component to use as the nonContinuousLayoutDivider.
|
|
*
|
|
* @param newDivider The component to use as the nonContinuousLayoutDivider.
|
|
* @param rememberSizes FIXME: document.
|
|
*/
|
|
protected void setNonContinuousLayoutDivider(Component newDivider,
|
|
boolean rememberSizes)
|
|
{
|
|
// FIXME: use rememberSizes for something
|
|
nonContinuousLayoutDivider = newDivider;
|
|
}
|
|
|
|
/**
|
|
* This method returns the nonContinuousLayoutDivider.
|
|
*
|
|
* @return The nonContinuousLayoutDivider.
|
|
*/
|
|
public Component getNonContinuousLayoutDivider()
|
|
{
|
|
return nonContinuousLayoutDivider;
|
|
}
|
|
|
|
/**
|
|
* This method returns the JSplitPane that this BasicSplitPaneUI draws.
|
|
*
|
|
* @return The JSplitPane.
|
|
*/
|
|
public JSplitPane getSplitPane()
|
|
{
|
|
return splitPane;
|
|
}
|
|
|
|
/**
|
|
* This method creates the divider used normally with the JSplitPane.
|
|
*
|
|
* @return The default divider.
|
|
*/
|
|
public BasicSplitPaneDivider createDefaultDivider()
|
|
{
|
|
if (divider == null)
|
|
divider = new BasicSplitPaneDivider(this);
|
|
return divider;
|
|
}
|
|
|
|
/**
|
|
* This method is called when JSplitPane's resetToPreferredSizes is called.
|
|
* It resets the sizes of all components in the JSplitPane.
|
|
*
|
|
* @param jc The JSplitPane to reset.
|
|
*/
|
|
public void resetToPreferredSizes(JSplitPane jc)
|
|
{
|
|
layoutManager.resetToPreferredSizes();
|
|
}
|
|
|
|
/**
|
|
* This method sets the location of the divider.
|
|
*
|
|
* @param jc The JSplitPane to set the divider location in.
|
|
* @param location The new location of the divider.
|
|
*/
|
|
public void setDividerLocation(JSplitPane jc, int location)
|
|
{
|
|
setLastDragLocation(getDividerLocation(splitPane));
|
|
splitPane.setLastDividerLocation(getDividerLocation(splitPane));
|
|
int[] tmpSizes = layoutManager.getSizes();
|
|
tmpSizes[0] = location
|
|
- layoutManager.getInitialLocation(splitPane.getInsets());
|
|
tmpSizes[1] = layoutManager.getAvailableSize(splitPane.getSize(),
|
|
splitPane.getInsets())
|
|
- tmpSizes[0] - tmpSizes[1];
|
|
Point p = divider.getLocation();
|
|
|
|
// if (getOrientation() == JSplitPane.HORIZONTAL_SPLIT)
|
|
// setLastDragLocation(p.x);
|
|
// else
|
|
// setLastDragLocation(p.y);
|
|
layoutManager.setSizes(tmpSizes);
|
|
layoutManager.layoutContainer(splitPane);
|
|
|
|
splitPane.repaint();
|
|
}
|
|
|
|
/**
|
|
* This method returns the location of the divider.
|
|
*
|
|
* @param jc The JSplitPane to retrieve the location for.
|
|
*
|
|
* @return The location of the divider.
|
|
*/
|
|
public int getDividerLocation(JSplitPane jc)
|
|
{
|
|
return layoutManager.sizes[0]
|
|
+ layoutManager.getInitialLocation(splitPane.getInsets());
|
|
}
|
|
|
|
/**
|
|
* This method returns the smallest value possible for the location of the
|
|
* divider.
|
|
*
|
|
* @param jc The JSplitPane.
|
|
*
|
|
* @return The minimum divider location.
|
|
*/
|
|
public int getMinimumDividerLocation(JSplitPane jc)
|
|
{
|
|
int value = layoutManager.getInitialLocation(jc.getInsets());
|
|
if (layoutManager.components[0] != null)
|
|
value += layoutManager.minimumSizeOfComponent(0);
|
|
return value;
|
|
}
|
|
|
|
/**
|
|
* This method returns the largest value possible for the location of the
|
|
* divider.
|
|
*
|
|
* @param jc The JSplitPane.
|
|
*
|
|
* @return The maximum divider location.
|
|
*/
|
|
public int getMaximumDividerLocation(JSplitPane jc)
|
|
{
|
|
int value = layoutManager.getInitialLocation(jc.getInsets())
|
|
+ layoutManager.getAvailableSize(jc.getSize(), jc.getInsets())
|
|
- splitPane.getDividerSize();
|
|
if (layoutManager.components[1] != null)
|
|
value -= layoutManager.minimumSizeOfComponent(1);
|
|
return value;
|
|
}
|
|
|
|
/**
|
|
* This method is called after the children of the JSplitPane are painted.
|
|
*
|
|
* @param jc The JSplitPane.
|
|
* @param g The Graphics object to paint with.
|
|
*/
|
|
public void finishedPaintingChildren(JSplitPane jc, Graphics g)
|
|
{
|
|
if (! splitPane.isContinuousLayout() && nonContinuousLayoutDivider != null
|
|
&& nonContinuousLayoutDivider.isVisible())
|
|
javax.swing.SwingUtilities.paintComponent(g, nonContinuousLayoutDivider,
|
|
null,
|
|
nonContinuousLayoutDivider
|
|
.getBounds());
|
|
}
|
|
|
|
/**
|
|
* This method is called to paint the JSplitPane.
|
|
*
|
|
* @param g The Graphics object to paint with.
|
|
* @param jc The JSplitPane to paint.
|
|
*/
|
|
public void paint(Graphics g, JComponent jc)
|
|
{
|
|
// Do nothing. All the painting is handled by children.
|
|
}
|
|
|
|
/**
|
|
* This method returns the preferred size of the JSplitPane.
|
|
*
|
|
* @param jc The JSplitPane.
|
|
*
|
|
* @return The preferred size of the JSplitPane.
|
|
*/
|
|
public Dimension getPreferredSize(JComponent jc)
|
|
{
|
|
return layoutManager.preferredLayoutSize((Container) jc);
|
|
}
|
|
|
|
/**
|
|
* This method returns the minimum size of the JSplitPane.
|
|
*
|
|
* @param jc The JSplitPane.
|
|
*
|
|
* @return The minimum size of the JSplitPane.
|
|
*/
|
|
public Dimension getMinimumSize(JComponent jc)
|
|
{
|
|
return layoutManager.minimumLayoutSize((Container) jc);
|
|
}
|
|
|
|
/**
|
|
* This method returns the maximum size of the JSplitPane.
|
|
*
|
|
* @param jc The JSplitPane.
|
|
*
|
|
* @return The maximum size of the JSplitPane.
|
|
*/
|
|
public Dimension getMaximumSize(JComponent jc)
|
|
{
|
|
return layoutManager.maximumLayoutSize((Container) jc);
|
|
}
|
|
|
|
/**
|
|
* This method returns the border insets of the current border.
|
|
*
|
|
* @param jc The JSplitPane.
|
|
*
|
|
* @return The current border insets.
|
|
*/
|
|
public Insets getInsets(JComponent jc)
|
|
{
|
|
return splitPane.getBorder().getBorderInsets(splitPane);
|
|
}
|
|
|
|
/**
|
|
* This method resets the current layout manager. The type of layout manager
|
|
* is dependent on the current orientation.
|
|
*/
|
|
protected void resetLayoutManager()
|
|
{
|
|
if (getOrientation() == JSplitPane.HORIZONTAL_SPLIT)
|
|
layoutManager = new BasicHorizontalLayoutManager();
|
|
else
|
|
layoutManager = new BasicVerticalLayoutManager();
|
|
layoutManager.invalidateLayout(splitPane);
|
|
layoutManager.updateComponents();
|
|
getSplitPane().setLayout(layoutManager);
|
|
|
|
// invalidating by itself does not invalidate the layout.
|
|
getSplitPane().invalidate();
|
|
}
|
|
|
|
/**
|
|
* This method is called when dragging starts. It resets lastDragLocation
|
|
* and dividerSize.
|
|
*/
|
|
protected void startDragging()
|
|
{
|
|
dividerSize = divider.getDividerSize();
|
|
setLastDragLocation(-1);
|
|
|
|
if (! splitPane.getLeftComponent().isLightweight()
|
|
|| ! splitPane.getRightComponent().isLightweight())
|
|
draggingHW = true;
|
|
|
|
if (splitPane.isContinuousLayout())
|
|
nonContinuousLayoutDivider.setVisible(false);
|
|
else
|
|
{
|
|
nonContinuousLayoutDivider.setVisible(true);
|
|
nonContinuousLayoutDivider.setBounds(divider.getBounds());
|
|
}
|
|
splitPane.invalidate();
|
|
splitPane.repaint();
|
|
}
|
|
|
|
/**
|
|
* This method is called whenever the divider is dragged. If the JSplitPane
|
|
* is in continuousLayout mode, the divider needs to be moved and the
|
|
* JSplitPane needs to be laid out.
|
|
*
|
|
* @param location The new location of the divider.
|
|
*/
|
|
protected void dragDividerTo(int location)
|
|
{
|
|
location = validLocation(location);
|
|
if (beginDragDividerLocation == -1)
|
|
beginDragDividerLocation = location;
|
|
|
|
if (splitPane.isContinuousLayout())
|
|
splitPane.setDividerLocation(location);
|
|
else
|
|
{
|
|
Point p = nonContinuousLayoutDivider.getLocation();
|
|
if (getOrientation() == JSplitPane.HORIZONTAL_SPLIT)
|
|
p.x = location;
|
|
else
|
|
p.y = location;
|
|
nonContinuousLayoutDivider.setLocation(p);
|
|
}
|
|
setLastDragLocation(location);
|
|
splitPane.repaint();
|
|
}
|
|
|
|
/**
|
|
* This method is called when the dragging is finished.
|
|
*
|
|
* @param location The location where the drag finished.
|
|
*/
|
|
protected void finishDraggingTo(int location)
|
|
{
|
|
if (nonContinuousLayoutDivider != null)
|
|
nonContinuousLayoutDivider.setVisible(false);
|
|
draggingHW = false;
|
|
location = validLocation(location);
|
|
dragDividerTo(location);
|
|
splitPane.setDividerLocation(location);
|
|
splitPane.setLastDividerLocation(beginDragDividerLocation);
|
|
beginDragDividerLocation = -1;
|
|
splitPane.repaint();
|
|
}
|
|
|
|
/**
|
|
* Deprecated. This method returns the width of one of the sides of the
|
|
* divider's border.
|
|
*
|
|
* @return The width of one side of the divider's border.
|
|
*/
|
|
protected int getDividerBorderSize()
|
|
{
|
|
if (getOrientation() == JSplitPane.HORIZONTAL_SPLIT)
|
|
return divider.getBorder().getBorderInsets(divider).left;
|
|
else
|
|
return divider.getBorder().getBorderInsets(divider).top;
|
|
}
|
|
|
|
/**
|
|
* This is a helper method that returns a valid location for the divider
|
|
* when dragging.
|
|
*
|
|
* @param location The location to check.
|
|
*
|
|
* @return A valid location.
|
|
*/
|
|
private int validLocation(int location)
|
|
{
|
|
if (location < getMinimumDividerLocation(splitPane))
|
|
return getMinimumDividerLocation(splitPane);
|
|
if (location > getMaximumDividerLocation(splitPane))
|
|
return getMaximumDividerLocation(splitPane);
|
|
return location;
|
|
}
|
|
}
|