Add common palette tray implementation.

ash/common/system/chromeos/palette/palette_tool.cc

 // Copyright 2016 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/common/system/chromeos/palette/palette_tool.h"
 
 #include "ash/common/shelf/shelf_constants.h"
 #include "ash/common/system/chromeos/palette/palette_ids.h"
 #include "ash/common/system/chromeos/palette/palette_tool_manager.h"
 #include "ash/common/system/tray/hover_highlight_view.h"
 #include "ash/common/system/tray/view_click_listener.h"
 #include "base/strings/utf_string_conversions.h"
 #include "grit/ash_resources.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/gfx/paint_vector_icon.h"
 #include "ui/gfx/vector_icons_public.h"
 
 namespace ash {
 
+namespace {
+
+// A PaletteTool implementation with a standard view support.
+class CommonPaletteTool : public PaletteTool, public ash::ViewClickListener {
+ protected:
+  views::View* CreateDefaultView(const std::string& message) {
+    highlight_view_ = new HoverHighlightView(this);
+
+    gfx::ImageSkia image = CreateVectorIcon(icon_id(), SK_ColorBLACK);
+    gfx::ImageSkia checkbox =
+        CreateVectorIcon(gfx::VectorIconId::CHECK, SK_ColorGREEN);

[Evan Stade, 2016/07/13 18:33:55]

Are these the right colors? If not can you add a TODO to update them?

[jdufault, 2016/07/13 19:29:01]

Added TODO.

+
+    const base::string16& name = base::ASCIIToUTF16(message);

[Evan Stade, 2016/07/13 18:33:55]

this is not right, presumably message can contain non-ASCII characters. You want
|message| to be a string16.

Unless this entire class is just for debug or something? The docs are not
sufficient for me to figure that out.

[jdufault, 2016/07/13 19:29:01]

Right, these are stub tool implementations to provide a UI that looks right but
doesn't actually do anything.

The derived CommonPaletteTool classes are going to get replaced, but I'd like to
keep most of the view logic in CommonPaletteTool.

+
+    highlight_view_->AddIndentedIconAndLabel(image, name, false);
+    highlight_view_->AddRightIcon(checkbox);
+
+    if (enabled())
+      highlight_view_->SetHighlight(true);
+    else
+      highlight_view_->SetRightIconVisible(false);
+
+    return highlight_view_;
+  }
+
+  views::View* CreateView() override {
+    return CreateDefaultView("[TODO] " + PaletteToolIdToString(tool_id()));
+  }
+  void DestroyView() override { highlight_view_ = nullptr; }
+
+  void OnEnable() override {
+    PaletteTool::OnEnable();
+
+    if (highlight_view_) {
+      highlight_view_->SetHighlight(true);
+      highlight_view_->SetRightIconVisible(true);
+    }
+  }
+
+  void OnDisable() override {
+    PaletteTool::OnDisable();
+
+    if (highlight_view_) {
+      highlight_view_->SetHighlight(false);
+      highlight_view_->SetRightIconVisible(false);
+    }
+  }
+
+  // ViewClickListener overrides.
+  void OnViewClicked(views::View* sender) override {
+    if (enabled())
+      DisableSelf();
+    else
+      EnableSelf();
+  }
+
+ protected:
+  virtual gfx::VectorIconId icon_id() = 0;
+
+ private:
+  HoverHighlightView* highlight_view_ = nullptr;
+};
+
+class CreateNoteAction : public CommonPaletteTool {
+ public:
+  CreateNoteAction() {}
+  ~CreateNoteAction() override {}
+
+ private:
+  // PaletteTool overrides.
+  PaletteGroup group() const override { return PaletteGroup::ACTION; }
+  PaletteToolId tool_id() const override {
+    return PaletteToolId::CREATE_NEW_NOTE;
+  }
+
+  gfx::VectorIconId icon_id() override {
+    return gfx::VectorIconId::PALETTE_CAPTURE_SCREEN;
+  }
+
+  DISALLOW_COPY_AND_ASSIGN(CreateNoteAction);
+};
+
+class CaptureRegionAction : public CommonPaletteTool {
+ public:
+  CaptureRegionAction() {}
+  ~CaptureRegionAction() override {}
+
+ private:
+  // PaletteTool overrides.
+  PaletteGroup group() const override { return PaletteGroup::ACTION; }
+  PaletteToolId tool_id() const override {
+    return PaletteToolId::CAPTURE_REGION;
+  }
+
+  gfx::VectorIconId icon_id() override {
+    return gfx::VectorIconId::PALETTE_CAPTURE_REGION;
+  }
+
+  DISALLOW_COPY_AND_ASSIGN(CaptureRegionAction);
+};
+
+class ScreenshotAction : public CommonPaletteTool {
+ public:
+  ScreenshotAction() {}
+  ~ScreenshotAction() override {}
+
+ private:
+  // PaletteTool overrides.
+  PaletteGroup group() const override { return PaletteGroup::ACTION; }
+  PaletteToolId tool_id() const override { return PaletteToolId::SCREENSHOT; }
+  void OnEnable() override {
+    CommonPaletteTool::OnEnable();
+    DisableSelf();
+  }
+
+  gfx::VectorIconId icon_id() override {
+    return gfx::VectorIconId::PALETTE_CAPTURE_SCREEN;
+  }
+
+  DISALLOW_COPY_AND_ASSIGN(ScreenshotAction);
+};
+
+class PresentationMode : public CommonPaletteTool {
+ public:
+  PresentationMode() {}
+  ~PresentationMode() override {}
+
+ private:
+  // PaletteTool overrides.
+  PaletteGroup group() const override { return PaletteGroup::MODE; }
+  PaletteToolId tool_id() const override { return PaletteToolId::PRESENTATION; }
+
+  gfx::VectorIconId icon_id() override {
+    return gfx::VectorIconId::PALETTE_PRESENTATION_MODE;
+  }
+
+  DISALLOW_COPY_AND_ASSIGN(PresentationMode);
+};
+
+class MagnifierMode : public CommonPaletteTool {
+ public:
+  MagnifierMode() {}
+  ~MagnifierMode() override {}
+
+ private:
+  // PaletteTool overrides.
+  PaletteGroup group() const override { return PaletteGroup::MODE; }
+  PaletteToolId tool_id() const override { return PaletteToolId::MAGNIFY; }
+
+  gfx::VectorIconId icon_id() override {
+    return gfx::VectorIconId::PALETTE_MAGNIFY_MODE;
+  }
+
+  DISALLOW_COPY_AND_ASSIGN(MagnifierMode);
+};
+
+}  // namespace
+
 // static
-void PaletteTool::RegisterToolInstances(PaletteToolManager* tool_manager) {}
+void PaletteTool::RegisterToolInstances(PaletteToolManager* tool_manager) {
+  tool_manager->AddTool(base::WrapUnique(new CreateNoteAction()));
+  tool_manager->AddTool(base::WrapUnique(new CaptureRegionAction()));
+  tool_manager->AddTool(base::WrapUnique(new ScreenshotAction()));
+  tool_manager->AddTool(base::WrapUnique(new PresentationMode()));
+  tool_manager->AddTool(base::WrapUnique(new MagnifierMode()));
+}
 
 PaletteTool::PaletteTool() {}
 
 PaletteTool::~PaletteTool() {}
 
 void PaletteTool::Initialize(WmWindow* window,
                              const ToolAction& enable_tool,
                              const ToolAction& disable_tool) {
   window_ = window;
   enable_tool_ = enable_tool;
@@ skipping 22 matching lines @@
   DCHECK(!disable_tool_.is_null()) << "PaletteTool was not initialized";
 
   disable_tool_.Run(tool_id());
 }
 
 WmWindow* PaletteTool::window() const {
   return window_;
 }
 
 }  // namespace ash