ash uber tray: Add the detailed network popup

ash/system/network/tray_network.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/system/network/tray_network.h"
 
 #include "ash/shell.h"
+#include "ash/system/tray/system_tray.h"
 #include "ash/system/tray/system_tray_delegate.h"
+#include "base/utf_string_conversions.h"
+#include "grit/ash_strings.h"
+#include "grit/ui_resources.h"
+#include "ui/base/resource/resource_bundle.h"
+#include "ui/gfx/font.h"
+#include "ui/gfx/image/image.h"
 #include "ui/views/controls/image_view.h"
 #include "ui/views/controls/label.h"
+#include "ui/views/controls/scroll_view.h"
 #include "ui/views/layout/fill_layout.h"
 #include "ui/views/layout/box_layout.h"
 #include "ui/views/view.h"
+#include "ui/views/widget/widget.h"
+
+namespace {
+
+// Padding for items that do not have any icons.
+const int kItemPaddingLeft = 27;
+
+class ViewClickListener {
+ public:
+  virtual void ClickedOn(views::View* sender) = 0;
+};
+
+class HoverHighlightView : public views::View {
+ public:
+  explicit HoverHighlightView(ViewClickListener* listener)
+      : listener_(listener) {
+    set_notify_enter_exit_on_child(true);
+  }
+
+  virtual ~HoverHighlightView() {}
+
+ private:
+  // Overridden from views::View.
+  virtual bool OnMousePressed(const views::MouseEvent& event) OVERRIDE {
+    if (!listener_)
+      return false;
+    listener_->ClickedOn(this);
+    return true;
+  }
+
+  virtual void OnMouseEntered(const views::MouseEvent& event) OVERRIDE {
+    set_background(views::Background::CreateSolidBackground(
+        SkColorSetARGB(10, 0, 0, 0)));
+    SchedulePaint();
+  }
+
+  virtual void OnMouseExited(const views::MouseEvent& event) OVERRIDE {
+    set_background(NULL);
+    SchedulePaint();
+  }
+
+  ViewClickListener* listener_;
+
+  DISALLOW_COPY_AND_ASSIGN(HoverHighlightView);
+};
+
+}
 
 namespace ash {
 namespace internal {
 
 namespace tray {
 
 enum ResourceSize {
   SMALL,
   LARGE,
 };
 
 class NetworkTrayView : public views::View {
  public:
   explicit NetworkTrayView(ResourceSize size) : resource_size_(size) {
     SetLayoutManager(new views::FillLayout());
 
     image_view_ = new views::ImageView;
     AddChildView(image_view_);
 
-    Update(Shell::GetInstance()->tray_delegate()->GetMostRelevantNetworkIcon());
+    Update(Shell::GetInstance()->tray_delegate()->
+        GetMostRelevantNetworkIcon(resource_size_ == LARGE));
   }
 
   virtual ~NetworkTrayView() {}
 
   void Update(const NetworkIconInfo& info) {
     image_view_->SetImage(info.image);
     SchedulePaint();
   }
 
  private:
   views::ImageView* image_view_;
   ResourceSize resource_size_;
 
   DISALLOW_COPY_AND_ASSIGN(NetworkTrayView);
 };
 
 class NetworkDefaultView : public views::View {
  public:
-  NetworkDefaultView() {
+  explicit NetworkDefaultView(SystemTrayItem* owner) : owner_(owner) {
     SetLayoutManager(new views::BoxLayout(views::BoxLayout::kHorizontal,
         0, 0, 5));
 
     icon_ = new NetworkTrayView(LARGE);
     AddChildView(icon_);
 
     label_ = new views::Label();
     AddChildView(label_);
 
-    Update(Shell::GetInstance()->tray_delegate()->GetMostRelevantNetworkIcon());
+    views::ImageView* more = new views::ImageView;
+    more->SetImage(ui::ResourceBundle::GetSharedInstance().GetImageNamed(
+        IDR_AURA_UBER_TRAY_MORE).ToSkBitmap());
+    AddChildView(more);
+
+    Update(Shell::GetInstance()->tray_delegate()->
+        GetMostRelevantNetworkIcon(true));
   }
 
   virtual ~NetworkDefaultView() {}
 
   void Update(const NetworkIconInfo& info) {
     icon_->Update(info);
     label_->SetText(info.description);
   }
 
  private:
+  // Overridden from views::View.
+  virtual bool OnMousePressed(const views::MouseEvent& event) OVERRIDE {
+    owner_->PopupDetailedView(0, true);
+    return true;
+  }
+
+  SystemTrayItem* owner_;
   NetworkTrayView* icon_;
   views::Label* label_;
 
   DISALLOW_COPY_AND_ASSIGN(NetworkDefaultView);
 };
 
+class NetworkDetailedView : public views::View,
+                            public ViewClickListener {
+ public:
+  explicit NetworkDetailedView(user::LoginStatus login)
+      : login_(login) {
+    SetLayoutManager(new views::BoxLayout(
+        views::BoxLayout::kVertical, 1, 1, 1));
+    Update();
+  }
+
+  virtual ~NetworkDetailedView() {}
+
+  void Update() {

[Ben Goodger (Google), 2012/03/13 14:55:50]

huge functions like this are easier to read/modify if you split all the various
updating chunks out into separate helper functions.

[sadrul, 2012/03/13 15:19:37]

Did some refactoring. PTAL

+    RemoveAllChildViews(true);
+    ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
+
+    views::View* container = new HoverHighlightView(this);
+    container->SetLayoutManager(new
+        views::BoxLayout(views::BoxLayout::kHorizontal, 0, 3, 5));
+    views::ImageView* back = new views::ImageView;
+    back->SetImage(rb.GetImageNamed(IDR_AURA_UBER_TRAY_LESS).ToSkBitmap());
+    container->AddChildView(back);
+    views::Label* header = new views::Label(rb.GetLocalizedString(
+        IDS_ASH_STATUS_TRAY_NETWORK));
+    header->SetHorizontalAlignment(views::Label::ALIGN_LEFT);
+    header->SetFont(header->font().DeriveFont(4));
+    container->AddChildView(header);
+    AddChildView(container);
+    header_ = container;
+
+    // List the networks.
+    views::View* networks = new views::View;
+    networks->SetLayoutManager(new views::BoxLayout(
+        views::BoxLayout::kVertical, 0, 0, 1));
+    std::vector<NetworkIconInfo> list;
+    Shell::GetInstance()->tray_delegate()->GetAvailableNetworks(&list);
+    for (size_t i = 0; i < list.size(); i++) {
+      container = new HoverHighlightView(this);
+      container->SetLayoutManager(new views::BoxLayout(
+          views::BoxLayout::kHorizontal, 0, 3, 5));
+      views::ImageView* image = new views::ImageView;
+      image->SetImage(list[i].image);
+      container->AddChildView(image);
+      container->AddChildView(new views::Label(list[i].name));
+      networks->AddChildView(container);
+
+      network_map_[container] = list[i].unique_id;
+    }
+    networks->set_border(views::Border::CreateSolidSidedBorder(1, 0, 1, 0,
+        SkColorSetARGB(25, 0, 0, 0)));
+    AddChildView(networks);
+
+    // Airplane mode.
+    container = new HoverHighlightView(this);
+    container->SetLayoutManager(new views::BoxLayout(
+        views::BoxLayout::kHorizontal, 0, 3, 5));
+    views::ImageView* image = new views::ImageView;
+    image->SetImage(rb.GetImageNamed(
+        IDR_AURA_UBER_TRAY_NETWORK_AIRPLANE).ToSkBitmap());
+    container->AddChildView(image);
+    container->AddChildView(new views::Label(rb.GetLocalizedString(
+        IDS_ASH_STATUS_TRAY_AIRPLANE_MODE)));
+    AddChildView(container);
+    airplane_ = container;
+
+    // Settings, only if logged in.
+    if (login_ != user::LOGGED_IN_NONE) {
+      container = new HoverHighlightView(this);
+      views::Label* settings = new views::Label(rb.GetLocalizedString(
+            IDS_ASH_STATUS_TRAY_NETWORK_SETTINGS));
+      settings->set_border(views::Border::CreateEmptyBorder(5, kItemPaddingLeft,
+            5, 0));
+      settings->SetHorizontalAlignment(views::Label::ALIGN_LEFT);
+      container->AddChildView(settings);
+      container->SetLayoutManager(new views::FillLayout());
+      AddChildView(container);
+      settings_ = container;
+    }
+  }
+
+ private:
+  // Overridden from ViewClickListener.
+  virtual void ClickedOn(views::View* sender) OVERRIDE {
+    ash::SystemTrayDelegate* delegate =
+        ash::Shell::GetInstance()->tray_delegate();
+    if (sender == header_) {
+      Shell::GetInstance()->tray()->ShowDefaultView();
+    } else if (sender == settings_) {
+      delegate->ShowNetworkSettings();
+    } else if (sender == airplane_) {
+      delegate->ToggleAirplaneMode();
+    } else {
+      std::map<views::View*, std::string>::iterator find;
+      find = network_map_.find(sender);
+      if (find != network_map_.end()) {
+        std::string network_id = find->second;
+        delegate->ConnectToNetwork(network_id);
+      }
+    }
+  }
+
+  user::LoginStatus login_;
+  std::map<views::View*, std::string> network_map_;
+  views::View* header_;
+  views::View* airplane_;
+  views::View* settings_;
+  DISALLOW_COPY_AND_ASSIGN(NetworkDetailedView);
+};
+
 }  // namespace tray
 
 TrayNetwork::TrayNetwork() {
 }
 
 TrayNetwork::~TrayNetwork() {
 }
 
 views::View* TrayNetwork::CreateTrayView(user::LoginStatus status) {
   tray_.reset(new tray::NetworkTrayView(tray::SMALL));
   return tray_.get();
 }
 
 views::View* TrayNetwork::CreateDefaultView(user::LoginStatus status) {
-  default_.reset(new tray::NetworkDefaultView);
+  default_.reset(new tray::NetworkDefaultView(this));
   return default_.get();
 }
 
 views::View* TrayNetwork::CreateDetailedView(user::LoginStatus status) {
-  return NULL;
+  detailed_.reset(new tray::NetworkDetailedView(status));
+  return detailed_.get();
 }
 
 void TrayNetwork::DestroyTrayView() {
   tray_.reset();
 }
 
 void TrayNetwork::DestroyDefaultView() {
   default_.reset();
 }
 
 void TrayNetwork::DestroyDetailedView() {
+  detailed_.reset();
 }
 
 void TrayNetwork::OnNetworkRefresh(const NetworkIconInfo& info) {
   if (tray_.get())
     tray_->Update(info);
   if (default_.get())
     default_->Update(info);
+  if (detailed_.get())
+    detailed_->Update();
 }
 
 }  // namespace internal
 }  // namespace ash