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