| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2016 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_COMMON_WM_WINDOW_H_ | |
| 6 #define ASH_COMMON_WM_WINDOW_H_ | |
| 7 | |
| 8 #include <memory> | |
| 9 #include <vector> | |
| 10 | |
| 11 #include "ash/ash_export.h" | |
| 12 #include "base/macros.h" | |
| 13 #include "base/observer_list.h" | |
| 14 #include "base/strings/string16.h" | |
| 15 #include "base/time/time.h" | |
| 16 #include "ui/aura/window_observer.h" | |
| 17 #include "ui/base/ui_base_types.h" | |
| 18 #include "ui/compositor/layer_animation_element.h" | |
| 19 #include "ui/wm/core/transient_window_observer.h" | |
| 20 #include "ui/wm/core/window_animations.h" | |
| 21 #include "ui/wm/public/window_types.h" | |
| 22 | |
| 23 namespace display { | |
| 24 class Display; | |
| 25 } | |
| 26 | |
| 27 namespace gfx { | |
| 28 class Point; | |
| 29 class Rect; | |
| 30 class Size; | |
| 31 class Transform; | |
| 32 } | |
| 33 | |
| 34 namespace ui { | |
| 35 class EventHandler; | |
| 36 class Layer; | |
| 37 } | |
| 38 | |
| 39 namespace views { | |
| 40 class View; | |
| 41 class Widget; | |
| 42 } | |
| 43 | |
| 44 namespace ash { | |
| 45 | |
| 46 class ImmersiveFullscreenController; | |
| 47 class RootWindowController; | |
| 48 class WmLayoutManager; | |
| 49 class WmShell; | |
| 50 class WmTransientWindowObserver; | |
| 51 class WmWindowTestApi; | |
| 52 enum class WmWindowProperty; | |
| 53 | |
| 54 namespace wm { | |
| 55 class WindowState; | |
| 56 } | |
| 57 | |
| 58 // WmWindow abstracts away differences between ash running in classic mode | |
| 59 // and ash running with aura-mus. | |
| 60 // | |
| 61 // WmWindow is tied to the life of the underlying aura::Window. Use the | |
| 62 // static Get() function to obtain a WmWindow from an aura::Window. | |
| 63 class ASH_EXPORT WmWindow : public aura::WindowObserver, | |
| 64 public ::wm::TransientWindowObserver { | |
| 65 public: | |
| 66 // See comments in SetBoundsInScreen(). | |
| 67 enum class BoundsInScreenBehavior { | |
| 68 USE_LOCAL_COORDINATES, | |
| 69 USE_SCREEN_COORDINATES, | |
| 70 }; | |
| 71 | |
| 72 using Windows = std::vector<WmWindow*>; | |
| 73 | |
| 74 // NOTE: this class is owned by the corresponding window. You shouldn't delete | |
| 75 // TODO(sky): friend deleter and make private. | |
| 76 ~WmWindow() override; | |
| 77 | |
| 78 // Returns a WmWindow for an aura::Window, creating if necessary. |window| may | |
| 79 // be null, in which case null is returned. | |
| 80 static WmWindow* Get(aura::Window* window) { | |
| 81 return const_cast<WmWindow*>(Get(const_cast<const aura::Window*>(window))); | |
| 82 } | |
| 83 static const WmWindow* Get(const aura::Window* window); | |
| 84 | |
| 85 static std::vector<WmWindow*> FromAuraWindows( | |
| 86 const std::vector<aura::Window*>& aura_windows); | |
| 87 static std::vector<aura::Window*> ToAuraWindows( | |
| 88 const std::vector<WmWindow*>& windows); | |
| 89 | |
| 90 // Convenience for wm_window->aura_window(). Returns null if |wm_window| is | |
| 91 // null. | |
| 92 static aura::Window* GetAuraWindow(WmWindow* wm_window) { | |
| 93 return const_cast<aura::Window*>( | |
| 94 GetAuraWindow(const_cast<const WmWindow*>(wm_window))); | |
| 95 } | |
| 96 static const aura::Window* GetAuraWindow(const WmWindow* wm_window); | |
| 97 | |
| 98 aura::Window* aura_window() { return window_; } | |
| 99 const aura::Window* aura_window() const { return window_; } | |
| 100 | |
| 101 // See description of |children_use_extended_hit_region_|. | |
| 102 bool ShouldUseExtendedHitRegion() const; | |
| 103 | |
| 104 void Destroy(); | |
| 105 | |
| 106 WmWindow* GetRootWindow() { | |
| 107 return const_cast<WmWindow*>( | |
| 108 const_cast<const WmWindow*>(this)->GetRootWindow()); | |
| 109 } | |
| 110 const WmWindow* GetRootWindow() const; | |
| 111 RootWindowController* GetRootWindowController(); | |
| 112 | |
| 113 // TODO(sky): fix constness. | |
| 114 WmShell* GetShell() const; | |
| 115 | |
| 116 // Used for debugging. | |
| 117 void SetName(const char* name); | |
| 118 std::string GetName() const; | |
| 119 | |
| 120 void SetTitle(const base::string16& title); | |
| 121 base::string16 GetTitle() const; | |
| 122 | |
| 123 // See shell_window_ids.h for list of known ids. | |
| 124 void SetShellWindowId(int id); | |
| 125 int GetShellWindowId() const; | |
| 126 WmWindow* GetChildByShellWindowId(int id); | |
| 127 | |
| 128 ui::wm::WindowType GetType() const; | |
| 129 int GetAppType() const; | |
| 130 void SetAppType(int app_type) const; | |
| 131 | |
| 132 ui::Layer* GetLayer(); | |
| 133 | |
| 134 // TODO(sky): these are temporary until GetLayer() always returns non-null. | |
| 135 bool GetLayerTargetVisibility(); | |
| 136 bool GetLayerVisible(); | |
| 137 | |
| 138 display::Display GetDisplayNearestWindow(); | |
| 139 | |
| 140 bool HasNonClientArea(); | |
| 141 int GetNonClientComponent(const gfx::Point& location); | |
| 142 gfx::Point ConvertPointToTarget(const WmWindow* target, | |
| 143 const gfx::Point& point) const; | |
| 144 | |
| 145 gfx::Point ConvertPointToScreen(const gfx::Point& point) const; | |
| 146 gfx::Point ConvertPointFromScreen(const gfx::Point& point) const; | |
| 147 gfx::Rect ConvertRectToScreen(const gfx::Rect& rect) const; | |
| 148 gfx::Rect ConvertRectFromScreen(const gfx::Rect& rect) const; | |
| 149 | |
| 150 gfx::Size GetMinimumSize() const; | |
| 151 gfx::Size GetMaximumSize() const; | |
| 152 | |
| 153 // Returns the visibility requested by this window. IsVisible() takes into | |
| 154 // account the visibility of the layer and ancestors, where as this tracks | |
| 155 // whether Show() without a Hide() has been invoked. | |
| 156 bool GetTargetVisibility() const; | |
| 157 | |
| 158 bool IsVisible() const; | |
| 159 | |
| 160 void SetOpacity(float opacity); | |
| 161 float GetTargetOpacity() const; | |
| 162 | |
| 163 gfx::Rect GetMinimizeAnimationTargetBoundsInScreen() const; | |
| 164 | |
| 165 void SetTransform(const gfx::Transform& transform); | |
| 166 gfx::Transform GetTargetTransform() const; | |
| 167 | |
| 168 bool IsSystemModal() const; | |
| 169 | |
| 170 wm::WindowState* GetWindowState() { | |
| 171 return const_cast<wm::WindowState*>( | |
| 172 const_cast<const WmWindow*>(this)->GetWindowState()); | |
| 173 } | |
| 174 const wm::WindowState* GetWindowState() const; | |
| 175 | |
| 176 // The implementation of this matches aura::Window::GetToplevelWindow(). | |
| 177 WmWindow* GetToplevelWindow(); | |
| 178 | |
| 179 // The implementation of this matches | |
| 180 // aura::client::ActivationClient::GetToplevelWindow(). | |
| 181 WmWindow* GetToplevelWindowForFocus(); | |
| 182 | |
| 183 // See aura::client::ParentWindowWithContext() for details of what this does. | |
| 184 void SetParentUsingContext(WmWindow* context, const gfx::Rect& screen_bounds); | |
| 185 void AddChild(WmWindow* window); | |
| 186 void RemoveChild(WmWindow* child); | |
| 187 | |
| 188 WmWindow* GetParent() { | |
| 189 return const_cast<WmWindow*>( | |
| 190 const_cast<const WmWindow*>(this)->GetParent()); | |
| 191 } | |
| 192 const WmWindow* GetParent() const; | |
| 193 | |
| 194 WmWindow* GetTransientParent() { | |
| 195 return const_cast<WmWindow*>( | |
| 196 const_cast<const WmWindow*>(this)->GetTransientParent()); | |
| 197 } | |
| 198 const WmWindow* GetTransientParent() const; | |
| 199 std::vector<WmWindow*> GetTransientChildren(); | |
| 200 | |
| 201 // Moves this to the display where |event| occurred; returns true if moved. | |
| 202 bool MoveToEventRoot(const ui::Event& event); | |
| 203 | |
| 204 void SetLayoutManager(std::unique_ptr<WmLayoutManager> layout_manager); | |
| 205 WmLayoutManager* GetLayoutManager(); | |
| 206 | |
| 207 // See wm::SetWindowVisibilityChangesAnimated() for details on what this | |
| 208 // does. | |
| 209 void SetVisibilityChangesAnimated(); | |
| 210 // |type| is WindowVisibilityAnimationType. Has to be an int to match aura. | |
| 211 void SetVisibilityAnimationType(int type); | |
| 212 void SetVisibilityAnimationDuration(base::TimeDelta delta); | |
| 213 void SetVisibilityAnimationTransition( | |
| 214 ::wm::WindowVisibilityAnimationTransition transition); | |
| 215 void Animate(::wm::WindowAnimationType type); | |
| 216 void StopAnimatingProperty( | |
| 217 ui::LayerAnimationElement::AnimatableProperty property); | |
| 218 void SetChildWindowVisibilityChangesAnimated(); | |
| 219 | |
| 220 // See description in ui::Layer. | |
| 221 void SetMasksToBounds(bool value); | |
| 222 void SetBounds(const gfx::Rect& bounds); | |
| 223 void SetBoundsWithTransitionDelay(const gfx::Rect& bounds, | |
| 224 base::TimeDelta delta); | |
| 225 // Sets the bounds in such a way that LayoutManagers are circumvented. | |
| 226 void SetBoundsDirect(const gfx::Rect& bounds); | |
| 227 void SetBoundsDirectAnimated(const gfx::Rect& bounds); | |
| 228 void SetBoundsDirectCrossFade(const gfx::Rect& bounds); | |
| 229 | |
| 230 // Sets the bounds in two distinct ways. The exact behavior is dictated by | |
| 231 // the value of BoundsInScreenBehavior set on the parent: | |
| 232 // | |
| 233 // USE_LOCAL_COORDINATES: the bounds are applied as is to the window. In other | |
| 234 // words this behaves the same as if SetBounds(bounds_in_screen) was used. | |
| 235 // This is the default. | |
| 236 // USE_SCREEN_COORDINATES: the bounds are actual screen bounds and converted | |
| 237 // from the display. In this case the window may move to a different | |
| 238 // display if allowed (see SetLockedToRoot()). | |
| 239 void SetBoundsInScreen(const gfx::Rect& bounds_in_screen, | |
| 240 const display::Display& dst_display); | |
| 241 gfx::Rect GetBoundsInScreen() const; | |
| 242 const gfx::Rect& GetBounds() const; | |
| 243 gfx::Rect GetTargetBounds(); | |
| 244 void ClearRestoreBounds(); | |
| 245 void SetRestoreBoundsInScreen(const gfx::Rect& bounds); | |
| 246 gfx::Rect GetRestoreBoundsInScreen() const; | |
| 247 | |
| 248 bool Contains(const WmWindow* other) const; | |
| 249 | |
| 250 void SetShowState(ui::WindowShowState show_state); | |
| 251 ui::WindowShowState GetShowState() const; | |
| 252 | |
| 253 void SetPreMinimizedShowState(ui::WindowShowState show_state); | |
| 254 ui::WindowShowState GetPreMinimizedShowState() const; | |
| 255 void SetPreFullscreenShowState(ui::WindowShowState show_state); | |
| 256 | |
| 257 // Sets the restore bounds and show state overrides. These values take | |
| 258 // precedence over the restore bounds and restore show state (if set). | |
| 259 // If |bounds_override| is empty the values are cleared. | |
| 260 void SetRestoreOverrides(const gfx::Rect& bounds_override, | |
| 261 ui::WindowShowState window_state_override); | |
| 262 | |
| 263 // If |value| is true the window can not be moved to another root, regardless | |
| 264 // of the bounds set on it. | |
| 265 void SetLockedToRoot(bool value); | |
| 266 bool IsLockedToRoot() const; | |
| 267 | |
| 268 void SetCapture(); | |
| 269 bool HasCapture(); | |
| 270 void ReleaseCapture(); | |
| 271 | |
| 272 bool HasRestoreBounds() const; | |
| 273 bool CanMaximize() const; | |
| 274 bool CanMinimize() const; | |
| 275 bool CanResize() const; | |
| 276 bool CanActivate() const; | |
| 277 | |
| 278 void StackChildAtTop(WmWindow* child); | |
| 279 void StackChildAtBottom(WmWindow* child); | |
| 280 void StackChildAbove(WmWindow* child, WmWindow* target); | |
| 281 void StackChildBelow(WmWindow* child, WmWindow* target); | |
| 282 | |
| 283 // See ScreenPinningController::SetPinnedWindow() for details. | |
| 284 void SetPinned(bool trusted); | |
| 285 | |
| 286 void SetAlwaysOnTop(bool value); | |
| 287 bool IsAlwaysOnTop() const; | |
| 288 | |
| 289 void Hide(); | |
| 290 void Show(); | |
| 291 | |
| 292 // Returns the widget associated with this window, or null if not associated | |
| 293 // with a widget. Only ash system UI widgets are returned, not widgets created | |
| 294 // by the mus window manager code to show a non-client frame. | |
| 295 views::Widget* GetInternalWidget(); | |
| 296 | |
| 297 // Requests the window to close and destroy itself. This is intended to | |
| 298 // forward to an associated widget. | |
| 299 void CloseWidget(); | |
| 300 | |
| 301 void SetFocused(); | |
| 302 bool IsFocused() const; | |
| 303 | |
| 304 bool IsActive() const; | |
| 305 void Activate(); | |
| 306 void Deactivate(); | |
| 307 | |
| 308 void SetFullscreen(bool fullscreen); | |
| 309 | |
| 310 void Maximize(); | |
| 311 void Minimize(); | |
| 312 void Unminimize(); | |
| 313 | |
| 314 std::vector<WmWindow*> GetChildren(); | |
| 315 | |
| 316 // Shows/hides the resize shadow. |component| is the component to show the | |
| 317 // shadow for (one of the constants in ui/base/hit_test.h). | |
| 318 void ShowResizeShadow(int component); | |
| 319 void HideResizeShadow(); | |
| 320 | |
| 321 // Installs a resize handler on the window that makes it easier to resize | |
| 322 // the window. See ResizeHandleWindowTargeter for the specifics. | |
| 323 void InstallResizeHandleWindowTargeter( | |
| 324 ImmersiveFullscreenController* immersive_fullscreen_controller); | |
| 325 | |
| 326 // See description in SetBoundsInScreen(). | |
| 327 void SetBoundsInScreenBehaviorForChildren(BoundsInScreenBehavior behavior); | |
| 328 | |
| 329 // See description of SnapToPixelBoundaryIfNecessary(). | |
| 330 void SetSnapsChildrenToPhysicalPixelBoundary(); | |
| 331 | |
| 332 // If an ancestor has been set to snap children to pixel boundaries, then | |
| 333 // snaps the layer associated with this window to the layer associated with | |
| 334 // the ancestor. | |
| 335 void SnapToPixelBoundaryIfNecessary(); | |
| 336 | |
| 337 // Makes the hit region for children slightly larger for easier resizing. | |
| 338 void SetChildrenUseExtendedHitRegion(); | |
| 339 | |
| 340 // Returns a View that renders the contents of this window's layers. | |
| 341 std::unique_ptr<views::View> CreateViewWithRecreatedLayers(); | |
| 342 | |
| 343 void AddTransientWindowObserver(WmTransientWindowObserver* observer); | |
| 344 void RemoveTransientWindowObserver(WmTransientWindowObserver* observer); | |
| 345 | |
| 346 // Adds or removes a handler to receive events targeted at this window, before | |
| 347 // this window handles the events itself; the handler does not recieve events | |
| 348 // from embedded windows. This only supports windows with internal widgets; | |
| 349 // see GetInternalWidget(). Ownership of the handler is not transferred. | |
| 350 // | |
| 351 // Also note that the target of these events is always an aura::Window. | |
| 352 void AddLimitedPreTargetHandler(ui::EventHandler* handler); | |
| 353 void RemoveLimitedPreTargetHandler(ui::EventHandler* handler); | |
| 354 | |
| 355 private: | |
| 356 friend class WmWindowTestApi; | |
| 357 | |
| 358 explicit WmWindow(aura::Window* window); | |
| 359 | |
| 360 // aura::WindowObserver: | |
| 361 void OnWindowPropertyChanged(aura::Window* window, | |
| 362 const void* key, | |
| 363 intptr_t old) override; | |
| 364 | |
| 365 // ::wm::TransientWindowObserver overrides: | |
| 366 void OnTransientChildAdded(aura::Window* window, | |
| 367 aura::Window* transient) override; | |
| 368 void OnTransientChildRemoved(aura::Window* window, | |
| 369 aura::Window* transient) override; | |
| 370 | |
| 371 aura::Window* window_; | |
| 372 | |
| 373 bool added_transient_observer_ = false; | |
| 374 base::ObserverList<WmTransientWindowObserver> transient_observers_; | |
| 375 | |
| 376 // If true child windows should get a slightly larger hit region to make | |
| 377 // resizing easier. | |
| 378 bool children_use_extended_hit_region_ = false; | |
| 379 | |
| 380 // Default value for |use_empty_minimum_size_for_testing_|. | |
| 381 static bool default_use_empty_minimum_size_for_testing_; | |
| 382 | |
| 383 // If true the minimum size is 0x0, default is minimum size comes from widget. | |
| 384 bool use_empty_minimum_size_for_testing_; | |
| 385 | |
| 386 DISALLOW_COPY_AND_ASSIGN(WmWindow); | |
| 387 }; | |
| 388 | |
| 389 } // namespace ash | |
| 390 | |
| 391 #endif // ASH_COMMON_WM_WINDOW_H_ | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2734653002:
chromeos: Move files in //ash/common to //ash (Closed)
