package javax.swing;
import java.awt.Color;
import java.awt.Component;
import java.awt.Container;
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;
import java.awt.event.ActionListener;
import java.awt.event.ContainerEvent;
import java.awt.event.ContainerListener;
import java.awt.event.FocusEvent;
import java.awt.event.FocusListener;
import java.awt.event.MouseEvent;
import java.awt.image.ImageObserver;
import java.awt.peer.LightweightPeer;
import java.beans.PropertyChangeListener;
import java.beans.PropertyVetoException;
import java.beans.VetoableChangeListener;
import java.io.Serializable;
import java.util.EventListener;
import java.util.Hashtable;
import javax.accessibility.Accessible;
import javax.accessibility.AccessibleContext;
import javax.accessibility.AccessibleRole;
import javax.accessibility.AccessibleStateSet;
import javax.swing.border.Border;
import javax.swing.event.AncestorListener;
import javax.swing.event.EventListenerList;
import javax.swing.event.SwingPropertyChangeSupport;
import javax.swing.plaf.ComponentUI;
public abstract class JComponent extends Container implements Serializable
{
static final long serialVersionUID = -5242478962609715464L;
protected EventListenerList listenerList = new EventListenerList();
protected AccessibleContext accessibleContext;
Dimension pref,min,max;
Border border;
JToolTip tooltip;
String tool_tip_text;
boolean use_double_buffer = false, opaque;
Image doubleBuffer;
int doubleBufferWidth = -1;
int doubleBufferHeight = -1;
ComponentUI ui;
private SwingPropertyChangeSupport changeSupport;
Hashtable prop_hash;
public abstract class AccessibleJComponent
extends AccessibleAWTContainer {
protected class AccessibleFocusHandler implements FocusListener {
protected AccessibleFocusHandler(AccessibleJComponent component) {
}
public void focusGained(FocusEvent event) {
}
public void focusLost(FocusEvent valevent) {
} }
protected class AccessibleContainerHandler implements ContainerListener {
protected AccessibleContainerHandler(AccessibleJComponent component) {
}
public void componentAdded(ContainerEvent event) {
}
public void componentRemoved(ContainerEvent valevent) {
} }
protected ContainerListener accessibleContainerHandler;
protected FocusListener accessibleFocusHandler;
protected AccessibleJComponent(JComponent component) {
}
public void addPropertyChangeListener(PropertyChangeListener listener) {
}
public void removePropertyChangeListener(PropertyChangeListener listener) {
}
public int getAccessibleChildrenCount() {
return 0; }
public Accessible getAccessibleChild(int value0) {
return null; }
public AccessibleStateSet getAccessibleStateSet() {
return null; }
public String getAccessibleName() {
return null; }
public String getAccessibleDescription() {
return null; }
public AccessibleRole getAccessibleRole() {
return null; }
protected String getBorderTitle(Border value0) {
return null; }
}
public JComponent()
{
super();
super.setLayout(new FlowLayout());
}
public boolean contains(int x, int y)
{
return super.contains(x,y);
}
public void addNotify()
{
super.addNotify();
}
Hashtable get_prop_hash()
{
if (prop_hash == null)
prop_hash = new Hashtable();
return prop_hash;
}
public Object getClientProperty(Object key)
{ return get_prop_hash().get(key); }
public void putClientProperty(Object key, Object value)
{ get_prop_hash().put(key, value); }
public void removeAncestorListener(AncestorListener listener)
{
listenerList.remove(AncestorListener.class, listener);
}
public void removePropertyChangeListener(PropertyChangeListener listener)
{
if (changeSupport != null)
changeSupport.removePropertyChangeListener(listener);
}
public void removePropertyChangeListener(String propertyName, PropertyChangeListener listener)
{
listenerList.remove(PropertyChangeListener.class, listener);
}
public void removeVetoableChangeListener(VetoableChangeListener listener)
{
listenerList.remove(VetoableChangeListener.class, listener);
}
public void addAncestorListener(AncestorListener listener)
{
listenerList.add(AncestorListener.class, listener);
}
public void addPropertyChangeListener(PropertyChangeListener listener)
{
if (changeSupport == null)
changeSupport = new SwingPropertyChangeSupport(this);
changeSupport.addPropertyChangeListener(listener);
}
public void addPropertyChangeListener(String propertyName, PropertyChangeListener listener)
{
listenerList.add(PropertyChangeListener.class, listener);
}
public void addVetoableChangeListener(VetoableChangeListener listener)
{
listenerList.add(VetoableChangeListener.class, listener);
}
public EventListener[] getListeners (Class listenerType)
{
return listenerList.getListeners (listenerType);
}
public AncestorListener[] getAncestorListeners()
{
return (AncestorListener[]) getListeners (AncestorListener.class);
}
public VetoableChangeListener[] getVetoableChangeListeners()
{
return (VetoableChangeListener[]) getListeners (VetoableChangeListener.class);
}
public void computeVisibleRect(Rectangle rect)
{
}
public PropertyChangeListener[] getPropertyChangeListeners(String property)
{
return changeSupport == null ? new PropertyChangeListener[0]
: changeSupport.getPropertyChangeListeners(property);
}
public void firePropertyChange(String propertyName, boolean oldValue, boolean newValue)
{
if (changeSupport != null)
changeSupport.firePropertyChange(propertyName, new Boolean(oldValue),
new Boolean(newValue));
}
public void firePropertyChange(String propertyName, byte oldValue, byte newValue)
{
if (changeSupport != null)
changeSupport.firePropertyChange(propertyName, new Byte(oldValue),
new Byte(newValue));
}
public void firePropertyChange(String propertyName, char oldValue, char newValue)
{
if (changeSupport != null)
changeSupport.firePropertyChange(propertyName, new Character(oldValue),
new Character(newValue));
}
public void firePropertyChange(String propertyName, double oldValue, double newValue)
{
if (changeSupport != null)
changeSupport.firePropertyChange(propertyName, new Double(oldValue),
new Double(newValue));
}
public void firePropertyChange(String propertyName, float oldValue, float newValue)
{
if (changeSupport != null)
changeSupport.firePropertyChange(propertyName, new Float(oldValue),
new Float(newValue));
}
public void firePropertyChange(String propertyName, int oldValue, int newValue)
{
if (changeSupport != null)
changeSupport.firePropertyChange(propertyName, new Integer(oldValue),
new Integer(newValue));
}
public void firePropertyChange(String propertyName, long oldValue, long newValue)
{
if (changeSupport != null)
changeSupport.firePropertyChange(propertyName, new Long(oldValue),
new Long(newValue));
}
protected void firePropertyChange(String propertyName, Object oldValue, Object newValue)
{
if (changeSupport != null)
changeSupport.firePropertyChange(propertyName, oldValue, newValue);
}
public void firePropertyChange(String propertyName, short oldValue, short newValue)
{
if (changeSupport != null)
changeSupport.firePropertyChange(propertyName, new Short(oldValue),
new Short(newValue));
}
protected void fireVetoableChange(String propertyName, Object oldValue, Object newValue)
throws PropertyVetoException
{
}
public AccessibleContext getAccessibleContext()
{
return null;
}
public ActionListener getActionForKeyStroke(KeyStroke aKeyStroke)
{
return null;
}
public float getAlignmentX()
{
return 0;
}
public float getAlignmentY()
{
return 0;
}
public boolean getAutoscrolls()
{
return false;
}
public void setBorder(Border border)
{
this.border = border;
revalidate();
repaint();
}
public Border getBorder()
{ return border; }
public Rectangle getBounds(Rectangle rv)
{
if (rv == null)
return new Rectangle(getX(),getY(),getWidth(),getHeight());
else
{
rv.setBounds(getX(),getY(),getWidth(),getHeight());
return rv;
}
}
protected Graphics getComponentGraphics(Graphics g)
{ return g; }
public int getConditionForKeyStroke(KeyStroke aKeyStroke)
{
return 0;
}
public int getDebugGraphicsOptions()
{
return 0;
}
public Graphics getGraphics()
{ return super.getGraphics(); }
public Insets getInsets()
{
if (border == null)
{
return super.getInsets();
}
return getBorder().getBorderInsets(this);
}
public Insets getInsets(Insets insets)
{
Insets t = getInsets();
if (insets == null)
return t;
return new Insets(t.top, t.left, t.bottom, t.right);
}
public Point getLocation(Point rv)
{
if (rv == null)
return new Point(getX(),
getY());
rv.setLocation(getX(),
getY());
return rv;
}
public Dimension getMaximumSize()
{
if (max != null)
{
return max;
}
if (ui != null)
{
Dimension s = ui.getMaximumSize(this);
if (s != null)
{
return s;
}
}
Dimension p = super.getMaximumSize();
return p;
}
public Dimension getMinimumSize()
{
if (min != null)
{
return min;
}
if (ui != null)
{
Dimension s = ui.getMinimumSize(this);
if (s != null)
{
return s;
}
}
Dimension p = super.getMinimumSize();
return p;
}
public Dimension getPreferredSize()
{
if (pref != null)
{
return pref;
}
if (ui != null)
{
Dimension s = ui.getPreferredSize(this);
if (s != null)
{
return s;
}
}
Dimension p = super.getPreferredSize();
return p;
}
public Component getNextFocusableComponent()
{
return null;
}
public KeyStroke[] getRegisteredKeyStrokes()
{
return null;
}
public JRootPane getRootPane()
{
JRootPane p = SwingUtilities.getRootPane(this);
System.out.println("root = " + p);
return p;
}
public Dimension getSize(Dimension rv)
{
if (rv == null)
return new Dimension(getWidth(),
getHeight());
else
{
rv.setSize(getWidth(),
getHeight());
return rv;
}
}
public JToolTip createToolTip()
{
if (tooltip == null)
tooltip = new JToolTip(tool_tip_text);
return tooltip;
}
public Point getToolTipLocation(MouseEvent event)
{ return null; }
public void setToolTipText(String text)
{ tool_tip_text = text; }
public String getToolTipText()
{ return tool_tip_text; }
public String getToolTipText(MouseEvent event)
{ return tool_tip_text; }
public Container getTopLevelAncestor()
{
System.out.println("JComponent, getTopLevelAncestor()");
return null;
}
public Rectangle getVisibleRect()
{
System.out.println("JComponent, getVisibleRect()");
return null;
}
public void grabFocus()
{
}
public boolean hasFocus()
{
return false;
}
public boolean isDoubleBuffered()
{ return use_double_buffer; }
public boolean isFocusCycleRoot()
{
return false;
}
public boolean isFocusTraversable()
{
return false;
}
public static boolean isLightweightComponent(Component c)
{
return c.getPeer() instanceof LightweightPeer;
}
public boolean isManagingFocus()
{
return false;
}
public boolean isOpaque()
{ return opaque; }
public boolean isOptimizedDrawingEnabled()
{
return true;
}
public boolean isPaintingTile()
{
return false;
}
public boolean isRequestFocusEnabled()
{
return false;
}
public boolean isValidateRoot()
{
return false;
}
public void paint(Graphics g)
{
Graphics g2 = g;
Rectangle r = getBounds ();
if (use_double_buffer)
{
if (doubleBuffer == null
|| doubleBufferWidth != r.width
|| doubleBufferHeight != r.height)
{
doubleBuffer = createImage(r.width, r.height);
doubleBufferWidth = r.width;
doubleBufferHeight = r.height;
}
g2 = doubleBuffer.getGraphics ();
if (this.getBackground() != null)
{
Color save = g2.getColor();
g2.setColor(this.getBackground());
g2.fillRect (0, 0, r.width, r.height);
g2.setColor(save);
}
else
g2.clearRect(0, 0, r.width, r.height);
}
paintBorder(g2);
paintComponent(g2);
paintChildren(g2);
if (use_double_buffer)
{
g.drawImage (doubleBuffer, 0, 0, (ImageObserver)null);
}
}
protected void paintBorder(Graphics g)
{
if (getBorder() != null)
{
getBorder().paintBorder(this,
g,
0,
0,
getWidth(),
getHeight());
}
}
protected void paintChildren(Graphics g)
{
super.paint(g);
}
protected void paintComponent(Graphics g)
{
if (ui != null)
{
ui.paint(g, this);
}
}
public void paintImmediately(int x, int y, int w, int h)
{
}
public void paintImmediately(Rectangle r)
{
paintImmediately((int)r.getX(),
(int)r.getY(),
(int)r.getWidth(),
(int)r.getHeight());
}
protected String paramString()
{
return "JComponent";
}
public void registerKeyboardAction(ActionListener anAction,
KeyStroke aKeyStroke,
int aCondition)
{
registerKeyboardAction(anAction,
null,
aKeyStroke,
aCondition);
}
public void registerKeyboardAction(ActionListener anAction,
String aCommand,
KeyStroke aKeyStroke,
int aCondition)
{
}
public void removeNotify()
{
}
public void repaint(long tm, int x, int y, int width, int height)
{
super.repaint(tm, x,y,width,height);
}
public void repaint(Rectangle r)
{
repaint((long)0,
(int)r.getX(),
(int)r.getY(),
(int)r.getWidth(),
(int)r.getHeight());
}
public boolean requestDefaultFocus()
{
return false;
}
public void requestFocus()
{
super.requestFocus();
}
public void resetKeyboardActions()
{
}
public void reshape(int x, int y, int w, int h)
{
super.reshape(x,y,w,h);
}
public void revalidate()
{
if (getParent() == null)
invalidate();
}
public void scrollRectToVisible(Rectangle aRect)
{
}
public void setAlignmentX(float alignmentX)
{
}
public void setAlignmentY(float alignmentY)
{
}
public void setAutoscrolls(boolean autoscrolls)
{
}
public void setDebugGraphicsOptions(int debugOptions)
{
}
public void setDoubleBuffered(boolean aFlag)
{
use_double_buffer = aFlag;
}
public void setEnabled(boolean enabled)
{
super.setEnabled(enabled);
repaint();
}
public void setFont(Font font)
{
super.setFont(font);
revalidate();
repaint();
}
public void setBackground(Color bg)
{
super.setBackground(bg);
revalidate();
repaint();
}
public void setForeground(Color fg)
{
super.setForeground(fg);
revalidate();
repaint();
}
public void setMaximumSize(Dimension maximumSize)
{ max = maximumSize; }
public void setMinimumSize(Dimension minimumSize)
{ min = minimumSize; }
public void setPreferredSize(Dimension preferredSize)
{ pref = preferredSize; }
public void setNextFocusableComponent(Component aComponent)
{
}
public void setOpaque(boolean isOpaque)
{
opaque = isOpaque;
revalidate();
repaint();
}
public void setRequestFocusEnabled(boolean aFlag)
{
}
public void setVisible(boolean aFlag)
{
super.setVisible(aFlag);
if (getParent() != null)
{
Rectangle dims = getBounds();
getParent().repaint((int)dims.getX(),
(int)dims.getY(),
(int)dims.getWidth(),
(int)dims.getHeight());
}
}
public void unregisterKeyboardAction(KeyStroke aKeyStroke)
{
}
public void update(Graphics g)
{
paint(g);
}
public String getUIClassID()
{
return "ComponentUI";
}
protected void setUI(ComponentUI newUI)
{
if (ui != null)
{
ui.uninstallUI(this);
}
ui = newUI;
if (ui != null)
{
ui.installUI(this);
}
revalidate();
repaint();
}
public void updateUI()
{
System.out.println("update UI not overwritten in class: " + this);
}
}