OLD | NEW |
| (Empty) |
1 // Copyright 2014 The Chromium Authors. All rights reserved. | |
2 // Use of this source code is governed by a BSD-style license that can be | |
3 // found in the LICENSE file. | |
4 | |
5 #ifndef ASH_WM_MAXIMIZE_MODE_MAXIMIZE_MODE_WINDOW_MANAGER_H_ | |
6 #define ASH_WM_MAXIMIZE_MODE_MAXIMIZE_MODE_WINDOW_MANAGER_H_ | |
7 | |
8 #include <stdint.h> | |
9 | |
10 #include <map> | |
11 #include <unordered_set> | |
12 | |
13 #include "ash/ash_export.h" | |
14 #include "ash/shell_observer.h" | |
15 #include "ash/wm/window_state.h" | |
16 #include "base/macros.h" | |
17 #include "ui/aura/window_observer.h" | |
18 #include "ui/display/display_observer.h" | |
19 | |
20 namespace aura { | |
21 class Window; | |
22 } | |
23 | |
24 namespace ash { | |
25 class MaximizeModeController; | |
26 class MaximizeModeWindowState; | |
27 | |
28 namespace wm { | |
29 class MaximizeModeEventHandler; | |
30 } | |
31 | |
32 // A window manager which - when created - will force all windows into maximized | |
33 // mode. Exception are panels and windows which cannot be maximized. | |
34 // Windows which cannot be maximized / resized are centered with a layer placed | |
35 // behind the window so that no other windows are visible and/or obscured. | |
36 // With the destruction of the manager all windows will be restored to their | |
37 // original state. | |
38 class ASH_EXPORT MaximizeModeWindowManager : public aura::WindowObserver, | |
39 public display::DisplayObserver, | |
40 public ShellObserver { | |
41 public: | |
42 // This should only be deleted by the creator (ash::Shell). | |
43 ~MaximizeModeWindowManager() override; | |
44 | |
45 // Returns the number of maximized & tracked windows by this manager. | |
46 int GetNumberOfManagedWindows(); | |
47 | |
48 // Adds a window which needs to be maximized. This is used by other window | |
49 // managers for windows which needs to get tracked due to (upcoming) state | |
50 // changes. | |
51 // The call gets ignored if the window was already or should not be handled. | |
52 void AddWindow(aura::Window* window); | |
53 | |
54 // Called from a window state object when it gets destroyed. | |
55 void WindowStateDestroyed(aura::Window* window); | |
56 | |
57 // ShellObserver overrides: | |
58 void OnOverviewModeStarting() override; | |
59 void OnOverviewModeEnded() override; | |
60 | |
61 // Overridden from WindowObserver: | |
62 void OnWindowDestroying(aura::Window* window) override; | |
63 void OnWindowHierarchyChanged(const HierarchyChangeParams& params) override; | |
64 void OnWindowPropertyChanged(aura::Window* window, | |
65 const void* key, | |
66 intptr_t old) override; | |
67 void OnWindowBoundsChanged(aura::Window* window, | |
68 const gfx::Rect& old_bounds, | |
69 const gfx::Rect& new_bounds) override; | |
70 void OnWindowVisibilityChanged(aura::Window* window, bool visible) override; | |
71 | |
72 // display::DisplayObserver overrides: | |
73 void OnDisplayAdded(const display::Display& display) override; | |
74 void OnDisplayRemoved(const display::Display& display) override; | |
75 void OnDisplayMetricsChanged(const display::Display& display, | |
76 uint32_t metrics) override; | |
77 | |
78 // Tell all managing windows not to handle WM events. | |
79 void SetIgnoreWmEventsForExit(); | |
80 | |
81 protected: | |
82 friend class MaximizeModeController; | |
83 | |
84 // The object should only be created by the ash::Shell. | |
85 MaximizeModeWindowManager(); | |
86 | |
87 private: | |
88 using WindowToState = std::map<aura::Window*, MaximizeModeWindowState*>; | |
89 | |
90 // Maximize all windows and restore their current state. | |
91 void MaximizeAllWindows(); | |
92 | |
93 // Restore all windows to their previous state. | |
94 void RestoreAllWindows(); | |
95 | |
96 // Set whether to defer bounds updates on all tracked windows. When set to | |
97 // false bounds will be updated as they may be stale. | |
98 void SetDeferBoundsUpdates(bool defer_bounds_updates); | |
99 | |
100 // If the given window should be handled by us, this function will maximize it | |
101 // and add it to the list of known windows (remembering the initial show | |
102 // state). | |
103 // Note: If the given window cannot be handled by us the function will return | |
104 // immediately. | |
105 void MaximizeAndTrackWindow(aura::Window* window); | |
106 | |
107 // Remove a window from our tracking list. | |
108 void ForgetWindow(aura::Window* window); | |
109 | |
110 // Returns true when the given window should be modified in any way by us. | |
111 bool ShouldHandleWindow(aura::Window* window); | |
112 | |
113 // Add window creation observers to track creation of new windows. | |
114 void AddWindowCreationObservers(); | |
115 | |
116 // Remove Window creation observers. | |
117 void RemoveWindowCreationObservers(); | |
118 | |
119 // Change the internal state (e.g. observers) when the display configuration | |
120 // changes. | |
121 void DisplayConfigurationChanged(); | |
122 | |
123 // Returns true when the |window| is a container window. | |
124 bool IsContainerWindow(aura::Window* window); | |
125 | |
126 // Add a backdrop behind the currently active window on each desktop. | |
127 void EnableBackdropBehindTopWindowOnEachDisplay(bool enable); | |
128 | |
129 // Every window which got touched by our window manager gets added here. | |
130 WindowToState window_state_map_; | |
131 | |
132 // All container windows which have to be tracked. | |
133 std::unordered_set<aura::Window*> observed_container_windows_; | |
134 | |
135 // Windows added to the container, but not yet shown. | |
136 std::unordered_set<aura::Window*> added_windows_; | |
137 | |
138 std::unique_ptr<wm::MaximizeModeEventHandler> event_handler_; | |
139 | |
140 DISALLOW_COPY_AND_ASSIGN(MaximizeModeWindowManager); | |
141 }; | |
142 | |
143 } // namespace ash | |
144 | |
145 #endif // ASH_WM_MAXIMIZE_MODE_MAXIMIZE_MODE_WINDOW_MANAGER_H_ | |
OLD | NEW |