Java CausedFocusEvent.Cause方法代码示例

import sun.awt.CausedFocusEvent; //导入方法依赖的package包/类
boolean addLightweightRequest(Component descendant,
                              boolean temporary, CausedFocusEvent.Cause cause) {
    if (log.isLoggable(PlatformLogger.Level.FINE)) {
        if (this == HeavyweightFocusRequest.CLEAR_GLOBAL_FOCUS_OWNER) {
            log.fine("Assertion (this != HeavyweightFocusRequest.CLEAR_GLOBAL_FOCUS_OWNER) failed");
        }
        if (descendant == null) {
            log.fine("Assertion (descendant != null) failed");
        }
    }

    Component lastDescendant = ((lightweightRequests.size() > 0)
        ? lightweightRequests.getLast().component
        : null);

    if (descendant != lastDescendant) {
        // Not a duplicate request
        lightweightRequests.add
            (new LightweightFocusRequest(descendant, temporary, cause));
        return true;
    } else {
        return false;
    }
}
 

import sun.awt.CausedFocusEvent; //导入方法依赖的package包/类
@Override
public boolean requestWindowFocus(CausedFocusEvent.Cause cause) {
    if (!focusAllowedFor()) {
        return false;
    }
    if (getPlatformWindow().rejectFocusRequest(cause)) {
        return false;
    }

    Window opposite = LWKeyboardFocusManagerPeer.getInstance().
        getCurrentFocusedWindow();

    changeFocusedWindow(true, opposite);

    return true;
}
 

import sun.awt.CausedFocusEvent; //导入方法依赖的package包/类
public static boolean deliverFocus(Component lightweightChild,
                                   Component target,
                                   boolean temporary,
                                   boolean focusedWindowChangeAllowed,
                                   long time,
                                   CausedFocusEvent.Cause cause)
{
    // TODO: do something to eliminate this forwarding
    return KeyboardFocusManagerPeerImpl.deliverFocus(lightweightChild,
                                                     target,
                                                     temporary,
                                                     focusedWindowChangeAllowed,
                                                     time,
                                                     cause,
                                                     getNativeFocusOwner());
}
 

import sun.awt.CausedFocusEvent; //导入方法依赖的package包/类
private boolean isRequestFocusAccepted(boolean temporary,
                                       boolean focusedWindowChangeAllowed,
                                       CausedFocusEvent.Cause cause)
{
    if (!isFocusable() || !isVisible()) {
        if (focusLog.isLoggable(PlatformLogger.FINEST)) {
            focusLog.finest("Not focusable or not visible");
        }
        return false;
    }

    ComponentPeer peer = this.peer;
    if (peer == null) {
        if (focusLog.isLoggable(PlatformLogger.FINEST)) {
            focusLog.finest("peer is null");
        }
        return false;
    }

    Window window = getContainingWindow();
    if (window == null || !((Window)window).isFocusableWindow()) {
        if (focusLog.isLoggable(PlatformLogger.FINEST)) {
            focusLog.finest("Component doesn't have toplevel");
        }
        return false;
    }

    // We have passed all regular checks for focus request,
    // now let's call RequestFocusController and see what it says.
    Component focusOwner = KeyboardFocusManager.getMostRecentFocusOwner(window);
    if (focusOwner == null) {
        // sometimes most recent focus owner may be null, but focus owner is not
        // e.g. we reset most recent focus owner if user removes focus owner
        focusOwner = KeyboardFocusManager.getCurrentKeyboardFocusManager().getFocusOwner();
        if (focusOwner != null && focusOwner.getContainingWindow() != window) {
            focusOwner = null;
        }
    }

    if (focusOwner == this || focusOwner == null) {
        // Controller is supposed to verify focus transfers and for this it
        // should know both from and to components.  And it shouldn't verify
        // transfers from when these components are equal.
        if (focusLog.isLoggable(PlatformLogger.FINEST)) {
            focusLog.finest("focus owner is null or this");
        }
        return true;
    }

    if (CausedFocusEvent.Cause.ACTIVATION == cause) {
        // we shouldn't call RequestFocusController in case we are
        // in activation.  We do request focus on component which
        // has got temporary focus lost and then on component which is
        // most recent focus owner.  But most recent focus owner can be
        // changed by requestFocsuXXX() call only, so this transfer has
        // been already approved.
        if (focusLog.isLoggable(PlatformLogger.FINEST)) {
            focusLog.finest("cause is activation");
        }
        return true;
    }

    boolean ret = Component.requestFocusController.acceptRequestFocus(focusOwner,
                                                                      this,
                                                                      temporary,
                                                                      focusedWindowChangeAllowed,
                                                                      cause);
    if (focusLog.isLoggable(PlatformLogger.FINEST)) {
        focusLog.finest("RequestFocusController returns {0}", ret);
    }

    return ret;
}
 

import sun.awt.CausedFocusEvent; //导入方法依赖的package包/类
public int shouldNativelyFocusHeavyweight(Component heavyweight,
                                   Component descendant,
                                   boolean temporary,
                                   boolean focusedWindowChangeAllowed,
                                   long time,
                                   CausedFocusEvent.Cause cause)
{
    return KeyboardFocusManager.shouldNativelyFocusHeavyweight(
        heavyweight, descendant, temporary, focusedWindowChangeAllowed, time, cause);
}
 

import sun.awt.CausedFocusEvent; //导入方法依赖的package包/类
@Override
public boolean requestFocus
     (Component lightweightChild, boolean temporary,
      boolean focusedWindowChangeAllowed, long time, CausedFocusEvent.Cause cause)
{
    return false;
}
 

import sun.awt.CausedFocusEvent; //导入方法依赖的package包/类
@Override
public boolean rejectFocusRequest(CausedFocusEvent.Cause cause) {
    // Cross-app activation requests are not allowed.
    if (cause != CausedFocusEvent.Cause.MOUSE_EVENT &&
        !target.isParentWindowActive())
    {
        focusLogger.fine("the embedder is inactive, so the request is rejected");
        return true;
    }
    return false;
}
 

import sun.awt.CausedFocusEvent; //导入方法依赖的package包/类
public static boolean deliverFocus(Component lightweightChild,
                                   Component target,
                                   boolean temporary,
                                   boolean focusedWindowChangeAllowed,
                                   long time,
                                   CausedFocusEvent.Cause cause)
{
    return KeyboardFocusManagerPeerImpl.deliverFocus(lightweightChild,
                                                     target,
                                                     temporary,
                                                     focusedWindowChangeAllowed,
                                                     time,
                                                     cause,
                                                     getInstance().getCurrentFocusOwner());
}
 

import sun.awt.CausedFocusEvent; //导入方法依赖的package包/类
@Override
public boolean requestFocus
     (Component lightweightChild, boolean temporary,
      boolean focusedWindowChangeAllowed, long time, CausedFocusEvent.Cause cause)
{

    return false;
}
 

import sun.awt.CausedFocusEvent; //导入方法依赖的package包/类
LightweightFocusRequest(Component component, boolean temporary, CausedFocusEvent.Cause cause) {
    this.component = component;
    this.temporary = temporary;
    this.cause = cause;
}
 

import sun.awt.CausedFocusEvent; //导入方法依赖的package包/类
boolean requestFocusInWindow(CausedFocusEvent.Cause cause) {
    return requestFocusHelper(false, false, cause);
}
 

import sun.awt.CausedFocusEvent; //导入方法依赖的package包/类
public boolean requestFocus(Component comp, CausedFocusEvent.Cause cause) {
    return comp.requestFocus(cause);
}
 

import sun.awt.CausedFocusEvent; //导入方法依赖的package包/类
boolean requestFocus(boolean temporary, CausedFocusEvent.Cause cause) {
    return requestFocusHelper(temporary, true, cause);
}
 

import sun.awt.CausedFocusEvent; //导入方法依赖的package包/类
private boolean isRequestFocusAccepted(boolean temporary,
                                       boolean focusedWindowChangeAllowed,
                                       CausedFocusEvent.Cause cause)
{
    if (!isFocusable() || !isVisible()) {
        if (focusLog.isLoggable(PlatformLogger.Level.FINEST)) {
            focusLog.finest("Not focusable or not visible");
        }
        return false;
    }

    ComponentPeer peer = this.peer;
    if (peer == null) {
        if (focusLog.isLoggable(PlatformLogger.Level.FINEST)) {
            focusLog.finest("peer is null");
        }
        return false;
    }

    Window window = getContainingWindow();
    if (window == null || !window.isFocusableWindow()) {
        if (focusLog.isLoggable(PlatformLogger.Level.FINEST)) {
            focusLog.finest("Component doesn't have toplevel");
        }
        return false;
    }

    // We have passed all regular checks for focus request,
    // now let's call RequestFocusController and see what it says.
    Component focusOwner = KeyboardFocusManager.getMostRecentFocusOwner(window);
    if (focusOwner == null) {
        // sometimes most recent focus owner may be null, but focus owner is not
        // e.g. we reset most recent focus owner if user removes focus owner
        focusOwner = KeyboardFocusManager.getCurrentKeyboardFocusManager().getFocusOwner();
        if (focusOwner != null && focusOwner.getContainingWindow() != window) {
            focusOwner = null;
        }
    }

    if (focusOwner == this || focusOwner == null) {
        // Controller is supposed to verify focus transfers and for this it
        // should know both from and to components.  And it shouldn't verify
        // transfers from when these components are equal.
        if (focusLog.isLoggable(PlatformLogger.Level.FINEST)) {
            focusLog.finest("focus owner is null or this");
        }
        return true;
    }

    if (CausedFocusEvent.Cause.ACTIVATION == cause) {
        // we shouldn't call RequestFocusController in case we are
        // in activation.  We do request focus on component which
        // has got temporary focus lost and then on component which is
        // most recent focus owner.  But most recent focus owner can be
        // changed by requestFocsuXXX() call only, so this transfer has
        // been already approved.
        if (focusLog.isLoggable(PlatformLogger.Level.FINEST)) {
            focusLog.finest("cause is activation");
        }
        return true;
    }

    boolean ret = Component.requestFocusController.acceptRequestFocus(focusOwner,
                                                                      this,
                                                                      temporary,
                                                                      focusedWindowChangeAllowed,
                                                                      cause);
    if (focusLog.isLoggable(PlatformLogger.Level.FINEST)) {
        focusLog.finest("RequestFocusController returns {0}", ret);
    }

    return ret;
}
 

import sun.awt.CausedFocusEvent; //导入方法依赖的package包/类
@Override
@SuppressWarnings("deprecation")
public boolean requestFocus(Component lightweightChild, boolean temporary,
                            boolean focusedWindowChangeAllowed, long time,
                            CausedFocusEvent.Cause cause)
{
    if (WKeyboardFocusManagerPeer.
        processSynchronousLightweightTransfer((Component)target, lightweightChild, temporary,
                                              focusedWindowChangeAllowed, time))
    {
        return true;
    }

    int result = WKeyboardFocusManagerPeer
        .shouldNativelyFocusHeavyweight((Component)target, lightweightChild,
                                        temporary, focusedWindowChangeAllowed,
                                        time, cause);

    switch (result) {
      case WKeyboardFocusManagerPeer.SNFH_FAILURE:
          return false;
      case WKeyboardFocusManagerPeer.SNFH_SUCCESS_PROCEED:
          if (focusLog.isLoggable(PlatformLogger.Level.FINER)) {
              focusLog.finer("Proceeding with request to " + lightweightChild + " in " + target);
          }
          Window parentWindow = SunToolkit.getContainingWindow((Component)target);
          if (parentWindow == null) {
              return rejectFocusRequestHelper("WARNING: Parent window is null");
          }
          WWindowPeer wpeer = (WWindowPeer)parentWindow.getPeer();
          if (wpeer == null) {
              return rejectFocusRequestHelper("WARNING: Parent window's peer is null");
          }
          boolean res = wpeer.requestWindowFocus(cause);

          if (focusLog.isLoggable(PlatformLogger.Level.FINER)) {
              focusLog.finer("Requested window focus: " + res);
          }
          // If parent window can be made focused and has been made focused(synchronously)
          // then we can proceed with children, otherwise we retreat.
          if (!(res && parentWindow.isFocused())) {
              return rejectFocusRequestHelper("Waiting for asynchronous processing of the request");
          }
          return WKeyboardFocusManagerPeer.deliverFocus(lightweightChild,
                                                        (Component)target,
                                                        temporary,
                                                        focusedWindowChangeAllowed,
                                                        time, cause);

      case WKeyboardFocusManagerPeer.SNFH_SUCCESS_HANDLED:
          // Either lightweight or excessive request - all events are generated.
          return true;
    }
    return false;
}