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/grid.c,v 1.15 2011/05/16 16:21:57 william Exp $
19 */
20
21 #define _INCLUDE_FROM_GRID_C_
22
23 #include "tgifdefs.h"
24 #include "cmdids.h"
25 #include "expfdefs.h"
26
27 #include "choice.e"
28 #include "color.e"
29 #include "cursor.e"
30 #include "dialog.e"
31 #include "drawing.e"
32 #include "dup.e"
33 #include "file.e"
34 #include "grid.e"
35 #include "mainmenu.e"
36 #include "menu.e"
37 #include "menuinfo.e"
38 #include "msg.e"
39 #include "navigate.e"
40 #include "obj.e"
41 #include "page.e"
42 #include "pattern.e"
43 #include "raster.e"
44 #include "ruler.e"
45 #include "scroll.e"
46 #include "select.e"
47 #include "setup.e"
48 #include "stretch.e"
49 #include "strtbl.e"
50 #include "text.e"
51 #include "util.e"
52 #include "wb.e"
53 #include "xprtfltr.e"
54
55 #define ENGLISH_GRID_STEP 8
56 #define METRIC_GRID_STEP 5
57
58 int gridSystem = ENGLISH_GRID;
59 int snapOn = TRUE;
60 int xyEnglishGrid = DEFAULT_ENGLISH_GRID;
61 int xyMetricGrid = DEFAULT_METRIC_GRID;
62 int pageStyle = PORTRAIT;
63 int whereToPrint = LATEX_FIG;
64 int moveMode = UNCONST_MOVE;
65 int gridShown = TRUE;
66 int mapShown = TRUE;
67 int usePaperSizeStoredInFile = FALSE;
68 int oneMotionSelectMove = FALSE;
69 int queryZoomInPoint=FALSE;
70
71 int shiftForDiagMouseMove=TRUE;
72 #ifdef RESTRICTED_MOUSE_MOVE
73 int useRecentForDiagMouseMove=TRUE;
74 #else /* ~RESTRICTED_MOUSE_MOVE */
75 int useRecentForDiagMouseMove=FALSE;
76 #endif /* RESTRICTED_MOUSE_MOVE */
77
78 int defRightMargin=(ONE_INCH*TIK_PER_PIXEL);
79 int defRightMarginEnabled=INVALID;
80 int rightMargin=(ONE_INCH*TIK_PER_PIXEL);
81 int rightMarginEnabled=INVALID;
82 int rightMarginActive=TRUE;
83
84 static
MyHDotLine(Win,gc,Y,XStart,XEnd)85 void MyHDotLine(Win, gc, Y, XStart, XEnd)
86 Window Win;
87 GC gc;
88 int Y, XStart, XEnd;
89 {
90 int x, step=0;
91
92 switch (gridSystem) {
93 case ENGLISH_GRID: step = ENGLISH_GRID_STEP; break;
94 case METRIC_GRID: step = METRIC_GRID_STEP; break;
95 }
96 for (x=XStart; x < XEnd; x += step) {
97 PUT_A_POINT(mainDisplay, Win, gc, x, Y);
98 }
99 }
100
101 static
MyVDotLine(Win,gc,X,YStart,YEnd)102 void MyVDotLine(Win, gc, X, YStart, YEnd)
103 Window Win;
104 GC gc;
105 int X, YStart, YEnd;
106 {
107 int y, step=0;
108
109 switch (gridSystem) {
110 case ENGLISH_GRID: step = ENGLISH_GRID_STEP; break;
111 case METRIC_GRID: step = METRIC_GRID_STEP; break;
112 }
113 for (y=YStart; y < YEnd; y += step) {
114 PUT_A_POINT(mainDisplay, Win, gc, X, y);
115 }
116 }
117
118 #define FAKE_CM 80
119
120 static
DrawGridLinesSetVars(pn_inc,pn_step,pn_abs_inc)121 void DrawGridLinesSetVars(pn_inc, pn_step, pn_abs_inc)
122 int *pn_inc, *pn_step, *pn_abs_inc;
123 {
124 switch (gridSystem) {
125 case ENGLISH_GRID:
126 *pn_inc = HALF_INCH;
127 *pn_step = ENGLISH_GRID_STEP;
128 break;
129 case METRIC_GRID:
130 if (zoomedIn && zoomScale > 1) {
131 *pn_inc = (FAKE_CM>>1);
132 } else {
133 *pn_inc = ONE_CM;
134 }
135 *pn_step = METRIC_GRID_STEP;
136 break;
137 }
138 *pn_abs_inc = ABS_SIZE(*pn_inc);
139 }
140
141 static
PrepareDrawGCForGridPoints()142 void PrepareDrawGCForGridPoints()
143 {
144 XGCValues values;
145
146 values.foreground = myFgPixel;
147 values.function = GXcopy;
148 values.fill_style = FillSolid;
149 values.line_width = 1;
150 values.line_style = LineSolid;
151 XChangeGC(mainDisplay, drawGC,
152 GCForeground | GCFunction | GCFillStyle | GCLineWidth | GCLineStyle,
153 &values);
154 }
155
RedrawGridLines(Win)156 void RedrawGridLines(Win)
157 Window Win;
158 {
159 int i, inc=0, abs_inc=0, step=ENGLISH_GRID_STEP;
160 int x_start, y_start, x_end, y_end, x_grid_start, y_grid_start;
161
162 if (!gridShown || (inSlideShow && !visibleGridInSlideShow)) return;
163
164 DrawGridLinesSetVars(&inc, &step, &abs_inc);
165
166 if (drawOrigX % abs_inc == 0) {
167 x_start = 0;
168 } else {
169 x_start = OFFSET_X(((int)(drawOrigX / abs_inc) + 1) * abs_inc);
170 }
171 if (drawOrigY % abs_inc == 0) {
172 y_start = 0;
173 } else {
174 y_start = OFFSET_Y(((int)(drawOrigY / abs_inc) + 1) * abs_inc);
175 }
176 x_end = min(OFFSET_X(paperWidth), OFFSET_X(drawOrigX+drawWinW));
177 y_end = min(OFFSET_Y(paperHeight), OFFSET_Y(drawOrigY+drawWinH));
178
179 if (ZOOMED_SIZE(drawOrigX) % step == 0) {
180 x_grid_start = 0;
181 } else {
182 x_grid_start = ((int)(ZOOMED_SIZE(drawOrigX) / step)) * step -
183 ZOOMED_SIZE(drawOrigX);
184 }
185 if (ZOOMED_SIZE(drawOrigY) % step == 0) {
186 y_grid_start = 0;
187 } else {
188 y_grid_start = ((int)(ZOOMED_SIZE(drawOrigY) / step)) * step -
189 ZOOMED_SIZE(drawOrigY);
190 }
191 PrepareDrawGCForGridPoints();
192 for (i=x_start; i < x_end; i += inc) {
193 MyVDotLine(Win, drawGC, i, y_grid_start, y_end);
194 }
195 for (i=y_start; i < y_end; i += inc) {
196 MyHDotLine(Win, drawGC, i, x_grid_start, x_end);
197 }
198 }
199
DrawGridLines(Win,LtX,LtY,W,H)200 void DrawGridLines(Win, LtX, LtY, W, H)
201 Window Win;
202 int LtX, LtY, W, H; /* screen offsets */
203 {
204 int i, inc=0, abs_inc=0, step=ENGLISH_GRID_STEP;
205 int x_start, y_start, x_end, y_end, x_grid_start, y_grid_start;
206 int x_grid_end=0, y_grid_end=0, x_max=0, y_max=0;
207
208 if (!gridShown || (inSlideShow && !visibleGridInSlideShow)) return;
209
210 DrawGridLinesSetVars(&inc, &step, &abs_inc);
211
212 /* large divisions - use 'inc' */
213 if (drawOrigX % abs_inc == 0) {
214 x_start = 0;
215 } else {
216 x_start = OFFSET_X(((int)(drawOrigX / abs_inc) + 1) * abs_inc);
217 }
218 if (drawOrigY % abs_inc == 0) {
219 y_start = 0;
220 } else {
221 y_start = OFFSET_Y(((int)(drawOrigY / abs_inc) + 1) * abs_inc);
222 }
223 x_max = min(OFFSET_X(paperWidth), OFFSET_X(drawOrigX+drawWinW));
224 y_max = min(OFFSET_Y(paperHeight), OFFSET_Y(drawOrigY+drawWinH));
225 while (x_start+1 < LtX) x_start += inc;
226 while (y_start+1 < LtY) y_start += inc;
227 for (x_end=x_start; x_end < LtX+W+1; x_end += inc) {
228 if (x_end >= x_max) {
229 break;
230 }
231 }
232 x_end -= inc;
233 for (y_end=y_start; y_end < LtY+H+1; y_end += inc) {
234 if (y_end >= y_max) {
235 break;
236 }
237 }
238 y_end -= inc;
239 /* small divisions - use 'step' */
240 x_grid_start = x_start-inc;
241 y_grid_start = y_start-inc;
242 while (x_grid_start+1 < LtX) x_grid_start += step;
243 while (y_grid_start+1 < LtY) y_grid_start += step;
244 for (x_grid_end=x_end+step; x_grid_end < LtX+W+1; x_grid_end += step) {
245 if (x_grid_end >= x_max) {
246 break;
247 }
248 }
249 for (y_grid_end=y_end+step; y_grid_end < LtY+H+1; y_grid_end += step) {
250 if (y_grid_end >= y_max) {
251 break;
252 }
253 }
254 PrepareDrawGCForGridPoints();
255 for (i=x_start; i <= x_end; i += inc) {
256 MyVDotLine(Win, drawGC, i, y_grid_start, y_grid_end);
257 }
258 for (i=y_start; i <= y_end; i += inc) {
259 MyHDotLine(Win, drawGC, i, x_grid_start, x_grid_end);
260 }
261 }
262
RedrawPageLines(Win)263 void RedrawPageLines(Win)
264 Window Win;
265 {
266 register int i, x, y;
267 int end;
268
269 if (pageLayoutMode == PAGE_STACK || !pageLineShownInTileMode) return;
270
271 PrepareDrawGCForGridPoints();
272 end = OFFSET_Y(min(drawOrigY+drawWinH,paperHeight));
273 for (i=0; i < paperWidth; i += onePageWidth) {
274 x = OFFSET_X(i);
275 if (i >= drawOrigX && i < drawOrigX+drawWinW) {
276 XDrawLine(mainDisplay, Win, drawGC, x, 0, x, end);
277 }
278 if (i > drawOrigX+drawWinW) {
279 break;
280 }
281 }
282 end = OFFSET_X(min(drawOrigX+drawWinW,paperWidth));
283 for (i=0; i < paperHeight; i += onePageHeight) {
284 y = OFFSET_Y(i);
285 if (i >= drawOrigY && i < drawOrigY+drawWinH) {
286 XDrawLine(mainDisplay, Win, drawGC, 0, y, end, y);
287 }
288 if (i > drawOrigY+drawWinH) {
289 break;
290 }
291 }
292 }
293
DrawPageLines(Win,LtX,LtY,W,H)294 void DrawPageLines(Win, LtX, LtY, W, H)
295 Window Win;
296 int LtX, LtY, W, H; /* screen offsets */
297 {
298 int i, x, y, start, end;
299
300 if (pageLayoutMode == PAGE_STACK || !pageLineShownInTileMode) return;
301
302 PrepareDrawGCForGridPoints();
303 start = max(0,LtY);
304 end = min(LtY+H,OFFSET_Y(min(drawOrigY+drawWinH,paperHeight)));
305 if (end > start) {
306 for (i=0; i < paperWidth; i += onePageWidth) {
307 x = OFFSET_X(i);
308 if (x >= LtX && x < LtX+W) {
309 XDrawLine(mainDisplay, Win, drawGC, x, start, x, end);
310 }
311 if (i > drawOrigX+drawWinW) {
312 break;
313 }
314 }
315 }
316 start = max(0,LtX);
317 end = min(LtX+W,OFFSET_X(min(drawOrigX+drawWinW,paperWidth)));
318 if (end > start) {
319 for (i=0; i < paperHeight; i += onePageHeight) {
320 y = OFFSET_Y(i);
321 if (y >= LtY && y < LtY+H) {
322 XDrawLine(mainDisplay, Win, drawGC, start, y, end, y);
323 }
324 if (i > drawOrigY+drawWinH) {
325 break;
326 }
327 }
328 }
329 }
330
331 static
GetRightMarginSpec(buf)332 void GetRightMarginSpec(buf)
333 char *buf;
334 {
335 double dval=(double)0;
336
337 dval = ((double)rightMargin) * ((double)printMag) /
338 ((double)TIK_PER_PIXEL);
339 dval /= ((double)100);
340 PixelToCurrentUnit(buf, round(dval));
341 }
342
ToggleRightMargin()343 void ToggleRightMargin()
344 {
345 switch (rightMarginEnabled) {
346 case INVALID: rightMarginEnabled = TRUE; break;
347 case FALSE: rightMarginEnabled = TRUE; break;
348 case TRUE: rightMarginEnabled = FALSE; break;
349 }
350 SetFileModified(TRUE);
351 RedrawHRulerWindow();
352
353 if (rightMarginEnabled == TRUE) {
354 char buf[80];
355
356 *buf = '\0';
357 GetRightMarginSpec(buf);
358 sprintf(gszMsgBox, TgLoadString(STID_RIGHT_MARGIN_IS), buf);
359 Msg(gszMsgBox);
360 } else {
361 sprintf(gszMsgBox, TgLoadString(STID_RIGHT_MARGIN_DISABLED));
362 Msg(gszMsgBox);
363 }
364 }
365
SpecifyRightMargin()366 void SpecifyRightMargin()
367 {
368 char buf[MAXSTRING+1], spec[MAXSTRING+1];
369 double dval=(double)0;
370
371 *gszMsgBox = '\0';
372 GetRightMarginSpec(gszMsgBox);
373
374 sprintf(buf, TgLoadString(STID_CURRENT_RIGHT_MARGIN_IS), gszMsgBox);
375 strcpy(gszMsgBox, TgLoadString(STID_ENTER_RIGHT_MARGIN));
376 *spec = '\0';
377 Dialog(gszMsgBox, buf, spec);
378 UtilTrimBlanks(spec);
379 if (*spec == '\0') return;
380 if (GetDimensionInDouble(spec, TRUE, &dval)) {
381 dval = dval * ((double)100) * ((double)TIK_PER_PIXEL) /
382 ((double)printMag);
383 rightMargin = round(dval);
384 RedrawHRulerWindow();
385 SetFileModified(TRUE);
386
387 GetRightMarginSpec(buf);
388 sprintf(gszMsgBox, TgLoadString(STID_RIGHT_MARGIN_IS), buf);
389 Msg(gszMsgBox);
390 }
391 }
392
ToggleGridSystem()393 void ToggleGridSystem()
394 {
395 int saved_orig_x, saved_orig_y;
396
397 switch (gridSystem) {
398 case ENGLISH_GRID: Msg(TgLoadString(STID_USING_METRIC_SYSTEM)); break;
399 case METRIC_GRID: Msg(TgLoadString(STID_USING_ENGLISH_SYSTEM)); break;
400 }
401 gridSystem = !gridSystem;
402 if (drawOrigX != 0 || drawOrigY != 0) {
403 saved_orig_x = drawOrigX;
404 saved_orig_y = drawOrigY;
405 drawOrigX = drawOrigY = 0;
406 RedrawScrollBars();
407 UpdDrawWinBBox();
408 AdjSplineVs();
409 AdjustCurText(-(saved_orig_x), -(saved_orig_y));
410 }
411 ClearAndRedrawDrawWindow();
412 RedrawRulers();
413 UpdatePinnedMenu(MENU_LAYOUT);
414 }
415
IncGrid()416 void IncGrid()
417 {
418 if (!snapOn) {
419 Msg(TgLoadString(STID_SNAP_NOT_ON_GRID_SZ_SAME));
420 } else if (gridSystem == ENGLISH_GRID && xyEnglishGrid < HALF_INCH) {
421 xyEnglishGrid <<= 1;
422 RedrawRulers();
423 } else if (gridSystem == METRIC_GRID && xyMetricGrid < ONE_CM) {
424 switch (xyMetricGrid) {
425 case ONE_MM: xyMetricGrid = TWO_MM; break;
426 case TWO_MM: xyMetricGrid = FIVE_MM; break;
427 case FIVE_MM: xyMetricGrid = ONE_CM; break;
428 }
429 RedrawRulers();
430 } else {
431 Msg(TgLoadString(STID_AT_MAX_GRID_GRID_SZ_SAME));
432 }
433 }
434
DecGrid()435 void DecGrid()
436 {
437 if (!snapOn) {
438 Msg(TgLoadString(STID_SNAP_NOT_ON_GRID_SZ_SAME));
439 } else if (gridSystem == ENGLISH_GRID && xyEnglishGrid > 4) {
440 xyEnglishGrid >>= 1;
441 RedrawRulers();
442 } else if (gridSystem == METRIC_GRID && xyMetricGrid > ONE_MM) {
443 switch (xyMetricGrid) {
444 case TWO_MM: xyMetricGrid = ONE_MM; break;
445 case FIVE_MM: xyMetricGrid = TWO_MM; break;
446 case ONE_CM: xyMetricGrid = FIVE_MM; break;
447 }
448 RedrawRulers();
449 } else {
450 Msg(TgLoadString(STID_AT_MIN_GRID_GRID_SZ_SAME));
451 }
452 }
453
ToggleGridShown()454 void ToggleGridShown()
455 {
456 gridShown = !gridShown;
457 ClearAndRedrawDrawWindow();
458 UpdatePinnedMenu(MENU_LAYOUT);
459 }
460
ToggleSnapOn()461 void ToggleSnapOn()
462 {
463 snapOn = !snapOn;
464 if (snapOn) {
465 Msg(TgLoadString(STID_SNAP_TO_GRID_ACTV));
466 } else {
467 Msg(TgLoadString(STID_SNAP_TO_GRID_DISABLED));
468 }
469 RedrawRulers();
470 UpdatePinnedMenu(MENU_LAYOUT);
471 }
472
ToggleColorPostScript()473 void ToggleColorPostScript()
474 {
475 colorDump = !colorDump;
476 if (colorDump) {
477 Msg(TgLoadString(STID_WILL_PRINT_IN_COLOR));
478 } else {
479 Msg(TgLoadString(STID_WILL_PRINT_IN_BW));
480 }
481 ShowWhereToPrint();
482 SetFileModified(TRUE);
483 UpdatePinnedMenu(MENU_LAYOUT);
484 UpdatePinnedMenu(MENU_FILE);
485 }
486
ToggleMoveMode()487 void ToggleMoveMode()
488 {
489 moveMode = !moveMode;
490 switch (moveMode) {
491 case CONST_MOVE: Msg(TgLoadString(STID_CONSTRAINED_MOVE)); break;
492 case UNCONST_MOVE: Msg(TgLoadString(STID_UNCONSTRAINED_MOVE)); break;
493 }
494 ShowMoveMode();
495 UpdatePinnedMenu(MENU_LAYOUT);
496 UpdatePinnedMenu(MENU_MOVEMODE);
497 }
498
ToggleMapShown()499 void ToggleMapShown()
500 {
501 mapShown = !mapShown;
502 if (mapShown) {
503 Msg(TgLoadString(STID_WILL_DISPLAY_XBM_XPM));
504 } else {
505 Msg(TgLoadString(STID_WILL_NOT_DISPLAY_XBM_XPM));
506 }
507 ClearAndRedrawDrawWindow();
508 UpdatePinnedMenu(MENU_LAYOUT);
509 }
510
ToggleUseGray()511 void ToggleUseGray()
512 {
513 useGray = !useGray;
514 if (useGray) {
515 Msg(TgLoadString(STID_GRAY_SCALE_IN_BW_PRINTING));
516 } else {
517 Msg(TgLoadString(STID_NO_GRAY_SCALE_IN_BW_PRINTING));
518 }
519 SetFileModified(TRUE);
520 UpdatePinnedMenu(MENU_LAYOUT);
521 }
522
SetMeasureUnit()523 void SetMeasureUnit()
524 {
525 char buf[MAXSTRING+1], spec[MAXSTRING+1];
526
527 GetUnitSpec(gszMsgBox);
528 sprintf(buf, TgLoadString(STID_CURRENT_SPEC_IS), gszMsgBox);
529 strcpy(gszMsgBox, TgLoadString(STID_ENTER_MEASURE_UNIT_SPEC));
530 *spec = '\0';
531 Dialog(gszMsgBox, buf, spec);
532 UtilTrimBlanks(spec);
533 if (*spec == '\0') return;
534 if (SetUnit(spec)) {
535 RedrawRulers();
536 ShowUnitMsg();
537 SetFileModified(TRUE);
538 }
539 }
540
ToggleShowMenubar()541 void ToggleShowMenubar()
542 {
543 noMenubar = !noMenubar;
544 if (noMenubar) {
545 XUnmapWindow(mainDisplay, menubarWindow);
546 } else {
547 XMapWindow(mainDisplay, menubarWindow);
548 }
549 Reconfigure(TRUE);
550 UpdatePinnedMenu(MENU_LAYOUT);
551 }
552
ToggleShowStatus()553 void ToggleShowStatus()
554 {
555 noStatusWindow = !noStatusWindow;
556 if (noStatusWindow) {
557 XUnmapWindow(mainDisplay, userRedrawWindow);
558 XUnmapWindow(mainDisplay, statusWindow);
559 } else {
560 XMapWindow(mainDisplay, userRedrawWindow);
561 XMapWindow(mainDisplay, statusWindow);
562 }
563 Reconfigure(TRUE);
564 UpdatePinnedMenu(MENU_LAYOUT);
565 }
566
ToggleShowChoicebar()567 void ToggleShowChoicebar()
568 {
569 noChoiceWindow = !noChoiceWindow;
570 if (noChoiceWindow) {
571 XUnmapWindow(mainDisplay, choiceWindow);
572 XUnmapWindow(mainDisplay, msgWindow);
573 } else {
574 XMapWindow(mainDisplay, choiceWindow);
575 XMapWindow(mainDisplay, msgWindow);
576 }
577 Reconfigure(TRUE);
578 UpdatePinnedMenu(MENU_LAYOUT);
579 }
580
ToggleShowMode()581 void ToggleShowMode()
582 {
583 noModeWindow = !noModeWindow;
584 if (noModeWindow) {
585 XUnmapWindow(mainDisplay, modeWindow);
586 } else {
587 XMapWindow(mainDisplay, modeWindow);
588 }
589 Reconfigure(TRUE);
590 UpdatePinnedMenu(MENU_LAYOUT);
591 }
592
593 static
WhereToPrintMsg()594 void WhereToPrintMsg()
595 {
596 if (whereToPrint >= MAXDEFWHERETOPRINT) {
597 sprintf(gszMsgBox, TgLoadString(STID_WILL_EXPORT_FORMAT_FILE),
598 GetExportName(whereToPrint, EXPORT_THIS));
599 Msg(gszMsgBox);
600 } else {
601 switch (whereToPrint) {
602 case PRINTER: Msg(TgLoadString(STID_PRINT_DEV_SET_TO_PRINTER)); break;
603 case LATEX_FIG: Msg(TgLoadString(STID_WILL_EXPORT_EPS_FILE)); break;
604 case PS_FILE: Msg(TgLoadString(STID_WILL_EXPORT_RAW_PS_FILE)); break;
605 case XBM_FILE:
606 Msg(TgLoadString(colorDump ? STID_WILL_EXPORT_XPM_FILE :
607 STID_WILL_EXPORT_XBM_FILE));
608 break;
609 case TEXT_FILE: Msg(TgLoadString(STID_WILL_EXPORT_TEXT_FILE)); break;
610 case EPSI_FILE: Msg(TgLoadString(STID_WILL_EXPORT_EPSI_FILE)); break;
611 case GIF_FILE: Msg(TgLoadString(STID_WILL_EXPORT_GIF_FILE)); break;
612 case HTML_FILE: Msg(TgLoadString(STID_WILL_EXPORT_HTML_FILE)); break;
613 case PDF_FILE: Msg(TgLoadString(STID_WILL_EXPORT_PDF_FILE)); break;
614 case TIFFEPSI_FILE:
615 Msg(TgLoadString(STID_WILL_EXPORT_TIFFEPSI_FILE));
616 break;
617 case PNG_FILE: Msg(TgLoadString(STID_WILL_EXPORT_PNG_FILE)); break;
618 case JPEG_FILE: Msg(TgLoadString(STID_WILL_EXPORT_JPEG_FILE)); break;
619 case PPM_FILE:
620 Msg(TgLoadString(colorDump ? STID_WILL_EXPORT_PPM_FILE :
621 STID_WILL_EXPORT_PBM_FILE));
622 break;
623 case NETLIST_FILE:
624 Msg(TgLoadString(STID_WILL_EXPORT_NETLIST_FILE));
625 break;
626 case SVG_FILE: Msg(TgLoadString(STID_WILL_EXPORT_SVG_FILE)); break;
627 }
628 }
629 }
630
SetWhereToPrint(nIndex)631 void SetWhereToPrint(nIndex)
632 int nIndex;
633 {
634 whereToPrint = nIndex;
635 WhereToPrintMsg();
636 ShowWhereToPrint();
637 UpdatePinnedMenu(MENU_LAYOUT);
638 UpdatePinnedMenu(MENU_FILE);
639 }
640
ToggleWhereToPrint()641 void ToggleWhereToPrint()
642 {
643 int nIndex=0;
644 char szLeft[MAXSTRING], szRight[MAXSTRING];
645
646 whereToPrint = (whereToPrint+1) % maxWhereToPrint;
647 WhereToPrintMsg();
648 ShowWhereToPrint();
649 UpdatePinnedMenu(MENU_FILE);
650
651 nIndex = GetExportIndex(whereToPrint, EXPORT_NEXT);
652 if (nIndex == PRINTER) {
653 sprintf(szLeft, TgLoadCachedString(CSTID_PRINT_MODE),
654 GetExportName(whereToPrint, EXPORT_NEXT));
655 } else {
656 sprintf(szLeft, TgLoadCachedString(CSTID_EXPORT_MODE),
657 GetExportName(whereToPrint, EXPORT_NEXT));
658 }
659 nIndex = GetExportIndex(whereToPrint, EXPORT_PREV);
660 if (nIndex == PRINTER) {
661 sprintf(szRight, TgLoadCachedString(CSTID_PRINT_MODE),
662 GetExportName(whereToPrint, EXPORT_PREV));
663 } else {
664 sprintf(szRight, TgLoadCachedString(CSTID_EXPORT_MODE),
665 GetExportName(whereToPrint, EXPORT_PREV));
666 }
667 SetMouseStatus(szLeft, TgLoadCachedString(CSTID_LAYOUT_MENU), szRight);
668 }
669
ToggleOneMotionSelectMove()670 void ToggleOneMotionSelectMove()
671 {
672 oneMotionSelectMove = !oneMotionSelectMove;
673 if (oneMotionSelectMove) {
674 Msg(TgLoadString(STID_ONE_MOTION_SEL_MOVE_MODE));
675 } else {
676 Msg(TgLoadString(STID_CLICK_SEL_CLICK_MOVE_MODE));
677 }
678 UpdatePinnedMenu(MENU_LAYOUT);
679 }
680
ToggleColorLayers()681 void ToggleColorLayers()
682 {
683 if (!colorDisplay) {
684 MsgBox(TgLoadString(STID_CANT_TOGGLE_COLOR_LAYER_BW), TOOL_NAME, INFO_MB);
685 return;
686 }
687 colorLayers = !colorLayers;
688 if (colorLayers) {
689 XMapWindow(mainDisplay, colorWindow);
690 XMapWindow(mainDisplay, colorDummyWindow);
691 Msg(TgLoadString(STID_COLOR_LAYERS_ENABLED));
692 } else {
693 XUnmapWindow(mainDisplay, colorWindow);
694 XUnmapWindow(mainDisplay, colorDummyWindow);
695 Msg(TgLoadString(STID_COLOR_LAYERS_DISABLED));
696 }
697 Reconfigure(TRUE);
698 UpdatePinnedMenu(MENU_LAYOUT);
699 ClearAndRedrawDrawWindow();
700 }
701
ToggleStretchableText()702 void ToggleStretchableText()
703 {
704 stretchableText = !stretchableText;
705 if (stretchableText) {
706 Msg(TgLoadString(STID_STRETCHABLE_TEXT_MODE));
707 } else {
708 Msg(TgLoadString(STID_NON_STRETCHABLE_TEXT_MODE));
709 }
710 ShowStretchableTextMode();
711 UpdatePinnedMenu(MENU_STRETCHTEXT);
712 }
713
ToggleTransPatMode()714 void ToggleTransPatMode()
715 {
716 transPat = !transPat;
717 if (transPat) {
718 Msg(TgLoadString(STID_TRANS_PAT_MODE));
719 } else {
720 Msg(TgLoadString(STID_NON_TRANS_PAT_MODE));
721 }
722 ShowTransPatMode();
723 UpdatePinnedMenu(MENU_TRANSPAT);
724 }
725
726 static
PostZoom(xc,yc)727 void PostZoom(xc, yc)
728 int xc, yc;
729 {
730 int new_orig_x=0, new_orig_y=0;
731
732 UpdDrawWinWH();
733
734 new_orig_x = ((xc<<1)-drawWinW)>>1;
735 new_orig_y = ((yc<<1)-drawWinH)>>1;
736
737 drawOrigX = max(0,new_orig_x);
738 drawOrigY = max(0,new_orig_y);
739
740 if (drawOrigX>=0 && drawWinW<paperWidth && drawOrigX+drawWinW>=paperWidth) {
741 switch (gridSystem) {
742 case ENGLISH_GRID:
743 if ((paperWidth-drawWinW) % ABS_SIZE(HALF_INCH) == 0) {
744 drawOrigX = paperWidth-drawWinW;
745 } else {
746 drawOrigX = max(0, ((int)((paperWidth-drawWinW)/
747 ABS_SIZE(HALF_INCH)) + 1) * ABS_SIZE(HALF_INCH));
748 }
749 break;
750 case METRIC_GRID:
751 if (zoomedIn && zoomScale > 1) {
752 if ((paperWidth-drawWinW) % ABS_SIZE(FAKE_CM) == 0) {
753 drawOrigX = paperWidth-drawWinW;
754 } else {
755 drawOrigX = max(0, ((int)((paperWidth-drawWinW)/
756 ABS_SIZE(FAKE_CM)) + 1) * ABS_SIZE(FAKE_CM));
757 }
758 } else {
759 if ((paperWidth-drawWinW) % ABS_SIZE(ONE_CM) == 0) {
760 drawOrigX = paperWidth-drawWinW;
761 } else {
762 drawOrigX = max(0, ((int)((paperWidth-drawWinW)/
763 ABS_SIZE(ONE_CM)) + 1) * ABS_SIZE(ONE_CM));
764 }
765 }
766 break;
767 }
768 } else if (drawOrigX < 0 || drawWinW >= paperWidth) {
769 drawOrigX = 0;
770 }
771 if (drawOrigY>=0 && drawWinH<paperHeight &&
772 drawOrigY+drawWinH>=paperHeight) {
773 switch (gridSystem) {
774 case ENGLISH_GRID:
775 if ((paperHeight-drawWinH) % ABS_SIZE(HALF_INCH) == 0) {
776 drawOrigY = paperHeight-drawWinH;
777 } else {
778 drawOrigY = max(0, ((int)((paperHeight-drawWinH)/
779 ABS_SIZE(HALF_INCH)) + 1) * ABS_SIZE(HALF_INCH));
780 }
781 break;
782 case METRIC_GRID:
783 if (zoomedIn && zoomScale > 1) {
784 if ((paperHeight-drawWinH) % ABS_SIZE(FAKE_CM) == 0) {
785 drawOrigY = paperHeight-drawWinH;
786 } else {
787 drawOrigY = max(0, ((int)((paperHeight-drawWinH)/
788 ABS_SIZE(FAKE_CM)) + 1) * ABS_SIZE(FAKE_CM));
789 }
790 } else {
791 if ((paperHeight-drawWinH) % ABS_SIZE(ONE_CM) == 0) {
792 drawOrigY = paperHeight-drawWinH;
793 } else {
794 drawOrigY = max(0, ((int)((paperHeight-drawWinH)/
795 ABS_SIZE(ONE_CM)) + 1) * ABS_SIZE(ONE_CM));
796 }
797 }
798 break;
799 }
800 } else if (drawOrigY < 0 || drawWinH >= paperHeight) {
801 drawOrigY = 0;
802 }
803 drawOrigX = ABS_SIZE(ZOOMED_SIZE(drawOrigX));
804 drawOrigY = ABS_SIZE(ZOOMED_SIZE(drawOrigY));
805
806 UpdDrawWinBBox();
807
808 SetWatchCursor(drawWindow);
809 SetWatchCursor(mainWindow);
810 RedrawRulers();
811 RedrawScrollBars();
812 AdjSplineVs();
813 AdjCaches();
814 ShowZoom();
815 /* use to be ClearAndRedrawDrawWindowDontDrawCurText() */
816 ClearAndRedrawDrawWindowNoCurT();
817 SetDefaultCursor(mainWindow);
818 ShowCursor();
819
820 justDupped = FALSE;
821 if (!(curChoice==DRAWTEXT && textCursorShown)) {
822 ShowCurChoiceMouseStatus(curChoice, 0, FALSE);
823 }
824 }
825
DefaultZoom()826 void DefaultZoom()
827 {
828 int xc, yc;
829
830 if (zoomScale == 0) {
831 Msg(TgLoadString(STID_ALREADY_AT_DEF_ZOOM));
832 return;
833 }
834 if (curChoice==DRAWTEXT && textCursorShown) {
835 PrepareZoomCurText(&xc, &yc);
836 } else {
837 xc = (topSel==NULL) ? ((drawOrigX<<1)+drawWinW)>>1 : (selLtX+selRbX)>>1;
838 yc = (topSel==NULL) ? ((drawOrigY<<1)+drawWinH)>>1 : (selLtY+selRbY)>>1;
839 }
840 if (curChoice == VERTEXMODE) {
841 TieLooseEnds();
842 SetCurChoice(NOTHING);
843 }
844 zoomScale = 0;
845 zoomedIn = FALSE;
846
847 if (curChoice==DRAWTEXT && textCursorShown) PreZoomCurText();
848 PostZoom(xc, yc);
849 if (curChoice==DRAWTEXT && textCursorShown) PostZoomCurText(xc, yc);
850 }
851
852 static int zoomInAbsX=0, zoomInAbsY=0;
853 static int zoomInAtCursor=FALSE;
854 static int panAtCursor=FALSE;
855
856 static
FixUpZoomCenter(p_abs_cx,p_abs_cy,zooming_in)857 void FixUpZoomCenter(p_abs_cx, p_abs_cy, zooming_in)
858 int *p_abs_cx, *p_abs_cy, zooming_in;
859 {
860 int saved_zoomed_in=zoomedIn, saved_zoom_scale=zoomScale;
861 int anchor_x_off=OFFSET_X(*p_abs_cx), anchor_y_off=OFFSET_Y(*p_abs_cy);
862 int new_anchor_abs_x=0, new_anchor_abs_y=0;
863 int abs_dx=0, abs_dy=0, new_abs_cx=0, new_abs_cy=0;
864
865 switch (zooming_in) {
866 case INVALID: break;
867 case FALSE:
868 if (!zoomedIn) {
869 zoomScale++;
870 } else if (zoomScale == 1) {
871 zoomedIn = FALSE;
872 zoomScale--;
873 } else {
874 zoomScale--;
875 }
876 break;
877 default:
878 if (zoomedIn) {
879 zoomScale++;
880 } else if (zoomScale == 0) {
881 zoomedIn = TRUE;
882 zoomScale++;
883 } else {
884 zoomScale--;
885 }
886 break;
887 }
888 UpdDrawWinWH();
889
890 new_anchor_abs_x = ABS_X(anchor_x_off);
891 new_anchor_abs_y = ABS_Y(anchor_y_off);
892
893 new_abs_cx = (((drawOrigX<<1)+drawWinW)>>1);
894 new_abs_cy = (((drawOrigY<<1)+drawWinH)>>1);
895
896 abs_dx = new_abs_cx - new_anchor_abs_x;
897 abs_dy = new_abs_cy - new_anchor_abs_y;
898
899 if (zooming_in) {
900 *p_abs_cx += (abs_dx);
901 *p_abs_cy += (abs_dy);
902 } else {
903 *p_abs_cx += (abs_dx);
904 *p_abs_cy += (abs_dy);
905 }
906 zoomedIn = saved_zoomed_in;
907 zoomScale = saved_zoom_scale;
908 UpdDrawWinWH();
909 }
910
ZoomIn()911 void ZoomIn()
912 {
913 int xc=0, yc=0, need_to_restore_cur_choice=FALSE;
914
915 if (zoomedIn && zoomScale == MAX_ZOOMED_IN &&
916 !(zoomInAtCursor && panAtCursor)) {
917 MsgBox(TgLoadString(STID_ALREADY_AT_HIGHEST_MAG), TOOL_NAME, INFO_MB);
918 return;
919 }
920 if (curChoice==DRAWTEXT && textCursorShown) {
921 if (zoomInAtCursor) {
922 sprintf(gszMsgBox, " %s", TgLoadString(STID_CURSOR_IGNORED_CSBTN1));
923 TwoLineMsg(TgLoadString(STID_ZOOMIN_AROUND_EDIT_TEXT), gszMsgBox);
924 }
925 PrepareZoomCurText(&xc, &yc);
926 } else if (zoomInAtCursor) {
927 xc = zoomInAbsX;
928 yc = zoomInAbsY;
929 if (!panAtCursor) {
930 FixUpZoomCenter(&xc, &yc, TRUE);
931 }
932 } else if (queryZoomInPoint==TRUE || (queryZoomInPoint==INVALID &&
933 topSel==NULL)) {
934 if (queryZoomInPoint==INVALID && topSel==NULL) {
935 MakeQuiescent();
936 need_to_restore_cur_choice = TRUE;
937 }
938 SetMouseStatus(TgLoadString(STID_SEL_ZOOM_CENTER),
939 TgLoadCachedString(CSTID_CANCEL),
940 TgLoadCachedString(CSTID_CANCEL));
941 if (DrawWindowLoop(&xc, &yc, magCursor, FALSE) != Button1) {
942 Msg(TgLoadString(STID_ZOOMIN_CANCEL_BY_USER));
943 return;
944 }
945 xc = ABS_X(xc);
946 yc = ABS_Y(yc);
947 FixUpZoomCenter(&xc, &yc, TRUE);
948 } else if (queryZoomInPoint == BAD) {
949 Window root_win, child_win;
950 int root_x, root_y;
951 unsigned int status;
952
953 XQueryPointer(mainDisplay, drawWindow, &root_win, &child_win,
954 &root_x, &root_y, &xc, &yc, &status);
955 xc = ABS_X(xc);
956 yc = ABS_Y(yc);
957 FixUpZoomCenter(&xc, &yc, TRUE);
958 } else {
959 xc = (topSel==NULL) ? ((drawOrigX<<1)+drawWinW)>>1 : (selLtX+selRbX)>>1;
960 yc = (topSel==NULL) ? ((drawOrigY<<1)+drawWinH)>>1 : (selLtY+selRbY)>>1;
961 }
962 if (curChoice == VERTEXMODE) {
963 TieLooseEnds();
964 SetCurChoice(NOTHING);
965 }
966 if (!panAtCursor) {
967 if (zoomedIn) {
968 zoomScale++;
969 } else if (zoomScale == 0) {
970 zoomedIn = TRUE;
971 zoomScale++;
972 } else {
973 zoomScale--;
974 }
975 }
976 if (curChoice==DRAWTEXT && textCursorShown) PreZoomCurText();
977 PostZoom(xc, yc);
978 if (curChoice==DRAWTEXT && textCursorShown) PostZoomCurText(xc, yc);
979 if (need_to_restore_cur_choice) {
980 SetCurChoice(curChoiceBeforeMakeQuiescent);
981 }
982 }
983
ZoomInAtCursor(abs_x,abs_y)984 void ZoomInAtCursor(abs_x, abs_y)
985 int abs_x, abs_y;
986 {
987 zoomInAbsX = abs_x;
988 zoomInAbsY = abs_y;
989 zoomInAtCursor = TRUE;
990 ZoomIn();
991 zoomInAtCursor = FALSE;
992 }
993
ZoomWayOut()994 void ZoomWayOut()
995 {
996 int saved_zoom_scale=zoomScale, saved_zoomed_in=zoomedIn;
997
998 while ((drawWinW>>1) >= paperWidth && (drawWinH>>1) >= paperHeight) {
999 if (zoomedIn) {
1000 zoomScale++;
1001 } else if (zoomScale == 0) {
1002 zoomedIn = TRUE;
1003 zoomScale++;
1004 } else {
1005 zoomScale--;
1006 }
1007 drawWinW >>= 1;
1008 drawWinH >>= 1;
1009 }
1010 while (drawWinW < paperWidth || drawWinH < paperHeight) {
1011 if (!zoomedIn) {
1012 zoomScale++;
1013 } else if (zoomScale == 1) {
1014 zoomedIn = FALSE;
1015 zoomScale--;
1016 } else {
1017 zoomScale--;
1018 }
1019 drawWinW <<= 1;
1020 drawWinH <<= 1;
1021 }
1022 if (saved_zoom_scale==zoomScale && saved_zoomed_in==zoomedIn &&
1023 drawOrigX==0 && drawOrigY==0) {
1024 return;
1025 }
1026 TieLooseEnds();
1027 SetCurChoice(NOTHING);
1028
1029 PostZoom(0, 0);
1030 }
1031
ZoomOut()1032 void ZoomOut()
1033 {
1034 int xc, yc;
1035
1036 if (paperWidth <= drawWinW && paperHeight <= drawWinH) {
1037 MsgBox(TgLoadString(STID_AT_PAPER_EDGE_CANT_ZOOMOUT), TOOL_NAME, INFO_MB);
1038 return;
1039 }
1040 if (curChoice==DRAWTEXT && textCursorShown) {
1041 PrepareZoomCurText(&xc, &yc);
1042 } else if (queryZoomInPoint == BAD) {
1043 Window root_win, child_win;
1044 int root_x, root_y;
1045 unsigned int status;
1046
1047 XQueryPointer(mainDisplay, drawWindow, &root_win, &child_win,
1048 &root_x, &root_y, &xc, &yc, &status);
1049 xc = ABS_X(xc);
1050 yc = ABS_Y(yc);
1051 FixUpZoomCenter(&xc, &yc, FALSE);
1052 } else {
1053 xc = (topSel==NULL) ? ((drawOrigX<<1)+drawWinW)>>1 : (selLtX+selRbX)>>1;
1054 yc = (topSel==NULL) ? ((drawOrigY<<1)+drawWinH)>>1 : (selLtY+selRbY)>>1;
1055 }
1056 if (curChoice == VERTEXMODE) {
1057 TieLooseEnds();
1058 SetCurChoice(NOTHING);
1059 }
1060 if (!zoomedIn) {
1061 zoomScale++;
1062 } else if (zoomScale == 1) {
1063 zoomedIn = FALSE;
1064 zoomScale--;
1065 } else {
1066 zoomScale--;
1067 }
1068 if (curChoice==DRAWTEXT && textCursorShown) PreZoomCurText();
1069 PostZoom(xc, yc);
1070 if (curChoice==DRAWTEXT && textCursorShown) PostZoomCurText(xc, yc);
1071 }
1072
CenterAtCursor(abs_x,abs_y)1073 void CenterAtCursor(abs_x, abs_y)
1074 int abs_x, abs_y;
1075 {
1076 panAtCursor = TRUE;
1077 ZoomInAtCursor(abs_x, abs_y);
1078 panAtCursor = FALSE;
1079 }
1080
PreciseZoom(zoomed_in,zoom_scale,force_zoom)1081 void PreciseZoom(zoomed_in, zoom_scale, force_zoom)
1082 int zoomed_in, zoom_scale, force_zoom;
1083 {
1084 int xc, yc;
1085
1086 if (!force_zoom && zoomedIn == zoomed_in && zoomScale == zoom_scale) return;
1087
1088 if (curChoice==DRAWTEXT && textCursorShown) {
1089 PrepareZoomCurText(&xc, &yc);
1090 } else {
1091 xc = (topSel==NULL) ? ((drawOrigX<<1)+drawWinW)>>1 : (selLtX+selRbX)>>1;
1092 yc = (topSel==NULL) ? ((drawOrigY<<1)+drawWinH)>>1 : (selLtY+selRbY)>>1;
1093 }
1094 if (curChoice == VERTEXMODE) {
1095 TieLooseEnds();
1096 SetCurChoice(NOTHING);
1097 }
1098 zoomedIn = zoomed_in;
1099 zoomScale = zoom_scale;
1100
1101 if (curChoice==DRAWTEXT && textCursorShown) PreZoomCurText();
1102 PostZoom(xc, yc);
1103 if (curChoice==DRAWTEXT && textCursorShown) PostZoomCurText(xc, yc);
1104 }
1105
SetPSPageWidthHeight()1106 void SetPSPageWidthHeight()
1107 {
1108
1109 if (psYOffStr != NULL && psYOff != NULL) {
1110 float fval=(float)0;
1111
1112 fval = (float)(((float)onePageHeight)/((float)PIX_PER_INCH));
1113 FormatFloat(&fval, psYOffStr[0]);
1114 psYOff[0] = ((float)onePageHeight)/((float)PIX_PER_INCH);
1115 psPageWidthInInch[0]=((float)onePageWidth)/((float)PIX_PER_INCH);
1116 psPageWidthInInch[1]=((float)onePageHeight)/((float)PIX_PER_INCH);
1117 psPageHeightInInch[0]=((float)onePageHeight)/((float)PIX_PER_INCH);
1118 psPageHeightInInch[1]=((float)onePageWidth)/((float)PIX_PER_INCH);
1119 }
1120 }
1121
ResetOnePageSize()1122 void ResetOnePageSize()
1123 { /* reset 8.5in x 11in */
1124 #ifndef A4PAPER
1125 onePageWidth = (85*PIX_PER_INCH)/10;
1126 onePageHeight = 11*PIX_PER_INCH;
1127 #else /* A4PAPER */
1128 onePageWidth = (825*PIX_PER_INCH)/100;
1129 onePageHeight = (117*PIX_PER_INCH)/10;
1130 #endif /* A4PAPER */
1131 SetPSPageWidthHeight();
1132 }
1133
UpdPageStyle(NewPageStyle)1134 int UpdPageStyle(NewPageStyle)
1135 int NewPageStyle;
1136 {
1137 int changed=FALSE, old_w=paperWidth, old_h=paperHeight;
1138
1139 pageStyle = NewPageStyle;
1140 onePageWidth =
1141 round(psPageWidthInInch[NewPageStyle]*PIX_PER_INCH*100.0/printMag);
1142 onePageHeight =
1143 round(psPageHeightInInch[NewPageStyle]*PIX_PER_INCH*100.0/printMag);
1144 paperWidth = onePageWidth * paperCol;
1145 paperHeight = onePageHeight * paperRow;
1146 if (drawOrigX+drawWinW > paperWidth || drawOrigX+drawWinW > old_w) {
1147 if (drawOrigX+drawWinW > paperWidth) {
1148 int tmp_x=paperWidth-drawWinW;
1149
1150 switch (gridSystem) {
1151 case ENGLISH_GRID:
1152 if (zoomedIn) {
1153 if ((ZOOMED_SIZE(tmp_x) % HALF_INCH) == 0) {
1154 drawOrigX = max(0,tmp_x);
1155 } else {
1156 drawOrigX = max(0,((int)(ZOOMED_SIZE(tmp_x)/HALF_INCH)) *
1157 HALF_INCH);
1158 }
1159 } else {
1160 if ((tmp_x % (ABS_SIZE(HALF_INCH))) == 0) {
1161 drawOrigX = max(0,tmp_x);
1162 } else {
1163 drawOrigX = max(0,((int)(tmp_x/ABS_SIZE(HALF_INCH))) *
1164 ABS_SIZE(HALF_INCH));
1165 }
1166 }
1167 break;
1168 case METRIC_GRID:
1169 if (zoomedIn) {
1170 if (zoomScale > 1) {
1171 if ((ZOOMED_SIZE(tmp_x) % ONE_CM) == 0) {
1172 drawOrigX = max(0,tmp_x);
1173 } else {
1174 drawOrigX = max(0,((int)(ZOOMED_SIZE(tmp_x)/ONE_CM)) *
1175 ONE_CM);
1176 }
1177 } else {
1178 if ((ZOOMED_SIZE(tmp_x) % FAKE_CM) == 0) {
1179 drawOrigX = max(0,tmp_x);
1180 } else {
1181 drawOrigX = max(0,((int)(ZOOMED_SIZE(tmp_x)/FAKE_CM)) *
1182 FAKE_CM);
1183 }
1184 }
1185 } else {
1186 if ((tmp_x % (ABS_SIZE(ONE_CM))) == 0) {
1187 drawOrigX = max(0,tmp_x);
1188 } else {
1189 drawOrigX = max(0,((int)(tmp_x/ABS_SIZE(ONE_CM))) *
1190 ABS_SIZE(ONE_CM));
1191 }
1192 }
1193 break;
1194 }
1195 }
1196 drawOrigX = ABS_SIZE(ZOOMED_SIZE(drawOrigX));
1197 changed = TRUE;
1198 }
1199 if (drawOrigY+drawWinH > paperHeight || drawOrigY+drawWinH > old_h) {
1200 if (drawOrigY+drawWinH > paperHeight) {
1201 int tmp_y=paperHeight-drawWinH;
1202
1203 switch (gridSystem) {
1204 case ENGLISH_GRID:
1205 if (zoomedIn) {
1206 if ((ZOOMED_SIZE(tmp_y) % HALF_INCH) == 0) {
1207 drawOrigY = max(0,tmp_y);
1208 } else {
1209 drawOrigY = max(0,((int)(ZOOMED_SIZE(tmp_y)/HALF_INCH)) *
1210 HALF_INCH);
1211 }
1212 } else {
1213 if ((tmp_y % (ABS_SIZE(HALF_INCH))) == 0) {
1214 drawOrigY = max(0,tmp_y);
1215 } else {
1216 drawOrigY = max(0,((int)(tmp_y/ABS_SIZE(HALF_INCH))) *
1217 ABS_SIZE(HALF_INCH));
1218 }
1219 }
1220 break;
1221 case METRIC_GRID:
1222 if (zoomedIn) {
1223 if (zoomScale > 1) {
1224 if ((ZOOMED_SIZE(tmp_y) % FAKE_CM) == 0) {
1225 drawOrigY = max(0,tmp_y);
1226 } else {
1227 drawOrigY = max(0,((int)(ZOOMED_SIZE(tmp_y)/FAKE_CM)) *
1228 FAKE_CM);
1229 }
1230 } else {
1231 if ((ZOOMED_SIZE(tmp_y) % ONE_CM) == 0) {
1232 drawOrigY = max(0,tmp_y);
1233 } else {
1234 drawOrigY = max(0,((int)(ZOOMED_SIZE(tmp_y)/ONE_CM)) *
1235 ONE_CM);
1236 }
1237 }
1238 } else {
1239 if ((tmp_y % (ABS_SIZE(ONE_CM))) == 0) {
1240 drawOrigY = max(0,tmp_y);
1241 } else {
1242 drawOrigY = max(0,((int)(tmp_y/ABS_SIZE(ONE_CM))) *
1243 ABS_SIZE(ONE_CM));
1244 }
1245 }
1246 break;
1247 }
1248 }
1249 drawOrigY = ABS_SIZE(ZOOMED_SIZE(drawOrigY));
1250 changed = TRUE;
1251 }
1252 return changed;
1253 }
1254
ChangePageStyle(NewPageStyle)1255 void ChangePageStyle(NewPageStyle)
1256 int NewPageStyle;
1257 {
1258 if (pageStyle != NewPageStyle) {
1259 if (UpdPageStyle(NewPageStyle)) {
1260 UpdDrawWinBBox();
1261 AdjSplineVs();
1262 ClearAndRedrawDrawWindow();
1263 }
1264 ShowFile();
1265 UpdatePinnedMenu(MENU_LAYOUT);
1266 RedrawScrollBars();
1267 RedrawRulers();
1268 SetFileModified(TRUE);
1269 switch (NewPageStyle) {
1270 case LANDSCAPE: Msg(TgLoadString(STID_PAGE_STYLE_CHANGE_TO_LAND)); break;
1271 case PORTRAIT: Msg(TgLoadString(STID_PAGE_STYLE_CHANGE_TO_PORT)); break;
1272 }
1273 }
1274 }
1275
RefreshPageStyleMenu(menu)1276 int RefreshPageStyleMenu(menu)
1277 TgMenu *menu;
1278 {
1279 int ok=TRUE;
1280
1281 /* Portrait */
1282 ok &= TgSetMenuItemRadioById(menu, CMDID_PORTRAITMODE,
1283 (pageStyle==PORTRAIT));
1284 /* Landscape */
1285 ok &= TgSetMenuItemRadioById(menu, CMDID_LANDSCAPEMODE,
1286 (pageStyle==LANDSCAPE));
1287
1288 return ok;
1289 }
1290
CreatePageStyleMenu(parent_menu,x,y,menu_info,status_str_xlated)1291 TgMenu *CreatePageStyleMenu(parent_menu, x, y, menu_info, status_str_xlated)
1292 TgMenu *parent_menu;
1293 int x, y;
1294 TgMenuInfo *menu_info;
1295 int status_str_xlated; /* ignored, always 0 */
1296 {
1297 TgMenu *menu=TgCreateMenuFromMenuInfo(parent_menu, x, y, menu_info, FALSE);
1298
1299 if (menu != NULL) {
1300 if (!RefreshPageStyleMenu(menu)) {
1301 return TgDestroyMenu(menu, TRUE);
1302 }
1303 }
1304 return menu;
1305 }
1306
PageStyleMenu(X,Y,TrackMenubar)1307 int PageStyleMenu(X, Y, TrackMenubar)
1308 int X, Y, TrackMenubar;
1309 {
1310 int rc=INVALID;
1311 TgMenu *menu=(pageStyleMenuInfo.create_proc)(NULL, X, Y, &pageStyleMenuInfo,
1312 INVALID);
1313
1314 activeMenu = INVALID;
1315 if (menu != NULL) {
1316 menu->track_menubar = TrackMenubar;
1317
1318 rc = TgMenuLoop(menu);
1319 TgDestroyMenu(menu, TRUE);
1320 }
1321 return rc;
1322 }
1323
RefreshExportFormatMenu(menu)1324 void RefreshExportFormatMenu(menu)
1325 TgMenu *menu;
1326 {
1327 int i, num_items=menu->num_items;
1328 TgMenuItem *menuitems=menu->menuitems;
1329
1330 for (i=0; i < num_items; i++) {
1331 TgMenuItem *menu_item=(&menuitems[i]);
1332 TgMenuItem stMenuItem;
1333
1334 memset(&stMenuItem, 0, sizeof(TgMenuItem));
1335 stMenuItem.state = TGBS_NORMAL;
1336 stMenuItem.checked = (i == whereToPrint);
1337 TgSetMenuItemInfo(menu_item, TGMU_MASK_STATE|TGMU_MASK_CHECK,
1338 &stMenuItem);
1339 }
1340 }
1341
CreateExportFormatMenu(parent_menu,x,y,menu_info,status_str_xlated)1342 TgMenu *CreateExportFormatMenu(parent_menu, x, y, menu_info, status_str_xlated)
1343 TgMenu *parent_menu;
1344 int x, y;
1345 TgMenuInfo *menu_info;
1346 int status_str_xlated; /* ignored, always 0 */
1347 {
1348 int i=0;
1349 TgMenu *menu=NULL;
1350 TgMenuInfo stMenuInfo;
1351 TgMenuItemInfo *item_info=NULL;
1352
1353 memcpy(&stMenuInfo, menu_info, sizeof(TgMenuInfo));
1354 stMenuInfo.items = (TgMenuItemInfo*)malloc(
1355 (maxWhereToPrint+1)*sizeof(TgMenuItemInfo));
1356 if (stMenuInfo.items == NULL) FailAllocMessage();
1357 memset(stMenuInfo.items, 0, (maxWhereToPrint+1)*sizeof(TgMenuItemInfo));
1358 for (item_info=stMenuInfo.items, i=0; i < maxWhereToPrint;
1359 item_info++, i++) {
1360 item_info->menu_str = (char*)(Pixmap*)(&whereToPrintPixmap[i]);
1361 item_info->shortcut_str = NULL;
1362 if (i < MAXDEFWHERETOPRINT) {
1363 strcpy(gszMsgBox, ExportFormatMenuLoadString(i, colorDump));
1364 } else {
1365 sprintf(gszMsgBox, ExportFormatMenuLoadString(i, colorDump),
1366 GetExportName(i, EXPORT_THIS));
1367 }
1368 item_info->status_str = UtilStrDup(gszMsgBox);
1369 if (item_info->status_str == NULL) FailAllocMessage();
1370 item_info->submenu_info = NULL;
1371 item_info->cmdid = CMDID_SETWHERETOPRINT;
1372 }
1373 stMenuInfo.items[maxWhereToPrint].cmdid = INVALID;
1374
1375 /* the status_str has been translated in ExportFormatMenuLoadString() */
1376 menu = TgCreateMenuFromMenuInfo(parent_menu, x, y, &stMenuInfo, TRUE);
1377 for (item_info=stMenuInfo.items, i=0; i < maxWhereToPrint;
1378 item_info++, i++) {
1379 UtilFree(item_info->status_str);
1380 }
1381 memset(stMenuInfo.items, 0, (maxWhereToPrint+1)*sizeof(TgMenuItemInfo));
1382 free(stMenuInfo.items);
1383 stMenuInfo.items = NULL;
1384 if (menu != NULL) {
1385 TgMenuItem *menu_item=NULL;
1386 TgMenuItem stMenuItem;
1387
1388 menu->track_menubar = TRUE;
1389 TgAdjustMenuGeometry(menu, choiceImageW, choiceImageH, maxWhereToPrint);
1390 menu_item = (&menu->menuitems[whereToPrint]);
1391
1392 memset(&stMenuItem, 0, sizeof(TgMenuItem));
1393 stMenuItem.checked = TRUE;
1394 if (!TgSetMenuItemInfo(menu_item, TGMU_MASK_CHECK, &stMenuItem)) {
1395 return TgDestroyMenu(menu, TRUE);
1396 }
1397 menu->refresh_proc = ((RefreshMenuFunc*)RefreshExportFormatMenu);
1398 }
1399 return menu;
1400 }
1401
ExportFormatMenu(X,Y,TrackMenubar)1402 int ExportFormatMenu(X, Y, TrackMenubar)
1403 int X, Y, TrackMenubar;
1404 {
1405 int rc=INVALID;
1406 TgMenu *menu=(exportFormatMenuInfo.create_proc)(NULL, X, Y,
1407 &exportFormatMenuInfo, INVALID);
1408
1409 activeMenu = INVALID;
1410 if (menu != NULL) {
1411 menu->track_menubar = TrackMenubar;
1412
1413 rc = TgMenuLoop(menu);
1414 TgDestroyMenu(menu, TRUE);
1415 }
1416 return rc;
1417 }
1418
RefreshShowHideMenu(menu)1419 int RefreshShowHideMenu(menu)
1420 TgMenu *menu;
1421 {
1422 int ok=TRUE;
1423
1424 /* ShowBit/Pixmap */
1425 ok &= TgSetMenuItemCheckById(menu, CMDID_TOGGLEMAPSHOWN, mapShown);
1426 /* ShowMeasurement */
1427 ok &= TgSetMenuItemCheckById(menu, CMDID_TOGGLESHOWMEASUREMENT,
1428 showMeasurement);
1429 if (!showMeasurement) {
1430 ok &= TgEnableMenuItemById(menu, CMDID_TOGGLESHOWMEASUREMENTINTT, FALSE);
1431 }
1432 /* ShowMeasurementInTooltip */
1433 ok &= TgSetMenuItemCheckById(menu, CMDID_TOGGLESHOWMEASUREMENTINTT,
1434 showMeasurementInTooltip);
1435 /* ShowMenubar */
1436 ok &= TgSetMenuItemCheckById(menu, CMDID_TOGGLESHOWMENUBAR, !noMenubar);
1437 /* ShowStatus */
1438 ok &= TgSetMenuItemCheckById(menu, CMDID_TOGGLESHOWSTATUS,
1439 !noStatusWindow);
1440 /* ShowChoice */
1441 ok &= TgSetMenuItemCheckById(menu, CMDID_TOGGLESHOWCHOICEBAR,
1442 !noChoiceWindow);
1443 /* ShowMode */
1444 ok &= TgSetMenuItemCheckById(menu, CMDID_TOGGLESHOWMODE, !noModeWindow);
1445
1446 /* ToggleRightMargin */
1447 ok &= TgSetMenuItemCheckById(menu, CMDID_TOGGLERIGHTMARGIN,
1448 rightMarginEnabled == TRUE);
1449 /* SpecifyRightMargin */
1450 ok &= TgEnableMenuItemById(menu, CMDID_SPECIFYRIGHTMARGIN,
1451 rightMarginEnabled == TRUE);
1452
1453 if (gstWBInfo.do_whiteboard) {
1454 /* ShowChat */
1455 ok &= TgEnableMenuItemById(menu, CMDID_TOGGLESHOWCHAT, TRUE);
1456 ok &= TgSetMenuItemCheckById(menu, CMDID_TOGGLESHOWCHAT, !noChatWindow);
1457 } else {
1458 ok &= TgEnableMenuItemById(menu, CMDID_TOGGLESHOWCHAT, FALSE);
1459 }
1460 return ok;
1461 }
1462
CreateShowHideMenu(parent_menu,x,y,menu_info,status_str_xlated)1463 TgMenu *CreateShowHideMenu(parent_menu, x, y, menu_info, status_str_xlated)
1464 TgMenu *parent_menu;
1465 int x, y;
1466 TgMenuInfo *menu_info;
1467 int status_str_xlated; /* ignored, always 0 */
1468 {
1469 TgMenu *menu=TgCreateMenuFromMenuInfo(parent_menu, x, y, menu_info, FALSE);
1470
1471 if (menu != NULL) {
1472 if (!RefreshShowHideMenu(menu)) {
1473 return TgDestroyMenu(menu, TRUE);
1474 }
1475 }
1476 return menu;
1477 }
1478
RefreshLayoutMenu(menu)1479 int RefreshLayoutMenu(menu)
1480 TgMenu *menu;
1481 {
1482 int ok=TRUE;
1483
1484 /* VisibleGrid */
1485 ok &= TgSetMenuItemCheckById(menu, CMDID_TOGGLEGRID, gridShown);
1486 /* SnapToGrid */
1487 ok &= TgSetMenuItemCheckById(menu, CMDID_TOGGLESNAP, snapOn);
1488 /* Landscape */
1489 ok &= TgSetMenuItemRadioById(menu, CMDID_LANDSCAPEMODE,
1490 (pageStyle==LANDSCAPE));
1491 /* Portrait */
1492 ok &= TgSetMenuItemRadioById(menu, CMDID_PORTRAITMODE,
1493 (pageStyle==PORTRAIT));
1494 /* Print/ExportInColor */
1495 ok &= TgSetMenuItemCheckById(menu, CMDID_TOGGLEBWCOLORPS, colorDump);
1496 /* MetricGrid */
1497 ok &= TgSetMenuItemCheckById(menu, CMDID_TOGGLEGRIDSYSTEM,
1498 (gridSystem==METRIC_GRID));
1499 /* OneMotionSelMove */
1500 ok &= TgSetMenuItemCheckById(menu, CMDID_TOGGLEONEMOTIONSELMOVE,
1501 oneMotionSelectMove);
1502 /* UseGrayScale */
1503 ok &= TgSetMenuItemCheckById(menu, CMDID_TOGGLEUSEGRAYSCALE, useGray);
1504 /* UseColorLayers */
1505 ok &= TgEnableMenuItemById(menu, CMDID_TOGGLECOLORLAYERS, colorDisplay);
1506 if (colorDisplay) {
1507 ok &= TgSetMenuItemCheckById(menu, CMDID_TOGGLECOLORLAYERS, colorLayers);
1508 } else {
1509 ok &= TgSetMenuItemCheckById(menu, CMDID_TOGGLECOLORLAYERS, FALSE);
1510 }
1511 /* StackedPage */
1512 ok &= TgEnableMenuItemById(menu, MENU_STACKEDPAGE,
1513 (pageLayoutMode==PAGE_STACK));
1514 /* TiledPage */
1515 ok &= TgEnableMenuItemById(menu, MENU_TILEDPAGE,
1516 (pageLayoutMode!=PAGE_STACK));
1517
1518 return ok;
1519 }
1520
CreateLayoutMenu(parent_menu,x,y,menu_info,status_str_xlated)1521 TgMenu *CreateLayoutMenu(parent_menu, x, y, menu_info, status_str_xlated)
1522 TgMenu *parent_menu;
1523 int x, y;
1524 TgMenuInfo *menu_info;
1525 int status_str_xlated; /* ignored, always 0 */
1526 {
1527 TgMenu *menu=TgCreateMenuFromMenuInfo(parent_menu, x, y, menu_info, FALSE);
1528
1529 if (menu != NULL) {
1530 if (!RefreshLayoutMenu(menu)) {
1531 return TgDestroyMenu(menu, TRUE);
1532 }
1533 }
1534 return menu;
1535 }
1536
LayoutMenu(X,Y,TrackMenubar)1537 int LayoutMenu(X, Y, TrackMenubar)
1538 int X, Y, TrackMenubar;
1539 {
1540 int rc=INVALID;
1541 TgMenu *menu=(layoutMenuInfo.create_proc)(NULL, X, Y, &layoutMenuInfo,
1542 INVALID);
1543
1544 activeMenu = MENU_LAYOUT;
1545 if (menu != NULL) {
1546 menu->track_menubar = TrackMenubar;
1547
1548 rc = TgMenuLoop(menu);
1549 TgDestroyMenu(menu, TRUE);
1550 }
1551 return rc;
1552 }
1553
GridSize()1554 int GridSize()
1555 {
1556 int grid=1;
1557
1558 if (snapOn) {
1559 switch (gridSystem) {
1560 case ENGLISH_GRID: grid = xyEnglishGrid; break;
1561 case METRIC_GRID: grid = xyMetricGrid; break;
1562 }
1563 if (zoomedIn) {
1564 grid <<= zoomScale;
1565 }
1566 } else {
1567 if (zoomedIn) {
1568 grid = 1 << zoomScale;
1569 }
1570 }
1571 return grid;
1572 }
1573
GridXY(X,Y,GridX,GridY)1574 void GridXY(X, Y, GridX, GridY)
1575 int X, Y, *GridX, *GridY;
1576 {
1577 int dx, dy, grid=GridSize();
1578
1579 if (snapOn) {
1580 if (zoomedIn) {
1581 dx = (X+(drawOrigX<<zoomScale)) % grid;
1582 dy = (Y+(drawOrigY<<zoomScale)) % grid;
1583 } else {
1584 dx = (X+(drawOrigX>>zoomScale)) % grid;
1585 dy = (Y+(drawOrigY>>zoomScale)) % grid;
1586 }
1587 *GridX = ((dx<<1) < grid) ? X-dx : X-dx+grid;
1588 *GridY = ((dy<<1) < grid) ? Y-dy : Y-dy+grid;
1589 } else {
1590 if (zoomedIn) {
1591 dx = (X+(drawOrigX<<zoomScale)) % grid;
1592 dy = (Y+(drawOrigY<<zoomScale)) % grid;
1593 *GridX = ((dx<<1) < grid) ? X-dx : X-dx+grid;
1594 *GridY = ((dy<<1) < grid) ? Y-dy : Y-dy+grid;
1595 } else {
1596 *GridX = X;
1597 *GridY = Y;
1598 }
1599 }
1600 }
1601
ControlKeyPressedEvent(ev)1602 int ControlKeyPressedEvent(ev)
1603 XEvent *ev;
1604 {
1605 if (ev->type == KeyPress || ev->type == KeyRelease) {
1606 char s[80];
1607 KeySym key_sym;
1608
1609 XLookupString(&(ev->xkey), s, sizeof(s), &key_sym, NULL);
1610 if (key_sym == XK_Control_L || key_sym == XK_Control_R) {
1611 return (ev->type == KeyPress);
1612 }
1613 }
1614 return FALSE;
1615 }
1616
DiagEventCheck(ev)1617 int DiagEventCheck(ev)
1618 XEvent *ev;
1619 {
1620 static int prev_diag_state=FALSE;
1621
1622 if (ev->type == MotionNotify) {
1623 prev_diag_state = (ev->xmotion.state & ShiftMask) &&
1624 (!(ev->xmotion.state & ControlMask));
1625 } else if (ev->type == KeyPress || ev->type == KeyRelease) {
1626 char s[80];
1627 KeySym key_sym;
1628
1629 XLookupString(&(ev->xkey), s, sizeof(s), &key_sym, NULL);
1630 if (key_sym == XK_Shift_L || key_sym == XK_Shift_R) {
1631 prev_diag_state = (ev->type == KeyPress);
1632 return TRUE;
1633 }
1634 }
1635 return prev_diag_state;
1636 }
1637
DiagGridXY(OrigX,OrigY,NewX,NewY)1638 void DiagGridXY(OrigX, OrigY, NewX, NewY)
1639 int OrigX, OrigY, *NewX, *NewY;
1640 {
1641 int X=(*NewX), Y=(*NewY);
1642 int dx, dy;
1643 int p0, p1, p2, p3;
1644
1645 dx = OrigX - X;
1646 dy = OrigY - Y;
1647
1648 p0 = dy - (dx >> 1); /* y = x/2 */
1649 p1 = (dy >> 1) - dx; /* y = 2x */
1650 p2 = (dy >> 1) + dx; /* y = -2x */
1651 p3 = dy + (dx >> 1); /* y = -x/2 */
1652
1653 if ( (p3 ^ p0) < 0) {
1654 Y = OrigY;
1655 } else if ( (p0 ^ p1) < 0) {
1656 X = OrigX - ((dx + dy)>>1);
1657 Y = OrigY - ((dx + dy)>>1);
1658 } else if ( (p1 ^ p2) >= 0) {
1659 X = OrigX;
1660 } else {
1661 X = OrigX - ((dx - dy)>>1);
1662 Y = OrigY + ((dx - dy)>>1);
1663 if ((GridSize() & 0x1) == 0) {
1664 X--;
1665 }
1666 }
1667 (*NewX) = X;
1668 (*NewY) = Y;
1669 }
1670
CleanUpGrids()1671 void CleanUpGrids()
1672 {
1673 }
1674
MoveModeSubMenu(index)1675 void MoveModeSubMenu(index)
1676 int index;
1677 {
1678 moveMode = index;
1679 switch (moveMode) {
1680 case CONST_MOVE: Msg(TgLoadString(STID_CONSTRAINED_MOVE)); break;
1681 case UNCONST_MOVE: Msg(TgLoadString(STID_UNCONSTRAINED_MOVE)); break;
1682 }
1683 ShowMoveMode();
1684 UpdatePinnedMenu(MENU_LAYOUT);
1685 UpdatePinnedMenu(MENU_MOVEMODE);
1686 }
1687
RefreshMoveModeMenu(menu)1688 void RefreshMoveModeMenu(menu)
1689 TgMenu *menu;
1690 {
1691 int i, num_items=menu->num_items;
1692 TgMenuItem *menuitems=menu->menuitems;
1693
1694 for (i=0; i < num_items; i++) {
1695 TgMenuItem *menu_item=(&menuitems[i]);
1696 TgMenuItem stMenuItem;
1697
1698 memset(&stMenuItem, 0, sizeof(TgMenuItem));
1699 stMenuItem.state = TGBS_NORMAL;
1700 stMenuItem.checked = (i == moveMode);
1701 TgSetMenuItemInfo(menu_item, TGMU_MASK_STATE|TGMU_MASK_CHECK,
1702 &stMenuItem);
1703 }
1704 }
1705
CreateMoveModeMenu(parent_menu,x,y,menu_info,status_str_xlated)1706 TgMenu *CreateMoveModeMenu(parent_menu, x, y, menu_info, status_str_xlated)
1707 TgMenu *parent_menu;
1708 int x, y;
1709 TgMenuInfo *menu_info;
1710 int status_str_xlated; /* ignored, always 0 */
1711 {
1712 TgMenu *menu=TgCreateMenuFromMenuInfo(parent_menu, x, y, menu_info, FALSE);
1713
1714 if (menu != NULL) {
1715 TgMenuItem *menu_item=NULL;
1716 TgMenuItem stMenuItem;
1717
1718 menu->track_menubar = TRUE;
1719 TgAdjustMenuGeometry(menu, choiceImageW, choiceImageH, MAXMOVEMODES);
1720 menu_item = (&menu->menuitems[moveMode]);
1721
1722 memset(&stMenuItem, 0, sizeof(TgMenuItem));
1723 stMenuItem.checked = TRUE;
1724 if (!TgSetMenuItemInfo(menu_item, TGMU_MASK_CHECK, &stMenuItem)) {
1725 return TgDestroyMenu(menu, TRUE);
1726 }
1727 menu->refresh_proc = ((RefreshMenuFunc*)RefreshMoveModeMenu);
1728 }
1729 return menu;
1730 }
1731
MoveModeMenu(X,Y,TrackMenubar)1732 int MoveModeMenu(X, Y, TrackMenubar)
1733 int X, Y, TrackMenubar;
1734 {
1735 int rc=INVALID;
1736 TgMenu *menu=(moveModeMenuInfo.create_proc)(NULL, X, Y, &moveModeMenuInfo,
1737 INVALID);
1738
1739 activeMenu = MENU_MOVEMODE;
1740 if (menu != NULL) {
1741 menu->track_menubar = TrackMenubar;
1742
1743 rc = TgMenuLoop(menu);
1744 TgDestroyMenu(menu, TRUE);
1745 }
1746 return rc;
1747 }
1748
StretchableTextModeSubMenu(index)1749 void StretchableTextModeSubMenu(index)
1750 int index;
1751 {
1752 stretchableText = index;
1753 switch (stretchableText) {
1754 case NO_STRETCHABLE_TEXT:
1755 Msg(TgLoadString(STID_NON_STRETCHABLE_TEXT_MODE));
1756 break;
1757 case STRETCHABLE_TEXT: Msg(TgLoadString(STID_STRETCHABLE_TEXT_MODE)); break;
1758 }
1759 ShowStretchableTextMode();
1760 UpdatePinnedMenu(MENU_STRETCHTEXT);
1761 }
1762
RefreshStretchableTextModeMenu(menu)1763 void RefreshStretchableTextModeMenu(menu)
1764 TgMenu *menu;
1765 {
1766 int i, num_items=menu->num_items;
1767 TgMenuItem *menuitems=menu->menuitems;
1768
1769 for (i=0; i < num_items; i++) {
1770 TgMenuItem *menu_item=(&menuitems[i]);
1771 TgMenuItem stMenuItem;
1772
1773 memset(&stMenuItem, 0, sizeof(TgMenuItem));
1774 stMenuItem.state = TGBS_NORMAL;
1775 stMenuItem.checked = (i == stretchableText);
1776 TgSetMenuItemInfo(menu_item, TGMU_MASK_STATE|TGMU_MASK_CHECK,
1777 &stMenuItem);
1778 }
1779 }
1780
CreateStretchableTextModeMenu(parent_menu,x,y,menu_info,status_str_xlated)1781 TgMenu *CreateStretchableTextModeMenu(parent_menu, x, y, menu_info,
1782 status_str_xlated)
1783 TgMenu *parent_menu;
1784 int x, y;
1785 TgMenuInfo *menu_info;
1786 int status_str_xlated; /* ignored, always 0 */
1787 {
1788 TgMenu *menu=TgCreateMenuFromMenuInfo(parent_menu, x, y, menu_info, FALSE);
1789
1790 if (menu != NULL) {
1791 TgMenuItem *menu_item=NULL;
1792 TgMenuItem stMenuItem;
1793
1794 menu->track_menubar = TRUE;
1795 TgAdjustMenuGeometry(menu, choiceImageW, choiceImageH,
1796 MAXSTRETCHABLEMODES);
1797 menu_item = (&menu->menuitems[stretchableText]);
1798
1799 memset(&stMenuItem, 0, sizeof(TgMenuItem));
1800 stMenuItem.checked = TRUE;
1801 if (!TgSetMenuItemInfo(menu_item, TGMU_MASK_CHECK, &stMenuItem)) {
1802 return TgDestroyMenu(menu, TRUE);
1803 }
1804 menu->refresh_proc = ((RefreshMenuFunc*)RefreshStretchableTextModeMenu);
1805 }
1806 return menu;
1807 }
1808
StretchableTextModeMenu(X,Y,TrackMenubar)1809 int StretchableTextModeMenu(X, Y, TrackMenubar)
1810 int X, Y, TrackMenubar;
1811 {
1812 int rc=INVALID;
1813 TgMenu *menu=(stretchableTextModeMenuInfo.create_proc)(NULL, X, Y,
1814 &stretchableTextModeMenuInfo, INVALID);
1815
1816 activeMenu = MENU_STRETCHTEXT;
1817 if (menu != NULL) {
1818 menu->track_menubar = TrackMenubar;
1819
1820 rc = TgMenuLoop(menu);
1821 TgDestroyMenu(menu, TRUE);
1822 }
1823 return rc;
1824 }
1825
RefreshTransPatModeMenu(menu)1826 void RefreshTransPatModeMenu(menu)
1827 TgMenu *menu;
1828 {
1829 int i, num_items=menu->num_items;
1830 TgMenuItem *menuitems=menu->menuitems;
1831
1832 for (i=0; i < num_items; i++) {
1833 TgMenuItem *menu_item=(&menuitems[i]);
1834 TgMenuItem stMenuItem;
1835
1836 memset(&stMenuItem, 0, sizeof(TgMenuItem));
1837 stMenuItem.state = TGBS_NORMAL;
1838 stMenuItem.checked = (i == transPat);
1839 TgSetMenuItemInfo(menu_item, TGMU_MASK_STATE|TGMU_MASK_CHECK,
1840 &stMenuItem);
1841 }
1842 }
1843
CreateTransPatModeMenu(parent_menu,x,y,menu_info,status_str_xlated)1844 TgMenu *CreateTransPatModeMenu(parent_menu, x, y, menu_info, status_str_xlated)
1845 TgMenu *parent_menu;
1846 int x, y;
1847 TgMenuInfo *menu_info;
1848 int status_str_xlated; /* ignored, always 0 */
1849 {
1850 TgMenu *menu=TgCreateMenuFromMenuInfo(parent_menu, x, y, menu_info, FALSE);
1851
1852 if (menu != NULL) {
1853 TgMenuItem *menu_item=NULL;
1854 TgMenuItem stMenuItem;
1855
1856 menu->track_menubar = TRUE;
1857 TgAdjustMenuGeometry(menu, choiceImageW, choiceImageH, MAXTRANSPATMODES);
1858 menu_item = (&menu->menuitems[transPat]);
1859
1860 memset(&stMenuItem, 0, sizeof(TgMenuItem));
1861 stMenuItem.checked = TRUE;
1862 if (!TgSetMenuItemInfo(menu_item, TGMU_MASK_CHECK, &stMenuItem)) {
1863 return TgDestroyMenu(menu, TRUE);
1864 }
1865 menu->refresh_proc = ((RefreshMenuFunc*)RefreshTransPatModeMenu);
1866 }
1867 return menu;
1868 }
1869
TransPatModeMenu(X,Y,TrackMenubar)1870 int TransPatModeMenu(X, Y, TrackMenubar)
1871 int X, Y, TrackMenubar;
1872 {
1873 int rc=INVALID;
1874 TgMenu *menu=(transPatModeMenuInfo.create_proc)(NULL, X, Y,
1875 &transPatModeMenuInfo, INVALID);
1876
1877 activeMenu = MENU_TRANSPAT;
1878 if (menu != NULL) {
1879 menu->track_menubar = TrackMenubar;
1880
1881 rc = TgMenuLoop(menu);
1882 TgDestroyMenu(menu, TRUE);
1883 }
1884 return rc;
1885 }
1886
RefreshGridMenu(menu)1887 int RefreshGridMenu(menu)
1888 TgMenu *menu;
1889 {
1890 int ok=TRUE;
1891
1892 /* VisibleGrid */
1893 ok &= TgSetMenuItemCheckById(menu, CMDID_TOGGLEGRID, gridShown);
1894 /* SnapToGrid */
1895 ok &= TgSetMenuItemCheckById(menu, CMDID_TOGGLESNAP, snapOn);
1896 /* MetricGrid */
1897 ok &= TgSetMenuItemCheckById(menu, CMDID_TOGGLEGRIDSYSTEM,
1898 (gridSystem==METRIC_GRID));
1899
1900 /* ToggleRightMargin */
1901 ok &= TgSetMenuItemCheckById(menu, CMDID_TOGGLERIGHTMARGIN,
1902 rightMarginEnabled == TRUE);
1903 /* SpecifyRightMargin */
1904 ok &= TgEnableMenuItemById(menu, CMDID_SPECIFYRIGHTMARGIN,
1905 rightMarginEnabled == TRUE);
1906
1907 return ok;
1908 }
1909
CreateGridMenu(parent_menu,x,y,menu_info,status_str_xlated)1910 TgMenu *CreateGridMenu(parent_menu, x, y, menu_info, status_str_xlated)
1911 TgMenu *parent_menu;
1912 int x, y;
1913 TgMenuInfo *menu_info;
1914 int status_str_xlated; /* ignored, always 0 */
1915 {
1916 TgMenu *menu=TgCreateMenuFromMenuInfo(parent_menu, x, y, menu_info, FALSE);
1917
1918 if (menu != NULL) {
1919 if (!RefreshGridMenu(menu)) {
1920 return TgDestroyMenu(menu, TRUE);
1921 }
1922 menu->refresh_proc = ((RefreshMenuFunc*)RefreshGridMenu);
1923 }
1924 return menu;
1925 }
1926
GridMenu(X,Y,TrackMenubar)1927 int GridMenu(X, Y, TrackMenubar)
1928 int X, Y, TrackMenubar;
1929 {
1930 int rc=INVALID;
1931 TgMenu *menu=(gridMenuInfo.create_proc)(NULL, X, Y, &gridMenuInfo, INVALID);
1932
1933 activeMenu = INVALID;
1934 if (menu != NULL) {
1935 menu->track_menubar = TrackMenubar;
1936
1937 rc = TgMenuLoop(menu);
1938 TgDestroyMenu(menu, TRUE);
1939 }
1940 return rc;
1941 }
1942
1943