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