wellton/chromium
1
0
Fork 0
Código Issues Pull Requests Ações Pacotes Projetos Versões Wiki Atividade

This CL removes the last (major) Windows specific part out of the focus manager.

Ver Código-Fonte 
It was previously landed and reverted because it broke the reliability tests.
http://codereview.chromium.org/125148

The breakage was caused by constrained windows not getting a hold of the FocusManager when in unparented tabs.
The fix is to ensure unparented tab still have a way to access their FocusManager for proper closure.
Files changed from the previous patch that need reviewing:
native_tab_contents_container_win.cc
tab_contents_view_win.h
tab_contents_view_win.cc

BUG=None
TEST=Run all tests (unit, ui, interactive). Extensively test the focus in Chrome.



Review URL: http://codereview.chromium.org/146093

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@19617 0039d316-1c4b-4281-b951-d872f2087c98
Esse commit está contido em:
jcampan@chromium.org
2009-06-30 18:48:00 +00:00
pai da9acbd48d
commit e29b47dae1
50 arquivos alterados com 266 adições e 459 exclusões
Baixar Arquivo de Patch Baixar Arquivo de Diff Expandir todos os arquivos Colapsar todos os arquivos
chrome/browser/autocomplete/autocomplete_edit_view_win.cc
+1 -2
Ver Arquivo
@@ -1610,8 +1610,7 @@ void AutocompleteEditViewWin::OnPaste() {
}
void AutocompleteEditViewWin::OnSetFocus(HWND focus_wnd) {
views::FocusManager* focus_manager =
views::FocusManager::GetFocusManager(m_hWnd);
views::FocusManager* focus_manager = parent_view_->GetFocusManager();
if (focus_manager) {
// Notify the FocusManager that the focused view is now the location bar
// (our parent view).
chrome/browser/automation/automation_provider.cc
+1 -1
Ver Arquivo
@@ -1705,7 +1705,7 @@ void AutomationProvider::GetFocusedViewID(int handle, int* view_id) {
if (window_tracker_->ContainsHandle(handle)) {
HWND hwnd = window_tracker_->GetResource(handle);
views::FocusManager* focus_manager =
views::FocusManager::GetFocusManager(hwnd);
views::FocusManager::GetFocusManagerForNativeView(hwnd);
DCHECK(focus_manager);
views::View* focused_view = focus_manager->GetFocusedView();
if (focused_view)
chrome/browser/browser_focus_uitest.cc
+11 -11
Ver Arquivo
@@ -108,7 +108,7 @@ IN_PROC_BROWSER_TEST_F(BrowserFocusTest, BrowsersRememberFocus) {
BrowserView* browser_view = BrowserView::GetBrowserViewForNativeWindow(hwnd);
ASSERT_TRUE(browser_view);
views::FocusManager* focus_manager =
views::FocusManager::GetFocusManager(hwnd);
views::FocusManager::GetFocusManagerForNativeView(hwnd);
ASSERT_TRUE(focus_manager);
EXPECT_EQ(browser_view->GetTabContentsContainerView(),
@@ -149,7 +149,7 @@ IN_PROC_BROWSER_TEST_F(BrowserFocusTest, BrowsersRememberFocus) {
BrowserView::GetBrowserViewForNativeWindow(hwnd2);
ASSERT_TRUE(browser_view2);
views::FocusManager* focus_manager2 =
views::FocusManager::GetFocusManager(hwnd2);
views::FocusManager::GetFocusManagerForNativeView(hwnd2);
ASSERT_TRUE(focus_manager2);
EXPECT_EQ(browser_view2->GetTabContentsContainerView(),
focus_manager2->GetFocusedView());
@@ -183,13 +183,13 @@ IN_PROC_BROWSER_TEST_F(BrowserFocusTest, TabsRememberFocus) {
ASSERT_TRUE(browser_view);
views::FocusManager* focus_manager =
views::FocusManager::GetFocusManager(hwnd);
views::FocusManager::GetFocusManagerForNativeView(hwnd);
ASSERT_TRUE(focus_manager);
// Create several tabs.
for (int i = 0; i < 4; ++i) {
browser()->AddTabWithURL(url, GURL(), PageTransition::TYPED, true, -1, false,
NULL);
browser()->AddTabWithURL(url, GURL(), PageTransition::TYPED, true, -1,
false, NULL);
}
// Alternate focus for the tab.
@@ -284,7 +284,7 @@ IN_PROC_BROWSER_TEST_F(BrowserFocusTest, LocationBarLockFocus) {
HWND hwnd = reinterpret_cast<HWND>(browser()->window()->GetNativeHandle());
BrowserView* browser_view = BrowserView::GetBrowserViewForNativeWindow(hwnd);
views::FocusManager* focus_manager =
views::FocusManager::GetFocusManager(hwnd);
views::FocusManager::GetFocusManagerForNativeView(hwnd);
// Click on the location bar.
LocationBarView* location_bar = browser_view->GetLocationBarView();
@@ -312,7 +312,7 @@ IN_PROC_BROWSER_TEST_F(BrowserFocusTest, FocusTraversal) {
HWND hwnd = reinterpret_cast<HWND>(browser()->window()->GetNativeHandle());
BrowserView* browser_view = BrowserView::GetBrowserViewForNativeWindow(hwnd);
views::FocusManager* focus_manager =
views::FocusManager::GetFocusManager(hwnd);
views::FocusManager::GetFocusManagerForNativeView(hwnd);
// Click on the location bar.
LocationBarView* location_bar = browser_view->GetLocationBarView();
@@ -402,7 +402,7 @@ IN_PROC_BROWSER_TEST_F(BrowserFocusTest, FocusTraversalOnInterstitial) {
HWND hwnd = reinterpret_cast<HWND>(browser()->window()->GetNativeHandle());
BrowserView* browser_view = BrowserView::GetBrowserViewForNativeWindow(hwnd);
views::FocusManager* focus_manager =
views::FocusManager::GetFocusManager(hwnd);
views::FocusManager::GetFocusManagerForNativeView(hwnd);
// Focus should be on the page.
EXPECT_EQ(browser_view->GetTabContentsContainerView(),
@@ -497,7 +497,7 @@ IN_PROC_BROWSER_TEST_F(BrowserFocusTest, InterstitialFocus) {
HWND hwnd = reinterpret_cast<HWND>(browser()->window()->GetNativeHandle());
BrowserView* browser_view = BrowserView::GetBrowserViewForNativeWindow(hwnd);
views::FocusManager* focus_manager =
views::FocusManager::GetFocusManager(hwnd);
views::FocusManager::GetFocusManagerForNativeView(hwnd);
// Page should have focus.
EXPECT_EQ(browser_view->GetTabContentsContainerView(),
@@ -542,7 +542,7 @@ IN_PROC_BROWSER_TEST_F(BrowserFocusTest, FindFocusTest) {
HWND hwnd = reinterpret_cast<HWND>(browser()->window()->GetNativeHandle());
BrowserView* browser_view = BrowserView::GetBrowserViewForNativeWindow(hwnd);
views::FocusManager* focus_manager =
views::FocusManager::GetFocusManager(hwnd);
views::FocusManager::GetFocusManagerForNativeView(hwnd);
LocationBarView* location_bar = browser_view->GetLocationBarView();
// Press Ctrl+F, which will make the Find box open and request focus.
@@ -615,7 +615,7 @@ IN_PROC_BROWSER_TEST_F(BrowserFocusTest, DISABLED_TabInitialFocus) {
BrowserView* browser_view = BrowserView::GetBrowserViewForNativeWindow(hwnd);
ASSERT_TRUE(browser_view);
views::FocusManager* focus_manager =
views::FocusManager::GetFocusManager(hwnd);
views::FocusManager::GetFocusManagerForNativeView(hwnd);
ASSERT_TRUE(focus_manager);
// Open the history tab, focus should be on the tab contents.
chrome/browser/external_tab_container.cc
+2 -1
Ver Arquivo
@@ -53,11 +53,12 @@ bool ExternalTabContainer::Init(Profile* profile,
}
set_window_style(WS_POPUP);
views::WidgetWin::Init(NULL, bounds, true);
views::WidgetWin::Init(NULL, bounds);
if (!IsWindow()) {
NOTREACHED();
return false;
}
// TODO(jcampan): limit focus traversal to contents.
// We don't ever remove the prop because the lifetime of this object
// is the same as the lifetime of the window
chrome/browser/first_run_win.cc
+1 -1
Ver Arquivo
@@ -684,7 +684,7 @@ class TryChromeDialog : public views::ButtonListener,
popup->set_delete_on_destroy(true);
popup->set_window_style(WS_POPUP | WS_CLIPCHILDREN);
popup->set_window_ex_style(WS_EX_TOOLWINDOW);
popup->Init(NULL, pos, true);
popup->Init(NULL, pos);
views::RootView* root_view = popup->GetRootView();
// The window color is a tiny bit off-white.
chrome/browser/renderer_host/render_widget_host_view_win.cc
+1 -1
Ver Arquivo
@@ -406,7 +406,7 @@ void RenderWidgetHostViewWin::Focus() {
void RenderWidgetHostViewWin::Blur() {
views::FocusManager* focus_manager =
views::FocusManager::GetFocusManager(GetParent());
views::FocusManager::GetFocusManagerForNativeView(m_hWnd);
// We don't have a FocusManager if we are hidden.
if (focus_manager && render_widget_host_->CanBlur())
focus_manager->ClearFocus();
chrome/browser/views/autocomplete/autocomplete_popup_win.cc
+1 -1
Ver Arquivo
@@ -28,7 +28,7 @@ void AutocompletePopupWin::Init(AutocompleteEditViewWin* edit_view,
views::View* contents) {
// Create the popup
WidgetWin::Init(edit_view->parent_view()->GetWidget()->GetNativeView(),
contents_->GetPopupBounds(), false);
contents_->GetPopupBounds());
// The contents is owned by the LocationBarView.
contents_->SetParentOwned(false);
SetContentsView(contents_);
chrome/browser/views/blocked_popup_container_view_win.cc
+1 -1
Ver Arquivo
@@ -398,7 +398,7 @@ BlockedPopupContainerViewWin::BlockedPopupContainerViewWin(
set_window_style(WS_CHILD | WS_CLIPSIBLINGS | WS_CLIPCHILDREN);
WidgetWin::Init(GetModel()->GetConstrainingContents(NULL)->GetNativeView(),
gfx::Rect(), false);
gfx::Rect());
SetContentsView(container_view_);
SetPosition();
}
chrome/browser/views/bookmark_bubble_view.cc
+1 -3
Ver Arquivo
@@ -182,9 +182,7 @@ void BookmarkBubbleView::DidChangeBounds(const gfx::Rect& previous,
void BookmarkBubbleView::BubbleShown() {
DCHECK(GetWidget());
views::FocusManager* focus_manager =
views::FocusManager::GetFocusManager(GetWidget()->GetNativeView());
focus_manager->RegisterAccelerator(
GetFocusManager()->RegisterAccelerator(
views::Accelerator(VK_RETURN, false, false, false), this);
title_tf_->RequestFocus();
chrome/browser/views/browser_bubble_win.cc
+1 -3
Ver Arquivo
@@ -24,9 +24,7 @@ void BrowserBubble::InitPopup() {
#endif
// A focus manager is necessary if you want to be able to handle various
// mouse events properly.
pop->Init(frame_native_view_,
bounds_,
true); // Give the widget a focus manager.
pop->Init(frame_native_view_, bounds_);
pop->SetContentsView(view_);
popup_.reset(pop);
Reposition();
chrome/browser/views/constrained_window_win.cc
+1 -37
Ver Arquivo
@@ -626,7 +626,6 @@ ConstrainedWindowWin::ConstrainedWindowWin(
owner_(owner) {
GetNonClientView()->SetFrameView(CreateFrameViewForWindow());
focus_restoration_disabled_ = false;
set_window_style(WS_CHILD | WS_CLIPSIBLINGS | WS_CLIPCHILDREN | WS_CAPTION |
WS_THICKFRAME | WS_SYSMENU);
set_focus_on_creation(false);
@@ -638,48 +637,13 @@ ConstrainedWindowWin::ConstrainedWindowWin(
void ConstrainedWindowWin::ActivateConstrainedWindow() {
// Other pop-ups are simply moved to the front of the z-order.
SetWindowPos(HWND_TOP, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_SHOWWINDOW);
// Store the focus of our parent focus manager so we can restore it when we
// close.
views::FocusManager* focus_manager =
views::FocusManager::GetFocusManager(GetNativeView());
DCHECK(focus_manager);
focus_manager = focus_manager->GetParentFocusManager();
if (focus_manager) {
// We could not have a parent focus manager if the ConstrainedWindow is
// displayed in a tab that is not currently selected.
// TODO(jcampan): we should store the ConstrainedWindow active events in
// that case and replay them when the TabContents becomes selected.
focus_manager->StoreFocusedView();
// Give our window the focus so we get keyboard messages.
::SetFocus(GetNativeView());
}
}
////////////////////////////////////////////////////////////////////////////////
// ConstrainedWindowWin, views::WidgetWin overrides:
void ConstrainedWindowWin::OnDestroy() {
// We do this here, rather than |Close|, since the window may be destroyed in
// a way other than by some other component calling Close, e.g. by the native
// window hierarchy closing. We are guaranteed to receive a WM_DESTROY
// message regardless of how the window is closed.
// Note that when we get this message, the focus manager of the
// ConstrainedWindow has already been destroyed (by the processing of
// WM_DESTROY in FocusManager). So the FocusManager we retrieve here is the
// parent one (the one from the top window).
views::FocusManager* focus_manager =
views::FocusManager::GetFocusManager(GetNativeView());
if (focus_manager) {
// We may not have a focus manager if:
// - we are hidden when closed (the TabContent would be detached).
// - the tab has been closed and we are closed as a result.
// TODO(jcampan): when hidden, we should modify the stored focus of the tab
// so when it becomes visible again we retrieve the focus appropriately.
if (!focus_restoration_disabled_)
focus_manager->RestoreFocusedView();
}
// TODO(jcampan): figure out focus restoration
// Make sure we call super so that it can do its cleanup.
WindowWin::OnDestroy();
chrome/browser/views/constrained_window_win.h
+1 -5
Ver Arquivo
@@ -24,7 +24,7 @@ class WindowDelegate;
// a child HWND with a custom window frame.
//
class ConstrainedWindowWin : public ConstrainedWindow,
public views::WindowWin {
public views::WindowWin {
public:
virtual ~ConstrainedWindowWin();
@@ -61,10 +61,6 @@ class ConstrainedWindowWin : public ConstrainedWindow,
// The TabContents that owns and constrains this ConstrainedWindow.
TabContents* owner_;
// True if focus should not be restored to whatever view was focused last
// when this window is destroyed.
bool focus_restoration_disabled_;
// Current "anchor point", the lower right point at which we render
// the constrained title bar.
gfx::Point anchor_point_;
chrome/browser/views/download_started_animation_win.cc
+1 -1
Ver Arquivo
@@ -106,7 +106,7 @@ DownloadStartedAnimationWin::DownloadStartedAnimationWin(
popup_->set_window_ex_style(WS_EX_LAYERED | WS_EX_TOOLWINDOW |
WS_EX_TRANSPARENT);
popup_->SetOpacity(0x00);
popup_->Init(tab_contents_->GetNativeView(), rc, false);
popup_->Init(tab_contents_->GetNativeView(), rc);
popup_->SetContentsView(this);
Reposition();
popup_->Show();
chrome/browser/views/find_bar_win.cc
+3 -2
Ver Arquivo
@@ -95,12 +95,13 @@ FindBarWin::FindBarWin(BrowserView* browser_view)
// Initialize the host.
host_.reset(new Host(this));
host_->Init(browser_view->GetWidget()->GetNativeView(), gfx::Rect(), false);
host_->Init(browser_view->GetWidget()->GetNativeView(), gfx::Rect());
host_->SetContentsView(view_);
// Start listening to focus changes, so we can register and unregister our
// own handler for Escape.
focus_manager_ = views::FocusManager::GetFocusManager(host_->GetNativeView());
focus_manager_ =
views::FocusManager::GetFocusManagerForNativeView(host_->GetNativeView());
focus_manager_->AddFocusChangeListener(this);
// Stores the currently focused view, and tracks focus changes so that we can
chrome/browser/views/find_bar_win_browsertest.cc
+3 -2
Ver Arquivo
@@ -573,8 +573,9 @@ IN_PROC_BROWSER_TEST_F(FindInPageControllerTest, AcceleratorRestoring) {
GURL url = server->TestServerPageW(kSimplePage);
ui_test_utils::NavigateToURL(browser(), url);
views::FocusManager* focus_manager = views::FocusManager::GetFocusManager(
browser()->window()->GetNativeHandle());
gfx::NativeView browser_view = browser()->window()->GetNativeHandle();
views::FocusManager* focus_manager =
views::FocusManager::GetFocusManagerForNativeView(browser_view);
// See where Escape is registered.
views::Accelerator escape(VK_ESCAPE, false, false, false);
chrome/browser/views/first_run_bubble.cc
+2 -6
Ver Arquivo
@@ -343,9 +343,7 @@ void FirstRunBubble::InfoBubbleClosing(InfoBubble* info_bubble,
if (!IsWindowEnabled(GetParent()))
::EnableWindow(GetParent(), true);
enable_window_method_factory_.RevokeAll();
views::FocusManager* focus_manager =
views::FocusManager::GetFocusManager(GetNativeView());
focus_manager->RemoveFocusChangeListener(view_);
GetFocusManager()->RemoveFocusChangeListener(view_);
}
// static
@@ -362,9 +360,7 @@ FirstRunBubble* FirstRunBubble::Show(Profile* profile, views::Window* parent,
window->set_view(view);
window->Init(parent, position_relative_to, view);
window->ShowWindow(SW_SHOW);
views::FocusManager* focus_manager =
views::FocusManager::GetFocusManager(window->GetNativeView());
focus_manager->AddFocusChangeListener(view);
window->GetFocusManager()->AddFocusChangeListener(view);
view->BubbleShown();
return window;
}
chrome/browser/views/fullscreen_exit_bubble.cc
+1 -1
Ver Arquivo
@@ -144,7 +144,7 @@ FullscreenExitBubble::FullscreenExitBubble(
popup_->set_window_ex_style(WS_EX_LAYERED | WS_EX_TOOLWINDOW |
l10n_util::GetExtendedTooltipStyles());
popup_->SetOpacity(static_cast<unsigned char>(0xff * kOpacity));
popup_->Init(frame->GetNativeView(), GetPopupRect(false), false);
popup_->Init(frame->GetNativeView(), GetPopupRect(false));
popup_->SetContentsView(view_);
popup_->Show(); // This does not activate the popup.
chrome/browser/views/info_bubble.cc
+4 -6
Ver Arquivo
@@ -133,7 +133,7 @@ void InfoBubble::Init(views::Window* parent,
content_view_->CalculateWindowBoundsAndAjust(position_relative_to);
#if defined(OS_WIN)
WidgetWin::Init(parent->GetNativeWindow(), bounds, true);
WidgetWin::Init(parent->GetNativeWindow(), bounds);
#else
WidgetGtk::Init(GTK_WIDGET(parent->GetNativeWindow()), bounds, true);
#endif
@@ -155,11 +155,9 @@ void InfoBubble::Init(views::Window* parent,
#if defined(OS_WIN)
// Register the Escape accelerator for closing.
views::FocusManager* focus_manager =
views::FocusManager::GetFocusManager(GetNativeView());
focus_manager->RegisterAccelerator(views::Accelerator(VK_ESCAPE, false,
false, false),
this);
GetFocusManager()->RegisterAccelerator(views::Accelerator(VK_ESCAPE, false,
false, false),
this);
// Set initial alpha value of the layered window.
SetLayeredWindowAttributes(GetNativeView(),
RGB(0xFF, 0xFF, 0xFF),
chrome/browser/views/infobars/infobars.cc
+2 -3
Ver Arquivo
@@ -203,9 +203,8 @@ void InfoBar::InfoBarAdded() {
// focus so that we can restore focus when we're removed.
views::Widget* widget = GetWidget();
if (widget) {
focus_tracker_.reset(
new views::ExternalFocusTracker(this,
views::FocusManager::GetFocusManager(widget->GetNativeView())));
focus_tracker_.reset(new views::ExternalFocusTracker(this,
GetFocusManager()));
}
#endif
}
chrome/browser/views/shelf_item_dialog.cc
+1 -2
Ver Arquivo
@@ -259,8 +259,7 @@ bool ShelfItemDialog::AcceleratorPressed(
if (accelerator.GetKeyCode() == VK_ESCAPE) {
window()->Close();
} else if (accelerator.GetKeyCode() == VK_RETURN) {
views::FocusManager* fm = views::FocusManager::GetFocusManager(
GetWidget()->GetNativeView());
views::FocusManager* fm = GetFocusManager();
if (fm->GetFocusedView() == url_table_) {
// Return on table behaves like a double click.
OnDoubleClick();
chrome/browser/views/status_bubble_views.cc
+1 -1
Ver Arquivo
@@ -485,7 +485,7 @@ void StatusBubbleViews::Init() {
WS_EX_TRANSPARENT |
l10n_util::GetExtendedTooltipStyles());
popup->SetOpacity(0x00);
popup->Init(frame_->GetNativeView(), gfx::Rect(), false);
popup->Init(frame_->GetNativeView(), gfx::Rect());
popup->SetContentsView(view_);
Reposition();
popup->Show();
chrome/browser/views/tab_contents/native_tab_contents_container_win.cc
+3 -1
Ver Arquivo
@@ -8,6 +8,8 @@
#include "chrome/browser/tab_contents/interstitial_page.h"
#include "chrome/browser/tab_contents/tab_contents.h"
#include "chrome/browser/views/tab_contents/tab_contents_container.h"
#include "chrome/browser/views/tab_contents/tab_contents_view_win.h"
#include "views/focus/focus_manager.h"
////////////////////////////////////////////////////////////////////////////////
@@ -44,7 +46,7 @@ void NativeTabContentsContainerWin::DetachContents(TabContents* contents) {
ShowWindow(container_hwnd, SW_HIDE);
// Reset the parent to NULL to ensure hidden tabs don't receive messages.
::SetParent(container_hwnd, NULL);
static_cast<TabContentsViewWin*>(contents->view())->Unparent();
}
// Now detach the TabContents.
chrome/browser/views/tab_contents/tab_contents_view_win.cc
+33 -7
Ver Arquivo
@@ -53,7 +53,8 @@ TabContentsView* TabContentsView::Create(TabContents* tab_contents) {
TabContentsViewWin::TabContentsViewWin(TabContents* tab_contents)
: TabContentsView(tab_contents),
ignore_next_char_event_(false) {
ignore_next_char_event_(false),
focus_manager_(NULL) {
last_focused_view_storage_id_ =
views::ViewStorage::GetSharedInstance()->CreateStorageID();
}
@@ -68,12 +69,21 @@ TabContentsViewWin::~TabContentsViewWin() {
view_storage->RemoveView(last_focused_view_storage_id_);
}
void TabContentsViewWin::Unparent() {
// Remember who our FocusManager is, we won't be able to access it once
// unparented.
focus_manager_ = views::WidgetWin::GetFocusManager();
// Note that we do not DCHECK on focus_manager_ as it may be NULL when used
// with an external tab container.
::SetParent(GetNativeView(), NULL);
}
void TabContentsViewWin::CreateView() {
set_delete_on_destroy(false);
// Since we create these windows parented to the desktop window initially, we
// don't want to create them initially visible.
set_window_style(WS_CHILD | WS_CLIPCHILDREN | WS_CLIPSIBLINGS);
WidgetWin::Init(GetDesktopWindow(), gfx::Rect(), false);
WidgetWin::Init(GetDesktopWindow(), gfx::Rect());
// Remove the root view drop target so we can register our own.
RevokeDragDrop(GetNativeView());
@@ -236,7 +246,7 @@ void TabContentsViewWin::SizeContents(const gfx::Size& size) {
void TabContentsViewWin::Focus() {
views::FocusManager* focus_manager =
views::FocusManager::GetFocusManager(GetNativeView());
views::FocusManager::GetFocusManagerForNativeView(GetNativeView());
if (tab_contents()->interstitial_page()) {
tab_contents()->interstitial_page()->Focus();
@@ -272,7 +282,7 @@ void TabContentsViewWin::StoreFocus() {
view_storage->RemoveView(last_focused_view_storage_id_);
views::FocusManager* focus_manager =
views::FocusManager::GetFocusManager(GetNativeView());
views::FocusManager::GetFocusManagerForNativeView(GetNativeView());
if (focus_manager) {
// |focus_manager| can be NULL if the tab has been detached but still
// exists.
@@ -304,7 +314,7 @@ void TabContentsViewWin::RestoreFocus() {
SetInitialFocus();
} else {
views::FocusManager* focus_manager =
views::FocusManager::GetFocusManager(GetNativeView());
views::FocusManager::GetFocusManagerForNativeView(GetNativeView());
// If you hit this DCHECK, please report it to Jay (jcampan).
DCHECK(focus_manager != NULL) << "No focus manager when restoring focus.";
@@ -336,7 +346,7 @@ void TabContentsViewWin::GotFocus() {
void TabContentsViewWin::TakeFocus(bool reverse) {
if (!tab_contents()->delegate()->TakeFocus(reverse)) {
views::FocusManager* focus_manager =
views::FocusManager::GetFocusManager(GetNativeView());
views::FocusManager::GetFocusManagerForNativeView(GetNativeView());
// We may not have a focus manager if the tab has been switched before this
// message arrived.
@@ -360,7 +370,7 @@ void TabContentsViewWin::HandleKeyboardEvent(
// a keyboard shortcut that we have to process.
if (event.type == WebInputEvent::RawKeyDown) {
views::FocusManager* focus_manager =
views::FocusManager::GetFocusManager(GetNativeView());
views::FocusManager::GetFocusManagerForNativeView(GetNativeView());
// We may not have a focus_manager at this point (if the tab has been
// switched by the time this message returned).
if (focus_manager) {
@@ -396,6 +406,22 @@ void TabContentsViewWin::HandleKeyboardEvent(
event.os_event.lParam);
}
views::FocusManager* TabContentsViewWin::GetFocusManager() {
views::FocusManager* focus_manager = WidgetWin::GetFocusManager();
if (focus_manager) {
// If focus_manager_ is non NULL, it means we have been reparented, in which
// case its value may not be valid anymore.
focus_manager_ = NULL;
return focus_manager;
}
// TODO(jcampan): we should DCHECK on focus_manager_, as it should not be
// NULL. We are not doing it as it breaks some unit-tests. We should
// probably have an empty TabContentView implementation for the unit-tests,
// that would prevent that code being executed in the unit-test case.
// DCHECK(focus_manager_);
return focus_manager_;
}
void TabContentsViewWin::ShowContextMenu(const ContextMenuParams& params) {
// Allow delegates to handle the context menu operation first.
if (tab_contents()->delegate()->HandleContextMenu(params))
chrome/browser/views/tab_contents/tab_contents_view_win.h
+11
Ver Arquivo
@@ -26,6 +26,10 @@ class TabContentsViewWin : public TabContentsView,
explicit TabContentsViewWin(TabContents* tab_contents);
virtual ~TabContentsViewWin();
// Reset the native parent of this view to NULL. Unparented windows should
// not receive any messages.
virtual void Unparent();
// TabContentsView implementation --------------------------------------------
virtual void CreateView();
@@ -52,6 +56,9 @@ class TabContentsViewWin : public TabContentsView,
virtual void TakeFocus(bool reverse);
virtual void HandleKeyboardEvent(const NativeWebKeyboardEvent& event);
// WidgetWin overridde.
virtual views::FocusManager* GetFocusManager();
private:
// Windows events ------------------------------------------------------------
@@ -104,6 +111,10 @@ class TabContentsViewWin : public TabContentsView,
// The context menu. Callbacks are asynchronous so we need to keep it around.
scoped_ptr<RenderViewContextMenuWin> context_menu_;
// The FocusManager associated with this tab. Stored as it is not directly
// accessible when unparented.
views::FocusManager* focus_manager_;
DISALLOW_COPY_AND_ASSIGN(TabContentsViewWin);
};
chrome/browser/views/tabs/dragged_tab_controller.cc
+1 -1
Ver Arquivo
@@ -198,7 +198,7 @@ class DraggedTabController::DockDisplayer : public AnimationDelegate {
popup->set_window_ex_style(WS_EX_LAYERED | WS_EX_TOOLWINDOW |
WS_EX_TOPMOST);
popup->SetOpacity(0x00);
popup->Init(NULL, info.GetPopupRect(), false);
popup->Init(NULL, info.GetPopupRect());
popup->SetContentsView(new DockView(info.type()));
if (info.in_enable_area())
animation_.Reset(1);
chrome/browser/views/tabs/dragged_tab_view.cc
+1 -1
Ver Arquivo
@@ -48,7 +48,7 @@ DraggedTabView::DraggedTabView(TabContents* datasource,
container_->set_window_ex_style(
WS_EX_LAYERED | WS_EX_TOPMOST | WS_EX_TOOLWINDOW);
container_->set_can_update_layered_window(false);
container_->Init(NULL, gfx::Rect(0, 0, 0, 0), false);
container_->Init(NULL, gfx::Rect(0, 0, 0, 0));
container_->SetContentsView(this);
BOOL drag;
chrome/browser/views/tabs/native_view_photobooth_win.cc
+1 -1
Ver Arquivo
@@ -155,7 +155,7 @@ void NativeViewPhotoboothWin::CreateCaptureWindow(HWND initial_hwnd) {
// WS_EX_TOOLWINDOW ensures the capture window doesn't produce a Taskbar
// button.
capture_window_->set_window_ex_style(WS_EX_LAYERED | WS_EX_TOOLWINDOW);
capture_window_->Init(NULL, capture_bounds, false);
capture_window_->Init(NULL, capture_bounds);
// If the capture window isn't visible, blitting from the TabContents'
// HWND's DC to the capture bitmap produces blankness.
capture_window_->Show();
chrome/browser/views/tabs/tab_strip.cc
+1 -2
Ver Arquivo
@@ -1388,8 +1388,7 @@ TabStrip::DropInfo::DropInfo(int drop_index, bool drop_before, bool point_down)
arrow_window->Init(
NULL,
gfx::Rect(0, 0, drop_indicator_width, drop_indicator_height),
true);
gfx::Rect(0, 0, drop_indicator_width, drop_indicator_height));
arrow_window->SetContentsView(arrow_view);
#else
NOTIMPLEMENTED();
views/controls/menu/chrome_menu.cc
+1 -1
Ver Arquivo
@@ -685,7 +685,7 @@ class MenuHost : public WidgetWin {
const gfx::Rect& bounds,
View* contents_view,
bool do_capture) {
WidgetWin::Init(parent, bounds, true);
WidgetWin::Init(parent, bounds);
SetContentsView(contents_view);
// We don't want to take focus away from the hosting window.
ShowWindow(SW_SHOWNA);
views/controls/native_control.cc
+1 -2
Ver Arquivo
@@ -367,8 +367,7 @@ LRESULT CALLBACK NativeControl::NativeControlWndProc(HWND window, UINT message,
return 0;
} else if (message == WM_SETFOCUS) {
// Let the focus manager know that the focus changed.
FocusManager* focus_manager =
FocusManager::GetFocusManager(native_control->GetNativeControlHWND());
FocusManager* focus_manager = native_control->GetFocusManager();
if (focus_manager) {
focus_manager->SetFocusedView(native_control);
} else {
views/controls/native_control_win.cc
+1 -2
Ver Arquivo
@@ -183,8 +183,7 @@ LRESULT NativeControlWin::NativeControlWndProc(HWND window,
return 0;
} else if (message == WM_SETFOCUS) {
// Let the focus manager know that the focus changed.
FocusManager* focus_manager =
FocusManager::GetFocusManager(native_control->native_view());
FocusManager* focus_manager = native_control->GetFocusManager();
if (focus_manager) {
focus_manager->SetFocusedView(native_control->focus_view());
} else {
views/controls/tabbed_pane.cc
+1 -1
Ver Arquivo
@@ -172,7 +172,7 @@ HWND TabbedPane::CreateNativeControl(HWND parent_container) {
// Create the view container which is a child of the TabControl.
content_window_ = new WidgetWin();
content_window_->Init(tab_control_, gfx::Rect(), false);
content_window_->Init(tab_control_, gfx::Rect());
// Explicitly setting the WS_EX_LAYOUTRTL property for the HWND (see above
// for a thorough explanation regarding why we waited until |content_window_|
views/controls/textfield/native_textfield_win.cc
+1 -2
Ver Arquivo
@@ -681,8 +681,7 @@ void NativeTextfieldWin::OnPaste() {
void NativeTextfieldWin::OnSetFocus(HWND hwnd) {
SetMsgHandled(FALSE); // We still want the default processing of the message.
views::FocusManager* focus_manager =
views::FocusManager::GetFocusManager(m_hWnd);
views::FocusManager* focus_manager = textfield_->GetFocusManager();
if (!focus_manager) {
NOTREACHED();
return;
views/controls/tree/tree_view.cc
+1 -3
Ver Arquivo
@@ -471,13 +471,11 @@ bool TreeView::OnKeyDown(int virtual_key_code) {
} else if (virtual_key_code == VK_RETURN && !process_enter_) {
Widget* widget = GetWidget();
DCHECK(widget);
FocusManager* fm = FocusManager::GetFocusManager(widget->GetNativeView());
DCHECK(fm);
Accelerator accelerator(Accelerator(static_cast<int>(virtual_key_code),
win_util::IsShiftPressed(),
win_util::IsCtrlPressed(),
win_util::IsAltPressed()));
fm->ProcessAccelerator(accelerator);
GetFocusManager()->ProcessAccelerator(accelerator);
return true;
}
return false;
views/focus/external_focus_tracker.cc
+3
Ver Arquivo
@@ -4,6 +4,7 @@
#include "views/focus/external_focus_tracker.h"
#include "base/logging.h"
#include "views/view.h"
#include "views/focus/view_storage.h"
@@ -13,6 +14,8 @@ ExternalFocusTracker::ExternalFocusTracker(View* parent_view,
FocusManager* focus_manager)
: focus_manager_(focus_manager),
parent_view_(parent_view) {
DCHECK(focus_manager);
DCHECK(parent_view);
view_storage_ = ViewStorage::GetSharedInstance();
last_focused_view_storage_id_ = view_storage_->CreateStorageID();
// Store the view which is focused when we're created.
views/focus/focus_manager.cc
+13 -211
Ver Arquivo
@@ -12,7 +12,6 @@
#include <gtk/gtk.h>
#endif
#include "base/histogram.h"
#include "base/logging.h"
#include "views/accelerator.h"
#include "views/focus/view_storage.h"
@@ -24,158 +23,17 @@
#include "base/win_util.h"
#endif
// The following keys are used in SetProp/GetProp to associate additional
// information needed for focus tracking with a window.
// Maps to the FocusManager instance for a top level window. See
// CreateFocusManager/DestoryFocusManager for usage.
static const wchar_t* const kFocusManagerKey = L"__VIEW_CONTAINER__";
// Maps to the View associated with a window.
// We register views with window so we can:
// - keep in sync the native focus with the view focus (when the native
// component gets the focus, we get the WM_SETFOCUS event and we can focus the
// associated view).
// - prevent tab key events from being sent to views.
static const wchar_t* const kViewKey = L"__CHROME_VIEW__";
// A property set to 1 to indicate whether the focus manager has subclassed that
// window. We are doing this to ensure we are not subclassing several times.
// Subclassing twice is not a problem if no one is subclassing the HWND between
// the 2 subclassings (the 2nd subclassing is ignored since the WinProc is the
// same as the current one). However if some other app goes and subclasses the
// HWND between the 2 subclassings, we will end up subclassing twice.
// This flag lets us test that whether we have or not subclassed yet.
static const wchar_t* const kFocusSubclassInstalled =
L"__FOCUS_SUBCLASS_INSTALLED__";
namespace views {
#if defined(OS_WIN)
// Callback installed via InstallFocusSubclass.
static LRESULT CALLBACK FocusWindowCallback(HWND window, UINT message,
WPARAM wParam, LPARAM lParam) {
if (!::IsWindow(window)) {
// QEMU has reported crashes when calling GetProp (this seems to happen for
// some weird messages, not sure what they are).
// Here we are just trying to avoid the crasher.
NOTREACHED();
return 0;
}
WNDPROC original_handler = win_util::GetSuperclassWNDPROC(window);
DCHECK(original_handler);
FocusManager* focus_manager = FocusManager::GetFocusManager(window);
// There are cases when we have no FocusManager for the window. This happens
// because we subclass certain windows (such as the TabContents window)
// but that window may not have an associated FocusManager.
if (focus_manager) {
switch (message) {
case WM_NCDESTROY:
if (!focus_manager->OnNCDestroy(window))
return 0;
break;
default:
break;
}
}
return CallWindowProc(original_handler, window, message, wParam, lParam);
}
#endif
// FocusManager -----------------------------------------------------
#if defined(OS_WIN)
// static
FocusManager* FocusManager::CreateFocusManager(HWND window,
RootView* root_view) {
DCHECK(window);
DCHECK(root_view);
InstallFocusSubclass(window, NULL);
FocusManager* focus_manager = new FocusManager(window, root_view);
SetProp(window, kFocusManagerKey, focus_manager);
return focus_manager;
}
// static
void FocusManager::InstallFocusSubclass(HWND window, View* view) {
DCHECK(window);
bool already_subclassed =
reinterpret_cast<bool>(GetProp(window,
kFocusSubclassInstalled));
if (already_subclassed &&
!win_util::IsSubclassed(window, &FocusWindowCallback)) {
NOTREACHED() << "window sub-classed by someone other than the FocusManager";
// Track in UMA so we know if this case happens.
UMA_HISTOGRAM_COUNTS("FocusManager.MultipleSubclass", 1);
} else {
win_util::Subclass(window, &FocusWindowCallback);
SetProp(window, kFocusSubclassInstalled, reinterpret_cast<HANDLE>(true));
}
if (view)
SetProp(window, kViewKey, view);
}
void FocusManager::UninstallFocusSubclass(HWND window) {
DCHECK(window);
if (win_util::Unsubclass(window, &FocusWindowCallback)) {
RemoveProp(window, kViewKey);
RemoveProp(window, kFocusSubclassInstalled);
}
}
#endif
// static
FocusManager* FocusManager::GetFocusManager(gfx::NativeView window) {
#if defined(OS_WIN)
DCHECK(window);
// In case parent windows belong to a different process, yet
// have the kFocusManagerKey property set, we have to be careful
// to also check the process id of the window we're checking.
DWORD window_pid = 0, current_pid = GetCurrentProcessId();
FocusManager* focus_manager;
for (focus_manager = NULL; focus_manager == NULL && IsWindow(window);
window = GetParent(window)) {
GetWindowThreadProcessId(window, &window_pid);
if (current_pid != window_pid)
break;
focus_manager = reinterpret_cast<FocusManager*>(
GetProp(window, kFocusManagerKey));
}
return focus_manager;
#else
NOTIMPLEMENTED();
return NULL;
#endif
}
#if defined(OS_WIN)
// static
View* FocusManager::GetViewForWindow(gfx::NativeView window, bool look_in_parents) {
DCHECK(window);
do {
View* v = reinterpret_cast<View*>(GetProp(window, kViewKey));
if (v)
return v;
} while (look_in_parents && (window = ::GetParent(window)));
return NULL;
}
FocusManager::FocusManager(HWND root, RootView* root_view)
: root_(root),
top_root_view_(root_view),
focused_view_(NULL),
ignore_set_focus_msg_(false) {
FocusManager::FocusManager(Widget* widget)
: widget_(widget),
focused_view_(NULL) {
DCHECK(widget_);
stored_focused_view_storage_id_ =
ViewStorage::GetSharedInstance()->CreateStorageID();
DCHECK(root_);
}
#endif
FocusManager::~FocusManager() {
// If there are still registered FocusChange listeners, chances are they were
@@ -185,29 +43,12 @@ FocusManager::~FocusManager() {
#if defined(OS_WIN)
// Message handlers.
bool FocusManager::OnNCDestroy(HWND window) {
// Window is being destroyed, undo the subclassing.
FocusManager::UninstallFocusSubclass(window);
if (window == root_) {
// We are the top window.
DCHECK(GetProp(window, kFocusManagerKey));
// Make sure this is called on the window that was set with the
// FocusManager.
RemoveProp(window, kFocusManagerKey);
delete this;
}
return true;
}
bool FocusManager::OnKeyDown(HWND window, UINT message, WPARAM wparam,
LPARAM lparam) {
DCHECK((message == WM_KEYDOWN) || (message == WM_SYSKEYDOWN));
HWND hwnd = widget_->GetNativeView();
if (!IsWindowVisible(root_)) {
if (!IsWindowVisible(hwnd)) {
// We got a message for a hidden window. Because WidgetWin::Close hides the
// window, then destroys it, it it possible to get a message after we've
// hidden the window. If we allow the message to be dispatched chances are
@@ -245,9 +86,10 @@ bool FocusManager::OnKeyDown(HWND window, UINT message, WPARAM wparam,
// Note that we don't do focus traversal if the root window is not part of the
// active window hierarchy as this would mean we have no focused view and
// would focus the first focusable view.
HWND top_window = widget_->GetNativeView();
HWND active_window = ::GetActiveWindow();
if ((active_window == root_ || ::IsChild(active_window, root_)) &&
IsTabTraversalKeyEvent(key_event)) {
if ((active_window == top_window || ::IsChild(active_window, top_window)) &&
IsTabTraversalKeyEvent(key_event)) {
AdvanceFocus(win_util::IsShiftPressed());
return false;
}
@@ -324,9 +166,10 @@ bool FocusManager::ContainsView(View* view) {
if (!widget)
return false;
gfx::NativeView top_window = widget_->GetNativeView();
gfx::NativeView window = widget->GetNativeView();
while (window) {
if (window == root_)
if (window == top_window)
return true;
#if defined(OS_WIN)
window = ::GetParent(window);
@@ -377,7 +220,7 @@ View* FocusManager::GetNextFocusableView(View* original_starting_view,
starting_view = original_starting_view;
}
} else {
focus_traversable = top_root_view_;
focus_traversable = widget_->GetRootView();
}
// Traverse the FocusTraversable tree down to find the focusable view.
@@ -457,30 +300,9 @@ void FocusManager::SetFocusedView(View* view) {
void FocusManager::ClearFocus() {
SetFocusedView(NULL);
ClearHWNDFocus();
ClearNativeFocus();
}
void FocusManager::ClearHWNDFocus() {
// Keep the top root window focused so we get keyboard events.
ignore_set_focus_msg_ = true;
#if defined(OS_WIN)
::SetFocus(root_);
#else
NOTIMPLEMENTED();
#endif
ignore_set_focus_msg_ = false;
}
#if defined(OS_WIN)
void FocusManager::FocusHWND(HWND hwnd) {
ignore_set_focus_msg_ = true;
// Only reset focus if hwnd is not already focused.
if (hwnd && ::GetFocus() != hwnd)
::SetFocus(hwnd);
ignore_set_focus_msg_ = false;
}
#endif
void FocusManager::StoreFocusedView() {
ViewStorage* view_storage = ViewStorage::GetSharedInstance();
if (!view_storage) {
@@ -535,19 +357,6 @@ void FocusManager::ClearStoredFocusedView() {
view_storage->RemoveView(stored_focused_view_storage_id_);
}
FocusManager* FocusManager::GetParentFocusManager() const {
#if defined(OS_WIN)
HWND parent = ::GetParent(root_);
#else
GtkWidget* parent = gtk_widget_get_parent(root_);
#endif
// If we are a top window, we don't have a parent FocusManager.
if (!parent)
return NULL;
return GetFocusManager(parent);
}
// Find the next (previous if reverse is true) focusable view for the specified
// FocusTraversable, starting at the specified view, traversing down the
// FocusTraversable hierarchy.
@@ -629,13 +438,6 @@ bool FocusManager::ProcessAccelerator(const Accelerator& accelerator) {
}
}
// When dealing with child windows that have their own FocusManager (such
// as ConstrainedWindow), we still want the parent FocusManager to process
// the accelerator if the child window did not process it.
FocusManager* parent_focus_manager = GetParentFocusManager();
if (parent_focus_manager)
return parent_focus_manager->ProcessAccelerator(accelerator);
return false;
}
views/focus/focus_manager.h
+20 -69
Ver Arquivo
@@ -20,7 +20,7 @@
// focused views and handle keyboard accelerators.
//
// There are 2 types of focus:
// - the native focus, which is the focus that an HWND has.
// - the native focus, which is the focus that an gfx::NativeView 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
@@ -32,13 +32,9 @@
// This is already done for you if you subclass the NativeControl class or if
// you use the NativeViewHost class.
//
// 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).
// 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.
//
// The FocusTraversable interface exposes the methods a class should implement
// in order to be able to be focus traversed when tab key is pressed.
@@ -77,8 +73,9 @@
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).
@@ -153,22 +150,10 @@ class FocusChangeListener {
class FocusManager {
public:
#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);
explicit FocusManager(Widget* widget);
~FocusManager();
#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,
@@ -195,27 +180,10 @@ class FocusManager {
// 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();
@@ -224,11 +192,6 @@ class FocusManager {
// 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.
@@ -280,22 +243,17 @@ class FocusManager {
// pressed).
static bool IsTabTraversalKeyEvent(const KeyEvent& key_event);
// Sets the focus to the specified native view.
virtual void FocusNativeView(gfx::NativeView native_view);
// Clears the native view having the focus.
virtual void ClearNativeFocus();
// Retrieves the FocusManager associated with the passed native view.
static FocusManager* GetFocusManagerForNativeView(
gfx::NativeView native_view);
private:
#if defined(OS_WIN)
explicit FocusManager(HWND root, RootView* root_view);
// 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);
// Uninstalls the window subclass installed by InstallFocusSubclass.
static void UninstallFocusSubclass(HWND window);
#endif
~FocusManager();
// Returns the next focusable view.
View* GetNextFocusableView(View* starting_view, bool reverse, bool dont_loop);
@@ -307,8 +265,8 @@ class FocusManager {
View* starting_view,
bool reverse);
// The RootView of the window associated with this FocusManager.
RootView* top_root_view_;
// The top-level Widget this FocusManager is associated with.
Widget* widget_;
// The view that currently is focused.
View* focused_view_;
@@ -317,13 +275,6 @@ class FocusManager {
// 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;
views/focus/focus_manager_gtk.cc
+25
Ver Arquivo
@@ -0,0 +1,25 @@
// Copyright (c) 2006-2009 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.
#include "views/focus/focus_manager.h"
#include "base/logging.h"
namespace views {
void FocusManager::ClearNativeFocus() {
NOTIMPLEMENTED();
}
void FocusManager::FocusNativeView(gfx::NativeView native_view) {
NOTIMPLEMENTED();
}
// static
FocusManager* FocusManager::GetFocusManagerForNativeView(
gfx::NativeView native_view) {
NOTIMPLEMENTED();
}
} // namespace views
views/focus/focus_manager_unittest.cc
+3 -2
Ver Arquivo
@@ -120,7 +120,7 @@ class BorderView : public NativeControl {
parent_container, NULL, NULL, NULL);
// Create the view container which is a child of the TabControl.
widget_ = new WidgetWin();
widget_->Init(tab_control, gfx::Rect(), false);
widget_->Init(tab_control, gfx::Rect());
widget_->SetContentsView(child_);
widget_->SetFocusTraversableParentView(this);
ResizeContents(tab_control);
@@ -211,7 +211,8 @@ class FocusManagerTest : public testing::Test, public WindowDelegate {
}
FocusManager* GetFocusManager() {
return FocusManager::GetFocusManager(window_->GetNativeWindow());
return FocusManager::GetFocusManagerForNativeView(
window_->GetNativeWindow());
}
// WindowDelegate Implementation.
views/focus/focus_manager_win.cc
+34
Ver Arquivo
@@ -0,0 +1,34 @@
// Copyright (c) 2006-2009 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.
#include "views/focus/focus_manager.h"
#include "views/view.h"
#include "views/widget/widget_win.h"
namespace views {
void FocusManager::ClearNativeFocus() {
// Keep the top root window focused so we get keyboard events.
::SetFocus(widget_->GetNativeView());
}
void FocusManager::FocusNativeView(gfx::NativeView native_view) {
// Only reset focus if hwnd is not already focused.
if (native_view && ::GetFocus() != native_view)
::SetFocus(native_view);
}
// static
FocusManager* FocusManager::GetFocusManagerForNativeView(
gfx::NativeView native_view) {
HWND root = ::GetAncestor(native_view, GA_ROOT);
if (!root)
return NULL;
WidgetWin* widget = WidgetWin::GetWidget(root);
return widget ? widget->GetFocusManager() : NULL;
}
} // namespace views
views/view.cc
+5
Ver Arquivo
@@ -264,6 +264,11 @@ void View::SetFocusable(bool focusable) {
focusable_ = focusable;
}
FocusManager* View::GetFocusManager() {
Widget* widget = GetWidget();
return widget ? widget->GetFocusManager() : NULL;
}
bool View::HasFocus() {
FocusManager* focus_manager = GetFocusManager();
if (focus_manager)
views/view_unittest.cc
+5 -5
Ver Arquivo
@@ -306,7 +306,7 @@ TEST_F(ViewTest, MouseEvent) {
views::WidgetWin window;
window.set_delete_on_destroy(false);
window.set_window_style(WS_OVERLAPPEDWINDOW);
window.Init(NULL, gfx::Rect(50, 50, 650, 650), false);
window.Init(NULL, gfx::Rect(50, 50, 650, 650));
RootView* root = window.GetRootView();
root->AddChildView(v1);
@@ -647,7 +647,7 @@ TEST_F(ViewTest, TextfieldCutCopyPaste) {
Clipboard clipboard;
WidgetWin* window = new WidgetWin;
window->Init(NULL, gfx::Rect(0, 0, 100, 100), true);
window->Init(NULL, gfx::Rect(0, 0, 100, 100));
RootView* root_view = window->GetRootView();
Textfield* normal = new Textfield();
@@ -769,7 +769,7 @@ TEST_F(ViewTest, ActivateAccelerator) {
// Create a window and add the view as its child.
WidgetWin window;
window.Init(NULL, gfx::Rect(0, 0, 100, 100), true);
window.Init(NULL, gfx::Rect(0, 0, 100, 100));
window.set_delete_on_destroy(false);
window.set_window_style(WS_OVERLAPPEDWINDOW);
RootView* root = window.GetRootView();
@@ -777,7 +777,7 @@ TEST_F(ViewTest, ActivateAccelerator) {
// Get the focus manager.
views::FocusManager* focus_manager =
views::FocusManager::GetFocusManager(window.GetNativeView());
views::FocusManager::GetFocusManagerForNativeView(window.GetNativeView());
ASSERT_TRUE(focus_manager);
// Hit the return key and see if it takes effect.
@@ -1032,7 +1032,7 @@ class DefaultButtonTest : public ViewTest {
dialog_view_);
window->Show();
native_window_ = window->GetNativeWindow();
focus_manager_ = FocusManager::GetFocusManager(native_window_);
focus_manager_ = FocusManager::GetFocusManagerForNativeView(native_window_);
client_view_ =
static_cast<views::DialogClientView*>(window->GetClientView());
ok_button_ = client_view_->ok_button();
views/view_win.cc
+1 -13
Ver Arquivo
@@ -17,18 +17,6 @@
namespace views {
FocusManager* View::GetFocusManager() {
Widget* widget = GetWidget();
if (!widget)
return NULL;
HWND hwnd = widget->GetNativeView();
if (!hwnd)
return NULL;
return FocusManager::GetFocusManager(hwnd);
}
void View::DoDrag(const MouseEvent& e, int press_x, int press_y) {
int drag_operations = GetDragOperations(press_x, press_y);
if (drag_operations == DragDropTypes::DRAG_NONE)
@@ -55,7 +43,7 @@ void View::Focus() {
// messages.
FocusManager* focus_manager = GetFocusManager();
if (focus_manager)
focus_manager->FocusHWND(GetRootView()->GetWidget()->GetNativeView());
focus_manager->FocusNativeView(GetRootView()->GetWidget()->GetNativeView());
}
int View::GetHorizontalDragThreshold() {
views/views.gyp
+5 -3
Ver Arquivo
@@ -42,9 +42,9 @@
'type': '<(library)',
'msvs_guid': '6F9258E5-294F-47B2-919D-17FFE7A8B751',
'dependencies': [
'../app/app.gyp:app_base',
'../app/app.gyp:app_strings',
'../app/app.gyp:app_resources',
'../app/app.gyp:app_base',
'../app/app.gyp:app_strings',
'../app/app.gyp:app_resources',
'../skia/skia.gyp:skia',
'../third_party/icu38/icu38.gyp:icui18n',
'../third_party/icu38/icu38.gyp:icuuc',
@@ -174,6 +174,8 @@
'fill_layout.h',
'focus/external_focus_tracker.cc',
'focus/external_focus_tracker.h',
'focus/focus_manager_gtk.cc',
'focus/focus_manager_win.cc',
'focus/focus_manager.cc',
'focus/focus_manager.h',
'focus/focus_util_win.cc',
views/widget/accelerator_handler.cc
+2 -1
Ver Arquivo
@@ -15,7 +15,8 @@ bool AcceleratorHandler::Dispatch(const MSG& msg) {
bool process_message = true;
if (msg.message >= WM_KEYFIRST && msg.message <= WM_KEYLAST) {
FocusManager* focus_manager = FocusManager::GetFocusManager(msg.hwnd);
FocusManager* focus_manager =
FocusManager::GetFocusManagerForNativeView(msg.hwnd);
if (focus_manager) {
// FocusManager::OnKeyDown and OnKeyUp return false if this message has
// been consumed and should not be propagated further.
views/widget/root_view.cc
+4 -17
Ver Arquivo
@@ -46,7 +46,7 @@ class PaintTask : public Task {
// The target root view.
RootView* root_view_;
DISALLOW_EVIL_CONSTRUCTORS(PaintTask);
DISALLOW_COPY_AND_ASSIGN(PaintTask);
};
const char RootView::kViewClassName[] = "views/RootView";
@@ -262,23 +262,11 @@ void RootView::ViewHierarchyChanged(bool is_add, View* parent, View* child) {
default_keyboard_handler_ = NULL;
}
// For a given widget hierarchy, focus is tracked by a FocusManager attached
// to our nearest enclosing Window. <-- Important Assumption!
// We may not have access to our window if this function is called as a
// result of teardown during the deletion of the RootView and its hierarchy,
// so we don't bother notifying the FocusManager in that case because it
// will have already been destroyed (the Widget that contains us is
// NCDESTROY'ed which in turn destroys the focus manager _before_ the
// RootView is deleted.)
#if defined(OS_WIN)
Window* window = GetWindow();
if (window) {
FocusManager* focus_manager =
FocusManager::GetFocusManager(window->GetNativeWindow());
FocusManager* focus_manager = widget_->GetFocusManager();
// An unparanted RootView does not have a FocusManager.
if (focus_manager)
focus_manager->ViewRemoved(parent, child);
}
ViewStorage::GetSharedInstance()->ViewRemoved(parent, child);
#endif
}
}
@@ -521,7 +509,6 @@ void RootView::OnWidgetDestroyed() {
// TODO(port): Port RootViewDropTarget and this goes away.
NOTIMPLEMENTED();
#endif
widget_ = NULL;
}
void RootView::ProcessMouseDragCanceled() {
views/widget/widget.h
+7 -2
Ver Arquivo
@@ -17,6 +17,7 @@ class Rect;
namespace views {
class Accelerator;
class FocusManager;
class RootView;
class TooltipManager;
class Window;
@@ -105,13 +106,17 @@ class Widget {
virtual Window* GetWindow() { return NULL; }
virtual const Window* GetWindow() const { return NULL; }
// Get the theme provider.
// Gets the theme provider.
virtual ThemeProvider* GetThemeProvider() const { return NULL; }
// Get the default theme provider; this is necessary for when a widget has
// Gets the default theme provider; this is necessary for when a widget has
// no profile (and ThemeProvider) associated with it. The default theme
// provider provides a default set of bitmaps that such widgets can use.
virtual ThemeProvider* GetDefaultThemeProvider() { return NULL; }
// Returns the FocusManager for this widget.
// Note that all widgets in a widget hierarchy share the same focus manager.
virtual FocusManager* GetFocusManager() { return NULL; }
};
} // namespace views
views/widget/widget_win.cc
+29 -14
Ver Arquivo
@@ -154,8 +154,7 @@ WidgetWin::~WidgetWin() {
MessageLoopForUI::current()->RemoveObserver(this);
}
void WidgetWin::Init(HWND parent, const gfx::Rect& bounds,
bool has_own_focus_manager) {
void WidgetWin::Init(HWND parent, const gfx::Rect& bounds) {
if (window_style_ == 0)
window_style_ = parent ? kWindowDefaultChildStyle : kWindowDefaultStyle;
@@ -187,8 +186,9 @@ void WidgetWin::Init(HWND parent, const gfx::Rect& bounds,
root_view_->OnWidgetCreated();
if (has_own_focus_manager) {
FocusManager::CreateFocusManager(hwnd_, GetRootView());
if ((window_style_ & WS_CHILD) == 0) {
// Top-level widgets get a FocusManager.
focus_manager_.reset(new FocusManager(this));
}
// Sets the RootView as a property, so the automation can introspect windows.
@@ -266,6 +266,7 @@ void WidgetWin::Close() {
// Let's hide ourselves right away.
Hide();
if (close_widget_factory_.empty()) {
// And we delay the close so that if we are called from an ATL callback,
// we don't destroy the window before the callback returned (as the caller
@@ -419,6 +420,19 @@ const Window* WidgetWin::GetWindow() const {
return GetWindowImpl(hwnd_);
}
FocusManager* WidgetWin::GetFocusManager() {
if (focus_manager_.get())
return focus_manager_.get();
WidgetWin* widget = static_cast<WidgetWin*>(GetRootWidget());
if (widget && widget != this) {
// WidgetWin subclasses may override GetFocusManager(), for example for
// dealing with cases where the widget has been unparented.
return widget->GetFocusManager();
}
return NULL;
}
void WidgetWin::SetUseLayeredBuffer(bool use_layered_buffer) {
if (use_layered_buffer_ == use_layered_buffer)
return;
@@ -460,7 +474,12 @@ RootView* WidgetWin::FindRootView(HWND hwnd) {
return root_view;
}
///////////////////////////////////////////////////////////////////////////////
// static
WidgetWin* WidgetWin::GetWidget(HWND hwnd) {
return reinterpret_cast<WidgetWin*>(win_util::GetWindowUserData(hwnd));
}
////////////////////////////////////////////////////////////////////////////////
// MessageLoop::Observer
void WidgetWin::WillProcessMessage(const MSG& msg) {
@@ -472,7 +491,7 @@ void WidgetWin::DidProcessMessage(const MSG& msg) {
}
}
///////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
// FocusTraversable
View* WidgetWin::FindNextFocusableView(
@@ -1039,10 +1058,8 @@ LRESULT CALLBACK WidgetWin::WndProc(HWND window, UINT message,
// Otherwise we handle everything else.
if (!widget->ProcessWindowMessage(window, message, w_param, l_param, result))
result = DefWindowProc(window, message, w_param, l_param);
if (message == WM_NCDESTROY) {
widget->hwnd_ = NULL;
if (message == WM_NCDESTROY)
widget->OnFinalMessage(window);
}
if (message == WM_ACTIVATE)
PostProcessActivateMessage(widget, LOWORD(w_param));
return result;
@@ -1051,18 +1068,16 @@ LRESULT CALLBACK WidgetWin::WndProc(HWND window, UINT message,
// static
void WidgetWin::PostProcessActivateMessage(WidgetWin* widget,
int activation_state) {
FocusManager* focus_manager =
FocusManager::GetFocusManager(widget->GetNativeView());
if (!focus_manager) {
if (!widget->focus_manager_.get()) {
NOTREACHED();
return;
}
if (WA_INACTIVE == activation_state) {
focus_manager->StoreFocusedView();
widget->focus_manager_->StoreFocusedView();
} else {
// We must restore the focus after the message has been DefProc'ed as it
// does set the focus to the last focused HWND.
focus_manager->RestoreFocusedView();
widget->focus_manager_->RestoreFocusedView();
}
}
} // namespace views
views/widget/widget_win.h
+11 -6
Ver Arquivo
@@ -78,11 +78,7 @@ class WidgetWin : public Widget,
// this view, you are responsible for its destruction. If this value is NULL,
// the caller is responsible for populating the RootView, and sizing its
// contents as the window is sized.
// If |has_own_focus_manager| is true, the focus traversal stay confined to
// the window.
void Init(HWND parent,
const gfx::Rect& bounds,
bool has_own_focus_manager);
void Init(HWND parent, const gfx::Rect& bounds);
// Sets the specified view as the contents of this Widget. There can only
// be one contnets view child of this Widget's RootView. This view is sized to
@@ -122,6 +118,9 @@ class WidgetWin : public Widget,
// Returns the RootView associated with the specified HWND (if any).
static RootView* FindRootView(HWND hwnd);
// Returns the Widget associated with the specified HWND (if any).
static WidgetWin* GetWidget(HWND hwnd);
// All classes registered by WidgetWin start with this name.
static const wchar_t* const kBaseClassName;
@@ -230,6 +229,7 @@ class WidgetWin : public Widget,
virtual ThemeProvider* GetThemeProvider() const;
virtual Window* GetWindow();
virtual const Window* GetWindow() const;
virtual FocusManager* GetFocusManager();
// Overridden from MessageLoop::Observer:
void WillProcessMessage(const MSG& msg);
@@ -327,7 +327,6 @@ class WidgetWin : public Widget,
}
protected:
// Call close instead of this to Destroy the window.
BOOL DestroyWindow() {
DCHECK(::IsWindow(GetNativeView()));
@@ -523,6 +522,12 @@ class WidgetWin : public Widget,
// the TooltipManager.
scoped_ptr<TooltipManagerWin> tooltip_manager_;
// The focus manager keeping track of focus for this Widget and any of its
// children. NULL for non top-level widgets.
// WARNING: RootView's destructor calls into the FocusManager. As such, this
// must be destroyed AFTER root_view_.
scoped_ptr<FocusManager> focus_manager_;
// The root of the View hierarchy attached to this window.
// WARNING: see warning in tooltip_manager_ for ordering dependencies with
// this and tooltip_manager_.
views/window/window_win.cc
+1 -1
Ver Arquivo
@@ -511,7 +511,7 @@ void WindowWin::Init(HWND parent, const gfx::Rect& bounds) {
if (window_ex_style() == 0)
set_window_ex_style(CalculateWindowExStyle());
WidgetWin::Init(parent, bounds, true);
WidgetWin::Init(parent, bounds);
win_util::SetWindowUserData(GetNativeView(), this);
// Create the ClientView, add it to the NonClientView and add the