PageRenderTime 97ms CodeModel.GetById 29ms RepoModel.GetById 1ms app.codeStats 1ms

/fontforgeexe/cvpalettes.c

https://github.com/tshinnic/fontforge
C | 4443 lines | 3820 code | 433 blank | 190 comment | 983 complexity | 8f7bb73147e3a5162aad5752bd1dd8bc MD5 | raw file
Possible License(s): AGPL-1.0, GPL-3.0, Unlicense 
    

  1. /* Copyright (C) 2000-2012 by George Williams */
    2. 

  2. /*
    3. 

  3.  * Redistribution and use in source and binary forms, with or without
    4. 

  4.  * modification, are permitted provided that the following conditions are met:
    5. 

    6. 

  6.  * Redistributions of source code must retain the above copyright notice, this
    7. 

  7.  * list of conditions and the following disclaimer.
    8. 

    9. 

  9.  * Redistributions in binary form must reproduce the above copyright notice,
    10. 

  10.  * this list of conditions and the following disclaimer in the documentation
    11. 

  11.  * and/or other materials provided with the distribution.
    12. 

    13. 

  13.  * The name of the author may not be used to endorse or promote products
    14. 

  14.  * derived from this software without specific prior written permission.
    15. 

    16. 

  16.  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
    17. 

  17.  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
    18. 

  18.  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
    19. 

  19.  * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
    20. 

  20.  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
    21. 

  21.  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
    22. 

  22.  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
    23. 

  23.  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
    24. 

  24.  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
    25. 

  25.  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    26. 

  26.  */
    27. 

  27. #include "fontforgeui.h"
    28. 

  28. #include "collabclientui.h"
    29. 

  29. 

  30. int palettes_docked=1;
    31. 

  31. int rectelipse=0, polystar=0, regular_star=1;
    32. 

  32. int center_out[2] = { false, true };
    33. 

  33. float rr_radius=0;
    34. 

  34. int ps_pointcnt=6;
    35. 

  35. float star_percent=1.7320508;	/* Regular 6 pointed star */
    36. 

  36. extern int interpCPsOnMotion;
    37. 

  37. 

  38. #include <gkeysym.h>
    39. 

  39. #include <math.h>
    40. 

  40. #include "splinefont.h"
    41. 

  41. #include <ustring.h>
    42. 

  42. #include <utype.h>
    43. 

  43. #include <gresource.h>
    44. 

  44. #include "charview_private.h"
    45. 

  45. #include "gdraw/hotkeys.h"
    46. 

  46. 

  47. static void CVLCheckLayerCount(CharView *cv, int resize);
    48. 

  48. 

  49. extern void CVDebugFree(DebugView *dv);
    50. 

  50. 

  51. extern GBox _ggadget_Default_Box;
    52. 

  52. #define ACTIVE_BORDER   (_ggadget_Default_Box.active_border)
    53. 

  53. #define MAIN_FOREGROUND (_ggadget_Default_Box.main_foreground)
    54. 

  54. 

  55. extern GDevEventMask input_em[];
    56. 

  56. extern const int input_em_cnt;
    57. 

  57. 

  58. int cvvisible[2] = { 1, 1}, bvvisible[3]= { 1,1,1 };
    59. 

  59. static GWindow cvlayers, cvtools, bvlayers, bvtools, bvshades;
    60. 

  60. static GWindow cvlayers2=NULL;
    61. 

  61. 

  62. #define LSHOW_CUBIC   1
    63. 

  63. #define LSHOW_FG      2
    64. 

  64. #define LSHOW_PREVIEW 4
    65. 

  65. static int layerscols = LSHOW_CUBIC|LSHOW_FG|LSHOW_PREVIEW; /* which columns to show in layers1 palette */
    66. 

  66. static int layer_height = 0;        /* height of each layer row in layers1 palette */
    67. 

  67. static int layer_header_height = 0; /* height of initial stuff in layers1 palette  */
    68. 

  68. static int layer_footer_height = 0; /* height of +/- buttons at bottom of layers1 palette */
    69. 

  69. static int layers_max = 2; /* Maximum number of layers for which widgets have been allocated in layers1 palette */
    70. 

  70. struct l2 {
    71. 

  71.     int active;           /* index of the active layer */
    72. 

  72.     int offtop;           /* first layer to show at the top line in layers palette */
    73. 

  73.     int visible_layers;   /* number of layers apart from the guides layer to show before using a scrollbar      */
    74. 

  74.     int current_layers;   /* number of layers for the current character, and the number used in l2.layers       */
    75. 

  75.     int max_layers;       /* maximum number of layers for which layer controls and previews have been allocated */
    76. 

  76.     BDFChar **layers;     /* layer thumbnail previews              */
    77. 

  77.     int sb_start;         /* x pixel position of the scrollbar     */
    78. 

  78.     int column_width;     /* width of various indicator columns    */
    79. 

  79.     int mo_col, mo_layer; /* mouse over column and layer           */
    80. 

  80.     int rename_active;    /* If >=2, layer number for which the edit box for layer names is active */
    81. 

  81.     GClut *clut;
    82. 

  82.     GFont *font;          /* font to draw text in the palette with */
    83. 

  83. } layerinfo = {           /* info about the current layers in the layers palette */
    84. 

  84.     2, 0, 0, 0, 0, NULL, 0, 0, 0, 0, 0, NULL, NULL
    85. 

  85. };
    86. 

  86. 

  87. struct l2 layer2 = { 2, 0, 0, 0, 0, NULL, 0, 0, 0, 0, 0, NULL, NULL };
    88. 

  88. static int layers2_active = -1;
    89. 

  89. static GPoint cvtoolsoff = { -9999, -9999 }, cvlayersoff = { -9999, -9999 }, bvlayersoff = { -9999, -9999 }, bvtoolsoff = { -9999, -9999 }, bvshadesoff = { -9999, -9999 };
    90. 

  90. int palettes_fixed=1;
    91. 

  91. static GCursor tools[cvt_max+1] = { ct_pointer }, spirotools[cvt_max+1];
    92. 

  92. 

  93. enum cvtools cv_b1_tool = cvt_pointer, cv_cb1_tool = cvt_pointer,
    94. 

  94. 	     cv_b2_tool = cvt_magnify, cv_cb2_tool = cvt_ruler;
    95. 

  95. 

  96. static GFont *toolsfont=NULL, *layersfont=NULL;
    97. 

  97. 

  98. #define CV_TOOLS_WIDTH		53
    99. 

  99. #define CV_TOOLS_HEIGHT		(10*27+4*12+2)
    100. 

  100. #define CV_LAYERS_WIDTH		104
    101. 

  101. #define CV_LAYERS_HEIGHT	100
    102. 

  102. #define CV_LAYERS_INITIALCNT	6
    103. 

  103. #define CV_LAYERS_LINE_HEIGHT	25
    104. 

  104. #define CV_LAYERS2_WIDTH	120
    105. 

  105. #define CV_LAYERS2_HEIGHT	196
    106. 

  106. #define CV_LAYERS2_LINE_HEIGHT	25
    107. 

  107. #define CV_LAYERS2_HEADER_HEIGHT	20
    108. 

  108. #define CV_LAYERS2_VISLAYERS	( (CV_LAYERS2_HEIGHT-CV_LAYERS2_HEADER_HEIGHT-2*CV_LAYERS2_LINE_HEIGHT)/CV_LAYERS2_LINE_HEIGHT )
    109. 

  109. #define BV_TOOLS_WIDTH		53
    110. 

  110. #define BV_TOOLS_HEIGHT		80
    111. 

  111. #define BV_LAYERS_HEIGHT	73
    112. 

  112. #define BV_LAYERS_WIDTH		73
    113. 

  113. #define BV_SHADES_HEIGHT	(8+9*16)
    114. 

  114. 

  115. /* These are control ids for the layers palette controls */
    116. 

  116. #define CID_VBase	1000
    117. 

  117. #define CID_VGrid	(CID_VBase+ly_grid)
    118. 

  118. #define CID_VBack	(CID_VBase+ly_back)
    119. 

  119. #define CID_VFore	(CID_VBase+ly_fore)
    120. 

  120. 

  121. #define CID_EBase	3000
    122. 

  122. #define CID_EGrid	(CID_EBase+ly_grid)
    123. 

  123. #define CID_EBack	(CID_EBase+ly_back)
    124. 

  124. #define CID_EFore	(CID_EBase+ly_fore)
    125. 

  125. 

  126. #define CID_QBase	5000
    127. 

  127. #define CID_QGrid	(CID_QBase+ly_grid)
    128. 

  128. #define CID_QBack	(CID_QBase+ly_back)
    129. 

  129. #define CID_QFore	(CID_QBase+ly_fore)
    130. 

  130. 

  131. #define CID_FBase	7000
    132. 

  132. 

  133. #define CID_SB		8000
    134. 

  134. #define CID_Edit	8001
    135. 

  135. 

  136. #define CID_AddLayer    9000
    137. 

  137. #define CID_RemoveLayer 9001
    138. 

  138. #define CID_RenameLayer 9002
    139. 

  139. #define CID_LayersMenu  9003
    140. 

  140. 

  141. static void ReparentFixup(GWindow child,GWindow parent, int x, int y, int width, int height ) {
    142. 

  142.     /* This is so nice */
    143. 

  143.     /* KDE does not honor my request for a border for top level windows */
    144. 

  144.     /* KDE does not honor my request for size (for narrow) top level windows */
    145. 

  145.     /* Gnome gets very confused by reparenting */
    146. 

  146. 	/* If we've got a top level window, then reparenting it removes gnome's */
    147. 

  147. 	/* decoration window, but sets the new parent to root (rather than what */
    148. 

  148. 	/* we asked for */
    149. 

  149. 	/* I have tried reparenting it twice, unmapping & reparenting. Nothing works */
    150. 

  150. 

  151.     GWidgetReparentWindow(child,parent,x,y);
    152. 

  152.     if ( width!=0 )
    153. 

  153. 	GDrawResize(child,width,height);
    154. 

  154.     GDrawSetWindowBorder(child,1,GDrawGetDefaultForeground(NULL));
    155. 

  155. }
    156. 

  156. 

  157. void onCollabSessionStateChanged( GObject* gobj, FontViewBase* fv )
    158. 

  158. {
    159. 

  159.     bool inCollab = collabclient_inSessionFV( fv );
    160. 

  160. 

  161.     if (cvlayers != NULL) {
    162. 

  162.       GGadgetSetEnabled(GWidgetGetControl(cvlayers,CID_AddLayer),    !inCollab );
    163. 

  163.       GGadgetSetEnabled(GWidgetGetControl(cvlayers,CID_RemoveLayer), !inCollab );
    164. 

  164.       GGadgetSetEnabled(GWidgetGetControl(cvlayers,CID_RenameLayer), !inCollab );
    165. 

  165.     } else if (cvlayers2 != NULL && 0) {
    166. 

  166.       // These controls seem not to exist in cvlayers2. We can look deeper into this later.
    167. 

  167.       GGadgetSetEnabled(GWidgetGetControl(cvlayers2,CID_AddLayer),    !inCollab );
    168. 

  168.       GGadgetSetEnabled(GWidgetGetControl(cvlayers2,CID_RemoveLayer), !inCollab );
    169. 

  169.       GGadgetSetEnabled(GWidgetGetControl(cvlayers2,CID_RenameLayer), !inCollab );
    170. 

  170.     }
    171. 

  171. }
    172. 

  172. 

  173. /* Initialize a window that is to be used for a palette. Specific widgets and other functionality are added elsewhere. */
    174. 

  174. static GWindow CreatePalette(GWindow w, GRect *pos, int (*eh)(GWindow,GEvent *), void *user_data, GWindowAttrs *wattrs, GWindow v) {
    175. 

  175.     GWindow gw;
    176. 

  176.     GPoint pt, base;
    177. 

  177.     GRect newpos;
    178. 

  178.     GWindow root;
    179. 

  179.     GRect ownerpos, screensize;
    180. 

  180. 

  181.     pt.x = pos->x; pt.y = pos->y;
    182. 

  182.     if ( !palettes_fixed ) {
    183. 

  183. 	root = GDrawGetRoot(NULL);
    184. 

  184. 	GDrawGetSize(w,&ownerpos);
    185. 

  185. 	GDrawGetSize(root,&screensize);
    186. 

  186. 	GDrawTranslateCoordinates(w,root,&pt);
    187. 

  187. 	base.x = base.y = 0;
    188. 

  188. 	GDrawTranslateCoordinates(w,root,&base);
    189. 

  189. 	if ( pt.x<0 ) {
    190. 

  190. 	    if ( base.x+ownerpos.width+20+pos->width+20 > screensize.width )
    191. 

  191. 		pt.x=0;
    192. 

  192. 	    else
    193. 

  193. 		pt.x = base.x+ownerpos.width+20;
    194. 

  194. 	}
    195. 

  195. 	if ( pt.y<0 ) pt.y=0;
    196. 

  196. 	if ( pt.x+pos->width>screensize.width )
    197. 

  197. 	    pt.x = screensize.width-pos->width;
    198. 

  198. 	if ( pt.y+pos->height>screensize.height )
    199. 

  199. 	    pt.y = screensize.height-pos->height;
    200. 

  200.     }
    201. 

  201.     wattrs->mask |= wam_bordcol|wam_bordwidth;
    202. 

  202.     wattrs->border_width = 1;
    203. 

  203.     wattrs->border_color = GDrawGetDefaultForeground(NULL);
    204. 

  204. 

  205.     newpos.x = pt.x; newpos.y = pt.y; newpos.width = pos->width; newpos.height = pos->height;
    206. 

  206.     wattrs->mask|= wam_positioned;
    207. 

  207.     wattrs->positioned = true;
    208. 

  208.     gw = GDrawCreateTopWindow(NULL,&newpos,eh,user_data,wattrs);
    209. 

  209.     if ( palettes_docked )
    210. 

  210. 	ReparentFixup(gw,v,0,pos->y,pos->width,pos->height);
    211. 

  211. 

  212.     collabclient_addSessionJoiningCallback( onCollabSessionStateChanged );
    213. 

  213.     collabclient_addSessionLeavingCallback( onCollabSessionStateChanged );
    214. 

  214.     
    215. 

  215. return( gw );
    216. 

  216. }
    217. 

  217. 

  218. 

  219. 

  220. /* Return screen coordinates of the palette in off, relative to the root window origin. */
    221. 

  221. static void SaveOffsets(GWindow main, GWindow palette, GPoint *off) {
    222. 

  222.     if ( !palettes_docked && !palettes_fixed && GDrawIsVisible(palette)) {
    223. 

  223. 	GRect mr, pr;
    224. 

  224. 	GWindow root, temp;
    225. 

  225. 	root = GDrawGetRoot(NULL);
    226. 

  226. 	while ( (temp=GDrawGetParentWindow(main))!=root )
    227. 

  227. 	    main = temp;
    228. 

  228. 	GDrawGetSize(main,&mr);
    229. 

  229. 	GDrawGetSize(palette,&pr);
    230. 

  230. 	off->x = pr.x-mr.x;
    231. 

  231. 	off->y = pr.y-mr.y;
    232. 

  232. 	if ( off->x<0 ) off->x = 0;
    233. 

  233. 	if ( off->y<0 ) off->y = 0;
    234. 

  234.     }
    235. 

  235. }
    236. 

  236. 

  237. /* Set the palette window position to off, a point in the root window space. */
    238. 

  238. static void RestoreOffsets(GWindow main, GWindow palette, GPoint *off) {
    239. 

  239.     GPoint pt;
    240. 

  240.     GWindow root,temp;
    241. 

  241.     GRect screensize, pos;
    242. 

  242. 

  243.     if ( palettes_fixed )
    244. 

  244. return;
    245. 

  245.     pt = *off;
    246. 

  246.     root = GDrawGetRoot(NULL);
    247. 

  247.     GDrawGetSize(root,&screensize);
    248. 

  248.     GDrawGetSize(palette,&pos);
    249. 

  249.     while ( (temp=GDrawGetParentWindow(main))!=root )
    250. 

  250. 	main = temp;
    251. 

  251.     GDrawTranslateCoordinates(main,root,&pt);
    252. 

  252.     if ( pt.x<0 ) pt.x=0;
    253. 

  253.     if ( pt.y<0 ) pt.y=0;
    254. 

  254.     if ( pt.x+pos.width>screensize.width )
    255. 

  255. 	pt.x = screensize.width-pos.width;
    256. 

  256.     if ( pt.y+pos.height>screensize.height )
    257. 

  257. 	pt.y = screensize.height-pos.height;
    258. 

  258.     GDrawTrueMove(palette,pt.x,pt.y);
    259. 

  259.     GDrawRaise(palette);
    260. 

  260. }
    261. 

  261. 

  262. static void CVMenuTool(GWindow gw,struct gmenuitem *mi,GEvent *e) {
    263. 

  263.     CharView *cv = (CharView *) GDrawGetUserData(gw);
    264. 

  264.     cv->b1_tool = mi->mid;
    265. 

  265.     if ( cvtools!=NULL )
    266. 

  266. 	GDrawRequestExpose(cvtools,NULL,false);
    267. 

  267.     CVToolsSetCursor(cv,0,NULL);
    268. 

  268. }
    269. 

  269. 

  270. static void CVChangeSpiroMode(CharView *cv);
    271. 

  271. static void CVMenuSpiroSet(GWindow gw,struct gmenuitem *mi,GEvent *e) {
    272. 

  272.     CharView *cv = (CharView *) GDrawGetUserData(gw);
    273. 

  273.     CVChangeSpiroMode(cv);
    274. 

  274. }
    275. 

  275. 

  276. void cvtoollist_check(GWindow gw,struct gmenuitem *mi,GEvent *e) {
    277. 

  277.     CharView *cv = (CharView *) GDrawGetUserData(gw);
    278. 

  278.     int order2 = cv->b.layerheads[cv->b.drawmode]->order2;
    279. 

  279. 

  280.     for ( mi = mi->sub; mi->ti.text!=NULL || mi->ti.line ; ++mi ) {
    281. 

  281. 	mi->ti.checked = mi->mid==cv->b1_tool;
    282. 

  282. 	switch ( mi->mid ) {
    283. 

  283. 	  case cvt_freehand:
    284. 

  284. 	    mi->ti.disabled = order2;
    285. 

  285. 	  break;
    286. 

  286. 	  case cvt_spiro:
    287. 

  287. 	    mi->ti.disabled = !hasspiro();
    288. 

  288. 	  break;
    289. 

  289.         }
    290. 

  290.     }
    291. 

  291. }
    292. 

  292. 

  293. /* Note: If you change this ordering, change enum cvtools */
    294. 

  294. static char *popupsres[] = {
    295. 

  295.     N_("Pointer"),               N_("Magnify (Minify with alt)"),
    296. 

  296.     N_("Draw a freehand curve"), N_("Scroll by hand"),
    297. 

  297.     N_("Cut splines in two"),    N_("Measure distance, angle between points"),
    298. 

  298.     N_("Add a point, then drag out its control points"), N_("Change whether spiro is active or not"),
    299. 

  299.     N_("Add a curve point"),     N_("Add a curve point always either horizontal or vertical"),
    300. 

  300.     N_("Add a corner point"),    N_("Add a tangent point"),
    301. 

  301.     N_("Scale the selection"),   N_("Rotate the selection"),
    302. 

  302.     N_("Flip the selection"),  N_("Skew the selection"),
    303. 

  303.     N_("Rotate the selection in 3D and project back to plain"), N_("Perform a perspective transformation on the selection"),
    304. 

  304.     N_("Rectangle or Ellipse"),  N_("Polygon or Star"),
    305. 

  305.     N_("Rectangle or Ellipse"),  N_("Polygon or Star")};
    306. 

  306. GMenuItem2 cvtoollist[] = {
    307. 

  307.     { { (unichar_t *) N_("_Pointer"), (GImage *) "toolspointer.png", COLOR_DEFAULT, COLOR_DEFAULT, NULL, NULL, 0, 1, 1, 0, 0, 0, 1, 1, 0, 'C' }, H_("Pointer|No Shortcut"), NULL, NULL, CVMenuTool, cvt_pointer },
    308. 

  308.     { { (unichar_t *) N_("_Magnify"), (GImage *) "toolsmagnify.png", COLOR_DEFAULT, COLOR_DEFAULT, NULL, NULL, 0, 1, 1, 0, 0, 0, 1, 1, 0, 'C' }, H_("Magnify|No Shortcut"), NULL, NULL, CVMenuTool, cvt_magnify },
    309. 

  309.     { { (unichar_t *) N_("_Freehand"), (GImage *) "toolsfreehand.png", COLOR_DEFAULT, COLOR_DEFAULT, NULL, NULL, 0, 1, 1, 0, 0, 0, 1, 1, 0, 'C' }, H_("Freehand|No Shortcut"), NULL, NULL, CVMenuTool, cvt_freehand },
    310. 

  310.     { { (unichar_t *) N_("_Scroll"), (GImage *) "toolsscroll.png", COLOR_DEFAULT, COLOR_DEFAULT, NULL, NULL, 0, 1, 1, 0, 0, 0, 1, 1, 0, 'C' }, H_("Scroll|No Shortcut"), NULL, NULL, CVMenuTool, cvt_hand },
    311. 

  311.     { { (unichar_t *) N_("_Knife"), (GImage *) "toolsknife.png", COLOR_DEFAULT, COLOR_DEFAULT, NULL, NULL, 0, 1, 1, 0, 0, 0, 1, 1, 0, 'T' }, H_("Knife|No Shortcut"), NULL, NULL, CVMenuTool, cvt_knife },
    312. 

  312.     { { (unichar_t *) N_("_Ruler"), (GImage *) "toolsruler.png", COLOR_DEFAULT, COLOR_DEFAULT, NULL, NULL, 0, 1, 1, 0, 0, 0, 1, 1, 0, 'T' }, H_("Ruler|No Shortcut"), NULL, NULL, CVMenuTool, cvt_ruler },
    313. 

  313.     { { NULL, NULL, COLOR_DEFAULT, COLOR_DEFAULT, NULL, NULL, 0, 1, 0, 0, 0, 1, 0, 0, 0, '\0' }, NULL, NULL, NULL, NULL, 0 }, /* line */
    314. 

  314.     { { (unichar_t *) N_("P_en"), (GImage *) "toolspen.png", COLOR_DEFAULT, COLOR_DEFAULT, NULL, NULL, 0, 1, 1, 0, 0, 0, 1, 1, 0, 'T' }, H_("Pen|No Shortcut"), NULL, NULL, CVMenuTool, cvt_pen },
    315. 

  315.     { { (unichar_t *) N_("_Activate Spiro"), (GImage *) "toolsspiro.png", COLOR_DEFAULT, COLOR_DEFAULT, NULL, NULL, 0, 1, 1, 0, 0, 0, 1, 1, 0, 'T' }, H_("Activate Spiro|No Shortcut"), NULL, NULL, CVMenuSpiroSet, cvt_spiro },
    316. 

  316.     { { (unichar_t *) N_("_Curve"), (GImage *) "pointscurve.png", COLOR_DEFAULT, COLOR_DEFAULT, NULL, NULL, 0, 1, 1, 0, 0, 0, 1, 1, 0, 'C' }, H_("Curve Tool|No Shortcut"), NULL, NULL, CVMenuTool, cvt_curve },
    317. 

  317.     { { (unichar_t *) N_("_HVCurve"), (GImage *) "pointshvcurve.png", COLOR_DEFAULT, COLOR_DEFAULT, NULL, NULL, 0, 1, 1, 0, 0, 0, 1, 1, 0, 'o' }, H_("HVCurve Tool|No Shortcut"), NULL, NULL, CVMenuTool, cvt_hvcurve },
    318. 

  318.     { { (unichar_t *) N_("C_orner"), (GImage *) "pointscorner.png", COLOR_DEFAULT, COLOR_DEFAULT, NULL, NULL, 0, 1, 1, 0, 0, 0, 1, 1, 0, 'o' }, H_("Corner Tool|No Shortcut"), NULL, NULL, CVMenuTool, cvt_corner },
    319. 

  319.     { { (unichar_t *) N_("_Tangent"), (GImage *) "pointstangent.png", COLOR_DEFAULT, COLOR_DEFAULT, NULL, NULL, 0, 1, 1, 0, 0, 0, 1, 1, 0, 'T' }, H_("Tangent Tool|No Shortcut"), NULL, NULL, CVMenuTool, cvt_tangent },
    320. 

  320.     { { NULL, NULL, COLOR_DEFAULT, COLOR_DEFAULT, NULL, NULL, 0, 1, 0, 0, 0, 1, 0, 0, 0, '\0' }, NULL, NULL, NULL, NULL, 0 }, /* line */
    321. 

  321.     { { (unichar_t *) N_("Sca_le"), (GImage *) "toolsscale.png", COLOR_DEFAULT, COLOR_DEFAULT, NULL, NULL, 0, 1, 1, 0, 0, 0, 1, 1, 0, 'T' }, H_("Scale|No Shortcut"), NULL, NULL, CVMenuTool, cvt_scale },
    322. 

  322.     { { (unichar_t *) N_("Rotate"), (GImage *) "toolsrotate.png", COLOR_DEFAULT, COLOR_DEFAULT, NULL, NULL, 0, 1, 1, 0, 0, 0, 1, 1, 0, 'T' }, H_("Rotate|No Shortcut"), NULL, NULL, CVMenuTool, cvt_rotate },
    323. 

  323.     { { (unichar_t *) N_("Flip"), (GImage *) "toolsflip.png", COLOR_DEFAULT, COLOR_DEFAULT, NULL, NULL, 0, 1, 1, 0, 0, 0, 1, 1, 0, 'T' }, H_("Flip|No Shortcut"), NULL, NULL, CVMenuTool, cvt_flip },
    324. 

  324.     { { (unichar_t *) N_("Ske_w"), (GImage *) "toolsskew.png", COLOR_DEFAULT, COLOR_DEFAULT, NULL, NULL, 0, 1, 1, 0, 0, 0, 1, 1, 0, 'T' }, H_("Skew|No Shortcut"), NULL, NULL, CVMenuTool, cvt_skew },
    325. 

  325.     { { (unichar_t *) N_("_3D Rotate"), (GImage *) "tools3drotate.png", COLOR_DEFAULT, COLOR_DEFAULT, NULL, NULL, 0, 1, 1, 0, 0, 0, 1, 1, 0, 'T' }, H_("3D Rotate|No Shortcut"), NULL, NULL, CVMenuTool, cvt_3d_rotate },
    326. 

  326.     { { (unichar_t *) N_("Perspecti_ve"), (GImage *) "toolsperspective.png", COLOR_DEFAULT, COLOR_DEFAULT, NULL, NULL, 0, 1, 1, 0, 0, 0, 1, 1, 0, 'T' }, H_("Perspective|No Shortcut"), NULL, NULL, CVMenuTool, cvt_perspective },
    327. 

  327.     { { NULL, NULL, COLOR_DEFAULT, COLOR_DEFAULT, NULL, NULL, 0, 1, 0, 0, 0, 1, 0, 0, 0, '\0' }, NULL, NULL, NULL, NULL, 0 }, /* line */
    328. 

  328.     { { (unichar_t *) N_("Rectan_gle"), (GImage *) "toolsrect.png", COLOR_DEFAULT, COLOR_DEFAULT, NULL, NULL, 0, 1, 1, 0, 0, 0, 1, 1, 0, 'T' }, H_("Rectangle|No Shortcut"), NULL, NULL, CVMenuTool, cvt_rect },
    329. 

  329.     { { (unichar_t *) N_("Pol_ygon"), (GImage *) "toolspolygon.png", COLOR_DEFAULT, COLOR_DEFAULT, NULL, NULL, 0, 1, 1, 0, 0, 0, 1, 1, 0, 'T' }, H_("Polygon|No Shortcut"), NULL, NULL, CVMenuTool, cvt_poly },
    330. 

  330.     { { (unichar_t *) N_("Ellipse"), (GImage *) "toolselipse.png", COLOR_DEFAULT, COLOR_DEFAULT, NULL, NULL, 0, 1, 1, 0, 0, 0, 1, 1, 0, 'T' }, H_("Ellipse|No Shortcut"), NULL, NULL, CVMenuTool, cvt_elipse },
    331. 

  331.     { { (unichar_t *) N_("Star"), (GImage *) "toolsstar.png", COLOR_DEFAULT, COLOR_DEFAULT, NULL, NULL, 0, 1, 1, 0, 0, 0, 1, 1, 0, 'T' }, H_("Star|No Shortcut"), NULL, NULL, CVMenuTool, cvt_star },
    332. 

  332.     GMENUITEM2_EMPTY
    333. 

  333. };
    334. 

  334. GMenuItem2 cvspirotoollist[] = {
    335. 

  335.     { { (unichar_t *) N_("_Pointer"), (GImage *) "toolspointer.png", COLOR_DEFAULT, COLOR_DEFAULT, NULL, NULL, 0, 1, 1, 0, 0, 0, 1, 1, 0, 'C' }, H_("Pointer|No Shortcut"), NULL, NULL, CVMenuTool, cvt_pointer },
    336. 

  336.     { { (unichar_t *) N_("_Magnify"), (GImage *) "toolsmagnify.png", COLOR_DEFAULT, COLOR_DEFAULT, NULL, NULL, 0, 1, 1, 0, 0, 0, 1, 1, 0, 'C' }, H_("Magnify|No Shortcut"), NULL, NULL, CVMenuTool, cvt_magnify },
    337. 

  337.     { { (unichar_t *) N_("_Freehand"), (GImage *) "toolsfreehand.png", COLOR_DEFAULT, COLOR_DEFAULT, NULL, NULL, 0, 1, 1, 0, 0, 0, 1, 1, 0, 'C' }, H_("Freehand|No Shortcut"), NULL, NULL, CVMenuTool, cvt_freehand },
    338. 

  338.     { { (unichar_t *) N_("_Scroll"), (GImage *) "toolsscroll.png", COLOR_DEFAULT, COLOR_DEFAULT, NULL, NULL, 0, 1, 1, 0, 0, 0, 1, 1, 0, 'C' }, H_("Scroll|No Shortcut"), NULL, NULL, CVMenuTool, cvt_hand },
    339. 

  339.     { { (unichar_t *) N_("_Knife"), (GImage *) "toolsknife.png", COLOR_DEFAULT, COLOR_DEFAULT, NULL, NULL, 0, 1, 1, 0, 0, 0, 1, 1, 0, 'T' }, H_("Knife|No Shortcut"), NULL, NULL, CVMenuTool, cvt_knife },
    340. 

  340.     { { (unichar_t *) N_("_Ruler"), (GImage *) "toolsruler.png", COLOR_DEFAULT, COLOR_DEFAULT, NULL, NULL, 0, 1, 1, 0, 0, 0, 1, 1, 0, 'T' }, H_("Ruler|No Shortcut"), NULL, NULL, CVMenuTool, cvt_ruler },
    341. 

  341.     { { NULL, NULL, COLOR_DEFAULT, COLOR_DEFAULT, NULL, NULL, 0, 1, 0, 0, 0, 1, 0, 0, 0, '\0' }, NULL, NULL, NULL, NULL, 0 }, /* line */
    342. 

  342.     { { (unichar_t *) N_("_Knife"), (GImage *) "toolsknife.png", COLOR_DEFAULT, COLOR_DEFAULT, NULL, NULL, 0, 1, 1, 0, 0, 0, 1, 1, 0, 'T' }, H_("Knife|No Shortcut"), NULL, NULL, CVMenuTool, cvt_knife },
    343. 

  343.     { { (unichar_t *) N_("_Ruler"), (GImage *) "toolsruler.png", COLOR_DEFAULT, COLOR_DEFAULT, NULL, NULL, 0, 1, 1, 0, 0, 0, 1, 1, 0, 'T' }, H_("Ruler|No Shortcut"), NULL, NULL, CVMenuTool, cvt_ruler },
    344. 

  344.     { { NULL, NULL, COLOR_DEFAULT, COLOR_DEFAULT, NULL, NULL, 0, 1, 0, 0, 0, 1, 0, 0, 0, '\0' }, NULL, NULL, NULL, NULL, 0 }, /* line */
    345. 

  345.     { { (unichar_t *) N_("De_activate Spiro"), (GImage *) "toolsspiro.png", COLOR_DEFAULT, COLOR_DEFAULT, NULL, NULL, 0, 1, 1, 0, 0, 0, 1, 1, 0, 'T' }, H_("Activate Spiro|No Shortcut"), NULL, NULL, CVMenuSpiroSet, cvt_spiro },
    346. 

  346.     { { (unichar_t *) N_("C_orner"), (GImage *) "pointscorner.png", COLOR_DEFAULT, COLOR_DEFAULT, NULL, NULL, 0, 1, 1, 0, 0, 0, 1, 1, 0, 'o' }, H_("Corner Tool|No Shortcut"), NULL, NULL, CVMenuTool, cvt_spirocorner },
    347. 

  347.     { { NULL, NULL, COLOR_DEFAULT, COLOR_DEFAULT, NULL, NULL, 0, 1, 0, 0, 0, 1, 0, 0, 0, '\0' }, NULL, NULL, NULL, NULL, 0 }, /* line */
    348. 

  348.     { { (unichar_t *) N_("G_4"), (GImage *) "pointscurve.png", COLOR_DEFAULT, COLOR_DEFAULT, NULL, NULL, 0, 1, 1, 0, 0, 0, 1, 1, 0, 'C' }, H_("G4 Tool|No Shortcut"), NULL, NULL, CVMenuTool, cvt_spirog4 },
    349. 

  349.     { { (unichar_t *) N_("G_2"), (GImage *) "pointsG2curve.png", COLOR_DEFAULT, COLOR_DEFAULT, NULL, NULL, 0, 1, 1, 0, 0, 0, 1, 1, 0, 'o' }, H_("G2 Tool|No Shortcut"), NULL, NULL, CVMenuTool, cvt_spirog2 },
    350. 

  350.     { { (unichar_t *) N_("Lef_t"), (GImage *) "pointsspiroprev.png", COLOR_DEFAULT, COLOR_DEFAULT, NULL, NULL, 0, 1, 1, 0, 0, 0, 1, 1, 0, 'T' }, H_("Left Tool|No Shortcut"), NULL, NULL, CVMenuTool, cvt_spiroleft },
    351. 

  351.     { { (unichar_t *) N_("Rig_ht"), (GImage *) "pointsspironext.png", COLOR_DEFAULT, COLOR_DEFAULT, NULL, NULL, 0, 1, 1, 0, 0, 0, 1, 1, 0, 'T' }, H_("Right Tool|No Shortcut"), NULL, NULL, CVMenuTool, cvt_spiroright },
    352. 

  352.     { { NULL, NULL, COLOR_DEFAULT, COLOR_DEFAULT, NULL, NULL, 0, 1, 0, 0, 0, 1, 0, 0, 0, '\0' }, NULL, NULL, NULL, NULL, 0 }, /* line */
    353. 

  353.     { { (unichar_t *) N_("Sca_le"), (GImage *) "toolsscale.png", COLOR_DEFAULT, COLOR_DEFAULT, NULL, NULL, 0, 1, 1, 0, 0, 0, 1, 1, 0, 'T' }, H_("Scale|No Shortcut"), NULL, NULL, CVMenuTool, cvt_scale },
    354. 

  354.     { { (unichar_t *) N_("Rotate"), (GImage *) "toolsrotate.png", COLOR_DEFAULT, COLOR_DEFAULT, NULL, NULL, 0, 1, 1, 0, 0, 0, 1, 1, 0, 'T' }, H_("Rotate|No Shortcut"), NULL, NULL, CVMenuTool, cvt_rotate },
    355. 

  355.     { { (unichar_t *) N_("Flip"), (GImage *) "toolsflip.png", COLOR_DEFAULT, COLOR_DEFAULT, NULL, NULL, 0, 1, 1, 0, 0, 0, 1, 1, 0, 'T' }, H_("Flip|No Shortcut"), NULL, NULL, CVMenuTool, cvt_flip },
    356. 

  356.     { { (unichar_t *) N_("Ske_w"), (GImage *) "toolsskew.png", COLOR_DEFAULT, COLOR_DEFAULT, NULL, NULL, 0, 1, 1, 0, 0, 0, 1, 1, 0, 'T' }, H_("Skew|No Shortcut"), NULL, NULL, CVMenuTool, cvt_skew },
    357. 

  357.     { { (unichar_t *) N_("_3D Rotate"), (GImage *) "tools3drotate.png", COLOR_DEFAULT, COLOR_DEFAULT, NULL, NULL, 0, 1, 1, 0, 0, 0, 1, 1, 0, 'T' }, H_("3D Rotate|No Shortcut"), NULL, NULL, CVMenuTool, cvt_3d_rotate },
    358. 

  358.     { { (unichar_t *) N_("Perspecti_ve"), (GImage *) "toolsperspective.png", COLOR_DEFAULT, COLOR_DEFAULT, NULL, NULL, 0, 1, 1, 0, 0, 0, 1, 1, 0, 'T' }, H_("Perspective|No Shortcut"), NULL, NULL, CVMenuTool, cvt_perspective },
    359. 

  359.     { { NULL, NULL, COLOR_DEFAULT, COLOR_DEFAULT, NULL, NULL, 0, 1, 0, 0, 0, 1, 0, 0, 0, '\0' }, NULL, NULL, NULL, NULL, 0 }, /* line */
    360. 

  360.     { { (unichar_t *) N_("Rectan_gle"), (GImage *) "toolsrect.png", COLOR_DEFAULT, COLOR_DEFAULT, NULL, NULL, 0, 1, 1, 0, 0, 0, 1, 1, 0, 'T' }, H_("Rectangle|No Shortcut"), NULL, NULL, CVMenuTool, cvt_rect },
    361. 

  361.     { { (unichar_t *) N_("Pol_ygon"), (GImage *) "toolspolygon.png", COLOR_DEFAULT, COLOR_DEFAULT, NULL, NULL, 0, 1, 1, 0, 0, 0, 1, 1, 0, 'T' }, H_("Polygon|No Shortcut"), NULL, NULL, CVMenuTool, cvt_poly },
    362. 

  362.     { { (unichar_t *) N_("Ellipse"), (GImage *) "toolselipse.png", COLOR_DEFAULT, COLOR_DEFAULT, NULL, NULL, 0, 1, 1, 0, 0, 0, 1, 1, 0, 'T' }, H_("Ellipse|No Shortcut"), NULL, NULL, CVMenuTool, cvt_elipse },
    363. 

  363.     { { (unichar_t *) N_("Star"), (GImage *) "toolsstar.png", COLOR_DEFAULT, COLOR_DEFAULT, NULL, NULL, 0, 1, 1, 0, 0, 0, 1, 1, 0, 'T' }, H_("Star|No Shortcut"), NULL, NULL, CVMenuTool, cvt_star },
    364. 

  364.     GMENUITEM2_EMPTY
    365. 

  365. };
    366. 

  366. 

  367. static char *editablelayers[] = {
    368. 

  368. /* GT: Foreground, make it short */
    369. 

  369.     N_("F_ore"),
    370. 

  370. /* GT: Background, make it short */
    371. 

  371.     N_("_Back"),
    372. 

  372. /* GT: Guide layer, make it short */
    373. 

  373.     N_("_Guide")
    374. 

  374. };
    375. 

  375. static real raddiam_x = 20, raddiam_y = 20, rotate_by=0;
    376. 

  376. static StrokeInfo expand = {
    377. 

  377.     25, lj_round, lc_butt, si_centerline,
    378. 

  378.     false, /* removeexternal */
    379. 

  379.     false, /* removeinternal */
    380. 

  380.     false, /* leave users */
    381. 

  381.     3.1415926535897932/4, 25, NULL, 50,
    382. 

  382.     0.0, 0, 0, NULL, NULL
    383. 

  383. };
    384. 

  384. 

  385. real CVRoundRectRadius(void) {
    386. 

  386. return( rr_radius );
    387. 

  387. }
    388. 

  388. 

  389. int CVRectElipseCenter(void) {
    390. 

  390. return( center_out[rectelipse] );
    391. 

  391. }
    392. 

  392. 

  393. int CVPolyStarPoints(void) {
    394. 

  394. return( ps_pointcnt );
    395. 

  395. }
    396. 

  396. 

  397. real CVStarRatio(void) {
    398. 

  398.     if ( regular_star )
    399. 

  399. return( sin(3.1415926535897932/ps_pointcnt)*tan(2*3.1415926535897932/ps_pointcnt)+cos(3.1415926535897932/ps_pointcnt) );
    400. 

  400. 	
    401. 

  401. return( star_percent );
    402. 

  402. }
    403. 

  403. 

  404. StrokeInfo *CVFreeHandInfo(void) {
    405. 

  405. return( &expand );
    406. 

  406. }
    407. 

  407.     
    408. 

  408. struct ask_info {
    409. 

  409.     GWindow gw;
    410. 

  410.     int done;
    411. 

  411.     int ret;
    412. 

  412.     float *val;
    413. 

  413.     int *co;
    414. 

  414.     GGadget *rb1;
    415. 

  415.     GGadget *reg;
    416. 

  416.     GGadget *pts;
    417. 

  417.     int ispolystar;
    418. 

  418.     int haspos;
    419. 

  419.     char *lab;
    420. 

  420.     CharView *cv;
    421. 

  421. };
    422. 

  422. #define CID_ValText		1001
    423. 

  423. #define CID_PointPercent	1002
    424. 

  424. #define CID_CentCornLab		1003
    425. 

  425. #define CID_CentCornX		1004
    426. 

  426. #define CID_CentCornY		1005
    427. 

  427. #define CID_RadDiamLab		1006
    428. 

  428. #define CID_RadDiamX		1007
    429. 

  429. #define CID_RadDiamY		1008
    430. 

  430. #define CID_Angle		1009
    431. 

  431. 

  432. static void FakeShapeEvents(CharView *cv) {
    433. 

  433.     GEvent event;
    434. 

  434.     real trans[6];
    435. 

  435. 

  436.     cv->active_tool = rectelipse ? cvt_elipse : cvt_rect;
    437. 

  437.     if ( cv->b.sc->inspiro && hasspiro() ) {
    438. 

  438. 	GDrawSetCursor(cv->v,spirotools[cv->active_tool]);
    439. 

  439. 	GDrawSetCursor(cvtools,spirotools[cv->active_tool]);
    440. 

  440.     } else {
    441. 

  441. 	GDrawSetCursor(cv->v,tools[cv->active_tool]);
    442. 

  442. 	GDrawSetCursor(cvtools,tools[cv->active_tool]);
    443. 

  443.     }
    444. 

  444.     cv->showing_tool = cv->active_tool;
    445. 

  445. 

  446.     memset(&event,0,sizeof(event));
    447. 

  447.     event.type = et_mousedown;
    448. 

  448.     CVMouseDownShape(cv,&event);
    449. 

  449.     cv->info.x += raddiam_x;
    450. 

  450.     cv->info.y += raddiam_y;
    451. 

  451.     CVMouseMoveShape(cv);
    452. 

  452.     CVMouseUpShape(cv);
    453. 

  453.     if ( raddiam_x!=0 && raddiam_y!=0 && rotate_by!=0 ) {
    454. 

  454. 	trans[0] = trans[3] = cos ( rotate_by*3.1415926535897932/180. );
    455. 

  455. 	trans[1] = sin( rotate_by*3.1415926535897932/180. );
    456. 

  456. 	trans[2] = -trans[1];
    457. 

  457. 	trans[4] = -cv->p.x*trans[0] - cv->p.y*trans[2] + cv->p.x;
    458. 

  458. 	trans[5] = -cv->p.x*trans[1] - cv->p.y*trans[3] + cv->p.y;
    459. 

  459. 	SplinePointListTransform(cv->b.layerheads[cv->b.drawmode]->splines,trans,
    460. 

  460. 		interpCPsOnMotion?tpt_OnlySelectedInterpCPs:tpt_OnlySelected);
    461. 

  461. 	SCUpdateAll(cv->b.sc);
    462. 

  462.     }
    463. 

  463.     cv->active_tool = cvt_none;
    464. 

  464. }
    465. 

  465. 

  466. static int TA_OK(GGadget *g, GEvent *e) {
    467. 

  467.     if ( e->type==et_controlevent && e->u.control.subtype == et_buttonactivate ) {
    468. 

  468. 	struct ask_info *d = GDrawGetUserData(GGadgetGetWindow(g));
    469. 

  469. 	real val, val2=0;
    470. 

  470. 	int err=0;
    471. 

  471. 	int re = !GGadgetIsChecked(d->rb1);
    472. 

  472. 	if ( d->ispolystar ) {
    473. 

  473. 	    val = GetInt8(d->gw,CID_ValText,d->lab,&err);
    474. 

  474. 	    if ( !(regular_star = GGadgetIsChecked(d->reg)))
    475. 

  475. 		val2 = GetReal8(d->gw,CID_PointPercent,_("Size of Points"),&err);
    476. 

  476. 	} else {
    477. 

  477. 	    val = GetReal8(d->gw,CID_ValText,d->lab,&err);
    478. 

  478. 	    d->co[re] = !GGadgetIsChecked(d->reg);
    479. 

  479. 	}
    480. 

  480. 	if ( err )
    481. 

  481. return( true );
    482. 

  482. 	if ( d->haspos ) {
    483. 

  483. 	    real x,y, radx,rady, ang;
    484. 

  484. 	    x = GetInt8(d->gw,CID_CentCornX,_("_X"),&err);
    485. 

  485. 	    y = GetInt8(d->gw,CID_CentCornY,_("_Y"),&err);
    486. 

  486. 	    radx = GetInt8(d->gw,CID_RadDiamX,_("Radius:   "),&err);
    487. 

  487. 	    rady = GetInt8(d->gw,CID_RadDiamY,_("Radius:   "),&err);
    488. 

  488. 	    ang = GetInt8(d->gw,CID_Angle,_("Angle:"),&err);
    489. 

  489. 	    if ( err )
    490. 

  490. return( true );
    491. 

  491. 	    d->cv->p.x = d->cv->info.x = x;
    492. 

  492. 	    d->cv->p.y = d->cv->info.y = y;
    493. 

  493. 	    raddiam_x = radx; raddiam_y = rady;
    494. 

  494. 	    rotate_by = ang;
    495. 

  495. 	    rectelipse = re;
    496. 

  496. 	    *d->val = val;
    497. 

  497. 	    FakeShapeEvents(d->cv);
    498. 

  498. 	}
    499. 

  499. 	*d->val = val;
    500. 

  500. 	d->ret = re;
    501. 

  501. 	d->done = true;
    502. 

  502. 	if ( !regular_star && d->ispolystar )
    503. 

  503. 	    star_percent = val2/100;
    504. 

  504. 	SavePrefs(true);
    505. 

  505.     }
    506. 

  506. return( true );
    507. 

  507. }
    508. 

  508. 

  509. static int TA_Cancel(GGadget *g, GEvent *e) {
    510. 

  510.     if ( e->type==et_controlevent && e->u.control.subtype == et_buttonactivate ) {
    511. 

  511. 	struct ask_info *d = GDrawGetUserData(GGadgetGetWindow(g));
    512. 

  512. 	d->done = true;
    513. 

  513.     }
    514. 

  514. return( true );
    515. 

  515. }
    516. 

  516. 

  517. static int TA_CenRadChange(GGadget *g, GEvent *e) {
    518. 

  518.     if ( e->type==et_controlevent && e->u.control.subtype == et_radiochanged ) {
    519. 

  519. 	struct ask_info *d = GDrawGetUserData(GGadgetGetWindow(g));
    520. 

  520. 	int is_bb = GGadgetIsChecked(d->reg);
    521. 

  521. 	GGadgetSetTitle8(GWidgetGetControl(d->gw,CID_CentCornLab),
    522. 

  522. 		is_bb ? _("Corner") : _("C_enter"));
    523. 

  523. 	GGadgetSetTitle8(GWidgetGetControl(d->gw,CID_RadDiamLab),
    524. 

  524. 		is_bb ? _("Diameter:") : _("Radius:   "));
    525. 

  525.     }
    526. 

  526. return( true );
    527. 

  527. }
    528. 

  528. 

  529. static int TA_RadChange(GGadget *g, GEvent *e) {
    530. 

  530.     if ( e->type==et_controlevent && e->u.control.subtype == et_radiochanged ) {
    531. 

  531. 	struct ask_info *d = GDrawGetUserData(GGadgetGetWindow(g));
    532. 

  532. 	int is_ellipse = !GGadgetIsChecked(d->rb1);
    533. 

  533. 	GGadgetSetEnabled(GWidgetGetControl(d->gw,CID_ValText), !is_ellipse );
    534. 

  534. 	GGadgetSetChecked(d->reg,!center_out[is_ellipse]);
    535. 

  535. 	GGadgetSetChecked(d->pts,center_out[is_ellipse]);
    536. 

  536. 	if ( d->haspos )
    537. 

  537. 	    TA_CenRadChange(g,e);
    538. 

  538.     }
    539. 

  539. return( true );
    540. 

  540. }
    541. 

  541. 

  542. static int toolask_e_h(GWindow gw, GEvent *event) {
    543. 

  543.     if ( event->type==et_close ) {
    544. 

  544. 	struct ask_info *d = GDrawGetUserData(gw);
    545. 

  545. 	d->done = true;
    546. 

  546.     } else if ( event->type == et_map ) {
    547. 

  547. 	/* Above palettes */
    548. 

  548. 	GDrawRaise(gw);
    549. 

  549.     }
    550. 

  550. return( event->type!=et_char );
    551. 

  551. }
    552. 

  552. 

  553. static int Ask(char *rb1, char *rb2, int rb, char *lab, float *val, int *co,
    554. 

  554. 	int ispolystar, CharView *cv ) {
    555. 

  555.     struct ask_info d;
    556. 

  556.     char buffer[20], buf[20];
    557. 

  557.     char cenx[20], ceny[20], radx[20], rady[20], angle[20];
    558. 

  558.     GRect pos;
    559. 

  559.     GWindowAttrs wattrs;
    560. 

  560.     GGadgetCreateData gcd[19];
    561. 

  561.     GTextInfo label[19];
    562. 

  562.     int off = ((ispolystar&1)?15:0) + ((ispolystar&2)?84:0);
    563. 

  563.     int haspos = (ispolystar&2)?1:0;
    564. 

  564. 

  565.     ispolystar &= 1;
    566. 

  566. 

  567.     d.done = false;
    568. 

  568.     d.ret = rb;
    569. 

  569.     d.val = val;
    570. 

  570.     d.co = co;
    571. 

  571.     d.ispolystar = ispolystar;
    572. 

  572.     d.haspos = haspos;
    573. 

  573.     d.lab = lab;
    574. 

  574.     d.cv = cv;
    575. 

  575. 

  576. 	memset(&wattrs,0,sizeof(wattrs));
    577. 

  577. 	wattrs.mask = wam_events|wam_cursor|wam_utf8_wtitle|wam_undercursor|wam_isdlg|wam_restrict;
    578. 

  578. 	wattrs.event_masks = ~(1<<et_charup);
    579. 

  579. 	wattrs.restrict_input_to_me = 1;
    580. 

  580. 	wattrs.undercursor = 1;
    581. 

  581. 	wattrs.cursor = ct_pointer;
    582. 

  582. 	wattrs.utf8_window_title = _("Shape Type");
    583. 

  583. 	wattrs.is_dlg = true;
    584. 

  584. 	pos.x = pos.y = 0;
    585. 

  585. 	pos.width = GGadgetScale(GDrawPointsToPixels(NULL,190));
    586. 

  586. 	pos.height = GDrawPointsToPixels(NULL,120+off);
    587. 

  587. 	d.gw = GDrawCreateTopWindow(NULL,&pos,toolask_e_h,&d,&wattrs);
    588. 

  588. 

  589. 	memset(&label,0,sizeof(label));
    590. 

  590. 	memset(&gcd,0,sizeof(gcd));
    591. 

  591. 

  592. 	label[0].text = (unichar_t *) rb1;
    593. 

  593. 	label[0].text_is_1byte = true;
    594. 

  594. 	gcd[0].gd.label = &label[0];
    595. 

  595. 	gcd[0].gd.pos.x = 5; gcd[0].gd.pos.y = 5; 
    596. 

  596. 	gcd[0].gd.flags = gg_enabled|gg_visible | (rb==0?gg_cb_on:0);
    597. 

  597. 	gcd[0].creator = GRadioCreate;
    598. 

  598. 

  599. 	label[1].text = (unichar_t *) rb2;
    600. 

  600. 	label[1].text_is_1byte = true;
    601. 

  601. 	gcd[1].gd.label = &label[1];
    602. 

  602. 	gcd[1].gd.pos.x = ispolystar?65:75; gcd[1].gd.pos.y = 5; 
    603. 

  603. 	gcd[1].gd.flags = gg_enabled|gg_visible | (rb==1?gg_cb_on:0);
    604. 

  604. 	gcd[1].creator = GRadioCreate;
    605. 

  605. 

  606. 	label[2].text = (unichar_t *) lab;
    607. 

  607. 	label[2].text_is_1byte = true;
    608. 

  608. 	gcd[2].gd.label = &label[2];
    609. 

  609. 	gcd[2].gd.pos.x = 5; gcd[2].gd.pos.y = 25; 
    610. 

  610. 	gcd[2].gd.flags = gg_enabled|gg_visible ;
    611. 

  611. 	gcd[2].creator = GLabelCreate;
    612. 

  612. 

  613. 	sprintf( buffer, "%g", *val );
    614. 

  614. 	label[3].text = (unichar_t *) buffer;
    615. 

  615. 	label[3].text_is_1byte = true;
    616. 

  616. 	gcd[3].gd.label = &label[3];
    617. 

  617. 	gcd[3].gd.pos.x = 5; gcd[3].gd.pos.y = 40; 
    618. 

  618. 	gcd[3].gd.flags = gg_enabled|gg_visible ;
    619. 

  619. 	gcd[3].gd.cid = CID_ValText;
    620. 

  620. 	gcd[3].creator = GTextFieldCreate;
    621. 

  621. 

  622. 	gcd[4].gd.pos.x = 20-3; gcd[4].gd.pos.y = 85+off;
    623. 

  623. 	gcd[4].gd.pos.width = -1; gcd[4].gd.pos.height = 0;
    624. 

  624. 	gcd[4].gd.flags = gg_visible | gg_enabled | gg_but_default;
    625. 

  625. 	label[4].text = (unichar_t *) _("_OK");
    626. 

  626. 	label[4].text_is_1byte = true;
    627. 

  627. 	label[4].text_in_resource = true;
    628. 

  628. 	gcd[4].gd.mnemonic = 'O';
    629. 

  629. 	gcd[4].gd.label = &label[4];
    630. 

  630. 	gcd[4].gd.handle_controlevent = TA_OK;
    631. 

  631. 	gcd[4].creator = GButtonCreate;
    632. 

  632. 

  633. 	gcd[5].gd.pos.x = -20; gcd[5].gd.pos.y = 85+3+off;
    634. 

  634. 	gcd[5].gd.pos.width = -1; gcd[5].gd.pos.height = 0;
    635. 

  635. 	gcd[5].gd.flags = gg_visible | gg_enabled | gg_but_cancel;
    636. 

  636. 	label[5].text = (unichar_t *) _("_Cancel");
    637. 

  637. 	label[5].text_is_1byte = true;
    638. 

  638. 	label[5].text_in_resource = true;
    639. 

  639. 	gcd[5].gd.label = &label[5];
    640. 

  640. 	gcd[5].gd.mnemonic = 'C';
    641. 

  641. 	gcd[5].gd.handle_controlevent = TA_Cancel;
    642. 

  642. 	gcd[5].creator = GButtonCreate;
    643. 

  643. 

  644. 	if ( ispolystar ) {
    645. 

  645. 	    label[6].text = (unichar_t *) _("Regular");
    646. 

  646. 	    label[6].text_is_1byte = true;
    647. 

  647. 	    gcd[6].gd.label = &label[6];
    648. 

  648. 	    gcd[6].gd.pos.x = 5; gcd[6].gd.pos.y = 70; 
    649. 

  649. 	    gcd[6].gd.flags = gg_enabled|gg_visible | (rb==0?gg_cb_on:0);
    650. 

  650. 	    gcd[6].creator = GRadioCreate;
    651. 

  651. 

  652. 	    label[7].text = (unichar_t *) _("Points:");
    653. 

  653. 	    label[7].text_is_1byte = true;
    654. 

  654. 	    gcd[7].gd.label = &label[7];
    655. 

  655. 	    gcd[7].gd.pos.x = 65; gcd[7].gd.pos.y = 70; 
    656. 

  656. 	    gcd[7].gd.flags = gg_enabled|gg_visible | (rb==1?gg_cb_on:0);
    657. 

  657. 	    gcd[7].creator = GRadioCreate;
    658. 

  658. 

  659. 	    sprintf( buf, "%4g", star_percent*100 );
    660. 

  660. 	    label[8].text = (unichar_t *) buf;
    661. 

  661. 	    label[8].text_is_1byte = true;
    662. 

  662. 	    gcd[8].gd.label = &label[8];
    663. 

  663. 	    gcd[8].gd.pos.x = 125; gcd[8].gd.pos.y = 70;  gcd[8].gd.pos.width=50;
    664. 

  664. 	    gcd[8].gd.flags = gg_enabled|gg_visible ;
    665. 

  665. 	    gcd[8].gd.cid = CID_PointPercent;
    666. 

  666. 	    gcd[8].creator = GTextFieldCreate;
    667. 

  667. 

  668. 	    label[9].text = (unichar_t *) "%";
    669. 

  669. 	    label[9].text_is_1byte = true;
    670. 

  670. 	    gcd[9].gd.label = &label[9];
    671. 

  671. 	    gcd[9].gd.pos.x = 180; gcd[9].gd.pos.y = 70; 
    672. 

  672. 	    gcd[9].gd.flags = gg_enabled|gg_visible ;
    673. 

  673. 	    gcd[9].creator = GLabelCreate;
    674. 

  674. 	} else {
    675. 

  675. 	    label[6].text = (unichar_t *) _("Bounding Box");
    676. 

  676. 	    label[6].text_is_1byte = true;
    677. 

  677. 	    gcd[6].gd.label = &label[6];
    678. 

  678. 	    gcd[6].gd.pos.x = 5; gcd[6].gd.pos.y = 65; 
    679. 

  679. 	    gcd[6].gd.flags = gg_enabled|gg_visible | (co[rb]==0?gg_cb_on:0);
    680. 

  680. 	    gcd[6].creator = GRadioCreate;
    681. 

  681. 

  682. 	    label[7].text = (unichar_t *) _("Center Out");
    683. 

  683. 	    label[7].text_is_1byte = true;
    684. 

  684. 	    gcd[7].gd.label = &label[7];
    685. 

  685. 	    gcd[7].gd.pos.x = 90; gcd[7].gd.pos.y = 65; 
    686. 

  686. 	    gcd[7].gd.flags = gg_enabled|gg_visible | (co[rb]==1?gg_cb_on:0);
    687. 

  687. 	    gcd[7].creator = GRadioCreate;
    688. 

  688. 

  689. 	    if ( rb )
    690. 

  690. 		gcd[3].gd.flags = gg_visible;
    691. 

  691. 	    gcd[0].gd.handle_controlevent = TA_RadChange;
    692. 

  692. 	    gcd[1].gd.handle_controlevent = TA_RadChange;
    693. 

  693. 

  694. 	    if ( haspos ) {
    695. 

  695. 		gcd[6].gd.handle_controlevent = TA_CenRadChange;
    696. 

  696. 		gcd[7].gd.handle_controlevent = TA_CenRadChange;
    697. 

  697. 

  698. 		label[8].text = (unichar_t *) _("_X");
    699. 

  699. 		label[8].text_is_1byte = true;
    700. 

  700. 		label[8].text_in_resource = true;
    701. 

  701. 		gcd[8].gd.label = &label[8];
    702. 

  702. 		gcd[8].gd.pos.x = 70; gcd[8].gd.pos.y = gcd[7].gd.pos.y+15;
    703. 

  703. 		gcd[8].gd.flags = gg_enabled|gg_visible;
    704. 

  704. 		gcd[8].creator = GLabelCreate;
    705. 

  705. 

  706. 		label[9].text = (unichar_t *) _("_Y");
    707. 

  707. 		label[9].text_is_1byte = true;
    708. 

  708. 		label[9].text_in_resource = true;
    709. 

  709. 		gcd[9].gd.label = &label[9];
    710. 

  710. 		gcd[9].gd.pos.x = 120; gcd[9].gd.pos.y = gcd[8].gd.pos.y;
    711. 

  711. 		gcd[9].gd.flags = gg_enabled|gg_visible;
    712. 

  712. 		gcd[9].creator = GLabelCreate;
    713. 

  713. 

  714. 		label[10].text = (unichar_t *) (co[rb] ? _("C_enter") : _("C_orner") );
    715. 

  715. 		label[10].text_is_1byte = true;
    716. 

  716. 		label[10].text_in_resource = true;
    717. 

  717. 		gcd[10].gd.label = &label[10];
    718. 

  718. 		gcd[10].gd.pos.x = 5; gcd[10].gd.pos.y = gcd[8].gd.pos.y+17;
    719. 

  719. 		gcd[10].gd.flags = gg_enabled|gg_visible;
    720. 

  720. 		gcd[10].gd.cid = CID_CentCornLab;
    721. 

  721. 		gcd[10].creator = GLabelCreate;
    722. 

  722. 

  723. 		sprintf( cenx, "%g", (double) cv->info.x );
    724. 

  724. 		label[11].text = (unichar_t *) cenx;
    725. 

  725. 		label[11].text_is_1byte = true;
    726. 

  726. 		gcd[11].gd.label = &label[11];
    727. 

  727. 		gcd[11].gd.pos.x = 60; gcd[11].gd.pos.y = gcd[10].gd.pos.y-4;
    728. 

  728. 		gcd[11].gd.pos.width = 40;
    729. 

  729. 		gcd[11].gd.flags = gg_enabled|gg_visible;
    730. 

  730. 		gcd[11].gd.cid = CID_CentCornX;
    731. 

  731. 		gcd[11].creator = GTextFieldCreate;
    732. 

  732. 

  733. 		sprintf( ceny, "%g", (double) cv->info.y );
    734. 

  734. 		label[12].text = (unichar_t *) ceny;
    735. 

  735. 		label[12].text_is_1byte = true;
    736. 

  736. 		gcd[12].gd.label = &label[12];
    737. 

  737. 		gcd[12].gd.pos.x = 110; gcd[12].gd.pos.y = gcd[11].gd.pos.y;
    738. 

  738. 		gcd[12].gd.pos.width = gcd[11].gd.pos.width;
    739. 

  739. 		gcd[12].gd.flags = gg_enabled|gg_visible;
    740. 

  740. 		gcd[12].gd.cid = CID_CentCornY;
    741. 

  741. 		gcd[12].creator = GTextFieldCreate;
    742. 

  742. 

  743. 		label[13].text = (unichar_t *) (co[rb] ? _("Radius:   ") : _("Diameter:") );
    744. 

  744. 		label[13].text_is_1byte = true;
    745. 

  745. 		gcd[13].gd.label = &label[13];
    746. 

  746. 		gcd[13].gd.pos.x = 5; gcd[13].gd.pos.y = gcd[10].gd.pos.y+24;
    747. 

  747. 		gcd[13].gd.flags = gg_enabled|gg_visible;
    748. 

  748. 		gcd[13].gd.cid = CID_RadDiamLab;
    749. 

  749. 		gcd[13].creator = GLabelCreate;
    750. 

  750. 

  751. 		sprintf( radx, "%g", (double) raddiam_x );
    752. 

  752. 		label[14].text = (unichar_t *) radx;
    753. 

  753. 		label[14].text_is_1byte = true;
    754. 

  754. 		gcd[14].gd.label = &label[14];
    755. 

  755. 		gcd[14].gd.pos.x = gcd[11].gd.pos.x; gcd[14].gd.pos.y = gcd[13].gd.pos.y-4;
    756. 

  756. 		gcd[14].gd.pos.width = gcd[11].gd.pos.width;
    757. 

  757. 		gcd[14].gd.flags = gg_enabled|gg_visible;
    758. 

  758. 		gcd[14].gd.cid = CID_RadDiamX;
    759. 

  759. 		gcd[14].creator = GTextFieldCreate;
    760. 

  760. 

  761. 		sprintf( rady, "%g", (double) raddiam_y );
    762. 

  762. 		label[15].text = (unichar_t *) rady;
    763. 

  763. 		label[15].text_is_1byte = true;
    764. 

  764. 		gcd[15].gd.label = &label[15];
    765. 

  765. 		gcd[15].gd.pos.x = gcd[12].gd.pos.x; gcd[15].gd.pos.y = gcd[14].gd.pos.y;
    766. 

  766. 		gcd[15].gd.pos.width = gcd[11].gd.pos.width;
    767. 

  767. 		gcd[15].gd.flags = gg_enabled|gg_visible;
    768. 

  768. 		gcd[15].gd.cid = CID_RadDiamY;
    769. 

  769. 		gcd[15].creator = GTextFieldCreate;
    770. 

  770. 

  771. 		label[16].text = (unichar_t *) _("Angle:");
    772. 

  772. 		label[16].text_is_1byte = true;
    773. 

  773. 		gcd[16].gd.label = &label[16];
    774. 

  774. 		gcd[16].gd.pos.x = 5; gcd[16].gd.pos.y = gcd[13].gd.pos.y+24;
    775. 

  775. 		gcd[16].gd.flags = gg_enabled|gg_visible;
    776. 

  776. 		gcd[16].creator = GLabelCreate;
    777. 

  777. 

  778. 		sprintf( angle, "%g", (double) rotate_by );
    779. 

  779. 		label[17].text = (unichar_t *) angle;
    780. 

  780. 		label[17].text_is_1byte = true;
    781. 

  781. 		gcd[17].gd.label = &label[17];
    782. 

  782. 		gcd[17].gd.pos.x = 60; gcd[17].gd.pos.y = gcd[16].gd.pos.y-4;
    783. 

  783. 		gcd[17].gd.pos.width = gcd[11].gd.pos.width;
    784. 

  784. 		gcd[17].gd.flags = gg_enabled|gg_visible;
    785. 

  785. 		gcd[17].gd.cid = CID_Angle;
    786. 

  786. 		gcd[17].creator = GTextFieldCreate;
    787. 

  787. 	    }
    788. 

  788. 	}
    789. 

  789. 	GGadgetsCreate(d.gw,gcd);
    790. 

  790.     d.rb1 = gcd[0].ret;
    791. 

  791.     d.reg = gcd[6].ret;
    792. 

  792.     d.pts = gcd[7].ret;
    793. 

  793. 

  794.     GWidgetHidePalettes();
    795. 

  795.     GDrawSetVisible(d.gw,true);
    796. 

  796.     while ( !d.done )
    797. 

  797. 	GDrawProcessOneEvent(NULL);
    798. 

  798.     GDrawDestroyWindow(d.gw);
    799. 

  799. return( d.ret );
    800. 

  800. }
    801. 

  801. 

  802. static void CVRectElipse(CharView *cv) {
    803. 

  803.     rectelipse = Ask(_("Rectangle"),_("Ellipse"),rectelipse,
    804. 

  804. 	    _("Round Rectangle Radius"),&rr_radius,center_out,false, cv);
    805. 

  805.     GDrawRequestExpose(cvtools,NULL,false);
    806. 

  806. }
    807. 

  807. 

  808. void CVRectEllipsePosDlg(CharView *cv) {
    809. 

  809.     rectelipse = Ask(_("Rectangle"),_("Ellipse"),rectelipse,
    810. 

  810. 	    _("Round Rectangle Radius"),&rr_radius,center_out,2, cv);
    811. 

  811.     GDrawRequestExpose(cvtools,NULL,false);
    812. 

  812. }
    813. 

  813. 

  814. static void CVPolyStar(CharView *cv) {
    815. 

  815.     float temp = ps_pointcnt;
    816. 

  816.     int foo[2];
    817. 

  817.     polystar = Ask(_("Polygon"),_("Star"),polystar,
    818. 

  818. 	    _("Number of star points/Polygon vertices"),&temp,foo,true, cv);
    819. 

  819.     ps_pointcnt = temp;
    820. 

  820. }
    821. 

  821. 

  822. static void ToolsExpose(GWindow pixmap, CharView *cv, GRect *r) {
    823. 

  823.     GRect old;
    824. 

  824.     /* Note: If you change this ordering, change enum cvtools */
    825. 

  825.     static GImage *normbuttons[][2] = { { &GIcon_pointer, &GIcon_magnify },
    826. 

  826. 				    { &GIcon_freehand, &GIcon_hand },
    827. 

  827. 			            { &GIcon_knife, &GIcon_ruler },
    828. 

  828. 			            { &GIcon_pen, &GIcon_spirodisabled },
    829. 

  829. 				    { &GIcon_curve, &GIcon_hvcurve },
    830. 

  830. 			            { &GIcon_corner, &GIcon_tangent},
    831. 

  831. 			            { &GIcon_scale, &GIcon_rotate },
    832. 

  832. 			            { &GIcon_flip, &GIcon_skew },
    833. 

  833. 			            { &GIcon_3drotate, &GIcon_perspective },
    834. 

  834. 			            { &GIcon_rect, &GIcon_poly},
    835. 

  835. 			            { &GIcon_elipse, &GIcon_star}};
    836. 

  836.     static GImage *spirobuttons[][2] = { { &GIcon_pointer, &GIcon_magnify },
    837. 

  837. 				    { &GIcon_freehand, &GIcon_hand },
    838. 

  838. 			            { &GIcon_knife, &GIcon_ruler },
    839. 

  839. 			            { &GIcon_spiroright, &GIcon_spirodown },
    840. 

  840. 				    { &GIcon_spirocurve, &GIcon_spirog2curve },
    841. 

  841. 			            { &GIcon_spirocorner, &GIcon_spiroleft },
    842. 

  842. 			            { &GIcon_scale, &GIcon_rotate },
    843. 

  843. 			            { &GIcon_flip, &GIcon_skew },
    844. 

  844. 			            { &GIcon_3drotate, &GIcon_perspective },
    845. 

  845. 			            { &GIcon_rect, &GIcon_poly},
    846. 

  846. 			            { &GIcon_elipse, &GIcon_star}};
    847. 

  847.     static GImage *normsmalls[] = { &GIcon_smallpointer, &GIcon_smallmag,
    848. 

  848. 				    &GIcon_smallpencil, &GIcon_smallhand,
    849. 

  849. 			            &GIcon_smallknife, &GIcon_smallruler,
    850. 

  850. 			            &GIcon_smallpen, NULL,
    851. 

  851. 				    &GIcon_smallcurve, &GIcon_smallhvcurve,
    852. 

  852. 			            &GIcon_smallcorner, &GIcon_smalltangent,
    853. 

  853. 			            &GIcon_smallscale, &GIcon_smallrotate,
    854. 

  854. 			            &GIcon_smallflip, &GIcon_smallskew,
    855. 

  855. 			            &GIcon_small3drotate, &GIcon_smallperspective,
    856. 

  856. 			            &GIcon_smallrect, &GIcon_smallpoly,
    857. 

  857. 			            &GIcon_smallelipse, &GIcon_smallstar };
    858. 

  858.     static GImage *spirosmalls[] = { &GIcon_smallpointer, &GIcon_smallmag,
    859. 

  859. 				    &GIcon_smallpencil, &GIcon_smallhand,
    860. 

  860. 			            &GIcon_smallknife, &GIcon_smallruler,
    861. 

  861. 			            &GIcon_smallspiroright, NULL,
    862. 

  862. 				    &GIcon_smallspirocurve, &GIcon_smallspirog2curve,
    863. 

  863. 			            &GIcon_smallspirocorner, &GIcon_smallspiroleft,
    864. 

  864. 			            &GIcon_smallscale, &GIcon_smallrotate,
    865. 

  865. 			            &GIcon_smallflip, &GIcon_smallskew,
    866. 

  866. 			            &GIcon_small3drotate, &GIcon_smallperspective,
    867. 

  867. 			            &GIcon_smallrect, &GIcon_smallpoly,
    868. 

  868. 			            &GIcon_smallelipse, &GIcon_smallstar };
    869. 

  869.     static const unichar_t _Mouse[][9] = {
    870. 

  870. 	    { 'M', 's', 'e', '1',  '\0' },
    871. 

  871. 	    { '^', 'M', 's', 'e', '1',  '\0' },
    872. 

  872. 	    { 'M', 's', 'e', '2',  '\0' },
    873. 

  873. 	    { '^', 'M', 's', 'e', '2',  '\0' }};
    874. 

  874.     int i,j,norm, mi;
    875. 

  875.     int tool = cv->cntrldown?cv->cb1_tool:cv->b1_tool;
    876. 

  876.     int dither = GDrawSetDither(NULL,false);
    877. 

  877.     GRect temp;
    878. 

  878.     int canspiro = hasspiro(), inspiro = canspiro && cv->b.sc->inspiro;
    879. 

  879.     GImage *(*buttons)[2] = inspiro ? spirobuttons : normbuttons;
    880. 

  880.     GImage **smalls = inspiro ? spirosmalls : normsmalls;
    881. 

  881. 

  882.     normbuttons[3][1] = canspiro ? &GIcon_spiroup : &GIcon_spirodisabled;
    883. 

  883. 

  884.     GDrawPushClip(pixmap,r,&old);
    885. 

  885.     GDrawFillRect(pixmap,r,GDrawGetDefaultBackground(NULL));
    886. 

  886.     GDrawSetLineWidth(pixmap,0);
    887. 

  887.     for ( i=0; i<sizeof(normbuttons)/sizeof(normbuttons[0])-1; ++i ) for ( j=0; j<2; ++j ) {
    888. 

  888. 	mi = i;
    889. 

  889. 	if ( i==(cvt_rect)/2 && ((j==0 && rectelipse) || (j==1 && polystar)) )
    890. 

  890. 	    ++mi;
    891. 

  891. /*	if ( cv->b.sc->parent->order2 && buttons[mi][j]==&GIcon_freehand ) */
    892. 

  892. /*	    GDrawDrawImage(pixmap,&GIcon_greyfree,NULL,j*27+1,i*27+1);	 */
    893. 

  893. /*	else								 */
    894. 

  894. 	    GDrawDrawImage(pixmap,buttons[mi][j],NULL,j*27+1,i*27+1);
    895. 

  895. 	norm = (mi*2+j!=tool);
    896. 

  896. 	{
    897. 

  897. 	  // These are from charview.c.
    898. 

  898. 	  extern int cvbutton3d; // Default 1.
    899. 

  899. 	  extern Color cvbutton3dedgelightcol; // Default 0xe0e0e0.
    900. 

  900. 	  extern Color cvbutton3dedgedarkcol; // Default 0x707070.
    901. 

  901. 	  if (cvbutton3d) {
    902. 

  902. 	    GDrawDrawLine(pixmap,j*27,i*27,j*27+25,i*27,norm?cvbutton3dedgelightcol:cvbutton3dedgedarkcol);
    903. 

  903. 	    GDrawDrawLine(pixmap,j*27,i*27,j*27,i*27+25,norm?cvbutton3dedgelightcol:cvbutton3dedgedarkcol);
    904. 

  904. 	    GDrawDrawLine(pixmap,j*27,i*27+25,j*27+25,i*27+25,norm?cvbutton3dedgedarkcol:cvbutton3dedgelightcol);
    905. 

  905. 	    GDrawDrawLine(pixmap,j*27+25,i*27,j*27+25,i*27+25,norm?cvbutton3dedgedarkcol:cvbutton3dedgelightcol);
    906. 

  906. 	  }
    907. 

  907. 	}
    908. 

  908.     }
    909. 

  909.     GDrawSetFont(pixmap,toolsfont);
    910. 

  910.     temp.x = 52-16; temp.y = i*27; temp.width = 16; temp.height = 4*12;
    911. 

  911.     GDrawFillRect(pixmap,&temp,GDrawGetDefaultBackground(NULL));
    912. 

  912.     for ( j=0; j<4; ++j ) {
    913. 

  913. 	GDrawDrawText(pixmap,2,i*27+j*12+10,(unichar_t *) _Mouse[j],-1,GDrawGetDefaultForeground(NULL));
    914. 

  914. 	if ( (&cv->b1_tool)[j]!=cvt_none && smalls[(&cv->b1_tool)[j]])
    915. 

  915. 	    GDrawDrawImage(pixmap,smalls[(&cv->b1_tool)[j]],NULL,52-16,i*27+j*12);
    916. 

  916.     }
    917. 

  917.     GDrawPopClip(pixmap,&old);
    918. 

  918.     GDrawSetDither(NULL,dither);
    919. 

  919. }
    920. 

  920. 

  921. int TrueCharState(GEvent *event) {
    922. 

  922.     int bit = 0;
    923. 

  923.     /* X doesn't set the state until after the event. I want the state to */
    924. 

  924.     /*  reflect whatever key just got depressed/released */
    925. 

  925.     int keysym = event->u.chr.keysym;
    926. 

  926. 

  927.     if ( keysym == GK_Caps_Lock || keysym == GK_Shift_Lock ) {
    928. 

  928. 	static int set_on_last_down = false;
    929. 

  929. 	/* caps lock is sticky and doesn't work like the other modifiers */
    930. 

  930. 	/* but it is even worse. the bit seems to be set on key down, but */
    931. 

  931. 	/* unset on key up. In other words on key up, the bit will always */
    932. 

  932. 	/* set and we have no idea which way it will go. So we guess, and */
    933. 

  933. 	/* if they haven't messed with the key outside ff we should be right */
    934. 

  934. 	if ( event->type == et_char ) {
    935. 

  935. 	    set_on_last_down = (event->u.chr.state ^ ksm_capslock)& ksm_capslock;
    936. 

  936. return( event->u.chr.state ^ ksm_capslock );
    937. 

  937. 	} else if ( !(event->u.chr.state & ksm_capslock) || set_on_last_down )
    938. 

  938. return( event->u.chr.state );
    939. 

  939. 	else
    940. 

  940. return( event->u.chr.state & ~ksm_capslock );
    941. 

  941.     }
    942. 

  942. 

  943.     if ( keysym == GK_Meta_L || keysym == GK_Meta_R ||
    944. 

  944. 	    keysym == GK_Alt_L || keysym == GK_Alt_R )
    945. 

  945. 	bit = ksm_meta;
    946. 

  946.     else if ( keysym == GK_Shift_L || keysym == GK_Shift_R )
    947. 

  947. 	bit = ksm_shift;
    948. 

  948.     else if ( keysym == GK_Control_L || keysym == GK_Control_R )
    949. 

  949. 	bit = ksm_control;
    950. 

  950.     else if ( keysym == GK_Super_L || keysym == GK_Super_L )
    951. 

  951. 	bit = ksm_super;
    952. 

  952.     else if ( keysym == GK_Hyper_L || keysym == GK_Hyper_L )
    953. 

  953. 	bit = ksm_hyper;
    954. 

  954.     else
    955. 

  955. return( event->u.chr.state );
    956. 

  956. 

  957.     if ( event->type == et_char )
    958. 

  958. return( event->u.chr.state | bit );
    959. 

  959.     else
    960. 

  960. return( event->u.chr.state & ~bit );
    961. 

  961. }
    962. 

  962. 

  963. void CVToolsSetCursor(CharView *cv, int state, char *device) {
    964. 

  964.     int shouldshow;
    965. 

  965.     int cntrl;
    966. 

  966. 

  967.     if ( tools[0] == ct_pointer ) {
    968. 

  968. 	tools[cvt_pointer] = ct_mypointer;
    969. 

  969. 	tools[cvt_magnify] = ct_magplus;
    970. 

  970. 	tools[cvt_freehand] = ct_pencil;
    971. 

  971. 	tools[cvt_hand] = ct_myhand;
    972. 

  972. 	tools[cvt_curve] = ct_circle;
    973. 

  973. 	tools[cvt_hvcurve] = ct_hvcircle;
    974. 

  974. 	tools[cvt_corner] = ct_square;
    975. 

  975. 	tools[cvt_tangent] = ct_triangle;
    976. 

  976. 	tools[cvt_pen] = ct_pen;
    977. 

  977. 	tools[cvt_knife] = ct_knife;
    978. 

  978. 	tools[cvt_ruler] = ct_ruler;
    979. 

  979. 	tools[cvt_scale] = ct_scale;
    980. 

  980. 	tools[cvt_flip] = ct_flip;
    981. 

  981. 	tools[cvt_rotate] = ct_rotate;
    982. 

  982. 	tools[cvt_skew] = ct_skew;
    983. 

  983. 	tools[cvt_3d_rotate] = ct_3drotate;
    984. 

  984. 	tools[cvt_perspective] = ct_perspective;
    985. 

  985. 	tools[cvt_rect] = ct_rect;
    986. 

  986. 	tools[cvt_poly] = ct_poly;
    987. 

  987. 	tools[cvt_elipse] = ct_elipse;
    988. 

  988. 	tools[cvt_star] = ct_star;
    989. 

  989. 	tools[cvt_minify] = ct_magminus;
    990. 

  990. 	memcpy(spirotools,tools,sizeof(tools));
    991. 

  991. 	spirotools[cvt_spirog2] = ct_g2circle;
    992. 

  992. 	spirotools[cvt_spiroleft] = ct_spiroleft;
    993. 

  993. 	spirotools[cvt_spiroright] = ct_spiroright;
    994. 

  994.     }
    995. 

  995. 

  996.     shouldshow = cvt_none;
    997. 

  997.     if ( cv->active_tool!=cvt_none )
    998. 

  998. 	shouldshow = cv->active_tool;
    999. 

  999.     else if ( cv->pressed_display!=cvt_none )
    1000. 

  1000. 	shouldshow = cv->pressed_display;
    1001. 

  1001.     else if ( device==NULL || strcmp(device,"Mouse1")==0 ) {
    1002. 

  1002. 	if ( (state&(ksm_shift|ksm_control)) && (state&ksm_button4))
    1003. 

  1003. 	    shouldshow = cvt_magnify;
    1004. 

  1004. 	else if ( (state&(ksm_shift|ksm_control)) && (state&ksm_button5))
    1005. 

  1005. 	    shouldshow = cvt_minify;
    1006. 

  1006. 	else if ( (state&ksm_control) && (state&(ksm_button2|ksm_super)) )
    1007. 

  1007. 	    shouldshow = cv->cb2_tool;
    1008. 

  1008. 	else if ( (state&(ksm_button2|ksm_super)) )
    1009. 

  1009. 	    shouldshow = cv->b2_tool;
    1010. 

  1010. 	else if ( (state&ksm_control) )
    1011. 

  1011. 	    shouldshow = cv->cb1_tool;
    1012. 

  1012. 	else
    1013. 

  1013. 	    shouldshow = cv->b1_tool;
    1014. 

  1014.     } else if ( strcmp(device,"eraser")==0 )
    1015. 

  1015. 	shouldshow = cv->er_tool;
    1016. 

  1016.     else if ( strcmp(device,"stylus")==0 ) {
    1017. 

  1017. 	if ( (state&(ksm_button2|ksm_control|ksm_super)) )
    1018. 

  1018. 	    shouldshow = cv->s2_tool;
    1019. 

  1019. 	else
    1020. 

  1020. 	    shouldshow = cv->s1_tool;
    1021. 

  1021.     }
    1022. 

  1022.     if ( shouldshow==cvt_magnify && (state&ksm_meta))
    1023. 

  1023. 	shouldshow = cvt_minify;
    1024. 

  1024.     if ( shouldshow!=cv->showing_tool ) {
    1025. 

  1025. 	CPEndInfo(cv);
    1026. 

  1026. 	if ( cv->b.sc->inspiro && hasspiro()) {
    1027. 

  1027. 	    GDrawSetCursor(cv->v,spirotools[shouldshow]);
    1028. 

  1028. 	    if ( cvtools!=NULL )	/* Might happen if window owning docked palette destroyed */
    1029. 

  1029. 		GDrawSetCursor(cvtools,spirotools[shouldshow]);
    1030. 

  1030. 	} else {
    1031. 

  1031. 	    GDrawSetCursor(cv->v,tools[shouldshow]);
    1032. 

  1032. 	    if ( cvtools!=NULL )	/* Might happen if window owning docked palette destroyed */
    1033. 

  1033. 		GDrawSetCursor(cvtools,tools[shouldshow]);
    1034. 

  1034. 	}
    1035. 

  1035. 	cv->showing_tool = shouldshow;
    1036. 

  1036.     }
    1037. 

  1037. 

  1038.     if ( device==NULL || strcmp(device,"stylus")==0 ) {
    1039. 

  1039. 	cntrl = (state&ksm_control)?1:0;
    1040. 

  1040. 	if ( device!=NULL && (state&ksm_button2))
    1041. 

  1041. 	    cntrl = true;
    1042. 

  1042. 	if ( cntrl != cv->cntrldown ) {
    1043. 

  1043. 	    cv->cntrldown = cntrl;
    1044. 

  1044. 	    GDrawRequestExpose(cvtools,NULL,false);
    1045. 

  1045. 	}
    1046. 

  1046.     }
    1047. 

  1047. }
    1048. 

  1048. 

  1049. static int CVCurrentTool(CharView *cv, GEvent *event) {
    1050. 

  1050.     if ( event->u.mouse.device!=NULL && strcmp(event->u.mouse.device,"eraser")==0 )
    1051. 

  1051. return( cv->er_tool );
    1052. 

  1052.     else if ( event->u.mouse.device!=NULL && strcmp(event->u.mouse.device,"stylus")==0 ) {
    1053. 

  1053. 	if ( event->u.mouse.button==2 )
    1054. 

  1054. 	    /* Only thing that matters is touch which maps to button 1 */;
    1055. 

  1055. 	else if ( cv->had_control )
    1056. 

  1056. return( cv->s2_tool );
    1057. 

  1057. 	else
    1058. 

  1058. return( cv->s1_tool );
    1059. 

  1059.     }
    1060. 

  1060.     if ( cv->had_control && event->u.mouse.button==2 )
    1061. 

  1061. return( cv->cb2_tool );
    1062. 

  1062.     else if ( event->u.mouse.button==2 )
    1063. 

  1063. return( cv->b2_tool );
    1064. 

  1064.     else if ( cv->had_control ) {
    1065. 

  1065. return( cv->cb1_tool );
    1066. 

  1066.     } else {
    1067. 

  1067. return( cv->b1_tool );
    1068. 

  1068.     }
    1069. 

  1069. }
    1070. 

  1070. 

  1071. static void SCCheckForSSToOptimize(SplineChar *sc, SplineSet *ss,int order2) {
    1072. 

  1072. 

  1073.     for ( ; ss!=NULL ; ss = ss->next ) {
    1074. 

  1074. 	if ( ss->beziers_need_optimizer ) {
    1075. 

  1075. 	    SplineSetAddExtrema(sc,ss,ae_only_good,sc->parent->ascent+sc->parent->descent);
    1076. 

  1076. 	    ss->beziers_need_optimizer = false;
    1077. 

  1077. 	}
    1078. 

  1078. 	if ( order2 && ss->first->next!=NULL && !ss->first->next->order2 ) {
    1079. 

  1079. 	    SplineSet *temp = SSttfApprox(ss), foo;
    1080. 

  1080. 	    foo = *ss;
    1081. 

  1081. 	    ss->first = temp->first; ss->last = temp->last;
    1082. 

  1082. 	    temp->first = foo.first; temp->last = foo.last;
    1083. 

  1083. 	    SplinePointListFree(temp);
    1084. 

  1084. 	}
    1085. 

  1085.     }
    1086. 

  1086. }
    1087. 

  1087. 

  1088. static void CVChangeSpiroMode(CharView *cv) {
    1089. 

  1089.     if ( hasspiro() ) {
    1090. 

  1090. 	cv->b.sc->inspiro = !cv->b.sc->inspiro;
    1091. 

  1091. 	cv->showing_tool = cvt_none;
    1092. 

  1092. 	CVClearSel(cv);
    1093. 

  1093. 	if ( !cv->b.sc->inspiro )
    1094. 

  1094. 	    SCCheckForSSToOptimize(cv->b.sc,cv->b.layerheads[cv->b.drawmode]->splines,
    1095. 

  1095. 		    cv->b.layerheads[cv->b.drawmode]->order2);
    1096. 

  1096. 	GDrawRequestExpose(cvtools,NULL,false);
    1097. 

  1097. 	SCUpdateAll(cv->b.sc);
    1098. 

  1098.     } else
    1099. 

  1099. #ifdef _NO_LIBSPIRO
    1100. 

  1100. 	ff_post_error(_("You may not use spiros"),_("This version of fontforge was not linked with the spiro library, so you may not use them."));
    1101. 

  1101. #else
    1102. 

  1102. 	ff_post_error(_("You may not use spiros"),_("FontForge was unable to load libspiro, spiros are not available for use."));
    1103. 

  1103. #endif
    1104. 

  1104. }
    1105. 

  1105. 

  1106. char* HKTextInfoToUntranslatedTextFromTextInfo( GTextInfo* ti ); // From ../gdraw/gmenu.c.
    1107. 

  1107. 

  1108. static void ToolsMouse(CharView *cv, GEvent *event) {
    1109. 

  1109.     int i = (event->u.mouse.y/27), j = (event->u.mouse.x/27), mi=i;
    1110. 

  1110.     int pos;
    1111. 

  1111.     int isstylus = event->u.mouse.device!=NULL && strcmp(event->u.mouse.device,"stylus")==0;
    1112. 

  1112.     int styluscntl = isstylus && (event->u.mouse.state&0x200);
    1113. 

  1113.     static int settings[2];
    1114. 

  1114. 

  1115.     if(j >= 2)
    1116. 

  1116. return;			/* If the wm gave me a window the wrong size */
    1117. 

  1117. 

  1118. 

  1119.     if ( i==(cvt_rect)/2 ) {
    1120. 

  1120. 	int current = CVCurrentTool(cv,event);
    1121. 

  1121. 	int changed = false;
    1122. 

  1122. 	if ( event->type == et_mousedown && event->u.mouse.clicks>=2 ) {
    1123. 

  1123. 	    rectelipse = settings[0];
    1124. 

  1124. 	    polystar = settings[1];
    1125. 

  1125. 	} else if ( event->type == et_mousedown ) {
    1126. 

  1126. 	    settings[0] = rectelipse; settings[1] = polystar;
    1127. 

  1127. 	    /* A double click will change the type twice, which leaves it where it was, which is desired */
    1128. 

  1128. 	    if ( j==0 && ((!rectelipse && current==cvt_rect) || (rectelipse && current==cvt_elipse)) ) {
    1129. 

  1129. 		rectelipse = !rectelipse;
    1130. 

  1130. 		changed = true;
    1131. 

  1131. 	    } else if (j==1 && ((!polystar && current==cvt_poly) || (polystar && current==cvt_star)) ) {
    1132. 

  1132. 		polystar = !polystar;
    1133. 

  1133. 		changed = true;
    1134. 

  1134. 	    }
    1135. 

  1135. 	    if ( changed ) {
    1136. 

  1136. 		SavePrefs(true);
    1137. 

  1137. 		GDrawRequestExpose(cvtools,NULL,false);
    1138. 

  1138. 	    }
    1139. 

  1139. 	}
    1140. 

  1140. 	if ( (j==0 && rectelipse) || (j==1 && polystar) )
    1141. 

  1141. 	    ++mi;
    1142. 

  1142.     }
    1143. 

  1143.     pos = mi*2 + j;
    1144. 

  1144.     GGadgetEndPopup();
    1145. 

  1145.     /* we have two fewer buttons than commands as two bottons each control two commands */
    1146. 

  1146.     if ( pos<0 || pos>=cvt_max )
    1147. 

  1147. 	pos = cvt_none;
    1148. 

  1148.     if ( event->type == et_mousedown ) {
    1149. 

  1149. 	if ( isstylus && event->u.mouse.button==2 )
    1150. 

  1150. 	    /* Not a real button press, only touch counts. This is a modifier */;
    1151. 

  1151. 	else if ( pos==cvt_spiro ) {
    1152. 

  1152. 	    CVChangeSpiroMode(cv);
    1153. 

  1153. 	    /* This is just a button that indicates a state */
    1154. 

  1154. 	} else {
    1155. 

  1155. 	    cv->pressed_tool = cv->pressed_display = pos;
    1156. 

  1156. 	    cv->had_control = ((event->u.mouse.state&ksm_control) || styluscntl)?1:0;
    1157. 

  1157. 	    event->u.mouse.state |= (1<<(7+event->u.mouse.button));
    1158. 

  1158. 	}
    1159. 

  1159. 	if ( event->u.mouse.clicks>=2 &&
    1160. 

  1160. 		(pos/2 == cvt_scale/2 || pos/2 == cvt_rotate/2 || pos == cvt_3d_rotate ))
    1161. 

  1161. 	    CVDoTransform(cv,pos);
    1162. 

  1162.     } else if ( event->type == et_mousemove ) {
    1163. 

  1163. 	if ( cv->pressed_tool==cvt_none && pos!=cvt_none ) {
    1164. 

  1164. 	    /* Not pressed */
    1165. 

  1165. 	    char *msg = _(popupsres[pos]);
    1166. 

  1166. 	    if ( cv->b.sc->inspiro && hasspiro()) {
    1167. 

  1167. 		if ( pos==cvt_spirog2 )
    1168. 

  1168. 		    msg = _("Add a g2 curve point");
    1169. 

  1169. 		else if ( pos==cvt_spiroleft )
    1170. 

  1170. 		    msg = _("Add a prev constraint point (sometimes like a tangent)");
    1171. 

  1171. 		else if ( pos==cvt_spiroright )
    1172. 

  1172. 		    msg = _("Add a next constraint point (sometimes like a tangent)");
    1173. 

  1173. 	    }
    1174. 

  1174. 	    // We want to display the hotkey for the key in question if possible.
    1175. 

  1175. 	    char * mininame = HKTextInfoToUntranslatedTextFromTextInfo(&cvtoollist[pos].ti);
    1176. 

  1176. 	    char * menuname = NULL;
    1177. 

  1177. 	    Hotkey* toolhotkey = NULL;
    1178. 

  1178.             if (mininame != NULL) {
    1179. 

  1179.               if (asprintf(&menuname, "%s%s", "Point.Tools.", mininame) != -1) {
    1180. 

  1180. 	        toolhotkey = hotkeyFindByMenuPath(cv->gw, menuname);
    1181. 

  1181. 	        free(menuname); menuname = NULL;
    1182. 

  1182.               }
    1183. 

  1183.               free(mininame); mininame = NULL;
    1184. 

  1184.             }
    1185. 

  1185. 	    char * finalmsg = NULL;
    1186. 

  1186. 	    if (toolhotkey != NULL && asprintf(&finalmsg, "%s (%s)", msg, toolhotkey->text) != -1) {
    1187. 

  1187. 	      GGadgetPreparePopup8(cvtools, finalmsg);
    1188. 

  1188. 	      free(finalmsg); finalmsg = NULL;
    1189. 

  1189. 	    } else GGadgetPreparePopup8(cvtools, msg); // That's what we were doing before. Much simpler.
    1190. 

  1190. 	} else if ( pos!=cv->pressed_tool || cv->had_control != (((event->u.mouse.state&ksm_control) || styluscntl)?1:0) )
    1191. 

  1191. 	    cv->pressed_display = cvt_none;
    1192. 

  1192. 	else
    1193. 

  1193. 	    cv->pressed_display = cv->pressed_tool;
    1194. 

  1194.     } else if ( event->type == et_mouseup ) {
    1195. 

  1195. 	if ( pos==cvt_freehand && event->u.mouse.clicks==2 ) {
    1196. 

  1196. 	    FreeHandStrokeDlg(&expand);
    1197. 

  1197. 	} else if ( pos==cvt_pointer && event->u.mouse.clicks==2 ) {
    1198. 

  1198. 	    PointerDlg(cv);
    1199. 

  1199. 	} else if ( pos==cvt_ruler && event->u.mouse.clicks==2 ) {
    1200. 

  1200. 	    RulerDlg(cv);
    1201. 

  1201. 	} else if ( i==cvt_rect/2 && event->u.mouse.clicks==2 ) {
    1202. 

  1202. 	    ((j==0)?CVRectElipse:CVPolyStar)(cv);
    1203. 

  1203. 	    mi = i;
    1204. 

  1204. 	    if ( (j==0 && rectelipse) || (j==1 && polystar) )
    1205. 

  1205. 		++mi;
    1206. 

  1206. 	    pos = mi*2 + j;
    1207. 

  1207. 	    cv->pressed_tool = cv->pressed_display = pos;
    1208. 

  1208. 	}
    1209. 

  1209. 	if ( pos!=cv->pressed_tool || cv->had_control != (((event->u.mouse.state&ksm_control)||styluscntl)?1:0) )
    1210. 

  1210. 	    cv->pressed_tool = cv->pressed_display = cvt_none;
    1211. 

  1211. 	else {
    1212. 

  1212. 	    if ( event->u.mouse.device!=NULL && strcmp(event->u.mouse.device,"eraser")==0 )
    1213. 

  1213. 		cv->er_tool = pos;
    1214. 

  1214. 	    else if ( isstylus ) {
    1215. 

  1215. 	        if ( event->u.mouse.button==2 )
    1216. 

  1216. 		    /* Only thing that matters is touch which maps to button 1 */;
    1217. 

  1217. 		else if ( cv->had_control )
    1218. 

  1218. 		    cv->s2_tool = pos;
    1219. 

  1219. 		else
    1220. 

  1220. 		    cv->s1_tool = pos;
    1221. 

  1221. 	    } else if ( cv->had_control && event->u.mouse.button==2 )
    1222. 

  1222. 		cv->cb2_tool = cv_cb2_tool = pos;
    1223. 

  1223. 	    else if ( event->u.mouse.button==2 )
    1224. 

  1224. 		cv->b2_tool = cv_b2_tool = pos;
    1225. 

  1225. 	    else if ( cv->had_control ) {
    1226. 

  1226. 		cv->cb1_tool = cv_cb1_tool = pos;
    1227. 

  1227. 	    } else {
    1228. 

  1228. 		cv->b1_tool = cv_b1_tool = pos;
    1229. 

  1229. 	    }
    1230. 

  1230. 	    SavePrefs(true);
    1231. 

  1231. 	    cv->pressed_tool = cv->pressed_display = cvt_none;
    1232. 

  1232. 	}
    1233. 

  1233. 	GDrawRequestExpose(cvtools,NULL,false);
    1234. 

  1234. 	event->u.chr.state &= ~(1<<(7+event->u.mouse.button));
    1235. 

  1235.     }
    1236. 

  1236.     CVToolsSetCursor(cv,event->u.mouse.state,event->u.mouse.device);
    1237. 

  1237. }
    1238. 

  1238. 

  1239. static void PostCharToWindow(GWindow to, GEvent *e) {
    1240. 

  1240.     GPoint p;
    1241. 

  1241. 

  1242.     p.x = e->u.chr.x; p.y = e->u.chr.y;
    1243. 

  1243.     GDrawTranslateCoordinates(e->w,to,&p);
    1244. 

  1244.     e->u.chr.x = p.x; e->u.chr.y = p.y;
    1245. 

  1245.     e->w = to;
    1246. 

  1246.     GDrawPostEvent(e);
    1247. 

  1247. }
    1248. 

  1248. 

  1249. static int cvtools_e_h(GWindow gw, GEvent *event) {
    1250. 

  1250.     CharView *cv = (CharView *) GDrawGetUserData(gw);
    1251. 

  1251. 

  1252.     if ( event->type==et_destroy ) {
    1253. 

  1253. 	cvtools = NULL;
    1254. 

  1254. return( true );
    1255. 

  1255.     }
    1256. 

  1256. 

  1257.     if ( cv==NULL )
    1258. 

  1258. return( true );
    1259. 

  1259. 

  1260.     GGadgetPopupExternalEvent(event);
    1261. 

  1261.     switch ( event->type ) {
    1262. 

  1262.       case et_expose:
    1263. 

  1263. 	ToolsExpose(gw,cv,&event->u.expose.rect);
    1264. 

  1264.       break;
    1265. 

  1265.       case et_mousedown:
    1266. 

  1266. 	ToolsMouse(cv,event);
    1267. 

  1267.       break;
    1268. 

  1268.       case et_mousemove:
    1269. 

  1269. 	ToolsMouse(cv,event);
    1270. 

  1270.       break;
    1271. 

  1271.       case et_mouseup:
    1272. 

  1272. 	ToolsMouse(cv,event);
    1273. 

  1273.       break;
    1274. 

  1274.       case et_crossing:
    1275. 

  1275. 	cv->pressed_display = cvt_none;
    1276. 

  1276. 	CVToolsSetCursor(cv,event->u.mouse.state,NULL);
    1277. 

  1277.       break;
    1278. 

  1278.       case et_char: case et_charup:
    1279. 

  1279. 	if ( cv->had_control != ((event->u.chr.state&ksm_control)?1:0) )
    1280. 

  1280. 	    cv->pressed_display = cvt_none;
    1281. 

  1281. 	PostCharToWindow(cv->gw,event);
    1282. 

  1282.       break;
    1283. 

  1283.       case et_close:
    1284. 

  1284. 	GDrawSetVisible(gw,false);
    1285. 

  1285.       break;
    1286. 

  1286.     }
    1287. 

  1287. return( true );
    1288. 

  1288. }
    1289. 

  1289. 

  1290. GWindow CVMakeTools(CharView *cv) {
    1291. 

  1291.     GRect r;
    1292. 

  1292.     GWindowAttrs wattrs;
    1293. 

  1293.     FontRequest rq;
    1294. 

  1294. 

  1295.     if ( cvtools!=NULL )
    1296. 

  1296. return( cvtools );
    1297. 

  1297. 

  1298.     memset(&wattrs,0,sizeof(wattrs));
    1299. 

  1299.     wattrs.mask = wam_events|wam_cursor|wam_utf8_wtitle|wam_positioned|wam_isdlg;
    1300. 

  1300.     wattrs.event_masks = -1;
    1301. 

  1301.     wattrs.cursor = ct_mypointer;
    1302. 

  1302.     wattrs.positioned = true;
    1303. 

  1303.     wattrs.is_dlg = true;
    1304. 

  1304.     wattrs.utf8_window_title = _("Tools");
    1305. 

  1305. 

  1306.     r.width = CV_TOOLS_WIDTH; r.height = CV_TOOLS_HEIGHT;
    1307. 

  1307.     if ( cvtoolsoff.x==-9999 ) {
    1308. 

  1308. 	cvtoolsoff.x = -r.width-6; cvtoolsoff.y = cv->mbh+20;
    1309. 

  1309.     }
    1310. 

  1310.     r.x = cvtoolsoff.x; r.y = cvtoolsoff.y;
    1311. 

  1311.     if ( palettes_docked )
    1312. 

  1312. 	r.x = r.y = 0;
    1313. 

  1313.     cvtools = CreatePalette( cv->gw, &r, cvtools_e_h, NULL, &wattrs, cv->v );
    1314. 

  1314. 

  1315.     if ( GDrawRequestDeviceEvents(cvtools,input_em_cnt,input_em)>0 ) {
    1316. 

  1316. 	/* Success! They've got a wacom tablet */
    1317. 

  1317.     }
    1318. 

  1318. 

  1319.     if ( toolsfont==NULL ) {
    1320. 

  1320. 	memset(&rq,0,sizeof(rq));
    1321. 

  1321. 	rq.utf8_family_name = SANS_UI_FAMILIES;
    1322. 

  1322. 	rq.point_size = -10;
    1323. 

  1323. 	rq.weight = 400;
    1324. 

  1324. 	toolsfont = GDrawInstanciateFont(NULL,&rq);
    1325. 

  1325. 	toolsfont = GResourceFindFont("ToolsPalette.Font",toolsfont);
    1326. 

  1326.     }
    1327. 

  1327. 

  1328.     if ( cvvisible[1])
    1329. 

  1329. 	GDrawSetVisible(cvtools,true);
    1330. 

  1330. return( cvtools );
    1331. 

  1331. }
    1332. 

  1332. 

  1333. 

  1334.     /* ********************************************************* */
    1335. 

  1335.     /* ******************  Layers Palette  ********************* */
    1336. 

  1336.     /* ********************************************************* */
    1337. 

  1337. 

  1338. 

  1339. 

  1340. /* Create a layer thumbnail */
    1341. 

  1341. static BDFChar *BDFCharFromLayer(SplineChar *sc,int layer) {
    1342. 

  1342.     SplineChar dummy;
    1343. 

  1343.     memset(&dummy,0,sizeof(dummy));
    1344. 

  1344.     dummy.layer_cnt = 2;
    1345. 

  1345.     dummy.layers = sc->layers+layer-1;
    1346. 

  1346.     dummy.parent = sc->parent;
    1347. 

  1347. return( SplineCharAntiAlias(&dummy,ly_fore,24,4));
    1348. 

  1348. }
    1349. 

  1349. 

  1350. /* Update the type3 layers palette to the given character view */
    1351. 

  1351. static void CVLayers2Set(CharView *cv) {
    1352. 

  1352.     int i, top;
    1353. 

  1353. 

  1354.     GGadgetSetChecked(GWidgetGetControl(cvlayers2,CID_VFore),cv->showfore);
    1355. 

  1355.     GGadgetSetChecked(GWidgetGetControl(cvlayers2,CID_VBack),cv->showback[0]&1);
    1356. 

  1356.     GGadgetSetChecked(GWidgetGetControl(cvlayers2,CID_VGrid),cv->showgrids);
    1357. 

  1357. 

  1358.     int ly = 0;
    1359. 

  1359.     // We want to look at the unhandled layers.
    1360. 

  1360.     if (ly <= ly_back) ly = ly_back + 1;
    1361. 

  1361.     if (ly <= ly_fore) ly = ly_fore + 1;
    1362. 

  1362.     if (ly <= ly_grid) ly = ly_grid + 1;
    1363. 

  1363.     while (ly < cv->b.sc->parent->layer_cnt) {
    1364. 

  1364.       GGadget *tmpgadget = GWidgetGetControl(cvlayers2, CID_VBase + ly);
    1365. 

  1365.       if (tmpgadget != NULL) {
    1366. 

  1366.         // We set a low cap on the number of layers provisioned with check boxes for safety.
    1367. 

  1367.         // So it is important to check that this exists.
    1368. 

  1368.         GGadgetSetChecked(tmpgadget, cv->showback[ly>>5]&(1<<(ly&31)));
    1369. 

  1369.       }
    1370. 

  1370.       ly ++;
    1371. 

  1371.     }
    1372. 

  1372. 

  1373. 	 /* set old to NULL */
    1374. 

  1374.     layer2.offtop = 0;
    1375. 

  1375.     for ( i=2; i<layer2.current_layers; ++i ) {
    1376. 

  1376. 	BDFCharFree(layer2.layers[i]);
    1377. 

  1377. 	layer2.layers[i]=NULL;
    1378. 

  1378.     }
    1379. 

  1379. 

  1380. 	 /* reallocate enough space if necessary */
    1381. 

  1381.     if ( cv->b.sc->layer_cnt+1>=layer2.max_layers ) {
    1382. 

  1382. 	top = cv->b.sc->layer_cnt+10;
    1383. 

  1383. 	if ( layer2.layers==NULL )
    1384. 

  1384. 	    layer2.layers = calloc(top,sizeof(BDFChar *));
    1385. 

  1385. 	else {
    1386. 

  1386. 	    layer2.layers = realloc(layer2.layers,top*sizeof(BDFChar *));
    1387. 

  1387. 	    for ( i=layer2.current_layers; i<top; ++i )
    1388. 

  1388. 		layer2.layers[i] = NULL;
    1389. 

  1389. 	}
    1390. 

  1390. 	layer2.max_layers = top;
    1391. 

  1391.     }
    1392. 

  1392.     layer2.current_layers = cv->b.sc->layer_cnt+1;
    1393. 

  1393.     for ( i=ly_fore; i<cv->b.sc->layer_cnt; ++i )
    1394. 

  1394. 	layer2.layers[i+1] = BDFCharFromLayer(cv->b.sc,i);
    1395. 

  1395.     layer2.active = CVLayer(&cv->b)+1;
    1396. 

  1396. 

  1397.     GScrollBarSetBounds(GWidgetGetControl(cvlayers2,CID_SB),0,cv->b.sc->layer_cnt+1-2,
    1398. 

  1398. 	    CV_LAYERS2_VISLAYERS);
    1399. 

  1399.     if ( layer2.offtop>cv->b.sc->layer_cnt-1-CV_LAYERS2_VISLAYERS )
    1400. 

  1400. 	layer2.offtop = cv->b.sc->layer_cnt-1-CV_LAYERS2_VISLAYERS;
    1401. 

  1401.     if ( layer2.offtop<0 ) layer2.offtop = 0;
    1402. 

  1402.     GScrollBarSetPos(GWidgetGetControl(cvlayers2,CID_SB),layer2.offtop);
    1403. 

  1403. 

  1404.     GDrawRequestExpose(cvlayers2,NULL,false);
    1405. 

  1405. }
    1406. 

  1406. 

  1407. static void Layers2Expose(CharView *cv,GWindow pixmap,GEvent *event) {
    1408. 

  1408.     int i, ll;
    1409. 

  1409.     const char *str;
    1410. 

  1410.     GRect r;
    1411. 

  1411.     struct _GImage base;
    1412. 

  1412.     GImage gi;
    1413. 

  1413.     int as = (24*cv->b.sc->parent->ascent)/(cv->b.sc->parent->ascent+cv->b.sc->parent->descent);
    1414. 

  1414. 

  1415.     if ( event->u.expose.rect.y+event->u.expose.rect.height<CV_LAYERS2_HEADER_HEIGHT )
    1416. 

  1416. return;
    1417. 

  1417. 

  1418.     r.x = 30; r.width = layer2.sb_start-r.x;
    1419. 

  1419.     r.y = CV_LAYERS2_HEADER_HEIGHT;
    1420. 

  1420.     r.height = CV_LAYERS2_LINE_HEIGHT-CV_LAYERS2_HEADER_HEIGHT;
    1421. 

  1421.     GDrawFillRect(pixmap,&r,GDrawGetDefaultBackground(NULL));
    1422. 

  1422. 

  1423.     GDrawSetDither(NULL, false);	/* on 8 bit displays we don't want any dithering */
    1424. 

  1424. 

  1425.     memset(&gi,0,sizeof(gi));
    1426. 

  1426.     memset(&base,0,sizeof(base));
    1427. 

  1427.     gi.u.image = &base;
    1428. 

  1428.     base.image_type = it_index;
    1429. 

  1429.     base.clut = layer2.clut;
    1430. 

  1430.     base.trans = -1;
    1431. 

  1431.     GDrawSetFont(pixmap,layer2.font);
    1432. 

  1432. 

  1433.     for ( i=(event->u.expose.rect.y-CV_LAYERS2_HEADER_HEIGHT)/CV_LAYERS2_LINE_HEIGHT;
    1434. 

  1434. 	    i<(event->u.expose.rect.y+event->u.expose.rect.height+CV_LAYERS2_LINE_HEIGHT-1-CV_LAYERS2_HEADER_HEIGHT)/CV_LAYERS2_LINE_HEIGHT;
    1435. 

  1435. 	    ++i ) {
    1436. 

  1436. 	ll = i<2 ? i : i+layer2.offtop;
    1437. 

  1437. 	if ( ll==layer2.active ) {
    1438. 

  1438. 	    r.x = 30; r.width = layer2.sb_start-r.x;
    1439. 

  1439. 	    r.y = CV_LAYERS2_HEADER_HEIGHT + i*CV_LAYERS2_LINE_HEIGHT;
    1440. 

  1440. 	    r.height = CV_LAYERS2_LINE_HEIGHT;
    1441. 

  1441. 	    GDrawFillRect(pixmap,&r,GDrawGetDefaultForeground(NULL));
    1442. 

  1442. 	}
    1443. 

  1443. 	GDrawDrawLine(pixmap,r.x,CV_LAYERS2_HEADER_HEIGHT+i*CV_LAYERS2_LINE_HEIGHT,
    1444. 

  1444. 		r.x+r.width,CV_LAYERS2_HEADER_HEIGHT+i*CV_LAYERS2_LINE_HEIGHT,
    1445. 

  1445. 		0x808080);
    1446. 

  1446. 	if ( i==0 || i==1 ) {
    1447. 

  1447. 	    str = i==0?_("Guide") : _("Back");
    1448. 

  1448. 	    GDrawDrawText8(pixmap,r.x+2,CV_LAYERS2_HEADER_HEIGHT + i*CV_LAYERS2_LINE_HEIGHT + (CV_LAYERS2_LINE_HEIGHT-12)/2+12,
    1449. 

  1449. 		    (char *) str,-1,ll==layer2.active?0xffffff:GDrawGetDefaultForeground(NULL));
    1450. 

  1450. 	} else if ( layer2.offtop+i>=layer2.current_layers ) {
    1451. 

  1451.     break;
    1452. 

  1452. 	} else if ( layer2.layers[layer2.offtop+i]!=NULL ) {
    1453. 

  1453. #if 0
    1454. 

  1454. 	    // This is currently broken, and we do not have time to fix it.
    1455. 

  1455. 	    BDFChar *bdfc = layer2.layers[layer2.offtop+i];
    1456. 

  1456. 	    base.data = bdfc->bitmap;
    1457. 

  1457. 	    base.bytes_per_line = bdfc->bytes_per_line;
    1458. 

  1458. 	    base.width = bdfc->xmax-bdfc->xmin+1;
    1459. 

  1459. 	    base.height = bdfc->ymax-bdfc->ymin+1;
    1460. 

  1460. 	    GDrawDrawImage(pixmap,&gi,NULL,
    1461. 

  1461. 		    r.x+2+bdfc->xmin,
    1462. 

  1462. 		    CV_LAYERS2_HEADER_HEIGHT + i*CV_LAYERS2_LINE_HEIGHT+as-bdfc->ymax);
    1463. 

  1463. #else
    1464. 

  1464. 	    // This logic comes from CVInfoDrawText.
    1465. 

  1465. 	    const int layernamesz = 100;
    1466. 

  1466. 	    char layername[layernamesz+1];
    1467. 

  1467. 	    strncpy(layername,_("Guide"),layernamesz);
    1468. 

  1468. 	    int idx = layer2.offtop+i-1;
    1469. 

  1469. 	    if(idx >= 0 && idx < cv->b.sc->parent->layer_cnt) {
    1470. 

  1470. 	      strncpy(layername,cv->b.sc->parent->layers[idx].name,layernamesz);
    1471. 

  1471. 	    } else {
    1472. 

  1472. 	      fprintf(stderr, "Invalid layer!\n");
    1473. 

  1473. 	    }
    1474. 

  1474. 	    // And this comes from above.
    1475. 

  1475. 	    GDrawDrawText8(pixmap,r.x+2,CV_LAYERS2_HEADER_HEIGHT + i*CV_LAYERS2_LINE_HEIGHT + (CV_LAYERS2_LINE_HEIGHT-12)/2+12,
    1476. 

  1476. 		    (char *) layername,-1,ll==layer2.active?0xffffff:GDrawGetDefaultForeground(NULL));
    1477. 

  1477. #endif // 0
    1478. 

  1478. 	}
    1479. 

  1479.     }
    1480. 

  1480. }
    1481. 

  1481. 

  1482. // Frank changed the prefix from MID to MIDL in order to avert conflicts with values set in charview_private.h.
    1483. 

  1483. #define MIDL_LayerInfo	1
    1484. 

  1484. #define MIDL_NewLayer	2
    1485. 

  1485. #define MIDL_DelLayer	3
    1486. 

  1486. #define MIDL_First	4
    1487. 

  1487. #define MIDL_Earlier	5
    1488. 

  1488. #define MIDL_Later	6
    1489. 

  1489. #define MIDL_Last	7
    1490. 

  1490. #define MIDL_MakeLine 100
    1491. 

  1491. #define MIDL_MakeArc  200
    1492. 

  1492. #define MIDL_InsertPtOnSplineAt  2309
    1493. 

  1493. #define MIDL_NamePoint  2318
    1494. 

  1494. #define MIDL_NameContour  2319
    1495. 

  1495. 

  1496. static void CVLayer2Invoked(GWindow v, GMenuItem *mi, GEvent *e) {
    1497. 

  1497.     CharView *cv = (CharView *) GDrawGetUserData(v);
    1498. 

  1498.     Layer temp;
    1499. 

  1499.     int layer = CVLayer(&cv->b);
    1500. 

  1500.     SplineChar *sc = cv->b.sc;
    1501. 

  1501.     int i;
    1502. 

  1502.     char *buts[3];
    1503. 

  1503.     buts[0] = _("_Yes"); buts[1]=_("_No"); buts[2] = NULL;
    1504. 

  1504. 

  1505.     switch ( mi->mid ) {
    1506. 

  1506.       case MIDL_LayerInfo:
    1507. 

  1507. 	if ( !LayerDialog(cv->b.layerheads[cv->b.drawmode],cv->b.sc->parent))
    1508. 

  1508. return;
    1509. 

  1509.       break;
    1510. 

  1510.       case MIDL_NewLayer:
    1511. 

  1511. 	LayerDefault(&temp);
    1512. 

  1512. 	if ( !LayerDialog(&temp,cv->b.sc->parent))
    1513. 

  1513. return;
    1514. 

  1514. 	sc->layers = realloc(sc->layers,(sc->layer_cnt+1)*sizeof(Layer));
    1515. 

  1515. 	sc->layers[sc->layer_cnt] = temp;
    1516. 

  1516. 	cv->b.layerheads[dm_fore] = &sc->layers[sc->layer_cnt];
    1517. 

  1517. 	cv->b.layerheads[dm_back] = &sc->layers[ly_back];
    1518. 

  1518. 	++sc->layer_cnt;
    1519. 

  1519.       break;
    1520. 

  1520.       case MIDL_DelLayer:
    1521. 

  1521. 	if ( sc->layer_cnt==2 )		/* May not delete the last foreground layer */
    1522. 

  1522. return;
    1523. 

  1523. 	if ( gwwv_ask(_("Cannot Be Undone"),(const char **) buts,0,1,_("This operation cannot be undone, do it anyway?"))==1 )
    1524. 

  1524. return;
    1525. 

  1525. 	SplinePointListsFree(sc->layers[layer].splines);
    1526. 

  1526. 	RefCharsFree(sc->layers[layer].refs);
    1527. 

  1527. 	ImageListsFree(sc->layers[layer].images);
    1528. 

  1528. 	UndoesFree(sc->layers[layer].undoes);
    1529. 

  1529. 	UndoesFree(sc->layers[layer].redoes);
    1530. 

  1530. 	for ( i=layer+1; i<sc->layer_cnt; ++i )
    1531. 

  1531. 	    sc->layers[i-1] = sc->layers[i];
    1532. 

  1532. 	--sc->layer_cnt;
    1533. 

  1533. 	if ( layer==sc->layer_cnt )
    1534. 

  1534. 	    cv->b.layerheads[dm_fore] = &sc->layers[layer-1];
    1535. 

  1535.       break;
    1536. 

  1536.       case MIDL_First:
    1537. 

  1537. 	if ( layer==ly_fore )
    1538. 

  1538. return;
    1539. 

  1539. 	temp = sc->layers[layer];
    1540. 

  1540. 	for ( i=layer-1; i>=ly_fore; --i )
    1541. 

  1541. 	    sc->layers[i+1] = sc->layers[i];
    1542. 

  1542. 	sc->layers[i+1] = temp;
    1543. 

  1543. 	cv->b.layerheads[dm_fore] = &sc->layers[ly_fore];
    1544. 

  1544.       break;
    1545. 

  1545.       case MIDL_Earlier:
    1546. 

  1546. 	if ( layer==ly_fore )
    1547. 

  1547. return;
    1548. 

  1548. 	temp = sc->layers[layer];
    1549. 

  1549. 	sc->layers[layer] = sc->layers[layer-1];
    1550. 

  1550. 	sc->layers[layer-1] = temp;
    1551. 

  1551. 	cv->b.layerheads[dm_fore] = &sc->layers[layer-1];
    1552. 

  1552.       break;
    1553. 

  1553.       case MIDL_Later:
    1554. 

  1554. 	if ( layer==sc->layer_cnt-1 )
    1555. 

  1555. return;
    1556. 

  1556. 	temp = sc->layers[layer];
    1557. 

  1557. 	sc->layers[layer] = sc->layers[layer+1];
    1558. 

  1558. 	sc->layers[layer+1] = temp;
    1559. 

  1559. 	cv->b.layerheads[dm_fore] = &sc->layers[layer+1];
    1560. 

  1560.       break;
    1561. 

  1561.       case MIDL_Last:
    1562. 

  1562. 	if ( layer==sc->layer_cnt-1 )
    1563. 

  1563. return;
    1564. 

  1564. 	temp = sc->layers[layer];
    1565. 

  1565. 	for ( i=layer+1; i<sc->layer_cnt; ++i )
    1566. 

  1566. 	    sc->layers[i-1] = sc->layers[i];
    1567. 

  1567. 	sc->layers[i-1] = temp;
    1568. 

  1568. 	cv->b.layerheads[dm_fore] = &sc->layers[i-1];
    1569. 

  1569.       break;
    1570. 

  1570.     }
    1571. 

  1571.     CVLayers2Set(cv);
    1572. 

  1572.     CVCharChangedUpdate(&cv->b);
    1573. 

  1573. }
    1574. 

  1574. 

  1575. static void Layer2Menu(CharView *cv,GEvent *event, int nolayer) {
    1576. 

  1576.     GMenuItem mi[20];
    1577. 

  1577.     int i;
    1578. 

  1578.     static char *names[] = { N_("Layer Info..."), N_("New Layer..."), N_("Del Layer"), (char *) -1,
    1579. 

  1579. 	    N_("_First"), N_("_Earlier"), N_("L_ater"), N_("_Last"), NULL };
    1580. 

  1580.     static int mids[] = { MIDL_LayerInfo, MIDL_NewLayer, MIDL_DelLayer, -1,
    1581. 

  1581. 	    MIDL_First, MIDL_Earlier, MIDL_Later, MIDL_Last, 0 };
    1582. 

  1582.     int layer = CVLayer(&cv->b);
    1583. 

  1583. 

  1584.     memset(mi,'\0',sizeof(mi));
    1585. 

  1585.     for ( i=0; names[i]!=0; ++i ) {
    1586. 

  1586. 	if ( names[i]!=(char *) -1 ) {
    1587. 

  1587. 	    mi[i].ti.text = (unichar_t *) _(names[i]);
    1588. 

  1588. 	    mi[i].ti.text_is_1byte = true;
    1589. 

  1589. 	} else
    1590. 

  1590. 	    mi[i].ti.line = true;
    1591. 

  1591. 	mi[i].ti.fg = COLOR_DEFAULT;
    1592. 

  1592. 	mi[i].ti.bg = COLOR_DEFAULT;
    1593. 

  1593. 	mi[i].mid = mids[i];
    1594. 

  1594. 	mi[i].invoke = CVLayer2Invoked;
    1595. 

  1595. 	if ( mids[i]!=MIDL_NewLayer && nolayer )
    1596. 

  1596. 	    mi[i].ti.disabled = true;
    1597. 

  1597. 	if (( mids[i]==MIDL_First || mids[i]==MIDL_Earlier ) && layer==ly_fore )
    1598. 

  1598. 	    mi[i].ti.disabled = true;
    1599. 

  1599. 	if (( mids[i]==MIDL_Last || mids[i]==MIDL_Later ) && layer==cv->b.sc->layer_cnt-1 )
    1600. 

  1600. 	    mi[i].ti.disabled = true;
    1601. 

  1601. 	if ( mids[i]==MIDL_DelLayer && cv->b.sc->layer_cnt==2 )
    1602. 

  1602. 	    mi[i].ti.disabled = true;
    1603. 

  1603.     }
    1604. 

  1604.     GMenuCreatePopupMenu(cvlayers2,event, mi);
    1605. 

  1605. }
    1606. 

  1606. 

  1607. static void Layer2Scroll(CharView *cv, GEvent *event) {
    1608. 

  1608.     int off = 0;
    1609. 

  1609.     enum sb sbt = event->u.control.u.sb.type;
    1610. 

  1610. 

  1611.     if ( sbt==et_sb_top )
    1612. 

  1612. 	off = 0;
    1613. 

  1613.     else if ( sbt==et_sb_bottom )
    1614. 

  1614. 	off = cv->b.sc->layer_cnt-1-CV_LAYERS2_VISLAYERS;
    1615. 

  1615.     else if ( sbt==et_sb_up ) {
    1616. 

  1616. 	off = layer2.offtop-1;
    1617. 

  1617.     } else if ( sbt==et_sb_down ) {
    1618. 

  1618. 	off = layer2.offtop+1;
    1619. 

  1619.     } else if ( sbt==et_sb_uppage ) {
    1620. 

  1620. 	off = layer2.offtop-CV_LAYERS2_VISLAYERS+1;
    1621. 

  1621.     } else if ( sbt==et_sb_downpage ) {
    1622. 

  1622. 	off = layer2.offtop+CV_LAYERS2_VISLAYERS-1;
    1623. 

  1623.     } else /* if ( sbt==et_sb_thumb || sbt==et_sb_thumbrelease ) */ {
    1624. 

  1624. 	off = event->u.control.u.sb.pos;
    1625. 

  1625.     }
    1626. 

  1626.     if ( off>cv->b.sc->layer_cnt-1-CV_LAYERS2_VISLAYERS )
    1627. 

  1627. 	off = cv->b.sc->layer_cnt-1-CV_LAYERS2_VISLAYERS;
    1628. 

  1628.     if ( off<0 ) off=0;
    1629. 

  1629.     if ( off==layer2.offtop )
    1630. 

  1630. return;
    1631. 

  1631.     layer2.offtop = off;
    1632. 

  1632.     GScrollBarSetPos(GWidgetGetControl(cvlayers2,CID_SB),off);
    1633. 

  1633.     GDrawRequestExpose(cvlayers2,NULL,false);
    1634. 

  1634. }
    1635. 

  1635. 

  1636. static int cvlayers2_e_h(GWindow gw, GEvent *event) {
    1637. 

  1637.     CharView *cv = (CharView *) GDrawGetUserData(gw);
    1638. 

  1638. 

  1639.     if ( event->type==et_destroy ) {
    1640. 

  1640. 	cvlayers2 = NULL;
    1641. 

  1641. return( true );
    1642. 

  1642.     }
    1643. 

  1643. 

  1644.     if ( cv==NULL )
    1645. 

  1645. return( true );
    1646. 

  1646. 

  1647.     switch ( event->type ) {
    1648. 

  1648.       case et_close:
    1649. 

  1649. 	GDrawSetVisible(gw,false);
    1650. 

  1650.       break;
    1651. 

  1651.       case et_char: case et_charup:
    1652. 

  1652. 	PostCharToWindow(cv->gw,event);
    1653. 

  1653.       break;
    1654. 

  1654.       case et_expose:
    1655. 

  1655. 	Layers2Expose(cv,gw,event);
    1656. 

  1656.       break;
    1657. 

  1657.       case et_mousedown: {
    1658. 

  1658. 	int layer = (event->u.mouse.y-CV_LAYERS2_HEADER_HEIGHT)/CV_LAYERS2_LINE_HEIGHT;
    1659. 

  1659. 	if ( event->u.mouse.y>CV_LAYERS2_HEADER_HEIGHT ) {
    1660. 

  1660. 	    if ( layer<2 ) {
    1661. 

  1661. 		cv->b.drawmode = layer==0 ? dm_grid : dm_back;
    1662. 

  1662. 		layer2.active = layer;
    1663. 

  1663. 	    } else if ( layer-1+layer2.offtop >= cv->b.sc->layer_cnt ) {
    1664. 

  1664. 		if ( event->u.mouse.button==3 )
    1665. 

  1665. 		    Layer2Menu(cv,event,true);
    1666. 

  1666. 		else
    1667. 

  1667. 		    GDrawBeep(NULL);
    1668. 

  1668. return(true);
    1669. 

  1669. 	    } else {
    1670. 

  1670. 		layer2.active = layer+layer2.offtop;
    1671. 

  1671. 		cv->b.drawmode = dm_fore;
    1672. 

  1672. 		cv->b.layerheads[dm_fore] = &cv->b.sc->layers[layer-1+layer2.offtop];
    1673. 

  1673. 	    }
    1674. 

  1674. 	    GDrawRequestExpose(cvlayers2,NULL,false);
    1675. 

  1675. 	    GDrawRequestExpose(cv->v,NULL,false);
    1676. 

  1676. 	    GDrawRequestExpose(cv->gw,NULL,false);	/* the logo (where the scrollbars join) shows what layer we are in */
    1677. 

  1677. 	    if ( event->u.mouse.button==3 )
    1678. 

  1678. 		Layer2Menu(cv,event,cv->b.drawmode!=dm_fore);
    1679. 

  1679. 	    else if ( event->u.mouse.clicks==2 && cv->b.drawmode==dm_fore ) {
    1680. 

  1680. 		if ( LayerDialog(cv->b.layerheads[cv->b.drawmode],cv->b.sc->parent))
    1681. 

  1681. 		    CVCharChangedUpdate(&cv->b);
    1682. 

  1682. 	    }
    1683. 

  1683. 	}
    1684. 

  1684.       } break;
    1685. 

  1685.       case et_controlevent:
    1686. 

  1686. 	if ( event->u.control.subtype == et_radiochanged ) {
    1687. 

  1687. 	    enum drawmode dm = cv->b.drawmode;
    1688. 

  1688. 	    int tmpcid = -1;
    1689. 

  1689. 	    int tmplayer = -1;
    1690. 

  1690. 	    switch(GGadgetGetCid(event->u.control.g)) {
    1691. 

  1691. 	      case CID_VFore:
    1692. 

  1692. 		CVShows.showfore = cv->showfore = GGadgetIsChecked(event->u.control.g);
    1693. 

  1693. 		if ( CVShows.showback )
    1694. 

  1694. 		    cv->showback[0] |= 2;
    1695. 

  1695. 		else
    1696. 

  1696. 		    cv->showback[0] &= ~2;
    1697. 

  1697. 	      break;
    1698. 

  1698. 	      case CID_VBack:
    1699. 

  1699. 		CVShows.showback = GGadgetIsChecked(event->u.control.g);
    1700. 

  1700. 		if ( CVShows.showback )
    1701. 

  1701. 		    cv->showback[0] |= 1;
    1702. 

  1702. 		else
    1703. 

  1703. 		    cv->showback[0] &= ~1;
    1704. 

  1704. 		cv->back_img_out_of_date = true;
    1705. 

  1705. 	      break;
    1706. 

  1706. 	      case CID_VGrid:
    1707. 

  1707. 		CVShows.showgrids = cv->showgrids = GGadgetIsChecked(event->u.control.g);
    1708. 

  1708. 	      break;
    1709. 

  1709. 	      default:
    1710. 

  1710. 		tmpcid = GGadgetGetCid(event->u.control.g);
    1711. 

  1711. 		tmplayer = tmpcid - CID_VBase;
    1712. 

  1712. 		if (tmpcid < 0 || tmplayer < 0) break;
    1713. 

  1713. 		// We check that the layer is valid (since the code does not presently, as far as Frank knows, handle layer deletion).
    1714. 

  1714. 		// We also check that the CID is within the allocated range (although this may not be necessary since the checkbox would not exist otherwise).
    1715. 

  1715. 		if (tmplayer > 0 && tmplayer < 999 && tmplayer < cv->b.sc->parent->layer_cnt) {
    1716. 

  1716. 		  if (GGadgetIsChecked(event->u.control.g)) {
    1717. 

  1717. 		    cv->showback[tmplayer>>5]|=(1<<(tmplayer&31));
    1718. 

  1718. 		  } else {
    1719. 

  1719. 		    cv->showback[tmplayer>>5]&=~(1<<(tmplayer&31));
    1720. 

  1720. 		  }
    1721. 

  1721. 		}
    1722. 

  1722. 		break;
    1723. 

  1723. 	    }
    1724. 

  1724. 	    GDrawRequestExpose(cv->v,NULL,false);
    1725. 

  1725. 	    if ( dm!=cv->b.drawmode )
    1726. 

  1726. 		GDrawRequestExpose(cv->gw,NULL,false);	/* the logo (where the scrollbars join) shows what layer we are in */
    1727. 

  1727. 	} else
    1728. 

  1728. 	    Layer2Scroll(cv,event);
    1729. 

  1729.       break;
    1730. 

  1730.     }
    1731. 

  1731. return( true );
    1732. 

  1732. }
    1733. 

  1733. 

  1734. /* This is used for Type 3 fonts. CVMakeLayers is used for other fonts. */
    1735. 

  1735. static void CVMakeLayers2(CharView *cv) {
    1736. 

  1736.     GRect r;
    1737. 

  1737.     GWindowAttrs wattrs;
    1738. 

  1738.     GGadgetCreateData gcd[25];
    1739. 

  1739.     GTextInfo label[25];
    1740. 

  1740.     static GBox radio_box = { bt_none, bs_rect, 0, 0, 0, 0, 0, 0, 0, 0, COLOR_DEFAULT, COLOR_DEFAULT, 0, 0, 0, 0, 0, 0, 0 };
    1741. 

  1741.     FontRequest rq;
    1742. 

  1742.     int i;
    1743. 

  1743.     extern int _GScrollBar_Width;
    1744. 

  1744. 

  1745.     if ( layer2.clut==NULL )
    1746. 

  1746. 	layer2.clut = _BDFClut(4);
    1747. 

  1747.     if ( cvlayers2!=NULL )
    1748. 

  1748. return;
    1749. 

  1749.     memset(&wattrs,0,sizeof(wattrs));
    1750. 

  1750.     wattrs.mask = wam_events|wam_cursor|wam_utf8_wtitle|wam_positioned|wam_isdlg;
    1751. 

  1751.     wattrs.event_masks = -1;
    1752. 

  1752.     wattrs.cursor = ct_mypointer;
    1753. 

  1753.     wattrs.positioned = true;
    1754. 

  1754.     wattrs.is_dlg = true;
    1755. 

  1755.     wattrs.utf8_window_title = _("Layers");
    1756. 

  1756. 

  1757.     r.width = GGadgetScale(CV_LAYERS2_WIDTH); r.height = CV_LAYERS2_HEIGHT;
    1758. 

  1758.     if ( cvlayersoff.x==-9999 ) {
    1759. 

  1759. 	cvlayersoff.x = -r.width-6;
    1760. 

  1760. 	cvlayersoff.y = cv->mbh+CV_TOOLS_HEIGHT+45/*25*/;	/* 45 is right if there's decor, 25 when none. twm gives none, kde gives decor */
    1761. 

  1761.     }
    1762. 

  1762.     r.x = cvlayersoff.x; r.y = cvlayersoff.y;
    1763. 

  1763.     if ( palettes_docked ) { r.x = 0; r.y=CV_TOOLS_HEIGHT+2; }
    1764. 

  1764.     cvlayers2 = CreatePalette( cv->gw, &r, cvlayers2_e_h, NULL, &wattrs, cv->v );
    1765. 

  1765. 

  1766.     memset(&label,0,sizeof(label));
    1767. 

  1767.     memset(&gcd,0,sizeof(gcd));
    1768. 

  1768. 

  1769.     if ( layersfont==NULL ) {
    1770. 

  1770. 	memset(&rq,'\0',sizeof(rq));
    1771. 

  1771. 	rq.utf8_family_name = SANS_UI_FAMILIES;
    1772. 

  1772. 	rq.point_size = -12;
    1773. 

  1773. 	rq.weight = 400;
    1774. 

  1774. 	layersfont = GDrawInstanciateFont(cvlayers2,&rq);
    1775. 

  1775. 	layersfont = GResourceFindFont("LayersPalette.Font",layersfont);
    1776. 

  1776.     }
    1777. 

  1777. 

  1778.     for ( i=0; i<sizeof(label)/sizeof(label[0]); ++i )
    1779. 

  1779. 	label[i].font = layersfont;
    1780. 

  1780.     layer2.font = layersfont;
    1781. 

  1781. 

  1782.     gcd[0].gd.pos.width = GDrawPointsToPixels(cv->gw,_GScrollBar_Width);
    1783. 

  1783.     gcd[0].gd.pos.x = CV_LAYERS2_WIDTH-gcd[0].gd.pos.width;
    1784. 

  1784.     gcd[0].gd.pos.y = CV_LAYERS2_HEADER_HEIGHT+2*CV_LAYERS2_LINE_HEIGHT;
    1785. 

  1785.     gcd[0].gd.pos.height = CV_LAYERS2_HEIGHT-gcd[0].gd.pos.y;
    1786. 

  1786.     gcd[0].gd.flags = gg_enabled|gg_visible|gg_pos_in_pixels|gg_sb_vert;
    1787. 

  1787.     gcd[0].gd.cid = CID_SB;
    1788. 

  1788.     gcd[0].creator = GScrollBarCreate;
    1789. 

  1789.     layer2.sb_start = gcd[0].gd.pos.x;
    1790. 

  1790. 

  1791. /* GT: Abbreviation for "Visible" */
    1792. 

  1792.     label[1].text = (unichar_t *) _("V");
    1793. 

  1793.     label[1].text_is_1byte = true;
    1794. 

  1794.     gcd[1].gd.label = &label[1];
    1795. 

  1795.     gcd[1].gd.pos.x = 7; gcd[1].gd.pos.y = 5; 
    1796. 

  1796.     gcd[1].gd.flags = gg_enabled|gg_visible|gg_pos_in_pixels|gg_utf8_popup;
    1797. 

  1797.     gcd[1].gd.popup_msg = (unichar_t *) _("Is Layer Visible?");
    1798. 

  1798.     gcd[1].creator = GLabelCreate;
    1799. 

  1799. 

  1800.     label[2].text = (unichar_t *) _("Layer");
    1801. 

  1801.     label[2].text_is_1byte = true;
    1802. 

  1802.     gcd[2].gd.label = &label[2];
    1803. 

  1803.     gcd[2].gd.pos.x = 30; gcd[2].gd.pos.y = 5; 
    1804. 

  1804.     gcd[2].gd.flags = gg_enabled|gg_visible|gg_pos_in_pixels|gg_utf8_popup;
    1805. 

  1805.     gcd[2].gd.popup_msg = (unichar_t *) _("Is Layer Editable?");
    1806. 

  1806.     gcd[2].creator = GLabelCreate;
    1807. 

  1807. 

  1808.     gcd[3].gd.pos.x = 5; gcd[3].gd.pos.y = CV_LAYERS2_HEADER_HEIGHT+(CV_LAYERS2_LINE_HEIGHT-12)/2; 
    1809. 

  1809.     gcd[3].gd.flags = gg_enabled|gg_visible|gg_dontcopybox|gg_pos_in_pixels|gg_utf8_popup;
    1810. 

  1810.     gcd[3].gd.cid = CID_VGrid;
    1811. 

  1811.     gcd[3].gd.popup_msg = (unichar_t *) _("Is Layer Visible?");
    1812. 

  1812.     gcd[3].gd.box = &radio_box;
    1813. 

  1813.     gcd[3].creator = GCheckBoxCreate;
    1814. 

  1814. 

  1815.     gcd[4].gd.pos.x = 5; gcd[4].gd.pos.y = gcd[3].gd.pos.y+CV_LAYERS2_LINE_HEIGHT; 
    1816. 

  1816.     gcd[4].gd.flags = gg_enabled|gg_visible|gg_dontcopybox|gg_pos_in_pixels|gg_utf8_popup;
    1817. 

  1817.     gcd[4].gd.cid = CID_VBack;
    1818. 

  1818.     gcd[4].gd.popup_msg = (unichar_t *) _("Is Layer Visible?");
    1819. 

  1819.     gcd[4].gd.box = &radio_box;
    1820. 

  1820.     gcd[4].creator = GCheckBoxCreate;
    1821. 

  1821. 

  1822.     gcd[5].gd.pos.x = 5; gcd[5].gd.pos.y = gcd[4].gd.pos.y+CV_LAYERS2_LINE_HEIGHT; 
    1823. 

  1823.     gcd[5].gd.flags = gg_enabled|gg_visible|gg_dontcopybox|gg_pos_in_pixels|gg_utf8_popup;
    1824. 

  1824.     gcd[5].gd.cid = CID_VFore;
    1825. 

  1825.     gcd[5].gd.popup_msg = (unichar_t *) _("Is Layer Visible?");
    1826. 

  1826.     gcd[5].gd.box = &radio_box;
    1827. 

  1827.     gcd[5].creator = GCheckBoxCreate;
    1828. 

  1828. 

  1829.     int wi = 6; // Widget index.
    1830. 

  1830.     int ly = 0;
    1831. 

  1831.     // We want to look at the unhandled layers.
    1832. 

  1832.     if (ly <= ly_back) ly = ly_back + 1;
    1833. 

  1833.     if (ly <= ly_fore) ly = ly_fore + 1;
    1834. 

  1834.     if (ly <= ly_grid) ly = ly_grid + 1;
    1835. 

  1835.     while (ly < cv->b.sc->parent->layer_cnt && wi < 24) {
    1836. 

  1836.       gcd[wi].gd.pos.x = 5; gcd[wi].gd.pos.y = gcd[wi-1].gd.pos.y+CV_LAYERS2_LINE_HEIGHT; 
    1837. 

  1837.       gcd[wi].gd.flags = gg_enabled|gg_visible|gg_dontcopybox|gg_pos_in_pixels|gg_utf8_popup;
    1838. 

  1838.       gcd[wi].gd.cid = CID_VBase + ly; // There are plenty of CID values available for these above CID_VBase.
    1839. 

  1839.       gcd[wi].gd.popup_msg = (unichar_t *) _("Is Layer Visible?");
    1840. 

  1840.       gcd[wi].gd.box = &radio_box;
    1841. 

  1841.       gcd[wi].creator = GCheckBoxCreate;
    1842. 

  1842.       ly++;
    1843. 

  1843.       wi++;
    1844. 

  1844.     }
    1845. 

  1845. 

  1846.     if ( cv->showgrids ) gcd[3].gd.flags |= gg_cb_on;
    1847. 

  1847.     if ( cv->showback[0]&1 ) gcd[4].gd.flags |= gg_cb_on;
    1848. 

  1848.     if ( cv->showfore ) gcd[5].gd.flags |= gg_cb_on;
    1849. 

  1849. 

  1850.     GGadgetsCreate(cvlayers2,gcd);
    1851. 

  1851.     if ( cvvisible[0] )
    1852. 

  1852. 	GDrawSetVisible(cvlayers2,true);
    1853. 

  1853. }
    1854. 

  1854. 

  1855. static void LayersSwitch(CharView *cv) {
    1856. 

  1856. }
    1857. 

  1857. 

  1858. void SC_MoreLayers(SplineChar *sc, Layer *old) { /* We've added more layers */
    1859. 

  1859.     CharView *curcv, *cv;
    1860. 

  1860.     if ( sc->parent==NULL || !sc->parent->multilayer )
    1861. 

  1861. return;
    1862. 

  1862.     for ( cv=(CharView *) (sc->views); cv!=NULL ; cv=(CharView *) (cv->b.next) ) {
    1863. 

  1863. 	cv->b.layerheads[dm_fore] = &cv->b.sc->layers[cv->b.layerheads[dm_fore]-old];
    1864. 

  1864. 	cv->b.layerheads[dm_back] = &cv->b.sc->layers[ly_back];
    1865. 

  1865.     }
    1866. 

  1866.     if ( cvtools==NULL )
    1867. 

  1867. return;
    1868. 

  1868.     curcv = GDrawGetUserData(cvtools);
    1869. 

  1869.     if ( curcv==NULL || curcv->b.sc!=sc )
    1870. 

  1870. return;
    1871. 

  1871.     CVLayers2Set(curcv);
    1872. 

  1872. }
    1873. 

  1873. 

  1874. void SCLayersChange(SplineChar *sc) { /* many of the foreground layers need to be redrawn */
    1875. 

  1875.     CharView *curcv;
    1876. 

  1876.     if ( cvtools==NULL || !sc->parent->multilayer )
    1877. 

  1877. return;
    1878. 

  1878.     curcv = GDrawGetUserData(cvtools);
    1879. 

  1879.     if ( curcv==NULL || curcv->b.sc!=sc )
    1880. 

  1880. return;
    1881. 

  1881.     CVLayers2Set(curcv);
    1882. 

  1882. }
    1883. 

  1883. 

  1884. void CVLayerChange(CharView *cv) { /* Current layer needs to be redrawn */
    1885. 

  1885.     CharView *curcv;
    1886. 

  1886.     int layer;
    1887. 

  1887. 

  1888.     if ( cvtools==NULL  || !cv->b.sc->parent->multilayer )
    1889. 

  1889. return;
    1890. 

  1890.     curcv = GDrawGetUserData(cvtools);
    1891. 

  1891.     if ( curcv!=cv )
    1892. 

  1892. return;
    1893. 

  1893.     if ( cv->b.drawmode==dm_grid || cv->b.drawmode==dm_back )
    1894. 

  1894. return;
    1895. 

  1895.     layer = CVLayer(&cv->b);
    1896. 

  1896.     BDFCharFree(layer2.layers[layer+1]);
    1897. 

  1897.     layer2.layers[layer+1] = BDFCharFromLayer(cv->b.sc,layer);
    1898. 

  1898.     GDrawRequestExpose(cvlayers2,NULL,false);
    1899. 

  1899. }
    1900. 

  1900. 

  1901. /* Update the state of the controls of the non-type3 layers palette to the given character view */
    1902. 

  1902. /* New widgets are not allocated here. For that, see CVLCheckLayerCount(). */
    1903. 

  1903. static void CVLayers1Set(CharView *cv) {
    1904. 

  1904.     int i, top;
    1905. 

  1905. 

  1906.     GGadgetSetChecked(GWidgetGetControl(cvlayers,CID_VFore),cv->showfore);
    1907. 

  1907.     GGadgetSetChecked(GWidgetGetControl(cvlayers,CID_VBack),cv->showback[0]&1);
    1908. 

  1908.     GGadgetSetChecked(GWidgetGetControl(cvlayers,CID_VGrid),cv->showgrids);
    1909. 

  1909. 

  1910.      /* clear old layer previews */
    1911. 

  1911.     layerinfo.offtop = 0;
    1912. 

  1912.     for ( i=2; i<layerinfo.current_layers; ++i ) {
    1913. 

  1913. 	BDFCharFree(layerinfo.layers[i]);
    1914. 

  1914. 	layerinfo.layers[i]=NULL;
    1915. 

  1915.     }
    1916. 

  1916. 

  1917.      /* reallocate enough space if necessary */
    1918. 

  1918.     if ( cv->b.sc->layer_cnt+1>=layerinfo.max_layers ) {
    1919. 

  1919. 	top = cv->b.sc->layer_cnt+10;
    1920. 

  1920. 	if ( layerinfo.layers==NULL )
    1921. 

  1921. 	    layerinfo.layers = calloc(top,sizeof(BDFChar *));
    1922. 

  1922. 	else {
    1923. 

  1923. 	    layerinfo.layers = realloc(layerinfo.layers,top*sizeof(BDFChar *));
    1924. 

  1924. 	    for ( i=layerinfo.current_layers; i<top; ++i )
    1925. 

  1925. 		layerinfo.layers[i] = NULL;
    1926. 

  1926. 	}
    1927. 

  1927. 	layerinfo.max_layers = top;
    1928. 

  1928.     }
    1929. 

  1929.     layerinfo.current_layers = cv->b.sc->layer_cnt+1;
    1930. 

  1930.     for ( i=ly_fore; i<cv->b.sc->layer_cnt; ++i )
    1931. 

  1931. 	layerinfo.layers[i+1] = BDFCharFromLayer(cv->b.sc,i);
    1932. 

  1932.     layerinfo.active = CVLayer(&cv->b)+1;
    1933. 

  1933. 

  1934.     if ( layerinfo.visible_layers==0 ) {
    1935. 

  1935.         GRect size;
    1936. 

  1936.         GDrawGetSize(cvlayers,&size);
    1937. 

  1937.         layerinfo.visible_layers=(size.height-layer_header_height)/layer_height;
    1938. 

  1938.     }
    1939. 

  1939.     GScrollBarSetBounds(GWidgetGetControl(cvlayers,CID_SB),0,cv->b.sc->layer_cnt+1-2, layerinfo.visible_layers);
    1940. 

  1940.     if ( layerinfo.offtop>cv->b.sc->layer_cnt-1-layerinfo.visible_layers )
    1941. 

  1941.         layerinfo.offtop = cv->b.sc->layer_cnt-1-layerinfo.visible_layers;
    1942. 

  1942.     if ( layerinfo.offtop<0 ) layerinfo.offtop = 0;
    1943. 

  1943.     GScrollBarSetPos(GWidgetGetControl(cvlayers,CID_SB),layerinfo.offtop);
    1944. 

  1944. 

  1945.     for ( i=0; i<cv->b.sc->layer_cnt; i++ ) {
    1946. 

  1946.         GGadgetSetChecked(GWidgetGetControl(cvlayers,CID_VBase+i),cv->showback[i>>5]&(1<<(i&31)));
    1947. 

  1947.     }
    1948. 

  1948. 

  1949.     layerinfo.active = CVLayer(&cv->b); /* the index of the active layer */
    1950. 

  1950.     GDrawRequestExpose(cvlayers,NULL,false);
    1951. 

  1951. }
    1952. 

  1952. 

  1953. /* Update the layers palette to reflect the given character view. No new gadgets
    1954. 

  1954.  * are created or hid here, only the state of existing gadgets is changed.
    1955. 

  1955.  * New layer gadgets are created in CVLCheckLayerCount(). */
    1956. 

  1956. void CVLayersSet(CharView *cv) {
    1957. 

  1957.     if( cv )
    1958. 

  1958. 	onCollabSessionStateChanged( 0, cv->b.fv );
    1959. 

  1959.     
    1960. 

  1960.     if ( cv->b.sc->parent->multilayer ) {
    1961. 

  1961. 	CVLayers2Set(cv);
    1962. 

  1962. return;
    1963. 

  1963.     }
    1964. 

  1964.      /* This is for the non-type3 layers palette: */
    1965. 

  1965.     CVLayers1Set(cv);
    1966. 

  1966. }
    1967. 

  1967. 

  1968. /**
    1969. 

  1969.  * Get the offset at the right hand size of the eyeball to show/hide
    1970. 

  1970.  * a layer. This is the x offset where the Q/C indicators might be drawn.
    1971. 

  1971.  */
    1972. 

  1972. static int32 Layers_getOffsetAtRightOfViewLayer(CharView *cv)
    1973. 

  1973. {
    1974. 

  1974.     int32 ret = 64;
    1975. 

  1975.     GGadget *v = GWidgetGetControl(cvlayers,CID_VBack);
    1976. 

  1976.     if( v )
    1977. 

  1977.     {
    1978. 

  1978. 	GRect size;
    1979. 

  1979. 	GGadgetGetSize(v,&size);
    1980. 

  1980. 	ret = 7 + size.width;
    1981. 

  1981.     }
    1982. 

  1982.     return ret;
    1983. 

  1983. }
    1984. 

  1984. 

  1985. 

  1986.  /* Draw the fg/bg, cubic/quadratic columns, plus layer preview and label name */
    1987. 

  1987. static void LayersExpose(CharView *cv,GWindow pixmap,GEvent *event) {
    1988. 

  1988.     int i, ll, y;
    1989. 

  1989.     const char *str;
    1990. 

  1990.     GRect r;
    1991. 

  1991.     struct _GImage base;
    1992. 

  1992.     GImage gi;
    1993. 

  1993.     Color mocolor = ACTIVE_BORDER; /* mouse over color */
    1994. 

  1994.     int ww;
    1995. 

  1995. 

  1996.     int yt = .7*layer_height; /* vertical spacer to add when drawing text in the row */
    1997. 

  1997.     int column_width;
    1998. 

  1998.     int quadcol, fgcol, editcol;
    1999. 

  1999. 

  2000.     if ( event->u.expose.rect.y+event->u.expose.rect.height<layer_header_height )
    2001. 

  2001. return;
    2002. 

  2002. 

  2003.     int offsetAtRightOfViewLayer = Layers_getOffsetAtRightOfViewLayer(cv);
    2004. 

  2004.     column_width = layerinfo.column_width;
    2005. 

  2005.     
    2006. 

  2006.     GDrawSetDither(NULL, false);	/* on 8 bit displays we don't want any dithering */
    2007. 

  2007.     ww=layerinfo.sb_start;
    2008. 

  2008. 

  2009.     memset(&gi,0,sizeof(gi));
    2010. 

  2010.     memset(&base,0,sizeof(base));
    2011. 

  2011.     gi.u.image = &base;
    2012. 

  2012.     base.image_type = it_index;
    2013. 

  2013.     base.clut = layer2.clut;
    2014. 

  2014.     base.trans = -1;
    2015. 

  2015.     GDrawSetFont(pixmap,layerinfo.font);
    2016. 

  2016. 

  2017.     quadcol=fgcol=offsetAtRightOfViewLayer;
    2018. 

  2018.     if ( layerscols & LSHOW_CUBIC )
    2019. 

  2019.     {
    2020. 

  2020. 	/* show quad col */
    2021. 

  2021. 	quadcol = offsetAtRightOfViewLayer;
    2022. 

  2022. 	fgcol   = offsetAtRightOfViewLayer+column_width;
    2023. 

  2023.     } 
    2024. 

  2024.     if ( layerscols & LSHOW_FG )
    2025. 

  2025.     {
    2026. 

  2026. 	/* show fg col */
    2027. 

  2027. 	fgcol = quadcol+column_width;
    2028. 

  2028.     }
    2029. 

  2029.     // editcol is the X offset where the layer name label should be drawn
    2030. 

  2030.     editcol = fgcol+column_width;
    2031. 

  2031.     int bottomOfLast = 0;
    2032. 

  2032.     
    2033. 

  2033.      /* loop once per layer, where 0==guides, 1=back, 2=fore, etc */
    2034. 

  2034.     for ( i=(event->u.expose.rect.y-layer_header_height)/layer_height;
    2035. 

  2035. 	    i<(event->u.expose.rect.y+event->u.expose.rect.height+layer_height-layer_header_height)/layer_height;
    2036. 

  2036. 	    ++i ) {
    2037. 

  2037. 	ll = i-1+layerinfo.offtop;
    2038. 

  2038.         if ( ll>=cv->b.sc->layer_cnt || ll<-1 ) continue;
    2039. 

  2039. 

  2040.         y = layer_header_height + i*layer_height;
    2041. 

  2041. 	bottomOfLast = y + layer_height;
    2042. 

  2042.         if ( y<layer_header_height ) continue;
    2043. 

  2043. 

  2044.          /* draw quadratic/cubic toggle */
    2045. 

  2045.         if ( layerscols & LSHOW_CUBIC ) {
    2046. 

  2046.             if ( layerinfo.mo_layer==ll && layerinfo.mo_col==CID_QBase ) {
    2047. 

  2047.                 r.x = quadcol; r.width = column_width;
    2048. 

  2048.                 r.y = y;
    2049. 

  2049.                 r.height = layer_height;
    2050. 

  2050.                 GDrawFillRect(pixmap,&r,mocolor);
    2051. 

  2051.             }
    2052. 

  2052.             str = ( ll>=0 && ll<cv->b.sc->layer_cnt ? (cv->b.sc->layers[ll].order2? "Q" : "C") : " ");
    2053. 

  2053. 	    GDrawDrawText8(pixmap, quadcol, y + yt,
    2054. 

  2054. 		    (char *) str,-1,GDrawGetDefaultForeground(NULL));
    2055. 

  2055.         }
    2056. 

  2056. 

  2057.          /* draw fg/bg toggle */
    2058. 

  2058.         if ( layerscols & LSHOW_FG ) {
    2059. 

  2059.             if ( layerinfo.mo_layer==ll && layerinfo.mo_col==CID_FBase ) {
    2060. 

  2060.                 r.x = fgcol; r.width = column_width;
    2061. 

  2061.                 r.y = y;
    2062. 

  2062.                 r.height = layer_height;
    2063. 

  2063.                 GDrawFillRect(pixmap,&r,mocolor);
    2064. 

  2064.             }
    2065. 

  2065.             str = ( ll>=0 && ll<cv->b.sc->layer_cnt ? (cv->b.sc->layers[ll].background? "B" : "F") : "#");
    2066. 

  2066. 	    GDrawDrawText8(pixmap, fgcol, y + yt,
    2067. 

  2067. 		    (char *) str,-1,GDrawGetDefaultForeground(NULL));
    2068. 

  2068.         }
    2069. 

  2069. 

  2070.          /* draw layer thumbnail and label */
    2071. 

  2071. 	if ( ll==layerinfo.active ) {
    2072. 

  2072.             r.x = editcol; r.width = ww-r.x;
    2073. 

  2073. 	    r.y = y;
    2074. 

  2074. 	    r.height = layer_height;
    2075. 

  2075. 	    GDrawFillRect(pixmap,&r,GDrawGetDefaultForeground(NULL));
    2076. 

  2076. 	} else if ( layerinfo.mo_layer==ll && layerinfo.mo_col==CID_EBase ) {
    2077. 

  2077.             r.x = editcol; r.width = ww-r.x;
    2078. 

  2078.             r.y = y;
    2079. 

  2079.             r.height = layer_height;
    2080. 

  2080.             GDrawFillRect(pixmap,&r,mocolor);
    2081. 

  2081.         }
    2082. 

  2082.         r.x=editcol;
    2083. 

  2083. 	if ( ll==-1 || ll==0 || ll==1) {
    2084. 

  2084. 	    str = ll==-1 ? _("Guide") : (ll==0 ?_("Back") : _("Fore")) ;
    2085. 

  2085. 	    GDrawDrawText8(pixmap,r.x+2,y + yt,
    2086. 

  2086. 		    (char *) str,-1,ll==layerinfo.active?0xffffff:GDrawGetDefaultForeground(NULL));
    2087. 

  2087. 	} else if ( ll>=layerinfo.current_layers ) {
    2088. 

  2088.              break; /* no more layers to draw! */
    2089. 

  2089. 	} else if ( ll>=0 && layerinfo.layers[ll]!=NULL ) {
    2090. 

  2090. 	    BDFChar *bdfc = layerinfo.layers[ll];
    2091. 

  2091. 	    base.data = bdfc->bitmap;
    2092. 

  2092. 	    base.bytes_per_line = bdfc->bytes_per_line;
    2093. 

  2093. 	    base.width = bdfc->xmax-bdfc->xmin+1;
    2094. 

  2094. 	    base.height = bdfc->ymax-bdfc->ymin+1;
    2095. 

  2095. //	    GDrawDrawImage(pixmap,&gi,NULL,
    2096. 

  2096. //		    r.x+2+bdfc->xmin,
    2097. 

  2097. //		    y+as-bdfc->ymax);
    2098. 

  2098.             str = cv->b.sc->parent->layers[ll].name;
    2099. 

  2099.             if ( !str || !*str ) str="-";
    2100. 

  2100. 	    GDrawDrawText8(pixmap, r.x+2, y + yt,
    2101. 

  2101. 		        (char *) str,-1,ll==layerinfo.active?0xffffff:GDrawGetDefaultForeground(NULL));
    2102. 

  2102. 	}
    2103. 

  2103.     }
    2104. 

  2104. 

  2105.     if( bottomOfLast )
    2106. 

  2106.     {
    2107. 

  2107. 	GGadgetSetY(GWidgetGetControl(cvlayers,CID_AddLayer),    bottomOfLast + 2 );
    2108. 

  2108. 	GGadgetSetY(GWidgetGetControl(cvlayers,CID_RemoveLayer), bottomOfLast + 2 );
    2109. 

  2109. 	GGadgetSetY(GWidgetGetControl(cvlayers,CID_LayersMenu),  bottomOfLast + 2 );
    2110. 

  2110.     }
    2111. 

  2111.     
    2112. 

  2112. }
    2113. 

  2113. 

  2114. /* Remove the layer rename edit box. If save!=0, then record the text as the new layer name. */
    2115. 

  2115. static void CVLRemoveEdit(CharView *cv, int save) {
    2116. 

  2116.     if ( layerinfo.rename_active ) {
    2117. 

  2117. 	GGadget *g = GWidgetGetControl(cvlayers,CID_Edit);
    2118. 

  2118. 	const unichar_t *str = GGadgetGetTitle(g);
    2119. 

  2119. 	int l = layerinfo.active;
    2120. 

  2120. 

  2121. 	if ( save
    2122. 

  2122. 		&& layerinfo.active>=0 && str!=NULL && str[0]!='\0' 
    2123. 

  2123. 		&& uc_strcmp( str,cv->b.sc->parent->layers[l].name) ) {
    2124. 

  2124. 	    free( cv->b.sc->parent->layers[l].name );
    2125. 

  2125. 	    cv->b.sc->parent->layers[l].name = cu_copy( str );
    2126. 

  2126. 

  2127. 	    CVLCheckLayerCount(cv,true);
    2128. 

  2128. 	    CVLayersSet(cv);
    2129. 

  2129. 	}
    2130. 

  2130. 	GGadgetSetVisible(g,false);
    2131. 

  2131. 	GDrawRequestExpose(cvlayers,NULL,false);
    2132. 

  2132. 

  2133. 	layerinfo.rename_active = 0;
    2134. 

  2134. 	CVInfoDrawText(cv,cv->gw);
    2135. 

  2135.     }
    2136. 

  2136. }
    2137. 

  2137. 

  2138.  /* Make sure we've got the right number of gadgets in the layers palette, and that
    2139. 

  2139.   * they are positioned properly. Their state are updated in CVLayers1Set().
    2140. 

  2140.   * If resize, then make the palette fit the layers up to a max number of layers. */
    2141. 

  2141. static void CVLCheckLayerCount(CharView *cv, int resize) {
    2142. 

  2142. 

  2143.     SplineChar *sc = cv->b.sc;
    2144. 

  2144.     int i;
    2145. 

  2145.     GGadgetCreateData gcd[4];
    2146. 

  2146.     GTextInfo label[3];
    2147. 

  2147.     GRect size;
    2148. 

  2148.     int width;
    2149. 

  2149.     int maxwidth=0;
    2150. 

  2150.     int togsize=0;
    2151. 

  2151.     int x, y;
    2152. 

  2152.     int column_width = layerinfo.column_width;
    2153. 

  2153.     char namebuf[40];
    2154. 

  2154.     int viscol=0, quadcol, fgcol, editcol;
    2155. 

  2155.     extern int _GScrollBar_Width;
    2156. 

  2156.     int offsetAtRightOfViewLayer = Layers_getOffsetAtRightOfViewLayer(cv);
    2157. 

  2157. 

  2158.     if (layerinfo.rename_active) CVLRemoveEdit(cv,true);
    2159. 

  2159. 

  2160.     quadcol=fgcol=offsetAtRightOfViewLayer;
    2161. 

  2161.     if ( layerscols & LSHOW_CUBIC )
    2162. 

  2162.     {
    2163. 

  2163. 	quadcol = offsetAtRightOfViewLayer;
    2164. 

  2164. 	fgcol   = offsetAtRightOfViewLayer+column_width;
    2165. 

  2165.     }
    2166. 

  2166.     if ( layerscols & LSHOW_FG )
    2167. 

  2167.     {
    2168. 

  2168. 	fgcol = quadcol+column_width;
    2169. 

  2169.     }
    2170. 

  2170.     // editcol is the X offset where the layer name label should be drawn
    2171. 

  2171.     editcol = fgcol+column_width;
    2172. 

  2172. 

  2173.     /* First figure out if we need to create any new widgets. If we have more */
    2174. 

  2174.     /* widgets than we need, we just set them to be invisible.                */
    2175. 

  2175.     if ( sc->layer_cnt > layers_max ) {
    2176. 

  2176. 	memset(&label,0,sizeof(label));
    2177. 

  2177. 	memset(&gcd,0,sizeof(gcd));
    2178. 

  2178. 	for ( i=layers_max; i<sc->layer_cnt; ++i ) {
    2179. 

  2179. 	     /* for each new layer, create new widgets */
    2180. 

  2180. 

  2181. 	     /* Visibility toggle */
    2182. 

  2182. 	    gcd[0].gd.flags = gg_enabled|gg_utf8_popup;
    2183. 

  2183. 	    gcd[0].gd.cid = CID_VBase+i;
    2184. 

  2184. 	    gcd[0].gd.popup_msg = (unichar_t *) _("Is Layer Visible?");
    2185. 

  2185. 	    gcd[0].creator = GVisibilityBoxCreate;
    2186. 

  2186. 

  2187. 	    GGadgetsCreate(cvlayers,gcd);
    2188. 

  2188. 	    GVisibilityBoxSetToMinWH(GWidgetGetControl(cvlayers,CID_VBase+i));
    2189. 

  2189. 	}
    2190. 

  2190. 	layers_max = sc->layer_cnt;
    2191. 

  2191.     }
    2192. 

  2192. 

  2193.     /* Then position everything, and name it properly */
    2194. 

  2194. 

  2195.     GDrawSetFont(cvlayers,layerinfo.font); /* for width finding code, need this */
    2196. 

  2196. 

  2197.      /* First need to position the add, remove, and layers gadgets */
    2198. 

  2198.     GGadgetGetSize(GWidgetGetControl(cvlayers,CID_RemoveLayer),&size);
    2199. 

  2199.     x = 7+size.width;
    2200. 

  2200.     y = layer_header_height;
    2201. 

  2201.     GGadgetMove(GWidgetGetControl(cvlayers,CID_AddLayer), x, 5);
    2202. 

  2202.     GGadgetSetSize(GWidgetGetControl(cvlayers,CID_AddLayer),&size);
    2203. 

  2203.     GGadgetGetSize(GWidgetGetControl(cvlayers,CID_AddLayer),&size);
    2204. 

  2204.     x += size.width;
    2205. 

  2205.     GGadgetGetSize(GWidgetGetControl(cvlayers,CID_LayersMenu),&size);
    2206. 

  2206.     GGadgetMove(GWidgetGetControl(cvlayers,CID_LayersMenu), x+5, 5+(y-8-size.height)/2);
    2207. 

  2207.     maxwidth=x+5+size.width;
    2208. 

  2208. 

  2209.     if ( !resize )
    2210. 

  2210.     {
    2211. 

  2211.          /* adjust the number of layers that can be visible in the palette */
    2212. 

  2212.         GDrawGetSize(cvlayers,&size);
    2213. 

  2213.         layerinfo.visible_layers=(size.height-layer_header_height)/layer_height;
    2214. 

  2214.         if ( layerinfo.offtop+layerinfo.visible_layers>=sc->layer_cnt )
    2215. 

  2215.             layerinfo.offtop = sc->layer_cnt-layerinfo.visible_layers;
    2216. 

  2216.         if ( layerinfo.offtop<0 ) layerinfo.offtop=0;
    2217. 

  2217.     }
    2218. 

  2218.     if ( layerinfo.visible_layers<2 ) layerinfo.visible_layers=2;
    2219. 

  2219. 

  2220.      /* Now position each layer row */
    2221. 

  2221.     for ( i=-1; i<layers_max; ++i ) {
    2222. 

  2222. 	GGadget *v = GWidgetGetControl(cvlayers,CID_VBase+i);
    2223. 

  2223. 

  2224.         width=0;
    2225. 

  2225. 	togsize = editcol;
    2226. 

  2226. 	
    2227. 

  2227. 	if ( i>=0 && i<sc->layer_cnt ) {
    2228. 

  2228. 	    char *hasmn = strchr(sc->parent->layers[i].name,'_');
    2229. 

  2229. 	    if ( hasmn==NULL && i>=2 && i<9 && strlen(sc->parent->layers[i].name)<30 ) {
    2230. 

  2230. 		 /* For the first 10 or so layers, add a mnemonic like "(_3)" to the name label */
    2231. 

  2231. 		 /* if it does not already have a mnemonic.                                     */
    2232. 

  2232. 		/* sprintf(namebuf, "%s (_%d)", sc->parent->layers[i].name, i+1); */
    2233. 

  2233. 		sprintf(namebuf, "%s", sc->parent->layers[i].name);
    2234. 

  2234. 	    } else if ( hasmn==NULL ) {
    2235. 

  2235.                 sprintf(namebuf,"%s", i==-1 ? _("Guide") : (i==0 ?_("Back") : _("Fore")) );
    2236. 

  2236.             }
    2237. 

  2237.             width = GDrawGetText8Width(cvlayers, namebuf, -1);
    2238. 

  2238. 	    width += 10; // padding takes up some space.
    2239. 

  2239. 	    if ( width+togsize>maxwidth ) maxwidth = width + togsize;
    2240. 

  2240. 	} else if ( i==-1 ) {
    2241. 

  2241. 	    if ( width+togsize>maxwidth ) maxwidth = width + togsize;
    2242. 

  2242.         }
    2243. 

  2243. 

  2244. 	if ( i+1<layerinfo.offtop || i>=layerinfo.offtop+layerinfo.visible_layers ||
    2245. 

  2245. 		(sc->layer_cnt<=layerinfo.visible_layers && i>=sc->layer_cnt)) {
    2246. 

  2246.              /* layer is currently scrolled out of palette */
    2247. 

  2247. 	    GGadgetSetVisible(v,false);
    2248. 

  2248. 	} else {
    2249. 

  2249. 	    GGadgetMove(v,viscol ,y);
    2250. 

  2250. 	    GGadgetSetVisible(v,true);
    2251. 

  2251. 	    y += layer_height;
    2252. 

  2252. 	}
    2253. 

  2253.     }
    2254. 

  2254. 

  2255.      /* Update the scroll bar */
    2256. 

  2256.     if ( sc->layer_cnt+1<=layerinfo.visible_layers ) {
    2257. 

  2257.          /* don't need the scroll bar, so turn it off */
    2258. 

  2258. 	GGadgetSetVisible(GWidgetGetControl(cvlayers,CID_SB),false);
    2259. 

  2259.     } else {
    2260. 

  2260. 	if( !resize )
    2261. 

  2261. 	{
    2262. 

  2262. 	    GGadget *sb = GWidgetGetControl(cvlayers,CID_SB);
    2263. 

  2263. 	    maxwidth += 2 + GDrawPointsToPixels(cv->gw,_GScrollBar_Width);
    2264. 

  2264. 	    GScrollBarSetBounds(sb,0,sc->layer_cnt,layerinfo.visible_layers);
    2265. 

  2265. 	    GScrollBarSetPos(sb,cv->layers_off_top);
    2266. 

  2266. 	    GGadgetSetVisible(sb,true);
    2267. 

  2267. 	}
    2268. 

  2268.     }
    2269. 

  2269. 

  2270.      /* Resize the palette to fit */
    2271. 

  2271.     if ( resize )
    2272. 

  2272.     {
    2273. 

  2273.         y += GDrawPointsToPixels(NULL,3);
    2274. 

  2274.         GDrawGetSize(cvlayers,&size);
    2275. 

  2275. 	GDrawResize(cvlayers,maxwidth,y+layer_footer_height);
    2276. 

  2276.     }
    2277. 

  2277. 

  2278.     GDrawGetSize(cvlayers,&size);
    2279. 

  2279.     layerinfo.sb_start = size.width
    2280. 

  2280.                 - (sc->layer_cnt+1<=layerinfo.visible_layers ? 0 : GDrawPointsToPixels(cv->gw,_GScrollBar_Width));
    2281. 

  2281.     GGadget *sb = GWidgetGetControl(cvlayers,CID_SB);
    2282. 

  2282.     GGadgetResize(sb, GDrawPointsToPixels(cv->gw,_GScrollBar_Width), size.height-layer_header_height);
    2283. 

  2283.     GGadgetMove(sb,layerinfo.sb_start,layer_header_height);
    2284. 

  2284. 

  2285.     GDrawRequestExpose(cvlayers,NULL,false);
    2286. 

  2286. }
    2287. 

  2287. 

  2288. /* Respond to scroll events from cvlayers scrollbar. */
    2289. 

  2289. static void LayerScroll(CharView *cv, GEvent *event) {
    2290. 

  2290.     int off = 0;
    2291. 

  2291.     enum sb sbt = event->u.control.u.sb.type;
    2292. 

  2292. 

  2293.     if ( sbt==et_sb_top )
    2294. 

  2294. 	off = 0;
    2295. 

  2295.     else if ( sbt==et_sb_bottom )
    2296. 

  2296. 	off = cv->b.sc->layer_cnt-layerinfo.visible_layers;
    2297. 

  2297.     else if ( sbt==et_sb_up ) {
    2298. 

  2298. 	off = cv->layers_off_top-1;
    2299. 

  2299.     } else if ( sbt==et_sb_down ) {
    2300. 

  2300. 	off = cv->layers_off_top+1;
    2301. 

  2301.     } else if ( sbt==et_sb_uppage ) {
    2302. 

  2302. 	off = cv->layers_off_top-layerinfo.visible_layers+1;
    2303. 

  2303.     } else if ( sbt==et_sb_downpage ) {
    2304. 

  2304. 	off = cv->layers_off_top+layerinfo.visible_layers-1;
    2305. 

  2305.     } else /* if ( sbt==et_sb_thumb || sbt==et_sb_thumbrelease ) */ {
    2306. 

  2306. 	off = event->u.control.u.sb.pos;
    2307. 

  2307.     }
    2308. 

  2308.     if ( off>cv->b.sc->layer_cnt-layerinfo.visible_layers )
    2309. 

  2309. 	off = cv->b.sc->layer_cnt-layerinfo.visible_layers;
    2310. 

  2310.     if ( off<0 ) off=0;
    2311. 

  2311.     if ( off==cv->layers_off_top )
    2312. 

  2312. return;
    2313. 

  2313.     cv->layers_off_top = off;
    2314. 

  2314.     layerinfo.offtop = off;
    2315. 

  2315.     CVLCheckLayerCount(cv, false);
    2316. 

  2316.     GScrollBarSetPos(GWidgetGetControl(cvlayers,CID_SB),off);
    2317. 

  2317.     GDrawRequestExpose(cvlayers,NULL,false);
    2318. 

  2318. }
    2319. 

  2319. 

  2320. /* Layers palette menu ids */
    2321. 

  2321. #define LMID_LayerInfo	1
    2322. 

  2322. #define LMID_NewLayer	2
    2323. 

  2323. #define LMID_DelLayer	3
    2324. 

  2324. #define LMID_Fill       4
    2325. 

  2325. #define LMID_First	5
    2326. 

  2326. #define LMID_Up     	6
    2327. 

  2327. #define LMID_Down	7
    2328. 

  2328. #define LMID_Last	8
    2329. 

  2329. #define LMID_Foreground 9
    2330. 

  2330. #define LMID_Background 10
    2331. 

  2331. #define LMID_Cubic      11
    2332. 

  2332. #define LMID_Quadratic  12
    2333. 

  2333. #define LMID_ShowCubic  13
    2334. 

  2334. #define LMID_ShowFore   14
    2335. 

  2335. 

  2336. /* Return a unique layer name based on base.
    2337. 

  2337.  * This just appends a number to base until the name is not found. */
    2338. 

  2338. static char *UniqueLayerName(SplineChar *sc, const char *base)
    2339. 

  2339. {
    2340. 

  2340.     static char buffer[100];
    2341. 

  2341.     const char *basestr=base;
    2342. 

  2342.     int i=1, c;
    2343. 

  2343.     
    2344. 

  2344.     if ( basestr==NULL || basestr[0]=='\0' ) basestr=_("Layer");
    2345. 

  2345. 

  2346.     while (1) {
    2347. 

  2347.         if (i==1) sprintf( buffer,"%s",basestr );
    2348. 

  2348.         else sprintf( buffer,"%s %d",basestr, i );
    2349. 

  2349.         
    2350. 

  2350.         for (c=0; c<sc->layer_cnt; c++) {
    2351. 

  2351.             if (!strcmp(sc->parent->layers[c].name,buffer)) break;
    2352. 

  2352.         }
    2353. 

  2353. 

  2354.         if ( c==sc->layer_cnt ) break;
    2355. 

  2355.         i++;
    2356. 

  2356.     }
    2357. 

  2357. 

  2358.     return buffer;
    2359. 

  2359. }
    2360. 

  2360. 

  2361. /* Layers palette menu selection */
    2362. 

  2362. static void CVLayerInvoked(GWindow v, GMenuItem *mi, GEvent *e) {
    2363. 

  2363.     CharView *cv = (CharView *) GDrawGetUserData(v);
    2364. 

  2364.     int layer = CVLayer(&cv->b);
    2365. 

  2365.     SplineChar *sc = cv->b.sc;
    2366. 

  2366.     Layer temp;
    2367. 

  2367.     int i;
    2368. 

  2368.     char *buts[3];
    2369. 

  2369.     buts[0] = _("_Yes"); buts[1]=_("_No"); buts[2] = NULL;
    2370. 

  2370. 

  2371.     switch ( mi->mid ) {
    2372. 

  2372.       case LMID_Fill:
    2373. 

  2373.         cv->showfilled = !cv->showfilled;
    2374. 

  2374.         CVRegenFill(cv);
    2375. 

  2375.         GDrawRequestExpose(cv->v,NULL,false);
    2376. 

  2376.       break;
    2377. 

  2377. 

  2378.       case LMID_ShowCubic:
    2379. 

  2379.         layerscols=(layerscols&~LSHOW_CUBIC)|((layerscols&LSHOW_CUBIC)?0:1);
    2380. 

  2380.         CVLCheckLayerCount(cv, true);
    2381. 

  2381.       break;
    2382. 

  2382. 

  2383.       case LMID_ShowFore:
    2384. 

  2384.         layerscols=(layerscols&~LSHOW_FG)|((layerscols&LSHOW_FG)?0:2);
    2385. 

  2385.         CVLCheckLayerCount(cv, true);
    2386. 

  2386.       break;
    2387. 

  2387. 

  2388.       case LMID_Foreground:
    2389. 

  2389.         if ( layer>ly_fore && cv->b.sc->parent->layers[layer].background==1) {
    2390. 

  2390.             SFLayerSetBackground(cv->b.sc->parent,layer,0);
    2391. 

  2391. 	    GDrawRequestExpose(cvlayers,NULL,false);
    2392. 

  2392.         }
    2393. 

  2393.       break;
    2394. 

  2394. 

  2395.       case LMID_Background:
    2396. 

  2396.         if ( layer>=ly_fore && cv->b.sc->parent->layers[layer].background==0) {
    2397. 

  2397.             SFLayerSetBackground(cv->b.sc->parent,layer,1);
    2398. 

  2398. 	    GDrawRequestExpose(cvlayers,NULL,false);
    2399. 

  2399.         }
    2400. 

  2400.       break;
    2401. 

  2401. 

  2402.       case LMID_Cubic:
    2403. 

  2403.         if ( layer!=ly_grid && cv->b.sc->layers[layer].order2 ) {
    2404. 

  2404.             SFConvertLayerToOrder3(cv->b.sc->parent, layer);
    2405. 

  2405. 	    GDrawRequestExpose(cvlayers,NULL,false);
    2406. 

  2406.             cv->back_img_out_of_date = true;
    2407. 

  2407.         }
    2408. 

  2408.       break;
    2409. 

  2409. 

  2410.       case LMID_Quadratic:
    2411. 

  2411.         if ( layer!=ly_grid && !cv->b.sc->layers[layer].order2 ) {
    2412. 

  2412.             SFConvertLayerToOrder2(cv->b.sc->parent, layer);
    2413. 

  2413. 	    GDrawRequestExpose(cvlayers,NULL,false);
    2414. 

  2414.             cv->back_img_out_of_date = true;
    2415. 

  2415.         }
    2416. 

  2416.       break;
    2417. 

  2417. 

  2418.       case LMID_NewLayer:
    2419. 

  2419.         SFAddLayer(cv->b.sc->parent, /* font of the glyph in the charview */
    2420. 

  2420.                         UniqueLayerName(sc,_("Back")),     /* Name */
    2421. 

  2421.                         0,         /* 0=cubic, 1=quad */
    2422. 

  2422.                         1);       /* 1=back,  0=fore */
    2423. 

  2423. 

  2424.         layer=cv->b.sc->parent->layer_cnt-1;
    2425. 

  2425.         
    2426. 

  2426.         cv->showback[layer>>5] |=  (1<<(layer&31)); /* make it visible */
    2427. 

  2427.         CVLCheckLayerCount(cv, true); /* update widget existence */
    2428. 

  2428.         CVLayersSet(cv);       /* update widget state     */
    2429. 

  2429.       break;
    2430. 

  2430.       case LMID_DelLayer:
    2431. 

  2431.         layer = CVLayer((CharViewBase *) cv); /* the index of the active layer */
    2432. 

  2432.         if (layer==ly_fore || layer==ly_back || layer==ly_grid)
    2433. 

  2433. return;
    2434. 

  2434.         if ( gwwv_ask(_("Cannot Be Undone"),(const char **) buts,0,1,_("This operation cannot be undone, do it anyway?"))==1 )
    2435. 

  2435. return;
    2436. 

  2436.         SFRemoveLayer(cv->b.sc->parent, layer);
    2437. 

  2437.         CVLCheckLayerCount(cv, true); /* update widget existence */
    2438. 

  2438.         CVLayersSet(cv);       /* update widget state     */
    2439. 

  2439.       break;
    2440. 

  2440. 

  2441.       case LMID_First: /* move layer contents to top */
    2442. 

  2442. 	if ( layer==ly_fore )
    2443. 

  2443. return;
    2444. 

  2444. 	temp = sc->layers[layer];
    2445. 

  2445. 	for ( i=layer-1; i>=ly_fore; --i )
    2446. 

  2446. 	    sc->layers[i+1] = sc->layers[i];
    2447. 

  2447. 	sc->layers[i+1] = temp;
    2448. 

  2448. 	cv->b.layerheads[dm_fore] = &sc->layers[ly_fore];
    2449. 

  2449.       break;
    2450. 

  2450.       case LMID_Up: /* move layer contents one up */
    2451. 

  2451. 	if ( layer==ly_fore )
    2452. 

  2452. return;
    2453. 

  2453. 	temp = sc->layers[layer];
    2454. 

  2454. 	sc->layers[layer] = sc->layers[layer-1];
    2455. 

  2455. 	sc->layers[layer-1] = temp;
    2456. 

  2456. 	cv->b.layerheads[dm_fore] = &sc->layers[layer-1];
    2457. 

  2457.       break;
    2458. 

  2458.       case LMID_Down: /* move layer contents one down */
    2459. 

  2459. 	if ( layer==sc->layer_cnt-1 )
    2460. 

  2460. return;
    2461. 

  2461. 	temp = sc->layers[layer];
    2462. 

  2462. 	sc->layers[layer] = sc->layers[layer+1];
    2463. 

  2463. 	sc->layers[layer+1] = temp;
    2464. 

  2464. 	cv->b.layerheads[dm_fore] = &sc->layers[layer+1];
    2465. 

  2465.       break;
    2466. 

  2466.       case LMID_Last:
    2467. 

  2467. 	if ( layer==sc->layer_cnt-1 )
    2468. 

  2468. return;
    2469. 

  2469. 	temp = sc->layers[layer]; /* move layer contents to bottom */
    2470. 

  2470. 	for ( i=layer+1; i<sc->layer_cnt; ++i )
    2471. 

  2471. 	    sc->layers[i-1] = sc->layers[i];
    2472. 

  2472. 	sc->layers[i-1] = temp;
    2473. 

  2473. 	cv->b.layerheads[dm_fore] = &sc->layers[i-1];
    2474. 

  2474.       break;
    2475. 

  2475.     }
    2476. 

  2476.     CVLayersSet(cv);
    2477. 

  2477.     CVCharChangedUpdate(&cv->b);
    2478. 

  2478. }
    2479. 

  2479. 

  2480. /* Pop up the layers palette context menu */
    2481. 

  2481. static void LayerMenu(CharView *cv,GEvent *event, int nolayer) {
    2482. 

  2482.     GMenuItem mi[20];
    2483. 

  2483.     int i;
    2484. 

  2484.     static char *names[] = {
    2485. 

  2485.                      /*N_("Rename Layer..."),*/
    2486. 

  2486.                      N_("New Layer"),
    2487. 

  2487.                      N_("Del Layer"),
    2488. 

  2488.                      (char *) -1,
    2489. 

  2489.                      N_("Shift Contents To _First"),
    2490. 

  2490.                      N_("Shift Contents _Up"),
    2491. 

  2491.                      N_("Shift Contents _Down"),
    2492. 

  2492.                      N_("Shift Contents To _Last"),
    2493. 

  2493.                      (char *) -1,
    2494. 

  2494.                      N_("Make Foreground"),/* or N_("Make Background"), */
    2495. 

  2495.                      N_("Make Cubic"),     /* or N_("Make Quadratic"),  */
    2496. 

  2496.                      (char *) -1,
    2497. 

  2497.                      N_("Fill"),
    2498. 

  2498.                      (char *) -1,
    2499. 

  2499.                      N_("Show Cubic Column"),
    2500. 

  2500.                      N_("Show Fore/Back Column"),
    2501. 

  2501.                      NULL,
    2502. 

  2502.                     };
    2503. 

  2503.     static int mids[] = {
    2504. 

  2504.                      /*LMID_RenameLayer,*/
    2505. 

  2505.                      LMID_NewLayer,
    2506. 

  2506.                      LMID_DelLayer,
    2507. 

  2507.                      -1,
    2508. 

  2508.                      LMID_First,
    2509. 

  2509.                      LMID_Up,
    2510. 

  2510.                      LMID_Down,
    2511. 

  2511.                      LMID_Last,
    2512. 

  2512.                      -1,
    2513. 

  2513.                      LMID_Foreground, /* or LMID_Background, */
    2514. 

  2514.                      LMID_Cubic,      /* or LMID_Quadratic,  */
    2515. 

  2515.                      -1,
    2516. 

  2516.                      LMID_Fill,
    2517. 

  2517.                      -1,
    2518. 

  2518.                      LMID_ShowCubic,
    2519. 

  2519.                      LMID_ShowFore,
    2520. 

  2520.                      0
    2521. 

  2521.                     };
    2522. 

  2522.     int layer = CVLayer(&cv->b);
    2523. 

  2523. 

  2524.     memset(mi,'\0',sizeof(mi));
    2525. 

  2525.     for ( i=0; names[i]!=0; ++i ) {
    2526. 

  2526. 	if ( names[i]!=(char *) -1 ) {
    2527. 

  2527. 	    mi[i].ti.text = (unichar_t *) _(names[i]);
    2528. 

  2528. 	    mi[i].ti.text_is_1byte = true;
    2529. 

  2529. 	    mi[i].ti.text_in_resource = true;
    2530. 

  2530. 	} else
    2531. 

  2531. 	    mi[i].ti.line = true;
    2532. 

  2532. 

  2533. 	mi[i].ti.fg = COLOR_DEFAULT;
    2534. 

  2534. 	mi[i].ti.bg = COLOR_DEFAULT;
    2535. 

  2535. 	mi[i].mid = mids[i];
    2536. 

  2536. 	mi[i].invoke = CVLayerInvoked;
    2537. 

  2537. 

  2538. 	/*if ( mids[i]!=LMID_NewLayer && nolayer )
    2539. 

  2539. 	    mi[i].ti.disabled = true;*/
    2540. 

  2540. 

  2541. 	if ( ( mids[i]==LMID_First || mids[i]==LMID_Up ) && ( layer==-1 || layer==0) )
    2542. 

  2542. 	    mi[i].ti.disabled = true;
    2543. 

  2543. 

  2544.         else if ( ( mids[i]==LMID_Last || mids[i]==LMID_Down ) && (layer==ly_grid || layer==cv->b.sc->layer_cnt-1) )
    2545. 

  2545. 	    mi[i].ti.disabled = true;
    2546. 

  2546. 

  2547.         else if ( mids[i]==LMID_DelLayer && ( layer<2 || cv->b.sc->layer_cnt==2) )
    2548. 

  2548. 	    mi[i].ti.disabled = true;
    2549. 

  2549. 

  2550.         else if ( mids[i]==LMID_Fill ) {
    2551. 

  2551.             mi[i].ti.checkable = 1;
    2552. 

  2552.             mi[i].ti.checked = cv->showfilled;
    2553. 

  2553. 

  2554.         } else if ( mids[i]==LMID_Foreground ) {
    2555. 

  2555.             if ( layer>=0 ) {
    2556. 

  2556.                 if ( ! cv->b.sc->layers[layer].background ) {
    2557. 

  2557.                     mi[i].mid = LMID_Background;
    2558. 

  2558.                     mi[i].ti.text = (unichar_t *) _("Make Background");
    2559. 

  2559.                 }
    2560. 

  2560.             } else {
    2561. 

  2561. 	        mi[i].ti.disabled = true;
    2562. 

  2562.             }
    2563. 

  2563.         } else if ( mids[i]==LMID_Cubic ) {
    2564. 

  2564.             if ( ! cv->b.sc->layers[layer].order2 ) {
    2565. 

  2565.                 mi[i].mid = LMID_Quadratic;
    2566. 

  2566.                 mi[i].ti.text = (unichar_t *) _("Make Quadratic");
    2567. 

  2567.             }
    2568. 

  2568. 

  2569.         } else if ( mids[i]==LMID_ShowCubic ) {
    2570. 

  2570.             mi[i].ti.checkable = 1;
    2571. 

  2571.             mi[i].ti.checked = (layerscols & LSHOW_CUBIC)?1:0;
    2572. 

  2572. 

  2573.         } else if ( mids[i]==LMID_ShowFore ) {
    2574. 

  2574.             mi[i].ti.checkable = 1;
    2575. 

  2575.             mi[i].ti.checked = (layerscols & LSHOW_FG)?1:0;
    2576. 

  2576.         }
    2577. 

  2577.     }
    2578. 

  2578.     GMenuCreatePopupMenu(cvlayers, event, mi);
    2579. 

  2579. }
    2580. 

  2580. 

  2581. /* Scan for which layer and column one clicks on in the layers 1 palette                */
    2582. 

  2582. /* -1 is the guides layer, 0 is default back, 1 default fore, etc.                      */
    2583. 

  2583. /* col will be set to either -1 for none, CID_VBase, CID_QBase, CID_FBase, or CID_EBase */
    2584. 

  2584. static int CVLScanForItem(int x, int y, int *col) {
    2585. 

  2585.     int l=(y-layer_header_height)/layer_height + layerinfo.offtop - 1;
    2586. 

  2586.     int viscol=0, quadcol, fgcol, editcol;
    2587. 

  2587.     int cw=layerinfo.column_width;
    2588. 

  2588. 

  2589.     quadcol=fgcol=viscol;
    2590. 

  2590.     if ( layerscols & LSHOW_CUBIC ) { quadcol = viscol+cw; fgcol=viscol+cw; }
    2591. 

  2591.     if ( layerscols & LSHOW_FG    ) { fgcol = quadcol+cw; }
    2592. 

  2592.     editcol=fgcol+cw;
    2593. 

  2593. 

  2594.     *col=-1;
    2595. 

  2595.     if ( x>0 && x<viscol+cw ) *col=CID_VBase;
    2596. 

  2596.     /**
    2597. 

  2597.      * The two below options, CID_QBase and CID_FBase allow the curve
    2598. 

  2598.      * type and foreground/background to be changed simply by clicking
    2599. 

  2599.      * on them. The cubic/quadratic and background/foreground
    2600. 

  2600.      * attributes should NOT be buttons that can change these
    2601. 

  2601.      * attributes, they should only SHOW the attribute. Changing the
    2602. 

  2602.      * attributes can be done in Font Info, Layers, and is done
    2603. 

  2603.      * infrequently and has a lot of implications so shouldn't be
    2604. 

  2604.      * easily done by mistake.
    2605. 

  2605.      */
    2606. 

  2606. //    else if ( (layerscols & LSHOW_CUBIC) && x>=quadcol && x<quadcol+cw ) *col=CID_QBase;
    2607. 

  2607. //    else if ( (layerscols & LSHOW_FG) && x>=fgcol && x<fgcol+cw ) *col=CID_FBase;
    2608. 

  2608.     else if ( x>=editcol ) *col=CID_EBase;
    2609. 

  2609. 

  2610.     return l;
    2611. 

  2611. }
    2612. 

  2612. 

  2613. /* Called in response to some event where we want to change the current layer. */
    2614. 

  2614. void CVLSelectLayer(CharView *cv, int layer) {
    2615. 

  2615.     enum drawmode dm = cv->b.drawmode;
    2616. 

  2616. 

  2617.     if ( layer<-1 || layer>=cv->b.sc->layer_cnt )
    2618. 

  2618. 	return;
    2619. 

  2619. 

  2620.     if ( layer==-1 ) {
    2621. 

  2621.         cv->b.drawmode = dm_grid;
    2622. 

  2622.         cv->lastselpt = NULL;
    2623. 

  2623.     } else {
    2624. 

  2624.         if ( layer==1 ) {
    2625. 

  2625.             cv->b.drawmode = dm_fore;
    2626. 

  2626.             cv->lastselpt = NULL;
    2627. 

  2627.         } else {
    2628. 

  2628.             cv->b.drawmode = dm_back;
    2629. 

  2629.             cv->b.layerheads[dm_back] = &cv->b.sc->layers[layer];
    2630. 

  2630.             cv->lastselpt = NULL;
    2631. 

  2631.         }
    2632. 

  2632. 

  2633.         CVDebugFree(cv->dv);
    2634. 

  2634.         SplinePointListsFree(cv->b.gridfit); cv->b.gridfit = NULL;
    2635. 

  2635.         FreeType_FreeRaster(cv->oldraster); cv->oldraster = NULL;
    2636. 

  2636.         FreeType_FreeRaster(cv->raster); cv->raster = NULL;
    2637. 

  2637.         cv->show_ft_results = false;
    2638. 

  2638.     }
    2639. 

  2639.     layerinfo.active = CVLayer(&cv->b); /* the index of the active layer */
    2640. 

  2640. 

  2641.     CVRegenFill(cv);
    2642. 

  2642.     GDrawRequestExpose(cv->v,NULL,false);
    2643. 

  2643.     if (cvlayers2) GDrawRequestExpose(cvlayers2,NULL,false);
    2644. 

  2644.     if (cvlayers)  GDrawRequestExpose(cvlayers,NULL,false);
    2645. 

  2645.     if ( dm!=cv->b.drawmode )
    2646. 

  2646.         GDrawRequestExpose(cv->gw,NULL,false); /* the logo (where the scrollbars join) shows what layer we are in */
    2647. 

  2647.     CVInfoDrawText(cv,cv->gw);
    2648. 

  2648. }
    2649. 

  2649. 

  2650. static int cvlayers_e_h(GWindow gw, GEvent *event) {
    2651. 

  2651.     CharView *cv = (CharView *) GDrawGetUserData(gw);
    2652. 

  2652.     char *buts[3];
    2653. 

  2653.     buts[0] = _("_Yes"); buts[1]=_("_No"); buts[2] = NULL;
    2654. 

  2654. 

  2655.     if ( event->type==et_destroy )
    2656. 

  2656.     {
    2657. 

  2657. 	cvlayers = NULL;
    2658. 

  2658. 	return( true );
    2659. 

  2659.     }
    2660. 

  2660. 

  2661.     if ( cv==NULL )
    2662. 

  2662. 	return( true );
    2663. 

  2663. 

  2664.     switch ( event->type ) {
    2665. 

  2665.       case et_close:
    2666. 

  2666. 	GDrawSetVisible(gw,false);
    2667. 

  2667.       break;
    2668. 

  2668.       case et_char: case et_charup:
    2669. 

  2669. 	if ( event->u.chr.keysym == GK_Return) {
    2670. 

  2670. 	    CVLRemoveEdit(cv, true);
    2671. 

  2671. 	} else if ( event->u.chr.keysym == GK_Escape) {
    2672. 

  2672. 	    CVLRemoveEdit(cv, false);
    2673. 

  2673. 	} else PostCharToWindow(cv->gw,event);
    2674. 

  2674.       break;
    2675. 

  2675.       case et_mousemove: {
    2676. 

  2676.         int l, col;
    2677. 

  2677. 

  2678.         l = CVLScanForItem(event->u.mouse.x,event->u.mouse.y, &col);
    2679. 

  2679.         if ( l!=layerinfo.mo_layer || col!=layerinfo.mo_col ) {
    2680. 

  2680.             layerinfo.mo_layer = l;
    2681. 

  2681.             layerinfo.mo_col = col;
    2682. 

  2682.             GDrawRequestExpose(cvlayers,NULL,false);
    2683. 

  2683.         }
    2684. 

  2684. 

  2685. return( true );
    2686. 

  2686. 

  2687.       } break;
    2688. 

  2688.       case et_mousedown: {
    2689. 

  2689.         if ( layerinfo.rename_active ) CVLRemoveEdit(cv, true);
    2690. 

  2690.       } break;
    2691. 

  2691.       case et_mouseup: {
    2692. 

  2692.         int l, x, cid, h;
    2693. 

  2693.         GGadget *g;
    2694. 

  2694.         l = CVLScanForItem(event->u.mouse.x,event->u.mouse.y, &cid);
    2695. 

  2695. 

  2696.         if ( cid==CID_EBase && l>=-1 && l<cv->b.sc->layer_cnt )
    2697. 

  2697. 	{
    2698. 

  2698. 	    /* Need to check for this BEFORE checking for right click! */
    2699. 

  2699.             if ( event->u.mouse.button==1 && event->u.mouse.clicks==2 )
    2700. 

  2700. 	    {
    2701. 

  2701. 		 /* bring up edit box for layer name */
    2702. 

  2702. 

  2703.                 if ( l<2 )
    2704. 

  2704. 		    return ( true );
    2705. 

  2705. 

  2706.                 x = 7+(1+((layerscols&LSHOW_CUBIC)?1:0)+((layerscols&LSHOW_FG)?1:0))*layerinfo.column_width;
    2707. 

  2707.                 g = GWidgetGetControl(cvlayers,CID_Edit);
    2708. 

  2708. 		h = 1.5*layer_height;
    2709. 

  2709. 

  2710.                 GGadgetResize(g, layerinfo.sb_start-x, h);
    2711. 

  2711.                 GGadgetMove(g, x,layer_header_height+(l+1.5+layerinfo.offtop)*layer_height-h/2);
    2712. 

  2712.                 GGadgetSetVisible(g,true);
    2713. 

  2713.                 /* GGadgetSetTitle8((GTextField*)g, cv->b.sc->parent->layers[l].name); */
    2714. 

  2714.                 GGadgetSetTitle8(g, cv->b.sc->parent->layers[l].name);
    2715. 

  2715. 

  2716. 		layerinfo.active=l;
    2717. 

  2717.                 layerinfo.rename_active=1;
    2718. 

  2718.                 return ( true );
    2719. 

  2719.             }
    2720. 

  2720. 

  2721.             CVLSelectLayer(cv, l);
    2722. 

  2722.         }
    2723. 

  2723. 

  2724.          /* right click to pop up menu */
    2725. 

  2725. 	if ( event->u.mouse.button==3 ) {
    2726. 

  2726. 	    LayerMenu(cv,event,true);
    2727. 

  2727. 	    return(true);
    2728. 

  2728.         }
    2729. 

  2729. 

  2730.          /* otherwise, deal with clicking up on the various controls */
    2731. 

  2731.         if ( l<-1 || l>=cv->b.sc->layer_cnt)
    2732. 

  2732. 	    return (true);
    2733. 

  2733. 

  2734.         if ( cid==CID_QBase) {
    2735. 

  2735.             if (l>=0) { /* don't try to adjust if calling for guides layer */
    2736. 

  2736.                 if (cv->b.sc->layers[l].order2)
    2737. 

  2737.                     SFConvertLayerToOrder3(cv->b.sc->parent, l);
    2738. 

  2738.                 else
    2739. 

  2739.                     SFConvertLayerToOrder2(cv->b.sc->parent, l);
    2740. 

  2740.                 cv->back_img_out_of_date = true;
    2741. 

  2741. 	        GDrawRequestExpose(cvlayers,NULL,false);
    2742. 

  2742.                 GDrawRequestExpose(cv->v,NULL,false);
    2743. 

  2743.             }
    2744. 

  2744.         } else if ( cid==CID_FBase) {
    2745. 

  2745.             if (l>1) { /* don't try to adjust if calling guides, default fore or back layer */
    2746. 

  2746.                 if (cv->b.sc->layers[l].background)
    2747. 

  2747.                     SFLayerSetBackground(cv->b.sc->parent,l,0);
    2748. 

  2748.                 else
    2749. 

  2749.                     SFLayerSetBackground(cv->b.sc->parent,l,1);
    2750. 

  2750. 	        GDrawRequestExpose(cvlayers,NULL,false);
    2751. 

  2751.                 GDrawRequestExpose(cv->v,NULL,false);
    2752. 

  2752.             }
    2753. 

  2753.         }
    2754. 

  2754.       } break; /* case et_mouseup */
    2755. 

  2755.       case et_expose:
    2756. 

  2756. 	LayersExpose(cv,gw,event);
    2757. 

  2757.       break;
    2758. 

  2758.       case et_resize:
    2759. 

  2759.         if ( event->u.resize.sized ) {
    2760. 

  2760.             CVLCheckLayerCount(cv,false); /* update widget existence, but do not resize */
    2761. 

  2761.         }
    2762. 

  2762.       break;
    2763. 

  2763.       case et_controlevent:
    2764. 

  2764. 	if ( event->u.control.subtype == et_buttonactivate ) {
    2765. 

  2765. 	    int cid = GGadgetGetCid(event->u.control.g);
    2766. 

  2766. 	    int layer;
    2767. 

  2767. 

  2768. 	    switch( cid ) {
    2769. 

  2769. 	      case CID_AddLayer: {
    2770. 

  2770.                 SplineChar *sc = cv->b.sc;
    2771. 

  2771. 

  2772. 		 /* This adds a new layer to the end of the current layers list.
    2773. 

  2773. 		  * Somehow it is created as an invisible layer. */
    2774. 

  2774. 		SFAddLayer(cv->b.sc->parent, /* font of the glyph in the charview */
    2775. 

  2775. 				UniqueLayerName(sc,_("Back")),     /* Name */
    2776. 

  2776. 				0,         /* 0=cubic, 1=quad */
    2777. 

  2777. 				1);       /* 1=back,  0=fore */
    2778. 

  2778. 

  2779. 		layer=cv->b.sc->parent->layer_cnt-1;
    2780. 

  2780. 		
    2781. 

  2781. 		cv->showback[layer>>5] |=  (1<<(layer&31)); /* make it visible */
    2782. 

  2782. 		CVLCheckLayerCount(cv,true); /* update widget existence */
    2783. 

  2783. 		CVLayersSet(cv);       /* update widget state     */
    2784. 

  2784.               } break;
    2785. 

  2785. 	      case CID_RemoveLayer:
    2786. 

  2786. 		layer = CVLayer((CharViewBase *) cv); /* the index of the active layer */
    2787. 

  2787.                 if (layer==ly_fore || layer==ly_back || layer==ly_grid)
    2788. 

  2788. return ( true );
    2789. 

  2789. 	        if ( gwwv_ask(_("Cannot Be Undone"),(const char **) buts,0,1,_("This operation cannot be undone, do it anyway?"))==1 )
    2790. 

  2790. return ( true );
    2791. 

  2791.                 SFRemoveLayer(cv->b.sc->parent, layer);
    2792. 

  2792.                 CVLCheckLayerCount(cv,true); /* update widget existence */
    2793. 

  2793.                 CVLayersSet(cv);       /* update widget state     */
    2794. 

  2794. 	      break;
    2795. 

  2795. 	      case CID_RenameLayer: {
    2796. 

  2796. 		/* *** */
    2797. 

  2797.                 int x = 7+(1+((layerscols&LSHOW_CUBIC)?1:0)+((layerscols&LSHOW_FG)?1:0))*layerinfo.column_width;
    2798. 

  2798.                 GGadget *g = GWidgetGetControl(cvlayers,CID_Edit);
    2799. 

  2799. 		layer = CVLayer((CharViewBase *) cv); /* the index of the active layer */
    2800. 

  2800. 		/* layer = layerinfo.active */ /* the index of the active layer */
    2801. 

  2801. 

  2802.                 GGadgetResize(g, layerinfo.sb_start-x,1.5*layer_height);
    2803. 

  2803.                 GGadgetMove(g, x,layer_header_height+(layer+1+layerinfo.offtop)*layer_height);
    2804. 

  2804.                 GGadgetSetVisible(g,true);
    2805. 

  2805.                 GGadgetSetTitle8(g, cv->b.sc->parent->layers[layer].name);
    2806. 

  2806. 

  2807.                 layerinfo.rename_active=1;
    2808. 

  2808. 

  2809. 		CVLCheckLayerCount(cv,true); /* update widget existence */
    2810. 

  2810. 		CVLayersSet(cv);       /* update widget state     */
    2811. 

  2811. 		GDrawRequestExpose(cvtools,NULL,false);
    2812. 

  2812. 		
    2813. 

  2813.               } break;
    2814. 

  2814. 	    }
    2815. 

  2815.         } else if ( event->u.control.subtype == et_radiochanged ) {
    2816. 

  2816. 	    enum drawmode dm = cv->b.drawmode;
    2817. 

  2817. 	    int cid = GGadgetGetCid(event->u.control.g);
    2818. 

  2818. 

  2819. 	    switch( cid ) {
    2820. 

  2820. 	      case CID_VFore:
    2821. 

  2821. 		CVShows.showfore = cv->showfore = GGadgetIsChecked(event->u.control.g);
    2822. 

  2822.                 GDrawRequestExpose(cv->v,NULL,false);
    2823. 

  2823. 	      break;
    2824. 

  2824. 	      case CID_VBack:
    2825. 

  2825. 		CVShows.showback = GGadgetIsChecked(event->u.control.g);
    2826. 

  2826. 		if ( CVShows.showback )
    2827. 

  2827. 		    cv->showback[0] |= 1;
    2828. 

  2828. 		else
    2829. 

  2829. 		    cv->showback[0] &= ~1;
    2830. 

  2830. 		cv->back_img_out_of_date = true;
    2831. 

  2831.                 GDrawRequestExpose(cv->v,NULL,false);
    2832. 

  2832. 	      break;
    2833. 

  2833. 	      case CID_VGrid:
    2834. 

  2834. 		CVShows.showgrids = cv->showgrids = GGadgetIsChecked(event->u.control.g);
    2835. 

  2835.                 GDrawRequestExpose(cv->v,NULL,false);
    2836. 

  2836. 	      break;
    2837. 

  2837. 	      case CID_EFore:
    2838. 

  2838. 		cv->b.drawmode = dm_fore;
    2839. 

  2839. 		cv->lastselpt = NULL;
    2840. 

  2840. 

  2841. 		CVDebugFree(cv->dv);
    2842. 

  2842. 		SplinePointListsFree(cv->b.gridfit); cv->b.gridfit = NULL;
    2843. 

  2843. 		FreeType_FreeRaster(cv->oldraster); cv->oldraster = NULL;
    2844. 

  2844. 		FreeType_FreeRaster(cv->raster); cv->raster = NULL;
    2845. 

  2845. 		cv->show_ft_results = false;
    2846. 

  2846. 	      break;
    2847. 

  2847. 	      case CID_EBack:
    2848. 

  2848. 		cv->b.drawmode = dm_back;
    2849. 

  2849. 		cv->b.layerheads[dm_back] = &cv->b.sc->layers[ly_back];
    2850. 

  2850. 		cv->lastselpt = NULL;
    2851. 

  2851. 

  2852. 		CVDebugFree(cv->dv);
    2853. 

  2853. 		SplinePointListsFree(cv->b.gridfit); cv->b.gridfit = NULL;
    2854. 

  2854. 		FreeType_FreeRaster(cv->oldraster); cv->oldraster = NULL;
    2855. 

  2855. 		FreeType_FreeRaster(cv->raster); cv->raster = NULL;
    2856. 

  2856. 		cv->show_ft_results = false;
    2857. 

  2857. 	      break;
    2858. 

  2858. 	      case CID_EGrid:
    2859. 

  2859. 		cv->b.drawmode = dm_grid;
    2860. 

  2860. 		cv->lastselpt = NULL;
    2861. 

  2861. 	      break;
    2862. 

  2862. 	      default:
    2863. 

  2863.                 if ( cid>=CID_VBase-1 && cid<CID_VBase+999) {
    2864. 

  2864.                     cid -= CID_VBase;
    2865. 

  2865.                     if ( GGadgetIsChecked(event->u.control.g))
    2866. 

  2866.                         cv->showback[cid>>5] |=  (1<<(cid&31));
    2867. 

  2867.                     else
    2868. 

  2868.                         cv->showback[cid>>5] &= ~(1<<(cid&31));
    2869. 

  2869.                     cv->back_img_out_of_date = true;
    2870. 

  2870. 

  2871.                     GDrawRequestExpose(cv->v,NULL,false);
    2872. 

  2872.                     if ( dm!=cv->b.drawmode )
    2873. 

  2873.                         GDrawRequestExpose(cv->gw,NULL,false);	/* the logo (where the scrollbars join) shows what layer we are in */
    2874. 

  2874.                 }
    2875. 

  2875.             }
    2876. 

  2876. 

  2877.         } else if ( event->u.control.subtype == et_scrollbarchange ) {
    2878. 

  2878. 	    LayerScroll(cv,event);
    2879. 

  2879. 

  2880. 	}
    2881. 

  2881.       break; /* case et_controlevent */
    2882. 

  2882.       default: {
    2883. 

  2883.       } break;
    2884. 

  2884.     } /* switch ( event->type ) */
    2885. 

  2885. return( true );
    2886. 

  2886. }
    2887. 

  2887. 

  2888. /* Set to true the editable field for the current layer, and false for the other layers. */
    2889. 

  2889. void CVSetLayer(CharView *cv,int layer) {
    2890. 

  2890. 

  2891.      /* Update the drawmode of cv */
    2892. 

  2892.     if ( layer == ly_grid )
    2893. 

  2893. 	cv->b.drawmode = dm_grid;
    2894. 

  2894.     else if (layer == ly_fore )
    2895. 

  2895. 	cv->b.drawmode = dm_fore;
    2896. 

  2896.     else {
    2897. 

  2897. 	cv->b.drawmode = dm_back;
    2898. 

  2898. 	cv->b.layerheads[dm_back] = &cv->b.sc->layers[layer];
    2899. 

  2899.     }
    2900. 

  2900.     if ( cvlayers!=NULL && GDrawGetUserData(cvlayers)==cv ) 
    2901. 

  2901. 	GDrawRequestExpose(cvlayers,NULL,false);
    2902. 

  2902. }
    2903. 

  2903. 

  2904. /* Check if a key press corresponds to a mnemonic the palette knows about. */
    2905. 

  2905. int CVPaletteMnemonicCheck(GEvent *event) {
    2906. 

  2906.     static struct strmatch { char *str; int cid; } strmatch[] = {
    2907. 

  2907. /* GT: Foreground, make it short */
    2908. 

  2908. 	{ N_("F_ore"), CID_EFore },
    2909. 

  2909. /* GT: Background, make it short */
    2910. 

  2910. 	{ N_("_Back"), CID_EBack },
    2911. 

  2911. /* GT: Guide layer, make it short */
    2912. 

  2912. 	{ N_("_Guide"), CID_EGrid },
    2913. 

  2913. 	{ NULL, 0 }
    2914. 

  2914.     };
    2915. 

  2915.     unichar_t mn, mnc;
    2916. 

  2916.     int j, i, ch;
    2917. 

  2917.     char *foo;
    2918. 

  2918.     GEvent fake;
    2919. 

  2919.     GGadget *g;
    2920. 

  2920.     CharView *cv;
    2921. 

  2921.     SplineFont *parent;
    2922. 

  2922.     int curlayer;
    2923. 

  2923. 

  2924.     if ( cvtools==NULL )
    2925. 

  2925. return( false );
    2926. 

  2926.     cv = GDrawGetUserData(cvtools);
    2927. 

  2927.     parent = cv->b.sc->parent;
    2928. 

  2928.     curlayer = CVLayer(&cv->b); /* the index of the active layer */
    2929. 

  2929. 

  2930.     if ( isdigit(event->u.chr.keysym) ) {
    2931. 

  2931. 	int off = event->u.chr.keysym - '0';
    2932. 

  2932. 

  2933. 	g = GWidgetGetControl(cvlayers, CID_EBase+off-1);
    2934. 

  2934. 	if ( off-1<parent->layer_cnt && off!=curlayer ) {
    2935. 

  2935.             CVLSelectLayer(cv, off);
    2936. 

  2936. 	    if ( cv->b.sc->parent->multilayer )
    2937. 

  2937. 	    	GDrawRequestExpose(cvlayers2,NULL,false);
    2938. 

  2938. 	    else
    2939. 

  2939. return( true );
    2940. 

  2940. 	}
    2941. 

  2941.     }
    2942. 

  2942. 

  2943.      /* mnemonic is encoded in the layer name */
    2944. 

  2944.     for ( j=0; j<2; ++j ) {
    2945. 

  2945. 	for ( i=0; j==0 ? i<parent->layer_cnt : strmatch[i].str!=NULL; ++i ) {
    2946. 

  2946. 	    for ( foo = j==0 ? parent->layers[i].name : _(strmatch[i].str);
    2947. 

  2947. 		    (ch=utf8_ildb((const char **) &foo))!=0; )
    2948. 

  2948. 		if ( ch=='_' )
    2949. 

  2949. 	    break;
    2950. 

  2950. 	    if ( ch=='_' )
    2951. 

  2951. 		mnc = utf8_ildb((const char **) &foo);
    2952. 

  2952. 	    else
    2953. 

  2953. 		mnc = 0;
    2954. 

  2954. 	    mn = mnc;
    2955. 

  2955. 	    if ( islower(mn)) mnc = toupper(mn);
    2956. 

  2956. 	    else if ( isupper(mn)) mnc = tolower(mn);
    2957. 

  2957. 	    if ( event->u.chr.chars[0]==mn || event->u.chr.chars[0]==mnc ) {
    2958. 

  2958. 		if ( cv->b.sc->parent->multilayer ) {
    2959. 

  2959. 		    fake.type = et_mousedown;
    2960. 

  2960. 		    fake.w = cvlayers;
    2961. 

  2961. 		    fake.u.mouse.x = 40;
    2962. 

  2962. 		    if ( strmatch[i].cid==CID_EGrid ) {
    2963. 

  2963. 			fake.u.mouse.y = CV_LAYERS2_HEADER_HEIGHT+12;
    2964. 

  2964. 		    } else if ( strmatch[i].cid==CID_EBack ) {
    2965. 

  2965. 			fake.u.mouse.y = CV_LAYERS2_HEADER_HEIGHT+12+CV_LAYERS2_LINE_HEIGHT;
    2966. 

  2966. 		    } else {
    2967. 

  2967. 			fake.u.mouse.y = CV_LAYERS2_HEADER_HEIGHT+12+2*CV_LAYERS2_LINE_HEIGHT;
    2968. 

  2968. 		    }
    2969. 

  2969. 		    cvlayers2_e_h(cvlayers2,&fake);
    2970. 

  2970. 		} else {
    2971. 

  2971.             	    CVLSelectLayer(cv, i);
    2972. 

  2972. 	    	    GDrawRequestExpose(cvlayers,NULL,false);
    2973. 

  2973. 		}
    2974. 

  2974.     return( true );
    2975. 

  2975. 	    }
    2976. 

  2976. 	}
    2977. 

  2977.     }
    2978. 

  2978. return( false );
    2979. 

  2979. }
    2980. 

  2980. 

  2981. /* This is used for fonts other than Type 3 fonts. CVMakeLayers2() is used for Type 3.
    2982. 

  2982.  * Only the basics of the palette are set up here, with the widgets for the default fore, back,
    2983. 

  2983.  * and guides layers. The palette is updated to actual character views in CVLCheckLayerCount(). */
    2984. 

  2984. GWindow CVMakeLayers(CharView *cv) {
    2985. 

  2985.     GRect r,size;
    2986. 

  2986.     GWindowAttrs wattrs;
    2987. 

  2987.     GGadgetCreateData gcd[25];
    2988. 

  2988.     GTextInfo label[25];
    2989. 

  2989.     GGadget *gadget;
    2990. 

  2990.     FontRequest rq;
    2991. 

  2991.     extern int _GScrollBar_Width;
    2992. 

  2992.     int i=0;
    2993. 

  2993.     int viscol=0;
    2994. 

  2994. 

  2995.     if ( cvlayers!=NULL )
    2996. 

  2996. return( cvlayers );
    2997. 

  2997. 

  2998.      /* Initialize layerinfo */
    2999. 

  2999.     if ( layerinfo.clut==NULL )
    3000. 

  3000. 	layerinfo.clut = _BDFClut(4);
    3001. 

  3001.     if ( layersfont==NULL ) {
    3002. 

  3002. 	memset(&rq,'\0',sizeof(rq));
    3003. 

  3003. 	rq.utf8_family_name = SANS_UI_FAMILIES;
    3004. 

  3004. 	rq.point_size = -12;
    3005. 

  3005. 	rq.weight = 400;
    3006. 

  3006. 	layersfont = GDrawInstanciateFont(cvlayers2,&rq);
    3007. 

  3007. 	layersfont = GResourceFindFont("LayersPalette.Font",layersfont);
    3008. 

  3008.     }
    3009. 

  3009.     layerinfo.font = layersfont;
    3010. 

  3010. 

  3011.      /* Initialize palette window */
    3012. 

  3012.     memset(&wattrs,0,sizeof(wattrs));
    3013. 

  3013.     wattrs.mask = wam_events|wam_cursor|wam_utf8_wtitle|wam_positioned|wam_isdlg;
    3014. 

  3014.     wattrs.event_masks = -1;
    3015. 

  3015.     wattrs.cursor = ct_mypointer;
    3016. 

  3016.     wattrs.positioned = true;
    3017. 

  3017.     wattrs.is_dlg = true;
    3018. 

  3018.     wattrs.utf8_window_title = _("Layers");
    3019. 

  3019. 

  3020.     r.width = GGadgetScale(104); r.height = CV_LAYERS_HEIGHT;
    3021. 

  3021.     if ( cvlayersoff.x==-9999 ) {
    3022. 

  3022. 	 /* Offset of window on screen, by default make it sit just below the tools palette */
    3023. 

  3023. 	cvlayersoff.x = -r.width-6;
    3024. 

  3024. 	cvlayersoff.y = cv->mbh+CV_TOOLS_HEIGHT+45/*25*/; /* 45 is right if there's decor, 25 when none. twm gives none, kde gives decor */
    3025. 

  3025.     }
    3026. 

  3026.     r.x = cvlayersoff.x; r.y = cvlayersoff.y;
    3027. 

  3027.     if ( palettes_docked ) { r.x = 0; r.y=CV_TOOLS_HEIGHT+2; }
    3028. 

  3028.     cvlayers = CreatePalette( cv->gw, &r, cvlayers_e_h, NULL, &wattrs, cv->v );
    3029. 

  3029. 

  3030.     memset(&label,0,sizeof(label));
    3031. 

  3031.     memset(&gcd,0,sizeof(gcd));
    3032. 

  3032. 

  3033.     int32 plusw = GDrawGetText8Width(cv->gw,  _("+"), -1);
    3034. 

  3034.     int32 plush = GDrawGetText8Height(cv->gw, _("+"), -1);
    3035. 

  3035.     plusw = GDrawPointsToPixels(NULL,plusw+4);
    3036. 

  3036.     plush = GDrawPointsToPixels(NULL,plush+4);
    3037. 

  3037.     plush = MAX( plush, plusw ); // make it square.
    3038. 

  3038.     
    3039. 

  3039.      /* Remove Layer button */
    3040. 

  3040.     label[0].text = (unichar_t *) _("-");
    3041. 

  3041.     label[0].text_is_1byte = true;
    3042. 

  3042.     gcd[i].gd.label = &label[0];
    3043. 

  3043.     gcd[i].gd.pos.x = 7; gcd[i].gd.pos.y = 5; 
    3044. 

  3044.     gcd[i].gd.pos.width  = plusw; gcd[i].gd.pos.height = plush;
    3045. 

  3045.     gcd[i].gd.flags = gg_enabled|gg_visible|gg_pos_in_pixels|gg_utf8_popup;
    3046. 

  3046.     gcd[i].gd.cid = CID_RemoveLayer;
    3047. 

  3047.     gcd[i].gd.popup_msg = (unichar_t *) _("Delete the current layer");
    3048. 

  3048.     gcd[i].creator = GButtonCreate;
    3049. 

  3049.     ++i;
    3050. 

  3050. 

  3051.      /* Add Layer button */
    3052. 

  3052.     label[1].text = (unichar_t *) _("+");
    3053. 

  3053.     label[1].text_is_1byte = true;
    3054. 

  3054.     gcd[i].gd.label = &label[1];
    3055. 

  3055.     gcd[i].gd.pos.x = 30; gcd[i].gd.pos.y = 5; 
    3056. 

  3056.     gcd[i].gd.pos.width  = plusw; gcd[i].gd.pos.height = plush;
    3057. 

  3057.     gcd[i].gd.flags = gg_enabled|gg_visible|gg_pos_in_pixels|gg_utf8_popup;
    3058. 

  3058.     gcd[i].gd.cid = CID_AddLayer;
    3059. 

  3059.     gcd[i].gd.popup_msg = (unichar_t *) _("Add a new layer");
    3060. 

  3060.     gcd[i].creator = GButtonCreate;
    3061. 

  3061.     ++i;
    3062. 

  3062. 

  3063.      /* "Layers" label next to the add and remove buttons */
    3064. 

  3064.     label[2].text = (unichar_t *) "";
    3065. 

  3065.     label[2].text_is_1byte = true;
    3066. 

  3066.     gcd[i].gd.label = &label[2];
    3067. 

  3067.     gcd[i].gd.pos.x = 47; gcd[i].gd.pos.y = 5; 
    3068. 

  3068.     gcd[i].gd.flags = gg_enabled|gg_visible|gg_pos_in_pixels|gg_utf8_popup;
    3069. 

  3069.     gcd[i].gd.cid = CID_LayersMenu;
    3070. 

  3070.     /* gcd[i].gd.popup_msg = (unichar_t *) _("Rename the current layer"); */
    3071. 

  3071.     gcd[i].creator = GLabelCreate;
    3072. 

  3072.     ++i;
    3073. 

  3073. 

  3074.      /* Default visibility toggles for Fore, Back, and Guides */
    3075. 

  3075.     gcd[i].gd.pos.x = viscol; gcd[i].gd.pos.y = 38; 
    3076. 

  3076.     gcd[i].gd.flags = gg_enabled|gg_visible|gg_dontcopybox|gg_pos_in_pixels|gg_utf8_popup;
    3077. 

  3077.     if ( cv->showgrids ) gcd[i].gd.flags |= gg_cb_on;
    3078. 

  3078.     gcd[i].gd.cid = CID_VGrid;
    3079. 

  3079.     gcd[i].gd.popup_msg = (unichar_t *) _("Is Layer Visible?");
    3080. 

  3080.     gcd[i].creator = GVisibilityBoxCreate;
    3081. 

  3081.     ++i;
    3082. 

  3082. 

  3083.     gcd[i].gd.pos.x = viscol; gcd[i].gd.pos.y = 38; 
    3084. 

  3084.     gcd[i].gd.flags = gg_enabled|gg_visible|gg_dontcopybox|gg_pos_in_pixels|gg_utf8_popup;
    3085. 

  3085.     if ( cv->showback[0]&1 ) gcd[i].gd.flags |= gg_cb_on;
    3086. 

  3086.     gcd[i].gd.cid = CID_VBack;
    3087. 

  3087.     gcd[i].gd.popup_msg = (unichar_t *) _("Is Layer Visible?");
    3088. 

  3088.     gcd[i].creator = GVisibilityBoxCreate;
    3089. 

  3089.     ++i;
    3090. 

  3090. 

  3091.     gcd[i].gd.pos.x = viscol; gcd[i].gd.pos.y = 21; 
    3092. 

  3092.     gcd[i].gd.flags = gg_enabled|gg_visible|gg_dontcopybox|gg_pos_in_pixels|gg_utf8_popup;
    3093. 

  3093.     if ( cv->showfore ) gcd[i].gd.flags |= gg_cb_on;
    3094. 

  3094.     gcd[i].gd.cid = CID_VFore;
    3095. 

  3095.     gcd[i].gd.popup_msg = (unichar_t *) _("Is Layer Visible?");
    3096. 

  3096.     gcd[i].creator = GVisibilityBoxCreate;
    3097. 

  3097.     ++i;
    3098. 

  3098. 

  3099. 

  3100.      /* Scroll bar */
    3101. 

  3101.     gcd[i].gd.pos.width = GDrawPointsToPixels(cv->gw,_GScrollBar_Width);
    3102. 

  3102.     gcd[i].gd.pos.x = 0; /* <- these get updated to real values later */
    3103. 

  3103.     gcd[i].gd.pos.y = 0;
    3104. 

  3104.     gcd[i].gd.pos.height = 50;
    3105. 

  3105.     gcd[i].gd.flags = gg_enabled|gg_pos_in_pixels|gg_sb_vert;
    3106. 

  3106.     gcd[i].gd.cid = CID_SB;
    3107. 

  3107.     gcd[i].creator = GScrollBarCreate;
    3108. 

  3108.     layerinfo.sb_start = gcd[i].gd.pos.x;
    3109. 

  3109.     ++i;
    3110. 

  3110. 

  3111.      /* Edit box for in place layer rename */
    3112. 

  3112.     gcd[i].gd.pos.width=gcd[i].gd.pos.height=1;
    3113. 

  3113.     gcd[i].gd.flags = gg_enabled|gg_pos_in_pixels|gg_utf8_popup;
    3114. 

  3114.     gcd[i].gd.cid = CID_Edit;
    3115. 

  3115.     gcd[i].gd.popup_msg = (unichar_t *) _("Type in new layer name");
    3116. 

  3116.     gcd[i].creator = GTextFieldCreate;
    3117. 

  3117.     ++i;
    3118. 

  3118. 

  3119.     GGadgetsCreate(cvlayers,gcd);
    3120. 

  3120.     if ( cvvisible[0] )
    3121. 

  3121. 	GDrawSetVisible(cvlayers,true);
    3122. 

  3122.     layers_max=2;
    3123. 

  3123. 

  3124.     gadget=GWidgetGetControl(cvlayers,CID_AddLayer);
    3125. 

  3125.     GGadgetGetSize(gadget,&size);
    3126. 

  3126.     layer_header_height = 0;
    3127. 

  3127.     layer_footer_height = size.y + size.height;
    3128. 

  3128. 

  3129.     GGadgetGetSize(GWidgetGetControl(cvlayers,CID_VGrid),&size);
    3130. 

  3130.     layer_height = size.height;
    3131. 

  3131.     int32 w = GDrawGetText8Width(cvlayers, "W", -1);
    3132. 

  3132.     layerinfo.column_width = w+6;
    3133. 

  3133. 

  3134.     layerinfo.active = CVLayer(&cv->b); /* the index of the active layer */
    3135. 

  3135.     layerinfo.mo_col   = -2; /* -2 forces this variable to be updated. afterwords it will be -1 for nothing, or >=0 */
    3136. 

  3136.     layerinfo.mo_layer = -2;
    3137. 

  3137.     layerinfo.offtop   = 0;
    3138. 

  3138.     layerinfo.rename_active = 0;
    3139. 

  3139. 

  3140.     GVisibilityBoxSetToMinWH(GWidgetGetControl(cvlayers,CID_VGrid));
    3141. 

  3141.     GVisibilityBoxSetToMinWH(GWidgetGetControl(cvlayers,CID_VBack));
    3142. 

  3142.     GVisibilityBoxSetToMinWH(GWidgetGetControl(cvlayers,CID_VFore));
    3143. 

  3143. 

  3144. return( cvlayers );
    3145. 

  3145. }
    3146. 

  3146. 

  3147. 

  3148. /* ***************** CVTools and other common palette functions follow ************ */
    3149. 

  3149. 

  3150. static void CVPopupInvoked(GWindow v, GMenuItem *mi, GEvent *e) {
    3151. 

  3151.     CharView *cv = (CharView *) GDrawGetUserData(v);
    3152. 

  3152.     int pos;
    3153. 

  3153. 

  3154.     pos = mi->mid;
    3155. 

  3155.     if ( pos==cvt_spiro ) {
    3156. 

  3156. 	CVChangeSpiroMode(cv);
    3157. 

  3157.     } else if ( cv->had_control ) {
    3158. 

  3158. 	if ( cv->cb1_tool!=pos ) {
    3159. 

  3159. 	    cv->cb1_tool = cv_cb1_tool = pos;
    3160. 

  3160. 	    GDrawRequestExpose(cvtools,NULL,false);
    3161. 

  3161. 	}
    3162. 

  3162.     } else {
    3163. 

  3163. 	if ( cv->b1_tool!=pos ) {
    3164. 

  3164. 	    cv->b1_tool = cv_b1_tool = pos;
    3165. 

  3165. 	    GDrawRequestExpose(cvtools,NULL,false);
    3166. 

  3166. 	}
    3167. 

  3167.     }
    3168. 

  3168.     CVToolsSetCursor(cv,cv->had_control?ksm_control:0,NULL);
    3169. 

  3169. }
    3170. 

  3170. 

  3171. static void CVPopupLayerInvoked(GWindow v, GMenuItem *mi, GEvent *e) {
    3172. 

  3172.     CharView *cv = (CharView *) GDrawGetUserData(v);
    3173. 

  3173.     int layer = mi->mid==0 ? 1 : mi->mid==1 ? 0 : -1;
    3174. 

  3174. 

  3175.     if ( layerinfo.active!=layer )
    3176. 

  3176.         CVLSelectLayer(cv, layer);
    3177. 

  3177. }
    3178. 

  3178. 

  3179. static void CVPopupSelectInvoked(GWindow v, GMenuItem *mi, GEvent *e) {
    3180. 

  3180.     CharView *cv = (CharView *) GDrawGetUserData(v);
    3181. 

  3181. 

  3182.     switch ( mi->mid ) {
    3183. 

  3183.       case 0:
    3184. 

  3184. 	CVPGetInfo(cv);
    3185. 

  3185.       break;
    3186. 

  3186.       case 1:
    3187. 

  3187. 	if ( cv->p.ref!=NULL )
    3188. 

  3188. 	    CharViewCreate(cv->p.ref->sc,(FontView *) (cv->b.fv),-1);
    3189. 

  3189.       break;
    3190. 

  3190.       case 2:
    3191. 

  3191. 	CVAddAnchor(cv);
    3192. 

  3192.       break;
    3193. 

  3193.       case 3:
    3194. 

  3194. 	CVMakeClipPath(cv);
    3195. 

  3195.       break;
    3196. 

  3196.     case MIDL_MakeLine: {
    3197. 

  3197. 	_CVMenuMakeLine((CharViewBase *) cv,mi->mid==MIDL_MakeArc, e!=NULL && (e->u.mouse.state&ksm_meta));
    3198. 

  3198. 	break;
    3199. 

  3199.     }
    3200. 

  3200.     case MIDL_MakeArc: {
    3201. 

  3201. 	_CVMenuMakeLine((CharViewBase *) cv,mi->mid==MIDL_MakeArc, e!=NULL && (e->u.mouse.state&ksm_meta));
    3202. 

  3202. 	break;
    3203. 

  3203.     }
    3204. 

  3204.     case MIDL_InsertPtOnSplineAt: {
    3205. 

  3205. 	_CVMenuInsertPt( cv );
    3206. 

  3206. 	break;
    3207. 

  3207.     }
    3208. 

  3208.     case MIDL_NamePoint: {
    3209. 

  3209. 	if ( cv->p.sp )
    3210. 

  3210. 	    _CVMenuNamePoint( cv, cv->p.sp );
    3211. 

  3211. 	break;
    3212. 

  3212.     }
    3213. 

  3213.     case MIDL_NameContour: {
    3214. 

  3214. 	_CVMenuNameContour( cv );
    3215. 

  3215. 	break;
    3216. 

  3216.     }
    3217. 

  3217.       
    3218. 

  3218.     }
    3219. 

  3219. }
    3220. 

  3220. 

  3221. void CVToolsPopup(CharView *cv, GEvent *event) {
    3222. 

  3222.     GMenuItem mi[125];
    3223. 

  3223.     int i=0;
    3224. 

  3224.     int j=0;
    3225. 

  3225.     int anysel=0;
    3226. 

  3226.     static char *selectables[] = { N_("Get Info..."), N_("Open Reference"), N_("Add Anchor"), NULL };
    3227. 

  3227. 

  3228.     memset(mi,'\0',sizeof(mi));
    3229. 

  3229.     anysel = CVTestSelectFromEvent(cv,event);
    3230. 

  3230. 

  3231.     if( anysel )
    3232. 

  3232.     {
    3233. 

  3233. 	    mi[i].ti.text = (unichar_t *) _("Curve");
    3234. 

  3234. 	    mi[i].ti.text_is_1byte = true;
    3235. 

  3235. 	    mi[i].ti.fg = COLOR_DEFAULT;
    3236. 

  3236. 	    mi[i].ti.bg = COLOR_DEFAULT;
    3237. 

  3237. 	    mi[i].mid = MID_Curve;
    3238. 

  3238. 	    mi[i].invoke = CVMenuPointType;
    3239. 

  3239. 	    i++;
    3240. 

  3240. 	    mi[i].ti.text = (unichar_t *) _("HVCurve");
    3241. 

  3241. 	    mi[i].ti.text_is_1byte = true;
    3242. 

  3242. 	    mi[i].ti.fg = COLOR_DEFAULT;
    3243. 

  3243. 	    mi[i].ti.bg = COLOR_DEFAULT;
    3244. 

  3244. 	    mi[i].mid = MID_HVCurve;
    3245. 

  3245. 	    mi[i].invoke = CVMenuPointType;
    3246. 

  3246. 	    i++;
    3247. 

  3247. 	    mi[i].ti.text = (unichar_t *) _("Corner");
    3248. 

  3248. 	    mi[i].ti.text_is_1byte = true;
    3249. 

  3249. 	    mi[i].ti.fg = COLOR_DEFAULT;
    3250. 

  3250. 	    mi[i].ti.bg = COLOR_DEFAULT;
    3251. 

  3251. 	    mi[i].mid = MID_Corner;
    3252. 

  3252. 	    mi[i].invoke = CVMenuPointType;
    3253. 

  3253. 	    i++;
    3254. 

  3254. 	    mi[i].ti.text = (unichar_t *) _("Tangent");
    3255. 

  3255. 	    mi[i].ti.text_is_1byte = true;
    3256. 

  3256. 	    mi[i].ti.fg = COLOR_DEFAULT;
    3257. 

  3257. 	    mi[i].ti.bg = COLOR_DEFAULT;
    3258. 

  3258. 	    mi[i].mid = MID_Tangent;
    3259. 

  3259. 	    mi[i].invoke = CVMenuPointType;
    3260. 

  3260. 	    i++;
    3261. 

  3261. 

  3262. 	    mi[i].ti.line = true;
    3263. 

  3263. 	    mi[i].ti.fg = COLOR_DEFAULT;
    3264. 

  3264. 	    mi[i].ti.bg = COLOR_DEFAULT;
    3265. 

  3265. 	    i++;
    3266. 

  3266. 

  3267. 	    mi[i].ti.text = (unichar_t *) _("Merge");
    3268. 

  3268. 	    mi[i].ti.text_is_1byte = true;
    3269. 

  3269. 	    mi[i].ti.fg = COLOR_DEFAULT;
    3270. 

  3270. 	    mi[i].ti.bg = COLOR_DEFAULT;
    3271. 

  3271. 	    mi[i].mid = MID_Merge;
    3272. 

  3272. 	    mi[i].invoke = CVMerge;
    3273. 

  3273. 	    i++;
    3274. 

  3274. 	    mi[i].ti.text = (unichar_t *) _("Merge to Line");
    3275. 

  3275. 	    mi[i].ti.text_is_1byte = true;
    3276. 

  3276. 	    mi[i].ti.fg = COLOR_DEFAULT;
    3277. 

  3277. 	    mi[i].ti.bg = COLOR_DEFAULT;
    3278. 

  3278. 	    mi[i].mid = MID_MergeToLine;
    3279. 

  3279. 	    mi[i].invoke = CVMergeToLine;
    3280. 

  3280. 	    i++;
    3281. 

  3281. 

  3282. 	    mi[i].ti.text = (unichar_t *) _("Align Points");
    3283. 

  3283. 	    mi[i].ti.text_is_1byte = true;
    3284. 

  3284. 	    mi[i].ti.fg = COLOR_DEFAULT;
    3285. 

  3285. 	    mi[i].ti.bg = COLOR_DEFAULT;
    3286. 

  3286. 	    mi[i].mid = MID_Average;
    3287. 

  3287. 	    mi[i].invoke = CVMenuConstrain;
    3288. 

  3288. 	    i++;
    3289. 

  3289.         
    3290. 

  3290.     }
    3291. 

  3291.     
    3292. 

  3292.     
    3293. 

  3293.     if( !anysel )
    3294. 

  3294.     {
    3295. 

  3295. 	for ( i=0;i<=cvt_skew; ++i ) {
    3296. 

  3296. 	    char *msg = _(popupsres[i]);
    3297. 

  3297. 	    if ( cv->b.sc->inspiro && hasspiro()) {
    3298. 

  3298. 		if ( i==cvt_spirog2 )
    3299. 

  3299. 		    msg = _("Add a g2 curve point");
    3300. 

  3300. 		else if ( i==cvt_spiroleft )
    3301. 

  3301. 		    msg = _("Add a left \"tangent\" point");
    3302. 

  3302. 		else if ( i==cvt_spiroright )
    3303. 

  3303. 		    msg = _("Add a right \"tangent\" point");
    3304. 

  3304. 	    }
    3305. 

  3305. 	    mi[i].ti.text = (unichar_t *) msg;
    3306. 

  3306. 	    mi[i].ti.text_is_1byte = true;
    3307. 

  3307. 	    mi[i].ti.fg = COLOR_DEFAULT;
    3308. 

  3308. 	    mi[i].ti.bg = COLOR_DEFAULT;
    3309. 

  3309. 	    mi[i].mid = i;
    3310. 

  3310. 	    mi[i].invoke = CVPopupInvoked;
    3311. 

  3311. 	}
    3312. 

  3312.     }
    3313. 

  3313.     
    3314. 

  3314.     if( !anysel )
    3315. 

  3315.     {
    3316. 

  3316. 	if ( cvlayers!=NULL && !cv->b.sc->parent->multilayer ) {
    3317. 

  3317. 	    mi[i].ti.line = true;
    3318. 

  3318. 	    mi[i].ti.fg = COLOR_DEFAULT;
    3319. 

  3319. 	    mi[i++].ti.bg = COLOR_DEFAULT;
    3320. 

  3320. 	    for ( j=0;j<3; ++j, ++i ) {
    3321. 

  3321. 		mi[i].ti.text = (unichar_t *) _(editablelayers[j]);
    3322. 

  3322. 		mi[i].ti.text_in_resource = true;
    3323. 

  3323. 		mi[i].ti.text_is_1byte = true;
    3324. 

  3324. 		mi[i].ti.fg = COLOR_DEFAULT;
    3325. 

  3325. 		mi[i].ti.bg = COLOR_DEFAULT;
    3326. 

  3326. 		mi[i].mid = j;
    3327. 

  3327. 		mi[i].invoke = CVPopupLayerInvoked;
    3328. 

  3328. 	    }
    3329. 

  3329. 	}
    3330. 

  3330.     }
    3331. 

  3331. 

  3332.     if( i > 0 ) {
    3333. 

  3333. 	mi[i].ti.line = true;
    3334. 

  3334. 	mi[i].ti.fg = COLOR_DEFAULT;
    3335. 

  3335. 	mi[i++].ti.bg = COLOR_DEFAULT;
    3336. 

  3336.     }
    3337. 

  3337.     
    3338. 

  3338.     for ( j=0; selectables[j]!=0; ++j )
    3339. 

  3339.     {
    3340. 

  3340. 	if ( (!anysel && j!=2 ) ||
    3341. 

  3341. 		( j==0 && cv->p.spline ) ||
    3342. 

  3342. 		( j==1 && !cv->p.ref ))
    3343. 

  3343. 	{
    3344. 

  3344. 	    // don't show them a disabled item
    3345. 

  3345. 	    continue;
    3346. 

  3346. 	    
    3347. 

  3347. 	    // or, if the above "continue;" is commented then keep the entry
    3348. 

  3348. 	    // but don't let them select it 
    3349. 

  3349. 	    mi[i].ti.disabled = true; 
    3350. 

  3350. 	}
    3351. 

  3351. 	mi[i].ti.text = (unichar_t *) _(selectables[j]);
    3352. 

  3352. 	mi[i].ti.text_is_1byte = true;
    3353. 

  3353. 	mi[i].ti.fg = COLOR_DEFAULT;
    3354. 

  3354. 	mi[i].ti.bg = COLOR_DEFAULT;
    3355. 

  3355. 	mi[i].mid = j;
    3356. 

  3356. 	mi[i].invoke = CVPopupSelectInvoked;
    3357. 

  3357. 	i++;
    3358. 

  3358.     }
    3359. 

  3359. 

  3360.     if ( anysel ) {
    3361. 

  3361. 	mi[i].ti.text = (unichar_t *)_("Name Point...");
    3362. 

  3362. 	mi[i].ti.text_is_1byte = true;
    3363. 

  3363. 	mi[i].ti.fg = COLOR_DEFAULT;
    3364. 

  3364. 	mi[i].ti.bg = COLOR_DEFAULT;
    3365. 

  3365. 	mi[i].mid = MIDL_NamePoint;
    3366. 

  3366. 	mi[i].invoke = CVPopupSelectInvoked;
    3367. 

  3367. 	i++;
    3368. 

  3368.     }
    3369. 

  3369. 

  3370.     if ( cv->b.sc->parent->multilayer ) {
    3371. 

  3371. 	mi[i].ti.text = (unichar_t *) _("Make Clip Path");
    3372. 

  3372. 	mi[i].ti.text_is_1byte = true;
    3373. 

  3373. 	mi[i].ti.fg = COLOR_DEFAULT;
    3374. 

  3374. 	mi[i].ti.bg = COLOR_DEFAULT;
    3375. 

  3375. 	mi[i].mid = j;
    3376. 

  3376. 	mi[i].invoke = CVPopupSelectInvoked;
    3377. 

  3377. 	i++; 
    3378. 

  3378.     }
    3379. 

  3379. 

  3380.     int cnt = CVCountSelectedPoints(cv);
    3381. 

  3381.     printf(".... count:%d\n", cnt );
    3382. 

  3382.     if( cnt > 1 ) {
    3383. 

  3383. 	mi[i].ti.text = (unichar_t *) _("Make Line");
    3384. 

  3384. 	mi[i].ti.text_is_1byte = true;
    3385. 

  3385. 	mi[i].ti.fg = COLOR_DEFAULT;
    3386. 

  3386. 	mi[i].ti.bg = COLOR_DEFAULT;
    3387. 

  3387. 	mi[i].mid = MIDL_MakeLine;
    3388. 

  3388. 	mi[i].invoke = CVPopupSelectInvoked;
    3389. 

  3389. 	i++;
    3390. 

  3390. 

  3391. 	mi[i].ti.text = (unichar_t *) _("Make Arc");
    3392. 

  3392. 	mi[i].ti.text_is_1byte = true;
    3393. 

  3393. 	mi[i].ti.fg = COLOR_DEFAULT;
    3394. 

  3394. 	mi[i].ti.bg = COLOR_DEFAULT;
    3395. 

  3395. 	mi[i].mid = MIDL_MakeArc;
    3396. 

  3396. 	mi[i].invoke = CVPopupSelectInvoked;
    3397. 

  3397. 	i++;
    3398. 

  3398. 

  3399. 	mi[i].ti.text = (unichar_t *) _("Insert Point On Spline At...");
    3400. 

  3400. 	mi[i].ti.text_is_1byte = true;
    3401. 

  3401. 	mi[i].ti.fg = COLOR_DEFAULT;
    3402. 

  3402. 	mi[i].ti.bg = COLOR_DEFAULT;
    3403. 

  3403. 	mi[i].mid = MIDL_InsertPtOnSplineAt;
    3404. 

  3404. 	mi[i].invoke = CVPopupSelectInvoked;
    3405. 

  3405. 	i++;
    3406. 

  3406. 

  3407. 	mi[i].ti.text = (unichar_t *) _("Name Point");
    3408. 

  3408. 	mi[i].ti.text_is_1byte = true;
    3409. 

  3409. 	mi[i].ti.fg = COLOR_DEFAULT;
    3410. 

  3410. 	mi[i].ti.bg = COLOR_DEFAULT;
    3411. 

  3411. 	mi[i].mid = MIDL_NamePoint;
    3412. 

  3412. 	mi[i].invoke = CVPopupSelectInvoked;
    3413. 

  3413. 	i++;
    3414. 

  3414. 

  3415. 	mi[i].ti.text = (unichar_t *) _("Name Contour");
    3416. 

  3416. 	mi[i].ti.text_is_1byte = true;
    3417. 

  3417. 	mi[i].ti.fg = COLOR_DEFAULT;
    3418. 

  3418. 	mi[i].ti.bg = COLOR_DEFAULT;
    3419. 

  3419. 	mi[i].mid = MIDL_NameContour;
    3420. 

  3420. 	mi[i].invoke = CVPopupSelectInvoked;
    3421. 

  3421. 	i++;
    3422. 

  3422.     }
    3423. 

  3423. 

  3424.     cv->had_control = (event->u.mouse.state&ksm_control)?1:0;
    3425. 

  3425.     GMenuCreatePopupMenuWithName(cv->v,event, "Popup", mi);
    3426. 

  3426. }
    3427. 

  3427. 

  3428. static void CVPaletteCheck(CharView *cv) {
    3429. 

  3429.     if ( cvtools==NULL ) {
    3430. 

  3430. 	if ( palettes_fixed ) {
    3431. 

  3431. 	    cvtoolsoff.x = 0; cvtoolsoff.y = 0;
    3432. 

  3432. 	}
    3433. 

  3433. 	CVMakeTools(cv);
    3434. 

  3434.     }
    3435. 

  3435.     if ( cv->b.sc->parent->multilayer && cvlayers2==NULL ) {
    3436. 

  3436. 	if ( palettes_fixed ) {
    3437. 

  3437. 	    cvlayersoff.x = 0; cvlayersoff.y = CV_TOOLS_HEIGHT+45/*25*/;	/* 45 is right if there's decor, 25 when none. twm gives none, kde gives decor */
    3438. 

  3438. 	}
    3439. 

  3439. 	CVMakeLayers2(cv);
    3440. 

  3440.     } else if ( !cv->b.sc->parent->multilayer && cvlayers==NULL ) {
    3441. 

  3441. 	if ( palettes_fixed ) {
    3442. 

  3442. 	    cvlayersoff.x = 0; cvlayersoff.y = CV_TOOLS_HEIGHT+45/*25*/;	/* 45 is right if there's decor, 25 when none. twm gives none, kde gives decor */
    3443. 

  3443. 	}
    3444. 

  3444. 	CVMakeLayers(cv);
    3445. 

  3445.     }
    3446. 

  3446. }
    3447. 

  3447. 

  3448. int CVPaletteIsVisible(CharView *cv,int which) {
    3449. 

  3449.     CVPaletteCheck(cv);
    3450. 

  3450.     if ( which==1 )
    3451. 

  3451. return( cvtools!=NULL && GDrawIsVisible(cvtools) );
    3452. 

  3452. 

  3453.     if ( cv->b.sc->parent->multilayer )
    3454. 

  3454. return( cvlayers2!=NULL && GDrawIsVisible(cvlayers2));
    3455. 

  3455. 

  3456. return( cvlayers!=NULL && GDrawIsVisible(cvlayers) );
    3457. 

  3457. }
    3458. 

  3458. 

  3459. void CVPaletteSetVisible(CharView *cv,int which,int visible) {
    3460. 

  3460.     CVPaletteCheck(cv);
    3461. 

  3461.     if ( which==1 && cvtools!=NULL)
    3462. 

  3462. 	GDrawSetVisible(cvtools,visible );
    3463. 

  3463.     else if ( which==0 && cv->b.sc->parent->multilayer && cvlayers2!=NULL )
    3464. 

  3464. 	GDrawSetVisible(cvlayers2,visible );
    3465. 

  3465.     else if ( which==0 && cvlayers!=NULL )
    3466. 

  3466. 	GDrawSetVisible(cvlayers,visible );
    3467. 

  3467.     cvvisible[which] = visible;
    3468. 

  3468.     SavePrefs(true);
    3469. 

  3469. }
    3470. 

  3470. 

  3471. void CVPalettesRaise(CharView *cv) {
    3472. 

  3472.     if ( cvtools!=NULL && GDrawIsVisible(cvtools))
    3473. 

  3473. 	GDrawRaise(cvtools);
    3474. 

  3474.     if ( cvlayers!=NULL && GDrawIsVisible(cvlayers))
    3475. 

  3475. 	GDrawRaise(cvlayers);
    3476. 

  3476.     if ( cvlayers2!=NULL && GDrawIsVisible(cvlayers2))
    3477. 

  3477. 	GDrawRaise(cvlayers2);
    3478. 

  3478. }
    3479. 

  3479. 

  3480. void _CVPaletteActivate(CharView *cv,int force) {
    3481. 

  3481.     CharView *old;
    3482. 

  3482. 

  3483.     CVPaletteCheck(cv);
    3484. 

  3484.     if ( layers2_active!=-1 && layers2_active!=cv->b.sc->parent->multilayer ) {
    3485. 

  3485. 	if ( !cvvisible[0] ) {
    3486. 

  3486. 	    if ( cvlayers2!=NULL ) GDrawSetVisible(cvlayers2,false);
    3487. 

  3487. 	    if ( cvlayers !=NULL ) GDrawSetVisible(cvlayers,false);
    3488. 

  3488. 	} else if ( layers2_active && cvlayers!=NULL ) {
    3489. 

  3489. 	    if ( cvlayers2!=NULL ) GDrawSetVisible(cvlayers2,false);
    3490. 

  3490. 	    GDrawSetVisible(cvlayers,true);
    3491. 

  3491. 	} else if ( !layers2_active && cvlayers2!=NULL ) {
    3492. 

  3492. 	    if ( cvlayers !=NULL ) GDrawSetVisible(cvlayers,false);
    3493. 

  3493. 	    GDrawSetVisible(cvlayers2,true);
    3494. 

  3494. 	}
    3495. 

  3495.     }
    3496. 

  3496.     layers2_active = cv->b.sc->parent->multilayer;
    3497. 

  3497.     if ( (old = GDrawGetUserData(cvtools))!=cv || force) {
    3498. 

  3498. 	if ( old!=NULL ) {
    3499. 

  3499. 	    SaveOffsets(old->gw,cvtools,&cvtoolsoff);
    3500. 

  3500. 	    if ( old->b.sc->parent->multilayer )
    3501. 

  3501. 		SaveOffsets(old->gw,cvlayers2,&cvlayersoff);
    3502. 

  3502. 	    else
    3503. 

  3503. 		SaveOffsets(old->gw,cvlayers,&cvlayersoff);
    3504. 

  3504. 	}
    3505. 

  3505. 	GDrawSetUserData(cvtools,cv);
    3506. 

  3506. 	if ( cv->b.sc->parent->multilayer ) {
    3507. 

  3507. 	    LayersSwitch(cv);
    3508. 

  3508. 	    GDrawSetUserData(cvlayers2,cv);
    3509. 

  3509. 	} else {
    3510. 

  3510. 	    GDrawSetUserData(cvlayers,cv);
    3511. 

  3511.             CVLCheckLayerCount(cv,true);
    3512. 

  3512. 	}
    3513. 

  3513. 	if ( palettes_docked ) {
    3514. 

  3514. 	    ReparentFixup(cvtools,cv->v,0,0,CV_TOOLS_WIDTH,CV_TOOLS_HEIGHT);
    3515. 

  3515. 	    if ( cv->b.sc->parent->multilayer )
    3516. 

  3516. 		ReparentFixup(cvlayers2,cv->v,0,CV_TOOLS_HEIGHT+2,0,0);
    3517. 

  3517. 	    else
    3518. 

  3518. 		ReparentFixup(cvlayers,cv->v,0,CV_TOOLS_HEIGHT+2,0,0);
    3519. 

  3519. 	} else {
    3520. 

  3520. 	    if ( cvvisible[0]) {
    3521. 

  3521. 		if ( cv->b.sc->parent->multilayer )
    3522. 

  3522. 		    RestoreOffsets(cv->gw,cvlayers2,&cvlayersoff);
    3523. 

  3523. 		else
    3524. 

  3524. 		    RestoreOffsets(cv->gw,cvlayers,&cvlayersoff);
    3525. 

  3525. 	    }
    3526. 

  3526. 	    if ( cvvisible[1])
    3527. 

  3527. 		RestoreOffsets(cv->gw,cvtools,&cvtoolsoff);
    3528. 

  3528. 	}
    3529. 

  3529. 	GDrawSetVisible(cvtools,cvvisible[1]);
    3530. 

  3530. 	if ( cv->b.sc->parent->multilayer )
    3531. 

  3531. 	    GDrawSetVisible(cvlayers2,cvvisible[0]);
    3532. 

  3532. 	else
    3533. 

  3533. 	    GDrawSetVisible(cvlayers,cvvisible[0]);
    3534. 

  3534. 	if ( cvvisible[1]) {
    3535. 

  3535. 	    cv->showing_tool = cvt_none;
    3536. 

  3536. 	    CVToolsSetCursor(cv,0,NULL);
    3537. 

  3537. 	    GDrawRequestExpose(cvtools,NULL,false);
    3538. 

  3538. 	}
    3539. 

  3539. 	if ( cvvisible[0])
    3540. 

  3540. 	    CVLayersSet(cv);
    3541. 

  3541.     }
    3542. 

  3542.     if ( bvtools!=NULL ) {
    3543. 

  3543. 	BitmapView *bv = GDrawGetUserData(bvtools);
    3544. 

  3544. 	if ( bv!=NULL ) {
    3545. 

  3545. 	    SaveOffsets(bv->gw,bvtools,&bvtoolsoff);
    3546. 

  3546. 	    SaveOffsets(bv->gw,bvlayers,&bvlayersoff);
    3547. 

  3547. 	    if ( !bv->shades_hidden )
    3548. 

  3548. 		SaveOffsets(bv->gw,bvshades,&bvshadesoff);
    3549. 

  3549. 	    GDrawSetUserData(bvtools,NULL);
    3550. 

  3550. 	    GDrawSetUserData(bvlayers,NULL);
    3551. 

  3551. 	    GDrawSetUserData(bvshades,NULL);
    3552. 

  3552. 	}
    3553. 

  3553. 	GDrawSetVisible(bvtools,false);
    3554. 

  3554. 	GDrawSetVisible(bvlayers,false);
    3555. 

  3555. 	GDrawSetVisible(bvshades,false);
    3556. 

  3556.     }
    3557. 

  3557. }
    3558. 

  3558. 

  3559. void CVPaletteActivate(CharView *cv) {
    3560. 

  3560.     _CVPaletteActivate(cv,false);
    3561. 

  3561. }
    3562. 

  3562. 

  3563. void CV_LayerPaletteCheck(SplineFont *sf) {
    3564. 

  3564.     CharView *old;
    3565. 

  3565. 

  3566.     if ( cvlayers!=NULL ) {
    3567. 

  3567. 	if ( (old = GDrawGetUserData(cvlayers))!=NULL ) {
    3568. 

  3568. 	    if ( old->b.sc->parent==sf )
    3569. 

  3569. 		_CVPaletteActivate(old,true);
    3570. 

  3570. 	}
    3571. 

  3571.     }
    3572. 

  3572. }
    3573. 

  3573. 

  3574. /* make the charview point to the correct layer heads for the specified glyph */
    3575. 

  3575. void SFLayerChange(SplineFont *sf) {
    3576. 

  3576.     CharView *old, *cv;
    3577. 

  3577.     int i;
    3578. 

  3578. 

  3579.     for ( i=0; i<sf->glyphcnt; ++i ) if ( sf->glyphs[i]!=NULL ) {
    3580. 

  3580. 	SplineChar *sc = sf->glyphs[i];
    3581. 

  3581. 	for ( cv=(CharView *) (sc->views); cv!=NULL; cv=(CharView *) (cv->b.next) ) {
    3582. 

  3582. 	    cv->b.layerheads[dm_back] = &sc->layers[ly_back];
    3583. 

  3583. 	    cv->b.layerheads[dm_fore] = &sc->layers[ly_fore];
    3584. 

  3584. 	    cv->b.layerheads[dm_grid] = &sf->grid;
    3585. 

  3585. 	}
    3586. 

  3586.     }
    3587. 

  3587. 

  3588.     if ( cvtools==NULL )
    3589. 

  3589. return;					/* No charviews open */
    3590. 

  3590.     old = GDrawGetUserData(cvtools);
    3591. 

  3591.     if ( old==NULL || old->b.sc->parent!=sf )	/* Irrelevant */
    3592. 

  3592. return;
    3593. 

  3593.     _CVPaletteActivate(old,true);
    3594. 

  3594. }
    3595. 

  3595. 

  3596. void CVPalettesHideIfMine(CharView *cv) {
    3597. 

  3597.     if ( cvtools==NULL )
    3598. 

  3598. return;
    3599. 

  3599.     if ( GDrawGetUserData(cvtools)==cv ) {
    3600. 

  3600. 	SaveOffsets(cv->gw,cvtools,&cvtoolsoff);
    3601. 

  3601. 	GDrawSetVisible(cvtools,false);
    3602. 

  3602. 	GDrawSetUserData(cvtools,NULL);
    3603. 

  3603. 	if ( cv->b.sc->parent->multilayer && cvlayers2!=NULL ) {
    3604. 

  3604. 	    SaveOffsets(cv->gw,cvlayers2,&cvlayersoff);
    3605. 

  3605. 	    GDrawSetVisible(cvlayers2,false);
    3606. 

  3606. 	    GDrawSetUserData(cvlayers2,NULL);
    3607. 

  3607. 	} else {
    3608. 

  3608. 	    SaveOffsets(cv->gw,cvlayers,&cvlayersoff);
    3609. 

  3609. 	    GDrawSetVisible(cvlayers,false);
    3610. 

  3610. 	    GDrawSetUserData(cvlayers,NULL);
    3611. 

  3611. 	}
    3612. 

  3612.     }
    3613. 

  3613. }
    3614. 

  3614. 

  3615. int CVPalettesWidth(void) {
    3616. 

  3616. return( GGadgetScale(CV_LAYERS2_WIDTH));
    3617. 

  3617. }
    3618. 

  3618. 

  3619. /* ************************************************************************** */
    3620. 

  3620. /* **************************** Bitmap Palettes ***************************** */
    3621. 

  3621. /* ************************************************************************** */
    3622. 

  3622. 

  3623. static void BVLayersSet(BitmapView *bv) {
    3624. 

  3624.     GGadgetSetChecked(GWidgetGetControl(bvlayers,CID_VFore),bv->showfore);
    3625. 

  3625.     GGadgetSetChecked(GWidgetGetControl(bvlayers,CID_VBack),bv->showoutline);
    3626. 

  3626.     GGadgetSetChecked(GWidgetGetControl(bvlayers,CID_VGrid),bv->showgrid);
    3627. 

  3627. }
    3628. 

  3628. 

  3629. static int bvlayers_e_h(GWindow gw, GEvent *event) {
    3630. 

  3630.     BitmapView *bv = (BitmapView *) GDrawGetUserData(gw);
    3631. 

  3631. 

  3632.     if ( event->type==et_destroy ) {
    3633. 

  3633. 	bvlayers = NULL;
    3634. 

  3634. return( true );
    3635. 

  3635.     }
    3636. 

  3636. 

  3637.     if ( bv==NULL )
    3638. 

  3638. return( true );
    3639. 

  3639. 

  3640.     switch ( event->type ) {
    3641. 

  3641.       case et_close:
    3642. 

  3642. 	GDrawSetVisible(gw,false);
    3643. 

  3643.       break;
    3644. 

  3644.       case et_char: case et_charup:
    3645. 

  3645. 	PostCharToWindow(bv->gw,event);
    3646. 

  3646.       break;
    3647. 

  3647.       case et_controlevent:
    3648. 

  3648. 	if ( event->u.control.subtype == et_radiochanged ) {
    3649. 

  3649. 	    switch(GGadgetGetCid(event->u.control.g)) {
    3650. 

  3650. 	      case CID_VFore:
    3651. 

  3651. 		BVShows.showfore = bv->showfore = GGadgetIsChecked(event->u.control.g);
    3652. 

  3652. 	      break;
    3653. 

  3653. 	      case CID_VBack:
    3654. 

  3654. 		BVShows.showoutline = bv->showoutline = GGadgetIsChecked(event->u.control.g);
    3655. 

  3655. 	      break;
    3656. 

  3656. 	      case CID_VGrid:
    3657. 

  3657. 		BVShows.showgrid = bv->showgrid = GGadgetIsChecked(event->u.control.g);
    3658. 

  3658. 	      break;
    3659. 

  3659. 	    }
    3660. 

  3660. 	    GDrawRequestExpose(bv->v,NULL,false);
    3661. 

  3661. 	}
    3662. 

  3662.       break;
    3663. 

  3663.     }
    3664. 

  3664. return( true );
    3665. 

  3665. }
    3666. 

  3666. 

  3667. GWindow BVMakeLayers(BitmapView *bv) {
    3668. 

  3668.     GRect r;
    3669. 

  3669.     GWindowAttrs wattrs;
    3670. 

  3670.     GGadgetCreateData gcd[8], boxes[2], *hvarray[5][3];
    3671. 

  3671.     GTextInfo label[8];
    3672. 

  3672.     static GBox radio_box = { bt_none, bs_rect, 0, 0, 0, 0, 0, 0, 0, 0, COLOR_DEFAULT, COLOR_DEFAULT, 0, 0, 0, 0, 0, 0, 0 };
    3673. 

  3673.     FontRequest rq;
    3674. 

  3674.     int i;
    3675. 

  3675. 

  3676.     if ( bvlayers!=NULL )
    3677. 

  3677. return(bvlayers);
    3678. 

  3678.     memset(&wattrs,0,sizeof(wattrs));
    3679. 

  3679.     wattrs.mask = wam_events|wam_cursor|wam_utf8_wtitle|wam_positioned|wam_isdlg;
    3680. 

  3680.     wattrs.event_masks = -1;
    3681. 

  3681.     wattrs.cursor = ct_mypointer;
    3682. 

  3682.     wattrs.positioned = true;
    3683. 

  3683.     wattrs.is_dlg = true;
    3684. 

  3684.     wattrs.utf8_window_title = _("Layers");
    3685. 

  3685. 

  3686.     r.width = GGadgetScale(BV_LAYERS_WIDTH); r.height = BV_LAYERS_HEIGHT;
    3687. 

  3687.     r.x = -r.width-6; r.y = bv->mbh+BV_TOOLS_HEIGHT+45/*25*/;	/* 45 is right if there's decor, is in kde, not in twm. Sigh */
    3688. 

  3688.     if ( palettes_docked ) {
    3689. 

  3689. 	r.x = 0; r.y = BV_TOOLS_HEIGHT+4;
    3690. 

  3690.     } else if ( palettes_fixed ) {
    3691. 

  3691. 	r.x = 0; r.y = BV_TOOLS_HEIGHT+45;
    3692. 

  3692.     }
    3693. 

  3693.     bvlayers = CreatePalette( bv->gw, &r, bvlayers_e_h, bv, &wattrs, bv->v );
    3694. 

  3694. 

  3695.     memset(&label,0,sizeof(label));
    3696. 

  3696.     memset(&gcd,0,sizeof(gcd));
    3697. 

  3697.     memset(&boxes,0,sizeof(boxes));
    3698. 

  3698. 

  3699.     if ( layersfont==NULL ) {
    3700. 

  3700. 	memset(&rq,'\0',sizeof(rq));
    3701. 

  3701. 	rq.utf8_family_name = SANS_UI_FAMILIES;
    3702. 

  3702. 	rq.point_size = -12;
    3703. 

  3703. 	rq.weight = 400;
    3704. 

  3704. 	layersfont = GDrawInstanciateFont(cvlayers2,&rq);
    3705. 

  3705. 	layersfont = GResourceFindFont("LayersPalette.Font",layersfont);
    3706. 

  3706.     }
    3707. 

  3707.     for ( i=0; i<sizeof(label)/sizeof(label[0]); ++i )
    3708. 

  3708. 	label[i].font = layersfont;
    3709. 

  3709. 

  3710. /* GT: Abbreviation for "Visible" */
    3711. 

  3711.     label[0].text = (unichar_t *) _("V");
    3712. 

  3712.     label[0].text_is_1byte = true;
    3713. 

  3713.     gcd[0].gd.label = &label[0];
    3714. 

  3714.     gcd[0].gd.pos.x = 7; gcd[0].gd.pos.y = 5; 
    3715. 

  3715.     gcd[0].gd.flags = gg_enabled|gg_visible|gg_pos_in_pixels|gg_utf8_popup;
    3716. 

  3716.     gcd[0].gd.popup_msg = (unichar_t *) _("Is Layer Visible?");
    3717. 

  3717.     gcd[0].creator = GLabelCreate;
    3718. 

  3718. 

  3719.     label[1].text = (unichar_t *) "Layer";
    3720. 

  3720.     label[1].text_is_1byte = true;
    3721. 

  3721.     gcd[1].gd.label = &label[1];
    3722. 

  3722.     gcd[1].gd.pos.x = 23; gcd[1].gd.pos.y = 5; 
    3723. 

  3723.     gcd[1].gd.flags = gg_enabled|gg_visible|gg_pos_in_pixels|gg_utf8_popup;
    3724. 

  3724.     gcd[1].gd.popup_msg = (unichar_t *) _("Is Layer Visible?");
    3725. 

  3725.     gcd[1].creator = GLabelCreate;
    3726. 

  3726.     hvarray[0][0] = &gcd[0]; hvarray[0][1] = &gcd[1]; hvarray[0][2] = NULL;
    3727. 

  3727. 

  3728.     gcd[2].gd.pos.x = 5; gcd[2].gd.pos.y = 21; 
    3729. 

  3729.     gcd[2].gd.flags = gg_enabled|gg_visible|gg_dontcopybox|gg_pos_in_pixels|gg_utf8_popup;
    3730. 

  3730.     gcd[2].gd.cid = CID_VFore;
    3731. 

  3731.     gcd[2].gd.popup_msg = (unichar_t *) _("Is Layer Visible?");
    3732. 

  3732.     gcd[2].gd.box = &radio_box;
    3733. 

  3733.     gcd[2].creator = GCheckBoxCreate;
    3734. 

  3734.     label[2].text = (unichar_t *) _("Bitmap");
    3735. 

  3735.     label[2].text_is_1byte = true;
    3736. 

  3736.     gcd[2].gd.label = &label[2];
    3737. 

  3737.     hvarray[1][0] = &gcd[2]; hvarray[1][1] = GCD_ColSpan; hvarray[1][2] = NULL;
    3738. 

  3738. 

  3739.     gcd[3].gd.pos.x = 5; gcd[3].gd.pos.y = 37; 
    3740. 

  3740.     gcd[3].gd.flags = gg_enabled|gg_visible|gg_dontcopybox|gg_pos_in_pixels|gg_utf8_popup;
    3741. 

  3741.     gcd[3].gd.cid = CID_VBack;
    3742. 

  3742.     gcd[3].gd.popup_msg = (unichar_t *) _("Is Layer Visible?");
    3743. 

  3743.     gcd[3].gd.box = &radio_box;
    3744. 

  3744.     gcd[3].creator = GCheckBoxCreate;
    3745. 

  3745.     label[3].text = (unichar_t *) _("Outline");
    3746. 

  3746.     label[3].text_is_1byte = true;
    3747. 

  3747.     gcd[3].gd.label = &label[3];
    3748. 

  3748.     hvarray[2][0] = &gcd[3]; hvarray[2][1] = GCD_ColSpan; hvarray[2][2] = NULL;
    3749. 

  3749. 

  3750.     gcd[4].gd.pos.x = 5; gcd[4].gd.pos.y = 53; 
    3751. 

  3751.     gcd[4].gd.flags = gg_enabled|gg_visible|gg_dontcopybox|gg_pos_in_pixels|gg_utf8_popup;
    3752. 

  3752.     gcd[4].gd.cid = CID_VGrid;
    3753. 

  3753.     gcd[4].gd.popup_msg = (unichar_t *) _("Is Layer Visible?");
    3754. 

  3754.     gcd[4].gd.box = &radio_box;
    3755. 

  3755.     gcd[4].creator = GCheckBoxCreate;
    3756. 

  3756.     label[4].text = (unichar_t *) _("_Guide");
    3757. 

  3757.     label[4].text_is_1byte = true;
    3758. 

  3758.     label[4].text_in_resource = true;
    3759. 

  3759.     gcd[4].gd.label = &label[4];
    3760. 

  3760.     hvarray[3][0] = &gcd[4]; hvarray[3][1] = GCD_ColSpan; hvarray[3][2] = NULL;
    3761. 

  3761.     hvarray[4][0] = NULL;
    3762. 

  3762. 

  3763.     if ( bv->showfore ) gcd[2].gd.flags |= gg_cb_on;
    3764. 

  3764.     if ( bv->showoutline ) gcd[3].gd.flags |= gg_cb_on;
    3765. 

  3765.     if ( bv->showgrid ) gcd[4].gd.flags |= gg_cb_on;
    3766. 

  3766. 

  3767.     boxes[0].gd.pos.x = boxes[0].gd.pos.y = 2;
    3768. 

  3768.     boxes[0].gd.flags = gg_enabled|gg_visible;
    3769. 

  3769.     boxes[0].gd.u.boxelements = hvarray[0];
    3770. 

  3770.     boxes[0].creator = GHVGroupCreate;
    3771. 

  3771. 

  3772.     GGadgetsCreate(bvlayers,boxes);
    3773. 

  3773.     GHVBoxFitWindow(boxes[0].ret);
    3774. 

  3774. 

  3775.     if ( bvvisible[0] )
    3776. 

  3776. 	GDrawSetVisible(bvlayers,true);
    3777. 

  3777. return( bvlayers );
    3778. 

  3778. }
    3779. 

  3779. 

  3780. struct shades_layout {
    3781. 

  3781.     int depth;
    3782. 

  3782.     int div;
    3783. 

  3783.     int cnt;		/* linear number of squares */
    3784. 

  3784.     int size;
    3785. 

  3785. };
    3786. 

  3786. 

  3787. static void BVShadesDecompose(BitmapView *bv, struct shades_layout *lay) {
    3788. 

  3788.     GRect r;
    3789. 

  3789.     int temp;
    3790. 

  3790. 

  3791.     GDrawGetSize(bvshades,&r);
    3792. 

  3792.     lay->depth = BDFDepth(bv->bdf);
    3793. 

  3793.     lay->div = 255/((1<<lay->depth)-1);
    3794. 

  3794.     lay->cnt = lay->depth==8 ? 16 : lay->depth;
    3795. 

  3795.     temp = r.width>r.height ? r.height : r.width;
    3796. 

  3796.     lay->size = (temp-8+1)/lay->cnt - 1;
    3797. 

  3797. }
    3798. 

  3798. 

  3799. static void BVShadesExpose(GWindow pixmap, BitmapView *bv, GRect *r) {
    3800. 

  3800.     struct shades_layout lay;
    3801. 

  3801.     GRect old;
    3802. 

  3802.     int i,j,index;
    3803. 

  3803.     GRect block;
    3804. 

  3804.     Color bg = default_background;
    3805. 

  3805.     int greybg = (3*COLOR_RED(bg)+6*COLOR_GREEN(bg)+COLOR_BLUE(bg))/10;
    3806. 

  3806. 

  3807.     GDrawSetLineWidth(pixmap,0);
    3808. 

  3808.     BVShadesDecompose(bv,&lay);
    3809. 

  3809.     GDrawPushClip(pixmap,r,&old);
    3810. 

  3810.     for ( i=0; i<=lay.cnt; ++i ) {
    3811. 

  3811. 	int p = 3+i*(lay.size+1);
    3812. 

  3812. 	int m = 8+lay.cnt*(lay.size+1);
    3813. 

  3813. 	GDrawDrawLine(pixmap,p,0,p,m,bg);
    3814. 

  3814. 	GDrawDrawLine(pixmap,0,p,m,p,bg);
    3815. 

  3815.     }
    3816. 

  3816.     block.width = block.height = lay.size;
    3817. 

  3817.     for ( i=0; i<lay.cnt; ++i ) {
    3818. 

  3818. 	block.y = 4 + i*(lay.size+1);
    3819. 

  3819. 	for ( j=0; j<lay.cnt; ++j ) {
    3820. 

  3820. 	    block.x = 4 + j*(lay.size+1);
    3821. 

  3821. 	    index = (i*lay.cnt+j)*lay.div;
    3822. 

  3822. 	    if (( bv->color >= index - lay.div/2 &&
    3823. 

  3823. 			bv->color <= index + lay.div/2 ) ||
    3824. 

  3824. 		 ( bv->color_under_cursor >= index - lay.div/2 &&
    3825. 

  3825. 		    bv->color_under_cursor <= index + lay.div/2 )) {
    3826. 

  3826. 		GRect outline;
    3827. 

  3827. 		outline.x = block.x-1; outline.y = block.y-1;
    3828. 

  3828. 		outline.width = block.width+1; outline.height = block.height+1;
    3829. 

  3829. 		GDrawDrawRect(pixmap,&outline,
    3830. 

  3830. 		    ( bv->color >= index - lay.div/2 &&
    3831. 

  3831. 			bv->color <= index + lay.div/2 )?0x00ff00:0xffffff);
    3832. 

  3832. 	    }
    3833. 

  3833. 	    index = (255-index) * greybg / 255;
    3834. 

  3834. 	    GDrawFillRect(pixmap,&block,0x010101*index);
    3835. 

  3835. 	}
    3836. 

  3836.     }
    3837. 

  3837. }
    3838. 

  3838. 

  3839. static void BVShadesMouse(BitmapView *bv, GEvent *event) {
    3840. 

  3840.     struct shades_layout lay;
    3841. 

  3841.     int i, j;
    3842. 

  3842. 

  3843.     GGadgetEndPopup();
    3844. 

  3844.     if ( event->type == et_mousemove && !bv->shades_down )
    3845. 

  3845. return;
    3846. 

  3846.     BVShadesDecompose(bv,&lay);
    3847. 

  3847.     if ( event->u.mouse.x<4 || event->u.mouse.y<4 ||
    3848. 

  3848. 	    event->u.mouse.x>=4+lay.cnt*(lay.size+1) ||
    3849. 

  3849. 	    event->u.mouse.y>=4+lay.cnt*(lay.size+1) )
    3850. 

  3850. return;
    3851. 

  3851.     i = (event->u.mouse.y-4)/(lay.size+1);
    3852. 

  3852.     j = (event->u.mouse.x-4)/(lay.size+1);
    3853. 

  3853.     if ( bv->color != (i*lay.cnt + j)*lay.div ) {
    3854. 

  3854. 	bv->color = (i*lay.cnt + j)*lay.div;
    3855. 

  3855. 	GDrawRequestExpose(bvshades,NULL,false);
    3856. 

  3856.     }
    3857. 

  3857.     if ( event->type == et_mousedown ) bv->shades_down = true;
    3858. 

  3858.     else if ( event->type == et_mouseup ) bv->shades_down = false;
    3859. 

  3859.     if ( event->type == et_mouseup )
    3860. 

  3860. 	GDrawRequestExpose(bv->gw,NULL,false);
    3861. 

  3861. }
    3862. 

  3862. 

  3863. static int bvshades_e_h(GWindow gw, GEvent *event) {
    3864. 

  3864.     BitmapView *bv = (BitmapView *) GDrawGetUserData(gw);
    3865. 

  3865. 

  3866.     if ( event->type==et_destroy ) {
    3867. 

  3867. 	bvshades = NULL;
    3868. 

  3868. return( true );
    3869. 

  3869.     }
    3870. 

  3870. 

  3871.     if ( bv==NULL )
    3872. 

  3872. return( true );
    3873. 

  3873. 

  3874.     switch ( event->type ) {
    3875. 

  3875.       case et_expose:
    3876. 

  3876. 	BVShadesExpose(gw,bv,&event->u.expose.rect);
    3877. 

  3877.       break;
    3878. 

  3878.       case et_mousemove:
    3879. 

  3879.       case et_mouseup:
    3880. 

  3880.       case et_mousedown:
    3881. 

  3881. 	BVShadesMouse(bv,event);
    3882. 

  3882.       break;
    3883. 

  3883.       break;
    3884. 

  3884.       case et_char: case et_charup:
    3885. 

  3885. 	PostCharToWindow(bv->gw,event);
    3886. 

  3886.       break;
    3887. 

  3887.       case et_destroy:
    3888. 

  3888.       break;
    3889. 

  3889.       case et_close:
    3890. 

  3890. 	GDrawSetVisible(gw,false);
    3891. 

  3891.       break;
    3892. 

  3892.     }
    3893. 

  3893. return( true );
    3894. 

  3894. }
    3895. 

  3895. 

  3896. static GWindow BVMakeShades(BitmapView *bv) {
    3897. 

  3897.     GRect r;
    3898. 

  3898.     GWindowAttrs wattrs;
    3899. 

  3899. 

  3900.     if ( bvshades!=NULL )
    3901. 

  3901. return( bvshades );
    3902. 

  3902.     memset(&wattrs,0,sizeof(wattrs));
    3903. 

  3903.     wattrs.mask = wam_events|wam_cursor|wam_utf8_wtitle|wam_positioned|wam_isdlg/*|wam_backcol*/;
    3904. 

  3904.     wattrs.event_masks = -1;
    3905. 

  3905.     wattrs.cursor = ct_eyedropper;
    3906. 

  3906.     wattrs.positioned = true;
    3907. 

  3907.     wattrs.is_dlg = true;
    3908. 

  3908.     wattrs.background_color = 0xffffff;
    3909. 

  3909.     wattrs.utf8_window_title = _("Shades");
    3910. 

  3910. 

  3911.     r.width = BV_SHADES_HEIGHT; r.height = r.width;
    3912. 

  3912.     r.x = -r.width-6; r.y = bv->mbh+225;
    3913. 

  3913.     if ( palettes_docked ) {
    3914. 

  3914. 	r.x = 0; r.y = BV_TOOLS_HEIGHT+BV_LAYERS_HEIGHT+4;
    3915. 

  3915.     } else if ( palettes_fixed ) {
    3916. 

  3916. 	r.x = 0; r.y = BV_TOOLS_HEIGHT+BV_LAYERS_HEIGHT+90;
    3917. 

  3917.     }
    3918. 

  3918.     bvshades = CreatePalette( bv->gw, &r, bvshades_e_h, bv, &wattrs, bv->v );
    3919. 

  3919.     bv->shades_hidden = BDFDepth(bv->bdf)==1;
    3920. 

  3920.     if ( bvvisible[2] && !bv->shades_hidden )
    3921. 

  3921. 	GDrawSetVisible(bvshades,true);
    3922. 

  3922. return( bvshades );
    3923. 

  3923. }
    3924. 

  3924. 

  3925. static char *bvpopups[] = { N_("Pointer"), N_("Magnify (Minify with alt)"),
    3926. 

  3926. 				    N_("Set/Clear Pixels"), N_("Draw a Line"),
    3927. 

  3927. 			            N_("Shift Entire Bitmap"), N_("Scroll Bitmap") };
    3928. 

  3928. 

  3929. static void BVToolsExpose(GWindow pixmap, BitmapView *bv, GRect *r) {
    3930. 

  3930.     GRect old;
    3931. 

  3931.     /* Note: If you change this ordering, change enum bvtools */
    3932. 

  3932.     static GImage *buttons[][2] = { { &GIcon_pointer, &GIcon_magnify },
    3933. 

  3933. 				    { &GIcon_pencil, &GIcon_line },
    3934. 

  3934. 			            { &GIcon_shift, &GIcon_hand }};
    3935. 

  3935.     int i,j,norm;
    3936. 

  3936.     int tool = bv->cntrldown?bv->cb1_tool:bv->b1_tool;
    3937. 

  3937.     int dither = GDrawSetDither(NULL,false);
    3938. 

  3938. 

  3939.     GDrawPushClip(pixmap,r,&old);
    3940. 

  3940.     GDrawSetLineWidth(pixmap,0);
    3941. 

  3941.     for ( i=0; i<sizeof(buttons)/sizeof(buttons[0]); ++i ) for ( j=0; j<2; ++j ) {
    3942. 

  3942. 	GDrawDrawImage(pixmap,buttons[i][j],NULL,j*27+1,i*27+1);
    3943. 

  3943. 	norm = (i*2+j!=tool);
    3944. 

  3944. 	GDrawDrawLine(pixmap,j*27,i*27,j*27+25,i*27,norm?0xe0e0e0:0x707070);
    3945. 

  3945. 	GDrawDrawLine(pixmap,j*27,i*27,j*27,i*27+25,norm?0xe0e0e0:0x707070);
    3946. 

  3946. 	GDrawDrawLine(pixmap,j*27,i*27+25,j*27+25,i*27+25,norm?0x707070:0xe0e0e0);
    3947. 

  3947. 	GDrawDrawLine(pixmap,j*27+25,i*27,j*27+25,i*27+25,norm?0x707070:0xe0e0e0);
    3948. 

  3948.     }
    3949. 

  3949.     GDrawPopClip(pixmap,&old);
    3950. 

  3950.     GDrawSetDither(NULL,dither);
    3951. 

  3951. }
    3952. 

  3952. 

  3953. void BVToolsSetCursor(BitmapView *bv, int state,char *device) {
    3954. 

  3954.     int shouldshow;
    3955. 

  3955.     static enum bvtools tools[bvt_max2+1] = { bvt_none };
    3956. 

  3956.     int cntrl;
    3957. 

  3957. 

  3958.     if ( tools[0] == bvt_none ) {
    3959. 

  3959. 	tools[bvt_pointer] = ct_mypointer;
    3960. 

  3960. 	tools[bvt_magnify] = ct_magplus;
    3961. 

  3961. 	tools[bvt_pencil] = ct_pencil;
    3962. 

  3962. 	tools[bvt_line] = ct_line;
    3963. 

  3963. 	tools[bvt_shift] = ct_shift;
    3964. 

  3964. 	tools[bvt_hand] = ct_myhand;
    3965. 

  3965. 	tools[bvt_minify] = ct_magminus;
    3966. 

  3966. 	tools[bvt_eyedropper] = ct_eyedropper;
    3967. 

  3967. 	tools[bvt_setwidth] = ct_setwidth;
    3968. 

  3968. 	tools[bvt_setvwidth] = ct_updown;
    3969. 

  3969. 	tools[bvt_rect] = ct_rect;
    3970. 

  3970. 	tools[bvt_filledrect] = ct_filledrect;
    3971. 

  3971. 	tools[bvt_elipse] = ct_elipse;
    3972. 

  3972. 	tools[bvt_filledelipse] = ct_filledelipse;
    3973. 

  3973.     }
    3974. 

  3974. 

  3975.     shouldshow = bvt_none;
    3976. 

  3976.     if ( bv->active_tool!=bvt_none )
    3977. 

  3977. 	shouldshow = bv->active_tool;
    3978. 

  3978.     else if ( bv->pressed_display!=bvt_none )
    3979. 

  3979. 	shouldshow = bv->pressed_display;
    3980. 

  3980.     else if ( device==NULL || strcmp(device,"Mouse1")==0 ) {
    3981. 

  3981. 	if ( (state&(ksm_shift|ksm_control)) && (state&ksm_button4))
    3982. 

  3982. 	    shouldshow = bvt_magnify;
    3983. 

  3983. 	else if ( (state&(ksm_shift|ksm_control)) && (state&ksm_button5))
    3984. 

  3984. 	    shouldshow = bvt_minify;
    3985. 

  3985. 	else if ( (state&ksm_control) && (state&(ksm_button2|ksm_super)) )
    3986. 

  3986. 	    shouldshow = bv->cb2_tool;
    3987. 

  3987. 	else if ( (state&(ksm_button2|ksm_super)) )
    3988. 

  3988. 	    shouldshow = bv->b2_tool;
    3989. 

  3989. 	else if ( (state&ksm_control) )
    3990. 

  3990. 	    shouldshow = bv->cb1_tool;
    3991. 

  3991. 	else
    3992. 

  3992. 	    shouldshow = bv->b1_tool;
    3993. 

  3993.     } else if ( strcmp(device,"eraser")==0 )
    3994. 

  3994. 	shouldshow = bv->er_tool;
    3995. 

  3995.     else if ( strcmp(device,"stylus")==0 ) {
    3996. 

  3996. 	if ( (state&(ksm_button2|ksm_control|ksm_super)) )
    3997. 

  3997. 	    shouldshow = bv->s2_tool;
    3998. 

  3998. 	else
    3999. 

  3999. 	    shouldshow = bv->s1_tool;
    4000. 

  4000.     }
    4001. 

  4001.     
    4002. 

  4002.     if ( shouldshow==bvt_magnify && (state&ksm_meta))
    4003. 

  4003. 	shouldshow = bvt_minify;
    4004. 

  4004.     if ( (shouldshow==bvt_pencil || shouldshow==bvt_line) && (state&ksm_meta) && bv->bdf->clut!=NULL )
    4005. 

  4005. 	shouldshow = bvt_eyedropper;
    4006. 

  4006.     if ( shouldshow!=bv->showing_tool ) {
    4007. 

  4007. 	GDrawSetCursor(bv->v,tools[shouldshow]);
    4008. 

  4008. 	if ( bvtools != NULL )
    4009. 

  4009. 	    GDrawSetCursor(bvtools,tools[shouldshow]);
    4010. 

  4010. 	bv->showing_tool = shouldshow;
    4011. 

  4011.     }
    4012. 

  4012. 

  4013.     if ( device==NULL || strcmp(device,"stylus")==0 ) {
    4014. 

  4014. 	cntrl = (state&ksm_control)?1:0;
    4015. 

  4015. 	if ( device!=NULL && (state&ksm_button2))
    4016. 

  4016. 	    cntrl = true;
    4017. 

  4017. 	if ( cntrl != bv->cntrldown ) {
    4018. 

  4018. 	    bv->cntrldown = cntrl;
    4019. 

  4019. 	    GDrawRequestExpose(bvtools,NULL,false);
    4020. 

  4020. 	}
    4021. 

  4021.     }
    4022. 

  4022. }
    4023. 

  4023. 

  4024. static void BVToolsMouse(BitmapView *bv, GEvent *event) {
    4025. 

  4025.     int i = (event->u.mouse.y/27), j = (event->u.mouse.x/27);
    4026. 

  4026.     int pos;
    4027. 

  4027.     int isstylus = event->u.mouse.device!=NULL && strcmp(event->u.mouse.device,"stylus")==0;
    4028. 

  4028.     int styluscntl = isstylus && (event->u.mouse.state&0x200);
    4029. 

  4029. 

  4030.     if(j >= 2)
    4031. 

  4031. return;			/* If the wm gave me a window the wrong size */
    4032. 

  4032. 

  4033.     pos = i*2 + j;
    4034. 

  4034.     GGadgetEndPopup();
    4035. 

  4035.     if ( pos<0 || pos>=bvt_max )
    4036. 

  4036. 	pos = bvt_none;
    4037. 

  4037.     if ( event->type == et_mousedown ) {
    4038. 

  4038.         if ( isstylus && event->u.mouse.button==2 )
    4039. 

  4039.             /* Not a real button press, only touch counts. This is a modifier */;
    4040. 

  4040. 	else {
    4041. 

  4041. 	    bv->pressed_tool = bv->pressed_display = pos;
    4042. 

  4042. 	    bv->had_control = ((event->u.mouse.state&ksm_control) || styluscntl)?1:0;
    4043. 

  4043. 	    event->u.chr.state |= (1<<(7+event->u.mouse.button));
    4044. 

  4044. 	}
    4045. 

  4045.     } else if ( event->type == et_mousemove ) {
    4046. 

  4046. 	if ( bv->pressed_tool==bvt_none && pos!=bvt_none ) {
    4047. 

  4047. 	    /* Not pressed */
    4048. 

  4048. 	    if ( !bv->shades_hidden && strcmp(bvpopups[pos],"Set/Clear Pixels")==0 )
    4049. 

  4049. 		GGadgetPreparePopup8(bvtools,_("Set/Clear Pixels\n(Eyedropper with alt)"));
    4050. 

  4050. 	    else
    4051. 

  4051. 		GGadgetPreparePopup8(bvtools,_(bvpopups[pos]));
    4052. 

  4052. 	} else if ( pos!=bv->pressed_tool || bv->had_control != (((event->u.mouse.state&ksm_control)||styluscntl)?1:0) )
    4053. 

  4053. 	    bv->pressed_display = bvt_none;
    4054. 

  4054. 	else
    4055. 

  4055. 	    bv->pressed_display = bv->pressed_tool;
    4056. 

  4056.     } else if ( event->type == et_mouseup ) {
    4057. 

  4057. 	if ( pos!=bv->pressed_tool || bv->had_control != (((event->u.mouse.state&ksm_control)||styluscntl)?1:0) )
    4058. 

  4058. 	    bv->pressed_tool = bv->pressed_display = bvt_none;
    4059. 

  4059. 	else {
    4060. 

  4060. 	    if ( event->u.mouse.device!=NULL && strcmp(event->u.mouse.device,"eraser")==0 )
    4061. 

  4061. 		bv->er_tool = pos;
    4062. 

  4062. 	    else if ( isstylus ) {
    4063. 

  4063. 	        if ( event->u.mouse.button==2 )
    4064. 

  4064. 		    /* Only thing that matters is touch which maps to button 1 */;
    4065. 

  4065. 		else if ( bv->had_control )
    4066. 

  4066. 		    bv->s2_tool = pos;
    4067. 

  4067. 		else
    4068. 

  4068. 		    bv->s1_tool = pos;
    4069. 

  4069. 	    } else if ( bv->had_control && event->u.mouse.button==2 )
    4070. 

  4070. 		bv->cb2_tool = pos;
    4071. 

  4071. 	    else if ( event->u.mouse.button==2 )
    4072. 

  4072. 		bv->b2_tool = pos;
    4073. 

  4073. 	    else if ( bv->had_control ) {
    4074. 

  4074. 		if ( bv->cb1_tool!=pos ) {
    4075. 

  4075. 		    bv->cb1_tool = pos;
    4076. 

  4076. 		    GDrawRequestExpose(bvtools,NULL,false);
    4077. 

  4077. 		}
    4078. 

  4078. 	    } else {
    4079. 

  4079. 		if ( bv->b1_tool!=pos ) {
    4080. 

  4080. 		    bv->b1_tool = pos;
    4081. 

  4081. 		    GDrawRequestExpose(bvtools,NULL,false);
    4082. 

  4082. 		}
    4083. 

  4083. 	    }
    4084. 

  4084. 	    bv->pressed_tool = bv->pressed_display = bvt_none;
    4085. 

  4085. 	}
    4086. 

  4086. 	event->u.mouse.state &= ~(1<<(7+event->u.mouse.button));
    4087. 

  4087.     }
    4088. 

  4088.     BVToolsSetCursor(bv,event->u.mouse.state,event->u.mouse.device);
    4089. 

  4089. }
    4090. 

  4090. 

  4091. static int bvtools_e_h(GWindow gw, GEvent *event) {
    4092. 

  4092.     BitmapView *bv = (BitmapView *) GDrawGetUserData(gw);
    4093. 

  4093. 

  4094.     if ( event->type==et_destroy ) {
    4095. 

  4095. 	bvtools = NULL;
    4096. 

  4096. return( true );
    4097. 

  4097.     }
    4098. 

  4098. 

  4099.     if ( bv==NULL )
    4100. 

  4100. return( true );
    4101. 

  4101. 

  4102.     switch ( event->type ) {
    4103. 

  4103.       case et_expose:
    4104. 

  4104. 	BVToolsExpose(gw,bv,&event->u.expose.rect);
    4105. 

  4105.       break;
    4106. 

  4106.       case et_mousedown:
    4107. 

  4107. 	BVToolsMouse(bv,event);
    4108. 

  4108.       break;
    4109. 

  4109.       case et_mousemove:
    4110. 

  4110. 	BVToolsMouse(bv,event);
    4111. 

  4111.       break;
    4112. 

  4112.       case et_mouseup:
    4113. 

  4113. 	BVToolsMouse(bv,event);
    4114. 

  4114.       break;
    4115. 

  4115.       case et_crossing:
    4116. 

  4116. 	bv->pressed_display = bvt_none;
    4117. 

  4117. 	BVToolsSetCursor(bv,event->u.mouse.state,event->u.mouse.device);
    4118. 

  4118.       break;
    4119. 

  4119.       case et_char: case et_charup:
    4120. 

  4120. 	if ( bv->had_control != ((event->u.chr.state&ksm_control)?1:0) )
    4121. 

  4121. 	    bv->pressed_display = bvt_none;
    4122. 

  4122. 	PostCharToWindow(bv->gw,event);
    4123. 

  4123.       break;
    4124. 

  4124.       case et_close:
    4125. 

  4125. 	GDrawSetVisible(gw,false);
    4126. 

  4126.       break;
    4127. 

  4127.     }
    4128. 

  4128. return( true );
    4129. 

  4129. }
    4130. 

  4130. 

  4131. GWindow BVMakeTools(BitmapView *bv) {
    4132. 

  4132.     GRect r;
    4133. 

  4133.     GWindowAttrs wattrs;
    4134. 

  4134. 

  4135.     if ( bvtools!=NULL )
    4136. 

  4136. return( bvtools );
    4137. 

  4137.     memset(&wattrs,0,sizeof(wattrs));
    4138. 

  4138.     wattrs.mask = wam_events|wam_cursor|wam_utf8_wtitle|wam_positioned|wam_isdlg;
    4139. 

  4139.     wattrs.event_masks = -1;
    4140. 

  4140.     wattrs.cursor = ct_mypointer;
    4141. 

  4141.     wattrs.positioned = true;
    4142. 

  4142.     wattrs.is_dlg = true;
    4143. 

  4143.     wattrs.utf8_window_title = _("Tools");
    4144. 

  4144. 

  4145.     r.width = BV_TOOLS_WIDTH; r.height = BV_TOOLS_HEIGHT;
    4146. 

  4146.     r.x = -r.width-6; r.y = bv->mbh+20;
    4147. 

  4147.     if ( palettes_fixed || palettes_docked ) {
    4148. 

  4148. 	r.x = 0; r.y = 0;
    4149. 

  4149.     }
    4150. 

  4150.     bvtools = CreatePalette( bv->gw, &r, bvtools_e_h, bv, &wattrs, bv->v );
    4151. 

  4151.     if ( bvvisible[1] )
    4152. 

  4152. 	GDrawSetVisible(bvtools,true);
    4153. 

  4153. return( bvtools );
    4154. 

  4154. }
    4155. 

  4155. 

  4156. static void BVPopupInvoked(GWindow v, GMenuItem *mi,GEvent *e) {
    4157. 

  4157.     BitmapView *bv = (BitmapView *) GDrawGetUserData(v);
    4158. 

  4158.     int pos;
    4159. 

  4159. 

  4160.     pos = mi->mid;
    4161. 

  4161.     if ( bv->had_control ) {
    4162. 

  4162. 	if ( bv->cb1_tool!=pos ) {
    4163. 

  4163. 	    bv->cb1_tool = pos;
    4164. 

  4164. 	    GDrawRequestExpose(bvtools,NULL,false);
    4165. 

  4165. 	}
    4166. 

  4166.     } else {
    4167. 

  4167. 	if ( bv->b1_tool!=pos ) {
    4168. 

  4168. 	    bv->b1_tool = pos;
    4169. 

  4169. 	    GDrawRequestExpose(bvtools,NULL,false);
    4170. 

  4170. 	}
    4171. 

  4171.     }
    4172. 

  4172.     BVToolsSetCursor(bv,bv->had_control?ksm_control:0,NULL);
    4173. 

  4173. }
    4174. 

  4174. 

  4175. void BVToolsPopup(BitmapView *bv, GEvent *event) {
    4176. 

  4176.     GMenuItem mi[21];
    4177. 

  4177.     int i, j;
    4178. 

  4178. 

  4179.     memset(mi,'\0',sizeof(mi));
    4180. 

  4180.     for ( i=0;i<6; ++i ) {
    4181. 

  4181. 	mi[i].ti.text = (unichar_t *) _(bvpopups[i]);
    4182. 

  4182. 	mi[i].ti.text_is_1byte = true;
    4183. 

  4183. 	mi[i].ti.fg = COLOR_DEFAULT;
    4184. 

  4184. 	mi[i].ti.bg = COLOR_DEFAULT;
    4185. 

  4185. 	mi[i].mid = i;
    4186. 

  4186. 	mi[i].invoke = BVPopupInvoked;
    4187. 

  4187.     }
    4188. 

  4188. 

  4189.     mi[i].ti.text = (unichar_t *) _("Rectangle");
    4190. 

  4190.     mi[i].ti.text_is_1byte = true;
    4191. 

  4191.     mi[i].ti.fg = COLOR_DEFAULT;
    4192. 

  4192.     mi[i].ti.bg = COLOR_DEFAULT;
    4193. 

  4193.     mi[i].mid = bvt_rect;
    4194. 

  4194.     mi[i++].invoke = BVPopupInvoked;
    4195. 

  4195.     mi[i].ti.text = (unichar_t *) _("Filled Rectangle"); mi[i].ti.text_is_1byte = true;
    4196. 

  4196.     mi[i].ti.fg = COLOR_DEFAULT;
    4197. 

  4197.     mi[i].ti.bg = COLOR_DEFAULT;
    4198. 

  4198.     mi[i].mid = bvt_filledrect;
    4199. 

  4199.     mi[i++].invoke = BVPopupInvoked;
    4200. 

  4200.     mi[i].ti.text = (unichar_t *) _("Ellipse"); mi[i].ti.text_is_1byte = true;
    4201. 

  4201.     mi[i].ti.fg = COLOR_DEFAULT;
    4202. 

  4202.     mi[i].ti.bg = COLOR_DEFAULT;
    4203. 

  4203.     mi[i].mid = bvt_elipse;
    4204. 

  4204.     mi[i++].invoke = BVPopupInvoked;
    4205. 

  4205.     mi[i].ti.text = (unichar_t *) _("Filled Ellipse"); mi[i].ti.text_is_1byte = true;
    4206. 

  4206.     mi[i].ti.fg = COLOR_DEFAULT;
    4207. 

  4207.     mi[i].ti.bg = COLOR_DEFAULT;
    4208. 

  4208.     mi[i].mid = bvt_filledelipse;
    4209. 

  4209.     mi[i++].invoke = BVPopupInvoked;
    4210. 

  4210. 

  4211.     mi[i].ti.fg = COLOR_DEFAULT;
    4212. 

  4212.     mi[i].ti.bg = COLOR_DEFAULT;
    4213. 

  4213.     mi[i++].ti.line = true;
    4214. 

  4214.     for ( j=0; j<6; ++j, ++i ) {
    4215. 

  4215. 	mi[i].ti.text = (unichar_t *) BVFlipNames[j];
    4216. 

  4216. 	mi[i].ti.text_is_1byte = true;
    4217. 

  4217. 	mi[i].ti.fg = COLOR_DEFAULT;
    4218. 

  4218. 	mi[i].ti.bg = COLOR_DEFAULT;
    4219. 

  4219. 	mi[i].mid = j;
    4220. 

  4220. 	mi[i].invoke = BVMenuRotateInvoked;
    4221. 

  4221.     }
    4222. 

  4222.     if ( bv->fv->b.sf->onlybitmaps ) {
    4223. 

  4223. 	mi[i].ti.fg = COLOR_DEFAULT;
    4224. 

  4224. 	mi[i].ti.bg = COLOR_DEFAULT;
    4225. 

  4225. 	mi[i++].ti.line = true;
    4226. 

  4226. 	mi[i].ti.text = (unichar_t *) _("Set _Width...");
    4227. 

  4227. 	mi[i].ti.text_is_1byte = true;
    4228. 

  4228. 	mi[i].ti.text_in_resource = true;
    4229. 

  4229. 	mi[i].ti.fg = COLOR_DEFAULT;
    4230. 

  4230. 	mi[i].ti.bg = COLOR_DEFAULT;
    4231. 

  4231. 	mi[i].mid = bvt_setwidth;
    4232. 

  4232. 	mi[i].invoke = BVPopupInvoked;
    4233. 

  4233.     }
    4234. 

  4234.     bv->had_control = (event->u.mouse.state&ksm_control)?1:0;
    4235. 

  4235.     GMenuCreatePopupMenu(bv->v,event, mi);
    4236. 

  4236. }
    4237. 

  4237. 

  4238. static void BVPaletteCheck(BitmapView *bv) {
    4239. 

  4239.     if ( bvtools==NULL ) {
    4240. 

  4240. 	BVMakeTools(bv);
    4241. 

  4241. 	BVMakeLayers(bv);
    4242. 

  4242. 	BVMakeShades(bv);
    4243. 

  4243.     }
    4244. 

  4244. }
    4245. 

  4245. 

  4246. int BVPaletteIsVisible(BitmapView *bv,int which) {
    4247. 

  4247.     BVPaletteCheck(bv);
    4248. 

  4248.     if ( which==1 )
    4249. 

  4249. return( bvtools!=NULL && GDrawIsVisible(bvtools) );
    4250. 

  4250.     if ( which==2 )
    4251. 

  4251. return( bvshades!=NULL && GDrawIsVisible(bvshades) );
    4252. 

  4252. 

  4253. return( bvlayers!=NULL && GDrawIsVisible(bvlayers) );
    4254. 

  4254. }
    4255. 

  4255. 

  4256. void BVPaletteSetVisible(BitmapView *bv,int which,int visible) {
    4257. 

  4257.     BVPaletteCheck(bv);
    4258. 

  4258.     if ( which==1 && bvtools!=NULL)
    4259. 

  4259. 	GDrawSetVisible(bvtools,visible );
    4260. 

  4260.     else if ( which==2 && bvshades!=NULL)
    4261. 

  4261. 	GDrawSetVisible(bvshades,visible );
    4262. 

  4262.     else if ( which==0 && bvlayers!=NULL )
    4263. 

  4263. 	GDrawSetVisible(bvlayers,visible );
    4264. 

  4264.     bvvisible[which] = visible;
    4265. 

  4265.     SavePrefs(true);
    4266. 

  4266. }
    4267. 

  4267. 

  4268. void BVPaletteActivate(BitmapView *bv) {
    4269. 

  4269.     BitmapView *old;
    4270. 

  4270. 

  4271.     BVPaletteCheck(bv);
    4272. 

  4272.     if ( (old = GDrawGetUserData(bvtools))!=bv ) {
    4273. 

  4273. 	if ( old!=NULL ) {
    4274. 

  4274. 	    SaveOffsets(old->gw,bvtools,&bvtoolsoff);
    4275. 

  4275. 	    SaveOffsets(old->gw,bvlayers,&bvlayersoff);
    4276. 

  4276. 	    SaveOffsets(old->gw,bvshades,&bvshadesoff);
    4277. 

  4277. 	}
    4278. 

  4278. 	GDrawSetUserData(bvtools,bv);
    4279. 

  4279. 	GDrawSetUserData(bvlayers,bv);
    4280. 

  4280. 	GDrawSetUserData(bvshades,bv);
    4281. 

  4281. 	if ( palettes_docked ) {
    4282. 

  4282. 	    ReparentFixup(bvtools,bv->v,0,0,BV_TOOLS_WIDTH,BV_TOOLS_HEIGHT);
    4283. 

  4283. 	    ReparentFixup(bvlayers,bv->v,0,BV_TOOLS_HEIGHT+2,0,0);
    4284. 

  4284. 	    ReparentFixup(bvshades,bv->v,0,BV_TOOLS_HEIGHT+BV_TOOLS_HEIGHT+4,0,0);
    4285. 

  4285. 	} else {
    4286. 

  4286. 	    if ( bvvisible[0])
    4287. 

  4287. 		RestoreOffsets(bv->gw,bvlayers,&bvlayersoff);
    4288. 

  4288. 	    if ( bvvisible[1])
    4289. 

  4289. 		RestoreOffsets(bv->gw,bvtools,&bvtoolsoff);
    4290. 

  4290. 	    if ( bvvisible[2] && !bv->shades_hidden )
    4291. 

  4291. 		RestoreOffsets(bv->gw,bvshades,&bvshadesoff);
    4292. 

  4292. 	}
    4293. 

  4293. 	GDrawSetVisible(bvtools,bvvisible[1]);
    4294. 

  4294. 	GDrawSetVisible(bvlayers,bvvisible[0]);
    4295. 

  4295. 	GDrawSetVisible(bvshades,bvvisible[2] && bv->bdf->clut!=NULL);
    4296. 

  4296. 	if ( bvvisible[1]) {
    4297. 

  4297. 	    bv->showing_tool = bvt_none;
    4298. 

  4298. 	    BVToolsSetCursor(bv,0,NULL);
    4299. 

  4299. 	    GDrawRequestExpose(bvtools,NULL,false);
    4300. 

  4300. 	}
    4301. 

  4301. 	if ( bvvisible[0])
    4302. 

  4302. 	    BVLayersSet(bv);
    4303. 

  4303. 	if ( bvvisible[2] && !bv->shades_hidden )
    4304. 

  4304. 	    GDrawRequestExpose(bvtools,NULL,false);
    4305. 

  4305.     }
    4306. 

  4306.     if ( cvtools!=NULL ) {
    4307. 

  4307. 	CharView *cv = GDrawGetUserData(cvtools);
    4308. 

  4308. 	if ( cv!=NULL ) {
    4309. 

  4309. 	    SaveOffsets(cv->gw,cvtools,&cvtoolsoff);
    4310. 

  4310. 	    SaveOffsets(cv->gw,cvlayers,&cvlayersoff);
    4311. 

  4311. 	    GDrawSetUserData(cvtools,NULL);
    4312. 

  4312. 	    if ( cvlayers!=NULL )
    4313. 

  4313. 		GDrawSetUserData(cvlayers,NULL);
    4314. 

  4314. 	    if ( cvlayers2!=NULL )
    4315. 

  4315. 		GDrawSetUserData(cvlayers2,NULL);
    4316. 

  4316. 	}
    4317. 

  4317. 	GDrawSetVisible(cvtools,false);
    4318. 

  4318. 	if ( cvlayers!=NULL )
    4319. 

  4319. 	    GDrawSetVisible(cvlayers,false);
    4320. 

  4320. 	if ( cvlayers2!=NULL )
    4321. 

  4321. 	    GDrawSetVisible(cvlayers2,false);
    4322. 

  4322.     }
    4323. 

  4323. }
    4324. 

  4324. 

  4325. void BVPalettesHideIfMine(BitmapView *bv) {
    4326. 

  4326.     if ( bvtools==NULL )
    4327. 

  4327. return;
    4328. 

  4328.     if ( GDrawGetUserData(bvtools)==bv ) {
    4329. 

  4329. 	SaveOffsets(bv->gw,bvtools,&bvtoolsoff);
    4330. 

  4330. 	SaveOffsets(bv->gw,bvlayers,&bvlayersoff);
    4331. 

  4331. 	SaveOffsets(bv->gw,bvshades,&bvshadesoff);
    4332. 

  4332. 	GDrawSetVisible(bvtools,false);
    4333. 

  4333. 	GDrawSetVisible(bvlayers,false);
    4334. 

  4334. 	GDrawSetVisible(bvshades,false);
    4335. 

  4335. 	GDrawSetUserData(bvtools,NULL);
    4336. 

  4336. 	GDrawSetUserData(bvlayers,NULL);
    4337. 

  4337. 	GDrawSetUserData(bvshades,NULL);
    4338. 

  4338.     }
    4339. 

  4339. }
    4340. 

  4340. 

  4341. void CVPaletteDeactivate(void) {
    4342. 

  4342.     if ( cvtools!=NULL ) {
    4343. 

  4343. 	CharView *cv = GDrawGetUserData(cvtools);
    4344. 

  4344. 	if ( cv!=NULL ) {
    4345. 

  4345. 	    SaveOffsets(cv->gw,cvtools,&cvtoolsoff);
    4346. 

  4346. 	    GDrawSetUserData(cvtools,NULL);
    4347. 

  4347. 	    if ( cv->b.sc->parent->multilayer && cvlayers2!=NULL ) {
    4348. 

  4348. 		SaveOffsets(cv->gw,cvlayers2,&cvlayersoff);
    4349. 

  4349. 		GDrawSetUserData(cvlayers2,NULL);
    4350. 

  4350. 	    } else if ( cvlayers!=NULL ) {
    4351. 

  4351. 		SaveOffsets(cv->gw,cvlayers,&cvlayersoff);
    4352. 

  4352. 		GDrawSetUserData(cvlayers,NULL);
    4353. 

  4353. 	    }
    4354. 

  4354. 	}
    4355. 

  4355. 	GDrawSetVisible(cvtools,false);
    4356. 

  4356. 	if ( cvlayers!=NULL )
    4357. 

  4357. 	    GDrawSetVisible(cvlayers,false);
    4358. 

  4358. 	if ( cvlayers2!=NULL )
    4359. 

  4359. 	    GDrawSetVisible(cvlayers2,false);
    4360. 

  4360.     }
    4361. 

  4361.     if ( bvtools!=NULL ) {
    4362. 

  4362. 	BitmapView *bv = GDrawGetUserData(bvtools);
    4363. 

  4363. 	if ( bv!=NULL ) {
    4364. 

  4364. 	    SaveOffsets(bv->gw,bvtools,&bvtoolsoff);
    4365. 

  4365. 	    SaveOffsets(bv->gw,bvlayers,&bvlayersoff);
    4366. 

  4366. 	    SaveOffsets(bv->gw,bvshades,&bvshadesoff);
    4367. 

  4367. 	    GDrawSetUserData(bvtools,NULL);
    4368. 

  4368. 	    GDrawSetUserData(bvlayers,NULL);
    4369. 

  4369. 	    GDrawSetUserData(bvshades,NULL);
    4370. 

  4370. 	}
    4371. 

  4371. 	GDrawSetVisible(bvtools,false);
    4372. 

  4372. 	GDrawSetVisible(bvlayers,false);
    4373. 

  4373. 	GDrawSetVisible(bvshades,false);
    4374. 

  4374.     }
    4375. 

  4375. }
    4376. 

  4376. 

  4377. void BVPaletteColorChange(BitmapView *bv) {
    4378. 

  4378.     if ( bvshades!=NULL )
    4379. 

  4379. 	GDrawRequestExpose(bvshades,NULL,false);
    4380. 

  4380.     GDrawRequestExpose(bv->gw,NULL,false);
    4381. 

  4381. }
    4382. 

  4382. 

  4383. void BVPaletteColorUnderChange(BitmapView *bv,int color_under) {
    4384. 

  4384.     if ( bvshades!=NULL && color_under!=bv->color_under_cursor ) {
    4385. 

  4385. 	bv->color_under_cursor = color_under;
    4386. 

  4386. 	GDrawRequestExpose(bvshades,NULL,false);
    4387. 

  4387.     }
    4388. 

  4388. }
    4389. 

  4389. 

  4390. void BVPaletteChangedChar(BitmapView *bv) {
    4391. 

  4391.     if ( bvshades!=NULL && bvvisible[2]) {
    4392. 

  4392. 	int hidden = bv->bdf->clut==NULL;
    4393. 

  4393. 	if ( hidden!=bv->shades_hidden ) {
    4394. 

  4394. 	    GDrawSetVisible(bvshades,!hidden);
    4395. 

  4395. 	    bv->shades_hidden = hidden;
    4396. 

  4396. 	    GDrawRequestExpose(bv->gw,NULL,false);
    4397. 

  4397. 	} else
    4398. 

  4398. 	    GDrawRequestExpose(bvshades,NULL,false);
    4399. 

  4399.     }
    4400. 

  4400. }
    4401. 

  4401. 

  4402. void PalettesChangeDocking(void) {
    4403. 

  4403. 

  4404.     palettes_docked = !palettes_docked;
    4405. 

  4405.     if ( palettes_docked ) {
    4406. 

  4406. 	if ( cvtools!=NULL ) {
    4407. 

  4407. 	    CharView *cv = GDrawGetUserData(cvtools);
    4408. 

  4408. 	    if ( cv!=NULL ) {
    4409. 

  4409. 		ReparentFixup(cvtools,cv->v,0,0,CV_TOOLS_WIDTH,CV_TOOLS_HEIGHT);
    4410. 

  4410. 		if ( cvlayers!=NULL )
    4411. 

  4411. 		    ReparentFixup(cvlayers,cv->v,0,CV_TOOLS_HEIGHT+2,0,0);
    4412. 

  4412. 		if ( cvlayers2!=NULL )
    4413. 

  4413. 		    ReparentFixup(cvlayers2,cv->v,0,CV_TOOLS_HEIGHT+2,0,0);
    4414. 

  4414. 	    }
    4415. 

  4415. 	}
    4416. 

  4416. 	if ( bvtools!=NULL ) {
    4417. 

  4417. 	    BitmapView *bv = GDrawGetUserData(bvtools);
    4418. 

  4418. 	    if ( bv!=NULL ) {
    4419. 

  4419. 		ReparentFixup(bvtools,bv->v,0,0,BV_TOOLS_WIDTH,BV_TOOLS_HEIGHT);
    4420. 

  4420. 		ReparentFixup(bvlayers,bv->v,0,BV_TOOLS_HEIGHT+2,0,0);
    4421. 

  4421. 		ReparentFixup(bvshades,bv->v,0,BV_TOOLS_HEIGHT+BV_LAYERS_HEIGHT+4,0,0);
    4422. 

  4422. 	    }
    4423. 

  4423. 	}
    4424. 

  4424.     } else {
    4425. 

  4425. 	if ( cvtools!=NULL ) {
    4426. 

  4426. 	    GDrawReparentWindow(cvtools,GDrawGetRoot(NULL),0,0);
    4427. 

  4427. 	    if ( cvlayers!=NULL )
    4428. 

  4428. 		GDrawReparentWindow(cvlayers,GDrawGetRoot(NULL),0,CV_TOOLS_HEIGHT+2+45);
    4429. 

  4429. 	    if ( cvlayers2!=NULL )
    4430. 

  4430. 		GDrawReparentWindow(cvlayers2,GDrawGetRoot(NULL),0,CV_TOOLS_HEIGHT+2+45);
    4431. 

  4431. 	}
    4432. 

  4432. 	if ( bvtools!=NULL ) {
    4433. 

  4433. 	    GDrawReparentWindow(bvtools,GDrawGetRoot(NULL),0,0);
    4434. 

  4434. 	    GDrawReparentWindow(bvlayers,GDrawGetRoot(NULL),0,BV_TOOLS_HEIGHT+2+45);
    4435. 

  4435. 	    GDrawReparentWindow(bvshades,GDrawGetRoot(NULL),0,BV_TOOLS_HEIGHT+BV_LAYERS_HEIGHT+4+90);
    4436. 

  4436. 	}
    4437. 

  4437.     }
    4438. 

  4438.     SavePrefs(true);
    4439. 

  4439. }
    4440. 

  4440. 

  4441. int BVPalettesWidth(void) {
    4442. 

  4442. return( GGadgetScale(BV_LAYERS_WIDTH));
    4443. 

  4443. }
    4444. 

  4444.