OLD | NEW |
| (Empty) |
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 #include "chrome/browser/ui/views/fullscreen_exit_bubble_views.h" | |
6 | |
7 #include "base/message_loop/message_loop.h" | |
8 #include "base/strings/utf_string_conversions.h" | |
9 #include "chrome/app/chrome_command_ids.h" | |
10 #include "chrome/browser/chrome_notification_types.h" | |
11 #include "chrome/browser/ui/fullscreen/fullscreen_controller.h" | |
12 #include "chrome/browser/ui/views/frame/browser_view.h" | |
13 #include "chrome/browser/ui/views/frame/immersive_mode_controller.h" | |
14 #include "chrome/browser/ui/views/frame/top_container_view.h" | |
15 #include "chrome/grit/generated_resources.h" | |
16 #include "content/public/browser/notification_service.h" | |
17 #include "ui/base/l10n/l10n_util.h" | |
18 #include "ui/base/resource/resource_bundle.h" | |
19 #include "ui/events/keycodes/keyboard_codes.h" | |
20 #include "ui/gfx/animation/slide_animation.h" | |
21 #include "ui/gfx/canvas.h" | |
22 #include "ui/gfx/screen.h" | |
23 #include "ui/strings/grit/ui_strings.h" | |
24 #include "ui/views/bubble/bubble_border.h" | |
25 #include "ui/views/controls/button/label_button.h" | |
26 #include "ui/views/controls/link.h" | |
27 #include "ui/views/controls/link_listener.h" | |
28 #include "ui/views/layout/box_layout.h" | |
29 #include "ui/views/layout/grid_layout.h" | |
30 #include "ui/views/view.h" | |
31 #include "ui/views/widget/widget.h" | |
32 #include "url/gurl.h" | |
33 | |
34 #if defined(OS_WIN) | |
35 #include "ui/base/l10n/l10n_util_win.h" | |
36 #endif | |
37 | |
38 // FullscreenExitView ---------------------------------------------------------- | |
39 | |
40 namespace { | |
41 | |
42 // Space between the site info label and the buttons / link. | |
43 const int kMiddlePaddingPx = 30; | |
44 | |
45 class ButtonView : public views::View { | |
46 public: | |
47 ButtonView(views::ButtonListener* listener, int between_button_spacing); | |
48 ~ButtonView() override; | |
49 | |
50 // Returns an empty size when the view is not visible. | |
51 gfx::Size GetPreferredSize() const override; | |
52 | |
53 views::LabelButton* accept_button() const { return accept_button_; } | |
54 views::LabelButton* deny_button() const { return deny_button_; } | |
55 | |
56 private: | |
57 views::LabelButton* accept_button_; | |
58 views::LabelButton* deny_button_; | |
59 | |
60 DISALLOW_COPY_AND_ASSIGN(ButtonView); | |
61 }; | |
62 | |
63 ButtonView::ButtonView(views::ButtonListener* listener, | |
64 int between_button_spacing) | |
65 : accept_button_(NULL), | |
66 deny_button_(NULL) { | |
67 accept_button_ = new views::LabelButton(listener, base::string16()); | |
68 accept_button_->SetStyle(views::Button::STYLE_BUTTON); | |
69 accept_button_->SetFocusable(false); | |
70 AddChildView(accept_button_); | |
71 | |
72 deny_button_ = new views::LabelButton(listener, base::string16()); | |
73 deny_button_->SetStyle(views::Button::STYLE_BUTTON); | |
74 deny_button_->SetFocusable(false); | |
75 AddChildView(deny_button_); | |
76 | |
77 SetLayoutManager(new views::BoxLayout(views::BoxLayout::kHorizontal, 0, 0, | |
78 between_button_spacing)); | |
79 } | |
80 | |
81 ButtonView::~ButtonView() { | |
82 } | |
83 | |
84 gfx::Size ButtonView::GetPreferredSize() const { | |
85 return visible() ? views::View::GetPreferredSize() : gfx::Size(); | |
86 } | |
87 | |
88 } // namespace | |
89 | |
90 class FullscreenExitBubbleViews::FullscreenExitView | |
91 : public views::View, | |
92 public views::ButtonListener, | |
93 public views::LinkListener { | |
94 public: | |
95 FullscreenExitView(FullscreenExitBubbleViews* bubble, | |
96 const base::string16& accelerator, | |
97 const GURL& url, | |
98 FullscreenExitBubbleType bubble_type); | |
99 ~FullscreenExitView() override; | |
100 | |
101 // views::ButtonListener | |
102 void ButtonPressed(views::Button* sender, const ui::Event& event) override; | |
103 | |
104 // views::LinkListener | |
105 void LinkClicked(views::Link* source, int event_flags) override; | |
106 | |
107 void UpdateContent(const GURL& url, FullscreenExitBubbleType bubble_type); | |
108 | |
109 private: | |
110 FullscreenExitBubbleViews* bubble_; | |
111 | |
112 // Clickable hint text for exiting fullscreen mode. | |
113 views::Link* link_; | |
114 // Instruction for exiting mouse lock. | |
115 views::Label* mouse_lock_exit_instruction_; | |
116 // Informational label: 'www.foo.com has gone fullscreen'. | |
117 views::Label* message_label_; | |
118 ButtonView* button_view_; | |
119 const base::string16 browser_fullscreen_exit_accelerator_; | |
120 | |
121 DISALLOW_COPY_AND_ASSIGN(FullscreenExitView); | |
122 }; | |
123 | |
124 FullscreenExitBubbleViews::FullscreenExitView::FullscreenExitView( | |
125 FullscreenExitBubbleViews* bubble, | |
126 const base::string16& accelerator, | |
127 const GURL& url, | |
128 FullscreenExitBubbleType bubble_type) | |
129 : bubble_(bubble), | |
130 link_(NULL), | |
131 mouse_lock_exit_instruction_(NULL), | |
132 message_label_(NULL), | |
133 button_view_(NULL), | |
134 browser_fullscreen_exit_accelerator_(accelerator) { | |
135 scoped_ptr<views::BubbleBorder> bubble_border( | |
136 new views::BubbleBorder(views::BubbleBorder::NONE, | |
137 views::BubbleBorder::BIG_SHADOW, | |
138 SK_ColorWHITE)); | |
139 set_background(new views::BubbleBackground(bubble_border.get())); | |
140 SetBorder(bubble_border.Pass()); | |
141 SetFocusable(false); | |
142 | |
143 ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance(); | |
144 const gfx::FontList& medium_font_list = | |
145 rb.GetFontList(ui::ResourceBundle::MediumFont); | |
146 message_label_ = new views::Label(base::string16(), medium_font_list); | |
147 | |
148 mouse_lock_exit_instruction_ = | |
149 new views::Label(bubble_->GetInstructionText(), medium_font_list); | |
150 mouse_lock_exit_instruction_->set_collapse_when_hidden(true); | |
151 | |
152 link_ = new views::Link(); | |
153 link_->set_collapse_when_hidden(true); | |
154 link_->SetFocusable(false); | |
155 #if defined(OS_CHROMEOS) | |
156 // On CrOS, the link text doesn't change, since it doesn't show the shortcut. | |
157 link_->SetText(l10n_util::GetStringUTF16(IDS_EXIT_FULLSCREEN_MODE)); | |
158 #endif | |
159 link_->set_listener(this); | |
160 link_->SetFontList(medium_font_list); | |
161 link_->SetPressedColor(message_label_->enabled_color()); | |
162 link_->SetEnabledColor(message_label_->enabled_color()); | |
163 link_->SetVisible(false); | |
164 | |
165 link_->SetBackgroundColor(background()->get_color()); | |
166 message_label_->SetBackgroundColor(background()->get_color()); | |
167 mouse_lock_exit_instruction_->SetBackgroundColor(background()->get_color()); | |
168 | |
169 button_view_ = new ButtonView(this, kPaddingPx); | |
170 button_view_->accept_button()->SetText(bubble->GetAllowButtonText()); | |
171 | |
172 views::GridLayout* layout = new views::GridLayout(this); | |
173 views::ColumnSet* columns = layout->AddColumnSet(0); | |
174 columns->AddColumn(views::GridLayout::LEADING, views::GridLayout::CENTER, 0, | |
175 views::GridLayout::USE_PREF, 0, 0); | |
176 columns->AddPaddingColumn(1, kMiddlePaddingPx); | |
177 columns->AddColumn(views::GridLayout::LEADING, views::GridLayout::CENTER, 0, | |
178 views::GridLayout::USE_PREF, 0, 0); | |
179 columns->AddColumn(views::GridLayout::LEADING, views::GridLayout::CENTER, 0, | |
180 views::GridLayout::USE_PREF, 0, 0); | |
181 columns->AddColumn(views::GridLayout::LEADING, views::GridLayout::CENTER, 0, | |
182 views::GridLayout::USE_PREF, 0, 0); | |
183 | |
184 layout->StartRow(0, 0); | |
185 layout->AddView(message_label_); | |
186 layout->AddView(button_view_); | |
187 layout->AddView(mouse_lock_exit_instruction_); | |
188 layout->AddView(link_); | |
189 | |
190 gfx::Insets padding(kPaddingPx, kPaddingPx, kPaddingPx, kPaddingPx); | |
191 padding += GetInsets(); | |
192 layout->SetInsets(padding); | |
193 SetLayoutManager(layout); | |
194 | |
195 UpdateContent(url, bubble_type); | |
196 } | |
197 | |
198 FullscreenExitBubbleViews::FullscreenExitView::~FullscreenExitView() { | |
199 } | |
200 | |
201 void FullscreenExitBubbleViews::FullscreenExitView::ButtonPressed( | |
202 views::Button* sender, | |
203 const ui::Event& event) { | |
204 if (sender == button_view_->accept_button()) | |
205 bubble_->Accept(); | |
206 else | |
207 bubble_->Cancel(); | |
208 } | |
209 | |
210 void FullscreenExitBubbleViews::FullscreenExitView::LinkClicked( | |
211 views::Link* link, | |
212 int event_flags) { | |
213 bubble_->ToggleFullscreen(); | |
214 } | |
215 | |
216 void FullscreenExitBubbleViews::FullscreenExitView::UpdateContent( | |
217 const GURL& url, | |
218 FullscreenExitBubbleType bubble_type) { | |
219 DCHECK_NE(FEB_TYPE_NONE, bubble_type); | |
220 | |
221 message_label_->SetText(bubble_->GetCurrentMessageText()); | |
222 if (fullscreen_bubble::ShowButtonsForType(bubble_type)) { | |
223 link_->SetVisible(false); | |
224 mouse_lock_exit_instruction_->SetVisible(false); | |
225 button_view_->SetVisible(true); | |
226 button_view_->deny_button()->SetText(bubble_->GetCurrentDenyButtonText()); | |
227 button_view_->deny_button()->SetMinSize(gfx::Size()); | |
228 } else { | |
229 bool link_visible = true; | |
230 base::string16 accelerator; | |
231 if (bubble_type == FEB_TYPE_BROWSER_FULLSCREEN_EXIT_INSTRUCTION || | |
232 bubble_type == FEB_TYPE_BROWSER_EXTENSION_FULLSCREEN_EXIT_INSTRUCTION) { | |
233 accelerator = browser_fullscreen_exit_accelerator_; | |
234 } else if (bubble_type == FEB_TYPE_FULLSCREEN_EXIT_INSTRUCTION) { | |
235 accelerator = l10n_util::GetStringUTF16(IDS_APP_ESC_KEY); | |
236 } else { | |
237 link_visible = false; | |
238 } | |
239 #if !defined(OS_CHROMEOS) | |
240 if (link_visible) { | |
241 link_->SetText( | |
242 l10n_util::GetStringUTF16(IDS_EXIT_FULLSCREEN_MODE) + | |
243 base::UTF8ToUTF16(" ") + | |
244 l10n_util::GetStringFUTF16(IDS_EXIT_FULLSCREEN_MODE_ACCELERATOR, | |
245 accelerator)); | |
246 } | |
247 #endif | |
248 link_->SetVisible(link_visible); | |
249 mouse_lock_exit_instruction_->SetVisible(!link_visible); | |
250 button_view_->SetVisible(false); | |
251 } | |
252 } | |
253 | |
254 | |
255 // FullscreenExitBubbleViews --------------------------------------------------- | |
256 | |
257 FullscreenExitBubbleViews::FullscreenExitBubbleViews( | |
258 BrowserView* browser_view, | |
259 const GURL& url, | |
260 FullscreenExitBubbleType bubble_type) | |
261 : FullscreenExitBubble(browser_view->browser(), url, bubble_type), | |
262 browser_view_(browser_view), | |
263 popup_(NULL), | |
264 animation_(new gfx::SlideAnimation(this)), | |
265 animated_attribute_(ANIMATED_ATTRIBUTE_BOUNDS) { | |
266 animation_->Reset(1); | |
267 | |
268 // Create the contents view. | |
269 ui::Accelerator accelerator(ui::VKEY_UNKNOWN, ui::EF_NONE); | |
270 bool got_accelerator = browser_view_->GetWidget()->GetAccelerator( | |
271 IDC_FULLSCREEN, &accelerator); | |
272 DCHECK(got_accelerator); | |
273 view_ = new FullscreenExitView( | |
274 this, accelerator.GetShortcutText(), url, bubble_type_); | |
275 | |
276 // TODO(yzshen): Change to use the new views bubble, BubbleDelegateView. | |
277 // TODO(pkotwicz): When this becomes a views bubble, make sure that this | |
278 // bubble is ignored by ImmersiveModeControllerAsh::BubbleManager. | |
279 // Initialize the popup. | |
280 popup_ = new views::Widget; | |
281 views::Widget::InitParams params(views::Widget::InitParams::TYPE_POPUP); | |
282 params.opacity = views::Widget::InitParams::TRANSLUCENT_WINDOW; | |
283 params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET; | |
284 params.parent = browser_view_->GetWidget()->GetNativeView(); | |
285 params.bounds = GetPopupRect(false); | |
286 popup_->Init(params); | |
287 gfx::Size size = GetPopupRect(true).size(); | |
288 popup_->SetContentsView(view_); | |
289 // We set layout manager to NULL to prevent the widget from sizing its | |
290 // contents to the same size as itself. This prevents the widget contents from | |
291 // shrinking while we animate the height of the popup to give the impression | |
292 // that it is sliding off the top of the screen. | |
293 popup_->GetRootView()->SetLayoutManager(NULL); | |
294 view_->SetBounds(0, 0, size.width(), size.height()); | |
295 popup_->ShowInactive(); // This does not activate the popup. | |
296 | |
297 popup_->AddObserver(this); | |
298 | |
299 registrar_.Add( | |
300 this, | |
301 chrome::NOTIFICATION_FULLSCREEN_CHANGED, | |
302 content::Source<FullscreenController>( | |
303 browser_view_->browser()->fullscreen_controller())); | |
304 | |
305 UpdateForImmersiveState(); | |
306 } | |
307 | |
308 FullscreenExitBubbleViews::~FullscreenExitBubbleViews() { | |
309 popup_->RemoveObserver(this); | |
310 | |
311 // This is tricky. We may be in an ATL message handler stack, in which case | |
312 // the popup cannot be deleted yet. We also can't set the popup's ownership | |
313 // model to NATIVE_WIDGET_OWNS_WIDGET because if the user closed the last tab | |
314 // while in fullscreen mode, Windows has already destroyed the popup HWND by | |
315 // the time we get here, and thus either the popup will already have been | |
316 // deleted (if we set this in our constructor) or the popup will never get | |
317 // another OnFinalMessage() call (if not, as currently). So instead, we tell | |
318 // the popup to synchronously hide, and then asynchronously close and delete | |
319 // itself. | |
320 popup_->Close(); | |
321 base::MessageLoop::current()->DeleteSoon(FROM_HERE, popup_); | |
322 } | |
323 | |
324 void FullscreenExitBubbleViews::UpdateContent( | |
325 const GURL& url, | |
326 FullscreenExitBubbleType bubble_type) { | |
327 DCHECK_NE(FEB_TYPE_NONE, bubble_type); | |
328 if (bubble_type_ == bubble_type && url_ == url) | |
329 return; | |
330 | |
331 url_ = url; | |
332 bubble_type_ = bubble_type; | |
333 view_->UpdateContent(url_, bubble_type_); | |
334 | |
335 gfx::Size size = GetPopupRect(true).size(); | |
336 view_->SetSize(size); | |
337 popup_->SetBounds(GetPopupRect(false)); | |
338 Show(); | |
339 | |
340 // Stop watching the mouse even if UpdateMouseWatcher() will start watching | |
341 // it again so that the popup with the new content is visible for at least | |
342 // |kInitialDelayMs|. | |
343 StopWatchingMouse(); | |
344 | |
345 UpdateMouseWatcher(); | |
346 } | |
347 | |
348 void FullscreenExitBubbleViews::RepositionIfVisible() { | |
349 if (popup_->IsVisible()) | |
350 UpdateBounds(); | |
351 } | |
352 | |
353 void FullscreenExitBubbleViews::UpdateMouseWatcher() { | |
354 bool should_watch_mouse = false; | |
355 if (popup_->IsVisible()) | |
356 should_watch_mouse = !fullscreen_bubble::ShowButtonsForType(bubble_type_); | |
357 else | |
358 should_watch_mouse = CanMouseTriggerSlideIn(); | |
359 | |
360 if (should_watch_mouse == IsWatchingMouse()) | |
361 return; | |
362 | |
363 if (should_watch_mouse) | |
364 StartWatchingMouse(); | |
365 else | |
366 StopWatchingMouse(); | |
367 } | |
368 | |
369 void FullscreenExitBubbleViews::UpdateForImmersiveState() { | |
370 AnimatedAttribute expected_animated_attribute = | |
371 browser_view_->immersive_mode_controller()->IsEnabled() ? | |
372 ANIMATED_ATTRIBUTE_OPACITY : ANIMATED_ATTRIBUTE_BOUNDS; | |
373 if (animated_attribute_ != expected_animated_attribute) { | |
374 // If an animation is currently in progress, skip to the end because | |
375 // switching the animated attribute midway through the animation looks | |
376 // weird. | |
377 animation_->End(); | |
378 | |
379 animated_attribute_ = expected_animated_attribute; | |
380 | |
381 // We may have finished hiding |popup_|. However, the bounds animation | |
382 // assumes |popup_| has the opacity when it is fully shown and the opacity | |
383 // animation assumes |popup_| has the bounds when |popup_| is fully shown. | |
384 if (animated_attribute_ == ANIMATED_ATTRIBUTE_BOUNDS) | |
385 popup_->SetOpacity(255); | |
386 else | |
387 UpdateBounds(); | |
388 } | |
389 | |
390 UpdateMouseWatcher(); | |
391 } | |
392 | |
393 void FullscreenExitBubbleViews::UpdateBounds() { | |
394 gfx::Rect popup_rect(GetPopupRect(false)); | |
395 if (!popup_rect.IsEmpty()) { | |
396 popup_->SetBounds(popup_rect); | |
397 view_->SetY(popup_rect.height() - view_->height()); | |
398 } | |
399 } | |
400 | |
401 views::View* FullscreenExitBubbleViews::GetBrowserRootView() const { | |
402 return browser_view_->GetWidget()->GetRootView(); | |
403 } | |
404 | |
405 void FullscreenExitBubbleViews::AnimationProgressed( | |
406 const gfx::Animation* animation) { | |
407 if (animated_attribute_ == ANIMATED_ATTRIBUTE_OPACITY) { | |
408 int opacity = animation_->CurrentValueBetween(0, 255); | |
409 if (opacity == 0) { | |
410 popup_->Hide(); | |
411 } else { | |
412 popup_->Show(); | |
413 popup_->SetOpacity(opacity); | |
414 } | |
415 } else { | |
416 if (GetPopupRect(false).IsEmpty()) { | |
417 popup_->Hide(); | |
418 } else { | |
419 UpdateBounds(); | |
420 popup_->Show(); | |
421 } | |
422 } | |
423 } | |
424 | |
425 void FullscreenExitBubbleViews::AnimationEnded( | |
426 const gfx::Animation* animation) { | |
427 AnimationProgressed(animation); | |
428 } | |
429 | |
430 gfx::Rect FullscreenExitBubbleViews::GetPopupRect( | |
431 bool ignore_animation_state) const { | |
432 gfx::Size size(view_->GetPreferredSize()); | |
433 // NOTE: don't use the bounds of the root_view_. On linux GTK changing window | |
434 // size is async. Instead we use the size of the screen. | |
435 gfx::Screen* screen = | |
436 gfx::Screen::GetScreenFor(browser_view_->GetWidget()->GetNativeView()); | |
437 gfx::Rect screen_bounds = screen->GetDisplayNearestWindow( | |
438 browser_view_->GetWidget()->GetNativeView()).bounds(); | |
439 int x = screen_bounds.x() + (screen_bounds.width() - size.width()) / 2; | |
440 | |
441 int top_container_bottom = screen_bounds.y(); | |
442 if (browser_view_->immersive_mode_controller()->IsEnabled()) { | |
443 // Skip querying the top container height in non-immersive fullscreen | |
444 // because: | |
445 // - The top container height is always zero in non-immersive fullscreen. | |
446 // - Querying the top container height may return the height before entering | |
447 // fullscreen because layout is disabled while entering fullscreen. | |
448 // A visual glitch due to the delayed layout is avoided in immersive | |
449 // fullscreen because entering fullscreen starts with the top container | |
450 // revealed. When revealed, the top container has the same height as before | |
451 // entering fullscreen. | |
452 top_container_bottom = | |
453 browser_view_->top_container()->GetBoundsInScreen().bottom(); | |
454 } | |
455 int y = top_container_bottom + kPopupTopPx; | |
456 | |
457 if (!ignore_animation_state && | |
458 animated_attribute_ == ANIMATED_ATTRIBUTE_BOUNDS) { | |
459 int total_height = size.height() + kPopupTopPx; | |
460 int popup_bottom = animation_->CurrentValueBetween(total_height, 0); | |
461 int y_offset = std::min(popup_bottom, kPopupTopPx); | |
462 size.set_height(size.height() - popup_bottom + y_offset); | |
463 y -= y_offset; | |
464 } | |
465 return gfx::Rect(gfx::Point(x, y), size); | |
466 } | |
467 | |
468 gfx::Point FullscreenExitBubbleViews::GetCursorScreenPoint() { | |
469 gfx::Point cursor_pos = gfx::Screen::GetScreenFor( | |
470 browser_view_->GetWidget()->GetNativeView())->GetCursorScreenPoint(); | |
471 views::View::ConvertPointFromScreen(GetBrowserRootView(), &cursor_pos); | |
472 return cursor_pos; | |
473 } | |
474 | |
475 bool FullscreenExitBubbleViews::WindowContainsPoint(gfx::Point pos) { | |
476 return GetBrowserRootView()->HitTestPoint(pos); | |
477 } | |
478 | |
479 bool FullscreenExitBubbleViews::IsWindowActive() { | |
480 return browser_view_->GetWidget()->IsActive(); | |
481 } | |
482 | |
483 void FullscreenExitBubbleViews::Hide() { | |
484 animation_->SetSlideDuration(kSlideOutDurationMs); | |
485 animation_->Hide(); | |
486 } | |
487 | |
488 void FullscreenExitBubbleViews::Show() { | |
489 animation_->SetSlideDuration(kSlideInDurationMs); | |
490 animation_->Show(); | |
491 } | |
492 | |
493 bool FullscreenExitBubbleViews::IsAnimating() { | |
494 return animation_->is_animating(); | |
495 } | |
496 | |
497 bool FullscreenExitBubbleViews::CanMouseTriggerSlideIn() const { | |
498 return !browser_view_->immersive_mode_controller()->IsEnabled(); | |
499 } | |
500 | |
501 void FullscreenExitBubbleViews::Observe( | |
502 int type, | |
503 const content::NotificationSource& source, | |
504 const content::NotificationDetails& details) { | |
505 DCHECK_EQ(chrome::NOTIFICATION_FULLSCREEN_CHANGED, type); | |
506 UpdateForImmersiveState(); | |
507 } | |
508 | |
509 void FullscreenExitBubbleViews::OnWidgetVisibilityChanged( | |
510 views::Widget* widget, | |
511 bool visible) { | |
512 UpdateMouseWatcher(); | |
513 } | |
OLD | NEW |