1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
|
// Copyright (c) 2011 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef CHROME_BROWSER_UI_VIEWS_DROPDOWN_BAR_HOST_H_
#define CHROME_BROWSER_UI_VIEWS_DROPDOWN_BAR_HOST_H_
#include <memory>
#include "base/compiler_specific.h"
#include "base/macros.h"
#include "content/public/browser/native_web_keyboard_event.h"
#include "ui/gfx/animation/animation_delegate.h"
#include "ui/gfx/geometry/rect.h"
#include "ui/gfx/native_widget_types.h"
#include "ui/views/focus/focus_manager.h"
class BrowserView;
class DropdownBarHostDelegate;
class DropdownBarView;
namespace gfx {
class SlideAnimation;
} // namespace gfx
namespace views {
class ExternalFocusTracker;
class View;
class Widget;
} // namespace views
////////////////////////////////////////////////////////////////////////////////
//
// The DropdownBarHost implements the container widget for the UI that
// is shown at the top of browser contents. It uses the implementation from
// dropdown_bar_host_aura.cc to draw its content and is responsible for showing,
// hiding, animating, closing, and moving the bar if needed, for example if the
// widget is obscuring the selection results in FindBar.
//
////////////////////////////////////////////////////////////////////////////////
class DropdownBarHost : public ui::AcceleratorTarget,
public views::FocusChangeListener,
public gfx::AnimationDelegate {
public:
explicit DropdownBarHost(BrowserView* browser_view);
~DropdownBarHost() override;
// Initializes the DropdownBarHost. This creates the widget that |view| paints
// into.
// |host_view| is the view whose position in the |browser_view_| view
// hierarchy determines the z-order of the widget relative to views with
// layers and views with associated NativeViews.
void Init(views::View* host_view,
views::View* view,
DropdownBarHostDelegate* delegate);
// Whether we are animating the position of the dropdown widget.
bool IsAnimating() const;
// Returns true if the dropdown bar view is visible, or false otherwise.
bool IsVisible() const;
// Selects text in the entry field and set focus.
void SetFocusAndSelection();
// Stops the animation.
void StopAnimation();
// Shows the dropdown bar.
virtual void Show(bool animate);
// Hides the dropdown bar.
virtual void Hide(bool animate);
// Returns the rectangle representing where to position the dropdown widget.
virtual gfx::Rect GetDialogPosition(gfx::Rect avoid_overlapping_rect) = 0;
// Moves the widget to the provided location, moves it to top
// in the z-order (HWND_TOP, not HWND_TOPMOST for windows), and sets the size
// of the |view_|.
virtual void SetDialogPosition(const gfx::Rect& new_pos);
// Overridden from views::FocusChangeListener:
void OnWillChangeFocus(views::View* focused_before,
views::View* focused_now) override;
void OnDidChangeFocus(views::View* focused_before,
views::View* focused_now) override;
// Overridden from ui::AcceleratorTarget:
bool AcceleratorPressed(const ui::Accelerator& accelerator) override = 0;
bool CanHandleAccelerators() const override = 0;
// gfx::AnimationDelegate implementation:
void AnimationProgressed(const gfx::Animation* animation) override;
void AnimationEnded(const gfx::Animation* animation) override;
// During testing we can disable animations by setting this flag to true,
// so that opening and closing the dropdown bar is shown instantly, instead of
// having to poll it while it animates to open/closed status.
static bool disable_animations_during_testing_;
// Returns the browser view that the dropdown belongs to.
BrowserView* browser_view() const { return browser_view_; }
// Registers this class as the handler for when Escape is pressed. Once we
// loose focus we will unregister Escape and (any accelerators the derived
// classes registers by using overrides of RegisterAccelerators). See also:
// SetFocusChangeListener().
virtual void RegisterAccelerators();
// When we loose focus, we unregister all accelerator handlers. See also:
// SetFocusChangeListener().
virtual void UnregisterAccelerators();
protected:
// Called when the drop down bar visibility, aka the value of IsVisible(),
// changes.
virtual void OnVisibilityChanged();
// Returns the dropdown bar view.
views::View* view() const { return view_; }
// Returns the focus tracker.
views::ExternalFocusTracker* focus_tracker() const {
return focus_tracker_.get();
}
// Resets the focus tracker.
void ResetFocusTracker();
// The focus manager we register with to keep track of focus changes.
views::FocusManager* focus_manager() const { return focus_manager_; }
// Returns the host widget.
views::Widget* host() const { return host_.get(); }
// Retrieves the boundary that the dropdown widget has to work with
// within the Chrome frame window. The boundary differs depending on
// the dropdown bar implementation. The default implementation
// returns the boundary of browser_view and the drop down
// can be shown in any client area.
virtual void GetWidgetBounds(gfx::Rect* bounds);
// Returns the animation for the dropdown.
gfx::SlideAnimation* animation() {
return animation_.get();
}
private:
// Set the view whose position in the |browser_view_| view hierarchy
// determines the z-order of |host_| relative to views with layers and
// views with associated NativeViews.
void SetHostViewNative(views::View* host_view);
// The BrowserView that created us.
BrowserView* browser_view_;
// Our view, which is responsible for drawing the UI.
views::View* view_;
DropdownBarHostDelegate* delegate_;
// The animation class to use when opening the Dropdown widget.
std::unique_ptr<gfx::SlideAnimation> animation_;
// The focus manager we register with to keep track of focus changes.
views::FocusManager* focus_manager_;
// True if the accelerator target for Esc key is registered.
bool esc_accel_target_registered_;
// Tracks and stores the last focused view which is not the DropdownBarView
// or any of its children. Used to restore focus once the DropdownBarView is
// closed.
std::unique_ptr<views::ExternalFocusTracker> focus_tracker_;
// Host is the Widget implementation that is created and maintained by the
// dropdown bar. It contains the DropdownBarView.
std::unique_ptr<views::Widget> host_;
// A flag to manually manage visibility. GTK/X11 is asynchronous and
// the state of the widget can be out of sync.
bool is_visible_;
DISALLOW_COPY_AND_ASSIGN(DropdownBarHost);
};
#endif // CHROME_BROWSER_UI_VIEWS_DROPDOWN_BAR_HOST_H_
|
