File: base_struct.h

package info (click to toggle)
kicad 0.0.20060829-2
  • links: PTS
  • area: main
  • in suites: etch, etch-m68k
  • size: 56,544 kB
  • ctags: 9,194
  • sloc: cpp: 88,990; ansic: 4,790; makefile: 88; sh: 39
file content (255 lines) | stat: -rw-r--r-- 8,070 bytes parent folder | download
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
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
/*********************************************************************/
/*	base_struct.h :  Basic classes for most kicad item descriptions  */
/*********************************************************************/

#ifndef BASE_STRUCT_H
#define BASE_STRUCT_H


/* Id for class identification, at run time */
enum DrawStructureType {
	TYPE_NOT_INIT = 0,
	TYPEPCB,
	// Items in pcb
	PCB_EQUIPOT_STRUCT_TYPE,
	TYPEMODULE,
	TYPEPAD,
	TYPEDRAWSEGMENT,
	TYPETEXTE,
	TYPETEXTEMODULE,
	TYPEEDGEMODULE,
	TYPETRACK,
	TYPEZONE,
	TYPEVIA,
	TYPEMARQUEUR,
	TYPECOTATION,
	TYPEMIRE,
	TYPESCREEN,
	TYPEBLOCK,
	TYPEEDGEZONE,
	// Draw Items in schematic
	DRAW_POLYLINE_STRUCT_TYPE,
	DRAW_JUNCTION_STRUCT_TYPE,
	DRAW_TEXT_STRUCT_TYPE,
	DRAW_LABEL_STRUCT_TYPE,
	DRAW_GLOBAL_LABEL_STRUCT_TYPE,
	DRAW_LIB_ITEM_STRUCT_TYPE,
	DRAW_PICK_ITEM_STRUCT_TYPE,
	DRAW_SEGMENT_STRUCT_TYPE,
	DRAW_BUSENTRY_STRUCT_TYPE,
	DRAW_SHEET_STRUCT_TYPE,
	DRAW_SHEETLABEL_STRUCT_TYPE,
	DRAW_MARKER_STRUCT_TYPE,
	DRAW_NOCONNECT_STRUCT_TYPE,
	DRAW_PART_TEXT_STRUCT_TYPE,
	// General
	SCREEN_STRUCT_TYPE,
	BLOCK_LOCATE_STRUCT_TYPE,
	// Draw Items in library component
	LIBCOMPONENT_STRUCT_TYPE,
	COMPONENT_ARC_DRAW_TYPE,
	COMPONENT_CIRCLE_DRAW_TYPE,
	COMPONENT_GRAPHIC_TEXT_DRAW_TYPE,
	COMPONENT_RECT_DRAW_TYPE,
	COMPONENT_POLYLINE_DRAW_TYPE,
	COMPONENT_LINE_DRAW_TYPE,
	COMPONENT_PIN_DRAW_TYPE,
	COMPONENT_FIELD_DRAW_TYPE,
	// End value
	MAX_STRUCT_TYPE_ID
};


/********************************************************************/
/* Classes de base: servent a deriver les classes reellement utiles */
/********************************************************************/

class EDA_BaseStruct		/* Basic class, not directly used */
{
public:
	int m_StructType;			/* Type Structure */
	EDA_BaseStruct * Pnext;		/* Linked list: Link (next struct) */
	EDA_BaseStruct * Pback;		/* Linked list: Link (previous struct) */
	EDA_BaseStruct * m_Parent;	/* Linked list: Link (parent struct) */
	EDA_BaseStruct *m_Son;		/* Linked list: Link (son struct) */
	int m_Flags;				// flags for editions and other
	long m_TimeStamp;			// Time stamp (used for logical links)
	int m_Selected;				/* Used by block commands, and selective editing */

private:
	int m_Status;

private:
	void InitVars(void);

public:

	EDA_BaseStruct(EDA_BaseStruct * parent, int idType);
	EDA_BaseStruct(int struct_type);
	virtual ~EDA_BaseStruct() {};
	EDA_BaseStruct * Next(void) { return Pnext; }
	/* Gestion de l'etat (status) de la structure (active, deleted..) */
	int GetState(int type);
	void SetState(int type, int state );
	int ReturnStatus(void) const
		{
		return(m_Status);
		}
	void SetStatus(int new_status)
		{
		m_Status = new_status;
		}
	wxString ReturnClassName(void);
	/* addition d'une nouvelle struct a la liste chaine */
	void AddToChain(EDA_BaseStruct * laststruct);
	/* fonction de placement */
	virtual void Place(WinEDA_DrawFrame * frame, wxDC * DC);
};

// Gestion de la justification des textes
// Les valeurs -1,0,1 interviennent dans les calculs, elles ne sont pas arbitraires
typedef enum {
	GR_TEXT_HJUSTIFY_LEFT = -1,
	GR_TEXT_HJUSTIFY_CENTER = 0,
	GR_TEXT_HJUSTIFY_RIGHT = 1
} GRTextHorizJustifyType;

typedef enum {
	GR_TEXT_VJUSTIFY_TOP = -1,
	GR_TEXT_VJUSTIFY_CENTER = 0,
	GR_TEXT_VJUSTIFY_BOTTOM = 1
} GRTextVertJustifyType;

/* controle des remplissages a l'ecran (Segments textes...)*/
#define FILAIRE  0
#define FILLED  1
#define SKETCH  2


#define DEFAULT_SIZE_TEXT 60		/* Hauteur (en 1/000" par defaut des textes */

/* classe de gestion des textes (labels, textes composants ..)
	(Non utilisee seule) */
class EDA_TextStruct
{
public:
	wxString m_Text;				/* text! */
	int m_Layer;					/* couche d'appartenance */
	wxPoint m_Pos;					/* XY position of anchor text. */
	wxSize m_Size;					/* XY size of text */
	int m_Width;					/* epaisseur du trait */
	int m_Orient;                   /* Orient in 0.1 degrees */
	int m_Miroir;					// Display Normal / mirror
	int m_Attributs;				/* controle visibilite */
	int m_CharType;					/* normal, bold, italic ... */
	int m_HJustify, m_VJustify;		/* Justifications Horiz et Vert du texte */
	int m_ZoomLevelDrawable;		/* Niveau de zoom acceptable pour affichage normal */
	int * m_TextDrawings;			/* pointeur sur la liste des segments de dessin */
	int m_TextDrawingsSize;			/* nombre de segments a dessiner */


public:
	EDA_TextStruct(const wxString & text = wxEmptyString);
	virtual ~EDA_TextStruct(void);
	void CreateDrawData(void);
	int GetLength(void) { return m_Text.Length(); };
	int Pitch(void);	/* retourne le pas entre 2 caracteres */
	void Draw(WinEDA_DrawPanel * panel, wxDC * DC,
				const wxPoint & offset, int color,
				int draw_mode, int display_mode = FILAIRE, int anchor_color = -1);
	/* locate functions */
	int Locate(const wxPoint & posref);
	int Len_Size(void);	// Return the text lenght in internal units
};



/* Basic class for build items like lines, which have 1 start point and 1 end point.
   Arc and circles can use this class.
*/
class EDA_BaseLineStruct: public EDA_BaseStruct
{
public:
	int m_Layer;				// Layer number
	int m_Width;                // 0 = line, > 0 = tracks, bus ...
	wxPoint m_Start;			// Line start point
	wxPoint m_End;				// Line end point

public:
	EDA_BaseLineStruct(EDA_BaseStruct * StructFather, DrawStructureType idtype);
};


	/**************************/
	/* class DrawPickedStruct */
	/**************************/

/* Class to hold structures picked by pick events (like block selection)
	This class has only one useful member: .m_PickedStruct, used as a link.
	It does not describe really an item.
	It is used to create a linked list of selected items (in block selection).
	Each DrawPickedStruct item has is member: .m_PickedStruct pointing the
	real selected item
*/
class DrawPickedStruct: public EDA_BaseStruct
{
public:
	EDA_BaseStruct *m_PickedStruct;

public:
	DrawPickedStruct(EDA_BaseStruct *pickedstruct = NULL);
	~DrawPickedStruct(void);
	void Place(WinEDA_DrawFrame * frame, wxDC * DC) {};
	void DeleteWrapperList(void);
	DrawPickedStruct * Next(void) { return (DrawPickedStruct*) Pnext; }
};


/* class to handle component boundary box.
	This class is similar to wxRect, but some wxRect functions are very curious,
	so I prefer this suitable class
*/
class EDA_Rect
{
public:
	wxPoint m_Pos;		// Rectangle Origin
	wxSize m_Size;		// Rectangle Size 

public:
	EDA_Rect(void) {};
	wxPoint Centre(void)
	{
		return wxPoint(m_Pos.x + (m_Size.x>>1), m_Pos.y + (m_Size.y>>1) );
	}

	void Normalize(void);	// Ensure the height ant width are >= 0
	bool Inside(const wxPoint & point);	// Return TRUE if point is in Rect
	bool Inside(int x, int y) { return Inside(wxPoint(x,y)); }
	wxSize GetSize(void) { return m_Size; }
	int GetX(void) { return m_Pos.x;}
	int GetY(void) { return m_Pos.y;}
	wxPoint GetOrigin(void) { return m_Pos;}
	wxPoint GetPosition(void) { return m_Pos;}
	wxPoint GetEnd(void) { return wxPoint(GetRight(),GetBottom());}
	int GetWidth(void) { return m_Size.x; }
	int GetHeight(void) { return m_Size.y; }
	int GetRight(void) {return m_Pos.x + m_Size.x; }
	int GetBottom(void) {return m_Pos.y + m_Size.y; }
	void SetOrigin(const wxPoint & pos) { m_Pos = pos; }
	void SetOrigin(int x, int y) { m_Pos.x = x; m_Pos.y = y; }
	void SetSize(const wxSize & size) { m_Size = size; }
	void SetSize(int w, int h) { m_Size.x = w; m_Size.y = h; }
	void Offset(int dx, int dy) { m_Pos.x += dx; m_Pos.y += dy; }
	void Offset(const wxPoint & offset) { m_Pos.x += offset.x; m_Pos.y += offset.y; }
	void SetX(int val) { m_Pos.x = val; }
	void SetY(int val) { m_Pos.y = val; }
	void SetWidth(int val) { m_Size.x = val; }
	void SetHeight(int val) { m_Size.y = val; }
	void SetEnd(const wxPoint & pos)
	{
		m_Size.x = pos.x - m_Pos.x; m_Size.y = pos.y - m_Pos.y;
	}
	EDA_Rect& Inflate(wxCoord dx, wxCoord dy);
};

#endif /* BASE_STRUCT_H */