← Back to branch summary

~jeru-sheng/kicad/kicad-feature

« back to all changes in this revision

Viewing changes to common/drawtxt.cpp

  • Committer: plyatov
  • Date: 2007-05-06 16:03:28 UTC
  • Revision ID: svn-v4:16bec504-3128-0410-b3e8-8e38c2123bca:trunk/kicad:13
Initial import of KiCad.

Show diffs side-by-side

added added

removed removed

Lines of Context:
common/drawtxt.cpp
 
1
        /************************************************/
 
2
        /* drawtxt.cpp : trace des textes de composants */
 
3
        /************************************************/
 
4
 
 
5
#include "fctsys.h"
 
6
#include "gr_basic.h"
 
7
 
 
8
#include "common.h"
 
9
#include "plot_common.h"
 
10
 
 
11
#include "trigo.h"
 
12
#include "macros.h"
 
13
 
 
14
#ifndef DEFAULT_SIZE_TEXT
 
15
#define DEFAULT_SIZE_TEXT 50
 
16
#endif
 
17
 
 
18
#define EDA_DRAWBASE
 
19
#include "grfonte.h"
 
20
 
 
21
/* fonctions locales : */
 
22
 
 
23
 
 
24
/****************************************************************************/
 
25
void DrawGraphicText(WinEDA_DrawPanel * panel, wxDC * DC,
 
26
                        const wxPoint & Pos, int gcolor, const wxString & Text,
 
27
                        int orient, const wxSize & Size, int h_justify, int v_justify, int width)
 
28
/*****************************************************************************/
 
29
/* Draw a graphic text (like module texts)
 
30
        Text = text to draw
 
31
        Pos = text position (according to h_justify, v_justify)
 
32
        Size = text size (size.x or size.y can be < 0 for mirrored texts) 
 
33
        orient = angle in 0.1 degree
 
34
        mode_color = GR_OR, GR_XOR..
 
35
        h_justify = horizontal justification (Left, center, right)
 
36
        v_justify = vertical justification (bottom, center, top)
 
37
        width = line width (pen width) (default = 0)
 
38
                if width < 0 : draw segments in sketch mode, width = abs(width)
 
39
*/
 
40
{
 
41
int ii, kk,nbchar, AsciiCode, endcar;
 
42
int k1 , k2, x0, y0;
 
43
int zoom;
 
44
int size_h , size_v , espacement ;
 
45
SH_CODE f_cod , plume = 'U';
 
46
const SH_CODE * ptcar;
 
47
int ptr;
 
48
int ux0, uy0, dx, dy;   // Coord de trace des segments de texte & variables de calcul */
 
49
int cX, cY;                             // Centre du texte
 
50
int ox, oy;                             // coord de trace du caractere courant
 
51
int coord[100];                 // liste des coord des segments a tracer
 
52
bool sketch_mode = FALSE;
 
53
        
 
54
        zoom = panel->GetZoom();
 
55
 
 
56
        size_h = Size.x;
 
57
        size_v = Size.y;
 
58
 
 
59
        if ( width < 0 )
 
60
        {
 
61
                width = - width;
 
62
                sketch_mode = TRUE;
 
63
        }
 
64
        kk = 0 ; ptr = 0;       /* ptr = text index */
 
65
 
 
66
        /* calcul de la position du debut des textes: ox et oy */
 
67
        nbchar = Text.Len();
 
68
        if ( nbchar == 0 ) return;
 
69
 
 
70
        espacement = (10 * size_h ) / 9;
 
71
        ox = cX = Pos.x; oy = cY = Pos.y;
 
72
 
 
73
        /* Si le texte est totalement hors fenetre d'affichage, termin�! */
 
74
        if ( panel )
 
75
        {
 
76
                int xm, ym, ll, xc, yc;
 
77
                int textsize = ABS(espacement);
 
78
                ll = (textsize * nbchar) / zoom;
 
79
                xc = GRMapX(cX);
 
80
                yc = GRMapY(cY);
 
81
                x0 = panel->m_ClipBox.GetX() - ll;
 
82
                y0 = panel->m_ClipBox.GetY() -ll ;
 
83
                xm = panel->m_ClipBox.GetRight() + ll;
 
84
                ym = panel->m_ClipBox.GetBottom() + ll;
 
85
                if ( xc < x0 ) return;
 
86
                if ( yc < y0 ) return;
 
87
                if ( xc > xm ) return;
 
88
                if ( yc > ym ) return;
 
89
        }
 
90
 
 
91
 
 
92
        /* Calcul du cadrage du texte */
 
93
        dx = (espacement * nbchar) / 2;
 
94
        dy = size_v / 2;        /* Decalage du debut du texte / centre */
 
95
 
 
96
        ux0 = uy0 = 0;  /* Decalage du centre du texte / coord de ref */
 
97
 
 
98
        if( (orient == 0) || (orient == 1800) ) /* Texte Horizontal */
 
99
                {
 
100
                switch(h_justify)
 
101
                        {
 
102
                        case GR_TEXT_HJUSTIFY_CENTER:
 
103
                                break;
 
104
 
 
105
                        case GR_TEXT_HJUSTIFY_RIGHT:
 
106
                                ux0 = - dx;
 
107
                                break;
 
108
 
 
109
                        case GR_TEXT_HJUSTIFY_LEFT:
 
110
                                ux0 = dx;
 
111
                                break;
 
112
                        }
 
113
 
 
114
                switch(v_justify)
 
115
                        {
 
116
                        case GR_TEXT_VJUSTIFY_CENTER:
 
117
                                break;
 
118
 
 
119
                        case GR_TEXT_VJUSTIFY_TOP:
 
120
                                uy0 = dy;
 
121
                                break;
 
122
 
 
123
                        case GR_TEXT_VJUSTIFY_BOTTOM:
 
124
                                uy0 = -dy;
 
125
                                break;
 
126
                        }
 
127
                }
 
128
 
 
129
        else    /* Texte Vertical */
 
130
                {
 
131
                switch(h_justify)
 
132
                        {
 
133
                        case GR_TEXT_HJUSTIFY_CENTER:
 
134
                                break;
 
135
 
 
136
                        case GR_TEXT_HJUSTIFY_RIGHT:
 
137
                                ux0 = - dy;
 
138
                                break;
 
139
 
 
140
                        case GR_TEXT_HJUSTIFY_LEFT:
 
141
                                ux0 = dy;
 
142
                                break;
 
143
                        }
 
144
 
 
145
                switch(v_justify)
 
146
                        {
 
147
                        case GR_TEXT_VJUSTIFY_CENTER:
 
148
                                break;
 
149
 
 
150
                        case GR_TEXT_VJUSTIFY_TOP:
 
151
                                uy0 = dx;
 
152
                                break;
 
153
 
 
154
                        case GR_TEXT_VJUSTIFY_BOTTOM:
 
155
                                uy0 = -dx;
 
156
                                break;
 
157
                        }
 
158
                }
 
159
        cX += ux0; cY += uy0;
 
160
        ox = cX - dx; ; oy = cY + dy;
 
161
 
 
162
        if( (Size.x/zoom) == 0 ) return;
 
163
 
 
164
        if( ABS((Size.x/zoom)) < 3) /* chars trop petits pour etre dessines */
 
165
        {       /* le texte est symbolise par une barre */
 
166
                dx = (espacement * nbchar) / 2;
 
167
                dy = size_v / 2;         /* Decalage du debut du texte / centre */
 
168
 
 
169
                ux0 = cX - dx; uy0 = cY;
 
170
                dx += cX; dy = cY;
 
171
                RotatePoint(&ux0, &uy0, cX, cY, orient);
 
172
                RotatePoint(&dx, &dy, cX, cY, orient);
 
173
                GRLine(&panel->m_ClipBox, DC, ux0, uy0, dx, dy, gcolor);
 
174
 
 
175
                return;
 
176
        }
 
177
 
 
178
#if 0
 
179
dx = (espacement * nbchar) / 2;
 
180
dy = size_v / 2;         /* Decalage du debut du texte / centre */
 
181
ux0 = cX - dx; uy0 = cY;
 
182
dx += cX; dy = cY;
 
183
RotatePoint(&ux0, &uy0, cX, cY, orient);
 
184
RotatePoint(&dx, &dy, cX, cY, orient);
 
185
DC->SetTextForeground( wxColour(
 
186
                                                ColorRefs[gcolor].r,
 
187
                                                ColorRefs[gcolor].g,
 
188
                                                ColorRefs[gcolor].b) );
 
189
DC->DrawRotatedText(Text, GRMapX(ux0), GRMapY(uy0), (double) orient / 10.0);
 
190
return;
 
191
#endif
 
192
 
 
193
        while(kk++ < nbchar)
 
194
                {
 
195
                x0 = 0 ; y0 = 0 ;
 
196
                AsciiCode = Text.GetChar(ptr) & 255;
 
197
                ptcar = graphic_fonte_shape[AsciiCode] ; /* ptcar pointe la description
 
198
                                                du caractere a dessiner */
 
199
 
 
200
                for(ii = 0, endcar = FALSE; ! endcar; ptcar++)
 
201
                        {
 
202
                         f_cod = *ptcar ; /* get code n de la forme selectionnee */
 
203
                         switch(f_cod)
 
204
                                 {
 
205
                                 case 'X' :
 
206
                                        endcar = TRUE;/* fin du caractere */
 
207
                                        break;
 
208
 
 
209
                                 case 'U' :
 
210
                                                if(ii && (plume == 'D' ) )
 
211
                                                        {
 
212
                                                        if ( width <= 1 )
 
213
                                                                GRPoly(&panel->m_ClipBox, DC, ii /2, coord, 0,
 
214
                                                                        gcolor, gcolor);
 
215
                                                        else if ( sketch_mode )
 
216
                                                        {
 
217
                                                                int ik, * coordptr;
 
218
                                                                coordptr = coord;
 
219
                                                                for ( ik = 0; ik < (ii-2); ik += 2,  coordptr+= 2)
 
220
                                                                        GRCSegm(&panel->m_ClipBox, DC, *coordptr, *(coordptr+1),
 
221
                                                                                        *(coordptr+2), *(coordptr+3), width, gcolor) ;
 
222
                                                        }
 
223
                                                                
 
224
                                                        else
 
225
                                                                GRPolyLines(&panel->m_ClipBox, DC, ii /2, coord,
 
226
                                                                        gcolor, gcolor, width);
 
227
                                                        }
 
228
                                                plume = f_cod; ii = 0;
 
229
                                                break;
 
230
 
 
231
                                 case 'D' : plume = f_cod ; break ;
 
232
 
 
233
                                 default  :
 
234
                                        {
 
235
                                        k1 = f_cod; /* trace sur axe V */
 
236
                                        k1 = - ((k1 * size_v) / 9) ;
 
237
                                        ptcar++ ;
 
238
                                        f_cod = *ptcar  ;
 
239
                                        k2 = f_cod; /* trace sur axe H */
 
240
                                        k2 = (k2 * size_h) / 9 ;
 
241
                                        dx = k2 + ox; dy = k1 + oy;
 
242
                                        RotatePoint(&dx, &dy, cX, cY, orient);
 
243
                                        coord[ii] = dx;  ii++; coord[ii] = dy; ii++;
 
244
                                        break ;
 
245
                                        }
 
246
                                 } /* end switch */
 
247
                        } /* end boucle for = end trace de 1 caractere */
 
248
 
 
249
                ptr++; ox += espacement;
 
250
                } /* end trace du texte */
 
251
 
 
252
}
 
253
 
 
254
 
 
255
/******************************************************************************************/
 
256
void PlotGraphicText(int format_plot, const wxPoint & Pos, int gcolor,
 
257
                                 const wxString & Text,
 
258
                                int orient, const wxSize & Size, int h_justify, int v_justify)
 
259
/******************************************************************************************/
 
260
/*
 
261
 id DrawGraphicText, for plot graphic text
 
262
*/
 
263
{
 
264
int kk, nbchar, end, AsciiCode;
 
265
int k1 , k2 , x0 , y0, ox, oy ;
 
266
int size_h , size_v , espacement ;
 
267
SH_CODE f_cod , plume = 'U';
 
268
const SH_CODE * ptcar;
 
269
int ptr;
 
270
int ux0, uy0, dx, dy;   // Coord de trace des segments de texte & variables de calcul */
 
271
int cX, cY;                             // Centre du texte
 
272
void (*FctPlume)(wxPoint pos, int state);
 
273
        
 
274
        switch ( format_plot)
 
275
        {
 
276
                case PLOT_FORMAT_POST:
 
277
                        FctPlume = LineTo_PS;
 
278
                        break;
 
279
 
 
280
                case PLOT_FORMAT_HPGL:
 
281
                        FctPlume = Move_Plume_HPGL;
 
282
                        break;
 
283
 
 
284
                case PLOT_FORMAT_GERBER:
 
285
                default:
 
286
                        return;
 
287
        }
 
288
 
 
289
        if ( (gcolor >= 0) && (format_plot == PLOT_FORMAT_POST) )
 
290
                SetColorMapPS ( gcolor );
 
291
 
 
292
        size_h = Size.x;
 
293
        size_v = Size.y;
 
294
        if(size_h == 0) size_h = DEFAULT_SIZE_TEXT;
 
295
        if(size_v == 0) size_v = DEFAULT_SIZE_TEXT;
 
296
 
 
297
        kk = 0 ; ptr = 0; /* ptr = text index */
 
298
 
 
299
        /* calcul de la position du debut des textes: ox et oy */
 
300
        nbchar = Text.Len();
 
301
 
 
302
        espacement = (10 * size_h ) / 9;
 
303
        ox = cX = Pos.x; oy = cY = Pos.y;
 
304
 
 
305
        /* Calcul du cadrage du texte */
 
306
        dx = (espacement * nbchar) / 2;
 
307
        dy = size_v / 2;        /* Decalage du debut du texte / centre */
 
308
 
 
309
        ux0 = uy0 = 0;  /* Decalage du centre du texte / ccord de ref */
 
310
 
 
311
        if( (orient == 0) || (orient == 1800) ) /* Texte Horizontal */
 
312
        {
 
313
                switch(h_justify)
 
314
                {
 
315
                        case GR_TEXT_HJUSTIFY_CENTER:
 
316
                                break;
 
317
 
 
318
                        case GR_TEXT_HJUSTIFY_RIGHT:
 
319
                                ux0 = - dx;
 
320
                                break;
 
321
 
 
322
                        case GR_TEXT_HJUSTIFY_LEFT:
 
323
                                ux0 = dx;
 
324
                                break;
 
325
                }
 
326
 
 
327
                switch(v_justify)
 
328
                {
 
329
                        case GR_TEXT_VJUSTIFY_CENTER:
 
330
                                break;
 
331
 
 
332
                        case GR_TEXT_VJUSTIFY_TOP:
 
333
                                uy0 = dy;
 
334
                                break;
 
335
 
 
336
                        case GR_TEXT_VJUSTIFY_BOTTOM:
 
337
                                uy0 = -dy;
 
338
                                break;
 
339
                }
 
340
        }
 
341
 
 
342
        else    /* Texte Vertical */
 
343
        {
 
344
                switch(h_justify)
 
345
                {
 
346
                        case GR_TEXT_HJUSTIFY_CENTER:
 
347
                                break;
 
348
 
 
349
                        case GR_TEXT_HJUSTIFY_RIGHT:
 
350
                                ux0 = -dy;
 
351
                                break;
 
352
 
 
353
                        case GR_TEXT_HJUSTIFY_LEFT:
 
354
                                ux0 = dy;
 
355
                                break;
 
356
                }
 
357
 
 
358
                switch(v_justify)
 
359
                {
 
360
                        case GR_TEXT_VJUSTIFY_CENTER:
 
361
                                break;
 
362
 
 
363
                        case GR_TEXT_VJUSTIFY_TOP:
 
364
                                uy0 = dx;
 
365
                                break;
 
366
 
 
367
                        case GR_TEXT_VJUSTIFY_BOTTOM:
 
368
                                uy0 = -dx;
 
369
                                break;
 
370
                }
 
371
        }
 
372
        cX += ux0; cY += uy0;   /* cX, cY = coord du centre du texte */
 
373
        ox = -dx; oy = +dy; /* ox, oy = coord debut texte, relativement au centre */
 
374
 
 
375
        FctPlume(wxPoint(0,0), 'Z');
 
376
 
 
377
        while(kk++ < nbchar)
 
378
                {
 
379
                AsciiCode = Text.GetChar(ptr) & 255;
 
380
                ptcar = graphic_fonte_shape[AsciiCode] ; /* ptcar pointe la description
 
381
                                                du caractere a dessiner */
 
382
 
 
383
                for(end = 0 ; end == 0; ptcar++)
 
384
                        {
 
385
                         f_cod = *ptcar ; /* get code n de la forme selectionnee */
 
386
                         switch(f_cod)
 
387
                                {
 
388
                                case 'X' : end = 1 ;/* fin du caractere */
 
389
 
 
390
                                case 'U' :
 
391
                                case 'D' : plume = f_cod ; break ;
 
392
 
 
393
                                default  :
 
394
                                        k1 = f_cod ; /* trace sur axe V */
 
395
                                        k1 = -(k1 * size_v) / 9 ;
 
396
                                        ptcar++ ;
 
397
                                        f_cod = *ptcar;
 
398
                                        k2 = f_cod; /* trace sur axe H */
 
399
                                        k2 = (k2 * size_h) / 9 ;
 
400
                                        dx = k2 + ox; dy = k1 + oy;
 
401
                                        RotatePoint(&dx, &dy, orient);
 
402
                                        FctPlume(wxPoint(cX + dx, cY + dy), plume);
 
403
                                        x0 = k2 ; y0 = k1 ;
 
404
                                        break ;
 
405
                                } /* end switch */
 
406
                        } /* end boucle for = end trace de 1 caractere */
 
407
 
 
408
                FctPlume(wxPoint(0,0), 'Z');
 
409
                ptr++; ox += espacement;
 
410
                } /* end trace du texte */
 
411
        FctPlume(wxPoint(0,0), 'Z');
 
412
}
 
413