| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2012 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_WORKSPACE_WORKSPACE_WINDOW_RESIZER_H_ | |
| 6 #define ASH_COMMON_WM_WORKSPACE_WORKSPACE_WINDOW_RESIZER_H_ | |
| 7 | |
| 8 #include <stdint.h> | |
| 9 | |
| 10 #include <memory> | |
| 11 #include <vector> | |
| 12 | |
| 13 #include "ash/common/wm/window_resizer.h" | |
| 14 #include "ash/common/wm/workspace/magnetism_matcher.h" | |
| 15 #include "base/compiler_specific.h" | |
| 16 #include "base/macros.h" | |
| 17 #include "base/memory/weak_ptr.h" | |
| 18 #include "ui/aura/window_tracker.h" | |
| 19 | |
| 20 namespace ash { | |
| 21 class DockedWindowLayoutManager; | |
| 22 class PhantomWindowController; | |
| 23 class TwoStepEdgeCycler; | |
| 24 class WindowSize; | |
| 25 class WmShell; | |
| 26 | |
| 27 namespace wm { | |
| 28 class WindowState; | |
| 29 } | |
| 30 | |
| 31 // WindowResizer implementation for workspaces. This enforces that windows are | |
| 32 // not allowed to vertically move or resize outside of the work area. As windows | |
| 33 // are moved outside the work area they are shrunk. We remember the height of | |
| 34 // the window before it was moved so that if the window is again moved up we | |
| 35 // attempt to restore the old height. | |
| 36 class ASH_EXPORT WorkspaceWindowResizer : public WindowResizer { | |
| 37 public: | |
| 38 // When dragging an attached window this is the min size we'll make sure is | |
| 39 // visible. In the vertical direction we take the max of this and that from | |
| 40 // the delegate. | |
| 41 static const int kMinOnscreenSize; | |
| 42 | |
| 43 // Min height we'll force on screen when dragging the caption. | |
| 44 // TODO: this should come from a property on the window. | |
| 45 static const int kMinOnscreenHeight; | |
| 46 | |
| 47 // Snap region when dragging close to the edges. That is, as the window gets | |
| 48 // this close to an edge of the screen it snaps to the edge. | |
| 49 static const int kScreenEdgeInset; | |
| 50 | |
| 51 // Distance in pixels that the cursor must move past an edge for a window | |
| 52 // to move or resize beyond that edge. | |
| 53 static const int kStickyDistancePixels; | |
| 54 | |
| 55 ~WorkspaceWindowResizer() override; | |
| 56 | |
| 57 static WorkspaceWindowResizer* Create( | |
| 58 wm::WindowState* window_state, | |
| 59 const std::vector<WmWindow*>& attached_windows); | |
| 60 | |
| 61 // WindowResizer: | |
| 62 void Drag(const gfx::Point& location_in_parent, int event_flags) override; | |
| 63 void CompleteDrag() override; | |
| 64 void RevertDrag() override; | |
| 65 | |
| 66 private: | |
| 67 friend class WorkspaceWindowResizerTest; | |
| 68 | |
| 69 // The edge to which the window should be snapped at the end of the drag. | |
| 70 enum SnapType { SNAP_LEFT, SNAP_RIGHT, SNAP_NONE }; | |
| 71 | |
| 72 WorkspaceWindowResizer(wm::WindowState* window_state, | |
| 73 const std::vector<WmWindow*>& attached_windows); | |
| 74 | |
| 75 // Lays out the attached windows. |bounds| is the bounds of the main window. | |
| 76 void LayoutAttachedWindows(gfx::Rect* bounds); | |
| 77 | |
| 78 // Calculates the new sizes of the attached windows, given that the main | |
| 79 // window has been resized (along the primary axis) by |delta|. | |
| 80 // |available_size| is the maximum length of the space that the attached | |
| 81 // windows are allowed to occupy (ie: the distance between the right/bottom | |
| 82 // edge of the primary window and the right/bottom of the desktop area). | |
| 83 // Populates |sizes| with the desired sizes of the attached windows, and | |
| 84 // returns the number of pixels that couldn't be allocated to the attached | |
| 85 // windows (due to min/max size constraints). | |
| 86 // Note the return value can be positive or negative, a negative value | |
| 87 // indicating that that many pixels couldn't be removed from the attached | |
| 88 // windows. | |
| 89 int CalculateAttachedSizes(int delta, | |
| 90 int available_size, | |
| 91 std::vector<int>* sizes) const; | |
| 92 | |
| 93 // Divides |amount| evenly between |sizes|. If |amount| is negative it | |
| 94 // indicates how many pixels |sizes| should be shrunk by. | |
| 95 // Returns how many pixels failed to be allocated/removed from |sizes|. | |
| 96 int GrowFairly(int amount, std::vector<WindowSize>* sizes) const; | |
| 97 | |
| 98 // Calculate the ratio of pixels that each WindowSize in |sizes| should | |
| 99 // receive when growing or shrinking. | |
| 100 void CalculateGrowthRatios(const std::vector<WindowSize*>& sizes, | |
| 101 std::vector<float>* out_ratios) const; | |
| 102 | |
| 103 // Adds a WindowSize to |sizes| for each attached window. | |
| 104 void CreateBucketsForAttached(std::vector<WindowSize>* sizes) const; | |
| 105 | |
| 106 // If possible snaps the window to a neary window. Updates |bounds| if there | |
| 107 // was a close enough window. | |
| 108 void MagneticallySnapToOtherWindows(gfx::Rect* bounds); | |
| 109 | |
| 110 // If possible snaps the resize to a neary window. Updates |bounds| if there | |
| 111 // was a close enough window. | |
| 112 void MagneticallySnapResizeToOtherWindows(gfx::Rect* bounds); | |
| 113 | |
| 114 // Finds the neareset window to magentically snap to. Updates | |
| 115 // |magnetism_window_| and |magnetism_edge_| appropriately. |edges| is a | |
| 116 // bitmask of the MagnetismEdges to match again. Returns true if a match is | |
| 117 // found. | |
| 118 bool UpdateMagnetismWindow(const gfx::Rect& bounds, uint32_t edges); | |
| 119 | |
| 120 // Adjusts the bounds of the window: magnetically snapping, ensuring the | |
| 121 // window has enough on screen... |snap_size| is the distance from an edge of | |
| 122 // the work area before the window is snapped. A value of 0 results in no | |
| 123 // snapping. | |
| 124 void AdjustBoundsForMainWindow(int snap_size, gfx::Rect* bounds); | |
| 125 | |
| 126 // Stick the window bounds to the work area during a move. | |
| 127 bool StickToWorkAreaOnMove(const gfx::Rect& work_area, | |
| 128 int sticky_size, | |
| 129 gfx::Rect* bounds) const; | |
| 130 | |
| 131 // Stick the window bounds to the work area during a resize. | |
| 132 void StickToWorkAreaOnResize(const gfx::Rect& work_area, | |
| 133 int sticky_size, | |
| 134 gfx::Rect* bounds) const; | |
| 135 | |
| 136 // Returns a coordinate along the primary axis. Used to share code for | |
| 137 // left/right multi window resize and top/bottom resize. | |
| 138 int PrimaryAxisSize(const gfx::Size& size) const; | |
| 139 int PrimaryAxisCoordinate(int x, int y) const; | |
| 140 | |
| 141 // Updates the bounds of the phantom window for window snapping. | |
| 142 void UpdateSnapPhantomWindow(const gfx::Point& location, | |
| 143 const gfx::Rect& bounds); | |
| 144 | |
| 145 // Restacks the windows z-order position so that one of the windows is at the | |
| 146 // top of the z-order, and the rest directly underneath it. | |
| 147 void RestackWindows(); | |
| 148 | |
| 149 // Returns the edge to which the window should be snapped to if the user does | |
| 150 // no more dragging. SNAP_NONE is returned if the window should not be | |
| 151 // snapped. | |
| 152 SnapType GetSnapType(const gfx::Point& location) const; | |
| 153 | |
| 154 // Returns true if |bounds_in_parent| are valid bounds for snapped state type | |
| 155 // |snapped_type|. | |
| 156 bool AreBoundsValidSnappedBounds(wm::WindowStateType snapped_type, | |
| 157 const gfx::Rect& bounds_in_parent) const; | |
| 158 | |
| 159 // Docks or undocks the dragged window. | |
| 160 void SetDraggedWindowDocked(bool should_dock); | |
| 161 | |
| 162 wm::WindowState* window_state() { return window_state_; } | |
| 163 | |
| 164 const std::vector<WmWindow*> attached_windows_; | |
| 165 | |
| 166 WmShell* shell_; | |
| 167 | |
| 168 // Returns the currently used instance for test. | |
| 169 static WorkspaceWindowResizer* GetInstanceForTest(); | |
| 170 | |
| 171 bool did_lock_cursor_; | |
| 172 | |
| 173 // Set to true once Drag() is invoked and the bounds of the window change. | |
| 174 bool did_move_or_resize_; | |
| 175 | |
| 176 // True if the window initially had |bounds_changed_by_user_| set in state. | |
| 177 bool initial_bounds_changed_by_user_; | |
| 178 | |
| 179 // The initial size of each of the windows in |attached_windows_| along the | |
| 180 // primary axis. | |
| 181 std::vector<int> initial_size_; | |
| 182 | |
| 183 // Sum of the minimum sizes of the attached windows. | |
| 184 int total_min_; | |
| 185 | |
| 186 // Sum of the sizes in |initial_size_|. | |
| 187 int total_initial_size_; | |
| 188 | |
| 189 // Gives a previews of where the the window will end up. Only used if there | |
| 190 // is a grid and the caption is being dragged. | |
| 191 std::unique_ptr<PhantomWindowController> snap_phantom_window_controller_; | |
| 192 | |
| 193 // Used to determine whether the window should be snapped or docked when | |
| 194 // the user drags a window to the edge of the screen. | |
| 195 std::unique_ptr<TwoStepEdgeCycler> edge_cycler_; | |
| 196 | |
| 197 // The edge to which the window should be snapped to at the end of the drag. | |
| 198 SnapType snap_type_; | |
| 199 | |
| 200 // Number of mouse moves since the last bounds change. Only used for phantom | |
| 201 // placement to track when the mouse is moved while pushed against the edge of | |
| 202 // the screen. | |
| 203 int num_mouse_moves_since_bounds_change_; | |
| 204 | |
| 205 // The mouse location passed to Drag(). | |
| 206 gfx::Point last_mouse_location_; | |
| 207 | |
| 208 // Window the drag has magnetically attached to. | |
| 209 WmWindow* magnetism_window_; | |
| 210 | |
| 211 // Used to verify |magnetism_window_| is still valid. | |
| 212 aura::WindowTracker window_tracker_; | |
| 213 | |
| 214 // If |magnetism_window_| is non-NULL this indicates how the two windows | |
| 215 // should attach. | |
| 216 MatchedEdge magnetism_edge_; | |
| 217 | |
| 218 // Dock container window layout manager. | |
| 219 DockedWindowLayoutManager* dock_layout_; | |
| 220 | |
| 221 // Used to determine if this has been deleted during a drag such as when a tab | |
| 222 // gets dragged into another browser window. | |
| 223 base::WeakPtrFactory<WorkspaceWindowResizer> weak_ptr_factory_; | |
| 224 | |
| 225 DISALLOW_COPY_AND_ASSIGN(WorkspaceWindowResizer); | |
| 226 }; | |
| 227 | |
| 228 } // namespace ash | |
| 229 | |
| 230 #endif // ASH_COMMON_WM_WORKSPACE_WORKSPACE_WINDOW_RESIZER_H_ | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2734653002:
chromeos: Move files in //ash/common to //ash (Closed)
