Animated Rotation

views/view.h

 // 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.
 
 #ifndef VIEWS_VIEW_H_
 #define VIEWS_VIEW_H_
 #pragma once
 
 #include <algorithm>
 #include <map>
@@ skipping 39 matching lines @@
 
 class Background;
 class Border;
 class ContextMenuController;
 class DragController;
 class FocusManager;
 class FocusTraversable;
 class InputMethod;
 class LayerPropertySetter;
 class LayoutManager;
+class PaintListener;
 class ScrollView;
 class TextInputClient;
 class Widget;
 
 namespace internal {
 class NativeWidgetView;
 class RootView;
 }
 
 /////////////////////////////////////////////////////////////////////////////
@@ skipping 399 matching lines @@
   Background* background() { return background_.get(); }
 
   // The border object is owned by this object and may be NULL.
   void set_border(Border* b) { border_.reset(b); }
   const Border* border() const { return border_.get(); }
   Border* border() { return border_.get(); }
 
   // Get the theme provider from the parent widget.
   virtual ui::ThemeProvider* GetThemeProvider() const;
 
+  // Add/Remove listeners that are notified when painting and compositing end.
+  // The view does not own the listeners, and it is the responsibility of the
+  // listener to remove itself when it is done listening.
+  void AddPaintListener(PaintListener* listener);
+  void RemovePaintListener(PaintListener* listener);
+
   // RTL painting --------------------------------------------------------------
 
   // This method determines whether the gfx::Canvas object passed to
   // View::Paint() needs to be transformed such that anything drawn on the
   // canvas object during View::Paint() is flipped horizontally.
   //
   // By default, this function returns false (which is the initial value of
   // |flip_canvas_on_paint_for_rtl_ui_|). View subclasses that need to paint on
   // a flipped gfx::Canvas when the UI layout is right-to-left need to call
   // EnableCanvasFlippingForRTLUI().
@@ skipping 608 matching lines @@
   // used by the public static method ExceededDragThreshold().
   static int GetHorizontalDragThreshold();
   static int GetVerticalDragThreshold();
 
  private:
   friend class internal::NativeWidgetView;
   friend class internal::RootView;
   friend class FocusManager;
   friend class ViewStorage;
   friend class Widget;
+  friend class PaintLock;
 
   // Used to track a drag. RootView passes this into
   // ProcessMousePressed/Dragged.
   struct DragInfo {
     // Sets possible_drag to false and start_x/y to 0. This is invoked by
     // RootView prior to invoke ProcessMousePressed.
     void Reset();
 
     // Sets possible_drag to true and start_pt to the specified point.
     // This is invoked by the target view if it detects the press may generate
@@ skipping 105 matching lines @@
   bool ConvertPointForAncestor(const View* ancestor, gfx::Point* point) const;
 
   // Convert a point in the ancestor's coordinate system to the view's
   // coordinate system using necessary transformations. Returns whether the
   // point was successfully from the ancestor's coordinate system to the view's
   // coordinate system.
   bool ConvertPointFromAncestor(const View* ancestor, gfx::Point* point) const;
 
   // Accelerated painting ------------------------------------------------------
 
+  // Disables painting during time-critical operations. Used by PaintLock.
+  void set_painting_enabled(bool enabled) { painting_enabled_ = enabled; }
+
   // Returns true if this view should paint to layer.
   bool ShouldPaintToLayer() const;
 
   // Creates the layer and related fields for this view.
   void CreateLayer();
 
   // Reparents any descendant layer to our current layer parent and destroys
   // this views layer.
   void DestroyLayerAndReparent();
 
@@ skipping 104 matching lines @@
 
   // This View's bounds in the parent coordinate system.
   gfx::Rect bounds_;
 
   // Whether this view is visible.
   bool visible_;
 
   // Whether this view is enabled.
   bool enabled_;
 
+  // Whether this view is painting.
+  bool painting_enabled_;
+
   // Whether or not RegisterViewForVisibleBoundsNotification on the RootView
   // has been invoked.
   bool registered_for_visible_bounds_notification_;
 
   // List of descendants wanting notification when their visible bounds change.
   scoped_ptr<Views> descendants_to_notify_;
 
   // Transformations -----------------------------------------------------------
 
   // Clipping parameters. skia transformation matrix does not give us clipping.
@@ skipping 11 matching lines @@
   scoped_ptr<LayoutManager> layout_manager_;
 
   // Painting ------------------------------------------------------------------
 
   // Background
   scoped_ptr<Background> background_;
 
   // Border.
   scoped_ptr<Border> border_;
 
+  // Listeners. These are not owned by the view.
+  std::set<PaintListener*> paint_listeners_;

[sky, 2011/08/26 19:10:25]

Use ObserverList (in base) for this.

I don't like making all views pay the cost of this. How about making it only for
views with layers and moving it to LayerHelper?

+
   // RTL painting --------------------------------------------------------------
 
   // Indicates whether or not the gfx::Canvas object passed to View::Paint()
   // is going to be flipped horizontally (using the appropriate transform) on
   // right-to-left locales for this View.
   bool flip_canvas_on_paint_for_rtl_ui_;
 
   // Accelerated painting ------------------------------------------------------
 
   scoped_ptr<internal::LayerHelper> layer_helper_;
@@ skipping 43 matching lines @@
 #if defined(OS_WIN)
   scoped_refptr<NativeViewAccessibilityWin> native_view_accessibility_win_;
 #endif
 
   DISALLOW_COPY_AND_ASSIGN(View);
 };
 
 }  // namespace views
 
 #endif  // VIEWS_VIEW_H_