mojo/examples/aura_demo/aura_demo.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include <stdio.h>
   6 #include <string>
   7
   8 #include "base/bind.h"
   9 #include "mojo/aura/context_factory_mojo.h"
  10 #include "mojo/aura/screen_mojo.h"
  11 #include "mojo/aura/window_tree_host_mojo.h"
  12 #include "mojo/aura/window_tree_host_mojo_delegate.h"
  13 #include "mojo/public/cpp/application/application.h"
  14 #include "mojo/public/cpp/system/core.h"
  15 #include "mojo/public/interfaces/service_provider/service_provider.mojom.h"
  16 #include "mojo/services/public/cpp/view_manager/node.h"
  17 #include "mojo/services/public/cpp/view_manager/view.h"
  18 #include "mojo/services/public/cpp/view_manager/view_manager.h"
  19 #include "mojo/services/public/cpp/view_manager/view_manager_delegate.h"
  20 #include "mojo/services/public/interfaces/native_viewport/native_viewport.mojom.h"
  21 #include "ui/aura/client/default_capture_client.h"
  22 #include "ui/aura/client/window_tree_client.h"
  23 #include "ui/aura/env.h"
  24 #include "ui/aura/window.h"
  25 #include "ui/aura/window_delegate.h"
  26 #include "ui/base/hit_test.h"
  27 #include "ui/gfx/canvas.h"
  28 #include "ui/gfx/codec/png_codec.h"
  29
  30 namespace mojo {
  31 namespace examples {
  32
  33 // Trivial WindowDelegate implementation that draws a colored background.
  34 class DemoWindowDelegate : public aura::WindowDelegate {
  35  public:
  36   explicit DemoWindowDelegate(SkColor color) : color_(color) {}
  37
  38   // Overridden from WindowDelegate:
  39   virtual gfx::Size GetMinimumSize() const OVERRIDE {
  40     return gfx::Size();
  41   }
  42
  43   virtual gfx::Size GetMaximumSize() const OVERRIDE {
  44     return gfx::Size();
  45   }
  46
  47   virtual void OnBoundsChanged(const gfx::Rect& old_bounds,
  48                                const gfx::Rect& new_bounds) OVERRIDE {}
  49   virtual gfx::NativeCursor GetCursor(const gfx::Point& point) OVERRIDE {
  50     return gfx::kNullCursor;
  51   }
  52   virtual int GetNonClientComponent(const gfx::Point& point) const OVERRIDE {
  53     return HTCAPTION;
  54   }
  55   virtual bool ShouldDescendIntoChildForEventHandling(
  56       aura::Window* child,
  57       const gfx::Point& location) OVERRIDE {
  58     return true;
  59   }
  60   virtual bool CanFocus() OVERRIDE { return true; }
  61   virtual void OnCaptureLost() OVERRIDE {}
  62   virtual void OnPaint(gfx::Canvas* canvas) OVERRIDE {
  63     canvas->DrawColor(color_, SkXfermode::kSrc_Mode);
  64   }
  65   virtual void OnDeviceScaleFactorChanged(float device_scale_factor) OVERRIDE {}
  66   virtual void OnWindowDestroying(aura::Window* window) OVERRIDE {}
  67   virtual void OnWindowDestroyed(aura::Window* window) OVERRIDE {}
  68   virtual void OnWindowTargetVisibilityChanged(bool visible) OVERRIDE {}
  69   virtual bool HasHitTestMask() const OVERRIDE { return false; }
  70   virtual void GetHitTestMask(gfx::Path* mask) const OVERRIDE {}
  71
  72  private:
  73   const SkColor color_;
  74
  75   DISALLOW_COPY_AND_ASSIGN(DemoWindowDelegate);
  76 };
  77
  78 class DemoWindowTreeClient : public aura::client::WindowTreeClient {
  79  public:
  80   explicit DemoWindowTreeClient(aura::Window* window) : window_(window) {
  81     aura::client::SetWindowTreeClient(window_, this);
  82   }
  83
  84   virtual ~DemoWindowTreeClient() {
  85     aura::client::SetWindowTreeClient(window_, NULL);
  86   }
  87
  88   // Overridden from aura::client::WindowTreeClient:
  89   virtual aura::Window* GetDefaultParent(aura::Window* context,
  90                                          aura::Window* window,
  91                                          const gfx::Rect& bounds) OVERRIDE {
  92     if (!capture_client_) {
  93       capture_client_.reset(
  94           new aura::client::DefaultCaptureClient(window_->GetRootWindow()));
  95     }
  96     return window_;
  97   }
  98
  99  private:
 100   aura::Window* window_;
 101   scoped_ptr<aura::client::DefaultCaptureClient> capture_client_;
 102
 103   DISALLOW_COPY_AND_ASSIGN(DemoWindowTreeClient);
 104 };
 105
 106 class AuraDemo : public Application,
 107                  public WindowTreeHostMojoDelegate,
 108                  public view_manager::ViewManagerDelegate {
 109  public:
 110   AuraDemo()
 111       : window1_(NULL),
 112         window2_(NULL),
 113         window21_(NULL),
 114         view_(NULL) {
 115     view_manager::ViewManager::Create(this, this);
 116   }
 117   virtual ~AuraDemo() {}
 118
 119  private:
 120   // Overridden from view_manager::ViewManagerDelegate:
 121   virtual void OnRootAdded(view_manager::ViewManager* view_manager,
 122                            view_manager::Node* root) OVERRIDE {
 123     // TODO(beng): this function could be called multiple times!
 124     view_ = view_manager::View::Create(view_manager);
 125     root->SetActiveView(view_);
 126
 127     window_tree_host_.reset(new WindowTreeHostMojo(root, this));
 128     window_tree_host_->InitHost();
 129
 130     window_tree_client_.reset(
 131         new DemoWindowTreeClient(window_tree_host_->window()));
 132
 133     delegate1_.reset(new DemoWindowDelegate(SK_ColorBLUE));
 134     window1_ = new aura::Window(delegate1_.get());
 135     window1_->Init(aura::WINDOW_LAYER_TEXTURED);
 136     window1_->SetBounds(gfx::Rect(100, 100, 400, 400));
 137     window1_->Show();
 138     window_tree_host_->window()->AddChild(window1_);
 139
 140     delegate2_.reset(new DemoWindowDelegate(SK_ColorRED));
 141     window2_ = new aura::Window(delegate2_.get());
 142     window2_->Init(aura::WINDOW_LAYER_TEXTURED);
 143     window2_->SetBounds(gfx::Rect(200, 200, 350, 350));
 144     window2_->Show();
 145     window_tree_host_->window()->AddChild(window2_);
 146
 147     delegate21_.reset(new DemoWindowDelegate(SK_ColorGREEN));
 148     window21_ = new aura::Window(delegate21_.get());
 149     window21_->Init(aura::WINDOW_LAYER_TEXTURED);
 150     window21_->SetBounds(gfx::Rect(10, 10, 50, 50));
 151     window21_->Show();
 152     window2_->AddChild(window21_);
 153
 154     window_tree_host_->Show();
 155   }
 156
 157   // WindowTreeHostMojoDelegate:
 158   virtual void CompositorContentsChanged(const SkBitmap& bitmap) OVERRIDE {
 159     view_->SetContents(bitmap);
 160   }
 161
 162   virtual void Initialize() OVERRIDE {
 163     aura::Env::CreateInstance(true);
 164     context_factory_.reset(new ContextFactoryMojo);
 165     aura::Env::GetInstance()->set_context_factory(context_factory_.get());
 166     screen_.reset(ScreenMojo::Create());
 167     gfx::Screen::SetScreenInstance(gfx::SCREEN_TYPE_NATIVE, screen_.get());
 168   }
 169
 170   scoped_ptr<DemoWindowTreeClient> window_tree_client_;
 171
 172   scoped_ptr<ui::ContextFactory> context_factory_;
 173
 174   scoped_ptr<ScreenMojo> screen_;
 175
 176   scoped_ptr<DemoWindowDelegate> delegate1_;
 177   scoped_ptr<DemoWindowDelegate> delegate2_;
 178   scoped_ptr<DemoWindowDelegate> delegate21_;
 179
 180   aura::Window* window1_;
 181   aura::Window* window2_;
 182   aura::Window* window21_;
 183
 184   view_manager::View* view_;
 185
 186   scoped_ptr<aura::WindowTreeHost> window_tree_host_;
 187
 188   DISALLOW_COPY_AND_ASSIGN(AuraDemo);
 189 };
 190
 191 }  // namespace examples
 192
 193 // static
 194 Application* Application::Create() {
 195   return new examples::AuraDemo();
 196 }
 197
 198 }  // namespace mojo