electron/shell/browser/native_window_views.h

314 lines
11 KiB
C
Raw Normal View History

// Copyright (c) 2014 GitHub, Inc.
2014-07-02 14:14:52 +00:00
// Use of this source code is governed by the MIT license that can be
// found in the LICENSE file.
#ifndef ATOM_BROWSER_NATIVE_WINDOW_VIEWS_H_
#define ATOM_BROWSER_NATIVE_WINDOW_VIEWS_H_
2014-07-02 14:14:52 +00:00
#include "atom/browser/native_window.h"
#include <memory>
#include <set>
#include <string>
#include <tuple>
2014-07-08 04:55:33 +00:00
#include "ui/views/widget/widget_observer.h"
2015-08-06 02:15:27 +00:00
#if defined(OS_WIN)
2015-08-06 03:10:34 +00:00
#include "atom/browser/ui/win/taskbar_host.h"
2016-05-31 08:47:45 +00:00
#include "base/win/scoped_gdi_object.h"
2015-08-06 02:15:27 +00:00
#endif
namespace views {
class UnhandledKeyboardEventHandler;
}
2014-07-02 14:14:52 +00:00
namespace atom {
class GlobalMenuBarX11;
class RootView;
2014-11-25 03:46:30 +00:00
class WindowStateWatcher;
#if defined(USE_X11)
class EventDisabler;
#endif
class NativeWindowViews : public NativeWindow,
public views::WidgetObserver,
public ui::EventHandler {
2014-07-02 14:14:52 +00:00
public:
2018-04-18 01:44:10 +00:00
NativeWindowViews(const mate::Dictionary& options, NativeWindow* parent);
~NativeWindowViews() override;
2014-07-02 14:14:52 +00:00
// NativeWindow:
void SetContentView(views::View* view) override;
void Close() override;
void CloseImmediately() override;
void Focus(bool focus) override;
bool IsFocused() override;
void Show() override;
void ShowInactive() override;
void Hide() override;
bool IsVisible() override;
bool IsEnabled() override;
2018-04-08 11:20:43 +00:00
void SetEnabled(bool enable) override;
void Maximize() override;
void Unmaximize() override;
bool IsMaximized() override;
void Minimize() override;
void Restore() override;
bool IsMinimized() override;
2014-11-25 06:34:14 +00:00
void SetFullScreen(bool fullscreen) override;
2015-04-21 13:35:36 +00:00
bool IsFullscreen() const override;
2016-01-15 04:54:12 +00:00
void SetBounds(const gfx::Rect& bounds, bool animate) override;
gfx::Rect GetBounds() override;
2016-07-29 01:19:17 +00:00
gfx::Rect GetContentBounds() override;
gfx::Size GetContentSize() override;
gfx::Rect GetNormalBounds() override;
void SetContentSizeConstraints(
const extensions::SizeConstraints& size_constraints) override;
void SetResizable(bool resizable) override;
void MoveTop() override;
bool IsResizable() override;
void SetMovable(bool movable) override;
bool IsMovable() override;
void SetMinimizable(bool minimizable) override;
bool IsMinimizable() override;
2016-01-22 21:24:33 +00:00
void SetMaximizable(bool maximizable) override;
bool IsMaximizable() override;
2016-01-23 07:47:37 +00:00
void SetFullScreenable(bool fullscreenable) override;
bool IsFullScreenable() override;
void SetClosable(bool closable) override;
bool IsClosable() override;
2018-04-18 01:44:10 +00:00
void SetAlwaysOnTop(bool top,
const std::string& level,
int relativeLevel,
std::string* error) override;
bool IsAlwaysOnTop() override;
void Center() override;
void Invalidate() override;
void SetTitle(const std::string& title) override;
std::string GetTitle() override;
void FlashFrame(bool flash) override;
void SetSkipTaskbar(bool skip) override;
void SetExcludedFromShownWindowsMenu(bool excluded) override;
bool IsExcludedFromShownWindowsMenu() override;
void SetSimpleFullScreen(bool simple_fullscreen) override;
bool IsSimpleFullScreen() override;
void SetKiosk(bool kiosk) override;
bool IsKiosk() override;
void SetBackgroundColor(SkColor color) override;
2016-01-23 10:55:12 +00:00
void SetHasShadow(bool has_shadow) override;
bool HasShadow() override;
2017-09-29 02:26:02 +00:00
void SetOpacity(const double opacity) override;
double GetOpacity() override;
void SetIgnoreMouseEvents(bool ignore, bool forward) override;
void SetContentProtection(bool enable) override;
2016-06-13 08:10:28 +00:00
void SetFocusable(bool focusable) override;
void SetMenu(AtomMenuModel* menu_model) override;
void AddBrowserView(NativeBrowserView* browser_view) override;
void RemoveBrowserView(NativeBrowserView* browser_view) override;
void SetParentWindow(NativeWindow* parent) override;
2017-05-21 18:57:19 +00:00
gfx::NativeView GetNativeView() const override;
gfx::NativeWindow GetNativeWindow() const override;
2015-02-07 01:00:26 +00:00
void SetOverlayIcon(const gfx::Image& overlay,
const std::string& description) override;
void SetProgressBar(double progress, const ProgressState state) override;
2014-11-12 12:32:14 +00:00
void SetAutoHideMenuBar(bool auto_hide) override;
bool IsMenuBarAutoHide() override;
void SetMenuBarVisibility(bool visible) override;
bool IsMenuBarVisible() override;
void SetVisibleOnAllWorkspaces(bool visible,
bool visibleOnFullScreen) override;
bool IsVisibleOnAllWorkspaces() override;
2014-07-02 14:14:52 +00:00
2017-05-21 18:57:19 +00:00
gfx::AcceleratedWidget GetAcceleratedWidget() const override;
NativeWindowHandle GetNativeWindowHandle() const override;
2014-07-21 14:03:58 +00:00
gfx::Rect ContentBoundsToWindowBounds(const gfx::Rect& bounds) const override;
gfx::Rect WindowBoundsToContentBounds(const gfx::Rect& bounds) const override;
void UpdateDraggableRegions(std::unique_ptr<SkRegion> region);
void IncrementChildModals();
void DecrementChildModals();
2015-08-06 03:10:34 +00:00
#if defined(OS_WIN)
// Catch-all message handling and filtering. Called before
// HWNDMessageHandler's built-in handling, which may pre-empt some
// expectations in Views/Aura if messages are consumed. Returns true if the
// message was consumed by the delegate and should not be processed further
// by the HWNDMessageHandler. In this case, |result| is returned. |result| is
// not modified otherwise.
bool PreHandleMSG(UINT message,
WPARAM w_param,
LPARAM l_param,
LRESULT* result);
2016-05-20 10:46:05 +00:00
void SetIcon(HICON small_icon, HICON app_icon);
2016-05-20 13:22:15 +00:00
#elif defined(USE_X11)
void SetIcon(const gfx::ImageSkia& icon);
2015-08-06 03:10:34 +00:00
#endif
SkRegion* draggable_region() const { return draggable_region_.get(); }
2016-05-20 10:46:05 +00:00
2016-05-20 13:22:15 +00:00
#if defined(OS_WIN)
TaskbarHost& taskbar_host() { return taskbar_host_; }
#endif
2014-07-02 14:14:52 +00:00
private:
2014-07-08 04:55:33 +00:00
// views::WidgetObserver:
2018-04-18 01:44:10 +00:00
void OnWidgetActivationChanged(views::Widget* widget, bool active) override;
void OnWidgetBoundsChanged(views::Widget* widget,
const gfx::Rect& bounds) override;
void OnWidgetDestroying(views::Widget* widget) override;
// views::WidgetDelegate:
void DeleteDelegate() override;
views::View* GetInitiallyFocusedView() override;
bool CanResize() const override;
bool CanMaximize() const override;
bool CanMinimize() const override;
base::string16 GetWindowTitle() const override;
views::View* GetContentsView() override;
bool ShouldDescendIntoChildForEventHandling(
2018-04-18 01:44:10 +00:00
gfx::NativeView child,
const gfx::Point& location) override;
views::ClientView* CreateClientView(views::Widget* widget) override;
views::NonClientFrameView* CreateNonClientFrameView(
views::Widget* widget) override;
void OnWidgetMove() override;
2014-11-25 06:28:34 +00:00
#if defined(OS_WIN)
bool ExecuteWindowsCommand(int command_id) override;
#endif
#if defined(OS_WIN)
void HandleSizeEvent(WPARAM w_param, LPARAM l_param);
void SetForwardMouseMessages(bool forward);
2018-04-18 01:44:10 +00:00
static LRESULT CALLBACK SubclassProc(HWND hwnd,
UINT msg,
WPARAM w_param,
LPARAM l_param,
UINT_PTR subclass_id,
DWORD_PTR ref_data);
static LRESULT CALLBACK MouseHookProc(int n_code,
WPARAM w_param,
LPARAM l_param);
#endif
// Enable/disable:
bool ShouldBeEnabled();
void SetEnabledInternal(bool enabled);
// NativeWindow:
void HandleKeyboardEvent(
2014-07-04 08:54:10 +00:00
content::WebContents*,
const content::NativeWebKeyboardEvent& event) override;
2014-07-04 08:54:10 +00:00
#if defined(OS_LINUX)
// ui::EventHandler:
void OnMouseEvent(ui::MouseEvent* event) override;
#endif
// Returns the restore state for the window.
ui::WindowShowState GetRestoredState();
std::unique_ptr<RootView> root_view_;
// The view should be focused by default.
views::View* focused_view_ = nullptr;
2014-07-04 08:54:10 +00:00
2018-04-25 07:25:55 +00:00
// 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
// events from resizing the window.
extensions::SizeConstraints old_size_constraints_;
#if defined(USE_X11)
2016-05-23 01:59:39 +00:00
std::unique_ptr<GlobalMenuBarX11> global_menu_bar_;
2014-11-25 03:46:30 +00:00
// Handles window state events.
2016-05-23 01:59:39 +00:00
std::unique_ptr<WindowStateWatcher> window_state_watcher_;
// To disable the mouse events.
std::unique_ptr<EventDisabler> event_disabler_;
#endif
2018-04-25 07:25:55 +00:00
#if defined(OS_WIN)
ui::WindowShowState last_window_state_;
gfx::Rect last_normal_placement_bounds_;
// There's an issue with restore on Windows, that sometimes causes the Window
// to receive the wrong size (#2498). To circumvent that, we keep tabs on the
// size of the window while in the normal state (not maximized, minimized or
// fullscreen), so we restore it correctly.
gfx::Rect last_normal_bounds_;
gfx::Rect last_normal_bounds_before_move_;
// last_normal_bounds_ may or may not require update on WM_MOVE. When a
// window is maximized, it is moved (WM_MOVE) to maximum size first and then
// sized (WM_SIZE). In this case, last_normal_bounds_ should not update. We
// keep last_normal_bounds_candidate_ as a candidate which will become valid
// last_normal_bounds_ if the moves are consecutive with no WM_SIZE event in
// between.
gfx::Rect last_normal_bounds_candidate_;
bool consecutive_moves_;
2015-08-06 02:30:22 +00:00
// In charge of running taskbar related APIs.
2015-08-06 03:10:34 +00:00
TaskbarHost taskbar_host_;
// Memoized version of a11y check
bool checked_for_a11y_support_ = false;
2016-07-09 12:49:15 +00:00
// Whether to show the WS_THICKFRAME style.
bool thick_frame_ = true;
2016-07-09 12:49:15 +00:00
2016-07-09 14:16:57 +00:00
// The bounds of window before maximize/fullscreen.
gfx::Rect restore_bounds_;
2016-05-31 08:47:45 +00:00
// The icons of window and taskbar.
base::win::ScopedHICON window_icon_;
base::win::ScopedHICON app_icon_;
// The set of windows currently forwarding mouse messages.
static std::set<NativeWindowViews*> forwarding_windows_;
static HHOOK mouse_hook_;
bool forwarding_mouse_messages_ = false;
HWND legacy_window_ = NULL;
2017-09-29 02:26:02 +00:00
bool layered_ = false;
#endif
2014-11-25 03:46:30 +00:00
// Handles unhandled keyboard messages coming back from the renderer process.
2016-05-23 01:59:39 +00:00
std::unique_ptr<views::UnhandledKeyboardEventHandler> keyboard_event_handler_;
// For custom drag, the whole window is non-draggable and the draggable region
// has to been explicitly provided.
std::unique_ptr<SkRegion> draggable_region_; // used in custom drag.
// Whether the window should be enabled based on user calls to SetEnabled()
bool is_enabled_ = true;
// How many modal children this window has;
// used to determine enabled state
unsigned int num_modal_children_ = 0;
bool use_content_size_ = false;
bool movable_ = true;
bool resizable_ = true;
bool maximizable_ = true;
bool minimizable_ = true;
bool fullscreenable_ = true;
std::string title_;
2015-05-09 15:55:10 +00:00
gfx::Size widget_size_;
double opacity_ = 1.0;
2014-07-02 14:14:52 +00:00
DISALLOW_COPY_AND_ASSIGN(NativeWindowViews);
2014-07-02 14:14:52 +00:00
};
} // namespace atom
#endif // ATOM_BROWSER_NATIVE_WINDOW_VIEWS_H_