Adds a hide button to the desktop capture notification bar.

chrome/browser/ui/views/screen_capture_notification_ui_views.cc

 // Copyright 2013 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.
 
 #include "chrome/browser/ui/screen_capture_notification_ui.h"
 
 #include "ash/shell.h"
 #include "chrome/app/chrome_dll_resource.h"
 #include "chrome/browser/ui/views/chrome_views_export.h"
 #include "grit/generated_resources.h"
 #include "grit/theme_resources.h"
 #include "ui/aura/window_event_dispatcher.h"
 #include "ui/base/hit_test.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/views/bubble/bubble_border.h"
 #include "ui/views/bubble/bubble_frame_view.h"
 #include "ui/views/controls/button/blue_button.h"
 #include "ui/views/controls/image_view.h"
+#include "ui/views/controls/link.h"
+#include "ui/views/controls/link_listener.h"
 #include "ui/views/corewm/shadow_types.h"
 #include "ui/views/layout/box_layout.h"
 #include "ui/views/view.h"
 #include "ui/views/widget/widget.h"
 #include "ui/views/widget/widget_delegate.h"
 
 namespace {
 
 const int kMinimumWidth = 460;
 const int kMaximumWidth = 1000;
@@ skipping 34 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(NotificationBarClientView);
 };
 
 }  // namespace
 
 // ScreenCaptureNotificationUI implementation using Views.
 class ScreenCaptureNotificationUIViews
     : public ScreenCaptureNotificationUI,
       public views::WidgetDelegateView,
-      public views::ButtonListener {
+      public views::ButtonListener,
+      public views::LinkListener {
  public:
   explicit ScreenCaptureNotificationUIViews(const base::string16& text);
   virtual ~ScreenCaptureNotificationUIViews();
 
   // ScreenCaptureNotificationUI interface.
   virtual void OnStarted(const base::Closure& stop_callback) OVERRIDE;
 
   // views::View overrides.
   virtual gfx::Size GetPreferredSize() OVERRIDE;
   virtual void Layout() OVERRIDE;
 
   // views::WidgetDelegateView overrides.
   virtual void DeleteDelegate() OVERRIDE;
   virtual views::View* GetContentsView() OVERRIDE;
   virtual views::ClientView* CreateClientView(views::Widget* widget) OVERRIDE;
   virtual views::NonClientFrameView* CreateNonClientFrameView(
       views::Widget* widget) OVERRIDE;
   virtual base::string16 GetWindowTitle() const OVERRIDE;
   virtual bool ShouldShowWindowTitle() const OVERRIDE;
   virtual bool ShouldShowCloseButton() const OVERRIDE;
+  virtual bool CanActivate() const OVERRIDE;
 
   // views::ButtonListener interface.
   virtual void ButtonPressed(views::Button* sender,
                              const ui::Event& event) OVERRIDE;
 
+  // views::LinkListener interface.
+  virtual void LinkClicked(views::Link* source, int event_flags) OVERRIDE;
+
  private:
   // Helper to call |stop_callback_|.
   void NotifyStopped();
 
   const base::string16 text_;
   base::Closure stop_callback_;
   NotificationBarClientView* client_view_;
   views::ImageView* gripper_;
   views::Label* label_;
   views::BlueButton* stop_button_;
+  views::Link* hide_link_;
 
   DISALLOW_COPY_AND_ASSIGN(ScreenCaptureNotificationUIViews);
 };
 
 ScreenCaptureNotificationUIViews::ScreenCaptureNotificationUIViews(
     const base::string16& text)
     : text_(text),
       client_view_(NULL),
       gripper_(NULL),
       label_(NULL),
-      stop_button_(NULL) {
+      stop_button_(NULL),
+      hide_link_(NULL) {
   set_owned_by_client();
 
   set_background(views::Background::CreateSolidBackground(GetNativeTheme()->
       GetSystemColor(ui::NativeTheme::kColorId_DialogBackground)));
 
   gripper_ = new views::ImageView();
   gripper_->SetImage(
       ui::ResourceBundle::GetSharedInstance().GetImageSkiaNamed(
           IDR_SCREEN_CAPTURE_NOTIFICATION_GRIP));
   AddChildView(gripper_);
 
   label_ = new views::Label();
   AddChildView(label_);
 
   base::string16 stop_text =
       l10n_util::GetStringUTF16(IDS_MEDIA_SCREEN_CAPTURE_NOTIFICATION_STOP);
   stop_button_ = new views::BlueButton(this, stop_text);
   AddChildView(stop_button_);
+
+  hide_link_ = new views::Link(
+      l10n_util::GetStringUTF16(IDS_PASSWORDS_PAGE_VIEW_HIDE_BUTTON));

[msw, 2014/03/12 19:37:25]

nit: Add a TODO here to fix this up soon. I hope the translation for hiding a
password and hiding (minimizing) a window are close enough.

+  hide_link_->set_listener(this);
+  AddChildView(hide_link_);
 }
 
 ScreenCaptureNotificationUIViews::~ScreenCaptureNotificationUIViews() {
   stop_callback_.Reset();
   delete GetWidget();
 }
 
 void ScreenCaptureNotificationUIViews::OnStarted(
     const base::Closure& stop_callback) {
   stop_callback_ = stop_callback;
 
   label_->SetElideBehavior(views::Label::ELIDE_IN_MIDDLE);
   label_->SetHorizontalAlignment(gfx::ALIGN_LEFT);
   label_->SetText(text_);
 
   views::Widget* widget = new views::Widget;
 
   views::Widget::InitParams params;
   params.delegate = this;
   params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
   params.opacity = views::Widget::InitParams::TRANSLUCENT_WINDOW;
   params.remove_standard_frame = true;
   params.keep_on_top = true;
   params.top_level = true;
-  params.can_activate = false;
+  // Make sure can_activate is true so the window icon will show in the taskbar.
+  params.can_activate = true;
 
 #if defined(USE_ASH)
   // TODO(sergeyu): The notification bar must be shown on the monitor that's
   // being captured. Make sure it's always the case. Currently we always capture
   // the primary monitor.
   if (ash::Shell::HasInstance())
     params.context = ash::Shell::GetPrimaryRootWindow();
 #endif
 
   widget->set_frame_type(views::Widget::FRAME_TYPE_FORCE_CUSTOM);
@@ skipping 11 matching lines @@
       work_area.x() + work_area.width() / 2 - size.width() / 2,
       work_area.y() + work_area.height() - size.height(),
       size.width(), size.height());
   widget->SetBounds(bounds);
 
   widget->Show();
 }
 
 gfx::Size ScreenCaptureNotificationUIViews::GetPreferredSize() {
   gfx::Size grip_size = gripper_->GetPreferredSize();
-  gfx::Size label_size = child_at(1)->GetPreferredSize();
-  gfx::Size button_size = child_at(2)->GetPreferredSize();
-  int width = kHorizontalMargin * 2 + grip_size.width() + label_size.width() +
-      button_size.width();
+  gfx::Size label_size = label_->GetPreferredSize();
+  gfx::Size stop_button_size = stop_button_->GetPreferredSize();
+  gfx::Size hide_link_size = hide_link_->GetPreferredSize();
+  int width = kHorizontalMargin * 3 + grip_size.width() + label_size.width() +
+      stop_button_size.width() + hide_link_size.width();
   width = std::max(width, kMinimumWidth);
   width = std::min(width, kMaximumWidth);
-  return gfx::Size(width, std::max(label_size.height(), button_size.height()));
+  return gfx::Size(width, std::max(label_size.height(),
+                                   std::max(hide_link_size.height(),
+                                            stop_button_size.height())));
 }
 
 void ScreenCaptureNotificationUIViews::Layout() {
   gfx::Rect grip_rect(gripper_->GetPreferredSize());
-  grip_rect.set_y(bounds().height() / 2 - grip_rect.height() / 2);
+  grip_rect.set_y((bounds().height() - grip_rect.height()) / 2);
   gripper_->SetBoundsRect(grip_rect);
 
-  gfx::Rect button_rect(stop_button_->GetPreferredSize());
-  button_rect.set_x(bounds().width() - button_rect.width());
-  stop_button_->SetBoundsRect(button_rect);
+  gfx::Rect stop_button_rect(stop_button_->GetPreferredSize());
+  gfx::Rect hide_link_rect(hide_link_->GetPreferredSize());
+
+  hide_link_rect.set_x(bounds().width() - hide_link_rect.width());
+  hide_link_rect.set_y((bounds().height() - hide_link_rect.height()) / 2);
+  hide_link_->SetBoundsRect(hide_link_rect);
+
+  stop_button_rect.set_x(
+      hide_link_rect.x() - kHorizontalMargin - stop_button_rect.width());
+  stop_button_->SetBoundsRect(stop_button_rect);
 
   gfx::Rect label_rect;
   label_rect.set_x(grip_rect.right() + kHorizontalMargin);
-  label_rect.set_width(button_rect.x() - kHorizontalMargin - label_rect.x());
+  label_rect.set_width(
+      stop_button_rect.x() - kHorizontalMargin - label_rect.x());
   label_rect.set_height(bounds().height());
   label_->SetBoundsRect(label_rect);
 
-  client_view_->SetClientRect(button_rect);
+  client_view_->SetClientRect(gfx::Rect(
+      stop_button_rect.x(), stop_button_rect.y(),
+      stop_button_rect.width() + kHorizontalMargin + hide_link_rect.width(),
+      std::max(stop_button_rect.height(), hide_link_rect.height())));
 }
 
 void ScreenCaptureNotificationUIViews::DeleteDelegate() {
   NotifyStopped();
 }
 
 views::View* ScreenCaptureNotificationUIViews::GetContentsView() {
   return this;
 }
 
@@ skipping 23 matching lines @@
 }
 
 bool ScreenCaptureNotificationUIViews::ShouldShowWindowTitle() const {
   return false;
 }
 
 bool ScreenCaptureNotificationUIViews::ShouldShowCloseButton() const {
   return false;
 }
 
+bool ScreenCaptureNotificationUIViews::CanActivate() const {
+  // If we do not override this method, the window sometimes does not properly
+  // restore to its normal size on Windows.
+  return false;
+}
+
 void ScreenCaptureNotificationUIViews::ButtonPressed(views::Button* sender,
                                                      const ui::Event& event) {
   NotifyStopped();
 }
 
+void ScreenCaptureNotificationUIViews::LinkClicked(views::Link* source,
+                                                   int event_flags) {
+  GetWidget()->Minimize();
+}
+
 void ScreenCaptureNotificationUIViews::NotifyStopped() {
   if (!stop_callback_.is_null()) {
     base::Closure callback = stop_callback_;
     stop_callback_.Reset();
     callback.Run();
   }
 }
 
 }  // namespace
 
 scoped_ptr<ScreenCaptureNotificationUI> ScreenCaptureNotificationUI::Create(
     const base::string16& text) {
   return scoped_ptr<ScreenCaptureNotificationUI>(
       new ScreenCaptureNotificationUIViews(text));
 }