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
|
#include "emb-rect.h"
#include "emb-logging.h"
#include <stdlib.h>
/**************************************************/
/* EmbRect */
/**************************************************/
double embRect_x(EmbRect rect)
{
return rect.left;
}
double embRect_y(EmbRect rect)
{
return rect.top;
}
double embRect_width(EmbRect rect)
{
return rect.right - rect.left;
}
double embRect_height(EmbRect rect)
{
return rect.bottom - rect.top;
}
/* Sets the left edge of the rect to x. The right edge is not modified. */
void embRect_setX(EmbRect* rect, double x)
{
rect->left = x;
}
/* Sets the top edge of the rect to y. The bottom edge is not modified. */
void embRect_setY(EmbRect* rect, double y)
{
rect->top = y;
}
/* Sets the width of the rect to w. The right edge is modified. The left edge is not modified. */
void embRect_setWidth(EmbRect* rect, double w)
{
rect->right = rect->left + w;
}
/* Sets the height of the rect to h. The bottom edge is modified. The top edge is not modified. */
void embRect_setHeight(EmbRect* rect, double h)
{
rect->bottom = rect->top + h;
}
void embRect_setCoords(EmbRect* rect, double x1, double y1, double x2, double y2)
{
rect->left = x1;
rect->top = y1;
rect->right = x2;
rect->bottom = y2;
}
void embRect_setRect(EmbRect* rect, double x, double y, double w, double h)
{
rect->left = x;
rect->top = y;
rect->right = x + w;
rect->bottom = y + h;
}
/**************************************************/
/* EmbRectObject */
/**************************************************/
/* Returns an EmbRectObject. It is created on the stack. */
EmbRectObject embRectObject_make(double x, double y, double w, double h)
{
EmbRectObject stackRectObj;
stackRectObj.rect.left = x;
stackRectObj.rect.top = y;
stackRectObj.rect.right = x + w;
stackRectObj.rect.bottom = y + h;
return stackRectObj;
}
/* Returns a pointer to an EmbRectObject. It is created on the heap. The caller is responsible for freeing the allocated memory. */
EmbRectObject* embRectObject_create(double x, double y, double w, double h)
{
EmbRectObject* heapRectObj = (EmbRectObject*)malloc(sizeof(EmbRectObject));
if(!heapRectObj) { embLog_error("emb-rect.c embRectObject_create(), cannot allocate memory for heapRectObj\n"); return 0; }
heapRectObj->rect.left = x;
heapRectObj->rect.top = y;
heapRectObj->rect.right = x + w;
heapRectObj->rect.bottom = y + h;
return heapRectObj;
}
/**************************************************/
/* EmbRectObjectList */
/**************************************************/
EmbRectObjectList* embRectObjectList_create(EmbRectObject data)
{
EmbRectObjectList* heapRectObjList = (EmbRectObjectList*)malloc(sizeof(EmbRectObjectList));
if(!heapRectObjList) { embLog_error("emb-rect.c embRectObjectList_create(), cannot allocate memory for heapRectObjList\n"); return 0; }
heapRectObjList->rectObj = data;
heapRectObjList->next = 0;
return heapRectObjList;
}
EmbRectObjectList* embRectObjectList_add(EmbRectObjectList* pointer, EmbRectObject data)
{
if(!pointer) { embLog_error("emb-rect.c embRectObjectList_add(), pointer argument is null\n"); return 0; }
if(pointer->next) { embLog_error("emb-rect.c embRectObjectList_add(), pointer->next should be null\n"); return 0; }
pointer->next = (EmbRectObjectList*)malloc(sizeof(EmbRectObjectList));
if(!pointer->next) { embLog_error("emb-rect.c embRectObjectList_add(), cannot allocate memory for pointer->next\n"); return 0; }
pointer = pointer->next;
pointer->rectObj = data;
pointer->next = 0;
return pointer;
}
int embRectObjectList_count(EmbRectObjectList* pointer)
{
int i = 1;
if(!pointer) return 0;
while(pointer->next)
{
pointer = pointer->next;
i++;
}
return i;
}
int embRectObjectList_empty(EmbRectObjectList* pointer)
{
if(!pointer)
return 1;
return 0;
}
void embRectObjectList_free(EmbRectObjectList* pointer)
{
EmbRectObjectList* tempPointer = pointer;
EmbRectObjectList* nextPointer = 0;
while(tempPointer)
{
nextPointer = tempPointer->next;
free(tempPointer);
tempPointer = nextPointer;
}
pointer = 0;
}
/* kate: bom off; indent-mode cstyle; indent-width 4; replace-trailing-space-save on; */
|
