Move maximize/fullscreen/restore to shell

ui/aura/window.cc

 // Copyright (c) 2011 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 "ui/aura/window.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "ui/aura/desktop.h"
 #include "ui/aura/desktop_delegate.h"
 #include "ui/aura/event.h"
 #include "ui/aura/event_filter.h"
 #include "ui/aura/layout_manager.h"
 #include "ui/aura/window_delegate.h"
 #include "ui/aura/window_observer.h"
 #include "ui/aura/window_types.h"
 #include "ui/base/animation/multi_animation.h"
 #include "ui/base/view_prop.h"
 #include "ui/gfx/canvas_skia.h"
 #include "ui/gfx/compositor/compositor.h"
 #include "ui/gfx/screen.h"
 
 namespace aura {
 
 Window::Window(WindowDelegate* delegate)
     : type_(WINDOW_TYPE_UNKNOWN),
       delegate_(delegate),
-      show_state_(ui::SHOW_STATE_NORMAL),
       parent_(NULL),
       transient_parent_(NULL),
       id_(-1),
       user_data_(NULL),
       stops_event_propagation_(false) {
 }
 
 Window::~Window() {
   // Let the delegate know we're in the processing of destroying.
   if (delegate_)
@@ skipping 55 matching lines @@
   if (Desktop::GetInstance()->active_window() == this ||
       !Desktop::GetInstance()->active_window()) {
     Desktop::GetInstance()->ActivateTopmostWindow();
   }
 }
 
 bool Window::IsVisible() const {
   return layer_->IsDrawn();
 }
 
-void Window::Maximize() {
-  // The desktop size may have changed, so make sure the window is maximized to
-  // the correct size even if it's already maximized.
-  gfx::Rect rect = gfx::Screen::GetMonitorWorkAreaNearestWindow(this);
-  if (UpdateShowStateAndRestoreBounds(ui::SHOW_STATE_MAXIMIZED) ||
-      rect != bounds())
-    SetBoundsInternal(rect);
-}
-
-void Window::Fullscreen() {
-  // The desktop size may have changed, so make sure the window is fullscreen to
-  // the correct size even if it's already fullscreen.
-  gfx::Rect rect = gfx::Screen::GetMonitorAreaNearestWindow(this);
-  if (UpdateShowStateAndRestoreBounds(ui::SHOW_STATE_FULLSCREEN) ||
-      rect != bounds())
-    SetBoundsInternal(rect);
-}
-
-void Window::Restore() {
-  if (show_state_ != ui::SHOW_STATE_NORMAL) {
-    show_state_ = ui::SHOW_STATE_NORMAL;
-    SetBoundsInternal(restore_bounds_);
-    restore_bounds_.SetRect(0, 0, 0, 0);
-  }
-}
-
 gfx::Rect Window::GetScreenBounds() const {
   const gfx::Rect local_bounds = bounds();
   gfx::Point origin = local_bounds.origin();
   Window::ConvertPointToWindow(parent_,
                                aura::Desktop::GetInstance(),
                                &origin);
   return gfx::Rect(origin, local_bounds.size());
 }
 
 void Window::Activate() {
@@ skipping 19 matching lines @@
 
 void Window::SetTransform(const ui::Transform& transform) {
   layer()->SetTransform(transform);
 }
 
 void Window::SetLayoutManager(LayoutManager* layout_manager) {
   layout_manager_.reset(layout_manager);
 }
 
 void Window::SetBounds(const gfx::Rect& new_bounds) {
-  gfx::Rect adjusted_bounds = new_bounds;
   if (parent_ && parent_->layout_manager())
-    parent_->layout_manager()->CalculateBoundsForChild(this, &adjusted_bounds);
-
-  if (show_state_ == ui::SHOW_STATE_MAXIMIZED ||
-      show_state_ == ui::SHOW_STATE_FULLSCREEN) {
-    restore_bounds_ = adjusted_bounds;
-    return;
-  }
-  SetBoundsInternal(adjusted_bounds);
+    parent_->layout_manager()->SetChildBounds(this, new_bounds);
+  else
+    SetBoundsInternal(new_bounds);
 }
 
 gfx::Rect Window::GetTargetBounds() const {
   return layer_->GetTargetBounds();
 }
 
 const gfx::Rect& Window::bounds() const {
   return layer_->bounds();
 }
 
@@ skipping 211 matching lines @@
 }
 
 Window* Window::GetToplevelWindow() {
   Window* window = this;
   while (window && window->parent() &&
          !window->parent()->AsToplevelWindowContainer())
     window = window->parent();
   return window && window->parent() ? window : NULL;
 }
 
-bool Window::IsOrContainsFullscreenWindow() const {
-  if (delegate_)
-    return IsVisible() && show_state_ == ui::SHOW_STATE_FULLSCREEN;
-
-  for (Windows::const_iterator it = children_.begin();
-       it != children_.end(); ++it) {
-    if ((*it)->IsOrContainsFullscreenWindow())
-      return true;
-  }
-  return false;
-}
-
 void Window::SetProperty(const char* name, void* value) {
+  void* old = GetProperty(name);
   ui::ViewProp* prop = prop_map_[name];
   delete prop;
   if (value)
     prop_map_[name] = new ui::ViewProp(this, name, value);
   else
     prop_map_.erase(name);
+  FOR_EACH_OBSERVER(WindowObserver, observers_,
+                    OnPropertyChanged(this, name, old));
+}
+
+void Window::SetIntProperty(const char* name, int value) {
+  SetProperty(name, reinterpret_cast<void*>(value));
 }
 
 void* Window::GetProperty(const char* name) const {
   return ui::ViewProp::GetValue(const_cast<gfx::NativeView>(this), name);
 }
 
+int Window::GetIntProperty(const char* name) const {
+  return static_cast<int>(reinterpret_cast<intptr_t>(
+      GetProperty(name)));
+}
+
 Desktop* Window::GetDesktop() {
   return parent_ ? parent_->GetDesktop() : NULL;
 }
 
 void Window::SetBoundsInternal(const gfx::Rect& new_bounds) {
   const gfx::Rect old_bounds = bounds();
   if (old_bounds == new_bounds)
     return;
 
   bool was_move = old_bounds.size() == new_bounds.size();
@@ skipping 30 matching lines @@
 }
 
 void Window::SchedulePaint() {
   SchedulePaintInRect(gfx::Rect(0, 0, bounds().width(), bounds().height()));
 }
 
 bool Window::StopsEventPropagation() const {
   return stops_event_propagation_ && !children_.empty();
 }
 
-bool Window::UpdateShowStateAndRestoreBounds(
-    ui::WindowShowState new_show_state) {
-  if (show_state_ == new_show_state)
-    return false;
-  show_state_ = new_show_state;
-  if (restore_bounds_.IsEmpty())
-    restore_bounds_ = bounds();
-  return true;
-}
-
 Window* Window::GetWindowForPoint(const gfx::Point& local_point,
                                   bool return_tightest,
                                   bool for_event_handling) {
   if (!IsVisible())
     return NULL;
 
   if ((for_event_handling && !HitTest(local_point)) ||
       (!for_event_handling && !ContainsPoint(local_point)))
     return NULL;
 
@@ skipping 23 matching lines @@
 
 void Window::OnPaintLayer(gfx::Canvas* canvas) {
   delegate_->OnPaint(canvas);
 }
 
 void Window::OnLayerAnimationEnded(
     const ui::LayerAnimationSequence* animation) {
 }
 
 }  // namespace aura