Formatting changes.

Review URL: http://codereview.chromium.org/7307014

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@91595 0039d316-1c4b-4281-b951-d872f2087c98

1 files changed, 141 insertions, 88 deletions

diff --git a/ppapi/cpp/rect.h b/ppapi/cpp/rect.h
index 399b112..7d354df 100644
--- a/ppapi/cpp/rect.h
+++ b/ppapi/cpp/rect.h
@@ -19,8 +19,8 @@ namespace pp {
 class Rect {
  public:
 
-  /// The default constructor. Creates a Rect in the upper-left starting
-  /// coordinate at 0,0 and height and width of 0.
+  /// The default constructor. Creates a <code>Rect</code> in the upper-left
+  /// at 0,0 with height and width of 0.
   Rect() {
     rect_.point.x = 0;
     rect_.point.y = 0;
@@ -28,9 +28,11 @@ class Rect {
     rect_.size.height = 0;
   }
 
-  /// A constructor accepting a reference to a PP_Rect and converting the
-  /// PP_Rect to a Rect. This is an implicit conversion constructor.
-  /// @param[in] rect A pointer to a PP_Rect.
+  /// A constructor accepting a reference to a <code>PP_Rect and</code>
+  /// converting the <code>PP_Rect</code> to a <code>Rect</code>. This is an
+  /// implicit conversion constructor.
+  ///
+  /// @param[in] rect A <code>PP_Rect</code>.
   Rect(const PP_Rect& rect) {  // Implicit.
     set_x(rect.point.x);
     set_y(rect.point.y);
@@ -39,8 +41,9 @@ class Rect {
   }
 
   /// A constructor accepting two int32_t values for width and height and
-  /// converting them to a Rect in the upper-left starting coordinate of
-  /// 0,0.
+  /// converting them to a <code>Rect</code> in the upper-left starting
+  /// coordinate of 0,0.
+  ///
   /// @param[in] w An int32_t value representing a width.
   /// @param[in] h An int32_t value representing a height.
   Rect(int32_t w, int32_t h) {
@@ -51,6 +54,7 @@ class Rect {
   }
 
   /// A constructor accepting four int32_t values for width, height, x, and y.
+  ///
   /// @param[in] x An int32_t value representing a horizontal coordinate
   /// of a point, starting with 0 as the left-most coordinate.
   /// @param[in] y An int32_t value representing a vertical coordinate
@@ -64,21 +68,25 @@ class Rect {
     set_height(h);
   }
 
-  /// A constructor accepting a pointer to a Size and converting the Size to a
-  /// Rect in the upper-left starting coordinate of 0,0.
-  /// @param[in] s A pointer to a Size.
+  /// A constructor accepting a pointer to a Size and converting the
+  /// <code>Size</code> to a <code>Rect</code> in the upper-left starting
+  /// coordinate of 0,0.
+  ///
+  /// @param[in] s A pointer to a <code>Size</code>.
   explicit Rect(const Size& s) {
     set_x(0);
     set_y(0);
     set_size(s);
   }
 
-  /// A constructor accepting a pointer to a Point representing the origin
-  /// of the rectangle and a pointer to a Size representing the height and
-  /// width.
-  /// @param[in] origin A pointer to a Point representing the upper-left
-  /// starting coordinate.
-  /// @param[in] size A pointer to a Size representing the height and width.
+  /// A constructor accepting a pointer to a <code>Point</code> representing
+  /// the origin of the rectangle and a pointer to a Size representing the
+  /// height and width.
+  ///
+  /// @param[in] origin A pointer to a <code>Point<code> representing the
+  /// upper-left starting coordinate.
+  /// @param[in] size A pointer to a <code>Size</code> representing the height
+  /// and width.
   Rect(const Point& origin, const Size& size) {
     set_point(origin);
     set_size(size);
@@ -88,56 +96,66 @@ class Rect {
   ~Rect() {
   }
 
-  /// A function allowing implicit conversion of a Rect to a PP_Rect.
-  /// @return A Point.
+  /// PP_Rect() allows implicit conversion of a <code>Rect</code> to a
+  /// <code>PP_Rect</code>.
+  ///
+  /// @return A <code>Point</code>.
   operator PP_Rect() const {
     return rect_;
   }
 
-  /// Getter function for returning the internal PP_Rect struct.
-  /// @return A const reference to the internal PP_Rect struct.
+  /// Getter function for returning the internal <code>PP_Rect</code> struct.
+  ///
+  /// @return A const reference to the internal <code>PP_Rect</code> struct.
   const PP_Rect& pp_rect() const {
     return rect_;
   }
 
-  /// Getter function for returning the internal PP_Rect struct.
-  /// @return A mutable reference to the PP_Rect struct.
+  /// Getter function for returning the internal <code>PP_Rect</code> struct.
+  ///
+  /// @return A mutable reference to the <code>PP_Rect</code> struct.
   PP_Rect& pp_rect() {
     return rect_;
   }
 
 
   /// Getter function for returning the value of x.
-  /// @return The value of x for this Point.
+  ///
+  /// @return The value of x for this <code>Point</code>.
   int32_t x() const {
     return rect_.point.x;
   }
 
   /// Setter function for setting the value of x.
+  ///
   /// @param[in] in_x A new x value.
   void set_x(int32_t in_x) {
     rect_.point.x = in_x;
   }
 
   /// Getter function for returning the value of y.
-  /// @return The value of y for this Point.
+  ///
+  /// @return The value of y for this <code>Point</code>.
   int32_t y() const {
     return rect_.point.y;
   }
 
   /// Setter function for setting the value of y.
+  ///
   /// @param[in] in_y A new y value.
   void set_y(int32_t in_y) {
     rect_.point.y = in_y;
   }
 
   /// Getter function for returning the value of width.
-  /// @return The value of width for this Rect.
+  ///
+  /// @return The value of width for this <code>Rect</code>.
   int32_t width() const {
     return rect_.size.width;
   }
 
   /// Setter function for setting the value of width.
+  ///
   /// @param[in] w A new width value.
   void set_width(int32_t w) {
     if (w < 0) {
@@ -148,12 +166,14 @@ class Rect {
   }
 
   /// Getter function for returning the value of height.
-  /// @return The value of height for this Rect.
+  ///
+  /// @return The value of height for this <code>Rect</code>.
   int32_t height() const {
     return rect_.size.height;
   }
 
   /// Setter function for setting the value of height.
+  ///
   /// @param[in] h A new width height.
   void set_height(int32_t h) {
     if (h < 0) {
@@ -163,27 +183,32 @@ class Rect {
     rect_.size.height = h;
   }
 
-  /// Getter function for returning the Point.
-  /// @return A Point.
+  /// Getter function for returning the <code>Point</code>.
+  ///
+  /// @return A <code>Point</code>.
   Point point() const {
     return Point(rect_.point);
   }
 
-  /// Setter function for setting the value of the Point.
-  /// @param[in] origin A Point representing the upper-left
+  /// Setter function for setting the value of the <code>Point</code>.
+  ///
+  /// @param[in] origin A <code>Point</code> representing the upper-left
   /// starting coordinate.
   void set_point(const Point& origin) {
     rect_.point = origin;
   }
 
-  /// Getter function for returning the Size.
+  /// Getter function for returning the <code>Size</code>.
+  ///
   /// @return The size of the rectangle.
   Size size() const {
     return Size(rect_.size);
   }
 
-  /// Setter function for setting the Size.
-  /// @param[in] s A pointer to a Size representing the height and width.
+  /// Setter function for setting the <code>Size</code>.
+  ///
+  /// @param[in] s A pointer to a <code>Size</code> representing the height
+  /// and width.
   void set_size(const Size& s) {
     rect_.size.width = s.width();
     rect_.size.height = s.height();
@@ -211,7 +236,8 @@ class Rect {
     return y() + height();
   }
 
-  /// Setter function for setting the value of the Rect.
+  /// Setter function for setting the value of the <code>Rect</code>.
+  ///
   /// @param[in] x A new x value.
   /// @param[in] y A new y value.
   /// @param[in] w A new width value.
@@ -223,14 +249,16 @@ class Rect {
     set_height(h);
   }
 
-  /// Setter function for setting the value of the Rect.
-  /// @param[in] rect A pointer to a PP_Rect.
+  /// Setter function for setting the value of the <code>Rect</code>.
+  ///
+  /// @param[in] rect A pointer to a <code>PP_Rect</code>.
   void SetRect(const PP_Rect& rect) {
     rect_ = rect;
   }
 
-  /// A function used to shrink the rectangle by a horizontal and vertical
+  /// Inset() shrinks the rectangle by a horizontal and vertical
   /// distance on all sides.
+  ///
   /// @param[in] horizontal An int32_t value representing a horizontal
   /// shrinking distance.
   /// @param[in] vertical An int32_t value representing a vertical
@@ -239,8 +267,9 @@ class Rect {
     Inset(horizontal, vertical, horizontal, vertical);
   }
 
-  /// A function used to shrink the rectangle by the specified amount on each
+  /// Inset() shrinks the rectangle by the specified amount on each
   /// side.
+  ///
   /// @param[in] left An int32_t value representing a left
   /// shrinking distance.
   /// @param[in] top An int32_t value representing a top
@@ -251,97 +280,116 @@ class Rect {
   /// shrinking distance.
   void Inset(int32_t left, int32_t top, int32_t right, int32_t bottom);
 
-  /// A function used to move the rectangle by a horizontal and vertical
-  /// distance.
+  /// Offset() moves the rectangle by a horizontal and vertical distance.
+  ///
   /// @param[in] horizontal An int32_t value representing a horzontal
   /// move distance.
   /// @param[in] vertical An int32_t value representing a vertical
   /// move distance.
   void Offset(int32_t horizontal, int32_t vertical);
 
-  /// A function used to move the rectangle by a horizontal and vertical
-  /// distance.
-  /// @param[in] point A pointer to a Point representing the horizontal and
-  /// vertical move distances.
+  /// Offset() moves the rectangle by a horizontal and vertical distance.
+  ///
+  /// @param[in] point A pointer to a <code>Point</code> representing the
+  /// horizontal and vertical move distances.
   void Offset(const Point& point) {
     Offset(point.x(), point.y());
   }
 
-  /// A function used to determine if the area of a rectangle is zero.
-  ///  Returns true if the area of the rectangle is zero.
+  /// IsEmpty() determines if the area of a rectangle is zero. Returns true if
+  /// the area of the rectangle is zero.
+  ///
   /// @return True if the area of the rectangle is zero.
   bool IsEmpty() const {
     return rect_.size.width == 0 && rect_.size.height == 0;
   }
 
-  /// A function used to determine if the point identified by point_x and
-  /// point_y falls inside this rectangle. The point (x, y) is inside the
-  /// rectangle, but the point (x + width, y + height) is not.
+  /// Contains() determines if the point identified by point_x and point_y
+  /// falls inside this rectangle. The point (x, y) is inside the rectangle,
+  /// but the point (x + width, y + height) is not.
+  ///
   /// @param[in] point_x An int32_t value representing a x value.
   /// @param[in] point_y An int32_t value representing a y value.
+  ///
   /// @return True if the point_x and point_y fall inside the rectangle.
   bool Contains(int32_t point_x, int32_t point_y) const;
 
-  /// A function used to determine if the specified point is contained by this
+  /// Contains() determines if the specified point is contained by this
   /// rectangle.
+  ///
   /// @param[in] point A pointer to a Point representing a 2D coordinate.
+  ///
   /// @return True if the point_x and point_y fall inside the rectangle.
   bool Contains(const Point& point) const {
     return Contains(point.x(), point.y());
   }
 
-  /// A function used to determine if this rectangle contains the specified
-  /// rectangle.
-  /// @param[in] rect A pointer to a Rect.
+  /// Contains() determines if this rectangle contains the specified rectangle.
+  ///
+  /// @param[in] rect A pointer to a <code>Rect</code>.
+  ///
   /// @return True if the rectangle fall inside this rectangle.
   bool Contains(const Rect& rect) const;
 
-  /// A function used to determine if this rectangle intersects the specified
+  /// Insersects() determines if this rectangle intersects the specified
   /// rectangle.
-  /// @param[in] rect A pointer to a Rect.
+  ///
+  /// @param[in] rect A pointer to a <code>Rect</code>.
+  ///
   /// @return True if the rectangle intersects  this rectangle.
   bool Intersects(const Rect& rect) const;
 
-  /// A function used to compute the intersection of this rectangle with the
-  /// given rectangle.
-  /// @param[in] rect A pointer to a Rect.
-  /// @return A Rect representing the intersection.
+  /// Intersect() computes the intersection of this rectangle with the given
+  /// rectangle.
+  ///
+  /// @param[in] rect A pointer to a <code>Rect</code>.
+  ///
+  /// @return A <code>Rect</code> representing the intersection.
   Rect Intersect(const Rect& rect) const;
 
-  /// A function used to compute the union of this rectangle with the given
-  /// rectangle.  The union is the smallest rectangle containing both
-  /// rectangles.
-  /// @param[in] rect A pointer to a Rect.
-  /// @return A Rect representing the union.
+  /// Union() computes the union of this rectangle with the given rectangle.
+  /// The union is the smallest rectangle containing both rectangles.
+  ///
+  /// @param[in] rect A pointer to a <code>Rect</code>.
+  ///
+  /// @return A <code>Rect</code> representing the union.
   Rect Union(const Rect& rect) const;
 
-  /// A function used to compute the rectangle resulting from subtracting
-  /// |rect| from |this|.  If |rect| does not intersect completely in either
-  /// the x- or y-direction, then |*this| is returned. If |rect| contains
-  /// |this|, then an empty Rect is returned.
-  /// @param[in] rect A pointer to a Rect.
-  /// @return A Rect representing the subtraction.
+  /// Subtract() computes the rectangle resulting from subtracting
+  /// <code>rect</code> from this Rect.  If <code>rect</code>does not intersect
+  /// completely in either the x or y direction, then <code>*this</code> is
+  /// returned. If <code>rect<code> contains <code>this</code>, then an empty
+  /// <code>Rect</code> is returned.
+  ///
+  /// @param[in] rect A pointer to a <code>Rect</code>.
+  ///
+  /// @return A <code>Rect</code> representing the subtraction.
   Rect Subtract(const Rect& rect) const;
 
-  /// A function used to fit as much of the receiving rectangle within the
-  /// supplied rectangle as possible, returning the result. For example, if the
-  /// receiver had a x-location of 2 and a width of 4, and the supplied
+  /// AdjustToFit() fits as much of the receiving rectangle within
+  /// the supplied rectangle as possible, returning the result. For example,
+  /// if the receiver had a x-location of 2 and a width of 4, and the supplied
   /// rectangle had an x-location of 0 with a width of 5, the returned
   /// rectangle would have an x-location of 1 with a width of 4.
-  /// @param[in] rect A pointer to a Rect.
-  /// @return A Rect representing the difference between this rectangle and the
-  /// receiving rectangle.
+  ///
+  /// @param[in] rect A pointer to a <code>Rect</code>.
+  ///
+  /// @return A <code>Rect</code> representing the difference between this
+  /// rectangle and the receiving rectangle.
   Rect AdjustToFit(const Rect& rect) const;
 
-  /// A function used to determine the center of this rectangle.
-  /// @return A Point representing the center of this rectangle.
+  /// CenterPoint() determines the center of this rectangle.
+  ///
+  /// @return A <code>Point</code> representing the center of this rectangle.
   Point CenterPoint() const;
 
-  /// A function used to determine if this rectangle shares an entire edge
+  /// SharesEdgeWith() determines if this rectangle shares an entire edge
   /// (same width or same height) with the given rectangle, and the
   /// rectangles do not overlap.
-  /// @param[in] rect A pointer to a Rect.
-  /// @return TRUE if this rectangle and supplied rectangle share an edge.
+  ///
+  /// @param[in] rect A pointer to a <code>Rect</code>.
+  ///
+  /// @return true if this rectangle and supplied rectangle share an edge.
   bool SharesEdgeWith(const Rect& rect) const;
 
  private:
@@ -350,10 +398,12 @@ class Rect {
 
 }  // namespace pp
 
-/// Determines whether the x, y, width, and height values of two rectangles and
-/// are equal.
-/// @param[in] lhs The Rect on the left-hand side of the equation.
-/// @param[in] rhs The Rect on the right-hand side of the equation.
+/// This function determines whether the x, y, width, and height values of two
+/// rectangles and are equal.
+///
+/// @param[in] lhs The <code>Rect</code> on the left-hand side of the equation.
+/// @param[in] rhs The <code>Rect</code> on the right-hand side of the equation.
+///
 /// @return true if they are equal, false if unequal.
 inline bool operator==(const pp::Rect& lhs, const pp::Rect& rhs) {
   return lhs.x() == rhs.x() &&
@@ -362,9 +412,12 @@ inline bool operator==(const pp::Rect& lhs, const pp::Rect& rhs) {
          lhs.height() == rhs.height();
 }
 
-/// Determines whether two Rects are not equal.
-/// @param[in] lhs The Rect on the left-hand side of the equation.
-/// @param[in] rhs The Rect on the right-hand side of the equation.
+/// This function determines whether two Rects are not equal.
+///
+/// @param[in] lhs The <code>Rect</code> on the left-hand side of the equation.
+/// @param[in] rhs The <code>Rect</code> on the right-hand side of the
+/// equation.
+///
 /// @return true if the given Rects are equal, otherwise false.
 inline bool operator!=(const pp::Rect& lhs, const pp::Rect& rhs) {
   return !(lhs == rhs);