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 set_window_component(int window_component)29 void set_window_component(int window_component) { 30 window_component_ = window_component; 31 } 32 set_minimum_size(const gfx::Size & minimum_size)33 void set_minimum_size(const gfx::Size& minimum_size) { 34 minimum_size_ = minimum_size; 35 } 36 set_maximum_size(const gfx::Size & maximum_size)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. set_can_focus(bool can_focus)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 void DidRecreateLayer(ui::Layer* old_layer, 64 ui::Layer* new_layer) OVERRIDE; 65 66 private: 67 int window_component_; 68 bool delete_on_destroyed_; 69 gfx::Size minimum_size_; 70 gfx::Size maximum_size_; 71 bool can_focus_; 72 73 DISALLOW_COPY_AND_ASSIGN(TestWindowDelegate); 74 }; 75 76 // A simple WindowDelegate implementation for these tests. It owns itself 77 // (deletes itself when the Window it is attached to is destroyed). 78 class ColorTestWindowDelegate : public TestWindowDelegate { 79 public: 80 explicit ColorTestWindowDelegate(SkColor color); 81 virtual ~ColorTestWindowDelegate(); 82 last_key_code()83 ui::KeyboardCode last_key_code() const { return last_key_code_; } 84 85 // Overridden from TestWindowDelegate: 86 virtual void OnKeyEvent(ui::KeyEvent* event) OVERRIDE; 87 virtual void OnWindowDestroyed() OVERRIDE; 88 virtual void OnPaint(gfx::Canvas* canvas) OVERRIDE; 89 90 private: 91 SkColor color_; 92 ui::KeyboardCode last_key_code_; 93 94 DISALLOW_COPY_AND_ASSIGN(ColorTestWindowDelegate); 95 }; 96 97 // A simple WindowDelegate that has a hit-test mask. 98 class MaskedWindowDelegate : public TestWindowDelegate { 99 public: 100 explicit MaskedWindowDelegate(const gfx::Rect mask_rect); 101 102 // Overridden from TestWindowDelegate: 103 virtual bool HasHitTestMask() const OVERRIDE; 104 virtual void GetHitTestMask(gfx::Path* mask) const OVERRIDE; 105 106 private: 107 gfx::Rect mask_rect_; 108 109 DISALLOW_COPY_AND_ASSIGN(MaskedWindowDelegate); 110 }; 111 112 // Keeps track of mouse/key events. 113 class EventCountDelegate : public TestWindowDelegate { 114 public: 115 EventCountDelegate(); 116 117 // Overridden from TestWindowDelegate: 118 virtual void OnKeyEvent(ui::KeyEvent* event) OVERRIDE; 119 virtual void OnMouseEvent(ui::MouseEvent* event) OVERRIDE; 120 121 // Returns the counts of mouse motion events in the 122 // form of "<enter> <move> <leave>". 123 std::string GetMouseMotionCountsAndReset(); 124 125 // Returns the counts of mouse button events in the 126 // form of "<press> <release>". 127 std::string GetMouseButtonCountsAndReset(); 128 129 // Returns the counts of key events in the form of 130 // "<press> <release>". 131 std::string GetKeyCountsAndReset(); 132 133 private: 134 int mouse_enter_count_; 135 int mouse_move_count_; 136 int mouse_leave_count_; 137 int mouse_press_count_; 138 int mouse_release_count_; 139 int key_press_count_; 140 int key_release_count_; 141 142 DISALLOW_COPY_AND_ASSIGN(EventCountDelegate); 143 }; 144 145 } // namespace test 146 } // namespace aura 147 148 #endif // UI_AURA_TEST_TEST_WINDOW_DELEGATE_H_ 149