1

/* $Id$ */

     2

#ifndef RECT_H

     3

#define RECT_H

     4

     5

/** Template based point */

     6

template <typename T> struct PointT {

     7

	T x, y;

     8

     9

	PointT(T x_a = 0, T y_a = 0)

    10

		: x(x_a), y(y_a)

    11

	{}

    12

    13

	template <typename Ta> PointT(const PointT<Ta> &src)

    14

		: x((T)src.x), y((T)src.y)

    15

	{}

    16

    17

	PointT& operator =(const PointT &src)

    18

	{

    19

		x = (T)src.x;

    20

		y = (T)src.y;

    21

		return *this;

    22

	}

    23

    24

	PointT operator -() const

    25

	{

    26

		return PointT(-x, -y);

    27

	}

    28

    29

	void DoMove(T dx, T dy)

    30

	{

    31

		x += dx;

    32

		y += dy;

    33

	}

    34

    35

	void DoMove(const PointT &offset)

    36

	{

    37

		DoMove((T)offset.x, (T)offset.y);

    38

	}

    39

    40

	PointT operator +(const PointT &offset) const

    41

	{

    42

		PointT pt;

    43

		pt.DoMove(offset);

    44

		return pt;

    45

	}

    46

    47

	PointT operator -(const PointT &offset) const

    48

	{

    49

		PointT pt;

    50

		pt.DoMove(-offset);

    51

		return pt;

    52

	}

    53

    54

	PointT& operator +=(const PointT &offset)

    55

	{

    56

		DoMove(offset);

    57

		return *this;

    58

	}

    59

    60

	PointT& operator -=(const PointT &offset)

    61

	{

    62

		DoMove(-offset);

    63

		return *this;

    64

	}

    65

};

    66

    67

    68

    69

/** Template based rectangle */

    70

template <typename T> struct RectT

    71

{

    72

	PointT<T> top_left, bottom_right;

    73

    74

	RectT(T left = 0, T top = 0, T right = 0, T bottom = 0)

    75

		: top_left(left, top), bottom_right(right, bottom)

    76

	{}

    77

    78

	template <typename Ta> RectT(const RectT<Ta> &src)

    79

		: top_left(src.top_left), bottom_right(src.bottom_right)

    80

	{}

    81

    82

	T Left() const

    83

	{

    84

		return top_left.x;

    85

	}

    86

    87

	T Top() const

    88

	{

    89

		return top_left.y;

    90

	}

    91

    92

	T Right() const

    93

	{

    94

		return bottom_right.x;

    95

	}

    96

    97

	T Bottom() const

    98

	{

    99

		return bottom_right.y;

   100

	}

   101

   102

	T Width() const

   103

	{

   104

		return bottom_right.x - top_left.x + 1;

   105

	}

   106

   107

	T Height() const

   108

	{

   109

		return bottom_right.y - top_left.y + 1;

   110

	}

   111

   112

	const PointT<T>& TopLeft() const

   113

	{

   114

		return top_left;

   115

	}

   116

   117

	const PointT<T>& BottomRight() const

   118

	{

   119

		return bottom_right;

   120

	}

   121

   122

	void SetLeft(T val)

   123

	{

   124

		top_left.x = val;

   125

	}

   126

   127

	void SetTop(T val)

   128

	{

   129

		top_left.y = val;

   130

	}

   131

   132

	void SetRight(T val)

   133

	{

   134

		bottom_right.x = val;

   135

	}

   136

   137

	void SetBottom(T val)

   138

	{

   139

		bottom_right.y = val;

   140

	}

   141

   142

	void SetWidth(T val)

   143

	{

   144

		bottom_right.x = top_left.x + val - 1;

   145

	}

   146

   147

	void SetHeight(T val)

   148

	{

   149

		bottom_right.y = top_left.y + val - 1;

   150

	}

   151

   152

	void SetTopLeft(const PointT<T> &pt)

   153

	{

   154

		top_left = pt;

   155

	}

   156

   157

	void SetBottomRight(const PointT<T> &pt)

   158

	{

   159

		bottom_right = pt;

   160

	}

   161

   162

	bool PtInRect(const PointT<T> &pt) const

   163

	{

   164

		return (top_left.x <= pt.x && pt.x <= bottom_right.x && top_left.y <= pt.y && pt.y <= bottom_right.y);

   165

	}

   166

   167

	RectT& operator =(const RectT &src)

   168

	{

   169

		top_left     = src.top_left;

   170

		bottom_right = src.bottom_right;

   171

		return *this;

   172

	}

   173

   174

	void DoMove(T dx, T dy)

   175

	{

   176

		DoMove(PointT<T>(dx, dy));

   177

	}

   178

   179

	void DoMove(const PointT<T> &offset)

   180

	{

   181

		top_left.DoMove(offset);

   182

		bottom_right.DoMove(offset);

   183

	}

   184

   185

	RectT operator +(const PointT<T> &offset) const

   186

	{

   187

		RectT r;

   188

		r.DoMove(offset);

   189

		return r;

   190

	}

   191

   192

	RectT operator -(const PointT<T> &offset) const

   193

	{

   194

		RectT r;

   195

		r.DoMove(-offset);

   196

		return r;

   197

	}

   198

   199

	RectT& operator +=(const PointT<T> &offset)

   200

	{

   201

		DoMove(offset);

   202

		return *this;

   203

	}

   204

   205

	RectT& operator -=(const PointT<T> &offset)

   206

	{

   207

		DoMove(-offset);

   208

		return *this;

   209

	}

   210

   211

	void DoUnion(const PointT<T> &pt)

   212

	{

   213

		if (pt.x < top_left.x) {

   214

			top_left.x = pt.x;

   215

		} else if (pt.x > bottom_right.x) {

   216

			bottom_right.x = pt.x;

   217

		}

   218

		if (pt.y < top_left.y) {

   219

			top_left.y = pt.y;

   220

		} else if (pt.y > bottom_right.y) {

   221

			bottom_right.y = pt.y;

   222

		}

   223

	}

   224

   225

	void DoUnion(const RectT &rc)

   226

	{

   227

		if (rc.top_left.x < top_left.x) {

   228

			top_left.x = rc.top_left.x;

   229

		} else if (rc.bottom_right.x > bottom_right.x) {

   230

			bottom_right.x = rc.bottom_right.x;

   231

		}

   232

		if (rc.top_left.y < top_left.y) {

   233

			top_left.y = rc.top_left.y;

   234

		} else if (rc.bottom_right.y > bottom_right.y) {

   235

			bottom_right.y = rc.bottom_right.y;

   236

		}

   237

	}

   238

};

   239

   240

   241

   242

typedef PointT<int16> Point16;

   243

typedef PointT<int32> Point32;

   244

   245

typedef RectT<int16> Rect16;

   246

typedef RectT<int32> Rect32;

   247

   248

#endif /*RECT_H*/