Home | History | Annotate | Download | only in test 
      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 UI_AURA_TEST_TEST_WINDOW_DELEGATE_H_
      6 #define UI_AURA_TEST_TEST_WINDOW_DELEGATE_H_
      7 
      8 #include <string>
      9 
     10 #include "base/compiler_specific.h"
     11 #include "third_party/skia/include/core/SkColor.h"
     12 #include "ui/aura/window_delegate.h"
     13 #include "ui/events/keycodes/keyboard_codes.h"
     14 #include "ui/gfx/rect.h"
     15 
     16 namespace aura {
     17 namespace test {
     18 
     19 // WindowDelegate implementation with all methods stubbed out.
     20 class TestWindowDelegate : public WindowDelegate {
     21  public:
     22   TestWindowDelegate();
     23   virtual ~TestWindowDelegate();
     24 
     25   // Returns a TestWindowDelegate that delete itself when
     26   // the associated window is destroyed.
     27   static TestWindowDelegate* CreateSelfDestroyingDelegate();
     28 
     29   void set_window_component(int window_component) {
     30     window_component_ = window_component;
     31   }
     32 
     33   void set_minimum_size(const gfx::Size& minimum_size) {
     34     minimum_size_ = minimum_size;
     35   }
     36 
     37   void set_maximum_size(const gfx::Size& maximum_size) {
     38     maximum_size_ = maximum_size;
     39   }
     40 
     41   // Sets the return value for CanFocus(). Default is true.
     42   void set_can_focus(bool can_focus) { can_focus_ = can_focus; }
     43 
     44   // Overridden from WindowDelegate:
     45   virtual gfx::Size GetMinimumSize() const OVERRIDE;
     46   virtual gfx::Size GetMaximumSize() const OVERRIDE;
     47   virtual void OnBoundsChanged(const gfx::Rect& old_bounds,
     48                                const gfx::Rect& new_bounds) OVERRIDE;
     49   virtual gfx::NativeCursor GetCursor(const gfx::Point& point) OVERRIDE;
     50   virtual int GetNonClientComponent(const gfx::Point& point) const OVERRIDE;
     51   virtual bool ShouldDescendIntoChildForEventHandling(
     52       Window* child,
     53       const gfx::Point& location) OVERRIDE;
     54   virtual bool CanFocus() OVERRIDE;
     55   virtual void OnCaptureLost() OVERRIDE;
     56   virtual void OnPaint(gfx::Canvas* canvas) OVERRIDE;
     57   virtual void OnDeviceScaleFactorChanged(float device_scale_factor) OVERRIDE;
     58   virtual void OnWindowDestroying(Window* window) OVERRIDE;
     59   virtual void OnWindowDestroyed(Window* window) OVERRIDE;
     60   virtual void OnWindowTargetVisibilityChanged(bool visible) OVERRIDE;
     61   virtual bool HasHitTestMask() const OVERRIDE;
     62   virtual void GetHitTestMask(gfx::Path* mask) const OVERRIDE;
     63 
     64  private:
     65   int window_component_;
     66   bool delete_on_destroyed_;
     67   gfx::Size minimum_size_;
     68   gfx::Size maximum_size_;
     69   bool can_focus_;
     70 
     71   DISALLOW_COPY_AND_ASSIGN(TestWindowDelegate);
     72 };
     73 
     74 // A simple WindowDelegate implementation for these tests. It owns itself
     75 // (deletes itself when the Window it is attached to is destroyed).
     76 class ColorTestWindowDelegate : public TestWindowDelegate {
     77  public:
     78   explicit ColorTestWindowDelegate(SkColor color);
     79   virtual ~ColorTestWindowDelegate();
     80 
     81   ui::KeyboardCode last_key_code() const { return last_key_code_; }
     82 
     83   // Overridden from TestWindowDelegate:
     84   virtual void OnKeyEvent(ui::KeyEvent* event) OVERRIDE;
     85   virtual void OnWindowDestroyed(Window* window) OVERRIDE;
     86   virtual void OnPaint(gfx::Canvas* canvas) OVERRIDE;
     87 
     88  private:
     89   SkColor color_;
     90   ui::KeyboardCode last_key_code_;
     91 
     92   DISALLOW_COPY_AND_ASSIGN(ColorTestWindowDelegate);
     93 };
     94 
     95 // A simple WindowDelegate that has a hit-test mask.
     96 class MaskedWindowDelegate : public TestWindowDelegate {
     97  public:
     98   explicit MaskedWindowDelegate(const gfx::Rect mask_rect);
     99 
    100   // Overridden from TestWindowDelegate:
    101   virtual bool HasHitTestMask() const OVERRIDE;
    102   virtual void GetHitTestMask(gfx::Path* mask) const OVERRIDE;
    103 
    104  private:
    105   gfx::Rect mask_rect_;
    106 
    107   DISALLOW_COPY_AND_ASSIGN(MaskedWindowDelegate);
    108 };
    109 
    110 // Keeps track of mouse/key events.
    111 class EventCountDelegate : public TestWindowDelegate {
    112  public:
    113   EventCountDelegate();
    114 
    115   // Overridden from TestWindowDelegate:
    116   virtual void OnKeyEvent(ui::KeyEvent* event) OVERRIDE;
    117   virtual void OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
    118   virtual void OnGestureEvent(ui::GestureEvent* event) OVERRIDE;
    119 
    120   // Returns the counts of mouse motion events in the
    121   // form of "<enter> <move> <leave>".
    122   std::string GetMouseMotionCountsAndReset();
    123 
    124   // Returns the counts of mouse button events in the
    125   // form of "<press> <release>".
    126   std::string GetMouseButtonCountsAndReset();
    127 
    128   // Returns the counts of key events in the form of
    129   // "<press> <release>".
    130   std::string GetKeyCountsAndReset();
    131 
    132   // Returns number of gesture events.
    133   int GetGestureCountAndReset();
    134 
    135  private:
    136   int mouse_enter_count_;
    137   int mouse_move_count_;
    138   int mouse_leave_count_;
    139   int mouse_press_count_;
    140   int mouse_release_count_;
    141   int key_press_count_;
    142   int key_release_count_;
    143   int gesture_count_;
    144 
    145   DISALLOW_COPY_AND_ASSIGN(EventCountDelegate);
    146 };
    147 
    148 }  // namespace test
    149 }  // namespace aura
    150 
    151 #endif  // UI_AURA_TEST_TEST_WINDOW_DELEGATE_H_
    152