Adds sizing, maximizing, minimizing to simple_wm

mash/simple_wm/simple_wm.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 "mash/simple_wm/simple_wm.h"
 
 #include "base/observer_list.h"
 #include "base/strings/utf_string_conversions.h"
 #include "mash/simple_wm/move_event_handler.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/layout_manager.h"
 #include "ui/display/screen_base.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/geometry/mojo/geometry.mojom.h"
 #include "ui/views/controls/button/md_text_button.h"
 #include "ui/views/controls/label.h"
 #include "ui/views/mus/aura_init.h"
 #include "ui/views/mus/mus_client.h"
 #include "ui/views/widget/native_widget_aura.h"
 #include "ui/views/widget/widget.h"
 #include "ui/views/widget/widget_delegate.h"
 #include "ui/wm/core/default_activation_client.h"
 
 namespace simple_wm {
 
 namespace {
 
 const int kNonClientTopHeight = 24;
 const int kNonClientSize = 5;
+const int kNonClientMaximizedTopOverlap = 4;
 
 }  // namespace
 
 class SimpleWM::WindowListModelObserver {
  public:
   virtual void OnWindowAddedOrRemoved() = 0;
   virtual void OnWindowTitleChanged(size_t index,
                                     const base::string16& title) = 0;
 };
 
@@ skipping 86 matching lines @@
     for (int i = 0; i < child_count(); ++i) {
       View* v = child_at(i);
       gfx::Size ps = v->GetPreferredSize();
       gfx::Rect bounds(x_offset, kButtonSpacing, ps.width(), ps.height());
       v->SetBoundsRect(bounds);
       x_offset = bounds.right() + kButtonSpacing;
     }
   }
   void OnPaint(gfx::Canvas* canvas) override {
     canvas->DrawColor(SK_ColorLTGRAY);
+    gfx::Rect stroke_bounds = GetLocalBounds();
+    stroke_bounds.set_height(1);
+    canvas->FillRect(stroke_bounds, SK_ColorDKGRAY);
   }
   gfx::Size GetPreferredSize() const override {
     std::unique_ptr<views::MdTextButton> measure_button(
         views::MdTextButton::Create(nullptr, base::UTF8ToUTF16("Sample")));
     int height =
         measure_button->GetPreferredSize().height() + 2 * kButtonSpacing;
     return gfx::Size(0, height);
   }
 
  private:
@@ skipping 59 matching lines @@
                                                : base::UTF8ToUTF16("(Window)");
     // TODO(beng): quick hack to cause WindowObserver::OnWindowTitleChanged to
     //             fire.
     GetWidget()->GetNativeWindow()->SetTitle(title);
     return title;
   }
   void Layout() override {
     // Client offsets are applied automatically by the window service.
     gfx::Rect parent_bounds = GetWidget()->GetNativeWindow()->bounds();
     parent_bounds.set_origin(gfx::Point());
+
+    if (GetWidget()->IsMaximized()) {
+      parent_bounds.Inset(-kNonClientSize, -kNonClientMaximizedTopOverlap,
+                          -kNonClientSize, -kNonClientSize);
+    }
+
     client_window_->SetBounds(parent_bounds);
   }
+  bool CanMaximize() const override {
+    return (client_window_->GetProperty(aura::client::kResizeBehaviorKey) &
+        ui::mojom::kResizeBehaviorCanMaximize) != 0;
+  }
+
+  bool CanMinimize() const override {
+    return (client_window_->GetProperty(aura::client::kResizeBehaviorKey) &
+        ui::mojom::kResizeBehaviorCanMinimize) != 0;
+  }
+
+  bool CanResize() const override {
+    return (client_window_->GetProperty(aura::client::kResizeBehaviorKey) &
+        ui::mojom::kResizeBehaviorCanResize) != 0;
+  }
 
   // aura::WindowObserver:
   void OnWindowPropertyChanged(aura::Window* window, const void* key,
                                intptr_t old) override {
     if (key == aura::client::kTitleKey)
       GetWidget()->UpdateWindowTitle();
+    else if (key == aura::client::kResizeBehaviorKey)
+      GetWidget()->non_client_view()->frame_view()->Layout();
   }
 
   aura::Window* client_window_;
   std::unique_ptr<MoveEventHandler> move_event_handler_;
 
   DISALLOW_COPY_AND_ASSIGN(FrameView);
 };
 
+class SimpleWM::WorkspaceLayoutManager : public aura::WindowObserver {
+ public:
+  explicit WorkspaceLayoutManager(aura::Window* window_root)
+      : window_root_(window_root) {}
+  ~WorkspaceLayoutManager() override {}
+
+ private:
+  // aura::WindowObserver:
+  void OnWindowPropertyChanged(aura::Window* window, const void* key,
+                               intptr_t old) override {
+    if (key == aura::client::kShowStateKey) {
+      ui::WindowShowState show_state =
+          window->GetProperty(aura::client::kShowStateKey);
+      switch (show_state) {
+      case ui::SHOW_STATE_NORMAL:
+        window->Show();
+        window->SetBounds(
+            *window->GetProperty(aura::client::kRestoreBoundsKey));
+        break;
+      case ui::SHOW_STATE_MINIMIZED:
+        window->Hide();
+        break;
+      case ui::SHOW_STATE_MAXIMIZED:
+        window->Show();
+        window->SetProperty(aura::client::kRestoreBoundsKey,
+                            new gfx::Rect(window->bounds()));
+        window->SetBounds(gfx::Rect(window_root_->bounds().size()));
+        break;
+      default:
+        NOTREACHED();
+        break;
+      }
+    }
+  }
+  void OnWindowDestroying(aura::Window* window) override {
+    window->RemoveObserver(this);
+  }
+
+  aura::Window* window_root_;
+
+  DISALLOW_COPY_AND_ASSIGN(WorkspaceLayoutManager);
+};
+
 class SimpleWM::DisplayLayoutManager : public aura::LayoutManager {
  public:
   DisplayLayoutManager(aura::Window* display_root,
                        aura::Window* window_root,
                        SimpleWM::WindowListView* window_list_view)
       : display_root_(display_root),
         window_root_(window_root),
         window_list_view_(window_list_view) {}
   ~DisplayLayoutManager() override {}
 
@@ skipping 133 matching lines @@
   FrameView* frame_view = new FrameView(client_window);
   params.delegate = frame_view;
   params.native_widget = frame_native_widget;
   params.parent = window_root_;
   params.bounds = gfx::Rect(10, 10, 500, 500);
   frame_widget->Init(params);
   frame_widget->Show();
   frame_view->Init();
 
   frame_widget->GetNativeWindow()->AddChild(client_window);
+  frame_widget->GetNativeWindow()->AddObserver(workspace_layout_manager_.get());
 
   client_window_to_frame_view_[client_window] = frame_view;
   // TODO(beng): probably need to observe client_window from now on so we can
   // clean up this map.
 
   return client_window;
 }
 
 void SimpleWM::OnWmClientJankinessChanged(
     const std::set<aura::Window*>& client_windows,
     bool janky) {
   // Don't care.
 }
 
 void SimpleWM::OnWmWillCreateDisplay(const display::Display& display) {
   screen_->display_list().AddDisplay(display,
                                      display::DisplayList::Type::PRIMARY);
 }
 
 void SimpleWM::OnWmNewDisplay(
     std::unique_ptr<aura::WindowTreeHostMus> window_tree_host,
     const display::Display& display) {
   // Only handles a single root.
   DCHECK(!window_root_);
   window_tree_host_ = std::move(window_tree_host);
   window_tree_host_->InitHost();
   window_tree_host_->window()->Show();
   display_root_ = window_tree_host_->window();
   window_root_ = new aura::Window(nullptr);
-  window_root_->Init(ui::LAYER_NOT_DRAWN);
+  window_root_->Init(ui::LAYER_SOLID_COLOR);
+  window_root_->layer()->SetColor(SK_ColorWHITE);
   display_root_->AddChild(window_root_);
   window_root_->Show();
+  workspace_layout_manager_ =
+      base::MakeUnique<WorkspaceLayoutManager>(window_root_);
 
   window_list_model_ = base::MakeUnique<WindowListModel>(window_root_);
 
   views::Widget* window_list_widget = new views::Widget;
   views::NativeWidgetAura* window_list_widget_native_widget =
       new views::NativeWidgetAura(window_list_widget, true);
   views::Widget::InitParams params(views::Widget::InitParams::TYPE_CONTROL);
   WindowListView* window_list_view =
       new WindowListView(window_list_model_.get(),
                          base::Bind(&SimpleWM::OnWindowListViewItemActivated,
@@ skipping 44 matching lines @@
     const gfx::Insets& insets,
     const std::vector<gfx::Rect>& additional_client_areas) {}
 
 SimpleWM::FrameView* SimpleWM::GetFrameViewForClientWindow(
     aura::Window* client_window) {
   auto it = client_window_to_frame_view_.find(client_window);
   return it != client_window_to_frame_view_.end() ? it->second : nullptr;
 }
 
 void SimpleWM::OnWindowListViewItemActivated(aura::Window* window) {
+  window->Show();
   aura::client::ActivationClient* activation_client =
       aura::client::GetActivationClient(window->GetRootWindow());
   activation_client->ActivateWindow(window);
 }
 
 }  // namespace simple_wm