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 31 matching lines @@
 }
 
 #if defined(OS_WIN)
 class NativeViewAccessibilityWin;
 #endif
 
 namespace views {
 
 class Background;
 class Border;
+class CallbackLock;
 class ContextMenuController;
 class DragController;
 class FocusManager;
 class FocusTraversable;
 class InputMethod;
 class LayerPropertySetter;
 class LayoutManager;
 class ScrollView;
 class TextInputClient;
 class Widget;
@@ skipping 177 matching lines @@
   virtual bool IsVisibleInRootView() const;
 
   // Set whether this view is enabled. A disabled view does not receive keyboard
   // or mouse inputs. If flag differs from the current value, SchedulePaint is
   // invoked.
   void SetEnabled(bool enabled);
 
   // Returns whether the view is enabled.
   virtual bool IsEnabled() const;
 
+  //TODO(vollick) return a ref-counted lock that releases painting when destroyed.

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

+80

+  //These methods are dangerous.
+  void SetPaintingEnabled(bool enabled);
+  bool IsPaintingEnabled() const;
+
   // Transformations -----------------------------------------------------------
 
   // Methods for setting transformations for a view (e.g. rotation, scaling).
 
   const ui::Transform& GetTransform() const;
 
   // Clipping parameters. Clipping happens from the right and/or bottom. The
   // clipping amount is in parent's coordinate system, as in, if the view is
   // rotated, then the clipping will be applied after the rotation (and other
   // transformations, if any).
@@ skipping 152 matching lines @@
   static void ConvertPointToView(const View* src,
                                  const View* dst,
                                  gfx::Point* point);
 
   // Convert a point from the coordinate system of a View to that of the
   // Widget. This is useful for example when sizing HWND children of the
   // Widget that don't know about the View hierarchy and need to be placed
   // relative to the Widget that is their parent.
   static void ConvertPointToWidget(const View* src, gfx::Point* point);
 
+  // TODO(vollick) get from Sadrul's fix
+  static void ConvertRectToWidget(const View* src, gfx::Rect* rect);
+
   // Convert a point from a view Widget to a View dest
   static void ConvertPointFromWidget(const View* dest, gfx::Point* p);
 
   // Convert a point from the coordinate system of a View to that of the
   // screen. This is useful for example when placing popup windows.
   static void ConvertPointToScreen(const View* src, gfx::Point* point);
 
   // Applies transformation on the rectangle, which is in the view's coordinate
   // system, to convert it into the parent's coordinate system.
   gfx::Rect ConvertRectToParent(const gfx::Rect& rect) const;
 
   // Painting ------------------------------------------------------------------
 
   // Mark all or part of the View's bounds as dirty (needing repaint).
   // |r| is in the View's coordinates.
   // Rectangle |r| should be in the view's coordinate system. The
   // transformations are applied to it to convert it into the parent coordinate
   // system before propagating SchedulePaint up the view hierarchy.
   // TODO(beng): Make protected.
   virtual void SchedulePaint();
   virtual void SchedulePaintInRect(const gfx::Rect& r);
 
+  virtual void ScheduleComposite();
+  virtual void ScheduleCompositeInRect(const gfx::Rect& r);
+
   // Called by the framework to paint a View. Performs translation and clipping
   // for View coordinates and language direction as required, allows the View
   // to paint itself via the various OnPaint*() event handlers and then paints
   // the hierarchy beneath it.
   virtual void Paint(gfx::Canvas* canvas);
 
   // The background object is owned by this object and may be NULL.
   void set_background(Background* b) { background_.reset(b); }
   const Background* background() const { return background_.get(); }
   Background* background() { return background_.get(); }
@@ skipping 716 matching lines @@
   static void ConvertPointToView(const View* src,
                                  const View* dst,
                                  gfx::Point* point,
                                  bool try_other_direction);
 
   // Convert a point in the view's coordinate to an ancestor view's coordinate
   // system using necessary transformations. Returns whether the point was
   // successfully converted to the ancestor's coordinate system.
   bool ConvertPointForAncestor(const View* ancestor, gfx::Point* point) const;
 
+  // TODO(vollick) use Sadrul's fix;
+  bool ConvertRectForAncestor(const View* ancestor, gfx::Rect* rect) 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 ------------------------------------------------------
 
   // Returns true if this view should paint to layer.
   bool ShouldPaintToLayer() const;
@@ skipping 209 matching lines @@
   // Next view to be focused when the Shift-Tab key combination is pressed.
   View* previous_focusable_view_;
 
   // Whether this view can be focused.
   bool focusable_;
 
   // Whether this view is focusable if the user requires full keyboard access,
   // even though it may not be normally focusable.
   bool accessibility_focusable_;
 
+  // Whether this view can be painted
+  bool painting_enabled_;
+
   // Context menus -------------------------------------------------------------
 
   // The menu controller.
   ContextMenuController* context_menu_controller_;
 
   // Drag and drop -------------------------------------------------------------
 
   DragController* drag_controller_;
 
   // Accessibility -------------------------------------------------------------
 
   // The Windows-specific accessibility implementation for this view.
 #if defined(OS_WIN)
   scoped_refptr<NativeViewAccessibilityWin> native_view_accessibility_win_;
 #endif
 
   DISALLOW_COPY_AND_ASSIGN(View);
 };
 
 }  // namespace views
 
 #endif  // VIEWS_VIEW_H_