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.
5 #include "chrome/browser/ui/views/reload_button.h"
7 #include "base/strings/utf_string_conversions.h"
8 #include "chrome/app/chrome_command_ids.h"
9 #include "chrome/browser/command_updater.h"
10 #include "chrome/browser/search/search.h"
11 #include "chrome/browser/ui/search/search_model.h"
12 #include "chrome/browser/ui/views/location_bar/location_bar_view.h"
13 #include "grit/generated_resources.h"
14 #include "grit/theme_resources.h"
15 #include "ui/base/l10n/l10n_util.h"
16 #include "ui/base/models/simple_menu_model.h"
17 #include "ui/base/theme_provider.h"
18 #include "ui/base/window_open_disposition.h"
19 #include "ui/views/metrics.h"
20 #include "ui/views/widget/widget.h"
25 const int kReloadImages[] =
26 { IDR_RELOAD, IDR_RELOAD_H, IDR_RELOAD_P, IDR_RELOAD_D };
28 const int kStopImages[] = { IDR_STOP, IDR_STOP_H, IDR_STOP_P, IDR_STOP_D };
30 // Contents of the Reload drop-down menu.
31 const int kReloadMenuItems[] = {
32 IDS_RELOAD_MENU_NORMAL_RELOAD_ITEM,
33 IDS_RELOAD_MENU_HARD_RELOAD_ITEM,
34 IDS_RELOAD_MENU_EMPTY_AND_HARD_RELOAD_ITEM,
40 // ReloadButton ---------------------------------------------------------------
43 const char ReloadButton::kViewClassName[] = "ReloadButton";
45 ReloadButton::ReloadButton(LocationBarView* location_bar,
46 CommandUpdater* command_updater)
47 : ButtonDropDown(this, CreateMenuModel()),
48 location_bar_(location_bar),
49 command_updater_(command_updater),
50 intended_mode_(MODE_RELOAD),
51 visible_mode_(MODE_RELOAD),
52 double_click_timer_delay_(
53 base::TimeDelta::FromMilliseconds(views::GetDoubleClickInterval())),
54 stop_to_reload_timer_delay_(base::TimeDelta::FromMilliseconds(1350)),
56 testing_mouse_hovered_(false),
57 testing_reload_count_(0) {
60 ReloadButton::~ReloadButton() {
63 void ReloadButton::ChangeMode(Mode mode, bool force) {
64 intended_mode_ = mode;
66 // If the change is forced, or the user isn't hovering the icon, or it's safe
67 // to change it to the other image type, make the change immediately;
68 // otherwise we'll let it happen later.
69 if (force || (!IsMouseHovered() && !testing_mouse_hovered_) ||
70 ((mode == MODE_STOP) ?
71 !double_click_timer_.IsRunning() : (visible_mode_ != MODE_STOP))) {
72 double_click_timer_.Stop();
73 stop_to_reload_timer_.Stop();
74 ChangeModeInternal(mode);
77 // We want to disable the button if we're preventing a change from stop to
78 // reload due to hovering, but not if we're preventing a change from reload to
79 // stop due to the double-click timer running. (Disabled reload state is only
80 // applicable when instant extended API is enabled and mode is NTP, which is
81 // handled just above.)
82 } else if (visible_mode_ != MODE_RELOAD) {
85 // Go ahead and change to reload after a bit, which allows repeated reloads
86 // without moving the mouse.
87 if (!stop_to_reload_timer_.IsRunning()) {
88 stop_to_reload_timer_.Start(FROM_HERE, stop_to_reload_timer_delay_, this,
89 &ReloadButton::OnStopToReloadTimer);
94 void ReloadButton::LoadImages(ui::ThemeProvider* tp) {
95 DCHECK_EQ(static_cast<int>(arraysize(kReloadImages)), STATE_COUNT);
96 DCHECK_EQ(static_cast<int>(arraysize(kStopImages)), STATE_COUNT);
98 gfx::ImageSkia* reload_images = images_;
99 gfx::ImageSkia* stop_images = alternate_images_;
100 if (visible_mode_ == MODE_STOP)
101 std::swap(reload_images, stop_images);
103 for (int i = 0; i < STATE_COUNT; i++) {
104 reload_images[i] = *(tp->GetImageSkiaNamed(kReloadImages[i]));
105 stop_images[i] = *(tp->GetImageSkiaNamed(kStopImages[i]));
109 PreferredSizeChanged();
112 void ReloadButton::OnMouseExited(const ui::MouseEvent& event) {
113 ButtonDropDown::OnMouseExited(event);
114 if (!IsMenuShowing())
115 ChangeMode(intended_mode_, true);
118 bool ReloadButton::GetTooltipText(const gfx::Point& p,
119 string16* tooltip) const {
120 int reload_tooltip = menu_enabled_ ?
121 IDS_TOOLTIP_RELOAD_WITH_MENU : IDS_TOOLTIP_RELOAD;
122 int text_id = (visible_mode_ == MODE_RELOAD) ?
123 reload_tooltip : IDS_TOOLTIP_STOP;
124 tooltip->assign(l10n_util::GetStringUTF16(text_id));
128 const char* ReloadButton::GetClassName() const {
129 return kViewClassName;
132 void ReloadButton::GetAccessibleState(ui::AccessibleViewState* state) {
134 ButtonDropDown::GetAccessibleState(state);
136 CustomButton::GetAccessibleState(state);
139 bool ReloadButton::ShouldShowMenu() {
140 return menu_enabled_ && (visible_mode_ == MODE_RELOAD);
143 void ReloadButton::ShowDropDownMenu(ui::MenuSourceType source_type) {
144 ButtonDropDown::ShowDropDownMenu(source_type); // Blocks.
145 ChangeMode(intended_mode_, true);
148 void ReloadButton::ButtonPressed(views::Button* /* button */,
149 const ui::Event& event) {
152 if (visible_mode_ == MODE_STOP) {
153 if (command_updater_)
154 command_updater_->ExecuteCommandWithDisposition(IDC_STOP, CURRENT_TAB);
155 // The user has clicked, so we can feel free to update the button,
156 // even if the mouse is still hovering.
157 ChangeMode(MODE_RELOAD, true);
158 } else if (!double_click_timer_.IsRunning()) {
159 // Shift-clicking or ctrl-clicking the reload button means we should ignore
160 // any cached content.
162 int flags = event.flags();
163 if (event.IsShiftDown() || event.IsControlDown()) {
164 command = IDC_RELOAD_IGNORING_CACHE;
165 // Mask off Shift and Control so they don't affect the disposition below.
166 flags &= ~(ui::EF_SHIFT_DOWN | ui::EF_CONTROL_DOWN);
168 command = IDC_RELOAD;
171 // Start a timer - while this timer is running, the reload button cannot be
172 // changed to a stop button. We do not set |intended_mode_| to MODE_STOP
173 // here as the browser will do that when it actually starts loading (which
174 // may happen synchronously, thus the need to do this before telling the
175 // browser to execute the reload command).
176 double_click_timer_.Start(FROM_HERE, double_click_timer_delay_, this,
177 &ReloadButton::OnDoubleClickTimer);
179 ExecuteBrowserCommand(command, flags);
180 ++testing_reload_count_;
184 bool ReloadButton::IsCommandIdChecked(int command_id) const {
188 bool ReloadButton::IsCommandIdEnabled(int command_id) const {
192 bool ReloadButton::IsCommandIdVisible(int command_id) const {
196 bool ReloadButton::GetAcceleratorForCommandId(int command_id,
197 ui::Accelerator* accelerator) {
198 switch (command_id) {
199 case IDS_RELOAD_MENU_NORMAL_RELOAD_ITEM:
200 GetWidget()->GetAccelerator(IDC_RELOAD, accelerator);
202 case IDS_RELOAD_MENU_HARD_RELOAD_ITEM:
203 GetWidget()->GetAccelerator(IDC_RELOAD_IGNORING_CACHE, accelerator);
206 return GetWidget()->GetAccelerator(command_id, accelerator);
209 void ReloadButton::ExecuteCommand(int command_id, int event_flags) {
210 int browser_command = 0;
211 switch (command_id) {
212 case IDS_RELOAD_MENU_NORMAL_RELOAD_ITEM:
213 browser_command = IDC_RELOAD;
215 case IDS_RELOAD_MENU_HARD_RELOAD_ITEM:
216 browser_command = IDC_RELOAD_IGNORING_CACHE;
218 case IDS_RELOAD_MENU_EMPTY_AND_HARD_RELOAD_ITEM:
219 browser_command = IDC_RELOAD_CLEARING_CACHE;
224 ExecuteBrowserCommand(browser_command, event_flags);
227 ui::SimpleMenuModel* ReloadButton::CreateMenuModel() {
228 ui::SimpleMenuModel* menu_model = new ui::SimpleMenuModel(this);
229 for (size_t i = 0; i < arraysize(kReloadMenuItems); ++i)
230 menu_model->AddItemWithStringId(kReloadMenuItems[i], kReloadMenuItems[i]);
235 void ReloadButton::ExecuteBrowserCommand(int command, int event_flags) {
236 if (!command_updater_)
239 WindowOpenDisposition disposition =
240 ui::DispositionFromEventFlags(event_flags);
241 if ((disposition == CURRENT_TAB) && location_bar_) {
242 // Forcibly reset the location bar, since otherwise it won't discard any
243 // ongoing user edits, since it doesn't realize this is a user-initiated
245 location_bar_->Revert();
247 command_updater_->ExecuteCommandWithDisposition(command, disposition);
250 void ReloadButton::ChangeModeInternal(Mode mode) {
251 if (visible_mode_ == mode)
254 for (size_t i = 0; i < STATE_COUNT; ++i)
255 std::swap(images_[i], alternate_images_[i]);
256 visible_mode_ = mode;
260 void ReloadButton::OnDoubleClickTimer() {
261 if (!IsMenuShowing())
262 ChangeMode(intended_mode_, false);
265 void ReloadButton::OnStopToReloadTimer() {
266 DCHECK(!IsMenuShowing());
267 ChangeMode(intended_mode_, true);