Line data Source code
1 : /* Copyright (C) 2009-2012 by George Williams */
2 : /*
3 : * Redistribution and use in source and binary forms, with or without
4 : * modification, are permitted provided that the following conditions are met:
5 :
6 : * Redistributions of source code must retain the above copyright notice, this
7 : * list of conditions and the following disclaimer.
8 :
9 : * Redistributions in binary form must reproduce the above copyright notice,
10 : * this list of conditions and the following disclaimer in the documentation
11 : * and/or other materials provided with the distribution.
12 :
13 : * The name of the author may not be used to endorse or promote products
14 : * derived from this software without specific prior written permission.
15 :
16 : * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
17 : * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
18 : * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
19 : * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
20 : * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
21 : * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
22 : * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
23 : * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
24 : * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
25 : * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 : */
27 : #include "cvundoes.h"
28 : #include "fontforgeui.h"
29 : #include <ustring.h>
30 : #include <chardata.h>
31 : #include <utype.h>
32 : #include <gkeysym.h>
33 : #include <gimage.h>
34 : #include <math.h>
35 : #include "delta.h"
36 :
37 : /* Suggestions for where delta instructions might be wanted */
38 :
39 : #define CID_Sizes 100
40 : #define CID_DPI 101
41 : #define CID_BW 102
42 : #define CID_Within 103
43 : #define CID_Msg 104
44 : #define CID_Ok 105
45 : #define CID_Cancel 106
46 : #define CID_Top 107
47 :
48 : static double delta_within = .02;
49 : static char *delta_sizes=NULL;
50 : static int delta_dpi = 100;
51 : static int delta_depth = 1;
52 :
53 : static void StartDeltaDisplay(QGData *qg);
54 :
55 0 : static int Delta_OK(GGadget *g, GEvent *e) {
56 0 : if ( e->type==et_controlevent && e->u.control.subtype == et_buttonactivate ) {
57 0 : QGData *qg = GDrawGetUserData(GGadgetGetWindow(g));
58 0 : int err=false;
59 : int dpi, depth;
60 : double within;
61 : char *sizes;
62 :
63 0 : within = GetReal8(qg->gw,CID_Within,_("Proximity"),&err);
64 0 : dpi = GetInt8(qg->gw,CID_DPI,_("DPI"),&err);
65 0 : if ( err )
66 0 : return(true);
67 0 : if ( within<=0 || within>=.5 ) {
68 0 : ff_post_error(_("Bad Number"),_("The \"Proximity\" field must be more than 0 and less than a half."));
69 0 : return( true );
70 : }
71 0 : if ( dpi<10 || dpi>5000 ) {
72 0 : ff_post_error(_("Unreasonable DPI"),_("The \"DPI\" field must be more than 10 and less than 5000."));
73 0 : return( true );
74 : }
75 0 : depth = GGadgetIsChecked(GWidgetGetControl(qg->gw,CID_BW)) ? 1 : 8;
76 0 : sizes = GGadgetGetTitle8(GWidgetGetControl(qg->gw,CID_Sizes));
77 :
78 0 : GGadgetSetVisible(GWidgetGetControl(qg->gw,CID_Msg),true);
79 0 : GGadgetSetVisible(GWidgetGetControl(qg->gw,CID_Ok),false);
80 0 : GGadgetSetVisible(GWidgetGetControl(qg->gw,CID_Cancel),false);
81 0 : GDrawSetCursor(qg->gw,ct_watch);
82 0 : GDrawProcessPendingEvents(NULL);
83 :
84 0 : qg->within = within;
85 0 : qg->dpi = dpi;
86 0 : qg->pixelsizes = sizes;
87 0 : qg->depth = depth;
88 0 : TopFindQuestionablePoints(qg);
89 :
90 0 : GGadgetSetVisible(GWidgetGetControl(qg->gw,CID_Msg),false);
91 0 : GGadgetSetVisible(GWidgetGetControl(qg->gw,CID_Ok),true);
92 0 : GGadgetSetVisible(GWidgetGetControl(qg->gw,CID_Cancel),true);
93 0 : GDrawSetCursor(qg->gw,ct_pointer);
94 0 : GDrawProcessPendingEvents(NULL);
95 :
96 0 : if ( qg->error!=qg_ok ) {
97 0 : switch ( qg->error ) {
98 : case qg_notnumber:
99 0 : ff_post_error(_("Bad Number"),_("An entry in the \"Sizes\" field is not a number."));
100 0 : break;
101 : case qg_badnumber:
102 0 : ff_post_error(_("Bad Number"),_("An entry in the \"Sizes\" field is unreasonable."));
103 0 : break;
104 : case qg_badrange:
105 0 : ff_post_error(_("Bad Number"),_("An range in the \"Sizes\" field is incorrectly ordered."));
106 0 : break;
107 : case qg_nofont:
108 0 : ff_post_error(_("FreeType unavailable"),_("FreeType unavailable."));
109 0 : break;
110 : default:
111 0 : IError(_("Unexpected error"));
112 0 : break;
113 : }
114 0 : free(sizes);
115 0 : qg->cur = 0;
116 0 : return( true );
117 : }
118 :
119 0 : free(delta_sizes);
120 0 : delta_within = within;
121 0 : delta_dpi = dpi;
122 0 : delta_depth = depth;
123 0 : delta_sizes = sizes;
124 :
125 0 : if ( qg->cur==0 ) {
126 0 : ff_post_error(_("Nothing found"),_("Nothng found."));
127 0 : qg->done = true;
128 0 : return( true );
129 : }
130 :
131 0 : if ( qg->cur >= qg->max )
132 0 : qg->qg = realloc(qg->qg,(qg->max += 1) * sizeof(QuestionableGrid));
133 0 : memset(qg->qg+qg->cur,0,sizeof(QuestionableGrid));
134 0 : GDrawSetVisible(qg->gw,false);
135 0 : StartDeltaDisplay(qg);
136 0 : qg->done = true;
137 : }
138 0 : return( true );
139 : }
140 :
141 0 : static int Delta_Cancel(GGadget *g, GEvent *e) {
142 0 : if ( e->type==et_controlevent && e->u.control.subtype == et_buttonactivate ) {
143 0 : QGData *qg = GDrawGetUserData(GGadgetGetWindow(g));
144 0 : qg->done = true;
145 : }
146 0 : return( true );
147 : }
148 :
149 0 : static int delta_e_h(GWindow gw, GEvent *event) {
150 0 : if ( event->type==et_close ) {
151 0 : QGData *qg = GDrawGetUserData(gw);
152 0 : qg->done = true;
153 0 : } else if ( event->type == et_char ) {
154 0 : return( false );
155 0 : } else if ( event->type == et_map ) {
156 : /* Above palettes */
157 0 : GDrawRaise(gw);
158 0 : } else if ( event->type == et_destroy ) {
159 0 : QGData *qg = GDrawGetUserData(gw);
160 0 : free(qg->qg);
161 0 : free(qg);
162 : }
163 0 : return( true );
164 : }
165 :
166 0 : void DeltaSuggestionDlg(FontView *fv,CharView *cv) {
167 : GRect pos;
168 : GWindow gw;
169 : GWindowAttrs wattrs;
170 : GGadgetCreateData gcd[13], boxes[4];
171 : GTextInfo label[13];
172 : GGadgetCreateData *varray[7][5], *barray[9];
173 : char dpi_buffer[40], within_buffer[40];
174 : QGData *data;
175 0 : int failed = false;
176 : int k, r;
177 : FontView *savefv;
178 :
179 0 : if ( !hasFreeType() ) {
180 0 : ff_post_error(_("No FreeType"),_("You must install the freetype library before using this command."));
181 0 : return;
182 : }
183 0 : if ( !hasFreeTypeByteCode() ) {
184 0 : ff_post_error(_("No FreeType"),_("Your version of the freetype library does not contain the bytecode interpreter."));
185 0 : return;
186 : }
187 :
188 0 : if ( delta_sizes==NULL )
189 0 : delta_sizes = copy("7-40,72,80,88,96");
190 :
191 0 : data = calloc(1,sizeof(QGData));
192 0 : data->fv = (FontViewBase *) fv;
193 0 : data->cv = cv;
194 0 : if ( cv!=NULL ) {
195 0 : data->sc = cv->b.sc;
196 0 : savefv = (FontView *) cv->b.fv;
197 0 : data->layer = CVLayer((CharViewBase *) cv);
198 0 : if ( !data->sc->parent->layers[data->layer].order2 )
199 0 : failed = true;
200 0 : if ( !failed && data->sc->ttf_instrs_len==0 )
201 0 : ff_post_notice(_("No Instructions"),_("This glyph has no instructions. Adding instructions (a DELTA) may change its rasterization significantly."));
202 0 : cv->qg = data;
203 0 : cv->note_x = cv->note_y = 32766;
204 : } else {
205 0 : savefv = fv;
206 0 : data->layer = fv->b.active_layer;
207 0 : if ( !fv->b.sf->layers[data->layer].order2 )
208 0 : failed = true;
209 : }
210 0 : if ( failed ) {
211 0 : ff_post_error(_("Not quadratic"),_("This must be a truetype layer."));
212 0 : free(data);
213 0 : if ( cv!=NULL )
214 0 : cv->qg = NULL;
215 0 : return;
216 : }
217 0 : savefv->qg = data;
218 :
219 0 : memset(&wattrs,0,sizeof(wattrs));
220 0 : wattrs.mask = wam_events|wam_cursor|wam_utf8_wtitle|wam_undercursor|wam_isdlg|wam_restrict;
221 0 : wattrs.event_masks = ~(1<<et_charup);
222 0 : wattrs.restrict_input_to_me = 1;
223 0 : wattrs.undercursor = 1;
224 0 : wattrs.cursor = ct_pointer;
225 0 : wattrs.utf8_window_title = _("DELTA suggestions");
226 0 : wattrs.is_dlg = true;
227 0 : pos.x = pos.y = 0;
228 0 : pos.width = GGadgetScale(GDrawPointsToPixels(NULL,190));
229 0 : pos.height = GDrawPointsToPixels(NULL,106);
230 0 : data->gw = gw = GDrawCreateTopWindow(NULL,&pos,delta_e_h,data,&wattrs);
231 :
232 0 : memset(&label,0,sizeof(label));
233 0 : memset(&gcd,0,sizeof(gcd));
234 0 : memset(&boxes,0,sizeof(boxes));
235 :
236 0 : k=r=0;
237 :
238 0 : label[k].text = (unichar_t *) _(
239 : "When a curve passes very close to the center of a\n"
240 : "pixel you might want to check that the curve is on\n"
241 : "the intended side of that pixel.\n"
242 : "If it's on the wrong side, consider using a DELTA\n"
243 : "instruction to adjust the closest point at the\n"
244 : "current pixelsize."
245 : );
246 0 : label[k].text_is_1byte = true;
247 0 : label[k].text_in_resource = true;
248 0 : gcd[k].gd.label = &label[k];
249 0 : gcd[k].gd.flags = gg_enabled|gg_visible;
250 0 : gcd[k++].creator = GLabelCreate;
251 0 : varray[r][0] = &gcd[k-1]; varray[r][1] = GCD_ColSpan; varray[r][2] = GCD_ColSpan; varray[r][3] = GCD_ColSpan; varray[r++][4] = NULL;
252 :
253 0 : label[k].text = (unichar_t *) _("Rasterize at sizes:");
254 0 : label[k].text_is_1byte = true;
255 0 : label[k].text_in_resource = true;
256 0 : gcd[k].gd.label = &label[k];
257 0 : gcd[k].gd.flags = gg_enabled|gg_visible;
258 0 : gcd[k++].creator = GLabelCreate;
259 :
260 0 : label[k].text = (unichar_t *) delta_sizes;
261 0 : label[k].text_is_1byte = true;
262 0 : label[k].text_in_resource = true;
263 0 : gcd[k].gd.label = &label[k];
264 0 : gcd[k].gd.flags = gg_enabled|gg_visible;
265 0 : gcd[k].gd.cid = CID_Sizes;
266 0 : gcd[k++].creator = GTextFieldCreate;
267 0 : varray[r][0] = &gcd[k-2]; varray[r][1] = &gcd[k-1]; varray[r][2] = GCD_ColSpan; varray[r][3] = GCD_ColSpan; varray[r++][4] = NULL;
268 :
269 0 : label[k].text = (unichar_t *) _("DPI:");
270 0 : label[k].text_is_1byte = true;
271 0 : label[k].text_in_resource = true;
272 0 : gcd[k].gd.label = &label[k];
273 0 : gcd[k].gd.flags = gg_enabled|gg_visible;
274 0 : gcd[k++].creator = GLabelCreate;
275 :
276 0 : sprintf( dpi_buffer, "%d", delta_dpi );
277 0 : label[k].text = (unichar_t *) dpi_buffer;
278 0 : label[k].text_is_1byte = true;
279 0 : label[k].text_in_resource = true;
280 0 : gcd[k].gd.label = &label[k];
281 0 : gcd[k].gd.pos.width = 40;
282 0 : gcd[k].gd.cid = CID_DPI;
283 0 : gcd[k].gd.flags = gg_enabled|gg_visible;
284 0 : gcd[k++].creator = GTextFieldCreate;
285 :
286 0 : label[k].text = (unichar_t *) _("_Mono");
287 0 : label[k].text_is_1byte = true;
288 0 : label[k].text_in_resource = true;
289 0 : gcd[k].gd.label = &label[k];
290 0 : gcd[k].gd.flags = delta_depth==1 ? (gg_enabled|gg_visible|gg_cb_on) : (gg_enabled|gg_visible);
291 0 : gcd[k].gd.cid = CID_BW;
292 0 : gcd[k++].creator = GRadioCreate;
293 0 : varray[r][0] = &gcd[k-1]; varray[r][1] = GCD_HPad10;
294 :
295 0 : label[k].text = (unichar_t *) _("_Anti-Aliased");
296 0 : label[k].text_is_1byte = true;
297 0 : label[k].text_in_resource = true;
298 0 : gcd[k].gd.label = &label[k];
299 0 : gcd[k].gd.flags = delta_depth!=1 ? (gg_enabled|gg_visible|gg_cb_on) : (gg_enabled|gg_visible);
300 0 : gcd[k++].creator = GRadioCreate;
301 0 : varray[r][0] = &gcd[k-4]; varray[r][1] = &gcd[k-3]; varray[r][2] = &gcd[k-2]; varray[r][3] = &gcd[k-1]; varray[r++][4] = NULL;
302 :
303 0 : label[k].text = (unichar_t *) _("Proximity:");
304 0 : label[k].text_is_1byte = true;
305 0 : label[k].text_in_resource = true;
306 0 : gcd[k].gd.label = &label[k];
307 0 : gcd[k].gd.flags = gg_enabled|gg_visible;
308 0 : gcd[k++].creator = GLabelCreate;
309 :
310 0 : sprintf( within_buffer, "%g", delta_within );
311 0 : label[k].text = (unichar_t *) within_buffer;
312 0 : label[k].text_is_1byte = true;
313 0 : label[k].text_in_resource = true;
314 0 : gcd[k].gd.label = &label[k];
315 0 : gcd[k].gd.flags = gg_enabled|gg_visible;
316 0 : gcd[k].gd.pos.width = 40;
317 0 : gcd[k].gd.cid = CID_Within;
318 0 : gcd[k++].creator = GTextFieldCreate;
319 :
320 0 : label[k].text = (unichar_t *) _("pixels");
321 0 : label[k].text_is_1byte = true;
322 0 : label[k].text_in_resource = true;
323 0 : gcd[k].gd.label = &label[k];
324 0 : gcd[k].gd.flags = gg_enabled|gg_visible;
325 0 : gcd[k++].creator = GLabelCreate;
326 0 : varray[r][0] = &gcd[k-3]; varray[r][1] = &gcd[k-2]; varray[r][2] = &gcd[k-1]; varray[r][3] = GCD_ColSpan; varray[r++][4] = NULL;
327 :
328 0 : label[k].text = (unichar_t *) _( "This may take a while. Please be patient..." );
329 0 : label[k].text_is_1byte = true;
330 0 : label[k].text_in_resource = true;
331 0 : gcd[k].gd.label = &label[k];
332 0 : gcd[k].gd.flags = gg_enabled;
333 0 : gcd[k].gd.cid = CID_Msg;
334 0 : gcd[k++].creator = GLabelCreate;
335 0 : varray[r][0] = &gcd[k-1]; varray[r][1] = GCD_ColSpan; varray[r][2] = GCD_ColSpan; varray[r][3] = GCD_ColSpan; varray[r++][4] = NULL;
336 :
337 0 : gcd[k].gd.flags = gg_visible | gg_enabled | gg_but_default;
338 0 : label[k].text = (unichar_t *) _("_OK");
339 0 : label[k].text_is_1byte = true;
340 0 : label[k].text_in_resource = true;
341 0 : gcd[k].gd.label = &label[k];
342 0 : gcd[k].gd.handle_controlevent = Delta_OK;
343 0 : gcd[k].gd.cid = CID_Ok;
344 0 : gcd[k++].creator = GButtonCreate;
345 0 : barray[0] = GCD_Glue; barray[1] = &gcd[k-1]; barray[2] = GCD_Glue;
346 :
347 0 : gcd[k].gd.flags = gg_visible | gg_enabled | gg_but_cancel;
348 0 : label[k].text = (unichar_t *) _("_Cancel");
349 0 : label[k].text_is_1byte = true;
350 0 : label[k].text_in_resource = true;
351 0 : gcd[k].gd.label = &label[k];
352 0 : gcd[k].gd.handle_controlevent = Delta_Cancel;
353 0 : gcd[k].gd.cid = CID_Cancel;
354 0 : gcd[k++].creator = GButtonCreate;
355 0 : barray[3] = GCD_Glue; barray[4] = &gcd[k-1]; barray[5] = GCD_Glue; barray[6] = NULL;
356 :
357 0 : boxes[2].gd.flags = gg_enabled|gg_visible;
358 0 : boxes[2].gd.u.boxelements = barray;
359 0 : boxes[2].creator = GHBoxCreate;
360 0 : varray[r][0] = &boxes[2]; varray[r][1] = GCD_ColSpan; varray[r][2] = GCD_ColSpan; varray[r][3] = GCD_ColSpan; varray[r++][4] = NULL;
361 0 : varray[r][0] = NULL;
362 :
363 0 : boxes[0].gd.pos.x = boxes[0].gd.pos.y = 2;
364 0 : boxes[0].gd.flags = gg_enabled|gg_visible;
365 0 : boxes[0].gd.u.boxelements = varray[0];
366 0 : boxes[0].gd.cid = CID_Top;
367 0 : boxes[0].creator = GHVGroupCreate;
368 :
369 :
370 0 : GGadgetsCreate(gw,boxes);
371 0 : GHVBoxFitWindow(boxes[0].ret);
372 :
373 0 : GDrawSetVisible(gw,true);
374 0 : while ( !data->done )
375 0 : GDrawProcessOneEvent(NULL);
376 0 : GDrawDestroyWindow(gw);
377 0 : if ( data->cv!=NULL )
378 0 : data->cv->qg = NULL;
379 0 : if ( savefv->qg == data )
380 0 : savefv->qg = NULL;
381 : }
382 :
383 0 : void QGRmCharView(QGData *qg,CharView *cv) {
384 0 : if ( qg->cv==cv )
385 0 : qg->cv = NULL;
386 0 : }
387 :
388 0 : void QGRmFontView(QGData *qg,FontView *fv) {
389 0 : qg->done = true;
390 0 : fv->qg = NULL;
391 0 : }
392 : /* ************************************************************************** */
393 : /* ************************************************************************** */
394 :
395 : #define CID_Sort 200
396 : #define CID_GlyphSort 201
397 :
398 : static GTextInfo sorts[] = {
399 : { (unichar_t *) N_("Glyph, Size, Point"), NULL, 0, 0, (void *) is_glyph_size_pt, NULL, 0, 0, 0, 0, 0, 0, 1, 0, 0, '\0' },
400 : { (unichar_t *) N_("Glyph, Point, Size"), NULL, 0, 0, (void *) is_glyph_pt_size, NULL, 0, 0, 0, 0, 0, 0, 1, 0, 0, '\0' },
401 : { (unichar_t *) N_("Size, Glyph, Point"), NULL, 0, 0, (void *) is_size_glyph_pt, NULL, 0, 0, 0, 0, 0, 0, 1, 0, 0, '\0' },
402 : GTEXTINFO_EMPTY
403 : };
404 : static GTextInfo glyphsorts[] = {
405 : { (unichar_t *) N_("Unicode"), NULL, 0, 0, (void *) gs_unicode, NULL, 0, 0, 0, 0, 0, 0, 1, 0, 0, '\0' },
406 : { (unichar_t *) N_("Sort|Alphabetic"), NULL, 0, 0, (void *) gs_alpha, NULL, 0, 0, 0, 0, 0, 0, 1, 0, 0, '\0' },
407 : { (unichar_t *) N_("Glyph Order"), NULL, 0, 0, (void *) gs_gid, NULL, 0, 0, 0, 0, 0, 0, 1, 0, 0, '\0' },
408 : GTEXTINFO_EMPTY
409 : };
410 :
411 0 : static int QG_VScroll(GGadget *g, GEvent *e) {
412 0 : QGData *qg = GDrawGetUserData(GGadgetGetWindow(g));
413 0 : int newpos = qg->loff_top;
414 :
415 0 : switch( e->u.control.u.sb.type ) {
416 : case et_sb_top:
417 0 : newpos = 0;
418 0 : break;
419 : case et_sb_uppage:
420 0 : newpos -= 9*qg->vlcnt/10;
421 0 : break;
422 : case et_sb_up:
423 0 : newpos -= qg->vlcnt/15;
424 0 : break;
425 : case et_sb_down:
426 0 : newpos += qg->vlcnt/15;
427 0 : break;
428 : case et_sb_downpage:
429 0 : newpos += 9*qg->vlcnt/10;
430 0 : break;
431 : case et_sb_bottom:
432 0 : newpos = 0;
433 0 : break;
434 : case et_sb_thumb:
435 : case et_sb_thumbrelease:
436 0 : newpos = e->u.control.u.sb.pos;
437 0 : break;
438 : case et_sb_halfup:
439 0 : newpos -= qg->vlcnt/30;
440 0 : break;
441 : case et_sb_halfdown:
442 0 : newpos += qg->vlcnt/30;
443 0 : break;
444 : }
445 0 : if ( newpos + qg->vlcnt > qg->lcnt )
446 0 : newpos = qg->lcnt-qg->vlcnt;
447 0 : if ( newpos<0 )
448 0 : newpos = 0;
449 0 : if ( qg->loff_top!=newpos ) {
450 0 : qg->loff_top = newpos;
451 0 : GScrollBarSetPos(qg->vsb,newpos);
452 0 : GDrawRequestExpose(qg->v,NULL,false);
453 : }
454 0 : return( true );
455 : }
456 :
457 0 : static void QG_SetSb(QGData *qg) {
458 0 : if ( qg->loff_top + qg->vlcnt > qg->lcnt )
459 0 : qg->loff_top = qg->lcnt-qg->vlcnt;
460 0 : if ( qg->loff_top<0 )
461 0 : qg->loff_top = 0;
462 0 : GScrollBarSetBounds(qg->vsb,0,qg->lcnt,qg->vlcnt);
463 0 : GScrollBarSetPos(qg->vsb,qg->loff_top);
464 0 : }
465 :
466 0 : static int QG_Count(struct qgnode *parent) {
467 0 : int l, cnt=0;
468 :
469 0 : if ( !parent->open )
470 0 : return( 0 );
471 0 : if ( parent->kids==NULL )
472 0 : return( parent->qg_cnt );
473 :
474 0 : for ( l=0; l<parent->kid_cnt; ++l ) {
475 0 : parent->kids[l].tot_under = QG_Count(&parent->kids[l]);
476 0 : cnt += 1 + parent->kids[l].tot_under;
477 : }
478 0 : return( cnt );
479 : }
480 :
481 0 : static void QG_Remetric(QGData *qg) {
482 : GRect size;
483 :
484 0 : GDrawGetSize(qg->v,&size);
485 0 : qg->vlcnt = size.height/qg->fh;
486 0 : qg->lcnt = QG_Count(&qg->list);
487 0 : QG_SetSb(qg);
488 0 : }
489 :
490 : struct navigate {
491 : struct qgnode *parent;
492 : int offset; /* offset of -1 means the qgnode */
493 : };
494 :
495 0 : static void QG_FindLine(struct qgnode *parent, int l,struct navigate *where) {
496 : int k;
497 :
498 0 : if ( parent->kids == NULL ) {
499 0 : if ( l<parent->qg_cnt ) {
500 0 : where->parent = parent;
501 0 : where->offset = l;
502 : } else {
503 0 : where->parent = NULL;
504 0 : where->offset = -1;
505 : }
506 0 : return;
507 : }
508 0 : for ( k=0; k<parent->kid_cnt; ++k ) {
509 0 : if ( l==0 ) {
510 0 : where->parent = &parent->kids[k];
511 0 : where->offset = -1;
512 0 : return;
513 : }
514 0 : --l;
515 0 : if ( parent->kids[k].open ) {
516 0 : if ( l<parent->kids[k].tot_under ) {
517 0 : QG_FindLine(&parent->kids[k],l,where);
518 0 : return;
519 : } else
520 0 : l -= parent->kids[k].tot_under;
521 : }
522 : }
523 0 : where->parent = NULL;
524 0 : where->offset = -1;
525 : }
526 :
527 0 : static void QG_NextLine(struct navigate *where) {
528 : int k;
529 :
530 0 : if ( where->parent==NULL )
531 0 : return;
532 0 : if ( where->offset!=-1 && where->offset+1<where->parent->qg_cnt ) {
533 0 : ++where->offset;
534 0 : return;
535 : }
536 0 : if ( where->parent->open && where->offset==-1 ) {
537 0 : if ( where->parent->kids==NULL ) {
538 0 : where->offset = 0;
539 0 : return;
540 : } else {
541 0 : where->parent = &where->parent->kids[0];
542 0 : where->offset = -1;
543 0 : return;
544 : }
545 : }
546 : for (;;) {
547 0 : if ( where->parent->parent==NULL ) {
548 0 : where->parent = NULL;
549 0 : where->offset = -1;
550 0 : return;
551 : }
552 0 : k = where->parent - where->parent->parent->kids;
553 0 : if ( k+1< where->parent->parent->kid_cnt ) {
554 0 : ++where->parent;
555 0 : where->offset = -1;
556 0 : return;
557 : }
558 0 : where->parent = where->parent->parent;
559 0 : }
560 : }
561 :
562 0 : static void qgnodeFree(struct qgnode *parent) {
563 : int i;
564 :
565 0 : for ( i=0; i<parent->kid_cnt; ++i )
566 0 : qgnodeFree(&parent->kids[i]);
567 0 : free(parent->kids);
568 0 : free(parent->name);
569 0 : }
570 :
571 : static const QGData *kludge;
572 :
573 0 : static int qg_sorter(const void *pt1, const void *pt2) {
574 0 : const QuestionableGrid *q1 = pt1, *q2 = pt2;
575 0 : const QGData *qg = kludge;
576 0 : int pt_cmp = q1->nearestpt - q2->nearestpt;
577 0 : int size_cmp = q1->size - q2->size;
578 : int g_cmp;
579 : int t1, t2, t3;
580 :
581 0 : switch ( qg->glyph_sort ) {
582 : case gs_unicode:
583 0 : g_cmp = q1->sc->unicodeenc - q2->sc->unicodeenc;
584 0 : break;
585 : case gs_gid:
586 0 : g_cmp = q1->sc->orig_pos - q2->sc->orig_pos;
587 0 : break;
588 : case gs_alpha:
589 0 : g_cmp = strcmp(q1->sc->name,q2->sc->name);
590 0 : break;
591 : }
592 0 : switch ( qg->info_sort ) {
593 : case is_glyph_size_pt:
594 0 : t1 = g_cmp; t2 = size_cmp; t3 = pt_cmp;
595 0 : break;
596 : case is_glyph_pt_size:
597 0 : t1 = g_cmp; t2 = pt_cmp; t3 = size_cmp;
598 0 : break;
599 : case is_size_glyph_pt:
600 0 : t1 = size_cmp; t2 = g_cmp; t3 = pt_cmp;
601 0 : break;
602 : }
603 0 : if ( t1!=0 )
604 0 : return( t1 );
605 0 : if ( t2!=0 )
606 0 : return( t2 );
607 :
608 0 : return( t3 );
609 : }
610 :
611 0 : static void QGSecondLevel(QGData *qg, struct qgnode *parent) {
612 : int cnt, l, lstart;
613 : int size;
614 : SplineChar *sc;
615 : int pt;
616 : char buffer[200];
617 :
618 0 : switch ( qg->info_sort ) {
619 : case is_glyph_size_pt: /* size */
620 0 : size = -1;
621 0 : cnt = 0;
622 0 : for ( l=0; l<parent->qg_cnt; ++l ) {
623 0 : if ( size!=parent->first[l].size ) {
624 0 : ++cnt;
625 0 : size = parent->first[l].size;
626 : }
627 : }
628 0 : parent->kid_cnt = cnt;
629 0 : parent->kids = calloc(cnt,sizeof(struct qgnode));
630 0 : cnt = 0;
631 0 : lstart = 0; size=-1;
632 0 : for ( l=0; l<parent->qg_cnt; ++l ) {
633 0 : if ( size!=parent->first[l].size && size!=-1 ) {
634 0 : sprintf( buffer, _("Size: %d (%d)"), size, l-lstart );
635 0 : parent->kids[cnt].name = copy(buffer);
636 0 : parent->kids[cnt].parent = parent;
637 0 : parent->kids[cnt].first = &parent->first[lstart];
638 0 : parent->kids[cnt].qg_cnt = l-lstart;
639 0 : ++cnt;
640 0 : lstart = l;
641 0 : size = parent->first[l].size;
642 0 : } else if ( size!=parent->first[l].size )
643 0 : size = parent->first[l].size;
644 : }
645 0 : if ( size!=-1 ) {
646 0 : sprintf( buffer, _("Size: %d (%d)"), size, l-lstart );
647 0 : parent->kids[cnt].name = copy(buffer);
648 0 : parent->kids[cnt].parent = parent;
649 0 : parent->kids[cnt].first = &parent->first[lstart];
650 0 : parent->kids[cnt].qg_cnt = l-lstart;
651 : }
652 0 : break;
653 : case is_glyph_pt_size: /* pt */
654 0 : pt = -1;
655 0 : cnt = 0;
656 0 : for ( l=0; l<parent->qg_cnt; ++l ) {
657 0 : if ( pt!=parent->first[l].nearestpt ) {
658 0 : ++cnt;
659 0 : pt = parent->first[l].nearestpt;
660 : }
661 : }
662 0 : parent->kid_cnt = cnt;
663 0 : parent->kids = calloc(cnt,sizeof(struct qgnode));
664 0 : cnt = 0;
665 0 : lstart = 0; pt=-1;
666 0 : for ( l=0; l<parent->qg_cnt; ++l ) {
667 0 : if ( pt!=parent->first[l].nearestpt && pt!=-1 ) {
668 0 : sprintf( buffer, _("Point: %d (%d)"), pt, l-lstart );
669 0 : parent->kids[cnt].name = copy(buffer);
670 0 : parent->kids[cnt].parent = parent;
671 0 : parent->kids[cnt].first = &parent->first[lstart];
672 0 : parent->kids[cnt].qg_cnt = l-lstart;
673 0 : ++cnt;
674 0 : lstart = l;
675 0 : pt = parent->first[l].nearestpt;
676 0 : } else if ( pt!=parent->first[l].nearestpt )
677 0 : pt = parent->first[l].nearestpt;
678 : }
679 0 : if ( pt!=-1 ) {
680 0 : sprintf( buffer, _("Point: %d (%d)"), pt, l-lstart );
681 0 : parent->kids[cnt].name = copy(buffer);
682 0 : parent->kids[cnt].parent = parent;
683 0 : parent->kids[cnt].first = &parent->first[lstart];
684 0 : parent->kids[cnt].qg_cnt = l-lstart;
685 : }
686 0 : break;
687 : case is_size_glyph_pt: /* glyph */
688 0 : sc = NULL;
689 0 : cnt = 0;
690 0 : for ( l=0; l<parent->qg_cnt; ++l ) {
691 0 : if ( sc!=parent->first[l].sc ) {
692 0 : ++cnt;
693 0 : sc = parent->first[l].sc;
694 : }
695 : }
696 0 : parent->kid_cnt = cnt;
697 0 : parent->kids = calloc(cnt,sizeof(struct qgnode));
698 0 : cnt = 0;
699 0 : lstart = 0;
700 0 : sc = NULL;
701 0 : for ( l=0; l<parent->qg_cnt; ++l ) {
702 0 : if ( sc!=parent->first[l].sc && sc!=NULL ) {
703 0 : sprintf( buffer, "\"%.40s\" (%d)", sc->name, l-lstart );
704 0 : parent->kids[cnt].name = copy(buffer);
705 0 : parent->kids[cnt].parent = parent;
706 0 : parent->kids[cnt].first = &parent->first[lstart];
707 0 : parent->kids[cnt].qg_cnt = l-lstart;
708 0 : ++cnt;
709 0 : lstart = l;
710 0 : sc = parent->first[l].sc;
711 0 : } else if ( sc!=parent->first[l].sc )
712 0 : sc = parent->first[l].sc;
713 : }
714 0 : if ( sc!=NULL ) {
715 0 : sprintf( buffer, "\"%.40s\" (%d)", sc->name, l-lstart );
716 0 : parent->kids[cnt].name = copy(buffer);
717 0 : parent->kids[cnt].parent = parent;
718 0 : parent->kids[cnt].first = &parent->first[lstart];
719 0 : parent->kids[cnt].qg_cnt = l-lstart;
720 : }
721 0 : break;
722 : }
723 0 : }
724 :
725 0 : static void QGDoSort(QGData *qg) {
726 : int pos, l, k, cnt, lstart;
727 : char buffer[200];
728 :
729 0 : pos = GGadgetGetFirstListSelectedItem(GWidgetGetControl(qg->gw,CID_Sort));
730 0 : qg->info_sort = (intpt) sorts[pos].userdata;
731 :
732 0 : pos = GGadgetGetFirstListSelectedItem(GWidgetGetControl(qg->gw,CID_GlyphSort));
733 0 : qg->glyph_sort = (intpt) glyphsorts[pos].userdata;
734 :
735 0 : kludge = qg;
736 0 : qsort(qg->qg,qg->cur,sizeof(QuestionableGrid),qg_sorter);
737 :
738 0 : qgnodeFree(&qg->list);
739 0 : memset(&qg->list,0,sizeof(struct qgnode));
740 0 : qg->list.open = true;
741 0 : qg->list.first = qg->qg;
742 0 : if ( qg->info_sort == is_glyph_size_pt || qg->info_sort == is_glyph_pt_size ) {
743 0 : SplineChar *sc = NULL;
744 0 : cnt = 0;
745 0 : for ( l=0; l<qg->cur; ++l ) {
746 0 : if ( sc!=qg->qg[l].sc ) {
747 0 : ++cnt;
748 0 : sc = qg->qg[l].sc;
749 : }
750 : }
751 0 : qg->list.kid_cnt = cnt;
752 0 : qg->list.kids = calloc(cnt,sizeof(struct qgnode));
753 0 : cnt = 0;
754 0 : lstart = 0; sc=NULL;
755 0 : for ( l=0; l<qg->cur; ++l ) {
756 0 : if ( sc!=qg->qg[l].sc && sc!=NULL ) {
757 0 : sprintf( buffer, "\"%.40s\" (%d)", sc->name, l-lstart );
758 0 : qg->list.kids[cnt].name = copy(buffer);
759 0 : qg->list.kids[cnt].parent = &qg->list;
760 0 : qg->list.kids[cnt].first = &qg->qg[lstart];
761 0 : qg->list.kids[cnt].qg_cnt = l-lstart;
762 0 : ++cnt;
763 0 : lstart = l;
764 0 : sc = qg->qg[l].sc;
765 0 : } else if ( sc!=qg->qg[l].sc )
766 0 : sc = qg->qg[l].sc;
767 : }
768 0 : if ( sc!=NULL ) {
769 0 : sprintf( buffer, "\"%.40s\" (%d)", sc->name, l-lstart );
770 0 : qg->list.kids[cnt].name = copy(buffer);
771 0 : qg->list.kids[cnt].parent = &qg->list;
772 0 : qg->list.kids[cnt].first = &qg->qg[lstart];
773 0 : qg->list.kids[cnt].qg_cnt = l-lstart;
774 : }
775 : } else {
776 0 : int size = -1;
777 0 : cnt = 0;
778 0 : for ( l=0; l<qg->cur; ++l ) {
779 0 : if ( size!=qg->qg[l].size ) {
780 0 : ++cnt;
781 0 : size = qg->qg[l].size;
782 : }
783 : }
784 0 : qg->list.kid_cnt = cnt;
785 0 : qg->list.kids = calloc(cnt,sizeof(struct qgnode));
786 0 : cnt = 0;
787 0 : lstart = 0; size=-1;
788 0 : for ( l=0; l<qg->cur; ++l ) {
789 0 : if ( size!=qg->qg[l].size && size!=-1 ) {
790 0 : sprintf( buffer, _("Size: %d (%d)"), size, l-lstart );
791 0 : qg->list.kids[cnt].name = copy(buffer);
792 0 : qg->list.kids[cnt].parent = &qg->list;
793 0 : qg->list.kids[cnt].first = &qg->qg[lstart];
794 0 : qg->list.kids[cnt].qg_cnt = l-lstart;
795 0 : ++cnt;
796 0 : lstart = l;
797 0 : size = qg->qg[l].size;
798 0 : } else if ( size!=qg->qg[l].size )
799 0 : size = qg->qg[l].size;
800 : }
801 0 : if ( size!=-1 ) {
802 0 : sprintf( buffer, _("Size: %d (%d)"), size, l-lstart );
803 0 : qg->list.kids[cnt].name = copy(buffer);
804 0 : qg->list.kids[cnt].parent = &qg->list;
805 0 : qg->list.kids[cnt].first = &qg->qg[lstart];
806 0 : qg->list.kids[cnt].qg_cnt = l-lstart;
807 : }
808 : }
809 0 : if ( qg->list.kid_cnt==1 )
810 0 : qg->list.kids[0].open = true;
811 0 : for ( k=0; k<qg->list.kid_cnt; ++k )
812 0 : QGSecondLevel(qg,&qg->list.kids[k]);
813 0 : QG_Remetric(qg);
814 0 : }
815 :
816 0 : static int QGSorter(GGadget *g, GEvent *e) {
817 0 : if ( e->u.control.subtype == et_listselected ) {
818 0 : QGData *qg = GDrawGetUserData(GGadgetGetWindow(g));
819 0 : QGDoSort(qg);
820 0 : GDrawRequestExpose(qg->v,NULL,false);
821 : }
822 0 : return( true );
823 : }
824 :
825 0 : static void QGDrawWindow(GWindow pixmap, QGData *qg, GEvent *e) {
826 : int l, y, depth;
827 : char buffer[200];
828 : GRect old, r;
829 : struct navigate where;
830 : struct qgnode *parent;
831 :
832 0 : GDrawPushClip(pixmap,&e->u.expose.rect,&old);
833 0 : r.width = r.height = qg->as;
834 0 : y = qg->as;
835 0 : memset(&where,0,sizeof(where));
836 0 : QG_FindLine(&qg->list,qg->loff_top,&where);
837 :
838 0 : for ( l=0; l<qg->vlcnt && where.parent!=NULL; ++l ) {
839 0 : for ( parent=where.parent, depth= -2; parent!=NULL; parent=parent->parent, ++depth );
840 0 : if ( where.offset==-1 ) {
841 0 : r.x = 2+depth*qg->fh; r.y = y-qg->as+1;
842 0 : GDrawDrawRect(pixmap,&r,0x000000);
843 0 : GDrawDrawLine(pixmap,r.x+2,r.y+qg->as/2,r.x+qg->as-2,r.y+qg->as/2,
844 : 0x000000);
845 0 : if ( !where.parent->open )
846 0 : GDrawDrawLine(pixmap,r.x+qg->as/2,r.y+2,r.x+qg->as/2,r.y+qg->as-2,
847 : 0x000000);
848 0 : GDrawDrawText8(pixmap,r.x+qg->fh,y,where.parent->name,-1, 0x000000);
849 : } else {
850 0 : QuestionableGrid *q = &where.parent->first[where.offset];
851 0 : sprintf( buffer, _("\"%.40s\" size=%d point=%d (%d,%d) distance=%g"),
852 0 : q->sc->name, q->size, q->nearestpt, q->x, q->y, q->distance );
853 0 : GDrawDrawText8(pixmap,2+(depth+1)*qg->fh,y,buffer,-1, 0x000000);
854 : }
855 0 : y += qg->fh;
856 0 : QG_NextLine(&where);
857 : }
858 0 : GDrawPopClip(pixmap,&old);
859 0 : }
860 :
861 0 : static void QGMouse( QGData *qg, GEvent *e) {
862 0 : int l = qg->loff_top + e->u.mouse.y/qg->fh;
863 : struct navigate where;
864 :
865 0 : if ( (e->type == et_mousedown) && (e->u.mouse.button==1)) {
866 0 : memset(&where,0,sizeof(where));
867 0 : QG_FindLine(&qg->list,l,&where);
868 0 : if ( where.parent==NULL )
869 0 : return;
870 0 : if ( where.offset==-1 ) {
871 0 : where.parent->open = !where.parent->open;
872 0 : QG_Remetric(qg);
873 0 : GDrawRequestExpose(qg->v,NULL,false);
874 0 : return;
875 : } else {
876 0 : QuestionableGrid *q = &where.parent->first[where.offset];
877 : CharView *cv;
878 0 : if ( qg->inprocess )
879 0 : return;
880 0 : cv = qg->cv;
881 0 : if ( cv==NULL && qg->fv!=NULL ) {
882 0 : qg->inprocess = true;
883 0 : cv = qg->cv = CharViewCreate(q->sc,(FontView *) (qg->fv),qg->fv->map->backmap[q->sc->orig_pos]);
884 0 : if ( qg->layer == ly_fore ) {
885 0 : cv->b.drawmode = dm_fore;
886 : } else {
887 0 : cv->b.layerheads[dm_back] = &qg->sc->layers[qg->layer];
888 0 : cv->b.drawmode = dm_back;
889 : }
890 0 : cv->qg = qg;
891 0 : qg->inprocess = false;
892 0 : } else if ( qg->cv==NULL )
893 0 : return;
894 0 : else if ( qg->cv->b.sc != q->sc ) {
895 0 : CVChangeSC(qg->cv,q->sc);
896 : }
897 0 : cv->ft_pointsizex = cv->ft_pointsizey = q->size;
898 0 : cv->ft_ppemy = cv->ft_ppemx = rint(q->size*qg->dpi/72.0);
899 0 : cv->ft_dpi = qg->dpi;
900 0 : cv->ft_depth = qg->depth;
901 0 : cv->note_x = q->x; cv->note_y = q->y;
902 0 : cv->show_ft_results = true; cv->showgrids = true;
903 0 : CVGridFitChar(cv);
904 : }
905 : }
906 : }
907 :
908 0 : static int qgv_e_h(GWindow gw, GEvent *event) {
909 0 : QGData *qg = (QGData *) GDrawGetUserData(gw);
910 :
911 0 : switch ( event->type ) {
912 : case et_expose:
913 0 : QGDrawWindow(gw,qg,event);
914 0 : break;
915 : case et_mouseup:
916 : case et_mousedown:
917 : case et_mousemove:
918 0 : QGMouse(qg,event);
919 0 : break;
920 : case et_char:
921 0 : return( false );
922 : break;
923 : case et_resize: {
924 0 : int vlcnt = event->u.resize.size.height/qg->fh;
925 0 : qg->vlcnt = vlcnt;
926 0 : QG_SetSb(qg);
927 0 : GDrawRequestExpose(qg->v,NULL,false);
928 0 : } break;
929 : }
930 0 : return( true );
931 : }
932 :
933 0 : static int QG_OK(GGadget *g, GEvent *e) {
934 :
935 0 : if ( e->type==et_controlevent && e->u.control.subtype == et_buttonactivate ) {
936 0 : QGData *qg = GDrawGetUserData(GGadgetGetWindow(g));
937 0 : qg->done = true;
938 : }
939 0 : return( true );
940 : }
941 :
942 0 : static int qg_e_h(GWindow gw, GEvent *event) {
943 :
944 0 : if ( event->type==et_close ) {
945 0 : QGData *qg = (QGData *) GDrawGetUserData(gw);
946 0 : qg->done = true;
947 0 : } else if ( event->type == et_char ) {
948 0 : return( false );
949 : }
950 0 : return( true );
951 : }
952 :
953 0 : static void StartDeltaDisplay(QGData *qg) {
954 : GWindowAttrs wattrs;
955 : GRect pos;
956 0 : GWindow gw, oldgw = qg->gw;
957 : GGadgetCreateData gcd[8], boxes[5], *harray[4], *harray2[5], *butarray[8],
958 : *varray[4];
959 : GTextInfo label[8];
960 : int i, k;
961 : FontRequest rq;
962 : int as, ds, ld;
963 : static GFont *valfont=NULL;
964 : static int sorts_translated = 0;
965 :
966 0 : if (!sorts_translated)
967 : {
968 0 : for (i=0; i<sizeof(sorts)/sizeof(sorts[0]); i++)
969 0 : sorts[i].text = (unichar_t *) _((char *) sorts[i].text);
970 0 : for (i=0; i<sizeof(glyphsorts)/sizeof(glyphsorts[0]); i++)
971 0 : glyphsorts[i].text = (unichar_t *) _((char *) glyphsorts[i].text);
972 0 : sorts_translated=1;
973 : }
974 :
975 0 : memset(&wattrs,0,sizeof(wattrs));
976 0 : wattrs.mask = wam_events|wam_cursor|wam_utf8_wtitle|wam_undercursor|wam_isdlg;
977 0 : wattrs.event_masks = -1;
978 0 : wattrs.cursor = ct_mypointer;
979 0 : wattrs.utf8_window_title = _("Potential spots for Delta instructions");
980 0 : wattrs.is_dlg = true;
981 0 : wattrs.undercursor = 1;
982 0 : pos.x = pos.y = 0;
983 0 : pos.width = GDrawPointsToPixels(NULL,200);
984 0 : pos.height = GDrawPointsToPixels(NULL,300);
985 0 : qg->gw = gw = GDrawCreateTopWindow(NULL,&pos,qg_e_h,qg,&wattrs);
986 0 : qg->done = false;
987 :
988 0 : if ( valfont==NULL ) {
989 0 : memset(&rq,0,sizeof(rq));
990 0 : rq.utf8_family_name = "Helvetica";
991 0 : rq.point_size = 11;
992 0 : rq.weight = 400;
993 0 : valfont = GDrawInstanciateFont(gw,&rq);
994 0 : valfont = GResourceFindFont("Validate.Font",valfont);
995 : }
996 0 : qg->font = valfont;
997 0 : GDrawWindowFontMetrics(gw,qg->font,&as,&ds,&ld);
998 0 : qg->fh = as+ds;
999 0 : qg->as = as;
1000 :
1001 0 : memset(&label,0,sizeof(label));
1002 0 : memset(&gcd,0,sizeof(gcd));
1003 0 : memset(&boxes,0,sizeof(boxes));
1004 :
1005 0 : k = 0;
1006 0 : label[k].text = (unichar_t *) _("Sort:");
1007 0 : label[k].text_is_1byte = true;
1008 0 : gcd[k].gd.label = &label[k];
1009 0 : gcd[k].gd.flags = gg_enabled|gg_visible;
1010 0 : gcd[k++].creator = GLabelCreate;
1011 :
1012 0 : sorts[0].selected = true; sorts[1].selected = sorts[2].selected = false;
1013 0 : sorts[2].disabled = qg->fv==NULL;
1014 0 : gcd[k].gd.u.list = sorts;
1015 0 : gcd[k].gd.cid = CID_Sort;
1016 0 : gcd[k].gd.flags = gg_enabled|gg_visible;
1017 0 : gcd[k].gd.handle_controlevent = QGSorter;
1018 0 : gcd[k++].creator = GListButtonCreate;
1019 :
1020 0 : label[k].text = (unichar_t *) _("Glyph:");
1021 0 : label[k].text_is_1byte = true;
1022 0 : gcd[k].gd.label = &label[k];
1023 0 : gcd[k].gd.flags = gg_enabled|gg_visible;
1024 0 : gcd[k++].creator = GLabelCreate;
1025 :
1026 0 : gcd[k].gd.u.list = glyphsorts;
1027 0 : gcd[k].gd.flags = gg_enabled|gg_visible;
1028 0 : gcd[k].gd.cid = CID_GlyphSort;
1029 0 : gcd[k].gd.handle_controlevent = QGSorter;
1030 0 : gcd[k++].creator = GListButtonCreate;
1031 0 : if ( qg->fv==NULL )
1032 0 : gcd[k-1].gd.flags = gcd[k-2].gd.flags = gg_enabled;
1033 0 : harray2[0] = &gcd[k-4]; harray2[1] = &gcd[k-3]; harray2[2] = &gcd[k-2]; harray2[3] = &gcd[k-1]; harray2[4] = NULL;
1034 :
1035 :
1036 0 : gcd[k].gd.flags = gg_visible | gg_enabled;
1037 0 : gcd[k].gd.u.drawable_e_h = qgv_e_h;
1038 0 : gcd[k++].creator = GDrawableCreate;
1039 :
1040 0 : gcd[k].gd.flags = gg_visible | gg_enabled | gg_sb_vert;
1041 0 : gcd[k].gd.handle_controlevent = QG_VScroll;
1042 0 : gcd[k++].creator = GScrollBarCreate;
1043 0 : harray[0] = &gcd[k-2]; harray[1] = &gcd[k-1]; harray[2] = NULL; harray[3] = NULL;
1044 :
1045 0 : gcd[k].gd.flags = gg_visible | gg_enabled | gg_but_default;
1046 0 : label[k].text = (unichar_t *) _("_OK");
1047 0 : label[k].text_is_1byte = true;
1048 0 : label[k].text_in_resource = true;
1049 0 : gcd[k].gd.label = &label[k];
1050 0 : gcd[k].gd.handle_controlevent = QG_OK;
1051 0 : gcd[k++].creator = GButtonCreate;
1052 0 : butarray[0] = GCD_Glue; butarray[1] = &gcd[k-1]; butarray[2] = GCD_Glue; butarray[3] = NULL;
1053 :
1054 0 : boxes[2].gd.flags = gg_enabled|gg_visible;
1055 0 : boxes[2].gd.u.boxelements = harray;
1056 0 : boxes[2].creator = GHVGroupCreate;
1057 :
1058 0 : boxes[3].gd.flags = gg_enabled|gg_visible;
1059 0 : boxes[3].gd.u.boxelements = butarray;
1060 0 : boxes[3].creator = GHBoxCreate;
1061 :
1062 0 : boxes[4].gd.flags = gg_enabled|gg_visible;
1063 0 : boxes[4].gd.u.boxelements = harray2;
1064 0 : boxes[4].creator = GHBoxCreate;
1065 0 : varray[0] = &boxes[4]; varray[1] = &boxes[2]; varray[2] = &boxes[3]; varray[3] = NULL;
1066 :
1067 0 : boxes[0].gd.flags = gg_enabled|gg_visible;
1068 0 : boxes[0].gd.u.boxelements = varray;
1069 0 : boxes[0].creator = GVBoxCreate;
1070 :
1071 0 : GGadgetsCreate(gw,boxes);
1072 0 : qg->vsb = gcd[5].ret;
1073 0 : qg->v = GDrawableGetWindow(gcd[4].ret);
1074 0 : GHVBoxSetExpandableRow(boxes[0].ret,1);
1075 0 : GHVBoxSetExpandableCol(boxes[2].ret,0);
1076 0 : GHVBoxSetPadding(boxes[2].ret,0,0);
1077 0 : GHVBoxSetExpandableCol(boxes[3].ret,gb_expandglue);
1078 0 : GHVBoxFitWindow(boxes[0].ret);
1079 :
1080 0 : QGDoSort(qg);
1081 :
1082 0 : GDrawSetVisible(gw,true);
1083 0 : while ( !qg->done )
1084 0 : GDrawProcessOneEvent(NULL);
1085 0 : GDrawDestroyWindow(gw);
1086 :
1087 0 : qgnodeFree(&qg->list);
1088 0 : qg->gw = oldgw;
1089 0 : }
|
