1 /*
2 * Author: William Chia-Wei Cheng (bill.cheng@acm.org)
3 *
4 * Copyright (C) 2001-2009, William Chia-Wei Cheng.
5 *
6 * This file may be distributed under the terms of the Q Public License
7 * as defined by Trolltech AS of Norway and appearing in the file
8 * LICENSE.QPL included in the packaging of this file.
9 *
10 * THIS FILE IS PROVIDED AS IS WITH NO WARRANTY OF ANY KIND, INCLUDING
11 * THE WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR
12 * PURPOSE. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL,
13 * INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING
14 * FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
15 * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
16 * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17 *
18 * @(#)$Header: /mm2/home/cvs/bc-src/tgif/raster.c,v 1.21 2011/05/16 16:21:59 william Exp $
19 */
20
21 #define _INCLUDE_FROM_RASTER_C_
22
23 #include "tgifdefs.h"
24 #include "expfdefs.h"
25
26 #include "choice.e"
27 #include "color.e"
28 #include "dialog.e"
29 #include "file.e"
30 #include "font.e"
31 #include "menu.e"
32 #include "miniline.e"
33 #include "msg.e"
34 #include "pattern.e"
35 #include "poly.e"
36 #include "shape.e"
37 #include "raster.e"
38 #include "setup.e"
39 #include "strtbl.e"
40 #include "text.e"
41 #include "util.e"
42 #include "xprtfltr.e"
43
44 #include "xbm/arrow.xbm"
45 #include "xbm/text.xbm"
46 #include "xbm/box.xbm"
47 #include "xbm/oval.xbm"
48 #include "xbm/ovalcent.xbm"
49 #include "xbm/ovaledge.xbm"
50 #include "xbm/poly.xbm"
51 #include "xbm/polygon.xbm"
52 #include "xbm/arc.xbm"
53 #include "xbm/arc_edge.xbm"
54 #include "xbm/rcbox.xbm"
55 #include "xbm/freehand.xbm"
56 #include "xbm/vmode.xbm"
57 #include "xbm/rot_mode.xbm"
58 #include "xbm/rot_mode2.xbm"
59
60 #include "xbm/pat0.xbm"
61 #include "xbm/pat1.xbm"
62 #include "xbm/pat2.xbm"
63 #include "xbm/pat3.xbm"
64 #include "xbm/pat4.xbm"
65 #include "xbm/pat5.xbm"
66 #include "xbm/pat6.xbm"
67 #include "xbm/pat7.xbm"
68 #include "xbm/pat8.xbm"
69 #include "xbm/pat9.xbm"
70 #include "xbm/pat10.xbm"
71 #include "xbm/pat11.xbm"
72 #include "xbm/pat12.xbm"
73 #include "xbm/pat13.xbm"
74 #include "xbm/pat14.xbm"
75 #include "xbm/pat15.xbm"
76 #include "xbm/pat16.xbm"
77 #include "xbm/pat17.xbm"
78 #include "xbm/pat18.xbm"
79 #include "xbm/pat19.xbm"
80 #include "xbm/pat20.xbm"
81 #include "xbm/pat21.xbm"
82 #include "xbm/pat22.xbm"
83 #include "xbm/pat23.xbm"
84 #include "xbm/pat24.xbm"
85 #include "xbm/pat25.xbm"
86 #include "xbm/pat26.xbm"
87 #include "xbm/pat27.xbm"
88 #include "xbm/pat28.xbm"
89 #include "xbm/pat29.xbm"
90 #include "xbm/pat30.xbm"
91 #include "xbm/pat31.xbm"
92 #include "xbm/pat32.xbm"
93
94 #include "xbm/shape0.xbm"
95 #include "xbm/shape1.xbm"
96 #include "xbm/shape2.xbm"
97 #include "xbm/shape3.xbm"
98 #include "xbm/shape4.xbm"
99 #include "xbm/shape5.xbm"
100 #include "xbm/shape6.xbm"
101 #include "xbm/shape7.xbm"
102 #include "xbm/shape8.xbm"
103 #include "xbm/shape9.xbm"
104 #include "xbm/shape10.xbm"
105 #include "xbm/shape11.xbm"
106 #include "xbm/shape12.xbm"
107 #include "xbm/shape13.xbm"
108 #include "xbm/shape14.xbm"
109 #include "xbm/shape15.xbm"
110 #include "xbm/shape16.xbm"
111 #include "xbm/shape17.xbm"
112 #include "xbm/shape18.xbm"
113 #include "xbm/shape19.xbm"
114
115 #include "xbm/just_l.xbm"
116 #include "xbm/just_c.xbm"
117 #include "xbm/just_r.xbm"
118
119 #include "xbm/align_n.xbm"
120
121 #include "xbm/align_l.xbm"
122 #include "xbm/align_c.xbm"
123 #include "xbm/align_r.xbm"
124
125 #include "xbm/align_t.xbm"
126 #include "xbm/align_m.xbm"
127 #include "xbm/align_b.xbm"
128
129 #include "xbm/align_s.xbm"
130
131 #include "xbm/align_lt.xbm"
132 #include "xbm/align_lm.xbm"
133 #include "xbm/align_lb.xbm"
134 #include "xbm/align_ct.xbm"
135 #include "xbm/align_cm.xbm"
136 #include "xbm/align_cb.xbm"
137 #include "xbm/align_rt.xbm"
138 #include "xbm/align_rm.xbm"
139 #include "xbm/align_rb.xbm"
140
141 #include "xbm/align_sn.xbm"
142 #include "xbm/align_st.xbm"
143 #include "xbm/align_sm.xbm"
144 #include "xbm/align_sb.xbm"
145 #include "xbm/align_ns.xbm"
146 #include "xbm/align_ls.xbm"
147 #include "xbm/align_cs.xbm"
148 #include "xbm/align_rs.xbm"
149 #include "xbm/align_ss.xbm"
150
151 #include "xbm/lw0.xbm"
152 #include "xbm/lw1.xbm"
153 #include "xbm/lw2.xbm"
154 #include "xbm/lw3.xbm"
155 #include "xbm/lw4.xbm"
156 #include "xbm/lw5.xbm"
157 #include "xbm/lw6.xbm"
158
159 #include "xbm/lt0.xbm"
160 #include "xbm/lt1.xbm"
161 #include "xbm/lt2.xbm"
162 #include "xbm/lt3.xbm"
163
164 #include "xbm/ls0.xbm"
165 #include "xbm/ls1.xbm"
166 #include "xbm/ls2.xbm"
167 #include "xbm/ls3.xbm"
168
169 #include "xbm/ld0.xbm"
170 #include "xbm/ld1.xbm"
171 #include "xbm/ld2.xbm"
172 #include "xbm/ld3.xbm"
173 #include "xbm/ld4.xbm"
174 #include "xbm/ld5.xbm"
175 #include "xbm/ld6.xbm"
176 #include "xbm/ld7.xbm"
177 #include "xbm/ld8.xbm"
178
179 #include "xbm/lw0s.xbm"
180 #include "xbm/lw1s.xbm"
181 #include "xbm/lw2s.xbm"
182 #include "xbm/lw3s.xbm"
183 #include "xbm/lw4s.xbm"
184 #include "xbm/lw5s.xbm"
185 #include "xbm/lw6s.xbm"
186
187 #include "xbm/lt0s.xbm"
188 #include "xbm/lt1s.xbm"
189 #include "xbm/lt2s.xbm"
190 #include "xbm/lt3s.xbm"
191
192 #include "xbm/ls0s.xbm"
193 #include "xbm/ls1s.xbm"
194 #include "xbm/ls2s.xbm"
195 #include "xbm/ls3s.xbm"
196
197 #include "xbm/ld0s.xbm"
198 #include "xbm/ld1s.xbm"
199 #include "xbm/ld2s.xbm"
200 #include "xbm/ld3s.xbm"
201 #include "xbm/ld4s.xbm"
202 #include "xbm/ld5s.xbm"
203 #include "xbm/ld6s.xbm"
204 #include "xbm/ld7s.xbm"
205 #include "xbm/ld8s.xbm"
206
207 #include "xbm/printer.xbm"
208 #include "xbm/latex.xbm"
209 #include "xbm/psfile.xbm"
210 #include "xbm/xbm.xbm"
211 #include "xbm/ascii.xbm"
212 #include "xbm/epsi.xbm"
213 #include "xbm/gif.xbm"
214 #include "xbm/html.xbm"
215 #include "xbm/pdf.xbm"
216 #include "xbm/tiffepsi.xbm"
217 #include "xbm/png.xbm"
218 #include "xbm/jpeg.xbm"
219 #include "xbm/pbm.xbm"
220 #include "xbm/netlist.xbm"
221 #include "xbm/svg.xbm"
222
223 #include "xbm/file.xbm"
224 #include "xbm/landscap.xbm"
225 #include "xbm/special.xbm"
226 #include "xbm/vspace.xbm"
227
228 #include "xbm/rcb_rad.xbm"
229 #include "xbm/const_mv.xbm"
230 #include "xbm/uncon_mv.xbm"
231 #include "xbm/edit.xbm"
232 #include "xbm/intr.xbm"
233 #include "xbm/intr90.xbm"
234 #include "xbm/trek.xbm"
235 #include "xbm/stack.xbm"
236 #include "xbm/tile.xbm"
237 #include "xbm/leftend.xbm"
238 #include "xbm/lfarrow.xbm"
239 #include "xbm/rtarrow.xbm"
240 #include "xbm/rightend.xbm"
241 #include "xbm/upend.xbm"
242 #include "xbm/uparrow.xbm"
243 #include "xbm/dnarrow.xbm"
244 #include "xbm/downend.xbm"
245 #include "xbm/chkall.xbm"
246 #include "xbm/unchkall.xbm"
247 #include "xbm/scrl_up.xbm"
248 #include "xbm/scrl_dn.xbm"
249 #include "xbm/scrl_lf.xbm"
250 #include "xbm/scrl_rt.xbm"
251 #include "xbm/stretch.xbm"
252 #include "xbm/nstretch.xbm"
253 #include "xbm/pattrans.xbm"
254 #include "xbm/patopaq.xbm"
255
256 #include "xbm/rot_0.xbm"
257 #include "xbm/rot_90.xbm"
258 #include "xbm/rot_180.xbm"
259 #include "xbm/rot_270.xbm"
260
261 #include "xbm/wire.xbm"
262 #include "xbm/run.xbm"
263 #include "xbm/check.xbm"
264 #include "xbm/radio.xbm"
265 #include "xbm/submenu.xbm"
266 #include "xbm/gsubmenu.xbm"
267
268 #include "xbm/redraw.xbm"
269
270 #include "xbm/btn1.xbm"
271 #include "xbm/btn2.xbm"
272 #include "xbm/btn3.xbm"
273
274 #include "xbm/stop.xbm"
275 #include "xbm/question.xbm"
276 #include "xbm/info.xbm"
277 #include "xbm/dialog.xbm"
278
279 GC rasterGC=NULL;
280 GC patGC=NULL;
281
282 unsigned long xorOne=0L;
283 unsigned long xorZero=0L;
284
285 GC drawGC=NULL;
286 GC drawSBGC=NULL;
287 GC defaultGC=NULL;
288 GC revDefaultGC=NULL;
289 GC revGrayGC=NULL;
290
291 Pixmap rotateModePixmap[2];
292 Pixmap choicePixmap[MAXCHOICES];
293 Pixmap patPixmap[MAXPATTERNS+1];
294 Pixmap *lineWidthPixmap=NULL;
295 Pixmap lineTypePixmap[MAXLINETYPES];
296 Pixmap lineDashPixmap[MAXDASHES];
297 Pixmap lineStylePixmap[MAXLINESTYLES];
298 Pixmap justPixmap[MAXJUSTS];
299 Pixmap alignHoriPixmap[MAXALIGNS];
300 Pixmap alignVertPixmap[MAXALIGNS];
301 Pixmap alignDirectPixmap[(MAXALIGNS-1)*(MAXALIGNS-1)];
302 Pixmap distrDirectPixmap[MAXALIGNS*MAXALIGNS];
303 Pixmap *shortLineWidthPixmap=NULL;
304 Pixmap filePixmap=None;
305 Pixmap landscapePixmap=None;
306 Pixmap specialPixmap=None;
307 Pixmap vspacePixmap=None;
308 Pixmap rcbRadiusPixmap=None;
309 Pixmap moveModePixmap[MAXMOVEMODES];
310 Pixmap editPixmap=None;
311 Pixmap intrPixmap[MAXINTRS];
312 Pixmap trekPixmap=None;
313 Pixmap pageLayoutPixmap[MAXPAGELAYOUTMODES];
314 Pixmap scrollPixmap[MAXSCROLLBUTTONS];
315 Pixmap scrlBitmap[4];
316 Pixmap shapePixmap[MAXSHAPES];
317 Pixmap stretchableModePixmap[MAXSTRETCHABLEMODES];
318 Pixmap transPatPixmap[MAXTRANSPATMODES];
319
320 Pixmap rotatePixmap[4];
321 Pixmap *whereToPrintPixmap=NULL;
322 Pixmap shortLineTypePixmap[MAXLINETYPES];
323 Pixmap shortLineStylePixmap[MAXLINESTYLES];
324 Pixmap shortDashPixmap[MAXDASHES];
325
326 Pixmap wireBitmap=None;
327 Pixmap runBitmap=None;
328 Pixmap checkBitmap=None;
329 Pixmap radioBitmap=None;
330 Pixmap submenuBitmap=None;
331 Pixmap graySubmenuBitmap=None;
332 Pixmap userRedrawBitmap=None;
333 Pixmap statusBtnPixmap[MAX_STATUS_BTNS];
334 Pixmap msgBoxPixmap[MAX_MB_ICONS];
335
336 int maxLineWidths=MAXLINEWIDTHS;
337 int maxWhereToPrint=MAXDEFWHERETOPRINT;
338
339 int dashListLength[MAXDASHES] = { 0, 2, 2, 2, 4, 2, 6, 2, 2 };
340 char *dashList[MAXDASHES] =
341 {"","\004\014","\010\010","\014\004","\024\004\004\004",
342 "\004\004","\014\004\004\004\004\004","\020\020","\002\002"};
343
344 static int pat_w[MAXPATTERNS+1], pat_h[MAXPATTERNS+1];
345 static int shape_w[MAXSHAPES+1], shape_h[MAXSHAPES+1];
346
347 static unsigned char *patData[MAXPATTERNS+1];
348 static int needToFreePat[MAXPATTERNS+1];
349 static unsigned char *shapeData[MAXSHAPES+1];
350
351 static int newLineWidthAllocated=FALSE;
352
353 static Pixmap defaultLineWidthPixmap[MAXLINEWIDTHS];
354 static Pixmap defaultShortLineWidthPixmap[MAXLINEWIDTHS];
355
356 static
InitLines()357 void InitLines()
358 {
359 int i, j, y, short_y, len, x;
360 char *c_ptr, buf[80], s[MAXSTRING];
361 XGCValues values;
362 GC tmp_gc, tmp_rev_gc;
363 Pixmap dummy_pixmap;
364
365 newLineWidthAllocated = FALSE;
366
367 maxLineWidths = MAXLINEWIDTHS;
368 if ((c_ptr=XGetDefault(mainDisplay, TOOL_NAME, "MaxLineWidths")) != NULL) {
369 maxLineWidths = atoi(c_ptr);
370 if (maxLineWidths <= 0) {
371 fprintf(stderr, TgLoadString(STID_INVALID_XDEF_USE_ALT_VALUE),
372 TOOL_NAME, "MaxLineWidths", c_ptr, MAXLINEWIDTHS);
373 maxLineWidths = MAXLINEWIDTHS;
374 }
375 }
376
377 curWidthOfLine = (short*)malloc(maxLineWidths*sizeof(short));
378 curArrowHeadW = (short*)malloc(maxLineWidths*sizeof(short));
379 curArrowHeadH = (short*)malloc(maxLineWidths*sizeof(short));
380 curWidthOfLineSpec = (char**)malloc(maxLineWidths*sizeof(char*));
381 curArrowHeadWSpec = (char**)malloc(maxLineWidths*sizeof(char*));
382 curArrowHeadHSpec = (char**)malloc(maxLineWidths*sizeof(char*));
383 memset(curWidthOfLineSpec, 0, sizeof(maxLineWidths*sizeof(char*)));
384 memset(curArrowHeadWSpec, 0, sizeof(maxLineWidths*sizeof(char*)));
385 memset(curArrowHeadHSpec, 0, sizeof(maxLineWidths*sizeof(char*)));
386
387 *buf = '\0';
388 for (i = 0; i < maxLineWidths; i++) {
389 float fval;
390 char *sval;
391
392 sprintf(buf, "LineWidth%1d", i);
393 if ((c_ptr=XGetDefault(mainDisplay, TOOL_NAME, buf)) != NULL) {
394 strcpy(gszMsgBox, c_ptr);
395 sval = strtok(gszMsgBox, ", \t\n\r");
396 if (sval == NULL) break;
397 if (sscanf(sval, "%f", &fval) != 1) break;
398 curWidthOfLine[i] = round(fval);
399 curWidthOfLineSpec[i] = UtilStrDup(sval);
400 } else if (i < MAXLINEWIDTHS) {
401 curWidthOfLine[i] = origWidthOfLine[i];
402 sprintf(gszMsgBox, "%1d", curWidthOfLine[i]);
403 curWidthOfLineSpec[i] = UtilStrDup(gszMsgBox);
404 } else {
405 break;
406 }
407 sprintf(buf, "ArrowWidth%1d", i);
408 if ((c_ptr=XGetDefault(mainDisplay, TOOL_NAME, buf)) != NULL) {
409 strcpy(gszMsgBox, c_ptr);
410 sval = strtok(gszMsgBox, ", \t\n\r");
411 if (sval == NULL) break;
412 if (sscanf(sval, "%f", &fval) != 1) break;
413 curArrowHeadW[i] = round(fval);
414 curArrowHeadWSpec[i] = UtilStrDup(sval);
415 } else if (i < MAXLINEWIDTHS) {
416 curArrowHeadW[i] = origArrowHeadW[i];
417 sprintf(gszMsgBox, "%1d", curArrowHeadW[i]);
418 curArrowHeadWSpec[i] = UtilStrDup(gszMsgBox);
419 } else {
420 break;
421 }
422 sprintf(buf, "ArrowHeight%1d", i);
423 if ((c_ptr=XGetDefault(mainDisplay, TOOL_NAME, buf)) != NULL) {
424 strcpy(gszMsgBox, c_ptr);
425 sval = strtok(gszMsgBox, ", \t\n\r");
426 if (sval == NULL) break;
427 if (sscanf(sval, "%f", &fval) != 1) break;
428 curArrowHeadH[i] = round(fval);
429 curArrowHeadHSpec[i] = UtilStrDup(sval);
430 } else if (i < MAXLINEWIDTHS) {
431 curArrowHeadH[i] = origArrowHeadH[i];
432 sprintf(gszMsgBox, "%1d", curArrowHeadH[i]);
433 curArrowHeadHSpec[i] = UtilStrDup(gszMsgBox);
434 } else {
435 break;
436 }
437 }
438 if (i != maxLineWidths) {
439 fprintf(stderr, TgLoadString(STID_CANT_GET_XDEF_DEF_WIDTHS_USED),
440 TOOL_NAME, buf);
441 fprintf(stderr, "\n");
442
443 free(curWidthOfLine);
444 free(curArrowHeadW);
445 free(curArrowHeadH);
446 for (j=0; j < i; j++) {
447 if (curWidthOfLineSpec[j] != NULL) free(curWidthOfLineSpec[j]);
448 if (curArrowHeadWSpec[j] != NULL) free(curArrowHeadWSpec[j]);
449 if (curArrowHeadHSpec[j] != NULL) free(curArrowHeadHSpec[j]);
450 }
451 free(curWidthOfLine);
452 free(curArrowHeadW);
453 free(curArrowHeadH);
454 } else {
455 y = HALF_W(menuImageH);
456 short_y = HALF_W(choiceImageH);
457
458 lineWidthPixmap = (Pixmap*)malloc(maxLineWidths*sizeof(Pixmap));
459 if (lineWidthPixmap == NULL) FailAllocMessage();
460 shortLineWidthPixmap = (Pixmap*)malloc(maxLineWidths*sizeof(Pixmap));
461 if (shortLineWidthPixmap == NULL) FailAllocMessage();
462
463 dummy_pixmap = XCreatePixmap(mainDisplay, mainWindow, 1, 1, 1);
464
465 values.foreground = 1;
466 values.background = 0;
467 values.fill_style = FillSolid;
468 values.function = GXcopy;
469 values.font = rulerFontPtr->fid;
470 tmp_gc = XCreateGC(mainDisplay, dummy_pixmap,
471 GCForeground | GCBackground | GCFillStyle | GCFunction | GCFont,
472 &values);
473
474 values.foreground = 0;
475 tmp_rev_gc = XCreateGC(mainDisplay, dummy_pixmap,
476 GCForeground | GCBackground | GCFillStyle | GCFunction | GCFont,
477 &values);
478
479 for (i = 0; i < maxLineWidths; i++) {
480 lineWidthPixmap[i] = XCreatePixmap(mainDisplay, mainWindow,
481 menuImageW, menuImageH, 1);
482 shortLineWidthPixmap[i] = XCreatePixmap(mainDisplay, mainWindow,
483 choiceImageW, choiceImageH, 1);
484
485 XFillRectangle(mainDisplay, lineWidthPixmap[i], tmp_rev_gc,
486 0, 0, menuImageW, menuImageH);
487 XFillRectangle(mainDisplay, shortLineWidthPixmap[i], tmp_rev_gc,
488 0, 0, choiceImageW, choiceImageH);
489
490 values.line_width = curWidthOfLine[i];
491 #ifdef NO_THIN_LINE
492 if (values.line_width < 1) values.line_width = 1;
493 #endif
494 XChangeGC(mainDisplay, tmp_gc, GCLineWidth, &values);
495
496 XDrawLine(mainDisplay, lineWidthPixmap[i], tmp_gc,
497 4, y, menuImageW-4, y);
498 XDrawLine(mainDisplay, shortLineWidthPixmap[i], tmp_gc,
499 4, short_y, choiceImageW-4, short_y);
500
501 sprintf(s, "%1d", curWidthOfLine[i]);
502 len = strlen(s);
503
504 x = HALF_W(menuImageW-len*rulerFontWidth);
505 if (curWidthOfLine[i] > menuImageH-4) {
506 XDrawString(mainDisplay, lineWidthPixmap[i], tmp_rev_gc, x,
507 y+HALF_W(rulerFontHeight)-rulerFontDes, s, len);
508 }
509 x = HALF_W(choiceImageW-len*rulerFontWidth);
510 if (curWidthOfLine[i] > choiceImageH-4) {
511 XDrawString(mainDisplay, shortLineWidthPixmap[i], tmp_rev_gc, x,
512 y+HALF_W(rulerFontHeight)-rulerFontDes, s, len);
513 }
514 }
515 XFreeGC(mainDisplay, tmp_gc);
516 XFreeGC(mainDisplay, tmp_rev_gc);
517 XFreePixmap(mainDisplay, dummy_pixmap);
518
519 newLineWidthAllocated = TRUE;
520 }
521 if (!newLineWidthAllocated) {
522 maxLineWidths = MAXLINEWIDTHS;
523
524 curWidthOfLine = (short*)malloc(maxLineWidths*sizeof(short));
525 curArrowHeadW = (short*)malloc(maxLineWidths*sizeof(short));
526 curArrowHeadH = (short*)malloc(maxLineWidths*sizeof(short));
527 curWidthOfLineSpec = (char**)malloc(maxLineWidths*sizeof(char*));
528 curArrowHeadWSpec = (char**)malloc(maxLineWidths*sizeof(char*));
529 curArrowHeadHSpec = (char**)malloc(maxLineWidths*sizeof(char*));
530 memset(curWidthOfLineSpec, 0, sizeof(maxLineWidths*sizeof(char*)));
531 memset(curArrowHeadWSpec, 0, sizeof(maxLineWidths*sizeof(char*)));
532 memset(curArrowHeadHSpec, 0, sizeof(maxLineWidths*sizeof(char*)));
533
534 lineWidthPixmap = (Pixmap*)malloc(maxLineWidths*sizeof(Pixmap));
535 if (lineWidthPixmap == NULL) FailAllocMessage();
536 shortLineWidthPixmap = (Pixmap*)malloc(maxLineWidths*sizeof(Pixmap));
537 if (shortLineWidthPixmap == NULL) FailAllocMessage();
538
539 for (i = 0; i < maxLineWidths; i++) {
540 curWidthOfLine[i] = origWidthOfLine[i];
541 curArrowHeadW[i] = origArrowHeadW[i];
542 curArrowHeadH[i] = origArrowHeadH[i];
543 lineWidthPixmap[i] = defaultLineWidthPixmap[i];
544 shortLineWidthPixmap[i] = defaultShortLineWidthPixmap[i];
545 sprintf(gszMsgBox, "%1d", curWidthOfLine[i]);
546 curWidthOfLineSpec[i] = UtilStrDup(gszMsgBox);
547 sprintf(gszMsgBox, "%s", curArrowHeadWSpec[i]);
548 curArrowHeadWSpec[i] = UtilStrDup(gszMsgBox);
549 sprintf(gszMsgBox, "%s", curArrowHeadHSpec[i]);
550 curArrowHeadHSpec[i] = UtilStrDup(gszMsgBox);
551 }
552 }
553 lineWidth = 0;
554 if ((c_ptr=XGetDefault(mainDisplay,TOOL_NAME,"DefaultLineWidth"))!=NULL) {
555 lineWidth = atoi(c_ptr);
556 if (lineWidth < 0 || lineWidth >= maxLineWidths) {
557 fprintf(stderr, TgLoadString(STID_INVALID_XDEF_USE_ALT_VALUE),
558 TOOL_NAME, "DefaultLineWidth", c_ptr, 0);
559 }
560 }
561 }
562
563 static
SetCustomPatDir()564 void SetCustomPatDir()
565 {
566 *customPatDir = '\0';
567 if (*cmdLineCustomPatternDir != '\0') {
568 UtilStrCpyN(customPatDir, sizeof(customPatDir), cmdLineCustomPatternDir);
569 } else if (!PRTGIF || cmdLineOpenDisplay) {
570 char *c_ptr=NULL;
571
572 if ((c_ptr=XGetDefault(mainDisplay,TOOL_NAME,"CustomPatternDir"))!=NULL) {
573 if (c_ptr != NULL && *c_ptr != '\0' && UtilIsDirectory(c_ptr)) {
574 int len=0;
575
576 UtilStrCpyN(customPatDir, sizeof(customPatDir), c_ptr);
577 len = strlen(customPatDir);
578 if (len > 0 && customPatDir[len-1] == DIR_SEP) {
579 customPatDir[len-1] = '\0';
580 }
581 }
582 }
583 }
584 }
585
InitPatFill()586 void InitPatFill()
587 {
588 register int i;
589
590 pat_w[0] = pat0_width; pat_h[0] = pat0_height; patData[0] = pat0_bits;
591 pat_w[1] = pat1_width; pat_h[1] = pat1_height; patData[1] = pat1_bits;
592 pat_w[2] = pat2_width; pat_h[2] = pat2_height; patData[2] = pat2_bits;
593 pat_w[3] = pat3_width; pat_h[3] = pat3_height; patData[3] = pat3_bits;
594 pat_w[4] = pat4_width; pat_h[4] = pat4_height; patData[4] = pat4_bits;
595 pat_w[5] = pat5_width; pat_h[5] = pat5_height; patData[5] = pat5_bits;
596 pat_w[6] = pat6_width; pat_h[6] = pat6_height; patData[6] = pat6_bits;
597 pat_w[7] = pat7_width; pat_h[7] = pat7_height; patData[7] = pat7_bits;
598 pat_w[8] = pat8_width; pat_h[8] = pat8_height; patData[8] = pat8_bits;
599 pat_w[9] = pat9_width; pat_h[9] = pat9_height; patData[9] = pat9_bits;
600 pat_w[10] = pat10_width; pat_h[10] = pat10_height; patData[10] = pat10_bits;
601 pat_w[11] = pat11_width; pat_h[11] = pat11_height; patData[11] = pat11_bits;
602 pat_w[12] = pat12_width; pat_h[12] = pat12_height; patData[12] = pat12_bits;
603 pat_w[13] = pat13_width; pat_h[13] = pat13_height; patData[13] = pat13_bits;
604 pat_w[14] = pat14_width; pat_h[14] = pat14_height; patData[14] = pat14_bits;
605 pat_w[15] = pat15_width; pat_h[15] = pat15_height; patData[15] = pat15_bits;
606 pat_w[16] = pat16_width; pat_h[16] = pat16_height; patData[16] = pat16_bits;
607 pat_w[17] = pat17_width; pat_h[17] = pat17_height; patData[17] = pat17_bits;
608 pat_w[18] = pat18_width; pat_h[18] = pat18_height; patData[18] = pat18_bits;
609 pat_w[19] = pat19_width; pat_h[19] = pat19_height; patData[19] = pat19_bits;
610 pat_w[20] = pat20_width; pat_h[20] = pat20_height; patData[20] = pat20_bits;
611 pat_w[21] = pat21_width; pat_h[21] = pat21_height; patData[21] = pat21_bits;
612 pat_w[22] = pat22_width; pat_h[22] = pat22_height; patData[22] = pat22_bits;
613 pat_w[23] = pat23_width; pat_h[23] = pat23_height; patData[23] = pat23_bits;
614 pat_w[24] = pat24_width; pat_h[24] = pat24_height; patData[24] = pat24_bits;
615 pat_w[25] = pat25_width; pat_h[25] = pat25_height; patData[25] = pat25_bits;
616 pat_w[26] = pat26_width; pat_h[26] = pat26_height; patData[26] = pat26_bits;
617 pat_w[27] = pat27_width; pat_h[27] = pat27_height; patData[27] = pat27_bits;
618 pat_w[28] = pat28_width; pat_h[28] = pat28_height; patData[28] = pat28_bits;
619 pat_w[29] = pat29_width; pat_h[29] = pat29_height; patData[29] = pat29_bits;
620 pat_w[30] = pat30_width; pat_h[30] = pat30_height; patData[30] = pat30_bits;
621 pat_w[31] = pat31_width; pat_h[31] = pat31_height; patData[31] = pat31_bits;
622 pat_w[32] = pat32_width; pat_h[32] = pat32_height; patData[32] = pat32_bits;
623
624 for (i=0; i < MAXPATTERNS+1; i++) {
625 needToFreePat[i] = FALSE;
626 }
627 }
628
629 static int gnPatFillInitialized=FALSE;
630
Init2PatFill()631 void Init2PatFill()
632 {
633 register int i;
634
635 if (gnPatFillInitialized) return;
636
637 SetCustomPatDir();
638
639 for (i=3; i < MAXPATTERNS+1; i++) {
640 if (*customPatDir != '\0') {
641 unsigned int w_return=0, h_return=0;
642 int x_hot=0, y_hot=0;
643 unsigned char *data_return=NULL;
644 char path[MAXPATHLENGTH<<1];
645
646 snprintf(path, sizeof(path), "%s%cpat%1d.xbm", customPatDir, DIR_SEP,
647 i);
648 if (UtilPathExists(path)) {
649 if (XReadBitmapFileData(path, &w_return, &h_return, &data_return,
650 &x_hot, &y_hot) == BitmapSuccess) {
651 pat_w[i] = w_return;
652 pat_h[i] = h_return;
653 patData[i] = data_return;
654 needToFreePat[i] = TRUE;
655 } else {
656 fprintf(stderr, TgLoadString(STID_INVALID_XBM_CUST_PAT), path);
657 fprintf(stderr, "\n");
658 }
659 }
660 }
661 }
662 gnPatFillInitialized = TRUE;
663 }
664
InitPattern()665 void InitPattern()
666 {
667 register int i;
668 XGCValues values;
669
670 values.foreground = myFgPixel;
671 values.background = (threeDLook ? myLtGryPixel : myBgPixel);
672 values.fill_style = FillOpaqueStippled;
673
674 rasterGC = XCreateGC(mainDisplay, mainWindow,
675 GCForeground | GCBackground | GCFillStyle, &values);
676
677 values.fill_style = FillOpaqueStippled;
678 patGC = XCreateGC(mainDisplay, mainWindow,
679 GCForeground | GCBackground | GCFillStyle, &values);
680
681 values.background = myBgPixel;
682 values.graphics_exposures = False;
683 drawGC = XCreateGC(mainDisplay, mainWindow,
684 GCBackground | GCGraphicsExposures, &values);
685 drawSBGC = XCreateGC(mainDisplay, mainWindow,
686 GCBackground | GCGraphicsExposures, &values);
687
688 values.background = (threeDLook ? myLtGryPixel : myBgPixel);
689 values.font = defaultFontPtr->fid;
690 values.line_width = 1;
691 defaultGC = XCreateGC(mainDisplay, mainWindow,
692 GCForeground | GCBackground | GCFont | GCLineWidth, &values);
693
694 values.foreground = xorOne;
695 values.background = xorZero;
696 values.function = GXxor;
697 values.fill_style = FillSolid;
698 revDefaultGC = XCreateGC(mainDisplay, mainWindow, GCForeground |
699 GCBackground | GCFunction | GCFillStyle | GCFont, &values);
700
701 InitPatFill();
702 Init2PatFill();
703 for (i = 0; i < MAXPATTERNS+1; i++) {
704 patPixmap[i] = XCreateBitmapFromData(mainDisplay, mainWindow,
705 (char *)patData[i], pat_w[i], pat_h[i]);
706 }
707 values.foreground = xorOne;
708 values.background = xorZero;
709 values.function = GXxor;
710 values.line_width = 1;
711 values.fill_style = FillStippled;
712 values.stipple = patPixmap[SCROLLPAT];
713 revGrayGC = XCreateGC(mainDisplay, mainWindow,
714 GCForeground | GCBackground | GCFunction | GCLineWidth | GCFillStyle |
715 GCStipple, &values);
716
717 justPixmap[JUST_L] = XCreateBitmapFromData(mainDisplay, mainWindow,
718 (char *)just_l_bits, just_l_width, just_l_height);
719 justPixmap[JUST_C] = XCreateBitmapFromData(mainDisplay, mainWindow,
720 (char *)just_c_bits, just_c_width, just_c_height);
721 justPixmap[JUST_R] = XCreateBitmapFromData(mainDisplay, mainWindow,
722 (char *)just_r_bits, just_r_width, just_r_height);
723
724 alignHoriPixmap[ALIGN_N] = XCreateBitmapFromData(mainDisplay, mainWindow,
725 (char *)align_n_bits, align_n_width, align_n_height);
726 alignHoriPixmap[ALIGN_L] = XCreateBitmapFromData(mainDisplay, mainWindow,
727 (char *)align_l_bits, align_l_width, align_l_height);
728 alignHoriPixmap[ALIGN_C] = XCreateBitmapFromData(mainDisplay, mainWindow,
729 (char *)align_c_bits, align_c_width, align_c_height);
730 alignHoriPixmap[ALIGN_R] = XCreateBitmapFromData(mainDisplay, mainWindow,
731 (char *)align_r_bits, align_r_width, align_r_height);
732 alignHoriPixmap[ALIGN_S] = XCreateBitmapFromData(mainDisplay, mainWindow,
733 (char *)align_s_bits, align_s_width, align_s_height);
734
735 alignVertPixmap[ALIGN_N] = XCreateBitmapFromData(mainDisplay, mainWindow,
736 (char *)align_n_bits, align_n_width, align_n_height);
737 alignVertPixmap[ALIGN_T] = XCreateBitmapFromData(mainDisplay, mainWindow,
738 (char *)align_t_bits, align_t_width, align_t_height);
739 alignVertPixmap[ALIGN_M] = XCreateBitmapFromData(mainDisplay, mainWindow,
740 (char *)align_m_bits, align_m_width, align_m_height);
741 alignVertPixmap[ALIGN_B] = XCreateBitmapFromData(mainDisplay, mainWindow,
742 (char *)align_b_bits, align_b_width, align_b_height);
743 alignVertPixmap[ALIGN_S] = XCreateBitmapFromData(mainDisplay, mainWindow,
744 (char *)align_s_bits, align_s_width, align_s_height);
745
746 distrDirectPixmap[0] = XCreateBitmapFromData(mainDisplay, mainWindow,
747 (char *)patData[0], pat_w[0], pat_h[0]);
748 distrDirectPixmap[1] = XCreateBitmapFromData(mainDisplay, mainWindow,
749 (char *)align_t_bits, align_t_width, align_t_height);
750 distrDirectPixmap[2] = XCreateBitmapFromData(mainDisplay, mainWindow,
751 (char *)align_m_bits, align_m_width, align_m_height);
752 distrDirectPixmap[3] = XCreateBitmapFromData(mainDisplay, mainWindow,
753 (char *)align_b_bits, align_b_width, align_b_height);
754 distrDirectPixmap[4] = XCreateBitmapFromData(mainDisplay, mainWindow,
755 (char *)align_ns_bits, align_ns_width, align_ns_height);
756 distrDirectPixmap[5] = XCreateBitmapFromData(mainDisplay, mainWindow,
757 (char *)align_l_bits, align_l_width, align_l_height);
758 distrDirectPixmap[6] = XCreateBitmapFromData(mainDisplay, mainWindow,
759 (char *)align_lt_bits, align_lt_width, align_lt_height);
760 distrDirectPixmap[7] = XCreateBitmapFromData(mainDisplay, mainWindow,
761 (char *)align_lm_bits, align_lm_width, align_lm_height);
762 distrDirectPixmap[8] = XCreateBitmapFromData(mainDisplay, mainWindow,
763 (char *)align_lb_bits, align_lb_width, align_lb_height);
764 distrDirectPixmap[9] = XCreateBitmapFromData(mainDisplay, mainWindow,
765 (char *)align_ls_bits, align_ls_width, align_ls_height);
766 distrDirectPixmap[10] = XCreateBitmapFromData(mainDisplay, mainWindow,
767 (char *)align_c_bits, align_c_width, align_c_height);
768 distrDirectPixmap[11] = XCreateBitmapFromData(mainDisplay, mainWindow,
769 (char *)align_ct_bits, align_ct_width, align_ct_height);
770 distrDirectPixmap[12] = XCreateBitmapFromData(mainDisplay, mainWindow,
771 (char *)align_cm_bits, align_cm_width, align_cm_height);
772 distrDirectPixmap[13] = XCreateBitmapFromData(mainDisplay, mainWindow,
773 (char *)align_cb_bits, align_cb_width, align_cb_height);
774 distrDirectPixmap[14] = XCreateBitmapFromData(mainDisplay, mainWindow,
775 (char *)align_cs_bits, align_cs_width, align_cs_height);
776 distrDirectPixmap[15] = XCreateBitmapFromData(mainDisplay, mainWindow,
777 (char *)align_r_bits, align_r_width, align_r_height);
778 distrDirectPixmap[16] = XCreateBitmapFromData(mainDisplay, mainWindow,
779 (char *)align_rt_bits, align_rt_width, align_rt_height);
780 distrDirectPixmap[17] = XCreateBitmapFromData(mainDisplay, mainWindow,
781 (char *)align_rm_bits, align_rm_width, align_rm_height);
782 distrDirectPixmap[18] = XCreateBitmapFromData(mainDisplay, mainWindow,
783 (char *)align_rb_bits, align_rb_width, align_rb_height);
784 distrDirectPixmap[19] = XCreateBitmapFromData(mainDisplay, mainWindow,
785 (char *)align_rs_bits, align_rs_width, align_rs_height);
786 distrDirectPixmap[20] = XCreateBitmapFromData(mainDisplay, mainWindow,
787 (char *)align_sn_bits, align_sn_width, align_sn_height);
788 distrDirectPixmap[21] = XCreateBitmapFromData(mainDisplay, mainWindow,
789 (char *)align_st_bits, align_st_width, align_st_height);
790 distrDirectPixmap[22] = XCreateBitmapFromData(mainDisplay, mainWindow,
791 (char *)align_sm_bits, align_sm_width, align_sm_height);
792 distrDirectPixmap[23] = XCreateBitmapFromData(mainDisplay, mainWindow,
793 (char *)align_sb_bits, align_sb_width, align_sb_height);
794 distrDirectPixmap[24] = XCreateBitmapFromData(mainDisplay, mainWindow,
795 (char *)align_ss_bits, align_ss_width, align_ss_height);
796
797 alignDirectPixmap[0] = distrDirectPixmap[0];
798 alignDirectPixmap[1] = distrDirectPixmap[1];
799 alignDirectPixmap[2] = distrDirectPixmap[2];
800 alignDirectPixmap[3] = distrDirectPixmap[3];
801 alignDirectPixmap[4] = distrDirectPixmap[5];
802 alignDirectPixmap[5] = distrDirectPixmap[6];
803 alignDirectPixmap[6] = distrDirectPixmap[7];
804 alignDirectPixmap[7] = distrDirectPixmap[8];
805 alignDirectPixmap[8] = distrDirectPixmap[10];
806 alignDirectPixmap[9] = distrDirectPixmap[11];
807 alignDirectPixmap[10] = distrDirectPixmap[12];
808 alignDirectPixmap[11] = distrDirectPixmap[13];
809 alignDirectPixmap[12] = distrDirectPixmap[15];
810 alignDirectPixmap[13] = distrDirectPixmap[16];
811 alignDirectPixmap[14] = distrDirectPixmap[17];
812 alignDirectPixmap[15] = distrDirectPixmap[18];
813
814 defaultLineWidthPixmap[0] = XCreateBitmapFromData(mainDisplay, mainWindow,
815 (char *)lw0_bits, lw0_width, lw0_height);
816 defaultLineWidthPixmap[1] = XCreateBitmapFromData(mainDisplay, mainWindow,
817 (char *)lw1_bits, lw1_width, lw1_height);
818 defaultLineWidthPixmap[2] = XCreateBitmapFromData(mainDisplay, mainWindow,
819 (char *)lw2_bits, lw2_width, lw2_height);
820 defaultLineWidthPixmap[3] = XCreateBitmapFromData(mainDisplay, mainWindow,
821 (char *)lw3_bits, lw3_width, lw3_height);
822 defaultLineWidthPixmap[4] = XCreateBitmapFromData(mainDisplay, mainWindow,
823 (char *)lw4_bits, lw4_width, lw4_height);
824 defaultLineWidthPixmap[5] = XCreateBitmapFromData(mainDisplay, mainWindow,
825 (char *)lw5_bits, lw5_width, lw5_height);
826 defaultLineWidthPixmap[6] = XCreateBitmapFromData(mainDisplay, mainWindow,
827 (char *)lw6_bits, lw6_width, lw6_height);
828
829 lineStylePixmap[0] = XCreateBitmapFromData(mainDisplay, mainWindow,
830 (char *)ls0_bits, ls0_width, ls0_height);
831 lineStylePixmap[1] = XCreateBitmapFromData(mainDisplay, mainWindow,
832 (char *)ls1_bits, ls1_width, ls1_height);
833 lineStylePixmap[2] = XCreateBitmapFromData(mainDisplay, mainWindow,
834 (char *)ls2_bits, ls2_width, ls2_height);
835 lineStylePixmap[3] = XCreateBitmapFromData(mainDisplay, mainWindow,
836 (char *)ls3_bits, ls3_width, ls3_height);
837
838 lineTypePixmap[0] = XCreateBitmapFromData(mainDisplay, mainWindow,
839 (char *)lt0_bits, lt0_width, lt0_height);
840 lineTypePixmap[1] = XCreateBitmapFromData(mainDisplay, mainWindow,
841 (char *)lt1_bits, lt1_width, lt1_height);
842 lineTypePixmap[2] = XCreateBitmapFromData(mainDisplay, mainWindow,
843 (char *)lt2_bits, lt2_width, lt2_height);
844 lineTypePixmap[3] = XCreateBitmapFromData(mainDisplay, mainWindow,
845 (char *)lt3_bits, lt3_width, lt3_height);
846
847 lineDashPixmap[0] = XCreateBitmapFromData(mainDisplay, mainWindow,
848 (char *)ld0_bits, ld0_width, ld0_height);
849 lineDashPixmap[1] = XCreateBitmapFromData(mainDisplay, mainWindow,
850 (char *)ld1_bits, ld1_width, ld1_height);
851 lineDashPixmap[2] = XCreateBitmapFromData(mainDisplay, mainWindow,
852 (char *)ld2_bits, ld2_width, ld2_height);
853 lineDashPixmap[3] = XCreateBitmapFromData(mainDisplay, mainWindow,
854 (char *)ld3_bits, ld3_width, ld3_height);
855 lineDashPixmap[4] = XCreateBitmapFromData(mainDisplay, mainWindow,
856 (char *)ld4_bits, ld4_width, ld4_height);
857 lineDashPixmap[5] = XCreateBitmapFromData(mainDisplay, mainWindow,
858 (char *)ld5_bits, ld5_width, ld5_height);
859 lineDashPixmap[6] = XCreateBitmapFromData(mainDisplay, mainWindow,
860 (char *)ld6_bits, ld6_width, ld6_height);
861 lineDashPixmap[7] = XCreateBitmapFromData(mainDisplay, mainWindow,
862 (char *)ld7_bits, ld7_width, ld7_height);
863 lineDashPixmap[8] = XCreateBitmapFromData(mainDisplay, mainWindow,
864 (char *)ld8_bits, ld8_width, ld8_height);
865
866 shortLineStylePixmap[0] = XCreateBitmapFromData(mainDisplay, mainWindow,
867 (char *)ls0s_bits, ls0s_width, ls0s_height);
868 shortLineStylePixmap[1] = XCreateBitmapFromData(mainDisplay, mainWindow,
869 (char *)ls1s_bits, ls1s_width, ls1s_height);
870 shortLineStylePixmap[2] = XCreateBitmapFromData(mainDisplay, mainWindow,
871 (char *)ls2s_bits, ls2s_width, ls2s_height);
872 shortLineStylePixmap[3] = XCreateBitmapFromData(mainDisplay, mainWindow,
873 (char *)ls3s_bits, ls3s_width, ls3s_height);
874
875 filePixmap = XCreateBitmapFromData(mainDisplay, mainWindow,
876 (char *)file_bits, file_width, file_height);
877
878 landscapePixmap = XCreateBitmapFromData(mainDisplay, mainWindow,
879 (char *)landscap_bits, landscap_width, landscap_height);
880
881 specialPixmap = XCreateBitmapFromData(mainDisplay, mainWindow,
882 (char *)special_bits, special_width, special_height);
883
884 vspacePixmap = XCreateBitmapFromData(mainDisplay, mainWindow,
885 (char *)vspace_bits, vspace_width, vspace_height);
886
887 rcbRadiusPixmap = XCreateBitmapFromData(mainDisplay, mainWindow,
888 (char *)rcb_rad_bits, rcb_rad_width, rcb_rad_height);
889
890 moveModePixmap[CONST_MOVE] = XCreateBitmapFromData(mainDisplay, mainWindow,
891 (char *)const_mv_bits, const_mv_width, const_mv_height);
892
893 moveModePixmap[UNCONST_MOVE] = XCreateBitmapFromData(mainDisplay,
894 mainWindow, (char *)uncon_mv_bits, uncon_mv_width,
895 uncon_mv_height);
896
897 editPixmap = XCreateBitmapFromData(mainDisplay, mainWindow,
898 (char *)edit_bits, edit_width, edit_height);
899
900 intrPixmap[0] = XCreateBitmapFromData(mainDisplay, mainWindow,
901 (char *)intr_bits, intr_width, intr_height);
902 intrPixmap[1] = XCreateBitmapFromData(mainDisplay, mainWindow,
903 (char *)intr90_bits, intr90_width, intr90_height);
904
905 trekPixmap = XCreateBitmapFromData(mainDisplay, mainWindow,
906 (char *)trek_bits, trek_width, trek_height);
907
908 pageLayoutPixmap[PAGE_STACK] = XCreateBitmapFromData(mainDisplay,
909 mainWindow, (char *)stack_bits, stack_width, stack_height);
910
911 pageLayoutPixmap[PAGE_TILE] = XCreateBitmapFromData(mainDisplay,
912 mainWindow, (char *)tile_bits, tile_width, tile_height);
913
914 scrollPixmap[SCROLL_LEFTEND] = XCreateBitmapFromData(mainDisplay,
915 mainWindow, (char *)leftend_bits, leftend_width, leftend_height);
916 scrollPixmap[SCROLL_LEFT] = XCreateBitmapFromData(mainDisplay,
917 mainWindow, (char *)lfarrow_bits, lfarrow_width, lfarrow_height);
918 scrollPixmap[SCROLL_RIGHT] = XCreateBitmapFromData(mainDisplay,
919 mainWindow, (char *)rtarrow_bits, rtarrow_width, rtarrow_height);
920 scrollPixmap[SCROLL_RIGHTEND] = XCreateBitmapFromData(mainDisplay,
921 mainWindow, (char *)rightend_bits, rightend_width, rightend_height);
922 scrollPixmap[SCROLL_UPEND] = XCreateBitmapFromData(mainDisplay,
923 mainWindow, (char *)upend_bits, upend_width, upend_height);
924 scrollPixmap[SCROLL_UP] = XCreateBitmapFromData(mainDisplay,
925 mainWindow, (char *)uparrow_bits, uparrow_width, uparrow_height);
926 scrollPixmap[SCROLL_CHECKALL] = XCreateBitmapFromData(mainDisplay,
927 mainWindow, (char *)chkall_bits, chkall_width, chkall_height);
928 scrollPixmap[SCROLL_UNCHECKALL] = XCreateBitmapFromData(mainDisplay,
929 mainWindow, (char *)unchkall_bits, unchkall_width, unchkall_height);
930 scrollPixmap[SCROLL_DOWN] = XCreateBitmapFromData(mainDisplay,
931 mainWindow, (char *)dnarrow_bits, dnarrow_width, dnarrow_height);
932 scrollPixmap[SCROLL_DOWNEND] = XCreateBitmapFromData(mainDisplay,
933 mainWindow, (char *)downend_bits, downend_width, downend_height);
934
935 scrlBitmap[SCRL_UP] = XCreateBitmapFromData(mainDisplay,
936 mainWindow, (char *)scrl_up_bits, scrl_up_width, scrl_up_height);
937 scrlBitmap[SCRL_DN] = XCreateBitmapFromData(mainDisplay,
938 mainWindow, (char *)scrl_dn_bits, scrl_dn_width, scrl_dn_height);
939 scrlBitmap[SCRL_LF] = XCreateBitmapFromData(mainDisplay,
940 mainWindow, (char *)scrl_lf_bits, scrl_lf_width, scrl_lf_height);
941 scrlBitmap[SCRL_RT] = XCreateBitmapFromData(mainDisplay,
942 mainWindow, (char *)scrl_rt_bits, scrl_rt_width, scrl_rt_height);
943
944 shape_w[0] = shape0_width; shape_h[0] = shape0_height; shapeData[0] = shape0_bits;
945 shape_w[1] = shape1_width; shape_h[1] = shape1_height; shapeData[1] = shape1_bits;
946 shape_w[2] = shape2_width; shape_h[2] = shape2_height; shapeData[2] = shape2_bits;
947 shape_w[3] = shape3_width; shape_h[3] = shape3_height; shapeData[3] = shape3_bits;
948 shape_w[4] = shape4_width; shape_h[4] = shape4_height; shapeData[4] = shape4_bits;
949 shape_w[5] = shape5_width; shape_h[5] = shape5_height; shapeData[5] = shape5_bits;
950 shape_w[6] = shape6_width; shape_h[6] = shape6_height; shapeData[6] = shape6_bits;
951 shape_w[7] = shape7_width; shape_h[7] = shape7_height; shapeData[7] = shape7_bits;
952 shape_w[8] = shape8_width; shape_h[8] = shape8_height; shapeData[8] = shape8_bits;
953 shape_w[9] = shape9_width; shape_h[9] = shape9_height; shapeData[9] = shape9_bits;
954 shape_w[10] = shape10_width; shape_h[10] = shape10_height; shapeData[10] = shape10_bits;
955 shape_w[11] = shape11_width; shape_h[11] = shape11_height; shapeData[11] = shape11_bits;
956 shape_w[12] = shape12_width; shape_h[12] = shape12_height; shapeData[12] = shape12_bits;
957 shape_w[13] = shape13_width; shape_h[13] = shape13_height; shapeData[13] = shape13_bits;
958 shape_w[14] = shape14_width; shape_h[14] = shape14_height; shapeData[14] = shape14_bits;
959 shape_w[15] = shape15_width; shape_h[15] = shape15_height; shapeData[15] = shape15_bits;
960 shape_w[16] = shape16_width; shape_h[16] = shape16_height; shapeData[16] = shape16_bits;
961 shape_w[17] = shape17_width; shape_h[17] = shape17_height; shapeData[17] = shape17_bits;
962 shape_w[18] = shape18_width; shape_h[18] = shape18_height; shapeData[18] = shape18_bits;
963 shape_w[19] = shape19_width; shape_h[19] = shape19_height; shapeData[19] = shape19_bits;
964
965 for (i=0; i < MAXSHAPES; i++) {
966 shapePixmap[i] = XCreateBitmapFromData(mainDisplay, mainWindow,
967 (char *)shapeData[i], shape_w[i], shape_h[i]);
968 }
969 stretchableModePixmap[NO_STRETCHABLE_TEXT] = XCreateBitmapFromData(
970 mainDisplay, mainWindow, (char *)nstretch_bits, nstretch_width,
971 nstretch_height);
972 stretchableModePixmap[STRETCHABLE_TEXT] = XCreateBitmapFromData(mainDisplay,
973 mainWindow, (char *)stretch_bits, stretch_width, stretch_height);
974
975 transPatPixmap[NO_TRANSPAT_MODE] = XCreateBitmapFromData(mainDisplay,
976 mainWindow, (char *)patopaq_bits, patopaq_width, patopaq_height);
977 transPatPixmap[TRANSPAT_MODE] = XCreateBitmapFromData(mainDisplay,
978 mainWindow, (char *)pattrans_bits, pattrans_width, pattrans_height);
979
980 rotatePixmap[0] = XCreateBitmapFromData(mainDisplay, mainWindow,
981 (char *)rot_0_bits, rot_0_width, rot_0_height);
982 rotatePixmap[1] = XCreateBitmapFromData(mainDisplay, mainWindow,
983 (char *)rot_90_bits, rot_90_width, rot_90_height);
984 rotatePixmap[2] = XCreateBitmapFromData(mainDisplay, mainWindow,
985 (char *)rot_180_bits, rot_180_width, rot_180_height);
986 rotatePixmap[3] = XCreateBitmapFromData(mainDisplay, mainWindow,
987 (char *)rot_270_bits, rot_270_width, rot_270_height);
988
989 whereToPrintPixmap = (Pixmap*)malloc(MAXDEFWHERETOPRINT*sizeof(Pixmap));
990 if (whereToPrintPixmap == NULL) FailAllocMessage();
991 whereToPrintPixmap[PRINTER] = XCreateBitmapFromData(mainDisplay, mainWindow,
992 (char *)printer_bits, printer_width, printer_height);
993 whereToPrintPixmap[LATEX_FIG] = XCreateBitmapFromData(mainDisplay,
994 mainWindow, (char *)latex_bits, latex_width, latex_height);
995 whereToPrintPixmap[PS_FILE] = XCreateBitmapFromData(mainDisplay,
996 mainWindow, (char *)psfile_bits, psfile_width, psfile_height);
997 whereToPrintPixmap[XBM_FILE] = XCreateBitmapFromData(mainDisplay,
998 mainWindow, (char *)xbm_bits, xbm_width, xbm_height);
999 whereToPrintPixmap[TEXT_FILE] = XCreateBitmapFromData(mainDisplay,
1000 mainWindow, (char *)ascii_bits, ascii_width, ascii_height);
1001 whereToPrintPixmap[EPSI_FILE] = XCreateBitmapFromData(mainDisplay,
1002 mainWindow, (char *)epsi_bits, epsi_width, epsi_height);
1003 whereToPrintPixmap[GIF_FILE] = XCreateBitmapFromData(mainDisplay,
1004 mainWindow, (char *)gif_bits, gif_width, gif_height);
1005 whereToPrintPixmap[HTML_FILE] = XCreateBitmapFromData(mainDisplay,
1006 mainWindow, (char *)html_bits, html_width, html_height);
1007 whereToPrintPixmap[PDF_FILE] = XCreateBitmapFromData(mainDisplay,
1008 mainWindow, (char *)pdf_bits, pdf_width, pdf_height);
1009 whereToPrintPixmap[TIFFEPSI_FILE] = XCreateBitmapFromData(mainDisplay,
1010 mainWindow, (char *)tiffepsi_bits, tiffepsi_width, tiffepsi_height);
1011 whereToPrintPixmap[PNG_FILE] = XCreateBitmapFromData(mainDisplay,
1012 mainWindow, (char *)png_bits, png_width, png_height);
1013 whereToPrintPixmap[JPEG_FILE] = XCreateBitmapFromData(mainDisplay,
1014 mainWindow, (char *)jpeg_bits, jpeg_width, jpeg_height);
1015 whereToPrintPixmap[PPM_FILE] = XCreateBitmapFromData(mainDisplay,
1016 mainWindow, (char *)pbm_bits, pbm_width, pbm_height);
1017 whereToPrintPixmap[NETLIST_FILE] = XCreateBitmapFromData(mainDisplay,
1018 mainWindow, (char *)netlist_bits, netlist_width, netlist_height);
1019 whereToPrintPixmap[SVG_FILE] = XCreateBitmapFromData(mainDisplay,
1020 mainWindow, (char *)svg_bits, svg_width, svg_height);
1021
1022 shortLineTypePixmap[0] = XCreateBitmapFromData(mainDisplay, mainWindow,
1023 (char *)lt0s_bits, lt0s_width, lt0s_height);
1024 shortLineTypePixmap[1] = XCreateBitmapFromData(mainDisplay, mainWindow,
1025 (char *)lt1s_bits, lt1s_width, lt1s_height);
1026 shortLineTypePixmap[2] = XCreateBitmapFromData(mainDisplay, mainWindow,
1027 (char *)lt2s_bits, lt2s_width, lt2s_height);
1028 shortLineTypePixmap[3] = XCreateBitmapFromData(mainDisplay, mainWindow,
1029 (char *)lt3s_bits, lt3s_width, lt3s_height);
1030
1031 shortDashPixmap[0] = XCreateBitmapFromData(mainDisplay, mainWindow,
1032 (char *)ld0s_bits, ld0s_width, ld0s_height);
1033 shortDashPixmap[1] = XCreateBitmapFromData(mainDisplay, mainWindow,
1034 (char *)ld1s_bits, ld1s_width, ld1s_height);
1035 shortDashPixmap[2] = XCreateBitmapFromData(mainDisplay, mainWindow,
1036 (char *)ld2s_bits, ld2s_width, ld2s_height);
1037 shortDashPixmap[3] = XCreateBitmapFromData(mainDisplay, mainWindow,
1038 (char *)ld3s_bits, ld3s_width, ld3s_height);
1039 shortDashPixmap[4] = XCreateBitmapFromData(mainDisplay, mainWindow,
1040 (char *)ld4s_bits, ld4s_width, ld4s_height);
1041 shortDashPixmap[5] = XCreateBitmapFromData(mainDisplay, mainWindow,
1042 (char *)ld5s_bits, ld5s_width, ld5s_height);
1043 shortDashPixmap[6] = XCreateBitmapFromData(mainDisplay, mainWindow,
1044 (char *)ld6s_bits, ld6s_width, ld6s_height);
1045 shortDashPixmap[7] = XCreateBitmapFromData(mainDisplay, mainWindow,
1046 (char *)ld7s_bits, ld7s_width, ld7s_height);
1047 shortDashPixmap[8] = XCreateBitmapFromData(mainDisplay, mainWindow,
1048 (char *)ld8s_bits, ld8s_width, ld8s_height);
1049
1050 defaultShortLineWidthPixmap[0] = XCreateBitmapFromData(mainDisplay,
1051 mainWindow, (char *)lw0s_bits, lw0s_width, lw0s_height);
1052 defaultShortLineWidthPixmap[1] = XCreateBitmapFromData(mainDisplay,
1053 mainWindow, (char *)lw1s_bits, lw1s_width, lw1s_height);
1054 defaultShortLineWidthPixmap[2] = XCreateBitmapFromData(mainDisplay,
1055 mainWindow, (char *)lw2s_bits, lw2s_width, lw2s_height);
1056 defaultShortLineWidthPixmap[3] = XCreateBitmapFromData(mainDisplay,
1057 mainWindow, (char *)lw3s_bits, lw3s_width, lw3s_height);
1058 defaultShortLineWidthPixmap[4] = XCreateBitmapFromData(mainDisplay,
1059 mainWindow, (char *)lw4s_bits, lw4s_width, lw4s_height);
1060 defaultShortLineWidthPixmap[5] = XCreateBitmapFromData(mainDisplay,
1061 mainWindow, (char *)lw5s_bits, lw5s_width, lw5s_height);
1062 defaultShortLineWidthPixmap[6] = XCreateBitmapFromData(mainDisplay,
1063 mainWindow, (char *)lw6s_bits, lw6s_width, lw6s_height);
1064
1065 rotateModePixmap[0] = XCreateBitmapFromData(mainDisplay, mainWindow,
1066 (char *)rot_mode_bits, rot_mode_width, rot_mode_height);
1067 rotateModePixmap[1] = XCreateBitmapFromData(mainDisplay, mainWindow,
1068 (char *)rot_mode2_bits, rot_mode2_width, rot_mode2_height);
1069
1070 choicePixmap[NOTHING] = XCreateBitmapFromData(mainDisplay, mainWindow,
1071 (char *)arrow_bits, arrow_width, arrow_height);
1072 choicePixmap[DRAWTEXT] = XCreateBitmapFromData(mainDisplay, mainWindow,
1073 (char *)text_bits, text_width, text_height);
1074 choicePixmap[DRAWBOX] = XCreateBitmapFromData(mainDisplay, mainWindow,
1075 (char *)box_bits, box_width, box_height);
1076 choicePixmap[DRAWCORNEROVAL] = XCreateBitmapFromData(mainDisplay, mainWindow,
1077 (char *)oval_bits, oval_width, oval_height);
1078 choicePixmap[DRAWCENTEROVAL] = XCreateBitmapFromData(mainDisplay, mainWindow,
1079 (char *)ovalcent_bits, ovalcent_width, ovalcent_height);
1080 choicePixmap[DRAWEDGECIRCLE] = XCreateBitmapFromData(mainDisplay, mainWindow,
1081 (char *)ovaledge_bits, ovaledge_width, ovaledge_height);
1082 choicePixmap[DRAWPOLY] = XCreateBitmapFromData(mainDisplay, mainWindow,
1083 (char *)poly_bits, poly_width, poly_height);
1084 choicePixmap[DRAWPOLYGON] = XCreateBitmapFromData(mainDisplay, mainWindow,
1085 (char *)polygon_bits, polygon_width, polygon_height);
1086 choicePixmap[DRAWARC] = XCreateBitmapFromData(mainDisplay, mainWindow,
1087 (char *)arc_bits, arc_width, arc_height);
1088 choicePixmap[DRAWEDGEARC] = XCreateBitmapFromData(mainDisplay, mainWindow,
1089 (char *)arc_edge_bits, arc_edge_width, arc_edge_height);
1090 choicePixmap[DRAWRCBOX] = XCreateBitmapFromData(mainDisplay, mainWindow,
1091 (char *)rcbox_bits, rcbox_width, rcbox_height);
1092 choicePixmap[FREEHAND] = XCreateBitmapFromData(mainDisplay, mainWindow,
1093 (char *)freehand_bits, freehand_width, freehand_height);
1094 choicePixmap[VERTEXMODE] = XCreateBitmapFromData(mainDisplay, mainWindow,
1095 (char *)vmode_bits, vmode_width, vmode_height);
1096 choicePixmap[ROTATEMODE] = rotateModePixmap[1];
1097
1098 wireBitmap = XCreateBitmapFromData(mainDisplay, mainWindow,
1099 (char *)wire_bits, wire_width, wire_height);
1100
1101 runBitmap = XCreateBitmapFromData(mainDisplay, mainWindow,
1102 (char *)run_bits, run_width, run_height);
1103
1104 checkBitmap = XCreateBitmapFromData(mainDisplay, mainWindow,
1105 (char *)check_bits, check_width, check_height);
1106
1107 radioBitmap = XCreateBitmapFromData(mainDisplay, mainWindow,
1108 (char *)radio_bits, radio_width, radio_height);
1109
1110 submenuBitmap = XCreateBitmapFromData(mainDisplay, mainWindow,
1111 (char *)submenu_bits, submenu_width, submenu_height);
1112 graySubmenuBitmap = XCreateBitmapFromData(mainDisplay, mainWindow,
1113 (char *)gsubmenu_bits, gsubmenu_width, gsubmenu_height);
1114
1115 userRedrawBitmap = XCreateBitmapFromData(mainDisplay, mainWindow,
1116 (char *)redraw_bits, redraw_width, redraw_height);
1117
1118 statusBtnPixmap[0] = XCreateBitmapFromData(mainDisplay, mainWindow,
1119 (char *)btn1_bits, btn1_width, btn1_height);
1120 statusBtnPixmap[1] = XCreateBitmapFromData(mainDisplay, mainWindow,
1121 (char *)btn2_bits, btn2_width, btn2_height);
1122 statusBtnPixmap[2] = XCreateBitmapFromData(mainDisplay, mainWindow,
1123 (char *)btn3_bits, btn3_width, btn3_height);
1124
1125 msgBoxPixmap[0] = XCreateBitmapFromData(mainDisplay, mainWindow,
1126 (char *)stop_bits, stop_width, stop_height);
1127 msgBoxPixmap[1] = XCreateBitmapFromData(mainDisplay, mainWindow,
1128 (char *)question_bits, question_width, question_height);
1129 msgBoxPixmap[2] = XCreateBitmapFromData(mainDisplay, mainWindow,
1130 (char *)info_bits, info_width, info_height);
1131 msgBoxPixmap[3] = XCreateBitmapFromData(mainDisplay, mainWindow,
1132 (char *)dialog_bits, dialog_width, dialog_height);
1133
1134 InitLines();
1135 }
1136
RedrawChoiceWindow()1137 void RedrawChoiceWindow()
1138 {
1139 if (threeDLook) {
1140 struct BBRec bbox;
1141
1142 bbox.ltx = 0;
1143 bbox.lty = 0;
1144 bbox.rbx = choiceWindowW;
1145 bbox.rby = choiceWindowH;
1146 TgDrawThreeDButton(mainDisplay, choiceWindow, textMenuGC, &bbox,
1147 TGBS_RAISED, 1, FALSE);
1148 }
1149 ShowColor(FALSE);
1150 ShowFile();
1151 ShowWhereToPrint();
1152 ShowHoriAlign();
1153 ShowVertAlign();
1154 ShowRotate();
1155 ShowMoveMode();
1156 ShowRCBRadius();
1157 ShowZoom();
1158 ShowJust();
1159 ShowCurFont();
1160 ShowTextSize();
1161 ShowTextVSpace();
1162 ShowShape();
1163 ShowStretchableTextMode();
1164 ShowLineWidth();
1165 ShowLineStyle();
1166 ShowLineType();
1167 ShowDash();
1168 ShowFill();
1169 ShowTransPatMode();
1170 ShowPen();
1171 ShowPage();
1172 ShowPageLayout();
1173 }
1174
CleanUpPatFill()1175 void CleanUpPatFill()
1176 {
1177 register int i;
1178
1179 if (!gnPatFillInitialized) return;
1180
1181 for (i = 0; i < MAXPATTERNS+1; i++) {
1182 if (needToFreePat[i]) {
1183 XFree(patData[i]);
1184 }
1185 }
1186 gnPatFillInitialized = FALSE;
1187 }
1188
CleanUpRasters()1189 void CleanUpRasters()
1190 {
1191 register int i;
1192
1193 CleanUpPatFill();
1194 XFreePixmap(mainDisplay, rotateModePixmap[0]);
1195 XFreePixmap(mainDisplay, rotateModePixmap[1]);
1196 for (i = 0; i < MAXCHOICES-1; i++) XFreePixmap(mainDisplay, choicePixmap[i]);
1197 for (i = 0; i < MAXPATTERNS+1; i++) XFreePixmap(mainDisplay, patPixmap[i]);
1198 for (i = 0; i < MAXLINEWIDTHS; i++) {
1199 XFreePixmap(mainDisplay, defaultLineWidthPixmap[i]);
1200 }
1201 for (i = 0; i < MAXLINESTYLES; i++) {
1202 XFreePixmap(mainDisplay, lineStylePixmap[i]);
1203 }
1204 for (i = 0; i < MAXLINETYPES; i++) {
1205 XFreePixmap(mainDisplay, lineTypePixmap[i]);
1206 }
1207 for (i = 0; i < MAXDASHES; i++) {
1208 XFreePixmap(mainDisplay, lineDashPixmap[i]);
1209 }
1210 for (i = 0; i < MAXJUSTS; i++) XFreePixmap(mainDisplay, justPixmap[i]);
1211 for (i = 0; i < MAXALIGNS; i++) {
1212 XFreePixmap(mainDisplay, alignHoriPixmap[i]);
1213 }
1214 for (i = 0; i < MAXALIGNS; i++) {
1215 XFreePixmap(mainDisplay, alignVertPixmap[i]);
1216 }
1217 for (i = 0; i < MAXALIGNS*MAXALIGNS; i++) {
1218 XFreePixmap(mainDisplay, distrDirectPixmap[i]);
1219 }
1220 for (i = 0; i < MAXLINEWIDTHS; i++) {
1221 XFreePixmap(mainDisplay, defaultShortLineWidthPixmap[i]);
1222 }
1223 XFreePixmap(mainDisplay, filePixmap);
1224 XFreePixmap(mainDisplay, landscapePixmap);
1225 XFreePixmap(mainDisplay, specialPixmap);
1226 XFreePixmap(mainDisplay, vspacePixmap);
1227 XFreePixmap(mainDisplay, rcbRadiusPixmap);
1228 for (i = 0; i < MAXMOVEMODES; i++) {
1229 XFreePixmap(mainDisplay, moveModePixmap[i]);
1230 }
1231 XFreePixmap(mainDisplay, editPixmap);
1232 for (i = 0; i < MAXINTRS; i++) {
1233 XFreePixmap(mainDisplay, intrPixmap[i]);
1234 }
1235 XFreePixmap(mainDisplay, trekPixmap);
1236 for (i = 0; i < MAXPAGELAYOUTMODES; i++) {
1237 XFreePixmap(mainDisplay, pageLayoutPixmap[i]);
1238 }
1239 for (i = 0; i < MAXSCROLLBUTTONS; i++) {
1240 XFreePixmap(mainDisplay, scrollPixmap[i]);
1241 }
1242 for (i = 0; i < 4; i++) {
1243 XFreePixmap(mainDisplay, scrlBitmap[i]);
1244 }
1245 for (i = 0; i < MAXSHAPES; i++) {
1246 XFreePixmap(mainDisplay, shapePixmap[i]);
1247 }
1248 for (i = 0; i < MAXSTRETCHABLEMODES; i++) {
1249 XFreePixmap(mainDisplay, stretchableModePixmap[i]);
1250 }
1251 for (i = 0; i < MAXTRANSPATMODES; i++) {
1252 XFreePixmap(mainDisplay, transPatPixmap[i]);
1253 }
1254 for (i = 0; i < 4; i++) {
1255 XFreePixmap(mainDisplay, rotatePixmap[i]);
1256 }
1257 for (i = 0; i < MAXDEFWHERETOPRINT; i++) {
1258 XFreePixmap(mainDisplay, whereToPrintPixmap[i]);
1259 }
1260 free(whereToPrintPixmap);
1261 whereToPrintPixmap = NULL;
1262 for (i = 0; i < MAXLINETYPES; i++) {
1263 XFreePixmap(mainDisplay, shortLineTypePixmap[i]);
1264 }
1265 for (i = 0; i < MAXLINESTYLES; i++) {
1266 XFreePixmap(mainDisplay, shortLineStylePixmap[i]);
1267 }
1268 for (i = 0; i < MAXDASHES; i++) {
1269 XFreePixmap(mainDisplay, shortDashPixmap[i]);
1270 }
1271 XFreePixmap(mainDisplay, wireBitmap);
1272 XFreePixmap(mainDisplay, runBitmap);
1273 XFreePixmap(mainDisplay, checkBitmap);
1274 XFreePixmap(mainDisplay, radioBitmap);
1275 XFreePixmap(mainDisplay, submenuBitmap);
1276 XFreePixmap(mainDisplay, graySubmenuBitmap);
1277 XFreePixmap(mainDisplay, userRedrawBitmap);
1278 for (i = 0; i < MAX_STATUS_BTNS; i++) {
1279 XFreePixmap(mainDisplay, statusBtnPixmap[i]);
1280 }
1281 for (i = 0; i < MAX_MB_ICONS; i++) {
1282 XFreePixmap(mainDisplay, msgBoxPixmap[i]);
1283 }
1284 if (newLineWidthAllocated) {
1285 for (i = 0; i < maxLineWidths; i++)
1286 XFreePixmap(mainDisplay, lineWidthPixmap[i]);
1287 for (i = 0; i < maxLineWidths; i++)
1288 XFreePixmap(mainDisplay, shortLineWidthPixmap[i]);
1289 }
1290 free(lineWidthPixmap); lineWidthPixmap = NULL;
1291 free(shortLineWidthPixmap); shortLineWidthPixmap = NULL;
1292 free(curWidthOfLine); curWidthOfLine = NULL;
1293 free(curArrowHeadW); curArrowHeadW = NULL;
1294 free(curArrowHeadH); curArrowHeadH = NULL;
1295 for (i=0; i < maxLineWidths; i++) {
1296 if (curWidthOfLineSpec[i] != NULL) free(curWidthOfLineSpec[i]);
1297 if (curArrowHeadWSpec[i] != NULL) free(curArrowHeadWSpec[i]);
1298 if (curArrowHeadHSpec[i] != NULL) free(curArrowHeadHSpec[i]);
1299 }
1300 free(curWidthOfLineSpec); curWidthOfLineSpec = NULL;
1301 free(curArrowHeadWSpec); curArrowHeadWSpec = NULL;
1302 free(curArrowHeadHSpec); curArrowHeadHSpec = NULL;
1303
1304 XFreeGC(mainDisplay, rasterGC);
1305 XFreeGC(mainDisplay, patGC);
1306 XFreeGC(mainDisplay, drawGC); drawGC = NULL;
1307 XFreeGC(mainDisplay, drawSBGC); drawSBGC = NULL;
1308 XFreeGC(mainDisplay, defaultGC); defaultGC = NULL;
1309 XFreeGC(mainDisplay, revDefaultGC); revDefaultGC = NULL;
1310 XFreeGC(mainDisplay, revGrayGC); revGrayGC = NULL;
1311 }
1312
UpgradePenFill(pen_or_fill)1313 int UpgradePenFill(pen_or_fill)
1314 int pen_or_fill;
1315 {
1316 if (fileVersion <= 17 && pen_or_fill >= 8 && pen_or_fill < 12) {
1317 return (pen_or_fill+12);
1318 } else {
1319 return pen_or_fill;
1320 }
1321 }
1322
ByteReverse(byte)1323 unsigned char ByteReverse(byte)
1324 unsigned char byte;
1325 {
1326 int b=0;
1327 unsigned char flip=0, mask=1;
1328
1329 for (b=0; b < 8; b++) {
1330 flip <<= 1;
1331 flip += byte&mask;
1332 byte >>= 1;
1333 }
1334 return flip;
1335 }
1336
GetPatternCellsize(fill_or_pen,pn_cell_w,pn_cell_h)1337 void GetPatternCellsize(fill_or_pen, pn_cell_w, pn_cell_h)
1338 int fill_or_pen, *pn_cell_w, *pn_cell_h;
1339 {
1340 int w=pat_w[fill_or_pen];
1341 int bits_in_last_byte=(w & 0x07);
1342 int bytes_per_row_out=0;
1343
1344 switch (bits_in_last_byte) {
1345 case 1: bytes_per_row_out = (w+1); break;
1346 case 2: bytes_per_row_out = ((w>>3)<<2)+1; break;
1347 case 3: bytes_per_row_out = (w+3); break;
1348 case 4: bytes_per_row_out = ((w>>3)<<1)+1; break;
1349 case 5: bytes_per_row_out = (w+5); break;
1350 case 6: bytes_per_row_out = ((w>>3)<<2)+3; break;
1351 case 7: bytes_per_row_out = (w+7); break;
1352 default: bytes_per_row_out = (w>>3); break;
1353 }
1354 if (pn_cell_w != NULL) *pn_cell_w = (bytes_per_row_out<<3);
1355 if (pn_cell_h != NULL) *pn_cell_h = pat_h[fill_or_pen];
1356 }
1357
1358 static
SetBit(buf,bit_offset,ival)1359 void SetBit(buf, bit_offset, ival)
1360 unsigned char *buf;
1361 int bit_offset, ival;
1362 {
1363 int byte_index=(bit_offset>>3);
1364 int bit_in_byte=(7-(bit_offset&0x7));
1365 unsigned char *psz=(&buf[byte_index]);
1366
1367 if (ival) {
1368 *psz |= (((unsigned char)0x1) << bit_in_byte);
1369 } else {
1370 *psz &= (~(((unsigned char)0x1) << bit_in_byte));
1371 }
1372 }
1373
1374 static
GetBit(buf,bit_offset)1375 unsigned char GetBit(buf, bit_offset)
1376 unsigned char *buf;
1377 int bit_offset;
1378 {
1379 int byte_index=(bit_offset>>3);
1380 int bit_in_byte=(7-(bit_offset&0x7));
1381 unsigned char uch=buf[byte_index];
1382
1383 return ((uch >> bit_in_byte) & ((unsigned char)0x1));
1384 }
1385
GetPatternBytes(fill_or_pen,pn_num_bytes,pn_need_to_free)1386 unsigned char *GetPatternBytes(fill_or_pen, pn_num_bytes, pn_need_to_free)
1387 int fill_or_pen, *pn_num_bytes, *pn_need_to_free;
1388 {
1389 int w=pat_w[fill_or_pen];
1390 int h=pat_h[fill_or_pen];
1391 int bits_in_last_byte=(w & 0x07);
1392 int multiple_of_8=(bits_in_last_byte == 0);
1393 int bytes_per_row_in=0, bytes_per_row_out=0, total_bytes=0;
1394
1395 bytes_per_row_in = (multiple_of_8 ? (w>>3) : (w>>3)+1);
1396
1397 switch (bits_in_last_byte) {
1398 case 1: bytes_per_row_out = (w+1); break;
1399 case 2: bytes_per_row_out = ((w>>3)<<2)+1; break;
1400 case 3: bytes_per_row_out = (w+3); break;
1401 case 4: bytes_per_row_out = ((w>>3)<<1)+1; break;
1402 case 5: bytes_per_row_out = (w+5); break;
1403 case 6: bytes_per_row_out = ((w>>3)<<2)+3; break;
1404 case 7: bytes_per_row_out = (w+7); break;
1405 default: bytes_per_row_out = (w>>3); break;
1406 }
1407 total_bytes = h * bytes_per_row_out;
1408
1409 if (pn_num_bytes != NULL) *pn_num_bytes = total_bytes;
1410 if (!multiple_of_8) {
1411 unsigned char *buf=(unsigned char *)malloc(total_bytes);
1412 unsigned char *buf_in=patData[fill_or_pen], *buf_out=NULL;
1413 int r=0, i=0;
1414
1415 if (buf == NULL) FailAllocMessage();
1416 /* first reverse all the bits in buf_in */
1417 for (i=0; i < bytes_per_row_in*h; i++) {
1418 buf_in[i] = ByteReverse(buf_in[i]);
1419 }
1420 buf_out = buf;
1421 for (r=0; r < h; r++) {
1422 int c=0;
1423
1424 for (c=0; c < (bytes_per_row_out<<3); c++) {
1425 int bit_offset_in=(c % w);
1426
1427 SetBit(buf_out, c, GetBit(buf_in, bit_offset_in));
1428 }
1429 buf_in += bytes_per_row_in;
1430 buf_out += bytes_per_row_out;
1431 }
1432 /* reverse all the bits in buf_in back to what they were */
1433 buf_in = patData[fill_or_pen];
1434 for (i=0; i < bytes_per_row_in*h; i++) {
1435 buf_in[i] = ByteReverse(buf_in[i]);
1436 }
1437 for (i=0; i < total_bytes; i++) {
1438 buf[i] = ByteReverse(buf[i]);
1439 }
1440 if (pn_need_to_free != NULL) *pn_need_to_free = TRUE;
1441 return buf;
1442 }
1443 if (pn_need_to_free != NULL) *pn_need_to_free = FALSE;
1444
1445 return patData[fill_or_pen];
1446 }
1447
1448