From c67d1b62e390cb4b136f4afaa3a7a08c09228814 Mon Sep 17 00:00:00 2001 From: Cheng Zhao Date: Tue, 1 May 2018 13:28:22 +0900 Subject: [PATCH] refactor: NativeWindowViews should not be a View (#12750) --- atom/browser/native_window_views.cc | 253 +++++++--------------------- atom/browser/native_window_views.h | 24 +-- atom/browser/ui/views/root_view.cc | 197 ++++++++++++++++++++++ atom/browser/ui/views/root_view.h | 65 +++++++ filenames.gypi | 2 + 5 files changed, 328 insertions(+), 213 deletions(-) create mode 100644 atom/browser/ui/views/root_view.cc create mode 100644 atom/browser/ui/views/root_view.h diff --git a/atom/browser/native_window_views.cc b/atom/browser/native_window_views.cc index 4ee6d8f9507f..a391bc09c890 100644 --- a/atom/browser/native_window_views.cc +++ b/atom/browser/native_window_views.cc @@ -7,12 +7,12 @@ #if defined(OS_WIN) #include #endif -#include + #include #include "atom/browser/api/atom_api_web_contents.h" #include "atom/browser/native_browser_view_views.h" -#include "atom/browser/ui/views/menu_bar.h" +#include "atom/browser/ui/views/root_view.h" #include "atom/browser/web_contents_preferences.h" #include "atom/browser/web_view_manager.h" #include "atom/browser/window_list.h" @@ -23,7 +23,6 @@ #include "brightray/browser/inspectable_web_contents.h" #include "brightray/browser/inspectable_web_contents_view.h" #include "content/public/browser/browser_thread.h" -#include "content/public/browser/native_web_keyboard_event.h" #include "native_mate/dictionary.h" #include "ui/aura/window_tree_host.h" #include "ui/base/hit_test.h" @@ -67,13 +66,6 @@ namespace atom { namespace { -// The menu bar height in pixels. -#if defined(OS_WIN) -const int kMenuBarHeight = 20; -#else -const int kMenuBarHeight = 25; -#endif - #if defined(OS_WIN) void FlipWindowStyle(HWND handle, bool on, DWORD flag) { DWORD style = ::GetWindowLong(handle, GWL_STYLE); @@ -85,33 +77,22 @@ void FlipWindowStyle(HWND handle, bool on, DWORD flag) { } #endif -bool IsAltKey(const content::NativeWebKeyboardEvent& event) { - return event.windows_key_code == ui::VKEY_MENU; -} -bool IsAltModifier(const content::NativeWebKeyboardEvent& event) { - typedef content::NativeWebKeyboardEvent::Modifiers Modifiers; - int modifiers = event.GetModifiers(); - modifiers &= ~Modifiers::kNumLockOn; - modifiers &= ~Modifiers::kCapsLockOn; - return (modifiers == Modifiers::kAltKey) || - (modifiers == (Modifiers::kAltKey | Modifiers::kIsLeft)) || - (modifiers == (Modifiers::kAltKey | Modifiers::kIsRight)); -} - class NativeWindowClientView : public views::ClientView { public: NativeWindowClientView(views::Widget* widget, - NativeWindowViews* contents_view) - : views::ClientView(widget, contents_view) {} + views::View* root_view, + NativeWindowViews* window) + : views::ClientView(widget, root_view), window_(window) {} virtual ~NativeWindowClientView() {} bool CanClose() override { - static_cast(contents_view()) - ->NotifyWindowCloseButtonClicked(); + window_->NotifyWindowCloseButtonClicked(); return false; } private: + NativeWindowViews* window_; + DISALLOW_COPY_AND_ASSIGN(NativeWindowClientView); }; @@ -120,11 +101,9 @@ class NativeWindowClientView : public views::ClientView { NativeWindowViews::NativeWindowViews(const mate::Dictionary& options, NativeWindow* parent) : NativeWindow(options, parent), + root_view_(new RootView(this)), content_view_(nullptr), focused_view_(nullptr), - menu_bar_autohide_(false), - menu_bar_visible_(false), - menu_bar_alt_pressed_(false), #if defined(OS_WIN) checked_for_a11y_support_(false), thick_frame_(true), @@ -137,11 +116,11 @@ NativeWindowViews::NativeWindowViews(const mate::Dictionary& options, maximizable_(true), minimizable_(true), fullscreenable_(true) { - // The root view is this class, it is managed by us. - set_owned_by_client(); - options.Get(options::kTitle, &title_); - options.Get(options::kAutoHideMenuBar, &menu_bar_autohide_); + + bool menu_bar_autohide; + if (options.Get(options::kAutoHideMenuBar, &menu_bar_autohide)) + root_view_->SetAutoHideMenuBar(menu_bar_autohide); #if defined(OS_WIN) // On Windows we rely on the CanResize() to indicate whether window can be @@ -328,7 +307,7 @@ NativeWindowViews::~NativeWindowViews() { void NativeWindowViews::SetContentView( brightray::InspectableWebContents* web_contents) { if (content_view_) { - RemoveChildView(content_view_); + root_view_->RemoveChildView(content_view_); if (browser_view()) { content_view_->RemoveChildView( browser_view()->GetInspectableWebContentsView()->GetView()); @@ -337,8 +316,8 @@ void NativeWindowViews::SetContentView( } content_view_ = web_contents->GetView()->GetView(); focused_view_ = web_contents->GetView()->GetWebView(); - AddChildView(content_view_); - Layout(); + root_view_->AddChildView(content_view_); + root_view_->Layout(); } void NativeWindowViews::Close() { @@ -550,7 +529,7 @@ void NativeWindowViews::SetFullScreen(bool fullscreen) { if (fullscreen) SetMenuBarVisibility(false); else - SetMenuBarVisibility(!menu_bar_autohide_); + SetMenuBarVisibility(!IsMenuBarAutoHide()); #endif } @@ -809,7 +788,7 @@ bool NativeWindowViews::IsKiosk() { void NativeWindowViews::SetBackgroundColor(SkColor background_color) { // web views' background color. - SetBackground(views::CreateSolidBackground(background_color)); + root_view_->SetBackground(views::CreateSolidBackground(background_color)); #if defined(OS_WIN) // Set the background color of native window. @@ -901,22 +880,10 @@ void NativeWindowViews::SetFocusable(bool focusable) { } void NativeWindowViews::SetMenu(AtomMenuModel* menu_model) { - if (menu_model == nullptr) { - // Remove accelerators - accelerator_table_.clear(); - GetFocusManager()->UnregisterAccelerators(this); - // and menu bar. #if defined(USE_X11) + if (menu_model == nullptr) global_menu_bar_.reset(); -#endif - SetMenuBarVisibility(false); - menu_bar_.reset(); - return; - } - RegisterAccelerators(menu_model); - -#if defined(USE_X11) if (!global_menu_bar_ && ShouldUseGlobalMenuBar()) global_menu_bar_.reset(new GlobalMenuBarX11(this)); @@ -927,40 +894,33 @@ void NativeWindowViews::SetMenu(AtomMenuModel* menu_model) { } #endif - // Do not show menu bar in frameless window. - if (!has_frame()) - return; + // Should reset content size when setting menu. + gfx::Size content_size = GetContentSize(); + bool should_reset_size = use_content_size_ && has_frame() && + !IsMenuBarAutoHide() && + ((!!menu_model) != root_view_->HasMenu()); - if (!menu_bar_) { - gfx::Size content_size = GetContentSize(); - menu_bar_.reset(new MenuBar(this)); - menu_bar_->set_owned_by_client(); + root_view_->SetMenu(menu_model); - if (!menu_bar_autohide_) { - SetMenuBarVisibility(true); - if (use_content_size_) { - // Enlarge the size constraints for the menu. - extensions::SizeConstraints constraints = GetContentSizeConstraints(); - if (constraints.HasMinimumSize()) { - gfx::Size min_size = constraints.GetMinimumSize(); - min_size.set_height(min_size.height() + kMenuBarHeight); - constraints.set_minimum_size(min_size); - } - if (constraints.HasMaximumSize()) { - gfx::Size max_size = constraints.GetMaximumSize(); - max_size.set_height(max_size.height() + kMenuBarHeight); - constraints.set_maximum_size(max_size); - } - SetContentSizeConstraints(constraints); - - // Resize the window to make sure content size is not changed. - SetContentSize(content_size); - } + if (should_reset_size) { + // Enlarge the size constraints for the menu. + int menu_bar_height = root_view_->GetMenuBarHeight(); + extensions::SizeConstraints constraints = GetContentSizeConstraints(); + if (constraints.HasMinimumSize()) { + gfx::Size min_size = constraints.GetMinimumSize(); + min_size.set_height(min_size.height() + menu_bar_height); + constraints.set_minimum_size(min_size); } - } + if (constraints.HasMaximumSize()) { + gfx::Size max_size = constraints.GetMaximumSize(); + max_size.set_height(max_size.height() + menu_bar_height); + constraints.set_maximum_size(max_size); + } + SetContentSizeConstraints(constraints); - menu_bar_->SetMenu(menu_model); - Layout(); + // Resize the window to make sure content size is not changed. + SetContentSize(content_size); + } } void NativeWindowViews::SetBrowserView(NativeBrowserView* view) { @@ -1036,35 +996,19 @@ void NativeWindowViews::SetOverlayIcon(const gfx::Image& overlay, } void NativeWindowViews::SetAutoHideMenuBar(bool auto_hide) { - menu_bar_autohide_ = auto_hide; + root_view_->SetAutoHideMenuBar(auto_hide); } bool NativeWindowViews::IsMenuBarAutoHide() { - return menu_bar_autohide_; + return root_view_->IsMenuBarAutoHide(); } void NativeWindowViews::SetMenuBarVisibility(bool visible) { - if (!menu_bar_ || menu_bar_visible_ == visible) - return; - - // Always show the accelerator when the auto-hide menu bar shows. - if (menu_bar_autohide_) - menu_bar_->SetAcceleratorVisibility(visible); - - menu_bar_visible_ = visible; - if (visible) { - DCHECK_EQ(child_count(), 1); - AddChildView(menu_bar_.get()); - } else { - DCHECK_EQ(child_count(), 2); - RemoveChildView(menu_bar_.get()); - } - - Layout(); + root_view_->SetMenuBarVisibility(visible); } bool NativeWindowViews::IsMenuBarVisible() { - return menu_bar_visible_; + return root_view_->IsMenuBarVisible(); } void NativeWindowViews::SetVisibleOnAllWorkspaces(bool visible) { @@ -1102,9 +1046,10 @@ gfx::Rect NativeWindowViews::ContentBoundsToWindowBounds( widget()->non_client_view()->GetWindowBoundsForClientBounds(dpi_bounds)); #endif - if (menu_bar_ && menu_bar_visible_) { - window_bounds.set_y(window_bounds.y() - kMenuBarHeight); - window_bounds.set_height(window_bounds.height() + kMenuBarHeight); + if (root_view_->HasMenu() && root_view_->IsMenuBarVisible()) { + int menu_bar_height = root_view_->GetMenuBarHeight(); + window_bounds.set_y(window_bounds.y() - menu_bar_height); + window_bounds.set_height(window_bounds.height() + menu_bar_height); } return window_bounds; } @@ -1130,9 +1075,10 @@ gfx::Rect NativeWindowViews::WindowBoundsToContentBounds( display::win::ScreenWin::ScreenToDIPSize(hwnd, content_bounds.size())); #endif - if (menu_bar_ && menu_bar_visible_) { - content_bounds.set_y(content_bounds.y() + kMenuBarHeight); - content_bounds.set_height(content_bounds.height() - kMenuBarHeight); + if (root_view_->HasMenu() && root_view_->IsMenuBarVisible()) { + int menu_bar_height = root_view_->GetMenuBarHeight(); + content_bounds.set_y(content_bounds.y() + menu_bar_height); + content_bounds.set_height(content_bounds.height() - menu_bar_height); } return content_bounds; } @@ -1175,10 +1121,10 @@ void NativeWindowViews::OnWidgetActivationChanged(views::Widget* changed_widget, GetWeakPtr())); // Hide menu bar when window is blured. - if (!active && menu_bar_autohide_ && menu_bar_visible_) + if (!active && IsMenuBarAutoHide() && IsMenuBarVisible()) SetMenuBarVisibility(false); - menu_bar_alt_pressed_ = false; + root_view_->ResetAltState(); } void NativeWindowViews::OnWidgetBoundsChanged(views::Widget* changed_widget, @@ -1255,7 +1201,7 @@ bool NativeWindowViews::ShouldHandleSystemCommands() const { } views::View* NativeWindowViews::GetContentsView() { - return this; + return root_view_.get(); } bool NativeWindowViews::ShouldDescendIntoChildForEventHandling( @@ -1277,7 +1223,7 @@ bool NativeWindowViews::ShouldDescendIntoChildForEventHandling( } views::ClientView* NativeWindowViews::CreateClientView(views::Widget* widget) { - return new NativeWindowClientView(widget, this); + return new NativeWindowClientView(widget, root_view_.get(), this); } views::NonClientFrameView* NativeWindowViews::CreateNonClientFrameView( @@ -1304,86 +1250,9 @@ void NativeWindowViews::OnWidgetMove() { void NativeWindowViews::HandleKeyboardEvent( content::WebContents*, const content::NativeWebKeyboardEvent& event) { - keyboard_event_handler_->HandleKeyboardEvent(event, GetFocusManager()); - - if (!menu_bar_) - return; - - // Show accelerator when "Alt" is pressed. - if (menu_bar_visible_ && IsAltKey(event)) - menu_bar_->SetAcceleratorVisibility(event.GetType() == - blink::WebInputEvent::kRawKeyDown); - - // Show the submenu when "Alt+Key" is pressed. - if (event.GetType() == blink::WebInputEvent::kRawKeyDown && - !IsAltKey(event) && IsAltModifier(event)) { - if (!menu_bar_visible_ && - (menu_bar_->HasAccelerator(event.windows_key_code))) - SetMenuBarVisibility(true); - menu_bar_->ActivateAccelerator(event.windows_key_code); - return; - } - - if (!menu_bar_autohide_) - return; - - // Toggle the menu bar only when a single Alt is released. - if (event.GetType() == blink::WebInputEvent::kRawKeyDown && IsAltKey(event)) { - // When a single Alt is pressed: - menu_bar_alt_pressed_ = true; - } else if (event.GetType() == blink::WebInputEvent::kKeyUp && - IsAltKey(event) && menu_bar_alt_pressed_) { - // When a single Alt is released right after a Alt is pressed: - menu_bar_alt_pressed_ = false; - SetMenuBarVisibility(!menu_bar_visible_); - } else { - // When any other keys except single Alt have been pressed/released: - menu_bar_alt_pressed_ = false; - } -} - -void NativeWindowViews::Layout() { - if (!content_view_) // Not ready yet. - return; - - const auto size = GetContentsBounds().size(); - const auto menu_bar_bounds = - menu_bar_visible_ ? gfx::Rect(0, 0, size.width(), kMenuBarHeight) - : gfx::Rect(); - if (menu_bar_) { - menu_bar_->SetBoundsRect(menu_bar_bounds); - } - - content_view_->SetBoundsRect( - gfx::Rect(0, menu_bar_bounds.height(), size.width(), - size.height() - menu_bar_bounds.height())); -} - -gfx::Size NativeWindowViews::GetMinimumSize() const { - return NativeWindow::GetMinimumSize(); -} - -gfx::Size NativeWindowViews::GetMaximumSize() const { - return NativeWindow::GetMaximumSize(); -} - -bool NativeWindowViews::AcceleratorPressed(const ui::Accelerator& accelerator) { - return accelerator_util::TriggerAcceleratorTableCommand(&accelerator_table_, - accelerator); -} - -void NativeWindowViews::RegisterAccelerators(AtomMenuModel* menu_model) { - // Clear previous accelerators. - views::FocusManager* focus_manager = GetFocusManager(); - accelerator_table_.clear(); - focus_manager->UnregisterAccelerators(this); - - // Register accelerators with focus manager. - accelerator_util::GenerateAcceleratorTable(&accelerator_table_, menu_model); - for (const auto& iter : accelerator_table_) { - focus_manager->RegisterAccelerator( - iter.first, ui::AcceleratorManager::kNormalPriority, this); - } + keyboard_event_handler_->HandleKeyboardEvent(event, + root_view_->GetFocusManager()); + root_view_->HandleKeyEvent(event); } ui::WindowShowState NativeWindowViews::GetRestoredState() { diff --git a/atom/browser/native_window_views.h b/atom/browser/native_window_views.h index e91cae21bad7..fdf5e5772ee8 100644 --- a/atom/browser/native_window_views.h +++ b/atom/browser/native_window_views.h @@ -9,9 +9,7 @@ #include #include -#include -#include "atom/browser/ui/accelerator_util.h" #include "ui/views/widget/widget_observer.h" #if defined(OS_WIN) @@ -27,7 +25,7 @@ class UnhandledKeyboardEventHandler; namespace atom { class GlobalMenuBarX11; -class MenuBar; +class RootView; class WindowStateWatcher; #if defined(OS_WIN) @@ -40,7 +38,6 @@ class NativeWindowViews : public NativeWindow, #if defined(OS_WIN) public MessageHandlerDelegate, #endif - public views::View, public views::WidgetObserver { public: NativeWindowViews(const mate::Dictionary& options, NativeWindow* parent); @@ -195,26 +192,14 @@ class NativeWindowViews : public NativeWindow, content::WebContents*, const content::NativeWebKeyboardEvent& event) override; - // views::View: - void Layout() override; - gfx::Size GetMinimumSize() const override; - gfx::Size GetMaximumSize() const override; - bool AcceleratorPressed(const ui::Accelerator& accelerator) override; - - // Register accelerators supported by the menu model. - void RegisterAccelerators(AtomMenuModel* menu_model); - // Returns the restore state for the window. ui::WindowShowState GetRestoredState(); + std::unique_ptr root_view_; + views::View* content_view_; // Weak ref. views::View* focused_view_; // The view should be focused by default. - std::unique_ptr menu_bar_; - bool menu_bar_autohide_; - bool menu_bar_visible_; - bool menu_bar_alt_pressed_; - // The "resizable" flag on Linux is implemented by setting size constraints, // we need to make sure size constraints are restored when window becomes // resizable again. This is also used on Windows, to keep taskbar resize @@ -281,9 +266,6 @@ class NativeWindowViews : public NativeWindow, // Handles unhandled keyboard messages coming back from the renderer process. std::unique_ptr keyboard_event_handler_; - // Map from accelerator to menu item's command id. - accelerator_util::AcceleratorTable accelerator_table_; - // For custom drag, the whole window is non-draggable and the draggable region // has to been explicitly provided. std::unique_ptr draggable_region_; // used in custom drag. diff --git a/atom/browser/ui/views/root_view.cc b/atom/browser/ui/views/root_view.cc new file mode 100644 index 000000000000..b49dd014b07c --- /dev/null +++ b/atom/browser/ui/views/root_view.cc @@ -0,0 +1,197 @@ +// Copyright (c) 2018 GitHub, Inc. +// Use of this source code is governed by the MIT license that can be +// found in the LICENSE file. + +#include "atom/browser/ui/views/root_view.h" + +#include "atom/browser/native_window_views.h" +#include "atom/browser/ui/views/menu_bar.h" +#include "content/public/browser/native_web_keyboard_event.h" + +namespace atom { + +namespace { + +// The menu bar height in pixels. +#if defined(OS_WIN) +const int kMenuBarHeight = 20; +#else +const int kMenuBarHeight = 25; +#endif + +bool IsAltKey(const content::NativeWebKeyboardEvent& event) { + return event.windows_key_code == ui::VKEY_MENU; +} + +bool IsAltModifier(const content::NativeWebKeyboardEvent& event) { + typedef content::NativeWebKeyboardEvent::Modifiers Modifiers; + int modifiers = event.GetModifiers(); + modifiers &= ~Modifiers::kNumLockOn; + modifiers &= ~Modifiers::kCapsLockOn; + return (modifiers == Modifiers::kAltKey) || + (modifiers == (Modifiers::kAltKey | Modifiers::kIsLeft)) || + (modifiers == (Modifiers::kAltKey | Modifiers::kIsRight)); +} + +} // namespace + +RootView::RootView(NativeWindow* window) : window_(window) { + set_owned_by_client(); +} + +RootView::~RootView() {} + +void RootView::SetMenu(AtomMenuModel* menu_model) { + if (menu_model == nullptr) { + // Remove accelerators + accelerator_table_.clear(); + GetFocusManager()->UnregisterAccelerators(this); + // and menu bar. + SetMenuBarVisibility(false); + menu_bar_.reset(); + return; + } + + RegisterAccelerators(menu_model); + + // Do not show menu bar in frameless window. + if (!window_->has_frame()) + return; + + if (!menu_bar_) { + menu_bar_.reset(new MenuBar(this)); + menu_bar_->set_owned_by_client(); + if (!menu_bar_autohide_) + SetMenuBarVisibility(true); + } + + menu_bar_->SetMenu(menu_model); + Layout(); +} + +bool RootView::HasMenu() const { + return !!menu_bar_; +} + +int RootView::GetMenuBarHeight() const { + return kMenuBarHeight; +} + +void RootView::SetAutoHideMenuBar(bool auto_hide) { + menu_bar_autohide_ = auto_hide; +} + +bool RootView::IsMenuBarAutoHide() const { + return menu_bar_autohide_; +} + +void RootView::SetMenuBarVisibility(bool visible) { + if (!menu_bar_ || menu_bar_visible_ == visible) + return; + + // Always show the accelerator when the auto-hide menu bar shows. + if (menu_bar_autohide_) + menu_bar_->SetAcceleratorVisibility(visible); + + menu_bar_visible_ = visible; + if (visible) { + DCHECK_EQ(child_count(), 1); + AddChildView(menu_bar_.get()); + } else { + DCHECK_EQ(child_count(), 2); + RemoveChildView(menu_bar_.get()); + } + + Layout(); +} + +bool RootView::IsMenuBarVisible() const { + return menu_bar_visible_; +} + +void RootView::HandleKeyEvent(const content::NativeWebKeyboardEvent& event) { + if (!menu_bar_) + return; + + // Show accelerator when "Alt" is pressed. + if (menu_bar_visible_ && IsAltKey(event)) + menu_bar_->SetAcceleratorVisibility(event.GetType() == + blink::WebInputEvent::kRawKeyDown); + + // Show the submenu when "Alt+Key" is pressed. + if (event.GetType() == blink::WebInputEvent::kRawKeyDown && + !IsAltKey(event) && IsAltModifier(event)) { + if (!menu_bar_visible_ && + (menu_bar_->HasAccelerator(event.windows_key_code))) + SetMenuBarVisibility(true); + menu_bar_->ActivateAccelerator(event.windows_key_code); + return; + } + + if (!menu_bar_autohide_) + return; + + // Toggle the menu bar only when a single Alt is released. + if (event.GetType() == blink::WebInputEvent::kRawKeyDown && IsAltKey(event)) { + // When a single Alt is pressed: + menu_bar_alt_pressed_ = true; + } else if (event.GetType() == blink::WebInputEvent::kKeyUp && + IsAltKey(event) && menu_bar_alt_pressed_) { + // When a single Alt is released right after a Alt is pressed: + menu_bar_alt_pressed_ = false; + SetMenuBarVisibility(!menu_bar_visible_); + } else { + // When any other keys except single Alt have been pressed/released: + menu_bar_alt_pressed_ = false; + } +} + +void RootView::ResetAltState() { + menu_bar_alt_pressed_ = false; +} + +void RootView::Layout() { + views::View* content_view = + static_cast(window_)->content_view(); + if (!content_view) // Not ready yet. + return; + + const auto menu_bar_bounds = + menu_bar_visible_ ? gfx::Rect(0, 0, size().width(), kMenuBarHeight) + : gfx::Rect(); + if (menu_bar_) + menu_bar_->SetBoundsRect(menu_bar_bounds); + + content_view->SetBoundsRect( + gfx::Rect(0, menu_bar_bounds.height(), size().width(), + size().height() - menu_bar_bounds.height())); +} + +gfx::Size RootView::GetMinimumSize() const { + return window_->GetMinimumSize(); +} + +gfx::Size RootView::GetMaximumSize() const { + return window_->GetMaximumSize(); +} + +bool RootView::AcceleratorPressed(const ui::Accelerator& accelerator) { + return accelerator_util::TriggerAcceleratorTableCommand(&accelerator_table_, + accelerator); +} + +void RootView::RegisterAccelerators(AtomMenuModel* menu_model) { + // Clear previous accelerators. + views::FocusManager* focus_manager = GetFocusManager(); + accelerator_table_.clear(); + focus_manager->UnregisterAccelerators(this); + + // Register accelerators with focus manager. + accelerator_util::GenerateAcceleratorTable(&accelerator_table_, menu_model); + for (const auto& iter : accelerator_table_) { + focus_manager->RegisterAccelerator( + iter.first, ui::AcceleratorManager::kNormalPriority, this); + } +} + +} // namespace atom diff --git a/atom/browser/ui/views/root_view.h b/atom/browser/ui/views/root_view.h new file mode 100644 index 000000000000..66c6d4e8a557 --- /dev/null +++ b/atom/browser/ui/views/root_view.h @@ -0,0 +1,65 @@ +// Copyright (c) 2018 GitHub, Inc. +// Use of this source code is governed by the MIT license that can be +// found in the LICENSE file. + +#ifndef ATOM_BROWSER_UI_VIEWS_ROOT_VIEW_H_ +#define ATOM_BROWSER_UI_VIEWS_ROOT_VIEW_H_ + +#include + +#include "atom/browser/ui/accelerator_util.h" +#include "ui/views/view.h" + +namespace content { +struct NativeWebKeyboardEvent; +} + +namespace atom { + +class AtomMenuModel; +class MenuBar; +class NativeWindow; + +class RootView : public views::View { + public: + explicit RootView(NativeWindow* window); + ~RootView() override; + + void SetMenu(AtomMenuModel* menu_model); + bool HasMenu() const; + int GetMenuBarHeight() const; + void SetAutoHideMenuBar(bool auto_hide); + bool IsMenuBarAutoHide() const; + void SetMenuBarVisibility(bool visible); + bool IsMenuBarVisible() const; + void HandleKeyEvent(const content::NativeWebKeyboardEvent& event); + void ResetAltState(); + + // views::View: + void Layout() override; + gfx::Size GetMinimumSize() const override; + gfx::Size GetMaximumSize() const override; + bool AcceleratorPressed(const ui::Accelerator& accelerator) override; + + private: + // Register accelerators supported by the menu model. + void RegisterAccelerators(AtomMenuModel* menu_model); + + // Parent window, weak ref. + NativeWindow* window_; + + // Menu bar. + std::unique_ptr menu_bar_; + bool menu_bar_autohide_ = false; + bool menu_bar_visible_ = false; + bool menu_bar_alt_pressed_ = false; + + // Map from accelerator to menu item's command id. + accelerator_util::AcceleratorTable accelerator_table_; + + DISALLOW_COPY_AND_ASSIGN(RootView); +}; + +} // namespace atom + +#endif // ATOM_BROWSER_UI_VIEWS_ROOT_VIEW_H_ diff --git a/filenames.gypi b/filenames.gypi index 47ad0abc3933..44dcc015d58a 100644 --- a/filenames.gypi +++ b/filenames.gypi @@ -368,6 +368,8 @@ 'atom/browser/ui/views/menu_model_adapter.h', 'atom/browser/ui/views/native_frame_view.cc', 'atom/browser/ui/views/native_frame_view.h', + 'atom/browser/ui/views/root_view.cc', + 'atom/browser/ui/views/root_view.h', 'atom/browser/ui/views/submenu_button.cc', 'atom/browser/ui/views/submenu_button.h', 'atom/browser/ui/views/win_frame_view.cc',