Mercurial > vim
annotate src/gui_xmdlg.c @ 16150:b23048205589 v8.1.1080
patch 8.1.1080: when a screendump test fails, moving the file is a hassle
commit https://github.com/vim/vim/commit/ef7f0e367eeaf6fb31b1caa0e3de1a4b07e86af3
Author: Bram Moolenaar <Bram@vim.org>
Date: Sat Mar 30 15:59:51 2019 +0100
patch 8.1.1080: when a screendump test fails, moving the file is a hassle
Problem: When a screendump test fails, moving the file is a hassle.
Solution: Instead of appending ".failed" to the file name, keep the same
file name but put the screendump in the "failed" directory.
Then the file name only needs to be typed once when moving a
screendump.
author | Bram Moolenaar <Bram@vim.org> |
---|---|
date | Sat, 30 Mar 2019 16:00:06 +0100 |
parents | 90af0c60d78d |
children | e1f4e9d78a6a |
rev | line source |
---|---|
10042
4aead6a9b7a9
commit https://github.com/vim/vim/commit/edf3f97ae2af024708ebb4ac614227327033ca47
Christian Brabandt <cb@256bit.org>
parents:
2684
diff
changeset
|
1 /* vi:set ts=8 sts=4 sw=4 noet: |
44 | 2 * |
3 * VIM - Vi IMproved by Bram Moolenaar | |
4 * | |
5 * Do ":help uganda" in Vim to read copying and usage conditions. | |
6 * Do ":help credits" in Vim to see a list of people who contributed. | |
7 * See README.txt for an overview of the Vim source code. | |
8 */ | |
9 | |
10 /* | |
49 | 11 * (C) 2001,2005 by Marcin Dalecki <martin@dalecki.de> |
44 | 12 * |
1974 | 13 * Implementation of dialog functions for the Motif GUI variant. |
49 | 14 * |
1213 | 15 * Note about Lesstif: Apparently lesstif doesn't get the widget layout right, |
49 | 16 * when using a dynamic scrollbar policy. |
44 | 17 */ |
18 | |
10956
90af0c60d78d
patch 8.0.0367: types in include files may be inconsistent
Christian Brabandt <cb@256bit.org>
parents:
10042
diff
changeset
|
19 #include "vim.h" |
90af0c60d78d
patch 8.0.0367: types in include files may be inconsistent
Christian Brabandt <cb@256bit.org>
parents:
10042
diff
changeset
|
20 |
44 | 21 #include <Xm/Form.h> |
22 #include <Xm/PushBG.h> | |
23 #include <Xm/Text.h> | |
24 #include <Xm/TextF.h> | |
25 #include <Xm/Label.h> | |
26 #include <Xm/Frame.h> | |
27 #include <Xm/LabelG.h> | |
28 #include <Xm/ToggleBG.h> | |
29 #include <Xm/SeparatoG.h> | |
30 #include <Xm/DialogS.h> | |
31 #include <Xm/List.h> | |
32 #include <Xm/RowColumn.h> | |
33 #include <Xm/AtomMgr.h> | |
34 #include <Xm/Protocols.h> | |
35 | |
36 #include <X11/keysym.h> | |
37 #include <X11/Xatom.h> | |
38 #include <X11/StringDefs.h> | |
39 #include <X11/Intrinsic.h> | |
40 | |
41 extern Widget vimShell; | |
42 | |
43 #ifdef FEAT_MENU | |
44 # define apply_fontlist(w) gui_motif_menu_fontlist(w) | |
45 #else | |
46 # define apply_fontlist(w) | |
47 #endif | |
48 | |
49 /**************************************************************************** | |
50 * Font selection dialogue implementation. | |
51 */ | |
52 | |
53 static char wild[3] = "*"; | |
54 | |
55 /* | |
56 * FIXME: This is a generic function, which should be used throughout the whole | |
57 * application. | |
58 * | |
59 * Add close_callback, which will be called when the user selects close from | |
60 * the window menu. The close menu item usually activates f.kill which sends a | |
61 * WM_DELETE_WINDOW protocol request for the window. | |
62 */ | |
63 | |
64 static void | |
65 add_cancel_action(Widget shell, XtCallbackProc close_callback, void *arg) | |
66 { | |
67 static Atom wmp_atom = 0; | |
68 static Atom dw_atom = 0; | |
69 Display *display = XtDisplay(shell); | |
70 | |
71 /* deactivate the built-in delete response of killing the application */ | |
1621 | 72 XtVaSetValues(shell, XmNdeleteResponse, XmDO_NOTHING, NULL); |
44 | 73 |
74 /* add a delete window protocol callback instead */ | |
75 if (!dw_atom) | |
76 { | |
77 wmp_atom = XmInternAtom(display, "WM_PROTOCOLS", True); | |
78 dw_atom = XmInternAtom(display, "WM_DELETE_WINDOW", True); | |
79 } | |
80 XmAddProtocolCallback(shell, wmp_atom, dw_atom, close_callback, arg); | |
81 } | |
82 | |
83 #define MAX_FONTS 65535 | |
84 #define MAX_FONT_NAME_LEN 256 | |
85 #define MAX_ENTRIES_IN_LIST 5000 | |
86 #define MAX_DISPLAY_SIZE 150 | |
87 #define TEMP_BUF_SIZE 256 | |
88 | |
89 enum ListSpecifier | |
90 { | |
91 ENCODING, | |
92 NAME, | |
93 STYLE, | |
94 SIZE, | |
95 NONE | |
96 }; | |
97 | |
98 typedef struct _SharedFontSelData | |
99 { | |
100 Widget dialog; | |
101 Widget ok; | |
102 Widget cancel; | |
103 Widget encoding_pulldown; | |
104 Widget encoding_menu; | |
105 Widget list[NONE]; | |
106 Widget name; | |
107 Widget sample; | |
108 char **names; /* font name array of arrays */ | |
109 int num; /* number of font names */ | |
110 String sel[NONE]; /* selection category */ | |
111 Boolean in_pixels; /* toggle state - size in pixels */ | |
112 char *font_name; /* current font name */ | |
113 XFontStruct *old; /* font data structure for sample display */ | |
114 XmFontList old_list; /* font data structure for sample display */ | |
115 Boolean exit; /* used for program exit control */ | |
116 } SharedFontSelData; | |
117 | |
118 /* | |
119 * Checking access to the font name array for validity. | |
120 */ | |
121 static char * | |
122 fn(SharedFontSelData *data, int i) | |
123 { | |
124 /* Assertion checks: */ | |
125 if (data->num < 0) | |
126 abort(); | |
127 if (i >= data->num) | |
128 i = data->num - 1; | |
129 if (i < 0) | |
130 i = 0; | |
131 | |
132 return data->names[i]; | |
133 } | |
134 | |
135 /* | |
136 * Get a specific substring from a font name. | |
137 */ | |
138 static void | |
139 get_part(char *in, int pos, char *out) | |
140 { | |
141 int i; | |
142 int j; | |
143 | |
144 *out = '\0'; | |
145 | |
146 for (i = 0; (pos > 0) && (in[i] != '\0'); ++i) | |
147 if (in[i] == '-') | |
148 pos--; | |
149 | |
150 if (in[i] == '\0') | |
151 return; | |
152 | |
153 for (j = 0; (in[i] != '-') && (in[i] != '\0'); ++i, ++j) | |
154 out[j] = in[i]; | |
155 out[j] = '\0'; | |
156 } | |
157 | |
158 /* | |
159 * Given a font name this function returns the part used in the first | |
160 * scroll list. | |
161 */ | |
162 static void | |
163 name_part(char *font, char *buf) | |
164 { | |
165 char buf2[TEMP_BUF_SIZE]; | |
166 char buf3[TEMP_BUF_SIZE]; | |
167 | |
168 get_part(font, 2, buf2); | |
169 get_part(font, 1, buf3); | |
170 | |
2278
0b3be97064e5
Various small fixes from Dominique Pelle.
Bram Moolenaar <bram@vim.org>
parents:
2022
diff
changeset
|
171 if (*buf3 != NUL) |
273 | 172 vim_snprintf(buf, TEMP_BUF_SIZE, "%s (%s)", buf2, buf3); |
44 | 173 else |
273 | 174 vim_snprintf(buf, TEMP_BUF_SIZE, "%s", buf2); |
44 | 175 } |
176 | |
177 /* | |
178 * Given a font name this function returns the part used in the second scroll list. | |
179 */ | |
180 static void | |
181 style_part(char *font, char *buf) | |
182 { | |
183 char buf2[TEMP_BUF_SIZE]; | |
184 char buf3[TEMP_BUF_SIZE]; | |
185 | |
186 get_part(font, 3, buf3); | |
187 get_part(font, 5, buf2); | |
188 | |
189 if (!strcmp(buf2, "normal") && !strcmp(buf2, "Normal") | |
190 && !strcmp(buf2, "NORMAL")) | |
273 | 191 vim_snprintf(buf, TEMP_BUF_SIZE, "%s %s", buf3, buf2); |
44 | 192 else |
193 strcpy(buf, buf3); | |
194 | |
195 get_part(font, 6, buf2); | |
196 | |
197 if (buf2[0] != '\0') | |
273 | 198 vim_snprintf(buf3, TEMP_BUF_SIZE, "%s %s", buf, buf2); |
44 | 199 else |
200 strcpy(buf3, buf); | |
201 | |
202 get_part(font, 4, buf2); | |
203 | |
204 if (!strcmp(buf2, "o") || !strcmp(buf2, "O")) | |
273 | 205 vim_snprintf(buf, TEMP_BUF_SIZE, "%s oblique", buf3); |
44 | 206 else if (!strcmp(buf2, "i") || !strcmp(buf2, "I")) |
273 | 207 vim_snprintf(buf, TEMP_BUF_SIZE, "%s italic", buf3); |
44 | 208 |
209 if (!strcmp(buf, " ")) | |
210 strcpy(buf, "-"); | |
211 } | |
212 | |
213 /* | |
214 * Given a font name this function returns the part used in the third | |
215 * scroll list. | |
216 */ | |
217 static void | |
218 size_part(char *font, char *buf, int inPixels) | |
219 { | |
220 int size; | |
221 float temp; | |
222 | |
223 *buf = '\0'; | |
224 | |
225 if (inPixels) | |
226 { | |
227 get_part(font, 7, buf); | |
2278
0b3be97064e5
Various small fixes from Dominique Pelle.
Bram Moolenaar <bram@vim.org>
parents:
2022
diff
changeset
|
228 if (*buf != NUL) |
44 | 229 { |
230 size = atoi(buf); | |
231 sprintf(buf, "%3d", size); | |
232 } | |
233 } | |
234 else | |
235 { | |
236 get_part(font, 8, buf); | |
2278
0b3be97064e5
Various small fixes from Dominique Pelle.
Bram Moolenaar <bram@vim.org>
parents:
2022
diff
changeset
|
237 if (*buf != NUL) |
44 | 238 { |
239 size = atoi(buf); | |
240 temp = (float)size / 10.0; | |
241 size = temp; | |
242 if (buf[strlen(buf) - 1] == '0') | |
243 sprintf(buf, "%3d", size); | |
244 else | |
245 sprintf(buf, "%4.1f", temp); | |
246 } | |
247 } | |
248 } | |
249 | |
250 /* | |
251 * Given a font name this function returns the part used in the choice menu. | |
252 */ | |
253 static void | |
254 encoding_part(char *font, char *buf) | |
255 { | |
256 char buf1[TEMP_BUF_SIZE]; | |
257 char buf2[TEMP_BUF_SIZE]; | |
258 | |
259 *buf = '\0'; | |
260 | |
261 get_part(font, 13, buf1); | |
262 get_part(font, 14, buf2); | |
263 | |
2278
0b3be97064e5
Various small fixes from Dominique Pelle.
Bram Moolenaar <bram@vim.org>
parents:
2022
diff
changeset
|
264 if (*buf1 != NUL && *buf2 != NUL) |
273 | 265 vim_snprintf(buf, TEMP_BUF_SIZE, "%s-%s", buf1, buf2); |
44 | 266 if (!strcmp(buf, " ")) |
267 strcpy(buf, "-"); | |
268 } | |
269 | |
270 /* | |
271 * Inserts a string into correct sorted position in a list. | |
272 */ | |
273 static void | |
274 add_to_list(char **buf, char *item, int *count) | |
275 { | |
276 int i; | |
277 int j; | |
278 | |
279 if (*count == MAX_ENTRIES_IN_LIST) | |
280 return; | |
281 | |
282 /* avoid duplication */ | |
283 for (i = 0; i < *count; ++i) | |
284 { | |
285 if (!strcmp(buf[i], item)) | |
286 return; | |
287 } | |
288 | |
289 /* find order place, but make sure that wild card comes first */ | |
290 if (!strcmp(item, wild)) | |
291 i = 0; | |
292 else | |
293 for (i = 0; i < *count; ++i) | |
294 if (strcmp(buf[i], item) > 0 && strcmp(buf[i], wild)) | |
295 break; | |
296 | |
297 /* now insert the item */ | |
298 for (j = *count; j > i; --j) | |
299 buf[j] = buf[j-1]; | |
300 buf[i] = XtNewString(item); | |
301 | |
302 ++(*count); | |
303 } | |
304 | |
305 /* | |
306 * True if the font matches some field. | |
307 */ | |
308 static Boolean | |
309 match(SharedFontSelData *data, enum ListSpecifier l, int i) | |
310 { | |
311 char buf[TEMP_BUF_SIZE]; | |
312 | |
313 /* An empty selection or a wild card matches anything. | |
314 */ | |
315 if (!data->sel[l] || !strcmp(data->sel[l], wild)) | |
316 return True; | |
317 | |
318 /* chunk out the desired part... */ | |
319 switch (l) | |
320 { | |
321 case ENCODING: | |
322 encoding_part(fn(data, i), buf); | |
323 break; | |
324 | |
325 case NAME: | |
326 name_part(fn(data, i), buf); | |
327 break; | |
328 | |
329 case STYLE: | |
330 style_part(fn(data, i), buf); | |
331 break; | |
332 | |
333 case SIZE: | |
334 size_part(fn(data, i), buf, data->in_pixels); | |
335 break; | |
336 default: | |
337 ; | |
338 } | |
339 | |
340 /* ...and chew it now */ | |
341 | |
342 return !strcmp(buf, data->sel[l]); | |
343 } | |
344 | |
345 static Boolean | |
346 proportional(char *font) | |
347 { | |
348 char buf[TEMP_BUF_SIZE]; | |
349 | |
350 get_part(font, 11, buf); | |
351 | |
352 return !strcmp(buf, "p") || !strcmp(buf, "P"); | |
353 } | |
354 | |
355 | |
356 static void encoding_callback(Widget w, SharedFontSelData *data, | |
357 XtPointer dummy); | |
358 | |
359 /* | |
360 * Parse through the fontlist data and set up the three scroll lists. The fix | |
361 * parameter can be used to exclude a list from any changes. This is used for | |
362 * updates after selections caused by the users actions. | |
363 */ | |
364 static void | |
365 fill_lists(enum ListSpecifier fix, SharedFontSelData *data) | |
366 { | |
367 char *list[NONE][MAX_ENTRIES_IN_LIST]; | |
368 int count[NONE]; | |
369 char buf[TEMP_BUF_SIZE]; | |
370 XmString items[MAX_ENTRIES_IN_LIST]; | |
371 int i; | |
1757 | 372 int idx; |
44 | 373 |
1757 | 374 for (idx = (int)ENCODING; idx < (int)NONE; ++idx) |
375 count[idx] = 0; | |
44 | 376 |
377 /* First we insert the wild char into every single list. */ | |
378 if (fix != ENCODING) | |
379 add_to_list(list[ENCODING], wild, &count[ENCODING]); | |
380 if (fix != NAME) | |
381 add_to_list(list[NAME], wild, &count[NAME]); | |
382 if (fix != STYLE) | |
383 add_to_list(list[STYLE], wild, &count[STYLE]); | |
384 if (fix != SIZE) | |
385 add_to_list(list[SIZE], wild, &count[SIZE]); | |
386 | |
387 for (i = 0; i < data->num && i < MAX_ENTRIES_IN_LIST; i++) | |
388 { | |
389 if (proportional(fn(data, i))) | |
390 continue; | |
391 | |
392 if (fix != ENCODING | |
393 && match(data, NAME, i) | |
394 && match(data, STYLE, i) | |
395 && match(data, SIZE, i)) | |
396 { | |
397 encoding_part(fn(data, i), buf); | |
398 add_to_list(list[ENCODING], buf, &count[ENCODING]); | |
399 } | |
400 | |
401 if (fix != NAME | |
402 && match(data, ENCODING, i) | |
403 && match(data, STYLE, i) | |
404 && match(data, SIZE, i)) | |
405 { | |
406 name_part(fn(data, i), buf); | |
407 add_to_list(list[NAME], buf, &count[NAME]); | |
408 } | |
409 | |
410 if (fix != STYLE | |
411 && match(data, ENCODING, i) | |
412 && match(data, NAME, i) | |
413 && match(data, SIZE, i)) | |
414 { | |
415 style_part(fn(data, i), buf); | |
416 add_to_list(list[STYLE], buf, &count[STYLE]); | |
417 } | |
418 | |
419 if (fix != SIZE | |
420 && match(data, ENCODING, i) | |
421 && match(data, NAME, i) | |
422 && match(data, STYLE, i)) | |
423 { | |
424 size_part(fn(data, i), buf, data->in_pixels); | |
425 add_to_list(list[SIZE], buf, &count[SIZE]); | |
426 } | |
427 } | |
428 | |
429 /* | |
430 * And now do the preselection in all lists where there was one: | |
431 */ | |
432 | |
433 if (fix != ENCODING) | |
434 { | |
435 Cardinal n_items; | |
436 WidgetList children; | |
437 Widget selected_button = 0; | |
438 | |
439 /* Get and update the current button list. */ | |
440 XtVaGetValues(data->encoding_pulldown, | |
441 XmNchildren, &children, | |
442 XmNnumChildren, &n_items, | |
443 NULL); | |
444 | |
445 for (i = 0; i < count[ENCODING]; ++i) | |
446 { | |
447 Widget button; | |
448 | |
449 items[i] = XmStringCreateLocalized(list[ENCODING][i]); | |
450 | |
1887 | 451 if (i < (int)n_items) |
44 | 452 { |
453 /* recycle old button */ | |
454 XtVaSetValues(children[i], | |
455 XmNlabelString, items[i], | |
456 XmNuserData, i, | |
457 NULL); | |
458 button = children[i]; | |
459 } | |
460 else | |
461 { | |
462 /* create a new button */ | |
463 button = XtVaCreateManagedWidget("button", | |
464 xmPushButtonGadgetClass, | |
465 data->encoding_pulldown, | |
466 XmNlabelString, items[i], | |
467 XmNuserData, i, | |
468 NULL); | |
469 XtAddCallback(button, XmNactivateCallback, | |
470 (XtCallbackProc) encoding_callback, (XtPointer) data); | |
471 XtManageChild(button); | |
472 } | |
473 | |
474 if (data->sel[ENCODING]) | |
475 { | |
476 if (!strcmp(data->sel[ENCODING], list[ENCODING][i])) | |
477 selected_button = button; | |
478 } | |
479 XtFree(list[ENCODING][i]); | |
480 } | |
481 | |
1213 | 482 /* Destroy all the outstanding menu items. |
44 | 483 */ |
1887 | 484 for (i = count[ENCODING]; i < (int)n_items; ++i) |
44 | 485 { |
486 XtUnmanageChild(children[i]); | |
487 XtDestroyWidget(children[i]); | |
488 } | |
489 | |
490 /* Preserve the current selection visually. | |
491 */ | |
492 if (selected_button) | |
493 { | |
494 XtVaSetValues(data->encoding_menu, | |
495 XmNmenuHistory, selected_button, | |
496 NULL); | |
497 } | |
498 | |
499 for (i = 0; i < count[ENCODING]; ++i) | |
500 XmStringFree(items[i]); | |
501 } | |
502 | |
503 /* | |
504 * Now loop trough the remaining lists and set them up. | |
505 */ | |
1757 | 506 for (idx = (int)NAME; idx < (int)NONE; ++idx) |
44 | 507 { |
508 Widget w; | |
509 | |
1757 | 510 if (fix == (enum ListSpecifier)idx) |
44 | 511 continue; |
512 | |
1757 | 513 switch ((enum ListSpecifier)idx) |
44 | 514 { |
515 case NAME: | |
516 w = data->list[NAME]; | |
517 break; | |
518 case STYLE: | |
519 w = data->list[STYLE]; | |
520 break; | |
521 case SIZE: | |
522 w = data->list[SIZE]; | |
523 break; | |
524 default: | |
525 w = (Widget)0; /* for lint */ | |
526 } | |
527 | |
1757 | 528 for (i = 0; i < count[idx]; ++i) |
44 | 529 { |
1757 | 530 items[i] = XmStringCreateLocalized(list[idx][i]); |
531 XtFree(list[idx][i]); | |
44 | 532 } |
533 XmListDeleteAllItems(w); | |
1757 | 534 XmListAddItems(w, items, count[idx], 1); |
535 if (data->sel[idx]) | |
44 | 536 { |
537 XmStringFree(items[0]); | |
1757 | 538 items[0] = XmStringCreateLocalized(data->sel[idx]); |
44 | 539 XmListSelectItem(w, items[0], False); |
540 XmListSetBottomItem(w, items[0]); | |
541 } | |
1757 | 542 for (i = 0; i < count[idx]; ++i) |
44 | 543 XmStringFree(items[i]); |
544 } | |
545 } | |
546 | |
547 static void | |
1887 | 548 stoggle_callback(Widget w UNUSED, |
44 | 549 SharedFontSelData *data, |
550 XmToggleButtonCallbackStruct *call_data) | |
551 { | |
552 int i, do_sel; | |
273 | 553 char newSize[TEMP_BUF_SIZE]; |
44 | 554 XmString str; |
555 | |
556 if (call_data->reason != (int)XmCR_VALUE_CHANGED) | |
557 return; | |
558 | |
559 do_sel = (data->sel[SIZE] != NULL) && strcmp(data->sel[SIZE], wild); | |
560 | |
561 for (i = 0; do_sel && (i < data->num); i++) | |
562 if (match(data, ENCODING, i) | |
563 && match(data, NAME, i) | |
564 && match(data, STYLE, i) | |
565 && match(data, SIZE, i)) | |
566 { | |
567 size_part(fn(data, i), newSize, !data->in_pixels); | |
568 break; | |
569 } | |
570 | |
571 data->in_pixels = !data->in_pixels; | |
572 | |
573 if (data->sel[SIZE]) | |
574 XtFree(data->sel[SIZE]); | |
575 data->sel[SIZE] = NULL; | |
576 fill_lists(NONE, data); | |
577 | |
578 if (do_sel) | |
579 { | |
580 str = XmStringCreateLocalized(newSize); | |
581 XmListSelectItem(data->list[SIZE], str, True); | |
582 XmListSetBottomItem(data->list[SIZE], str); | |
583 XmStringFree(str); | |
584 } | |
585 } | |
586 | |
587 /* | |
588 * Show the currently selected font in the sample text label. | |
589 */ | |
590 static void | |
591 display_sample(SharedFontSelData *data) | |
592 { | |
593 Arg args[2]; | |
594 int n; | |
595 XFontStruct * font; | |
596 XmFontList font_list; | |
597 Display * display; | |
598 XmString str; | |
599 | |
600 display = XtDisplay(data->dialog); | |
601 font = XLoadQueryFont(display, data->font_name); | |
602 font_list = gui_motif_create_fontlist(font); | |
603 | |
604 n = 0; | |
605 str = XmStringCreateLocalized("AaBbZzYy 0123456789"); | |
606 XtSetArg(args[n], XmNlabelString, str); n++; | |
607 XtSetArg(args[n], XmNfontList, font_list); n++; | |
608 | |
609 XtSetValues(data->sample, args, n); | |
610 XmStringFree(str); | |
611 | |
612 if (data->old) | |
613 { | |
614 XFreeFont(display, data->old); | |
615 XmFontListFree(data->old_list); | |
616 } | |
617 data->old = font; | |
618 data->old_list = font_list; | |
619 } | |
620 | |
621 | |
622 static Boolean | |
623 do_choice(Widget w, | |
624 SharedFontSelData *data, | |
625 XmListCallbackStruct *call_data, | |
626 enum ListSpecifier which) | |
627 { | |
628 char *sel; | |
629 | |
630 XmStringGetLtoR(call_data->item, XmSTRING_DEFAULT_CHARSET, &sel); | |
631 | |
632 if (!data->sel[which]) | |
633 data->sel[which] = XtNewString(sel); | |
634 else | |
635 { | |
636 if (!strcmp(data->sel[which], sel)) | |
637 { | |
638 /* unselecting current selection */ | |
1974 | 639 XtFree(data->sel[which]); |
44 | 640 data->sel[which] = NULL; |
641 if (w) | |
642 XmListDeselectItem(w, call_data->item); | |
643 } | |
644 else | |
1974 | 645 { |
646 XtFree(data->sel[which]); | |
44 | 647 data->sel[which] = XtNewString(sel); |
1974 | 648 } |
44 | 649 } |
650 XtFree(sel); | |
651 | |
652 fill_lists(which, data); | |
653 | |
654 /* If there is a font selection, we display it. */ | |
655 if (data->sel[ENCODING] | |
656 && data->sel[NAME] | |
657 && data->sel[STYLE] | |
658 && data->sel[SIZE] | |
659 && strcmp(data->sel[ENCODING], wild) | |
660 && strcmp(data->sel[NAME], wild) | |
661 && strcmp(data->sel[STYLE], wild) | |
662 && strcmp(data->sel[SIZE], wild)) | |
663 { | |
664 int i; | |
665 | |
666 if (data->font_name) | |
667 XtFree(data->font_name); | |
668 data->font_name = NULL; | |
669 | |
670 for (i = 0; i < data->num; i++) | |
671 { | |
672 if (match(data, ENCODING, i) | |
673 && match(data, NAME, i) | |
674 && match(data, STYLE, i) | |
675 && match(data, SIZE, i)) | |
676 { | |
677 data->font_name = XtNewString(fn(data, i)); | |
678 break; | |
679 } | |
680 } | |
681 | |
682 if (data->font_name) | |
683 { | |
684 XmTextSetString(data->name, data->font_name); | |
685 display_sample(data); | |
686 } | |
687 else | |
688 do_dialog(VIM_ERROR, | |
689 (char_u *)_("Error"), | |
690 (char_u *)_("Invalid font specification"), | |
2684 | 691 (char_u *)_("&Dismiss"), 1, NULL, FALSE); |
44 | 692 |
693 return True; | |
694 } | |
695 else | |
696 { | |
697 int n; | |
698 XmString str; | |
699 Arg args[4]; | |
1757 | 700 char *nomatch_msg = _("no specific match"); |
44 | 701 |
702 n = 0; | |
1757 | 703 str = XmStringCreateLocalized(nomatch_msg); |
44 | 704 XtSetArg(args[n], XmNlabelString, str); ++n; |
705 XtSetValues(data->sample, args, n); | |
706 apply_fontlist(data->sample); | |
1757 | 707 XmTextSetString(data->name, nomatch_msg); |
44 | 708 XmStringFree(str); |
709 | |
710 return False; | |
711 } | |
712 } | |
713 | |
714 static void | |
715 encoding_callback(Widget w, | |
716 SharedFontSelData *data, | |
1887 | 717 XtPointer dummy UNUSED) |
44 | 718 { |
719 XmString str; | |
720 XmListCallbackStruct fake_data; | |
721 | |
722 XtVaGetValues(w, XmNlabelString, &str, NULL); | |
723 | |
724 if (!str) | |
725 return; | |
726 | |
727 fake_data.item = str; | |
728 | |
729 do_choice(0, data, &fake_data, ENCODING); | |
730 } | |
731 | |
732 static void | |
733 name_callback(Widget w, | |
734 SharedFontSelData *data, | |
735 XmListCallbackStruct *call_data) | |
736 { | |
737 do_choice(w, data, call_data, NAME); | |
738 } | |
739 | |
740 static void | |
741 style_callback(Widget w, | |
742 SharedFontSelData *data, | |
743 XmListCallbackStruct *call_data) | |
744 { | |
745 do_choice(w, data, call_data, STYLE); | |
746 } | |
747 | |
748 static void | |
749 size_callback(Widget w, | |
750 SharedFontSelData *data, | |
751 XmListCallbackStruct *call_data) | |
752 { | |
753 do_choice(w, data, call_data, SIZE); | |
754 } | |
755 | |
756 static void | |
1887 | 757 cancel_callback(Widget w UNUSED, |
44 | 758 SharedFontSelData *data, |
1887 | 759 XmListCallbackStruct *call_data UNUSED) |
44 | 760 { |
761 if (data->sel[ENCODING]) | |
762 { | |
763 XtFree(data->sel[ENCODING]); | |
764 data->sel[ENCODING] = NULL; | |
765 } | |
766 if (data->sel[NAME]) | |
767 { | |
768 XtFree(data->sel[NAME]); | |
769 data->sel[NAME] = NULL; | |
770 } | |
771 if (data->sel[STYLE]) | |
772 { | |
773 XtFree(data->sel[STYLE]); | |
774 data->sel[STYLE] = NULL; | |
775 } | |
776 if (data->sel[SIZE]) | |
777 { | |
778 XtFree(data->sel[SIZE]); | |
779 data->sel[SIZE] = NULL; | |
780 } | |
781 | |
782 if (data->font_name) | |
783 XtFree(data->font_name); | |
784 data->font_name = NULL; | |
785 | |
786 data->num = 0; | |
787 XFreeFontNames(data->names); | |
788 data->names = NULL; | |
789 data->exit = True; | |
790 } | |
791 | |
792 static void | |
1887 | 793 ok_callback(Widget w UNUSED, |
44 | 794 SharedFontSelData *data, |
1887 | 795 XmPushButtonCallbackStruct *call_data UNUSED) |
44 | 796 { |
797 char *pattern; | |
798 char **name; | |
799 int i; | |
800 | |
801 pattern = XmTextGetString(data->name); | |
802 name = XListFonts(XtDisplay(data->dialog), pattern, 1, &i); | |
803 XtFree(pattern); | |
804 | |
805 if (i != 1) | |
806 { | |
807 do_dialog(VIM_ERROR, | |
808 (char_u *)_("Error"), | |
809 (char_u *)_("Invalid font specification"), | |
2684 | 810 (char_u *)_("&Dismiss"), 1, NULL, FALSE); |
44 | 811 XFreeFontNames(name); |
812 } | |
813 else | |
814 { | |
815 if (data->font_name) | |
816 XtFree(data->font_name); | |
817 data->font_name = XtNewString(name[0]); | |
818 | |
819 if (data->sel[ENCODING]) | |
820 { | |
821 XtFree(data->sel[ENCODING]); | |
822 data->sel[ENCODING] = NULL; | |
823 } | |
824 if (data->sel[NAME]) | |
825 { | |
826 XtFree(data->sel[NAME]); | |
827 data->sel[NAME] = NULL; | |
828 } | |
829 if (data->sel[STYLE]) | |
830 { | |
831 XtFree(data->sel[STYLE]); | |
832 data->sel[STYLE] = NULL; | |
833 } | |
834 if (data->sel[SIZE]) | |
835 { | |
836 XtFree(data->sel[SIZE]); | |
837 data->sel[SIZE] = NULL; | |
838 } | |
839 | |
840 XFreeFontNames(name); | |
841 | |
842 data->num = 0; | |
843 XFreeFontNames(data->names); | |
844 data->names = NULL; | |
845 data->exit = True; | |
846 } | |
847 } | |
848 | |
849 /* | |
850 * Returns pointer to an ASCII character string that contains the name of the | |
851 * selected font (in X format for naming fonts); it is the users responsibility | |
852 * to free the space allocated to this string. | |
853 */ | |
854 char_u * | |
855 gui_xm_select_font(char_u *current) | |
856 { | |
857 static SharedFontSelData _data; | |
858 | |
859 Widget parent; | |
860 Widget form; | |
861 Widget separator; | |
862 Widget sub_form; | |
863 Widget size_toggle; | |
864 Widget name; | |
865 Widget disp_frame; | |
866 Widget frame; | |
867 Arg args[64]; | |
868 int n; | |
869 XmString str; | |
870 char big_font[MAX_FONT_NAME_LEN]; | |
871 SharedFontSelData *data; | |
872 | |
873 data = &_data; | |
874 | |
875 parent = vimShell; | |
876 data->names = XListFonts(XtDisplay(parent), "-*-*-*-*-*-*-*-*-*-*-*-*-*-*", | |
877 MAX_FONTS, &data->num); | |
878 | |
879 /* | |
880 * Find the name of the biggest font less than the given limit | |
881 * MAX_DISPLAY_SIZE used to set up the initial height of the display | |
882 * widget. | |
883 */ | |
884 | |
885 { | |
886 int i; | |
887 int max; | |
1757 | 888 int idx = 0; |
44 | 889 int size; |
1757 | 890 char buf[128]; |
44 | 891 |
892 for (i = 0, max = 0; i < data->num; i++) | |
893 { | |
1757 | 894 get_part(fn(data, i), 7, buf); |
895 size = atoi(buf); | |
44 | 896 if ((size > max) && (size < MAX_DISPLAY_SIZE)) |
897 { | |
1757 | 898 idx = i; |
44 | 899 max = size; |
900 } | |
901 } | |
1757 | 902 strcpy(big_font, fn(data, idx)); |
44 | 903 } |
904 data->old = XLoadQueryFont(XtDisplay(parent), big_font); | |
905 data->old_list = gui_motif_create_fontlist(data->old); | |
906 | |
907 /* Set the title of the Dialog window. */ | |
908 data->dialog = XmCreateDialogShell(parent, "fontSelector", NULL, 0); | |
909 str = XmStringCreateLocalized(_("Vim - Font Selector")); | |
910 | |
911 /* Create form popup dialog widget. */ | |
912 form = XtVaCreateWidget("form", | |
913 xmFormWidgetClass, data->dialog, | |
914 XmNdialogTitle, str, | |
915 XmNautoUnmanage, False, | |
916 XmNdialogStyle, XmDIALOG_FULL_APPLICATION_MODAL, | |
917 NULL); | |
918 XmStringFree(str); | |
919 | |
920 sub_form = XtVaCreateManagedWidget("subForm", | |
921 xmFormWidgetClass, form, | |
922 XmNbottomAttachment, XmATTACH_FORM, | |
923 XmNbottomOffset, 4, | |
924 XmNrightAttachment, XmATTACH_FORM, | |
925 XmNrightOffset, 4, | |
926 XmNtopAttachment, XmATTACH_FORM, | |
927 XmNtopOffset, 4, | |
928 XmNorientation, XmVERTICAL, | |
929 NULL); | |
930 | |
931 data->ok = XtVaCreateManagedWidget(_("OK"), | |
932 xmPushButtonGadgetClass, sub_form, | |
933 XmNleftAttachment, XmATTACH_FORM, | |
934 XmNrightAttachment, XmATTACH_FORM, | |
935 XmNtopAttachment, XmATTACH_FORM, | |
936 XmNtopOffset, 4, | |
937 NULL); | |
938 apply_fontlist(data->ok); | |
939 | |
940 data->cancel = XtVaCreateManagedWidget(_("Cancel"), | |
941 xmPushButtonGadgetClass, sub_form, | |
942 XmNrightAttachment, XmATTACH_FORM, | |
943 XmNleftAttachment, XmATTACH_FORM, | |
944 XmNtopAttachment, XmATTACH_WIDGET, | |
945 XmNtopWidget, data->ok, | |
946 XmNtopOffset, 4, | |
947 XmNshowAsDefault, True, | |
948 NULL); | |
949 apply_fontlist(data->cancel); | |
950 | |
951 /* Create the separator for beauty. */ | |
952 n = 0; | |
953 XtSetArg(args[n], XmNorientation, XmVERTICAL); n++; | |
954 XtSetArg(args[n], XmNbottomAttachment, XmATTACH_FORM); n++; | |
955 XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); n++; | |
956 XtSetArg(args[n], XmNrightAttachment, XmATTACH_WIDGET); n++; | |
957 XtSetArg(args[n], XmNrightWidget, sub_form); n++; | |
958 XtSetArg(args[n], XmNrightOffset, 4); n++; | |
959 separator = XmCreateSeparatorGadget(form, "separator", args, n); | |
960 XtManageChild(separator); | |
961 | |
962 /* Create font name text widget and the corresponding label. */ | |
963 data->name = XtVaCreateManagedWidget("fontName", | |
964 xmTextWidgetClass, form, | |
965 XmNbottomAttachment, XmATTACH_FORM, | |
966 XmNbottomOffset, 4, | |
967 XmNleftAttachment, XmATTACH_FORM, | |
968 XmNleftOffset, 4, | |
969 XmNrightAttachment, XmATTACH_WIDGET, | |
970 XmNrightWidget, separator, | |
971 XmNrightOffset, 4, | |
972 XmNeditable, False, | |
973 XmNeditMode, XmSINGLE_LINE_EDIT, | |
974 XmNmaxLength, MAX_FONT_NAME_LEN, | |
975 XmNcolumns, 60, | |
976 NULL); | |
977 | |
978 str = XmStringCreateLocalized(_("Name:")); | |
979 name = XtVaCreateManagedWidget("fontNameLabel", | |
980 xmLabelGadgetClass, form, | |
981 XmNlabelString, str, | |
982 XmNuserData, data->name, | |
983 XmNleftAttachment, XmATTACH_OPPOSITE_WIDGET, | |
984 XmNleftWidget, data->name, | |
985 XmNbottomAttachment, XmATTACH_WIDGET, | |
986 XmNbottomWidget, data->name, | |
987 XmNtopOffset, 1, | |
988 NULL); | |
989 XmStringFree(str); | |
990 apply_fontlist(name); | |
991 | |
992 /* create sample display label widget */ | |
993 disp_frame = XtVaCreateManagedWidget("sampleFrame", | |
994 xmFrameWidgetClass, form, | |
995 XmNshadowType, XmSHADOW_ETCHED_IN, | |
996 XmNleftAttachment, XmATTACH_FORM, | |
997 XmNleftOffset, 4, | |
998 XmNbottomAttachment, XmATTACH_WIDGET, | |
999 XmNbottomWidget, name, | |
1000 XmNrightAttachment, XmATTACH_WIDGET, | |
1001 XmNrightWidget, separator, | |
1002 XmNrightOffset, 4, | |
1003 XmNalignment, XmALIGNMENT_BEGINNING, | |
1004 NULL); | |
1005 | |
1006 data->sample = XtVaCreateManagedWidget("sampleLabel", | |
1007 xmLabelWidgetClass, disp_frame, | |
1008 XmNleftAttachment, XmATTACH_FORM, | |
1009 XmNtopAttachment, XmATTACH_FORM, | |
1010 XmNbottomAttachment, XmATTACH_FORM, | |
1011 XmNrightAttachment, XmATTACH_FORM, | |
1012 XmNalignment, XmALIGNMENT_BEGINNING, | |
1013 XmNrecomputeSize, False, | |
1014 XmNfontList, data->old_list, | |
1015 NULL); | |
1016 | |
1017 /* create toggle button */ | |
1018 str = XmStringCreateLocalized(_("Show size in Points")); | |
1019 size_toggle = XtVaCreateManagedWidget("sizeToggle", | |
1020 xmToggleButtonGadgetClass, form, | |
1021 XmNlabelString, str, | |
1022 XmNleftAttachment, XmATTACH_FORM, | |
1023 XmNleftOffset, 4, | |
1024 XmNbottomAttachment, XmATTACH_WIDGET, | |
1025 XmNbottomWidget, disp_frame, | |
1026 XmNbottomOffset, 4, | |
1027 NULL); | |
1028 XmStringFree(str); | |
1029 apply_fontlist(size_toggle); | |
1030 XtManageChild(size_toggle); | |
1031 | |
1032 /* Encoding pulldown menu. | |
1033 */ | |
1034 | |
1035 data->encoding_pulldown = XmCreatePulldownMenu(form, | |
1036 "encodingPulldown", NULL, 0); | |
1037 str = XmStringCreateLocalized(_("Encoding:")); | |
1038 n = 0; | |
1039 XtSetArg(args[n], XmNsubMenuId, data->encoding_pulldown); ++n; | |
1040 XtSetArg(args[n], XmNlabelString, str); ++n; | |
1041 XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); ++n; | |
1042 XtSetArg(args[n], XmNleftOffset, 4); ++n; | |
1043 XtSetArg(args[n], XmNbottomAttachment, XmATTACH_WIDGET); ++n; | |
1044 XtSetArg(args[n], XmNbottomWidget, size_toggle); ++n; | |
1045 XtSetArg(args[n], XmNbottomOffset, 4); ++n; | |
1046 XtSetArg(args[n], XmNrightAttachment, XmATTACH_WIDGET); ++n; | |
1047 XtSetArg(args[n], XmNrightWidget, separator); ++n; | |
1048 XtSetArg(args[n], XmNrightOffset, 4); ++n; | |
1049 data->encoding_menu = XmCreateOptionMenu(form, "encodingMenu", args, n); | |
1050 XmStringFree(str); | |
1051 XmAddTabGroup(data->encoding_menu); | |
1052 | |
1053 /* | |
1054 * Create scroll list widgets in a separate subform used to manage the | |
1055 * different sizes of the lists. | |
1056 */ | |
1057 | |
1058 sub_form = XtVaCreateManagedWidget("subForm", | |
1059 xmFormWidgetClass, form, | |
1060 XmNbottomAttachment, XmATTACH_WIDGET, | |
1061 XmNbottomWidget, data->encoding_menu, | |
1062 XmNbottomOffset, 4, | |
1063 XmNleftAttachment, XmATTACH_FORM, | |
1064 XmNleftOffset, 4, | |
1065 XmNrightAttachment, XmATTACH_WIDGET, | |
1066 XmNrightWidget, separator, | |
1067 XmNrightOffset, 4, | |
1068 XmNtopAttachment, XmATTACH_FORM, | |
1069 XmNtopOffset, 2, | |
1070 XmNorientation, XmVERTICAL, | |
1071 NULL); | |
1072 | |
1073 /* font list */ | |
1074 frame = XtVaCreateManagedWidget("frame", xmFrameWidgetClass, sub_form, | |
1075 XmNshadowThickness, 0, | |
1076 XmNtopAttachment, XmATTACH_FORM, | |
1077 XmNbottomAttachment, XmATTACH_FORM, | |
1078 XmNleftAttachment, XmATTACH_FORM, | |
1079 XmNrightAttachment, XmATTACH_POSITION, | |
1080 XmNrightPosition, 50, | |
1081 NULL); | |
1082 | |
1083 str = XmStringCreateLocalized(_("Font:")); | |
1084 name = XtVaCreateManagedWidget("nameListLabel", xmLabelGadgetClass, frame, | |
1085 XmNchildType, XmFRAME_TITLE_CHILD, | |
1086 XmNchildVerticalAlignment, XmALIGNMENT_CENTER, | |
1087 XmNchildHorizontalAlignment, XmALIGNMENT_BEGINNING, | |
1088 XmNlabelString, str, | |
1089 NULL); | |
1090 XmStringFree(str); | |
1091 apply_fontlist(name); | |
1092 | |
1093 n = 0; | |
1094 XtSetArg(args[n], XmNvisibleItemCount, 8); ++n; | |
1095 XtSetArg(args[n], XmNresizable, True); ++n; | |
1096 XtSetArg(args[n], XmNlistSizePolicy, XmCONSTANT); ++n; | |
1097 XtSetArg(args[n], XmNvisualPolicy, XmVARIABLE); ++n; | |
1098 #ifdef LESSTIF_VERSION | |
1099 XtSetArg(args[n], XmNscrollBarDisplayPolicy, XmSTATIC); ++n; | |
1100 #endif | |
1101 data->list[NAME] = XmCreateScrolledList(frame, "fontList", args, n); | |
1102 XtVaSetValues(name, XmNuserData, data->list[NAME], NULL); | |
1103 | |
1104 /* style list */ | |
1105 frame = XtVaCreateManagedWidget("frame", xmFrameWidgetClass, sub_form, | |
1106 XmNshadowThickness, 0, | |
1107 XmNtopAttachment, XmATTACH_FORM, | |
1108 XmNbottomAttachment, XmATTACH_FORM, | |
1109 XmNleftAttachment, XmATTACH_POSITION, | |
1110 XmNleftPosition, 50, | |
1111 XmNleftOffset, 4, | |
1112 XmNrightAttachment, XmATTACH_POSITION, | |
1113 XmNrightPosition, 80, | |
1114 NULL); | |
1115 | |
1116 str = XmStringCreateLocalized(_("Style:")); | |
1117 name = XtVaCreateManagedWidget("styleListLabel", xmLabelWidgetClass, frame, | |
1118 XmNchildType, XmFRAME_TITLE_CHILD, | |
1119 XmNchildVerticalAlignment, XmALIGNMENT_CENTER, | |
1120 XmNchildHorizontalAlignment, XmALIGNMENT_BEGINNING, | |
1121 XmNlabelString, str, | |
1122 NULL); | |
1123 XmStringFree(str); | |
1124 apply_fontlist(name); | |
1125 | |
1126 n = 0; | |
1127 XtSetArg(args[n], XmNvisibleItemCount, 8); ++n; | |
1128 XtSetArg(args[n], XmNresizable, True); ++n; | |
1129 XtSetArg(args[n], XmNlistSizePolicy, XmCONSTANT); ++n; | |
1130 XtSetArg(args[n], XmNvisualPolicy, XmVARIABLE); ++n; | |
1131 #ifdef LESSTIF_VERSION | |
1132 XtSetArg(args[n], XmNscrollBarDisplayPolicy, XmSTATIC); ++n; | |
1133 #endif | |
1134 data->list[STYLE] = XmCreateScrolledList(frame, "styleList", args, n); | |
1135 XtVaSetValues(name, XmNuserData, data->list[STYLE], NULL); | |
1136 | |
1137 /* size list */ | |
1138 frame = XtVaCreateManagedWidget("frame", xmFrameWidgetClass, sub_form, | |
1139 XmNshadowThickness, 0, | |
1140 XmNtopAttachment, XmATTACH_FORM, | |
1141 XmNbottomAttachment, XmATTACH_FORM, | |
1142 XmNleftAttachment, XmATTACH_POSITION, | |
1143 XmNleftPosition, 80, | |
1144 XmNleftOffset, 4, | |
1145 XmNrightAttachment, XmATTACH_FORM, | |
1146 NULL); | |
1147 | |
1148 str = XmStringCreateLocalized(_("Size:")); | |
1149 name = XtVaCreateManagedWidget("sizeListLabel", xmLabelGadgetClass, frame, | |
1150 XmNchildType, XmFRAME_TITLE_CHILD, | |
1151 XmNchildVerticalAlignment, XmALIGNMENT_CENTER, | |
1152 XmNchildHorizontalAlignment, XmALIGNMENT_BEGINNING, | |
1153 XmNlabelString, str, | |
1154 NULL); | |
1155 XmStringFree(str); | |
1156 apply_fontlist(name); | |
1157 | |
1158 n = 0; | |
1159 XtSetArg(args[n], XmNvisibleItemCount, 8); ++n; | |
1160 XtSetArg(args[n], XmNresizable, True); ++n; | |
1161 XtSetArg(args[n], XmNlistSizePolicy, XmCONSTANT); ++n; | |
1162 XtSetArg(args[n], XmNvisualPolicy, XmVARIABLE); ++n; | |
1163 #ifdef LESSTIF_VERSION | |
1164 XtSetArg(args[n], XmNscrollBarDisplayPolicy, XmSTATIC); ++n; | |
1165 #endif | |
1166 data->list[SIZE] = XmCreateScrolledList(frame, "sizeList", args, n); | |
1167 XtVaSetValues(name, XmNuserData, data->list[SIZE], NULL); | |
1168 | |
1169 /* update form widgets cancel button */ | |
1170 XtVaSetValues(form, XmNcancelButton, data->cancel, NULL); | |
1171 | |
1172 XtAddCallback(size_toggle, XmNvalueChangedCallback, | |
1173 (XtCallbackProc)stoggle_callback, (XtPointer)data); | |
1174 XtAddCallback(data->list[NAME], XmNbrowseSelectionCallback, | |
1175 (XtCallbackProc)name_callback, (XtPointer)data); | |
1176 XtAddCallback(data->list[STYLE], XmNbrowseSelectionCallback, | |
1177 (XtCallbackProc)style_callback, (XtPointer)data); | |
1178 XtAddCallback(data->list[SIZE], XmNbrowseSelectionCallback, | |
1179 (XtCallbackProc)size_callback, (XtPointer)data); | |
1180 XtAddCallback(data->ok, XmNactivateCallback, | |
1181 (XtCallbackProc)ok_callback, (XtPointer)data); | |
1182 XtAddCallback(data->cancel, XmNactivateCallback, | |
1183 (XtCallbackProc)cancel_callback, (XtPointer)data); | |
1184 | |
1185 XmProcessTraversal(data->list[NAME], XmTRAVERSE_CURRENT); | |
1186 | |
1187 /* setup tabgroups */ | |
1188 | |
1189 XmAddTabGroup(data->list[NAME]); | |
1190 XmAddTabGroup(data->list[STYLE]); | |
1191 XmAddTabGroup(data->list[SIZE]); | |
1192 XmAddTabGroup(size_toggle); | |
1193 XmAddTabGroup(data->name); | |
1194 XmAddTabGroup(data->ok); | |
1195 XmAddTabGroup(data->cancel); | |
1196 | |
1197 add_cancel_action(data->dialog, (XtCallbackProc)cancel_callback, data); | |
1198 | |
1199 /* Preset selection data. */ | |
1200 | |
1201 data->exit = False; | |
1202 data->in_pixels= True; | |
1203 data->sel[ENCODING] = NULL; | |
1204 data->sel[NAME] = NULL; | |
1205 data->sel[STYLE] = NULL; | |
1206 data->sel[SIZE] = NULL; | |
1207 data->font_name = NULL; | |
1208 | |
1209 /* set up current font parameters */ | |
1210 if (current && current[0] != '\0') | |
1211 { | |
1212 int i; | |
1213 char **names; | |
1214 | |
1215 names = XListFonts(XtDisplay(form), (char *) current, 1, &i); | |
1216 | |
1217 if (i != 0) | |
1218 { | |
1757 | 1219 char namebuf[TEMP_BUF_SIZE]; |
1220 char stylebuf[TEMP_BUF_SIZE]; | |
1221 char sizebuf[TEMP_BUF_SIZE]; | |
1222 char encodingbuf[TEMP_BUF_SIZE]; | |
44 | 1223 char *found; |
1224 | |
1225 found = names[0]; | |
1226 | |
1757 | 1227 name_part(found, namebuf); |
1228 style_part(found, stylebuf); | |
1229 size_part(found, sizebuf, data->in_pixels); | |
1230 encoding_part(found, encodingbuf); | |
44 | 1231 |
2278
0b3be97064e5
Various small fixes from Dominique Pelle.
Bram Moolenaar <bram@vim.org>
parents:
2022
diff
changeset
|
1232 if (*namebuf != NUL |
0b3be97064e5
Various small fixes from Dominique Pelle.
Bram Moolenaar <bram@vim.org>
parents:
2022
diff
changeset
|
1233 && *stylebuf != NUL |
0b3be97064e5
Various small fixes from Dominique Pelle.
Bram Moolenaar <bram@vim.org>
parents:
2022
diff
changeset
|
1234 && *sizebuf != NUL |
0b3be97064e5
Various small fixes from Dominique Pelle.
Bram Moolenaar <bram@vim.org>
parents:
2022
diff
changeset
|
1235 && *encodingbuf != NUL) |
44 | 1236 { |
1757 | 1237 data->sel[NAME] = XtNewString(namebuf); |
1238 data->sel[STYLE] = XtNewString(stylebuf); | |
1239 data->sel[SIZE] = XtNewString(sizebuf); | |
1240 data->sel[ENCODING] = XtNewString(encodingbuf); | |
44 | 1241 data->font_name = XtNewString(names[0]); |
1242 display_sample(data); | |
1243 XmTextSetString(data->name, data->font_name); | |
1244 } | |
1245 else | |
1246 { | |
1247 /* We can't preset a symbolic name, which isn't a full font | |
1248 * description. Therefore we just behave the same way as if the | |
1249 * user didn't have selected anything thus far. | |
1250 * | |
1251 * Unfortunately there is no known way to expand an abbreviated | |
1252 * font name. | |
1253 */ | |
1254 | |
1255 data->font_name = NULL; | |
1256 } | |
1257 } | |
1258 XFreeFontNames(names); | |
1259 } | |
1260 | |
1261 fill_lists(NONE, data); | |
1262 | |
1263 /* Unfortunately LessTif doesn't align the list widget's properly. I don't | |
1264 * have currently any idea how to fix this problem. | |
1265 */ | |
1266 XtManageChild(data->list[NAME]); | |
1267 XtManageChild(data->list[STYLE]); | |
1268 XtManageChild(data->list[SIZE]); | |
1269 XtManageChild(data->encoding_menu); | |
1270 manage_centered(form); | |
1271 | |
1272 /* modal event loop */ | |
1273 while (!data->exit) | |
1274 XtAppProcessEvent(XtWidgetToApplicationContext(data->dialog), | |
1275 (XtInputMask)XtIMAll); | |
1276 | |
1277 if (data->old) | |
1278 { | |
1279 XFreeFont(XtDisplay(data->dialog), data->old); | |
1280 XmFontListFree(data->old_list); | |
1281 } | |
2022 | 1282 XtDestroyWidget(data->dialog); |
44 | 1283 |
1284 gui_motif_synch_fonts(); | |
1285 | |
1286 return (char_u *) data->font_name; | |
1287 } |