Implement a callout widget for the active panel.

ash/wm/panel_layout_manager.cc

 // Copyright (c) 2012 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 "ash/wm/panel_layout_manager.h"
 
 #include <algorithm>
 
 #include "ash/launcher/launcher.h"
 #include "ash/shell.h"
+#include "ash/wm/frame_painter.h"
 #include "ash/wm/property_util.h"
 #include "base/auto_reset.h"
+#include "base/bind.h"
+#include "base/bind_helpers.h"
+#include "third_party/skia/include/core/SkColor.h"
+#include "third_party/skia/include/core/SkPaint.h"
+#include "third_party/skia/include/core/SkPath.h"
 #include "ui/aura/client/activation_client.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/root_window.h"
 #include "ui/aura/window.h"
+#include "ui/gfx/canvas.h"
 #include "ui/gfx/rect.h"
-#include "ui/gfx/size.h"
+#include "ui/views/background.h"
 #include "ui/views/widget/widget.h"
 
+namespace ash {
+namespace internal {
+
 namespace {
 const int kPanelMarginEdge = 4;
 const int kPanelMarginMiddle = 8;
 
 const int kMinimizedHeight = 24;
 
 const float kMaxHeightFactor = .80f;
 const float kMaxWidthFactor = .50f;
-}
 
-namespace ash {
-namespace internal {
+// Callout arrow dimensions.
+const int kArrowWidth = 20;
+const int kArrowHeight = 10;
+
+class CalloutWidgetBackground : public views::Background {
+ public:
+  CalloutWidgetBackground() {}
+  virtual void Paint(gfx::Canvas* canvas, views::View* view) const OVERRIDE {
+    SkPath path;
+    // TODO(dcheng): Verify if this results in off by one errors.
+    path.moveTo(SkIntToScalar(0), SkIntToScalar(0));
+    path.lineTo(SkIntToScalar(kArrowWidth / 2), SkIntToScalar(kArrowHeight));
+    path.lineTo(SkIntToScalar(kArrowWidth), SkIntToScalar(0));
+
+    // Use the same opacity and colors as the header for now.
+    SkPaint paint;
+    paint.setStyle(SkPaint::kFill_Style);
+    paint.setColor(
+        SkColorSetARGB(FramePainter::kActiveWindowOpacity, 189, 189, 189));
+    canvas->DrawPath(path, paint);
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(CalloutWidgetBackground);
+};
+
+}  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 // PanelLayoutManager public implementation:
 PanelLayoutManager::PanelLayoutManager(aura::Window* panel_container)
     : panel_container_(panel_container),
       in_layout_(false),
       dragged_panel_(NULL),
       launcher_(NULL),
-      last_active_panel_(NULL) {
+      last_active_panel_(NULL),
+      callout_widget_(new views::Widget),
+      weak_factory_(this) {
   DCHECK(panel_container);
+  views::Widget::InitParams params;
+  params.type = views::Widget::InitParams::TYPE_POPUP;
+  params.transparent = true;
+  params.can_activate = false;
+  params.keep_on_top = true;
+  params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
+  params.parent = panel_container_;
+  params.bounds.set_width(kArrowWidth);
+  params.bounds.set_height(kArrowHeight);
+  // Why do we need this and can_activate = false?
+  callout_widget_->set_focus_on_creation(false);
+  callout_widget_->Init(params);
+  views::View* content_view = new views::View;
+  content_view->set_background(new CalloutWidgetBackground);
+  callout_widget_->SetContentsView(content_view);
   Shell::GetRootWindow()->AddObserver(this);
 }
 
 PanelLayoutManager::~PanelLayoutManager() {
   if (launcher_)
     launcher_->RemoveIconObserver(this);
   Shell::GetRootWindow()->RemoveObserver(this);
 }
 
 void PanelLayoutManager::StartDragging(aura::Window* panel) {
@@ skipping 41 matching lines @@
   Relayout();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // PanelLayoutManager, aura::LayoutManager implementation:
 void PanelLayoutManager::OnWindowResized() {
   Relayout();
 }
 
 void PanelLayoutManager::OnWindowAddedToLayout(aura::Window* child) {
+  if (child == callout_widget_->GetNativeWindow())
+    return;
   panel_windows_.push_back(child);
   Relayout();
 }
 
 void PanelLayoutManager::OnWillRemoveWindowFromLayout(aura::Window* child) {
   PanelList::iterator found =
       std::find(panel_windows_.begin(), panel_windows_.end(), child);
   if (found != panel_windows_.end())
     panel_windows_.erase(found);
 
@@ skipping 54 matching lines @@
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // PanelLayoutManager, aura::WindowObserver implementation:
 void PanelLayoutManager::OnWindowPropertyChanged(aura::Window* window,
                                                  const void* key,
                                                  intptr_t old) {
   if (key == aura::client::kRootWindowActiveWindowKey) {
     aura::Window* active = window->GetProperty(
         aura::client::kRootWindowActiveWindowKey);
-    if (active && active->type() == aura::client::WINDOW_TYPE_PANEL)
+    if (active && active->type() == aura::client::WINDOW_TYPE_PANEL) {
       UpdateStacking(active);
+      UpdateCallout(active);
+    } else {
+      UpdateCallout(NULL);
+    }
   }
 }
 
 
 ////////////////////////////////////////////////////////////////////////////////
 // PanelLayoutManager private implementation:
 void PanelLayoutManager::Relayout() {
   if (in_layout_)
     return;
   AutoReset<bool> auto_reset_in_layout(&in_layout_, true);
 
+  int launcher_top = launcher_->widget()->GetWindowScreenBounds().y();
   aura::Window* active_panel = NULL;
   for (PanelList::iterator iter = panel_windows_.begin();
        iter != panel_windows_.end(); ++iter) {
     aura::Window* panel = *iter;
     if (!panel->IsVisible() || panel == dragged_panel_)
       continue;
 
     gfx::Rect icon_bounds =
         launcher_->GetScreenBoundsOfItemIconForWindow(panel);
 
@@ skipping 10 matching lines @@
     }
 
     gfx::Point icon_origin = icon_bounds.origin();
     aura::Window::ConvertPointToWindow(panel_container_->GetRootWindow(),
                                        panel_container_, &icon_origin);
 
     // TODO(dcheng): Need to clamp to screen edges.
     gfx::Rect bounds = panel->bounds();
     bounds.set_x(
         icon_origin.x() + icon_bounds.width() / 2 - bounds.width() / 2);
-    bounds.set_y(icon_origin.y() - bounds.height());
+    bounds.set_y(launcher_top - bounds.height());
     SetChildBoundsDirect(panel, bounds);
   }
 
   UpdateStacking(active_panel);
+  UpdateCallout(active_panel);
 }
 
 void PanelLayoutManager::UpdateStacking(aura::Window* active_panel) {
   if (!active_panel) {
     if (!last_active_panel_)
       return;
     active_panel = last_active_panel_;
   }
 
   // We want to to stack the panels like a deck of cards:
@@ skipping 28 matching lines @@
        it != window_ordering.rend() && it->second != active_panel; ++it) {
     if (previous_panel)
       panel_container_->StackChildAbove(it->second, previous_panel);
     previous_panel = it->second;
   }
 
   panel_container_->StackChildAtTop(active_panel);
   last_active_panel_ = active_panel;
 }
 
+void PanelLayoutManager::UpdateCallout(aura::Window* active_panel) {
+  weak_factory_.InvalidateWeakPtrs();
+  // TODO(dcheng): This doesn't account for panels in overflow. They should have
+  // a callout as well.
+  if (!active_panel ||
+      launcher_->GetScreenBoundsOfItemIconForWindow(active_panel).IsEmpty()) {
+    callout_widget_->Hide();
+    return;
+  }
+  MessageLoop::current()->PostTask(
+      FROM_HERE,
+      base::Bind(&PanelLayoutManager::ShowCalloutHelper,
+                 weak_factory_.GetWeakPtr(),
+                 active_panel));
+}
+
+void PanelLayoutManager::ShowCalloutHelper(aura::Window* active_panel) {
+  DCHECK(active_panel);
+  gfx::Rect bounds = active_panel->GetBoundsInRootWindow();
+  gfx::Rect callout_bounds = callout_widget_->GetWindowScreenBounds();
+  callout_bounds.set_x(
+      bounds.x() + (bounds.width() - callout_bounds.width()) / 2);
+  callout_bounds.set_y(bounds.bottom());
+  SetChildBoundsDirect(callout_widget_->GetNativeWindow(), callout_bounds);
+  panel_container_->StackChildAtTop(callout_widget_->GetNativeWindow());
+  callout_widget_->Show();
+}
+
 }  // namespace internal
 }  // namespace ash