athena/wm/window_manager_impl.cc

   1 // Copyright 2014 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 "athena/wm/public/window_manager.h"
   6
   7 #include "athena/input/public/accelerator_manager.h"
   8 #include "athena/screen/public/screen_manager.h"
   9 #include "athena/wm/public/window_manager_observer.h"
  10 #include "athena/wm/window_overview_mode.h"
  11 #include "base/logging.h"
  12 #include "base/observer_list.h"
  13 #include "ui/aura/layout_manager.h"
  14 #include "ui/aura/window.h"
  15 #include "ui/wm/public/window_types.h"
  16
  17 namespace athena {
  18 namespace {
  19
  20 class WindowManagerImpl : public WindowManager,
  21                           public WindowOverviewModeDelegate,
  22                           public aura::WindowObserver,
  23                           public AcceleratorHandler {
  24  public:
  25   WindowManagerImpl();
  26   virtual ~WindowManagerImpl();
  27
  28   void Layout();
  29
  30   // WindowManager:
  31   virtual void ToggleOverview() OVERRIDE {
  32     if (overview_) {
  33       overview_.reset();
  34       FOR_EACH_OBSERVER(WindowManagerObserver, observers_,
  35                         OnOverviewModeExit());
  36     } else {
  37       overview_ = WindowOverviewMode::Create(container_.get(), this);
  38       FOR_EACH_OBSERVER(WindowManagerObserver, observers_,
  39                         OnOverviewModeEnter());
  40     }
  41   }
  42
  43  private:
  44   enum Command {
  45     COMMAND_TOGGLE_OVERVIEW,
  46   };
  47
  48   void InstallAccelerators() {
  49     const AcceleratorData accelerator_data[] = {
  50         {TRIGGER_ON_PRESS, ui::VKEY_F6, ui::EF_NONE, COMMAND_TOGGLE_OVERVIEW,
  51          AF_NONE},
  52     };
  53     AcceleratorManager::Get()->RegisterAccelerators(
  54         accelerator_data, arraysize(accelerator_data), this);
  55   }
  56
  57   // WindowManager:
  58   virtual void AddObserver(WindowManagerObserver* observer) OVERRIDE {
  59     observers_.AddObserver(observer);
  60   }
  61
  62   virtual void RemoveObserver(WindowManagerObserver* observer) OVERRIDE {
  63     observers_.RemoveObserver(observer);
  64   }
  65
  66   // WindowOverviewModeDelegate:
  67   virtual void OnSelectWindow(aura::Window* window) OVERRIDE {
  68     CHECK_EQ(container_.get(), window->parent());
  69     container_->StackChildAtTop(window);
  70     overview_.reset();
  71     FOR_EACH_OBSERVER(WindowManagerObserver, observers_,
  72                       OnOverviewModeExit());
  73   }
  74
  75   // aura::WindowObserver
  76   virtual void OnWindowDestroying(aura::Window* window) OVERRIDE {
  77     if (window == container_)
  78       container_.reset();
  79   }
  80
  81   // AcceleratorHandler:
  82   virtual bool IsCommandEnabled(int command_id) const OVERRIDE { return true; }
  83   virtual bool OnAcceleratorFired(int command_id,
  84                                   const ui::Accelerator& accelerator) OVERRIDE {
  85     switch (command_id) {
  86       case COMMAND_TOGGLE_OVERVIEW:
  87         ToggleOverview();
  88         break;
  89     }
  90     return true;
  91   }
  92
  93   scoped_ptr<aura::Window> container_;
  94   scoped_ptr<WindowOverviewMode> overview_;
  95   ObserverList<WindowManagerObserver> observers_;
  96
  97   DISALLOW_COPY_AND_ASSIGN(WindowManagerImpl);
  98 };
  99
 100 class WindowManagerImpl* instance = NULL;
 101
 102 class AthenaContainerLayoutManager : public aura::LayoutManager {
 103  public:
 104   AthenaContainerLayoutManager() {}
 105   virtual ~AthenaContainerLayoutManager() {}
 106
 107  private:
 108   // aura::LayoutManager:
 109   virtual void OnWindowResized() OVERRIDE { instance->Layout(); }
 110   virtual void OnWindowAddedToLayout(aura::Window* child) OVERRIDE {
 111     instance->Layout();
 112   }
 113   virtual void OnWillRemoveWindowFromLayout(aura::Window* child) OVERRIDE {}
 114   virtual void OnWindowRemovedFromLayout(aura::Window* child) OVERRIDE {
 115     instance->Layout();
 116   }
 117   virtual void OnChildWindowVisibilityChanged(aura::Window* child,
 118                                               bool visible) OVERRIDE {
 119     instance->Layout();
 120   }
 121   virtual void SetChildBounds(aura::Window* child,
 122                               const gfx::Rect& requested_bounds) OVERRIDE {
 123     if (!requested_bounds.IsEmpty())
 124       SetChildBoundsDirect(child, requested_bounds);
 125   }
 126
 127   DISALLOW_COPY_AND_ASSIGN(AthenaContainerLayoutManager);
 128 };
 129
 130 WindowManagerImpl::WindowManagerImpl() {
 131   ScreenManager::ContainerParams params("DefaultContainer");
 132   params.can_activate_children = true;
 133   container_.reset(ScreenManager::Get()->CreateDefaultContainer(params));
 134   container_->SetLayoutManager(new AthenaContainerLayoutManager);
 135   container_->AddObserver(this);
 136   instance = this;
 137   InstallAccelerators();
 138 }
 139
 140 WindowManagerImpl::~WindowManagerImpl() {
 141   if (container_)
 142     container_->RemoveObserver(this);
 143   container_.reset();
 144   instance = NULL;
 145 }
 146
 147 void WindowManagerImpl::Layout() {
 148   if (!container_)
 149     return;
 150   gfx::Rect bounds = gfx::Rect(container_->bounds().size());
 151   const aura::Window::Windows& children = container_->children();
 152   for (aura::Window::Windows::const_iterator iter = children.begin();
 153        iter != children.end();
 154        ++iter) {
 155     if ((*iter)->type() == ui::wm::WINDOW_TYPE_NORMAL ||
 156         (*iter)->type() == ui::wm::WINDOW_TYPE_POPUP)
 157       (*iter)->SetBounds(bounds);
 158   }
 159 }
 160
 161 }  // namespace
 162
 163 // static
 164 WindowManager* WindowManager::Create() {
 165   DCHECK(!instance);
 166   new WindowManagerImpl;
 167   DCHECK(instance);
 168   return instance;
 169 }
 170
 171 // static
 172 void WindowManager::Shutdown() {
 173   DCHECK(instance);
 174   delete instance;
 175   DCHECK(!instance);
 176 }
 177
 178 // static
 179 WindowManager* WindowManager::GetInstance() {
 180   DCHECK(instance);
 181   return instance;
 182 }
 183
 184 }  // namespace athena