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/base/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() OVERRIDE;
     59   virtual void OnWindowDestroyed() OVERRIDE;
     60   virtual void OnWindowTargetVisibilityChanged(bool visible) OVERRIDE;
     61   virtual bool HasHitTestMask() const OVERRIDE;
     62   virtual void GetHitTestMask(gfx::Path* mask) const OVERRIDE;
     63   virtual scoped_refptr<ui::Texture> CopyTexture() OVERRIDE;
     64 
     65  private:
     66   int window_component_;
     67   bool delete_on_destroyed_;
     68   gfx::Size minimum_size_;
     69   gfx::Size maximum_size_;
     70   bool can_focus_;
     71 
     72   DISALLOW_COPY_AND_ASSIGN(TestWindowDelegate);
     73 };
     74 
     75 // A simple WindowDelegate implementation for these tests. It owns itself
     76 // (deletes itself when the Window it is attached to is destroyed).
     77 class ColorTestWindowDelegate : public TestWindowDelegate {
     78  public:
     79   explicit ColorTestWindowDelegate(SkColor color);
     80   virtual ~ColorTestWindowDelegate();
     81 
     82   ui::KeyboardCode last_key_code() const { return last_key_code_; }
     83 
     84   // Overridden from TestWindowDelegate:
     85   virtual void OnKeyEvent(ui::KeyEvent* event) OVERRIDE;
     86   virtual void OnWindowDestroyed() OVERRIDE;
     87   virtual void OnPaint(gfx::Canvas* canvas) OVERRIDE;
     88 
     89  private:
     90   SkColor color_;
     91   ui::KeyboardCode last_key_code_;
     92 
     93   DISALLOW_COPY_AND_ASSIGN(ColorTestWindowDelegate);
     94 };
     95 
     96 // A simple WindowDelegate that has a hit-test mask.
     97 class MaskedWindowDelegate : public TestWindowDelegate {
     98  public:
     99   explicit MaskedWindowDelegate(const gfx::Rect mask_rect);
    100 
    101   // Overridden from TestWindowDelegate:
    102   virtual bool HasHitTestMask() const OVERRIDE;
    103   virtual void GetHitTestMask(gfx::Path* mask) const OVERRIDE;
    104 
    105  private:
    106   gfx::Rect mask_rect_;
    107 
    108   DISALLOW_COPY_AND_ASSIGN(MaskedWindowDelegate);
    109 };
    110 
    111 // Keeps track of mouse/key events.
    112 class EventCountDelegate : public TestWindowDelegate {
    113  public:
    114   EventCountDelegate();
    115 
    116   // Overridden from TestWindowDelegate:
    117   virtual void OnKeyEvent(ui::KeyEvent* event) OVERRIDE;
    118   virtual void OnMouseEvent(ui::MouseEvent* 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  private:
    133   int mouse_enter_count_;
    134   int mouse_move_count_;
    135   int mouse_leave_count_;
    136   int mouse_press_count_;
    137   int mouse_release_count_;
    138   int key_press_count_;
    139   int key_release_count_;
    140 
    141   DISALLOW_COPY_AND_ASSIGN(EventCountDelegate);
    142 };
    143 
    144 }  // namespace test
    145 }  // namespace aura
    146 
    147 #endif  // UI_AURA_TEST_TEST_WINDOW_DELEGATE_H_
    148