开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 编辑器/阅读器 > 查看源码
gui_w32.c
资源名称：vim53src.zip　[点击查看]
上传用户：gddssl
上传日期：2007-01-06
资源大小：1003k
文件大小：132k
源码类别：

编辑器/阅读器

开发平台：

DOS

gui_w32.c：源码内容
  1. /* vi:set ts=8 sts=4 sw=4:
  2.  *
  3.  * VIM - Vi IMproved by Bram Moolenaar
  4.  * GUI support by Robert Webb
  5.  *
  6.  * Do ":help uganda"  in Vim to read copying and usage conditions.
  7.  * Do ":help credits" in Vim to see a list of people who contributed.
  8.  *
  9.  * Windows GUI.
  10.  *
  11.  * GUI support for Microsoft Windows.  Win32 initially; maybe Win16 later
  12.  *
  13.  * George V. Reilly <gvr@halcyon.com> wrote the original Win32 GUI.
  14.  * Robert Webb reworked it to use the existing GUI stuff and added menu,
  15.  * scrollbars, etc.
  16.  *
  17.  * Note: Clipboard stuff, for cutting and pasting text to other windows, is in
  18.  * os_win32.c. (It can also be done from the terminal version).
  19.  */
  21. #define WIN32_FIND_REPLACE /* include code for find/replace dialog */
  22. #define MENUHINTS /* show menu hints in command line */
  24. #include "vim.h"
  25. #include "version.h" /* used by dialog box routine for default title */
  26. #include <windows.h>
  27. #include <shellapi.h>
  28. #ifdef USE_GUI_WIN32_TOOLBAR
  29. #include <commctrl.h>
  30. #endif
  31. #include <windowsx.h>
  33. /* Some parameters for dialog boxes.  All in pixels. */
  34. #define DLG_PADDING_X 10
  35. #define DLG_PADDING_Y 10
  36. #define DLG_OLD_STYLE_PADDING_X 5
  37. #define DLG_OLD_STYLE_PADDING_Y 5
  38. #define DLG_VERT_PADDING_X 4   /* For vertical buttons */
  39. #define DLG_VERT_PADDING_Y 4
  40. #define DLG_ICON_WIDTH 34
  41. #define DLG_ICON_HEIGHT 34
  42. #define DLG_MIN_WIDTH 150
  43. #define DLG_FONT_NAME "MS Sans Serif"
  44. #define DLG_FONT_POINT_SIZE 8
  45. #define DLG_MIN_MAX_WIDTH 400
  47. /* Some parameters for tearoff menus.  All in pixels. */
  48. #define TEAROFF_PADDING_X 2
  49. #define TEAROFF_BUTTON_PAD_X 8
  50. #define TEAROFF_MIN_WIDTH 200
  51. #define TEAROFF_SUBMENU_LABEL ">>"
  52. #define TEAROFF_COLUMN_PADDING 3 // # spaces to pad column with.
  54. #ifdef PROTO
  55. /*
  56.  * Define a few things for generating prototypes.  This is just to avoid
  57.  * syntax errors, the defines do not need to be correct.
  58.  */
  59. # define HINSTANCE  void *
  60. # define HWND     void *
  61. # define HDC     void *
  62. # define HMENU     void *
  63. # define UINT     int
  64. # define WPARAM     int
  65. # define LPARAM     int
  66. typedef int LOGFONT[];
  67. # define ENUMLOGFONT int
  68. # define NEWTEXTMETRIC int
  69. # define VOID     void
  70. # define CALLBACK
  71. # define WORD     int
  72. # define DWORD     int
  73. # define HBITMAP    int
  74. # define HDROP     int
  75. # define BOOL     int
  76. # define PWORD     int
  77. # define LPWORD     int
  78. # define LPRECT     int
  79. # define LRESULT    int
  80. # define WINAPI
  81. # define APIENTRY
  82. # define LPSTR     int
  83. # define LPWINDOWPOS int
  84. # define RECT     int
  85. # define LPCREATESTRUCT int
  86. # define _cdecl
  87. # define FINDREPLACE int
  88. # define LPCTSTR int
  89. # define OSVERSIONINFO int
  90. #endif
  92. /* For the Intellimouse: */
  93. #ifndef WM_MOUSEWHEEL
  94. #define WM_MOUSEWHEEL 0x20a
  95. #endif
  97. #ifdef MULTI_BYTE
  98. static int sysfixed_width = 0;
  99. static int sysfixed_height = 0;
  100. #endif
  102. /* Local variables: */
  103. static int     s_button_pending = -1;
  104. static int     s_x_pending;
  105. static int     s_y_pending;
  106. static UINT     s_kFlags_pending;
  108. static HINSTANCE    s_hinst = NULL;
  109. static HWND     s_hwnd = NULL;
  110. static HDC     s_hdc = NULL;
  111. #ifdef USE_GUI_WIN32_TOOLBAR
  112. static HWND     s_toolbarhwnd = NULL;
  113. #endif
  114. #ifdef WIN32_FIND_REPLACE
  115. static HWND     s_findrep_hwnd = NULL;
  116. static UINT     s_findrep_msg = 0;
  117. static FINDREPLACE  s_findrep_struct;
  118. static int     s_findrep_is_find;
  119. #endif
  120. static HWND     s_textArea = NULL;
  121. static HMENU     s_menuBar = NULL;
  122. static UINT     s_menu_id = 0;
  123. static UINT     s_wait_timer = 0; /* Timer for get char from user */
  124. static int     destroying = FALSE; /* calling DestroyWindow() ourselves */
  126. static UINT     s_uMsg = 0;
  127. static WPARAM     s_wParam = 0;
  128. static LPARAM     s_lParam = 0;
  130. static int     s_timed_out = FALSE;
  132. static const LOGFONT s_lfDefault =
  133. {
  134.     -12, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, DEFAULT_CHARSET,
  135.     OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
  136.     PROOF_QUALITY, FIXED_PITCH | FF_DONTCARE,
  137.     "Fixedsys" /* see _ReadVimIni */
  138. };
  140. /* Initialise the "current height" to -12 (same as s_lfDefault) just
  141.  * in case the user specifies a font in "guifont" with no size before a font
  142.  * with an explicit size has been set. This defaults the size to this value
  143.  * (-12 equates to roughly 9pt).
  144.  */
  145. static int current_font_height = -12;
  147. static struct
  148. {
  149.     UINT    key_sym;
  150.     char_u  vim_code0;
  151.     char_u  vim_code1;
  152. } special_keys[] =
  153. {
  154.     {VK_UP,     'k', 'u'},
  155.     {VK_DOWN,     'k', 'd'},
  156.     {VK_LEFT,     'k', 'l'},
  157.     {VK_RIGHT,     'k', 'r'},
  159.     {VK_F1,     'k', '1'},
  160.     {VK_F2,     'k', '2'},
  161.     {VK_F3,     'k', '3'},
  162.     {VK_F4,     'k', '4'},
  163.     {VK_F5,     'k', '5'},
  164.     {VK_F6,     'k', '6'},
  165.     {VK_F7,     'k', '7'},
  166.     {VK_F8,     'k', '8'},
  167.     {VK_F9,     'k', '9'},
  168.     {VK_F10,     'k', ';'},
  170.     {VK_F11,     'F', '1'},
  171.     {VK_F12,     'F', '2'},
  172.     {VK_F13,     'F', '3'},
  173.     {VK_F14,     'F', '4'},
  174.     {VK_F15,     'F', '5'},
  175.     {VK_F16,     'F', '6'},
  176.     {VK_F17,     'F', '7'},
  177.     {VK_F18,     'F', '8'},
  178.     {VK_F19,     'F', '9'},
  179.     {VK_F20,     'F', 'A'},
  181.     {VK_F21,     'F', 'B'},
  182.     {VK_F22,     'F', 'C'},
  183.     {VK_F23,     'F', 'D'},
  184.     {VK_F24,     'F', 'E'},     /* winuser.h defines up to F24 */
  186.     {VK_HELP,     '%', '1'},
  187.     {VK_BACK,     'k', 'b'},
  188.     {VK_INSERT,     'k', 'I'},
  189.     {VK_DELETE,     'k', 'D'},
  190.     {VK_HOME,     'k', 'h'},
  191.     {VK_END,     '@', '7'},
  192.     {VK_PRIOR,     'k', 'P'},
  193.     {VK_NEXT,     'k', 'N'},
  194.     {VK_PRINT,     '%', '9'},
  195.     {VK_ADD,     'K', '6'},
  196.     {VK_SUBTRACT,   'K', '7'},
  197.     {VK_DIVIDE,     'K', '8'},
  198.     {VK_MULTIPLY,   'K', '9'},
  199.     {VK_SEPARATOR,  'K', 'A'},     /* Keypad Enter */
  201.     /* Keys that we want to be able to use any modifier with: */
  202.     {VK_SPACE,     ' ', NUL},
  203.     {VK_TAB,     TAB, NUL},
  204.     {VK_ESCAPE,     ESC, NUL},
  205.     {NL,     NL, NUL},
  206.     {CR,     CR, NUL},
  208.     /* End of list marker: */
  209.     {0,     0, 0}
  210. };
  213. #define VIM_NAME "vim"
  214. #define VIM_CLASS "Vim"
  216. static int dead_key = 0; /* 0 - no dead key, 1 - dead key pressed */
  217. static OSVERSIONINFO os_version;    /* like it says.  Init in gui_mch_init() */
  219. /* ron: No need to be stingy on Win32. Make it 16K - s/b big enough for
  220.  * everyone!
  221.  * I have had problems with the original 1000 byte, and with 2 or 5 K.  But
  222.  * 16K should be good for all but the biggest.  Anyway, we free the memory
  223.  * right away.
  224.  */
  225. #define DLG_ALLOC_SIZE 16 * 1024
  227. /*
  228.  * stuff for dialogs, menus, tearoffs etc.
  229.  */
  230. static LRESULT APIENTRY dialog_callback(HWND, UINT, WPARAM, LPARAM);
  231. static LRESULT APIENTRY tearoff_callback(HWND, UINT, WPARAM, LPARAM);
  232. static BOOL CenterWindow(HWND hwndChild, HWND hwndParent);
  233. static PWORD
  234. add_dialog_element(
  235. PWORD p,
  236. DWORD lStyle,
  237. WORD x,
  238. WORD y,
  239. WORD w,
  240. WORD h,
  241. WORD Id,
  242. WORD clss,
  243. const char *caption);
  244. static LPWORD lpwAlign(LPWORD);
  245. static int nCopyAnsiToWideChar(LPWORD, LPSTR);
  246. static void gui_mch_tearoff(char_u *title, GuiMenu *menu, int initX, int initY);
  247. static void rebuild_tearoff(GuiMenu *menu);
  248. static void get_dialog_font_metrics(void);
  250. /*
  251.  * The scrollbar stuff can handle only up to 32767 lines.  When the file is
  252.  * longer, scroll_shift is set to the number of shifts to reduce the count.
  253.  */
  254. static int scroll_shift = 0;
  256. /* Intellimouse support */
  257. static int mouse_scroll_lines = 0;
  258. static UINT msh_msgmousewheel = 0;
  260. static int s_usenewlook;     /* emulate W95/NT4 non-bold dialogs */
  261. static WORD s_dlgfntheight;     /* height of the dialog font */
  262. static WORD s_dlgfntwidth;     /* width of the dialog font */
  263. static HBITMAP s_htearbitmap;     /* bitmap used to indicate tearoff */
  264. #ifdef USE_GUI_WIN32_TOOLBAR
  265. static void initialise_toolbar(void);
  266. static int get_toolbar_bitmap(char_u *name);
  267. #endif
  269. #ifdef WIN32_FIND_REPLACE
  270. static void initialise_findrep(char_u *initial_string);
  271. static void find_rep_mode_adjust(char_u * buf);
  272. #endif
  274. #ifdef DEBUG
  275. /*
  276.  * Print out the last Windows error message
  277.  */
  278.     static void
  279. print_windows_error(void)
  280. {
  281.     LPVOID  lpMsgBuf;
  283.     FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
  284.   NULL, GetLastError(),
  285.   MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
  286.   (LPTSTR) &lpMsgBuf, 0, NULL);
  287.     TRACE1("Error: %sn", lpMsgBuf);
  288.     LocalFree(lpMsgBuf);
  289. }
  290. #endif /* DEBUG */
  292. /*
  293.  * Return TRUE when running under Windows NT 3.x or Win32s, both of which have
  294.  * less fancy GUI APIs.
  295.  */
  296.     static int
  297. is_winnt_3(void)
  298. {
  299.     return ((os_version.dwPlatformId == VER_PLATFORM_WIN32_NT
  300. && os_version.dwMajorVersion == 3)
  301.     || (os_version.dwPlatformId == VER_PLATFORM_WIN32s));
  302. }
  304. /*
  305.  * Return TRUE when running under Win32s.
  306.  */
  307.     int
  308. gui_is_win32s(void)
  309. {
  310.     return (os_version.dwPlatformId == VER_PLATFORM_WIN32s);
  311. }
  313. /*
  314.  * Figure out how high the menu bar is at the moment.
  315.  */
  316.     static int
  317. gui_w32_get_menu_height(
  318.     int     fix_window)     /* If TRUE, resize window if menu height changed */
  319. {
  320.     static int old_menu_height = -1;
  322.     RECT    rc1, rc2;
  323.     int     num;
  324.     int     menu_height;
  326.     if (gui.menu_is_active)
  327. num = GetMenuItemCount(s_menuBar);
  328.     else
  329. num = 0;
  331.     if (num == 0)
  332. menu_height = 0;
  333.     else
  334.     {
  335. if (is_winnt_3()) /* for NT 3.xx */
  336. {
  337.     RECT r1, r2;
  338.     int frameht = GetSystemMetrics(SM_CYFRAME);
  339.     int capht = GetSystemMetrics(SM_CYCAPTION);
  341.     /* get window rect of s_hwnd
  342. get client rect of s_hwnd
  343. get cap height
  344. subtract from window rect, the sum of client height,
  345. (if not maximized)frame thickness, and caption height.
  346.      */
  347.     GetWindowRect(s_hwnd, &r1);
  348.     GetClientRect(s_hwnd, &r2);
  349.     menu_height = r1.bottom - r1.top - (r2.bottom-r2.top +
  350.    2 * frameht * (!IsZoomed(s_hwnd)) + capht);
  351. }
  352. else /* win95 and variants (NT 4.0, I guess) */
  353. {
  354.     GetMenuItemRect(s_hwnd, s_menuBar, 0, &rc1);
  355.     GetMenuItemRect(s_hwnd, s_menuBar, num - 1, &rc2);
  356.     menu_height = rc2.bottom - rc1.top + 1;
  357. }
  358.     }
  360.     if (fix_window && menu_height != old_menu_height)
  361. gui_set_winsize(FALSE);
  363.     old_menu_height = menu_height;
  364.     return menu_height;
  365. }
  367. /*
  368.  * Cursor blink functions.
  369.  *
  370.  * This is a simple state machine:
  371.  * BLINK_NONE not blinking at all
  372.  * BLINK_OFF blinking, cursor is not shown
  373.  * BLINK_ON blinking, cursor is shown
  374.  */
  376. #define BLINK_NONE  0
  377. #define BLINK_OFF   1
  378. #define BLINK_ON    2
  380. static int blink_state = BLINK_NONE;
  381. static long_u blink_waittime = 700;
  382. static long_u blink_ontime = 400;
  383. static long_u blink_offtime = 250;
  384. static UINT blink_timer = 0;
  386.     void
  387. gui_mch_set_blinking(long wait, long on, long off)
  388. {
  389.     blink_waittime = wait;
  390.     blink_ontime = on;
  391.     blink_offtime = off;
  392. }
  394. /* ARGSUSED */
  395.     static VOID CALLBACK
  396. _OnBlinkTimer(
  397.     HWND hwnd,
  398.     UINT uMsg,
  399.     UINT idEvent,
  400.     DWORD dwTime)
  401. {
  402.     MSG msg;
  404.     /*
  405.     TRACE2("Got timer event, id %d, blink_timer %dn", idEvent, blink_timer);
  406.     */
  408.     KillTimer(NULL, idEvent);
  410.     /* Eat spurious WM_TIMER messages */
  411.     while (PeekMessage(&msg, hwnd, WM_TIMER, WM_TIMER, PM_REMOVE))
  412. ;
  414.     if (blink_state == BLINK_ON)
  415.     {
  416. gui_undraw_cursor();
  417. blink_state = BLINK_OFF;
  418. blink_timer = SetTimer(NULL, 0, (UINT)blink_offtime,
  419.     (TIMERPROC)_OnBlinkTimer);
  420.     }
  421.     else
  422.     {
  423. gui_update_cursor(TRUE, FALSE);
  424. blink_state = BLINK_ON;
  425. blink_timer = SetTimer(NULL, 0, (UINT)blink_ontime,
  426.     (TIMERPROC)_OnBlinkTimer);
  427.     }
  428. }
  430.     static void
  431. gui_w32_rm_blink_timer(void)
  432. {
  433.     MSG msg;
  435.     if (blink_timer != 0)
  436.     {
  437. KillTimer(NULL, blink_timer);
  438. /* Eat spurious WM_TIMER messages */
  439. while (PeekMessage(&msg, s_hwnd, WM_TIMER, WM_TIMER, PM_REMOVE))
  440.     ;
  441. blink_timer = 0;
  442.     }
  443. }
  445. /*
  446.  * Stop the cursor blinking.  Show the cursor if it wasn't shown.
  447.  */
  448.     void
  449. gui_mch_stop_blink(void)
  450. {
  451.     gui_w32_rm_blink_timer();
  452.     if (blink_state == BLINK_OFF)
  453. gui_update_cursor(TRUE, FALSE);
  454.     blink_state = BLINK_NONE;
  455. }
  457. /*
  458.  * Start the cursor blinking.  If it was already blinking, this restarts the
  459.  * waiting time and shows the cursor.
  460.  */
  461.     void
  462. gui_mch_start_blink(void)
  463. {
  464.     gui_w32_rm_blink_timer();
  466.     /* Only switch blinking on if none of the times is zero */
  467.     if (blink_waittime && blink_ontime && blink_offtime && gui.in_focus)
  468.     {
  469. blink_timer = SetTimer(NULL, 0, (UINT)blink_waittime,
  470.     (TIMERPROC)_OnBlinkTimer);
  471. blink_state = BLINK_ON;
  472. gui_update_cursor(TRUE, FALSE);
  473.     }
  474. }
  476. /*
  477.  * Call-back routines.
  478.  */
  480.     static VOID CALLBACK
  481. _OnTimer(
  482.     HWND hwnd,
  483.     UINT uMsg,
  484.     UINT idEvent,
  485.     DWORD dwTime)
  486. {
  487.     MSG msg;
  489.     /*
  490.     TRACE2("Got timer event, id %d, s_wait_timer %dn", idEvent, s_wait_timer);
  491.     */
  492.     KillTimer(NULL, idEvent);
  493.     s_timed_out = TRUE;
  495.     /* Eat spurious WM_TIMER messages */
  496.     while (PeekMessage(&msg, hwnd, WM_TIMER, WM_TIMER, PM_REMOVE))
  497. ;
  498.     if (idEvent == s_wait_timer)
  499. s_wait_timer = 0;
  500. }
  502. /*
  503.  * Get this message when the user clicks on the cross in the top right corner
  504.  * of a Windows95 window.
  505.  */
  506.     static void
  507. _OnClose(
  508.     HWND hwnd)
  509. {
  510. #ifdef USE_BROWSE
  511.     int save_browse = browse;
  512. #endif
  513. #if defined(GUI_DIALOG) || defined(CON_DIALOG)
  514.     int save_confirm = confirm;
  515. #endif
  517.     /* Only exit when there are no changed files */
  518.     exiting = TRUE;
  519. #ifdef USE_BROWSE
  520.     browse = TRUE;
  521. #endif
  522. #if defined(GUI_DIALOG) || defined(CON_DIALOG)
  523.     confirm = TRUE;
  524. #endif
  525.     if (!check_changed_any(FALSE))    /* will give warning for changed buffer */
  526. getout(0);
  528.     exiting = FALSE;
  529. #ifdef USE_BROWSE
  530.     browse = save_browse;
  531. #endif
  532. #if defined(GUI_DIALOG) || defined(CON_DIALOG)
  533.     confirm = save_confirm;
  534. #endif
  535.     setcursor();     /* position cursor */
  536.     out_flush();
  537. }
  539. /*
  540.  * Get a message when the user switches back to vim
  541.  */
  542.     static void
  543. _OnActivateApp(
  544.     HWND hwnd,
  545.     BOOL fActivate,
  546.     DWORD dwThreadId)
  547. {
  548.     /* When activated: Check if any file was modified outside of Vim. */
  549.     if (fActivate)
  550. check_timestamps();
  551. }
  553. /*
  554.  * Get a message when the the window is being destroyed.
  555.  */
  556.     static void
  557. _OnDestroy(
  558.     HWND hwnd)
  559. {
  560.     if (!destroying)
  561. _OnClose(hwnd);
  562. }
  564.     static void
  565. _OnDropFiles(
  566.     HWND hwnd,
  567.     HDROP hDrop)
  568. {
  569.     char    szFile[_MAX_PATH];
  570.     UINT    cFiles = DragQueryFile(hDrop, 0xFFFFFFFF, szFile, _MAX_PATH);
  571.     UINT    i;
  572.     char_u  *fname;
  573.     char_u  **fnames;
  574.     char_u  redo_dirs = FALSE;
  576.     /* TRACE("_OnDropFiles: %d files droppedn", cFiles); */
  578.     /* reset_VIsual(); */
  579.     if (VIsual_active)
  580.     {
  581. end_visual_mode();
  582. VIsual_reselect = FALSE;
  583. update_curbuf(NOT_VALID); /* delete the inversion */
  584.     }
  586.     fnames = (char_u **) alloc(cFiles * sizeof(char_u *));
  588.     for (i = 0; i < cFiles; ++i)
  589.     {
  590. DragQueryFile(hDrop, i, szFile, _MAX_PATH);
  591. /* TRACE("  dropped %2u: '%s'n", i, szFile); */
  593. mch_dirname(IObuff, IOSIZE);
  594. fname = shorten_fname(szFile, IObuff);
  595. if (fname == NULL)
  596.     fname = szFile;
  597. fnames[i] = vim_strsave(fname);
  598.     }
  600.     /*
  601.      * Handle dropping a directory on Vim.
  602.      */
  603.     if (cFiles == 1)
  604.     {
  605. if (mch_isdir(fnames[0]))
  606. {
  607.     if (mch_chdir(fnames[0]) == 0)
  608.     {
  609. vim_free(fnames[0]);
  610. fnames[0] = NULL;
  611. redo_dirs = TRUE;
  612.     }
  613. }
  614.     }
  616.     DragFinish(hDrop);
  618.     if (GetKeyState(VK_SHIFT) & 0x8000)
  619.     {
  620. /* Shift held down, change to first file's directory */
  621. if (vim_chdirfile(fnames[0]) == 0)
  622. {
  623.     redo_dirs = TRUE;
  624. }
  625.     }
  627.     /* Handle the drop, by resetting the :args list */
  628.     handle_drop(cFiles, fnames);
  630.     if (redo_dirs)
  631. shorten_fnames();
  633.     /* Update the screen display */
  634.     update_screen(NOT_VALID);
  635.     setcursor();
  636.     out_flush();
  637. }
  639.     static void
  640. _OnDeadChar(
  641.     HWND hwnd,
  642.     UINT ch,
  643.     int cRepeat)
  644. {
  645.     dead_key = 1;
  646. }
  648.     static void
  649. _OnChar(
  650.     HWND hwnd,
  651.     UINT ch,
  652.     int cRepeat)
  653. {
  654.     char_u string[1];
  656.     /* TRACE("OnChar(%d, %c)n", ch, ch); */
  658.     string[0] = ch;
  659.     if (string[0] == Ctrl('C') && !mapped_ctrl_c)
  660.     {
  661. trash_input_buf();
  662. got_int = TRUE;
  663.     }
  664.     add_to_input_buf(string, 1);
  665. }
  667.     static void
  668. _OnSysChar(
  669.     HWND hwnd,
  670.     UINT ch,
  671.     int cRepeat)
  672. {
  673.     char_u string[6]; /* Enough for maximum key sequence - see below */
  674.     int len;
  675.     int modifiers;
  677.     /* TRACE("OnSysChar(%d, %c)n", ch, ch); */
  679.     /* OK, we have a character key (given by ch) which was entered with the
  680.      * ALT key pressed. Eg, if the user presses Alt-A, then ch == 'A'. Note
  681.      * that the system distinguishes Alt-a and Alt-A (Alt-Shift-a unless
  682.      * CAPSLOCK is pressed) at this point.
  683.      */
  684.     modifiers = MOD_MASK_ALT;
  685.     if (GetKeyState(VK_SHIFT) & 0x8000)
  686. modifiers |= MOD_MASK_SHIFT;
  687.     if (GetKeyState(VK_CONTROL) & 0x8000)
  688. modifiers |= MOD_MASK_CTRL;
  690.     ch = simplify_key(ch, &modifiers);
  691.     /* remove the SHIFT modifier for keys where it's already included, e.g.,
  692.      * '(' and '*' */
  693.     if (ch < 0x100 && (!isalpha(ch)) && isprint(ch))
  694. modifiers &= ~MOD_MASK_SHIFT;
  695.     /* Interpret the ALT key as making the key META */
  696.     if (modifiers & MOD_MASK_ALT)
  697.     {
  698. ch |= 0x80;
  699. modifiers &= ~MOD_MASK_ALT;
  700.     }
  702.     len = 0;
  703.     if (modifiers)
  704.     {
  705. string[len++] = CSI;
  706. string[len++] = KS_MODIFIER;
  707. string[len++] = modifiers;
  708.     }
  709.     if (IS_SPECIAL(ch))
  710.     {
  711. string[len++] = CSI;
  712. string[len++] = K_SECOND(ch);
  713. string[len++] = K_THIRD(ch);
  714.     }
  715.     else
  716. string[len++] = ch;
  717.     add_to_input_buf(string, len);
  718. }
  720.     static void
  721. _OnMouseEvent(
  722.     int button,
  723.     int x,
  724.     int y,
  725.     int repeated_click,
  726.     UINT keyFlags)
  727. {
  728.     int vim_modifiers = 0x0;
  730.     if (keyFlags & MK_SHIFT)
  731. vim_modifiers |= MOUSE_SHIFT;
  732.     if (keyFlags & MK_CONTROL)
  733. vim_modifiers |= MOUSE_CTRL;
  734.     if (GetKeyState(VK_MENU) & 0x8000)
  735. vim_modifiers |= MOUSE_ALT;
  737.     gui_send_mouse_event(button, x, y, repeated_click, vim_modifiers);
  738. }
  740.     static void
  741. _OnMouseButtonDown(
  742.     HWND hwnd,
  743.     BOOL fDoubleClick,
  744.     int x,
  745.     int y,
  746.     UINT keyFlags)
  747. {
  748.     static LONG s_prevTime = 0;
  750.     LONG    currentTime = GetMessageTime();
  751.     int     button = -1;
  752.     int     repeated_click;
  754.     if (s_uMsg == WM_LBUTTONDOWN || s_uMsg == WM_LBUTTONDBLCLK)
  755. button = MOUSE_LEFT;
  756.     else if (s_uMsg == WM_MBUTTONDOWN || s_uMsg == WM_MBUTTONDBLCLK)
  757. button = MOUSE_MIDDLE;
  758.     else if (s_uMsg == WM_RBUTTONDOWN || s_uMsg == WM_RBUTTONDBLCLK)
  759. button = MOUSE_RIGHT;
  760.     else if (s_uMsg == WM_CAPTURECHANGED)
  761.     {
  762. /* on W95/NT4, somehow you get in here with an odd Msg
  763.  * if you press one button while holding down the other..*/
  764. if (s_button_pending == MOUSE_LEFT)
  765.     button = MOUSE_RIGHT;
  766. else
  767.     button = MOUSE_LEFT;
  768.     }
  770.     if (button >= 0)
  771.     {
  772. repeated_click = ((int)(currentTime - s_prevTime) < p_mouset);
  774. /*
  775.  * Holding down the left and right buttons simulates pushing the middle
  776.  * button.
  777.  */
  778. if (repeated_click &&
  779. ((button == MOUSE_LEFT && s_button_pending == MOUSE_RIGHT) ||
  780.  (button == MOUSE_RIGHT && s_button_pending == MOUSE_LEFT)))
  781. {
  782.     /*
  783.      * Hmm, gui.c will ignore more than one button down at a time, so
  784.      * pretend we let go of it first.
  785.      */
  786.     gui_send_mouse_event(MOUSE_RELEASE, x, y, FALSE, 0x0);
  787.     button = MOUSE_MIDDLE;
  788.     repeated_click = FALSE;
  789.     s_button_pending = -1;
  790.     _OnMouseEvent(button, x, y, repeated_click, keyFlags);
  791. }
  792. else if ((repeated_click)
  793. || (mouse_model_popup() && (button == MOUSE_RIGHT)))
  794. {
  795.     if (s_button_pending > -1)
  796.     {
  797.     _OnMouseEvent(s_button_pending, x, y, FALSE, keyFlags);
  798.     s_button_pending = -1;
  799.     }
  800.     /* TRACE("Button down at x %d, y %dn", x, y); */
  801.     _OnMouseEvent(button, x, y, repeated_click, keyFlags);
  802. }
  803. else
  804. {
  805.     /*
  806.      * If this is the first press (i.e. not a multiple click) don't
  807.      * action immediately, but store and wait for:
  808.      * i) button-up
  809.      * ii) mouse move
  810.      * iii) another button press
  811.      * before using it.
  812.      * This enables us to make left+right simulate middle button,
  813.      * without left or right being actioned first.  The side-effect is
  814.      * that if you click and hold the mouse without dragging, the
  815.      * cursor doesn't move until you release the button. In practice
  816.      * this is hardly a problem.
  817.      */
  818.     s_button_pending = button;
  819.     s_x_pending = x;
  820.     s_y_pending = y;
  821.     s_kFlags_pending = keyFlags;
  822. }
  824. s_prevTime = currentTime;
  825.     }
  826. }
  828.     static void
  829. _OnMouseMoveOrRelease(
  830.     HWND hwnd,
  831.     int x,
  832.     int y,
  833.     UINT keyFlags)
  834. {
  835.     int button;
  837.     if (s_button_pending > -1)
  838.     {
  839. /* Delayed action for mouse down event */
  840. _OnMouseEvent(s_button_pending, s_x_pending,
  841. s_y_pending, FALSE, s_kFlags_pending);
  842. s_button_pending = -1;
  843.     }
  844.     if (s_uMsg == WM_MOUSEMOVE)
  845.     {
  846. /*
  847.  * It's only a MOUSE_DRAG if one or more mouse buttons are being held
  848.  * down.
  849.  */
  850. if (!(keyFlags & (MK_LBUTTON | MK_MBUTTON | MK_RBUTTON)))
  851. {
  852.     gui_mouse_moved(y);
  853.     return;
  854. }
  856. /*
  857.  * While button is down, keep grabbing mouse move events when
  858.  * the mouse goes outside the window
  859.  */
  860. SetCapture(s_textArea);
  861. button = MOUSE_DRAG;
  862. /* TRACE("  move at x %d, y %dn", x, y); */
  863.     }
  864.     else
  865.     {
  866. ReleaseCapture();
  867. button = MOUSE_RELEASE;
  868. /* TRACE("  up at x %d, y %dn", x, y); */
  869.     }
  871.     _OnMouseEvent(button, x, y, FALSE, keyFlags);
  872. }
  874.     static void
  875. _OnPaint(
  876.     HWND hwnd)
  877. {
  878.     if (!IsMinimized(hwnd))
  879.     {
  880. PAINTSTRUCT ps;
  881. HDC hdc;
  884. out_flush();     /* make sure all output has been processed */
  885. hdc = BeginPaint(hwnd, &ps);
  887. #ifdef MULTI_BYTE
  888. /* prevent multi-byte characters from misprinting on an invalid
  889.  * rectangle */
  890. if (is_dbcs)
  891. {
  892.     RECT rect;
  894.     GetClientRect(hwnd, &rect);
  895.     ps.rcPaint.left = rect.left;
  896.     ps.rcPaint.right = rect.right;
  897. }
  898. #endif
  900. if (!IsRectEmpty(&ps.rcPaint))
  901.     gui_redraw(ps.rcPaint.left, ps.rcPaint.top,
  902.     ps.rcPaint.right - ps.rcPaint.left + 1,
  903.     ps.rcPaint.bottom - ps.rcPaint.top + 1);
  904. EndPaint(hwnd, &ps);
  905.     }
  906. }
  908.     static void
  909. _OnSize(
  910.     HWND hwnd,
  911.     UINT state,
  912.     int cx,
  913.     int cy)
  914. {
  915.     if (!IsMinimized(hwnd))
  916.     {
  917. gui_resize_window(cx, cy);
  919. /* Menu bar may wrap differently now */
  920. gui_w32_get_menu_height(TRUE);
  921.     }
  922. }
  924.     static void
  925. _OnSetFocus(
  926.     HWND hwnd,
  927.     HWND hwndOldFocus)
  928. {
  929.     gui_focus_change(TRUE);
  930. }
  932.     static void
  933. _OnKillFocus(
  934.     HWND hwnd,
  935.     HWND hwndNewFocus)
  936. {
  937.     gui_focus_change(FALSE);
  938. }
  940. /*
  941.  * Find the GuiMenu with the given id
  942.  */
  943.     static GuiMenu *
  944. gui_w32_find_menu(
  945.     GuiMenu *pMenu,
  946.     int id)
  947. {
  948.     GuiMenu *pChildMenu;
  950.     while (pMenu)
  951.     {
  952. if (pMenu->id == (UINT)id) /* && pMenu->submenu_id == NULL) */
  953.     break;
  954. if (pMenu->children != NULL)
  955. {
  956.     pChildMenu = gui_w32_find_menu(pMenu->children, id);
  957.     if (pChildMenu)
  958.     {
  959. pMenu = pChildMenu;
  960. break;
  961.     }
  962. }
  963. pMenu = pMenu->next;
  964.     }
  965.     return pMenu;
  966. }
  968.     static void
  969. _OnMenu(
  970.     HWND hwnd,
  971.     int id,
  972.     HWND hwndCtl,
  973.     UINT codeNotify)
  974. {
  975.     GuiMenu *pMenu;
  977.     pMenu = gui_w32_find_menu(gui.root_menu, id);
  978.     if (pMenu)
  979. gui_menu_cb(pMenu);
  980. }
  982. /*
  983.  * Find the scrollbar with the given hwnd.
  984.  */
  985.     static GuiScrollbar *
  986. gui_w32_find_scrollbar(HWND hwnd)
  987. {
  988.     WIN *wp;
  990.     if (gui.bottom_sbar.id == hwnd)
  991. return &gui.bottom_sbar;
  992.     for (wp = firstwin; wp != NULL; wp = wp->w_next)
  993.     {
  994. if (wp->w_scrollbars[SBAR_LEFT].id == hwnd)
  995.     return &wp->w_scrollbars[SBAR_LEFT];
  996. if (wp->w_scrollbars[SBAR_RIGHT].id == hwnd)
  997.     return &wp->w_scrollbars[SBAR_RIGHT];
  998.     }
  999.     return NULL;
  1000. }
  1002.     static int
  1003. _OnScroll(
  1004.     HWND hwnd,
  1005.     HWND hwndCtl,
  1006.     UINT code,
  1007.     int pos)
  1008. {
  1009.     GuiScrollbar *sb, *sb_info;
  1010.     int val;
  1011.     int dragging = FALSE;
  1012.     SCROLLINFO si;
  1013.     WIN *wp;
  1015.     sb = gui_w32_find_scrollbar(hwndCtl);
  1016.     if (sb == NULL)
  1017. return 0;
  1019.     if (sb->wp != NULL)     /* Left or right scrollbar */
  1020.     {
  1021. /*
  1022.  * Careful: need to get scrollbar info out of first (left) scrollbar
  1023.  * for window, but keep real scrollbar too because we must pass it to
  1024.  * gui_drag_scrollbar().
  1025.  */
  1026. sb_info = &sb->wp->w_scrollbars[0];
  1027.     }
  1028.     else     /* Bottom scrollbar */
  1029. sb_info = sb;
  1030.     val = sb_info->value;
  1032.     switch (code)
  1033.     {
  1034. case SB_THUMBTRACK:
  1035.     /* TRACE("SB_THUMBTRACK, %dn", pos); */
  1036.     val = pos;
  1037.     dragging = TRUE;
  1038.     if (scroll_shift > 0)
  1039. val <<= scroll_shift;
  1040.     break;
  1041. case SB_LINEDOWN:
  1042.     /* TRACE("SB_LINEDOWNn"); */
  1043.     val++;
  1044.     break;
  1045. case SB_LINEUP:
  1046.     /* TRACE("SB_LINEUPn"); */
  1047.     val--;
  1048.     break;
  1049. case SB_PAGEDOWN:
  1050.     /* TRACE("SB_PAGEDOWNn"); */
  1051.     val += (sb_info->size > 2 ? sb_info->size - 2 : 1);
  1052.     break;
  1053. case SB_PAGEUP:
  1054.     /* TRACE("SB_PAGEUPn"); */
  1055.     val -= (sb_info->size > 2 ? sb_info->size - 2 : 1);
  1056.     break;
  1057. case SB_TOP:
  1058.     /* TRACE("SB_TOPn"); */
  1059.     val = 0;
  1060.     break;
  1061. case SB_BOTTOM:
  1062.     /* TRACE("SB_BOTTOMn"); */
  1063.     val = sb_info->max;
  1064.     break;
  1065. case SB_ENDSCROLL:
  1066.     /*
  1067.      * "pos" only gives us 16-bit data.  In case of large file, use
  1068.      * GetScrollPos() which returns 32-bit.  Unfortunately it is not
  1069.      * valid while the scrollbar is being dragged.
  1070.      */
  1071.     /* TRACE("SB_ENDSCROLLn"); */
  1072.     val = GetScrollPos(hwndCtl, SB_CTL);
  1073.     if (scroll_shift > 0)
  1074. val <<= scroll_shift;
  1075.     break;
  1077. default:
  1078.     /* TRACE("Unknown scrollbar event %dn", code); */
  1079.     return 0;
  1080.     }
  1082.     si.cbSize = sizeof(si);
  1083.     si.fMask = SIF_POS;
  1084.     if (scroll_shift > 0)
  1085. si.nPos = val >> scroll_shift;
  1086.     else
  1087. si.nPos = val;
  1088.     SetScrollInfo(hwndCtl, SB_CTL, &si, TRUE);
  1090.     /*
  1091.      * When moving a vertical scrollbar, move the other vertical scrollbar too.
  1092.      */
  1093.     if (sb->wp != NULL)
  1094.     {
  1095. if (sb == &sb->wp->w_scrollbars[SBAR_LEFT])
  1096.     SetScrollInfo(sb->wp->w_scrollbars[SBAR_RIGHT].id,
  1097.    SB_CTL, &si, TRUE);
  1098. else
  1099.     SetScrollInfo(sb->wp->w_scrollbars[SBAR_LEFT].id,
  1100.    SB_CTL, &si, TRUE);
  1101.     }
  1103.     /*
  1104.      * Scrollbars seem to grab focus and vim doesn't read the input queue until
  1105.      * you stop dragging the scrollbar.  We get here each time the scrollbar is
  1106.      * dragged another pixel, but as far as the rest of vim goes, it thinks
  1107.      * we're just hanging in the call to DispatchMessage() in
  1108.      * process_message().  The DispatchMessage() call that hangs was passed a
  1109.      * mouse button click event in the scrollbar window. -- webb.
  1110.      *
  1111.      * Solution: Do the scrolling right here.  But only when allowed.
  1112.      * Ignore the scrollbars while executing an external command or when there
  1113.      * are still characters to be processed.
  1114.      */
  1115.     if (dont_scroll || !termcap_active || !vim_is_input_buf_empty())
  1116. return 0;
  1118.     if (dragging)
  1119.     {
  1120. if (sb->wp == NULL)
  1121.     gui.dragged_sb = SBAR_BOTTOM;
  1122. else if (sb == &sb->wp->w_scrollbars[SBAR_LEFT])
  1123.     gui.dragged_sb = SBAR_LEFT;
  1124. else
  1125.     gui.dragged_sb = SBAR_RIGHT;
  1126. gui.dragged_wp = sb->wp;
  1127.     }
  1128.     else
  1129. gui.dragged_sb = SBAR_NONE;
  1131.     /* Vertical sbar info is kept in the first sbar (the left one) */
  1132.     if (sb->wp != NULL)
  1133. sb = &sb->wp->w_scrollbars[0];
  1135.     /*
  1136.      * Check validity of value
  1137.      */
  1138.     if (val < 0)
  1139. val = 0;
  1140.     if (val > sb->max - sb->size + 1)
  1141. val = sb->max - sb->size + 1;
  1143.     sb->value = val;
  1145. #ifdef RIGHTLEFT
  1146.     if (sb->wp == NULL && curwin->w_p_rl)
  1147.     {
  1148. val = sb->max + 1 - sb->size - val;
  1149. if (val < 0)
  1150.     val = 0;
  1151.     }
  1152. #endif
  1154.     scrollbar_value = val;
  1156.     if (sb->wp != NULL) /* vertical scrollbar */
  1157.     {
  1158. current_scrollbar = 0;
  1159. for (wp = firstwin; wp != sb->wp && wp != NULL; wp = wp->w_next)
  1160.     current_scrollbar++;
  1161. if (wp == NULL)
  1162.     return 0;
  1164. if (State & NORMAL)
  1165. {
  1166.     gui_do_scroll();
  1167.     setcursor();
  1168. }
  1169. else if (State & INSERT)
  1170. {
  1171.     ins_scroll();
  1172.     setcursor();
  1173. }
  1174. else if (State & CMDLINE)
  1175. {
  1176.     if (!msg_scrolled)
  1177.     {
  1178. gui_do_scroll();
  1179. redrawcmdline();
  1180.     }
  1181. }
  1182.     }
  1183.     else
  1184.     {
  1185. colnr_t     old_leftcol = curwin->w_leftcol;
  1187. if (State & NORMAL)
  1188.     gui_do_horiz_scroll();
  1189. else if (State & INSERT)
  1190.     ins_horscroll();
  1191. else if (State & CMDLINE)
  1192. {
  1193.     if (!msg_scrolled)
  1194.     {
  1195. gui_do_horiz_scroll();
  1196. redrawcmdline();
  1197.     }
  1198. }
  1199. if (old_leftcol != curwin->w_leftcol)
  1200. {
  1201.     updateWindow(curwin);   /* update window, status line and cmdline */
  1202.     setcursor();
  1203. }
  1204.     }
  1205.     out_flush();
  1207.     return 0;
  1208. }
  1210. /*
  1211.  * Setup for the Intellimouse
  1212.  */
  1213.     static void
  1214. init_mouse_wheel(void)
  1215. {
  1217. #ifndef SPI_GETWHEELSCROLLLINES
  1218. # define SPI_GETWHEELSCROLLLINES    104
  1219. #endif
  1221. #define VMOUSEZ_CLASSNAME  "MouseZ" /* hidden wheel window class */
  1222. #define VMOUSEZ_TITLE      "Magellan MSWHEEL" /* hidden wheel window title */
  1223. #define VMSH_MOUSEWHEEL    "MSWHEEL_ROLLMSG"
  1224. #define VMSH_SCROLL_LINES  "MSH_SCROLL_LINES_MSG"
  1226.     HWND hdl_mswheel;
  1227.     UINT msh_msgscrolllines;
  1229.     msh_msgmousewheel = 0;
  1230.     mouse_scroll_lines = 3; /* reasonable default */
  1232.     if (os_version.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS
  1233.     || (os_version.dwPlatformId == VER_PLATFORM_WIN32_NT
  1234. && os_version.dwMajorVersion < 4))
  1235.     { /*
  1236.  * If Win95 or NT 3.51,
  1237.  * try to find the hidden point32 window.
  1238.  */
  1239. hdl_mswheel = FindWindow(VMOUSEZ_CLASSNAME, VMOUSEZ_TITLE);
  1240. if (hdl_mswheel)
  1241. {
  1242.     msh_msgscrolllines = RegisterWindowMessage(VMSH_SCROLL_LINES);
  1243.     if (msh_msgscrolllines)
  1244.     {
  1245. mouse_scroll_lines = SendMessage(hdl_mswheel,
  1246. msh_msgscrolllines, 0, 0);
  1247. msh_msgmousewheel  = RegisterWindowMessage(VMSH_MOUSEWHEEL);
  1248.     }
  1249. }
  1250.     }
  1251.     else if (os_version.dwPlatformId == VER_PLATFORM_WIN32_NT
  1252.     && os_version.dwMajorVersion >= 4)
  1253.     {
  1254. /* if NT 4.0 (or Win98) get scroll lines directly from system */
  1255. SystemParametersInfo(SPI_GETWHEELSCROLLLINES, 0,
  1256. &mouse_scroll_lines, 0);
  1257.     }
  1258. }
  1261. /* Intellimouse wheel handler */
  1262.     static void
  1263. _OnMouseWheel(
  1264.     HWND hwnd,
  1265.     short zDelta)
  1266. {
  1267. /* Treat a mouse wheel event as if it were a scroll request */
  1268.     int i;
  1269.     int size;
  1270.     HWND hwndCtl;
  1272.     if (curwin->w_scrollbars[SBAR_RIGHT].id != 0)
  1273.     {
  1274. hwndCtl = curwin->w_scrollbars[SBAR_RIGHT].id;
  1275. size = curwin->w_scrollbars[SBAR_RIGHT].size;
  1276.     }
  1277.     else if (curwin->w_scrollbars[SBAR_LEFT].id != 0)
  1278.     {
  1279. hwndCtl = curwin->w_scrollbars[SBAR_LEFT].id;
  1280. size = curwin->w_scrollbars[SBAR_LEFT].size;
  1281.     }
  1282.     else
  1283. return;
  1285.     size = curwin->w_height;
  1286.     if (mouse_scroll_lines == 0)
  1287. init_mouse_wheel();
  1289.     if (mouse_scroll_lines > 0
  1290.     && mouse_scroll_lines < (size > 2 ? size - 2 : 1))
  1291.     {
  1292. for (i = mouse_scroll_lines; i > 0; --i)
  1293.     _OnScroll(hwnd, hwndCtl, zDelta >= 0 ? SB_LINEUP : SB_LINEDOWN, 0);
  1294.     }
  1295.     else
  1296. _OnScroll(hwnd, hwndCtl, zDelta >= 0 ? SB_PAGEUP : SB_PAGEDOWN, 0);
  1297. }
  1299. /*
  1300.  * Get current x mouse coordinate in text window.
  1301.  * Return -1 when unknown.
  1302.  */
  1303.     int
  1304. gui_mch_get_mouse_x(void)
  1305. {
  1306.     RECT rct;
  1307.     POINT mp;
  1309.     if (GetWindowRect(s_textArea, &rct))
  1310.     {
  1311. if (GetCursorPos((LPPOINT)&mp))
  1312.     return (int)(mp.x - rct.left);
  1313.     }
  1314.     return -1;
  1315. }
  1317. /*
  1318.  * Get current y mouse coordinate in text window.
  1319.  * Return -1 when unknown.
  1320.  */
  1321.     int
  1322. gui_mch_get_mouse_y(void)
  1323. {
  1324.     RECT rct;
  1325.     POINT mp;
  1327.     if (GetWindowRect(s_textArea, &rct))
  1328.     {
  1329. if (GetCursorPos((LPPOINT)&mp))
  1330.     return (int)(mp.y - rct.top);
  1331.     }
  1332.     return -1;
  1333. }
  1335. /*
  1336.  * Move mouse pointer to character at (x, y).
  1337.  */
  1338.     void
  1339. gui_mch_setmouse(int x, int y)
  1340. {
  1341.     RECT rct;
  1343.     if (GetWindowRect(s_textArea, &rct))
  1344. (void)SetCursorPos(x + gui.border_offset + rct.left,
  1345.    y + gui.border_offset + rct.top);
  1346. }
  1348.     static void
  1349. gui_w32_get_valid_dimensions(
  1350.     int w,
  1351.     int h,
  1352.     int *valid_w,
  1353.     int *valid_h)
  1354. {
  1355.     int     base_width, base_height;
  1357.     base_width = gui_get_base_width()
  1358. + GetSystemMetrics(SM_CXSIZEFRAME) * 2;
  1359.     base_height = gui_get_base_height()
  1360. + GetSystemMetrics(SM_CYSIZEFRAME) * 2
  1361. + GetSystemMetrics(SM_CYCAPTION)
  1362. + gui_w32_get_menu_height(FALSE);
  1363.     *valid_w = base_width +
  1364.     ((w - base_width) / gui.char_width) * gui.char_width;
  1365.     *valid_h = base_height +
  1366.     ((h - base_height) / gui.char_height) * gui.char_height;
  1367. }
  1369. /*
  1370.  * Even though we have _DuringSizing() which makes the rubber band a valid
  1371.  * size, we need this for when the user maximises the window.
  1372.  * TODO: Doesn't seem to adjust the width though for some reason.
  1373.  */
  1374.     static BOOL
  1375. _OnWindowPosChanging(
  1376.     HWND hwnd,
  1377.     LPWINDOWPOS lpwpos)
  1378. {
  1379.     if (!(lpwpos->flags & SWP_NOSIZE))
  1380.     {
  1381. gui_w32_get_valid_dimensions(lpwpos->cx, lpwpos->cy,
  1382.      &lpwpos->cx, &lpwpos->cy);
  1383.     }
  1384.     return 0;
  1385. }
  1387.     static int
  1388. _DuringSizing(
  1389.     HWND hwnd,
  1390.     UINT fwSide,
  1391.     LPRECT lprc)
  1392. {
  1393.     int     w, h;
  1394.     int     valid_w, valid_h;
  1395.     int     w_offset, h_offset;
  1397.     w = lprc->right - lprc->left;
  1398.     h = lprc->bottom - lprc->top;
  1399.     gui_w32_get_valid_dimensions(w, h, &valid_w, &valid_h);
  1400.     w_offset = w - valid_w;
  1401.     h_offset = h - valid_h;
  1403.     if (fwSide == WMSZ_LEFT || fwSide == WMSZ_TOPLEFT
  1404.     || fwSide == WMSZ_BOTTOMLEFT)
  1405. lprc->left += w_offset;
  1406.     else if (fwSide == WMSZ_RIGHT || fwSide == WMSZ_TOPRIGHT
  1407.     || fwSide == WMSZ_BOTTOMRIGHT)
  1408. lprc->right -= w_offset;
  1410.     if (fwSide == WMSZ_TOP || fwSide == WMSZ_TOPLEFT
  1411.     || fwSide == WMSZ_TOPRIGHT)
  1412. lprc->top += h_offset;
  1413.     else if (fwSide == WMSZ_BOTTOM || fwSide == WMSZ_BOTTOMLEFT
  1414.     || fwSide == WMSZ_BOTTOMRIGHT)
  1415. lprc->bottom -= h_offset;
  1416.     return TRUE;
  1417. }
  1419. /*
  1420.  * Erase parts of the window that are not redrawn.
  1421.  * Draw the rectangle just under the left and/or right scrollbars.
  1422.  */
  1423.     static void
  1424. _OnEraseBG(HWND hwnd)
  1425. {
  1426.     HDC hdc =  GetDC(hwnd);
  1427.     RECT rect, drect;
  1428.     WIN *wp;
  1430.     GetClientRect(hwnd, &rect);
  1432.     /* Draw blank rectangles for hidden scrollbars */
  1433.     for (wp = firstwin; wp; wp = wp->w_next)
  1434.     {
  1435. if (wp->w_height == 0)
  1436. {
  1437.     drect.top = rect.bottom - gui.char_height * (Rows - wp->w_winpos);
  1438.     if (gui.which_scrollbars[SBAR_BOTTOM])
  1439. drect.top -= gui.scrollbar_height;
  1440.     drect.bottom = drect.top + gui.char_height;
  1441.     if (gui.which_scrollbars[SBAR_LEFT])
  1442.     {
  1443. drect.left = 0;
  1444. drect.right = gui.scrollbar_width;
  1445. FillRect(hdc, &drect, GetSysColorBrush(COLOR_BTNFACE));
  1446.     }
  1447.     if (gui.which_scrollbars[SBAR_RIGHT])
  1448.     {
  1449. drect.left = rect.right - gui.scrollbar_width;
  1450. drect.right = rect.right;
  1451. FillRect(hdc, &drect, GetSysColorBrush(COLOR_BTNFACE));
  1452.     }
  1453. }
  1454.     }
  1456.     /* draw the rectangle below vertical scrollbars */
  1457.     /* top of the rectangle is just below the last window */
  1458.     drect.top = rect.bottom - gui.char_height
  1459.    * (Rows - (lastwin->w_winpos + lastwin->w_height));
  1460.     drect.top += lastwin->w_status_height * gui.char_height;
  1462.     if (gui.which_scrollbars[SBAR_BOTTOM])
  1463. drect.top -= gui.scrollbar_height;
  1464.     drect.bottom = rect.bottom;
  1466.     if (gui.which_scrollbars[SBAR_LEFT])
  1467.     {
  1468. drect.left = 0;
  1469. drect.right = gui.scrollbar_width;
  1470. FillRect(hdc, &drect, GetSysColorBrush(COLOR_BTNFACE));
  1471.     }
  1472.     if (gui.which_scrollbars[SBAR_RIGHT])
  1473.     {
  1474. drect.left = rect.right - gui.scrollbar_width;
  1475. drect.right = rect.right;
  1476. FillRect(hdc, &drect, GetSysColorBrush(COLOR_BTNFACE));
  1477.     }
  1478.     ReleaseDC(hwnd, hdc);
  1479. }
  1481.     static BOOL
  1482. _OnCreate (HWND hwnd, LPCREATESTRUCT lpcs)
  1483. {
  1484. #ifdef MULTI_BYTE
  1485.     /* get system fixed font size*/
  1486.     static const char ach[] = {'W', 'f', 'g', 'M'};
  1488.     HDC     hdc = GetWindowDC(hwnd);
  1489.     HFONT   hfntOld = SelectFont(hdc, GetStockObject(SYSTEM_FIXED_FONT));
  1490.     SIZE    siz;
  1492.     GetTextExtentPoint(hdc, ach, sizeof(ach), &siz);
  1494.     sysfixed_width = siz.cx / sizeof(ach);
  1495.     /*
  1496.      * Make characters one pixel higher, so that italic and bold fonts don't
  1497.      * draw off the bottom of their character space.  Also means that we can
  1498.      * underline an underscore for normal text.
  1499.      */
  1500.     sysfixed_height = siz.cy + 1;
  1502.     /* TRACE("GetFontSize: h %d, w %dn", gui.char_height, gui.char_width); */
  1504.     SelectFont(hdc, hfntOld);
  1506.     ReleaseDC(hwnd, hdc);
  1508. #endif
  1509.     return 0;
  1510. }
  1512. #ifdef WIN32_FIND_REPLACE
  1513. /*
  1514.  * Handle a Find/Replace window message.
  1515.  */
  1516.     static void
  1517. _OnFindRepl(void)
  1518. {
  1519.     char_u cmd[600]; //XXX kludge
  1521.     /* Add a char before the command if needed */
  1522.     if (State & INSERT)
  1523. cmd[0] = Ctrl('O');
  1524.     else if ((State | NORMAL) == 0 && State != CONFIRM)
  1525. cmd[0] = ESC;
  1526.     else
  1527. cmd[0] = NUL;
  1528.     cmd[1] = NUL;
  1530.     if (s_findrep_struct.Flags & FR_DIALOGTERM)
  1531.     {
  1532. if (State == CONFIRM)
  1533. {
  1534.     add_to_input_buf("q", 1);
  1535. }
  1536. return;
  1537.     }
  1539.     if (s_findrep_struct.Flags & FR_FINDNEXT)
  1540.     {
  1541. if (State == CONFIRM)
  1542. {
  1543.     STRCAT(cmd, "n");
  1544. }
  1545. else
  1546. {
  1547.     if (s_findrep_struct.Flags & FR_DOWN)
  1548. STRCAT(cmd, "/");
  1549.     else
  1550. STRCAT(cmd, "?");
  1552.     if (s_findrep_struct.Flags & FR_WHOLEWORD)
  1553. STRCAT(cmd, "\<");
  1554.     STRCAT(cmd, s_findrep_struct.lpstrFindWhat);
  1555.     if (s_findrep_struct.Flags & FR_WHOLEWORD)
  1556. STRCAT(cmd, "\>");
  1558.     STRCAT(cmd, "r");
  1559. }
  1560. /*
  1561.  * Give main window the focus back: this is so
  1562.  * the cursor isn't hollow.
  1563.  */
  1564. (void)SetFocus(s_hwnd);
  1565.     }
  1566.     else if (s_findrep_struct.Flags & FR_REPLACE)
  1567.     {
  1568. if (State == CONFIRM)
  1569. {
  1570.     STRCAT(cmd, "y");
  1571. }
  1572. else
  1573. {
  1574.     STRCAT(cmd, ":%sno/");
  1575.     STRCAT(cmd, s_findrep_struct.lpstrFindWhat);
  1576.     STRCAT(cmd, "/");
  1577.     STRCAT(cmd, s_findrep_struct.lpstrReplaceWith);
  1578.     STRCAT(cmd, "/gcr");
  1579. }
  1580. /*
  1581.  * Give main window the focus back: this is to allow
  1582.  * handling of the confirmation y/n/a/q stuff.
  1583.  */
  1584. (void)SetFocus(s_hwnd);
  1585.     }
  1586.     else if (s_findrep_struct.Flags & FR_REPLACEALL)
  1587.     {
  1588. if (State == CONFIRM)
  1589. {
  1590.     STRCAT(cmd, "a");
  1591. }
  1592. else
  1593. {
  1594.     STRCAT(cmd, ":%sno/");
  1595.     STRCAT(cmd, s_findrep_struct.lpstrFindWhat);
  1596.     STRCAT(cmd, "/");
  1597.     STRCAT(cmd, s_findrep_struct.lpstrReplaceWith);
  1598.     STRCAT(cmd, "/gr");
  1599. }
  1600.     }
  1601.     if (*cmd)
  1602. add_to_input_buf(cmd, STRLEN(cmd));
  1603. }
  1604. #endif
  1606.     static void
  1607. HandleMouseHide(UINT uMsg, LPARAM lParam)
  1608. {
  1609.     static LPARAM last_lParam = 0L;
  1611.     /* We sometimes get a mousemove when the mouse didn't move... */
  1612.     if (uMsg == WM_MOUSEMOVE)
  1613.     {
  1614. if (lParam == last_lParam)
  1615.     return;
  1616. last_lParam = lParam;
  1617.     }
  1619.     /* Handle specially, to centralise coding. We need to be sure we catch all
  1620.      * possible events which should cause us to restore the cursor (as it is a
  1621.      * shared resource, we take full responsibility for it).
  1622.      */
  1623.     switch (uMsg)
  1624.     {
  1625.     // Omit these, because a shift or control key should not hide the pointer
  1626.     // case WM_KEYDOWN:
  1627.     // case WM_SYSKEYDOWN:
  1628.     case WM_KEYUP:
  1629.     case WM_SYSKEYUP:
  1630.     case WM_CHAR:
  1631.     case WM_SYSCHAR:
  1632. /*
  1633.  * blank out the pointer if necessary
  1634.  */
  1635. if (p_mh)
  1636.     gui_mch_mousehide(TRUE);
  1637. break;
  1639.     case WM_MOUSEMOVE:
  1640.     case WM_LBUTTONDOWN:
  1641.     case WM_LBUTTONUP:
  1642.     case WM_MBUTTONDOWN:
  1643.     case WM_MBUTTONUP:
  1644.     case WM_RBUTTONDOWN:
  1645.     case WM_RBUTTONUP:
  1646.     case WM_NCMOUSEMOVE:
  1647.     case WM_NCLBUTTONDOWN:
  1648.     case WM_NCLBUTTONUP:
  1649.     case WM_NCMBUTTONDOWN:
  1650.     case WM_NCMBUTTONUP:
  1651.     case WM_NCRBUTTONDOWN:
  1652.     case WM_NCRBUTTONUP:
  1653.     case WM_KILLFOCUS:
  1654. /*
  1655.  * if the pointer is currently hidden, then we should show it.
  1656.  */
  1657. gui_mch_mousehide(FALSE);
  1658. break;
  1659.     }
  1660. }
  1662.     static LRESULT CALLBACK
  1663. _WndProc(
  1664.     HWND hwnd,
  1665.     UINT uMsg,
  1666.     WPARAM wParam,
  1667.     LPARAM lParam)
  1668. {
  1669.     /*
  1670.     TRACE("WndProc: hwnd = %08x, msg = %x, wParam = %x, lParam = %xn",
  1671.   hwnd, uMsg, wParam, lParam);
  1672.     */
  1674.     HandleMouseHide(uMsg, lParam);
  1676.     s_uMsg = uMsg;
  1677.     s_wParam = wParam;
  1678.     s_lParam = lParam;
  1680.     switch (uMsg)
  1681.     {
  1682. HANDLE_MSG(hwnd, WM_DEADCHAR, _OnDeadChar);
  1683. HANDLE_MSG(hwnd, WM_SYSDEADCHAR, _OnDeadChar);
  1684. /* HANDLE_MSG(hwnd, WM_ACTIVATE,    _OnActivate); */
  1685. HANDLE_MSG(hwnd, WM_CHAR, _OnChar);
  1686. HANDLE_MSG(hwnd, WM_CLOSE, _OnClose);
  1687. /* HANDLE_MSG(hwnd, WM_COMMAND, _OnCommand); */
  1688. HANDLE_MSG(hwnd, WM_DESTROY, _OnDestroy);
  1689. HANDLE_MSG(hwnd, WM_DROPFILES, _OnDropFiles);
  1690. HANDLE_MSG(hwnd, WM_HSCROLL, _OnScroll);
  1691. HANDLE_MSG(hwnd, WM_KILLFOCUS, _OnKillFocus);
  1692. HANDLE_MSG(hwnd, WM_COMMAND, _OnMenu);
  1693. /* HANDLE_MSG(hwnd, WM_MOVE,     _OnMove); */
  1694. /* HANDLE_MSG(hwnd, WM_NCACTIVATE,  _OnNCActivate); */
  1695. HANDLE_MSG(hwnd, WM_SETFOCUS, _OnSetFocus);
  1696. HANDLE_MSG(hwnd, WM_SIZE, _OnSize);
  1697. /* HANDLE_MSG(hwnd, WM_SYSCOMMAND,  _OnSysCommand); */
  1698. /* HANDLE_MSG(hwnd, WM_SYSKEYDOWN,  _OnAltKey); */
  1699. /* HANDLE_MSG(hwnd, WM_SYSKEYUP,    _OnAltKey); */
  1700. HANDLE_MSG(hwnd, WM_VSCROLL, _OnScroll);
  1701. HANDLE_MSG(hwnd, WM_WINDOWPOSCHANGING, _OnWindowPosChanging);
  1702. HANDLE_MSG(hwnd, WM_ACTIVATEAPP, _OnActivateApp);
  1704. /* HANDLE_MSG(hwnd, WM_SYSCHAR, _OnSysChar); */
  1705.     case WM_SYSCHAR:
  1706. /*
  1707.  * if 'winaltkeys' is "no", or it's "menu" and it's not a menu
  1708.  * shortcut key, handle like a typed ALT key, otherwise call Windows
  1709.  * ALT key handling.
  1710.  */
  1711. if (p_wak[0] == 'n'
  1712. || (p_wak[0] == 'm' && !gui_is_menu_shortcut((int)wParam)))
  1713.     return HANDLE_WM_SYSCHAR((hwnd), (wParam), (lParam), (_OnSysChar));
  1714. else
  1715.     return DefWindowProc(hwnd, uMsg, wParam, lParam);
  1717.     case WM_ERASEBKGND:
  1718. _OnEraseBG(hwnd);
  1719. break;
  1721.     case WM_CREATE: /* HANDLE_MSG doesn't seem to handle this one */
  1722. return _OnCreate (hwnd, (LPCREATESTRUCT)lParam);
  1724.     case WM_SIZING: /* HANDLE_MSG doesn't seem to handle this one */
  1725. return _DuringSizing(hwnd, wParam, (LPRECT)lParam);
  1727.     case WM_MOUSEWHEEL:
  1728. _OnMouseWheel(hwnd, HIWORD(wParam));
  1729. break;
  1731. #ifdef USE_GUI_WIN32_TOOLBAR
  1732.     case WM_NOTIFY:
  1733. switch (((LPNMHDR) lParam)->code)
  1734. {
  1735.     case TTN_NEEDTEXT:
  1736. {
  1737.     LPTOOLTIPTEXT lpttt;
  1738.     UINT idButton;
  1739.     int idx;
  1740.     GuiMenu *pMenu;
  1742.     lpttt = (LPTOOLTIPTEXT)lParam;
  1743.     idButton = lpttt->hdr.idFrom;
  1744.     pMenu = gui_w32_find_menu(gui.root_menu, idButton);
  1745.     if (pMenu)
  1746.     {
  1747. idx = MENU_INDEX_TIP;
  1748. if (pMenu->strings[idx])
  1749. {
  1750.     lpttt->hinst = NULL;  /* string, not resource*/
  1751.     lpttt->lpszText = pMenu->strings[idx];
  1752. }
  1753.     }
  1754. }
  1755. break;
  1756.     default:
  1757. break;
  1758. }
  1759. break;
  1760. #endif
  1761. #ifdef  MENUHINTS
  1762.     case WM_MENUSELECT:
  1763. if ((((UINT) HIWORD(wParam) &
  1764.     (0xffff ^ (MF_MOUSESELECT + MF_BITMAP))) == MF_HILITE) &
  1765.     ((State & CMDLINE) == 0))
  1766. {
  1767.     UINT idButton;
  1768.     int idx;
  1769.     GuiMenu *pMenu;
  1771.     idButton = (UINT)LOWORD(wParam);
  1772.     pMenu = gui_w32_find_menu(gui.root_menu, idButton);
  1773.     if (pMenu)
  1774.     {
  1775. idx = MENU_INDEX_TIP;
  1776. if (pMenu->strings[idx])
  1777.     msg(pMenu->strings[idx]);
  1778. else
  1779.     msg("");
  1780. setcursor();
  1781. out_flush();
  1782.     }
  1783. }
  1784. break;
  1785. #endif
  1786.     default:
  1787. if (uMsg == msh_msgmousewheel && msh_msgmousewheel != 0)
  1788. {   /* handle MSH_MOUSEWHEEL messages for Intellimouse */
  1789.     _OnMouseWheel(hwnd, HIWORD(wParam));
  1790.     break;
  1791. }
  1792. #ifdef WIN32_FIND_REPLACE
  1793. else if (uMsg == s_findrep_msg && s_findrep_msg != 0)
  1794. {
  1795.     _OnFindRepl();
  1796. }
  1797. #endif
  1798. return DefWindowProc(hwnd, uMsg, wParam, lParam);
  1799.     }
  1801.     return 1;
  1802. }
  1804.     static LRESULT CALLBACK
  1805. _TextAreaWndProc(
  1806.     HWND hwnd,
  1807.     UINT uMsg,
  1808.     WPARAM wParam,
  1809.     LPARAM lParam)
  1810. {
  1811.     /*
  1812.     TRACE("TextAreaWndProc: hwnd = %08x, msg = %x, wParam = %x, lParam = %xn",
  1813.   hwnd, uMsg, wParam, lParam);
  1814.     */
  1816.     HandleMouseHide(uMsg, lParam);
  1818.     s_uMsg = uMsg;
  1819.     s_wParam = wParam;
  1820.     s_lParam = lParam;
  1822.     switch (uMsg)
  1823.     {
  1824. HANDLE_MSG(hwnd, WM_LBUTTONDBLCLK,_OnMouseButtonDown);
  1825. HANDLE_MSG(hwnd, WM_LBUTTONDOWN,_OnMouseButtonDown);
  1826. HANDLE_MSG(hwnd, WM_LBUTTONUP, _OnMouseMoveOrRelease);
  1827. HANDLE_MSG(hwnd, WM_MBUTTONDBLCLK,_OnMouseButtonDown);
  1828. HANDLE_MSG(hwnd, WM_MBUTTONDOWN,_OnMouseButtonDown);
  1829. HANDLE_MSG(hwnd, WM_MBUTTONUP, _OnMouseMoveOrRelease);
  1830. HANDLE_MSG(hwnd, WM_MOUSEMOVE, _OnMouseMoveOrRelease);
  1831. HANDLE_MSG(hwnd, WM_PAINT, _OnPaint);
  1832. HANDLE_MSG(hwnd, WM_RBUTTONDBLCLK,_OnMouseButtonDown);
  1833. HANDLE_MSG(hwnd, WM_RBUTTONDOWN,_OnMouseButtonDown);
  1834. HANDLE_MSG(hwnd, WM_RBUTTONUP, _OnMouseMoveOrRelease);
  1836.     default:
  1837. return DefWindowProc(hwnd, uMsg, wParam, lParam);
  1838.     }
  1839. }
  1842. /*
  1843.  * End of call-back routines
  1844.  */
  1846. /*
  1847.  * Parse the GUI related command-line arguments.  Any arguments used are
  1848.  * deleted from argv, and *argc is decremented accordingly.  This is called
  1849.  * when vim is started, whether or not the GUI has been started.
  1850.  */
  1851.     void
  1852. gui_mch_prepare(int *argc, char **argv)
  1853. {
  1854.     /* We don't have any command line arguments for the Windows GUI yet */
  1856.     /* get the OS version info */
  1857.     os_version.dwOSVersionInfoSize = sizeof(os_version);
  1858.     GetVersionEx(&os_version); /* this call works on Win32s, Win95 and WinNT */
  1859. }
  1861. /*
  1862.  * Initialise the GUI. Create all the windows, set up all the call-backs
  1863.  * etc.
  1864.  */
  1865.     int
  1866. gui_mch_init(void)
  1867. {
  1868.     const char szVimWndClass[] = VIM_CLASS;
  1869.     const char szTextAreaClass[] = "VimTextArea";
  1870.     WNDCLASS wndclass;
  1872.     /* Display any pending error messages */
  1873.     mch_display_error();
  1875.     /*
  1876.      * Load the tearoff bitmap
  1877.      */
  1878.     s_htearbitmap = LoadBitmap(s_hinst, "IDB_TEAROFF");
  1880.     gui.scrollbar_width = GetSystemMetrics(SM_CXVSCROLL);
  1881.     gui.scrollbar_height = GetSystemMetrics(SM_CYHSCROLL);
  1882.     gui.menu_height = 0; /* Windows takes care of this */
  1883.     gui.border_width = 0;
  1885.     wndclass.style = CS_HREDRAW | CS_VREDRAW;
  1886.     wndclass.lpfnWndProc = _WndProc;
  1887.     wndclass.cbClsExtra = 0;
  1888.     wndclass.cbWndExtra = 0;
  1889.     wndclass.hInstance = s_hinst;
  1890.     wndclass.hIcon = LoadIcon(wndclass.hInstance, "IDR_VIM");
  1891.     wndclass.hCursor = LoadCursor(NULL, IDC_ARROW);
  1892.     wndclass.hbrBackground = GetStockBrush(LTGRAY_BRUSH);
  1893.     wndclass.lpszMenuName = NULL;
  1894.     wndclass.lpszClassName = szVimWndClass;
  1896.     if (RegisterClass(&wndclass) == 0)
  1897. return FAIL;
  1899.     s_hwnd = CreateWindow(
  1900. szVimWndClass, "Vim W32 GUI",
  1901. WS_OVERLAPPEDWINDOW,
  1902. CW_USEDEFAULT, CW_USEDEFAULT,
  1903. 100, /* Any value will do */
  1904. 100, /* Any value will do */
  1905. NULL, NULL,
  1906. s_hinst, NULL);
  1908.     if (s_hwnd == NULL)
  1909. return FAIL;
  1911.     /* Create the text area window */
  1912.     wndclass.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;
  1913.     wndclass.lpfnWndProc = _TextAreaWndProc;
  1914.     wndclass.cbClsExtra = 0;
  1915.     wndclass.cbWndExtra = 0;
  1916.     wndclass.hInstance = s_hinst;
  1917.     wndclass.hIcon = NULL;
  1918.     wndclass.hCursor = LoadCursor(NULL, IDC_ARROW);
  1919.     wndclass.hbrBackground = NULL;
  1920.     wndclass.lpszMenuName = NULL;
  1921.     wndclass.lpszClassName = szTextAreaClass;
  1923.     if (RegisterClass(&wndclass) == 0)
  1924. return FAIL;
  1926.     s_textArea = CreateWindow(
  1927. szTextAreaClass, "Vim text area",
  1928. WS_CHILD | WS_VISIBLE, 0, 0,
  1929. 100, /* Any value will do for now */
  1930. 100, /* Any value will do for now */
  1931. s_hwnd, NULL,
  1932. s_hinst, NULL);
  1934.     if (s_textArea == NULL)
  1935. return FAIL;
  1937.     s_menuBar = CreateMenu();
  1938.     s_hdc = GetDC(s_textArea);
  1940.     DragAcceptFiles(s_hwnd, TRUE);
  1942.     /* Do we need to bother with this? */
  1943.     /* m_fMouseAvail = GetSystemMetrics(SM_MOUSEPRESENT); */
  1945.     /* Get background/foreground colors from system */
  1946.     gui.norm_pixel = GetSysColor(COLOR_WINDOWTEXT);
  1947.     gui.back_pixel = GetSysColor(COLOR_WINDOW);
  1948.     gui.def_norm_pixel = gui.norm_pixel;
  1949.     gui.def_back_pixel = gui.back_pixel;
  1951.     /* Get the colors from the "Normal" group (set in syntax.c or in a vimrc
  1952.      * file) */
  1953.     set_normal_colors();
  1955.     /*
  1956.      * Check that none of the colors are the same as the background color.
  1957.      * Then store the current values as the defaults.
  1958.      */
  1959.     gui_check_colors();
  1960.     gui.def_norm_pixel = gui.norm_pixel;
  1961.     gui.def_back_pixel = gui.back_pixel;
  1963.     /* Get the colors for the highlight groups (gui_check_colors() might have
  1964.      * changed them) */
  1965.     highlight_gui_started();
  1967.     /*
  1968.      * Start out by adding the configured border width into the border offset
  1969.      */
  1970.     gui.border_offset = gui.border_width;
  1972.     /*
  1973.      * Set up for Intellimouse processing
  1974.      */
  1975.     init_mouse_wheel();
  1977.     /*
  1978.      * compute a couple of metrics used for the dialogs
  1979.      */
  1980.     get_dialog_font_metrics();
  1981. #ifdef USE_GUI_WIN32_TOOLBAR
  1982.     /*
  1983.      * Create the toolbar
  1984.      */
  1985.     initialise_toolbar();
  1986. #endif
  1987. #ifdef WIN32_FIND_REPLACE
  1988.     /*
  1989.      * Initialise the dialog box stuff
  1990.      */
  1991.     s_findrep_msg = RegisterWindowMessage(FINDMSGSTRING);
  1993.     /* Initialise the struct */
  1994.     s_findrep_struct.lStructSize = sizeof(s_findrep_struct);
  1995.     s_findrep_struct.lpstrFindWhat = alloc(256);
  1996.     s_findrep_struct.lpstrFindWhat[0] = NUL;
  1997.     s_findrep_struct.lpstrReplaceWith = alloc(256);
  1998.     s_findrep_struct.lpstrReplaceWith[0] = NUL;
  1999.     s_findrep_struct.wFindWhatLen = 256;
  2000.     s_findrep_struct.wReplaceWithLen = 256;
  2001. #endif
  2003.     return OK;
  2004. }
  2006. /*
  2007.  * Called when the foreground or background color has been changed.
  2008.  */
  2009.     void
  2010. gui_mch_new_colors(void)
  2011. {
  2012.     /* nothing to do? */
  2013. }
  2015. /*
  2016.  * Open the GUI window which was created by a call to gui_mch_init().
  2017.  */
  2018.     int
  2019. gui_mch_open(void)
  2020. {
  2021.     /* Actually open the window */
  2022.     ShowWindow(s_hwnd, SW_SHOWNORMAL);
  2024.     return OK;
  2025. }
  2027.     void
  2028. gui_mch_exit(int rc)
  2029. {
  2030.     ReleaseDC(s_textArea, s_hdc);
  2032.     /*
  2033.      * Unload the tearoff bitmap
  2034.      */
  2035.     (void)DeleteObject((HGDIOBJ) s_htearbitmap);
  2037.     /* Destroy our window (if we have one). */
  2038.     if (s_hwnd != NULL)
  2039.     {
  2040. destroying = TRUE; /* ignore WM_DESTROY message now */
  2041. DestroyWindow(s_hwnd);
  2042.     }
  2043. }
  2045. /*
  2046.  * Set the size of the window to the given width and height in pixels.
  2047.  */
  2048.     void
  2049. gui_mch_set_winsize(int width, int height, int min_width, int min_height,
  2050.     int base_width, int base_height)
  2051. {
  2052.     RECT    workarea_rect;
  2053.     int     win_width, win_height;
  2054.     int     win_xpos, win_ypos;
  2055.     WINDOWPLACEMENT wndpl;
  2057.     /* try to keep window completely on screen */
  2058.     /* get size of the screen work area (excludes taskbar, appbars) */
  2059.     SystemParametersInfo(SPI_GETWORKAREA, 0, &workarea_rect, 0);
  2061.     /* get current posision of our window */
  2062.     wndpl.length = sizeof(WINDOWPLACEMENT);
  2063.     GetWindowPlacement(s_hwnd, &wndpl);
  2064.     if (wndpl.showCmd == SW_SHOWNORMAL)
  2065.     {
  2066. win_xpos = wndpl.rcNormalPosition.left;
  2067. win_ypos = wndpl.rcNormalPosition.top;
  2068.     }
  2069.     else
  2070.     {
  2071. win_xpos = workarea_rect.left;
  2072. win_ypos = workarea_rect.top;
  2073.     }
  2075.     /* compute the size of the outside of the window */
  2076.     win_width = width + GetSystemMetrics(SM_CXSIZEFRAME) * 2;
  2077.     win_height = height + GetSystemMetrics(SM_CYSIZEFRAME) * 2
  2078. + GetSystemMetrics(SM_CYCAPTION)
  2079. + gui_w32_get_menu_height(FALSE);
  2081.     /* if the window is going off the screen, move it on to the screen */
  2082.     if (win_xpos + win_width > workarea_rect.right)
  2083. win_xpos = workarea_rect.right - win_width;
  2085.     if (win_xpos < workarea_rect.left)
  2086. win_xpos = workarea_rect.left;
  2088.     if (win_ypos + win_height > workarea_rect.bottom)
  2089. win_ypos = workarea_rect.bottom - win_height;
  2091.     if (win_ypos < workarea_rect.top)
  2092. win_ypos = workarea_rect.top;
  2094.     /* set window position */
  2095.     SetWindowPos(s_hwnd, NULL, win_xpos, win_ypos, win_width, win_height,
  2096.  SWP_NOZORDER | SWP_NOACTIVATE);
  2098.     /* Menu may wrap differently now */
  2099.     gui_w32_get_menu_height(!gui.starting);
  2100. }
  2102.     void
  2103. gui_mch_get_screen_dimensions(int *screen_w, int *screen_h)
  2104. {
  2105.     RECT    workarea_rect;
  2107.     /* get size of the screen work area (excludes taskbar, appbars) */
  2108.     SystemParametersInfo(SPI_GETWORKAREA, 0, &workarea_rect, 0);
  2110.     *screen_w = workarea_rect.right - workarea_rect.left
  2111.       - GetSystemMetrics(SM_CXSIZEFRAME) * 2;
  2112.     *screen_h = workarea_rect.bottom - workarea_rect.top
  2113.       - GetSystemMetrics(SM_CYSIZEFRAME) * 2
  2114.       - GetSystemMetrics(SM_CYCAPTION)
  2115.       - gui_w32_get_menu_height(FALSE);
  2116. }
  2118.     void
  2119. gui_mch_set_text_area_pos(int x, int y, int w, int h)
  2120. {
  2121.     SetWindowPos(s_textArea, NULL, x, y, w, h, SWP_NOZORDER | SWP_NOACTIVATE);
  2123. #ifdef USE_GUI_WIN32_TOOLBAR
  2124.     if (vim_strchr(p_guioptions, GO_TOOLBAR) != NULL)
  2125. SendMessage(s_toolbarhwnd, WM_SIZE,
  2126. (WPARAM)0, (LPARAM)(w + (long)(TOOLBAR_BUTTON_HEIGHT+8)<<16));
  2127. #endif
  2128. }
  2131. /*
  2132.  * Scrollbar stuff:
  2133.  */
  2135.     void
  2136. gui_mch_enable_scrollbar(
  2137.     GuiScrollbar    *sb,
  2138.     int     flag)
  2139. {
  2140.     ShowScrollBar(sb->id, SB_CTL, flag);
  2141. }
  2143.     void
  2144. gui_mch_set_scrollbar_thumb(
  2145.     GuiScrollbar    *sb,
  2146.     int     val,
  2147.     int     size,
  2148.     int     max)
  2149. {
  2150.     SCROLLINFO info;
  2152.     scroll_shift = 0;
  2153.     while (max > 32767)
  2154.     {
  2155. max = max + 1 >> 1;
  2156. val  >>= 1;
  2157. size >>= 1;
  2158. ++scroll_shift;
  2159.     }
  2161.     if (scroll_shift > 0)
  2162. ++size;
  2164.     info.cbSize = sizeof(info);
  2165.     info.fMask = SIF_POS | SIF_RANGE | SIF_PAGE;
  2166.     info.nPos = val;
  2167.     info.nMin = 0;
  2168.     info.nMax = max;
  2169.     info.nPage = size;
  2170.     SetScrollInfo(sb->id, SB_CTL, &info, TRUE);
  2171. }
  2173.     void
  2174. gui_mch_set_scrollbar_pos(
  2175.     GuiScrollbar    *sb,
  2176.     int     x,
  2177.     int     y,
  2178.     int     w,
  2179.     int     h)
  2180. {
  2181.     SetWindowPos(sb->id, NULL, x, y, w, h, SWP_NOZORDER | SWP_NOACTIVATE | SWP_SHOWWINDOW);
  2182. }
  2184.     void
  2185. gui_mch_create_scrollbar(
  2186.     GuiScrollbar    *sb,
  2187.     int     orient) /* SBAR_VERT or SBAR_HORIZ */
  2188. {
  2189.     sb->id = CreateWindow(
  2190. "SCROLLBAR", "Scrollbar",
  2191. WS_CHILD | ((orient == SBAR_VERT) ? SBS_VERT : SBS_HORZ), 0, 0,
  2192. 10, /* Any value will do for now */
  2193. 10, /* Any value will do for now */
  2194. s_hwnd, NULL,
  2195. s_hinst, NULL);
  2196. }
  2198.     void
  2199. gui_mch_destroy_scrollbar(GuiScrollbar *sb)
  2200. {
  2201.     DestroyWindow(sb->id);
  2202. }
  2204. /*
  2205.  * Get the character size of a font, by measuring the size of four characters.
  2206.  */
  2207.     static void
  2208. GetFontSize(GuiFont font)
  2209. {
  2210.     HWND    hwnd = GetDesktopWindow();
  2211.     HDC     hdc = GetWindowDC(hwnd);
  2212.     HFONT   hfntOld = SelectFont(hdc, (HFONT)font);
  2213.     TEXTMETRIC tm;
  2214.     /*
  2215.     static const char ach[] = {'W', 'f', 'g', 'M'};
  2216.     SIZE    siz;
  2218.     GetTextExtentPoint(hdc, ach, sizeof(ach), &siz);
  2219.     */
  2221.     GetTextMetrics(hdc, &tm);
  2222.     gui.char_width = tm.tmAveCharWidth + tm.tmOverhang;
  2224.     /*
  2225.      * Make characters one pixel higher, so that italic and bold fonts don't
  2226.      * draw off the bottom of their character space.  Also means that we can
  2227.      * underline an underscore for normal text.
  2228.      */
  2229.     gui.char_height = tm.tmHeight+1; /*siz.cy + 1;*/
  2231.     /* TRACE("GetFontSize: h %d, w %dn", gui.char_height, gui.char_width); */
  2233.     SelectFont(hdc, hfntOld);
  2235.     ReleaseDC(hwnd, hdc);
  2236. }
  2238.     static GuiFont
  2239. get_font_handle(LOGFONT *lf)
  2240. {
  2241.     HFONT   *font = NULL;
  2243.     /* Load the font */
  2244.     font = CreateFontIndirect(lf);
  2246.     if (font == NULL)
  2247. return (GuiFont)0;
  2249.     return (GuiFont)font;
  2250. }
  2252. /* Convert a string representing a point size into pixels. The string should
  2253.  * be a positive decimal number, with an optional decimal point (eg, "12", or
  2254.  * "10.5"). The pixel value is returned, and a pointer to the next unconverted
  2255.  * character is stored in *end. The flag "vertical" says whether this
  2256.  * calculation is for a vertical (height) size or a horizontal (width) one.
  2257.  */
  2258.     static int
  2259. points_to_pixels(char_u *str, char_u **end, int vertical)
  2260. {
  2261.     int pixels;
  2262.     int points = 0;
  2263.     int divisor = 0;
  2264.     HWND hwnd;
  2265.     HDC hdc;
  2267.     while (*str)
  2268.     {
  2269. if (*str == '.' && divisor == 0)
  2270. {
  2271.     /* Start keeping a divisor, for later */
  2272.     divisor = 1;
  2273.     continue;
  2274. }
  2276. if (!isdigit(*str))
  2277.     break;
  2279. points *= 10;
  2280. points += *str - '0';
  2281. divisor *= 10;
  2283. ++str;
  2284.     }
  2286.     if (divisor == 0)
  2287. divisor = 1;
  2289.     hwnd = GetDesktopWindow();
  2290.     hdc = GetWindowDC(hwnd);
  2292.     pixels = MulDiv(points,
  2293.     GetDeviceCaps(hdc, vertical ? LOGPIXELSY : LOGPIXELSX),
  2294.     72 * divisor);
  2296.     ReleaseDC(hwnd, hdc);
  2298.     *end = str;
  2299.     return pixels;
  2300. }
  2302.     static int
  2303. pixels_to_points(int pixels, int vertical)
  2304. {
  2305.     int points;
  2306.     HWND hwnd;
  2307.     HDC hdc;
  2309.     hwnd = GetDesktopWindow();
  2310.     hdc = GetWindowDC(hwnd);
  2312.     points = MulDiv(pixels, 72,
  2313.     GetDeviceCaps(hdc, vertical ? LOGPIXELSY : LOGPIXELSX));
  2315.     ReleaseDC(hwnd, hdc);
  2317.     return points;
  2318. }
  2320.     static int CALLBACK
  2321. font_enumproc(
  2322.     ENUMLOGFONT     *elf,
  2323.     NEWTEXTMETRIC   *ntm,
  2324.     int     type,
  2325.     LPARAM     lparam)
  2326. {
  2327.     /* Return value:
  2328.      *   0 = terminate now (monospace & ANSI)
  2329.      *   1 = continue, still no luck...
  2330.      *   2 = continue, but we have an acceptable LOGFONT
  2331.      *       (monospace, not ANSI)
  2332.      * We use these values, as EnumFontFamilies returns 1 if the
  2333.      * callback function is never called. So, we check the return as
  2334.      * 0 = perfect, 2 = OK, 1 = no good...
  2335.      * It's not pretty, but it works!
  2336.      */
  2338.     LOGFONT *lf = (LOGFONT *)(lparam);
  2340.     /* Ignore non-monospace fonts without further ado */
  2341.     if ((ntm->tmPitchAndFamily & 1) != 0)
  2342. return 1;
  2344.     /* Remember this LOGFONT as a "possible" */
  2345.     *lf = elf->elfLogFont;
  2347.     /* Terminate the scan as soon as we find an ANSI font */
  2348.     if (lf->lfCharSet == ANSI_CHARSET
  2349.     || lf->lfCharSet == OEM_CHARSET
  2350.     || lf->lfCharSet == DEFAULT_CHARSET)
  2351. return 0;
  2353.     /* Continue the scan - we have a non-ANSI font */
  2354.     return 2;
  2355. }
  2357.     static int
  2358. init_logfont(LOGFONT *lf)
  2359. {
  2360.     int n;
  2361.     HWND hwnd = GetDesktopWindow();
  2362.     HDC hdc = GetWindowDC(hwnd);
  2364.     n = EnumFontFamilies(hdc,
  2365.  lf->lfFaceName,
  2366.  (FONTENUMPROC)font_enumproc,
  2367.  (LPARAM)(lf));
  2369.     ReleaseDC(hwnd, hdc);
  2371.     /* If we couldn't find a useable font, return failure */
  2372.     if (n == 1)
  2373. return FAIL;
  2375.     /* Tidy up the rest of the LOGFONT structure. We set to a basic
  2376.      * font - get_logfont() sets bold, italic, etc based on the user's
  2377.      * input.
  2378.      */
  2379.     lf->lfHeight = current_font_height;
  2380.     lf->lfWidth = 0;
  2381.     lf->lfItalic = FALSE;
  2382.     lf->lfUnderline = FALSE;
  2383.     lf->lfStrikeOut = FALSE;
  2384.     lf->lfWeight = FW_NORMAL;
  2386.     /* Return success */
  2387.     return OK;
  2388. }
  2390.     static int
  2391. get_logfont(
  2392.     LOGFONT *lf,
  2393.     char_u  *name)
  2394. {
  2395.     char_u *p;
  2396.     CHOOSEFONT cf;
  2397.     int i;
  2398.     static LOGFONT *lastlf = NULL;
  2400.     *lf = s_lfDefault;
  2401.     if (name == NULL)
  2402. return 1;
  2404.     if (STRCMP(name, "*") == 0)
  2405.     {
  2406. /* ron: if name is "*", bring up std font dialog: */
  2407. memset(&cf, 0, sizeof(cf));
  2408. cf.lStructSize = sizeof(cf);
  2409. cf.hwndOwner = s_hwnd;
  2410. cf.Flags = CF_SCREENFONTS | CF_FIXEDPITCHONLY | CF_INITTOLOGFONTSTRUCT;
  2411. if (lastlf != NULL)
  2412.     *lf = *lastlf;
  2413. cf.lpLogFont = lf;
  2414. cf.nFontType = 0 ; //REGULAR_FONTTYPE;
  2415. if (ChooseFont(&cf))
  2416.     goto theend;
  2417.     }
  2419.     /*
  2420.      * Split name up, it could be <name>:h<height>:w<width> etc.
  2421.      */
  2422.     for (p = name; *p && *p != ':'; p++)
  2423.     {
  2424. if (p - name + 1 > LF_FACESIZE)
  2425.     return 0; /* Name too long */
  2426. lf->lfFaceName[p - name] = *p;
  2427.     }
  2428.     if (p != name)
  2429. lf->lfFaceName[p - name] = NUL;
  2431.     /* First set defaults */
  2432.     lf->lfHeight = -12;
  2433.     lf->lfWidth = 0;
  2434.     lf->lfWeight = FW_NORMAL;
  2435.     lf->lfItalic = FALSE;
  2436.     lf->lfUnderline = FALSE;
  2437.     lf->lfStrikeOut = FALSE;
  2439.     /*
  2440.      * If the font can't be found, try replacing '_' by ' '.
  2441.      */
  2442.     if (init_logfont(lf) == FAIL)
  2443.     {
  2444. int did_replace = FALSE;
  2446. for (i = 0; lf->lfFaceName[i]; ++i)
  2447.     if (lf->lfFaceName[i] == '_')
  2448.     {
  2449. lf->lfFaceName[i] = ' ';
  2450. did_replace = TRUE;
  2451.     }
  2452. if (!did_replace || init_logfont(lf) == FAIL)
  2453.     return 0;
  2454.     }
  2456.     while (*p == ':')
  2457. p++;
  2459.     /* Set the values found after ':' */
  2460.     while (*p)
  2461.     {
  2462. switch (*p++)
  2463. {
  2464.     case 'h':
  2465. lf->lfHeight = - points_to_pixels(p, &p, TRUE);
  2466. break;
  2467.     case 'w':
  2468. lf->lfWidth = points_to_pixels(p, &p, FALSE);
  2469. break;
  2470.     case 'b':
  2471. lf->lfWeight = FW_BOLD;
  2472. break;
  2473.     case 'i':
  2474. lf->lfItalic = TRUE;
  2475. break;
  2476.     case 'u':
  2477. lf->lfUnderline = TRUE;
  2478. break;
  2479.     case 's':
  2480. lf->lfStrikeOut = TRUE;
  2481. break;
  2482.     default:
  2483. sprintf((char *)IObuff,
  2484. "Illegal char '%c' in font name "%s"",
  2485. p[-1], name);
  2486. EMSG(IObuff);
  2487. break;
  2488. }
  2489. while (*p == ':')
  2490.     p++;
  2491.     }
  2493. theend:
  2494.     /* ron: init lastlf */
  2495.     vim_free(lastlf);
  2496.     lastlf = (LOGFONT *)alloc(sizeof(LOGFONT));
  2497.     if (lastlf != NULL)
  2498. mch_memmove(lastlf, lf, sizeof(LOGFONT));
  2500.     return 1;
  2501. }
  2503. /*
  2504.  * Initialise vim to use the font with the given name. Return FAIL if the font
  2505.  * could not be loaded, OK otherwise.
  2506.  */
  2507.     int
  2508. gui_mch_init_font(char_u *font_name)
  2509. {
  2510.     LOGFONT lf;
  2511.     GuiFont font = (GuiFont)0;
  2512.     char *p;
  2515.     /* Load the font */
  2516.     if (get_logfont(&lf, font_name))
  2517. font = get_font_handle(&lf);
  2518.     if (font == (GuiFont)0)
  2519. return FAIL;
  2520.     if (font_name == NULL)
  2521. font_name = lf.lfFaceName;
  2522.     gui_mch_free_font(gui.norm_font);
  2523.     gui.norm_font = font;
  2524.     current_font_height = lf.lfHeight;
  2525.     GetFontSize(font);
  2526.     hl_set_font_name(lf.lfFaceName);
  2527.     if (STRCMP(font_name, "*") == 0)
  2528.     {
  2529. p = alloc((unsigned)(strlen(lf.lfFaceName) + 10));
  2530. if (p != NULL)
  2531. {
  2532.     /* make a normal font string out of the lf thing:*/
  2533.     sprintf(p, "%s:h%d", lf.lfFaceName, pixels_to_points(
  2534.  lf.lfHeight < 0 ? -lf.lfHeight : lf.lfHeight, TRUE));
  2535.     vim_free(p_guifont);
  2536.     p_guifont = p;
  2537.     while (*p)
  2538.     {
  2539. if (*p == ' ')
  2540.     *p = '_';
  2541. ++p;
  2542.     }
  2543. }
  2544.     }
  2546.     if (!lf.lfItalic)
  2547.     {
  2548. lf.lfItalic = TRUE;
  2549. gui.ital_font = get_font_handle(&lf);
  2550. lf.lfItalic = FALSE;
  2551.     }
  2552.     if (lf.lfWeight < FW_BOLD)
  2553.     {
  2554. lf.lfWeight = FW_BOLD;
  2555. gui.bold_font = get_font_handle(&lf);
  2556. if (!lf.lfItalic)
  2557. {
  2558.     lf.lfItalic = TRUE;
  2559.     gui.boldital_font = get_font_handle(&lf);
  2560. }
  2561.     }
  2563.     return OK;
  2564. }
  2566.     GuiFont
  2567. gui_mch_get_font(
  2568.     char_u *name,
  2569.     int giveErrorIfMissing)
  2570. {
  2571.     LOGFONT lf;
  2572.     GuiFont font;
  2574.     get_logfont(&lf, name);
  2575.     font = get_font_handle(&lf);
  2576.     if (font == (GuiFont)0 && giveErrorIfMissing)
  2577. EMSG2("Unknown font: %s", name);
  2578.     return font;
  2579. }
  2581. /*
  2582.  * Set the current text font.
  2583.  */
  2584.     void
  2585. gui_mch_set_font(GuiFont font)
  2586. {
  2587.     gui.currFont = font;
  2588. }
  2590. /*
  2591.  * Return TRUE if the two fonts given are equivalent.
  2592.  */
  2593.     int
  2594. gui_mch_same_font(
  2595.     GuiFont f1,
  2596.     GuiFont f2)
  2597. {
  2598.     return f1 == f2;
  2599. }
  2601.     void
  2602. gui_mch_free_font(GuiFont font)
  2603. {
  2604.     if (font)
  2605. DeleteObject((HFONT)font);
  2606. }
  2608.     static int
  2609. hex_digit(int c)
  2610. {
  2611.     if (vim_isdigit(c))
  2612. return c - '0';
  2613.     c = TO_LOWER(c);
  2614.     if (c >= 'a' && c <= 'f')
  2615. return c - 'a' + 10;
  2616.     return -1000;
  2617. }
  2619. /*
  2620.  * Return the Pixel value (color) for the given color name.
  2621.  * Return -1 for error.
  2622.  */
  2623.     GuiColor
  2624. gui_mch_get_color(char_u *name)
  2625. {
  2626.     typedef struct GuiColorTable
  2627.     {
  2628. char     *name;
  2629. COLORREF    color;
  2630.     } GuiColorTable;
  2632.     static GuiColorTable table[] =
  2633.     {
  2634. {"Black", RGB(0x00, 0x00, 0x00)},
  2635. {"DarkGray", RGB(0x80, 0x80, 0x80)},
  2636. {"DarkGrey", RGB(0x80, 0x80, 0x80)},
  2637. {"Gray", RGB(0xC0, 0xC0, 0xC0)},
  2638. {"Grey", RGB(0xC0, 0xC0, 0xC0)},
  2639. {"LightGray", RGB(0xE0, 0xE0, 0xE0)},
  2640. {"LightGrey", RGB(0xE0, 0xE0, 0xE0)},
  2641. {"White", RGB(0xFF, 0xFF, 0xFF)},
  2642. {"DarkRed", RGB(0x80, 0x00, 0x00)},
  2643. {"Red", RGB(0xFF, 0x00, 0x00)},
  2644. {"LightRed", RGB(0xFF, 0xA0, 0xA0)},
  2645. {"DarkBlue", RGB(0x00, 0x00, 0x80)},
  2646. {"Blue", RGB(0x00, 0x00, 0xFF)},
  2647. {"LightBlue", RGB(0xA0, 0xA0, 0xFF)},
  2648. {"DarkGreen", RGB(0x00, 0x80, 0x00)},
  2649. {"Green", RGB(0x00, 0xFF, 0x00)},
  2650. {"LightGreen", RGB(0xA0, 0xFF, 0xA0)},
  2651. {"DarkCyan", RGB(0x00, 0x80, 0x80)},
  2652. {"Cyan", RGB(0x00, 0xFF, 0xFF)},
  2653. {"LightCyan", RGB(0xA0, 0xFF, 0xFF)},
  2654. {"DarkMagenta", RGB(0x80, 0x00, 0x80)},
  2655. {"Magenta", RGB(0xFF, 0x00, 0xFF)},
  2656. {"LightMagenta", RGB(0xFF, 0xA0, 0xFF)},
  2657. {"Brown", RGB(0x80, 0x40, 0x40)},
  2658. {"Yellow", RGB(0xFF, 0xFF, 0x00)},
  2659. {"LightYellow", RGB(0xFF, 0xFF, 0xA0)},
  2660. {"SeaGreen", RGB(0x2E, 0x8B, 0x57)},
  2661. {"Orange", RGB(0xFF, 0xA5, 0x00)},
  2662. {"Purple", RGB(0xA0, 0x20, 0xF0)},
  2663. {"SlateBlue", RGB(0x6A, 0x5A, 0xCD)},
  2664. {"Violet", RGB(0xEE, 0x82, 0xEE)},
  2665.     };
  2667.     typedef struct SysColorTable
  2668.     {
  2669. char     *name;
  2670. int     color;
  2671.     } SysColorTable;
  2673.     static SysColorTable sys_table[] =
  2674.     {
  2675. "SYS_3DDKSHADOW", COLOR_3DDKSHADOW,
  2676. "SYS_3DFACE", COLOR_3DFACE,
  2677. "SYS_BTNFACE", COLOR_BTNFACE,
  2678. "SYS_3DHILIGHT", COLOR_3DHILIGHT,
  2679. "SYS_3DHIGHLIGHT", COLOR_3DHIGHLIGHT,
  2680. "SYS_BTNHILIGHT", COLOR_BTNHILIGHT,
  2681. "SYS_BTNHIGHLIGHT", COLOR_BTNHIGHLIGHT,
  2682. "SYS_3DLIGHT", COLOR_3DLIGHT,
  2683. "SYS_3DSHADOW", COLOR_3DSHADOW,
  2684. "SYS_BTNSHADOW", COLOR_BTNSHADOW,
  2685. "SYS_ACTIVEBORDER", COLOR_ACTIVEBORDER,
  2686. "SYS_ACTIVECAPTION", COLOR_ACTIVECAPTION,
  2687. "SYS_APPWORKSPACE", COLOR_APPWORKSPACE,
  2688. "SYS_BACKGROUND", COLOR_BACKGROUND,
  2689. "SYS_DESKTOP", COLOR_DESKTOP,
  2690. "SYS_BTNTEXT", COLOR_BTNTEXT,
  2691. "SYS_CAPTIONTEXT", COLOR_CAPTIONTEXT,
  2692. "SYS_GRAYTEXT", COLOR_GRAYTEXT,
  2693. "SYS_HIGHLIGHT", COLOR_HIGHLIGHT,
  2694. "SYS_HIGHLIGHTTEXT", COLOR_HIGHLIGHTTEXT,
  2695. "SYS_INACTIVEBORDER", COLOR_INACTIVEBORDER,
  2696. "SYS_INACTIVECAPTION", COLOR_INACTIVECAPTION,
  2697. "SYS_INACTIVECAPTIONTEXT", COLOR_INACTIVECAPTIONTEXT,
  2698. "SYS_INFOBK", COLOR_INFOBK,
  2699. "SYS_INFOTEXT", COLOR_INFOTEXT,
  2700. "SYS_MENU", COLOR_MENU,
  2701. "SYS_MENUTEXT", COLOR_MENUTEXT,
  2702. "SYS_SCROLLBAR", COLOR_SCROLLBAR,
  2703. "SYS_WINDOW", COLOR_WINDOW,
  2704. "SYS_WINDOWFRAME", COLOR_WINDOWFRAME,
  2705. "SYS_WINDOWTEXT", COLOR_WINDOWTEXT,
  2706.     };
  2708.     int     r, g, b;
  2709.     int     i;
  2711.     if (name[0] == '#' && strlen(name) == 7)
  2712.     {
  2713. /* Name is in "#rrggbb" format */
  2714. r = hex_digit(name[1]) * 16 + hex_digit(name[2]);
  2715. g = hex_digit(name[3]) * 16 + hex_digit(name[4]);
  2716. b = hex_digit(name[5]) * 16 + hex_digit(name[6]);
  2717. if (r < 0 || g < 0 || b < 0)
  2718.     return (GuiColor)-1;
  2719. return RGB(r, g, b);
  2720.     }
  2721.     else
  2722.     {
  2723. /* Check if the name is one of the colors we know */
  2724. for (i = 0; i < sizeof(table) / sizeof(table[0]); i++)
  2725.     if (STRICMP(name, table[i].name) == 0)
  2726. return table[i].color;
  2727.     }
  2729.     /*
  2730.      * Try to look up a system colour.
  2731.      */
  2732.     for (i = 0; i < sizeof(sys_table) / sizeof(sys_table[0]); i++)
  2733. if (STRICMP(name, sys_table[i].name) == 0)
  2734.     return GetSysColor(sys_table[i].color);
  2736.     /*
  2737.      * Last attempt. Look in the file "$VIM/rgb.txt".
  2738.      */
  2739.     {
  2740. #define LINE_LEN 100