chrome/browser/ui/views/fullscreen_exit_bubble_views.cc

   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 "content/public/browser/notification_service.h"
  16 #include "grit/generated_resources.h"
  17 #include "grit/ui_strings.h"
  18 #include "ui/base/l10n/l10n_util.h"
  19 #include "ui/base/resource/resource_bundle.h"
  20 #include "ui/events/keycodes/keyboard_codes.h"
  21 #include "ui/gfx/animation/slide_animation.h"
  22 #include "ui/gfx/canvas.h"
  23 #include "ui/gfx/screen.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   virtual ~ButtonView();
  49
  50   // Returns an empty size when the view is not visible.
  51   virtual gfx::Size GetPreferredSize() 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() {
  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   virtual ~FullscreenExitView();
 100
 101   // views::ButtonListener
 102   virtual void ButtonPressed(views::Button* sender,
 103                              const ui::Event& event) OVERRIDE;
 104
 105   // views::LinkListener
 106   virtual void LinkClicked(views::Link* source, int event_flags) OVERRIDE;
 107
 108   void UpdateContent(const GURL& url, FullscreenExitBubbleType bubble_type);
 109
 110  private:
 111   FullscreenExitBubbleViews* bubble_;
 112
 113   // Clickable hint text for exiting fullscreen mode.
 114   views::Link* link_;
 115   // Instruction for exiting mouse lock.
 116   views::Label* mouse_lock_exit_instruction_;
 117   // Informational label: 'www.foo.com has gone fullscreen'.
 118   views::Label* message_label_;
 119   ButtonView* button_view_;
 120   const base::string16 browser_fullscreen_exit_accelerator_;
 121
 122   DISALLOW_COPY_AND_ASSIGN(FullscreenExitView);
 123 };
 124
 125 FullscreenExitBubbleViews::FullscreenExitView::FullscreenExitView(
 126     FullscreenExitBubbleViews* bubble,
 127     const base::string16& accelerator,
 128     const GURL& url,
 129     FullscreenExitBubbleType bubble_type)
 130     : bubble_(bubble),
 131       link_(NULL),
 132       mouse_lock_exit_instruction_(NULL),
 133       message_label_(NULL),
 134       button_view_(NULL),
 135       browser_fullscreen_exit_accelerator_(accelerator) {
 136   views::BubbleBorder* bubble_border = new views::BubbleBorder(
 137       views::BubbleBorder::NONE, views::BubbleBorder::BIG_SHADOW,
 138       SK_ColorWHITE);
 139   set_background(new views::BubbleBackground(bubble_border));
 140   set_border(bubble_border);
 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()->set_min_size(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.can_activate = false;
 284   params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
 285   params.parent = browser_view_->GetWidget()->GetNativeView();
 286   params.bounds = GetPopupRect(false);
 287   popup_->Init(params);
 288   gfx::Size size = GetPopupRect(true).size();
 289   popup_->SetContentsView(view_);
 290   // We set layout manager to NULL to prevent the widget from sizing its
 291   // contents to the same size as itself. This prevents the widget contents from
 292   // shrinking while we animate the height of the popup to give the impression
 293   // that it is sliding off the top of the screen.
 294   popup_->GetRootView()->SetLayoutManager(NULL);
 295   view_->SetBounds(0, 0, size.width(), size.height());
 296   popup_->ShowInactive();  // This does not activate the popup.
 297
 298   popup_->AddObserver(this);
 299
 300   registrar_.Add(
 301       this,
 302       chrome::NOTIFICATION_FULLSCREEN_CHANGED,
 303       content::Source<FullscreenController>(
 304           browser_view_->browser()->fullscreen_controller()));
 305
 306   UpdateForImmersiveState();
 307 }
 308
 309 FullscreenExitBubbleViews::~FullscreenExitBubbleViews() {
 310   popup_->RemoveObserver(this);
 311
 312   // This is tricky.  We may be in an ATL message handler stack, in which case
 313   // the popup cannot be deleted yet.  We also can't set the popup's ownership
 314   // model to NATIVE_WIDGET_OWNS_WIDGET because if the user closed the last tab
 315   // while in fullscreen mode, Windows has already destroyed the popup HWND by
 316   // the time we get here, and thus either the popup will already have been
 317   // deleted (if we set this in our constructor) or the popup will never get
 318   // another OnFinalMessage() call (if not, as currently).  So instead, we tell
 319   // the popup to synchronously hide, and then asynchronously close and delete
 320   // itself.
 321   popup_->Close();
 322   base::MessageLoop::current()->DeleteSoon(FROM_HERE, popup_);
 323 }
 324
 325 void FullscreenExitBubbleViews::UpdateContent(
 326     const GURL& url,
 327     FullscreenExitBubbleType bubble_type) {
 328   DCHECK_NE(FEB_TYPE_NONE, bubble_type);
 329   if (bubble_type_ == bubble_type && url_ == url)
 330     return;
 331
 332   url_ = url;
 333   bubble_type_ = bubble_type;
 334   view_->UpdateContent(url_, bubble_type_);
 335
 336   gfx::Size size = GetPopupRect(true).size();
 337   view_->SetSize(size);
 338   popup_->SetBounds(GetPopupRect(false));
 339   Show();
 340
 341   // Stop watching the mouse even if UpdateMouseWatcher() will start watching
 342   // it again so that the popup with the new content is visible for at least
 343   // |kInitialDelayMs|.
 344   StopWatchingMouse();
 345
 346   UpdateMouseWatcher();
 347 }
 348
 349 void FullscreenExitBubbleViews::RepositionIfVisible() {
 350   if (popup_->IsVisible())
 351     UpdateBounds();
 352 }
 353
 354 void FullscreenExitBubbleViews::UpdateMouseWatcher() {
 355   bool should_watch_mouse = false;
 356   if (popup_->IsVisible())
 357     should_watch_mouse = !fullscreen_bubble::ShowButtonsForType(bubble_type_);
 358   else
 359     should_watch_mouse = CanMouseTriggerSlideIn();
 360
 361   if (should_watch_mouse == IsWatchingMouse())
 362     return;
 363
 364   if (should_watch_mouse)
 365     StartWatchingMouse();
 366   else
 367     StopWatchingMouse();
 368 }
 369
 370 void FullscreenExitBubbleViews::UpdateForImmersiveState() {
 371   AnimatedAttribute expected_animated_attribute =
 372       browser_view_->immersive_mode_controller()->IsEnabled() ?
 373           ANIMATED_ATTRIBUTE_OPACITY : ANIMATED_ATTRIBUTE_BOUNDS;
 374   if (animated_attribute_ != expected_animated_attribute) {
 375     // If an animation is currently in progress, skip to the end because
 376     // switching the animated attribute midway through the animation looks
 377     // weird.
 378     animation_->End();
 379
 380     animated_attribute_ = expected_animated_attribute;
 381
 382     // We may have finished hiding |popup_|. However, the bounds animation
 383     // assumes |popup_| has the opacity when it is fully shown and the opacity
 384     // animation assumes |popup_| has the bounds when |popup_| is fully shown.
 385     if (animated_attribute_ == ANIMATED_ATTRIBUTE_BOUNDS)
 386       popup_->SetOpacity(255);
 387     else
 388       UpdateBounds();
 389   }
 390
 391   UpdateMouseWatcher();
 392 }
 393
 394 void FullscreenExitBubbleViews::UpdateBounds() {
 395   gfx::Rect popup_rect(GetPopupRect(false));
 396   if (!popup_rect.IsEmpty()) {
 397     popup_->SetBounds(popup_rect);
 398     view_->SetY(popup_rect.height() - view_->height());
 399   }
 400 }
 401
 402 views::View* FullscreenExitBubbleViews::GetBrowserRootView() const {
 403   return browser_view_->GetWidget()->GetRootView();
 404 }
 405
 406 void FullscreenExitBubbleViews::AnimationProgressed(
 407     const gfx::Animation* animation) {
 408   if (animated_attribute_ == ANIMATED_ATTRIBUTE_OPACITY) {
 409     int opacity = animation_->CurrentValueBetween(0, 255);
 410     if (opacity == 0) {
 411       popup_->Hide();
 412     } else {
 413       popup_->Show();
 414       popup_->SetOpacity(opacity);
 415     }
 416   } else {
 417     if (GetPopupRect(false).IsEmpty()) {
 418       popup_->Hide();
 419     } else {
 420       UpdateBounds();
 421       popup_->Show();
 422     }
 423   }
 424 }
 425
 426 void FullscreenExitBubbleViews::AnimationEnded(
 427     const gfx::Animation* animation) {
 428   AnimationProgressed(animation);
 429 }
 430
 431 gfx::Rect FullscreenExitBubbleViews::GetPopupRect(
 432     bool ignore_animation_state) const {
 433   gfx::Size size(view_->GetPreferredSize());
 434   // NOTE: don't use the bounds of the root_view_. On linux GTK changing window
 435   // size is async. Instead we use the size of the screen.
 436   gfx::Screen* screen =
 437       gfx::Screen::GetScreenFor(browser_view_->GetWidget()->GetNativeView());
 438   gfx::Rect screen_bounds = screen->GetDisplayNearestWindow(
 439       browser_view_->GetWidget()->GetNativeView()).bounds();
 440   int x = screen_bounds.x() + (screen_bounds.width() - size.width()) / 2;
 441
 442   int top_container_bottom = screen_bounds.y();
 443   if (browser_view_->immersive_mode_controller()->IsEnabled()) {
 444     // Skip querying the top container height in non-immersive fullscreen
 445     // because:
 446     // - The top container height is always zero in non-immersive fullscreen.
 447     // - Querying the top container height may return the height before entering
 448     //   fullscreen because layout is disabled while entering fullscreen.
 449     // A visual glitch due to the delayed layout is avoided in immersive
 450     // fullscreen because entering fullscreen starts with the top container
 451     // revealed. When revealed, the top container has the same height as before
 452     // entering fullscreen.
 453     top_container_bottom =
 454         browser_view_->top_container()->GetBoundsInScreen().bottom();
 455   }
 456   int y = top_container_bottom + kPopupTopPx;
 457
 458   if (!ignore_animation_state &&
 459       animated_attribute_ == ANIMATED_ATTRIBUTE_BOUNDS) {
 460     int total_height = size.height() + kPopupTopPx;
 461     int popup_bottom = animation_->CurrentValueBetween(total_height, 0);
 462     int y_offset = std::min(popup_bottom, kPopupTopPx);
 463     size.set_height(size.height() - popup_bottom + y_offset);
 464     y -= y_offset;
 465   }
 466   return gfx::Rect(gfx::Point(x, y), size);
 467 }
 468
 469 gfx::Point FullscreenExitBubbleViews::GetCursorScreenPoint() {
 470   gfx::Point cursor_pos = gfx::Screen::GetScreenFor(
 471       browser_view_->GetWidget()->GetNativeView())->GetCursorScreenPoint();
 472   views::View::ConvertPointFromScreen(GetBrowserRootView(), &cursor_pos);
 473   return cursor_pos;
 474 }
 475
 476 bool FullscreenExitBubbleViews::WindowContainsPoint(gfx::Point pos) {
 477   return GetBrowserRootView()->HitTestPoint(pos);
 478 }
 479
 480 bool FullscreenExitBubbleViews::IsWindowActive() {
 481   return browser_view_->GetWidget()->IsActive();
 482 }
 483
 484 void FullscreenExitBubbleViews::Hide() {
 485   animation_->SetSlideDuration(kSlideOutDurationMs);
 486   animation_->Hide();
 487 }
 488
 489 void FullscreenExitBubbleViews::Show() {
 490   animation_->SetSlideDuration(kSlideInDurationMs);
 491   animation_->Show();
 492 }
 493
 494 bool FullscreenExitBubbleViews::IsAnimating() {
 495   return animation_->is_animating();
 496 }
 497
 498 bool FullscreenExitBubbleViews::CanMouseTriggerSlideIn() const {
 499   return !browser_view_->immersive_mode_controller()->IsEnabled();
 500 }
 501
 502 void FullscreenExitBubbleViews::Observe(
 503     int type,
 504     const content::NotificationSource& source,
 505     const content::NotificationDetails& details) {
 506   DCHECK_EQ(chrome::NOTIFICATION_FULLSCREEN_CHANGED, type);
 507   UpdateForImmersiveState();
 508 }
 509
 510 void FullscreenExitBubbleViews::OnWidgetVisibilityChanged(
 511     views::Widget* widget,
 512     bool visible) {
 513   UpdateMouseWatcher();
 514 }