ash/wm/window_resizer.h

   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_WM_WINDOW_RESIZER_H_
   6 #define ASH_WM_WINDOW_RESIZER_H_
   7
   8 #include "ash/ash_export.h"
   9 #include "base/basictypes.h"
  10 #include "base/memory/scoped_ptr.h"
  11 #include "ui/gfx/rect.h"
  12
  13 namespace aura {
  14 class Window;
  15 }
  16
  17 namespace ash {
  18
  19 // WindowResizer is used by ToplevelWindowEventFilter to handle dragging, moving
  20 // or resizing a window. All coordinates passed to this are in the parent
  21 // windows coordinates.
  22 class ASH_EXPORT WindowResizer {
  23  public:
  24   // Constants to identify the type of resize.
  25   static const int kBoundsChange_None;
  26   static const int kBoundsChange_Repositions;
  27   static const int kBoundsChange_Resizes;
  28
  29   // Used to indicate which direction the resize occurs in.
  30   static const int kBoundsChangeDirection_None;
  31   static const int kBoundsChangeDirection_Horizontal;
  32   static const int kBoundsChangeDirection_Vertical;
  33
  34   WindowResizer();
  35   virtual ~WindowResizer();
  36
  37   // Returns a bitmask of the kBoundsChange_ values.
  38   static int GetBoundsChangeForWindowComponent(int component);
  39
  40   // Invoked to drag/move/resize the window. |location| is in the coordinates
  41   // of the window supplied to the constructor. |event_flags| is the event
  42   // flags from the event.
  43   virtual void Drag(const gfx::Point& location, int event_flags) = 0;
  44
  45   // Invoked to complete the drag.
  46   virtual void CompleteDrag(int event_flags) = 0;
  47
  48   // Reverts the drag.
  49   virtual void RevertDrag() = 0;
  50
  51   // Returns the target window the resizer was created for.
  52   virtual aura::Window* GetTarget() = 0;
  53
  54  protected:
  55   struct Details {
  56     Details();
  57     Details(aura::Window* window,
  58             const gfx::Point& location,
  59             int window_component);
  60     ~Details();
  61
  62     // The window we're resizing.
  63     aura::Window* window;
  64
  65     // Initial bounds of the window in parent coordinates.
  66     gfx::Rect initial_bounds_in_parent;
  67
  68     // Restore bounds (in screen coordinates) of the window before the drag
  69     // started. Only set if the window is normal and is being dragged.
  70     gfx::Rect restore_bounds;
  71
  72     // Location passed to the constructor, in |window->parent()|'s coordinates.
  73     gfx::Point initial_location_in_parent;
  74
  75     // Initial opacity of the window.
  76     float initial_opacity;
  77
  78     // The component the user pressed on.
  79     int window_component;
  80
  81     // Bitmask of the |kBoundsChange_| constants.
  82     int bounds_change;
  83
  84     // Bitmask of the |kBoundsChangeDirection_| constants.
  85     int position_change_direction;
  86
  87     // Bitmask of the |kBoundsChangeDirection_| constants.
  88     int size_change_direction;
  89
  90     // Will the drag actually modify the window?
  91     bool is_resizable;
  92   };
  93
  94   static gfx::Rect CalculateBoundsForDrag(const Details& details,
  95                                           const gfx::Point& location);
  96
  97   static gfx::Rect AdjustBoundsToGrid(const gfx::Rect& bounds,
  98                                       int grid_size);
  99
 100   static bool IsBottomEdge(int component);
 101
 102  private:
 103   // Returns the new origin of the window. The arguments are the difference
 104   // between the current location and the initial location.
 105   static gfx::Point GetOriginForDrag(const Details& details,
 106                                      int delta_x,
 107                                      int delta_y);
 108
 109   // Returns the size of the window for the drag.
 110   static gfx::Size GetSizeForDrag(const Details& details,
 111                                   int* delta_x,
 112                                   int* delta_y);
 113
 114   // Returns the width of the window.
 115   static int GetWidthForDrag(const Details& details,
 116                              int min_width,
 117                              int* delta_x);
 118
 119   // Returns the height of the drag.
 120   static int GetHeightForDrag(const Details& details,
 121                               int min_height,
 122                               int* delta_y);
 123 };
 124
 125 // Creates a WindowResizer for |window|. This can return a scoped_ptr
 126 // initialized with NULL if |window| should not be resized nor dragged.
 127 ASH_EXPORT scoped_ptr<WindowResizer> CreateWindowResizer(
 128     aura::Window* window,
 129     const gfx::Point& point_in_parent,
 130     int window_component);
 131
 132 }  // namespace aura
 133
 134 #endif  // ASH_WM_WINDOW_RESIZER_H_