Annotation of src/usr.bin/vim/gui.c, Revision 1.1.1.1
1.1 downsj 1: /* $OpenBSD$ */
2: /* vi:set ts=4 sw=4:
3: *
4: * VIM - Vi IMproved by Bram Moolenaar
5: * GUI/Motif support by Robert Webb
6: *
7: * Do ":help uganda" in Vim to read copying and usage conditions.
8: * Do ":help credits" in Vim to see a list of people who contributed.
9: */
10:
11: #include "vim.h"
12: #include "globals.h"
13: #include "proto.h"
14: #include "option.h"
15:
16: /* Structure containing all the GUI information */
17: Gui gui;
18:
19: /* Set to TRUE after adding/removing menus to ensure they are updated */
20: int force_menu_update = FALSE;
21:
22:
23: static void gui_check_screen __ARGS((void));
24: static void gui_outstr __ARGS((char_u *, int));
25: static void gui_update_selection __ARGS((void));
26: static int gui_get_menu_cmd_modes __ARGS((char_u *, int, int *, int *));
27: static int gui_add_menu_path __ARGS((char_u *, int, void (*)(), char_u *, int));
28: static int gui_remove_menu __ARGS((GuiMenu **, char_u *, int));
29: static void gui_free_menu __ARGS((GuiMenu *));
30: static void gui_free_menu_string __ARGS((GuiMenu *, int));
31: static int gui_show_menus __ARGS((char_u *, int));
32: static void gui_show_menus_recursive __ARGS((GuiMenu *, int, int));
33: static char_u *gui_menu_name_skip __ARGS((char_u *name));
34: static void gui_create_initial_menus __ARGS((GuiMenu *, GuiMenu *));
35: static void gui_update_scrollbars __ARGS((void));
36: static void gui_update_horiz_scrollbar __ARGS((void));
37:
38: /*
39: * The Athena scrollbars can move the thumb to after the end of the scrollbar,
40: * this makes the thumb indicate the part of the text that is shown. Motif
41: * can't do this.
42: */
43: #ifdef USE_GUI_ATHENA
44: # define SCROLL_PAST_END
45: #endif
46:
47: /*
48: * gui_start -- Called when user wants to start the GUI.
49: */
50: void
51: gui_start()
52: {
53: char_u *old_term;
54:
55: old_term = strsave(term_strings[KS_NAME]);
56: mch_setmouse(FALSE); /* first switch mouse off */
57:
58: /* set_termname() will call gui_init() to start the GUI */
59: termcapinit((char_u *)"builtin_gui");
60:
61: if (!gui.in_use) /* failed to start GUI */
62: termcapinit(old_term);
63:
64: vim_free(old_term);
65:
66: /*
67: * Quit the current process and continue in the child.
68: * Makes "gvim file" disconnect from the shell it was started in.
69: * Don't do this when Vim was started with "-f" or the 'f' flag is present
70: * in 'guioptions'.
71: */
72: if (gui.in_use && gui.dofork &&
73: vim_strchr(p_guioptions, GO_FORG) == NULL && fork() > 0)
74: exit(0);
75: }
76:
77: /*
78: * Call this when vim starts up, whether or not the GUI is started
79: */
80: void
81: gui_prepare(argc, argv)
82: int *argc;
83: char **argv;
84: {
85: /* Menu items may be added before the GUI is started, so set this now */
86: gui.root_menu = NULL;
87: gui.in_use = FALSE; /* No GUI yet (maybe later) */
88: gui.starting = FALSE; /* No GUI yet (maybe later) */
89: gui.dofork = TRUE; /* default is to use fork() */
90: gui_mch_prepare(argc, argv);
91: }
92:
93: static struct default_menu
94: {
95: char *name; /* name of menu item */
96: int mode; /* mode where menu is valid */
97: char *command; /* resulting command */
98: } default_menus[] =
99: {
100: /* Help menu. Some reason Motif is happier if this is added first. */
101: {"Help.Overview <F1>", MENU_NORMAL_MODE, ":help\r"},
102: {"Help.Overview <F1>", MENU_VISUAL_MODE|MENU_INSERT_MODE|MENU_CMDLINE_MODE,
103: "\033:help\r"},
104: {"Help.How to\\.\\.\\.",MENU_NORMAL_MODE, ":help how_to\r"},
105: {"Help.How to\\.\\.\\.",MENU_VISUAL_MODE|MENU_INSERT_MODE|MENU_CMDLINE_MODE,
106: "\033:help how_to\r"},
107: {"Help.GUI", MENU_NORMAL_MODE, ":help gui\r"},
108: {"Help.GUI", MENU_VISUAL_MODE|MENU_INSERT_MODE|MENU_CMDLINE_MODE,
109: "\033:help gui\r"},
110: {"Help.Version", MENU_NORMAL_MODE, ":version\r"},
111: {"Help.Version", MENU_VISUAL_MODE|MENU_INSERT_MODE|MENU_CMDLINE_MODE,
112: "\033:version\r"},
113: {"Help.Credits", MENU_NORMAL_MODE, ":help credits\r"},
114: {"Help.Credits", MENU_VISUAL_MODE|MENU_INSERT_MODE|MENU_CMDLINE_MODE,
115: "\033:help credits\r"},
116: {"Help.Copying", MENU_NORMAL_MODE, ":help uganda\r"},
117: {"Help.Copying", MENU_VISUAL_MODE|MENU_INSERT_MODE|MENU_CMDLINE_MODE,
118: "\033:help uganda\r"},
119:
120: /* File menu */
121: {"File.Save :w", MENU_NORMAL_MODE, ":w\r"},
122: {"File.Save :w", MENU_INSERT_MODE, "\017:w\r"},
123:
124: {"File.Close :q", MENU_NORMAL_MODE, ":q\r"},
125: {"File.Close :q", MENU_VISUAL_MODE|MENU_INSERT_MODE|MENU_CMDLINE_MODE,
126: "\033:q\r"},
127:
128: {"File.Quit :qa", MENU_NORMAL_MODE, ":qa\r"},
129: {"File.Quit :qa", MENU_VISUAL_MODE|MENU_INSERT_MODE|MENU_CMDLINE_MODE,
130: "\033:qa\r"},
131:
132: {"File.Save-Quit :wqa",MENU_NORMAL_MODE, ":wqa\r"},
133: {"File.Save-Quit :wqa",MENU_VISUAL_MODE|MENU_INSERT_MODE|MENU_CMDLINE_MODE,
134: "\033:wqa\r"},
135:
136: /* Edit menu */
137: {"Edit.Undo", MENU_NORMAL_MODE, "u"},
138: {"Edit.Redo", MENU_NORMAL_MODE, "\022"},
139:
140: {"Edit.Cut", MENU_VISUAL_MODE, "x"},
141: {"Edit.Copy", MENU_VISUAL_MODE, "y"},
142: {"Edit.Put Before", MENU_NORMAL_MODE, "[p"},
143: {"Edit.Put Before", MENU_INSERT_MODE, "\017[p"},
144: {"Edit.Put After", MENU_NORMAL_MODE, "]p"},
145: {"Edit.Put After", MENU_INSERT_MODE, "\017]p"},
146: {"Edit.Paste", MENU_NORMAL_MODE, "i\022*\033"}, /* CTRL-R * */
147: {"Edit.Paste", MENU_INSERT_MODE|MENU_CMDLINE_MODE,
148: "\022*"}, /* CTRL-R * */
149: {NULL, 0, NULL}
150: };
151:
152: /*
153: * This is the call which starts the GUI.
154: */
155: void
156: gui_init()
157: {
158: char_u *env_str;
159: int i;
160:
161: gui.dying = FALSE;
162: gui.in_focus = FALSE;
163: gui.dragged_sb = SB_NONE;
164: gui.dragged_wp = NULL;
165: gui.col = gui.num_cols = 0;
166: gui.row = gui.num_rows = 0;
167:
168: /* Initialise gui.cursor_row: */
169: INVALIDATE_CURSOR();
170: gui.scroll_region_top = 0;
171: gui.scroll_region_bot = Rows - 1;
172: gui.highlight_mask = HL_NORMAL;
173: gui.char_width = 0;
174: gui.char_height = 0;
175: gui.char_ascent = 0;
176: gui.border_width = 0;
177:
178: gui.selection.owned = FALSE;
179: gui.selection.start.lnum = 0;
180: gui.selection.start.col = 0;
181: gui.selection.end.lnum = 0;
182: gui.selection.end.col = 0;
183: gui.selection.state = SELECT_CLEARED;
184:
185: gui.root_menu = NULL;
186: gui.menu_is_active = TRUE; /* default: include menu */
187:
188: gui.scrollbar_width = SB_DEFAULT_WIDTH;
189: gui.menu_height = MENU_DEFAULT_HEIGHT;
190: for (i = 0; i < 3; i++)
191: gui.new_sb[i] = FALSE;
192:
193: gui.prev_wrap = -1;
194:
195: for (i = 0; default_menus[i].name != NULL; ++i)
196: gui_add_menu_path((char_u *)default_menus[i].name,
197: default_menus[i].mode, gui_menu_cb,
198: (char_u *)default_menus[i].command, TRUE);
199:
200: /*
201: * Switch on the mouse by default.
202: * This can be changed in the .gvimrc.
203: */
204: set_string_option((char_u *)"mouse", -1, (char_u *)"a", TRUE);
205:
206: /*
207: * Get system wide defaults for gvim (Unix only)
208: */
209: #ifdef HAVE_CONFIG_H
210: do_source(sys_gvimrc_fname, FALSE);
211: #endif
212:
213: /*
214: * Try to read GUI initialization commands from the following places:
215: * - environment variable GVIMINIT
216: * - the user gvimrc file (~/.gvimrc for Unix)
217: * The first that exists is used, the rest is ignored.
218: */
219: if ((env_str = vim_getenv((char_u *)"GVIMINIT")) != NULL && *env_str != NUL)
220: {
221: sourcing_name = (char_u *)"GVIMINIT";
222: do_cmdline(env_str, TRUE, TRUE);
223: sourcing_name = NULL;
224: }
225: else
226: do_source((char_u *)USR_GVIMRC_FILE, FALSE);
227:
228: /*
229: * Read initialization commands from ".gvimrc" in current directory. This
230: * is only done if the 'exrc' option is set. Because of security reasons
231: * we disallow shell and write commands now, except for unix if the file is
232: * owned by the user or 'secure' option has been reset in environment of
233: * global ".gvimrc". Only do this if GVIMRC_FILE is not the same as
234: * USR_GVIMRC_FILE or sys_gvimrc_fname.
235: */
236: if (p_exrc)
237: {
238: #ifdef UNIX
239: {
240: struct stat s;
241:
242: /* if ".gvimrc" file is not owned by user, set 'secure' mode */
243: if (stat(GVIMRC_FILE, &s) || s.st_uid != getuid())
244: secure = p_secure;
245: }
246: #else
247: secure = p_secure;
248: #endif
249:
250: i = FAIL;
251: if (fullpathcmp((char_u *)USR_GVIMRC_FILE,
252: (char_u *)GVIMRC_FILE) != FPC_SAME
253: #ifdef HAVE_CONFIG_H
254: && fullpathcmp(sys_gvimrc_fname,
255: (char_u *)GVIMRC_FILE) != FPC_SAME
256: #endif
257: )
258: i = do_source((char_u *)GVIMRC_FILE, FALSE);
259: }
260:
261: /*
262: * Actually start the GUI itself.
263: */
264: gui.in_use = TRUE; /* Must be set after menus have been set up */
265: if (gui_mch_init() == FAIL)
266: {
267: gui.in_use = FALSE;
268: return;
269: }
270:
271: maketitle();
272:
273: gui_create_initial_menus(gui.root_menu, NULL);
274: }
275:
276: void
277: gui_exit()
278: {
279: gui.in_use = FALSE;
280: gui_mch_exit();
281: }
282:
283: /*
284: * Set the font. Uses the 'font' option. The first font name that works is
285: * used. If none is found, use the default font.
286: */
287: int
288: gui_init_font()
289: {
290: #define FONTLEN 100
291: char_u *font_list;
292: char_u font_name[FONTLEN];
293:
294: if (!gui.in_use)
295: return FAIL;
296:
297: for (font_list = p_guifont; *font_list != NUL; )
298: {
299: /* Isolate one font name */
300: (void)copy_option_part(&font_list, font_name, FONTLEN, ",");
301: if (gui_mch_init_font(font_name) == OK)
302: return OK;
303: }
304:
305: /*
306: * Couldn't load any font in 'font', tell gui_mch_init_font() to try and
307: * find a font we can load.
308: */
309: return gui_mch_init_font(NULL);
310: }
311:
312: void
313: gui_set_cursor(row, col)
314: int row;
315: int col;
316: {
317: gui.row = row;
318: gui.col = col;
319: }
320:
321: /*
322: * gui_check_screen - check if the cursor is on the screen.
323: */
324: static void
325: gui_check_screen()
326: {
327: if (gui.row >= Rows)
328: gui.row = Rows - 1;
329: if (gui.col >= Columns)
330: gui.col = Columns - 1;
331: if (gui.cursor_row >= Rows || gui.cursor_col >= Columns)
332: INVALIDATE_CURSOR();
333: }
334:
335: void
336: gui_update_cursor()
337: {
338: gui_check_screen();
339: if (gui.row != gui.cursor_row || gui.col != gui.cursor_col)
340: {
341: gui_undraw_cursor();
342: gui.cursor_row = gui.row;
343: gui.cursor_col = gui.col;
344: gui_mch_draw_cursor();
345: }
346: }
347:
348: /*
349: * Should be called after the GUI window has been resized. Its arguments are
350: * the new width and height of the window in pixels.
351: */
352: void
353: gui_resize_window(pixel_width, pixel_height)
354: int pixel_width;
355: int pixel_height;
356: {
357: gui.num_cols = (pixel_width - 2 * gui.border_offset) / gui.char_width;
358: gui.num_rows = (pixel_height - 2 * gui.border_offset) / gui.char_height;
359:
360: gui_reset_scroll_region();
361: /*
362: * At the "more" prompt there is no redraw, put the cursor at the last
363: * line here (why does it have to be one row too low???).
364: */
365: if (State == ASKMORE)
366: gui.row = gui.num_rows;
367:
368: if (gui.num_rows != screen_Rows || gui.num_cols != screen_Columns)
369: set_winsize(0, 0, FALSE);
370: gui_update_cursor();
371: }
372:
373: /*
374: * Make scroll region cover whole screen.
375: */
376: void
377: gui_reset_scroll_region()
378: {
379: gui.scroll_region_top = 0;
380: gui.scroll_region_bot = gui.num_rows - 1;
381: }
382:
383: void
384: gui_start_highlight(mask)
385: long_u mask;
386: {
387: gui.highlight_mask |= mask;
388: }
389:
390: void
391: gui_stop_highlight(mask)
392: long_u mask;
393: {
394: gui.highlight_mask &= ~mask;
395: }
396:
397: void
398: gui_write(s, len)
399: char_u *s;
400: int len;
401: {
402: char_u *p;
403: int arg1 = 0, arg2 = 0;
404:
405: /* #define DEBUG_GUI_WRITE */
406: #ifdef DEBUG_GUI_WRITE
407: {
408: int i;
409: char_u *str;
410:
411: printf("gui_write(%d):\n ", len);
412: for (i = 0; i < len; i++)
413: if (s[i] == ESC)
414: {
415: if (i != 0)
416: printf("\n ");
417: printf("<ESC>");
418: }
419: else
420: {
421: str = transchar(s[i]);
422: if (str[0] && str[1])
423: printf("<%s>", (char *)str);
424: else
425: printf("%s", (char *)str);
426: }
427: printf("\n");
428: }
429: #endif
430: while (len)
431: {
432: if (s[0] == '\n')
433: {
434: len--;
435: s++;
436: gui.col = 0;
437: if (gui.row < gui.scroll_region_bot)
438: gui.row++;
439: else
440: gui_mch_delete_lines(gui.scroll_region_top, 1);
441: }
442: else if (s[0] == '\r')
443: {
444: len--;
445: s++;
446: gui.col = 0;
447: }
448: else if (s[0] == Ctrl('G')) /* Beep */
449: {
450: gui_mch_beep();
451: len--;
452: s++;
453: }
454: else if (s[0] == ESC && s[1] == '|')
455: {
456: p = s + 2;
457: if (isdigit(*p))
458: {
459: arg1 = getdigits(&p);
460: if (p > s + len)
461: break;
462: if (*p == ';')
463: {
464: ++p;
465: arg2 = getdigits(&p);
466: if (p > s + len)
467: break;
468: }
469: }
470: switch (*p)
471: {
472: case 'C': /* Clear screen */
473: gui_mch_clear_block(0, 0, Rows - 1, Columns - 1);
474: break;
475: case 'M': /* Move cursor */
476: gui_set_cursor(arg1, arg2);
477: break;
478: case 'R': /* Set scroll region */
479: if (arg1 < arg2)
480: {
481: gui.scroll_region_top = arg1;
482: gui.scroll_region_bot = arg2;
483: }
484: else
485: {
486: gui.scroll_region_top = arg2;
487: gui.scroll_region_bot = arg1;
488: }
489: break;
490: case 'd': /* Delete line */
491: gui_mch_delete_lines(gui.row, 1);
492: break;
493: case 'D': /* Delete lines */
494: gui_mch_delete_lines(gui.row, arg1);
495: break;
496: case 'i': /* Insert line */
497: gui_mch_insert_lines(gui.row, 1);
498: break;
499: case 'I': /* Insert lines */
500: gui_mch_insert_lines(gui.row, arg1);
501: break;
502: case '$': /* Clear to end-of-line */
503: gui_mch_clear_block(gui.row, gui.col, gui.row, Columns - 1);
504: break;
505: case 'h': /* Turn on highlighting */
506: gui_start_highlight(arg1);
507: break;
508: case 'H': /* Turn off highlighting */
509: gui_stop_highlight(arg1);
510: break;
511: case 'f': /* flash the window (visual bell) */
512: gui_mch_flash();
513: break;
514: default:
515: p = s + 1; /* Skip the ESC */
516: break;
517: }
518: len -= ++p - s;
519: s = p;
520: }
521: else if (s[0] < 0x20) /* Ctrl character, shouldn't happen */
522: {
523: /*
524: * For some reason vim sends me a ^M after hitting return on the
525: * ':' line. Make sure we ignore this here.
526: */
527: len--; /* Skip this char */
528: s++;
529: }
530: else
531: {
532: p = s;
533: while (len && *p >= 0x20)
534: {
535: len--;
536: p++;
537: }
538: gui_outstr(s, p - s);
539: s = p;
540: }
541: }
542: gui_update_cursor();
543: gui_update_scrollbars();
544: gui_update_horiz_scrollbar();
545:
546: /*
547: * We need to make sure this is cleared since Athena doesn't tell us when
548: * he is done dragging.
549: */
550: gui.dragged_sb = SB_NONE;
551:
552: if (vim_strchr(p_guioptions, GO_ASEL) != NULL)
553: gui_update_selection();
554: gui_mch_flush(); /* In case vim decides to take a nap */
555: }
556:
557: static void
558: gui_outstr(s, len)
559: char_u *s;
560: int len;
561: {
562: int this_len;
563:
564: if (len == 0)
565: return;
566:
567: if (len < 0)
568: len = STRLEN(s);
569:
570: while (gui.col + len > Columns)
571: {
572: this_len = Columns - gui.col;
573: gui_mch_outstr_nowrap(s, this_len, TRUE, FALSE);
574: s += this_len;
575: len -= this_len;
576: }
577: gui_mch_outstr_nowrap(s, len, TRUE, FALSE);
578: }
579:
580: /*
581: * Un-draw the cursor. Actually this just redraws the character at the given
582: * position.
583: */
584: void
585: gui_undraw_cursor()
586: {
587: if (IS_CURSOR_VALID())
588: gui_redraw_block(gui.cursor_row, gui.cursor_col, gui.cursor_row,
589: gui.cursor_col);
590: }
591:
592: void
593: gui_redraw(x, y, w, h)
594: int x;
595: int y;
596: int w;
597: int h;
598: {
599: int row1, col1, row2, col2;
600:
601: row1 = Y_2_ROW(y);
602: col1 = X_2_COL(x);
603: row2 = Y_2_ROW(y + h - 1);
604: col2 = X_2_COL(x + w - 1);
605:
606: gui_redraw_block(row1, col1, row2, col2);
607:
608: /* We may need to redraw the cursor */
609: gui_update_cursor();
610: }
611:
612: void
613: gui_redraw_block(row1, col1, row2, col2)
614: int row1;
615: int col1;
616: int row2;
617: int col2;
618: {
619: int old_row, old_col;
620: long_u old_hl_mask;
621: char_u *screenp, *attrp, first_attr;
622: int idx, len;
623:
624: /* Don't try to draw outside the window! */
625: /* Check everything, strange values may be caused by big border width */
626: col1 = check_col(col1);
627: col2 = check_col(col2);
628: row1 = check_row(row1);
629: row2 = check_row(row2);
630:
631: /* Don't try to update when NextScreen is not valid */
632: if (!screen_cleared || NextScreen == NULL)
633: return;
634:
635: /* Remember where our cursor was */
636: old_row = gui.row;
637: old_col = gui.col;
638: old_hl_mask = gui.highlight_mask;
639:
640: for (gui.row = row1; gui.row <= row2; gui.row++)
641: {
642: gui.col = col1;
643: screenp = LinePointers[gui.row] + gui.col;
644: attrp = screenp + Columns;
645: len = col2 - col1 + 1;
646: while (len > 0)
647: {
648: switch (attrp[0])
649: {
650: case CHAR_INVERT:
651: gui.highlight_mask = HL_INVERSE;
652: break;
653: case CHAR_UNDERL:
654: gui.highlight_mask = HL_UNDERLINE;
655: break;
656: case CHAR_BOLD:
657: gui.highlight_mask = HL_BOLD;
658: break;
659: case CHAR_STDOUT:
660: gui.highlight_mask = HL_STANDOUT;
661: break;
662: case CHAR_ITALIC:
663: gui.highlight_mask = HL_ITAL;
664: break;
665: case CHAR_NORMAL:
666: default:
667: gui.highlight_mask = HL_NORMAL;
668: break;
669: }
670: first_attr = attrp[0];
671: for (idx = 0; len > 0 && attrp[idx] == first_attr; idx++)
672: --len;
673: gui_mch_outstr_nowrap(screenp, idx, FALSE, FALSE);
674: screenp += idx;
675: attrp += idx;
676: }
677: }
678:
679: /* Put the cursor back where it was */
680: gui.row = old_row;
681: gui.col = old_col;
682: gui.highlight_mask = old_hl_mask;
683: }
684:
685: /*
686: * Check bounds for column number
687: */
688: int
689: check_col(col)
690: int col;
691: {
692: if (col < 0)
693: return 0;
694: if (col >= (int)Columns)
695: return (int)Columns - 1;
696: return col;
697: }
698:
699: /*
700: * Check bounds for row number
701: */
702: int
703: check_row(row)
704: int row;
705: {
706: if (row < 0)
707: return 0;
708: if (row >= (int)Rows)
709: return (int)Rows - 1;
710: return row;
711: }
712:
713: /*
714: * Generic mouse support function. Add a mouse event to the input buffer with
715: * the given properties.
716: * button --- may be any of MOUSE_LEFT, MOUSE_MIDDLE, MOUSE_RIGHT,
717: * MOUSE_DRAG, or MOUSE_RELEASE.
718: * x, y --- Coordinates of mouse in pixels.
719: * repeated_click --- TRUE if this click comes only a short time after a
720: * previous click.
721: * modifiers --- Bit field which may be any of the following modifiers
722: * or'ed together: MOUSE_SHIFT | MOUSE_CTRL | MOUSE_ALT.
723: * This function will ignore drag events where the mouse has not moved to a new
724: * character.
725: */
726: void
727: gui_send_mouse_event(button, x, y, repeated_click, modifiers)
728: int button;
729: int x;
730: int y;
731: int repeated_click;
732: int_u modifiers;
733: {
734: static int prev_row = 0, prev_col = 0;
735: static int prev_button = -1;
736: static linenr_t prev_topline = 0;
737: static int num_clicks = 1;
738: char_u string[6];
739: int row, col;
740:
741: row = Y_2_ROW(y);
742: col = X_2_COL(x);
743:
744: /*
745: * If we are dragging and the mouse hasn't moved far enough to be on a
746: * different character, then don't send an event to vim.
747: */
748: if (button == MOUSE_DRAG && row == prev_row && col == prev_col)
749: return;
750:
751: /*
752: * If topline has changed (window scrolled) since the last click, reset
753: * repeated_click, because we don't want starting Visual mode when
754: * clicking on a different character in the text.
755: */
756: if (curwin->w_topline != prev_topline)
757: repeated_click = FALSE;
758:
759: string[0] = CSI; /* this sequence is recognized by check_termcode() */
760: string[1] = KS_MOUSE;
761: string[2] = K_FILLER;
762: if (button != MOUSE_DRAG && button != MOUSE_RELEASE)
763: {
764: if (repeated_click)
765: {
766: /*
767: * Handle multiple clicks. They only count if the mouse is still
768: * pointing at the same character.
769: */
770: if (button != prev_button || row != prev_row || col != prev_col)
771: num_clicks = 1;
772: else if (++num_clicks > 4)
773: num_clicks = 1;
774: }
775: else
776: num_clicks = 1;
777: prev_button = button;
778: prev_topline = curwin->w_topline;
779:
780: string[3] = (char_u)(button | 0x20);
781: SET_NUM_MOUSE_CLICKS(string[3], num_clicks);
782: }
783: else
784: string[3] = (char_u)button;
785:
786: string[3] |= modifiers;
787: string[4] = (char_u)(col + ' ' + 1);
788: string[5] = (char_u)(row + ' ' + 1);
789: add_to_input_buf(string, 6);
790:
791: prev_row = row;
792: prev_col = col;
793: }
794:
795: /*
796: * Selection stuff, for cutting and pasting text to other windows.
797: */
798:
799: /*
800: * Check whether the VIsual area has changed, and if so try to become the owner
801: * of the selection, and free any old converted selection we may still have
802: * lying around. If the VIsual mode has ended, make a copy of what was
803: * selected so we can still give it to others. Will probably have to make sure
804: * this is called whenever VIsual mode is ended.
805: */
806: static void
807: gui_update_selection()
808: {
809: /* If visual mode is only due to a redo command ("."), then ignore it */
810: if (redo_VIsual_busy)
811: return;
812: if (!VIsual_active)
813: {
814: gui_mch_clear_selection();
815: gui.selection.start = gui.selection.end = VIsual;
816: }
817: else if (lt(VIsual, curwin->w_cursor))
818: {
819: if (!equal(gui.selection.start, VIsual) ||
820: !equal(gui.selection.end, curwin->w_cursor))
821: {
822: gui_mch_clear_selection();
823: gui.selection.start = VIsual;
824: gui.selection.end = curwin->w_cursor;
825: gui_free_selection();
826: gui_own_selection();
827: }
828: }
829: else
830: {
831: if (!equal(gui.selection.start, curwin->w_cursor) ||
832: !equal(gui.selection.end, VIsual))
833: {
834: gui_mch_clear_selection();
835: gui.selection.start = curwin->w_cursor;
836: gui.selection.end = VIsual;
837: gui_free_selection();
838: gui_own_selection();
839: }
840: }
841: }
842:
843: void
844: gui_own_selection()
845: {
846: /*
847: * Also want to check somehow that we are reading from the keyboard rather
848: * than a mapping etc.
849: */
850: if (!gui.selection.owned && gui_mch_own_selection())
851: {
852: gui_free_selection();
853: gui.selection.owned = TRUE;
854: }
855: }
856:
857: void
858: gui_lose_selection()
859: {
860: gui_free_selection();
861: gui.selection.owned = FALSE;
862: gui_mch_lose_selection();
863: }
864:
865: void
866: gui_copy_selection()
867: {
868: if (VIsual_active)
869: {
870: if (vim_strchr(p_guioptions, GO_ASEL) == NULL)
871: gui_update_selection();
872: gui_own_selection();
873: if (gui.selection.owned)
874: gui_get_selection();
875: }
876: }
877:
878: void
879: gui_auto_select()
880: {
881: if (vim_strchr(p_guioptions, GO_ASEL) != NULL)
882: gui_copy_selection();
883: }
884:
885: /*
886: * Menu stuff.
887: */
888:
889: void
890: gui_menu_cb(menu)
891: GuiMenu *menu;
892: {
893: char_u bytes[3 + sizeof(long_u)];
894:
895: bytes[0] = CSI;
896: bytes[1] = KS_MENU;
897: bytes[2] = K_FILLER;
898: add_long_to_buf((long_u)menu, bytes + 3);
899: add_to_input_buf(bytes, 3 + sizeof(long_u));
900: }
901:
902: /*
903: * Return the index into the menu->strings or menu->noremap arrays for the
904: * current state. Returns MENU_INDEX_INVALID if there is no mapping for the
905: * given menu in the current mode.
906: */
907: int
908: gui_get_menu_index(menu, state)
909: GuiMenu *menu;
910: int state;
911: {
912: int idx;
913:
914: if (VIsual_active)
915: idx = MENU_INDEX_VISUAL;
916: else if ((state & NORMAL))
917: idx = MENU_INDEX_NORMAL;
918: else if ((state & INSERT))
919: idx = MENU_INDEX_INSERT;
920: else if ((state & CMDLINE))
921: idx = MENU_INDEX_CMDLINE;
922: else
923: idx = MENU_INDEX_INVALID;
924:
925: if (idx != MENU_INDEX_INVALID && menu->strings[idx] == NULL)
926: idx = MENU_INDEX_INVALID;
927: return idx;
928: }
929:
930: /*
931: * Return the modes specified by the given menu command (eg :menu! returns
932: * MENU_CMDLINE_MODE | MENU_INSERT_MODE). If noremap is not NULL, then the
933: * flag it points to is set according to whether the command is a "nore"
934: * command. If unmenu is not NULL, then the flag it points to is set
935: * according to whether the command is an "unmenu" command.
936: */
937: static int
938: gui_get_menu_cmd_modes(cmd, force, noremap, unmenu)
939: char_u *cmd;
940: int force; /* Was there a "!" after the command? */
941: int *noremap;
942: int *unmenu;
943: {
944: int modes = 0x0;
945:
946: if (*cmd == 'n' && cmd[1] != 'o') /* nmenu, nnoremenu */
947: {
948: modes |= MENU_NORMAL_MODE;
949: cmd++;
950: }
951: else if (*cmd == 'v') /* vmenu, vnoremenu */
952: {
953: modes |= MENU_VISUAL_MODE;
954: cmd++;
955: }
956: else if (*cmd == 'i') /* imenu, inoremenu */
957: {
958: modes |= MENU_INSERT_MODE;
959: cmd++;
960: }
961: else if (*cmd == 'c') /* cmenu, cnoremenu */
962: {
963: modes |= MENU_CMDLINE_MODE;
964: cmd++;
965: }
966: else if (force) /* menu!, noremenu! */
967: modes |= MENU_INSERT_MODE | MENU_CMDLINE_MODE;
968: else /* menu, noremenu */
969: modes |= MENU_NORMAL_MODE | MENU_VISUAL_MODE;
970:
971: if (noremap != NULL)
972: *noremap = (*cmd == 'n');
973: if (unmenu != NULL)
974: *unmenu = (*cmd == 'u');
975: return modes;
976: }
977:
978: /*
979: * Do the :menu commands.
980: */
981: void
982: gui_do_menu(cmd, arg, force)
983: char_u *cmd;
984: char_u *arg;
985: int force;
986: {
987: char_u *menu_path;
988: int modes;
989: char_u *map_to;
990: int noremap;
991: int unmenu;
992: char_u *map_buf;
993:
994: modes = gui_get_menu_cmd_modes(cmd, force, &noremap, &unmenu);
995: menu_path = arg;
996: if (*menu_path == NUL)
997: {
998: gui_show_menus(menu_path, modes);
999: return;
1000: }
1001: while (*arg && !vim_iswhite(*arg))
1002: {
1003: if ((*arg == '\\' || *arg == Ctrl('V')) && arg[1] != NUL)
1004: arg++;
1005: arg++;
1006: }
1007: if (*arg != NUL)
1008: *arg++ = NUL;
1009: arg = skipwhite(arg);
1010: map_to = arg;
1011: if (*map_to == NUL && !unmenu)
1012: {
1013: gui_show_menus(menu_path, modes);
1014: return;
1015: }
1016: else if (*map_to != NUL && unmenu)
1017: {
1018: EMSG("Trailing characters");
1019: return;
1020: }
1021: if (unmenu)
1022: {
1023: if (STRCMP(menu_path, "*") == 0) /* meaning: remove all menus */
1024: menu_path = (char_u *)"";
1025: gui_remove_menu(&gui.root_menu, menu_path, modes);
1026: }
1027: else
1028: {
1029: /* Replace special key codes */
1030: map_to = replace_termcodes(map_to, &map_buf, FALSE);
1031: gui_add_menu_path(menu_path, modes, gui_menu_cb, map_to, noremap);
1032: vim_free(map_buf);
1033: }
1034: }
1035:
1036: /*
1037: * Add the menu with the given name to the menu hierarchy
1038: */
1039: static int
1040: gui_add_menu_path(path_name, modes, call_back, call_data, noremap)
1041: char_u *path_name;
1042: int modes;
1043: void (*call_back)();
1044: char_u *call_data;
1045: int noremap;
1046: {
1047: GuiMenu **menup;
1048: GuiMenu *menu = NULL;
1049: GuiMenu *parent;
1050: char_u *p;
1051: char_u *name;
1052: int i;
1053:
1054: /* Make a copy so we can stuff around with it, since it could be const */
1055: path_name = strsave(path_name);
1056: if (path_name == NULL)
1057: return FAIL;
1058: menup = &gui.root_menu;
1059: parent = NULL;
1060: name = path_name;
1061: while (*name)
1062: {
1063: /* Get name of this element in the menu hierarchy */
1064: p = gui_menu_name_skip(name);
1065:
1066: /* See if it's already there */
1067: menu = *menup;
1068: while (menu != NULL)
1069: {
1070: if (STRCMP(name, menu->name) == 0)
1071: {
1072: if (*p == NUL && menu->children != NULL)
1073: {
1074: EMSG("Menu path must not lead to a sub-menu");
1075: vim_free(path_name);
1076: return FAIL;
1077: }
1078: else if (*p != NUL && menu->children == NULL)
1079: {
1080: EMSG("Part of menu-item path is not sub-menu");
1081: vim_free(path_name);
1082: return FAIL;
1083: }
1084: break;
1085: }
1086: menup = &menu->next;
1087: menu = menu->next;
1088: }
1089: if (menu == NULL)
1090: {
1091: if (*p == NUL && parent == NULL)
1092: {
1093: EMSG("Must not add menu items directly to menu bar");
1094: vim_free(path_name);
1095: return FAIL;
1096: }
1097:
1098: /* Not already there, so lets add it */
1099: menu = (GuiMenu *)alloc(sizeof(GuiMenu));
1100: if (menu == NULL)
1101: {
1102: vim_free(path_name);
1103: return FAIL;
1104: }
1105: menu->modes = modes;
1106: menu->name = strsave(name);
1107: menu->cb = NULL;
1108: for (i = 0; i < 4; i++)
1109: {
1110: menu->strings[i] = NULL;
1111: menu->noremap[i] = FALSE;
1112: }
1113: menu->children = NULL;
1114: menu->next = NULL;
1115: if (gui.in_use) /* Otherwise it will be added when GUI starts */
1116: {
1117: if (*p == NUL)
1118: {
1119: /* Real menu item, not sub-menu */
1120: gui_mch_add_menu_item(menu, parent);
1121:
1122: /* Want to update menus now even if mode not changed */
1123: force_menu_update = TRUE;
1124: }
1125: else
1126: {
1127: /* Sub-menu (not at end of path yet) */
1128: gui_mch_add_menu(menu, parent);
1129: }
1130: }
1131: *menup = menu;
1132: }
1133: else
1134: {
1135: /*
1136: * If this menu option was previously only available in other
1137: * modes, then make sure it's available for this one now
1138: */
1139: menu->modes |= modes;
1140: }
1141:
1142: menup = &menu->children;
1143: parent = menu;
1144: name = p;
1145: }
1146: vim_free(path_name);
1147:
1148: if (menu != NULL)
1149: {
1150: menu->cb = call_back;
1151: p = (call_data == NULL) ? NULL : strsave(call_data);
1152:
1153: /* May match more than one of these */
1154: if (modes & MENU_NORMAL_MODE)
1155: {
1156: gui_free_menu_string(menu, MENU_INDEX_NORMAL);
1157: menu->strings[MENU_INDEX_NORMAL] = p;
1158: menu->noremap[MENU_INDEX_NORMAL] = noremap;
1159: }
1160: if (modes & MENU_VISUAL_MODE)
1161: {
1162: gui_free_menu_string(menu, MENU_INDEX_VISUAL);
1163: menu->strings[MENU_INDEX_VISUAL] = p;
1164: menu->noremap[MENU_INDEX_VISUAL] = noremap;
1165: }
1166: if (modes & MENU_INSERT_MODE)
1167: {
1168: gui_free_menu_string(menu, MENU_INDEX_INSERT);
1169: menu->strings[MENU_INDEX_INSERT] = p;
1170: menu->noremap[MENU_INDEX_INSERT] = noremap;
1171: }
1172: if (modes & MENU_CMDLINE_MODE)
1173: {
1174: gui_free_menu_string(menu, MENU_INDEX_CMDLINE);
1175: menu->strings[MENU_INDEX_CMDLINE] = p;
1176: menu->noremap[MENU_INDEX_CMDLINE] = noremap;
1177: }
1178: }
1179: return OK;
1180: }
1181:
1182: /*
1183: * Remove the (sub)menu with the given name from the menu hierarchy
1184: * Called recursively.
1185: */
1186: static int
1187: gui_remove_menu(menup, name, modes)
1188: GuiMenu **menup;
1189: char_u *name;
1190: int modes;
1191: {
1192: GuiMenu *menu;
1193: GuiMenu *child;
1194: char_u *p;
1195:
1196: if (*menup == NULL)
1197: return OK; /* Got to bottom of hierarchy */
1198:
1199: /* Get name of this element in the menu hierarchy */
1200: p = gui_menu_name_skip(name);
1201:
1202: /* Find the menu */
1203: menu = *menup;
1204: while (menu != NULL)
1205: {
1206: if (*name == NUL || STRCMP(name, menu->name) == 0)
1207: {
1208: if (*p != NUL && menu->children == NULL)
1209: {
1210: EMSG("Part of menu-item path is not sub-menu");
1211: return FAIL;
1212: }
1213: if ((menu->modes & modes) != 0x0)
1214: {
1215: if (gui_remove_menu(&menu->children, p, modes) == FAIL)
1216: return FAIL;
1217: }
1218: else if (*name != NUL)
1219: {
1220: EMSG("Menu only exists in another mode");
1221: return FAIL;
1222: }
1223:
1224: /*
1225: * When name is empty, we are removing all menu items for the given
1226: * modes, so keep looping, otherwise we are just removing the named
1227: * menu item (which has been found) so break here.
1228: */
1229: if (*name != NUL)
1230: break;
1231:
1232: /* Remove the menu item for the given mode[s] */
1233: menu->modes &= ~modes;
1234:
1235: if (menu->modes == 0x0)
1236: {
1237: /* The menu item is no longer valid in ANY mode, so delete it */
1238: *menup = menu->next;
1239: gui_free_menu(menu);
1240: }
1241: else
1242: menup = &menu->next;
1243: }
1244: else
1245: menup = &menu->next;
1246: menu = *menup;
1247: }
1248: if (*name != NUL)
1249: {
1250: if (menu == NULL)
1251: {
1252: EMSG("No menu of that name");
1253: return FAIL;
1254: }
1255:
1256: /* Recalculate modes for menu based on the new updated children */
1257: menu->modes = 0x0;
1258: for (child = menu->children; child != NULL; child = child->next)
1259: menu->modes |= child->modes;
1260: if (menu->modes == 0x0)
1261: {
1262: /* The menu item is no longer valid in ANY mode, so delete it */
1263: *menup = menu->next;
1264: gui_free_menu(menu);
1265: }
1266: }
1267:
1268: return OK;
1269: }
1270:
1271: /*
1272: * Free the given menu structure
1273: */
1274: static void
1275: gui_free_menu(menu)
1276: GuiMenu *menu;
1277: {
1278: int i;
1279:
1280: gui_mch_destroy_menu(menu); /* Free machine specific menu structures */
1281: vim_free(menu->name);
1282: for (i = 0; i < 4; i++)
1283: gui_free_menu_string(menu, i);
1284: vim_free(menu);
1285:
1286: /* Want to update menus now even if mode not changed */
1287: force_menu_update = TRUE;
1288: }
1289:
1290: /*
1291: * Free the menu->string with the given index.
1292: */
1293: static void
1294: gui_free_menu_string(menu, idx)
1295: GuiMenu *menu;
1296: int idx;
1297: {
1298: int count = 0;
1299: int i;
1300:
1301: for (i = 0; i < 4; i++)
1302: if (menu->strings[i] == menu->strings[idx])
1303: count++;
1304: if (count == 1)
1305: vim_free(menu->strings[idx]);
1306: menu->strings[idx] = NULL;
1307: }
1308:
1309: /*
1310: * Show the mapping associated with a menu item or hierarchy in a sub-menu.
1311: */
1312: static int
1313: gui_show_menus(path_name, modes)
1314: char_u *path_name;
1315: int modes;
1316: {
1317: char_u *p;
1318: char_u *name;
1319: GuiMenu *menu;
1320: GuiMenu *parent = NULL;
1321:
1322: menu = gui.root_menu;
1323: name = path_name = strsave(path_name);
1324: if (path_name == NULL)
1325: return FAIL;
1326:
1327: /* First, find the (sub)menu with the given name */
1328: while (*name)
1329: {
1330: p = gui_menu_name_skip(name);
1331: while (menu != NULL)
1332: {
1333: if (STRCMP(name, menu->name) == 0)
1334: {
1335: /* Found menu */
1336: if (*p != NUL && menu->children == NULL)
1337: {
1338: EMSG("Part of menu-item path is not sub-menu");
1339: vim_free(path_name);
1340: return FAIL;
1341: }
1342: else if ((menu->modes & modes) == 0x0)
1343: {
1344: EMSG("Menu only exists in another mode");
1345: vim_free(path_name);
1346: return FAIL;
1347: }
1348: break;
1349: }
1350: menu = menu->next;
1351: }
1352: if (menu == NULL)
1353: {
1354: EMSG("No menu of that name");
1355: vim_free(path_name);
1356: return FAIL;
1357: }
1358: name = p;
1359: parent = menu;
1360: menu = menu->children;
1361: }
1362:
1363: /* Now we have found the matching menu, and we list the mappings */
1364: set_highlight('t'); /* Highlight title */
1365: start_highlight();
1366: MSG_OUTSTR("\n--- Menus ---");
1367: stop_highlight();
1368:
1369: gui_show_menus_recursive(parent, modes, 0);
1370: return OK;
1371: }
1372:
1373: /*
1374: * Recursively show the mappings associated with the menus under the given one
1375: */
1376: static void
1377: gui_show_menus_recursive(menu, modes, depth)
1378: GuiMenu *menu;
1379: int modes;
1380: int depth;
1381: {
1382: int i;
1383: int bit;
1384:
1385: if (menu != NULL && (menu->modes & modes) == 0x0)
1386: return;
1387:
1388: if (menu != NULL)
1389: {
1390: msg_outchar('\n');
1391: if (got_int) /* "q" hit for "--more--" */
1392: return;
1393: for (i = 0; i < depth; i++)
1394: MSG_OUTSTR(" ");
1395: set_highlight('d'); /* Same as for directories!? */
1396: start_highlight();
1397: msg_outstr(menu->name);
1398: stop_highlight();
1399: }
1400:
1401: if (menu != NULL && menu->children == NULL)
1402: {
1403: for (bit = 0; bit < 4; bit++)
1404: if ((menu->modes & modes & (1 << bit)) != 0)
1405: {
1406: msg_outchar('\n');
1407: if (got_int) /* "q" hit for "--more--" */
1408: return;
1409: for (i = 0; i < depth + 2; i++)
1410: MSG_OUTSTR(" ");
1411: msg_outchar("nvic"[bit]);
1412: if (menu->noremap[bit])
1413: msg_outchar('*');
1414: else
1415: msg_outchar(' ');
1416: MSG_OUTSTR(" ");
1417: msg_outtrans_special(menu->strings[bit], TRUE);
1418: }
1419: }
1420: else
1421: {
1422: if (menu == NULL)
1423: {
1424: menu = gui.root_menu;
1425: depth--;
1426: }
1427: else
1428: menu = menu->children;
1429: for (; menu != NULL; menu = menu->next)
1430: gui_show_menus_recursive(menu, modes, depth + 1);
1431: }
1432: }
1433:
1434: /*
1435: * Used when expanding menu names.
1436: */
1437: static GuiMenu *expand_menu = NULL;
1438: static int expand_modes = 0x0;
1439:
1440: /*
1441: * Work out what to complete when doing command line completion of menu names.
1442: */
1443: char_u *
1444: gui_set_context_in_menu_cmd(cmd, arg, force)
1445: char_u *cmd;
1446: char_u *arg;
1447: int force;
1448: {
1449: char_u *after_dot;
1450: char_u *p;
1451: char_u *path_name = NULL;
1452: char_u *name;
1453: int unmenu;
1454: GuiMenu *menu;
1455:
1456: expand_context = EXPAND_UNSUCCESSFUL;
1457:
1458: after_dot = arg;
1459: for (p = arg; *p && !vim_iswhite(*p); ++p)
1460: {
1461: if ((*p == '\\' || *p == Ctrl('V')) && p[1] != NUL)
1462: p++;
1463: else if (*p == '.')
1464: after_dot = p + 1;
1465: }
1466: if (*p == NUL) /* Complete the menu name */
1467: {
1468: /*
1469: * With :unmenu, you only want to match menus for the appropriate mode.
1470: * With :menu though you might want to add a menu with the same name as
1471: * one in another mode, so match menus fom other modes too.
1472: */
1473: expand_modes = gui_get_menu_cmd_modes(cmd, force, NULL, &unmenu);
1474: if (!unmenu)
1475: expand_modes = MENU_ALL_MODES;
1476:
1477: menu = gui.root_menu;
1478: if (after_dot != arg)
1479: {
1480: path_name = alloc(after_dot - arg);
1481: if (path_name == NULL)
1482: return NULL;
1483: STRNCPY(path_name, arg, after_dot - arg - 1);
1484: path_name[after_dot - arg - 1] = NUL;
1485: }
1486: name = path_name;
1487: while (name != NULL && *name)
1488: {
1489: p = gui_menu_name_skip(name);
1490: while (menu != NULL)
1491: {
1492: if (STRCMP(name, menu->name) == 0)
1493: {
1494: /* Found menu */
1495: if ((*p != NUL && menu->children == NULL)
1496: || ((menu->modes & expand_modes) == 0x0))
1497: {
1498: /*
1499: * Menu path continues, but we have reached a leaf.
1500: * Or menu exists only in another mode.
1501: */
1502: vim_free(path_name);
1503: return NULL;
1504: }
1505: break;
1506: }
1507: menu = menu->next;
1508: }
1509: if (menu == NULL)
1510: {
1511: /* No menu found with the name we were looking for */
1512: vim_free(path_name);
1513: return NULL;
1514: }
1515: name = p;
1516: menu = menu->children;
1517: }
1518:
1519: expand_context = EXPAND_MENUS;
1520: expand_pattern = after_dot;
1521: expand_menu = menu;
1522: }
1523: else /* We're in the mapping part */
1524: expand_context = EXPAND_NOTHING;
1525: return NULL;
1526: }
1527:
1528: /*
1529: * Expand the menu names.
1530: */
1531: int
1532: gui_ExpandMenuNames(prog, num_file, file)
1533: regexp *prog;
1534: int *num_file;
1535: char_u ***file;
1536: {
1537: GuiMenu *menu;
1538: int round;
1539: int count;
1540:
1541: /*
1542: * round == 1: Count the matches.
1543: * round == 2: Save the matches into the array.
1544: */
1545: for (round = 1; round <= 2; ++round)
1546: {
1547: count = 0;
1548: for (menu = expand_menu; menu != NULL; menu = menu->next)
1549: if ((menu->modes & expand_modes) != 0x0
1550: && vim_regexec(prog, menu->name, TRUE))
1551: {
1552: if (round == 1)
1553: count++;
1554: else
1555: (*file)[count++] = strsave_escaped(menu->name,
1556: (char_u *)" \t\\.");
1557: }
1558: if (round == 1)
1559: {
1560: *num_file = count;
1561: if (count == 0 || (*file = (char_u **)
1562: alloc((unsigned)(count * sizeof(char_u *)))) == NULL)
1563: return FAIL;
1564: }
1565: }
1566: return OK;
1567: }
1568:
1569: /*
1570: * Skip over this element of the menu path and return the start of the next
1571: * element. Any \ and ^Vs are removed from the current element.
1572: */
1573: static char_u *
1574: gui_menu_name_skip(name)
1575: char_u *name;
1576: {
1577: char_u *p;
1578:
1579: for (p = name; *p && *p != '.'; p++)
1580: if (*p == '\\' || *p == Ctrl('V'))
1581: {
1582: STRCPY(p, p + 1);
1583: if (*p == NUL)
1584: break;
1585: }
1586: if (*p)
1587: *p++ = NUL;
1588: return p;
1589: }
1590:
1591: /*
1592: * After we have started the GUI, then we can create any menus that have been
1593: * defined. This is done once here. gui_add_menu_path() may have already been
1594: * called to define these menus, and may be called again. This function calls
1595: * itself recursively. Should be called at the top level with:
1596: * gui_create_initial_menus(gui.root_menu, NULL);
1597: */
1598: static void
1599: gui_create_initial_menus(menu, parent)
1600: GuiMenu *menu;
1601: GuiMenu *parent;
1602: {
1603: while (menu)
1604: {
1605: if (menu->children != NULL)
1606: {
1607: gui_mch_add_menu(menu, parent);
1608: gui_create_initial_menus(menu->children, menu);
1609: }
1610: else
1611: gui_mch_add_menu_item(menu, parent);
1612: menu = menu->next;
1613: }
1614: }
1615:
1616:
1617: /*
1618: * Set which components are present.
1619: * If "oldval" is not NULL, "oldval" is the previous value, the new * value is
1620: * in p_guioptions.
1621: */
1622: void
1623: gui_init_which_components(oldval)
1624: char_u *oldval;
1625: {
1626: char_u *p;
1627: int i;
1628: int grey_old, grey_new;
1629: char_u *temp;
1630:
1631: if (oldval != NULL)
1632: {
1633: /*
1634: * Check if the menu's go from grey to non-grey or vise versa.
1635: */
1636: grey_old = (vim_strchr(oldval, GO_GREY) != NULL);
1637: grey_new = (vim_strchr(p_guioptions, GO_GREY) != NULL);
1638: if (grey_old != grey_new)
1639: {
1640: temp = p_guioptions;
1641: p_guioptions = oldval;
1642: gui_x11_update_menus(MENU_ALL_MODES);
1643: p_guioptions = temp;
1644: }
1645: }
1646:
1647: gui.menu_is_active = FALSE;
1648: for (i = 0; i < 3; i++)
1649: gui.which_scrollbars[i] = FALSE;
1650: for (p = p_guioptions; *p; p++)
1651: switch (*p)
1652: {
1653: case GO_LEFT:
1654: gui.which_scrollbars[SB_LEFT] = TRUE;
1655: break;
1656: case GO_RIGHT:
1657: gui.which_scrollbars[SB_RIGHT] = TRUE;
1658: break;
1659: case GO_BOT:
1660: gui.which_scrollbars[SB_BOTTOM] = TRUE;
1661: break;
1662: case GO_MENUS:
1663: gui.menu_is_active = TRUE;
1664: break;
1665: case GO_GREY:
1666: /* make menu's have grey items, ignored here */
1667: break;
1668: default:
1669: /* Should give error message for internal error */
1670: break;
1671: }
1672: if (gui.in_use)
1673: gui_mch_create_which_components();
1674: }
1675:
1676:
1677: /*
1678: * Vertical scrollbar stuff:
1679: */
1680:
1681: static void
1682: gui_update_scrollbars()
1683: {
1684: WIN *wp;
1685: int worst_update = SB_UPDATE_NOTHING;
1686: int val, size, max;
1687: int which_sb;
1688: int cmdline_height;
1689:
1690: /*
1691: * Don't want to update a scrollbar while we're dragging it. But if we
1692: * have both a left and right scrollbar, and we drag one of them, we still
1693: * need to update the other one.
1694: */
1695: if ((gui.dragged_sb == SB_LEFT || gui.dragged_sb == SB_RIGHT) &&
1696: (!gui.which_scrollbars[SB_LEFT] || !gui.which_scrollbars[SB_RIGHT]))
1697: return;
1698:
1699: if (gui.dragged_sb == SB_LEFT || gui.dragged_sb == SB_RIGHT)
1700: {
1701: /*
1702: * If we have two scrollbars and one of them is being dragged, just
1703: * copy the scrollbar position from the dragged one to the other one.
1704: */
1705: which_sb = SB_LEFT + SB_RIGHT - gui.dragged_sb;
1706: if (gui.dragged_wp != NULL)
1707: gui.dragged_wp->w_scrollbar.update[which_sb] = SB_UPDATE_VALUE;
1708: else
1709: gui.cmdline_sb.update[which_sb] = SB_UPDATE_VALUE;
1710:
1711: gui_mch_update_scrollbars(SB_UPDATE_VALUE, which_sb);
1712: return;
1713: }
1714:
1715: /* Return straight away if there is neither a left nor right scrollbar */
1716: if (!gui.which_scrollbars[SB_LEFT] && !gui.which_scrollbars[SB_RIGHT])
1717: return;
1718:
1719: cmdline_height = Rows;
1720: for (wp = firstwin; wp; wp = wp->w_next)
1721: {
1722: cmdline_height -= wp->w_height + wp->w_status_height;
1723: if (wp->w_buffer == NULL) /* just in case */
1724: continue;
1725: #ifdef SCROLL_PAST_END
1726: max = wp->w_buffer->b_ml.ml_line_count;
1727: #else
1728: max = wp->w_buffer->b_ml.ml_line_count + wp->w_height - 1;
1729: #endif
1730: if (max < 1) /* empty buffer */
1731: max = 1;
1732: val = wp->w_topline;
1733: size = wp->w_height;
1734: #ifdef SCROLL_PAST_END
1735: if (val > max) /* just in case */
1736: val = max;
1737: #else
1738: if (size > max) /* just in case */
1739: size = max;
1740: if (val > max - size + 1)
1741: {
1742: val = max - size + 1;
1743: if (val < 1) /* minimal value is 1 */
1744: val = 1;
1745: }
1746: #endif
1747: if (size < 1 || wp->w_botline - 1 > max)
1748: {
1749: /*
1750: * This can happen during changing files. Just don't update the
1751: * scrollbar for now.
1752: */
1753: }
1754: else if (wp->w_scrollbar.height == 0)
1755: {
1756: /* Must be a new window */
1757: wp->w_scrollbar.update[SB_LEFT] = SB_UPDATE_CREATE;
1758: wp->w_scrollbar.update[SB_RIGHT] = SB_UPDATE_CREATE;
1759: wp->w_scrollbar.value = val;
1760: wp->w_scrollbar.size = size;
1761: wp->w_scrollbar.max = max;
1762: wp->w_scrollbar.top = wp->w_winpos;
1763: wp->w_scrollbar.height = wp->w_height;
1764: wp->w_scrollbar.status_height = wp->w_status_height;
1765: gui.num_scrollbars++;
1766: worst_update = SB_UPDATE_CREATE;
1767: }
1768: else if (wp->w_scrollbar.top != wp->w_winpos
1769: || wp->w_scrollbar.height != wp->w_height
1770: || wp->w_scrollbar.status_height != wp->w_status_height)
1771: {
1772: /* Height of scrollbar has changed */
1773: wp->w_scrollbar.update[SB_LEFT] = SB_UPDATE_HEIGHT;
1774: wp->w_scrollbar.update[SB_RIGHT] = SB_UPDATE_HEIGHT;
1775: wp->w_scrollbar.value = val;
1776: wp->w_scrollbar.size = size;
1777: wp->w_scrollbar.max = max;
1778: wp->w_scrollbar.top = wp->w_winpos;
1779: wp->w_scrollbar.height = wp->w_height;
1780: wp->w_scrollbar.status_height = wp->w_status_height;
1781: if (worst_update < SB_UPDATE_HEIGHT)
1782: worst_update = SB_UPDATE_HEIGHT;
1783: }
1784: else if (wp->w_scrollbar.value != val
1785: || wp->w_scrollbar.size != size
1786: || wp->w_scrollbar.max != max)
1787: {
1788: /* Thumb of scrollbar has moved */
1789: wp->w_scrollbar.update[SB_LEFT] = SB_UPDATE_VALUE;
1790: wp->w_scrollbar.update[SB_RIGHT] = SB_UPDATE_VALUE;
1791: wp->w_scrollbar.value = val;
1792: wp->w_scrollbar.size = size;
1793: wp->w_scrollbar.max = max;
1794: if (worst_update < SB_UPDATE_VALUE)
1795: worst_update = SB_UPDATE_VALUE;
1796: }
1797:
1798: /*
1799: * We may have just created the left scrollbar say, when we already had
1800: * the right one.
1801: */
1802: if (gui.new_sb[SB_LEFT])
1803: wp->w_scrollbar.update[SB_LEFT] = SB_UPDATE_CREATE;
1804: if (gui.new_sb[SB_RIGHT])
1805: wp->w_scrollbar.update[SB_RIGHT] = SB_UPDATE_CREATE;
1806: }
1807: if (cmdline_height < 1)
1808: cmdline_height = 1; /* Shouldn't happen, but just in case */
1809:
1810: /* Check the command line scrollbar */
1811: if (gui.cmdline_sb.height != cmdline_height
1812: || gui.cmdline_sb.status_height != lastwin->w_status_height)
1813: {
1814: /* Height of scrollbar has changed */
1815: gui.cmdline_sb.update[SB_LEFT] = SB_UPDATE_HEIGHT;
1816: gui.cmdline_sb.update[SB_RIGHT] = SB_UPDATE_HEIGHT;
1817: gui.cmdline_sb.value = 0;
1818: gui.cmdline_sb.size = 1; /* No thumb */
1819: gui.cmdline_sb.max = 0;
1820: gui.cmdline_sb.top = Rows - cmdline_height;
1821: gui.cmdline_sb.height = cmdline_height;
1822: gui.cmdline_sb.status_height = lastwin->w_status_height;
1823: if (worst_update < SB_UPDATE_HEIGHT)
1824: worst_update = SB_UPDATE_HEIGHT;
1825: }
1826:
1827: /*
1828: * If we have just created the left or right scrollbar-box, then we need to
1829: * update the height of the command line scrollbar (it will already be
1830: * created).
1831: */
1832: if (gui.new_sb[SB_LEFT])
1833: {
1834: gui.cmdline_sb.update[SB_LEFT] = SB_UPDATE_HEIGHT;
1835: worst_update = SB_UPDATE_CREATE;
1836: gui.new_sb[SB_LEFT] = FALSE;
1837: }
1838: if (gui.new_sb[SB_RIGHT])
1839: {
1840: gui.cmdline_sb.update[SB_RIGHT] = SB_UPDATE_HEIGHT;
1841: worst_update = SB_UPDATE_CREATE;
1842: gui.new_sb[SB_RIGHT] = FALSE;
1843: }
1844:
1845: if (worst_update != SB_UPDATE_NOTHING)
1846: {
1847: if (gui.which_scrollbars[SB_LEFT] && gui.dragged_sb != SB_LEFT)
1848: gui_mch_update_scrollbars(worst_update, SB_LEFT);
1849: if (gui.which_scrollbars[SB_RIGHT] && gui.dragged_sb != SB_RIGHT)
1850: gui_mch_update_scrollbars(worst_update, SB_RIGHT);
1851: }
1852: }
1853:
1854: /*
1855: * Scroll a window according to the values set in the globals current_scrollbar
1856: * and scrollbar_value. Return TRUE if the cursor in the current window moved
1857: * or FALSE otherwise.
1858: */
1859: int
1860: gui_do_scroll()
1861: {
1862: WIN *wp, *old_wp;
1863: int i;
1864: FPOS old_cursor;
1865:
1866: for (wp = firstwin, i = 0; i < current_scrollbar; i++)
1867: {
1868: if (wp == NULL)
1869: break;
1870: wp = wp->w_next;
1871: }
1872: if (wp != NULL)
1873: {
1874: old_cursor = curwin->w_cursor;
1875: old_wp = curwin;
1876: curwin = wp;
1877: curbuf = wp->w_buffer;
1878: i = (long)scrollbar_value - (long)wp->w_topline;
1879: if (i < 0)
1880: scrolldown(-i);
1881: else if (i > 0)
1882: scrollup(i);
1883: if (p_so)
1884: cursor_correct();
1885: coladvance(curwin->w_curswant);
1886:
1887: curwin = old_wp;
1888: curbuf = old_wp->w_buffer;
1889:
1890: if (wp == curwin)
1891: cursupdate(); /* fix window for 'so' */
1892: wp->w_redr_type = VALID;
1893: updateWindow(wp); /* update window, status line, and cmdline */
1894:
1895: return !equal(curwin->w_cursor, old_cursor);
1896: }
1897: else
1898: {
1899: /* Command-line scrollbar, unimplemented */
1900: return FALSE;
1901: }
1902: }
1903:
1904:
1905: /*
1906: * Horizontal scrollbar stuff:
1907: */
1908:
1909: static void
1910: gui_update_horiz_scrollbar()
1911: {
1912: int value, size, max;
1913:
1914: if (!gui.which_scrollbars[SB_BOTTOM])
1915: return;
1916:
1917: if (gui.dragged_sb == SB_BOTTOM)
1918: return;
1919:
1920: if (curwin->w_p_wrap && gui.prev_wrap)
1921: return;
1922:
1923: /*
1924: * It is possible for the cursor to be invalid if we're in the middle of
1925: * something (like changing files). If so, don't do anything for now.
1926: */
1927: if (curwin->w_cursor.lnum > curbuf->b_ml.ml_line_count)
1928: return;
1929:
1930: if (curwin->w_p_wrap)
1931: {
1932: value = 0;
1933: size = Columns;
1934: #ifdef SCROLL_PAST_END
1935: max = 0;
1936: #else
1937: max = Columns - 1;
1938: #endif
1939: }
1940: else
1941: {
1942: value = curwin->w_leftcol;
1943: size = Columns;
1944: #ifdef SCROLL_PAST_END
1945: max = gui_get_max_horiz_scroll();
1946: #else
1947: max = gui_get_max_horiz_scroll() + Columns - 1;
1948: #endif
1949: }
1950: gui_mch_update_horiz_scrollbar(value, size, max + 1);
1951: gui.prev_wrap = curwin->w_p_wrap;
1952: }
1953:
1954: /*
1955: * Determine the maximum value for scrolling right.
1956: */
1957: int
1958: gui_get_max_horiz_scroll()
1959: {
1960: int max = 0;
1961: char_u *p;
1962:
1963: p = ml_get_curline();
1964: if (p[0] != NUL)
1965: while (p[1] != NUL) /* Don't count last character */
1966: max += chartabsize(*p++, (colnr_t)max);
1967: return max;
1968: }
1969:
1970: /*
1971: * Do a horizontal scroll. Return TRUE if the cursor moved, or FALSE otherwise
1972: */
1973: int
1974: gui_do_horiz_scroll()
1975: {
1976: char_u *p;
1977: int i;
1978: int vcol;
1979: int ret_val = FALSE;
1980:
1981: /* no wrapping, no scrolling */
1982: if (curwin->w_p_wrap)
1983: return FALSE;
1984:
1985: curwin->w_leftcol = scrollbar_value;
1986:
1987: i = 0;
1988: vcol = 0;
1989: p = ml_get_curline();
1990: while (p[i] && i < curwin->w_cursor.col && vcol < curwin->w_leftcol)
1991: vcol += chartabsize(p[i++], (colnr_t)vcol);
1992: if (vcol < curwin->w_leftcol)
1993: {
1994: /*
1995: * Cursor is on a character that is at least partly off the left hand
1996: * side of the screen.
1997: */
1998: while (p[i] && vcol < curwin->w_leftcol)
1999: vcol += chartabsize(p[i++], (colnr_t)vcol);
2000: curwin->w_cursor.col = i;
2001: curwin->w_set_curswant = TRUE;
2002: ret_val = TRUE;
2003: }
2004:
2005: while (p[i] && i <= curwin->w_cursor.col
2006: && vcol <= curwin->w_leftcol + Columns)
2007: vcol += chartabsize(p[i++], (colnr_t)vcol);
2008: if (vcol > curwin->w_leftcol + Columns)
2009: {
2010: /*
2011: * Cursor is on a character that is at least partly off the right hand
2012: * side of the screen.
2013: */
2014: if (i < 2)
2015: i = 0;
2016: else
2017: i -= 2;
2018: curwin->w_cursor.col = i;
2019: curwin->w_set_curswant = TRUE;
2020: ret_val = TRUE;
2021: }
2022: updateScreen(NOT_VALID);
2023: return ret_val;
2024: }
![[BACK]](/icons/back.gif){kind=icon}
Return to gui.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / src / usr.bin / vim