gfx::Transform API clean-up

ui/views/view.cc

 // Copyright (c) 2012 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.
 
+#define _USE_MATH_DEFINES // For VC++ to get M_PI. This has to be first.
+
 #include "ui/views/view.h"
 
 #include <algorithm>
+#include <cmath>
 
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/stringprintf.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"
@@ skipping 307 matching lines @@
 gfx::Rect View::GetVisibleBounds() const {
   if (!IsDrawn())
     return gfx::Rect();
   gfx::Rect vis_bounds(GetLocalBounds());
   gfx::Rect ancestor_bounds;
   const View* view = this;
   gfx::Transform transform;
 
   while (view != NULL && !vis_bounds.IsEmpty()) {
     transform.ConcatTransform(view->GetTransform());
-    transform.ConcatTranslate(static_cast<float>(view->GetMirroredX()),
-                              static_cast<float>(view->y()));
+    gfx::Transform translation;
+    translation.Translate(static_cast<float>(view->GetMirroredX()),
+                          static_cast<float>(view->y()));
+    transform.ConcatTransform(translation);
 
     vis_bounds = view->ConvertRectToParent(vis_bounds);
     const View* ancestor = view->parent_;
     if (ancestor != NULL) {
       ancestor_bounds.SetRect(0, 0, ancestor->width(), ancestor->height());
       vis_bounds.Intersect(ancestor_bounds);
     } else if (!view->GetWidget()) {
       // If the view has no Widget, we're not visible. Return an empty rect.
       return gfx::Rect();
     }
@@ skipping 1078 matching lines @@
 
   base::snprintf(bounds_buffer,
                  arraysize(bounds_buffer),
                  "\\n bounds: (%d, %d), (%dx%d)",
                  bounds().x(),
                  bounds().y(),
                  bounds().width(),
                  bounds().height());
   result.append(bounds_buffer);
 
-  if (!GetTransform().IsIdentity()) {
-    gfx::Point translation;
-    float rotation;
-    gfx::Point3F scale;
-    if (ui::InterpolatedTransform::FactorTRS(GetTransform(),
-                                             &translation,
-                                             &rotation,
-                                             &scale)) {
-      if (!translation.IsOrigin()) {
-        base::snprintf(bounds_buffer,
-                       arraysize(bounds_buffer),
-                       "\\n translation: (%d, %d)",
-                       translation.x(),
-                       translation.y());
-        result.append(bounds_buffer);
-      }
+  gfx::DecomposedTransform decomp;
+  if (!GetTransform().IsIdentity() &&
+      gfx::DecomposeTransform(&decomp, GetTransform())) {
+    base::snprintf(bounds_buffer,
+                   arraysize(bounds_buffer),
+                   "\\n translation: (%f, %f)",
+                   decomp.translate[0],
+                   decomp.translate[1]);
+    result.append(bounds_buffer);
 
-      if (fabs(rotation) > 1e-5) {
-        base::snprintf(bounds_buffer,
-                       arraysize(bounds_buffer),
-                       "\\n rotation: %3.2f", rotation);
-        result.append(bounds_buffer);
-      }
+    base::snprintf(bounds_buffer,
+                   arraysize(bounds_buffer),
+                   "\\n rotation: %3.2f",
+                   std::acos(decomp.quaternion[3]) * 360.0 / M_PI);
+    result.append(bounds_buffer);
 
-      if (!gfx::ToFlooredPoint(scale.AsPointF()).IsOrigin()) {
-        base::snprintf(bounds_buffer,
-                       arraysize(bounds_buffer),
-                       "\\n scale: (%2.4f, %2.4f)",
-                       scale.x(),
-                       scale.y());
-        result.append(bounds_buffer);
-      }
-    }
+    base::snprintf(bounds_buffer,
+                   arraysize(bounds_buffer),
+                   "\\n scale: (%2.4f, %2.4f)",
+                   decomp.scale[0],
+                   decomp.scale[1]);
+    result.append(bounds_buffer);
   }
 
   result.append("\"");
   if (!parent_)
     result.append(", shape=box");
   if (layer()) {
     if (layer()->texture())
       result.append(", color=green");
     else
       result.append(", color=red");
@@ skipping 313 matching lines @@
 }
 
 // Transformations -------------------------------------------------------------
 
 bool View::GetTransformRelativeTo(const View* ancestor,
                                   gfx::Transform* transform) const {
   const View* p = this;
 
   while (p && p != ancestor) {
     transform->ConcatTransform(p->GetTransform());
-    transform->ConcatTranslate(static_cast<float>(p->GetMirroredX()),
-                               static_cast<float>(p->y()));
+    gfx::Transform translation;
+    translation.Translate(static_cast<float>(p->GetMirroredX()),
+                          static_cast<float>(p->y()));
+    transform->ConcatTransform(translation);
 
     p = p->parent_;
   }
 
   return p == ancestor;
 }
 
 // Coordinate conversion -------------------------------------------------------
 
 bool View::ConvertPointForAncestor(const View* ancestor,
@@ skipping 343 matching lines @@
   ConvertPointToWidget(this, &widget_location);
   GetWidget()->RunShellDrag(this, data, widget_location, drag_operations,
       source);
   return true;
 #else
   return false;
 #endif  // !defined(OS_MACOSX)
 }
 
 }  // namespace views