gcc/libjava/javax/swing/plaf/basic/BasicSplitPaneUI.java
Graydon Hoare c5d2de6b4c [multiple changes]
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
2004-05-27 06:17:44 +00:00

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;
}
}