Reverting 18872.

views/focus/focus_manager.h

 // Copyright (c) 2006-2008 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef VIEWS_FOCUS_FOCUS_MANAGER_H_
 #define VIEWS_FOCUS_FOCUS_MANAGER_H_
 
 #if defined(OS_WIN)
 #include <windows.h>
 #endif
 #include <vector>
 #include <map>
 #include <list>
 
 #include "base/basictypes.h"
 #include "base/gfx/native_widget_types.h"
 #include "views/accelerator.h"
 
 // The FocusManager class is used to handle focus traversal, store/restore
 // focused views and handle keyboard accelerators.
 //
 // There are 2 types of focus:
-// - the native focus, which is the focus that an gfx::NativeView has.
+// - the native focus, which is the focus that an HWND has.
 // - the view focus, which is the focus that a views::View has.
 //
 // Each native view must register with their Focus Manager so the focus manager
 // gets notified when they are focused (and keeps track of the native focus) and
 // as well so that the tab key events can be intercepted.
 // They can provide when they register a View that is kept in synch in term of
 // focus. This is used in NativeControl for example, where a View wraps an
 // actual native window.
 // This is already done for you if you subclass the NativeControl class or if
 // you use the NativeViewHost class.
 //
-// When creating a top window (derived from views::Widget) that is not a child
-// window, it creates and owns a FocusManager to manage the focus for itself and
-// all its child windows.
+// When creating a top window, if it derives from WidgetWin, the
+// |has_own_focus_manager| of the Init method lets you specify whether that
+// window should have its own focus manager (so focus traversal stays confined
+// in that window). If you are not deriving from WidgetWin or one of its
+// derived classes (Window, FramelessWindow, ConstrainedWindow), you must
+// create a FocusManager when the window is created (it is automatically deleted
+// when the window is destroyed).
 //
 // The FocusTraversable interface exposes the methods a class should implement
 // in order to be able to be focus traversed when tab key is pressed.
 // RootViews implement FocusTraversable.
 // The FocusManager contains a top FocusTraversable instance, which is the top
 // RootView.
 //
 // If you just use views, then the focus traversal is handled for you by the
 // RootView. The default traversal order is the order in which the views have
 // been added to their container. You can modify this order by using the View
@@ skipping 18 matching lines @@
 //   with when going to the next/previous view.
 //   In our example:
 //   hwnd_view_container_->GetRootView()->SetFocusTraversableParent(
 //      native_control);
 //
 // Note that FocusTraversable do not have to be RootViews: TabContents is
 // FocusTraversable.
 
 namespace views {
 
+class View;
 class RootView;
-class View;
-class Widget;
 
 // The FocusTraversable interface is used by components that want to process
 // focus traversal events (due to Tab/Shift-Tab key events).
 class FocusTraversable {
  public:
   // The direction in which the focus traversal is going.
   // TODO (jcampan): add support for lateral (left, right) focus traversal. The
   // goal is to switch to focusable views on the same level when using the arrow
   // keys (ala Windows: in a dialog box, arrow keys typically move between the
   // dialog OK, Cancel buttons).
@@ skipping 54 matching lines @@
 
 // This interface should be implemented by classes that want to be notified when
 // the focus is about to change.  See the Add/RemoveFocusChangeListener methods.
 class FocusChangeListener {
  public:
   virtual void FocusWillChange(View* focused_before, View* focused_now) = 0;
 };
 
 class FocusManager {
  public:
-  explicit FocusManager(Widget* widget);
-  ~FocusManager();
+#if defined(OS_WIN)
+  // Creates a FocusManager for the specified window. Top level windows
+  // must invoked this when created.
+  // The RootView specified should be the top RootView of the window.
+  // This also invokes InstallFocusSubclass.
+  static FocusManager* CreateFocusManager(HWND window, RootView* root_view);
+#endif
+
+  static FocusManager* GetFocusManager(gfx::NativeView window);
 
 #if defined(OS_WIN)
+  // Message handlers (for messages received from registered windows).
+  // Should return true if the message should be forwarded to the window
+  // original proc function, false otherwise.
+  bool OnSetFocus(HWND window);
+  bool OnNCDestroy(HWND window);
   // OnKeyDown covers WM_KEYDOWN and WM_SYSKEYDOWN.
   bool OnKeyDown(HWND window,
                  UINT message,
                  WPARAM wparam,
                  LPARAM lparam);
   bool OnKeyUp(HWND window,
                UINT message,
                WPARAM wparam,
                LPARAM lparam);
 #endif
 
   // Returns true is the specified is part of the hierarchy of the window
   // associated with this FocusManager.
   bool ContainsView(View* view);
 
   // Advances the focus (backward if reverse is true).
   void AdvanceFocus(bool reverse);
 
   // The FocusManager is handling the selected view for the RootView.
   View* GetFocusedView() const { return focused_view_; }
   void SetFocusedView(View* view);
 
   // Clears the focused view. The window associated with the top root view gets
   // the native focus (so we still get keyboard events).
   void ClearFocus();
 
+  // Clears the HWND that has the focus by focusing the HWND from the top
+  // RootView (so we still get keyboard events).
+  // Note that this does not change the currently focused view.
+  void ClearHWNDFocus();
+
+#if defined(OS_WIN)
+  // Focus the specified |hwnd| without changing the focused view.
+  void FocusHWND(HWND hwnd);
+#endif
+
   // Validates the focused view, clearing it if the window it belongs too is not
   // attached to the window hierarchy anymore.
   void ValidateFocusedView();
 
+#if defined(OS_WIN)
+  // Returns the view associated with the specified window if any.
+  // If |look_in_parents| is true, it goes up the window parents until it find
+  // a view.
+  static View* GetViewForWindow(HWND window, bool look_in_parents);
+#endif
+
   // Stores and restores the focused view. Used when the window becomes
   // active/inactive.
   void StoreFocusedView();
   void RestoreFocusedView();
 
   // Clears the stored focused view.
   void ClearStoredFocusedView();
 
+  // Returns the FocusManager of the parent window of the window that is the
+  // root of this FocusManager. This is useful with ConstrainedWindows that have
+  // their own FocusManager and need to return focus to the browser when closed.
+  FocusManager* GetParentFocusManager() const;
+
   // Register a keyboard accelerator for the specified target. If multiple
   // targets are registered for an accelerator, a target registered later has
   // higher priority.
   // Note that we are currently limited to accelerators that are either:
   // - a key combination including Ctrl or Alt
   // - the escape key
   // - the enter key
   // - any F key (F1, F2, F3 ...)
   // - any browser specific keys (as available on special keyboards)
   void RegisterAccelerator(const Accelerator& accelerator,
@@ skipping 31 matching lines @@
   // keyboard accelerator, or NULL if no view is registered for that keyboard
   // accelerator.
   AcceleratorTarget* GetCurrentTargetForAccelerator(
       const Accelerator& accelertor) const;
 
   // Convenience method that returns true if the passed |key_event| should
   // trigger tab traversal (if it is a TAB key press with or without SHIFT
   // pressed).
   static bool IsTabTraversalKeyEvent(const KeyEvent& key_event);
 
-  // Sets the focus to the specified native view.
-  virtual void FocusNativeView(gfx::NativeView native_view);
+ private:
+#if defined(OS_WIN)
+  explicit FocusManager(HWND root, RootView* root_view);
 
-  // Clears the native view having the focus.
-  virtual void ClearNativeFocus();
+  // Subclasses the specified window. The subclassed window procedure listens
+  // for WM_SETFOCUS notification and keeps the FocusManager's focus owner
+  // property in sync.
+  // It's not necessary to explicitly invoke Uninstall, it's automatically done
+  // when the window is destroyed and Uninstall wasn't invoked.
+  static void InstallFocusSubclass(HWND window, View* view);
 
-  // Retrieves the FocusManager associated with the passed native view.
-  static FocusManager* GetFocusManagerForNativeView(
-      gfx::NativeView native_view);
+  // Uninstalls the window subclass installed by InstallFocusSubclass.
+  static void UninstallFocusSubclass(HWND window);
+#endif
+  ~FocusManager();
 
- private:
   // Returns the next focusable view.
   View* GetNextFocusableView(View* starting_view, bool reverse, bool dont_loop);
 
   // Returns the focusable view found in the FocusTraversable specified starting
   // at the specified view. This traverses down along the FocusTraversable
   // hierarchy.
   // Returns NULL if no focusable view were found.
   View* FindFocusableView(FocusTraversable* focus_traversable,
                           View* starting_view,
                           bool reverse);
 
-  // The top-level Widget this FocusManager is associated with.
-  Widget* widget_;
+  // The RootView of the window associated with this FocusManager.
+  RootView* top_root_view_;
 
   // The view that currently is focused.
   View* focused_view_;
 
   // The storage id used in the ViewStorage to store/restore the view that last
   // had focus.
   int stored_focused_view_storage_id_;
 
+  // The window associated with this focus manager.
+  gfx::NativeView root_;
+
+  // Used to allow setting the focus on an HWND without changing the currently
+  // focused view.
+  bool ignore_set_focus_msg_;
+
   // The accelerators and associated targets.
   typedef std::list<AcceleratorTarget*> AcceleratorTargetList;
   typedef std::map<Accelerator, AcceleratorTargetList> AcceleratorMap;
   AcceleratorMap accelerators_;
 
   // The list of registered keystroke listeners
   typedef std::vector<KeystrokeListener*> KeystrokeListenerList;
   KeystrokeListenerList keystroke_listeners_;
 
   // The list of registered FocusChange listeners.
   typedef std::vector<FocusChangeListener*> FocusChangeListenerList;
   FocusChangeListenerList focus_change_listeners_;
 
   DISALLOW_COPY_AND_ASSIGN(FocusManager);
 };
 
 }  // namespace views
 
 #endif  // VIEWS_FOCUS_FOCUS_MANAGER_H_