Mercurial > vim
annotate src/gui_xmdlg.c @ 7510:b8104d67b976
Added tag v7.4.1056 for changeset a64793340689d0657962ca1f160e1c73895af666
| author | Christian Brabandt <cb@256bit.org> |
|---|---|
| date | Thu, 07 Jan 2016 16:30:09 +0100 |
| parents | 951641b8784d |
| children | 4aead6a9b7a9 |
| rev | line source |
|---|---|
| 44 | 1 /* vi:set ts=8 sts=4 sw=4: |
| 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 | |
| 19 #include <Xm/Form.h> | |
| 20 #include <Xm/PushBG.h> | |
| 21 #include <Xm/Text.h> | |
| 22 #include <Xm/TextF.h> | |
| 23 #include <Xm/Label.h> | |
| 24 #include <Xm/Frame.h> | |
| 25 #include <Xm/LabelG.h> | |
| 26 #include <Xm/ToggleBG.h> | |
| 27 #include <Xm/SeparatoG.h> | |
| 28 #include <Xm/DialogS.h> | |
| 29 #include <Xm/List.h> | |
| 30 #include <Xm/RowColumn.h> | |
| 31 #include <Xm/AtomMgr.h> | |
| 32 #include <Xm/Protocols.h> | |
| 33 | |
| 34 #include <X11/keysym.h> | |
| 35 #include <X11/Xatom.h> | |
| 36 #include <X11/StringDefs.h> | |
| 37 #include <X11/Intrinsic.h> | |
| 38 | |
| 39 #include "vim.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 } |