PC Plus SuperCD (UK) 2000 March/pcp161a.iso/handson/files/copyjava.exe/com/sun/java/swing/JComponent.class

Java Class File | 1998-02-26 | 25.5 KB | 1,432 lines

package com.sun.java.swing;

import com.sun.java.accessibility.AccessibleContext;
import com.sun.java.swing.border.Border;
import com.sun.java.swing.event.AncestorListener;
import com.sun.java.swing.event.EventListenerList;
import com.sun.java.swing.plaf.ComponentUI;
import java.applet.Applet;
import java.awt.AWTEvent;
import java.awt.Component;
import java.awt.Container;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Image;
import java.awt.Insets;
import java.awt.Point;
import java.awt.Rectangle;
import java.awt.Window;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.FocusEvent;
import java.awt.event.InputEvent;
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.PropertyChangeSupport;
import java.beans.PropertyVetoException;
import java.beans.VetoableChangeListener;
import java.beans.VetoableChangeSupport;
import java.io.Serializable;
import java.util.Dictionary;
import java.util.Enumeration;
import java.util.Hashtable;
import java.util.Vector;

public abstract class JComponent extends Container implements Serializable {
   private Dimension preferredSize;
   private Dimension minimumSize;
   private Dimension maximumSize;
   private Float alignmentX;
   private Float alignmentY;
   private AncestorNotifier ancestorNotifier;
   Rectangle _bounds = new Rectangle();
   // $FF: renamed from: ui com.sun.java.swing.plaf.ComponentUI
   protected ComponentUI field_0;
   protected EventListenerList listenerList = new EventListenerList();
   private Hashtable clientProperties;
   private VetoableChangeSupport vetoableChangeSupport;
   private Autoscroller autoscroller;
   private int flags;
   private Border border;
   private transient Rectangle tmpRect;
   public static final int WHEN_FOCUSED = 0;
   public static final int WHEN_ANCESTOR_OF_FOCUSED_COMPONENT = 1;
   public static final int WHEN_IN_FOCUSED_WINDOW = 2;
   public static final int UNDEFINED_CONDITION = -1;
   private static final String KEYBOARD_BINDINGS_KEY = "_KeyboardBindings";
   public static final String TOOL_TIP_TEXT_KEY = "ToolTipText";
   private static final String NEXT_FOCUS = "nextFocus";
   private static final int REQUEST_FOCUS_DISABLED = 0;
   private static final int IS_DOUBLE_BUFFERED = 1;
   private static final int ANCESTOR_USING_BUFFER = 2;
   private static final int IS_PAINTING_TILE = 3;
   private static final int HAS_FOCUS = 4;
   private static final int IS_OPAQUE = 5;
   protected AccessibleContext accessibleContext;
   private PropertyChangeSupport changeSupport;
   // $FF: synthetic field
   static Class class$com$sun$java$swing$JComponent$KeyboardState;

   public JComponent() {
      ((Component)this).enableEvents(4L);
   }

   public void updateUI() {
   }

   protected void setUI(ComponentUI var1) {
      if (this.field_0 != null) {
         this.field_0.uninstallUI(this);
      }

      ComponentUI var2 = this.field_0;
      this.field_0 = var1;
      if (this.field_0 != null) {
         this.field_0.installUI(this);
      }

      ((Container)this).invalidate();
      this.firePropertyChange("UI", var2, this.field_0);
   }

   public String getUIClassID() {
      return "not a pluggable look and feel class";
   }

   protected Graphics getComponentGraphics(Graphics var1) {
      Object var2 = var1;
      if (this.field_0 != null && DebugGraphics.debugComponentCount() != 0 && this.shouldDebugGraphics() != 0 && !(var1 instanceof DebugGraphics)) {
         if (var1 instanceof SwingGraphics) {
            if (!(((SwingGraphics)var1).subGraphics() instanceof DebugGraphics)) {
               DebugGraphics var3 = new DebugGraphics(((SwingGraphics)var1).subGraphics(), this);
               var2 = SwingGraphics.createSwingGraphics(var3);
            }
         } else {
            var2 = new DebugGraphics(var1, this);
         }
      }

      ((Graphics)var2).setColor(((Component)this).getForeground());
      ((Graphics)var2).setFont(((Component)this).getFont());
      return (Graphics)var2;
   }

   protected void paintComponent(Graphics var1) {
      if (this.field_0 != null) {
         SwingGraphics var2 = SwingGraphics.createSwingGraphics(var1.create());

         try {
            this.field_0.update(var2, this);
         } finally {
            ((Graphics)var2).dispose();
         }

      }
   }

   protected void paintChildren(Graphics var1) {
      boolean var3 = false;
      SwingGraphics var4;
      if (var1 instanceof SwingGraphics) {
         var4 = (SwingGraphics)var1;
      } else {
         var4 = SwingGraphics.createSwingGraphics(var1);
         var3 = true;
      }

      Object var5 = ((Component)this).getTreeLock();
      synchronized(var5){}

      try {
         for(int var7 = ((Container)this).getComponentCount() - 1; var7 >= 0; --var7) {
            Component var8 = ((Container)this).getComponent(var7);
            if (var8 != null && isLightweightComponent(var8) && var8.isVisible()) {
               boolean var2 = var8 instanceof JComponent;
               Rectangle var9;
               if (var2) {
                  if (this.tmpRect == null) {
                     this.tmpRect = new Rectangle();
                  }

                  var9 = this.tmpRect;
                  ((JComponent)var8).getBounds(var9);
               } else {
                  var9 = var8.getBounds();
               }

               if (var4.isClipIntersecting(var9)) {
                  Graphics var10 = SwingGraphics.createGraphics(var1, var9.x, var9.y, var9.width, var9.height);
                  boolean var11 = false;

                  try {
                     if (var2) {
                        if (this.getFlag(2)) {
                           ((JComponent)var8).setFlag(2, true);
                           var11 = true;
                        }

                        if (this.getFlag(3)) {
                           ((JComponent)var8).setFlag(3, true);
                           var11 = true;
                        }

                        ((JComponent)var8).paint(var10);
                     } else {
                        var8.paint(var10);
                     }
                  } finally {
                     var10.dispose();
                     if (var11) {
                        ((JComponent)var8).setFlag(2, false);
                        ((JComponent)var8).setFlag(3, false);
                     }

                  }
               }
            }
         }
      } catch (Throwable var19) {
         throw var19;
      }

      if (var3) {
         var4.recycle();
      }

   }

   protected void paintBorder(Graphics var1) {
      Border var2 = this.getBorder();
      if (var2 != null) {
         var2.paintBorder(this, var1, 0, 0, this.getWidth(), this.getHeight());
      }

   }

   public void update(Graphics var1) {
      this.paint(var1);
   }

   public void paint(Graphics var1) {
      if (this.getWidth() != 0 && this.getHeight() != 0) {
         Graphics var2 = this.getComponentGraphics(var1);
         boolean var3;
         if (var2 instanceof SwingGraphics) {
            var3 = false;
         } else {
            var3 = true;
         }

         SwingGraphics var4 = SwingGraphics.createSwingGraphics(var2);
         Object var5 = null;
         RepaintManager var6 = RepaintManager.currentManager(this);
         int var7 = var4.getClipX();
         int var8 = var4.getClipY();
         int var9 = var4.getClipWidth();
         int var10 = var4.getClipHeight();
         if (var9 > this.getWidth()) {
            var9 = this.getWidth();
         }

         if (var10 > this.getHeight()) {
            var10 = this.getHeight();
         }

         if (var6.isDoubleBufferingEnabled() && !this.getFlag(2) && this.isDoubleBuffered()) {
            Image var21 = var6.getOffscreenBuffer(this, var9, var10);
            if (var3) {
               var4.recycle();
               var3 = false;
            }

            var4 = SwingGraphics.createSwingGraphics(var21.getGraphics());
            var4.translate(-var7, -var8);
            int var11 = var21.getWidth((ImageObserver)null);
            int var12 = var21.getHeight((ImageObserver)null);
            if (var11 > var9) {
               var11 = var9;
            }

            if (var12 > var10) {
               var12 = var10;
            }

            try {
               this.setFlag(2, true);
               this.setFlag(3, true);
               int var13 = 0;

               for(int var15 = var9; var13 < var15; var13 += var11) {
                  int var14 = 0;

                  for(int var16 = var10; var14 < var16; var14 += var12) {
                     if (var14 + var12 >= var16 && var13 + var11 >= var15) {
                        this.setFlag(3, false);
                     }

                     var4.translate(-var13, -var14);
                     var4.setClip(var7 + var13, var8 + var14, var11, var12);
                     if (!this.rectangleIsObscured(var7, var8, var11, var12)) {
                        this.paintComponent(var4);
                        this.paintBorder(var4);
                     }

                     this.paintChildren(var4);
                     var1.drawImage(var21, var7 + var13, var8 + var14, this);
                     var4.translate(var13, var14);
                  }
               }
            } finally {
               this.setFlag(2, false);
               this.setFlag(3, false);
               var4.dispose();
            }
         } else {
            if (!this.rectangleIsObscured(var7, var8, var9, var10)) {
               this.paintComponent(var4);
               this.paintBorder(var4);
            }

            this.paintChildren(var4);
         }

         if (var3) {
            var4.recycle();
         }

      }
   }

   public boolean isPaintingTile() {
      return this.getFlag(3);
   }

   public boolean isFocusCycleRoot() {
      return false;
   }

   public boolean isManagingFocus() {
      return false;
   }

   public void setNextFocusableComponent(Component var1) {
      this.putClientProperty("nextFocus", var1);
   }

   public Component getNextFocusableComponent() {
      return (Component)this.getClientProperty("nextFocus");
   }

   public void setRequestFocusEnabled(boolean var1) {
      this.setFlag(0, !var1);
   }

   public boolean isRequestFocusEnabled() {
      return !this.getFlag(0);
   }

   public void requestFocus() {
      if (this.isRequestFocusEnabled()) {
         super.requestFocus();
      }

   }

   public void grabFocus() {
      super.requestFocus();
   }

   public void setPreferredSize(Dimension var1) {
      this.preferredSize = var1;
   }

   public Dimension getPreferredSize() {
      if (this.preferredSize != null) {
         return this.preferredSize;
      } else {
         Dimension var1 = null;
         if (this.field_0 != null) {
            var1 = this.field_0.getPreferredSize(this);
         }

         return var1 != null ? var1 : super.getPreferredSize();
      }
   }

   public void setMaximumSize(Dimension var1) {
      this.maximumSize = var1;
   }

   public Dimension getMaximumSize() {
      if (this.maximumSize != null) {
         return this.maximumSize;
      } else {
         Dimension var1 = null;
         if (this.field_0 != null) {
            var1 = this.field_0.getMaximumSize(this);
         }

         return var1 != null ? var1 : super.getMaximumSize();
      }
   }

   public void setMinimumSize(Dimension var1) {
      this.minimumSize = var1;
   }

   public Dimension getMinimumSize() {
      if (this.minimumSize != null) {
         return this.minimumSize;
      } else {
         Dimension var1 = null;
         if (this.field_0 != null) {
            var1 = this.field_0.getMinimumSize(this);
         }

         return var1 != null ? var1 : super.getMinimumSize();
      }
   }

   public boolean contains(int var1, int var2) {
      return this.field_0 != null ? this.field_0.contains(this, var1, var2) : super.contains(var1, var2);
   }

   public void setBorder(Border var1) {
      Border var2 = this.border;
      this.border = var1;
      this.firePropertyChange("border", var2, var1);
      ((Container)this).invalidate();
   }

   public Border getBorder() {
      return this.border;
   }

   public Insets getInsets() {
      return this.border != null ? this.border.getBorderInsets(this) : super.getInsets();
   }

   public float getAlignmentY() {
      return this.alignmentY != null ? this.alignmentY : super.getAlignmentY();
   }

   public void setAlignmentY(float var1) {
      this.alignmentY = new Float(var1 > 1.0F ? 1.0F : (var1 < 0.0F ? 0.0F : var1));
   }

   public float getAlignmentX() {
      return this.alignmentX != null ? this.alignmentX : super.getAlignmentX();
   }

   public void setAlignmentX(float var1) {
      this.alignmentX = new Float(var1 > 1.0F ? 1.0F : (var1 < 0.0F ? 0.0F : var1));
   }

   public Graphics getGraphics() {
      if (this.shouldDebugGraphics() != 0) {
         DebugGraphics var1 = new DebugGraphics(super.getGraphics(), this);
         return var1;
      } else {
         return SwingGraphics.createSwingGraphics(super.getGraphics());
      }
   }

   public void setDebugGraphicsOptions(int var1) {
      DebugGraphics.setDebugOptions(this, var1);
   }

   public int getDebugGraphicsOptions() {
      return DebugGraphics.getDebugOptions(this);
   }

   int shouldDebugGraphics() {
      return DebugGraphics.shouldComponentDebug(this);
   }

   public void registerKeyboardAction(ActionListener var1, String var2, KeyStroke var3, int var4) {
      boolean var6 = false;
      synchronized(this){}

      Hashtable var5;
      try {
         var5 = (Hashtable)this.getClientProperty("_KeyboardBindings");
         if (var5 == null) {
            var5 = new Hashtable();
            this.putClientProperty("_KeyboardBindings", var5);
            var6 = true;
         }
      } catch (Throwable var13) {
         throw var13;
      }

      synchronized(var5){}

      try {
         var5.put(var3, new KeyboardBinding(var1, var2, var3, var4));
      } catch (Throwable var12) {
         throw var12;
      }

      if (var6) {
         ((Component)this).enableEvents(8L);
      }

   }

   public void registerKeyboardAction(ActionListener var1, KeyStroke var2, int var3) {
      this.registerKeyboardAction(var1, (String)null, var2, var3);
   }

   private Hashtable keyboardBindings() {
      synchronized(this){}

      Hashtable var1;
      try {
         var1 = (Hashtable)this.getClientProperty("_KeyboardBindings");
      } catch (Throwable var4) {
         throw var4;
      }

      return var1;
   }

   public void unregisterKeyboardAction(KeyStroke var1) {
      Hashtable var2 = this.keyboardBindings();
      if (var2 != null) {
         synchronized(var2){}

         try {
            var2.remove(var1);
         } catch (Throwable var5) {
            throw var5;
         }

         var2.size();
      }
   }

   public KeyStroke[] getRegisteredKeyStrokes() {
      Hashtable var1 = this.keyboardBindings();
      if (var1 == null) {
         return new KeyStroke[0];
      } else {
         synchronized(var1){}

         KeyStroke[] var2;
         try {
            var2 = new KeyStroke[var1.size()];
            int var3 = 0;

            for(Enumeration var4 = var1.keys(); var4.hasMoreElements(); var2[var3++] = (KeyStroke)var4.nextElement()) {
            }
         } catch (Throwable var7) {
            throw var7;
         }

         return var2;
      }
   }

   public int getConditionForKeyStroke(KeyStroke var1) {
      Hashtable var2 = this.keyboardBindings();
      if (var2 == null) {
         return -1;
      } else {
         synchronized(var2){}

         int var3;
         try {
            KeyboardBinding var6 = (KeyboardBinding)var2.get(var1);
            if (var6 == null) {
               return -1;
            }

            var3 = var6.getCondition();
         } catch (Throwable var8) {
            throw var8;
         }

         return var3;
      }
   }

   public ActionListener getActionForKeyStroke(KeyStroke var1) {
      Hashtable var2 = this.keyboardBindings();
      if (var2 == null) {
         return null;
      } else {
         synchronized(var2){}

         ActionListener var3;
         try {
            KeyboardBinding var6 = (KeyboardBinding)var2.get(var1);
            if (var6 == null) {
               return null;
            }

            var3 = var6.getAction();
         } catch (Throwable var8) {
            throw var8;
         }

         return var3;
      }
   }

   public void resetKeyboardActions() {
      synchronized(this){}

      try {
         Hashtable var3 = (Hashtable)this.getClientProperty("_KeyboardBindings");
         if (var3 != null) {
            var3.clear();
         }
      } catch (Throwable var5) {
         throw var5;
      }

   }

   public boolean requestDefaultFocus() {
      Component[] var1 = ((Container)this).getComponents();

      for(int var2 = 0; var2 < var1.length; ++var2) {
         if (var1[var2].isFocusTraversable()) {
            if (var1[var2] instanceof JComponent) {
               ((JComponent)var1[var2]).grabFocus();
            } else {
               var1[var2].requestFocus();
            }

            return true;
         }

         if (var1[var2] instanceof JComponent && !((JComponent)var1[var2]).isManagingFocus() && ((JComponent)var1[var2]).requestDefaultFocus()) {
            return true;
         }
      }

      return false;
   }

   public void setVisible(boolean var1) {
      if (var1 != ((Component)this).isVisible()) {
         super.setVisible(var1);
         Container var2 = ((Component)this).getParent();
         if (var2 != null) {
            Rectangle var3 = ((Component)this).getBounds();
            ((Component)var2).repaint(var3.x, var3.y, var3.width, var3.height);
         }
      }

   }

   public boolean isFocusTraversable() {
      boolean var1 = false;
      synchronized(this){}

      Hashtable var2;
      try {
         var2 = (Hashtable)this.getClientProperty("_KeyboardBindings");
      } catch (Throwable var11) {
         throw var11;
      }

      if (var2 != null) {
         synchronized(var2){}

         try {
            Enumeration var5 = var2.keys();

            while(var5.hasMoreElements()) {
               KeyboardBinding var6 = (KeyboardBinding)var2.get(var5.nextElement());
               if (var6.getCondition() == 0) {
                  var1 = true;
                  break;
               }
            }
         } catch (Throwable var12) {
            throw var12;
         }
      }

      return var1;
   }

   protected void processFocusEvent(FocusEvent var1) {
      switch (((AWTEvent)var1).getID()) {
         case 1004:
            this.setFlag(4, true);
            break;
         case 1005:
            this.setFlag(4, false);
      }

      super.processFocusEvent(var1);
   }

   protected void processComponentKeyEvent(KeyEvent var1) {
   }

   protected void processKeyEvent(KeyEvent var1) {
      boolean var3 = false;
      if (FocusManager.isFocusManagerEnabled()) {
         FocusManager var4 = FocusManager.getCurrentManager();
         var4.processKeyEvent(this, var1);
         if (((InputEvent)var1).isConsumed()) {
            return;
         }
      }

      super.processKeyEvent(var1);
      if (!((InputEvent)var1).isConsumed()) {
         this.processComponentKeyEvent(var1);
      }

      if (((AWTEvent)var1).getID() == 401) {
         var3 = true;
         if (!com.sun.java.swing.JComponent.KeyboardState.keyIsPressed(var1.getKeyCode())) {
            com.sun.java.swing.JComponent.KeyboardState.registerKeyPressed(var1.getKeyCode());
         }
      } else if (((AWTEvent)var1).getID() == 402) {
         if (com.sun.java.swing.JComponent.KeyboardState.keyIsPressed(var1.getKeyCode())) {
            var3 = true;
            com.sun.java.swing.JComponent.KeyboardState.registerKeyReleased(var1.getKeyCode());
         }
      } else if (((AWTEvent)var1).getID() == 400) {
         var3 = true;
      }

      if (!((InputEvent)var1).isConsumed()) {
         if (var3 && ((AWTEvent)var1).getID() == 401) {
            boolean var6 = this.processKeyBindings(var1, true);
            if (var6) {
               ((InputEvent)var1).consume();
               return;
            }
         } else if (var3 && ((AWTEvent)var1).getID() == 402) {
            boolean var5 = this.processKeyBindings(var1, false);
            if (var5) {
               ((InputEvent)var1).consume();
               return;
            }
         } else if (var3 && ((AWTEvent)var1).getID() == 400) {
            boolean var2 = this.processKeyBindings(var1, false);
            if (var2) {
               ((InputEvent)var1).consume();
            }
         }

      }
   }

   KeyboardBinding bindingForKeyStroke(KeyStroke var1, int var2) {
      KeyboardBinding var5 = null;
      synchronized(this){}

      Hashtable var3;
      try {
         var3 = (Hashtable)this.getClientProperty("_KeyboardBindings");
      } catch (Throwable var13) {
         throw var13;
      }

      if (var3 != null) {
         synchronized(var3){}

         try {
            KeyboardBinding var4 = (KeyboardBinding)var3.get(var1);
            if (var4 != null) {
               ActionListener var8 = var4.getAction();
               if (var8 instanceof Action && !((Action)var8).isEnabled()) {
                  var8 = null;
               }

               if (var8 != null) {
                  switch (var4.getCondition()) {
                     case 0:
                        if (var2 == 0) {
                           var5 = var4;
                        }
                        break;
                     case 1:
                        if (var2 == 0 || var2 == 1) {
                           var5 = var4;
                        }
                        break;
                     case 2:
                        if (var2 == 0 || var2 == 2 || var2 == 1) {
                           var5 = var4;
                        }
                  }
               }
            }
         } catch (Throwable var14) {
            throw var14;
         }
      }

      return var5;
   }

   boolean processKeyBinding(KeyEvent var1, int var2, boolean var3) {
      boolean var4 = !var3;
      Object var5 = null;
      if (((Component)this).isEnabled()) {
         KeyboardBinding var8;
         if (((AWTEvent)var1).getID() == 400) {
            var8 = this.bindingForKeyStroke(KeyStroke.getKeyStroke(var1.getKeyChar()), var2);
         } else {
            var8 = this.bindingForKeyStroke(KeyStroke.getKeyStroke(var1.getKeyCode(), ((InputEvent)var1).getModifiers(), var4), var2);
         }

         if (var8 != null) {
            ActionListener var7 = var8.getAction();
            if (var7 != null) {
               var7.actionPerformed(new ActionEvent(this, 1001, var8.getCommand()));
               return true;
            }
         }
      }

      return false;
   }

   boolean processKeyBindings(KeyEvent var1, boolean var2) {
      Vector var4 = new Vector();
      if (this.processKeyBinding(var1, 0, var2)) {
         return true;
      } else {
         var4.addElement(this);

         Container var3;
         for(var3 = ((Component)this).getParent(); var3 != null && !(var3 instanceof Window) && !(var3 instanceof Applet); var3 = ((Component)var3).getParent()) {
            if (var3 instanceof JComponent) {
               if (((JComponent)var3).processKeyBinding(var1, 1, var2)) {
                  return true;
               }

               var4.addElement(var3);
            }
         }

         return var3 != null ? processKeyBindingsForAllComponents(var1, var3, var4, var2) : false;
      }
   }

   static boolean processKeyBindingsForAllComponents(KeyEvent var0, Container var1, Vector var2, boolean var3) {
      if (var1 instanceof JComponent && !var2.contains(var1) && ((JComponent)var1).processKeyBinding(var0, 2, var3)) {
         return true;
      } else {
         Component[] var5 = var1.getComponents();

         for(int var4 = 0; var4 < var5.length; ++var4) {
            if (var5[var4] instanceof Container && processKeyBindingsForAllComponents(var0, (Container)var5[var4], var2, var3)) {
               return true;
            }
         }

         return false;
      }
   }

   public void setToolTipText(String var1) {
      this.putClientProperty("ToolTipText", var1);
      ToolTipManager var2 = ToolTipManager.sharedInstance();
      if (var1 != null) {
         var2.registerComponent(this);
      } else {
         var2.unregisterComponent(this);
      }
   }

   public String getToolTipText() {
      return (String)this.getClientProperty("ToolTipText");
   }

   public String getToolTipText(MouseEvent var1) {
      return this.getToolTipText();
   }

   public Point getToolTipLocation(MouseEvent var1) {
      return null;
   }

   public JToolTip createToolTip() {
      JToolTip var1 = new JToolTip();
      var1.setComponent(this);
      return var1;
   }

   public void scrollRectToVisible(Rectangle var1) {
      int var3 = this.getX();
      int var4 = this.getY();

      Container var2;
      for(var2 = ((Component)this).getParent(); var2 != null && !(var2 instanceof JComponent); var2 = ((Component)var2).getParent()) {
         Rectangle var5 = ((Component)var2).getBounds();
         var3 += var5.x;
         var4 += var5.y;
      }

      if (var2 != null) {
         var1.x += var3;
         var1.y += var4;
         ((JComponent)var2).scrollRectToVisible(var1);
         var1.x -= var3;
         var1.y -= var4;
      }

   }

   public void setAutoscrolls(boolean var1) {
      if (var1) {
         if (this.autoscroller == null) {
            this.autoscroller = new Autoscroller(this);
            return;
         }
      } else if (this.autoscroller != null) {
         this.autoscroller.stop();
         this.autoscroller = null;
      }

   }

   public boolean getAutoscrolls() {
      return this.autoscroller != null;
   }

   protected void processMouseMotionEvent(MouseEvent var1) {
      boolean var2 = true;
      if (this.autoscroller != null && ((AWTEvent)var1).getID() == 506) {
         var2 = !this.autoscroller.timer.isRunning();
         this.autoscroller.mouseDragged(var1);
      }

      if (var2) {
         super.processMouseMotionEvent(var1);
      }

   }

   void superProcessMouseMotionEvent(MouseEvent var1) {
      super.processMouseMotionEvent(var1);
   }

   public AccessibleContext getAccessibleContext() {
      return this.accessibleContext;
   }

   private Dictionary getClientProperties() {
      if (this.clientProperties == null) {
         this.clientProperties = new Hashtable(2);
      }

      return this.clientProperties;
   }

   public final Object getClientProperty(Object var1) {
      return this.getClientProperties().get(var1);
   }

   public final void putClientProperty(Object var1, Object var2) {
      Object var3 = this.getClientProperties().get(var1);
      if (var2 != null) {
         this.getClientProperties().put(var1, var2);
      } else {
         this.getClientProperties().remove(var1);
      }

      this.firePropertyChange(var1.toString(), var3, var2);
   }

   public static boolean isLightweightComponent(Component var0) {
      return var0.getPeer() instanceof LightweightPeer;
   }

   public void reshape(int var1, int var2, int var3, int var4) {
      if (((Component)this).isShowing()) {
         if (this._bounds.x + this._bounds.width > var1 && this._bounds.y + this._bounds.height > var2 && this._bounds.x < var1 + var3 && this._bounds.y < var2 + var4) {
            Rectangle[] var5 = SwingUtilities.computeDifference(((Component)this).getBounds(), new Rectangle(var1, var2, var3, var4));
            Container var8 = ((Component)this).getParent();
            int var6 = 0;

            for(int var7 = var5.length; var6 < var7; ++var6) {
               ((Component)var8).repaint(var5[var6].x, var5[var6].y, var5[var6].width, var5[var6].height);
            }
         } else {
            ((Component)this).getParent().repaint(this._bounds.x, this._bounds.y, this._bounds.width, this._bounds.height);
         }
      }

      this._bounds.setBounds(var1, var2, var3, var4);
      super.reshape(var1, var2, var3, var4);
   }

   public void setBounds(Rectangle var1) {
      this._bounds.setBounds(var1);
      super.setBounds(var1);
   }

   public Rectangle getBounds(Rectangle var1) {
      if (var1 == null) {
         return new Rectangle(this.getX(), this.getY(), this.getWidth(), this.getHeight());
      } else {
         var1.setBounds(this.getX(), this.getY(), this.getWidth(), this.getHeight());
         return var1;
      }
   }

   public Dimension getSize(Dimension var1) {
      if (var1 == null) {
         return new Dimension(this.getWidth(), this.getHeight());
      } else {
         var1.setSize(this.getWidth(), this.getHeight());
         return var1;
      }
   }

   public Point getLocation(Point var1) {
      if (var1 == null) {
         return new Point(this.getX(), this.getY());
      } else {
         var1.setLocation(this.getX(), this.getY());
         return var1;
      }
   }

   public int getX() {
      return this._bounds.x;
   }

   public int getY() {
      return this._bounds.y;
   }

   public int getWidth() {
      return this._bounds.width;
   }

   public int getHeight() {
      return this._bounds.height;
   }

   public boolean hasFocus() {
      return this.getFlag(4);
   }

   public boolean isOpaque() {
      return this.getFlag(5);
   }

   public void setOpaque(boolean var1) {
      boolean var2 = this.getFlag(5);
      this.setFlag(5, var1);
      this.firePropertyChange("opaque", var2, var1);
   }

   boolean rectangleIsObscured(int var1, int var2, int var3, int var4) {
      Component[] var5 = ((Container)this).getComponents();
      if (var5 == null) {
         return false;
      } else {
         for(int var6 = 0; var6 < var5.length; ++var6) {
            Component var7 = var5[var6];
            Rectangle var8;
            if (var7 instanceof JComponent) {
               var8 = ((JComponent)var7)._bounds;
            } else {
               var8 = var7.getBounds();
            }

            if (var1 >= var8.x && var1 + var3 <= var8.x + var8.width && var2 >= var8.y && var2 + var4 <= var8.y + var8.height) {
               if (var7 instanceof JComponent) {
                  return ((JComponent)var7).isOpaque();
               }

               return false;
            }
         }

         return false;
      }
   }

   static final void computeVisibleRect(Component var0, Rectangle var1) {
      Container var2 = var0.getParent();
      Rectangle var3 = var0.getBounds();
      if (var2 != null && !(var2 instanceof Window) && !(var2 instanceof Applet)) {
         computeVisibleRect(var2, var1);
         var1.x -= var3.x;
         var1.y -= var3.y;
         SwingUtilities.computeIntersection(0, 0, var3.width, var3.height, var1);
      } else {
         var1.setBounds(0, 0, var3.width, var3.height);
      }
   }

   public void computeVisibleRect(Rectangle var1) {
      computeVisibleRect(this, var1);
   }

   public Rectangle getVisibleRect() {
      Rectangle var1 = new Rectangle();
      this.computeVisibleRect(var1);
      return var1;
   }

   protected void firePropertyChange(String var1, Object var2, Object var3) {
      if (this.changeSupport != null) {
         this.changeSupport.firePropertyChange(var1, var2, var3);
      }

   }

   public void firePropertyChange(String var1, byte var2, byte var3) {
      if (this.changeSupport != null && var2 != var3) {
         this.changeSupport.firePropertyChange(var1, new Byte(var2), new Byte(var3));
      }

   }

   public void firePropertyChange(String var1, char var2, char var3) {
      if (this.changeSupport != null && var2 != var3) {
         this.changeSupport.firePropertyChange(var1, new Character(var2), new Character(var3));
      }

   }

   public void firePropertyChange(String var1, short var2, short var3) {
      if (this.changeSupport != null && var2 != var3) {
         this.changeSupport.firePropertyChange(var1, new Short(var2), new Short(var3));
      }

   }

   public void firePropertyChange(String var1, int var2, int var3) {
      if (this.changeSupport != null && var2 != var3) {
         this.changeSupport.firePropertyChange(var1, new Integer(var2), new Integer(var3));
      }

   }

   public void firePropertyChange(String var1, long var2, long var4) {
      if (this.changeSupport != null && var2 != var4) {
         this.changeSupport.firePropertyChange(var1, new Long(var2), new Long(var4));
      }

   }

   public void firePropertyChange(String var1, float var2, float var3) {
      if (this.changeSupport != null && var2 != var3) {
         this.changeSupport.firePropertyChange(var1, new Float(var2), new Float(var3));
      }

   }

   public void firePropertyChange(String var1, double var2, double var4) {
      if (this.changeSupport != null && var2 != var4) {
         this.changeSupport.firePropertyChange(var1, new Double(var2), new Double(var4));
      }

   }

   public void firePropertyChange(String var1, boolean var2, boolean var3) {
      if (this.changeSupport != null && var2 != var3) {
         this.changeSupport.firePropertyChange(var1, new Boolean(var2), new Boolean(var3));
      }

   }

   public synchronized void addPropertyChangeListener(PropertyChangeListener var1) {
      if (this.changeSupport == null) {
         this.changeSupport = new PropertyChangeSupport(this);
      }

      this.changeSupport.addPropertyChangeListener(var1);
   }

   public synchronized void removePropertyChangeListener(PropertyChangeListener var1) {
      if (this.changeSupport != null) {
         this.changeSupport.removePropertyChangeListener(var1);
      }

   }

   protected void fireVetoableChange(String var1, Object var2, Object var3) throws PropertyVetoException {
      if (this.vetoableChangeSupport != null) {
         this.vetoableChangeSupport.fireVetoableChange(var1, var2, var3);
      }
   }

   public synchronized void addVetoableChangeListener(VetoableChangeListener var1) {
      if (this.vetoableChangeSupport == null) {
         this.vetoableChangeSupport = new VetoableChangeSupport(this);
      }

      this.vetoableChangeSupport.addVetoableChangeListener(var1);
   }

   public synchronized void removeVetoableChangeListener(VetoableChangeListener var1) {
      if (this.vetoableChangeSupport != null) {
         this.vetoableChangeSupport.removeVetoableChangeListener(var1);
      }
   }

   public Container getTopLevelAncestor() {
      for(Object var1 = this; var1 != null; var1 = ((Component)var1).getParent()) {
         if (var1 instanceof Window || var1 instanceof Applet) {
            return (Container)var1;
         }
      }

      return null;
   }

   public void addAncestorListener(AncestorListener var1) {
      if (this.ancestorNotifier == null) {
         this.ancestorNotifier = new AncestorNotifier(this);
      }

      this.ancestorNotifier.addAncestorListener(var1);
   }

   public void removeAncestorListener(AncestorListener var1) {
      if (this.ancestorNotifier != null) {
         this.ancestorNotifier.removeAncestorListener(var1);
         if (this.ancestorNotifier.listenerList.getListenerList().length == 0) {
            this.ancestorNotifier.removeAllListeners();
            this.ancestorNotifier = null;
         }

      }
   }

   public void addNotify() {
      super.addNotify();
      this.firePropertyChange("ancestor", (Object)null, ((Component)this).getParent());
   }

   public void removeNotify() {
      super.removeNotify();
      this.firePropertyChange("ancestor", ((Component)this).getParent(), (Object)null);
   }

   public void repaint(long var1, int var3, int var4, int var5, int var6) {
      RepaintManager.currentManager(this).addDirtyRegion(this, var3, var4, var5, var6);
   }

   public void repaint(Rectangle var1) {
      this.repaint(0L, var1.x, var1.y, var1.width, var1.height);
   }

   public void revalidate() {
      if (SwingUtilities.isEventDispatchThread()) {
         ((Container)this).invalidate();
         RepaintManager.currentManager(this).addInvalidComponent(this);
      } else {
         1 var1 = new 1(this);
         SwingUtilities.invokeLater(var1);
      }
   }

   public boolean isValidateRoot() {
      return false;
   }

   public boolean isOptimizedDrawingEnabled() {
      return true;
   }

   public void paintImmediately(int var1, int var2, int var3, int var4) {
      Object var5 = this;
      if (((Component)this).isShowing()) {
         while(!((JComponent)var5).isOpaque()) {
            Container var6 = ((Component)var5).getParent();
            if (var6 == null) {
               break;
            }

            Rectangle var7;
            if (var5 instanceof JComponent) {
               var7 = ((JComponent)var5)._bounds;
            } else {
               var7 = ((Component)var5).getBounds();
            }

            var1 += var7.x;
            var2 += var7.y;
            var5 = var6;
            if (!(var6 instanceof JComponent)) {
               break;
            }
         }

         if (var5 instanceof JComponent) {
            ((JComponent)var5)._paintImmediately(var1, var2, var3, var4);
         } else {
            ((Component)var5).repaint(var1, var2, var3, var4);
         }
      }
   }

   public void paintImmediately(Rectangle var1) {
      this.paintImmediately(var1.x, var1.y, var1.width, var1.height);
   }

   void _paintImmediately(int var1, int var2, int var3, int var4) {
      Rectangle var7 = new Rectangle(var1, var2, var3, var4);
      if (this.tmpRect == null) {
         this.tmpRect = new Rectangle();
      }

      this.tmpRect.x = this.tmpRect.y = 0;
      int var9 = 0;
      int var10 = 0;
      boolean var11 = false;
      boolean var12 = false;
      boolean var13 = false;
      JComponent var14 = null;
      JComponent var15 = this;
      RepaintManager var16 = RepaintManager.currentManager(this);

      Object var6;
      for(var6 = this; var6 != null && !(var6 instanceof Window) && !(var6 instanceof Applet); var6 = ((Component)var6).getParent()) {
         if (var6 instanceof JComponent && !((JComponent)var6).isOptimizedDrawingEnabled()) {
            var15 = (JComponent)var6;
            var10 = 0;
            var9 = 0;
            var13 = false;
         }

         if (var16.isDoubleBufferingEnabled() && var6 instanceof JComponent && ((JComponent)var6).isDoubleBuffered()) {
            var13 = true;
            var14 = (JComponent)var6;
         }

         Rectangle var8;
         if (var6 instanceof JComponent) {
            var8 = ((JComponent)var6)._bounds;
         } else {
            var8 = ((Component)var6).getBounds();
         }

         this.tmpRect.width = var8.width;
         this.tmpRect.height = var8.height;
         SwingUtilities.computeIntersection(this.tmpRect.x, this.tmpRect.y, this.tmpRect.width, this.tmpRect.height, var7);
         var7.x += var8.x;
         var7.y += var8.y;
         var9 += var8.x;
         var10 += var8.y;
      }

      if (var6 != null && ((Component)var6).getPeer() != null) {
         var7.x -= var9;
         var7.y -= var10;

         SwingGraphics var5;
         try {
            var5 = SwingGraphics.createSwingGraphics(var15.getGraphics());
         } catch (NullPointerException var22) {
            var5 = null;
            ((Throwable)var22).printStackTrace();
         }

         if (var5 == null) {
            System.err.println("In paintImmediately null graphics");
         } else if (var13) {
            Image var17 = var16.getOffscreenBuffer(var14, var7.width, var7.height);
            this.paintWithBuffer(var15, var5, var7, var17);
            ((Graphics)var5).dispose();
         } else {
            ((Graphics)var5).setClip(var7.x, var7.y, var7.width, var7.height);

            try {
               var15.paint(var5);
            } finally {
               ((Graphics)var5).dispose();
            }

         }
      }
   }

   private void paintWithBuffer(JComponent var1, Graphics var2, Rectangle var3, Image var4) {
      SwingGraphics var5 = SwingGraphics.createSwingGraphics(var4.getGraphics());
      int var6 = var4.getWidth((ImageObserver)null);
      int var7 = var4.getHeight((ImageObserver)null);
      if (var6 > var3.width) {
         var6 = var3.width;
      }

      if (var7 > var3.height) {
         var7 = var3.height;
      }

      try {
         var1.setFlag(2, true);
         var1.setFlag(3, true);
         int var8 = var3.x;

         for(int var10 = var3.x + var3.width; var8 < var10; var8 += var6) {
            int var9 = var3.y;

            for(int var11 = var3.y + var3.height; var9 < var11; var9 += var7) {
               if (var9 + var7 >= var11 && var8 + var6 >= var10) {
                  var1.setFlag(3, false);
               }

               ((Graphics)var5).translate(-var8, -var9);
               ((Graphics)var5).setClip(var8, var9, var6, var7);
               var1.paint(var5);
               var2.setClip(var8, var9, var6, var7);
               var2.drawImage(var4, var8, var9, var1);
               ((Graphics)var5).translate(var8, var9);
            }
         }
      } finally {
         var1.setFlag(2, false);
         var1.setFlag(3, false);
         ((Graphics)var5).dispose();
      }

   }

   private void setFlag(int var1, boolean var2) {
      if (var2) {
         this.flags |= 1 << var1;
      } else {
         this.flags &= ~(1 << var1);
      }
   }

   private boolean getFlag(int var1) {
      int var2 = 1 << var1;
      return (this.flags & var2) == var2;
   }

   public void setDoubleBuffered(boolean var1) {
      this.setFlag(1, var1);
   }

   public boolean isDoubleBuffered() {
      return this.getFlag(1);
   }

   public JRootPane getRootPane() {
      return SwingUtilities.getRootPane(this);
   }

   // $FF: synthetic method
   static Class class$(String var0) {
      try {
         return Class.forName(var0);
      } catch (ClassNotFoundException var2) {
         throw new NoClassDefFoundError(((Throwable)var2).getMessage());
      }
   }
}