2004-01-22 Graydon Hoare <graydon@redhat.com>
* gnu/java/awt/peer/gtk/GdkClasspathFontPeer.java: * gnu/java/awt/peer/gtk/GdkGlyphVector.java: Predicate static initialization on GtkToolkit.useGraphics2D(). * java/awt/Component.java (processPaintEvent): Consume event. * javax/swing/AbstractButton.java: Reimplement, document. * javax/swing/DefaultButtonModel.java: Reimplement, document. * javax/swing/JComponent.java (paint): Use double buffer. (listenerList): Enable member. * javax/swing/ToggleButtonModel.java: Remove incorrect constructor. * javax/swing/JToggleButton.java (JToggleButton): Modify model constructor. * javax/swing/SwingUtilities.java (layoutCompoundLabel): Adjust arithmetic. * javax/swing/plaf/basic/BasicButtonUI.java: Reimplement, document. * javax/swing/plaf/basic/BasicGraphicsUtils.java (getPreferredButtonSize): Include margins in calculation. * jni/gtk-peer/gnu_java_awt_peer_gtk_GtkWindowPeer.c (Java_gnu_java_awt_peer_gtk_GtkWindowPeer_connectSignals): Receive up events from subordinate layout component. From-SVN: r76344
This commit is contained in:
parent
1fd0507398
commit
ca3bb0c283
|
@ -1,3 +1,25 @@
|
|||
2004-01-22 Graydon Hoare <graydon@redhat.com>
|
||||
|
||||
* gnu/java/awt/peer/gtk/GdkClasspathFontPeer.java:
|
||||
* gnu/java/awt/peer/gtk/GdkGlyphVector.java:
|
||||
Predicate static initialization on GtkToolkit.useGraphics2D().
|
||||
* java/awt/Component.java (processPaintEvent): Consume event.
|
||||
* javax/swing/AbstractButton.java: Reimplement, document.
|
||||
* javax/swing/DefaultButtonModel.java: Reimplement, document.
|
||||
* javax/swing/JComponent.java (paint): Use double buffer.
|
||||
(listenerList): Enable member.
|
||||
* javax/swing/ToggleButtonModel.java: Remove incorrect constructor.
|
||||
* javax/swing/JToggleButton.java
|
||||
(JToggleButton): Modify model constructor.
|
||||
* javax/swing/SwingUtilities.java
|
||||
(layoutCompoundLabel): Adjust arithmetic.
|
||||
* javax/swing/plaf/basic/BasicButtonUI.java: Reimplement, document.
|
||||
* javax/swing/plaf/basic/BasicGraphicsUtils.java
|
||||
(getPreferredButtonSize): Include margins in calculation.
|
||||
* jni/gtk-peer/gnu_java_awt_peer_gtk_GtkWindowPeer.c
|
||||
(Java_gnu_java_awt_peer_gtk_GtkWindowPeer_connectSignals):
|
||||
Receive up events from subordinate layout component.
|
||||
|
||||
2004-01-21 Thomas Fitzsimmons <fitzsim@redhat.com>
|
||||
|
||||
* java/awt/Component.java (show): Set visible to true before
|
||||
|
|
|
@ -70,6 +70,8 @@ public class GdkClasspathFontPeer extends ClasspathFontPeer
|
|||
{
|
||||
System.loadLibrary("gtkpeer");
|
||||
}
|
||||
|
||||
if (GtkToolkit.useGraphics2D ())
|
||||
initStaticState ();
|
||||
}
|
||||
native static void initStaticState ();
|
||||
|
|
|
@ -60,6 +60,8 @@ public class GdkGlyphVector extends GlyphVector
|
|||
{
|
||||
System.loadLibrary("gtkpeer");
|
||||
}
|
||||
|
||||
if (GtkToolkit.useGraphics2D ())
|
||||
initStaticState ();
|
||||
}
|
||||
native static void initStaticState ();
|
||||
|
|
|
@ -4252,6 +4252,7 @@ p * <li>the set of backward traversal keys
|
|||
default:
|
||||
throw new IllegalArgumentException("unknown paint event");
|
||||
}
|
||||
event.consume ();
|
||||
}
|
||||
finally
|
||||
{
|
||||
|
|
File diff suppressed because it is too large
Load Diff
|
@ -1,5 +1,5 @@
|
|||
/* DefaultButtonModel.java --
|
||||
Copyright (C) 2002 Free Software Foundation, Inc.
|
||||
Copyright (C) 2002, 2004 Free Software Foundation, Inc.
|
||||
|
||||
This file is part of GNU Classpath.
|
||||
|
||||
|
@ -35,9 +35,10 @@ 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;
|
||||
|
||||
import java.awt.AWTEvent;
|
||||
import java.awt.AWTEventMulticaster;
|
||||
import java.awt.event.ActionEvent;
|
||||
import java.awt.event.ActionListener;
|
||||
import java.awt.event.ItemEvent;
|
||||
|
@ -49,130 +50,412 @@ import javax.swing.event.ChangeEvent;
|
|||
import javax.swing.event.ChangeListener;
|
||||
import javax.swing.event.EventListenerList;
|
||||
|
||||
public class DefaultButtonModel
|
||||
implements ButtonModel, Serializable
|
||||
/**
|
||||
* The purpose of this class is to model the dynamic state of an abstract
|
||||
* button. The concrete button type holding this state may be a a "toggle"
|
||||
* button (checkbox, radio button) or a "push" button (menu button, button).
|
||||
*
|
||||
* Any change to the model's properties will trigger the firing of a
|
||||
* ChangeEvent.
|
||||
*
|
||||
* Any change to the "pressed" property will trigger the firing of an
|
||||
* ItemEvent in addition to ChangeEvent.
|
||||
*
|
||||
* Any change which causes the enabled, armed and pressed properties to
|
||||
* simultaneously become <code>true</code> will trigger the firing of an
|
||||
* ActionEvent in addition to the ChangeEvent.
|
||||
*
|
||||
* @author Graydon Hoare (graydon&064;redhat.com)
|
||||
*/
|
||||
public class DefaultButtonModel implements ButtonModel, Serializable
|
||||
{
|
||||
static final long serialVersionUID = -5342609566534980231L;
|
||||
|
||||
Vector actions = new Vector();
|
||||
/** Indicates that the button is <em>partially</em> committed to being
|
||||
pressed, but not entirely. This usually happens when a user has pressed
|
||||
but not yet released the mouse button. */
|
||||
static int ARMED = 1;
|
||||
|
||||
Vector items = new Vector();
|
||||
Vector changes = new Vector();
|
||||
/** State constant indicating that the button is enabled. Buttons cannot
|
||||
be pressed or selected unless they are enabled. */
|
||||
static int ENABLED = 2;
|
||||
|
||||
/** State constant indicating that the button has been fully
|
||||
pressed. This usually happens when a user has released the mouse over a
|
||||
previously "armed" button. */
|
||||
static int PRESSED = 4;
|
||||
|
||||
/** State constant indicating that the mouse is currently positioned over
|
||||
the button. */
|
||||
static int ROLLOVER = 8;
|
||||
|
||||
/** State constant indicating that the button is selected. This constant
|
||||
is only meaningful for toggle-type buttons (radio buttons,
|
||||
checkboxes). */
|
||||
static int SELECTED = 16;
|
||||
|
||||
/** Represents the "state properties" (armed, enabled, pressed, rollover
|
||||
and selected) by a bitwise combination of integer constants. */
|
||||
int stateMask;
|
||||
|
||||
/** List of ItemListeners, ChangeListeners, and ActionListeners
|
||||
registered on this model. */
|
||||
EventListenerList listenerList;
|
||||
|
||||
/** The single ChangeEvent this model (re)uses to call its
|
||||
ChangeListeners. */
|
||||
ChangeEvent changeEvent;
|
||||
|
||||
/** The group this model belongs to. Only one button in a group may be
|
||||
selected at any given time. */
|
||||
ButtonGroup group;
|
||||
JComponent comp;
|
||||
|
||||
|
||||
DefaultButtonModel(JComponent a)
|
||||
{
|
||||
comp = a;
|
||||
}
|
||||
/** The key code (one of {@link java.awt.event.KeyEvent} VK_*) used to
|
||||
press this button via a keyboard interface. */
|
||||
int mnemonic;
|
||||
|
||||
/** The string used as the "command" property of any ActionEvent this
|
||||
model sends. */
|
||||
String actionCommand;
|
||||
|
||||
public DefaultButtonModel()
|
||||
{
|
||||
stateMask = 0;
|
||||
listenerList = new EventListenerList();
|
||||
changeEvent = new ChangeEvent(this);
|
||||
}
|
||||
|
||||
/**
|
||||
* Return <code>null</code>. Use {@link AbstractButton} if you wish to
|
||||
* interface with a button via an {@link ItemSelectable} interface.
|
||||
*
|
||||
* @return <code>null</code>
|
||||
*/
|
||||
public Object[] getSelectedObjects()
|
||||
{
|
||||
return null;
|
||||
}
|
||||
|
||||
|
||||
public void fireItemStateChanged(ItemEvent event)
|
||||
{
|
||||
for (int i=0;i<items.size();i++)
|
||||
/**
|
||||
* Add an ActionListener to the model. Usually only called to subscribe
|
||||
* an AbstractButton's listener to the model.
|
||||
*
|
||||
* @param l The listener to add
|
||||
*/
|
||||
public void addActionListener(ActionListener l)
|
||||
{
|
||||
ItemListener a = (ItemListener) items.get(i);
|
||||
a.itemStateChanged(event);
|
||||
}
|
||||
listenerList.add(ActionListener.class, l);
|
||||
}
|
||||
public void fireStateChanged(ChangeEvent event)
|
||||
|
||||
/**
|
||||
* Remove an ActionListener to the model. Usually only called to
|
||||
* unsubscribe an AbstractButton's listener to the model.
|
||||
*
|
||||
* @param l The listener to remove
|
||||
*/
|
||||
public void removeActionListener(ActionListener l)
|
||||
{
|
||||
listenerList.remove(ActionListener.class, l);
|
||||
}
|
||||
|
||||
/**
|
||||
* Add an ItemListener to the model. Usually only called to subscribe
|
||||
* an AbstractButton's listener to the model.
|
||||
*
|
||||
* @param l The listener to add
|
||||
*/
|
||||
public void addItemListener(ItemListener l)
|
||||
{
|
||||
listenerList.add(ItemListener.class, l);
|
||||
}
|
||||
|
||||
/**
|
||||
* Remove an ItemListener to the model. Usually only called to
|
||||
* unsubscribe an AbstractButton's listener to the model.
|
||||
*
|
||||
* @param l The listener to remove
|
||||
*/
|
||||
public void removeItemListener(ItemListener l)
|
||||
{
|
||||
listenerList.remove(ItemListener.class, l);
|
||||
}
|
||||
|
||||
/**
|
||||
* Add a ChangeListener to the model. Usually only called to subscribe
|
||||
* an AbstractButton's listener to the model.
|
||||
*
|
||||
* @param l The listener to add
|
||||
*/
|
||||
public void addChangeListener(ChangeListener l)
|
||||
{
|
||||
listenerList.add(ChangeListener.class, l);
|
||||
}
|
||||
|
||||
/**
|
||||
* Remove a ChangeListener to the model. Usually only called to
|
||||
* unsubscribe an AbstractButton's listener to the model.
|
||||
*
|
||||
* @param l The listener to remove
|
||||
*/
|
||||
public void removeChangeListener(ChangeListener l)
|
||||
{
|
||||
listenerList.remove(ChangeListener.class, l);
|
||||
}
|
||||
|
||||
/**
|
||||
* Inform each ItemListener in the {@link listenerList} that an ItemEvent
|
||||
* has occurred. This happens in response to any change to the {@link
|
||||
* stateMask} field.
|
||||
*
|
||||
* @param e The ItemEvent to fire
|
||||
*/
|
||||
public void fireItemStateChanged(ItemEvent e)
|
||||
{
|
||||
EventListener[] ll = listenerList.getListeners(ItemListener.class);
|
||||
for (int i = 0; i < ll.length; i++)
|
||||
((ItemListener)ll[i]).itemStateChanged(e);
|
||||
}
|
||||
|
||||
/**
|
||||
* Inform each ActionListener in the {@link listenerList} that an
|
||||
* ActionEvent has occurred. This happens in response to the any change
|
||||
* to the {@link stateMask} field which makes the enabled, armed and
|
||||
* pressed properties all simultaneously <code>true</code>.
|
||||
*
|
||||
* @param e The ActionEvent to fire
|
||||
*/
|
||||
public void fireActionPerformed(ActionEvent e)
|
||||
{
|
||||
EventListener[] ll = listenerList.getListeners(ActionListener.class);
|
||||
for (int i = 0; i < ll.length; i++)
|
||||
((ActionListener)ll[i]).actionPerformed(e);
|
||||
}
|
||||
|
||||
/**
|
||||
* Inform each ChangeListener in the {@link listenerList} that a
|
||||
* ChangeEvent has occurred. This happens in response to the any change
|
||||
* to a property of the model.
|
||||
*
|
||||
* @param event The ChangeEvent to fire
|
||||
*/
|
||||
public void fireStateChanged(ChangeEvent e)
|
||||
{
|
||||
EventListener[] ll = listenerList.getListeners(ChangeListener.class);
|
||||
for (int i = 0; i < ll.length; i++)
|
||||
((ChangeListener)ll[i]).stateChanged(e);
|
||||
}
|
||||
|
||||
/**
|
||||
* Helper method to fire a ChangeEvent with the model as the event's
|
||||
* source.
|
||||
*/
|
||||
protected void changeState(int stateflag, boolean b)
|
||||
{
|
||||
for (int i=0;i<changes.size();i++)
|
||||
int oldstate = stateMask;
|
||||
int newstate;
|
||||
|
||||
if (b)
|
||||
newstate = oldstate | stateflag;
|
||||
else
|
||||
newstate = oldstate & ~stateflag;
|
||||
|
||||
if (oldstate == newstate)
|
||||
return;
|
||||
|
||||
stateMask = newstate;
|
||||
|
||||
fireStateChanged(changeEvent);
|
||||
|
||||
if ((newstate & ENABLED) == 0)
|
||||
return;
|
||||
|
||||
if ((oldstate & SELECTED) == 0
|
||||
&& (newstate & SELECTED) == SELECTED)
|
||||
fireItemStateChanged(new ItemEvent(this, ItemEvent.ITEM_STATE_CHANGED,
|
||||
null, ItemEvent.SELECTED));
|
||||
|
||||
else if ((oldstate & SELECTED) == SELECTED
|
||||
&& (newstate & SELECTED) == 0)
|
||||
fireItemStateChanged(new ItemEvent(this, ItemEvent.ITEM_STATE_CHANGED,
|
||||
null, ItemEvent.DESELECTED));
|
||||
|
||||
else if ((newstate & ARMED) == ARMED
|
||||
&& (newstate & PRESSED) == PRESSED)
|
||||
{
|
||||
ChangeListener a = (ChangeListener) changes.get(i);
|
||||
a.stateChanged(event);
|
||||
fireActionPerformed(new ActionEvent(this, ActionEvent.ACTION_PERFORMED,
|
||||
actionCommand));
|
||||
stateMask = stateMask & ~(PRESSED | ARMED);
|
||||
}
|
||||
|
||||
}
|
||||
public void fireActionPerformed(ActionEvent event)
|
||||
{
|
||||
for (int i=0;i<actions.size();i++)
|
||||
|
||||
/**
|
||||
* Get the value of the model's "armed" property.
|
||||
*
|
||||
* @return The current "armed" property
|
||||
*/
|
||||
public boolean isArmed()
|
||||
{
|
||||
ActionListener a = (ActionListener) actions.get(i);
|
||||
a.actionPerformed(event);
|
||||
}
|
||||
return (stateMask & ARMED) == ARMED;
|
||||
}
|
||||
|
||||
boolean arm;
|
||||
public boolean isArmed() { return arm; }
|
||||
public void setArmed(boolean b) { arm = b; }
|
||||
/**
|
||||
* Set the value of the model's "armed" property.
|
||||
*
|
||||
* @param a The new "armed" property
|
||||
*/
|
||||
public void setArmed(boolean a)
|
||||
{
|
||||
changeState(ARMED, a);
|
||||
}
|
||||
|
||||
boolean enabled = true;
|
||||
public boolean isEnabled() { return enabled; }
|
||||
public void setEnabled(boolean b) { enabled = b; }
|
||||
|
||||
boolean pressed;
|
||||
public void setPressed(boolean b)
|
||||
/**
|
||||
* Get the value of the model's "enabled" property.
|
||||
*
|
||||
* @return The current "enabled" property.
|
||||
*/
|
||||
public boolean isEnabled()
|
||||
{
|
||||
pressed = b;
|
||||
return (stateMask & ENABLED) == ENABLED;
|
||||
}
|
||||
public boolean isPressed() { return pressed; }
|
||||
|
||||
/**
|
||||
* Set the value of the model's "enabled" property.
|
||||
*
|
||||
* @param e The new "enabled" property
|
||||
*/
|
||||
public void setEnabled(boolean e)
|
||||
{
|
||||
changeState(ENABLED, e);
|
||||
}
|
||||
|
||||
public void removeActionListener(ActionListener l) { actions.removeElement(l); }
|
||||
public void addActionListener(ActionListener l)
|
||||
/**
|
||||
* Set the value of the model's "pressed" property.
|
||||
*
|
||||
* @param p The new "pressed" property
|
||||
*/
|
||||
public void setPressed(boolean p)
|
||||
{
|
||||
// comp.enableEvents( AWTEvent.ACTION_EVENT_MASK );
|
||||
actions.addElement(l);
|
||||
changeState(PRESSED, p);
|
||||
}
|
||||
|
||||
public void addItemListener(ItemListener l) { items.addElement(l); }
|
||||
public void removeItemListener(ItemListener l) { items.removeElement(l); }
|
||||
/**
|
||||
* Get the value of the model's "pressed" property.
|
||||
*
|
||||
* @return The current "pressed" property
|
||||
*/
|
||||
public boolean isPressed()
|
||||
{
|
||||
return (stateMask & PRESSED) == PRESSED;
|
||||
}
|
||||
|
||||
public void addChangeListener(ChangeListener l) { changes.addElement(l); }
|
||||
public void removeChangeListener(ChangeListener l) { changes.removeElement(l); }
|
||||
/**
|
||||
* Set the value of the model's "rollover" property.
|
||||
*
|
||||
* @param r The new "rollover" property
|
||||
*/
|
||||
public void setRollover(boolean r)
|
||||
{
|
||||
changeState(ROLLOVER, r);
|
||||
}
|
||||
|
||||
boolean roll;
|
||||
public void setRollover(boolean b) { roll = b; }
|
||||
public boolean isRollover() { return roll; }
|
||||
|
||||
int mne;
|
||||
public int getMnemonic() { return mne; }
|
||||
public void setMnemonic(int key) { mne = key; }
|
||||
/**
|
||||
* Set the value of the model's "selected" property.
|
||||
*
|
||||
* @param s The new "selected" property
|
||||
*/
|
||||
public void setSelected(boolean s)
|
||||
{
|
||||
changeState(SELECTED, s);
|
||||
}
|
||||
|
||||
String com;
|
||||
public void setActionCommand(String s) { com = s; }
|
||||
public String getActionCommand() { return com; }
|
||||
/**
|
||||
* Get the value of the model's "selected" property.
|
||||
*
|
||||
* @return The current "selected" property
|
||||
*/
|
||||
public boolean isSelected()
|
||||
{
|
||||
return (stateMask & SELECTED) == SELECTED;
|
||||
}
|
||||
|
||||
public void setGroup(ButtonGroup group)
|
||||
/**
|
||||
* Get the value of the model's "rollover" property.
|
||||
*
|
||||
* @return The current "rollover" property
|
||||
*/
|
||||
public boolean isRollover()
|
||||
{
|
||||
this.group = group;
|
||||
return (stateMask & ROLLOVER) == ROLLOVER;
|
||||
}
|
||||
|
||||
boolean sel;
|
||||
public void setSelected(boolean b)
|
||||
/**
|
||||
* Get the value of the model's "mnemonic" property.
|
||||
*
|
||||
* @return The current "mnemonic" property
|
||||
*/
|
||||
public int getMnemonic()
|
||||
{
|
||||
if (group != null)
|
||||
return mnemonic;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set the value of the model's "mnemonic" property.
|
||||
*
|
||||
* @param key The new "mnemonic" property
|
||||
*/
|
||||
public void setMnemonic(int key)
|
||||
{
|
||||
if (b == true)
|
||||
if (mnemonic != key)
|
||||
{
|
||||
System.out.println("selected button in group:"+this);
|
||||
group.setSelected(this, b);
|
||||
sel = true;
|
||||
mnemonic = key;
|
||||
fireStateChanged(changeEvent);
|
||||
}
|
||||
else
|
||||
}
|
||||
|
||||
/**
|
||||
* Set the value of the model's "actionCommand" property. This property
|
||||
* is used as the "command" property of the {@link ActionEvent} fired
|
||||
* from the model.
|
||||
*
|
||||
* @param s The new "actionCommand" property.
|
||||
*/
|
||||
public void setActionCommand(String s)
|
||||
{
|
||||
System.out.println("deselected button in group: " + this);
|
||||
sel = false;
|
||||
if (actionCommand != s)
|
||||
{
|
||||
actionCommand = s;
|
||||
fireStateChanged(changeEvent);
|
||||
}
|
||||
}
|
||||
else
|
||||
|
||||
/**
|
||||
* Set the value of the model's "actionCommand" property. This property
|
||||
* is used as the "command" property of the {@link ActionEvent} fired
|
||||
* from the model.
|
||||
*
|
||||
* @return The current "actionCommand" property
|
||||
*/
|
||||
public String getActionCommand()
|
||||
{
|
||||
sel = b;
|
||||
return actionCommand;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set the value of the model's "group" property. The model is said to be
|
||||
* a member of the {@link ButtonGroup} held in its "group" property, and
|
||||
* only one models in a given group can have their "selected" property be
|
||||
* <code>true</code> at a time.
|
||||
*
|
||||
* @param g The new "group" property
|
||||
*/
|
||||
public void setGroup(ButtonGroup g)
|
||||
{
|
||||
if (group != g)
|
||||
{
|
||||
group = g;
|
||||
fireStateChanged(changeEvent);
|
||||
}
|
||||
}
|
||||
public boolean isSelected() { return sel; }
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
|
|
@ -46,6 +46,7 @@ import java.awt.Dimension;
|
|||
import java.awt.FlowLayout;
|
||||
import java.awt.Font;
|
||||
import java.awt.Graphics;
|
||||
import java.awt.Image;
|
||||
import java.awt.Insets;
|
||||
import java.awt.Point;
|
||||
import java.awt.Rectangle;
|
||||
|
@ -56,6 +57,7 @@ import java.awt.event.FocusEvent;
|
|||
import java.awt.event.FocusListener;
|
||||
import java.awt.event.KeyEvent;
|
||||
import java.awt.event.MouseEvent;
|
||||
import java.awt.image.ImageObserver;
|
||||
import java.awt.peer.LightweightPeer;
|
||||
import java.beans.PropertyChangeListener;
|
||||
import java.beans.PropertyVetoException;
|
||||
|
@ -271,13 +273,16 @@ public abstract class JComponent extends Container implements Serializable
|
|||
super();
|
||||
super.setLayout(new FlowLayout());
|
||||
|
||||
listenerList = new EventListenerList();
|
||||
|
||||
//eventMask |= AWTEvent.COMP_KEY_EVENT_MASK;
|
||||
enableEvents( AWTEvent.KEY_EVENT_MASK );
|
||||
// enableEvents( AWTEvent.KEY_EVENT_MASK );
|
||||
|
||||
//updateUI(); // get a proper ui
|
||||
}
|
||||
|
||||
// protected EventListenerList listenerList
|
||||
protected EventListenerList listenerList;
|
||||
|
||||
public boolean contains(int x, int y)
|
||||
{
|
||||
//return dims.contains(x,y);
|
||||
|
@ -701,11 +706,29 @@ public abstract class JComponent extends Container implements Serializable
|
|||
|
||||
public void paint(Graphics g)
|
||||
{
|
||||
// System.out.println("SWING_PAINT:" + this);
|
||||
Graphics g2 = g;
|
||||
Image im = null;
|
||||
Rectangle r = getBounds ();
|
||||
// System.err.println(this + ".paint(...), bounds = " + r);
|
||||
|
||||
if (use_double_buffer)
|
||||
{
|
||||
im = createImage (r.width, r.height);
|
||||
g2 = im.getGraphics ();
|
||||
g2.clearRect (0, 0, r.width, r.height);
|
||||
}
|
||||
|
||||
paintBorder(g2);
|
||||
paintComponent(g2);
|
||||
paintChildren(g2);
|
||||
|
||||
paintBorder(g);
|
||||
paintComponent(g);
|
||||
paintChildren(g);
|
||||
if (use_double_buffer)
|
||||
{
|
||||
// always draw at 0,0, because regardless of your current bounds,
|
||||
// the graphics object you were passed was positioned so the origin
|
||||
// was at the upper left corner of your bounds.
|
||||
g.drawImage (im, 0, 0, (ImageObserver)null);
|
||||
}
|
||||
}
|
||||
|
||||
protected void paintBorder(Graphics g)
|
||||
|
@ -729,7 +752,7 @@ public abstract class JComponent extends Container implements Serializable
|
|||
protected void paintChildren(Graphics g)
|
||||
{
|
||||
// Paint this component's children.
|
||||
//super.paintChildren(g);
|
||||
super.paint(g);
|
||||
}
|
||||
|
||||
protected void paintComponent(Graphics g)
|
||||
|
|
|
@ -74,7 +74,7 @@ public class JToggleButton extends AbstractButton implements Accessible
|
|||
super(text, icon);
|
||||
|
||||
// Create the model
|
||||
setModel(new ToggleButtonModel(this));
|
||||
setModel(new ToggleButtonModel());
|
||||
|
||||
model.setSelected(selected);
|
||||
}
|
||||
|
|
|
@ -97,8 +97,8 @@ public class SwingUtilities implements SwingConstants
|
|||
// view rect 'vr' already ok,
|
||||
// we need to compute ir (icon rect) and tr (text-rect)
|
||||
|
||||
int next_x = 0;//vr.x;
|
||||
int next_y = 0;//vr.y;
|
||||
int next_x = vr.x;
|
||||
int next_y = vr.y;
|
||||
|
||||
ir.height = ir.width = ir.y = ir.x = 0;
|
||||
|
||||
|
@ -115,10 +115,10 @@ public class SwingUtilities implements SwingConstants
|
|||
}
|
||||
|
||||
tr.x = next_x;
|
||||
tr.y = vr.y + (vr.height/2);
|
||||
tr.y = vr.y; // + (vr.height/2);
|
||||
|
||||
tr.width = fm.stringWidth(text);
|
||||
tr.height = fm.getHeight() + fm.getAscent()/2;
|
||||
tr.height = fm.getHeight(); // + fm.getAscent()/2;
|
||||
|
||||
return text;
|
||||
}
|
||||
|
|
|
@ -40,11 +40,6 @@ package javax.swing;
|
|||
|
||||
public class ToggleButtonModel extends DefaultButtonModel
|
||||
{
|
||||
ToggleButtonModel(JComponent c)
|
||||
{
|
||||
super(c);
|
||||
}
|
||||
|
||||
public void setPressed(boolean b)
|
||||
{
|
||||
if (! isEnabled())
|
||||
|
|
|
@ -35,16 +35,23 @@ 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.BasicStroke;
|
||||
import java.awt.Color;
|
||||
import java.awt.Dimension;
|
||||
import java.awt.Font;
|
||||
import java.awt.FontMetrics;
|
||||
import java.awt.Graphics;
|
||||
import java.awt.Graphics2D;
|
||||
import java.awt.Stroke;
|
||||
import java.awt.Insets;
|
||||
import java.awt.Rectangle;
|
||||
import java.awt.event.FocusAdapter;
|
||||
import java.awt.event.FocusEvent;
|
||||
import java.awt.event.InputEvent;
|
||||
import java.awt.event.MouseAdapter;
|
||||
import java.awt.event.MouseEvent;
|
||||
import javax.swing.AbstractButton;
|
||||
import javax.swing.JComponent;
|
||||
import javax.swing.SwingUtilities;
|
||||
|
@ -53,20 +60,161 @@ import javax.swing.plaf.ComponentUI;
|
|||
|
||||
public class BasicButtonUI extends ButtonUI
|
||||
{
|
||||
/** A constant used to pad out elements in the button's layout and
|
||||
preferred size calculations. */
|
||||
int gap = 3;
|
||||
// int y_text_space = 2, x_text_space + 5;
|
||||
|
||||
Color textColor, disabledTextColor;
|
||||
/** The color that text will be painted when the button is enabled */
|
||||
Color textColor;
|
||||
|
||||
/** The color that text will be painted when the button is disabled */
|
||||
Color disabledTextColor;
|
||||
|
||||
/** The color that the button's background will be painted when the
|
||||
button is pressed. */
|
||||
Color pressedBackgroundColor;
|
||||
Color normalBackgroundColor;
|
||||
|
||||
/** The color that the button's background will be painted when the
|
||||
button is not pressed. */
|
||||
Color normalBackgroundColor;
|
||||
|
||||
/**
|
||||
* Factory method to create an instance of BasicButtonUI for a given
|
||||
* {@link JComponent}, which should be an {@link AbstractButton}.
|
||||
*
|
||||
* @param c The component to create a UI got
|
||||
*
|
||||
* @return A new UI capable of drawing the component
|
||||
*/
|
||||
public static ComponentUI createUI(final JComponent c)
|
||||
{
|
||||
return new BasicButtonUI();
|
||||
}
|
||||
|
||||
/**
|
||||
* Helper class which listens to a button's focus events and disarms the
|
||||
* button's model when focus is lost.
|
||||
*/
|
||||
private static class FocusUIListener extends FocusAdapter
|
||||
{
|
||||
/** Button to listen to focus events from */
|
||||
AbstractButton button;
|
||||
|
||||
/**
|
||||
* Creates a new FocusUIListener object.
|
||||
*
|
||||
* @param b The button to listen to
|
||||
*/
|
||||
FocusUIListener(AbstractButton b)
|
||||
{
|
||||
button = b;
|
||||
}
|
||||
|
||||
/**
|
||||
* Called when the button loses focus.
|
||||
*
|
||||
* @param event The loss of focus event.
|
||||
*/
|
||||
public void focusLost(FocusEvent event)
|
||||
{
|
||||
// System.err.println("ButtonUI :: lost focus -- disarming");
|
||||
button.getModel().setArmed(false);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* A helper class which interprets mouse events as
|
||||
* state changes to the button's underlying model.
|
||||
*/
|
||||
private static class ButtonUIListener extends MouseAdapter
|
||||
{
|
||||
/** The button to change the model of */
|
||||
AbstractButton button;
|
||||
|
||||
/**
|
||||
* Creates a new ButtonUIListener object.
|
||||
*
|
||||
* @param b The button to change the model of
|
||||
*/
|
||||
public ButtonUIListener(AbstractButton b)
|
||||
{
|
||||
button = b;
|
||||
}
|
||||
|
||||
/**
|
||||
* Accept a mouse press event and arm the button's model.
|
||||
*
|
||||
* @param e The mouse press event to accept
|
||||
*/
|
||||
public void mousePressed(MouseEvent e)
|
||||
{
|
||||
// System.err.println("ButtonUI :: mouse pressed");
|
||||
if ((e.getModifiers() & InputEvent.BUTTON1_MASK) != 0)
|
||||
{
|
||||
// System.err.println("ButtonUI :: arming");
|
||||
button.getModel().setArmed(true);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Accept a mouse enter event and set the button's model's
|
||||
* "rollover" property to <code>true</code>. If the button's
|
||||
* model is currently armed and the mouse button is not held
|
||||
* down, this enter event will also disarm the model.
|
||||
*
|
||||
* @param e The mouse enter event to accept
|
||||
*/
|
||||
public void mouseEntered(MouseEvent e)
|
||||
{
|
||||
// System.err.println("ButtonUI :: mouse entered");
|
||||
// System.err.println("ButtonUI :: rolling over");
|
||||
button.getModel().setRollover(true);
|
||||
if (button.getModel().isArmed()
|
||||
&& (e.getModifiers() & InputEvent.BUTTON1_MASK) == 0)
|
||||
{
|
||||
// System.err.println("ButtonUI :: no button pressed -- disarming");
|
||||
button.getModel().setArmed(false);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Accept a mouse exit event and set the button's model's
|
||||
* "rollover" property to <code>false</code>.
|
||||
*
|
||||
* @param e The mouse exit event to accept
|
||||
*/
|
||||
public void mouseExited(MouseEvent e)
|
||||
{
|
||||
// System.err.println("ButtonUI :: mouse exited");
|
||||
button.getModel().setRollover(false);
|
||||
}
|
||||
|
||||
/**
|
||||
* Accept a mouse release event and set the button's model's
|
||||
* "pressed" property to <code>true</code>, if the model
|
||||
* is armed. If the model is not armed, ignore the event.
|
||||
*
|
||||
* @param e The mouse release event to accept
|
||||
*/
|
||||
public void mouseReleased(MouseEvent e)
|
||||
{
|
||||
// System.err.println("ButtonUI :: mouse released");
|
||||
if (button.getModel().isArmed()
|
||||
&& (e.getModifiers() & InputEvent.BUTTON1_MASK) != 0)
|
||||
{
|
||||
button.getModel().setPressed(true);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Install the BasicButtonUI as the UI for a particular component.
|
||||
* This means registering all the UI's listeners with the component,
|
||||
* and setting any properties of the button which are particular to
|
||||
* this look and feel.
|
||||
*
|
||||
* @param c The component to install the UI into
|
||||
*/
|
||||
public void installUI(final JComponent c)
|
||||
{
|
||||
super.installUI(c);
|
||||
|
@ -76,18 +224,37 @@ public class BasicButtonUI extends ButtonUI
|
|||
pressedBackgroundColor = new Color(150,150,150);
|
||||
pressedBackgroundColor = new Color(150,150,150);
|
||||
normalBackgroundColor = new Color(192,192,192);
|
||||
}
|
||||
|
||||
|
||||
// this tells the border (if we have one) how to paint.
|
||||
c.setBackground(normalBackgroundColor);
|
||||
((AbstractButton)c).setMargin (new Insets(10,10,10,10));
|
||||
|
||||
c.addMouseListener(new ButtonUIListener((AbstractButton) c));
|
||||
c.addFocusListener(new FocusUIListener((AbstractButton) c));
|
||||
}
|
||||
|
||||
/**
|
||||
* Calculate the preferred size of this component, by delegating to
|
||||
* {@link BasicGraphicsUtils.getPreferredButtonSize}.
|
||||
*
|
||||
* @param c The component to measure
|
||||
*
|
||||
* @return The preferred dimensions of the component
|
||||
*/
|
||||
public Dimension getPreferredSize(JComponent c)
|
||||
{
|
||||
AbstractButton b = (AbstractButton)c;
|
||||
Dimension d = BasicGraphicsUtils.getPreferredButtonSize(b, gap);
|
||||
// System.out.println("^^^^^^^^^^^^^^^^^^^^^^ BASIC-PREF="+d + ",T="+b.text);
|
||||
return d;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Paint the component, which is an {@link AbstractButton}, according to
|
||||
* its current state.
|
||||
*
|
||||
* @param g The graphics context to paint with
|
||||
* @param c The component to paint the state of
|
||||
*/
|
||||
public void paint(Graphics g, JComponent c)
|
||||
{
|
||||
AbstractButton b = (AbstractButton) c;
|
||||
|
@ -95,6 +262,7 @@ public class BasicButtonUI extends ButtonUI
|
|||
Rectangle tr = new Rectangle();
|
||||
Rectangle ir = new Rectangle();
|
||||
Rectangle vr = new Rectangle();
|
||||
Rectangle br = new Rectangle();
|
||||
|
||||
Font f = c.getFont();
|
||||
|
||||
|
@ -102,115 +270,150 @@ public class BasicButtonUI extends ButtonUI
|
|||
|
||||
FontMetrics fm = g.getFontMetrics(f);
|
||||
|
||||
Insets i = c.getInsets();
|
||||
Insets border = b.getInsets();
|
||||
Insets margin = b.getMargin();
|
||||
|
||||
vr.x = i.left;
|
||||
vr.y = i.top;
|
||||
vr.width = b.getWidth() - (i.right + vr.x);
|
||||
vr.height = b.getHeight() - (i.bottom + vr.y);
|
||||
|
||||
//System.out.println(" VIEW-RECT-BUTTON="+vr+", insets="+i+", FONTM="+fm);
|
||||
|
||||
String text = SwingUtilities.layoutCompoundLabel(c,
|
||||
fm,
|
||||
b.getText(),
|
||||
br.x = border.left;
|
||||
br.y = border.top;
|
||||
br.width = b.getWidth() - (border.right + border.left);
|
||||
br.height = b.getHeight() - (border.top + border.bottom);
|
||||
|
||||
vr.x = br.x + margin.left;
|
||||
vr.y = br.y + margin.top;
|
||||
vr.width = br.width - (margin.right + margin.left);
|
||||
vr.height = br.height - (margin.top + margin.bottom);
|
||||
|
||||
String text = SwingUtilities.layoutCompoundLabel(c, fm, b.getText(),
|
||||
b.getIcon(),
|
||||
b.getVerticalAlignment(),
|
||||
b.getHorizontalAlignment(),
|
||||
b.getVerticalTextPosition(),
|
||||
b.getHorizontalTextPosition(),
|
||||
vr,
|
||||
ir,
|
||||
tr,
|
||||
gap);
|
||||
vr, ir, tr, gap);
|
||||
|
||||
if (b.getModel().isPressed() ||
|
||||
b.getModel().isSelected())
|
||||
{
|
||||
//System.out.println("paint pressed");
|
||||
paintButtonPressed(g, c);
|
||||
}
|
||||
if ((b.getModel().isRollover() && b.getModel().isArmed())
|
||||
|| b.getModel().isSelected())
|
||||
paintButtonPressed(g, br, c);
|
||||
else
|
||||
{
|
||||
//System.out.println("paint normal");
|
||||
paintButtonNormal(g, c);
|
||||
}
|
||||
paintButtonNormal(g, br, c);
|
||||
|
||||
paintIcon(g, c, ir);
|
||||
paintText(g, c, tr, b.getText());
|
||||
paintFocus(g, c, vr, tr, ir);
|
||||
}
|
||||
|
||||
|
||||
protected void paintFocus(Graphics g,
|
||||
JComponent c,
|
||||
Rectangle vr,
|
||||
Rectangle tr,
|
||||
Rectangle ir)
|
||||
/**
|
||||
* Paint any focus decoration this {@link JComponent} might have. The
|
||||
* component, which in this case will be an {@link AbstractButton},
|
||||
* should only have focus decoration painted if it has the focus, and its
|
||||
* "focusPainted" property is <code>true</code>.
|
||||
*
|
||||
* @param g Graphics context to paint with
|
||||
* @param c Component to paint the focus of
|
||||
* @param vr Visible rectangle, the area in which to paint
|
||||
* @param tr Text rectangle, contained in visible rectangle
|
||||
* @param ir Icon rectangle, contained in visible rectangle
|
||||
*
|
||||
* @see AbstractButton.isFocusPainted()
|
||||
* @see JComponent.hasFocus()
|
||||
*/
|
||||
protected void paintFocus(Graphics g, JComponent c, Rectangle vr,
|
||||
Rectangle tr, Rectangle ir)
|
||||
{
|
||||
AbstractButton b = (AbstractButton) c;
|
||||
if (b.hasFocus() && b.isFocusPainted())
|
||||
{
|
||||
Graphics2D g2 = (Graphics2D) g;
|
||||
Stroke saved_stroke = g2.getStroke();
|
||||
Color saved_color = g2.getColor();
|
||||
float dashes[] = new float[] {1.0f, 1.0f};
|
||||
BasicStroke s = new BasicStroke(1.0f,
|
||||
BasicStroke.CAP_SQUARE,
|
||||
BasicStroke.JOIN_MITER,
|
||||
10, dashes, 0.0f);
|
||||
g2.setStroke(s);
|
||||
g2.setColor(Color.BLACK);
|
||||
g2.drawRect(vr.x + 2,
|
||||
vr.y + 2,
|
||||
vr.width - 4,
|
||||
vr.height - 4);
|
||||
g2.setStroke(saved_stroke);
|
||||
g2.setColor(saved_color);
|
||||
}
|
||||
}
|
||||
|
||||
protected void paintIcon(Graphics g,
|
||||
JComponent c,
|
||||
Rectangle iconRect)
|
||||
/**
|
||||
* Paint the icon for this component. Depending on the state of the
|
||||
* component and the availability of the button's various icon
|
||||
* properties, this might mean painting one of several different icons.
|
||||
*
|
||||
* @param g Graphics context to paint with
|
||||
* @param c Component to paint the icon of
|
||||
* @param iconRect Rectangle in which the icon should be painted
|
||||
*/
|
||||
protected void paintIcon(Graphics g, JComponent c, Rectangle iconRect)
|
||||
{
|
||||
AbstractButton b = (AbstractButton) c;
|
||||
if (b.getIcon() != null)
|
||||
{
|
||||
int x = iconRect.x;
|
||||
int y = iconRect.y;
|
||||
|
||||
System.out.println("WE HAVE AN ICON: " + b.getIcon());
|
||||
|
||||
b.getIcon().paintIcon(c, g, x, y);
|
||||
}
|
||||
else
|
||||
{
|
||||
//System.out.println("NO ICON FOR BUTTON:" + b.text);
|
||||
}
|
||||
}
|
||||
|
||||
protected void paintButtonPressed(Graphics g,
|
||||
JComponent b)
|
||||
/**
|
||||
* Paints the background area of an {@link AbstractButton} in the pressed
|
||||
* state. This means filling the supplied area with the {@link
|
||||
* pressedBackgroundColor}.
|
||||
*
|
||||
* @param g The graphics context to paint with
|
||||
* @param area The area in which to paint
|
||||
* @param b The component to paint the state of
|
||||
*/
|
||||
protected void paintButtonPressed(Graphics g, Rectangle area, JComponent b)
|
||||
{
|
||||
Dimension size = b.getSize();
|
||||
|
||||
g.setColor(pressedBackgroundColor);
|
||||
g.fillRect(1,1,size.width-2, size.height-2);
|
||||
|
||||
g.fillRect(area.x, area.y, area.width, area.height);
|
||||
}
|
||||
|
||||
protected void paintButtonNormal(Graphics g,
|
||||
JComponent b)
|
||||
/**
|
||||
* Paints the background area of an {@link AbstractButton} in the normal,
|
||||
* non-pressed state. This means filling the supplied area with the
|
||||
* {@link normalBackgroundColor}.
|
||||
*
|
||||
* @param g The graphics context to paint with
|
||||
* @param area The area in which to paint
|
||||
* @param b The component to paint the state of
|
||||
*/
|
||||
protected void paintButtonNormal(Graphics g, Rectangle area, JComponent b)
|
||||
{
|
||||
Dimension size = b.getSize();
|
||||
|
||||
g.setColor(normalBackgroundColor);
|
||||
g.fillRect(1,1,size.width-2, size.height-2);
|
||||
|
||||
g.fillRect(area.x, area.y, area.width, area.height);
|
||||
}
|
||||
|
||||
protected void paintText(Graphics g,
|
||||
JComponent c,
|
||||
Rectangle textRect,
|
||||
/**
|
||||
* Paints the "text" property of an {@link AbstractButton}, using the
|
||||
* {@link textColor} color.
|
||||
*
|
||||
* @param g The graphics context to paint with
|
||||
* @param c The component to paint the state of
|
||||
* @param textRect The area in which to paint the text
|
||||
* @param text The text to paint
|
||||
*/
|
||||
protected void paintText(Graphics g, JComponent c, Rectangle textRect,
|
||||
String text)
|
||||
{
|
||||
Font f = c.getFont();
|
||||
|
||||
g.setFont(f);
|
||||
|
||||
FontMetrics fm = g.getFontMetrics(f);
|
||||
|
||||
g.setColor(c.isEnabled() ? textColor : disabledTextColor);
|
||||
|
||||
BasicGraphicsUtils.drawString(g,
|
||||
text,
|
||||
BasicGraphicsUtils.drawString(g, text,
|
||||
0,
|
||||
textRect.x,
|
||||
textRect.y + fm.getAscent()/2);
|
||||
textRect.y + fm.getAscent());
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
|
|
@ -595,6 +595,7 @@ public class BasicGraphicsUtils
|
|||
Rectangle iconRect = new Rectangle();
|
||||
Rectangle textRect = new Rectangle();
|
||||
Insets insets = b.getInsets();
|
||||
Insets margin = b.getMargin();
|
||||
|
||||
/* For determining the ideal size, do not assume a size restriction. */
|
||||
viewRect = new Rectangle(0, 0,
|
||||
|
@ -620,7 +621,6 @@ public class BasicGraphicsUtils
|
|||
viewRect, iconRect, textRect,
|
||||
textIconGap);
|
||||
|
||||
|
||||
/* +------------------------+ +------------------------+
|
||||
* | | | |
|
||||
* | ICON | | CONTENTCONTENTCONTENT |
|
||||
|
@ -630,7 +630,11 @@ public class BasicGraphicsUtils
|
|||
*/
|
||||
contentRect = textRect.union(iconRect);
|
||||
|
||||
return new Dimension(insets.left + contentRect.width + insets.right,
|
||||
insets.top + contentRect.height + insets.bottom);
|
||||
return new Dimension(insets.left + margin.left
|
||||
+ contentRect.width
|
||||
+ insets.right + margin.right,
|
||||
insets.top + margin.top
|
||||
+ contentRect.height
|
||||
+ insets.bottom + margin.bottom);
|
||||
}
|
||||
}
|
||||
|
|
|
@ -228,12 +228,25 @@ Java_gnu_java_awt_peer_gtk_GtkWindowPeer_connectSignals
|
|||
{
|
||||
void *ptr = NSA_GET_PTR (env, obj);
|
||||
jobject *gref = NSA_GET_GLOBAL_REF (env, obj);
|
||||
GtkWidget* vbox, *layout;
|
||||
GList* children;
|
||||
g_assert (gref);
|
||||
|
||||
gdk_threads_enter ();
|
||||
|
||||
gtk_widget_realize (ptr);
|
||||
|
||||
/* Receive events from the GtkLayout too */
|
||||
children = gtk_container_get_children(GTK_CONTAINER(ptr));
|
||||
vbox = children->data;
|
||||
g_assert(GTK_IS_VBOX(vbox));
|
||||
children = gtk_container_get_children(GTK_CONTAINER(vbox));
|
||||
layout = children->data;
|
||||
g_assert(GTK_IS_LAYOUT(layout));
|
||||
|
||||
g_signal_connect (GTK_OBJECT (layout), "event",
|
||||
G_CALLBACK (pre_event_handler), *gref);
|
||||
|
||||
/* Connect signals for window event support. */
|
||||
g_signal_connect (G_OBJECT (ptr), "delete-event",
|
||||
G_CALLBACK (window_delete_cb), *gref);
|
||||
|
|
Loading…
Reference in New Issue