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 / unreleased / patches / 5.6a.018 < prev    next >
Encoding:
Internet Message Format  |  2000-01-07  |  180.2 KB
  1. To: vim-dev@vim.org
  2. Subject: Patch 5.6a.018
  3. Fcc: outbox
  4. From: Bram Moolenaar <Bram@moolenaar.net>
  5. ------------
  6.  
  7. Note: I received a number of fixes for the GTK version from Marcin Dalecki.  I
  8. found these important enough to include.  But since this is more than a small
  9. change, I'll give this another week before releasing 5.6.  A few functions
  10. were moved, which made patch quite big, even though not that much really
  11. changed.
  12.  
  13.  
  14. Patch 5.6a.018
  15. Problem:    GTK GUI: submenu priority doesn't work.
  16.         Help dialog could be destroyed too soon.
  17.         When closing a dialog window (e.g. the "ATTENTION" one), Vim would
  18.         just hang.
  19.         When GTK theme is changed, Vim doesn't adjust to the new colors.
  20.         Argument for ":promptfind" isn't used.
  21. Solution:   Fixed the mentioned problems.
  22.         Made the dialogs look&feel nicer.
  23.         Moved functions to avoid the need for a forward declaration.
  24.         Fixed reentrancy of the file browser dialog.
  25.         Added drag&drop support for GNOME.
  26.         Init the text for the Find/replace dialog from the last used
  27.         search string.  Set "match whole word" toggle button correctly.
  28.         Made repeat rate for drag outside of window depend on the
  29.         distance from the window.  (Marcin Dalecki)
  30.         Made the drag in Visual mode actually work.
  31.         Removed recursiveness protection from gui_mch_get_rgb(), it might
  32.         cause more trouble than it solves.
  33. Files:        src/ex_docmd.c, src/gui_gtk.c, src/gui_gtk_x11.c, src/ui.c,
  34.         src/proto/ui.pro, src/misc2.c
  35.  
  36.  
  37. *** ../vim-5.6a.17/src/ex_docmd.c    Wed Dec 29 12:11:01 1999
  38. --- src/ex_docmd.c    Sat Jan  8 13:45:47 2000
  39. ***************
  40. *** 5941,5947 ****
  41.       }
  42.   }
  43.   
  44. ! #if defined(USE_GUI_MSWIN) || defined(USE_GUI_BEOS) || defined(macintosh) || defined(PROTO)
  45.   /*
  46.    * Handle a file drop. The code is here because a drop is *nearly* like an
  47.    * :args command, but not quite (we have a list of exact filenames, so we
  48. --- 5941,5948 ----
  49.       }
  50.   }
  51.   
  52. ! #if defined(USE_GUI_MSWIN) || defined(USE_GUI_BEOS) || defined(macintosh) \
  53. !     || defined(USE_GUI_GTK) || defined(PROTO)
  54.   /*
  55.    * Handle a file drop. The code is here because a drop is *nearly* like an
  56.    * :args command, but not quite (we have a list of exact filenames, so we
  57. ***************
  58. *** 5949,5958 ****
  59.    * code is very similar to :args and hence needs access to a lot of the static
  60.    * functions in this file.
  61.    *
  62. -  * Arguments:
  63. -  *    FILEC => the number of files dropped
  64. -  *    FILEV => the list of files dropped
  65. -  *
  66.    * The list should be allocated using vim_alloc(), as should each item in the
  67.    * list. This function takes over responsibility for freeing the list.
  68.    *
  69. --- 5950,5955 ----
  70. ***************
  71. *** 5966,5973 ****
  72.   
  73.       void
  74.   handle_drop(filec, filev, split)
  75. !     int        filec;
  76. !     char_u    **filev;
  77.       int        split;        /* force splitting the window */
  78.   {
  79.       EXARG    ea;
  80. --- 5963,5970 ----
  81.   
  82.       void
  83.   handle_drop(filec, filev, split)
  84. !     int        filec;        /* the number of files dropped */
  85. !     char_u    **filev;    /* the list of files dropped */
  86.       int        split;        /* force splitting the window */
  87.   {
  88.       EXARG    ea;
  89. *** ../vim-5.6a.17/src/gui_gtk.c    Mon Dec 20 09:59:10 1999
  90. --- src/gui_gtk.c    Sat Jan  8 21:11:02 2000
  91. ***************
  92. *** 19,24 ****
  93. --- 19,29 ----
  94.    *    :-) <dalecki@cs.net.pl> (My native language is polish and I speak
  95.    *    native grade german too. I'm living in GĂ·ttingen.de.)
  96.    *    --mdcki"
  97. +  *
  98. +  *
  99. +  * Although some #ifdefs suggest that GTK 1.0 is supported, it isn't.  The
  100. +  * code requires GTK version 1.1.16 or later.  Stuff for older versions will
  101. +  * be removed some time.
  102.    */
  103.   
  104.   #include "gui_gtk_f.h"
  105. ***************
  106. *** 92,115 ****
  107.   #define FR_REPLACE    4
  108.   #define FR_REPLACEALL    5
  109.   
  110. - 
  111. - #if defined(USE_BROWSE) || defined(PROTO)
  112. - static void browse_ok_cb(GtkWidget * widget, gpointer cbdata);
  113. - static void browse_cancel_cb(GtkWidget * widget, gpointer cbdata);
  114. - static gboolean browse_destroy_cb(GtkWidget * widget);
  115. - #endif
  116. - 
  117. - #ifdef GUI_DIALOG
  118. - static void butproc(GtkWidget * widget, gpointer data);
  119. - #endif
  120. - 
  121.   static void entry_activate_cb(GtkWidget *widget, GtkWidget *with);
  122.   static void entry_changed_cb(GtkWidget *entry, GtkWidget *dialog);
  123.   static void find_direction_cb(GtkWidget *widget, gpointer data);
  124. ! static void find_replace_cb(GtkWidget *widget, gint flags);
  125.   static void exact_match_cb(GtkWidget *widget, gpointer data);
  126.   static void repl_dir_cb(GtkWidget * widget, gpointer data);
  127. - static void find_replace_dialog_create(int do_replace);
  128.   
  129.   #ifdef USE_TOOLBAR
  130.   static void get_pixmap(char *menuname, GdkPixmap **pixmap, GdkBitmap **mask);
  131. --- 97,108 ----
  132.   #define FR_REPLACE    4
  133.   #define FR_REPLACEALL    5
  134.   
  135.   static void entry_activate_cb(GtkWidget *widget, GtkWidget *with);
  136.   static void entry_changed_cb(GtkWidget *entry, GtkWidget *dialog);
  137.   static void find_direction_cb(GtkWidget *widget, gpointer data);
  138. ! static void find_replace_cb(GtkWidget *widget, unsigned int flags);
  139.   static void exact_match_cb(GtkWidget *widget, gpointer data);
  140.   static void repl_dir_cb(GtkWidget * widget, gpointer data);
  141.   
  142.   #ifdef USE_TOOLBAR
  143.   static void get_pixmap(char *menuname, GdkPixmap **pixmap, GdkBitmap **mask);
  144. ***************
  145. *** 120,127 ****
  146.   #endif
  147.   
  148.   #if defined(WANT_MENU) || defined(PROTO)
  149. - static void gui_mch_recurse_tearoffs(VimMenu *menu, int val);
  150. - static void menu_item_cb(GtkWidget *widget, gpointer data);
  151.   
  152.   /*
  153.    * Only use accelerators when gtk_menu_ensure_uline_accel_group() is
  154. --- 113,118 ----
  155. ***************
  156. *** 133,138 ****
  157. --- 124,130 ----
  158.   #  define GTK_USE_ACCEL
  159.   # endif
  160.   #endif
  161. + 
  162.   /*
  163.    * Create a highly customized menu item by hand instead of by using:
  164.    *
  165. ***************
  166. *** 192,198 ****
  167.        * additional underscores.
  168.        */
  169.       name = g_new(char, strlen((char *)menu->name) + num + 1);
  170. !     for (num = 0, tmp = (char *)menu->name; *tmp; tmp++) {
  171.       /* actext has been added above, stop at the TAB */
  172.       if (*tmp == TAB)
  173.           break;
  174. --- 184,190 ----
  175.        * additional underscores.
  176.        */
  177.       name = g_new(char, strlen((char *)menu->name) + num + 1);
  178. !     for (num = 0, tmp = (char *)menu->name; *tmp; ++tmp) {
  179.       /* actext has been added above, stop at the TAB */
  180.       if (*tmp == TAB)
  181.           break;
  182. ***************
  183. *** 285,294 ****
  184.       if (parent == NULL)
  185.       gtk_menu_bar_insert(GTK_MENU_BAR(gui.menubar), menu->id, idx);
  186.       else {
  187. - #ifdef GTK_HAVE_FEATURES_1_1_0
  188.       /* since the tearoff should always appear first, increment idx */
  189.       ++idx;
  190. - #endif
  191.       gtk_menu_insert(GTK_MENU(parent->submenu_id), menu->id, idx);
  192.       }
  193.   
  194. --- 277,284 ----
  195. ***************
  196. *** 314,319 ****
  197. --- 304,319 ----
  198.   #endif
  199.   }
  200.   
  201. + /*ARGSUSED*/
  202. + static void
  203. + menu_item_activate(GtkWidget * widget, gpointer data)
  204. + {
  205. +     gui_menu_cb((VimMenu *) data);
  206. + 
  207. +     /* make sure the menu action is taken immediately */
  208. +     if (gtk_main_level() > 0)
  209. +     gtk_main_quit();
  210. + }
  211.   
  212.   /*ARGSUSED*/
  213.   void
  214. ***************
  215. *** 337,343 ****
  216.                       (char *)(menu->strings[MENU_INDEX_TIP]),
  217.                       (char *)(menu->dname),
  218.                       gtk_pixmap_new(pixmap, mask),
  219. !                     GTK_SIGNAL_FUNC(menu_item_cb),
  220.                       (gpointer)menu,
  221.                       idx);
  222.       }
  223. --- 337,343 ----
  224.                       (char *)(menu->strings[MENU_INDEX_TIP]),
  225.                       (char *)(menu->dname),
  226.                       gtk_pixmap_new(pixmap, mask),
  227. !                     GTK_SIGNAL_FUNC(menu_item_activate),
  228.                       (gpointer)menu,
  229.                       idx);
  230.       }
  231. ***************
  232. *** 351,372 ****
  233.       if (parent->submenu_id == 0)
  234.       return;
  235.   
  236.       if (is_menu_separator(menu->name)) {
  237. !     /* just add it */
  238.       menu->id = gtk_menu_item_new();
  239.       gtk_widget_show(menu->id);
  240. !     gtk_menu_append(GTK_MENU(parent->submenu_id), menu->id);
  241.   
  242. !     return; /* that's all */
  243.       }
  244.   
  245.       menu_item_new(menu, parent->submenu_id, FALSE);
  246.       gtk_widget_show(menu->id);
  247. !     gtk_menu_append(GTK_MENU(parent->submenu_id), menu->id);
  248.   
  249.       if (menu->id != 0)
  250.       gtk_signal_connect(GTK_OBJECT(menu->id), "activate",
  251. !         GTK_SIGNAL_FUNC(menu_item_cb), (gpointer) menu);
  252.   }
  253.   #endif
  254.   
  255. --- 351,375 ----
  256.       if (parent->submenu_id == 0)
  257.       return;
  258.   
  259. +     /* make place for the possible tearoff handle item */
  260. +     ++idx;
  261.       if (is_menu_separator(menu->name)) {
  262. !     /* Separator: Just add it */
  263.       menu->id = gtk_menu_item_new();
  264.       gtk_widget_show(menu->id);
  265. !     gtk_menu_insert(GTK_MENU(parent->submenu_id), menu->id, idx);
  266.   
  267. !     return;
  268.       }
  269.   
  270. +     /* Add textual menu item. */
  271.       menu_item_new(menu, parent->submenu_id, FALSE);
  272.       gtk_widget_show(menu->id);
  273. !     gtk_menu_insert(GTK_MENU(parent->submenu_id), menu->id, idx);
  274.   
  275.       if (menu->id != 0)
  276.       gtk_signal_connect(GTK_OBJECT(menu->id), "activate",
  277. !         GTK_SIGNAL_FUNC(menu_item_activate), (gpointer) menu);
  278.   }
  279.   #endif
  280.   
  281. ***************
  282. *** 426,432 ****
  283.   
  284.       *pixmap = NULL;
  285.       *mask = NULL;
  286. !     if (strncmp(menuname, "BuiltIn", 7) == 0) {
  287.       if (isdigit((int)menuname[7]) && isdigit((int)menuname[8])) {
  288.           builtin_num = atoi(menuname + 7);
  289.           pixmap_create_by_num(builtin_num, pixmap, mask);
  290. --- 429,435 ----
  291.   
  292.       *pixmap = NULL;
  293.       *mask = NULL;
  294. !     if (strncmp(menuname, "BuiltIn", (size_t)7) == 0) {
  295.       if (isdigit((int)menuname[7]) && isdigit((int)menuname[8])) {
  296.           builtin_num = atoi(menuname + 7);
  297.           pixmap_create_by_num(builtin_num, pixmap, mask);
  298. ***************
  299. *** 549,565 ****
  300.       gtk_form_move_resize(GTK_FORM(gui.formwin), gui.drawarea, x, y, w, h);
  301.   }
  302.   
  303. - #if 0
  304. - /*
  305. -  * Nothing to be done here, since we have started to manage our windows with
  306. -  * abstract management widgets, which is much better in fact.
  307. -  */
  308. - /*ARGSUSED*/
  309. - void
  310. - gui_mch_set_menu_pos(int x, int y, int w, int h)
  311. - {
  312. - }
  313. - #endif
  314.   
  315.   #if defined(WANT_MENU) || defined(PROTO)
  316.   /*
  317. --- 552,557 ----
  318. ***************
  319. *** 571,577 ****
  320.   {
  321.   #if 0
  322.       VimMenu *menu;
  323. !     /*  FIXME: imeplemnt this later */
  324.       for (menu = root_menu; menu != NULL; menu = menu->next)
  325.       if (menu->id != 0)
  326.           XtVaSetValues(menu->id,
  327. --- 563,569 ----
  328.   {
  329.   #if 0
  330.       VimMenu *menu;
  331. !     /*  FIXME: implement this later */
  332.       for (menu = root_menu; menu != NULL; menu = menu->next)
  333.       if (menu->id != 0)
  334.           XtVaSetValues(menu->id,
  335. ***************
  336. *** 580,600 ****
  337.   #endif
  338.   }
  339.   
  340.   void
  341.   gui_mch_toggle_tearoffs(int enable)
  342.   {
  343. !     gui_mch_recurse_tearoffs(root_menu, enable);
  344.   }
  345.   #endif
  346.   
  347.   
  348.   #ifdef USE_TOOLBAR
  349.   /*
  350. !  * seems like there's a hole in the GTK Toolbar API: there's no provision for
  351. !  * removing an item from the toolbar!
  352.    */
  353.   static void
  354. ! gui_gtk_toolbar_remove_item_by_text(GtkToolbar *tb, const char *text)
  355.   {
  356.       GtkContainer *container;
  357.       GList *childl;
  358. --- 572,615 ----
  359.   #endif
  360.   }
  361.   
  362. + 
  363. + static void
  364. + recurse_tearoffs(VimMenu * menu, int val)
  365. + {
  366. + #ifdef GTK_HAVE_FEATURES_1_1_0
  367. +     while (menu != NULL) {
  368. +     if (!popup_menu(menu->name)) {
  369. +         if (menu->submenu_id != 0) {
  370. +         if (val)
  371. +             gtk_widget_show(menu->tearoff_handle);
  372. +         else
  373. +             gtk_widget_hide(menu->tearoff_handle);
  374. +         }
  375. +         recurse_tearoffs(menu->children, val);
  376. +     }
  377. +     menu = menu->next;
  378. +     }
  379. + #endif
  380. + }
  381. + 
  382. + 
  383.   void
  384.   gui_mch_toggle_tearoffs(int enable)
  385.   {
  386. !     recurse_tearoffs(root_menu, enable);
  387.   }
  388.   #endif
  389.   
  390.   
  391.   #ifdef USE_TOOLBAR
  392. + 
  393.   /*
  394. !  * Seems like there's a hole in the GTK Toolbar API: there's no provision for
  395. !  * removing an item from the toolbar.  Therefore I need to resort to going
  396. !  * really deeply into the internal widget structures.
  397.    */
  398.   static void
  399. ! toolbar_remove_item_by_text(GtkToolbar *tb, const char *text)
  400.   {
  401.       GtkContainer *container;
  402.       GList *childl;
  403. ***************
  404. *** 637,648 ****
  405.   {
  406.   #ifdef USE_TOOLBAR
  407.       if (menu->parent && toolbar_menu(menu->parent->name)) {
  408. ! #if 0
  409. !     /* FIXME: this isn't in GTK yet, but will be.  for now, use the alternative */
  410. !     gtk_toolbar_remove_item(GTK_TOOLBAR(gui.toolbar),
  411. !                 GTK_TOOLBAR_DATA_TEXT, menu->dname);
  412. ! #endif
  413. !     gui_gtk_toolbar_remove_item_by_text(GTK_TOOLBAR(gui.toolbar),
  414.                           (const char *)menu->dname);
  415.       return;
  416.       }
  417. --- 652,658 ----
  418.   {
  419.   #ifdef USE_TOOLBAR
  420.       if (menu->parent && toolbar_menu(menu->parent->name)) {
  421. !     toolbar_remove_item_by_text(GTK_TOOLBAR(gui.toolbar),
  422.                           (const char *)menu->dname);
  423.       return;
  424.       }
  425. ***************
  426. *** 716,724 ****
  427.       value = adjustment->value;
  428.   
  429.       /*
  430. !      * We just ignore the dragging argument, since otherwise
  431. !      * the scrollbar size will not be adjusted properly in
  432. !      * synthetic scrolls.
  433.        */
  434.       gui_drag_scrollbar(sb, value, FALSE);
  435.       if (gtk_main_level() > 0)
  436. --- 726,733 ----
  437.       value = adjustment->value;
  438.   
  439.       /*
  440. !      * We just ignore the dragging argument, since otherwise the scrollbar
  441. !      * size will not be adjusted properly in synthetic scrolls.
  442.        */
  443.       gui_drag_scrollbar(sb, value, FALSE);
  444.       if (gtk_main_level() > 0)
  445. ***************
  446. *** 768,773 ****
  447. --- 777,831 ----
  448.    * Implementation of the file selector related stuff
  449.    */
  450.   
  451. + /*ARGSUSED*/
  452. + static void
  453. + browse_ok_cb(GtkWidget *widget, gpointer cbdata)
  454. + {
  455. +     Gui *vw = (Gui *)cbdata;
  456. + 
  457. +     if (vw->browse_fname != NULL)
  458. +     g_free(vw->browse_fname);
  459. + 
  460. +     vw->browse_fname = (char_u *)g_strdup(gtk_file_selection_get_filename(
  461. +                     GTK_FILE_SELECTION(vw->filedlg)));
  462. +     gtk_widget_hide(vw->filedlg);
  463. +     if (gtk_main_level() > 0)
  464. +     gtk_main_quit();
  465. + }
  466. + 
  467. + /*ARGSUSED*/
  468. + static void
  469. + browse_cancel_cb(GtkWidget *widget, gpointer cbdata)
  470. + {
  471. +     Gui *vw = (Gui *)cbdata;
  472. + 
  473. +     if (vw->browse_fname != NULL)
  474. +     {
  475. +     g_free(vw->browse_fname);
  476. +     vw->browse_fname = NULL;
  477. +     }
  478. +     gtk_widget_hide(vw->filedlg);
  479. +     if (gtk_main_level() > 0)
  480. +     gtk_main_quit();
  481. + }
  482. + 
  483. + /*ARGSUSED*/
  484. + static gboolean
  485. + browse_destroy_cb(GtkWidget * widget)
  486. + {
  487. +     if (gui.browse_fname != NULL)
  488. +     {
  489. +     g_free(gui.browse_fname);
  490. +     gui.browse_fname = NULL;
  491. +     }
  492. +     gui.filedlg = NULL;
  493. + 
  494. +     if (gtk_main_level() > 0)
  495. +     gtk_main_quit();
  496. + 
  497. +     return FALSE;
  498. + }
  499. + 
  500.   /*
  501.    * Put up a file requester.
  502.    * Returns the selected name in allocated memory, or NULL for Cancel.
  503. ***************
  504. *** 793,804 ****
  505.       if (!gui.filedlg)
  506.       {
  507.       gui.filedlg = gtk_file_selection_new((const gchar *)title);
  508. -     fs = GTK_FILE_SELECTION(gui.filedlg);
  509.   #ifdef GTK_HAVE_FEATURES_1_1_4
  510.       gtk_window_set_modal(GTK_WINDOW(gui.filedlg), TRUE);
  511.       gtk_window_set_transient_for(GTK_WINDOW(gui.filedlg),
  512.           GTK_WINDOW(gui.mainwin));
  513.   #endif
  514.       gtk_container_border_width(GTK_CONTAINER(fs), 4);
  515.       gtk_file_selection_hide_fileop_buttons(fs);
  516.   
  517. --- 851,863 ----
  518.       if (!gui.filedlg)
  519.       {
  520.       gui.filedlg = gtk_file_selection_new((const gchar *)title);
  521.   #ifdef GTK_HAVE_FEATURES_1_1_4
  522.       gtk_window_set_modal(GTK_WINDOW(gui.filedlg), TRUE);
  523.       gtk_window_set_transient_for(GTK_WINDOW(gui.filedlg),
  524.           GTK_WINDOW(gui.mainwin));
  525.   #endif
  526. +     fs = GTK_FILE_SELECTION(gui.filedlg);
  527. + 
  528.       gtk_container_border_width(GTK_CONTAINER(fs), 4);
  529.       gtk_file_selection_hide_fileop_buttons(fs);
  530.   
  531. ***************
  532. *** 834,926 ****
  533.       if (gui.browse_fname == NULL)
  534.       return NULL;
  535.       return vim_strsave(gui.browse_fname);
  536. ! } /* gui_mch_browse */
  537.   
  538. ! /*ARGSUSED*/
  539. ! static void
  540. ! browse_ok_cb(GtkWidget *widget, gpointer cbdata)
  541. ! {
  542. !     Gui *vw = (Gui *)cbdata;
  543.   
  544. !     if (vw->browse_fname != NULL)
  545. !     g_free(vw->browse_fname);
  546.   
  547. !     vw->browse_fname = (char_u *)g_strdup(gtk_file_selection_get_filename(
  548. !                     GTK_FILE_SELECTION(vw->filedlg)));
  549. !     gtk_widget_hide(vw->filedlg);
  550. !     if (gtk_main_level() > 0)
  551. !     gtk_main_quit();
  552. ! }
  553.   
  554. ! /*ARGSUSED*/
  555.   static void
  556. ! browse_cancel_cb(GtkWidget *widget, gpointer cbdata)
  557.   {
  558. !     Gui *vw = (Gui *)cbdata;
  559. ! 
  560. !     if (vw->browse_fname != NULL)
  561. !     {
  562. !     g_free(vw->browse_fname);
  563. !     vw->browse_fname = NULL;
  564. !     }
  565. !     gtk_widget_hide(vw->filedlg);
  566. !     if (gtk_main_level() > 0)
  567. !     gtk_main_quit();
  568.   }
  569.   
  570.   /*ARGSUSED*/
  571. ! static gboolean
  572. ! browse_destroy_cb(GtkWidget * widget)
  573.   {
  574. !     if (gui.browse_fname != NULL)
  575. !     {
  576. !     g_free(gui.browse_fname);
  577. !     gui.browse_fname = NULL;
  578. !     }
  579. !     gui.filedlg = NULL;
  580.   
  581. !     /* This is needed to get out of gtk_main? */
  582. !     if (gtk_main_level() > 0)
  583. !     gtk_main_quit();
  584.   
  585. !     return FALSE;
  586.   }
  587.   
  588. - #endif    /* USE_BROWSE */
  589. - 
  590. - #ifdef GUI_DIALOG
  591. - 
  592. - static int dialogStatus;
  593. - static GtkWidget *dialogbb = NULL;
  594. - 
  595.   /* ARGSUSED */
  596.   int
  597. ! gui_mch_dialog(int type,
  598. !            char_u * title,
  599. !            char_u * message,
  600. !            char_u * buttons,
  601. !            int dfltbutton)
  602.   {
  603. !     char_u *buts;
  604. !     char_u *p, *next;
  605.       int butcount;
  606.   
  607. !     GtkWidget *vbox = NULL;
  608. !     GtkWidget *table = NULL;
  609.       GtkWidget *pixmap;
  610. !     GtkWidget *dialogmessage = NULL;
  611. !     GtkWidget *action_area = NULL;
  612. !     GtkWidget *separator = NULL;
  613.   
  614.       GdkPixmap *icon = NULL;
  615.       GdkBitmap *mask = NULL;
  616.       char **icon_data = NULL;
  617.   
  618.   #define MAXBUT 10
  619. !     GtkWidget *dialogButton[MAXBUT];
  620.   
  621.       if (title == NULL)
  622. !     title = (char_u *) "Vim dialog";
  623.   
  624.       if ((type < 0) || (type > VIM_LAST_TYPE))
  625.       type = VIM_GENERIC;
  626. --- 893,975 ----
  627.       if (gui.browse_fname == NULL)
  628.       return NULL;
  629.       return vim_strsave(gui.browse_fname);
  630. ! }
  631.   
  632. ! #endif    /* USE_BROWSE */
  633.   
  634. ! #ifdef GUI_DIALOG
  635.   
  636. ! typedef struct _ButtonData {
  637. !     int           *status;
  638. !     int           index;
  639. !     GtkWidget  *dialog;
  640. ! } ButtonData;
  641. ! 
  642. ! typedef struct _CancelData {
  643. !     int          *status;
  644. !     GtkWidget *dialog;
  645. ! } CancelData;
  646.   
  647. ! /* ARGSUSED */
  648.   static void
  649. ! dlg_button_clicked(GtkWidget * widget, ButtonData *data)
  650.   {
  651. !     *(data->status) = data->index + 1;
  652. !     gtk_widget_destroy(data->dialog);
  653.   }
  654.   
  655. + /*
  656. +  * This makes the Escape key equivalent to the cancel button.
  657. +  */
  658. + 
  659.   /*ARGSUSED*/
  660. ! static int
  661. ! dlg_key_press_event(GtkWidget * widget, GdkEventKey * event, CancelData *data)
  662.   {
  663. !     if (event->keyval != GDK_Escape)
  664. !     return FALSE;
  665.   
  666. !     /* The result value of 0 from a dialog is signaling cancelation. */
  667. !     *(data->status) = 0;
  668. !     gtk_widget_destroy(data->dialog);
  669.   
  670. !     return TRUE;
  671.   }
  672.   
  673.   /* ARGSUSED */
  674.   int
  675. ! gui_mch_dialog(int type,        /* type of dialog */
  676. !            char_u * title,        /* title of dialog */
  677. !            char_u * message,    /* message text */
  678. !            char_u * buttons,    /* names of buttons */
  679. !            int def_but)        /* default button */
  680.   {
  681. !     char_u *names;
  682. !     char_u *p;
  683.       int butcount;
  684. +     int dialog_status = -1;
  685.   
  686. !     GtkWidget *dialog;
  687. !     GtkWidget *frame;
  688. !     GtkWidget *vbox;
  689. !     GtkWidget *table;
  690.       GtkWidget *pixmap;
  691. !     GtkWidget *dialogmessage;
  692. !     GtkWidget *action_area;
  693. !     GtkWidget *sub_area;
  694. !     GtkWidget *separator;
  695.   
  696.       GdkPixmap *icon = NULL;
  697.       GdkBitmap *mask = NULL;
  698.       char **icon_data = NULL;
  699.   
  700.   #define MAXBUT 10
  701. !     GtkWidget *button[MAXBUT];
  702. !     ButtonData data[MAXBUT];
  703. !     CancelData cancel_data;
  704.   
  705.       if (title == NULL)
  706. !     title = (char_u *) "Vim dialog...";
  707.   
  708.       if ((type < 0) || (type > VIM_LAST_TYPE))
  709.       type = VIM_GENERIC;
  710. ***************
  711. *** 928,943 ****
  712.       /* if our pointer is currently hidden, then we should show it. */
  713.       gui_mch_mousehide(FALSE);
  714.   
  715. !     dialogbb = gtk_window_new(GTK_WINDOW_DIALOG);
  716. !     gtk_window_set_title(GTK_WINDOW(dialogbb), (const gchar *)title);
  717. !     gtk_window_position(GTK_WINDOW(dialogbb), GTK_WIN_POS_MOUSE);
  718.   #ifdef GTK_HAVE_FEATURES_1_1_4
  719. !     gtk_window_set_transient_for(GTK_WINDOW(dialogbb), GTK_WINDOW(gui.mainwin));
  720.   #endif
  721. !     gtk_grab_add(dialogbb);
  722.   
  723.       vbox = gtk_vbox_new(FALSE, 0);
  724. !     gtk_container_add(GTK_CONTAINER(dialogbb), vbox);
  725.       gtk_widget_show(vbox);
  726.   
  727.       table = gtk_table_new(1, 3, FALSE);
  728. --- 977,1007 ----
  729.       /* if our pointer is currently hidden, then we should show it. */
  730.       gui_mch_mousehide(FALSE);
  731.   
  732. !     dialog = gtk_window_new(GTK_WINDOW_DIALOG);
  733. !     gtk_window_set_title(GTK_WINDOW(dialog), (const gchar *)title);
  734. !     gtk_window_position(GTK_WINDOW(dialog), GTK_WIN_POS_MOUSE);
  735.   #ifdef GTK_HAVE_FEATURES_1_1_4
  736. !     gtk_window_set_transient_for(GTK_WINDOW(dialog), GTK_WINDOW(gui.mainwin));
  737.   #endif
  738. !     gtk_widget_realize(dialog);
  739. !     gdk_window_set_decorations(dialog->window, GDK_DECOR_BORDER);
  740. !     gdk_window_set_functions(dialog->window, GDK_FUNC_MOVE);
  741. ! 
  742. !     cancel_data.status = &dialog_status;
  743. !     cancel_data.dialog = dialog;
  744. !     gtk_signal_connect_after(GTK_OBJECT(dialog), "key_press_event",
  745. !             GTK_SIGNAL_FUNC(dlg_key_press_event),
  746. !             (gpointer) &cancel_data);
  747. ! 
  748. !     gtk_grab_add(dialog);
  749. ! 
  750. !     /* this makes it look beter on Motif style window managers */
  751. !     frame = gtk_frame_new(NULL);
  752. !     gtk_container_add(GTK_CONTAINER(dialog), frame);
  753. !     gtk_widget_show(frame);
  754.   
  755.       vbox = gtk_vbox_new(FALSE, 0);
  756. !     gtk_container_add(GTK_CONTAINER(frame), vbox);
  757.       gtk_widget_show(vbox);
  758.   
  759.       table = gtk_table_new(1, 3, FALSE);
  760. ***************
  761. *** 968,974 ****
  762.       icon_data = generic_xpm;
  763.       };
  764.       icon = gdk_pixmap_colormap_create_from_xpm_d(NULL,
  765. !                      gtk_widget_get_colormap(dialogbb),
  766.                        &mask, NULL, icon_data);
  767.       if (icon) {
  768.       pixmap = gtk_pixmap_new(icon, mask);
  769. --- 1032,1038 ----
  770.       icon_data = generic_xpm;
  771.       };
  772.       icon = gdk_pixmap_colormap_create_from_xpm_d(NULL,
  773. !                      gtk_widget_get_colormap(dialog),
  774.                        &mask, NULL, icon_data);
  775.       if (icon) {
  776.       pixmap = gtk_pixmap_new(icon, mask);
  777. ***************
  778. *** 976,1006 ****
  779.       gtk_table_attach_defaults(GTK_TABLE(table), pixmap, 0, 1, 0, 1);
  780.       gtk_widget_show(pixmap);
  781.       }
  782.       /* Add label */
  783.       dialogmessage = gtk_label_new((const gchar *)message);
  784.       gtk_table_attach_defaults(GTK_TABLE(table), dialogmessage, 1, 2, 0, 1);
  785.       gtk_widget_show(dialogmessage);
  786.   
  787. -     /* for some reason this doesn't work properly under kwm */
  788. -     /* gdk_window_set_decorations(dialogbb->window, GDK_DECOR_BORDER);
  789. -      * gdk_window_set_functions(dialogbb->window, 0);
  790. -      */
  791. - 
  792.       action_area = gtk_hbox_new(FALSE, 0);
  793.       gtk_container_border_width(GTK_CONTAINER(action_area), 4);
  794.       gtk_box_pack_end(GTK_BOX(vbox), action_area, FALSE, TRUE, 0);
  795.       gtk_widget_show(action_area);
  796.   
  797.       /* make a copy, so that we can insert NULs */
  798. !     buts = vim_strsave(buttons);
  799. !     if (buts == NULL)
  800.       return -1;
  801.   
  802.       /*
  803.        * Create the buttons.
  804.        */
  805. !     p = buts;
  806.       for (butcount = 0; butcount < MAXBUT; ++butcount) {
  807.       for (next = p; *next; ++next) {
  808.           if (*next == DLG_HOTKEY_CHAR)
  809.           mch_memmove(next, next + 1, STRLEN(next));
  810. --- 1040,1073 ----
  811.       gtk_table_attach_defaults(GTK_TABLE(table), pixmap, 0, 1, 0, 1);
  812.       gtk_widget_show(pixmap);
  813.       }
  814. + 
  815.       /* Add label */
  816.       dialogmessage = gtk_label_new((const gchar *)message);
  817.       gtk_table_attach_defaults(GTK_TABLE(table), dialogmessage, 1, 2, 0, 1);
  818.       gtk_widget_show(dialogmessage);
  819.   
  820.       action_area = gtk_hbox_new(FALSE, 0);
  821.       gtk_container_border_width(GTK_CONTAINER(action_area), 4);
  822.       gtk_box_pack_end(GTK_BOX(vbox), action_area, FALSE, TRUE, 0);
  823.       gtk_widget_show(action_area);
  824.   
  825. +     sub_area = gtk_hbox_new(TRUE, 0);
  826. +     gtk_container_set_border_width(GTK_CONTAINER(sub_area), 0);
  827. +     gtk_box_pack_start(GTK_BOX(action_area), sub_area, FALSE, TRUE, 0);
  828. +     gtk_widget_show(sub_area);
  829. + 
  830.       /* make a copy, so that we can insert NULs */
  831. !     names = vim_strsave(buttons);
  832. !     if (names == NULL)
  833.       return -1;
  834.   
  835.       /*
  836.        * Create the buttons.
  837.        */
  838. !     p = names;
  839.       for (butcount = 0; butcount < MAXBUT; ++butcount) {
  840. +     char_u *next;
  841. + 
  842.       for (next = p; *next; ++next) {
  843.           if (*next == DLG_HOTKEY_CHAR)
  844.           mch_memmove(next, next + 1, STRLEN(next));
  845. ***************
  846. *** 1010,1066 ****
  847.           }
  848.       }
  849.   
  850. !     dialogButton[butcount] = gtk_button_new_with_label((const gchar *)p);
  851. !     GTK_WIDGET_SET_FLAGS(dialogButton[butcount], GTK_CAN_DEFAULT);
  852. !     gtk_widget_show(dialogButton[butcount]);
  853. !     gtk_signal_connect(GTK_OBJECT(dialogButton[butcount]),
  854.                  (const char *)"clicked",
  855. !                GTK_SIGNAL_FUNC(butproc), GINT_TO_POINTER(butcount));
  856.   
  857.       if (*next == NUL) {
  858. !         gtk_box_pack_end(GTK_BOX(action_area), dialogButton[butcount],
  859. !                  FALSE, FALSE, 0);
  860.           break;
  861.       } else {
  862. !         gtk_box_pack_start(GTK_BOX(action_area), dialogButton[butcount],
  863. !                    FALSE, FALSE, 0);
  864.       }
  865.       p = next;
  866.       }
  867. !     ++butcount;
  868. !     vim_free(buts);
  869. !     if (dfltbutton < 1)
  870. !     dfltbutton = 1;
  871. !     if (dfltbutton > butcount)
  872. !     dfltbutton = butcount;
  873. !     /* XtVaSetValues(dialogbb, XmNdefaultButton, dialogButton[dfltbutton - 1], NULL); */
  874.   
  875. !     gtk_widget_grab_focus(dialogButton[dfltbutton - 1]);
  876. !     gtk_widget_grab_default(dialogButton[dfltbutton - 1]);
  877.   
  878.       separator = gtk_hseparator_new();
  879.       gtk_box_pack_end(GTK_BOX(vbox), separator, FALSE, TRUE, 0);
  880.       gtk_widget_show(separator);
  881.   
  882. !     dialogStatus = -1;
  883. !     gtk_widget_show(dialogbb);
  884. !     while (dialogbb)    /* stay here until dialog goes away */
  885.       gtk_main_iteration_do(TRUE);
  886.   
  887. !     return dialogStatus;
  888.   }
  889.   
  890. - /* ARGSUSED */
  891. - static void
  892. - butproc(GtkWidget * widget, gpointer data)
  893. - {
  894. -     dialogStatus = (GPOINTER_TO_INT(data)) + 1;
  895. - 
  896. -     gtk_widget_destroy(dialogbb);
  897. -     dialogbb = NULL;
  898. -     if (gtk_main_level() > 0)
  899. -     gtk_main_quit();
  900. - }
  901.   
  902.   #endif    /* GUI_DIALOG */
  903.   
  904. --- 1077,1131 ----
  905.           }
  906.       }
  907.   
  908. !     button[butcount] = gtk_button_new_with_label((const gchar *)p);
  909. !     GTK_WIDGET_SET_FLAGS(button[butcount], GTK_CAN_DEFAULT);
  910. !     gtk_widget_show(button[butcount]);
  911. ! 
  912. !     data[butcount].status = &dialog_status;
  913. !     data[butcount].index = butcount;
  914. !     data[butcount].dialog = dialog;
  915. !     gtk_signal_connect(GTK_OBJECT(button[butcount]),
  916.                  (const char *)"clicked",
  917. !                GTK_SIGNAL_FUNC(dlg_button_clicked),
  918. !                (gpointer) &data[butcount]);
  919.   
  920.       if (*next == NUL) {
  921. !         gtk_box_pack_end(GTK_BOX(action_area), button[butcount],
  922. !                  FALSE, TRUE, 0);
  923.           break;
  924.       } else {
  925. !         gtk_box_pack_start(GTK_BOX(sub_area), button[butcount],
  926. !                    TRUE, TRUE, 0);
  927.       }
  928.       p = next;
  929.       }
  930. !     vim_free(names);
  931. ! 
  932. !     --def_but;        /* 1 is first button */
  933. !     if (def_but < 0)
  934. !     def_but = 0;
  935. !     if (def_but > butcount)
  936. !     def_but = butcount;
  937.   
  938. !     gtk_widget_grab_focus(button[def_but]);
  939. !     gtk_widget_grab_default(button[def_but]);
  940.   
  941.       separator = gtk_hseparator_new();
  942.       gtk_box_pack_end(GTK_BOX(vbox), separator, FALSE, TRUE, 0);
  943.       gtk_widget_show(separator);
  944.   
  945. !     dialog_status = -1;
  946. !     gtk_widget_show(dialog);
  947. ! 
  948. !     /* loop here until the dialog goes away */
  949. !     while (dialog_status == -1 && GTK_WIDGET_VISIBLE(dialog))
  950.       gtk_main_iteration_do(TRUE);
  951.   
  952. !     if (dialog_status < 0)
  953. !     dialog_status = 0;
  954. !     return dialog_status;
  955.   }
  956.   
  957.   
  958.   #endif    /* GUI_DIALOG */
  959.   
  960. ***************
  961. *** 1069,1081 ****
  962.   gui_mch_show_popupmenu(VimMenu * menu)
  963.   {
  964.       gtk_menu_popup(GTK_MENU(menu->submenu_id),
  965. !            NULL, NULL, NULL, NULL, 3, GDK_CURRENT_TIME);
  966.   }
  967.   #endif
  968.   
  969.   
  970.   /*
  971. !  * Don't create it twice!
  972.    */
  973.   
  974.   typedef struct _SharedFindReplace {
  975. --- 1134,1146 ----
  976.   gui_mch_show_popupmenu(VimMenu * menu)
  977.   {
  978.       gtk_menu_popup(GTK_MENU(menu->submenu_id),
  979. !            NULL, NULL, NULL, NULL, 3, (guint32)GDK_CURRENT_TIME);
  980.   }
  981.   #endif
  982.   
  983.   
  984.   /*
  985. !  * We don't create it twice.
  986.    */
  987.   
  988.   typedef struct _SharedFindReplace {
  989. ***************
  990. *** 1090,1165 ****
  991.       GtkWidget *all;    /* 'Replace All' action button */
  992.   } SharedFindReplace;
  993.   
  994. ! static SharedFindReplace find_widgets;
  995. ! static SharedFindReplace repl_widgets;
  996. ! 
  997.   
  998. ! /*ARGSUSED*/
  999. ! void
  1000. ! gui_mch_find_dialog(char_u * arg)
  1001.   {
  1002. !     find_replace_dialog_create(FALSE);
  1003. ! }
  1004. ! 
  1005.   
  1006. ! /*ARGSUSED*/
  1007. ! void
  1008. ! gui_mch_replace_dialog(char_u * arg)
  1009. ! {
  1010. !     find_replace_dialog_create(TRUE);
  1011. ! }
  1012.   
  1013.   
  1014. ! /*
  1015. !  * Synchronize all gui elements, which are dependant upon the
  1016. !  * main text font used. Those are in esp. the find/replace dialogs.
  1017. !  * If You don't understand why this should be needed, please try to
  1018. !  * search for "piΩ╢µ" in iso8859-2.
  1019. !  */
  1020. ! void gui_gtk_synch_fonts(void)
  1021. ! {
  1022. !     SharedFindReplace *frdp;
  1023. !     int do_replace;
  1024.   
  1025. !     /* OK this loop is a bit tricky... */
  1026. !     for (do_replace = 0; do_replace <= 1; ++do_replace) {
  1027. !     frdp = (do_replace) ? (&repl_widgets) : (&find_widgets);
  1028. !     if (frdp->dialog) {
  1029. !         GtkStyle *style;
  1030.   
  1031. !         /* synch the font with whats used by the text itself */
  1032. !         style = gtk_style_copy(gtk_widget_get_style(frdp->what));
  1033. !         gdk_font_unref(style->font);
  1034. !         style->font = gui.norm_font;
  1035. !         gdk_font_ref(style->font);
  1036. !         gtk_widget_set_style(frdp->what, style);
  1037. !         gtk_style_unref(style);
  1038. !         if (do_replace) {
  1039. !         style = gtk_style_copy(gtk_widget_get_style(frdp->with));
  1040. !         gdk_font_unref(style->font);
  1041. !         style->font = gui.norm_font;
  1042. !         gdk_font_ref(style->font);
  1043. !         gtk_widget_set_style(frdp->with, style);
  1044. !         gtk_style_unref(style);
  1045. !         }
  1046. !     }
  1047. !     }
  1048.   }
  1049.   
  1050.   static void
  1051. ! find_replace_dialog_create(int do_replace)
  1052.   {
  1053. !     GtkWidget *hbox;        /* main top down box */
  1054. !     GtkWidget *actionarea;
  1055. !     GtkWidget *table;
  1056. !     GtkWidget *tmp;
  1057. !     GtkWidget *vbox;
  1058. !     gboolean sensitive;
  1059.       SharedFindReplace *frdp;
  1060. !     char *entry_text;
  1061.   
  1062.       frdp = (do_replace) ? (&repl_widgets) : (&find_widgets);
  1063.   
  1064.       if (frdp->dialog) {
  1065.       gui_gtk_synch_fonts();
  1066.       if (!GTK_WIDGET_VISIBLE(frdp->dialog)) {
  1067. --- 1155,1238 ----
  1068.       GtkWidget *all;    /* 'Replace All' action button */
  1069.   } SharedFindReplace;
  1070.   
  1071. ! static SharedFindReplace find_widgets = { NULL };
  1072. ! static SharedFindReplace repl_widgets = { NULL };
  1073.   
  1074. ! /* ARGSUSED */
  1075. ! static int
  1076. ! find_key_press_event(GtkWidget * widget,
  1077. !     GdkEventKey * event,
  1078. !     SharedFindReplace * frdp)
  1079.   {
  1080. !     /* If the user is holding one of the key modifiers we will just bail out,
  1081. !      * thus preserving the possibility of normal focus traversal.
  1082. !      */
  1083. !     if (event->state & (GDK_CONTROL_MASK | GDK_SHIFT_MASK))
  1084. !     return FALSE;
  1085.   
  1086. !     /* the scape key synthesizes a cancellation action */
  1087. !     if (event->keyval == GDK_Escape) {
  1088. !     find_replace_cb(widget, FR_DIALOGTERM);
  1089. !     gtk_widget_hide(frdp->dialog);
  1090.   
  1091. +     return TRUE;
  1092. +     }
  1093.   
  1094. !     /* block traversal resulting from those keys */
  1095. !     if (event->keyval == GDK_Left || event->keyval == GDK_Right)
  1096. !     return TRUE;
  1097.   
  1098. !     /* It would be delightfull if it where possible to do search history
  1099. !      * operations on the K_UP and K_DOWN keys here.
  1100. !      */
  1101.   
  1102. !     return FALSE;
  1103.   }
  1104.   
  1105.   static void
  1106. ! find_replace_dialog_create(char_u *arg, int do_replace)
  1107.   {
  1108. !     GtkWidget    *frame;
  1109. !     GtkWidget    *hbox;        /* main top down box */
  1110. !     GtkWidget    *actionarea;
  1111. !     GtkWidget    *table;
  1112. !     GtkWidget    *tmp;
  1113. !     GtkWidget    *vbox;
  1114. !     gboolean    sensitive;
  1115.       SharedFindReplace *frdp;
  1116. !     char_u    *entry_text = arg;
  1117. !     gboolean    exact_word = FALSE;
  1118.   
  1119.       frdp = (do_replace) ? (&repl_widgets) : (&find_widgets);
  1120.   
  1121. +     /*
  1122. +      * If the argument is emtpy, get the last used search pattern.  If it is
  1123. +      * surrounded by "\<..\>" remove that and set the "exact_word" toggle
  1124. +      * button.
  1125. +      */
  1126. +     if (*entry_text == NUL)
  1127. +     entry_text = last_search_pat();
  1128. +     if (entry_text != NULL)
  1129. +     {
  1130. +     entry_text = vim_strsave(entry_text);
  1131. +     if (entry_text != NULL)
  1132. +     {
  1133. +         int len = STRLEN(entry_text);
  1134. + 
  1135. +         if (len >= 4
  1136. +             && STRNCMP(entry_text, "\\<", 2) == 0
  1137. +             && STRNCMP(entry_text + len - 2, "\\>", 2) == 0)
  1138. +         {
  1139. +         exact_word = TRUE;
  1140. +         mch_memmove(entry_text, entry_text + 2, (size_t)(len - 4));
  1141. +         entry_text[len - 4] = NUL;
  1142. +         }
  1143. +     }
  1144. +     }
  1145. + 
  1146. +     /*
  1147. +      * If the dialog already exists, just raise it.
  1148. +      */
  1149.       if (frdp->dialog) {
  1150.       gui_gtk_synch_fonts();
  1151.       if (!GTK_WIDGET_VISIBLE(frdp->dialog)) {
  1152. ***************
  1153. *** 1167,1174 ****
  1154. --- 1240,1254 ----
  1155.           gtk_widget_show(frdp->dialog);
  1156.       }
  1157.   
  1158. +     if (entry_text != NULL)
  1159. +     {
  1160. +         gtk_entry_set_text(GTK_ENTRY(frdp->what), (char *)entry_text);
  1161. +         gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(frdp->exact),
  1162. +                                   exact_word);
  1163. +     }
  1164.       gdk_window_raise(frdp->dialog->window);
  1165.   
  1166. +     vim_free(entry_text);
  1167.       return;
  1168.       }
  1169.   
  1170. ***************
  1171. *** 1182,1190 ****
  1172.       }
  1173.   
  1174.       gtk_window_position(GTK_WINDOW(frdp->dialog), GTK_WIN_POS_MOUSE);
  1175.   
  1176.       hbox = gtk_hbox_new(FALSE, 0);
  1177. !     gtk_container_add(GTK_CONTAINER(frdp->dialog), hbox);
  1178.   
  1179.       if (do_replace)
  1180.       table = gtk_table_new(1024, 4, FALSE);
  1181. --- 1262,1279 ----
  1182.       }
  1183.   
  1184.       gtk_window_position(GTK_WINDOW(frdp->dialog), GTK_WIN_POS_MOUSE);
  1185. +     gtk_widget_realize(frdp->dialog);
  1186. +     gdk_window_set_decorations(frdp->dialog->window,
  1187. +         GDK_DECOR_TITLE | GDK_DECOR_BORDER | GDK_DECOR_RESIZEH);
  1188. +     gdk_window_set_functions(frdp->dialog->window,
  1189. +         GDK_FUNC_RESIZE | GDK_FUNC_MOVE);
  1190. + 
  1191. +     /* this makes it look beter on Motif style window managers */
  1192. +     frame = gtk_frame_new(NULL);
  1193. +     gtk_container_add(GTK_CONTAINER(frdp->dialog), frame);
  1194.   
  1195.       hbox = gtk_hbox_new(FALSE, 0);
  1196. !     gtk_container_add(GTK_CONTAINER(frame), hbox);
  1197.   
  1198.       if (do_replace)
  1199.       table = gtk_table_new(1024, 4, FALSE);
  1200. ***************
  1201. *** 1198,1208 ****
  1202.       gtk_table_attach(GTK_TABLE(table), tmp, 0, 1, 0, 1,
  1203.                GTK_FILL, GTK_EXPAND, 2, 2);
  1204.       frdp->what = gtk_entry_new();
  1205. !     entry_text = gtk_entry_get_text(GTK_ENTRY(frdp->what));
  1206. !     sensitive = (strlen(entry_text) != 0);
  1207. !     gtk_entry_set_text(GTK_ENTRY(frdp->what), entry_text);
  1208.       gtk_signal_connect(GTK_OBJECT(frdp->what), "changed",
  1209.                  GTK_SIGNAL_FUNC(entry_changed_cb), frdp->dialog);
  1210.       gtk_table_attach(GTK_TABLE(table), frdp->what, 1, 1024, 0, 1,
  1211.                GTK_EXPAND | GTK_FILL, GTK_EXPAND, 2, 2);
  1212.   
  1213. --- 1287,1300 ----
  1214.       gtk_table_attach(GTK_TABLE(table), tmp, 0, 1, 0, 1,
  1215.                GTK_FILL, GTK_EXPAND, 2, 2);
  1216.       frdp->what = gtk_entry_new();
  1217. !     sensitive = (entry_text != NULL && STRLEN(entry_text) != 0);
  1218. !     if (entry_text != NULL)
  1219. !     gtk_entry_set_text(GTK_ENTRY(frdp->what), (char *)entry_text);
  1220.       gtk_signal_connect(GTK_OBJECT(frdp->what), "changed",
  1221.                  GTK_SIGNAL_FUNC(entry_changed_cb), frdp->dialog);
  1222. +     gtk_signal_connect_after(GTK_OBJECT(frdp->what), "key_press_event",
  1223. +                  GTK_SIGNAL_FUNC(find_key_press_event),
  1224. +                  (gpointer) frdp);
  1225.       gtk_table_attach(GTK_TABLE(table), frdp->what, 1, 1024, 0, 1,
  1226.                GTK_EXPAND | GTK_FILL, GTK_EXPAND, 2, 2);
  1227.   
  1228. ***************
  1229. *** 1215,1220 ****
  1230. --- 1307,1315 ----
  1231.       gtk_signal_connect(GTK_OBJECT(frdp->with), "activate",
  1232.                  GTK_SIGNAL_FUNC(find_replace_cb),
  1233.                  (gpointer) FR_R_FINDNEXT);
  1234. +     gtk_signal_connect_after(GTK_OBJECT(frdp->with), "key_press_event",
  1235. +                  GTK_SIGNAL_FUNC(find_key_press_event),
  1236. +                  (gpointer) frdp);
  1237.       gtk_table_attach(GTK_TABLE(table), frdp->with, 1, 1024, 1, 2,
  1238.                GTK_EXPAND | GTK_FILL, GTK_EXPAND, 2, 2);
  1239.   
  1240. ***************
  1241. *** 1235,1241 ****
  1242.   
  1243.       /* exact match only button */
  1244.       frdp->exact = gtk_check_button_new_with_label("Match exact word only");
  1245. !     gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(frdp->exact), FALSE);
  1246.       gtk_signal_connect(GTK_OBJECT(frdp->exact), "clicked",
  1247.                  GTK_SIGNAL_FUNC(exact_match_cb), NULL);
  1248.       if (do_replace)
  1249. --- 1330,1336 ----
  1250.   
  1251.       /* exact match only button */
  1252.       frdp->exact = gtk_check_button_new_with_label("Match exact word only");
  1253. !     gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(frdp->exact), exact_word);
  1254.       gtk_signal_connect(GTK_OBJECT(frdp->exact), "clicked",
  1255.                  GTK_SIGNAL_FUNC(exact_match_cb), NULL);
  1256.       if (do_replace)
  1257. ***************
  1258. *** 1256,1262 ****
  1259.       gtk_container_border_width(GTK_CONTAINER(vbox), 0);
  1260.       gtk_container_add(GTK_CONTAINER(tmp), vbox);
  1261.   
  1262. !     /* 'up' and 'down' buttons */
  1263.       frdp->up = gtk_radio_button_new_with_label(NULL, "Up");
  1264.       gtk_box_pack_start(GTK_BOX(vbox), frdp->up, TRUE, TRUE, 0);
  1265.       frdp->down = gtk_radio_button_new_with_label(
  1266. --- 1351,1357 ----
  1267.       gtk_container_border_width(GTK_CONTAINER(vbox), 0);
  1268.       gtk_container_add(GTK_CONTAINER(tmp), vbox);
  1269.   
  1270. !     /* 'Up' and 'Down' buttons */
  1271.       frdp->up = gtk_radio_button_new_with_label(NULL, "Up");
  1272.       gtk_box_pack_start(GTK_BOX(vbox), frdp->up, TRUE, TRUE, 0);
  1273.       frdp->down = gtk_radio_button_new_with_label(
  1274. ***************
  1275. *** 1281,1287 ****
  1276.       }
  1277.       gtk_box_pack_end(GTK_BOX(hbox), actionarea, FALSE, FALSE, 0);
  1278.   
  1279. !     /* 'find next' button */
  1280.       frdp->find = gtk_button_new_with_label("Find Next");
  1281.       gtk_widget_set_sensitive(frdp->find, sensitive);
  1282.       if (do_replace)
  1283. --- 1376,1382 ----
  1284.       }
  1285.       gtk_box_pack_end(GTK_BOX(hbox), actionarea, FALSE, FALSE, 0);
  1286.   
  1287. !     /* 'Find Next' button */
  1288.       frdp->find = gtk_button_new_with_label("Find Next");
  1289.       gtk_widget_set_sensitive(frdp->find, sensitive);
  1290.       if (do_replace)
  1291. ***************
  1292. *** 1297,1303 ****
  1293.       gtk_widget_grab_default(frdp->find);
  1294.   
  1295.       if (do_replace) {
  1296. !     /* 'replace' button */
  1297.       frdp->replace = gtk_button_new_with_label("Replace");
  1298.       gtk_widget_set_sensitive(frdp->replace, sensitive);
  1299.       GTK_WIDGET_SET_FLAGS(frdp->replace, GTK_CAN_DEFAULT);
  1300. --- 1392,1398 ----
  1301.       gtk_widget_grab_default(frdp->find);
  1302.   
  1303.       if (do_replace) {
  1304. !     /* 'Replace' button */
  1305.       frdp->replace = gtk_button_new_with_label("Replace");
  1306.       gtk_widget_set_sensitive(frdp->replace, sensitive);
  1307.       GTK_WIDGET_SET_FLAGS(frdp->replace, GTK_CAN_DEFAULT);
  1308. ***************
  1309. *** 1306,1312 ****
  1310.                  GTK_SIGNAL_FUNC(find_replace_cb),
  1311.                  (gpointer) FR_REPLACE);
  1312.   
  1313. !     /* 'replace all' button */
  1314.       frdp->all = gtk_button_new_with_label("Replace All");
  1315.       gtk_widget_set_sensitive(frdp->all, sensitive);
  1316.       GTK_WIDGET_SET_FLAGS(frdp->all, GTK_CAN_DEFAULT);
  1317. --- 1401,1407 ----
  1318.                  GTK_SIGNAL_FUNC(find_replace_cb),
  1319.                  (gpointer) FR_REPLACE);
  1320.   
  1321. !     /* 'Replace All' button */
  1322.       frdp->all = gtk_button_new_with_label("Replace All");
  1323.       gtk_widget_set_sensitive(frdp->all, sensitive);
  1324.       GTK_WIDGET_SET_FLAGS(frdp->all, GTK_CAN_DEFAULT);
  1325. ***************
  1326. *** 1316,1322 ****
  1327.                  (gpointer) FR_REPLACEALL);
  1328.       }
  1329.   
  1330. !     /* 'cancel' button */
  1331.       tmp = gtk_button_new_with_label("Cancel");
  1332.       GTK_WIDGET_SET_FLAGS(tmp, GTK_CAN_DEFAULT);
  1333.       gtk_box_pack_end(GTK_BOX(actionarea), tmp, FALSE, FALSE, 0);
  1334. --- 1411,1417 ----
  1335.                  (gpointer) FR_REPLACEALL);
  1336.       }
  1337.   
  1338. !     /* 'Cancel' button */
  1339.       tmp = gtk_button_new_with_label("Cancel");
  1340.       GTK_WIDGET_SET_FLAGS(tmp, GTK_CAN_DEFAULT);
  1341.       gtk_box_pack_end(GTK_BOX(actionarea), tmp, FALSE, FALSE, 0);
  1342. ***************
  1343. *** 1340,1350 ****
  1344.       gui_gtk_synch_fonts();
  1345.   
  1346.       gtk_widget_show_all(frdp->dialog);
  1347.   }
  1348.   
  1349.   /*
  1350.    * Convenience function.
  1351. !  * creates a button with a label, and packs it into the box specified by the
  1352.    * parameter 'parent'.
  1353.    */
  1354.   GtkWidget *
  1355. --- 1435,1499 ----
  1356.       gui_gtk_synch_fonts();
  1357.   
  1358.       gtk_widget_show_all(frdp->dialog);
  1359. + 
  1360. +     vim_free(entry_text);
  1361. + }
  1362. + 
  1363. + void
  1364. + gui_mch_find_dialog(char_u * arg)
  1365. + {
  1366. +     find_replace_dialog_create(arg, FALSE);
  1367. + }
  1368. + 
  1369. + 
  1370. + void
  1371. + gui_mch_replace_dialog(char_u * arg)
  1372. + {
  1373. +     find_replace_dialog_create(arg, TRUE);
  1374. + }
  1375. + 
  1376. + 
  1377. + /*
  1378. +  * Synchronize all gui elements, which are dependant upon the
  1379. +  * main text font used. Those are in esp. the find/replace dialogs.
  1380. +  * If You don't understand why this should be needed, please try to
  1381. +  * search for "piΩ╢µ" in iso8859-2.
  1382. +  */
  1383. + void
  1384. + gui_gtk_synch_fonts(void)
  1385. + {
  1386. +     SharedFindReplace *frdp;
  1387. +     int do_replace;
  1388. + 
  1389. +     /* OK this loop is a bit tricky... */
  1390. +     for (do_replace = 0; do_replace <= 1; ++do_replace) {
  1391. +     frdp = (do_replace) ? (&repl_widgets) : (&find_widgets);
  1392. +     if (frdp->dialog) {
  1393. +         GtkStyle *style;
  1394. + 
  1395. +         /* synch the font with whats used by the text itself */
  1396. +         style = gtk_style_copy(gtk_widget_get_style(frdp->what));
  1397. +         gdk_font_unref(style->font);
  1398. +         style->font = gui.norm_font;
  1399. +         gdk_font_ref(style->font);
  1400. +         gtk_widget_set_style(frdp->what, style);
  1401. +         gtk_style_unref(style);
  1402. +         if (do_replace) {
  1403. +         style = gtk_style_copy(gtk_widget_get_style(frdp->with));
  1404. +         gdk_font_unref(style->font);
  1405. +         style->font = gui.norm_font;
  1406. +         gdk_font_ref(style->font);
  1407. +         gtk_widget_set_style(frdp->with, style);
  1408. +         gtk_style_unref(style);
  1409. +         }
  1410. +     }
  1411. +     }
  1412.   }
  1413.   
  1414. + 
  1415.   /*
  1416.    * Convenience function.
  1417. !  * Creates a button with a label, and packs it into the box specified by the
  1418.    * parameter 'parent'.
  1419.    */
  1420.   GtkWidget *
  1421. ***************
  1422. *** 1355,1362 ****
  1423.       GtkWidget *parent,
  1424.       int connect_object,
  1425.       gboolean expand,
  1426. !     gboolean fill
  1427. !     )
  1428.   {
  1429.       GtkWidget *tmp;
  1430.   
  1431. --- 1504,1510 ----
  1432.       GtkWidget *parent,
  1433.       int connect_object,
  1434.       gboolean expand,
  1435. !     gboolean fill)
  1436.   {
  1437.       GtkWidget *tmp;
  1438.   
  1439. ***************
  1440. *** 1374,1418 ****
  1441.   
  1442.   /*** private function definitions ***/
  1443.   
  1444. - #ifdef WANT_MENU
  1445. - static void
  1446. - gui_mch_recurse_tearoffs(VimMenu * menu, int val)
  1447. - {
  1448. - #ifdef GTK_HAVE_FEATURES_1_1_0
  1449. -     while (menu != NULL) {
  1450. -     if (!popup_menu(menu->name)) {
  1451. -         if (menu->submenu_id != 0) {
  1452. -         if (val)
  1453. -             gtk_widget_show(menu->tearoff_handle);
  1454. -         else
  1455. -             gtk_widget_hide(menu->tearoff_handle);
  1456. -         }
  1457. -         gui_mch_recurse_tearoffs(menu->children, val);
  1458. -     }
  1459. -     menu = menu->next;
  1460. -     }
  1461. - #endif
  1462. - }
  1463. - 
  1464. - /*ARGSUSED*/
  1465. - static void
  1466. - menu_item_cb(GtkWidget * widget, gpointer data)
  1467. - {
  1468. -     gui_menu_cb((VimMenu *) data);
  1469. - 
  1470. -     /* make sure the menu action is taken immediately */
  1471. -     if (gtk_main_level() > 0)
  1472. -     gtk_main_quit();
  1473. - }
  1474. - #endif
  1475. - 
  1476. - 
  1477.   /*
  1478.    * Callback for actions of the find and replace dialogs
  1479.    */
  1480.   /*ARGSUSED*/
  1481.   static void
  1482. ! find_replace_cb(GtkWidget * widget, gint flags)
  1483.   {
  1484.       char *find_text, *repl_text, *cmd;
  1485.       gboolean direction_down = TRUE;
  1486. --- 1522,1533 ----
  1487.   
  1488.   /*** private function definitions ***/
  1489.   
  1490.   /*
  1491.    * Callback for actions of the find and replace dialogs
  1492.    */
  1493.   /*ARGSUSED*/
  1494.   static void
  1495. ! find_replace_cb(GtkWidget * widget, unsigned int flags)
  1496.   {
  1497.       char *find_text, *repl_text, *cmd;
  1498.       gboolean direction_down = TRUE;
  1499. ***************
  1500. *** 1519,1525 ****
  1501.       }
  1502.   
  1503.       g_free(cmd);
  1504. ! } /* find_replace_cb */
  1505.   
  1506.   /* our usual callback function */
  1507.   /*ARGSUSED*/
  1508. --- 1634,1640 ----
  1509.       }
  1510.   
  1511.       g_free(cmd);
  1512. ! }
  1513.   
  1514.   /* our usual callback function */
  1515.   /*ARGSUSED*/
  1516. ***************
  1517. *** 1615,1631 ****
  1518.       }
  1519.   }
  1520.   
  1521. ! 
  1522. ! static void helpfind_ok(GtkWidget *wgt, gpointer cbdata);
  1523. ! static void helpfind_entry_changed(GtkWidget *entry, gpointer cbdata);
  1524.   
  1525.   static GtkWidget *helpfind = NULL;
  1526.   static GtkWidget *help_entry = NULL;
  1527.   
  1528. !     void
  1529. ! do_helpfind()
  1530.   {
  1531. !     GtkWidget *vbox, *hbox, *tmp;
  1532.   
  1533.       if (!gui.in_use)
  1534.       {
  1535. --- 1730,1808 ----
  1536.       }
  1537.   }
  1538.   
  1539. ! /*
  1540. !  * Handling of the nice additional asynchronous little help topic requester.
  1541. !  */
  1542.   
  1543.   static GtkWidget *helpfind = NULL;
  1544.   static GtkWidget *help_entry = NULL;
  1545. + static int     help_ok_sensitive = FALSE;
  1546.   
  1547. !     static void
  1548. ! helpfind_entry_changed(GtkWidget *entry, gpointer cbdata)
  1549.   {
  1550. !     GtkWidget *ok = (GtkWidget *)cbdata;
  1551. !     char *txt = gtk_entry_get_text(GTK_ENTRY(entry));
  1552. ! 
  1553. !     if (txt == NULL || *txt == NUL)
  1554. !     return;
  1555. ! 
  1556. !     gtk_widget_set_sensitive(ok, strlen(txt));
  1557. !     gtk_widget_grab_default(ok);
  1558. !     help_ok_sensitive = TRUE;
  1559. ! }
  1560. ! 
  1561. ! /*ARGSUSED*/
  1562. !     static void
  1563. ! helpfind_ok(GtkWidget *wgt, gpointer cbdata)
  1564. ! {
  1565. !     char *txt, *cmd;
  1566. !     GtkEntry *entry = GTK_ENTRY(cbdata);
  1567. ! 
  1568. !     if ((txt = gtk_entry_get_text(entry)) == NULL)
  1569. !     return;
  1570. ! 
  1571. !     /* When the OK button isn't sensitive, hitting CR means cancel. */
  1572. !     if (help_ok_sensitive)
  1573. !     {
  1574. !     if ((cmd = (char *)alloc(strlen(txt) + 8)) == NULL)
  1575. !         return;
  1576. ! 
  1577. !     /* use CTRL-\ CTRL-N to get Vim into Normal mode first */
  1578. !     g_snprintf(cmd, (gulong)(strlen(txt) + 7), "\034\016:h %s\r", txt);
  1579. !     add_to_input_buf((char_u *)cmd, STRLEN(cmd));
  1580. !     vim_free(cmd);
  1581. !     }
  1582. ! 
  1583. !     /* Don't destroy this dialogue just hide it from the users view.
  1584. !      * Reuse it later */
  1585. !     gtk_widget_hide(helpfind);
  1586. ! 
  1587. !     if (gtk_main_level() > 0)
  1588. !     gtk_main_quit();
  1589. ! }
  1590. ! 
  1591. ! /*ARGSUSED*/
  1592. !     static void
  1593. ! helpfind_cancel(GtkWidget *wgt, gpointer cbdata)
  1594. ! {
  1595. !     /* Don't destroy this dialogue just hide it from the users view.
  1596. !      * Reuse it later */
  1597. !     gtk_widget_hide(helpfind);
  1598. ! 
  1599. !     if (gtk_main_level() > 0)
  1600. !     gtk_main_quit();
  1601. ! }
  1602. ! 
  1603. ! void
  1604. ! do_helpfind(void)
  1605. ! {
  1606. !     GtkWidget *frame;
  1607. !     GtkWidget *vbox;
  1608. !     GtkWidget *hbox;
  1609. !     GtkWidget *tmp;
  1610. !     GtkWidget *action_area;
  1611. !     GtkWidget *sub_area;
  1612.   
  1613.       if (!gui.in_use)
  1614.       {
  1615. ***************
  1616. *** 1650,1735 ****
  1617.       gtk_window_set_transient_for(GTK_WINDOW(helpfind), GTK_WINDOW(gui.mainwin));
  1618.   #endif
  1619.       gtk_window_position(GTK_WINDOW(helpfind), GTK_WIN_POS_MOUSE);
  1620. !     gtk_window_set_title(GTK_WINDOW(helpfind), "VIM - Help on what?");
  1621.       gtk_signal_connect(GTK_OBJECT(helpfind), "destroy",
  1622.                  GTK_SIGNAL_FUNC(gtk_widget_destroyed), &helpfind);
  1623.   
  1624. !     vbox = gtk_vbox_new(FALSE, 6);
  1625. !     gtk_container_add(GTK_CONTAINER(helpfind), vbox);
  1626. !     gtk_container_border_width(GTK_CONTAINER(helpfind), 6);
  1627.   
  1628.       hbox = gtk_hbox_new(FALSE, 6);
  1629.       gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 0);
  1630.   
  1631. !     tmp = gtk_label_new("Topic: ");
  1632.       gtk_box_pack_start(GTK_BOX(hbox), tmp, TRUE, TRUE, 0);
  1633.   
  1634.       help_entry = gtk_entry_new();
  1635.       gtk_box_pack_start(GTK_BOX(hbox), help_entry, TRUE, TRUE, 0);
  1636.   
  1637. !     tmp = gtk_hseparator_new();
  1638. !     gtk_box_pack_start(GTK_BOX(vbox), tmp,  FALSE, TRUE, 0);
  1639.   
  1640. !     hbox = gtk_hbutton_box_new();
  1641. !     gtk_button_box_set_layout(GTK_BUTTON_BOX(hbox), GTK_BUTTONBOX_EDGE);
  1642. !     gtk_button_box_set_spacing(GTK_BUTTON_BOX(hbox), 0);
  1643. !     gtk_container_border_width(GTK_CONTAINER(hbox), 0);
  1644. !     gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
  1645. ! 
  1646. !     tmp = gui_gtk_button_new_with_label("Ok",
  1647. !                     GTK_SIGNAL_FUNC(helpfind_ok),
  1648. !                     help_entry, hbox, FALSE, FALSE, FALSE);
  1649.       gtk_signal_connect(GTK_OBJECT(help_entry), "changed",
  1650.                  GTK_SIGNAL_FUNC(helpfind_entry_changed), tmp);
  1651.       gtk_signal_connect(GTK_OBJECT(help_entry), "activate",
  1652.                  GTK_SIGNAL_FUNC(helpfind_ok), help_entry);
  1653.       gtk_widget_set_sensitive(tmp, FALSE);
  1654.       GTK_WIDGET_SET_FLAGS(tmp, GTK_CAN_DEFAULT);
  1655.   
  1656. !     tmp = gui_gtk_button_new_with_label("Cancel",
  1657. !                     GTK_SIGNAL_FUNC(gtk_widget_destroy),
  1658. !                     helpfind, hbox, TRUE, FALSE, FALSE);
  1659. !     GTK_WIDGET_SET_FLAGS(tmp, GTK_CAN_DEFAULT);
  1660. !     gtk_widget_grab_default(tmp);
  1661.   
  1662.       gtk_widget_grab_focus(help_entry);
  1663.       gtk_widget_show_all(helpfind);
  1664. - }
  1665. - 
  1666. - 
  1667. -     static void
  1668. - helpfind_entry_changed(GtkWidget *entry, gpointer cbdata)
  1669. - {
  1670. -     GtkWidget *ok = (GtkWidget *)cbdata;
  1671. -     char *txt = gtk_entry_get_text(GTK_ENTRY(entry));
  1672. - 
  1673. -     if (txt == NULL)
  1674. -     return;
  1675. - 
  1676. -     gtk_widget_set_sensitive(ok, strlen(txt));
  1677. - }
  1678. - 
  1679. - 
  1680. - /*ARGSUSED*/
  1681. -     static void
  1682. - helpfind_ok(GtkWidget *wgt, gpointer cbdata)
  1683. - {
  1684. -     char *txt, *cmd;
  1685. -     GtkEntry *entry = GTK_ENTRY(cbdata);
  1686. - 
  1687. -     if ((txt = gtk_entry_get_text(entry)) == NULL)
  1688. -     return;
  1689. - 
  1690. -     if ((cmd = (char *)alloc(strlen(txt) + 8)) == NULL)
  1691. -     return;
  1692. - 
  1693. -     /* use CTRL-\ CTRL-N to get Vim into Normal mode first */
  1694. -     g_snprintf(cmd, (gulong)(strlen(txt) + 7), "\034\016:h %s\r", txt);
  1695. -     add_to_input_buf((char_u *)cmd, STRLEN(cmd));
  1696. - 
  1697. -     gtk_widget_destroy(helpfind);
  1698. -     vim_free(cmd);
  1699. - 
  1700. -     if (gtk_main_level() > 0)
  1701. -     gtk_main_quit();
  1702.   }
  1703. --- 1827,1888 ----
  1704.       gtk_window_set_transient_for(GTK_WINDOW(helpfind), GTK_WINDOW(gui.mainwin));
  1705.   #endif
  1706.       gtk_window_position(GTK_WINDOW(helpfind), GTK_WIN_POS_MOUSE);
  1707. !     gtk_window_set_title(GTK_WINDOW(helpfind), "VIM - Help on...");
  1708. ! 
  1709. !     gtk_widget_realize(helpfind);
  1710. !     gdk_window_set_decorations(helpfind->window,
  1711. !             GDK_DECOR_BORDER | GDK_DECOR_TITLE);
  1712. !     gdk_window_set_functions(helpfind->window, GDK_FUNC_MOVE);
  1713. ! 
  1714.       gtk_signal_connect(GTK_OBJECT(helpfind), "destroy",
  1715.                  GTK_SIGNAL_FUNC(gtk_widget_destroyed), &helpfind);
  1716.   
  1717. !     /* this makes it look beter on Motif style window managers */
  1718. !     frame = gtk_frame_new(NULL);
  1719. !     gtk_container_add(GTK_CONTAINER(helpfind), frame);
  1720. !     gtk_widget_show(frame);
  1721. ! 
  1722. !     vbox = gtk_vbox_new(FALSE, 0);
  1723. !     gtk_container_add(GTK_CONTAINER(frame), vbox);
  1724.   
  1725.       hbox = gtk_hbox_new(FALSE, 6);
  1726.       gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 0);
  1727. +     gtk_container_border_width(GTK_CONTAINER(hbox), 6);
  1728.   
  1729. !     tmp = gtk_label_new("Topic:");
  1730.       gtk_box_pack_start(GTK_BOX(hbox), tmp, TRUE, TRUE, 0);
  1731.   
  1732.       help_entry = gtk_entry_new();
  1733.       gtk_box_pack_start(GTK_BOX(hbox), help_entry, TRUE, TRUE, 0);
  1734.   
  1735. !     action_area = gtk_hbox_new(FALSE, 0);
  1736. !     gtk_container_set_border_width(GTK_CONTAINER(action_area), 4);
  1737. !     gtk_box_pack_end(GTK_BOX(vbox), action_area, FALSE, TRUE, 0);
  1738.   
  1739. !     sub_area = gtk_hbox_new(TRUE, 0);
  1740. !     gtk_container_set_border_width(GTK_CONTAINER(sub_area), 0);
  1741. !     gtk_box_pack_end(GTK_BOX(action_area), sub_area, FALSE, TRUE, 0);
  1742. ! 
  1743. !     tmp = gui_gtk_button_new_with_label("Cancel",
  1744. !         GTK_SIGNAL_FUNC(helpfind_cancel),
  1745. !         help_entry, sub_area, TRUE, TRUE, TRUE);
  1746. !     GTK_WIDGET_SET_FLAGS(tmp, GTK_CAN_DEFAULT);
  1747. !     gtk_widget_grab_default(tmp);
  1748. ! 
  1749. !     tmp = gui_gtk_button_new_with_label("OK",
  1750. !         GTK_SIGNAL_FUNC(helpfind_ok),
  1751. !         help_entry, sub_area, FALSE, TRUE, TRUE);
  1752.       gtk_signal_connect(GTK_OBJECT(help_entry), "changed",
  1753.                  GTK_SIGNAL_FUNC(helpfind_entry_changed), tmp);
  1754.       gtk_signal_connect(GTK_OBJECT(help_entry), "activate",
  1755.                  GTK_SIGNAL_FUNC(helpfind_ok), help_entry);
  1756.       gtk_widget_set_sensitive(tmp, FALSE);
  1757. +     help_ok_sensitive = FALSE;
  1758.       GTK_WIDGET_SET_FLAGS(tmp, GTK_CAN_DEFAULT);
  1759.   
  1760. !     tmp = gtk_hseparator_new();
  1761. !     gtk_box_pack_end(GTK_BOX(vbox), tmp, FALSE, TRUE, 0);
  1762.   
  1763.       gtk_widget_grab_focus(help_entry);
  1764.       gtk_widget_show_all(helpfind);
  1765.   }
  1766. *** ../vim-5.6a.17/src/gui_gtk_x11.c    Wed Dec 29 12:11:01 1999
  1767. --- src/gui_gtk_x11.c    Sat Jan  8 21:15:25 2000
  1768. ***************
  1769. *** 19,24 ****
  1770. --- 19,29 ----
  1771.    *    :-) <dalecki@cs.net.pl> (My native language is polish and I speak
  1772.    *    native grade german too. I'm living in GĂ·ttingen.de.)
  1773.    *    --mdcki"
  1774. +  *
  1775. +  *
  1776. +  * Although some #ifdefs suggest that GTK 1.0 is supported, it isn't.  The
  1777. +  * code requires GTK version 1.1.16 or later.  Stuff for older versions will
  1778. +  * be removed some time.
  1779.    */
  1780.   
  1781.   #include "vim.h"
  1782. ***************
  1783. *** 36,46 ****
  1784.   
  1785.   /* slection distinguishers */
  1786.   enum {
  1787. !     SEL_TYPE_NONE,
  1788.       SELECTION_STRING,
  1789.       SELECTION_CLIPBOARD
  1790.   };
  1791.   
  1792.   /* This is the single only fixed width font in X11, which seems to be present
  1793.    * on all servers and available in all the variants we need.
  1794.    *
  1795. --- 41,69 ----
  1796.   
  1797.   /* slection distinguishers */
  1798.   enum {
  1799. !     SELECTION_TYPE_NONE,
  1800.       SELECTION_STRING,
  1801.       SELECTION_CLIPBOARD
  1802.   };
  1803.   
  1804. + /*
  1805. +  * Enable DND feature.  Disable this if it causes problems.
  1806. +  */
  1807. + #define GTK_DND
  1808. + 
  1809. + #ifdef GTK_DND
  1810. + /* DND specification constants. */
  1811. + enum {
  1812. +   TARGET_STRING
  1813. + };
  1814. + 
  1815. + static GtkTargetEntry target_table[] = {
  1816. +     { "STRING",     0, TARGET_STRING },
  1817. +     { "text/plain", 0, TARGET_STRING }
  1818. + };
  1819. + static guint n_targets = sizeof(target_table) / sizeof(target_table[0]);
  1820. + #endif
  1821. + 
  1822.   /* This is the single only fixed width font in X11, which seems to be present
  1823.    * on all servers and available in all the variants we need.
  1824.    *
  1825. ***************
  1826. *** 50,78 ****
  1827.   
  1828.   #define DFLT_FONT        "-adobe-courier-medium-r-normal-*-14-*-*-*-m-*-*-*"
  1829.   
  1830. ! #ifdef GTK_HAVE_FEATURES_1_1_0
  1831. ! static void font_sel_ok(GtkWidget *wgt, gpointer cbdata);
  1832. ! static void font_sel_cancel(GtkWidget *wgt, gpointer cbdata);
  1833. ! static void font_sel_destroy(GtkWidget *wgt, gpointer cbdata);
  1834. ! #endif
  1835. ! 
  1836. ! static gint expose_event(GtkWidget * widget, GdkEventExpose * event);
  1837. ! static gint button_press_event(GtkWidget * widget, GdkEventButton * event);
  1838. ! static gint button_release_event(GtkWidget * widget, GdkEventButton * event);
  1839. ! static gint motion_notify_event(GtkWidget * widget, GdkEventMotion * event);
  1840. ! static void destroy_callback(void);
  1841. ! static int  delete_event_cb(GtkWidget *wgt, gpointer cbdata);
  1842.   
  1843.   /*
  1844. !  * If of the atom used to communicate save yourself from the X11 session
  1845. !  * manager. There is no need to move this into the GUI struct, since this
  1846. !  * should be always constant.
  1847.    */
  1848. ! GdkAtom save_yourself_atom = GDK_NONE;
  1849.   
  1850.   /*
  1851.    * Keycodes recognized by vim.
  1852. -  * we will be using the techniques described here later for real work.
  1853.    */
  1854.   static struct special_key {
  1855.       guint key_sym;
  1856. --- 73,93 ----
  1857.   
  1858.   #define DFLT_FONT        "-adobe-courier-medium-r-normal-*-14-*-*-*-m-*-*-*"
  1859.   
  1860. ! /*
  1861. !  * Atom used to communicate save yourself from the X11 session manager. There
  1862. !  * is no need to move this into the GUI struct, since this should be always
  1863. !  * constant.
  1864. !  */
  1865. ! static GdkAtom save_yourself_atom = GDK_NONE;
  1866.   
  1867.   /*
  1868. !  * Atom used to recognize requests for on the fly GTK+ style configuration
  1869. !  * changes.
  1870.    */
  1871. ! static GdkAtom reread_rcfiles_atom = GDK_NONE;
  1872.   
  1873.   /*
  1874.    * Keycodes recognized by vim.
  1875.    */
  1876.   static struct special_key {
  1877.       guint key_sym;
  1878. ***************
  1879. *** 306,311 ****
  1880. --- 321,357 ----
  1881.   #endif
  1882.   
  1883.   /*
  1884. +  * Redraw the corresponding portions of the screen.
  1885. +  */
  1886. + /*ARGSUSED*/
  1887. + static gint
  1888. + expose_event(GtkWidget * widget, GdkEventExpose * event)
  1889. + {
  1890. +     out_flush();        /* make sure all output has been processed */
  1891. +     gui_redraw(event->area.x, event->area.y,
  1892. +            event->area.width, event->area.height);
  1893. + 
  1894. +     /* Clear the border areas if needed */
  1895. +     if (event->area.x < FILL_X(0))
  1896. +     gdk_window_clear_area(gui.drawarea->window, 0, 0, FILL_X(0), 0);
  1897. +     if (event->area.y < FILL_Y(0))
  1898. +     gdk_window_clear_area(gui.drawarea->window, 0, 0, 0, FILL_Y(0));
  1899. +     if (event->area.x > FILL_X(Columns))
  1900. +     gdk_window_clear_area(gui.drawarea->window,
  1901. +                   FILL_X((int)Columns), 0, 0, 0);
  1902. +     if (event->area.y > FILL_Y(Rows))
  1903. +     gdk_window_clear_area(gui.drawarea->window, 0, FILL_Y((int)Rows), 0, 0);
  1904. + 
  1905. +     return FALSE;
  1906. + }
  1907. + 
  1908. + 
  1909. + /****************************************************************************
  1910. +  * Focus handlers:
  1911. +  */
  1912. + 
  1913. + 
  1914. + /*
  1915.    * This is a simple state machine:
  1916.    * BLINK_NONE   not blinking at all
  1917.    * BLINK_OFF    blinking, cursor is not shown
  1918. ***************
  1919. *** 347,364 ****
  1920.   
  1921.   /*ARGSUSED*/
  1922.   static gint
  1923. ! gui_gtk_blink_cb(gpointer data)
  1924.   {
  1925.       if (blink_state == BLINK_ON) {
  1926.       gui_undraw_cursor();
  1927.       blink_state = BLINK_OFF;
  1928. !     blink_timer = gtk_timeout_add(blink_offtime,
  1929. !                    (GtkFunction) gui_gtk_blink_cb, NULL);
  1930.       } else {
  1931.       gui_update_cursor(TRUE, FALSE);
  1932.       blink_state = BLINK_ON;
  1933. !     blink_timer = gtk_timeout_add(blink_ontime,
  1934. !                    (GtkFunction) gui_gtk_blink_cb, NULL);
  1935.       }
  1936.   
  1937.       return FALSE;        /* don't happen again */
  1938. --- 393,410 ----
  1939.   
  1940.   /*ARGSUSED*/
  1941.   static gint
  1942. ! blink_cb(gpointer data)
  1943.   {
  1944.       if (blink_state == BLINK_ON) {
  1945.       gui_undraw_cursor();
  1946.       blink_state = BLINK_OFF;
  1947. !     blink_timer = gtk_timeout_add((guint32)blink_offtime,
  1948. !                    (GtkFunction) blink_cb, NULL);
  1949.       } else {
  1950.       gui_update_cursor(TRUE, FALSE);
  1951.       blink_state = BLINK_ON;
  1952. !     blink_timer = gtk_timeout_add((guint32)blink_ontime,
  1953. !                    (GtkFunction) blink_cb, NULL);
  1954.       }
  1955.   
  1956.       return FALSE;        /* don't happen again */
  1957. ***************
  1958. *** 375,382 ****
  1959.       gtk_timeout_remove(blink_timer);
  1960.       /* Only switch blinking on if none of the times is zero */
  1961.       if (blink_waittime && blink_ontime && blink_offtime && gui.in_focus) {
  1962. !     blink_timer = gtk_timeout_add(blink_waittime,
  1963. !                    (GtkFunction) gui_gtk_blink_cb, NULL);
  1964.       blink_state = BLINK_ON;
  1965.       gui_update_cursor(TRUE, FALSE);
  1966.       }
  1967. --- 421,428 ----
  1968.       gtk_timeout_remove(blink_timer);
  1969.       /* Only switch blinking on if none of the times is zero */
  1970.       if (blink_waittime && blink_ontime && blink_offtime && gui.in_focus) {
  1971. !     blink_timer = gtk_timeout_add((guint32)blink_waittime,
  1972. !                    (GtkFunction) blink_cb, NULL);
  1973.       blink_state = BLINK_ON;
  1974.       gui_update_cursor(TRUE, FALSE);
  1975.       }
  1976. ***************
  1977. *** 437,451 ****
  1978.   }
  1979.   
  1980.   
  1981.   /*ARGSUSED*/
  1982.   static gint
  1983.   key_press_event(GtkWidget * widget, GdkEventKey * event, gpointer data)
  1984.   {
  1985. - #ifdef USE_XIM
  1986.       char_u string[256], string2[256];
  1987. - #else
  1988. -     char_u string[3], string2[3];
  1989. - #endif
  1990.       guint key_sym;
  1991.       int len;
  1992.       int i;
  1993. --- 483,497 ----
  1994.   }
  1995.   
  1996.   
  1997. + /****************************************************************************
  1998. +  * Main keyboard handler:
  1999. +  */
  2000. + 
  2001.   /*ARGSUSED*/
  2002.   static gint
  2003.   key_press_event(GtkWidget * widget, GdkEventKey * event, gpointer data)
  2004.   {
  2005.       char_u string[256], string2[256];
  2006.       guint key_sym;
  2007.       int len;
  2008.       int i;
  2009. ***************
  2010. *** 571,576 ****
  2011. --- 617,628 ----
  2012.       return TRUE;
  2013.   }
  2014.   
  2015. + 
  2016. + /****************************************************************************
  2017. +  * Selection handlers:
  2018. +  */
  2019. + 
  2020. + 
  2021.   /*ARGSUSED*/
  2022.   static gint
  2023.   selection_clear_event(GtkWidget * widget, GdkEventSelection * event)
  2024. ***************
  2025. *** 647,653 ****
  2026.       clip_get_selection();
  2027.   
  2028.       /* get the selection from the * register */
  2029. !     motion_type = clip_convert_selection(&string, (long_u *)&length);
  2030.       if (motion_type < 0)
  2031.       return;
  2032.   
  2033. --- 699,705 ----
  2034.       clip_get_selection();
  2035.   
  2036.       /* get the selection from the * register */
  2037. !     motion_type = clip_convert_selection(&string, &length);
  2038.       if (motion_type < 0)
  2039.       return;
  2040.   
  2041. ***************
  2042. *** 655,661 ****
  2043.       if (info == SELECTION_CLIPBOARD)
  2044.       length++;
  2045.   
  2046. !     result = (char_u *)malloc(2 * length);
  2047.       if (result == NULL)
  2048.       {
  2049.       vim_free(string);
  2050. --- 707,713 ----
  2051.       if (info == SELECTION_CLIPBOARD)
  2052.       length++;
  2053.   
  2054. !     result = lalloc((long_u)(2 * length), FALSE);
  2055.       if (result == NULL)
  2056.       {
  2057.       vim_free(string);
  2058. ***************
  2059. *** 676,682 ****
  2060.       selection_data->type = selection_data->target;
  2061.       selection_data->format = 8;    /* 8 bits per char */
  2062.   
  2063. !     gtk_selection_data_set(selection_data, type, 8, result, length);
  2064.       vim_free(string);
  2065.       vim_free(result);
  2066.   }
  2067. --- 728,734 ----
  2068.       selection_data->type = selection_data->target;
  2069.       selection_data->format = 8;    /* 8 bits per char */
  2070.   
  2071. !     gtk_selection_data_set(selection_data, type, 8, result, (gint)length);
  2072.       vim_free(string);
  2073.       vim_free(result);
  2074.   }
  2075. ***************
  2076. *** 771,2916 ****
  2077.       return OK;
  2078.   }
  2079.   
  2080.   /*
  2081. !  * Setup the window icon after the main window has bee realized.
  2082.    */
  2083. ! /*ARGSUSED*/
  2084. ! static void
  2085. ! mainwin_realize(GtkWidget *widget)
  2086.   {
  2087. ! /* If you get an error message here, you still need to unpack the runtime
  2088. !  * archive! */
  2089. ! #include "../runtime/vim32x32.xpm"
  2090. !     static GdkPixmap *icon = NULL;
  2091. !     static GdkBitmap *icon_mask = NULL;
  2092.   
  2093. !     if (!icon)
  2094. !     icon = gdk_pixmap_create_from_xpm_d(gui.mainwin->window,
  2095. !                             &icon_mask, NULL, magick);
  2096. !     gdk_window_set_icon(gui.mainwin->window, NULL, icon, icon_mask);
  2097.   }
  2098.   
  2099.   /*
  2100. !  * After the drawing area comes up, we calculate all colors and create the
  2101. !  * dummy blank cursor.
  2102. !  *
  2103. !  * Don't try to set any VIM scrollbar sizes anywhere here. I'm relying on the
  2104. !  * fact that the main VIM engine doesn't take them into account anywhere.
  2105.    */
  2106. ! static void
  2107. ! drawarea_realize_cb(GtkWidget *widget)
  2108.   {
  2109. !     char blank_data[] = {0x0};
  2110. !     GdkPixmap *blank_mask;
  2111. !     GdkColor color;
  2112. !     GtkWidget *sbar;
  2113.   
  2114. ! #ifdef USE_XIM
  2115. !     xim_init();
  2116. ! #endif
  2117. !     gui_mch_new_colors();
  2118.   
  2119. !     blank_mask = gdk_bitmap_create_from_data(NULL, blank_data, 1, 1);
  2120. !     gdk_color_white(gdk_colormap_get_system(), &color);
  2121. !     gui.blank_pointer = gdk_cursor_new_from_pixmap(blank_mask, blank_mask,
  2122. !                             &color, &color, 0, 0);
  2123. !     gdk_bitmap_unref(blank_mask);
  2124. !     if (gui.pointer_hidden)
  2125. !         gdk_window_set_cursor(widget->window, gui.blank_pointer);
  2126.   
  2127. !     /* get the actual size of the scrollbars, if they are realized */
  2128. !     sbar = firstwin->w_scrollbars[SBAR_LEFT].id;
  2129. !     if (!sbar || (!gui.which_scrollbars[SBAR_LEFT]
  2130. !                     && firstwin->w_scrollbars[SBAR_RIGHT].id))
  2131. !     sbar = firstwin->w_scrollbars[SBAR_RIGHT].id;
  2132. !     if (sbar && GTK_WIDGET_REALIZED(sbar) && sbar->allocation.width)
  2133. !     gui.scrollbar_width = sbar->allocation.width;
  2134.   
  2135. !     sbar = gui.bottom_sbar.id;
  2136. !     if (sbar && GTK_WIDGET_REALIZED(sbar) && sbar->allocation.height)
  2137. !     gui.scrollbar_height = sbar->allocation.height;
  2138.   }
  2139.   
  2140. ! /*
  2141. !  * Initialise the X GUI.  Create all the windows, set up all the call-backs etc.
  2142. !  * Returns OK for success, FAIL when the GUI can't be started.
  2143. !  */
  2144. ! int
  2145. ! gui_mch_init()
  2146.   {
  2147. !     GtkWidget *vbox;
  2148.   
  2149. !     /* Uncomment this to enable synchronous mode for debugging */
  2150. !     /* XSynchronize(gui.dpy, True); */
  2151.   
  2152. !     /* Initialize values */
  2153. !     gui.rev_video = FALSE;
  2154. !     gui.border_width = 2;
  2155. !     gui.scrollbar_width = SB_DEFAULT_WIDTH;
  2156. !     gui.scrollbar_height = SB_DEFAULT_WIDTH;
  2157. !     gui.fgcolor = g_new0(GdkColor, 1);
  2158. !     gui.bgcolor = g_new0(GdkColor, 1);
  2159.   
  2160. ! #ifdef WANT_MENU
  2161. !     /* Don't change the menu height values used in gui.c at runtime */
  2162. !     gui.menu_height_fixed = TRUE;
  2163. ! #endif
  2164.   
  2165. !     /* Set default foreground and background colours. */
  2166. !     gui.norm_pixel = gui.def_norm_pixel;
  2167. !     gui.back_pixel = gui.def_back_pixel;
  2168.   
  2169. !     gui.mainwin = gtk_window_new(GTK_WINDOW_TOPLEVEL);
  2170. !     gtk_window_set_policy(GTK_WINDOW(gui.mainwin), TRUE, TRUE, TRUE);
  2171. !     gtk_container_border_width(GTK_CONTAINER(gui.mainwin), 0);
  2172. !     gtk_widget_set_events(gui.mainwin, GDK_VISIBILITY_NOTIFY_MASK);
  2173. !     (void)gtk_signal_connect(GTK_OBJECT(gui.mainwin), "delete_event",
  2174. !                  GTK_SIGNAL_FUNC(delete_event_cb), NULL);
  2175.   
  2176. !     /* Add an icon to the main window. For fun and convenience of the user. */
  2177. !     if (vim_strchr(p_go, GO_ICON) != NULL)
  2178. !     gtk_signal_connect(GTK_OBJECT(gui.mainwin), "realize",
  2179. !                       GTK_SIGNAL_FUNC(mainwin_realize), NULL);
  2180.   
  2181.   
  2182. ! #ifdef GTK_HAVE_FEATURES_1_1_0
  2183. !     /* FIXME: this should eventually get the accelgroup of the gui.mainwin */
  2184. !     gui.accel_group = gtk_accel_group_get_default();
  2185. ! #endif
  2186.   
  2187. !     vbox = gtk_vbox_new(FALSE, 0);
  2188. !     gtk_container_add(GTK_CONTAINER(gui.mainwin), vbox);
  2189. !     gtk_widget_show(vbox);
  2190.   
  2191. ! #ifdef WANT_MENU
  2192. !     /* create the menubar and handle */
  2193. !     gui.menubar = gtk_menu_bar_new();
  2194. !     gtk_widget_show(gui.menubar);
  2195. !     gtk_box_pack_start(GTK_BOX(vbox), gui.menubar, FALSE, TRUE, 0);
  2196. ! #endif
  2197.   
  2198. ! #ifdef USE_TOOLBAR
  2199. !     /* create the toolbar */
  2200. !     if (p_toolbar) {
  2201. !     if (strstr((const char *)p_toolbar, "text")
  2202. !         && strstr((const char *)p_toolbar, "icons"))
  2203. !         gui.toolbar = gtk_toolbar_new(GTK_ORIENTATION_HORIZONTAL,
  2204. !                       GTK_TOOLBAR_BOTH);
  2205. !     else if (strstr((const char *)p_toolbar, "text"))
  2206. !         gui.toolbar = gtk_toolbar_new(GTK_ORIENTATION_HORIZONTAL,
  2207. !                       GTK_TOOLBAR_TEXT);
  2208. !     else
  2209. !         gui.toolbar = gtk_toolbar_new(GTK_ORIENTATION_HORIZONTAL,
  2210. !                       GTK_TOOLBAR_ICONS);
  2211. !     } else
  2212. !     gui.toolbar = gtk_toolbar_new(GTK_ORIENTATION_HORIZONTAL,
  2213. !                       GTK_TOOLBAR_ICONS);
  2214.   
  2215. !     gtk_widget_show(gui.toolbar);
  2216. ! # ifdef GTK_HAVE_FEATURES_1_1_0
  2217. !     /* some aesthetics on the toolbar */
  2218. !     gtk_toolbar_set_button_relief(GTK_TOOLBAR(gui.toolbar), GTK_RELIEF_NONE);
  2219. ! # endif
  2220. !     gtk_container_border_width(GTK_CONTAINER(gui.toolbar), 1);
  2221. !     gtk_box_pack_start(GTK_BOX(vbox), gui.toolbar, FALSE, TRUE, 0);
  2222. ! #endif
  2223.   
  2224. !     gui.formwin = gtk_form_new();
  2225. !     gtk_container_border_width(GTK_CONTAINER(gui.formwin), 0);
  2226. !     gtk_widget_set_events(gui.formwin, GDK_EXPOSURE_MASK);
  2227.   
  2228. -     gui.drawarea = gtk_drawing_area_new();
  2229. - 
  2230. -     /* Determine which events we will filter. */
  2231. -     gtk_widget_set_events(gui.drawarea,
  2232. -               GDK_EXPOSURE_MASK |
  2233. -               GDK_ENTER_NOTIFY_MASK |
  2234. -               GDK_LEAVE_NOTIFY_MASK |
  2235. -               GDK_BUTTON_PRESS_MASK |
  2236. -               GDK_BUTTON_RELEASE_MASK |
  2237. -               GDK_POINTER_MOTION_MASK |
  2238. -               GDK_POINTER_MOTION_HINT_MASK);
  2239. -     gtk_widget_show(gui.drawarea);
  2240. -     gtk_form_put(GTK_FORM(gui.formwin), gui.drawarea, 0, 0);
  2241. -     gtk_widget_show(gui.formwin);
  2242. -     gtk_box_pack_start(GTK_BOX(vbox), gui.formwin, TRUE, TRUE, 0);
  2243. - 
  2244. -     gtk_signal_connect(GTK_OBJECT(gui.mainwin), "key_press_event",
  2245. -                (GtkSignalFunc) key_press_event, NULL);
  2246. -     gtk_signal_connect(GTK_OBJECT(gui.drawarea), "realize",
  2247. -                GTK_SIGNAL_FUNC(drawarea_realize_cb), NULL);
  2248.   
  2249. !     /* Check if reverse video needs to be applied (on Sun it's done by X) */
  2250. !     if (gui.rev_video && gui_mch_get_lightness(gui.back_pixel)
  2251. !     > gui_mch_get_lightness(gui.norm_pixel)) {
  2252. !     gui.norm_pixel = gui.def_back_pixel;
  2253. !     gui.back_pixel = gui.def_norm_pixel;
  2254. !     gui.def_norm_pixel = gui.norm_pixel;
  2255. !     gui.def_back_pixel = gui.back_pixel;
  2256. !     }
  2257. !     gui.visibility = GDK_VISIBILITY_UNOBSCURED;
  2258. !     clipboard.atom = gdk_atom_intern("_VIM_TEXT", FALSE);
  2259. !     save_yourself_atom = gdk_atom_intern("WM_SAVE_YOURSELF", FALSE);
  2260.   
  2261.       /*
  2262. !      * Start out by adding the configured border width into the border offset.
  2263.        */
  2264. !     gui.border_offset = gui.border_width;
  2265.   
  2266. ! #ifdef GTK_HAVE_FEATURES_1_1_0
  2267. !     gtk_signal_connect(GTK_OBJECT(gui.mainwin), "visibility_notify_event",
  2268. !                GTK_SIGNAL_FUNC(visibility_event), NULL);
  2269. ! #endif
  2270. !     gtk_signal_connect(GTK_OBJECT(gui.drawarea), "expose_event",
  2271. !                GTK_SIGNAL_FUNC(expose_event), NULL);
  2272.   
  2273. !     /*
  2274. !      * Only install these enter/leave callbacks when 'p' in 'guioptions'.
  2275. !      * Only needed for some window managers.
  2276. !      */
  2277. !     if (vim_strchr(p_go, GO_POINTER) != NULL) {
  2278. !     gtk_signal_connect(GTK_OBJECT(gui.drawarea), "leave_notify_event",
  2279. !                GTK_SIGNAL_FUNC(leave_notify_event), NULL);
  2280. !     gtk_signal_connect(GTK_OBJECT(gui.drawarea), "enter_notify_event",
  2281. !                GTK_SIGNAL_FUNC(enter_notify_event), NULL);
  2282.       }
  2283.   
  2284. !     gtk_signal_connect(GTK_OBJECT(gui.mainwin), "focus_out_event",
  2285. !                GTK_SIGNAL_FUNC(focus_out_event), NULL);
  2286. !     gtk_signal_connect(GTK_OBJECT(gui.mainwin), "focus_in_event",
  2287. !                GTK_SIGNAL_FUNC(focus_in_event), NULL);
  2288. ! 
  2289. !     gtk_signal_connect(GTK_OBJECT(gui.drawarea), "motion_notify_event",
  2290. !                GTK_SIGNAL_FUNC(motion_notify_event), NULL);
  2291. !     gtk_signal_connect(GTK_OBJECT(gui.drawarea), "button_press_event",
  2292. !                GTK_SIGNAL_FUNC(button_press_event), NULL);
  2293. !     gtk_signal_connect(GTK_OBJECT(gui.drawarea), "button_release_event",
  2294. !                GTK_SIGNAL_FUNC(button_release_event), NULL);
  2295.   
  2296. !     /*
  2297. !      * Add selection handler functions.
  2298. !      */
  2299. !     gtk_signal_connect(GTK_OBJECT(gui.drawarea), "selection_clear_event",
  2300. !                GTK_SIGNAL_FUNC(selection_clear_event), NULL);
  2301. !     gtk_signal_connect(GTK_OBJECT(gui.drawarea), "selection_received",
  2302. !                GTK_SIGNAL_FUNC(selection_received_event), NULL);
  2303.   
  2304. !     /* gtk_selection_add_target() is not in GTK 1.1.2 */
  2305. ! #ifdef GTK_HAVE_FEATURES_1_1_4
  2306. !     gtk_selection_add_target(gui.drawarea, GDK_SELECTION_PRIMARY,
  2307. !                 GDK_TARGET_STRING, SELECTION_STRING);
  2308. !     gtk_selection_add_target(gui.drawarea, GDK_SELECTION_PRIMARY,
  2309. !                 clipboard.atom, SELECTION_CLIPBOARD);
  2310. !     gtk_signal_connect(GTK_OBJECT(gui.drawarea), "selection_get",
  2311. !                GTK_SIGNAL_FUNC(selection_get_event), NULL);
  2312. ! #else
  2313. !     gtk_selection_add_handler(gui.drawarea, GDK_SELECTION_PRIMARY,
  2314. !                   GDK_TARGET_STRING, selection_handler, NULL);
  2315. !     gtk_selection_add_handler(gui.drawarea, GDK_SELECTION_PRIMARY,
  2316. !                   clipboard.atom, selection_handler, NULL);
  2317. ! #endif
  2318.   
  2319. !     /* Pretend we don't have input focus, we will get an event if we do. */
  2320. !     gui.in_focus = FALSE;
  2321.   
  2322. !     return OK;
  2323.   }
  2324.   
  2325. ! 
  2326. ! /*
  2327. !  * Called when the foreground or background color has been changed.
  2328. !  */
  2329. ! void
  2330. ! gui_mch_new_colors()
  2331.   {
  2332. !     /* This used to change the graphics contexts directly but we are currently
  2333. !      * manipulating them where desired.
  2334. !      */
  2335. !     if (gui.drawarea && gui.drawarea->window) {
  2336. !     GdkColor color;
  2337. !     color.pixel = gui.back_pixel;
  2338. !     gdk_window_set_background(gui.drawarea->window, &color);
  2339.       }
  2340.   }
  2341.   
  2342. - #ifdef GTK_HAVE_FEATURES_1_1_6
  2343. - # define USE_GEOMETRY_FOR_HINTS        1
  2344. - #endif
  2345.   
  2346.   static void
  2347. ! update_window_manager_hints(void)
  2348. ! {
  2349. !     int width;
  2350. !     int height;
  2351. ! #ifdef USE_GEOMETRY_FOR_HINTS
  2352. !     GdkGeometry geometry;
  2353. !     GdkWindowHints geometry_mask;
  2354.   
  2355. !     /* This also needs to be done when the main window isn't there yet,
  2356. !      * otherwise the hints don't work. */
  2357. !     width = gui_get_base_width();
  2358. !     height = gui_get_base_height();
  2359.   
  2360. !     geometry_mask = GDK_HINT_BASE_SIZE|GDK_HINT_RESIZE_INC|GDK_HINT_MIN_SIZE;
  2361. !     geometry.width_inc = gui.char_width;
  2362. !     geometry.height_inc = gui.char_height;
  2363. !     geometry.base_width = width;
  2364. !     geometry.base_height = height;
  2365. !     geometry.min_width = width + MIN_COLUMNS * gui.char_width;
  2366. !     geometry.min_height = height + MIN_LINES * gui.char_height;
  2367. !     gtk_window_set_geometry_hints(GTK_WINDOW(gui.mainwin), gui.formwin,
  2368. !                   &geometry, geometry_mask);
  2369. ! #else
  2370. !     XSizeHints size_hints;
  2371.   
  2372. !     /* Don't set the size until the main window is really there */
  2373. !     if (!GTK_WIDGET_REALIZED(gui.mainwin))
  2374. !     return;
  2375.   
  2376. !     width = gui_get_base_width();
  2377. !     height = gui_get_base_height();
  2378.   
  2379. !     /* The hints don't automatically take the menubar and toolbar into
  2380. !      * account.  Need to add their height here, if they are visible. */
  2381. ! # ifdef USE_TOOLBAR
  2382. !     if (gui.toolbar && GTK_WIDGET_REALIZED(gui.toolbar)
  2383. !         && GTK_WIDGET_VISIBLE(gui.toolbar))
  2384. !     height += gui.toolbar->allocation.height;
  2385. ! # endif
  2386. ! # ifdef WANT_MENU
  2387. !     if (gui.menubar && GTK_WIDGET_REALIZED(gui.menubar)
  2388. !         && GTK_WIDGET_VISIBLE(gui.menubar))
  2389. !     height += gui.menubar->allocation.height;
  2390. ! # endif
  2391.   
  2392.       /*
  2393. !      * Argh!!! Once again we need to deal with an ommission in GTK+ by
  2394. !      * resorting to direct Xlib calls. Fortunatly I know how to do it :-).
  2395.        */
  2396. !     size_hints.flags = (PResizeInc | PBaseSize | PMinSize | PSize);
  2397. !     size_hints.width_inc = gui.char_width;
  2398. !     size_hints.height_inc = gui.char_height;
  2399. !     size_hints.base_width = width;
  2400. !     size_hints.base_height = height;
  2401. !     size_hints.min_width = width + MIN_COLUMNS * gui.char_width;
  2402. !     size_hints.min_height = height + MIN_LINES * gui.char_height;
  2403.   
  2404. !     /* This is only needed for "older" window managers.  See a corresposning
  2405. !      * comment in the X11 headers. */
  2406. !     size_hints.width = width + Columns * gui.char_width;
  2407. !     size_hints.height = height + Rows * gui.char_height;
  2408.   
  2409. !     XSetWMNormalHints(GDK_DISPLAY(),
  2410. !               GDK_WINDOW_XWINDOW(gui.mainwin->window),
  2411. !               &size_hints);
  2412. ! #endif    /* USE_GEOMETRY_FOR_HINTS */
  2413.   }
  2414.   
  2415.   /*
  2416. !  * This signal informs us about the need to rearrange our subwidgets.
  2417.    */
  2418.   /*ARGSUSED*/
  2419. ! static gint
  2420. ! form_configure_event(GtkWidget * widget, GdkEventConfigure * event)
  2421.   {
  2422. !     gtk_form_freeze(GTK_FORM(gui.formwin));
  2423. !     gui_resize_window(event->width, event->height);
  2424. !     gtk_form_thaw(GTK_FORM(gui.formwin));
  2425. ! 
  2426. !     return TRUE;
  2427. ! }
  2428.   
  2429. ! /*ARGSUSED*/
  2430. ! static gint
  2431. ! client_event_cb(GtkWidget *widget, GdkEventClient *event)
  2432. ! {
  2433. !     if (event->message_type == save_yourself_atom ) {
  2434. !     out_flush();
  2435. !     ml_sync_all(FALSE, FALSE);      /* preserve all swap files */
  2436. !     return TRUE;
  2437. !     }
  2438. !     return FALSE;
  2439.   }
  2440.   
  2441.   /*
  2442. !  * Open the GUI window which was created by a call to gui_mch_init().
  2443.    */
  2444. ! int
  2445. ! gui_mch_open()
  2446.   {
  2447. !     int x = -1, y = -1;
  2448. ! 
  2449. !     /* Determine user specified geometry, if present. */
  2450. !     if (gui.geom) {
  2451. !     int mask;
  2452. !     unsigned w, h;
  2453. ! 
  2454. !     mask = XParseGeometry((char *)gui.geom, &x, &y, &w, &h);
  2455. !     if (mask & WidthValue)
  2456. !         Columns = w;
  2457. !     if (mask & HeightValue)
  2458. !         Rows = h;
  2459. !     if (mask & (XValue | YValue))
  2460. !         gtk_widget_set_uposition(gui.mainwin, x, y);
  2461. !     g_free(gui.geom);
  2462. !     gui.geom = NULL;
  2463. !     }
  2464. ! 
  2465. !     gtk_form_set_size(GTK_FORM(gui.formwin),
  2466. !         gui_get_base_width() + Columns * gui.char_width,
  2467. !         gui_get_base_height() + Rows * gui.char_height);
  2468. !     update_window_manager_hints();
  2469. ! 
  2470. !     if (found_reverse_arg )
  2471. !     {
  2472. !     gui.def_norm_pixel = gui_mch_get_color("White");
  2473. !     gui.def_back_pixel = gui_mch_get_color("Black");
  2474. !     }
  2475. !     else
  2476. !     {
  2477. !     gui.def_norm_pixel = gui_mch_get_color("Black");
  2478. !     gui.def_back_pixel = gui_mch_get_color("White");
  2479. !     }
  2480. ! 
  2481. !     /* Get the colors from the "Normal" and "Menu" group (set in syntax.c or
  2482. !      * in a vimrc file)
  2483. !      */
  2484. !     set_normal_colors();
  2485. ! 
  2486. !     /* Check that none of the colors are the same as the background color */
  2487. !     gui_check_colors();
  2488. ! 
  2489. !     /* Get the colors for the highlight groups (gui_check_colors() might have
  2490. !      * changed them).
  2491. !      */
  2492. !     highlight_gui_started();    /* re-init colors and fonts */
  2493. ! 
  2494. !     gtk_signal_connect(GTK_OBJECT(gui.mainwin), "destroy",
  2495. !                GTK_SIGNAL_FUNC(destroy_callback), NULL);
  2496.   
  2497. !     gtk_signal_connect(GTK_OBJECT(gui.mainwin), "client_event",
  2498. !                        GTK_SIGNAL_FUNC(client_event_cb), NULL);
  2499. ! #ifdef HANGUL_INPUT
  2500. !     hangul_keyboard_set();
  2501.   #endif
  2502.   
  2503. !     /*
  2504. !      * Notify the fixed area about the need to resize the contents of the
  2505. !      * gui.formwin, which we use for random positioning of the included
  2506. !      * components.
  2507. !      *
  2508. !      * We connect this signal deferred finally after anything is in place,
  2509. !      * since this is intended to handle resizements coming from the window
  2510. !      * manager upon us and should not interfere with what VIM is requesting
  2511. !      * upon startup.
  2512. !      */
  2513. !     gtk_signal_connect(GTK_OBJECT(gui.formwin), "configure_event",
  2514. !                GTK_SIGNAL_FUNC(form_configure_event), NULL);
  2515.   
  2516. !     gtk_widget_show(gui.mainwin);
  2517.   
  2518. !     return OK;
  2519.   }
  2520.   
  2521. ! 
  2522.   /*ARGSUSED*/
  2523. ! void
  2524. ! gui_mch_exit(int rc)
  2525.   {
  2526. !     gtk_exit(0);
  2527.   }
  2528.   
  2529.   /*
  2530. !  * Get the position of the top left corner of the window.
  2531.    */
  2532.   int
  2533. ! gui_mch_get_winpos(int *x, int *y)
  2534.   {
  2535. !     /* For some people this must be gdk_window_get_origin() for a correct
  2536. !      * result.  Where is the documentation! */
  2537. ! #ifdef GTK_HAVE_FEATURES_1_1_4
  2538. !     gdk_window_get_root_origin(gui.mainwin->window, x, y);
  2539. ! #else
  2540. !     gdk_window_get_origin(gui.mainwin->window, x, y);
  2541. ! #endif
  2542. !     return OK;
  2543. ! }
  2544.   
  2545. ! /*
  2546. !  * Set the position of the top left corner of the window to the given
  2547. !  * coordinates.
  2548. !  */
  2549. ! void
  2550. ! gui_mch_set_winpos(int x, int y)
  2551. ! {
  2552. !     gdk_window_move(gui.mainwin->window, x, y);
  2553. ! }
  2554.   
  2555. ! /*
  2556. !  * Set the windows size.
  2557. !  */
  2558. ! /*ARGSUSED*/
  2559. ! void
  2560. ! gui_mch_set_winsize(int width, int height,
  2561. !             int min_width, int min_height,
  2562. !             int base_width, int base_height)
  2563. ! {
  2564. !     gtk_form_set_size(GTK_FORM(gui.formwin), width, height);
  2565.   
  2566. !     /* give GTK+ a chance to put all widget's into place */
  2567. !     gui_mch_update();
  2568.   
  2569. !     /* this will cause the proper resizement to happen too */
  2570. !     update_window_manager_hints();
  2571. ! }
  2572.   
  2573.   
  2574. - /*
  2575. -  * The screen size is used to make sure the initial window doesn't get bigger
  2576. -  * then the screen.  This subtracts some room for menubar, toolbar and window
  2577. -  * decoreations.
  2578. -  */
  2579. - void
  2580. - gui_mch_get_screen_dimensions(int *screen_w, int *screen_h)
  2581. - {
  2582. -     *screen_w = gdk_screen_width();
  2583. -     /* Subtract 'guihearroom' from the height to allow some room for the
  2584. -      * window manager (task list and window title bar). */
  2585. -     *screen_h = gdk_screen_height() - p_ghr;
  2586.   
  2587. !     /*
  2588. !      * FIXME: dirty trick: Because the gui_get_base_height() doesn't include
  2589. !      * the toolbar and menubar for GTK, we subtract them from the screen
  2590. !      * hight, so that the window size can be made to fit on the screen.
  2591. !      * This should be completely changed later.
  2592. !      */
  2593. ! #ifdef USE_TOOLBAR
  2594. !     if (gui.toolbar && GTK_WIDGET_REALIZED(gui.toolbar)
  2595. !         && GTK_WIDGET_VISIBLE(gui.toolbar))
  2596. !     *screen_h -= gui.toolbar->allocation.height;
  2597. ! #endif
  2598. ! #ifdef WANT_MENU
  2599. !     if (gui.menubar && GTK_WIDGET_REALIZED(gui.menubar)
  2600. !         && GTK_WIDGET_VISIBLE(gui.menubar))
  2601. !     *screen_h -= gui.menubar->allocation.height;
  2602.   #endif
  2603. - }
  2604.   
  2605. ! #if defined(WANT_MENU) || defined(PROTO)
  2606. ! void
  2607. ! gui_mch_enable_menu(int flag)
  2608. ! {
  2609. !     if (flag)
  2610. !     gtk_widget_show(gui.menubar);
  2611. !     else
  2612. !     gtk_widget_hide(gui.menubar);
  2613.   
  2614. !     update_window_manager_hints();
  2615. ! }
  2616.   #endif
  2617.   
  2618. ! 
  2619. ! #if defined(USE_TOOLBAR) || defined(PROTO)
  2620. ! void
  2621. ! gui_mch_show_toolbar(int showit)
  2622. ! {
  2623. !     if (gui.toolbar == NULL)
  2624. !     return;
  2625. ! 
  2626. !     if (!showit) {
  2627. !     if (GTK_WIDGET_VISIBLE(gui.toolbar)) {
  2628. !         gtk_widget_hide(gui.toolbar);
  2629. !         /* wait util this gets done on the server side. */
  2630. !         update_window_manager_hints();
  2631. !     }
  2632. !     } else {
  2633. !     g_assert(p_toolbar != NULL);
  2634.       if (strstr((const char *)p_toolbar, "text")
  2635. !         && strstr((const char *)p_toolbar, "icons")) {
  2636. !         gtk_toolbar_set_style(GTK_TOOLBAR(gui.toolbar), GTK_TOOLBAR_BOTH);
  2637. !     } else if (strstr((const char *)p_toolbar, "text")) {
  2638. !         gtk_toolbar_set_style(GTK_TOOLBAR(gui.toolbar), GTK_TOOLBAR_TEXT);
  2639. !     } else if (strstr((const char *)p_toolbar, "icons")) {
  2640. !         gtk_toolbar_set_style(GTK_TOOLBAR(gui.toolbar), GTK_TOOLBAR_ICONS);
  2641. !     }
  2642. ! 
  2643. !     if (strstr((const char *)p_toolbar, "tooltips"))
  2644. !         gtk_toolbar_set_tooltips(GTK_TOOLBAR(gui.toolbar), TRUE);
  2645.       else
  2646. !         gtk_toolbar_set_tooltips(GTK_TOOLBAR(gui.toolbar), FALSE);
  2647.   
  2648. !     /*
  2649. !      * Black on white will catch the attention of the user more likely then
  2650. !      * black on grey. However due to errors / omissions in GTK+-1.1.5 this
  2651. !      * ceased to work properly. I had been looking after it and there seems
  2652. !      * to be no easy fix for it there. (--mdcki)
  2653. !      *
  2654. !      * This problem still applies for GTK+-1.2.3. (--mdcki)
  2655. !      * And I didn't find any current example where the tooltip colors
  2656. !      * would have need changed correctly.
  2657. !      */
  2658. !     gtk_tooltips_set_colors(GTK_TOOLBAR(gui.toolbar)->tooltips,
  2659. !                 &gui.toolbar->style->white,
  2660. !                 &gui.toolbar->style->black);
  2661. !     if (!GTK_WIDGET_VISIBLE(gui.toolbar)) {
  2662. !         gtk_widget_show(gui.toolbar);
  2663. !         update_window_manager_hints();
  2664. !     }
  2665. !     }
  2666. ! }
  2667.   #endif
  2668.   
  2669.   
  2670. ! #ifdef USE_FONTSET
  2671. ! static GuiFont
  2672. ! gui_mch_get_fontset(char_u * name, int report_error)
  2673. ! {
  2674. !     GdkFont *font;
  2675.   
  2676. !     if (!gui.in_use || name == NULL)
  2677. !     return (GuiFont) 0;
  2678.   
  2679. !     font = gdk_fontset_load((gchar *) name);
  2680.   
  2681. !     if (font == NULL) {
  2682. !     if (report_error)
  2683. !         EMSG2("Unknown fontset: %s", name);
  2684. !     return (GuiFont) 0;
  2685.       }
  2686.   
  2687. !     /* reference this font as beeing in use */
  2688. !     gdk_font_ref(font);
  2689.   
  2690. !     return (GuiFont) font;
  2691. ! }
  2692.   #endif
  2693.   
  2694. ! /*
  2695. !  * Initialise vim to use the font with the given name.
  2696. !  * Return FAIL if the font could not be loaded, OK otherwise.
  2697. !  */
  2698. ! int
  2699. ! gui_mch_init_font(char_u * font_name)
  2700. ! {
  2701. !     GdkFont    *font = NULL;
  2702. !     char    *chunk[28], *sdup, *tmp;
  2703. !     int        len, i;
  2704. ! 
  2705. ! #ifdef USE_FONTSET
  2706. !     {
  2707. !     static char_u *dflt_fontset = NULL;
  2708. ! 
  2709. !     if (gui.fontset)
  2710. !     {
  2711. !         /* If fontset is active, VIM treat all the font as a fontset. */
  2712. !         if (font_name == NULL || vim_strchr(font_name, ',') == NULL)
  2713. !         font_name = dflt_fontset;
  2714. !         font = gui_mch_get_fontset(font_name, FALSE);
  2715. !         if (font == NULL)
  2716. !         return FAIL;
  2717. !     }
  2718. !     else if (font_name == NULL && *p_guifontset)
  2719. !     {
  2720. !         font = gui_mch_get_fontset(p_guifontset, FALSE);
  2721. !         if (font)
  2722. !         {
  2723. !         font_name = p_guifontset;
  2724. !         dflt_fontset = alloc(STRLEN(p_guifontset) + 1);
  2725. !         STRCPY(dflt_fontset, p_guifontset);
  2726. !         }
  2727. !     }
  2728.       }
  2729.   
  2730. !     if (font == NULL)
  2731. ! #endif
  2732. !     {
  2733. !     /*
  2734. !      * If none of the fonts in 'font' could be loaded, try the default,
  2735. !      * which should be present on all X11 servers.
  2736. !      */
  2737. !     if (font_name == NULL)
  2738. !         font_name = (char_u *) DFLT_FONT;
  2739.   
  2740. ! #ifdef GTK_HAVE_FEATURES_1_1_0
  2741. !     if (STRCMP(font_name, "*") == 0) {
  2742. !         /*
  2743. !          * Request for a font handling dialog.
  2744. !          * Not quite sure we should handle this here...
  2745. !          */
  2746. !         /*
  2747. !          * NOTE about font selection widget: this can easily be backported
  2748. !          * to gtk-1.0.x.
  2749. !          */
  2750. !         if (!gui.fontdlg)
  2751. !         {
  2752. !         GtkFontSelectionDialog    *fsd = NULL;
  2753.   
  2754. !         gui.fontdlg = gtk_font_selection_dialog_new("Font Selection");
  2755. !         fsd = GTK_FONT_SELECTION_DIALOG(gui.fontdlg);
  2756. !         if (p_guifont != NULL)
  2757. !             gtk_font_selection_dialog_set_font_name(fsd,
  2758. !                                 (char *)p_guifont);
  2759. ! # ifdef GTK_HAVE_FEATURES_1_1_4
  2760. !         gtk_window_set_modal(GTK_WINDOW(gui.fontdlg), TRUE);
  2761. !         gtk_window_set_transient_for(GTK_WINDOW(gui.fontdlg),
  2762. !                              GTK_WINDOW(gui.mainwin));
  2763. ! # endif
  2764. !         gtk_signal_connect(GTK_OBJECT(gui.fontdlg), "destroy",
  2765. !                    GTK_SIGNAL_FUNC(font_sel_destroy), &gui);
  2766. !         gtk_signal_connect(GTK_OBJECT(fsd->ok_button), "clicked",
  2767. !                    GTK_SIGNAL_FUNC(font_sel_ok), &gui);
  2768. !         gtk_signal_connect(GTK_OBJECT(fsd->cancel_button), "clicked",
  2769. !                    GTK_SIGNAL_FUNC(font_sel_cancel), &gui);
  2770. !         }
  2771. !         if (gui.fontname)
  2772. !         {
  2773. !         g_free(gui.fontname);
  2774. !         gui.fontname = NULL;
  2775. !         }
  2776. !         gtk_window_position(GTK_WINDOW(gui.fontdlg), GTK_WIN_POS_MOUSE);
  2777. !         gtk_widget_show(gui.fontdlg);
  2778. ! # ifdef GTK_HAVE_FEATURES_1_1_4
  2779. !         {
  2780. !         static gchar        *spacings[] = {"c", "m", NULL};
  2781.   
  2782. !         /* In GTK 1.2.3 this must be after the gtk_widget_show() call,
  2783. !          * otherwise everything is blocked for ten seconds. */
  2784. !         gtk_font_selection_dialog_set_filter(
  2785. !             GTK_FONT_SELECTION_DIALOG(gui.fontdlg),
  2786. !             GTK_FONT_FILTER_BASE,
  2787. !             GTK_FONT_ALL, NULL, NULL,
  2788. !             NULL, NULL, spacings, NULL);
  2789. !         }
  2790. ! # endif
  2791.   
  2792. !         while (gui.fontdlg && GTK_WIDGET_VISIBLE(gui.fontdlg))
  2793. !         gtk_main_iteration_do(TRUE);
  2794.   
  2795. !         if (gui.fontname == NULL)
  2796. !         return FAIL;
  2797. !         vim_free(p_guifont);
  2798. !         p_guifont = vim_strsave(gui.fontname);
  2799. !         font_name = p_guifont;
  2800. !     }
  2801. ! #endif
  2802. !     if (font == NULL)
  2803. !         font = gui_mch_get_font(font_name, FALSE);
  2804.   
  2805. -     if (font == NULL)
  2806. -         return FAIL;
  2807. -     }
  2808.   
  2809. !     if (gui.norm_font != 0)
  2810. !     gdk_font_unref(font);
  2811. !     gui.norm_font = font;
  2812. ! #ifdef USE_FONTSET
  2813. !     if (font->type == GDK_FONT_FONTSET)
  2814. !     {
  2815. !     gui.fontset = (GuiFont) font;
  2816. !     gui.char_width = gdk_string_width(font, " ");
  2817.       }
  2818. !     else
  2819.   #endif
  2820. -     {
  2821. -     gui.char_width = ((XFontStruct *)
  2822. -                       GDK_FONT_XFONT(font))->max_bounds.width;
  2823. -     }
  2824.   
  2825. !     gui.char_height = font->ascent + font->descent;
  2826. !     gui.char_ascent = font->ascent;
  2827.   
  2828. !     /* Set the fontname, which will be used for information purposes */
  2829. !     hl_set_font_name(font_name);
  2830.   
  2831. !     if (font->type != GDK_FONT_FONTSET)
  2832. !     {
  2833. !     /* There is only one excuse I can give for the following attempt
  2834. !      * to manage font styles:
  2835. !      *
  2836. !      * I HATE THE BRAIN DEAD WAY X11 IS HANDLING FONTS (--mdcki)
  2837. !      */
  2838. !     if ((sdup = g_strdup((const char *)font_name)) == NULL)
  2839. !         return FAIL;
  2840.   
  2841. !     /* slipt up the whole */
  2842. !     i = 0;
  2843. !     for (tmp = sdup; *tmp != '\0'; ++tmp)
  2844. !         if (*tmp == '-')
  2845. !         {
  2846. !         *tmp = '\0';
  2847. !         chunk[i] = tmp + 1;
  2848. !         ++i;
  2849. !         }
  2850.   
  2851. !     g_free(sdup);
  2852.   
  2853. !     if (i == 14)
  2854. !     {
  2855. !         char *bold_name = NULL;
  2856. !         char *ital_name = NULL;
  2857. !         char *italbold_name = NULL;
  2858.   
  2859. !         /* font name was compleate */
  2860. !         len = strlen((const char *)font_name) + 32;
  2861. !         bold_name = (char *)alloc(len);
  2862. !         ital_name = (char *)alloc(len);
  2863. !         italbold_name = (char *)alloc(len);
  2864. !         if (bold_name == NULL || ital_name == NULL || italbold_name == NULL)
  2865. !         {
  2866. !         vim_free(bold_name);
  2867. !         vim_free(ital_name);
  2868. !         vim_free(italbold_name);
  2869. !         return FAIL;
  2870. !         }
  2871.   
  2872. !         *bold_name = '\0';
  2873. !         *ital_name = '\0';
  2874. !         *italbold_name = '\0';
  2875.   
  2876. !         for (i = 0; i < 14; ++i)
  2877. !         {
  2878. !         strcat(bold_name, "-");
  2879. !         strcat(ital_name, "-");
  2880. !         strcat(italbold_name, "-");
  2881. !         strcat(bold_name, (i != 2) ? chunk[i] : "bold");
  2882. !         strcat(ital_name, (i != 3) ? chunk[i] : "o");
  2883.   
  2884. !         if (i != 2 && i != 3)
  2885. !             strcat(italbold_name, chunk[i]);
  2886. !         else
  2887. !         {
  2888. !             if (i == 2)
  2889. !             strcat(italbold_name, "bold");
  2890. !             else if (i == 3)
  2891. !             strcat(italbold_name, "o");
  2892. !         }
  2893. !         }
  2894.   
  2895. !         font = gui_mch_get_font((char_u *)bold_name, FALSE);
  2896. !         if (font != NULL)
  2897. !         gui.bold_font = font;
  2898. !         else if (gui.bold_font)
  2899. !         {
  2900. !         gdk_font_unref(gui.bold_font);
  2901. !         gui.bold_font = NULL;
  2902. !         }
  2903.   
  2904. !         font = gui_mch_get_font((char_u *)ital_name, FALSE);
  2905. !         if (font != NULL)
  2906. !         gui.ital_font = font;
  2907. !         else if (gui.ital_font)
  2908. !         {
  2909. !         gdk_font_unref(gui.ital_font);
  2910. !         gui.ital_font = NULL;
  2911. !         }
  2912.   
  2913. !         font = gui_mch_get_font((char_u *)italbold_name, FALSE);
  2914. !         if (font != NULL)
  2915. !         gui.boldital_font = font;
  2916. !         else if (gui.boldital_font)
  2917. !         {
  2918. !         gdk_font_unref(gui.boldital_font);
  2919. !         gui.boldital_font = NULL;
  2920. !         }
  2921.   
  2922. -         vim_free(bold_name);
  2923. -         vim_free(ital_name);
  2924. -         vim_free(italbold_name);
  2925. -     }
  2926. -     }
  2927.   
  2928. !     /* Synchronize the fonts used in user input dialogs, since otherwise
  2929. !      * search/replace will be esp annoyig in case of international font usage.
  2930. !      */
  2931. !     gui_gtk_synch_fonts();
  2932.   
  2933. ! #ifdef USE_XIM
  2934. !     /* Adjust input management behaviour to the capabilities of the new
  2935. !      * fontset */
  2936. !     xim_decide_input_style();
  2937. !     if (xim_get_status_area_height())
  2938. !     {
  2939. !     /* Status area is required.  Just create the empty label so that
  2940. !      * mainwin will allocate the extra space for status area. */
  2941. !     GtkWidget *label = gtk_label_new("       ");
  2942.   
  2943. !     gtk_widget_set_usize(label, 20, gui.char_height + 2);
  2944. !     gtk_box_pack_end(GTK_BOX(GTK_BIN(gui.mainwin)->child), label,
  2945. !                                  FALSE, FALSE, 0);
  2946. !     gtk_widget_show(label);
  2947.       }
  2948. - #endif
  2949.   
  2950. !     /* Preserve the logical dimensions of the screen. */
  2951.       update_window_manager_hints();
  2952.   
  2953. !     return OK;
  2954. ! }
  2955.   
  2956.   
  2957. ! GuiFont
  2958. ! gui_mch_get_font(char_u * name, int report_error)
  2959. ! {
  2960. !     GdkFont *font;
  2961.   
  2962. !     if (!gui.in_use || name == NULL)    /* can't do this when GUI not running */
  2963. !     return (GuiFont) 0;
  2964.   
  2965. ! #ifdef USE_FONTSET
  2966. !     if (gui.fontset)
  2967. !     /* If fontset is active, VIM treat all the font as a fontset */
  2968. !     return gui_mch_get_fontset(name, report_error);
  2969. !     else if (vim_strchr(name, ','))
  2970. !     return (GuiFont)0;
  2971.   #endif
  2972.   
  2973. !     font = gdk_font_load((const gchar *) name);
  2974.   
  2975. !     if (font == NULL) {
  2976. !     if (report_error)
  2977. !         EMSG2("Unknown font: %s", name);
  2978. !     return (GuiFont) 0;
  2979. !     }
  2980.   
  2981. !     /* reference this font as beeing in use */
  2982. !     gdk_font_ref(font);
  2983. !     if (((XFontStruct *) GDK_FONT_XFONT(font))->max_bounds.width
  2984. !     != ((XFontStruct *) GDK_FONT_XFONT(font))->min_bounds.width) {
  2985. !     EMSG2("Font \"%s\" is not fixed-width", name);
  2986. !     gdk_font_unref(font);
  2987.   
  2988. !     return (GuiFont) 0;
  2989. !     }
  2990. !     return (GuiFont) font;
  2991.   }
  2992.   
  2993. ! /*
  2994. !  * Set the current text font.
  2995. !  * Since we create all GC on demand, we use just gui.current_font to
  2996. !  * indicate the desired current font.
  2997. !  */
  2998.   void
  2999. ! gui_mch_set_font(GuiFont font)
  3000.   {
  3001. !     gui.current_font = font;
  3002.   }
  3003.   
  3004. - #if 0 /* not used */
  3005.   /*
  3006. !  * Return TRUE if the two fonts given are equivalent.
  3007.    */
  3008.   int
  3009. ! gui_mch_same_font(GuiFont f1, GuiFont f2)
  3010.   {
  3011. !     return gdk_font_equal((GdkFont *) f1, (GdkFont *) f2);
  3012. ! }
  3013.   #endif
  3014.   
  3015.   /*
  3016. !  * If a font is not going to be used, free its structure.
  3017.    */
  3018.   void
  3019. ! gui_mch_free_font(GuiFont font)
  3020.   {
  3021. !     if (font)
  3022. !     gdk_font_unref((GdkFont *) font);
  3023.   }
  3024.   
  3025. - 
  3026.   /*
  3027. !  * Return the Pixel value (color) for the given color name.  This routine was
  3028. !  * pretty much taken from example code in the Silicon Graphics OSF/Motif
  3029. !  * Programmer's Guide.
  3030. !  * Return -1 for error.
  3031.    */
  3032. ! GuiColor
  3033. ! gui_mch_get_color(char_u * name)
  3034.   {
  3035. !     int i;
  3036. !     static char *(vimnames[][2]) =
  3037. !     {
  3038. !     /* A number of colors that some X11 systems don't have */
  3039. !     {"LightRed", "#FFA0A0"},
  3040. !     {"LightGreen", "#80FF80"},
  3041. !     {"LightMagenta", "#FFA0FF"},
  3042. !     {"DarkCyan", "#008080"},
  3043. !     {"DarkBlue", "#0000C0"},
  3044. !     {"DarkRed", "#C00000"},
  3045. !     {"DarkMagenta", "#C000C0"},
  3046. !     {"DarkGrey", "#C0C0C0"},
  3047. !     {NULL, NULL}
  3048. !     };
  3049. ! 
  3050. !     if (!gui.in_use)        /* can't do this when GUI not running */
  3051. !     return (GuiColor)(-1);
  3052. ! 
  3053. !     while (name != NULL) {
  3054. !     GdkColor color;
  3055. ! 
  3056. !     if (gdk_color_parse((const gchar *)name, &color)) {
  3057. !         GdkColormap *colormap;
  3058. !         colormap = gtk_widget_get_colormap(gui.drawarea);
  3059. !         gdk_color_alloc(colormap, &color);
  3060.   
  3061. !         return (GuiColor) color.pixel;
  3062. !     }
  3063. !     /* add a few builtin names */
  3064. !     for (i = 0;; ++i) {
  3065. !         if (vimnames[i][0] == NULL) {
  3066. !         name = NULL;
  3067. !         break;
  3068. !         }
  3069. !         if (STRICMP(name, vimnames[i][0]) == 0) {
  3070. !         name = (char_u *) vimnames[i][1];
  3071. !         break;
  3072. !         }
  3073. !     }
  3074. !     }
  3075.   
  3076. !     return (GuiColor)(-1);
  3077.   }
  3078.   
  3079. - /*
  3080. -  * Set the current text foreground color.
  3081. -  */
  3082. - void
  3083. - gui_mch_set_fg_color(GuiColor color)
  3084. - {
  3085. -     gui.fgcolor->pixel = (Pixel) color;
  3086. - }
  3087.   
  3088.   /*
  3089. !  * Set the current text background color.
  3090.    */
  3091.   void
  3092. ! gui_mch_set_bg_color(GuiColor color)
  3093.   {
  3094. !     gui.bgcolor->pixel = (Pixel) color;
  3095.   }
  3096.   
  3097. ! /*
  3098. !  * Use the blank mouse pointer or not.
  3099. !  *
  3100. !  * hide: TRUE = use blank ptr, FALSE = use parent ptr
  3101. !  */
  3102.   void
  3103. ! gui_mch_mousehide(int hide)
  3104.   {
  3105. !     if (gui.pointer_hidden != hide) {
  3106. !     if (gui.drawarea->window && gui.blank_pointer) {
  3107. !         if (hide)
  3108. !         gdk_window_set_cursor(gui.drawarea->window, gui.blank_pointer);
  3109. !         else
  3110. !         gdk_window_set_cursor(gui.drawarea->window, NULL);
  3111. !     }
  3112. !     gui.pointer_hidden = hide;
  3113. !     }
  3114.   }
  3115.   
  3116.   void
  3117. ! gui_mch_draw_string(int row, int col, char_u * s, int len, int flags)
  3118.   {
  3119. !     GdkGC *gc;
  3120. ! 
  3121. !     if (gui.current_font == NULL || gui.drawarea->window == NULL)
  3122.       return;
  3123.   
  3124. ! #if defined(USE_FONTSET) && defined(MULTI_BYTE)
  3125. !     if (gui.fontset)
  3126. !     {
  3127. !     if (col > 0 && mb_isbyte1(LinePointers[row], col - 1))
  3128. !     {
  3129. !         col++;
  3130. !         len--;
  3131. !         s++;
  3132.       }
  3133. -     if (len == 1 && IsLeadByte(*s))
  3134. -         len = 2;
  3135. -     }
  3136. - #endif
  3137.   
  3138. !     gc = gdk_gc_new(gui.drawarea->window);
  3139. !     gdk_gc_set_exposures(gc, gui.visibility != GDK_VISIBILITY_UNOBSCURED);
  3140. ! 
  3141. !     if (flags & DRAW_TRANSP) {
  3142. !     gdk_gc_set_foreground(gc, gui.fgcolor);
  3143. !     gdk_draw_text(gui.drawarea->window,
  3144. !               gui.current_font,
  3145. !               gc,
  3146. !               TEXT_X(col), TEXT_Y(row),
  3147. !               (const gchar *)s, len);
  3148. !     } else {
  3149. !     int width;
  3150. !     int height;
  3151. !     width = gdk_text_width(gui.current_font, (const gchar *)s, len);
  3152. !     height = gui.char_height;
  3153. ! 
  3154. !     gdk_gc_set_foreground(gc, gui.bgcolor);
  3155. !     gdk_draw_rectangle(gui.drawarea->window,
  3156. !                gc,
  3157. !                TRUE,
  3158. !                FILL_X(col), FILL_Y(row), width, height);
  3159. !     gdk_gc_set_foreground(gc, gui.fgcolor);
  3160. !     gdk_draw_text(gui.drawarea->window,
  3161. !               gui.current_font,
  3162. !               gc,
  3163. !               TEXT_X(col), TEXT_Y(row),
  3164. !               (const gchar *)s, len);
  3165. !     }
  3166. ! 
  3167. !     /* redraw the contents with an offset of 1 to emulate bold */
  3168. !     if (flags & DRAW_BOLD) {
  3169. !     gdk_draw_text(gui.drawarea->window,
  3170. !               gui.current_font,
  3171. !               gc,
  3172. !               TEXT_X(col) + 1, TEXT_Y(row),
  3173. !               (const gchar *)s, len);
  3174. !     }
  3175. ! 
  3176. !     if (flags & DRAW_UNDERL) {
  3177. !     gdk_draw_line(gui.drawarea->window,
  3178. !               gc, FILL_X(col),
  3179. !     FILL_Y(row + 1) - 1, FILL_X(col + len) - 1, FILL_Y(row + 1) - 1);
  3180. !     }
  3181. !     gdk_gc_destroy(gc);
  3182. ! }
  3183. ! 
  3184. ! /*
  3185. !  * Return OK if the key with the termcap name "name" is supported.
  3186. !  */
  3187. ! int
  3188. ! gui_mch_haskey(char_u * name)
  3189. ! {
  3190. !     int i;
  3191. ! 
  3192. !     for (i = 0; special_keys[i].key_sym != 0; i++)
  3193. !     if (name[0] == special_keys[i].code0 &&
  3194. !         name[1] == special_keys[i].code1)
  3195. !         return OK;
  3196. !     return FAIL;
  3197. ! }
  3198.   
  3199. ! #if defined(WANT_TITLE) || defined(PROTO)
  3200. ! /*
  3201. !  * Return the text window-id and display.  Only required for X-based GUI's
  3202. !  */
  3203. ! int
  3204. ! gui_get_x11_windis(Window * win, Display ** dis)
  3205. ! {
  3206. !     /*
  3207. !      * This is currently only used by the code which is handling the
  3208. !      * window manager title of this program.
  3209. !      */
  3210. !     *dis = GDK_DISPLAY();
  3211. !     if (gui.mainwin->window) {
  3212. !     *win = GDK_WINDOW_XWINDOW(gui.mainwin->window);
  3213. !     return OK;
  3214.       }
  3215. -     *win = 0;
  3216. -     return FAIL;
  3217.   }
  3218.   #endif
  3219.   
  3220. - void
  3221. - gui_mch_beep()
  3222. - {
  3223. -     gdk_beep();
  3224. - }
  3225.   
  3226. ! void
  3227. ! gui_mch_flash()
  3228.   {
  3229. !     GdkGCValues values;
  3230. !     GdkGC *invert_gc;
  3231. !     GdkColor foreground;
  3232. !     GdkColor background;
  3233. ! 
  3234. !     if (gui.drawarea->window == NULL)
  3235. !     return;
  3236.   
  3237. !     foreground.pixel = gui.norm_pixel ^ gui.back_pixel;
  3238. !     background.pixel = gui.norm_pixel ^ gui.back_pixel;
  3239.   
  3240. !     values.foreground = foreground;
  3241. !     values.background = background;
  3242. !     values.function = GDK_XOR;
  3243. !     invert_gc = gdk_gc_new_with_values(gui.drawarea->window,
  3244. !                        &values,
  3245. !                        GDK_GC_FOREGROUND |
  3246. !                        GDK_GC_BACKGROUND |
  3247. !                        GDK_GC_FUNCTION);
  3248. !     gdk_gc_set_exposures(invert_gc, gui.visibility != GDK_VISIBILITY_UNOBSCURED);
  3249.   
  3250. !     /* Do a visual beep by changing back and forth in some undetermined way,
  3251. !      * the foreground and background colors.  This is due to the fact that
  3252. !      * there can't be really any prediction about the effects of XOR on
  3253. !      * arbitrary X11 servers. However this seems to be enought for what we
  3254. !      * intend it to do.
  3255. !      */
  3256. !     gdk_draw_rectangle(gui.drawarea->window, invert_gc,
  3257. !                TRUE,
  3258. !                0, 0,
  3259. !                FILL_X((int) Columns) + gui.border_offset,
  3260. !                FILL_Y((int) Rows) + gui.border_offset);
  3261.   
  3262. !     gdk_flush();
  3263. !     ui_delay(20L, TRUE);    /* wait 1/50 of a second */
  3264. !     gdk_draw_rectangle(gui.drawarea->window, invert_gc,
  3265. !                TRUE,
  3266. !                0, 0,
  3267. !                FILL_X((int) Columns) + gui.border_offset,
  3268. !                FILL_Y((int) Rows) + gui.border_offset);
  3269.   
  3270. !     gdk_gc_destroy(invert_gc);
  3271.   }
  3272.   
  3273.   /*
  3274. !  * Invert a rectangle from row r, column c, for nr rows and nc columns.
  3275.    */
  3276. ! void
  3277. ! gui_mch_invert_rectangle(int r, int c, int nr, int nc)
  3278.   {
  3279. !     GdkGCValues values;
  3280. !     GdkGC *invert_gc;
  3281. !     GdkColor foreground;
  3282. !     GdkColor background;
  3283.   
  3284. !     if (gui.drawarea->window == NULL)
  3285. !     return;
  3286.   
  3287. !     foreground.pixel = gui.norm_pixel ^ gui.back_pixel;
  3288. !     background.pixel = gui.norm_pixel ^ gui.back_pixel;
  3289.   
  3290. !     values.foreground = foreground;
  3291. !     values.background = background;
  3292. !     values.function = GDK_XOR;
  3293. !     invert_gc = gdk_gc_new_with_values(gui.drawarea->window,
  3294. !                        &values,
  3295. !                        GDK_GC_FOREGROUND |
  3296. !                        GDK_GC_BACKGROUND |
  3297. !                        GDK_GC_FUNCTION);
  3298. !     gdk_gc_set_exposures(invert_gc, gui.visibility != GDK_VISIBILITY_UNOBSCURED);
  3299. !     gdk_draw_rectangle(gui.drawarea->window, invert_gc,
  3300. !                TRUE,
  3301. !                FILL_X(c), FILL_Y(r),
  3302. !                (nc) * gui.char_width, (nr) * gui.char_height);
  3303. !     gdk_gc_destroy(invert_gc);
  3304.   }
  3305.   
  3306. ! /*
  3307. !  * Iconify the GUI window.
  3308. !  */
  3309. ! void
  3310. ! gui_mch_iconify()
  3311.   {
  3312. !     XIconifyWindow(GDK_DISPLAY(),
  3313. !            GDK_WINDOW_XWINDOW(gui.mainwin->window),
  3314. !            DefaultScreen(GDK_DISPLAY()));
  3315.   }
  3316.   
  3317.   /*
  3318. !  * Draw a cursor without focus.
  3319.    */
  3320. ! void
  3321. ! gui_mch_draw_hollow_cursor(GuiColor color)
  3322.   {
  3323. !     GdkGC *gc;
  3324.   
  3325. !     if (gui.drawarea->window == NULL)
  3326. !     return;
  3327.   
  3328. !     gui_mch_set_fg_color(color);
  3329.   
  3330. !     gc = gdk_gc_new(gui.drawarea->window);
  3331. !     gdk_gc_set_exposures(gc, gui.visibility != GDK_VISIBILITY_UNOBSCURED);
  3332. !     gdk_gc_set_foreground(gc, gui.fgcolor);
  3333. ! #if defined(USE_FONTSET) && defined(MULTI_BYTE)
  3334. !     if (gui.fontset)
  3335.       {
  3336. !     if (IsLeadByte(LinePointers[gui.row][gui.col])
  3337. ! # ifdef HANGUL_INPUT
  3338. !         || composing_hangul
  3339.   # endif
  3340. !        )
  3341. !         gdk_draw_rectangle(gui.drawarea->window, gc,
  3342. !                    FALSE,
  3343. !                    FILL_X(gui.col), FILL_Y(gui.row),
  3344. !                    2*gui.char_width - 1, gui.char_height - 1);
  3345. !     else
  3346. !         gdk_draw_rectangle(gui.drawarea->window, gc,
  3347. !                    FALSE,
  3348. !                    FILL_X(gui.col), FILL_Y(gui.row),
  3349. !                    gui.char_width - 1, gui.char_height - 1);
  3350.       }
  3351.       else
  3352.   #endif
  3353. !     gdk_draw_rectangle(gui.drawarea->window, gc,
  3354. !                FALSE,
  3355. !                FILL_X(gui.col), FILL_Y(gui.row),
  3356. !                gui.char_width - 1, gui.char_height - 1);
  3357. !     gdk_gc_destroy(gc);
  3358. ! }
  3359.   
  3360. ! /*
  3361. !  * Draw part of a cursor, "w" pixels wide, and "h" pixels high, using
  3362. !  * color "color".
  3363. !  */
  3364. ! void
  3365. ! gui_mch_draw_part_cursor(int w, int h, GuiColor color)
  3366. ! {
  3367. !     GdkGC *gc;
  3368.   
  3369. !     if (gui.drawarea->window == NULL)
  3370. !     return;
  3371.   
  3372. !     gui_mch_set_fg_color(color);
  3373.   
  3374. !     gc = gdk_gc_new(gui.drawarea->window);
  3375. !     gdk_gc_set_exposures(gc, gui.visibility != GDK_VISIBILITY_UNOBSCURED);
  3376. !     gdk_gc_set_foreground(gc, gui.fgcolor);
  3377. !     gdk_draw_rectangle(gui.drawarea->window, gc,
  3378. !                TRUE,
  3379. ! #ifdef RIGHTLEFT
  3380. !     /* vertical line should be on the right of current point */
  3381. !        State != CMDLINE && curwin->w_p_rl ? FILL_X(gui.col + 1) - w :
  3382. ! #endif
  3383. !                FILL_X(gui.col),
  3384. !                FILL_Y(gui.row) + gui.char_height - h,
  3385. !                w, h);
  3386. !     gdk_gc_destroy(gc);
  3387. ! }
  3388.   
  3389. ! #ifndef GTK_HAVE_FEATURES_1_1_0
  3390. ! static gint
  3391. ! idle_function(GtkWidget * label)
  3392. ! {
  3393. !     if (gtk_main_level() > 0)
  3394. !     gtk_main_quit();
  3395.   
  3396. !     return FALSE;
  3397.   }
  3398. - #endif
  3399.   
  3400.   
  3401. ! /*
  3402. !  * Catch up with any queued X11 events.  This may put keyboard input into the
  3403. !  * input buffer, call resize call-backs, trigger timers etc.  If there is
  3404. !  * nothing in the X11 event queue (& no timers pending), then we return
  3405. !  * immediately.
  3406. !  */
  3407. ! void
  3408. ! gui_mch_update()
  3409.   {
  3410. ! #ifdef GTK_HAVE_FEATURES_1_1_0
  3411. !     while (gtk_events_pending() && !vim_is_input_buf_full())
  3412. !     gtk_main_iteration_do(FALSE);
  3413. ! #else
  3414. !     int pending;
  3415.   
  3416. !     /* Somehow the above loop hangs on GTK 1.0.6.  Use the idle_function() to
  3417. !      * work around this weird problem. */
  3418. !     while (((pending = gtk_events_pending()) > 1) && !vim_is_input_buf_full())
  3419. !     gtk_main_iteration();
  3420.   
  3421. !     if ((pending == 1) && !vim_is_input_buf_full()) {
  3422. !     gtk_idle_add((GtkFunction)idle_function, gui.mainwin);
  3423. !     gtk_main_iteration_do(FALSE);
  3424. !     }
  3425.   #endif
  3426. - }
  3427.   
  3428. ! static gint
  3429. ! input_timer_cb(gpointer data)
  3430. ! {
  3431. !     int *timed_out = (int *) data;
  3432.   
  3433. !     /* Just inform the caller about the accurence of it */
  3434. !     *timed_out = TRUE;
  3435.   
  3436. !     if (gtk_main_level() > 0)
  3437. !     gtk_main_quit();
  3438.   
  3439. !     return FALSE;        /* don't happen again */
  3440.   }
  3441.   
  3442.   /*
  3443. !  * GUI input routine called by gui_wait_for_chars().  Waits for a character
  3444. !  * from the keyboard.
  3445. !  *  wtime == -1     Wait forever.
  3446. !  *  wtime == 0      This should never happen.
  3447. !  *  wtime > 0       Wait wtime milliseconds for a character.
  3448. !  * Returns OK if a character was found to be available within the given time,
  3449. !  * or FAIL otherwise.
  3450.    */
  3451. ! int
  3452. ! gui_mch_wait_for_chars(long wtime)
  3453.   {
  3454. !     int focus;
  3455. !     guint timer;
  3456. ! 
  3457. !     static int timed_out;
  3458. ! 
  3459. !     timed_out = FALSE;
  3460. ! 
  3461. !     /* this timeout makes sure that we will return if no characters arrived in
  3462. !      * time */
  3463. ! 
  3464. !     if (wtime > 0)
  3465. !     timer = gtk_timeout_add(wtime, input_timer_cb, &timed_out);
  3466. !     else
  3467. !     timer = 0;
  3468. ! 
  3469. !     focus = gui.in_focus;
  3470. ! 
  3471. !     do {
  3472. !     /* Stop or start blinking when focus changes */
  3473. !     if (gui.in_focus != focus) {
  3474. !         if (gui.in_focus)
  3475. !         gui_mch_start_blink();
  3476. !         else
  3477. !         gui_mch_stop_blink();
  3478. !         focus = gui.in_focus;
  3479. !     }
  3480. ! 
  3481. !     /*
  3482. !      * Loop in GTK+ processing  until a timeout or input occurs.
  3483. !      */
  3484. !     gtk_main();
  3485. ! 
  3486. !     /* Got char, return immediately */
  3487. !     if (!vim_is_input_buf_empty()) {
  3488. !         if (timer != 0 && !timed_out)
  3489. !         gtk_timeout_remove(timer);
  3490. !         return OK;
  3491. !     }
  3492. !     } while (wtime < 0 || !timed_out);
  3493. ! 
  3494. !     /*
  3495. !      * Flush all eventually pending (drawing) events.
  3496. !      */
  3497. !     gui_mch_update();
  3498. ! 
  3499. !     return FAIL;
  3500.   }
  3501.   
  3502. ! 
  3503. ! /****************************************************************************
  3504. !  * Output drawing routines.
  3505. !  ****************************************************************************/
  3506. ! 
  3507. ! 
  3508. ! /* Flush any output to the screen */
  3509. ! void
  3510. ! gui_mch_flush()
  3511.   {
  3512. !     gdk_flush();
  3513.   }
  3514.   
  3515.   /*
  3516. !  * Clear a rectangular region of the screen from text pos (row1, col1) to
  3517. !  * (row2, col2) inclusive.
  3518.    */
  3519.   void
  3520. ! gui_mch_clear_block(int row1, int col1, int row2, int col2)
  3521.   {
  3522. !     GdkGC *gc;
  3523. !     GdkColor color;
  3524.   
  3525. -     if (gui.drawarea->window == NULL)
  3526. -     return;
  3527.   
  3528. !     color.pixel = gui.back_pixel;
  3529.   
  3530. !     gc = gdk_gc_new(gui.drawarea->window);
  3531. !     gdk_gc_set_exposures(gc, gui.visibility != GDK_VISIBILITY_UNOBSCURED);
  3532. !     gdk_gc_set_foreground(gc, &color);
  3533.   
  3534. !     /*
  3535. !      * Clear one extra pixel at the right, for when bold characters have
  3536. !      * spilled over to the next column.  This can erase part of the next
  3537. !      * character however in the usage context of this function it will be
  3538. !      * overriden immediately by the correct character again.
  3539. !      */
  3540.   
  3541. !     gdk_draw_rectangle(gui.drawarea->window, gc, TRUE,
  3542. !                FILL_X(col1), FILL_Y(row1),
  3543. !                (col2 - col1 + 1) * gui.char_width + 1,
  3544. !                (row2 - row1 + 1) * gui.char_height);
  3545. !     gdk_gc_destroy(gc);
  3546. ! }
  3547.   
  3548. ! void
  3549. ! gui_mch_clear_all(void)
  3550. ! {
  3551. !     if (gui.drawarea->window == NULL)
  3552. !     return;
  3553.   
  3554. !     gdk_window_clear(gui.drawarea->window);
  3555.   }
  3556.   
  3557.   /*
  3558. !  * Scroll the text between gui.scroll_region_top & gui.scroll_region_bot by the
  3559. !  * number of lines given.  Positive scrolls down (text goes up) and negative
  3560. !  * scrolls up (text goes down).
  3561.    */
  3562. ! static void check_copy_area(void)
  3563.   {
  3564. !     XEvent event;
  3565. !     XGraphicsExposeEvent *gevent;
  3566. ! 
  3567. !     if (gui.visibility != GDK_VISIBILITY_PARTIAL)
  3568. !     return;
  3569. ! 
  3570. !     gdk_flush();
  3571. ! 
  3572. !     /* Wait to check whether the scroll worked or not */
  3573. !     for (;;) {
  3574. !     if (XCheckTypedEvent(GDK_DISPLAY(), NoExpose, &event))
  3575. !         return;        /* The scroll worked. */
  3576.   
  3577. !     if (XCheckTypedEvent(GDK_DISPLAY(), GraphicsExpose, &event)) {
  3578. !         gevent = (XGraphicsExposeEvent *) & event;
  3579. !         gui_redraw(gevent->x, gevent->y, gevent->width, gevent->height);
  3580. !         if (gevent->count == 0)
  3581. !         return;        /* This was the last expose event */
  3582. !     }
  3583. !     gdk_flush();
  3584. !     }
  3585.   }
  3586.   
  3587.   /*
  3588. !  * Delete the given number of lines from the given row, scrolling up any
  3589. !  * text further down within the scroll region.
  3590.    */
  3591.   void
  3592. ! gui_mch_delete_lines(int row, int num_lines)
  3593.   {
  3594. !     if (gui.visibility == GDK_VISIBILITY_FULLY_OBSCURED)
  3595. !     return;            /* Can't see the window */
  3596. ! 
  3597. !     if (num_lines <= 0)
  3598. !     return;
  3599. ! 
  3600. !     if (row + num_lines > gui.scroll_region_bot) {
  3601. !     /* Scrolled out of region, just blank the lines out */
  3602. !     gui_clear_block(row, 0, gui.scroll_region_bot, (int) Columns - 1);
  3603. !     } else {
  3604. !     GdkGC *gc;
  3605. ! 
  3606. !     gc = gdk_gc_new(gui.drawarea->window);
  3607. !     gdk_gc_set_exposures(gc, gui.visibility != GDK_VISIBILITY_UNOBSCURED);
  3608. !     gdk_gc_set_foreground(gc, gui.fgcolor);
  3609. !     gdk_gc_set_background(gc, gui.bgcolor);
  3610. ! 
  3611. !     /* copy one extra pixel, for when bold has spilled over */
  3612. !     gdk_window_copy_area(gui.drawarea->window, gc,
  3613. !                  FILL_X(0), FILL_Y(row),
  3614. !                  gui.drawarea->window,
  3615. !                  FILL_X(0), FILL_Y(row + num_lines),
  3616. !                  gui.char_width * (int) Columns + 1,
  3617. !                  gui.char_height *
  3618. !                 (gui.scroll_region_bot - row - num_lines + 1));
  3619. !     gdk_gc_destroy(gc);
  3620. ! 
  3621. !     /* Update gui.cursor_row if the cursor scrolled or copied over */
  3622. !     if (gui.cursor_row >= row) {
  3623. !         if (gui.cursor_row < row + num_lines)
  3624. !         gui.cursor_is_valid = FALSE;
  3625. !         else if (gui.cursor_row <= gui.scroll_region_bot)
  3626. !         gui.cursor_row -= num_lines;
  3627.       }
  3628. !     gui_clear_block(gui.scroll_region_bot - num_lines + 1, 0,
  3629. !             gui.scroll_region_bot, (int) Columns - 1);
  3630. !     check_copy_area();
  3631.       }
  3632.   }
  3633.   
  3634. - /*
  3635. -  * Insert the given number of lines before the given row, scrolling down any
  3636. -  * following text within the scroll region.
  3637. -  */
  3638.   void
  3639. ! gui_mch_insert_lines(int row, int num_lines)
  3640.   {
  3641. !     if (gui.visibility == GDK_VISIBILITY_FULLY_OBSCURED)
  3642. !     return;            /* Can't see the window */
  3643.   
  3644. !     if (num_lines <= 0)
  3645.       return;
  3646.   
  3647. !     if (row + num_lines > gui.scroll_region_bot) {
  3648. !     /* Scrolled out of region, just blank the lines out */
  3649. !     gui_clear_block(row, 0, gui.scroll_region_bot, (int) Columns - 1);
  3650.       } else {
  3651. !     GdkGC *gc;
  3652.   
  3653. !     gc = gdk_gc_new(gui.drawarea->window);
  3654. !     gdk_gc_set_exposures(gc, gui.visibility != GDK_VISIBILITY_UNOBSCURED);
  3655.       gdk_gc_set_foreground(gc, gui.fgcolor);
  3656. !     gdk_gc_set_background(gc, gui.bgcolor);
  3657.   
  3658. !     /* copy one extra pixel, for when bold has spilled over */
  3659. !     gdk_window_copy_area(gui.drawarea->window, gc,
  3660. !                  FILL_X(0), FILL_Y(row + num_lines),
  3661. !                  gui.drawarea->window,
  3662. !                  FILL_X(0), FILL_Y(row),
  3663. !                  gui.char_width * (int) Columns + 1,
  3664. !                  gui.char_height *
  3665. !                 (gui.scroll_region_bot - row - num_lines + 1));
  3666. !     gdk_gc_destroy(gc);
  3667.   
  3668. !     /* Update gui.cursor_row if the cursor scrolled or copied over */
  3669. !     if (gui.cursor_row >= gui.row) {
  3670. !         if (gui.cursor_row <= gui.scroll_region_bot - num_lines)
  3671. !         gui.cursor_row += num_lines;
  3672. !         else if (gui.cursor_row <= gui.scroll_region_bot)
  3673. !         gui.cursor_is_valid = FALSE;
  3674. !     }
  3675. !     gui_clear_block(row, 0, row + num_lines - 1, (int) Columns - 1);
  3676. !     check_copy_area();
  3677.       }
  3678.   }
  3679.   
  3680.   /*
  3681. !  * X Selection stuff, for cutting and pasting text to other windows.
  3682.    */
  3683. ! void
  3684. ! clip_mch_request_selection()
  3685.   {
  3686. !     /* First try to get the content of our own special clipboard. */
  3687. !     received_selection = RS_NONE;
  3688. !     (void)gtk_selection_convert(gui.drawarea,
  3689. !                     GDK_SELECTION_PRIMARY, clipboard.atom,
  3690. !                     GDK_CURRENT_TIME);
  3691. !     while (received_selection == RS_NONE)
  3692. !     gtk_main();        /* wait for selection_received_event */
  3693.   
  3694. !     if (received_selection == RS_FAIL)
  3695. !     {
  3696. !     /* Now try to get it out of the usual string selection. */
  3697. !     received_selection = RS_NONE;
  3698. !     (void)gtk_selection_convert(gui.drawarea, GDK_SELECTION_PRIMARY,
  3699. !                     GDK_TARGET_STRING,
  3700. !                     GDK_CURRENT_TIME);
  3701. !     while (received_selection == RS_NONE)
  3702. !         gtk_main();        /* wait for selection_received_event */
  3703.       }
  3704.   }
  3705.   
  3706.   void
  3707. ! clip_mch_lose_selection()
  3708.   {
  3709. !     gtk_selection_owner_set(gui.drawarea,
  3710. !                      GDK_SELECTION_PRIMARY, GDK_CURRENT_TIME);
  3711. !     gui_mch_update();
  3712.   }
  3713.   
  3714.   /*
  3715. !  * Check whatever we allready own the selection
  3716.    */
  3717. ! int
  3718. ! clip_mch_own_selection()
  3719.   {
  3720. ! #if 0
  3721. !     return gdk_selection_owner_get(
  3722. !                 GDK_SELECTION_PRIMARY) == gui.drawarea->window;
  3723. ! #else
  3724. !     /* At this point we always already own the clipboard */
  3725.   
  3726. !     return OK;
  3727. ! #endif
  3728.   }
  3729.   
  3730.   /*
  3731. !  * Send the current selection to the clipboard.
  3732.    */
  3733.   void
  3734. ! clip_mch_set_selection()
  3735.   {
  3736. !     gtk_selection_owner_set(gui.drawarea,
  3737. !                 GDK_SELECTION_PRIMARY,
  3738. !                 GDK_CURRENT_TIME);
  3739. !     gui_mch_update();
  3740.   }
  3741.   
  3742. - 
  3743. - #if defined(WANT_MENU) || defined(PROTO)
  3744.   /*
  3745. !  * Make a menu item appear either active or not active (grey or not grey).
  3746.    */
  3747.   void
  3748. ! gui_mch_menu_grey(VimMenu * menu, int grey)
  3749.   {
  3750. !     if (menu->id == 0)
  3751.       return;
  3752.   
  3753. !     gui_mch_menu_hidden(menu, FALSE);
  3754. !     gtk_widget_set_sensitive(menu->id, !grey);
  3755.   
  3756. !     gui_mch_update();
  3757.   }
  3758.   
  3759.   /*
  3760. !  * Make menu item hidden or not hidden.
  3761.    */
  3762.   void
  3763. ! gui_mch_menu_hidden(VimMenu * menu, int hidden)
  3764.   {
  3765. !     if (menu->id == 0)
  3766.       return;
  3767.   
  3768. !     if (hidden) {
  3769. !     if (GTK_WIDGET_VISIBLE(menu->id))
  3770. !         gtk_widget_hide(menu->id);
  3771. !     } else {
  3772. !     if (!GTK_WIDGET_VISIBLE(menu->id))
  3773. !         gtk_widget_show(menu->id);
  3774. !     }
  3775.   
  3776. !     gui_mch_update();
  3777.   }
  3778.   
  3779. ! /*
  3780. !  * This is called after setting all the menus to grey/hidden or not.
  3781. !  */
  3782. ! void
  3783. ! gui_mch_draw_menubar()
  3784.   {
  3785. !     /* just make sure that the visual changes get effect immediately */
  3786. !     gui_mch_update();
  3787.   }
  3788.   #endif
  3789.   
  3790.   /*
  3791. !  * Scrollbar stuff.
  3792.    */
  3793.   void
  3794. ! gui_mch_enable_scrollbar(GuiScrollbar * sb, int flag)
  3795.   {
  3796. !     if (sb->id == 0)
  3797. !     return;
  3798. !     if (flag)
  3799. !     gtk_widget_show(sb->id);
  3800. !     else
  3801. !     gtk_widget_hide(sb->id);
  3802. !     update_window_manager_hints();
  3803.   }
  3804.   
  3805.   
  3806.   /*
  3807. !  * Return the lightness of a pixel.  White is 255.
  3808. !  *
  3809. !  * FIXME: port it compleatly to GDK.
  3810.    */
  3811.   int
  3812. ! gui_mch_get_lightness(GuiColor pixel)
  3813.   {
  3814. !     XColor xc;
  3815. !     GdkColormap *colormap;
  3816.   
  3817. !     colormap = gtk_widget_get_colormap(gui.mainwin);
  3818. !     xc.pixel = pixel;
  3819. !     XQueryColor(GDK_DISPLAY(), GDK_COLORMAP_XCOLORMAP(colormap), &xc);
  3820.   
  3821. !     return (int) (xc.red * 3 + xc.green * 6 + xc.blue) / (10 * 256);
  3822.   }
  3823.   
  3824. - #if (defined(SYNTAX_HL) && defined(WANT_EVAL)) || defined(PROTO)
  3825.   /*
  3826. !  * Return the RGB value of a pixel as "#RRGGBB".
  3827. !  *
  3828. !  * FIXME: It should be possible to avoid any direct usage of Xlib. Use gdk
  3829. !  * instead!
  3830.    */
  3831. ! char_u *
  3832. ! gui_mch_get_rgb(GuiColor pixel)
  3833.   {
  3834. !     XColor xc;
  3835. !     GdkColormap *colormap;
  3836. !     static char_u retval[10];
  3837. !     static int prevent_congestion = 0; /* Reduce the race! */
  3838.   
  3839. !     while (prevent_congestion)
  3840. !     /* shouldn't we do something here? */;
  3841.   
  3842. !     ++prevent_congestion;
  3843. !     colormap = gtk_widget_get_colormap(gui.mainwin);
  3844.   
  3845. !     xc.pixel = pixel;
  3846. !     XQueryColor(GDK_DISPLAY(), GDK_COLORMAP_XCOLORMAP(colormap), &xc);
  3847.   
  3848. !     sprintf((char *) retval, "#%02x%02x%02x",
  3849. !         (unsigned) xc.red >> 8,
  3850. !         (unsigned) xc.green >> 8,
  3851. !         (unsigned) xc.blue >> 8);
  3852. !     /* hope the following is atomic enought (99.999%) */
  3853. !     --prevent_congestion;
  3854.   
  3855. !     /* WOAH!!! Returning pointer to static string! */
  3856. !     return retval;
  3857.   }
  3858. - #endif
  3859.   
  3860.   /*
  3861. !  * Get current y mouse coordinate in text window.
  3862. !  * Return -1 when unknown.
  3863.    */
  3864. ! int
  3865. ! gui_mch_get_mouse_x(void)
  3866.   {
  3867. !     int winx, winy;
  3868. !     GdkModifierType mask;
  3869.   
  3870. !     if (gdk_window_get_pointer(gui.drawarea->window, &winx, &winy, &mask)) {
  3871. !     if (gui.which_scrollbars[SBAR_LEFT])
  3872. !         return winx;
  3873. !     return winx;
  3874. !     }
  3875. !     return -1;
  3876. ! }
  3877.   
  3878. ! int
  3879. ! gui_mch_get_mouse_y(void)
  3880. ! {
  3881. !     int winx, winy;
  3882. !     GdkModifierType mask;
  3883.   
  3884. !     if (gdk_window_get_pointer(gui.drawarea->window, &winx, &winy, &mask))
  3885. !     return winy;
  3886. !     return -1;
  3887.   }
  3888.   
  3889.   void
  3890. ! gui_mch_setmouse(int x, int y)
  3891.   {
  3892. !     /* Sorry for that, but we can't avoid it, since there seems to be
  3893. !        no internal GDK mechanism present to accomplish this */
  3894. !     XWarpPointer(GDK_DISPLAY(), (Window) 0,
  3895. !          GDK_WINDOW_XWINDOW(gui.drawarea->window), 0, 0, 0, 0, x, y);
  3896. ! }
  3897.   
  3898.   
  3899. ! /*** private function defintions ***/
  3900.   
  3901. ! /* redraw the corresponding portions of the screen */
  3902. ! /*ARGSUSED*/
  3903. ! static gint
  3904. ! expose_event(GtkWidget * widget, GdkEventExpose * event)
  3905. ! {
  3906. !     out_flush();        /* make sure all output has been processed */
  3907. !     gui_redraw(event->area.x, event->area.y,
  3908. !            event->area.width, event->area.height);
  3909.   
  3910. !     /* Clear the border areas if needed */
  3911. !     if (event->area.x < FILL_X(0))
  3912. !     gdk_window_clear_area(gui.drawarea->window, 0, 0, FILL_X(0), 0);
  3913. !     if (event->area.y < FILL_Y(0))
  3914. !     gdk_window_clear_area(gui.drawarea->window, 0, 0, 0, FILL_Y(0));
  3915. !     if (event->area.x > FILL_X(Columns))
  3916. !     gdk_window_clear_area(gui.drawarea->window,
  3917. !                   FILL_X((int)Columns), 0, 0, 0);
  3918. !     if (event->area.y > FILL_Y(Rows))
  3919. !     gdk_window_clear_area(gui.drawarea->window, 0, FILL_Y((int)Rows), 0, 0);
  3920.   
  3921. !     return FALSE;
  3922.   }
  3923.   
  3924. - static guint mouse_click_timer = 0;
  3925. - static int mouse_timed_out = TRUE;
  3926. - 
  3927.   /*
  3928. !  * Timer used to recognize multiple clicks of the mouse button
  3929.    */
  3930. ! static gint
  3931. ! mouse_click_timer_cb(gpointer data)
  3932.   {
  3933. !     /* we don't use this information currently */
  3934. !     int *timed_out = (int *) data;
  3935. ! 
  3936. !     *timed_out = TRUE;
  3937. !     return FALSE;        /* don't happen again */
  3938. ! }
  3939.   
  3940. ! /*
  3941. !  * Mouse button handling. Note please that we are capturing multiple click's by
  3942. !  * our own timeout mechanis instead of the one provided by GTK+ istelf. This is
  3943. !  * due to the way the generic VIM code is recognizing multiple clicks.
  3944. !  */
  3945. ! /*ARGSUSED*/
  3946. ! static gint
  3947. ! button_press_event(GtkWidget * widget, GdkEventButton * event)
  3948. ! {
  3949. !     int button;
  3950. !     int repeated_click = FALSE;
  3951. !     int x, y;
  3952. !     int_u vim_modifiers;
  3953.   
  3954. !     /*
  3955. !      * Don't let additional events about multiple clicks send by GTK to us
  3956. !      * after the inital button press event confuse us.
  3957. !      */
  3958. !     if (event->type != GDK_BUTTON_PRESS)
  3959. !     return FALSE;
  3960.   
  3961. !     x = event->x;
  3962. !     y = event->y;
  3963.   
  3964.   
  3965. !     /* Handle multiple clicks */
  3966. !     if (!mouse_timed_out && mouse_click_timer) {
  3967. !     gtk_timeout_remove(mouse_click_timer);
  3968. !     mouse_click_timer = 0;
  3969. !     repeated_click = TRUE;
  3970.       }
  3971.   
  3972. !     mouse_timed_out = FALSE;
  3973. !     mouse_click_timer = gtk_timeout_add(p_mouset,
  3974. !                   mouse_click_timer_cb, &mouse_timed_out);
  3975.   
  3976. !     switch (event->button)
  3977.       {
  3978. !     case 1:
  3979. !     button = MOUSE_LEFT;
  3980. !     break;
  3981. !     case 2:
  3982. !     button = MOUSE_MIDDLE;
  3983. !     break;
  3984. !     case 3:
  3985. !     button = MOUSE_RIGHT;
  3986. !     break;
  3987. !     case 4:
  3988. !     button = MOUSE_4;
  3989. !     break;
  3990. !     case 5:
  3991. !     button = MOUSE_5;
  3992. !     break;
  3993. !     default:
  3994. !     return FALSE;        /* Unknown button */
  3995.       }
  3996.   
  3997. !     vim_modifiers = 0x0;
  3998. !     if (event->state & GDK_SHIFT_MASK)
  3999. !     vim_modifiers |= MOUSE_SHIFT;
  4000. !     if (event->state & GDK_CONTROL_MASK)
  4001. !     vim_modifiers |= MOUSE_CTRL;
  4002. !     if (event->state & GDK_MOD1_MASK)
  4003. !     vim_modifiers |= MOUSE_ALT;
  4004.   
  4005. !     gui_send_mouse_event(button, x, y, repeated_click, vim_modifiers);
  4006. !     if (gtk_main_level() > 0)
  4007. !     gtk_main_quit();    /* make sure the above will be handled immediately */
  4008.   
  4009. !     return TRUE;
  4010.   }
  4011.   
  4012. - static guint motion_repeat_timer = 0;
  4013. - 
  4014.   /*
  4015. !  * Timer used to recognize multiple clicks of the mouse button
  4016.    */
  4017. ! /*ARGSUSED*/
  4018. ! static gint
  4019. ! motion_repeat_timer_cb(gpointer data)
  4020.   {
  4021. !     gint x, y;
  4022. !     GdkModifierType state;
  4023. !     GdkEventMotion event;
  4024. ! 
  4025. !     gdk_window_get_pointer(gui.drawarea->window, &x, &y, &state);
  4026. ! 
  4027. !     if (!(state & (GDK_BUTTON1_MASK | GDK_BUTTON3_MASK)))
  4028. !     return FALSE;
  4029. ! 
  4030. !     /* Fake a motion event. */
  4031. !     event.is_hint = 0;
  4032. !     event.x = x;
  4033. !     event.y = y;
  4034. !     event.state = state;
  4035.   
  4036. -     /* FIXME: argh! for some unknown reason this doesn't lead to nice
  4037. -      * autoscrolling and automatic extension of the selection area.  However
  4038. -      * the autorepeating works nice already.  We need certainly to investigate
  4039. -      * this further.
  4040. -      *
  4041. -      * BTW: It doesn't work properly in the motif version too. So maybe we need
  4042. -      * to look at how it's done in the Windows version again...
  4043. -      *
  4044. -      * I'm assuming that this is somehow related to the gui_mouse_moved
  4045. -      * stuff...
  4046. -      */
  4047.   
  4048. !     motion_notify_event(gui.drawarea, &event);
  4049.   
  4050. !     /* Don't happen again. We will get reinstalled in the synthetic
  4051. !      * event if needed - thus repeating should still work.
  4052. !      */
  4053.   
  4054. !     return FALSE;
  4055.   }
  4056.   
  4057. ! /*ARGSUSED*/
  4058. ! static gint
  4059. ! button_release_event(GtkWidget * widget, GdkEventButton * event)
  4060.   {
  4061. !     int x, y;
  4062. !     int_u vim_modifiers;
  4063.   
  4064. !     /* Remove any motion "mashine gun" timers used for automatic further
  4065. !        extension of allocation areas if outside of the applications window
  4066. !        area .*/
  4067. !     if (motion_repeat_timer) {
  4068. !     gtk_timeout_remove(motion_repeat_timer);
  4069. !     motion_repeat_timer = 0;
  4070.       }
  4071.   
  4072. !     x = event->x;
  4073. !     y = event->y;
  4074. ! 
  4075. !     vim_modifiers = 0x0;
  4076. !     if (event->state & GDK_SHIFT_MASK)
  4077. !     vim_modifiers |= MOUSE_SHIFT;
  4078. !     if (event->state & GDK_CONTROL_MASK)
  4079. !     vim_modifiers |= MOUSE_CTRL;
  4080. !     if (event->state & GDK_MOD1_MASK)
  4081. !     vim_modifiers |= MOUSE_ALT;
  4082. ! 
  4083. !     gui_send_mouse_event(MOUSE_RELEASE, x, y, FALSE, vim_modifiers);
  4084. !     if (gtk_main_level() > 0)
  4085. !     gtk_main_quit();        /* make sure it will be handled immediately */
  4086. ! 
  4087. !     return TRUE;
  4088.   }
  4089.   
  4090. ! 
  4091. ! /*ARGSUSED*/
  4092. ! static gint
  4093. ! motion_notify_event(GtkWidget * widget, GdkEventMotion * event)
  4094.   {
  4095. !     gint x, y;
  4096. !     GdkModifierType state;
  4097. !     int_u vim_modifiers;
  4098. !     int button;
  4099. ! 
  4100. !     if (event->is_hint)
  4101. !     gdk_window_get_pointer(event->window, &x, &y, &state);
  4102. !     else {
  4103. !     x = event->x;
  4104. !     y = event->y;
  4105. !     state = event->state;
  4106. !     }
  4107. !     button = (event->state & (GDK_BUTTON1_MASK | GDK_BUTTON2_MASK |
  4108. !                   GDK_BUTTON3_MASK | GDK_BUTTON4_MASK |
  4109. !                   GDK_BUTTON5_MASK))
  4110. !           ? MOUSE_DRAG : ' ';
  4111. ! 
  4112. !     /* If our pointer is currently hidden, then we should show it. */
  4113. !     gui_mch_mousehide(FALSE);
  4114. ! 
  4115. !     /* Just moving the rodent above the drawing area without
  4116. !        any button beeing pressed. */
  4117. !     if (button != MOUSE_DRAG) {
  4118. !     gui_mouse_moved(y);
  4119. !     return TRUE;
  4120. !     }
  4121. ! 
  4122. !     vim_modifiers = 0x0;
  4123. !     if (state & GDK_SHIFT_MASK)
  4124. !     vim_modifiers |= MOUSE_SHIFT;
  4125. !     if (state & GDK_CONTROL_MASK)
  4126. !     vim_modifiers |= MOUSE_CTRL;
  4127. !     if (state & GDK_MOD1_MASK)
  4128. !     vim_modifiers |= MOUSE_ALT;
  4129. ! 
  4130. !     /* inform the editor egine about the occurence of this event */
  4131. !     gui_send_mouse_event(button, x, y, FALSE, vim_modifiers);
  4132. !     if (gtk_main_level() > 0)
  4133. !     gtk_main_quit();
  4134. ! 
  4135. !     /*
  4136. !      * Auto repeat timer handling.
  4137. !      */
  4138. !     if (x < 0 || y < 0
  4139. !        || x >= gui.drawarea->allocation.width
  4140. !        || y >= gui.drawarea->allocation.height) {
  4141. ! 
  4142. !     /* just in case remove stale timers */
  4143. !     if (motion_repeat_timer)
  4144. !         gtk_timeout_remove(motion_repeat_timer);
  4145. !     /* shoot again */
  4146. !     motion_repeat_timer = gtk_timeout_add(100,
  4147. !                       motion_repeat_timer_cb, NULL);
  4148. !     }
  4149. ! 
  4150. !     return TRUE; /* handled */
  4151.   }
  4152.   
  4153.   /*
  4154. !  * Callback routine for the "delete_event" signal on the toplevel window.
  4155. !  * Tries to vim gracefully, or refuses to exit with changed buffers.
  4156.    */
  4157. ! /*ARGSUSED*/
  4158. ! static int
  4159. ! delete_event_cb(GtkWidget *wgt, gpointer cbdata)
  4160.   {
  4161. !     gui_window_closed();
  4162. !     return TRUE;
  4163.   }
  4164.   
  4165.   /*
  4166. !  * Function called when window already closed.
  4167. !  * We can't do much more here than to trying to preserve what had been done,
  4168. !  * since the window is already inevitably going away.
  4169.    */
  4170. ! static void
  4171. ! destroy_callback(void)
  4172.   {
  4173. !     /* preserve files and exit */
  4174. !     preserve_exit();
  4175. !     if (gtk_main_level() > 0)
  4176. !     gtk_main_quit();
  4177.   }
  4178.   
  4179. ! #ifdef GTK_HAVE_FEATURES_1_1_0
  4180.   /*
  4181. !  * Get a font structure for highlighting.
  4182. !  * "cbdata" is a pointer to the global gui structure.
  4183.    */
  4184. ! /*ARGSUSED*/
  4185. ! static void
  4186. ! font_sel_ok(GtkWidget *wgt, gpointer cbdata)
  4187.   {
  4188. !     Gui *vw = (Gui *)cbdata;
  4189. !     GtkFontSelectionDialog *fs = (GtkFontSelectionDialog *)vw->fontdlg;
  4190.   
  4191. !     if (vw->fontname)
  4192. !     g_free(vw->fontname);
  4193.   
  4194. !     vw->fontname = (char_u *)g_strdup(
  4195. !                 gtk_font_selection_dialog_get_font_name(fs));
  4196. !     gtk_widget_hide(vw->fontdlg);
  4197. !     if (gtk_main_level() > 0)
  4198. !     gtk_main_quit();
  4199.   }
  4200.   
  4201. ! /*ARGSUSED*/
  4202. ! static void
  4203. ! font_sel_cancel(GtkWidget *wgt, gpointer cbdata)
  4204.   {
  4205. !     Gui *vw = (Gui *)cbdata;
  4206.   
  4207. !     gtk_widget_hide(vw->fontdlg);
  4208. !     if (gtk_main_level() > 0)
  4209. !     gtk_main_quit();
  4210.   }
  4211.   
  4212. ! /*ARGSUSED*/
  4213. ! static void
  4214. ! font_sel_destroy(GtkWidget *wgt, gpointer cbdata)
  4215.   {
  4216. !     Gui *vw = (Gui *)cbdata;
  4217.   
  4218. !     vw->fontdlg = NULL;
  4219. !     if (gtk_main_level() > 0)
  4220. !     gtk_main_quit();
  4221.   }
  4222. - #endif
  4223. --- 823,3120 ----
  4224.       return OK;
  4225.   }
  4226.   
  4227. + 
  4228. + /****************************************************************************
  4229. +  * Mouse handling callbacks
  4230. +  */
  4231. + 
  4232. + 
  4233. + static guint mouse_click_timer = 0;
  4234. + static int mouse_timed_out = TRUE;
  4235. + 
  4236.   /*
  4237. !  * Timer used to recognize multiple clicks of the mouse button
  4238.    */
  4239. ! static gint
  4240. ! mouse_click_timer_cb(gpointer data)
  4241.   {
  4242. !     /* we don't use this information currently */
  4243. !     int *timed_out = (int *) data;
  4244.   
  4245. !     *timed_out = TRUE;
  4246. !     return FALSE;        /* don't happen again */
  4247.   }
  4248.   
  4249. + static guint motion_repeat_timer = 0;
  4250. + static int motion_repeat_offset = FALSE;
  4251. + 
  4252. + static gint motion_notify_event(GtkWidget *, GdkEventMotion *);
  4253. + 
  4254.   /*
  4255. !  * Timer used to recognize multiple clicks of the mouse button.
  4256.    */
  4257. ! /*ARGSUSED*/
  4258. ! static gint
  4259. ! motion_repeat_timer_cb(gpointer data)
  4260.   {
  4261. !     gint x, y;
  4262. !     GdkModifierType state;
  4263. !     GdkEventMotion event;
  4264.   
  4265. !     gdk_window_get_pointer(gui.drawarea->window, &x, &y, &state);
  4266.   
  4267. !     if (!(state & (GDK_BUTTON1_MASK | GDK_BUTTON2_MASK |
  4268. !             GDK_BUTTON3_MASK | GDK_BUTTON4_MASK |
  4269. !             GDK_BUTTON5_MASK)))
  4270. !     {
  4271. !     motion_repeat_timer = 0;
  4272. !     return FALSE;
  4273. !     }
  4274.   
  4275. !     /* If there already is a mouse click in the input buffer, wait another
  4276. !      * time (otherwise we would create a backlog of clicks) */
  4277. !     if (vim_used_in_input_buf() > 10)
  4278. !     return TRUE;
  4279.   
  4280. !     motion_repeat_timer = 0;
  4281. ! 
  4282. !     /* Fake a motion event.
  4283. !      * Trick: Pretend the mouse moved to the next character on every other
  4284. !      * event, otherwise drag events will be discarded, because they are still
  4285. !      * in the same character. */
  4286. !     event.is_hint = FALSE;
  4287. !     if (motion_repeat_offset)
  4288. !     {
  4289. !     event.x = x + gui.char_width;
  4290. !     motion_repeat_offset = FALSE;
  4291. !     }
  4292. !     else
  4293. !     {
  4294. !     event.x = x;
  4295. !     motion_repeat_offset = TRUE;
  4296. !     }
  4297. !     event.y = y;
  4298. !     event.state = state;
  4299. !     motion_notify_event(gui.drawarea, &event);
  4300. ! 
  4301. !     /* Don't happen again. We will get reinstalled in the synthetic event if
  4302. !      * needed - thus repeating should still work.
  4303. !      */
  4304. !     return FALSE;
  4305.   }
  4306.   
  4307. ! /*ARGSUSED*/
  4308. ! static gint
  4309. ! motion_notify_event(GtkWidget * widget, GdkEventMotion * event)
  4310.   {
  4311. !     gint x, y;
  4312. !     GdkModifierType state;
  4313. !     int_u vim_modifiers;
  4314. !     int button;
  4315.   
  4316. !     if (event->is_hint)
  4317. !     gdk_window_get_pointer(event->window, &x, &y, &state);
  4318. !     else {
  4319. !     x = event->x;
  4320. !     y = event->y;
  4321. !     state = event->state;
  4322. !     }
  4323.   
  4324. !     button = (event->state & (GDK_BUTTON1_MASK | GDK_BUTTON2_MASK |
  4325. !                   GDK_BUTTON3_MASK | GDK_BUTTON4_MASK |
  4326. !                   GDK_BUTTON5_MASK))
  4327. !           ? MOUSE_DRAG : ' ';
  4328.   
  4329. !     /* If our pointer is currently hidden, then we should show it. */
  4330. !     gui_mch_mousehide(FALSE);
  4331.   
  4332. !     /* Just moving the rodent above the drawing area without any button beeing
  4333. !      * pressed. */
  4334. !     if (button != MOUSE_DRAG) {
  4335. !     gui_mouse_moved(y);
  4336. !     return TRUE;
  4337. !     }
  4338.   
  4339. !     /* translate modifier coding between the main engine and GTK */
  4340. !     vim_modifiers = 0x0;
  4341. !     if (state & GDK_SHIFT_MASK)
  4342. !     vim_modifiers |= MOUSE_SHIFT;
  4343. !     if (state & GDK_CONTROL_MASK)
  4344. !     vim_modifiers |= MOUSE_CTRL;
  4345. !     if (state & GDK_MOD1_MASK)
  4346. !     vim_modifiers |= MOUSE_ALT;
  4347.   
  4348. !     /* inform the editor egine about the occurence of this event */
  4349. !     gui_send_mouse_event(button, x, y, FALSE, vim_modifiers);
  4350. !     if (gtk_main_level() > 0)
  4351. !     gtk_main_quit();
  4352.   
  4353. +     /*
  4354. +      * Auto repeat timer handling.
  4355. +      */
  4356. +     if (x < 0 || y < 0
  4357. +         || x >= gui.drawarea->allocation.width
  4358. +         || y >= gui.drawarea->allocation.height) {
  4359.   
  4360. !     int dx;
  4361. !     int dy;
  4362. !     int offshoot;
  4363. !     int delay = 10;
  4364.   
  4365. !     /* Calculate the maximal distance of the cursor from the drawing area.
  4366. !      * (offshoot can't become negative here!).
  4367. !      */
  4368. !     dx = x < 0 ? -x : x - gui.drawarea->allocation.width;
  4369. !     dy = y < 0 ? -y : y - gui.drawarea->allocation.height;
  4370.   
  4371. !     offshoot = dx > dy ? dx : dy;
  4372.   
  4373. !     /* Make a linearly declaying timer delay with a threshold of 5 at a
  4374. !      * distance of 127 pixels from the main window.
  4375. !      *
  4376. !      * One could think endlessly about the most ergonomic variant here.
  4377. !      * For example it could make sense to calculate the distance from the
  4378. !      * drags start instead...
  4379. !      *
  4380. !      * Maybe a parabolic interpolation would suite us better here too...
  4381. !      */
  4382. !     if (offshoot > 127) {
  4383. !         /* 5 appears to be somehow near to my perceptual limits :-). */
  4384. !         delay = 5;
  4385. !     } else {
  4386. !         delay = (130 * (127 - offshoot)) / 127 + 5;
  4387. !     }
  4388.   
  4389. !     /* shoot again */
  4390. !     if (!motion_repeat_timer)
  4391. !         motion_repeat_timer = gtk_timeout_add((guint32)delay,
  4392. !                         motion_repeat_timer_cb, NULL);
  4393. !     }
  4394.   
  4395. !     return TRUE; /* handled */
  4396. ! }
  4397.   
  4398.   
  4399. ! /*
  4400. !  * Mouse button handling.  Note please that we are capturing multiple click's
  4401. !  * by our own timeout mechanism instead of the one provided by GTK+ istelf.
  4402. !  * This is due to the way the generic VIM code is recognizing multiple clicks.
  4403. !  */
  4404. ! /*ARGSUSED*/
  4405. ! static gint
  4406. ! button_press_event(GtkWidget * widget, GdkEventButton * event)
  4407. ! {
  4408. !     int button;
  4409. !     int repeated_click = FALSE;
  4410. !     int x, y;
  4411. !     int_u vim_modifiers;
  4412.   
  4413.       /*
  4414. !      * Don't let additional events about multiple clicks send by GTK to us
  4415. !      * after the inital button press event confuse us.
  4416.        */
  4417. !     if (event->type != GDK_BUTTON_PRESS)
  4418. !     return FALSE;
  4419.   
  4420. !     x = event->x;
  4421. !     y = event->y;
  4422.   
  4423. !     /* Handle multiple clicks */
  4424. !     if (!mouse_timed_out && mouse_click_timer) {
  4425. !     gtk_timeout_remove(mouse_click_timer);
  4426. !     mouse_click_timer = 0;
  4427. !     repeated_click = TRUE;
  4428.       }
  4429.   
  4430. !     mouse_timed_out = FALSE;
  4431. !     mouse_click_timer = gtk_timeout_add((guint32)p_mouset,
  4432. !                   mouse_click_timer_cb, &mouse_timed_out);
  4433.   
  4434. !     switch (event->button) {
  4435. !     case 1:
  4436. !     button = MOUSE_LEFT;
  4437. !     break;
  4438. !     case 2:
  4439. !     button = MOUSE_MIDDLE;
  4440. !     break;
  4441. !     case 3:
  4442. !     button = MOUSE_RIGHT;
  4443. !     break;
  4444. !     case 4:
  4445. !     button = MOUSE_4;
  4446. !     break;
  4447. !     case 5:
  4448. !     button = MOUSE_5;
  4449. !     break;
  4450. !     default:
  4451. !     return FALSE;        /* Unknown button */
  4452. !     }
  4453.   
  4454. !     vim_modifiers = 0x0;
  4455. !     if (event->state & GDK_SHIFT_MASK)
  4456. !     vim_modifiers |= MOUSE_SHIFT;
  4457. !     if (event->state & GDK_CONTROL_MASK)
  4458. !     vim_modifiers |= MOUSE_CTRL;
  4459. !     if (event->state & GDK_MOD1_MASK)
  4460. !     vim_modifiers |= MOUSE_ALT;
  4461.   
  4462. !     gui_send_mouse_event(button, x, y, repeated_click, vim_modifiers);
  4463. !     if (gtk_main_level() > 0)
  4464. !     gtk_main_quit();    /* make sure the above will be handled immediately */
  4465.   
  4466. !     return TRUE;
  4467.   }
  4468.   
  4469. ! /*ARGSUSED*/
  4470. ! static gint
  4471. ! button_release_event(GtkWidget * widget, GdkEventButton * event)
  4472.   {
  4473. !     int x, y;
  4474. !     int_u vim_modifiers;
  4475. ! 
  4476. !     /* Remove any motion "mashine gun" timers used for automatic further
  4477. !        extension of allocation areas if outside of the applications window
  4478. !        area .*/
  4479. !     if (motion_repeat_timer) {
  4480. !     gtk_timeout_remove(motion_repeat_timer);
  4481. !     motion_repeat_timer = 0;
  4482.       }
  4483. + 
  4484. +     x = event->x;
  4485. +     y = event->y;
  4486. + 
  4487. +     vim_modifiers = 0x0;
  4488. +     if (event->state & GDK_SHIFT_MASK)
  4489. +     vim_modifiers |= MOUSE_SHIFT;
  4490. +     if (event->state & GDK_CONTROL_MASK)
  4491. +     vim_modifiers |= MOUSE_CTRL;
  4492. +     if (event->state & GDK_MOD1_MASK)
  4493. +     vim_modifiers |= MOUSE_ALT;
  4494. + 
  4495. +     gui_send_mouse_event(MOUSE_RELEASE, x, y, FALSE, vim_modifiers);
  4496. +     if (gtk_main_level() > 0)
  4497. +     gtk_main_quit();        /* make sure it will be handled immediately */
  4498. + 
  4499. +     return TRUE;
  4500.   }
  4501.   
  4502.   
  4503. + #ifdef GTK_DND
  4504. + /****************************************************************************
  4505. +  * Drag aNd Drop support handlers.
  4506. +  */
  4507. + 
  4508. + /*
  4509. +  * DND receiver.
  4510. +  */
  4511. + /*ARGSUSED*/
  4512.   static void
  4513. ! drag_data_received(GtkWidget *widget, GdkDragContext *context,
  4514. !     gint x, gint y,
  4515. !     GtkSelectionData *data,
  4516. !     guint info, guint time)
  4517. ! {
  4518. !     char_u    **fnames;
  4519. !     int        redo_dirs = FALSE;
  4520. !     int        i;
  4521. !     int        n;
  4522. !     char    *start;
  4523. !     char    *stop;
  4524. !     char    *copy;
  4525. !     int        nfiles;
  4526. !     GdkModifierType current_modifiers;
  4527. ! 
  4528. !     /* Get the current modifier state for proper distinguishment between
  4529. !      * different operations later. */
  4530. !     current_modifiers = 0;
  4531. !     gdk_window_get_pointer(NULL, NULL, NULL, ¤t_modifiers);
  4532. ! 
  4533. !     /* guard against trash */
  4534. !     if (((data->length <=  0) && (data->format != 8))
  4535. !         || (((char *)data->data)[data->length] != '\0')) {
  4536. !     gtk_drag_finish(context, FALSE, FALSE, time);
  4537.   
  4538. !     return;
  4539. !     }
  4540.   
  4541. !     /* Count how meny items there may be there and normalize
  4542. !      * delimiters.
  4543. !      */
  4544. !     n = 1;
  4545. !     copy = strdup((char *)data->data);
  4546. !     for (i = 0; i < data->length; ++i) {
  4547. !     if (copy[i] == '\n')
  4548. !         ++n;
  4549. !     else if(copy[i] == '\r') {
  4550. !         copy[i] = '\n';
  4551. !         ++n;
  4552. !     }
  4553. !     }
  4554.   
  4555. !     fnames = (char_u **) alloc((n + 1) * sizeof(char_u *));
  4556.   
  4557. !     start = copy;
  4558. !     stop = copy;
  4559. !     nfiles = 0;
  4560. !     for (i = 0; i < n; ++i) {
  4561. !     stop = strchr(start, '\n');
  4562. !     if (stop)
  4563. !         *stop = '\0';
  4564. ! 
  4565. !     if (!strlen(start))
  4566. !         continue;
  4567. ! 
  4568. !     if (strncmp(start, "file:", 5)) {
  4569. !         int j;
  4570. ! 
  4571. !         free(copy);
  4572. !         for (j = 0; j < nfiles; ++j)
  4573. !         free(fnames[j]);
  4574. !         gtk_drag_finish(context, FALSE, FALSE, time);
  4575.   
  4576. !         return;
  4577. !     }
  4578. ! 
  4579. !     if (!strncmp(start, "file://localhost", 16)) {
  4580. !         fnames[nfiles] = (char_u *)strdup(start + 16);
  4581. !         ++nfiles;
  4582. !     } else {
  4583. !         fnames[nfiles] = (char_u *)strdup(start + 5);
  4584. !         ++nfiles;
  4585. !     }
  4586. !     start = stop + 2;
  4587. !     }
  4588. !     free(copy);
  4589. ! 
  4590. !     /* accept */
  4591. !     gtk_drag_finish (context, TRUE, FALSE, time);
  4592.   
  4593.       /*
  4594. !      * Handle dropping a directory on Vim.
  4595.        */
  4596. !     if (nfiles == 1) {
  4597. !     if (mch_isdir(fnames[0])) {
  4598. !         if (mch_chdir((char *)fnames[0]) == 0) {
  4599. !         free(fnames[0]);
  4600. !         fnames[0] = NULL;
  4601. !         redo_dirs = TRUE;
  4602. !         }
  4603. !     }
  4604. !     } else {
  4605. !     /* Ignore any directories */
  4606. !     for (i = 0; i < nfiles; ++i) {
  4607. !         if (mch_isdir(fnames[i])) {
  4608. !         free(fnames[i]);
  4609. !         fnames[i] = NULL;
  4610. !         }
  4611. !     }
  4612. !     }
  4613.   
  4614. !     if (current_modifiers & GDK_SHIFT_MASK) {
  4615. !     /* Shift held down, change to first file's directory */
  4616. !     if (fnames[0] != NULL && vim_chdirfile(fnames[0]) == 0)
  4617. !         redo_dirs = TRUE;
  4618. !     }
  4619.   
  4620. !     /* Handle the drop, :edit or :split to get to the file */
  4621. !     handle_drop(nfiles, fnames, current_modifiers & GDK_CONTROL_MASK);
  4622. ! 
  4623. !     if (redo_dirs)
  4624. !     shorten_fnames(TRUE);
  4625. ! 
  4626. !     /* Update the screen display */
  4627. !     update_screen(NOT_VALID);
  4628. !     setcursor();
  4629. !     out_flush();
  4630.   }
  4631. + #endif /* GTK_DND */
  4632.   
  4633.   /*
  4634. !  * Setup the window icon after the main window has bee realized.
  4635.    */
  4636.   /*ARGSUSED*/
  4637. ! static void
  4638. ! mainwin_realize(GtkWidget *widget)
  4639.   {
  4640. ! /* If you get an error message here, you still need to unpack the runtime
  4641. !  * archive! */
  4642. ! #include "../runtime/vim32x32.xpm"
  4643. !     static GdkPixmap *icon = NULL;
  4644. !     static GdkBitmap *icon_mask = NULL;
  4645.   
  4646. !     if (!icon)
  4647. !     icon = gdk_pixmap_create_from_xpm_d(gui.mainwin->window,
  4648. !                             &icon_mask, NULL, magick);
  4649. !     gdk_window_set_icon(gui.mainwin->window, NULL, icon, icon_mask);
  4650.   }
  4651.   
  4652.   /*
  4653. !  * After the drawing area comes up, we calculate all colors and create the
  4654. !  * dummy blank cursor.
  4655. !  *
  4656. !  * Don't try to set any VIM scrollbar sizes anywhere here. I'm relying on the
  4657. !  * fact that the main VIM engine doesn't take them into account anywhere.
  4658.    */
  4659. ! static void
  4660. ! drawarea_realize_cb(GtkWidget *widget)
  4661.   {
  4662. !     char blank_data[] = {0x0};
  4663. !     GdkPixmap *blank_mask;
  4664. !     GdkColor color;
  4665. !     GtkWidget *sbar;
  4666.   
  4667. ! #ifdef USE_XIM
  4668. !     xim_init();
  4669.   #endif
  4670. +     gui_mch_new_colors();
  4671.   
  4672. !     blank_mask = gdk_bitmap_create_from_data(NULL, blank_data, 1, 1);
  4673. !     gdk_color_white(gdk_colormap_get_system(), &color);
  4674. !     gui.blank_pointer = gdk_cursor_new_from_pixmap(blank_mask, blank_mask,
  4675. !                             &color, &color, 0, 0);
  4676. !     gdk_bitmap_unref(blank_mask);
  4677. !     if (gui.pointer_hidden)
  4678. !         gdk_window_set_cursor(widget->window, gui.blank_pointer);
  4679.   
  4680. !     /* get the actual size of the scrollbars, if they are realized */
  4681. !     sbar = firstwin->w_scrollbars[SBAR_LEFT].id;
  4682. !     if (!sbar || (!gui.which_scrollbars[SBAR_LEFT]
  4683. !                     && firstwin->w_scrollbars[SBAR_RIGHT].id))
  4684. !     sbar = firstwin->w_scrollbars[SBAR_RIGHT].id;
  4685. !     if (sbar && GTK_WIDGET_REALIZED(sbar) && sbar->allocation.width)
  4686. !     gui.scrollbar_width = sbar->allocation.width;
  4687.   
  4688. !     sbar = gui.bottom_sbar.id;
  4689. !     if (sbar && GTK_WIDGET_REALIZED(sbar) && sbar->allocation.height)
  4690. !     gui.scrollbar_height = sbar->allocation.height;
  4691.   }
  4692.   
  4693. ! /*
  4694. !  * Callback routine for the "delete_event" signal on the toplevel window.
  4695. !  * Tries to vim gracefully, or refuses to exit with changed buffers.
  4696. !  */
  4697.   /*ARGSUSED*/
  4698. ! static int
  4699. ! delete_event_cb(GtkWidget *wgt, gpointer cbdata)
  4700.   {
  4701. !     gui_window_closed();
  4702. !     return TRUE;
  4703.   }
  4704.   
  4705.   /*
  4706. !  * Initialise the X GUI.  Create all the windows, set up all the call-backs etc.
  4707. !  * Returns OK for success, FAIL when the GUI can't be started.
  4708.    */
  4709.   int
  4710. ! gui_mch_init()
  4711.   {
  4712. !     GtkWidget *vbox;
  4713.   
  4714. !     /* Initialize values */
  4715. !     gui.rev_video = FALSE;
  4716. !     gui.border_width = 2;
  4717. !     gui.scrollbar_width = SB_DEFAULT_WIDTH;
  4718. !     gui.scrollbar_height = SB_DEFAULT_WIDTH;
  4719. !     gui.fgcolor = g_new0(GdkColor, 1);
  4720. !     gui.bgcolor = g_new0(GdkColor, 1);
  4721.   
  4722. ! #ifdef WANT_MENU
  4723. !     /* Don't change the menu height values used in gui.c at runtime */
  4724. !     gui.menu_height_fixed = TRUE;
  4725. ! #endif
  4726.   
  4727. !     /* Set default foreground and background colours. */
  4728. !     gui.norm_pixel = gui.def_norm_pixel;
  4729. !     gui.back_pixel = gui.def_back_pixel;
  4730.   
  4731. !     gui.mainwin = gtk_window_new(GTK_WINDOW_TOPLEVEL);
  4732. !     gtk_window_set_policy(GTK_WINDOW(gui.mainwin), TRUE, TRUE, TRUE);
  4733. !     gtk_container_border_width(GTK_CONTAINER(gui.mainwin), 0);
  4734. !     gtk_widget_set_events(gui.mainwin, GDK_VISIBILITY_NOTIFY_MASK);
  4735. !     (void)gtk_signal_connect(GTK_OBJECT(gui.mainwin), "delete_event",
  4736. !                  GTK_SIGNAL_FUNC(delete_event_cb), NULL);
  4737.   
  4738. +     /* Add an icon to the main window. For fun and convenience of the user. */
  4739. +     if (vim_strchr(p_go, GO_ICON) != NULL)
  4740. +     gtk_signal_connect(GTK_OBJECT(gui.mainwin), "realize",
  4741. +                       GTK_SIGNAL_FUNC(mainwin_realize), NULL);
  4742.   
  4743.   
  4744. ! #ifdef GTK_HAVE_FEATURES_1_1_0
  4745. !     /* FIXME: this should eventually get the accelgroup of the gui.mainwin */
  4746. !     gui.accel_group = gtk_accel_group_get_default();
  4747.   #endif
  4748.   
  4749. !     vbox = gtk_vbox_new(FALSE, 0);
  4750. !     gtk_container_add(GTK_CONTAINER(gui.mainwin), vbox);
  4751. !     gtk_widget_show(vbox);
  4752.   
  4753. ! #ifdef WANT_MENU
  4754. !     /* create the menubar and handle */
  4755. !     gui.menubar = gtk_menu_bar_new();
  4756. !     gtk_widget_show(gui.menubar);
  4757. !     gtk_box_pack_start(GTK_BOX(vbox), gui.menubar, FALSE, TRUE, 0);
  4758.   #endif
  4759.   
  4760. ! #ifdef USE_TOOLBAR
  4761. !     /* create the toolbar */
  4762. !     if (p_toolbar) {
  4763.       if (strstr((const char *)p_toolbar, "text")
  4764. !         && strstr((const char *)p_toolbar, "icons"))
  4765. !         gui.toolbar =
  4766. !         gtk_toolbar_new(GTK_ORIENTATION_HORIZONTAL, GTK_TOOLBAR_BOTH);
  4767. !     else if (strstr((const char *)p_toolbar, "text"))
  4768. !         gui.toolbar =
  4769. !         gtk_toolbar_new(GTK_ORIENTATION_HORIZONTAL, GTK_TOOLBAR_TEXT);
  4770.       else
  4771. !         gui.toolbar =
  4772. !         gtk_toolbar_new(GTK_ORIENTATION_HORIZONTAL, GTK_TOOLBAR_ICONS);
  4773. !     } else
  4774. !     gui.toolbar =
  4775. !         gtk_toolbar_new(GTK_ORIENTATION_HORIZONTAL, GTK_TOOLBAR_ICONS);
  4776.   
  4777. !     gtk_widget_show(gui.toolbar);
  4778. ! # ifdef GTK_HAVE_FEATURES_1_1_0
  4779. !     /* some aesthetics on the toolbar */
  4780. !     gtk_toolbar_set_button_relief(GTK_TOOLBAR(gui.toolbar), GTK_RELIEF_NONE);
  4781. ! # endif
  4782. !     gtk_container_border_width(GTK_CONTAINER(gui.toolbar), 1);
  4783. !     gtk_box_pack_start(GTK_BOX(vbox), gui.toolbar, FALSE, TRUE, 0);
  4784.   #endif
  4785.   
  4786. +     gui.formwin = gtk_form_new();
  4787. +     gtk_container_border_width(GTK_CONTAINER(gui.formwin), 0);
  4788. +     gtk_widget_set_events(gui.formwin, GDK_EXPOSURE_MASK);
  4789.   
  4790. !     gui.drawarea = gtk_drawing_area_new();
  4791.   
  4792. !     /* Determine which events we will filter. */
  4793. !     gtk_widget_set_events(gui.drawarea,
  4794. !               GDK_EXPOSURE_MASK |
  4795. !               GDK_ENTER_NOTIFY_MASK |
  4796. !               GDK_LEAVE_NOTIFY_MASK |
  4797. !               GDK_BUTTON_PRESS_MASK |
  4798. !               GDK_BUTTON_RELEASE_MASK |
  4799. !               GDK_POINTER_MOTION_MASK |
  4800. !               GDK_POINTER_MOTION_HINT_MASK);
  4801.   
  4802. !     gtk_widget_show(gui.drawarea);
  4803. !     gtk_form_put(GTK_FORM(gui.formwin), gui.drawarea, 0, 0);
  4804. !     gtk_widget_show(gui.formwin);
  4805. !     gtk_box_pack_start(GTK_BOX(vbox), gui.formwin, TRUE, TRUE, 0);
  4806.   
  4807. !     gtk_signal_connect(GTK_OBJECT(gui.mainwin), "key_press_event",
  4808. !                (GtkSignalFunc) key_press_event, NULL);
  4809. !     gtk_signal_connect(GTK_OBJECT(gui.drawarea), "realize",
  4810. !                GTK_SIGNAL_FUNC(drawarea_realize_cb), NULL);
  4811. ! 
  4812. !     /* Check if reverse video needs to be applied (on Sun it's done by X) */
  4813. !     if (gui.rev_video && gui_mch_get_lightness(gui.back_pixel)
  4814. !     > gui_mch_get_lightness(gui.norm_pixel)) {
  4815. !     gui.norm_pixel = gui.def_back_pixel;
  4816. !     gui.back_pixel = gui.def_norm_pixel;
  4817. !     gui.def_norm_pixel = gui.norm_pixel;
  4818. !     gui.def_back_pixel = gui.back_pixel;
  4819.       }
  4820. +     gui.visibility = GDK_VISIBILITY_UNOBSCURED;
  4821. +     clipboard.atom = gdk_atom_intern("_VIM_TEXT", FALSE);
  4822. +     save_yourself_atom = gdk_atom_intern("WM_SAVE_YOURSELF", FALSE);
  4823. +     reread_rcfiles_atom = gdk_atom_intern("_GTK_READ_RCFILES", FALSE);
  4824.   
  4825. !     /*
  4826. !      * Start out by adding the configured border width into the border offset.
  4827. !      */
  4828. !     gui.border_offset = gui.border_width;
  4829.   
  4830. ! #ifdef GTK_HAVE_FEATURES_1_1_0
  4831. !     gtk_signal_connect(GTK_OBJECT(gui.mainwin), "visibility_notify_event",
  4832. !                GTK_SIGNAL_FUNC(visibility_event), NULL);
  4833.   #endif
  4834. +     gtk_signal_connect(GTK_OBJECT(gui.drawarea), "expose_event",
  4835. +                GTK_SIGNAL_FUNC(expose_event), NULL);
  4836.   
  4837. !     /*
  4838. !      * Only install these enter/leave callbacks when 'p' in 'guioptions'.
  4839. !      * Only needed for some window managers.
  4840. !      */
  4841. !     if (vim_strchr(p_go, GO_POINTER) != NULL) {
  4842. !     gtk_signal_connect(GTK_OBJECT(gui.drawarea), "leave_notify_event",
  4843. !                GTK_SIGNAL_FUNC(leave_notify_event), NULL);
  4844. !     gtk_signal_connect(GTK_OBJECT(gui.drawarea), "enter_notify_event",
  4845. !                GTK_SIGNAL_FUNC(enter_notify_event), NULL);
  4846.       }
  4847.   
  4848. !     gtk_signal_connect(GTK_OBJECT(gui.mainwin), "focus_out_event",
  4849. !                GTK_SIGNAL_FUNC(focus_out_event), NULL);
  4850. !     gtk_signal_connect(GTK_OBJECT(gui.mainwin), "focus_in_event",
  4851. !                GTK_SIGNAL_FUNC(focus_in_event), NULL);
  4852.   
  4853. !     gtk_signal_connect(GTK_OBJECT(gui.drawarea), "motion_notify_event",
  4854. !                GTK_SIGNAL_FUNC(motion_notify_event), NULL);
  4855. !     gtk_signal_connect(GTK_OBJECT(gui.drawarea), "button_press_event",
  4856. !                GTK_SIGNAL_FUNC(button_press_event), NULL);
  4857. !     gtk_signal_connect(GTK_OBJECT(gui.drawarea), "button_release_event",
  4858. !                GTK_SIGNAL_FUNC(button_release_event), NULL);
  4859.   
  4860. !     /*
  4861. !      * Add selection handler functions.
  4862. !      */
  4863. !     gtk_signal_connect(GTK_OBJECT(gui.drawarea), "selection_clear_event",
  4864. !                GTK_SIGNAL_FUNC(selection_clear_event), NULL);
  4865. !     gtk_signal_connect(GTK_OBJECT(gui.drawarea), "selection_received",
  4866. !                GTK_SIGNAL_FUNC(selection_received_event), NULL);
  4867.   
  4868. !     /* gtk_selection_add_target() is not in GTK 1.1.2 */
  4869. ! #ifdef GTK_HAVE_FEATURES_1_1_4
  4870. !     gtk_selection_add_target(gui.drawarea, GDK_SELECTION_PRIMARY,
  4871. !                 GDK_TARGET_STRING, SELECTION_STRING);
  4872. !     gtk_selection_add_target(gui.drawarea, GDK_SELECTION_PRIMARY,
  4873. !                 clipboard.atom, SELECTION_CLIPBOARD);
  4874. !     gtk_signal_connect(GTK_OBJECT(gui.drawarea), "selection_get",
  4875. !                GTK_SIGNAL_FUNC(selection_get_event), NULL);
  4876. ! #else
  4877. !     gtk_selection_add_handler(gui.drawarea, GDK_SELECTION_PRIMARY,
  4878. !                   GDK_TARGET_STRING, selection_handler, NULL);
  4879. !     gtk_selection_add_handler(gui.drawarea, GDK_SELECTION_PRIMARY,
  4880. !                   clipboard.atom, selection_handler, NULL);
  4881. ! #endif
  4882.   
  4883. !     /* Pretend we don't have input focus, we will get an event if we do. */
  4884. !     gui.in_focus = FALSE;
  4885.   
  4886. !     return OK;
  4887. ! }
  4888.   
  4889.   
  4890. ! /*
  4891. !  * Called when the foreground or background color has been changed.
  4892. !  */
  4893. ! void
  4894. ! gui_mch_new_colors()
  4895. ! {
  4896. !     /* This used to change the graphics contexts directly but we are currently
  4897. !      * manipulating them where desired.
  4898. !      */
  4899. !     if (gui.drawarea && gui.drawarea->window) {
  4900. !     GdkColor color;
  4901. !     color.pixel = gui.back_pixel;
  4902. !     gdk_window_set_background(gui.drawarea->window, &color);
  4903.       }
  4904. ! }
  4905. ! 
  4906. ! #ifdef GTK_HAVE_FEATURES_1_1_6
  4907. ! # define USE_GEOMETRY_FOR_HINTS        1
  4908.   #endif
  4909.   
  4910. ! static void
  4911. ! update_window_manager_hints(void)
  4912. ! {
  4913. !     int width;
  4914. !     int height;
  4915. ! #ifdef USE_GEOMETRY_FOR_HINTS
  4916. !     GdkGeometry geometry;
  4917. !     GdkWindowHints geometry_mask;
  4918.   
  4919. !     /* This also needs to be done when the main window isn't there yet,
  4920. !      * otherwise the hints don't work. */
  4921. !     width = gui_get_base_width();
  4922. !     height = gui_get_base_height();
  4923.   
  4924. !     geometry_mask = GDK_HINT_BASE_SIZE|GDK_HINT_RESIZE_INC|GDK_HINT_MIN_SIZE;
  4925. !     geometry.width_inc = gui.char_width;
  4926. !     geometry.height_inc = gui.char_height;
  4927. !     geometry.base_width = width;
  4928. !     geometry.base_height = height;
  4929. !     geometry.min_width = width + MIN_COLUMNS * gui.char_width;
  4930. !     geometry.min_height = height + MIN_LINES * gui.char_height;
  4931. !     gtk_window_set_geometry_hints(GTK_WINDOW(gui.mainwin), gui.formwin,
  4932. !                   &geometry, geometry_mask);
  4933. ! #else
  4934. !     XSizeHints size_hints;
  4935.   
  4936. !     /* Don't set the size until the main window is really there */
  4937. !     if (!GTK_WIDGET_REALIZED(gui.mainwin))
  4938. !     return;
  4939.   
  4940. !     width = gui_get_base_width();
  4941. !     height = gui_get_base_height();
  4942.   
  4943. !     /* The hints don't automatically take the menubar and toolbar into
  4944. !      * account.  Need to add their height here, if they are visible. */
  4945. ! # ifdef USE_TOOLBAR
  4946. !     if (gui.toolbar && GTK_WIDGET_REALIZED(gui.toolbar)
  4947. !         && GTK_WIDGET_VISIBLE(gui.toolbar))
  4948. !     height += gui.toolbar->allocation.height;
  4949. ! # endif
  4950. ! # ifdef WANT_MENU
  4951. !     if (gui.menubar && GTK_WIDGET_REALIZED(gui.menubar)
  4952. !         && GTK_WIDGET_VISIBLE(gui.menubar))
  4953. !     height += gui.menubar->allocation.height;
  4954. ! # endif
  4955.   
  4956. !     /*
  4957. !      * Argh!!! Once again we need to deal with an ommission in GTK+ by
  4958. !      * resorting to direct Xlib calls. Fortunatly I know how to do it :-).
  4959. !      */
  4960. !     size_hints.flags = (PResizeInc | PBaseSize | PMinSize | PSize);
  4961. !     size_hints.width_inc = gui.char_width;
  4962. !     size_hints.height_inc = gui.char_height;
  4963. !     size_hints.base_width = width;
  4964. !     size_hints.base_height = height;
  4965. !     size_hints.min_width = width + MIN_COLUMNS * gui.char_width;
  4966. !     size_hints.min_height = height + MIN_LINES * gui.char_height;
  4967.   
  4968. !     /* This is only needed for "older" window managers.  See a corresposning
  4969. !      * comment in the X11 headers. */
  4970. !     size_hints.width = width + Columns * gui.char_width;
  4971. !     size_hints.height = height + Rows * gui.char_height;
  4972.   
  4973. !     XSetWMNormalHints(GDK_DISPLAY(),
  4974. !               GDK_WINDOW_XWINDOW(gui.mainwin->window),
  4975. !               &size_hints);
  4976. ! #endif    /* USE_GEOMETRY_FOR_HINTS */
  4977. ! }
  4978.   
  4979. ! /*
  4980. !  * This signal informs us about the need to rearrange our subwidgets.
  4981. !  */
  4982. ! /*ARGSUSED*/
  4983. ! static gint
  4984. ! form_configure_event(GtkWidget * widget, GdkEventConfigure * event)
  4985. ! {
  4986. !     gtk_form_freeze(GTK_FORM(gui.formwin));
  4987. !     gui_resize_window(event->width, event->height);
  4988. !     gtk_form_thaw(GTK_FORM(gui.formwin));
  4989.   
  4990. !     return TRUE;
  4991. ! }
  4992.   
  4993. ! /*
  4994. !  * X11 based inter client communication handler.
  4995. !  */
  4996. ! /*ARGSUSED*/
  4997. ! static gint
  4998. ! client_event_cb(GtkWidget *widget, GdkEventClient *event)
  4999. ! {
  5000. !     if (event->message_type == save_yourself_atom ) {
  5001. !     out_flush();
  5002. !     ml_sync_all(FALSE, FALSE);      /* preserve all swap files */
  5003. !     return TRUE;
  5004. !     } else if (event->message_type == reread_rcfiles_atom) {
  5005. !     gui_mch_new_colors();
  5006. !     return TRUE;
  5007. !     }
  5008. !     return FALSE;
  5009. ! }
  5010.   
  5011. ! /*
  5012. !  * Function called when window already closed.
  5013. !  * We can't do much more here than to trying to preserve what had been done,
  5014. !  * since the window is already inevitably going away.
  5015. !  */
  5016. ! static void
  5017. ! destroy_callback(void)
  5018. ! {
  5019. !     /* preserve files and exit */
  5020. !     preserve_exit();
  5021. !     if (gtk_main_level() > 0)
  5022. !     gtk_main_quit();
  5023. ! }
  5024.   
  5025.   
  5026. ! /*
  5027. !  * Open the GUI window which was created by a call to gui_mch_init().
  5028. !  */
  5029. ! int
  5030. ! gui_mch_open()
  5031. ! {
  5032. !     int x = -1, y = -1;
  5033.   
  5034. !     /* Determine user specified geometry, if present. */
  5035. !     if (gui.geom) {
  5036. !     int mask;
  5037. !     unsigned w, h;
  5038.   
  5039. !     mask = XParseGeometry((char *)gui.geom, &x, &y, &w, &h);
  5040. !     if (mask & WidthValue)
  5041. !         Columns = w;
  5042. !     if (mask & HeightValue)
  5043. !         Rows = h;
  5044. !     if (mask & (XValue | YValue))
  5045. !         gtk_widget_set_uposition(gui.mainwin, x, y);
  5046. !     g_free(gui.geom);
  5047. !     gui.geom = NULL;
  5048.       }
  5049.   
  5050. !     gtk_form_set_size(GTK_FORM(gui.formwin),
  5051. !         (guint)(gui_get_base_width() + Columns * gui.char_width),
  5052. !         (guint)(gui_get_base_height() + Rows * gui.char_height));
  5053.       update_window_manager_hints();
  5054.   
  5055. !     if (found_reverse_arg )
  5056. !     {
  5057. !     gui.def_norm_pixel = gui_mch_get_color((char_u *)"White");
  5058. !     gui.def_back_pixel = gui_mch_get_color((char_u *)"Black");
  5059. !     }
  5060. !     else
  5061. !     {
  5062. !     gui.def_norm_pixel = gui_mch_get_color((char_u *)"Black");
  5063. !     gui.def_back_pixel = gui_mch_get_color((char_u *)"White");
  5064. !     }
  5065.   
  5066. +     /* Get the colors from the "Normal" and "Menu" group (set in syntax.c or
  5067. +      * in a vimrc file)
  5068. +      */
  5069. +     set_normal_colors();
  5070.   
  5071. !     /* Check that none of the colors are the same as the background color */
  5072. !     gui_check_colors();
  5073.   
  5074. !     /* Get the colors for the highlight groups (gui_check_colors() might have
  5075. !      * changed them).
  5076. !      */
  5077. !     highlight_gui_started();    /* re-init colors and fonts */
  5078.   
  5079. !     gtk_signal_connect(GTK_OBJECT(gui.mainwin), "destroy",
  5080. !                GTK_SIGNAL_FUNC(destroy_callback), NULL);
  5081. ! 
  5082. !     /* Make this run after any internal handling of the client event happaned
  5083. !      * to make sure that all changes implicated by it are already in place and
  5084. !      * we thus can make our own adjustments.
  5085. !      */
  5086. !     gtk_signal_connect_after(GTK_OBJECT(gui.mainwin), "client_event",
  5087. !                        GTK_SIGNAL_FUNC(client_event_cb), NULL);
  5088. ! #ifdef HANGUL_INPUT
  5089. !     hangul_keyboard_set();
  5090.   #endif
  5091.   
  5092. !     /*
  5093. !      * Notify the fixed area about the need to resize the contents of the
  5094. !      * gui.formwin, which we use for random positioning of the included
  5095. !      * components.
  5096. !      *
  5097. !      * We connect this signal deferred finally after anything is in place,
  5098. !      * since this is intended to handle resizements coming from the window
  5099. !      * manager upon us and should not interfere with what VIM is requesting
  5100. !      * upon startup.
  5101. !      */
  5102. !     gtk_signal_connect(GTK_OBJECT(gui.formwin), "configure_event",
  5103. !                GTK_SIGNAL_FUNC(form_configure_event), NULL);
  5104.   
  5105. ! #ifdef GTK_DND
  5106. !     /*
  5107. !      * Set up for receiving DND items.
  5108. !      */
  5109. !     gtk_drag_dest_set(gui.drawarea,
  5110. !         GTK_DEST_DEFAULT_ALL,
  5111. !         target_table, n_targets,
  5112. !         GDK_ACTION_COPY | GDK_ACTION_MOVE);
  5113.   
  5114. !     gtk_signal_connect(GTK_OBJECT(gui.drawarea), "drag_data_received",
  5115. !         GTK_SIGNAL_FUNC(drag_data_received), NULL);
  5116. ! #endif
  5117.   
  5118. !     gtk_widget_show(gui.mainwin);
  5119. ! 
  5120. !     return OK;
  5121.   }
  5122.   
  5123. ! 
  5124. ! /*ARGSUSED*/
  5125.   void
  5126. ! gui_mch_exit(int rc)
  5127.   {
  5128. !     gtk_exit(0);
  5129.   }
  5130.   
  5131.   /*
  5132. !  * Get the position of the top left corner of the window.
  5133.    */
  5134.   int
  5135. ! gui_mch_get_winpos(int *x, int *y)
  5136.   {
  5137. !     /* For some people this must be gdk_window_get_origin() for a correct
  5138. !      * result.  Where is the documentation! */
  5139. ! #ifdef GTK_HAVE_FEATURES_1_1_4
  5140. !     gdk_window_get_root_origin(gui.mainwin->window, x, y);
  5141. ! #else
  5142. !     gdk_window_get_origin(gui.mainwin->window, x, y);
  5143.   #endif
  5144. +     return OK;
  5145. + }
  5146.   
  5147.   /*
  5148. !  * Set the position of the top left corner of the window to the given
  5149. !  * coordinates.
  5150.    */
  5151.   void
  5152. ! gui_mch_set_winpos(int x, int y)
  5153.   {
  5154. !     gdk_window_move(gui.mainwin->window, x, y);
  5155.   }
  5156.   
  5157.   /*
  5158. !  * Set the windows size.
  5159.    */
  5160. ! /*ARGSUSED*/
  5161. ! void
  5162. ! gui_mch_set_winsize(int width, int height,
  5163. !             int min_width, int min_height,
  5164. !             int base_width, int base_height)
  5165.   {
  5166. !     gtk_form_set_size(GTK_FORM(gui.formwin), width, height);
  5167.   
  5168. !     /* give GTK+ a chance to put all widget's into place */
  5169. !     gui_mch_update();
  5170.   
  5171. !     /* this will cause the proper resizement to happen too */
  5172. !     update_window_manager_hints();
  5173.   }
  5174.   
  5175.   
  5176.   /*
  5177. !  * The screen size is used to make sure the initial window doesn't get bigger
  5178. !  * then the screen.  This subtracts some room for menubar, toolbar and window
  5179. !  * decoreations.
  5180.    */
  5181.   void
  5182. ! gui_mch_get_screen_dimensions(int *screen_w, int *screen_h)
  5183.   {
  5184. !     *screen_w = gdk_screen_width();
  5185. !     /* Subtract 'guihearroom' from the height to allow some room for the
  5186. !      * window manager (task list and window title bar). */
  5187. !     *screen_h = gdk_screen_height() - p_ghr;
  5188. ! 
  5189. !     /*
  5190. !      * FIXME: dirty trick: Because the gui_get_base_height() doesn't include
  5191. !      * the toolbar and menubar for GTK, we subtract them from the screen
  5192. !      * hight, so that the window size can be made to fit on the screen.
  5193. !      * This should be completely changed later.
  5194. !      */
  5195. ! #ifdef USE_TOOLBAR
  5196. !     if (gui.toolbar && GTK_WIDGET_REALIZED(gui.toolbar)
  5197. !         && GTK_WIDGET_VISIBLE(gui.toolbar))
  5198. !     *screen_h -= gui.toolbar->allocation.height;
  5199. ! #endif
  5200. ! #ifdef WANT_MENU
  5201. !     if (gui.menubar && GTK_WIDGET_REALIZED(gui.menubar)
  5202. !         && GTK_WIDGET_VISIBLE(gui.menubar))
  5203. !     *screen_h -= gui.menubar->allocation.height;
  5204. ! #endif
  5205.   }
  5206.   
  5207. ! #if defined(WANT_MENU) || defined(PROTO)
  5208.   void
  5209. ! gui_mch_enable_menu(int flag)
  5210.   {
  5211. !     if (flag)
  5212. !     gtk_widget_show(gui.menubar);
  5213. !     else
  5214. !     gtk_widget_hide(gui.menubar);
  5215. ! 
  5216. !     update_window_manager_hints();
  5217.   }
  5218. + #endif
  5219. + 
  5220.   
  5221. + #if defined(USE_TOOLBAR) || defined(PROTO)
  5222.   void
  5223. ! gui_mch_show_toolbar(int showit)
  5224.   {
  5225. !     if (gui.toolbar == NULL)
  5226.       return;
  5227.   
  5228. !     if (!showit) {
  5229. !     if (GTK_WIDGET_VISIBLE(gui.toolbar)) {
  5230. !         gtk_widget_hide(gui.toolbar);
  5231. !         /* wait util this gets done on the server side. */
  5232. !         update_window_manager_hints();
  5233. !     }
  5234. !     } else {
  5235. !     g_assert(p_toolbar != NULL);
  5236. !     if (strstr((const char *)p_toolbar, "text")
  5237. !         && strstr((const char *)p_toolbar, "icons")) {
  5238. !         gtk_toolbar_set_style(GTK_TOOLBAR(gui.toolbar), GTK_TOOLBAR_BOTH);
  5239. !     } else if (strstr((const char *)p_toolbar, "text")) {
  5240. !         gtk_toolbar_set_style(GTK_TOOLBAR(gui.toolbar), GTK_TOOLBAR_TEXT);
  5241. !     } else if (strstr((const char *)p_toolbar, "icons")) {
  5242. !         gtk_toolbar_set_style(GTK_TOOLBAR(gui.toolbar), GTK_TOOLBAR_ICONS);
  5243.       }
  5244.   
  5245. !     if (!GTK_WIDGET_VISIBLE(gui.toolbar)) {
  5246. !         gtk_widget_show(gui.toolbar);
  5247. !         update_window_manager_hints();
  5248. !     }
  5249.   
  5250. !     if (strstr((const char *)p_toolbar, "tooltips"))
  5251. !         gtk_toolbar_set_tooltips(GTK_TOOLBAR(gui.toolbar), TRUE);
  5252. !     else
  5253. !         gtk_toolbar_set_tooltips(GTK_TOOLBAR(gui.toolbar), FALSE);
  5254.       }
  5255.   }
  5256.   #endif
  5257.   
  5258.   
  5259. ! #ifdef USE_FONTSET
  5260. ! static GuiFont
  5261. ! gui_mch_get_fontset(char_u * name, int report_error)
  5262.   {
  5263. !     GdkFont *font;
  5264.   
  5265. !     if (!gui.in_use || name == NULL)
  5266. !     return (GuiFont) 0;
  5267.   
  5268. !     font = gdk_fontset_load((gchar *) name);
  5269.   
  5270. !     if (font == NULL) {
  5271. !     if (report_error)
  5272. !         EMSG2("Unknown fontset: %s", name);
  5273. !     return (GuiFont) 0;
  5274. !     }
  5275.   
  5276. !     /* reference this font as beeing in use */
  5277. !     gdk_font_ref(font);
  5278.   
  5279. !     return (GuiFont) font;
  5280.   }
  5281. + #endif
  5282.   
  5283. + #ifdef GTK_HAVE_FEATURES_1_1_0
  5284.   /*
  5285. !  * Get a font structure for highlighting.
  5286. !  * "cbdata" is a pointer to the global gui structure.
  5287.    */
  5288. ! /*ARGSUSED*/
  5289. ! static void
  5290. ! font_sel_ok(GtkWidget *wgt, gpointer cbdata)
  5291.   {
  5292. !     Gui *vw = (Gui *)cbdata;
  5293. !     GtkFontSelectionDialog *fs = (GtkFontSelectionDialog *)vw->fontdlg;
  5294.   
  5295. !     if (vw->fontname)
  5296. !     g_free(vw->fontname);
  5297.   
  5298. !     vw->fontname = (char_u *)g_strdup(
  5299. !                 gtk_font_selection_dialog_get_font_name(fs));
  5300. !     gtk_widget_hide(vw->fontdlg);
  5301. !     if (gtk_main_level() > 0)
  5302. !     gtk_main_quit();
  5303. ! }
  5304.   
  5305. ! /*ARGSUSED*/
  5306. ! static void
  5307. ! font_sel_cancel(GtkWidget *wgt, gpointer cbdata)
  5308. ! {
  5309. !     Gui *vw = (Gui *)cbdata;
  5310. ! 
  5311. !     gtk_widget_hide(vw->fontdlg);
  5312. !     if (gtk_main_level() > 0)
  5313. !     gtk_main_quit();
  5314.   }
  5315.   
  5316. ! /*ARGSUSED*/
  5317. ! static void
  5318. ! font_sel_destroy(GtkWidget *wgt, gpointer cbdata)
  5319.   {
  5320. !     Gui *vw = (Gui *)cbdata;
  5321. ! 
  5322. !     vw->fontdlg = NULL;
  5323. !     if (gtk_main_level() > 0)
  5324. !     gtk_main_quit();
  5325.   }
  5326. + #endif
  5327.   
  5328.   /*
  5329. !  * Initialise vim to use the font with the given name.
  5330. !  * Return FAIL if the font could not be loaded, OK otherwise.
  5331.    */
  5332. ! int
  5333. ! gui_mch_init_font(char_u * font_name)
  5334.   {
  5335. !     GdkFont    *font = NULL;
  5336. !     char    *chunk[28], *sdup, *tmp;
  5337. !     int        len, i;
  5338.   
  5339. ! #ifdef USE_FONTSET
  5340. !     {
  5341. !     static char_u *dflt_fontset = NULL;
  5342.   
  5343. !     if (gui.fontset)
  5344. !     {
  5345. !         /* If fontset is active, VIM treat all the font as a fontset. */
  5346. !         if (font_name == NULL || vim_strchr(font_name, ',') == NULL)
  5347. !         font_name = dflt_fontset;
  5348. !         font = gui_mch_get_fontset(font_name, FALSE);
  5349. !         if (font == NULL)
  5350. !         return FAIL;
  5351. !     }
  5352. !     else if (font_name == NULL && *p_guifontset)
  5353. !     {
  5354. !         font = gui_mch_get_fontset(p_guifontset, FALSE);
  5355. !         if (font)
  5356. !         {
  5357. !         font_name = p_guifontset;
  5358. !         dflt_fontset = alloc(STRLEN(p_guifontset) + 1);
  5359. !         STRCPY(dflt_fontset, p_guifontset);
  5360. !         }
  5361. !     }
  5362. !     }
  5363.   
  5364. !     if (font == NULL)
  5365. ! #endif
  5366.       {
  5367. !     /*
  5368. !      * If none of the fonts in 'font' could be loaded, try the default,
  5369. !      * which should be present on all X11 servers.
  5370. !      */
  5371. !     if (font_name == NULL)
  5372. !         font_name = (char_u *) DFLT_FONT;
  5373. ! 
  5374. ! #ifdef GTK_HAVE_FEATURES_1_1_0
  5375. !     if (STRCMP(font_name, "*") == 0) {
  5376. !         /*
  5377. !          * Request for a font handling dialog.
  5378. !          * Not quite sure we should handle this here...
  5379. !          */
  5380. !         /*
  5381. !          * NOTE about font selection widget: this can easily be backported
  5382. !          * to gtk-1.0.x.
  5383. !          */
  5384. !         if (!gui.fontdlg)
  5385. !         {
  5386. !         GtkFontSelectionDialog    *fsd = NULL;
  5387. ! 
  5388. !         gui.fontdlg = gtk_font_selection_dialog_new("Font Selection");
  5389. !         fsd = GTK_FONT_SELECTION_DIALOG(gui.fontdlg);
  5390. !         if (p_guifont != NULL)
  5391. !             gtk_font_selection_dialog_set_font_name(fsd,
  5392. !                                 (char *)p_guifont);
  5393. ! # ifdef GTK_HAVE_FEATURES_1_1_4
  5394. !         gtk_window_set_modal(GTK_WINDOW(gui.fontdlg), TRUE);
  5395. !         gtk_window_set_transient_for(GTK_WINDOW(gui.fontdlg),
  5396. !                              GTK_WINDOW(gui.mainwin));
  5397.   # endif
  5398. !         gtk_signal_connect(GTK_OBJECT(gui.fontdlg), "destroy",
  5399. !                    GTK_SIGNAL_FUNC(font_sel_destroy), &gui);
  5400. !         gtk_signal_connect(GTK_OBJECT(fsd->ok_button), "clicked",
  5401. !                    GTK_SIGNAL_FUNC(font_sel_ok), &gui);
  5402. !         gtk_signal_connect(GTK_OBJECT(fsd->cancel_button), "clicked",
  5403. !                    GTK_SIGNAL_FUNC(font_sel_cancel), &gui);
  5404. !         }
  5405. !         if (gui.fontname)
  5406. !         {
  5407. !         g_free(gui.fontname);
  5408. !         gui.fontname = NULL;
  5409. !         }
  5410. !         gtk_window_position(GTK_WINDOW(gui.fontdlg), GTK_WIN_POS_MOUSE);
  5411. !         gtk_widget_show(gui.fontdlg);
  5412. ! # ifdef GTK_HAVE_FEATURES_1_1_4
  5413. !         {
  5414. !         static gchar        *spacings[] = {"c", "m", NULL};
  5415. ! 
  5416. !         /* In GTK 1.2.3 this must be after the gtk_widget_show() call,
  5417. !          * otherwise everything is blocked for ten seconds. */
  5418. !         gtk_font_selection_dialog_set_filter(
  5419. !             GTK_FONT_SELECTION_DIALOG(gui.fontdlg),
  5420. !             GTK_FONT_FILTER_BASE,
  5421. !             GTK_FONT_ALL, NULL, NULL,
  5422. !             NULL, NULL, spacings, NULL);
  5423. !         }
  5424. ! # endif
  5425. ! 
  5426. !         while (gui.fontdlg && GTK_WIDGET_VISIBLE(gui.fontdlg))
  5427. !         gtk_main_iteration_do(TRUE);
  5428. ! 
  5429. !         if (gui.fontname == NULL)
  5430. !         return FAIL;
  5431. !         vim_free(p_guifont);
  5432. !         p_guifont = vim_strsave(gui.fontname);
  5433. !         font_name = p_guifont;
  5434. !     }
  5435. ! #endif
  5436. !     if (font == NULL)
  5437. !         font = gui_mch_get_font(font_name, FALSE);
  5438. ! 
  5439. !     if (font == NULL)
  5440. !         return FAIL;
  5441. !     }
  5442. ! 
  5443. !     if (gui.norm_font != 0)
  5444. !     gdk_font_unref(font);
  5445. !     gui.norm_font = font;
  5446. ! #ifdef USE_FONTSET
  5447. !     if (font->type == GDK_FONT_FONTSET)
  5448. !     {
  5449. !     gui.fontset = (GuiFont) font;
  5450. !     gui.char_width = gdk_string_width(font, " ");
  5451.       }
  5452.       else
  5453.   #endif
  5454. !     {
  5455. !     gui.char_width = ((XFontStruct *)
  5456. !                       GDK_FONT_XFONT(font))->max_bounds.width;
  5457. !     }
  5458.   
  5459. !     gui.char_height = font->ascent + font->descent;
  5460. !     gui.char_ascent = font->ascent;
  5461.   
  5462. !     /* Set the fontname, which will be used for information purposes */
  5463. !     hl_set_font_name(font_name);
  5464.   
  5465. !     if (font->type != GDK_FONT_FONTSET)
  5466. !     {
  5467. !     /* There is only one excuse I can give for the following attempt
  5468. !      * to manage font styles:
  5469. !      *
  5470. !      * I HATE THE BRAIN DEAD WAY X11 IS HANDLING FONTS (--mdcki)
  5471. !      */
  5472. !     if ((sdup = g_strdup((const char *)font_name)) == NULL)
  5473. !         return FAIL;
  5474.   
  5475. !     /* slipt up the whole */
  5476. !     i = 0;
  5477. !     for (tmp = sdup; *tmp != '\0'; ++tmp)
  5478. !         if (*tmp == '-')
  5479. !         {
  5480. !         *tmp = '\0';
  5481. !         chunk[i] = tmp + 1;
  5482. !         ++i;
  5483. !         }
  5484. ! 
  5485. !     g_free(sdup);
  5486. ! 
  5487. !     if (i == 14)
  5488. !     {
  5489. !         char *bold_name = NULL;
  5490. !         char *ital_name = NULL;
  5491. !         char *italbold_name = NULL;
  5492. ! 
  5493. !         /* font name was compleate */
  5494. !         len = strlen((const char *)font_name) + 32;
  5495. !         bold_name = (char *)alloc(len);
  5496. !         ital_name = (char *)alloc(len);
  5497. !         italbold_name = (char *)alloc(len);
  5498. !         if (bold_name == NULL || ital_name == NULL || italbold_name == NULL)
  5499. !         {
  5500. !         vim_free(bold_name);
  5501. !         vim_free(ital_name);
  5502. !         vim_free(italbold_name);
  5503. !         return FAIL;
  5504. !         }
  5505. ! 
  5506. !         *bold_name = '\0';
  5507. !         *ital_name = '\0';
  5508. !         *italbold_name = '\0';
  5509. ! 
  5510. !         for (i = 0; i < 14; ++i)
  5511. !         {
  5512. !         strcat(bold_name, "-");
  5513. !         strcat(ital_name, "-");
  5514. !         strcat(italbold_name, "-");
  5515. !         strcat(bold_name, (i != 2) ? chunk[i] : "bold");
  5516. !         strcat(ital_name, (i != 3) ? chunk[i] : "o");
  5517. ! 
  5518. !         if (i != 2 && i != 3)
  5519. !             strcat(italbold_name, chunk[i]);
  5520. !         else
  5521. !         {
  5522. !             if (i == 2)
  5523. !             strcat(italbold_name, "bold");
  5524. !             else if (i == 3)
  5525. !             strcat(italbold_name, "o");
  5526. !         }
  5527. !         }
  5528. ! 
  5529. !         font = gui_mch_get_font((char_u *)bold_name, FALSE);
  5530. !         if (font != NULL)
  5531. !         gui.bold_font = font;
  5532. !         else if (gui.bold_font)
  5533. !         {
  5534. !         gdk_font_unref(gui.bold_font);
  5535. !         gui.bold_font = NULL;
  5536. !         }
  5537. ! 
  5538. !         font = gui_mch_get_font((char_u *)ital_name, FALSE);
  5539. !         if (font != NULL)
  5540. !         gui.ital_font = font;
  5541. !         else if (gui.ital_font)
  5542. !         {
  5543. !         gdk_font_unref(gui.ital_font);
  5544. !         gui.ital_font = NULL;
  5545. !         }
  5546. ! 
  5547. !         font = gui_mch_get_font((char_u *)italbold_name, FALSE);
  5548. !         if (font != NULL)
  5549. !         gui.boldital_font = font;
  5550. !         else if (gui.boldital_font)
  5551. !         {
  5552. !         gdk_font_unref(gui.boldital_font);
  5553. !         gui.boldital_font = NULL;
  5554. !         }
  5555. ! 
  5556. !         vim_free(bold_name);
  5557. !         vim_free(ital_name);
  5558. !         vim_free(italbold_name);
  5559. !     }
  5560. !     }
  5561. ! 
  5562. !     /* Synchronize the fonts used in user input dialogs, since otherwise
  5563. !      * search/replace will be esp annoyig in case of international font usage.
  5564. !      */
  5565. !     gui_gtk_synch_fonts();
  5566. ! 
  5567. ! #ifdef USE_XIM
  5568. !     /* Adjust input management behaviour to the capabilities of the new
  5569. !      * fontset */
  5570. !     xim_decide_input_style();
  5571. !     if (xim_get_status_area_height())
  5572. !     {
  5573. !     /* Status area is required.  Just create the empty label so that
  5574. !      * mainwin will allocate the extra space for status area. */
  5575. !     GtkWidget *label = gtk_label_new("       ");
  5576. ! 
  5577. !     gtk_widget_set_usize(label, 20, gui.char_height + 2);
  5578. !     gtk_box_pack_end(GTK_BOX(GTK_BIN(gui.mainwin)->child), label,
  5579. !                                  FALSE, FALSE, 0);
  5580. !     gtk_widget_show(label);
  5581. !     }
  5582. ! #endif
  5583.   
  5584. !     /* Preserve the logical dimensions of the screen. */
  5585. !     update_window_manager_hints();
  5586.   
  5587. !     return OK;
  5588.   }
  5589.   
  5590.   
  5591. ! GuiFont
  5592. ! gui_mch_get_font(char_u * name, int report_error)
  5593.   {
  5594. !     GdkFont *font;
  5595.   
  5596. !     if (!gui.in_use || name == NULL)    /* can't do this when GUI not running */
  5597. !     return (GuiFont) 0;
  5598.   
  5599. ! #ifdef USE_FONTSET
  5600. !     if (gui.fontset)
  5601. !     /* If fontset is active, VIM treat all the font as a fontset */
  5602. !     return gui_mch_get_fontset(name, report_error);
  5603. !     else if (vim_strchr(name, ','))
  5604. !     return (GuiFont)0;
  5605.   #endif
  5606.   
  5607. !     font = gdk_font_load((const gchar *) name);
  5608.   
  5609. !     if (font == NULL) {
  5610. !     if (report_error)
  5611. !         EMSG2("Unknown font: %s", name);
  5612. !     return (GuiFont) 0;
  5613. !     }
  5614.   
  5615. !     /* reference this font as beeing in use */
  5616. !     gdk_font_ref(font);
  5617. !     if (((XFontStruct *) GDK_FONT_XFONT(font))->max_bounds.width
  5618. !     != ((XFontStruct *) GDK_FONT_XFONT(font))->min_bounds.width) {
  5619. !     EMSG2("Font \"%s\" is not fixed-width", name);
  5620. !     gdk_font_unref(font);
  5621.   
  5622. !     return (GuiFont) 0;
  5623. !     }
  5624. !     return (GuiFont) font;
  5625.   }
  5626.   
  5627.   /*
  5628. !  * Set the current text font.
  5629. !  * Since we create all GC on demand, we use just gui.current_font to
  5630. !  * indicate the desired current font.
  5631.    */
  5632. ! void
  5633. ! gui_mch_set_font(GuiFont font)
  5634.   {
  5635. !     gui.current_font = font;
  5636.   }
  5637.   
  5638. ! #if 0 /* not used */
  5639. ! /*
  5640. !  * Return TRUE if the two fonts given are equivalent.
  5641. !  */
  5642. ! int
  5643. ! gui_mch_same_font(GuiFont f1, GuiFont f2)
  5644.   {
  5645. !     return gdk_font_equal((GdkFont *) f1, (GdkFont *) f2);
  5646.   }
  5647. + #endif
  5648.   
  5649.   /*
  5650. !  * If a font is not going to be used, free its structure.
  5651.    */
  5652.   void
  5653. ! gui_mch_free_font(GuiFont font)
  5654.   {
  5655. !     if (font)
  5656. !     gdk_font_unref((GdkFont *) font);
  5657. ! }
  5658.   
  5659.   
  5660. ! /*
  5661. !  * Return the Pixel value (color) for the given color name.  This routine was
  5662. !  * pretty much taken from example code in the Silicon Graphics OSF/Motif
  5663. !  * Programmer's Guide.
  5664. !  * Return -1 for error.
  5665. !  */
  5666. ! GuiColor
  5667. ! gui_mch_get_color(char_u * name)
  5668. ! {
  5669. !     int i;
  5670. !     static char *(vimnames[][2]) =
  5671. !     {
  5672. !     /* A number of colors that some X11 systems don't have */
  5673. !     {"LightRed", "#FFA0A0"},
  5674. !     {"LightGreen", "#80FF80"},
  5675. !     {"LightMagenta", "#FFA0FF"},
  5676. !     {"DarkCyan", "#008080"},
  5677. !     {"DarkBlue", "#0000C0"},
  5678. !     {"DarkRed", "#C00000"},
  5679. !     {"DarkMagenta", "#C000C0"},
  5680. !     {"DarkGrey", "#C0C0C0"},
  5681. !     {NULL, NULL}
  5682. !     };
  5683.   
  5684. !     if (!gui.in_use)        /* can't do this when GUI not running */
  5685. !     return (GuiColor)(-1);
  5686.   
  5687. !     while (name != NULL) {
  5688. !     GdkColor color;
  5689.   
  5690. !     if (gdk_color_parse((const gchar *)name, &color)) {
  5691. !         GdkColormap *colormap;
  5692. !         colormap = gtk_widget_get_colormap(gui.drawarea);
  5693. !         gdk_color_alloc(colormap, &color);
  5694.   
  5695. !         return (GuiColor) color.pixel;
  5696. !     }
  5697. !     /* add a few builtin names */
  5698. !     for (i = 0;; ++i) {
  5699. !         if (vimnames[i][0] == NULL) {
  5700. !         name = NULL;
  5701. !         break;
  5702. !         }
  5703. !         if (STRICMP(name, vimnames[i][0]) == 0) {
  5704. !         name = (char_u *) vimnames[i][1];
  5705. !         break;
  5706. !         }
  5707. !     }
  5708. !     }
  5709.   
  5710. !     return (GuiColor)(-1);
  5711.   }
  5712.   
  5713.   /*
  5714. !  * Set the current text foreground color.
  5715.    */
  5716. ! void
  5717. ! gui_mch_set_fg_color(GuiColor color)
  5718.   {
  5719. !     gui.fgcolor->pixel = (Pixel) color;
  5720. ! }
  5721.   
  5722. ! /*
  5723. !  * Set the current text background color.
  5724. !  */
  5725. ! void
  5726. ! gui_mch_set_bg_color(GuiColor color)
  5727. ! {
  5728. !     gui.bgcolor->pixel = (Pixel) color;
  5729.   }
  5730.   
  5731.   /*
  5732. !  * Use the blank mouse pointer or not.
  5733. !  *
  5734. !  * hide: TRUE = use blank ptr, FALSE = use parent ptr
  5735.    */
  5736.   void
  5737. ! gui_mch_mousehide(int hide)
  5738.   {
  5739. !     if (gui.pointer_hidden != hide) {
  5740. !     if (gui.drawarea->window && gui.blank_pointer) {
  5741. !         if (hide)
  5742. !         gdk_window_set_cursor(gui.drawarea->window, gui.blank_pointer);
  5743. !         else
  5744. !         gdk_window_set_cursor(gui.drawarea->window, NULL);
  5745.       }
  5746. !     gui.pointer_hidden = hide;
  5747.       }
  5748.   }
  5749.   
  5750.   void
  5751. ! gui_mch_draw_string(int row, int col, char_u * s, int len, int flags)
  5752.   {
  5753. !     GdkGC *gc;
  5754.   
  5755. !     if (gui.current_font == NULL || gui.drawarea->window == NULL)
  5756.       return;
  5757.   
  5758. ! #if defined(USE_FONTSET) && defined(MULTI_BYTE)
  5759. !     if (gui.fontset)
  5760. !     {
  5761. !     if (col > 0 && mb_isbyte1(LinePointers[row], col - 1))
  5762. !     {
  5763. !         col++;
  5764. !         len--;
  5765. !         s++;
  5766. !     }
  5767. !     if (len == 1 && IsLeadByte(*s))
  5768. !         len = 2;
  5769. !     }
  5770. ! #endif
  5771. ! 
  5772. !     gc = gdk_gc_new(gui.drawarea->window);
  5773. !     gdk_gc_set_exposures(gc, gui.visibility != GDK_VISIBILITY_UNOBSCURED);
  5774. ! 
  5775. !     if (flags & DRAW_TRANSP) {
  5776. !     gdk_gc_set_foreground(gc, gui.fgcolor);
  5777. !     gdk_draw_text(gui.drawarea->window,
  5778. !               gui.current_font,
  5779. !               gc,
  5780. !               TEXT_X(col), TEXT_Y(row),
  5781. !               (const gchar *)s, len);
  5782.       } else {
  5783. !     int width;
  5784. !     int height;
  5785. !     width = gdk_text_width(gui.current_font, (const gchar *)s, len);
  5786. !     height = gui.char_height;
  5787.   
  5788. !     gdk_gc_set_foreground(gc, gui.bgcolor);
  5789. !     gdk_draw_rectangle(gui.drawarea->window,
  5790. !                gc,
  5791. !                TRUE,
  5792. !                FILL_X(col), FILL_Y(row), width, height);
  5793.       gdk_gc_set_foreground(gc, gui.fgcolor);
  5794. !     gdk_draw_text(gui.drawarea->window,
  5795. !               gui.current_font,
  5796. !               gc,
  5797. !               TEXT_X(col), TEXT_Y(row),
  5798. !               (const gchar *)s, len);
  5799. !     }
  5800.   
  5801. !     /* redraw the contents with an offset of 1 to emulate bold */
  5802. !     if (flags & DRAW_BOLD) {
  5803. !     gdk_draw_text(gui.drawarea->window,
  5804. !               gui.current_font,
  5805. !               gc,
  5806. !               TEXT_X(col) + 1, TEXT_Y(row),
  5807. !               (const gchar *)s, len);
  5808. !     }
  5809.   
  5810. !     if (flags & DRAW_UNDERL) {
  5811. !     gdk_draw_line(gui.drawarea->window,
  5812. !               gc, FILL_X(col),
  5813. !     FILL_Y(row + 1) - 1, FILL_X(col + len) - 1, FILL_Y(row + 1) - 1);
  5814.       }
  5815. +     gdk_gc_destroy(gc);
  5816.   }
  5817.   
  5818.   /*
  5819. !  * Return OK if the key with the termcap name "name" is supported.
  5820.    */
  5821. ! int
  5822. ! gui_mch_haskey(char_u * name)
  5823.   {
  5824. !     int i;
  5825.   
  5826. !     for (i = 0; special_keys[i].key_sym != 0; i++)
  5827. !     if (name[0] == special_keys[i].code0 &&
  5828. !         name[1] == special_keys[i].code1)
  5829. !         return OK;
  5830. !     return FAIL;
  5831. ! }
  5832. ! 
  5833. ! #if defined(WANT_TITLE) || defined(PROTO)
  5834. ! /*
  5835. !  * Return the text window-id and display.  Only required for X-based GUI's
  5836. !  */
  5837. ! int
  5838. ! gui_get_x11_windis(Window * win, Display ** dis)
  5839. ! {
  5840. !     /*
  5841. !      * This is currently only used by the code which is handling the
  5842. !      * window manager title of this program.
  5843. !      */
  5844. !     *dis = GDK_DISPLAY();
  5845. !     if (gui.mainwin->window) {
  5846. !     *win = GDK_WINDOW_XWINDOW(gui.mainwin->window);
  5847. !     return OK;
  5848.       }
  5849. +     *win = 0;
  5850. +     return FAIL;
  5851.   }
  5852. + #endif
  5853.   
  5854.   void
  5855. ! gui_mch_beep()
  5856.   {
  5857. !     gdk_beep();
  5858. ! }
  5859. ! 
  5860. ! void
  5861. ! gui_mch_flash()
  5862. ! {
  5863. !     GdkGCValues values;
  5864. !     GdkGC *invert_gc;
  5865. !     GdkColor foreground;
  5866. !     GdkColor background;
  5867. ! 
  5868. !     if (gui.drawarea->window == NULL)
  5869. !     return;
  5870. ! 
  5871. !     foreground.pixel = gui.norm_pixel ^ gui.back_pixel;
  5872. !     background.pixel = gui.norm_pixel ^ gui.back_pixel;
  5873. ! 
  5874. !     values.foreground = foreground;
  5875. !     values.background = background;
  5876. !     values.function = GDK_XOR;
  5877. !     invert_gc = gdk_gc_new_with_values(gui.drawarea->window,
  5878. !                        &values,
  5879. !                        GDK_GC_FOREGROUND |
  5880. !                        GDK_GC_BACKGROUND |
  5881. !                        GDK_GC_FUNCTION);
  5882. !     gdk_gc_set_exposures(invert_gc, gui.visibility != GDK_VISIBILITY_UNOBSCURED);
  5883. ! 
  5884. !     /* Do a visual beep by changing back and forth in some undetermined way,
  5885. !      * the foreground and background colors.  This is due to the fact that
  5886. !      * there can't be really any prediction about the effects of XOR on
  5887. !      * arbitrary X11 servers. However this seems to be enought for what we
  5888. !      * intend it to do.
  5889. !      */
  5890. !     gdk_draw_rectangle(gui.drawarea->window, invert_gc,
  5891. !                TRUE,
  5892. !                0, 0,
  5893. !                FILL_X((int) Columns) + gui.border_offset,
  5894. !                FILL_Y((int) Rows) + gui.border_offset);
  5895. ! 
  5896. !     gdk_flush();
  5897. !     ui_delay(20L, TRUE);    /* wait 1/50 of a second */
  5898. !     gdk_draw_rectangle(gui.drawarea->window, invert_gc,
  5899. !                TRUE,
  5900. !                0, 0,
  5901. !                FILL_X((int) Columns) + gui.border_offset,
  5902. !                FILL_Y((int) Rows) + gui.border_offset);
  5903. ! 
  5904. !     gdk_gc_destroy(invert_gc);
  5905.   }
  5906.   
  5907.   /*
  5908. !  * Invert a rectangle from row r, column c, for nr rows and nc columns.
  5909.    */
  5910. ! void
  5911. ! gui_mch_invert_rectangle(int r, int c, int nr, int nc)
  5912.   {
  5913. !     GdkGCValues values;
  5914. !     GdkGC *invert_gc;
  5915. !     GdkColor foreground;
  5916. !     GdkColor background;
  5917.   
  5918. !     if (gui.drawarea->window == NULL)
  5919. !     return;
  5920. ! 
  5921. !     foreground.pixel = gui.norm_pixel ^ gui.back_pixel;
  5922. !     background.pixel = gui.norm_pixel ^ gui.back_pixel;
  5923. ! 
  5924. !     values.foreground = foreground;
  5925. !     values.background = background;
  5926. !     values.function = GDK_XOR;
  5927. !     invert_gc = gdk_gc_new_with_values(gui.drawarea->window,
  5928. !                        &values,
  5929. !                        GDK_GC_FOREGROUND |
  5930. !                        GDK_GC_BACKGROUND |
  5931. !                        GDK_GC_FUNCTION);
  5932. !     gdk_gc_set_exposures(invert_gc, gui.visibility != GDK_VISIBILITY_UNOBSCURED);
  5933. !     gdk_draw_rectangle(gui.drawarea->window, invert_gc,
  5934. !                TRUE,
  5935. !                FILL_X(c), FILL_Y(r),
  5936. !                (nc) * gui.char_width, (nr) * gui.char_height);
  5937. !     gdk_gc_destroy(invert_gc);
  5938.   }
  5939.   
  5940.   /*
  5941. !  * Iconify the GUI window.
  5942.    */
  5943.   void
  5944. ! gui_mch_iconify()
  5945.   {
  5946. !     XIconifyWindow(GDK_DISPLAY(),
  5947. !            GDK_WINDOW_XWINDOW(gui.mainwin->window),
  5948. !            DefaultScreen(GDK_DISPLAY()));
  5949.   }
  5950.   
  5951.   /*
  5952. !  * Draw a cursor without focus.
  5953.    */
  5954.   void
  5955. ! gui_mch_draw_hollow_cursor(GuiColor color)
  5956.   {
  5957. !     GdkGC *gc;
  5958. ! 
  5959. !     if (gui.drawarea->window == NULL)
  5960.       return;
  5961.   
  5962. !     gui_mch_set_fg_color(color);
  5963.   
  5964. !     gc = gdk_gc_new(gui.drawarea->window);
  5965. !     gdk_gc_set_exposures(gc, gui.visibility != GDK_VISIBILITY_UNOBSCURED);
  5966. !     gdk_gc_set_foreground(gc, gui.fgcolor);
  5967. ! #if defined(USE_FONTSET) && defined(MULTI_BYTE)
  5968. !     if (gui.fontset)
  5969. !     {
  5970. !     if (IsLeadByte(LinePointers[gui.row][gui.col])
  5971. ! # ifdef HANGUL_INPUT
  5972. !         || composing_hangul
  5973. ! # endif
  5974. !        )
  5975. !         gdk_draw_rectangle(gui.drawarea->window, gc,
  5976. !                    FALSE,
  5977. !                    FILL_X(gui.col), FILL_Y(gui.row),
  5978. !                    2*gui.char_width - 1, gui.char_height - 1);
  5979. !     else
  5980. !         gdk_draw_rectangle(gui.drawarea->window, gc,
  5981. !                    FALSE,
  5982. !                    FILL_X(gui.col), FILL_Y(gui.row),
  5983. !                    gui.char_width - 1, gui.char_height - 1);
  5984. !     }
  5985. !     else
  5986. ! #endif
  5987. !     gdk_draw_rectangle(gui.drawarea->window, gc,
  5988. !                FALSE,
  5989. !                FILL_X(gui.col), FILL_Y(gui.row),
  5990. !                gui.char_width - 1, gui.char_height - 1);
  5991. !     gdk_gc_destroy(gc);
  5992.   }
  5993.   
  5994.   /*
  5995. !  * Draw part of a cursor, "w" pixels wide, and "h" pixels high, using
  5996. !  * color "color".
  5997.    */
  5998.   void
  5999. ! gui_mch_draw_part_cursor(int w, int h, GuiColor color)
  6000.   {
  6001. !     GdkGC *gc;
  6002. ! 
  6003. !     if (gui.drawarea->window == NULL)
  6004.       return;
  6005.   
  6006. !     gui_mch_set_fg_color(color);
  6007.   
  6008. !     gc = gdk_gc_new(gui.drawarea->window);
  6009. !     gdk_gc_set_exposures(gc, gui.visibility != GDK_VISIBILITY_UNOBSCURED);
  6010. !     gdk_gc_set_foreground(gc, gui.fgcolor);
  6011. !     gdk_draw_rectangle(gui.drawarea->window, gc,
  6012. !                TRUE,
  6013. ! #ifdef RIGHTLEFT
  6014. !     /* vertical line should be on the right of current point */
  6015. !        State != CMDLINE && curwin->w_p_rl ? FILL_X(gui.col + 1) - w :
  6016. ! #endif
  6017. !                FILL_X(gui.col),
  6018. !                FILL_Y(gui.row) + gui.char_height - h,
  6019. !                w, h);
  6020. !     gdk_gc_destroy(gc);
  6021.   }
  6022.   
  6023. ! #ifndef GTK_HAVE_FEATURES_1_1_0
  6024. ! static gint
  6025. ! idle_function(GtkWidget * label)
  6026.   {
  6027. !     if (gtk_main_level() > 0)
  6028. !     gtk_main_quit();
  6029. ! 
  6030. !     return FALSE;
  6031.   }
  6032.   #endif
  6033.   
  6034. + 
  6035.   /*
  6036. !  * Catch up with any queued X11 events.  This may put keyboard input into the
  6037. !  * input buffer, call resize call-backs, trigger timers etc.  If there is
  6038. !  * nothing in the X11 event queue (& no timers pending), then we return
  6039. !  * immediately.
  6040.    */
  6041.   void
  6042. ! gui_mch_update()
  6043.   {
  6044. ! #ifdef GTK_HAVE_FEATURES_1_1_0
  6045. !     while (gtk_events_pending() && !vim_is_input_buf_full())
  6046. !     gtk_main_iteration_do(FALSE);
  6047. ! #else
  6048. !     int pending;
  6049. ! 
  6050. !     /* Somehow the above loop hangs on GTK 1.0.6.  Use the idle_function() to
  6051. !      * work around this weird problem. */
  6052. !     while (((pending = gtk_events_pending()) > 1) && !vim_is_input_buf_full())
  6053. !     gtk_main_iteration();
  6054. ! 
  6055. !     if ((pending == 1) && !vim_is_input_buf_full()) {
  6056. !     gtk_idle_add((GtkFunction)idle_function, gui.mainwin);
  6057. !     gtk_main_iteration_do(FALSE);
  6058. !     }
  6059. ! #endif
  6060.   }
  6061.   
  6062. + static gint
  6063. + input_timer_cb(gpointer data)
  6064. + {
  6065. +     int *timed_out = (int *) data;
  6066. + 
  6067. +     /* Just inform the caller about the accurence of it */
  6068. +     *timed_out = TRUE;
  6069. + 
  6070. +     if (gtk_main_level() > 0)
  6071. +     gtk_main_quit();
  6072. + 
  6073. +     return FALSE;        /* don't happen again */
  6074. + }
  6075.   
  6076.   /*
  6077. !  * GUI input routine called by gui_wait_for_chars().  Waits for a character
  6078. !  * from the keyboard.
  6079. !  *  wtime == -1     Wait forever.
  6080. !  *  wtime == 0      This should never happen.
  6081. !  *  wtime > 0       Wait wtime milliseconds for a character.
  6082. !  * Returns OK if a character was found to be available within the given time,
  6083. !  * or FAIL otherwise.
  6084.    */
  6085.   int
  6086. ! gui_mch_wait_for_chars(long wtime)
  6087.   {
  6088. !     int focus;
  6089. !     guint timer;
  6090.   
  6091. !     static int timed_out;
  6092.   
  6093. !     timed_out = FALSE;
  6094. ! 
  6095. !     /* this timeout makes sure that we will return if no characters arrived in
  6096. !      * time */
  6097. ! 
  6098. !     if (wtime > 0)
  6099. !     timer = gtk_timeout_add((guint32)wtime, input_timer_cb, &timed_out);
  6100. !     else
  6101. !     timer = 0;
  6102. ! 
  6103. !     focus = gui.in_focus;
  6104. ! 
  6105. !     do {
  6106. !     /* Stop or start blinking when focus changes */
  6107. !     if (gui.in_focus != focus) {
  6108. !         if (gui.in_focus)
  6109. !         gui_mch_start_blink();
  6110. !         else
  6111. !         gui_mch_stop_blink();
  6112. !         focus = gui.in_focus;
  6113. !     }
  6114. ! 
  6115. !     /*
  6116. !      * Loop in GTK+ processing  until a timeout or input occurs.
  6117. !      */
  6118. !     gtk_main();
  6119. ! 
  6120. !     /* Got char, return immediately */
  6121. !     if (!vim_is_input_buf_empty()) {
  6122. !         if (timer != 0 && !timed_out)
  6123. !         gtk_timeout_remove(timer);
  6124. !         return OK;
  6125. !     }
  6126. !     } while (wtime < 0 || !timed_out);
  6127. ! 
  6128. !     /*
  6129. !      * Flush all eventually pending (drawing) events.
  6130. !      */
  6131. !     gui_mch_update();
  6132. ! 
  6133. !     return FAIL;
  6134. ! }
  6135. ! 
  6136. ! 
  6137. ! /****************************************************************************
  6138. !  * Output drawing routines.
  6139. !  ****************************************************************************/
  6140. ! 
  6141. ! 
  6142. ! /* Flush any output to the screen */
  6143. ! void
  6144. ! gui_mch_flush()
  6145. ! {
  6146. !     gdk_flush();
  6147.   }
  6148.   
  6149.   /*
  6150. !  * Clear a rectangular region of the screen from text pos (row1, col1) to
  6151. !  * (row2, col2) inclusive.
  6152.    */
  6153. ! void
  6154. ! gui_mch_clear_block(int row1, int col1, int row2, int col2)
  6155.   {
  6156. !     GdkGC *gc;
  6157. !     GdkColor color;
  6158. ! 
  6159. !     if (gui.drawarea->window == NULL)
  6160. !     return;
  6161. ! 
  6162. !     color.pixel = gui.back_pixel;
  6163.   
  6164. !     gc = gdk_gc_new(gui.drawarea->window);
  6165. !     gdk_gc_set_exposures(gc, gui.visibility != GDK_VISIBILITY_UNOBSCURED);
  6166. !     gdk_gc_set_foreground(gc, &color);
  6167.   
  6168. !     /*
  6169. !      * Clear one extra pixel at the right, for when bold characters have
  6170. !      * spilled over to the next column.  This can erase part of the next
  6171. !      * character however in the usage context of this function it will be
  6172. !      * overriden immediately by the correct character again.
  6173. !      */
  6174.   
  6175. !     gdk_draw_rectangle(gui.drawarea->window, gc, TRUE,
  6176. !                FILL_X(col1), FILL_Y(row1),
  6177. !                (col2 - col1 + 1) * gui.char_width + 1,
  6178. !                (row2 - row1 + 1) * gui.char_height);
  6179. !     gdk_gc_destroy(gc);
  6180. ! }
  6181.   
  6182. ! void
  6183. ! gui_mch_clear_all(void)
  6184. ! {
  6185. !     if (gui.drawarea->window == NULL)
  6186. !     return;
  6187.   
  6188. !     gdk_window_clear(gui.drawarea->window);
  6189.   }
  6190.   
  6191.   /*
  6192. !  * Scroll the text between gui.scroll_region_top & gui.scroll_region_bot by the
  6193. !  * number of lines given.  Positive scrolls down (text goes up) and negative
  6194. !  * scrolls up (text goes down).
  6195.    */
  6196. ! static void check_copy_area(void)
  6197.   {
  6198. !     XEvent event;
  6199. !     XGraphicsExposeEvent *gevent;
  6200.   
  6201. !     if (gui.visibility != GDK_VISIBILITY_PARTIAL)
  6202. !     return;
  6203.   
  6204. !     gdk_flush();
  6205. ! 
  6206. !     /* Wait to check whether the scroll worked or not. */
  6207. !     for (;;) {
  6208. !     if (XCheckTypedEvent(GDK_DISPLAY(), NoExpose, &event))
  6209. !         return;        /* The scroll worked. */
  6210.   
  6211. !     if (XCheckTypedEvent(GDK_DISPLAY(), GraphicsExpose, &event)) {
  6212. !         gevent = (XGraphicsExposeEvent *) & event;
  6213. !         gui_redraw(gevent->x, gevent->y, gevent->width, gevent->height);
  6214. !         if (gevent->count == 0)
  6215. !         return;        /* This was the last expose event */
  6216. !     }
  6217. !     gdk_flush();
  6218. !     }
  6219.   }
  6220.   
  6221. + /*
  6222. +  * Delete the given number of lines from the given row, scrolling up any
  6223. +  * text further down within the scroll region.
  6224. +  */
  6225.   void
  6226. ! gui_mch_delete_lines(int row, int num_lines)
  6227.   {
  6228. !     if (gui.visibility == GDK_VISIBILITY_FULLY_OBSCURED)
  6229. !     return;            /* Can't see the window */
  6230.   
  6231. +     if (num_lines <= 0)
  6232. +     return;
  6233.   
  6234. !     if (row + num_lines > gui.scroll_region_bot) {
  6235. !     /* Scrolled out of region, just blank the lines out */
  6236. !     gui_clear_block(row, 0, gui.scroll_region_bot, (int) Columns - 1);
  6237. !     } else {
  6238. !     GdkGC *gc;
  6239.   
  6240. !     gc = gdk_gc_new(gui.drawarea->window);
  6241. !     gdk_gc_set_exposures(gc, gui.visibility != GDK_VISIBILITY_UNOBSCURED);
  6242. !     gdk_gc_set_foreground(gc, gui.fgcolor);
  6243. !     gdk_gc_set_background(gc, gui.bgcolor);
  6244.   
  6245. !     /* copy one extra pixel, for when bold has spilled over */
  6246. !     gdk_window_copy_area(gui.drawarea->window, gc,
  6247. !                  FILL_X(0), FILL_Y(row),
  6248. !                  gui.drawarea->window,
  6249. !                  FILL_X(0), FILL_Y(row + num_lines),
  6250. !                  gui.char_width * (int) Columns + 1,
  6251. !                  gui.char_height *
  6252. !                 (gui.scroll_region_bot - row - num_lines + 1));
  6253. !     gdk_gc_destroy(gc);
  6254.   
  6255. !     /* Update gui.cursor_row if the cursor scrolled or copied over */
  6256. !     if (gui.cursor_row >= row) {
  6257. !         if (gui.cursor_row < row + num_lines)
  6258. !         gui.cursor_is_valid = FALSE;
  6259. !         else if (gui.cursor_row <= gui.scroll_region_bot)
  6260. !         gui.cursor_row -= num_lines;
  6261. !     }
  6262. !     gui_clear_block(gui.scroll_region_bot - num_lines + 1, 0,
  6263. !             gui.scroll_region_bot, (int) Columns - 1);
  6264. !     check_copy_area();
  6265. !     }
  6266.   }
  6267.   
  6268.   /*
  6269. !  * Insert the given number of lines before the given row, scrolling down any
  6270. !  * following text within the scroll region.
  6271.    */
  6272. ! void
  6273. ! gui_mch_insert_lines(int row, int num_lines)
  6274.   {
  6275. !     if (gui.visibility == GDK_VISIBILITY_FULLY_OBSCURED)
  6276. !     return;            /* Can't see the window */
  6277.   
  6278. !     if (num_lines <= 0)
  6279. !     return;
  6280.   
  6281. !     if (row + num_lines > gui.scroll_region_bot) {
  6282. !     /* Scrolled out of region, just blank the lines out */
  6283. !     gui_clear_block(row, 0, gui.scroll_region_bot, (int) Columns - 1);
  6284. !     } else {
  6285. !     GdkGC *gc;
  6286.   
  6287. !     gc = gdk_gc_new(gui.drawarea->window);
  6288. !     gdk_gc_set_exposures(gc, gui.visibility != GDK_VISIBILITY_UNOBSCURED);
  6289. !     gdk_gc_set_foreground(gc, gui.fgcolor);
  6290. !     gdk_gc_set_background(gc, gui.bgcolor);
  6291.   
  6292. +     /* copy one extra pixel, for when bold has spilled over */
  6293. +     gdk_window_copy_area(gui.drawarea->window, gc,
  6294. +                  FILL_X(0), FILL_Y(row + num_lines),
  6295. +                  gui.drawarea->window,
  6296. +                  FILL_X(0), FILL_Y(row),
  6297. +                  gui.char_width * (int) Columns + 1,
  6298. +                  gui.char_height *
  6299. +                 (gui.scroll_region_bot - row - num_lines + 1));
  6300. +     gdk_gc_destroy(gc);
  6301.   
  6302. !     /* Update gui.cursor_row if the cursor scrolled or copied over */
  6303. !     if (gui.cursor_row >= gui.row) {
  6304. !         if (gui.cursor_row <= gui.scroll_region_bot - num_lines)
  6305. !         gui.cursor_row += num_lines;
  6306. !         else if (gui.cursor_row <= gui.scroll_region_bot)
  6307. !         gui.cursor_is_valid = FALSE;
  6308. !     }
  6309. !     gui_clear_block(row, 0, row + num_lines - 1, (int) Columns - 1);
  6310. !     check_copy_area();
  6311.       }
  6312. + }
  6313.   
  6314. ! /*
  6315. !  * X Selection stuff, for cutting and pasting text to other windows.
  6316. !  */
  6317. ! void
  6318. ! clip_mch_request_selection()
  6319. ! {
  6320. !     /* First try to get the content of our own special clipboard. */
  6321. !     received_selection = RS_NONE;
  6322. !     (void)gtk_selection_convert(gui.drawarea,
  6323. !                     GDK_SELECTION_PRIMARY, clipboard.atom,
  6324. !                     (guint32)GDK_CURRENT_TIME);
  6325. !     while (received_selection == RS_NONE)
  6326. !     gtk_main();        /* wait for selection_received_event */
  6327.   
  6328. !     if (received_selection == RS_FAIL)
  6329.       {
  6330. !     /* Now try to get it out of the usual string selection. */
  6331. !     received_selection = RS_NONE;
  6332. !     (void)gtk_selection_convert(gui.drawarea, GDK_SELECTION_PRIMARY,
  6333. !                     GDK_TARGET_STRING,
  6334. !                     (guint32)GDK_CURRENT_TIME);
  6335. !     while (received_selection == RS_NONE)
  6336. !         gtk_main();        /* wait for selection_received_event */
  6337.       }
  6338. + }
  6339.   
  6340. ! void
  6341. ! clip_mch_lose_selection()
  6342. ! {
  6343. !     gtk_selection_owner_set(gui.drawarea,
  6344. !                 GDK_SELECTION_PRIMARY, (guint32)GDK_CURRENT_TIME);
  6345. !     gui_mch_update();
  6346. ! }
  6347.   
  6348. ! /*
  6349. !  * Check whatever we allready own the selection.
  6350. !  */
  6351. ! int
  6352. ! clip_mch_own_selection()
  6353. ! {
  6354. ! #if 0
  6355. !     return gdk_selection_owner_get(
  6356. !                 GDK_SELECTION_PRIMARY) == gui.drawarea->window;
  6357. ! #else
  6358. !     /* At this point we always already own the clipboard */
  6359.   
  6360. !     return OK;
  6361. ! #endif
  6362.   }
  6363.   
  6364.   /*
  6365. !  * Send the current selection to the clipboard.
  6366.    */
  6367. ! void
  6368. ! clip_mch_set_selection()
  6369.   {
  6370. !     gtk_selection_owner_set(gui.drawarea,
  6371. !                 GDK_SELECTION_PRIMARY,
  6372. !                 (guint32)GDK_CURRENT_TIME);
  6373. !     gui_mch_update();
  6374. ! }
  6375.   
  6376.   
  6377. ! #if defined(WANT_MENU) || defined(PROTO)
  6378. ! /*
  6379. !  * Make a menu item appear either active or not active (grey or not grey).
  6380. !  */
  6381. ! void
  6382. ! gui_mch_menu_grey(VimMenu * menu, int grey)
  6383. ! {
  6384. !     if (menu->id == 0)
  6385. !     return;
  6386.   
  6387. !     gui_mch_menu_hidden(menu, FALSE);
  6388. !     gtk_widget_set_sensitive(menu->id, !grey);
  6389.   
  6390. !     gui_mch_update();
  6391.   }
  6392.   
  6393. ! /*
  6394. !  * Make menu item hidden or not hidden.
  6395. !  */
  6396. ! void
  6397. ! gui_mch_menu_hidden(VimMenu * menu, int hidden)
  6398.   {
  6399. !     if (menu->id == 0)
  6400. !     return;
  6401.   
  6402. !     if (hidden) {
  6403. !     if (GTK_WIDGET_VISIBLE(menu->id))
  6404. !         gtk_widget_hide(menu->id);
  6405. !     } else {
  6406. !     if (!GTK_WIDGET_VISIBLE(menu->id))
  6407. !         gtk_widget_show(menu->id);
  6408.       }
  6409.   
  6410. !     gui_mch_update();
  6411.   }
  6412.   
  6413. ! /*
  6414. !  * This is called after setting all the menus to grey/hidden or not.
  6415. !  */
  6416. ! void
  6417. ! gui_mch_draw_menubar()
  6418.   {
  6419. !     /* just make sure that the visual changes get effect immediately */
  6420. !     gui_mch_update();
  6421.   }
  6422. + #endif
  6423.   
  6424.   /*
  6425. !  * Scrollbar stuff.
  6426.    */
  6427. ! void
  6428. ! gui_mch_enable_scrollbar(GuiScrollbar * sb, int flag)
  6429.   {
  6430. !     if (sb->id == 0)
  6431. !     return;
  6432. !     if (flag)
  6433. !     gtk_widget_show(sb->id);
  6434. !     else
  6435. !     gtk_widget_hide(sb->id);
  6436. !     update_window_manager_hints();
  6437.   }
  6438.   
  6439. + 
  6440.   /*
  6441. !  * Return the lightness of a pixel.  White is 255.
  6442.    */
  6443. ! int
  6444. ! gui_mch_get_lightness(GuiColor pixel)
  6445.   {
  6446. !     XColor xc;
  6447. !     GdkColormap *colormap;
  6448. ! 
  6449. !     colormap = gtk_widget_get_colormap(gui.mainwin);
  6450. !     xc.pixel = pixel;
  6451. ! 
  6452. !     /* FIXME: this is crap in terms of actual accuracy */
  6453. !     XQueryColor(GDK_DISPLAY(), GDK_COLORMAP_XCOLORMAP(colormap), &xc);
  6454. ! 
  6455. !     return (int) (xc.red * 3 + xc.green * 6 + xc.blue) / (10 * 256);
  6456.   }
  6457.   
  6458. ! #if (defined(SYNTAX_HL) && defined(WANT_EVAL)) || defined(PROTO)
  6459. ! 
  6460.   /*
  6461. !  * Return the RGB value of a pixel as "#RRGGBB".
  6462. !  *
  6463. !  * Unfortunately there appears to be no way to accomplish this entierly
  6464. !  * without resorting to native X11 functions.
  6465.    */
  6466. ! char_u *
  6467. ! gui_mch_get_rgb(GuiColor pixel)
  6468.   {
  6469. !     XColor xc;
  6470. !     GdkColormap *colormap;
  6471. !     static char_u retval[10];
  6472.   
  6473. !     colormap = gtk_widget_get_colormap(gui.mainwin);
  6474.   
  6475. !     xc.pixel = pixel;
  6476. !     XQueryColor(GDK_DISPLAY(), GDK_COLORMAP_XCOLORMAP(colormap), &xc);
  6477. ! 
  6478. !     sprintf((char *) retval, "#%02x%02x%02x",
  6479. !         (unsigned) xc.red >> 8,
  6480. !         (unsigned) xc.green >> 8,
  6481. !         (unsigned) xc.blue >> 8);
  6482. ! 
  6483. !     /* WOAH!!! Returning pointer to static string!  Could be overwritten when
  6484. !      * this function is called recursively (e.g., when some event occurs). */
  6485. !     return retval;
  6486.   }
  6487. + #endif
  6488.   
  6489. ! /*
  6490. !  * Get current y mouse coordinate in text window.
  6491. !  * Return -1 when unknown.
  6492. !  */
  6493. ! int
  6494. ! gui_mch_get_mouse_x(void)
  6495.   {
  6496. !     int winx, winy;
  6497. !     GdkModifierType mask;
  6498.   
  6499. !     gdk_window_get_pointer(gui.drawarea->window, &winx, &winy, &mask);
  6500. !     return winx;
  6501.   }
  6502.   
  6503. ! int
  6504. ! gui_mch_get_mouse_y(void)
  6505.   {
  6506. !     int winx, winy;
  6507. !     GdkModifierType mask;
  6508.   
  6509. !     gdk_window_get_pointer(gui.drawarea->window, &winx, &winy, &mask);
  6510. !     return winy;
  6511. ! }
  6512. ! 
  6513. ! void
  6514. ! gui_mch_setmouse(int x, int y)
  6515. ! {
  6516. !     /* Sorry for the Xlib call, but we can't avoid it, since there is no
  6517. !      * internal GDK mechanism present to accomplish this.
  6518. !      */
  6519. !     XWarpPointer(GDK_DISPLAY(), (Window) 0,
  6520. !          GDK_WINDOW_XWINDOW(gui.drawarea->window), 0, 0, 0, 0, x, y);
  6521.   }
  6522. *** ../vim-5.6a.17/src/ui.c    Mon Dec 20 09:59:15 1999
  6523. --- src/ui.c    Sat Jan  8 20:56:28 2000
  6524. ***************
  6525. *** 1156,1161 ****
  6526. --- 1156,1169 ----
  6527.   }
  6528.   #endif
  6529.   
  6530. + #if defined(USE_GUI_GTK) || defined(PROTO)
  6531. +     int
  6532. + vim_used_in_input_buf()
  6533. + {
  6534. +     return inbufcount;
  6535. + }
  6536. + #endif
  6537. + 
  6538.   /* Add the given bytes to the input buffer */
  6539.       void
  6540.   add_to_input_buf(s, len)
  6541. *** ../vim-5.6a.17/src/proto/ui.pro    Mon Dec 20 09:58:55 1999
  6542. --- src/proto/ui.pro    Sat Jan  8 20:56:32 2000
  6543. ***************
  6544. *** 30,35 ****
  6545. --- 30,36 ----
  6546.   int vim_is_input_buf_full __ARGS((void));
  6547.   int vim_is_input_buf_empty __ARGS((void));
  6548.   int vim_free_in_input_buf __ARGS((void));
  6549. + int vim_used_in_input_buf __ARGS((void));
  6550.   void add_to_input_buf __ARGS((char_u *s, int len));
  6551.   void push_raw_key __ARGS((char_u *s, int len));
  6552.   void trash_input_buf __ARGS((void));
  6553. *** ../vim-5.6a.17/src/misc2.c    Thu Dec 23 11:13:43 1999
  6554. --- src/misc2.c    Sat Jan  8 21:27:11 2000
  6555. ***************
  6556. *** 2031,2037 ****
  6557.       return State;
  6558.   }
  6559.   
  6560. ! #if defined(MKSESSION) || defined(MSWIN) || defined(PROTO)
  6561.   /*
  6562.    * Change to a file's directory.
  6563.    */
  6564. --- 2031,2037 ----
  6565.       return State;
  6566.   }
  6567.   
  6568. ! #if defined(MKSESSION) || defined(MSWIN) || defined(USE_GUI_GTK) || defined(PROTO)
  6569.   /*
  6570.    * Change to a file's directory.
  6571.    */
  6572. *** ../vim-5.6a.17/src/version.c    Sat Jan  8 22:58:58 2000
  6573. --- src/version.c    Sat Jan  8 22:58:33 2000
  6574. ***************
  6575. *** 420,421 ****
  6576. --- 420,423 ----
  6577.   {   /* Add new patch number below this line */
  6578. + /**/
  6579. +     18,
  6580.   /**/
  6581.  
  6582. -- 
  6583. hundred-and-one symptoms of being an internet addict:
  6584. 79. All of your most erotic dreams have a scrollbar at the right side.
  6585.  
  6586. --/-/---- Bram Moolenaar ---- Bram@moolenaar.net ---- Bram@vim.org ---\-\--
  6587.   \ \    www.vim.org/iccf      www.moolenaar.net       www.vim.org    / /
  6588.