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