home *** CD-ROM | disk | FTP | other *** search
/ vim.ftp.fu-berlin.de / 2015-02-03.vim.ftp.fu-berlin.de.tar / vim.ftp.fu-berlin.de / amiga / vim46src.lha / vim-4.6 / src / gui_x11.c < prev    next >
Encoding:
C/C++ Source or Header  |  1997-02-06  |  56.6 KB  |  2,376 lines
  1. /* vi:set ts=4 sw=4:
  2.  *
  3.  * VIM - Vi IMproved            by Bram Moolenaar
  4.  *                                GUI/Motif support by Robert Webb
  5.  *
  6.  * Do ":help uganda"  in Vim to read copying and usage conditions.
  7.  * Do ":help credits" in Vim to see a list of people who contributed.
  8.  */
  9.  
  10. #include <X11/keysym.h>
  11. #include <X11/Xatom.h>
  12. #include <X11/StringDefs.h>
  13. #include <X11/Intrinsic.h>
  14. #include <X11/Shell.h>
  15.  
  16. #include "vim.h"
  17. #include "globals.h"
  18. #include "proto.h"
  19. #include "option.h"
  20. #include "ops.h"
  21.  
  22. #define VIM_NAME        "vim"
  23. #define VIM_CLASS        "Vim"
  24.  
  25. /* Default resource values */
  26. #define DFLT_FONT                "7x13"
  27. #define DFLT_MENU_BG_COLOR        "gray77"
  28. #define DFLT_MENU_FG_COLOR        "black"
  29. #define DFLT_SCROLL_BG_COLOR    "gray60"
  30. #define DFLT_SCROLL_FG_COLOR    "gray77"
  31.  
  32. Widget vimShell = (Widget)NULL;
  33.  
  34. static XtAppContext app_context;
  35. static Atom   Atom_WM_DELETE_WINDOW;
  36.  
  37. static Pixel gui_x11_get_color            __ARGS((char_u *));
  38. static void  gui_x11_set_color            __ARGS((GC, Pixel));
  39. static void  gui_x11_set_font             __ARGS((GC, Font));
  40. static void  gui_x11_check_copy_area      __ARGS((void));
  41. static void  gui_x11_update_menus_recurse __ARGS((GuiMenu *, int));
  42.  
  43. static void  gui_x11_request_selection_cb __ARGS((Widget, XtPointer,
  44.                                                   Atom *, Atom *, XtPointer,
  45.                                                   long_u *, int *));
  46.  
  47. static Boolean  gui_x11_convert_selection_cb __ARGS((Widget, Atom *, Atom *, 
  48.                                                       Atom *, XtPointer *,
  49.                                                      long_u *, int *));
  50.  
  51. static void  gui_x11_lose_ownership_cb __ARGS((Widget, Atom *));
  52.  
  53. static void  gui_x11_wm_protocol_handler __ARGS((Widget, XtPointer,
  54.                                             XEvent *, Boolean *));
  55.  
  56. static void gui_x11_invert_area         __ARGS((int, int, int, int));
  57. static void gui_x11_yank_selection      __ARGS((int, int, int, int));
  58. static void gui_x11_get_word_boundaries __ARGS((GuiSelection *, int, int));
  59. static int  gui_x11_get_line_end        __ARGS((int));
  60. static void gui_x11_update_selection    __ARGS((GuiSelection *, int, int, int,
  61.                                                 int));
  62.  
  63. #define char_class(c)    (c <= ' ' ? ' ' : iswordchar(c))
  64.  
  65. #define invert_rectangle(r, c, nr, nc)                                \
  66.             XFillRectangle(gui.dpy, gui.wid, gui.invert_gc,            \
  67.                     FILL_X(c), FILL_Y(r), (nc) * gui.char_width,    \
  68.                     (nr) * gui.char_height)
  69.  
  70.  
  71. static struct
  72. {
  73.     KeySym    key_sym;
  74.     char_u    vim_code0;
  75.     char_u    vim_code1;
  76. } special_keys[] =
  77. {
  78.     {XK_Up,            'k', 'u'},
  79.     {XK_Down,        'k', 'd'},
  80.     {XK_Left,        'k', 'l'},
  81.     {XK_Right,        'k', 'r'},
  82.  
  83.     {XK_F1,            'k', '1'},
  84.     {XK_F2,            'k', '2'},
  85.     {XK_F3,            'k', '3'},
  86.     {XK_F4,            'k', '4'},
  87.     {XK_F5,            'k', '5'},
  88.     {XK_F6,            'k', '6'},
  89.     {XK_F7,            'k', '7'},
  90.     {XK_F8,            'k', '8'},
  91.     {XK_F9,            'k', '9'},
  92.     {XK_F10,        'k', ';'},
  93.  
  94.     {XK_F11,        'F', '1'},
  95.     {XK_F12,        'F', '2'},
  96.     {XK_F13,        'F', '3'},
  97.     {XK_F14,        'F', '4'},
  98.     {XK_F15,        'F', '5'},
  99.     {XK_F16,        'F', '6'},
  100.     {XK_F17,        'F', '7'},
  101.     {XK_F18,        'F', '8'},
  102.     {XK_F19,        'F', '9'},
  103.     {XK_F20,        'F', 'A'},
  104.  
  105.     {XK_F21,        'F', 'B'},
  106.     {XK_F22,        'F', 'C'},
  107.     {XK_F23,        'F', 'D'},
  108.     {XK_F24,        'F', 'E'},
  109.     {XK_F25,        'F', 'F'},
  110.     {XK_F26,        'F', 'G'},
  111.     {XK_F27,        'F', 'H'},
  112.     {XK_F28,        'F', 'I'},
  113.     {XK_F29,        'F', 'J'},
  114.     {XK_F30,        'F', 'K'},
  115.  
  116.     {XK_F31,        'F', 'L'},
  117.     {XK_F32,        'F', 'M'},
  118.     {XK_F33,        'F', 'N'},
  119.     {XK_F34,        'F', 'O'},
  120.     {XK_F35,        'F', 'P'},        /* keysymdef.h defines up to F35 */
  121.  
  122.     {XK_Help,        '%', '1'},
  123.     {XK_Undo,        '&', '8'},
  124.     {XK_BackSpace,    'k', 'b'},
  125.     {XK_Insert,        'k', 'I'},
  126.     {XK_Delete,        'k', 'D'},
  127.     {XK_Home,        'k', 'h'},
  128.     {XK_End,        '@', '7'},
  129.     {XK_Prior,        'k', 'P'},
  130.     {XK_Next,        'k', 'N'},
  131.     {XK_Print,        '%', '9'},
  132.  
  133.     /* Keypad keys: */
  134. #ifdef XK_KP_Left
  135.     {XK_KP_Left,    'k', 'l'},
  136.     {XK_KP_Right,    'k', 'r'},
  137.     {XK_KP_Up,        'k', 'u'},
  138.     {XK_KP_Down,    'k', 'd'},
  139.     {XK_KP_Insert,    'k', 'I'},
  140.     {XK_KP_Delete,    'k', 'D'},
  141.     {XK_KP_Home,    'k', 'h'},
  142.     {XK_KP_End,        '@', '7'},
  143.     {XK_KP_Prior,    'k', 'P'},
  144.     {XK_KP_Next,    'k', 'N'},
  145. #endif
  146.  
  147.     /* End of list marker: */
  148.     {(KeySym)0,        0, 0}
  149. };
  150.  
  151. #define XtNboldColor        "boldColor"
  152. #define XtCBoldColor        "BoldColor"
  153. #define XtNitalicColor        "italicColor"
  154. #define XtCItalicColor        "ItalicColor"
  155. #define XtNunderlineColor    "underlineColor"
  156. #define XtCUnderlineColor    "UnderlineColor"
  157. #define XtNcursorColor        "cursorColor"
  158. #define XtCCursorColor        "CursorColor"
  159. #define XtNboldFont            "boldFont"
  160. #define XtCBoldFont            "BoldFont"
  161. #define XtNitalicFont        "italicFont"
  162. #define XtCItalicFont        "ItalicFont"
  163. #define XtNboldItalicFont    "boldItalicFont"
  164. #define XtCBoldItalicFont    "BoldItalicFont"
  165. #define XtNscrollbarWidth    "scrollbarWidth"
  166. #define XtCScrollbarWidth    "ScrollbarWidth"
  167. #define XtNmenuHeight        "menuHeight"
  168. #define XtCMenuHeight        "MenuHeight"
  169.  
  170. /* Resources for setting the foreground and background colors of menus */
  171. #define XtNmenuBackground    "menuBackground"
  172. #define XtCMenuBackground    "MenuBackground"
  173. #define XtNmenuForeground    "menuForeground"
  174. #define XtCMenuForeground    "MenuForeground"
  175.  
  176. /* Resources for setting the foreground and background colors of scrollbars */
  177. #define XtNscrollBackground    "scrollBackground"
  178. #define XtCScrollBackground    "ScrollBackground"
  179. #define XtNscrollForeground    "scrollForeground"
  180. #define XtCScrollForeground    "ScrollForeground"
  181.  
  182. /*
  183.  * X Resources:
  184.  */
  185. static XtResource vim_resources[] =
  186. {
  187.     {
  188.         XtNforeground,
  189.         XtCForeground,
  190.         XtRPixel,
  191.         sizeof(Pixel),
  192.         XtOffsetOf(Gui, norm_pixel),
  193.         XtRString,
  194.         XtDefaultForeground
  195.     },
  196.     {
  197.         XtNbackground,
  198.         XtCBackground,
  199.         XtRPixel,
  200.         sizeof(Pixel),
  201.         XtOffsetOf(Gui, back_pixel),
  202.         XtRString,
  203.         XtDefaultBackground
  204.     },
  205.     {
  206.         XtNboldColor,
  207.         XtCBoldColor,
  208.         XtRPixel,
  209.         sizeof(Pixel),
  210.         XtOffsetOf(Gui, bold_pixel),
  211.         XtRString,
  212.         XtDefaultForeground
  213.     },
  214.     {
  215.         XtNitalicColor,
  216.         XtCItalicColor,
  217.         XtRPixel,
  218.         sizeof(Pixel),
  219.         XtOffsetOf(Gui, ital_pixel),
  220.         XtRString,
  221.         XtDefaultForeground
  222.     },
  223.     {
  224.         XtNunderlineColor,
  225.         XtCUnderlineColor,
  226.         XtRPixel,
  227.         sizeof(Pixel),
  228.         XtOffsetOf(Gui, underline_pixel),
  229.         XtRString,
  230.         XtDefaultForeground
  231.     },
  232.     {
  233.         XtNcursorColor,
  234.         XtCCursorColor,
  235.         XtRPixel,
  236.         sizeof(Pixel),
  237.         XtOffsetOf(Gui, cursor_pixel),
  238.         XtRString,
  239.         XtDefaultForeground
  240.     },
  241.     {
  242.         XtNfont,
  243.         XtCFont,
  244.         XtRString,
  245.         sizeof(String *),
  246.         XtOffsetOf(Gui, dflt_font),
  247.         XtRImmediate,
  248.         XtDefaultFont
  249.     },
  250.     {
  251.         XtNboldFont,
  252.         XtCBoldFont,
  253.         XtRString,
  254.         sizeof(String *),
  255.         XtOffsetOf(Gui, dflt_bold_fn),
  256.         XtRImmediate,
  257.         ""
  258.     },
  259.     {
  260.         XtNitalicFont,
  261.         XtCItalicFont,
  262.         XtRString,
  263.         sizeof(String *),
  264.         XtOffsetOf(Gui, dflt_ital_fn),
  265.         XtRImmediate,
  266.         ""
  267.     },
  268.     {
  269.         XtNboldItalicFont,
  270.         XtCBoldItalicFont,
  271.         XtRString,
  272.         sizeof(String *),
  273.         XtOffsetOf(Gui, dflt_boldital_fn),
  274.         XtRImmediate,
  275.         ""
  276.     },
  277.     {
  278.         XtNgeometry,
  279.         XtCGeometry,
  280.         XtRString,
  281.         sizeof(String *),
  282.         XtOffsetOf(Gui, geom),
  283.         XtRImmediate,
  284.         ""
  285.     },
  286.     {
  287.         XtNreverseVideo,
  288.         XtCReverseVideo,
  289.         XtRBool,
  290.         sizeof(Bool),
  291.         XtOffsetOf(Gui, rev_video),
  292.         XtRImmediate,
  293.         (XtPointer) False
  294.     },
  295.     {
  296.         XtNborderWidth,
  297.         XtCBorderWidth,
  298.         XtRInt,
  299.         sizeof(int),
  300.         XtOffsetOf(Gui, border_width),
  301.         XtRImmediate,
  302.         (XtPointer) 2
  303.     },
  304.     {
  305.         XtNscrollbarWidth,
  306.         XtCScrollbarWidth,
  307.         XtRInt,
  308.         sizeof(int),
  309.         XtOffsetOf(Gui, scrollbar_width),
  310.         XtRImmediate,
  311.         (XtPointer) SB_DEFAULT_WIDTH 
  312.     },
  313.     {
  314.         XtNmenuHeight,
  315.         XtCMenuHeight,
  316.         XtRInt,
  317.         sizeof(int),
  318.         XtOffsetOf(Gui, menu_height),
  319.         XtRImmediate,
  320.         (XtPointer) MENU_DEFAULT_HEIGHT
  321.     },
  322.     {
  323.         XtNmenuForeground,
  324.         XtCMenuForeground,
  325.         XtRPixel,
  326.         sizeof(Pixel),
  327.         XtOffsetOf(Gui, menu_fg_pixel),
  328.         XtRString,
  329.         DFLT_MENU_FG_COLOR
  330.     },
  331.     {
  332.         XtNmenuBackground,
  333.         XtCMenuBackground,
  334.         XtRPixel,
  335.         sizeof(Pixel),
  336.         XtOffsetOf(Gui, menu_bg_pixel),
  337.         XtRString,
  338.         DFLT_MENU_BG_COLOR
  339.     },
  340.     {
  341.         XtNscrollForeground,
  342.         XtCScrollForeground,
  343.         XtRPixel,
  344.         sizeof(Pixel),
  345.         XtOffsetOf(Gui, scroll_fg_pixel),
  346.         XtRString,
  347.         DFLT_SCROLL_FG_COLOR
  348.     },
  349.     {
  350.         XtNscrollBackground,
  351.         XtCScrollBackground,
  352.         XtRPixel,
  353.         sizeof(Pixel),
  354.         XtOffsetOf(Gui, scroll_bg_pixel),
  355.         XtRString,
  356.         DFLT_SCROLL_BG_COLOR
  357.     },
  358. };
  359.  
  360. /*
  361.  * This table holds all the X GUI command line options allowed.  This includes
  362.  * the standard ones so that we can skip them when vim is started without the
  363.  * GUI (but the GUI might start up later).
  364.  * When changing this, also update doc/vim_gui.txt and the usage message!!!
  365.  */
  366. static XrmOptionDescRec cmdline_options[] =
  367. {
  368.     /* We handle these options ourselves */
  369.     {"-bg",                ".background",        XrmoptionSepArg,    NULL},
  370.     {"-background",        ".background",        XrmoptionSepArg,    NULL},
  371.     {"-fg",                ".foreground",        XrmoptionSepArg,    NULL},
  372.     {"-foreground",        ".foreground",        XrmoptionSepArg,    NULL},
  373.     {"-bold",            ".boldColor",        XrmoptionSepArg,    NULL},
  374.     {"-italic",            ".italicColor",        XrmoptionSepArg,    NULL},
  375.     {"-ul",                ".underlineColor",    XrmoptionSepArg,    NULL},
  376.     {"-underline",        ".underlineColor",    XrmoptionSepArg,    NULL},
  377.     {"-cursor",            ".cursorColor",        XrmoptionSepArg,    NULL},
  378.     {"-fn",                ".font",            XrmoptionSepArg,    NULL},
  379.     {"-font",            ".font",            XrmoptionSepArg,    NULL},
  380.     {"-boldfont",        ".boldFont",        XrmoptionSepArg,    NULL},
  381.     {"-italicfont",        ".italicFont",        XrmoptionSepArg,    NULL},
  382.     {"-geom",            ".geometry",        XrmoptionSepArg,    NULL},
  383.     {"-geometry",        ".geometry",        XrmoptionSepArg,    NULL},
  384.     {"-reverse",        "*reverseVideo",    XrmoptionNoArg,        "True"},
  385.     {"-rv",                "*reverseVideo",    XrmoptionNoArg,        "True"},
  386.     {"+reverse",        "*reverseVideo",    XrmoptionNoArg,        "False"},
  387.     {"+rv",                "*reverseVideo",    XrmoptionNoArg,        "False"},
  388.     {"-display",        ".display",            XrmoptionSepArg,    NULL},
  389.     {"-iconic",            "*iconic",            XrmoptionNoArg,        "True"},
  390.     {"-name",            ".name",            XrmoptionSepArg,    NULL},
  391.     {"-bw",                ".borderWidth",        XrmoptionSepArg,    NULL},
  392.     {"-borderwidth",    ".borderWidth",        XrmoptionSepArg,    NULL},
  393.     {"-sw",                ".scrollbarWidth",    XrmoptionSepArg,    NULL},
  394.     {"-scrollbarwidth",    ".scrollbarWidth",    XrmoptionSepArg,    NULL},
  395.     {"-mh",                ".menuHeight",        XrmoptionSepArg,    NULL},
  396.     {"-menuheight",        ".menuHeight",        XrmoptionSepArg,    NULL},
  397.     {"-xrm",            NULL,                XrmoptionResArg,    NULL}
  398. };
  399.  
  400. static int gui_argc = 0;
  401. static char **gui_argv = NULL;
  402.  
  403. /*
  404.  * Call-back routines.
  405.  */
  406.  
  407.     void
  408. gui_x11_timer_cb(timed_out, interval_id)
  409.     XtPointer    timed_out;
  410.     XtIntervalId *interval_id;
  411. {
  412.     *((int *)timed_out) = TRUE;
  413. }
  414.  
  415.     void
  416. gui_x11_visibility_cb(w, dud, event, bool)
  417.     Widget        w;
  418.     XtPointer    dud;
  419.     XEvent        *event;
  420.     Boolean        *bool;
  421. {
  422.     if (event->type != VisibilityNotify)
  423.         return;
  424.  
  425.     gui.visibility = event->xvisibility.state;
  426.  
  427.     /*
  428.      * When we do an XCopyArea(), and the window is partially obscured, we want
  429.      * to receive an event to tell us whether it worked or not.
  430.      */
  431.     XSetGraphicsExposures(gui.dpy, gui.text_gc,
  432.         gui.visibility != VisibilityUnobscured);
  433. }
  434.  
  435.     void
  436. gui_x11_expose_cb(w, dud, event, bool)
  437.     Widget        w;
  438.     XtPointer    dud;
  439.     XEvent        *event;
  440.     Boolean        *bool;
  441. {
  442.     XExposeEvent    *gevent;
  443.  
  444.     if (event->type != Expose)
  445.         return;
  446.  
  447.     gevent = (XExposeEvent *)event;
  448.     gui_redraw(gevent->x, gevent->y, gevent->width, gevent->height);
  449.  
  450.     /* Clear the border areas if needed */
  451.     if (gevent->x < FILL_X(0))
  452.         XClearArea(gui.dpy, gui.wid, 0, 0, FILL_X(0), 0, False);
  453.     if (gevent->y < FILL_Y(0))
  454.         XClearArea(gui.dpy, gui.wid, 0, 0, 0, FILL_Y(0), False);
  455.     if (gevent->x > FILL_X(Columns))
  456.         XClearArea(gui.dpy, gui.wid, FILL_X(Columns), 0, 0, 0, False);
  457.     if (gevent->y > FILL_Y(Rows))
  458.         XClearArea(gui.dpy, gui.wid, 0, FILL_Y(Rows), 0, 0, False);
  459.  
  460.     if (gui.selection.state != SELECT_CLEARED)
  461.         gui_x11_redraw_selection(gevent->x, gevent->y, gevent->width,
  462.                 gevent->height);
  463. }
  464.  
  465.     void
  466. gui_x11_resize_window_cb(w, dud, event, bool)
  467.     Widget        w;
  468.     XtPointer    dud;
  469.     XEvent        *event;
  470.     Boolean        *bool;
  471. {
  472.     if (event->type != ConfigureNotify)
  473.         return;
  474.  
  475.     gui_resize_window(event->xconfigure.width, event->xconfigure.height);
  476.  
  477.     /* Make sure the border strips on the right and bottom get cleared. */
  478.     XClearArea(gui.dpy, gui.wid,    FILL_X(Columns), 0, 0, 0, False);
  479.     XClearArea(gui.dpy, gui.wid, 0, FILL_Y(Rows),       0, 0, False);
  480. }
  481.  
  482.     void
  483. gui_x11_focus_change_cb(w, data, event, bool)
  484.     Widget        w;
  485.     XtPointer    data;
  486.     XEvent        *event;
  487.     Boolean        *bool;
  488. {
  489.     if (event->type == FocusIn)
  490.         gui.in_focus = TRUE;
  491.     else
  492.         gui.in_focus = FALSE;
  493.     if (gui.row == gui.cursor_row && gui.col == gui.cursor_col)
  494.         INVALIDATE_CURSOR();
  495.     gui_update_cursor();
  496. }
  497.  
  498.     void
  499. gui_x11_key_hit_cb(w, dud, event, bool)
  500.     Widget        w;
  501.     XtPointer    dud;
  502.     XEvent        *event;
  503.     Boolean        *bool;
  504. {
  505.     XKeyPressedEvent    *ev_press;
  506.     char_u    string[3], string2[3];
  507.     KeySym    key_sym;
  508.     int        num, i;
  509.  
  510.     ev_press = (XKeyPressedEvent *)event;
  511.  
  512.     num = XLookupString(ev_press, (char *)string, sizeof(string),
  513.             &key_sym, NULL);
  514.     
  515.     if (key_sym == XK_space)
  516.         string[0] = ' ';        /* Otherwise Ctrl-Space doesn't work */
  517.  
  518.     /* Check for Alt/Meta key (Mod1Mask) */
  519.     if (num == 1 && (ev_press->state & Mod1Mask))
  520.     {
  521.         /* 
  522.          * Before we set the 8th bit, check to make sure the user doesn't
  523.          * already have a mapping defined for this sequence. We determine this
  524.          * by checking to see if the input would be the same without the
  525.          * Alt/Meta key.
  526.          */
  527.         ev_press->state &= ~Mod1Mask;
  528.         if (XLookupString(ev_press, (char *)string2, sizeof(string2),
  529.                 &key_sym, NULL) == 1 && string[0] == string2[0])
  530.             string[0] |= 0x80;
  531.         ev_press->state |= Mod1Mask;
  532.     }
  533.  
  534. #if 0
  535.     if (num == 1 && string[0] == CSI) /* this doesn't work yet */
  536.     {
  537.         string[1] = CSI;
  538.         string[2] = CSI;
  539.         num = 3;
  540.     }
  541. #endif
  542.  
  543.     /* Check for special keys, making sure BS and DEL are recognised. */
  544.     if (num == 0 || key_sym == XK_BackSpace || key_sym == XK_Delete)
  545.     {
  546.         for (i = 0; special_keys[i].key_sym != (KeySym)0; i++)
  547.         {
  548.             if (special_keys[i].key_sym == key_sym)
  549.             {
  550.                 string[0] = CSI;
  551.                 string[1] = special_keys[i].vim_code0;
  552.                 string[2] = special_keys[i].vim_code1;
  553.                 num = 3;
  554.             }
  555.         }
  556.     }
  557.  
  558.     /* Unrecognised key */
  559.     if (num == 0)
  560.         return;
  561.  
  562.     /* Special keys (and a few others) may have modifiers */
  563.     if (num == 3 || key_sym == XK_space || key_sym == XK_Tab
  564.         || key_sym == XK_Return || key_sym == XK_Linefeed
  565.         || key_sym == XK_Escape)
  566.     {
  567.         string2[0] = CSI;
  568.         string2[1] = KS_MODIFIER;
  569.         string2[2] = 0;
  570.         if (ev_press->state & ShiftMask)
  571.             string2[2] |= MOD_MASK_SHIFT;
  572.         if (ev_press->state & ControlMask)
  573.             string2[2] |= MOD_MASK_CTRL;
  574.         if (ev_press->state & Mod1Mask)
  575.             string2[2] |= MOD_MASK_ALT;
  576.         if (string2[2] != 0)
  577.             add_to_input_buf(string2, 3);
  578.     }
  579.     if (num == 1 && string[0] == Ctrl('C'))
  580.     {
  581.         trash_input_buf();
  582.         got_int = TRUE;
  583.     }
  584.     add_to_input_buf(string, num);
  585. }
  586.  
  587.     void
  588. gui_x11_mouse_cb(w, dud, event, bool)
  589.     Widget        w;
  590.     XtPointer    dud;
  591.     XEvent        *event;
  592.     Boolean        *bool;
  593. {
  594.     static XtIntervalId timer = (XtIntervalId)0;
  595.     static int    timed_out = TRUE;
  596.  
  597.     int            button;
  598.     int            repeated_click = FALSE;
  599.     int            x, y;
  600.     int_u        x_modifiers;
  601.     int_u        vim_modifiers;
  602.     int            checkfor;
  603.  
  604.     if (event->type == MotionNotify)
  605.     {
  606.         x = event->xmotion.x;
  607.         y = event->xmotion.y;
  608.         button = MOUSE_DRAG;
  609.         x_modifiers = event->xmotion.state;
  610.     }
  611.     else
  612.     {
  613.         x = event->xbutton.x;
  614.         y = event->xbutton.y;
  615.         if (event->type == ButtonPress)
  616.         {
  617.             /* Handle multiple clicks */
  618.             if (!timed_out)
  619.             {
  620.                 XtRemoveTimeOut(timer);
  621.                 repeated_click = TRUE;
  622.             }
  623.             timed_out = FALSE;
  624.             timer = XtAppAddTimeOut(app_context, (long_u)p_mouset,
  625.                         gui_x11_timer_cb, &timed_out);
  626.             switch (event->xbutton.button)
  627.             {
  628.                 case Button1:    button = MOUSE_LEFT;    break;
  629.                 case Button2:    button = MOUSE_MIDDLE;    break;
  630.                 case Button3:    button = MOUSE_RIGHT;    break;
  631.                 default:
  632.                     return;        /* Unknown button */
  633.             }
  634.         }
  635.         else if (event->type == ButtonRelease)
  636.             button = MOUSE_RELEASE;
  637.         else
  638.             return;        /* Unknown mouse event type */
  639.  
  640.         x_modifiers = event->xbutton.state;
  641.     }
  642.  
  643.     vim_modifiers = 0x0;
  644.     if (x_modifiers & ShiftMask)
  645.         vim_modifiers |= MOUSE_SHIFT;
  646.     if (x_modifiers & ControlMask)
  647.         vim_modifiers |= MOUSE_CTRL;
  648.     if (x_modifiers & Mod1Mask)        /* Alt or Meta key */
  649.         vim_modifiers |= MOUSE_ALT;
  650.  
  651.     /* If an x11 selection is in progress, finish it */
  652.     if (gui.selection.state == SELECT_IN_PROGRESS)
  653.     {
  654.         gui_x11_process_selection(button, x, y, repeated_click, vim_modifiers);
  655.         return;
  656.     }
  657.  
  658.     /* Determine which mouse settings to look for based on the current mode */
  659.     switch (State)
  660.     {
  661.         case NORMAL_BUSY:
  662.         case NORMAL:        checkfor = MOUSE_NORMAL;    break;
  663.         case VISUAL:        checkfor = MOUSE_VISUAL;    break;
  664.         case REPLACE:
  665.         case INSERT:        checkfor = MOUSE_INSERT;    break;
  666.         case HITRETURN:        checkfor = MOUSE_RETURN;    break;
  667.  
  668.             /*
  669.              * On the command line, use the X11 selection on all lines but the
  670.              * command line.
  671.              */
  672.         case CMDLINE:        
  673.             if (Y_2_ROW(y) < cmdline_row)
  674.                 checkfor = ' ';
  675.             else
  676.                 checkfor = MOUSE_COMMAND;
  677.             break;
  678.  
  679.         default:
  680.             checkfor = ' ';
  681.             break;
  682.     };
  683.     /*
  684.      * Allow selection of text in the command line in "normal" modes.
  685.      */
  686.     if ((State == NORMAL || State == NORMAL_BUSY ||
  687.                                        State == INSERT || State == REPLACE) &&
  688.                                             Y_2_ROW(y) >= gui.num_rows - p_ch)
  689.         checkfor = ' ';
  690.  
  691.     /*
  692.      * If the mouse settings say to not use the mouse, use the X11 selection.
  693.      * But if Visual is active, assume that only the Visual area will be
  694.      * selected.
  695.      */
  696.     if (!mouse_has(checkfor) && !VIsual_active)
  697.     {
  698.         /* If the selection is done, allow the right button to extend it */
  699.         if (gui.selection.state == SELECT_DONE && button == MOUSE_RIGHT)
  700.         {
  701.             gui_x11_process_selection(button, x, y, repeated_click,
  702.                     vim_modifiers);
  703.             return;
  704.         }
  705.  
  706.         /* Allow the left button to start the selection */
  707.         else if (button == MOUSE_LEFT)
  708.         {
  709.             gui_x11_start_selection(button, x, y, repeated_click,
  710.                     vim_modifiers);
  711.             return;
  712.         }
  713.     }
  714.  
  715.     if (gui.selection.state != SELECT_CLEARED)
  716.         gui_mch_clear_selection();
  717.     gui_send_mouse_event(button, x, y, repeated_click, vim_modifiers);
  718. }
  719.  
  720. /*
  721.  * End of call-back routines
  722.  */
  723.  
  724. /*
  725.  * Parse the GUI related command-line arguments.  Any arguments used are
  726.  * deleted from argv, and *argc is decremented accordingly.  This is called
  727.  * when vim is started, whether or not the GUI has been started.
  728.  */
  729.     void
  730. gui_mch_prepare(argc, argv)
  731.     int        *argc;
  732.     char    **argv;
  733. {
  734.     int        arg;
  735.     int        i;
  736.  
  737.     /*
  738.      * Move all the entries in argv which are relevant to X into gui_argv.
  739.      */
  740.     gui_argc = 0;
  741.     gui_argv = (char **)lalloc(*argc * sizeof(char *), FALSE);
  742.     if (gui_argv == NULL)
  743.         return;
  744.     gui_argv[gui_argc++] = argv[0];
  745.     arg = 1;
  746.     while (arg < *argc)
  747.     {
  748.         /* Look for argv[arg] in cmdline_options[] table */
  749.         for (i = 0; i < XtNumber(cmdline_options); i++)
  750.             if (strcmp(argv[arg], cmdline_options[i].option) == 0)
  751.                 break;
  752.  
  753.         if (i < XtNumber(cmdline_options))
  754.         {
  755.             /* Found match in table, so move it into gui_argv */
  756.             gui_argv[gui_argc++] = argv[arg];
  757.             if (--*argc > arg)
  758.             {
  759.                 vim_memmove(&argv[arg], &argv[arg + 1], (*argc - arg)
  760.                                                     * sizeof(char *));
  761.                 if (cmdline_options[i].argKind != XrmoptionNoArg)
  762.                 {
  763.                     /* Move the options argument as well */
  764.                     gui_argv[gui_argc++] = argv[arg];
  765.                     if (--*argc > arg)
  766.                         vim_memmove(&argv[arg], &argv[arg + 1], (*argc - arg)
  767.                                                             * sizeof(char *));
  768.                 }
  769.             }
  770.         }
  771.         else
  772.             arg++;
  773.     }
  774. }
  775.  
  776. /*
  777.  * Initialise the X GUI.  Create all the windows, set up all the call-backs
  778.  * etc.
  779.  */
  780.     int
  781. gui_mch_init()
  782. {
  783.     Widget        AppShell;
  784.     long_u        gc_mask;
  785.     XGCValues    gc_vals;
  786.     Pixel        tmp_pixel;
  787.     int            x, y, mask;
  788.     unsigned    w, h;
  789.  
  790.     XtToolkitInitialize();
  791.     app_context = XtCreateApplicationContext();
  792.     gui.dpy = XtOpenDisplay(app_context, 0, VIM_NAME, VIM_CLASS,
  793.         cmdline_options, XtNumber(cmdline_options),
  794. #ifndef XtSpecificationRelease
  795.         (Cardinal*)&gui_argc, gui_argv);
  796. #else
  797. #if XtSpecificationRelease == 4
  798.         (Cardinal*)&gui_argc, gui_argv);
  799. #else
  800.         &gui_argc, gui_argv);
  801. #endif
  802. #endif
  803.     
  804.     vim_free(gui_argv);
  805.  
  806.     if (gui.dpy == NULL)
  807.     {
  808.         EMSG("cannot open display");
  809.         return FAIL;
  810.     }
  811.  
  812.     /* Uncomment this to enable synchronous mode for debugging */
  813.     /* XSynchronize(gui.dpy, True); */
  814.  
  815.     /*
  816.      * So converters work.
  817.      */
  818.     XtInitializeWidgetClass(applicationShellWidgetClass);
  819.     XtInitializeWidgetClass(topLevelShellWidgetClass);
  820.  
  821.     /*
  822.      * The applicationShell is created as an unrealized
  823.      * parent for multiple topLevelShells.    The topLevelShells
  824.      * are created as popup children of the applicationShell.
  825.      * This is a recommendation of Paul Asente & Ralph Swick in
  826.      * _X_Window_System_Toolkit_ p. 677.
  827.      */
  828.     AppShell = XtVaAppCreateShell(VIM_NAME, VIM_CLASS,
  829.             applicationShellWidgetClass, gui.dpy,
  830.             NULL);
  831.  
  832.     /*
  833.      * Get the application resources
  834.      */
  835.     XtVaGetApplicationResources(AppShell, &gui,
  836.         vim_resources, XtNumber(vim_resources), NULL);
  837.  
  838.     /*
  839.      * Check validity of resources
  840.      */
  841.     if (gui.border_width < 0)
  842.         gui.border_width = 0;
  843.  
  844.     /* For reverse video, swap foreground and background colours */
  845.     if (gui.rev_video)
  846.     {
  847.         tmp_pixel = gui.norm_pixel;
  848.         gui.norm_pixel = gui.back_pixel;
  849.         gui.back_pixel = tmp_pixel;
  850.     }
  851.  
  852.     /* Create shell widget to put vim in */
  853.     vimShell = XtVaCreatePopupShell("VIM", 
  854.         topLevelShellWidgetClass, AppShell,
  855.         XtNborderWidth, 0,
  856.         NULL);
  857.  
  858.     /*
  859.      * Check that none of the colours are the same as the background color
  860.      */
  861.     if (gui.norm_pixel == gui.back_pixel)
  862.     {
  863.         gui.norm_pixel = gui_x11_get_color((char_u *)"White");
  864.         if (gui.norm_pixel == gui.back_pixel)
  865.             gui.norm_pixel = gui_x11_get_color((char_u *)"Black");
  866.     }
  867.     if (gui.bold_pixel == gui.back_pixel)
  868.         gui.bold_pixel = gui.norm_pixel;
  869.     if (gui.ital_pixel == gui.back_pixel)
  870.         gui.ital_pixel = gui.norm_pixel;
  871.     if (gui.underline_pixel == gui.back_pixel)
  872.         gui.underline_pixel = gui.norm_pixel;
  873.     if (gui.cursor_pixel == gui.back_pixel)
  874.         gui.cursor_pixel = gui.norm_pixel;
  875.  
  876.     /*
  877.      * Set up the GCs.    The font attributes will be set in gui_init_font().
  878.      */
  879.  
  880.     gc_mask = GCForeground | GCBackground;
  881.     gc_vals.foreground = gui.norm_pixel;
  882.     gc_vals.background = gui.back_pixel;
  883.     gui.text_gc = XCreateGC(gui.dpy, DefaultRootWindow(gui.dpy), gc_mask,
  884.             &gc_vals);
  885.  
  886.     gc_vals.foreground = gui.back_pixel;
  887.     gc_vals.background = gui.norm_pixel;
  888.     gui.back_gc = XCreateGC(gui.dpy, DefaultRootWindow(gui.dpy), gc_mask,
  889.             &gc_vals);
  890.  
  891.     gc_mask |= GCFunction;
  892.     gc_vals.foreground = gui.norm_pixel ^ gui.back_pixel;
  893.     gc_vals.background = gui.norm_pixel ^ gui.back_pixel;
  894.     gc_vals.function   = GXxor;
  895.     gui.invert_gc = XCreateGC(gui.dpy, DefaultRootWindow(gui.dpy), gc_mask,
  896.             &gc_vals);
  897.  
  898.     gui.visibility = VisibilityUnobscured;
  899.     gui.selection.atom = XInternAtom(gui.dpy, "VIM_SELECTION", False);
  900.  
  901.     /*
  902.      * Set up the fonts.  This call will also set the window to the correct
  903.      * size for the used font.
  904.      */
  905.     gui.norm_font = NULL;
  906.     gui.bold_font = NULL;
  907.     gui.ital_font = NULL;
  908.     gui.boldital_font = NULL;
  909.     if (gui_init_font() == FAIL)
  910.         return FAIL;
  911.  
  912.     /* Now adapt the supplied(?) geometry-settings */
  913.     /* Added by Kjetil Jacobsen <kjetilja@stud.cs.uit.no> */
  914.     if (gui.geom != NULL && *gui.geom != NUL)
  915.     {
  916.         mask = XParseGeometry((char *)gui.geom, &x, &y, &w, &h);
  917.         if (mask & WidthValue)
  918.             Columns = w;
  919.         if (mask & HeightValue)
  920.             Rows = h;
  921.         /*
  922.          * Set the (x,y) position of the main window only if specified in the
  923.          * users geometry, so we get good defaults when they don't. This needs
  924.          * to be done before the shell is popped up.
  925.          */
  926.         if (mask & (XValue|YValue))
  927.             XtVaSetValues(vimShell, XtNgeometry, gui.geom, NULL);
  928.     }
  929.     gui.num_cols = Columns;
  930.     gui.num_rows = Rows;
  931.     gui_reset_scroll_region();
  932.  
  933.     gui_mch_create_widgets();
  934.  
  935.     /* Configure the desired scrollbars */
  936.     gui_init_which_components(NULL);
  937.  
  938.     /* Actually open the window */
  939.     XtPopup(vimShell, XtGrabNone);
  940.  
  941.     gui_mch_set_winsize();
  942.  
  943.     gui.wid = gui_mch_get_wid();
  944.  
  945.     /* Add a callback for the Close item on the window managers menu */
  946.     Atom_WM_DELETE_WINDOW = XInternAtom(gui.dpy, "WM_DELETE_WINDOW", False);
  947.     XSetWMProtocols(gui.dpy, XtWindow(vimShell), &Atom_WM_DELETE_WINDOW, 1);
  948.     XtAddEventHandler(vimShell, NoEventMask, True, gui_x11_wm_protocol_handler,
  949.                                                              NULL);
  950.  
  951. #ifdef ENABLE_EDITRES
  952.     /*
  953.      * Enable editres protocol (see editres(1))
  954.      * Usually will need to add -lXmu to the linker line as well.
  955.      */
  956.     {
  957.         extern void _XEditResCheckMessages();
  958.         XtAddEventHandler(vimShell, 0, True, _XEditResCheckMessages,
  959.                 (XtPointer)NULL);
  960.     }
  961. #endif
  962.  
  963.     return OK;
  964. }
  965.  
  966.     void
  967. gui_mch_exit()
  968. {
  969.     XtCloseDisplay(gui.dpy);
  970. }
  971.  
  972. /*
  973.  * While unmanaging and re-managing scrollbars etc, we don't want the resize
  974.  * callback to be called, so this function is used to disable this callback,
  975.  * and then re-enable it afterwards.  XSync() makes sure we don't register the
  976.  * callback before the server has finished processing any resize events we have
  977.  * created, otherwise we can get in a loop where the window flashes between two
  978.  * sizes, since resize_window_cb() calls set_winsize().
  979.  */
  980.     void
  981. gui_x11_use_resize_callback(widget, enabled)
  982.     Widget    widget;
  983.     int        enabled;
  984. {
  985.     if (enabled)
  986.     {
  987.         XSync(gui.dpy, False);
  988.         XtAddEventHandler(widget, StructureNotifyMask, FALSE,
  989.             gui_x11_resize_window_cb, (XtPointer)0);
  990.         XtAddEventHandler(widget, ExposureMask, FALSE, gui_x11_expose_cb,
  991.             (XtPointer)0);
  992.     }
  993.     else
  994.     {
  995.         XtRemoveEventHandler(widget, StructureNotifyMask, FALSE,
  996.             gui_x11_resize_window_cb, (XtPointer)0);
  997.         XtRemoveEventHandler(widget, ExposureMask, FALSE, gui_x11_expose_cb,
  998.             (XtPointer)0);
  999.         XSync(gui.dpy, False);
  1000.     }
  1001. }
  1002.  
  1003. /*
  1004.  * Initialise vim to use the font with the given name.    Return FAIL if the font
  1005.  * could not be loaded, OK otherwise.
  1006.  */
  1007.     int
  1008. gui_mch_init_font(font_name)
  1009.     char_u        *font_name;
  1010. {
  1011.     XFontStruct    *font = NULL;
  1012.  
  1013.     if (font_name == NULL)
  1014.     {
  1015.         /*
  1016.          * If none of the fonts in 'font' could be loaded, try the one set in
  1017.          * the X resource, and finally just try using DFLT_FONT, which will
  1018.          * hopefully always be there.
  1019.          */
  1020.         font = XLoadQueryFont(gui.dpy, (char *)gui.dflt_font);
  1021.         if (font == NULL)
  1022.             font_name = (char_u *)DFLT_FONT;
  1023.         font_name = (char_u *)DFLT_FONT;
  1024.     }
  1025.     if (font == NULL)
  1026.         font = XLoadQueryFont(gui.dpy, (char *)font_name);
  1027.     if (font == NULL)
  1028.         return FAIL;
  1029.     if (font->max_bounds.width != font->min_bounds.width)
  1030.     {
  1031.         sprintf((char *)IObuff, "Font \"%s\" is not fixed-width",
  1032.                                                            (char *)font_name);
  1033.         emsg(IObuff);
  1034.         XFreeFont(gui.dpy, font);
  1035.         return FAIL;
  1036.     }
  1037.     if (gui.norm_font != NULL)
  1038.         XFreeFont(gui.dpy, gui.norm_font);
  1039.     gui.norm_font = font;
  1040.     gui.char_width = font->max_bounds.width;
  1041.     gui.char_height = font->ascent + font->descent;
  1042.     gui.char_ascent = font->ascent;
  1043.  
  1044. #ifdef DEBUG
  1045.     printf("Font Information for '%s':\n", font_name);
  1046.     printf("  w = %d, h = %d, ascent = %d, descent = %d\n", gui.char_width,
  1047.            gui.char_height, gui.char_ascent, font->descent);
  1048.     printf("  max ascent = %d, max descent = %d, max h = %d\n",
  1049.            font->max_bounds.ascent, font->max_bounds.descent,
  1050.            font->max_bounds.ascent + font->max_bounds.descent);
  1051.     printf("  min lbearing = %d, min rbearing = %d\n",
  1052.            font->min_bounds.lbearing, font->min_bounds.rbearing);
  1053.     printf("  max lbearing = %d, max rbearing = %d\n",
  1054.            font->max_bounds.lbearing, font->max_bounds.rbearing);
  1055.     printf("  leftink = %d, rightink = %d\n",
  1056.            (font->min_bounds.lbearing < 0),
  1057.            (font->max_bounds.rbearing > gui.char_width));
  1058.     printf("\n");
  1059. #endif
  1060.  
  1061.     /*
  1062.      * Try to load other fonts for bold, italic, and bold-italic.
  1063.      * We should also try to work out what font to use for these when they are
  1064.      * not specified by X resources, but we don't yet.
  1065.      */
  1066.     if (gui.dflt_bold_fn != NULL && *gui.dflt_bold_fn != NUL)
  1067.         gui.bold_font = XLoadQueryFont(gui.dpy, (char *)gui.dflt_bold_fn);
  1068.     if (gui.dflt_ital_fn != NULL && *gui.dflt_ital_fn != NUL)
  1069.         gui.ital_font = XLoadQueryFont(gui.dpy, (char *)gui.dflt_ital_fn);
  1070.     if (gui.dflt_boldital_fn != NULL && *gui.dflt_boldital_fn != NUL)
  1071.         gui.boldital_font = XLoadQueryFont(gui.dpy, (char *)gui.dflt_boldital_fn);
  1072.  
  1073.     /* Must set the appropriate fonts for all the GCs */
  1074.     gui_x11_set_font(gui.text_gc, gui.norm_font->fid);
  1075.     gui_x11_set_font(gui.back_gc, gui.norm_font->fid);
  1076.  
  1077.     /*
  1078.      * Set the window sizes if the window is already visible.
  1079.      */
  1080.     if (vimShell != (Widget)NULL && XtIsRealized(vimShell))
  1081.     {
  1082.         WIN        *wp;
  1083.  
  1084.         gui_mch_set_winsize();
  1085.  
  1086.         /* Force the scrollbar heights to get updated when a font is changed */
  1087.         if (gui.which_scrollbars[SB_LEFT])
  1088.         {
  1089.             for (wp = firstwin; wp; wp = wp->w_next)
  1090.                 wp->w_scrollbar.update[SB_LEFT] = SB_UPDATE_HEIGHT;
  1091.             gui_mch_update_scrollbars(SB_UPDATE_HEIGHT, SB_LEFT);
  1092.         }
  1093.         if (gui.which_scrollbars[SB_RIGHT])
  1094.         {
  1095.             for (wp = firstwin; wp; wp = wp->w_next)
  1096.                 wp->w_scrollbar.update[SB_RIGHT] = SB_UPDATE_HEIGHT;
  1097.             gui_mch_update_scrollbars(SB_UPDATE_HEIGHT, SB_RIGHT);
  1098.         }
  1099.     }
  1100.  
  1101.     return OK;
  1102. }
  1103.  
  1104. /*
  1105.  * Return OK if the key with the termcap name "name" is supported.
  1106.  */
  1107.     int
  1108. gui_mch_haskey(name)
  1109.     char_u    *name;
  1110. {
  1111.     int i;
  1112.  
  1113.     for (i = 0; special_keys[i].key_sym != (KeySym)0; i++)
  1114.         if (name[0] == special_keys[i].vim_code0 &&
  1115.                                          name[1] == special_keys[i].vim_code1)
  1116.             return OK;
  1117.     return FAIL;
  1118. }
  1119.  
  1120. /*
  1121.  * Return the text window-id and display.  Only required for X-based GUI's
  1122.  */
  1123.     int
  1124. gui_get_x11_windis(win, dis)
  1125.     Window    *win;
  1126.     Display    **dis;
  1127. {
  1128.     *win = XtWindow(vimShell);
  1129.     *dis = gui.dpy;
  1130.     return OK;
  1131. }
  1132.  
  1133.     void
  1134. gui_mch_beep()
  1135. {
  1136.     XBell(gui.dpy, 0);
  1137. }
  1138.  
  1139.     void
  1140. gui_mch_flash()
  1141. {
  1142.     /* Do a visual beep by reversing the foreground and background colors */
  1143.     XFillRectangle(gui.dpy, gui.wid, gui.invert_gc, 0, 0,
  1144.             FILL_X(Columns) + gui.border_offset,
  1145.             FILL_Y(Rows) + gui.border_offset);
  1146.     XSync(gui.dpy, False);
  1147.     mch_delay(20L, TRUE);        /* wait 1/50 of a second */
  1148.     XFillRectangle(gui.dpy, gui.wid, gui.invert_gc, 0, 0,
  1149.             FILL_X(Columns) + gui.border_offset,
  1150.             FILL_Y(Rows) + gui.border_offset);
  1151. }
  1152.  
  1153. /*
  1154.  * Iconify the GUI window.
  1155.  */
  1156.     void
  1157. gui_mch_iconify()
  1158. {
  1159.     XIconifyWindow(gui.dpy, XtWindow(vimShell), DefaultScreen(gui.dpy));
  1160. }
  1161.  
  1162. /*
  1163.  * Return the Pixel value (color) for the given color name.  This routine was
  1164.  * pretty much taken from example code in the Silicon Graphics OSF/Motif
  1165.  * Programmer's Guide.
  1166.  */
  1167.     static Pixel
  1168. gui_x11_get_color(name)
  1169.     char_u *name;
  1170. {
  1171.     XrmValue    from, to;
  1172.  
  1173.     from.size = STRLEN(name) + 1;
  1174.     if (from.size < sizeof(String))
  1175.         from.size = sizeof(String);
  1176.     from.addr = (char *)name;
  1177.     to.addr = NULL;
  1178.     XtConvert(vimShell, XtRString, &from, XtRPixel, &to);
  1179.     if (to.addr != NULL)
  1180.         return (Pixel) *((Pixel *)to.addr);
  1181.     else
  1182.         return (Pixel)NULL;
  1183. }
  1184.  
  1185. /*
  1186.  * Set the current text font (gc should be either gui.text_gc or gui.back_gc)
  1187.  */
  1188.     static void
  1189. gui_x11_set_font(gc, fid)
  1190.     GC        gc;
  1191.     Font    fid;
  1192. {
  1193.     static Font prev_text_fid = (Font) -1;
  1194.     static Font prev_back_fid = (Font) -1;
  1195.  
  1196.     if (gc == gui.text_gc && fid != prev_text_fid)
  1197.     {
  1198.         XSetFont(gui.dpy, gc, fid);
  1199.         prev_text_fid = fid;
  1200.     }
  1201.     else if (gc == gui.back_gc && fid != prev_back_fid)
  1202.     {
  1203.         XSetFont(gui.dpy, gc, fid);
  1204.         prev_back_fid = fid;
  1205.     }
  1206. }
  1207.  
  1208. /*
  1209.  * Set the current text color (gc should be either gui.text_gc or gui.back_gc)
  1210.  */
  1211.     static void
  1212. gui_x11_set_color(gc, pixel)
  1213.     GC        gc;
  1214.     Pixel    pixel;
  1215. {
  1216.     static Pixel prev_text_pixel = (Pixel) -1;
  1217.     static Pixel prev_back_pixel = (Pixel) -1;
  1218.  
  1219.     if (gc == gui.text_gc && pixel != prev_text_pixel)
  1220.     {
  1221.         XSetForeground(gui.dpy, gc, pixel);
  1222.         prev_text_pixel = pixel;
  1223.     }
  1224.     else if (gc == gui.back_gc && pixel != prev_back_pixel)
  1225.     {
  1226.         XSetBackground(gui.dpy, gc, pixel);
  1227.         prev_back_pixel = pixel;
  1228.     }
  1229. }
  1230.  
  1231. /*
  1232.  * Draw the cursor.
  1233.  */
  1234.     void
  1235. gui_mch_draw_cursor()
  1236. {
  1237.     /* Only write to the screen after LinePointers[] has been initialized */
  1238.     if (screen_cleared && NextScreen != NULL)
  1239.     {
  1240.         /* Clear the selection if we are about to write over it */
  1241.         if (gui.selection.state == SELECT_DONE
  1242.                 && gui.row >= gui.selection.start.lnum
  1243.                 && gui.row <= gui.selection.end.lnum)
  1244.             gui_mch_clear_selection();
  1245.  
  1246.         if (gui.row < screen_Rows && gui.col < screen_Columns)
  1247.             gui_mch_outstr_nowrap(LinePointers[gui.row] + gui.col,
  1248.                                                               1, FALSE, TRUE);
  1249.         if (!gui.in_focus)
  1250.         {
  1251.             gui_x11_set_color(gui.text_gc, gui.cursor_pixel);
  1252.             XDrawRectangle(gui.dpy, gui.wid, gui.text_gc, FILL_X(gui.col),
  1253.                     FILL_Y(gui.row), gui.char_width - 1, gui.char_height - 1);
  1254.         }
  1255.     }
  1256. }
  1257.  
  1258. /*
  1259.  * Catch up with any queued X events.  This may put keyboard input into the
  1260.  * input buffer, call resize call-backs, trigger timers etc.  If there is
  1261.  * nothing in the X event queue (& no timers pending), then we return
  1262.  * immediately.
  1263.  */
  1264.     void
  1265. gui_mch_update()
  1266. {
  1267.     while(XtAppPending(app_context) && !is_input_buf_full())
  1268.         XtAppProcessEvent(app_context, XtIMAll);
  1269. }
  1270.  
  1271. /*
  1272.  * The main GUI input routine.    Waits for a character from the keyboard.
  1273.  * wtime == -1        Wait forever.
  1274.  * wtime == 0        Don't wait.
  1275.  * wtime > 0        Wait wtime milliseconds for a character.
  1276.  * Returns OK if a character was found to be available within the given time,
  1277.  * or FAIL otherwise.
  1278.  */
  1279.     int
  1280. gui_mch_wait_for_chars(wtime)
  1281.     int        wtime;
  1282. {
  1283.     XtIntervalId    timer = (XtIntervalId)0;
  1284.     XtIntervalId    updatescript_timer = (XtIntervalId)0;
  1285.     /*
  1286.      * Make these static, in case gui_x11_timer_cb is called after leaving
  1287.      * this function (otherwise a random value on the stack may be changed).
  1288.      */
  1289.     static int        timed_out;
  1290.     static int        do_updatescript;
  1291.  
  1292.     timed_out = FALSE;
  1293.     do_updatescript = FALSE;
  1294.  
  1295.     /*
  1296.      * If we're going to wait a bit, update the menus for the current State.
  1297.      */
  1298.     if (wtime != 0)
  1299.         gui_x11_update_menus(0);
  1300.     gui_mch_update();
  1301.     if (!is_input_buf_empty())    /* Got char, return immediately */
  1302.         return OK;
  1303.     else if (wtime == 0)        /* Don't wait for char */
  1304.         return FAIL;
  1305.     else if (wtime > 0)
  1306.     {
  1307.         timer = XtAppAddTimeOut(app_context, (long_u)wtime, gui_x11_timer_cb,
  1308.             &timed_out);
  1309.     }
  1310.     else
  1311.     {
  1312.         /* We are waiting for ever, so update swap files after p_ut msec's */
  1313.         updatescript_timer = XtAppAddTimeOut(app_context, (long_u)p_ut,
  1314.                                           gui_x11_timer_cb, &do_updatescript);
  1315.     }
  1316.  
  1317.     while (!timed_out)
  1318.     {
  1319.         /*
  1320.          * Don't use gui_mch_update() because then we will spin-lock until a
  1321.          * char arrives, instead we use XtAppProcessEvent() to hang until an
  1322.          * event arrives.  No need to check for input_buf_full because we are
  1323.          * returning as soon as it contains a single char.    Note that
  1324.          * XtAppNextEvent() may not be used because it will not return after a
  1325.          * timer event has arrived -- webb
  1326.          */
  1327.         XtAppProcessEvent(app_context, XtIMAll);
  1328.  
  1329.         /*
  1330.          * If no characters arrive within 'updatetime' milli-seconds, flush all
  1331.          * the swap files to disk.
  1332.          */
  1333.         if (do_updatescript)
  1334.         {
  1335.             updatescript(0);
  1336.             do_updatescript = FALSE;
  1337.             updatescript_timer = (XtIntervalId)0;
  1338.         }
  1339.         if (!is_input_buf_empty())
  1340.         {
  1341.             if (timer != (XtIntervalId)0 && !timed_out)
  1342.                 XtRemoveTimeOut(timer);
  1343.             if (updatescript_timer != (XtIntervalId)0 && !do_updatescript)
  1344.                 XtRemoveTimeOut(updatescript_timer);
  1345.             return OK;
  1346.         }
  1347.     }
  1348.     return FAIL;
  1349. }
  1350.  
  1351. /*
  1352.  * Output routines.
  1353.  */
  1354.  
  1355. /* Flush any output to the screen */
  1356.     void
  1357. gui_mch_flush()
  1358. {
  1359.     XFlush(gui.dpy);
  1360. }
  1361.  
  1362. /*
  1363.  * Clear a rectangular region of the screen from text pos (row1, col1) to
  1364.  * (row2, col2) inclusive.
  1365.  */
  1366.     void
  1367. gui_mch_clear_block(row1, col1, row2, col2)
  1368.     int        row1;
  1369.     int        col1;
  1370.     int        row2;
  1371.     int        col2;
  1372. {
  1373.     /* Clear the selection if we are about to write over it */
  1374.     if (gui.selection.state == SELECT_DONE
  1375.             && row2 >= gui.selection.start.lnum
  1376.             && row1 <= gui.selection.end.lnum)
  1377.         gui_mch_clear_selection();
  1378.  
  1379.     XFillRectangle(gui.dpy, gui.wid, gui.back_gc, FILL_X(col1),
  1380.         FILL_Y(row1), (col2 - col1 + 1) * gui.char_width,
  1381.         (row2 - row1 + 1) * gui.char_height);
  1382.  
  1383.     /* Invalidate cursor if it was in this block */
  1384.     if (gui.cursor_row >= row1 && gui.cursor_row <= row2
  1385.      && gui.cursor_col >= col1 && gui.cursor_col <= col2)
  1386.         INVALIDATE_CURSOR();
  1387. }
  1388.  
  1389. /*
  1390.  * Output the given string at the current cursor position.    If the string is
  1391.  * too long to fit on the line, then it is truncated.  wrap_cursor may be
  1392.  * TRUE if the cursor position should be wrapped when the end of the line is
  1393.  * reached, however the string will still be truncated and not continue on the
  1394.  * next line.  is_cursor should only be TRUE when this function is being called
  1395.  * to actually draw the cursor.
  1396.  */
  1397.     void
  1398. gui_mch_outstr_nowrap(s, len, wrap_cursor, is_cursor)
  1399.     char_u    *s;
  1400.     int        len;
  1401.     int        wrap_cursor;
  1402.     int        is_cursor;
  1403. {
  1404.     GC        text_gc;
  1405.     long_u    highlight_mask;
  1406.  
  1407.     if (len == 0)
  1408.         return;
  1409.  
  1410.     if (len < 0)
  1411.         len = STRLEN(s);
  1412.  
  1413.     if (is_cursor && gui.in_focus)
  1414.         highlight_mask = gui.highlight_mask | HL_INVERSE;
  1415.     else
  1416.         highlight_mask = gui.highlight_mask;
  1417.  
  1418.     if (highlight_mask & (HL_INVERSE | HL_STANDOUT))
  1419.         text_gc = gui.back_gc;
  1420.     else
  1421.         text_gc = gui.text_gc;
  1422.  
  1423.     /* Set the font */
  1424.     if ((highlight_mask & (HL_BOLD | HL_STANDOUT)) && gui.bold_font != NULL)
  1425.         if ((highlight_mask & HL_ITAL) && gui.boldital_font != NULL)
  1426.             gui_x11_set_font(text_gc, gui.boldital_font->fid);
  1427.         else
  1428.             gui_x11_set_font(text_gc, gui.bold_font->fid);
  1429.     else if ((highlight_mask & HL_ITAL) && gui.ital_font != NULL)
  1430.         gui_x11_set_font(text_gc, gui.ital_font->fid);
  1431.     else
  1432.         gui_x11_set_font(text_gc, gui.norm_font->fid);
  1433.  
  1434.     /* Set the color */
  1435.     if (is_cursor && gui.in_focus)
  1436.         gui_x11_set_color(text_gc, gui.cursor_pixel);
  1437.     else if (highlight_mask & (HL_BOLD | HL_STANDOUT))
  1438.         gui_x11_set_color(text_gc, gui.bold_pixel);
  1439.     else if (highlight_mask & HL_ITAL)
  1440.         gui_x11_set_color(text_gc, gui.ital_pixel);
  1441.     else if (highlight_mask & HL_UNDERLINE)
  1442.         gui_x11_set_color(text_gc, gui.underline_pixel);
  1443.     else
  1444.         gui_x11_set_color(text_gc, gui.norm_pixel);
  1445.  
  1446.     /* Clear the selection if we are about to write over it */
  1447.     if (gui.selection.state == SELECT_DONE
  1448.             && gui.row >= gui.selection.start.lnum
  1449.             && gui.row <= gui.selection.end.lnum)
  1450.         gui_mch_clear_selection();
  1451.  
  1452.     /* Draw the text */
  1453.     XDrawImageString(gui.dpy, gui.wid, text_gc,
  1454.         TEXT_X(gui.col), TEXT_Y(gui.row), (char *)s, len);
  1455.  
  1456.     /* No bold font, so fake it */
  1457.     if ((highlight_mask & (HL_BOLD | HL_STANDOUT)) && gui.bold_font == NULL)
  1458.         XDrawString(gui.dpy, gui.wid, text_gc,
  1459.             TEXT_X(gui.col) + 1, TEXT_Y(gui.row), (char *)s, len);
  1460.  
  1461.     /* Underline the text */
  1462.     if ((highlight_mask & HL_UNDERLINE)
  1463.      || ((highlight_mask & HL_ITAL) && gui.ital_font == NULL))
  1464.         XDrawLine(gui.dpy, gui.wid, text_gc, FILL_X(gui.col),
  1465.             FILL_Y(gui.row + 1) - 1, FILL_X(gui.col + len) - 1,
  1466.             FILL_Y(gui.row + 1) - 1);
  1467.  
  1468.     if (!is_cursor)
  1469.     {
  1470.         /* Invalidate the old physical cursor position if we wrote over it */
  1471.         if (gui.cursor_row == gui.row && gui.cursor_col >= gui.col
  1472.          && gui.cursor_col < gui.col + len)
  1473.             INVALIDATE_CURSOR();
  1474.  
  1475.         /* Update the cursor position */
  1476.         gui.col += len;
  1477.         if (wrap_cursor && gui.col >= Columns)
  1478.         {
  1479.             gui.col = 0;
  1480.             gui.row++;
  1481.         }
  1482.     }
  1483. }
  1484.  
  1485. /*
  1486.  * Delete the given number of lines from the given row, scrolling up any
  1487.  * text further down within the scroll region.
  1488.  */
  1489.     void
  1490. gui_mch_delete_lines(row, num_lines)
  1491.     int        row;
  1492.     int        num_lines;
  1493. {
  1494.     if (gui.visibility == VisibilityFullyObscured)
  1495.         return;        /* Can't see the window */
  1496.     
  1497.     if (num_lines <= 0)
  1498.         return;
  1499.  
  1500.     if (row + num_lines > gui.scroll_region_bot)
  1501.     {
  1502.         /* Scrolled out of region, just blank the lines out */
  1503.         gui_mch_clear_block(row, 0, gui.scroll_region_bot, Columns - 1);
  1504.     }
  1505.     else
  1506.     {
  1507.         XCopyArea(gui.dpy, gui.wid, gui.wid, gui.text_gc,
  1508.             FILL_X(0), FILL_Y(row + num_lines),
  1509.             gui.char_width * Columns,
  1510.             gui.char_height * (gui.scroll_region_bot - row - num_lines + 1),
  1511.             FILL_X(0), FILL_Y(row));
  1512.  
  1513.         /* Update gui.cursor_row if the cursor scrolled or copied over */
  1514.         if (gui.cursor_row >= row)
  1515.         {
  1516.             if (gui.cursor_row < row + num_lines)
  1517.                 INVALIDATE_CURSOR();
  1518.             else if (gui.cursor_row <= gui.scroll_region_bot)
  1519.                 gui.cursor_row -= num_lines;
  1520.         }
  1521.  
  1522.         gui_mch_clear_block(gui.scroll_region_bot - num_lines + 1, 0,
  1523.             gui.scroll_region_bot, Columns - 1);
  1524.         gui_x11_check_copy_area();
  1525.     }
  1526. }
  1527.  
  1528. /*
  1529.  * Insert the given number of lines before the given row, scrolling down any
  1530.  * following text within the scroll region.
  1531.  */
  1532.     void
  1533. gui_mch_insert_lines(row, num_lines)
  1534.     int        row;
  1535.     int        num_lines;
  1536. {
  1537.     if (gui.visibility == VisibilityFullyObscured)
  1538.         return;        /* Can't see the window */
  1539.     
  1540.     if (num_lines <= 0)
  1541.         return;
  1542.  
  1543.     if (row + num_lines > gui.scroll_region_bot)
  1544.     {
  1545.         /* Scrolled out of region, just blank the lines out */
  1546.         gui_mch_clear_block(row, 0, gui.scroll_region_bot, Columns - 1);
  1547.     }
  1548.     else
  1549.     {
  1550.         XCopyArea(gui.dpy, gui.wid, gui.wid, gui.text_gc,
  1551.             FILL_X(0), FILL_Y(row),
  1552.             gui.char_width * Columns,
  1553.             gui.char_height * (gui.scroll_region_bot - row - num_lines + 1),
  1554.             FILL_X(0), FILL_Y(row + num_lines));
  1555.  
  1556.         /* Update gui.cursor_row if the cursor scrolled or copied over */
  1557.         if (gui.cursor_row >= gui.row)
  1558.         {
  1559.             if (gui.cursor_row <= gui.scroll_region_bot - num_lines)
  1560.                 gui.cursor_row += num_lines;
  1561.             else if (gui.cursor_row <= gui.scroll_region_bot)
  1562.                 INVALIDATE_CURSOR();
  1563.         }
  1564.  
  1565.         gui_mch_clear_block(row, 0, row + num_lines - 1, Columns - 1);
  1566.         gui_x11_check_copy_area();
  1567.     }
  1568. }
  1569.  
  1570. /*
  1571.  * Scroll the text between gui.scroll_region_top & gui.scroll_region_bot by the
  1572.  * number of lines given.  Positive scrolls down (text goes up) and negative
  1573.  * scrolls up (text goes down).
  1574.  */
  1575.     static void
  1576. gui_x11_check_copy_area()
  1577. {
  1578.     XEvent                    event;
  1579.     XGraphicsExposeEvent    *gevent;
  1580.  
  1581.     if (gui.visibility != VisibilityPartiallyObscured)
  1582.         return;
  1583.  
  1584.     XFlush(gui.dpy);
  1585.  
  1586.     /* Wait to check whether the scroll worked or not */
  1587.     for (;;)
  1588.     {
  1589.         if (XCheckTypedEvent(gui.dpy, NoExpose, &event))
  1590.             return;        /* The scroll worked. */
  1591.         
  1592.         if (XCheckTypedEvent(gui.dpy, GraphicsExpose, &event))
  1593.         {
  1594.             gevent = (XGraphicsExposeEvent *)&event;
  1595.             gui_redraw(gevent->x, gevent->y, gevent->width, gevent->height);
  1596.             if (gevent->count == 0)
  1597.                 return;            /* This was the last expose event */
  1598.         }
  1599.         XSync(gui.dpy, False);
  1600.     }
  1601. }
  1602.  
  1603. /*
  1604.  * X Selection stuff, for cutting and pasting text to other windows.
  1605.  */
  1606.  
  1607.     static void
  1608. gui_x11_request_selection_cb(w, success, selection, type, value, length, format)
  1609.     Widget        w;
  1610.     XtPointer    success;
  1611.     Atom        *selection;
  1612.     Atom        *type;
  1613.     XtPointer    value;
  1614.     long_u        *length;
  1615.     int            *format;
  1616. {
  1617.     int        motion_type;
  1618.     long_u    len;
  1619.     char_u    *p;
  1620.  
  1621.     if (value == NULL || *length == 0)
  1622.     {
  1623.         gui_free_selection();    /* ??? */
  1624.         *(int *)success = FALSE;
  1625.         return;
  1626.     }
  1627.     motion_type = MCHAR;
  1628.     p = (char_u *)value;
  1629.     len = *length;
  1630.     if (*type == gui.selection.atom)
  1631.     {
  1632.         motion_type = *p++;
  1633.         len--;
  1634.     }
  1635.     gui_yank_selection(motion_type, p, len);
  1636.  
  1637.     XtFree((char *)value);
  1638.     *(int *)success = TRUE;
  1639. }
  1640.  
  1641.     void
  1642. gui_request_selection()
  1643. {
  1644.     XEvent    event;
  1645.     Atom    type = gui.selection.atom;
  1646.     int        success;
  1647.     int        i;
  1648.  
  1649.     for (i = 0; i < 2; i++)
  1650.     {
  1651.         XtGetSelectionValue(vimShell, XA_PRIMARY, type,
  1652.             gui_x11_request_selection_cb, (XtPointer)&success, CurrentTime);
  1653.  
  1654.         /* Do we need this?: */
  1655.         XFlush(gui.dpy);
  1656.  
  1657.         /*
  1658.          * Wait for result of selection request, otherwise if we type more
  1659.          * characters, then they will appear before the one that requested the
  1660.          * paste!  Don't worry, we will catch up with any other events later.
  1661.          */
  1662.         for (;;)
  1663.         {
  1664.             if (XCheckTypedEvent(gui.dpy, SelectionNotify, &event))
  1665.                 break;
  1666.  
  1667.             /* Do we need this?: */
  1668.             XSync(gui.dpy, False);
  1669.         }
  1670.         XtDispatchEvent(&event);
  1671.  
  1672.         if (success)
  1673.             return;
  1674.         type = XA_STRING;
  1675.     }
  1676. }
  1677.  
  1678.     static Boolean
  1679. gui_x11_convert_selection_cb(w, selection, target, type, value, length, format)
  1680.     Widget        w;
  1681.     Atom        *selection;
  1682.     Atom        *target;
  1683.     Atom        *type;
  1684.     XtPointer    *value;
  1685.     long_u        *length;
  1686.     int            *format;
  1687. {
  1688.     char_u    *string;
  1689.     char_u    *result;
  1690.     int        motion_type;
  1691.  
  1692.     if (!gui.selection.owned)
  1693.         return False;        /* Shouldn't ever happen */
  1694.  
  1695.     if (*target == gui.selection.atom)
  1696.     {
  1697.         gui_get_selection();
  1698.         motion_type = gui_convert_selection(&string, length);
  1699.         if (motion_type < 0)
  1700.             return False;
  1701.  
  1702.         (*length)++;
  1703.         *value = XtMalloc(*length);
  1704.         result = (char_u *)*value;
  1705.         if (result == NULL)
  1706.             return False;
  1707.         result[0] = motion_type;
  1708.         vim_memmove(result + 1, string, (size_t)(*length - 1));
  1709.         *type = *target;
  1710.         *format = 8;        /* 8 bits per char */
  1711.         return True;
  1712.     }
  1713.     else if (*target == XA_STRING)
  1714.     {
  1715.         gui_get_selection();
  1716.         motion_type = gui_convert_selection(&string, length);
  1717.         if (motion_type < 0)
  1718.             return False;
  1719.  
  1720.         *value = XtMalloc(*length);
  1721.         result = (char_u *)*value;
  1722.         if (result == NULL)
  1723.             return False;
  1724.         vim_memmove(result, string, (size_t)(*length));
  1725.         *type = *target;
  1726.         *format = 8;        /* 8 bits per char */
  1727.         return True;
  1728.     }
  1729.     else
  1730.         return False;
  1731. }
  1732.  
  1733.     static void
  1734. gui_x11_lose_ownership_cb(w, selection)
  1735.     Widget    w;
  1736.     Atom    *selection;
  1737. {
  1738.     gui_lose_selection();
  1739. }
  1740.  
  1741.     void
  1742. gui_mch_lose_selection()
  1743. {
  1744.     XtDisownSelection(vimShell, XA_PRIMARY, CurrentTime);
  1745.     gui_mch_clear_selection();
  1746. }
  1747.  
  1748.     int
  1749. gui_mch_own_selection()
  1750. {
  1751.     if (XtOwnSelection(vimShell, XA_PRIMARY, CurrentTime,
  1752.             gui_x11_convert_selection_cb, gui_x11_lose_ownership_cb,
  1753.             NULL) == False)
  1754.         return FAIL;
  1755.     
  1756.     return OK;
  1757. }
  1758.  
  1759. /*
  1760.  * Menu stuff.
  1761.  */
  1762.  
  1763.     void
  1764. gui_x11_menu_cb(w, client_data, call_data)
  1765.     Widget        w;
  1766.     XtPointer    client_data, call_data;
  1767. {
  1768.     gui_menu_cb((GuiMenu *)client_data);
  1769. }
  1770.  
  1771. /*
  1772.  * Used recursively by gui_x11_update_menus (see below)
  1773.  */
  1774.     static void
  1775. gui_x11_update_menus_recurse(menu, mode)
  1776.     GuiMenu    *menu;
  1777.     int        mode;
  1778. {
  1779.     while (menu)
  1780.     {
  1781.         if (menu->modes & mode)
  1782.         {
  1783.             if (vim_strchr(p_guioptions, GO_GREY) != NULL)
  1784.                 XtSetSensitive(menu->id, True);
  1785.             else
  1786.                 XtManageChild(menu->id);
  1787.             gui_x11_update_menus_recurse(menu->children, mode);
  1788.         }
  1789.         else
  1790.         {
  1791.             if (vim_strchr(p_guioptions, GO_GREY) != NULL)
  1792.                 XtSetSensitive(menu->id, False);
  1793.             else
  1794.                 XtUnmanageChild(menu->id);
  1795.         }
  1796.         menu = menu->next;
  1797.     }
  1798. }
  1799.  
  1800. /*
  1801.  * Make sure only the valid menu items appear for this mode.  If
  1802.  * force_menu_update is not TRUE, then we only do this if the mode has changed
  1803.  * since last time.  If "modes" is not 0, then we use these modes instead.
  1804.  */
  1805.     void
  1806. gui_x11_update_menus(modes)
  1807.     int        modes;
  1808. {
  1809.     static int prev_mode = -1;
  1810.  
  1811.     int mode = 0;
  1812.  
  1813.     if (modes != 0x0)
  1814.         mode = modes;
  1815.     else if (VIsual_active)
  1816.         mode = MENU_VISUAL_MODE;
  1817.     else if (State & NORMAL)
  1818.         mode = MENU_NORMAL_MODE;
  1819.     else if (State & INSERT)
  1820.         mode = MENU_INSERT_MODE;
  1821.     else if (State & CMDLINE)
  1822.         mode = MENU_CMDLINE_MODE;
  1823.  
  1824.     if (force_menu_update || mode != prev_mode)
  1825.     {
  1826.         gui_x11_update_menus_recurse(gui.root_menu, mode);
  1827.         prev_mode = mode;
  1828.         force_menu_update = FALSE;
  1829.     }
  1830. }
  1831.  
  1832. /*
  1833.  * Function called when window closed.  Preserve files and exit.
  1834.  * Should put up a requester!
  1835.  */
  1836. /*ARGSUSED*/
  1837.     static void
  1838. gui_x11_wm_protocol_handler(w, client_data, event, bool)
  1839.     Widget        w;
  1840.     XtPointer    client_data;
  1841.     XEvent        *event;
  1842.     Boolean        *bool;
  1843. {
  1844.     /*
  1845.      * On some HPUX system with Motif 1.2 this function is somehow called when
  1846.      * starting up.  This if () avoids an unexpected exit.
  1847.      */
  1848.     if (event->type != ClientMessage ||
  1849.            ((XClientMessageEvent *)event)->data.l[0] != Atom_WM_DELETE_WINDOW)
  1850.         return;
  1851.  
  1852.     STRCPY(IObuff, "Vim: Window closed\n");
  1853.     preserve_exit();                /* preserve files and exit */
  1854. }
  1855.  
  1856. /*
  1857.  * Compare two screen positions ala strcmp()
  1858.  */
  1859.     static int
  1860. gui_x11_compare_pos(row1, col1, row2, col2)
  1861.     short_u        row1;
  1862.     short_u        col1;
  1863.     short_u        row2;
  1864.     short_u        col2;
  1865. {
  1866.     if (row1 > row2) return( 1);
  1867.     if (row1 < row2) return(-1);
  1868.     if (col1 > col2) return( 1);
  1869.     if (col1 < col2) return(-1);
  1870.                      return( 0);
  1871. }
  1872.  
  1873. /*
  1874.  * Start out the selection
  1875.  */
  1876.     void
  1877. gui_x11_start_selection(button, x, y, repeated_click, modifiers)
  1878.     int     button;
  1879.     int     x;
  1880.     int     y;
  1881.     int     repeated_click;
  1882.     int_u   modifiers;
  1883. {
  1884.     GuiSelection    *gs = &gui.selection;
  1885.  
  1886.     if (gs->state == SELECT_DONE)
  1887.         gui_mch_clear_selection();
  1888.     
  1889.     gs->start.lnum    = Y_2_ROW(y);
  1890.     gs->start.col    = X_2_COL(x);
  1891.     gs->end            = gs->start;
  1892.     gs->origin_row    = gs->start.lnum;
  1893.     gs->state        = SELECT_IN_PROGRESS;
  1894.  
  1895.     if (repeated_click)
  1896.     {
  1897.         if (++(gs->mode) > SELECT_MODE_LINE)
  1898.             gs->mode = SELECT_MODE_CHAR;
  1899.     }
  1900.     else
  1901.         gs->mode = SELECT_MODE_CHAR;
  1902.  
  1903.     /* clear the cursor until the selection is made */
  1904.     gui_undraw_cursor();
  1905.  
  1906.     switch (gs->mode)
  1907.     {
  1908.         case SELECT_MODE_CHAR:
  1909.             gs->origin_start_col = gs->start.col;
  1910.             gs->word_end_col = gui_x11_get_line_end(gs->start.lnum);
  1911.             break;
  1912.  
  1913.         case SELECT_MODE_WORD:
  1914.             gui_x11_get_word_boundaries(gs, gs->start.lnum, gs->start.col);
  1915.             gs->origin_start_col = gs->word_start_col;
  1916.             gs->origin_end_col   = gs->word_end_col;
  1917.  
  1918.             gui_x11_invert_area(gs->start.lnum, gs->word_start_col,
  1919.                                 gs->end.lnum, gs->word_end_col);
  1920.             gs->start.col = gs->word_start_col;
  1921.             gs->end.col   = gs->word_end_col;
  1922.             break;
  1923.  
  1924.         case SELECT_MODE_LINE:
  1925.             gui_x11_invert_area(gs->start.lnum, 0, gs->start.lnum,
  1926.                     gui.num_cols);
  1927.             gs->start.col = 0;
  1928.             gs->end.col   = gui.num_cols;
  1929.             break;
  1930.     }
  1931.  
  1932.     gs->prev = gs->start;
  1933.             
  1934. #ifdef DEBUG_SELECTION
  1935.     printf("Selection started at (%u,%u)\n", gs->start.lnum, gs->start.col);
  1936. #endif
  1937. }
  1938.  
  1939. /*
  1940.  * Continue processing the selection
  1941.  */
  1942.     void
  1943. gui_x11_process_selection(button, x, y, repeated_click, modifiers)
  1944.     int     button;
  1945.     int     x;
  1946.     int     y;
  1947.     int     repeated_click;
  1948.     int_u   modifiers;
  1949. {
  1950.     GuiSelection    *gs = &gui.selection;
  1951.     int                   row, col;
  1952.     int                diff;
  1953.     
  1954.     if (button == MOUSE_RELEASE)
  1955.     {
  1956.         /* Check to make sure we have something selected */
  1957.         if (gs->start.lnum == gs->end.lnum && gs->start.col == gs->end.col)
  1958.         {
  1959.             gui_update_cursor();
  1960.             gs->state = SELECT_CLEARED;
  1961.             return;
  1962.         }
  1963.  
  1964. #ifdef DEBUG_SELECTION
  1965.         printf("Selection ended: (%u,%u) to (%u,%u)\n", gs->start.lnum,
  1966.                 gs->start.col, gs->end.lnum, gs->end.col);
  1967. #endif
  1968.         gui_free_selection();
  1969.         gui_own_selection();
  1970.         gui_x11_yank_selection(gs->start.lnum, gs->start.col, gs->end.lnum,
  1971.                 gs->end.col);
  1972.         gui_update_cursor();
  1973.  
  1974.         gs->state = SELECT_DONE;
  1975.         return;
  1976.     }
  1977.  
  1978.     row = Y_2_ROW(y);
  1979.     col = X_2_COL(x);
  1980.  
  1981.     row = check_row(row);
  1982.     col = check_col(col);
  1983.  
  1984.     if (col == gs->prev.col && row == gs->prev.lnum)
  1985.         return;
  1986.  
  1987.     /*
  1988.      * When extending the selection with the right mouse button, swap the
  1989.      * start and end if the position is before half the selection
  1990.      */
  1991.     if (gs->state == SELECT_DONE && button == MOUSE_RIGHT)
  1992.     {
  1993.         /*
  1994.          * If the click is before the start, or the click is inside the
  1995.          * selection and the start is the closest side, set the origin to the
  1996.          * end of the selection.
  1997.          */
  1998.         if (gui_x11_compare_pos(row, col, gs->start.lnum, gs->start.col) < 0 ||
  1999.                 (gui_x11_compare_pos(row, col, gs->end.lnum, gs->end.col) < 0 &&
  2000.                  (((gs->start.lnum == gs->end.lnum &&
  2001.                     gs->end.col - col > col - gs->start.col)) ||
  2002.                   ((diff = (gs->end.lnum - row) - (row - gs->start.lnum)) > 0 ||
  2003.                    (diff == 0 && col < (gs->start.col + gs->end.col) / 2)))))
  2004.         {
  2005.             gs->origin_row = gs->end.lnum;
  2006.             gs->origin_start_col = gs->end.col - 1;
  2007.             gs->origin_end_col = gs->end.col;
  2008.         }
  2009.         else
  2010.         {
  2011.             gs->origin_row = gs->start.lnum;
  2012.             gs->origin_start_col = gs->start.col;
  2013.             gs->origin_end_col = gs->start.col;
  2014.         }
  2015.         if (gs->mode == SELECT_MODE_WORD)
  2016.         {
  2017.             gui_x11_get_word_boundaries(gs, gs->origin_row,
  2018.                                                         gs->origin_start_col);
  2019.             gs->origin_start_col = gs->word_start_col;
  2020.             gs->origin_end_col   = gs->word_end_col;
  2021.         }
  2022.     }
  2023.  
  2024.     /* set state, for when using the right mouse button */
  2025.     gs->state = SELECT_IN_PROGRESS;
  2026.  
  2027. #ifdef DEBUG_SELECTION
  2028.     printf("Selection extending to (%d,%d)\n", row, col);
  2029. #endif
  2030.  
  2031.     switch (gs->mode)
  2032.     {
  2033.         case SELECT_MODE_CHAR:
  2034.             /* If we're on a different line, find where the line ends */
  2035.             if (row != gs->prev.lnum)
  2036.                 gs->word_end_col = gui_x11_get_line_end(row);
  2037.  
  2038.             /* See if we are before or after the origin of the selection */
  2039.             if (gui_x11_compare_pos(row, col, gs->origin_row,
  2040.                                                    gs->origin_start_col) >= 0)
  2041.             {
  2042.                 if (col >= (int)gs->word_end_col)
  2043.                     gui_x11_update_selection(gs, gs->origin_row,
  2044.                             gs->origin_start_col, row, gui.num_cols);
  2045.                 else
  2046.                     gui_x11_update_selection(gs, gs->origin_row,
  2047.                             gs->origin_start_col, row, col + 1);
  2048.             }
  2049.             else
  2050.             {
  2051.                 if (col >= (int)gs->word_end_col)
  2052.                     gui_x11_update_selection(gs, row, gs->word_end_col,
  2053.                             gs->origin_row, gs->origin_start_col + 1);
  2054.                 else
  2055.                     gui_x11_update_selection(gs, row, col, gs->origin_row,
  2056.                             gs->origin_start_col + 1);
  2057.             }
  2058.             break;
  2059.  
  2060.         case SELECT_MODE_WORD:
  2061.             /* If we are still within the same word, do nothing */
  2062.             if (row == gs->prev.lnum && col >= (int)gs->word_start_col
  2063.                     && col < (int)gs->word_end_col)
  2064.                 return;
  2065.  
  2066.             /* Get new word boundaries */
  2067.             gui_x11_get_word_boundaries(gs, row, col);
  2068.  
  2069.             /* Handle being after the origin point of selection */
  2070.             if (gui_x11_compare_pos(row, col, gs->origin_row,
  2071.                     gs->origin_start_col) >= 0)
  2072.                 gui_x11_update_selection(gs, gs->origin_row,
  2073.                         gs->origin_start_col, row, gs->word_end_col);
  2074.             else
  2075.                 gui_x11_update_selection(gs, row, gs->word_start_col,
  2076.                         gs->origin_row, gs->origin_end_col);
  2077.             break;
  2078.  
  2079.         case SELECT_MODE_LINE:
  2080.             if (row == gs->prev.lnum)
  2081.                 return;
  2082.  
  2083.             if (gui_x11_compare_pos(row, col, gs->origin_row,
  2084.                     gs->origin_start_col) >= 0)
  2085.                 gui_x11_update_selection(gs, gs->origin_row, 0, row,
  2086.                         gui.num_cols);
  2087.             else
  2088.                 gui_x11_update_selection(gs, row, 0, gs->origin_row,
  2089.                         gui.num_cols);
  2090.             break;
  2091.     }
  2092.  
  2093.     gs->prev.lnum = row;
  2094.     gs->prev.col  = col;
  2095.  
  2096. #ifdef DEBUG_SELECTION
  2097.         printf("Selection is: (%u,%u) to (%u,%u)\n", gs->start.lnum,
  2098.                 gs->start.col, gs->end.lnum, gs->end.col);
  2099. #endif
  2100. }
  2101.  
  2102. /*
  2103.  * Called after an Expose event to redraw the selection
  2104.  */
  2105.     void
  2106. gui_x11_redraw_selection(x, y, w, h)
  2107.     int     x;
  2108.     int     y;
  2109.     int     w;
  2110.     int     h;
  2111. {
  2112.     GuiSelection    *gs = &gui.selection;
  2113.     int                row1, col1, row2, col2;
  2114.     int             row;
  2115.     int             start;
  2116.     int             end;
  2117.     
  2118.     if (gs->state == SELECT_CLEARED)
  2119.         return;
  2120.  
  2121.     row1 = Y_2_ROW(y);
  2122.     col1 = X_2_COL(x);
  2123.     row2 = Y_2_ROW(y + h - 1);
  2124.     col2 = X_2_COL(x + w - 1);
  2125.  
  2126.     /* Limit the rows that need to be re-drawn */
  2127.     if (gs->start.lnum > row1)
  2128.         row1 = gs->start.lnum;
  2129.     if (gs->end.lnum < row2)
  2130.         row2 = gs->end.lnum;
  2131.     
  2132.     /* Look at each row that might need to be re-drawn */
  2133.     for (row = row1; row <= row2; row++)
  2134.     {
  2135.         /* For the first selection row, use the starting selection column */
  2136.         if (row == gs->start.lnum)
  2137.             start = gs->start.col;
  2138.         else
  2139.             start = 0;
  2140.  
  2141.         /* For the last selection row, use the ending selection column */
  2142.         if (row == gs->end.lnum)
  2143.             end = gs->end.col;
  2144.         else
  2145.             end = gui.num_cols;
  2146.         
  2147.         if (col1 > start)
  2148.             start = col1;
  2149.  
  2150.         if (col2 < end)
  2151.             end = col2 + 1;
  2152.  
  2153.         if (end > start)
  2154.             invert_rectangle(row, start, 1, end - start);
  2155.     }
  2156. }
  2157.  
  2158. /*
  2159.  * Called from outside to clear selected region from the display
  2160.  */
  2161.     void
  2162. gui_mch_clear_selection()
  2163. {
  2164.     GuiSelection    *gs = &gui.selection;
  2165.  
  2166.     if (gs->state == SELECT_CLEARED)
  2167.         return;
  2168.  
  2169.     gui_x11_invert_area(gs->start.lnum, gs->start.col, gs->end.lnum,
  2170.             gs->end.col);
  2171.     gs->state = SELECT_CLEARED;
  2172. }
  2173.  
  2174. /*
  2175.  * Invert a region of the display between a starting and ending row and column
  2176.  */
  2177.     static void
  2178. gui_x11_invert_area(row1, col1, row2, col2)
  2179.     int        row1;
  2180.     int        col1;
  2181.     int        row2;
  2182.     int        col2;
  2183. {
  2184.     /* Swap the from and to positions so the from is always before */
  2185.     if (gui_x11_compare_pos(row1, col1, row2, col2) > 0)
  2186.     {
  2187.         int tmp_row, tmp_col;
  2188.         tmp_row = row1;
  2189.         tmp_col = col1;
  2190.         row1    = row2;
  2191.         col1    = col2;
  2192.         row2    = tmp_row;
  2193.         col2    = tmp_col;
  2194.     }
  2195.  
  2196.     /* If all on the same line, do it the easy way */
  2197.     if (row1 == row2)
  2198.     {
  2199.         invert_rectangle(row1, col1, 1, col2 - col1);
  2200.         return;
  2201.     }
  2202.  
  2203.     /* Handle a piece of the first line */
  2204.     if (col1 > 0)
  2205.     {
  2206.         invert_rectangle(row1, col1, 1, gui.num_cols - col1);
  2207.         row1++;
  2208.     }
  2209.  
  2210.     /* Handle a piece of the last line */
  2211.     if (col2 < gui.num_cols - 1)
  2212.     {
  2213.         invert_rectangle(row2, 0, 1, col2);
  2214.         row2--;
  2215.     }
  2216.  
  2217.     /* Handle the rectangle thats left */
  2218.     if (row2 >= row1)
  2219.         invert_rectangle(row1, 0, row2 - row1 + 1, gui.num_cols);
  2220. }
  2221.  
  2222. /*
  2223.  * Yank the currently selected area into the special selection buffer so it
  2224.  * will be available for pasting.
  2225.  */
  2226.     static void
  2227. gui_x11_yank_selection(row1, col1, row2, col2)
  2228.     int        row1;
  2229.     int        col1;
  2230.     int        row2;
  2231.     int        col2;
  2232. {
  2233.     char_u    *buffer;
  2234.     char_u    *bufp;
  2235.     int          row;
  2236.     int       start_col;
  2237.     int       end_col;
  2238.     int          line_end_col;
  2239.     int          add_newline_flag = FALSE;
  2240.  
  2241.     /* Create a temporary buffer for storing the text */
  2242.     buffer = lalloc((row2 - row1 + 1) * gui.num_cols + 1, TRUE);
  2243.     if (buffer == NULL)
  2244.         return;                    /* Should there be an error message here? */
  2245.  
  2246.     /* Process each row in the selection */
  2247.     for (bufp = buffer, row = row1; row <= row2; row++)
  2248.     {
  2249.         if (row == row1)
  2250.             start_col = col1;
  2251.         else
  2252.             start_col = 0;
  2253.  
  2254.         if (row == row2)
  2255.             end_col = col2;
  2256.         else
  2257.             end_col = gui.num_cols;
  2258.  
  2259.         line_end_col = gui_x11_get_line_end(row);
  2260.  
  2261.         /* See if we need to nuke some trailing whitespace */
  2262.         if (end_col >= gui.num_cols && (row < row2 || end_col > line_end_col))
  2263.         {
  2264.             /* Get rid of trailing whitespace */
  2265.             end_col = line_end_col;
  2266.             if (end_col < start_col)
  2267.                 end_col = start_col;
  2268.  
  2269.             /* If the last line extended to the end, add an extra newline */
  2270.             if (row == row2)
  2271.                 add_newline_flag = TRUE;
  2272.         }
  2273.  
  2274.         /* If after the first row, we need to always add a newline */
  2275.         if (row > row1)
  2276.             *bufp++ = NL;
  2277.  
  2278.         if (gui.row < screen_Rows && end_col <= screen_Columns)
  2279.         {
  2280.             STRNCPY(bufp, &LinePointers[row][start_col], end_col - start_col);
  2281.             bufp += end_col - start_col;
  2282.         }
  2283.     }
  2284.  
  2285.     /* Add a newline at the end if the selection ended there */
  2286.     if (add_newline_flag)
  2287.         *bufp++ = NL;
  2288.  
  2289.     gui_yank_selection(MCHAR, buffer, bufp - buffer);
  2290.     vim_free(buffer);
  2291. }
  2292.  
  2293. /*
  2294.  * Find the starting and ending positions of the word at the given row and
  2295.  * column.
  2296.  */
  2297.     static void
  2298. gui_x11_get_word_boundaries(gs, row, col)
  2299.     GuiSelection    *gs;
  2300.     int                row;
  2301.     int                col;
  2302. {
  2303.     char    start_class;
  2304.     int        temp_col;
  2305.  
  2306.     if (row >= screen_Rows || col >= screen_Columns)
  2307.         return;
  2308.  
  2309.     start_class = char_class(LinePointers[row][col]);
  2310.  
  2311.     temp_col = col;
  2312.     for ( ; temp_col > 0; temp_col--)
  2313.         if (char_class(LinePointers[row][temp_col - 1]) != start_class)
  2314.             break;
  2315.  
  2316.     gs->word_start_col = temp_col;
  2317.  
  2318.     temp_col = col;
  2319.     for ( ; temp_col < screen_Columns; temp_col++)
  2320.         if (char_class(LinePointers[row][temp_col]) != start_class)
  2321.             break;
  2322.     gs->word_end_col = temp_col;
  2323.  
  2324. #ifdef DEBUG_SELECTION
  2325.     printf("Current word: col %u to %u\n", gs->word_start_col,
  2326.             gs->word_end_col);
  2327. #endif
  2328. }
  2329.  
  2330. /*
  2331.  * Find the column position for the last non-whitespace character on the given
  2332.  * line.
  2333.  */
  2334.     static int
  2335. gui_x11_get_line_end(row)
  2336.     int            row;
  2337. {
  2338.     int        i;
  2339.  
  2340.     if (row >= screen_Rows)
  2341.         return 0;
  2342.     for (i = screen_Columns; i > 0; i--)
  2343.         if (LinePointers[row][i - 1] != ' ')
  2344.             break;
  2345.     return i;
  2346. }
  2347.  
  2348. /*
  2349.  * Update the currently selected region by adding and/or subtracting from the
  2350.  * beginning or end and inverting the changed area(s).
  2351.  */
  2352.     static void
  2353. gui_x11_update_selection(gs, row1, col1, row2, col2)
  2354.     GuiSelection    *gs;
  2355.     int                row1;
  2356.     int                col1;
  2357.     int                row2;
  2358.     int                col2;
  2359. {
  2360.     /* See if we changed at the beginning of the selection */
  2361.     if (row1 != gs->start.lnum || col1 != gs->start.col)
  2362.     {
  2363.         gui_x11_invert_area(row1, col1, gs->start.lnum, gs->start.col);
  2364.         gs->start.lnum = row1;
  2365.         gs->start.col  = col1;
  2366.     }
  2367.  
  2368.     /* See if we changed at the end of the selection */
  2369.     if (row2 != gs->end.lnum || col2 != gs->end.col)
  2370.     {
  2371.         gui_x11_invert_area(row2, col2, gs->end.lnum, gs->end.col);
  2372.         gs->end.lnum = row2;
  2373.         gs->end.col  = col2;
  2374.     }
  2375. }
  2376.