Some launcher tweaks:

. Creates a model for the launcher.
. Makes the launcher support laying out and calculating a preferred
  size.
. Adds a ShellDelegate class that is used for interesting things.

BUG=97262
TEST=none
R=ben@chromium.org

Review URL: http://codereview.chromium.org/8220030

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@104943 0039d316-1c4b-4281-b951-d872f2087c98

6 files changed, 337 insertions, 22 deletions

diff --git a/ui/aura_shell/launcher/launcher_model.cc b/ui/aura_shell/launcher/launcher_model.cc
new file mode 100644
index 0000000..58ab9d3
--- /dev/null
+++ b/ui/aura_shell/launcher/launcher_model.cc
@@ -0,0 +1,71 @@
+// 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 "ui/aura_shell/launcher/launcher_model.h"
+
+#include "ui/aura_shell/launcher/launcher_model_observer.h"
+#include "views/view.h"
+
+namespace aura_shell {
+
+LauncherModel::LauncherModel() : selected_index_(-1) {
+}
+
+LauncherModel::~LauncherModel() {
+  for (Items::iterator i = items_.begin(); i != items_.end(); ++i) {
+    delete i->view;
+    i->view = NULL;
+  }
+}
+
+void LauncherModel::AddItem(views::View* view, int index, bool draggable) {
+  DCHECK(index >= 0 && index <= item_count());
+  Item item;
+  item.view = view;
+  item.draggable = draggable;
+  items_.insert(items_.begin() + index, item);
+  FOR_EACH_OBSERVER(LauncherModelObserver, observers_,
+                    LauncherItemAdded(index));
+}
+
+void LauncherModel::RemoveItem(views::View* view) {
+  int index = IndexOfItemByView(view);
+  if (index != -1)
+    RemoveItemAt(index);
+}
+
+void LauncherModel::RemoveItemAt(int index) {
+  DCHECK(index >= 0 && index < item_count());
+  items_.erase(items_.begin() + index);
+  FOR_EACH_OBSERVER(LauncherModelObserver, observers_,
+                    LauncherItemRemoved(index));
+}
+
+void LauncherModel::SetSelectedIndex(int index) {
+  if (index == selected_index_)
+    return;
+  DCHECK(selected_index_ == -1 ||
+         (selected_index_ >= 0 && selected_index_ < item_count()));
+  selected_index_ = index;
+  FOR_EACH_OBSERVER(LauncherModelObserver, observers_,
+                    LauncherSelectionChanged());
+}
+
+int LauncherModel::IndexOfItemByView(views::View* view) {
+  for (Items::const_iterator i = items_.begin(); i != items_.end(); ++i) {
+    if (i->view == view)
+      return i - items_.begin();
+  }
+  return -1;
+}
+
+void LauncherModel::AddObserver(LauncherModelObserver* observer) {
+  observers_.AddObserver(observer);
+}
+
+void LauncherModel::RemoveObserver(LauncherModelObserver* observer) {
+  observers_.RemoveObserver(observer);
+}
+
+}  // namespace aura_shell
diff --git a/ui/aura_shell/launcher/launcher_model.h b/ui/aura_shell/launcher/launcher_model.h
new file mode 100644
index 0000000..9aac41c
--- /dev/null
+++ b/ui/aura_shell/launcher/launcher_model.h
@@ -0,0 +1,69 @@
+// 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.
+
+#ifndef UI_AURA_SHELL_LAUNCHER_MODEL_H_
+#define UI_AURA_SHELL_LAUNCHER_MODEL_H_
+#pragma once
+
+#include <vector>
+
+#include "base/observer_list.h"
+#include "ui/aura_shell/aura_shell_export.h"
+
+namespace views {
+class View;
+}
+
+namespace aura_shell {
+
+class LauncherModelObserver;
+
+// Model used by LauncherView.
+class AURA_SHELL_EXPORT LauncherModel {
+ public:
+  LauncherModel();
+  ~LauncherModel();
+
+  // Adds a new view to the model. The model takes ownership of the view.
+  void AddItem(views::View* view, int index, bool draggable);
+
+  // Removes an item by the view.
+  void RemoveItem(views::View* view);
+
+  // Removes the item at |index|.
+  void RemoveItemAt(int index);
+
+  // The selected index; -1 if nothing is selected.
+  void SetSelectedIndex(int index);
+  int selected_index() const { return selected_index_; }
+
+  // Returns the index of |view|, or -1 if view isn't contained in this model.
+  int IndexOfItemByView(views::View* view);
+  int item_count() const { return static_cast<int>(items_.size()); }
+  views::View* view_at(int index) { return items_[index].view; }
+  bool is_draggable(int index) { return items_[index].draggable; }
+
+  void AddObserver(LauncherModelObserver* observer);
+  void RemoveObserver(LauncherModelObserver* observer);
+
+ private:
+  struct Item {
+    Item() : view(NULL), draggable(false) {}
+
+    // The view, we own this.
+    views::View* view;
+    bool draggable;
+  };
+  typedef std::vector<Item> Items;
+
+  Items items_;
+  int selected_index_;
+  ObserverList<LauncherModelObserver> observers_;
+
+  DISALLOW_COPY_AND_ASSIGN(LauncherModel);
+};
+
+}  // namespace aura_shell
+
+#endif  // UI_AURA_SHELL_LAUNCHER_MODEL_H_
diff --git a/ui/aura_shell/launcher/launcher_model_observer.h b/ui/aura_shell/launcher/launcher_model_observer.h
new file mode 100644
index 0000000..779262b
--- /dev/null
+++ b/ui/aura_shell/launcher/launcher_model_observer.h
@@ -0,0 +1,31 @@
+// 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.
+
+#ifndef UI_AURA_SHELL_LAUNCHER_MODEL_OBSERVER_H_
+#define UI_AURA_SHELL_LAUNCHER_MODEL_OBSERVER_H_
+#pragma once
+
+#include "ui/aura_shell/aura_shell_export.h"
+
+namespace aura_shell {
+
+class AURA_SHELL_EXPORT LauncherModelObserver {
+ public:
+  // Invoked after an item has been added to the model.
+  virtual void LauncherItemAdded(int index) = 0;
+
+  // Invoked after an item has been removed. |index| is the index the item was
+  // at.
+  virtual void LauncherItemRemoved(int index) = 0;
+
+  // Invoked when the selection changes.
+  virtual void LauncherSelectionChanged() = 0;
+
+ protected:
+  ~LauncherModelObserver() {}
+};
+
+}  // namespace aura_shell
+
+#endif  // UI_AURA_SHELL_LAUNCHER_MODEL_OBSERVER_H_
diff --git a/ui/aura_shell/launcher/launcher_model_unittest.cc b/ui/aura_shell/launcher/launcher_model_unittest.cc
new file mode 100644
index 0000000..c55decc
--- /dev/null
+++ b/ui/aura_shell/launcher/launcher_model_unittest.cc
@@ -0,0 +1,87 @@
+// 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 "ui/aura_shell/launcher/launcher_model.h"
+
+#include "base/stringprintf.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "ui/aura_shell/launcher/launcher_model_observer.h"
+#include "views/view.h"
+
+using views::View;
+
+namespace aura_shell {
+
+namespace {
+
+// LauncherModelObserver implementation that tracks what message are invoked.
+class TestLauncherModelObserver : public LauncherModelObserver {
+ public:
+  TestLauncherModelObserver()
+      : added_count_(0),
+        removed_count_(0),
+        selection_changed_count_(0) {
+  }
+
+  // Returns a string description of the changes that have occurred since this
+  // was last invoked. Resets state to initial state.
+  std::string StateStringAndClear() {
+    std::string result(base::StringPrintf("added=%d removed=%d s_changed=%d",
+        added_count_, removed_count_, selection_changed_count_));
+    added_count_ = removed_count_ = selection_changed_count_ = 0;
+    return result;
+  }
+
+  // LauncherModelObserver overrides:
+  virtual void LauncherItemAdded(int index) OVERRIDE {
+    added_count_++;
+  }
+  virtual void LauncherItemRemoved(int index) OVERRIDE {
+    removed_count_++;
+  }
+  virtual void LauncherSelectionChanged() OVERRIDE {
+    selection_changed_count_++;
+  }
+
+  private:
+  int added_count_;
+  int removed_count_;
+  int selection_changed_count_;
+
+  DISALLOW_COPY_AND_ASSIGN(TestLauncherModelObserver);
+};
+
+}  // namespace
+
+TEST(TestLauncher, BasicAssertions) {
+  TestLauncherModelObserver observer;
+  LauncherModel model;
+  // Add an item.
+  model.AddObserver(&observer);
+  EXPECT_EQ(-1, model.selected_index());
+  View* view = new View;
+  model.AddItem(view, 0, true);
+  EXPECT_EQ(1, model.item_count());
+  EXPECT_EQ(view, model.view_at(0));
+  EXPECT_EQ(true, model.is_draggable(0));
+  EXPECT_EQ(-1, model.selected_index());
+  EXPECT_EQ("added=1 removed=0 s_changed=0", observer.StateStringAndClear());
+
+  EXPECT_EQ(0, model.IndexOfItemByView(view));
+  EXPECT_EQ(-1, model.IndexOfItemByView(NULL));
+
+  // Change the selection.
+  model.SetSelectedIndex(0);
+  EXPECT_EQ("added=0 removed=0 s_changed=1", observer.StateStringAndClear());
+
+  // Remove the item.
+  model.RemoveItemAt(0);
+  delete view;  // We now own the view.
+  view = NULL;
+  EXPECT_EQ(0, model.item_count());
+  EXPECT_EQ(0, model.selected_index());
+  EXPECT_EQ("added=0 removed=1 s_changed=0", observer.StateStringAndClear());
+}
+
+}  // namespace aura_shell
diff --git a/ui/aura_shell/launcher/launcher_view.cc b/ui/aura_shell/launcher/launcher_view.cc
index f62afcc..0900e3c 100644
--- a/ui/aura_shell/launcher/launcher_view.cc
+++ b/ui/aura_shell/launcher/launcher_view.cc
@@ -7,47 +7,97 @@
 #include "base/utf_string_conversions.h"
 #include "ui/aura/desktop.h"
 #include "ui/aura_shell/aura_shell_export.h"
-#include "ui/aura_shell/launcher/launcher_button.h"
+#include "ui/aura_shell/launcher/launcher_model.h"
 #include "ui/aura_shell/shell.h"
 #include "ui/aura_shell/shell_window_ids.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/compositor/layer.h"
 #include "views/widget/widget.h"
 
+using views::View;
+
 namespace aura_shell {
 namespace internal {
 
-LauncherView::LauncherView()
-    : ALLOW_THIS_IN_INITIALIZER_LIST(chrome_button_(new LauncherButton(this))),
-      ALLOW_THIS_IN_INITIALIZER_LIST(
-          applist_button_(new LauncherButton(this))) {
-  AddChildView(chrome_button_);
-  AddChildView(applist_button_);
+// Padding between each view.
+static const int kHorizontalPadding = 12;
+
+// Height of the LauncherView. Hard coded to avoid resizing as items are
+// added/removed.
+static const int kPreferredHeight = 64;
+
+LauncherView::LauncherView() : model_(NULL) {
 }
+
 LauncherView::~LauncherView() {
+  // The model owns the views.
+  RemoveAllChildViews(false);
+
+  model_->RemoveObserver(this);
+}
+
+void LauncherView::Init(LauncherModel* model) {
+  DCHECK(!model_);
+  model_ = model;
+  model_->AddObserver(this);
+  for (int i = 0; i < model_->item_count(); ++i)
+    AddChildView(model_->view_at(i));
 }
 
 void LauncherView::Layout() {
+  // TODO: need to deal with overflow.
+  int x = 0;
+  for (int i = 0; i < child_count(); ++i) {
+    View* child = child_at(i);
+    if (child->IsVisible()) {
+      gfx::Size pref_size = child->GetPreferredSize();
+      int y = (height() - pref_size.height()) / 2;
+      child->SetBounds(x, y, pref_size.width(), pref_size.height());
+      x += child->width() + kHorizontalPadding;
+    }
+  }
+}
+
+gfx::Size LauncherView::GetPreferredSize() {
+  int x = 0;
+  for (int i = 0; i < child_count(); ++i) {
+    View* child = child_at(i);
+    if (child->IsVisible()) {
+      gfx::Size pref_size = child->GetPreferredSize();
+      x += pref_size.width() + kHorizontalPadding;
+    }
+  }
+  if (x > 0)
+    x -= kHorizontalPadding;
+  return gfx::Size(x, kPreferredHeight);
+}
+
+void LauncherView::LauncherItemAdded(int index) {
+  // TODO: to support animations is going to require coordinate conversions.
+  AddChildViewAt(model_->view_at(index), index);
 }
 
-void LauncherView::OnPaint(gfx::Canvas* canvas) {
-  canvas->FillRectInt(SK_ColorRED, 0, 0, width(), height());
+void LauncherView::LauncherItemRemoved(int index) {
+  // TODO: to support animations is going to require coordinate conversions.
+  RemoveChildView(child_at(index));
 }
 
-void LauncherView::ButtonPressed(views::Button* sender,
-                                 const views::Event& event) {
+void LauncherView::LauncherSelectionChanged() {
 }
 
-views::Widget* CreateLauncher() {
+views::Widget* CreateLauncher(LauncherModel* model) {
   views::Widget* launcher_widget = new views::Widget;
   views::Widget::InitParams params(views::Widget::InitParams::TYPE_CONTROL);
-  params.bounds = gfx::Rect(0, 0, 300, 64);
+  params.bounds = gfx::Rect(0, 0, 300, kPreferredHeight);
   params.parent = Shell::GetInstance()->GetContainer(
       aura_shell::internal::kShellWindowId_LauncherContainer);
   LauncherView* launcher_view = new LauncherView;
+  launcher_view->Init(model);
   params.delegate = launcher_view;
   launcher_widget->Init(params);
-  launcher_widget->GetNativeWindow()->layer()->SetOpacity(0.2f);
+  launcher_widget->GetNativeWindow()->layer()->SetOpacity(0.8f);
+  gfx::Size pref = static_cast<views::View*>(launcher_view)->GetPreferredSize();
+  launcher_widget->SetBounds(gfx::Rect(0, 0, pref.width(), pref.height()));
   launcher_widget->SetContentsView(launcher_view);
   launcher_widget->Show();
   launcher_widget->GetNativeView()->set_name("LauncherView");
diff --git a/ui/aura_shell/launcher/launcher_view.h b/ui/aura_shell/launcher/launcher_view.h
index 0f949cc..d7b6e79 100644
--- a/ui/aura_shell/launcher/launcher_view.h
+++ b/ui/aura_shell/launcher/launcher_view.h
@@ -6,31 +6,38 @@
 #define UI_AURA_SHELL_LAUNCHER_VIEW_H_
 #pragma once
 
+#include "ui/aura_shell/launcher/launcher_model_observer.h"
 #include "views/widget/widget_delegate.h"
-#include "views/controls/button/button.h"
 
 namespace aura_shell {
+
+class LauncherModel;
+
 namespace internal {
 
 class LauncherButton;
 
 class LauncherView : public views::WidgetDelegateView,
-                     public views::ButtonListener {
+                     public LauncherModelObserver {
  public:
   LauncherView();
   virtual ~LauncherView();
 
+  // Populates this LauncherView from the contents of |model|.
+  void Init(LauncherModel* model);
+
  private:
   // Overridden from views::View:
   virtual void Layout() OVERRIDE;
-  virtual void OnPaint(gfx::Canvas* canvas) OVERRIDE;
+  virtual gfx::Size GetPreferredSize() OVERRIDE;
 
-  // Overridden from views::ButtonListener:
-  virtual void ButtonPressed(views::Button* sender,
-                             const views::Event& event) OVERRIDE;
+  // Overridden from LauncherModelObserver:
+  virtual void LauncherItemAdded(int index) OVERRIDE;
+  virtual void LauncherItemRemoved(int index) OVERRIDE;
+  virtual void LauncherSelectionChanged() OVERRIDE;
 
-  LauncherButton* chrome_button_;
-  LauncherButton* applist_button_;
+  // The model, we don't own it.
+  LauncherModel* model_;
 
   DISALLOW_COPY_AND_ASSIGN(LauncherView);
 };