aura: brightness and volume bubble.

chrome/browser/chromeos/setting_level_bubble.cc

 // 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.
 
 #include "chrome/browser/chromeos/setting_level_bubble.h"
 
 #include <algorithm>
 
 #include "chrome/browser/chromeos/login/background_view.h"
 #include "chrome/browser/chromeos/login/login_utils.h"
 #include "chrome/browser/chromeos/login/webui_login_display.h"
 #include "chrome/browser/chromeos/setting_level_bubble_view.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/browser_window.h"
-#include "chrome/browser/ui/views/bubble/bubble.h"
 #include "ui/gfx/screen.h"
+#include "views/bubble/bubble_delegate.h"
+#include "views/bubble/bubble_view.h"
+#include "views/layout/fill_layout.h"
 #include "views/widget/root_view.h"
 
 using base::TimeDelta;
 using base::TimeTicks;
 using std::max;
 using std::min;
 
 namespace {
 
 // How long should the bubble be shown onscreen whenever the setting changes?
@@ skipping 23 matching lines @@
 namespace chromeos {
 
 // Temporary helper routine. Tries to first return the widget from the
 // most-recently-focused normal browser window, then from a login
 // background, and finally NULL if both of those fail.
 // TODO(glotov): remove this in favor of enabling Bubble class act
 // without |parent| specified. crosbug.com/4025
 static views::Widget* GetToplevelWidget() {
 #if defined(USE_AURA)
   // TODO(saintlou): Need to fix in PureViews.
+  // Is this the same as using parent->GetRootView()?

[Daniel Erat, 2011/10/19 17:28:09]

yeah, i think that the root view is what we want here.

[alicet1, 2011/10/20 15:03:08]

saintlou uploaded a fix to this code. let me know if there is anything else for
this method we need for aura.

   return WebUILoginDisplay::GetLoginWindow();
 #else
   GtkWindow* window = NULL;
 
   // We just use the default profile here -- this gets overridden as needed
   // in Chrome OS depending on whether the user is logged in or not.
   Browser* browser =
       BrowserList::FindTabbedBrowser(
           ProfileManager::GetDefaultProfile(),
           true);  // match_incognito
   if (browser) {
     window = GTK_WINDOW(browser->window()->GetNativeHandle());
   } else {
     // Otherwise, see if there's a background window that we can use.
     BackgroundView* background = LoginUtils::Get()->GetBackgroundView();
     if (background)
       window = GTK_WINDOW(background->GetNativeWindow());
   }
 
   if (window)
     return views::Widget::GetWidgetForNativeWindow(window);
   else
     return WebUILoginDisplay::GetLoginWindow();
 #endif
 }
 
+// static
+views::Widget* SettingLevelBubble::ConstructSettingLevelBubble(
+    SkBitmap* increase_icon,
+    SkBitmap* decrease_icon,
+    SkBitmap* zero_icon,
+    double percent,
+    bool enabled) {
+  views::Widget* parent = GetToplevelWidget();
+  SettingLevelBubble* delegate =
+      new SettingLevelBubble(increase_icon, decrease_icon, zero_icon);
+  delegate->UpdateSettingLevelInternal(percent, enabled);
+  // Construct and initialize settings.
+  views::Widget* widget = views::BubbleDelegateView::CreateBubble(
+      delegate, parent);
+  widget->client_view()->AsBubbleView()->set_close_on_esc(false);
+  return widget;
+}
+
 SettingLevelBubble::SettingLevelBubble(SkBitmap* increase_icon,
                                        SkBitmap* decrease_icon,
                                        SkBitmap* disabled_icon)
     : current_percent_(-1.0),
       target_percent_(-1.0),
       increase_icon_(increase_icon),
       decrease_icon_(decrease_icon),
       disabled_icon_(disabled_icon),
-      bubble_(NULL),
+      current_icon_(NULL),
       view_(NULL),
       is_animating_(false) {
 }
 
-SettingLevelBubble::~SettingLevelBubble() {}
+SettingLevelBubble::~SettingLevelBubble() {
+  WindowClosing();
+}
 
-void SettingLevelBubble::ShowBubble(double percent, bool enabled) {
+void SettingLevelBubble::StartHideTimer() {
+  hide_timer_.Stop();
+    hide_timer_.Start(FROM_HERE,
+                      base::TimeDelta::FromMilliseconds(kBubbleShowTimeoutMs),
+                      this, &SettingLevelBubble::OnHideTimeout);
+}
+
+void SettingLevelBubble::Init() {
+  SetLayoutManager(new views::FillLayout());
+  view_ = new SettingLevelBubbleView();
+
+  view_->Init(current_icon_, current_percent_, enabled_);
+  CalculateAnchorPoint();
+  AddChildView(view_);
+}
+
+gfx::Point SettingLevelBubble::GetAnchorPoint() const {
+  return anchor_point_;
+}
+
+void SettingLevelBubble::UpdateSettingLevelInternal(double percent,
+                                                    bool enabled) {
+  enabled_ = enabled;
   const double old_target_percent = target_percent_;
   UpdateTargetPercent(percent);
-
-  SkBitmap* icon = increase_icon_;
+  current_icon_ = increase_icon_;
   if (!enabled || target_percent_ == 0)
-    icon = disabled_icon_;
+    current_icon_ = disabled_icon_;
   else if (old_target_percent >= 0 && target_percent_ < old_target_percent)
-    icon = decrease_icon_;
-
-  if (!bubble_) {
-    views::Widget* parent_widget = GetToplevelWidget();
-    if (parent_widget == NULL) {
-      LOG(WARNING) << "Unable to locate parent widget to display a bubble";
-      return;
-    }
-    DCHECK(view_ == NULL);
-    view_ = new SettingLevelBubbleView;
-    view_->Init(icon, current_percent_, enabled);
-
-    // Calculate the position in screen coordinates that the bubble should
-    // "point" at (since we use BubbleBorder::FLOAT, this position actually
-    // specifies the center of the bubble).
-    const gfx::Rect monitor_area =
-        gfx::Screen::GetMonitorAreaNearestWindow(
-            parent_widget->GetNativeView());
-    const gfx::Size view_size = view_->GetPreferredSize();
-    const gfx::Rect position_relative_to(
-        monitor_area.x() + kBubbleXRatio * monitor_area.width(),
-        monitor_area.bottom() - view_size.height() / 2 - kBubbleBottomGap,
-        0, 0);
-
-    bubble_ = Bubble::ShowFocusless(parent_widget,
-                                    position_relative_to,
-                                    views::BubbleBorder::FLOAT,
-                                    view_,  // contents
-                                    this,   // delegate
-                                    true);  // show while screen is locked
-    // TODO(derat): We probably shouldn't be using Bubble.  It'd be nice to call
-    // bubble_->set_fade_away_on_close(true) here, but then, if ShowBubble()
-    // gets called while the bubble is fading away, we end up just adjusting the
-    // value on the disappearing bubble; ideally we'd have a way to cancel the
-    // fade and show the bubble at full opacity for another
-    // kBubbleShowTimeoutMs.
-  } else {
-    DCHECK(view_);
-    hide_timer_.Stop();
-    view_->SetIcon(icon);
-    view_->SetEnabled(enabled);
-  }
-
-  hide_timer_.Start(FROM_HERE,
-                    base::TimeDelta::FromMilliseconds(kBubbleShowTimeoutMs),
-                    this, &SettingLevelBubble::OnHideTimeout);
+    current_icon_ = decrease_icon_;
 }
 
-void SettingLevelBubble::HideBubble() {
-  if (bubble_)
-    bubble_->Close();
+views::BubbleBorder::ArrowLocation
+SettingLevelBubble::GetArrowLocation() const {
+  return views::BubbleBorder::FLOAT;
+}
+
+void SettingLevelBubble::WindowClosing() {
+  hide_timer_.Stop();
+  StopAnimation();
+  view_ = NULL;
+  current_percent_ = target_percent_;
+  target_time_ = TimeTicks();
+  last_animation_update_time_ = TimeTicks();
+  last_target_update_time_ = TimeTicks();
 }
 
 void SettingLevelBubble::UpdateWithoutShowingBubble(double percent,
                                                     bool enabled) {
   UpdateTargetPercent(percent);
   if (view_)
     view_->SetEnabled(enabled);
 }
 
+void SettingLevelBubble::CalculateAnchorPoint() {
+  // Calculate the position in screen coordinates that the bubble should
+  // "point" at (since we use BubbleBorder::FLOAT, this position actually
+  // specifies the center of the bubble).
+  const gfx::Rect monitor_area =
+      gfx::Screen::GetMonitorAreaNearestWindow(
+          GetWidget()->GetTopLevelWidget()->GetNativeView());
+  gfx::Size view_size = GetPreferredSize();
+  anchor_point_ = gfx::Point(
+      monitor_area.x() + kBubbleXRatio * monitor_area.width(),
+      monitor_area.bottom() - view_size.height() / 2 - kBubbleBottomGap);
+}
+
 void SettingLevelBubble::OnHideTimeout() {
-  HideBubble();
+  GetWidget()->Close();
 }
 
 void SettingLevelBubble::OnAnimationTimeout() {
   const TimeTicks now = TimeTicks::Now();
   const int64 remaining_ms = (target_time_ - now).InMilliseconds();
 
   if (remaining_ms <= 0) {
     current_percent_ = target_percent_;
     StopAnimation();
   } else {
     // Figure out what fraction of the total time until we want to reach the
     // target has elapsed since the last update.
     const double remaining_percent = target_percent_ - current_percent_;
     const int64 elapsed_ms =
         (now - last_animation_update_time_).InMilliseconds();
     current_percent_ +=
         remaining_percent *
         (static_cast<double>(elapsed_ms) / (elapsed_ms + remaining_ms));
   }
   last_animation_update_time_ = now;
 
   if (view_)
     view_->SetLevel(current_percent_);
 }
 
-void SettingLevelBubble::BubbleClosing(Bubble* bubble, bool) {
-  DCHECK(bubble == bubble_);
-  hide_timer_.Stop();
-  StopAnimation();
-  bubble_ = NULL;
-  view_ = NULL;
-  current_percent_ = target_percent_;
-  target_time_ = TimeTicks();
-  last_animation_update_time_ = TimeTicks();
-  last_target_update_time_ = TimeTicks();
-}
-
-bool SettingLevelBubble::CloseOnEscape() {
-  return true;
-}
-
-bool SettingLevelBubble::FadeInOnShow() {
-  return false;
-}
-
 void SettingLevelBubble::UpdateTargetPercent(double percent) {
   target_percent_ = LimitPercent(percent);
   const TimeTicks now = TimeTicks::Now();
 
   if (current_percent_ < 0.0) {
     // If we're setting the level for the first time, no need to animate.
     current_percent_ = target_percent_;
     if (view_)
       view_->SetLevel(current_percent_);
   } else {
@@ skipping 19 matching lines @@
 
   last_target_update_time_ = now;
 }
 
 void SettingLevelBubble::StopAnimation() {
   animation_timer_.Stop();
   is_animating_ = false;
 }
 
 }  // namespace chromeos