Home | History | Annotate | Download | only in aura_demo
      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
    199