ppapi/cpp/size.h

   1 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef PPAPI_CPP_SIZE_H_
   6 #define PPAPI_CPP_SIZE_H_
   7
   8 #include "ppapi/c/pp_size.h"
   9 #include "ppapi/cpp/logging.h"
  10
  11 /// @file
  12 /// This file defines the API to create a size based on width
  13 /// and height.
  14
  15 namespace pp {
  16
  17 /// A size of an object based on width and height.
  18 class Size {
  19  public:
  20
  21   /// The default constructor. Initializes the width and height to 0.
  22   Size() {
  23     size_.width = 0;
  24     size_.height = 0;
  25   }
  26
  27   /// A constructor accepting a pointer to a <code>PP_Size</code> and
  28   /// converting the <code>PP_Size</code> to a <code>Size</code>. This is an
  29   /// implicit conversion constructor.
  30   ///
  31   /// @param[in] s A pointer to a <code>PP_Size</code>.
  32   Size(const PP_Size& s) {  // Implicit.
  33     // Want the >= 0 checking of the setter.
  34     set_width(s.width);
  35     set_height(s.height);
  36   }
  37
  38   /// A constructor accepting two int values for width and height and
  39   /// converting them to a <code>Size</code>.
  40   ///
  41   /// @param[in] w An int value representing a width.
  42   /// @param[in] h An int value representing a height.
  43   Size(int w, int h) {
  44     // Want the >= 0 checking of the setter.
  45     set_width(w);
  46     set_height(h);
  47   }
  48
  49   /// Destructor.
  50   ~Size() {
  51   }
  52
  53   /// PP_Size() allows implicit conversion of a <code>Size</code> to a
  54   /// <code>PP_Size</code>.
  55   ///
  56   /// @return A Size.
  57   operator PP_Size() {
  58     return size_;
  59   }
  60
  61   /// Getter function for returning the internal <code>PP_Size</code> struct.
  62   ///
  63   /// @return A const reference to the internal <code>PP_Size</code> struct.
  64   const PP_Size& pp_size() const {
  65     return size_;
  66   }
  67
  68   /// Getter function for returning the internal <code>PP_Size</code> struct.
  69   ///
  70   /// @return A mutable reference to the <code>PP_Size</code> struct.
  71   PP_Size& pp_size() {
  72     return size_;
  73   }
  74
  75   /// Getter function for returning the value of width.
  76   ///
  77   /// @return The value of width for this <code>Size</code>.
  78   int width() const {
  79     return size_.width;
  80   }
  81
  82   /// Setter function for setting the value of width.
  83   ///
  84   /// @param[in] w A new width value.
  85   void set_width(int w) {
  86     if (w < 0) {
  87       PP_DCHECK(w >= 0);
  88       w = 0;
  89     }
  90     size_.width = w;
  91   }
  92
  93   /// Getter function for returning the value of height.
  94   ///
  95   /// @return The value of height for this <code>Size</code>.
  96   int height() const {
  97     return size_.height;
  98   }
  99
 100   /// Setter function for setting the value of height.
 101   ///
 102   /// @param[in] h A new height value.
 103   void set_height(int h) {
 104     if (h < 0) {
 105       PP_DCHECK(h >= 0);
 106       h = 0;
 107     }
 108     size_.height = h;
 109   }
 110
 111   /// GetArea() determines the area (width * height).
 112   ///
 113   /// @return The area.
 114   int GetArea() const {
 115     return width() * height();
 116   }
 117
 118   /// SetSize() sets the value of width and height.
 119   ///
 120   /// @param[in] w A new width value.
 121   /// @param[in] h A new height value.
 122   void SetSize(int w, int h) {
 123     set_width(w);
 124     set_height(h);
 125   }
 126
 127   /// Enlarge() enlarges the size of an object.
 128   ///
 129   /// @param[in] w A width to add the current width.
 130   /// @param[in] h A height to add to the current height.
 131   void Enlarge(int w, int h) {
 132     set_width(width() + w);
 133     set_height(height() + h);
 134   }
 135
 136   /// IsEmpty() determines if the size is zero.
 137   ///
 138   /// @return true if the size is zero.
 139   bool IsEmpty() const {
 140     // Size doesn't allow negative dimensions, so testing for 0 is enough.
 141     return (width() == 0) || (height() == 0);
 142   }
 143
 144  private:
 145   PP_Size size_;
 146 };
 147
 148 }  // namespace pp
 149
 150 /// This function determines whether the width and height values of two sizes
 151 /// are equal.
 152 ///
 153 /// @param[in] lhs The <code>Size</code> on the left-hand side of the equation.
 154 /// @param[in] rhs The <code>Size</code> on the right-hand side of the
 155 /// equation.
 156 ///
 157 /// @return true if they are equal, false if unequal.
 158 inline bool operator==(const pp::Size& lhs, const pp::Size& rhs) {
 159   return lhs.width() == rhs.width() && lhs.height() == rhs.height();
 160 }
 161
 162 /// This function determines whether two <code>Sizes</code> are not equal.
 163 ///
 164 /// @param[in] lhs The <code>Size</code> on the left-hand side of the equation.
 165 /// @param[in] rhs The <code>Size</code> on the right-hand side of the equation.
 166 ///
 167 /// @return true if the <code>Size</code> of lhs are equal to the
 168 /// <code>Size</code> of rhs, otherwise false.
 169 inline bool operator!=(const pp::Size& lhs, const pp::Size& rhs) {
 170   return !(lhs == rhs);
 171 }
 172
 173 #endif  // PPAPI_CPP_SIZE_H_
 174