Preliminary interactive layout of window manager's demo_launcher

mojo/examples/window_manager/window_manager.cc

 // Copyright 2014 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 "base/basictypes.h"
 #include "base/bind.h"
 #include "mojo/examples/keyboard/keyboard.mojom.h"
 #include "mojo/examples/window_manager/debug_panel.h"
 #include "mojo/examples/window_manager/window_manager.mojom.h"
 #include "mojo/public/cpp/application/application_connection.h"
 #include "mojo/public/cpp/application/application_delegate.h"
 #include "mojo/public/cpp/application/application_impl.h"
 #include "mojo/services/public/cpp/geometry/geometry_type_converters.h"
 #include "mojo/services/public/cpp/input_events/input_events_type_converters.h"
 #include "mojo/services/public/cpp/view_manager/node.h"
 #include "mojo/services/public/cpp/view_manager/node_observer.h"
 #include "mojo/services/public/cpp/view_manager/view.h"
 #include "mojo/services/public/cpp/view_manager/view_event_dispatcher.h"
 #include "mojo/services/public/cpp/view_manager/view_manager.h"
 #include "mojo/services/public/cpp/view_manager/view_manager_delegate.h"
 #include "mojo/services/public/interfaces/input_events/input_events.mojom.h"
 #include "mojo/services/public/interfaces/launcher/launcher.mojom.h"
 #include "mojo/services/public/interfaces/navigation/navigation.mojom.h"
 #include "mojo/views/views_init.h"
 #include "ui/events/event.h"
 #include "ui/events/event_constants.h"
+#include "ui/gfx/geometry/size_conversions.h"
 
 #if defined CreateWindow
 #undef CreateWindow
 #endif
 
 using mojo::view_manager::Id;
 using mojo::view_manager::Node;
 using mojo::view_manager::NodeObserver;
 using mojo::view_manager::View;
 using mojo::view_manager::ViewEventDispatcher;
@@ skipping 46 matching lines @@
                                   const mojo::String& url) OVERRIDE;
   virtual void RequestNavigate(
       uint32 source_node_id,
       navigation::Target target,
       navigation::NavigationDetailsPtr nav_details) OVERRIDE;
   WindowManager* window_manager_;
 
   DISALLOW_COPY_AND_ASSIGN(NavigatorHost);
 };
 
-class KeyboardManager : public KeyboardClient {
+class KeyboardManager : public KeyboardClient,
+                        public NodeObserver {
  public:
   KeyboardManager() : view_manager_(NULL), node_(NULL) {
   }
   virtual ~KeyboardManager() {
+    if (node_)
+      node_->parent()->RemoveObserver(this);
   }
 
   Node* node() { return node_; }
 
   void Init(ApplicationImpl* application,
             ViewManager* view_manager,
             Node* parent,
             const gfx::Rect& bounds) {
     view_manager_ = view_manager;
     node_ = Node::Create(view_manager);
     node_->SetBounds(bounds);
     parent->AddChild(node_);
     node_->Embed("mojo:mojo_keyboard");
     application->ConnectToService("mojo:mojo_keyboard", &keyboard_service_);
     keyboard_service_.set_client(this);
+    parent->AddObserver(this);
   }
 
   void Show(Id view_id, const gfx::Rect& bounds) {
     keyboard_service_->SetTarget(view_id);
     node_->SetVisible(true);
   }
 
   void Hide(Id view_id) {
     keyboard_service_->SetTarget(0);
     node_->SetVisible(false);
@@ skipping 17 matching lines @@
         Event::From(ui::KeyEvent(ui::ET_KEY_PRESSED,
                                  static_cast<ui::KeyboardCode>(code),
                                  flags, is_char)));
     view_manager_->DispatchEvent(
         view,
         Event::From(ui::KeyEvent(ui::ET_KEY_RELEASED,
                                  static_cast<ui::KeyboardCode>(code),
                                  flags, false)));
   }
 
+  // Overridden from NodeObserver:
+  virtual void OnNodeBoundsChanged(Node* parent,
+                                   const gfx::Rect& old_bounds,
+                                   const gfx::Rect& new_bounds) OVERRIDE {
+    gfx::Rect keyboard_bounds(node_->bounds());
+    keyboard_bounds.set_y(new_bounds.bottom() - keyboard_bounds.height());
+    keyboard_bounds.set_width(keyboard_bounds.width() +
+                              new_bounds.width() - old_bounds.width());
+    node_->SetBounds(keyboard_bounds);
+  }
+
+  // Overridden from NodeObserver:
+  virtual void OnNodeDestroying(Node* parent) OVERRIDE {
+    DCHECK_EQ(parent, node_->parent());
+    parent->RemoveObserver(this);
+  }
+
   KeyboardServicePtr keyboard_service_;
   ViewManager* view_manager_;
 
   // Node the keyboard is attached to.
   Node* node_;
 
   DISALLOW_COPY_AND_ASSIGN(KeyboardManager);
 };
 
 class RootLayoutManager : public NodeObserver {
  public:
-  explicit RootLayoutManager(ViewManager* view_manager,
-                             Node* root,
-                             Id content_node_id)
-                            : root_(root),
-                              view_manager_(view_manager),
-                              content_node_id_(content_node_id) {}
-  virtual ~RootLayoutManager() {}
+  RootLayoutManager(ViewManager* view_manager,
+                    Node* root,
+                    Id content_node_id,
+                    Id launcher_ui_node_id,
+                    Id control_panel_node_id)
+      : root_(root),
+        view_manager_(view_manager),
+        content_node_id_(content_node_id),
+        launcher_ui_node_id_(launcher_ui_node_id),
+        control_panel_node_id_(control_panel_node_id) {}
+  virtual ~RootLayoutManager() {
+    root_->RemoveObserver(this);
+  }
 
  private:
   // Overridden from NodeObserver:
   virtual void OnNodeBoundsChanged(Node* node,
-                                   const gfx::Rect& /*old_bounds*/,
+                                   const gfx::Rect& old_bounds,
                                    const gfx::Rect& new_bounds) OVERRIDE {
     DCHECK_EQ(node, root_);
+
     Node* content_node = view_manager_->GetNodeById(content_node_id_);
     content_node->SetBounds(new_bounds);
     // Force the view's bitmap to be recreated
     content_node->active_view()->SetColor(SK_ColorBLUE);
-    // TODO(hansmuller): Do Layout
+
+    int delta_width = new_bounds.width() - old_bounds.width();
+    int delta_height = new_bounds.height() - old_bounds.height();
+
+    Node* launcher_ui_node =
+        view_manager_->GetNodeById(launcher_ui_node_id_);
+    gfx::Rect launcher_ui_bounds(launcher_ui_node->bounds());
+    launcher_ui_bounds.set_width(launcher_ui_bounds.width() + delta_width);
+    launcher_ui_node->SetBounds(launcher_ui_bounds);
+
+    Node* control_panel_node =
+        view_manager_->GetNodeById(control_panel_node_id_);
+    gfx::Rect control_panel_bounds(control_panel_node->bounds());
+    control_panel_bounds.set_x(control_panel_bounds.x() + delta_width);
+    control_panel_node->SetBounds(control_panel_bounds);
+
+    const Node::Children& content_nodes = content_node->children();
+    Node::Children::const_iterator iter = content_nodes.begin();
+    for(; iter != content_nodes.end(); ++iter) {
+      Node* node = *iter;
+      if (node->id() == control_panel_node->id() ||
+          node->id() == launcher_ui_node->id())
+        continue;
+      gfx::Rect node_bounds(node->bounds());
+      node_bounds.set_width(node_bounds.width() + delta_width);
+      node_bounds.set_height(node_bounds.height() + delta_height);
+      node->SetBounds(node_bounds);
+    }
+  }
+
+  // Overridden from NodeObserver:
+  virtual void OnNodeDestroying(Node* node) OVERRIDE {
+    DCHECK_EQ(node, root_);
+    root_->RemoveObserver(this);
   }
 
   Node* root_;
   ViewManager* view_manager_;
-  Id content_node_id_;
+  const Id content_node_id_;
+  const Id launcher_ui_node_id_;
+  const Id control_panel_node_id_;
 
   DISALLOW_COPY_AND_ASSIGN(RootLayoutManager);
 };
 
 class WindowManager : public ApplicationDelegate,
                       public DebugPanel::Delegate,
                       public ViewManagerDelegate,
                       public ViewEventDispatcher {
  public:
   WindowManager()
@@ skipping 81 matching lines @@
   virtual void OnRootAdded(ViewManager* view_manager, Node* root) OVERRIDE {
     DCHECK(!view_manager_);
     view_manager_ = view_manager;
     view_manager_->SetEventDispatcher(this);
 
     Node* node = Node::Create(view_manager_);
     root->AddChild(node);
     node->SetBounds(gfx::Rect(root->bounds().size()));
     content_node_id_ = node->id();
 
-    root_layout_manager_.reset(
-        new RootLayoutManager(view_manager_, root, content_node_id_));
-    root->AddObserver(root_layout_manager_.get());
-
     View* view = View::Create(view_manager_);
     node->SetActiveView(view);
     view->SetColor(SK_ColorBLUE);
 
-    CreateLauncherUI();
-    CreateControlPanel(node);
+    Id launcher_ui_id = CreateLauncherUI();
+    Id control_panel_id = CreateControlPanel(node);
+
+    root_layout_manager_.reset(
+        new RootLayoutManager(view_manager, root,
+                              content_node_id_,
+                              launcher_ui_id,
+                              control_panel_id));
+    root->AddObserver(root_layout_manager_.get());
   }
   virtual void OnViewManagerDisconnected(ViewManager* view_manager) OVERRIDE {
     DCHECK_EQ(view_manager_, view_manager);
     view_manager_ = NULL;
     base::MessageLoop::current()->Quit();
   }
 
   // Overridden from ViewEventDispatcher:
   virtual void DispatchEvent(View* target, EventPtr event) OVERRIDE {
     // TODO(beng): More sophisticated focus handling than this is required!
@@ skipping 36 matching lines @@
         dest_node = windows_.back();
     }
 
     if (dest_node)
       Embed(dest_node, handler_url, nav_details.Pass(), response.Pass());
     else
       CreateWindow(handler_url, nav_details.Pass(), response.Pass());
   }
 
   // TODO(beng): proper layout manager!!
-  void CreateLauncherUI() {
+  Id CreateLauncherUI() {
     navigation::NavigationDetailsPtr nav_details;
     navigation::ResponseDetailsPtr response;
     Node* node = view_manager_->GetNodeById(content_node_id_);
     gfx::Rect bounds = node->bounds();
     bounds.Inset(kBorderInset, kBorderInset);
     bounds.set_height(kTextfieldHeight);
     launcher_ui_ = CreateChild(content_node_id_, "mojo:mojo_browser", bounds,
                                nav_details.Pass(), response.Pass());
+    return launcher_ui_->id();
   }
 
   void CreateWindow(const std::string& handler_url,
                     navigation::NavigationDetailsPtr nav_details,
                     navigation::ResponseDetailsPtr response) {
     Node* node = view_manager_->GetNodeById(content_node_id_);
     gfx::Rect bounds(kBorderInset,
                      2 * kBorderInset + kTextfieldHeight,
                      node->bounds().width() - 3 * kBorderInset -
                          kControlPanelWidth,
@@ skipping 31 matching lines @@
       app_->ConnectToService(app_url, &navigator);
       navigator->Navigate(node->id(), nav_details.Pass(), response.Pass());
     }
   }
 
   bool IsDescendantOfKeyboard(View* target) {
     return keyboard_manager_.get() &&
         keyboard_manager_->node()->Contains(target->node());
   }
 
-  void CreateControlPanel(view_manager::Node* root) {
+  Id CreateControlPanel(view_manager::Node* root) {
     Node* node = Node::Create(view_manager_);
     View* view = view_manager::View::Create(view_manager_);
     root->AddChild(node);
     node->SetActiveView(view);
 
     gfx::Rect bounds(root->bounds().width() - kControlPanelWidth -
                          kBorderInset,
                      kBorderInset * 2 + kTextfieldHeight,
                      kControlPanelWidth,
                      root->bounds().height() - kBorderInset * 3 -
                          kTextfieldHeight);
     node->SetBounds(bounds);
 
     debug_panel_ = new DebugPanel(this, node);
+    return node->id();
   }
 
   scoped_ptr<ViewsInit> views_init_;
   DebugPanel* debug_panel_;
   launcher::LauncherPtr launcher_;
   Node* launcher_ui_;
   std::vector<Node*> windows_;
   ViewManager* view_manager_;
   scoped_ptr<RootLayoutManager> root_layout_manager_;
 
@@ skipping 31 matching lines @@
 }
 
 }  // namespace examples
 
 // static
 ApplicationDelegate* ApplicationDelegate::Create() {
   return new examples::WindowManager;
 }
 
 }  // namespace mojo