keyboardfocusmanager.java

this gcc-g++-3.3.1.tar.gz is a source file of gcc, you can learn more about gcc through this codes f

  {
    // XXX Should this send focus events to the windows involved?
    firePropertyChange("activeWindow", activeWindow, window);
    try
      {
        fireVetoableChange("activeWindow", activeWindow, window);
        activeWindow = window;
      }
    catch (PropertyVetoException e)
      {
      }
  }

  public FocusTraversalPolicy getDefaultFocusTraversalPolicy()
  {
    if (defaultPolicy == null)
      defaultPolicy = new DefaultFocusTraversalPolicy();
    return defaultPolicy;
  }

  public void setDefaultFocusTraversalPolicy(FocusTraversalPolicy policy)
  {
    if (policy == null)
      throw new IllegalArgumentException();
    firePropertyChange("defaultFocusTraversalPolicy", defaultPolicy, policy);
    defaultPolicy = policy;
  }

  public void setDefaultFocusTraversalKeys(int id, Set keystrokes)
  {
    if (keystrokes == null)
      throw new IllegalArgumentException();
    Set sa;
    Set sb;
    Set sc;
    String type;
    switch (id)
      {
      case FORWARD_TRAVERSAL_KEYS:
        sa = defaultFocusKeys[BACKWARD_TRAVERSAL_KEYS];
        sb = defaultFocusKeys[UP_CYCLE_TRAVERSAL_KEYS];
        sc = defaultFocusKeys[DOWN_CYCLE_TRAVERSAL_KEYS];
        type = "forwardDefaultFocusTraversalKeys";
        break;
      case BACKWARD_TRAVERSAL_KEYS:
        sa = defaultFocusKeys[FORWARD_TRAVERSAL_KEYS];
        sb = defaultFocusKeys[UP_CYCLE_TRAVERSAL_KEYS];
        sc = defaultFocusKeys[DOWN_CYCLE_TRAVERSAL_KEYS];
        type = "backwardDefaultFocusTraversalKeys";
        break;
      case UP_CYCLE_TRAVERSAL_KEYS:
        sa = defaultFocusKeys[FORWARD_TRAVERSAL_KEYS];
        sb = defaultFocusKeys[BACKWARD_TRAVERSAL_KEYS];
        sc = defaultFocusKeys[DOWN_CYCLE_TRAVERSAL_KEYS];
        type = "upCycleDefaultFocusTraversalKeys";
        break;
      case DOWN_CYCLE_TRAVERSAL_KEYS:
        sa = defaultFocusKeys[FORWARD_TRAVERSAL_KEYS];
        sb = defaultFocusKeys[BACKWARD_TRAVERSAL_KEYS];
        sc = defaultFocusKeys[UP_CYCLE_TRAVERSAL_KEYS];
        type = "downCycleDefaultFocusTraversalKeys";
        break;
      default:
        throw new IllegalArgumentException();
      }
    int i = keystrokes.size();
    Iterator iter = keystrokes.iterator();
    while (--i >= 0)
      {
        Object o = iter.next();
        if (! (o instanceof AWTKeyStroke)
            || sa.contains(o) || sb.contains(o) || sc.contains(o)
            || ((AWTKeyStroke) o).keyCode == KeyEvent.VK_UNDEFINED)
          throw new IllegalArgumentException();
      }
    keystrokes = Collections.unmodifiableSet(new HashSet(keystrokes));
    firePropertyChange(type, defaultFocusKeys[id], keystrokes);
    defaultFocusKeys[id] = keystrokes;
  }

  public Set getDefaultFocusTraversalKeys(int id)
  {
    if (id < FORWARD_TRAVERSAL_KEYS || id > DOWN_CYCLE_TRAVERSAL_KEYS)
      throw new IllegalArgumentException();
    return defaultFocusKeys[id];
  }

  public Container getCurrentFocusCycleRoot()
  {
    // XXX Need an easy way to test if this thread is in the context of the
    // global focus owner, to avoid creating the exception in the first place.
    try
      {
        return getGlobalCurrentFocusCycleRoot();
      }
    catch (SecurityException e)
      {
        return null;
      }
  }

  protected Container getGlobalCurrentFocusCycleRoot()
  {
    // XXX Need a way to test if this thread is in the context of the focus
    // owner, and throw a SecurityException if that is the case.
    // XXX Implement.
    return focusCycleRoot;
  }

  protected void setGlobalCurrentFocusCycleRoot(Container cycleRoot)
  {
    firePropertyChange("currentFocusCycleRoot", focusCycleRoot, cycleRoot);
    focusCycleRoot = cycleRoot;
  }

  public void addPropertyChangeListener(PropertyChangeListener l)
  {
    if (l != null)
      propertyChangeSupport.addPropertyChangeListener(l);
  }

  public void removePropertyChangeListener(PropertyChangeListener l)
  {
    if (l != null)
      propertyChangeSupport.removePropertyChangeListener(l);
  }

  public PropertyChangeListener[] getPropertyChangeListeners()
  {
    return propertyChangeSupport.getPropertyChangeListeners();
  }

  public void addPropertyChangeListener(String name, PropertyChangeListener l)
  {
    if (l != null)
      propertyChangeSupport.addPropertyChangeListener(name, l);
  }

  public void removePropertyChangeListener(String name,
                                           PropertyChangeListener l)
  {
    if (l != null)
      propertyChangeSupport.removePropertyChangeListener(name, l);
  }

  public PropertyChangeListener[] getPropertyChangeListeners(String name)
  {
    return propertyChangeSupport.getPropertyChangeListeners(name);
  }

  protected void firePropertyChange(String name, Object o, Object n)
  {
    propertyChangeSupport.firePropertyChange(name, o, n);
  }

  public void addVetoableChangeListener(VetoableChangeListener l)
  {
    if (l != null)
      vetoableChangeSupport.addVetoableChangeListener(l);
  }

  public void removeVetoableChangeListener(VetoableChangeListener l)
  {
    if (l != null)
      vetoableChangeSupport.removeVetoableChangeListener(l);
  }

  public VetoableChangeListener[] getVetoableChangeListeners()
  {
    return vetoableChangeSupport.getVetoableChangeListeners();
  }

  public void addVetoableChangeListener(String name, VetoableChangeListener l)
  {
    if (l != null)
      vetoableChangeSupport.addVetoableChangeListener(name, l);
  }

  public void removeVetoableChangeListener(String name,
                                           VetoableChangeListener l)
  {
    if (l != null)
      vetoableChangeSupport.removeVetoableChangeListener(name, l);
  }

  public VetoableChangeListener[] getVetoableChangeListeners(String name)
  {
    return vetoableChangeSupport.getVetoableChangeListeners(name);
  }

  protected void fireVetoableChange(String name, Object o, Object n)
    throws PropertyVetoException
  {
    vetoableChangeSupport.fireVetoableChange(name, o, n);
  }

  public void addKeyEventDispatcher(KeyEventDispatcher dispatcher)
  {
    if (dispatcher != null)
      keyEventDispatchers.add(dispatcher);
  }

  public void removeKeyEventDispatcher(KeyEventDispatcher dispatcher)
  {
    keyEventDispatchers.remove(dispatcher);
  }

  protected List getKeyEventDispatchers()
  {
    return (List) keyEventDispatchers.clone();
  }

  public void addKeyEventPostProcessor(KeyEventPostProcessor postProcessor)
  {
    if (postProcessor != null)
      keyEventPostProcessors.add(postProcessor);
  }

  public void removeKeyEventPostProcessor(KeyEventPostProcessor postProcessor)
  {
    keyEventPostProcessors.remove(postProcessor);
  }

  protected List getKeyEventPostProcessors()
  {
    return (List) keyEventPostProcessors.clone();
  }

  public abstract boolean dispatchEvent(AWTEvent e);

  public final void redispatchEvent(Component target, AWTEvent e)
  {
    throw new Error("not implemented");
  }

  public abstract boolean dispatchKeyEvent(KeyEvent e);

  public abstract boolean postProcessKeyEvent(KeyEvent e);

  public abstract void processKeyEvent(Component focused, KeyEvent e);

  protected abstract void enqueueKeyEvents(long after, Component untilFocused);

  protected abstract void dequeueKeyEvents(long after, Component untilFocused);

  protected abstract void discardKeyEvents(Component comp);

  public abstract void focusNextComponent(Component comp);

  public abstract void focusPreviousComponent(Component comp);

  public abstract void upFocusCycle(Component comp);

  public abstract void downFocusCycle(Container cont);

  public final void focusNextComponent()
  {
    focusNextComponent(focusOwner);
  }

  public final void focusPreviousComponent()
  {
    focusPreviousComponent(focusOwner);
  }

  public final void upFocusCycle()
  {
    upFocusCycle(focusOwner);
  }

  public final void downFocusCycle()
  {
    if (focusOwner instanceof Container
        && ((Container) focusOwner).isFocusCycleRoot())
      downFocusCycle((Container) focusOwner);
  }
} // class KeyboardFocusManager