Animated Rotation

views/view.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 "views/view.h"
 
 #include <algorithm>
 
+#include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/utf_string_conversions.h"
 #include "third_party/skia/include/core/SkRect.h"
 #include "ui/base/accessibility/accessibility_types.h"
 #include "ui/base/dragdrop/drag_drop_types.h"
 #include "ui/gfx/canvas_skia.h"
 #include "ui/gfx/compositor/compositor.h"
 #include "ui/gfx/compositor/layer.h"
@@ skipping 15 matching lines @@
 #include "views/accessibility/native_view_accessibility_win.h"
 #endif
 #if defined(OS_LINUX)
 #include "ui/base/gtk/scoped_handle_gtk.h"
 #endif
 
 namespace {
 
 // Whether to use accelerated compositing when necessary (e.g. when a view has a
 // transformation).
-#if !defined(OS_CHROMEOS)
+//#if !defined(OS_CHROMEOS)

[Jói, 2011/06/30 19:50:50]

Should these commented-out lines be removed altogether?

 bool use_acceleration_when_possible = true;
-#else
-bool use_acceleration_when_possible = false;
-#endif
+//#else
+//bool use_acceleration_when_possible = false;
+//#endif
 
 // Saves the drawing state, and restores the state when going out of scope.
 class ScopedCanvas {
  public:
   explicit ScopedCanvas(gfx::Canvas* canvas) : canvas_(canvas) {
     if (canvas_)
       canvas_->Save();
   }
   ~ScopedCanvas() {
     if (canvas_)
@@ skipping 48 matching lines @@
       clip_y_(0.0),
       needs_layout_(true),
       flip_canvas_on_paint_for_rtl_ui_(false),
       accelerator_registration_delayed_(false),
       accelerator_focus_manager_(NULL),
       registered_accelerator_count_(0),
       next_focusable_view_(NULL),
       previous_focusable_view_(NULL),
       focusable_(false),
       accessibility_focusable_(false),
+      painting_enabled_(true),
       context_menu_controller_(NULL),
       drag_controller_(NULL) {
 }
 
 View::~View() {
   if (parent_)
     parent_->RemoveChildView(this);
 
   for (Views::const_iterator i(children_.begin()); i != children_.end(); ++i) {
     (*i)->parent_ = NULL;
@@ skipping 251 matching lines @@
 }
 
 int View::GetHeightForWidth(int w) {
   if (layout_manager_.get())
     return layout_manager_->GetPreferredHeightForWidth(this, w);
   return GetPreferredSize().height();
 }
 
 void View::SetVisible(bool visible) {
   if (visible != visible_) {
+    visible_ = visible;
     // If the tab is currently visible, schedule paint to refresh parent.
     if (visible_)
       SchedulePaint();
     else
       DestroyLayerRecurse();
 
-    visible_ = visible;
+     // This notifies all sub-views recursively.
+     PropagateVisibilityNotifications(this, visible_);
 
-    // This notifies all sub-views recursively.
-    PropagateVisibilityNotifications(this, visible_);
-
-    // If we are newly visible, schedule paint.
+     // If we are newly visible, schedule paint.
     if (visible_)
       SchedulePaint();
   }
 }
 
 bool View::IsVisible() const {
   return visible_;
 }
 
 bool View::IsVisibleInRootView() const {
   return IsVisible() && parent_ ? parent_->IsVisibleInRootView() : false;
 }
 
 void View::SetEnabled(bool enabled) {
   if (enabled != enabled_) {
     enabled_ = enabled;
     OnEnabledChanged();
   }
 }
 
 bool View::IsEnabled() const {
   return enabled_;
 }
 
 void View::OnEnabledChanged() {
   SchedulePaint();
 }
 
+void View::SetPaintingEnabled(bool enabled) {
+  painting_enabled_ = enabled;
+}
+
+bool View::IsPaintingEnabled() const {
+  return painting_enabled_;
+}
+
 // Transformations -------------------------------------------------------------
 
 const ui::Transform& View::GetTransform() const {
   static const ui::Transform* no_op = new ui::Transform;
   return transform() ? *transform() : *no_op;
 }
 
 void View::SetTransform(const ui::Transform& transform) {
   if (!transform.HasChange()) {
     if (!layer_helper_.get() || !this->transform())
       return;
     layer_helper_->SetTransform(transform);
 
     if (!ShouldPaintToLayer())
       DestroyLayerAndReparent();
     else if (layer())
       layer_helper_->property_setter()->SetTransform(layer(), transform);
 
     SchedulePaint();
   } else {
-    // Make sure if the view didn't have its own texture and was painting onto
-    // something else, that gets refreshed too.
-    if (!ShouldPaintToLayer())
-      MarkLayerDirty();
-
     if (!layer_helper_.get())
       layer_helper_.reset(new internal::LayerHelper());
     layer_helper_->SetTransform(transform);
     if (!layer()) {
       CreateLayer();
       SchedulePaint();
     } else {
       layer_helper_->property_setter()->SetTransform(layer(), transform);
-      // We have a layer. When the transform changes and the layer is up to
-      // date we don't want to SchedulePaint as it'll trigger painting to the
-      // layer. Instead we tell the Widget to paint, which makes the
-      // compositor draw using the existing layer.
-      // We schedule paint the complete bounds as compositor generally don't
-      // support partial painting.
-      Widget* widget = GetWidget();
-      if (widget)
-        widget->SchedulePaintInRect(widget->GetRootView()->bounds());
+      ScheduleComposite();
     }
   }
 }
 
 void View::SetPaintToLayer(bool value) {
   bool paint_to_layer = layer_helper_.get() && layer_helper_->paint_to_layer();
   if (value == paint_to_layer)
     return;
 
   if (value) {
@@ skipping 45 matching lines @@
   return base::i18n::IsRTL() ? width() - x : x;
 }
 
 int View::GetMirroredXWithWidthInView(int x, int w) const {
   return base::i18n::IsRTL() ? width() - x - w : x;
 }
 
 // Layout ----------------------------------------------------------------------
 
 void View::Layout() {
+  TRACE_EVENT0("View", "Layout");
   needs_layout_ = false;
 
   // If we have a layout manager, let it handle the layout for us.
   if (layout_manager_.get())
     layout_manager_->Layout(this);
 
   // Make sure to propagate the Layout() call to any children that haven't
   // received it yet through the layout manager and need to be laid out. This
   // is needed for the case when the child requires a layout but its bounds
   // weren't changed by the layout manager. If there is no layout manager, we
@@ skipping 98 matching lines @@
 
 // static
 void View::ConvertPointToWidget(const View* src, gfx::Point* p) {
   DCHECK(src);
   DCHECK(p);
 
   src->ConvertPointForAncestor(NULL, p);
 }
 
 // static
+void View::ConvertRectToWidget(const View* src, gfx::Rect* rect) {
+  DCHECK(src);
+  DCHECK(rect);
+
+  src->ConvertRectForAncestor(NULL, rect);
+}
+
+// static
 void View::ConvertPointFromWidget(const View* dest, gfx::Point* p) {
   DCHECK(dest);
   DCHECK(p);
 
   dest->ConvertPointFromAncestor(NULL, p);
 }
 
 // static
 void View::ConvertPointToScreen(const View* src, gfx::Point* p) {
   DCHECK(src);
@@ skipping 23 matching lines @@
 }
 
 void View::SchedulePaintInRect(const gfx::Rect& rect) {
   if (!IsVisible())
     return;
 
   MarkLayerDirty();
   SchedulePaintInternal(rect);
 }
 
+void View::ScheduleComposite() {
+  ScheduleCompositeInRect(GetLocalBounds());
+}
+
+void View::ScheduleCompositeInRect(const gfx::Rect& rect) {
+  if (!IsVisible())
+    return;
+
+  SchedulePaintInternal(rect);
+}
+
 void View::Paint(gfx::Canvas* canvas) {
-  if (!IsVisible())
+  TRACE_EVENT0("View", "Paint");
+  if (!IsVisible() || !IsPaintingEnabled())
     return;
 
   ScopedCanvas scoped_canvas(NULL);
   scoped_ptr<gfx::Canvas> layer_canvas;
   gfx::Rect layer_rect;
 
   if (layer()) {
     gfx::Rect dirty_rect;
     if (!layer_helper_->clip_rect().IsEmpty()) {
       dirty_rect = layer_helper_->clip_rect();
@@ skipping 454 matching lines @@
 }
 
 void View::OnPaintFocusBorder(gfx::Canvas* canvas) {
   if ((IsFocusable() || IsAccessibilityFocusableInRootView()) && HasFocus())
     canvas->DrawFocusRect(0, 0, width(), height());
 }
 
 // Accelerated Painting --------------------------------------------------------
 
 void View::PaintComposite() {
+  TRACE_EVENT0("View", "PaintComposite");
   if (!IsVisible())
     return;
 
   if (layer()) {
     OnWillCompositeLayer();
     layer()->Draw();
   }
 
   for (int i = 0, count = child_count(); i < count; ++i)
     GetChildViewAt(i)->PaintComposite();
@@ skipping 452 matching lines @@
 
 bool View::ConvertPointForAncestor(const View* ancestor,
                                    gfx::Point* point) const {
   ui::Transform trans;
   // TODO(sad): Have some way of caching the transformation results.
   bool result = GetTransformRelativeTo(ancestor, &trans);
   trans.TransformPoint(point);
   return result;
 }
 
+bool View::ConvertRectForAncestor(const View* ancestor,
+                                  gfx::Rect* rect) const {
+  ui::Transform trans;
+  // TODO(sad): Have some way of caching the transformation results.
+  bool result = GetTransformRelativeTo(ancestor, &trans);
+  trans.TransformRect(rect);
+  return result;
+}
+
 bool View::ConvertPointFromAncestor(const View* ancestor,
                                     gfx::Point* point) const {
   ui::Transform trans;
   bool result = GetTransformRelativeTo(ancestor, &trans);
   trans.TransformPointReverse(point);
   return result;
 }
 
 // Accelerated painting --------------------------------------------------------
 
@@ skipping 379 matching lines @@
     result.append(GetChildViewAt(i)->PrintViewGraph(false));
 
   if (first)
     result.append("}\n");
 
   return result;
 }
 #endif
 
 }  // namespace views