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