1 /*
   2  * Copyright (c) 2003, 2009, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 package sun.awt;
  26 
  27 import java.awt.Component;
  28 import java.awt.KeyboardFocusManager;
  29 import java.awt.Window;
  30 import java.awt.Canvas;
  31 import java.awt.Scrollbar;
  32 import java.awt.Panel;
  33 
  34 import java.awt.event.FocusEvent;
  35 
  36 import java.awt.peer.KeyboardFocusManagerPeer;
  37 import java.awt.peer.ComponentPeer;
  38 
  39 import java.lang.reflect.InvocationTargetException;
  40 import java.lang.reflect.Method;
  41 
  42 import sun.util.logging.PlatformLogger;
  43 
  44 public abstract class KeyboardFocusManagerPeerImpl implements KeyboardFocusManagerPeer {
  45 
  46     private static final PlatformLogger focusLog = PlatformLogger.getLogger("sun.awt.focus.KeyboardFocusManagerPeerImpl");
  47 
  48     private static AWTAccessor.KeyboardFocusManagerAccessor kfmAccessor =
  49         AWTAccessor.getKeyboardFocusManagerAccessor();
  50 
  51     // The constants are copied from java.awt.KeyboardFocusManager
  52     public static final int SNFH_FAILURE         = 0;
  53     public static final int SNFH_SUCCESS_HANDLED = 1;
  54     public static final int SNFH_SUCCESS_PROCEED = 2;
  55 
  56     protected KeyboardFocusManager manager;
  57 
  58     public KeyboardFocusManagerPeerImpl(KeyboardFocusManager manager) {
  59         this.manager = manager;
  60     }
  61 
  62     @Override
  63     public void clearGlobalFocusOwner(Window activeWindow) {
  64         if (activeWindow != null) {
  65             Component focusOwner = activeWindow.getFocusOwner();
  66             if (focusLog.isLoggable(PlatformLogger.FINE))
  67                 focusLog.fine("Clearing global focus owner " + focusOwner);
  68             if (focusOwner != null) {
  69                 FocusEvent fl = new CausedFocusEvent(focusOwner, FocusEvent.FOCUS_LOST, false, null,
  70                                                      CausedFocusEvent.Cause.CLEAR_GLOBAL_FOCUS_OWNER);
  71                 SunToolkit.postPriorityEvent(fl);
  72             }
  73         }
  74     }
  75 
  76     /*
  77      * WARNING: Don't call it on the Toolkit thread.
  78      *
  79      * Checks if the component:
  80      * 1) accepts focus on click (in general)
  81      * 2) may be a focus owner (in particular)
  82      */
  83     public static boolean shouldFocusOnClick(Component component) {
  84         boolean acceptFocusOnClick = false;
  85 
  86         // A component is generally allowed to accept focus on click
  87         // if its peer is focusable. There're some exceptions though.
  88 
  89 
  90         // CANVAS & SCROLLBAR accept focus on click
  91         if (component instanceof Canvas ||
  92             component instanceof Scrollbar)
  93         {
  94             acceptFocusOnClick = true;
  95 
  96         // PANEL, empty only, accepts focus on click
  97         } else if (component instanceof Panel) {
  98             acceptFocusOnClick = (((Panel)component).getComponentCount() == 0);
  99 
 100 
 101         // Other components
 102         } else {
 103             ComponentPeer peer = (component != null ? component.getPeer() : null);
 104             acceptFocusOnClick = (peer != null ? peer.isFocusable() : false);
 105         }
 106         return acceptFocusOnClick &&
 107                AWTAccessor.getComponentAccessor().canBeFocusOwner(component);
 108     }
 109 
 110     /*
 111      * Posts proper lost/gain focus events to the event queue.
 112      */
 113     public static boolean deliverFocus(Component lightweightChild,
 114                                        Component target,
 115                                        boolean temporary,
 116                                        boolean focusedWindowChangeAllowed,
 117                                        long time,
 118                                        CausedFocusEvent.Cause cause,
 119                                        Component currentFocusOwner) // provided by the descendant peers
 120     {
 121         if (lightweightChild == null) {
 122             lightweightChild = (Component)target;
 123         }
 124 
 125         Component currentOwner = currentFocusOwner;
 126         if (currentOwner != null && currentOwner.getPeer() == null) {
 127             currentOwner = null;
 128         }
 129         if (currentOwner != null) {
 130             FocusEvent fl = new CausedFocusEvent(currentOwner, FocusEvent.FOCUS_LOST,
 131                                                  false, lightweightChild, cause);
 132 
 133             if (focusLog.isLoggable(PlatformLogger.FINER))
 134                 focusLog.finer("Posting focus event: " + fl);
 135             SunToolkit.postEvent(SunToolkit.targetToAppContext(currentOwner), fl);
 136         }
 137 
 138         FocusEvent fg = new CausedFocusEvent(lightweightChild, FocusEvent.FOCUS_GAINED,
 139                                              false, currentOwner, cause);
 140 
 141         if (focusLog.isLoggable(PlatformLogger.FINER))
 142             focusLog.finer("Posting focus event: " + fg);
 143         SunToolkit.postEvent(SunToolkit.targetToAppContext(lightweightChild), fg);
 144         return true;
 145     }
 146 
 147     // WARNING: Don't call it on the Toolkit thread.
 148     public static boolean requestFocusFor(Component target, CausedFocusEvent.Cause cause) {
 149         return AWTAccessor.getComponentAccessor().requestFocus(target, cause);
 150     }
 151 
 152     // WARNING: Don't call it on the Toolkit thread.
 153     public static int shouldNativelyFocusHeavyweight(Component heavyweight,
 154                                                      Component descendant,
 155                                                      boolean temporary,
 156                                                      boolean focusedWindowChangeAllowed,
 157                                                      long time,
 158                                                      CausedFocusEvent.Cause cause)
 159     {
 160         return kfmAccessor.shouldNativelyFocusHeavyweight(
 161             heavyweight, descendant, temporary, focusedWindowChangeAllowed, time, cause);
 162     }
 163 
 164     public static void removeLastFocusRequest(Component heavyweight) {
 165         kfmAccessor.removeLastFocusRequest(heavyweight);
 166     }
 167 
 168     // WARNING: Don't call it on the Toolkit thread.
 169     public static boolean processSynchronousLightweightTransfer(Component heavyweight,
 170                                                                 Component descendant,
 171                                                                 boolean temporary,
 172                                                                 boolean focusedWindowChangeAllowed,
 173                                                                 long time)
 174     {
 175         return kfmAccessor.processSynchronousLightweightTransfer(
 176             heavyweight, descendant, temporary, focusedWindowChangeAllowed, time);
 177     }
 178 }