?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge branch 'master' of git://repo.or.cz/MacVim into KaoriYa
[MacVim/KaoriYa.git] / src / gui_w32.c
blobb92b3615f666ed9af4f3a64454bf5897195955cf
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 * See README.txt for an overview of the Vim source code.
9 */
10 /*
11 * Windows GUI.
12 *
13 * GUI support for Microsoft Windows. Win32 initially; maybe Win16 later
14 *
15 * George V. Reilly <george@reilly.org> wrote the original Win32 GUI.
16 * Robert Webb reworked it to use the existing GUI stuff and added menu,
17 * scrollbars, etc.
18 *
19 * Note: Clipboard stuff, for cutting and pasting text to other windows, is in
20 * os_win32.c. (It can also be done from the terminal version).
21 *
22 * TODO: Some of the function signatures ought to be updated for Win64;
23 * e.g., replace LONG with LONG_PTR, etc.
24 */
25
26 #include "vim.h"
27
28 /*
29 * These are new in Windows ME/XP, only defined in recent compilers.
30 */
31 #ifndef HANDLE_WM_XBUTTONUP
32 # define HANDLE_WM_XBUTTONUP(hwnd, wParam, lParam, fn) \
33 ((fn)((hwnd), (int)(short)LOWORD(lParam), (int)(short)HIWORD(lParam), (UINT)(wParam)), 0L)
34 #endif
35 #ifndef HANDLE_WM_XBUTTONDOWN
36 # define HANDLE_WM_XBUTTONDOWN(hwnd, wParam, lParam, fn) \
37 ((fn)((hwnd), FALSE, (int)(short)LOWORD(lParam), (int)(short)HIWORD(lParam), (UINT)(wParam)), 0L)
38 #endif
39 #ifndef HANDLE_WM_XBUTTONDBLCLK
40 # define HANDLE_WM_XBUTTONDBLCLK(hwnd, wParam, lParam, fn) \
41 ((fn)((hwnd), TRUE, (int)(short)LOWORD(lParam), (int)(short)HIWORD(lParam), (UINT)(wParam)), 0L)
42 #endif
43
44 /*
45 * Include the common stuff for MS-Windows GUI.
46 */
47 #include "gui_w48.c"
48
49 #ifdef FEAT_XPM_W32
50 # include "xpm_w32.h"
51 #endif
52
53 #ifdef PROTO
54 # define WINAPI
55 #endif
56
57 #ifdef __MINGW32__
58 /*
59 * Add a lot of missing defines.
60 * They are not always missing, we need the #ifndef's.
61 */
62 # ifndef _cdecl
63 # define _cdecl
64 # endif
65 # ifndef IsMinimized
66 # define IsMinimized(hwnd) IsIconic(hwnd)
67 # endif
68 # ifndef IsMaximized
69 # define IsMaximized(hwnd) IsZoomed(hwnd)
70 # endif
71 # ifndef SelectFont
72 # define SelectFont(hdc, hfont) ((HFONT)SelectObject((hdc), (HGDIOBJ)(HFONT)(hfont)))
73 # endif
74 # ifndef GetStockBrush
75 # define GetStockBrush(i) ((HBRUSH)GetStockObject(i))
76 # endif
77 # ifndef DeleteBrush
78 # define DeleteBrush(hbr) DeleteObject((HGDIOBJ)(HBRUSH)(hbr))
79 # endif
80
81 # ifndef HANDLE_WM_RBUTTONDBLCLK
82 # define HANDLE_WM_RBUTTONDBLCLK(hwnd, wParam, lParam, fn) \
83 ((fn)((hwnd), TRUE, (int)(short)LOWORD(lParam), (int)(short)HIWORD(lParam), (UINT)(wParam)), 0L)
84 # endif
85 # ifndef HANDLE_WM_MBUTTONUP
86 # define HANDLE_WM_MBUTTONUP(hwnd, wParam, lParam, fn) \
87 ((fn)((hwnd), (int)(short)LOWORD(lParam), (int)(short)HIWORD(lParam), (UINT)(wParam)), 0L)
88 # endif
89 # ifndef HANDLE_WM_MBUTTONDBLCLK
90 # define HANDLE_WM_MBUTTONDBLCLK(hwnd, wParam, lParam, fn) \
91 ((fn)((hwnd), TRUE, (int)(short)LOWORD(lParam), (int)(short)HIWORD(lParam), (UINT)(wParam)), 0L)
92 # endif
93 # ifndef HANDLE_WM_LBUTTONDBLCLK
94 # define HANDLE_WM_LBUTTONDBLCLK(hwnd, wParam, lParam, fn) \
95 ((fn)((hwnd), TRUE, (int)(short)LOWORD(lParam), (int)(short)HIWORD(lParam), (UINT)(wParam)), 0L)
96 # endif
97 # ifndef HANDLE_WM_RBUTTONDOWN
98 # define HANDLE_WM_RBUTTONDOWN(hwnd, wParam, lParam, fn) \
99 ((fn)((hwnd), FALSE, (int)(short)LOWORD(lParam), (int)(short)HIWORD(lParam), (UINT)(wParam)), 0L)
100 # endif
101 # ifndef HANDLE_WM_MOUSEMOVE
102 # define HANDLE_WM_MOUSEMOVE(hwnd, wParam, lParam, fn) \
103 ((fn)((hwnd), (int)(short)LOWORD(lParam), (int)(short)HIWORD(lParam), (UINT)(wParam)), 0L)
104 # endif
105 # ifndef HANDLE_WM_RBUTTONUP
106 # define HANDLE_WM_RBUTTONUP(hwnd, wParam, lParam, fn) \
107 ((fn)((hwnd), (int)(short)LOWORD(lParam), (int)(short)HIWORD(lParam), (UINT)(wParam)), 0L)
108 # endif
109 # ifndef HANDLE_WM_MBUTTONDOWN
110 # define HANDLE_WM_MBUTTONDOWN(hwnd, wParam, lParam, fn) \
111 ((fn)((hwnd), FALSE, (int)(short)LOWORD(lParam), (int)(short)HIWORD(lParam), (UINT)(wParam)), 0L)
112 # endif
113 # ifndef HANDLE_WM_LBUTTONUP
114 # define HANDLE_WM_LBUTTONUP(hwnd, wParam, lParam, fn) \
115 ((fn)((hwnd), (int)(short)LOWORD(lParam), (int)(short)HIWORD(lParam), (UINT)(wParam)), 0L)
116 # endif
117 # ifndef HANDLE_WM_LBUTTONDOWN
118 # define HANDLE_WM_LBUTTONDOWN(hwnd, wParam, lParam, fn) \
119 ((fn)((hwnd), FALSE, (int)(short)LOWORD(lParam), (int)(short)HIWORD(lParam), (UINT)(wParam)), 0L)
120 # endif
121 # ifndef HANDLE_WM_SYSCHAR
122 # define HANDLE_WM_SYSCHAR(hwnd, wParam, lParam, fn) \
123 ((fn)((hwnd), (TCHAR)(wParam), (int)(short)LOWORD(lParam)), 0L)
124 # endif
125 # ifndef HANDLE_WM_ACTIVATEAPP
126 # define HANDLE_WM_ACTIVATEAPP(hwnd, wParam, lParam, fn) \
127 ((fn)((hwnd), (BOOL)(wParam), (DWORD)(lParam)), 0L)
128 # endif
129 # ifndef HANDLE_WM_WINDOWPOSCHANGING
130 # define HANDLE_WM_WINDOWPOSCHANGING(hwnd, wParam, lParam, fn) \
131 (LRESULT)(DWORD)(BOOL)(fn)((hwnd), (LPWINDOWPOS)(lParam))
132 # endif
133 # ifndef HANDLE_WM_VSCROLL
134 # define HANDLE_WM_VSCROLL(hwnd, wParam, lParam, fn) \
135 ((fn)((hwnd), (HWND)(lParam), (UINT)(LOWORD(wParam)), (int)(short)HIWORD(wParam)), 0L)
136 # endif
137 # ifndef HANDLE_WM_SETFOCUS
138 # define HANDLE_WM_SETFOCUS(hwnd, wParam, lParam, fn) \
139 ((fn)((hwnd), (HWND)(wParam)), 0L)
140 # endif
141 # ifndef HANDLE_WM_KILLFOCUS
142 # define HANDLE_WM_KILLFOCUS(hwnd, wParam, lParam, fn) \
143 ((fn)((hwnd), (HWND)(wParam)), 0L)
144 # endif
145 # ifndef HANDLE_WM_HSCROLL
146 # define HANDLE_WM_HSCROLL(hwnd, wParam, lParam, fn) \
147 ((fn)((hwnd), (HWND)(lParam), (UINT)(LOWORD(wParam)), (int)(short)HIWORD(wParam)), 0L)
148 # endif
149 # ifndef HANDLE_WM_DROPFILES
150 # define HANDLE_WM_DROPFILES(hwnd, wParam, lParam, fn) \
151 ((fn)((hwnd), (HDROP)(wParam)), 0L)
152 # endif
153 # ifndef HANDLE_WM_CHAR
154 # define HANDLE_WM_CHAR(hwnd, wParam, lParam, fn) \
155 ((fn)((hwnd), (TCHAR)(wParam), (int)(short)LOWORD(lParam)), 0L)
156 # endif
157 # ifndef HANDLE_WM_SYSDEADCHAR
158 # define HANDLE_WM_SYSDEADCHAR(hwnd, wParam, lParam, fn) \
159 ((fn)((hwnd), (TCHAR)(wParam), (int)(short)LOWORD(lParam)), 0L)
160 # endif
161 # ifndef HANDLE_WM_DEADCHAR
162 # define HANDLE_WM_DEADCHAR(hwnd, wParam, lParam, fn) \
163 ((fn)((hwnd), (TCHAR)(wParam), (int)(short)LOWORD(lParam)), 0L)
164 # endif
165 #endif /* __MINGW32__ */
166
167
168 /* Some parameters for tearoff menus. All in pixels. */
169 #define TEAROFF_PADDING_X 2
170 #define TEAROFF_BUTTON_PAD_X 8
171 #define TEAROFF_MIN_WIDTH 200
172 #define TEAROFF_SUBMENU_LABEL ">>"
173 #define TEAROFF_COLUMN_PADDING 3 // # spaces to pad column with.
174
175
176 /* For the Intellimouse: */
177 #ifndef WM_MOUSEWHEEL
178 #define WM_MOUSEWHEEL 0x20a
179 #endif
180
181
182 #ifdef FEAT_BEVAL
183 # define ID_BEVAL_TOOLTIP 200
184 # define BEVAL_TEXT_LEN MAXPATHL
185
186 #if _MSC_VER < 1300
187 /* Work around old versions of basetsd.h which wrongly declares
188 * UINT_PTR as unsigned long. */
189 # define UINT_PTR UINT
190 #endif
191
192 static void make_tooltip __ARGS((BalloonEval *beval, char *text, POINT pt));
193 static void delete_tooltip __ARGS((BalloonEval *beval));
194 static VOID CALLBACK BevalTimerProc __ARGS((HWND hwnd, UINT uMsg, UINT_PTR idEvent, DWORD dwTime));
195
196 static BalloonEval *cur_beval = NULL;
197 static UINT_PTR BevalTimerId = 0;
198 static DWORD LastActivity = 0;
199
200 /*
201 * excerpts from headers since this may not be presented
202 * in the extremely old compilers
203 */
204 #include <pshpack1.h>
205
206 typedef struct _DllVersionInfo
207 {
208 DWORD cbSize;
209 DWORD dwMajorVersion;
210 DWORD dwMinorVersion;
211 DWORD dwBuildNumber;
212 DWORD dwPlatformID;
213 } DLLVERSIONINFO;
214
215 typedef struct tagTOOLINFOA_NEW
216 {
217 UINT cbSize;
218 UINT uFlags;
219 HWND hwnd;
220 UINT uId;
221 RECT rect;
222 HINSTANCE hinst;
223 LPSTR lpszText;
224 LPARAM lParam;
225 } TOOLINFO_NEW;
226
227 typedef struct tagNMTTDISPINFO_NEW
228 {
229 NMHDR hdr;
230 LPTSTR lpszText;
231 char szText[80];
232 HINSTANCE hinst;
233 UINT uFlags;
234 LPARAM lParam;
235 } NMTTDISPINFO_NEW;
236
237 #include <poppack.h>
238
239 typedef HRESULT (WINAPI* DLLGETVERSIONPROC)(DLLVERSIONINFO *);
240 #ifndef TTM_SETMAXTIPWIDTH
241 # define TTM_SETMAXTIPWIDTH (WM_USER+24)
242 #endif
243
244 #ifndef TTF_DI_SETITEM
245 # define TTF_DI_SETITEM 0x8000
246 #endif
247
248 #ifndef TTN_GETDISPINFO
249 # define TTN_GETDISPINFO (TTN_FIRST - 0)
250 #endif
251
252 #endif /* defined(FEAT_BEVAL) */
253
254 #if defined(FEAT_TOOLBAR) || defined(FEAT_GUI_TABLINE)
255 /* Older MSVC compilers don't have LPNMTTDISPINFO[AW] thus we need to define
256 * it here if LPNMTTDISPINFO isn't defined.
257 * MingW doesn't define LPNMTTDISPINFO but typedefs it. Thus we need to check
258 * _MSC_VER. */
259 # if !defined(LPNMTTDISPINFO) && defined(_MSC_VER)
260 typedef struct tagNMTTDISPINFOA {
261 NMHDR hdr;
262 LPSTR lpszText;
263 char szText[80];
264 HINSTANCE hinst;
265 UINT uFlags;
266 LPARAM lParam;
267 } NMTTDISPINFOA, *LPNMTTDISPINFOA;
268 # define LPNMTTDISPINFO LPNMTTDISPINFOA
269
270 # ifdef FEAT_MBYTE
271 typedef struct tagNMTTDISPINFOW {
272 NMHDR hdr;
273 LPWSTR lpszText;
274 WCHAR szText[80];
275 HINSTANCE hinst;
276 UINT uFlags;
277 LPARAM lParam;
278 } NMTTDISPINFOW, *LPNMTTDISPINFOW;
279 # endif
280 # endif
281 #endif
282
283 #ifndef TTN_GETDISPINFOW
284 # define TTN_GETDISPINFOW (TTN_FIRST - 10)
285 #endif
286
287 /* Local variables: */
288
289 #ifdef FEAT_MENU
290 static UINT s_menu_id = 100;
291
292 /*
293 * Use the system font for dialogs and tear-off menus. Remove this line to
294 * use DLG_FONT_NAME.
295 */
296 # define USE_SYSMENU_FONT
297 #endif
298
299 #define VIM_NAME "vim"
300 #define VIM_CLASS "Vim"
301 #define VIM_CLASSW L"Vim"
302
303 /* Initial size for the dialog template. For gui_mch_dialog() it's fixed,
304 * thus there should be room for every dialog. For tearoffs it's made bigger
305 * when needed. */
306 #define DLG_ALLOC_SIZE 16 * 1024
307
308 /*
309 * stuff for dialogs, menus, tearoffs etc.
310 */
311 static LRESULT APIENTRY dialog_callback(HWND, UINT, WPARAM, LPARAM);
312 static LRESULT APIENTRY tearoff_callback(HWND, UINT, WPARAM, LPARAM);
313 static PWORD
314 add_dialog_element(
315 PWORD p,
316 DWORD lStyle,
317 WORD x,
318 WORD y,
319 WORD w,
320 WORD h,
321 WORD Id,
322 WORD clss,
323 const char *caption);
324 static LPWORD lpwAlign(LPWORD);
325 static int nCopyAnsiToWideChar(LPWORD, LPSTR);
326 static void gui_mch_tearoff(char_u *title, vimmenu_T *menu, int initX, int initY);
327 static void get_dialog_font_metrics(void);
328
329 static int dialog_default_button = -1;
330
331 /* Intellimouse support */
332 static int mouse_scroll_lines = 0;
333 static UINT msh_msgmousewheel = 0;
334
335 static int s_usenewlook; /* emulate W95/NT4 non-bold dialogs */
336 #ifdef FEAT_TOOLBAR
337 static void initialise_toolbar(void);
338 static int get_toolbar_bitmap(vimmenu_T *menu);
339 #endif
340
341 #ifdef FEAT_GUI_TABLINE
342 static void initialise_tabline(void);
343 #endif
344
345 #ifdef FEAT_MBYTE_IME
346 static LRESULT _OnImeComposition(HWND hwnd, WPARAM dbcs, LPARAM param);
347 static char_u *GetResultStr(HWND hwnd, int GCS, int *lenp);
348 #endif
349 #if defined(FEAT_MBYTE_IME) && defined(DYNAMIC_IME)
350 # ifdef NOIME
351 typedef struct tagCOMPOSITIONFORM {
352 DWORD dwStyle;
353 POINT ptCurrentPos;
354 RECT rcArea;
355 } COMPOSITIONFORM, *PCOMPOSITIONFORM, NEAR *NPCOMPOSITIONFORM, FAR *LPCOMPOSITIONFORM;
356 typedef HANDLE HIMC;
357 # endif
358
359 static HINSTANCE hLibImm = NULL;
360 static LONG (WINAPI *pImmGetCompositionStringA)(HIMC, DWORD, LPVOID, DWORD);
361 static LONG (WINAPI *pImmGetCompositionStringW)(HIMC, DWORD, LPVOID, DWORD);
362 static HIMC (WINAPI *pImmGetContext)(HWND);
363 static HIMC (WINAPI *pImmAssociateContext)(HWND, HIMC);
364 static BOOL (WINAPI *pImmReleaseContext)(HWND, HIMC);
365 static BOOL (WINAPI *pImmGetOpenStatus)(HIMC);
366 static BOOL (WINAPI *pImmSetOpenStatus)(HIMC, BOOL);
367 static BOOL (WINAPI *pImmGetCompositionFont)(HIMC, LPLOGFONTA);
368 static BOOL (WINAPI *pImmSetCompositionFont)(HIMC, LPLOGFONTA);
369 static BOOL (WINAPI *pImmSetCompositionWindow)(HIMC, LPCOMPOSITIONFORM);
370 static BOOL (WINAPI *pImmGetConversionStatus)(HIMC, LPDWORD, LPDWORD);
371 static BOOL (WINAPI *pImmSetConversionStatus)(HIMC, DWORD, DWORD);
372 static void dyn_imm_load(void);
373 #else
374 # define pImmGetCompositionStringA ImmGetCompositionStringA
375 # define pImmGetCompositionStringW ImmGetCompositionStringW
376 # define pImmGetContext ImmGetContext
377 # define pImmAssociateContext ImmAssociateContext
378 # define pImmReleaseContext ImmReleaseContext
379 # define pImmGetOpenStatus ImmGetOpenStatus
380 # define pImmSetOpenStatus ImmSetOpenStatus
381 # define pImmGetCompositionFont ImmGetCompositionFontA
382 # define pImmSetCompositionFont ImmSetCompositionFontA
383 # define pImmSetCompositionWindow ImmSetCompositionWindow
384 # define pImmGetConversionStatus ImmGetConversionStatus
385 # define pImmSetConversionStatus ImmSetConversionStatus
386 #endif
387
388 #ifndef ETO_IGNORELANGUAGE
389 # define ETO_IGNORELANGUAGE 0x1000
390 #endif
391
392 /* multi monitor support */
393 typedef struct _MONITORINFOstruct
394 {
395 DWORD cbSize;
396 RECT rcMonitor;
397 RECT rcWork;
398 DWORD dwFlags;
399 } _MONITORINFO;
400
401 typedef HANDLE _HMONITOR;
402 typedef _HMONITOR (WINAPI *TMonitorFromWindow)(HWND, DWORD);
403 typedef BOOL (WINAPI *TGetMonitorInfo)(_HMONITOR, _MONITORINFO *);
404
405 static TMonitorFromWindow pMonitorFromWindow = NULL;
406 static TGetMonitorInfo pGetMonitorInfo = NULL;
407 static HANDLE user32_lib = NULL;
408 #ifdef FEAT_NETBEANS_INTG
409 int WSInitialized = FALSE; /* WinSock is initialized */
410 #endif
411 /*
412 * Return TRUE when running under Windows NT 3.x or Win32s, both of which have
413 * less fancy GUI APIs.
414 */
415 static int
416 is_winnt_3(void)
417 {
418 return ((os_version.dwPlatformId == VER_PLATFORM_WIN32_NT
419 && os_version.dwMajorVersion == 3)
420 || (os_version.dwPlatformId == VER_PLATFORM_WIN32s));
421 }
422
423 /*
424 * Return TRUE when running under Win32s.
425 */
426 int
427 gui_is_win32s(void)
428 {
429 return (os_version.dwPlatformId == VER_PLATFORM_WIN32s);
430 }
431
432 static int
433 get_caption_height(void)
434 {
435 /*
436 * A window's caption includes extra 1 dot margin. When caption is
437 * removed the margin also be removed. So we must return -1 when
438 * caption is diabled.
439 */
440 return GetWindowLong(s_hwnd, GWL_STYLE) & WS_CAPTION ?
441 GetSystemMetrics(SM_CYCAPTION) : -1;
442 }
443
444 void
445 gui_mch_show_caption(int show)
446 {
447 LONG style, newstyle;
448
449 /* Remove caption when title is null. */
450 style = newstyle = GetWindowLong(s_hwnd, GWL_STYLE);
451 if (show && !(style & WS_CAPTION))
452 newstyle = style | WS_CAPTION;
453 else if (!show && (style & WS_CAPTION))
454 newstyle = style & ~WS_CAPTION;
455 if (newstyle != style)
456 {
457 SetWindowLong(s_hwnd, GWL_STYLE, newstyle);
458 SetWindowPos(s_hwnd, NULL, 0, 0, 0, 0,
459 SWP_FRAMECHANGED | SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER);
460 gui_set_shellsize(FALSE, FALSE, RESIZE_BOTH);
461 }
462 }
463
464 #ifdef FEAT_MENU
465 /*
466 * Figure out how high the menu bar is at the moment.
467 */
468 static int
469 gui_mswin_get_menu_height(
470 int fix_window) /* If TRUE, resize window if menu height changed */
471 {
472 static int old_menu_height = -1;
473
474 RECT rc1, rc2;
475 int num;
476 int menu_height;
477
478 if (gui.menu_is_active)
479 num = GetMenuItemCount(s_menuBar);
480 else
481 num = 0;
482
483 if (num == 0)
484 menu_height = 0;
485 else
486 {
487 if (is_winnt_3()) /* for NT 3.xx */
488 {
489 if (gui.starting)
490 menu_height = GetSystemMetrics(SM_CYMENU);
491 else
492 {
493 RECT r1, r2;
494 int frameht = GetSystemMetrics(SM_CYFRAME);
495 int capht = get_caption_height();
496
497 /* get window rect of s_hwnd
498 * get client rect of s_hwnd
499 * get cap height
500 * subtract from window rect, the sum of client height,
501 * (if not maximized)frame thickness, and caption height.
502 */
503 GetWindowRect(s_hwnd, &r1);
504 GetClientRect(s_hwnd, &r2);
505 menu_height = r1.bottom - r1.top - (r2.bottom - r2.top
506 + 2 * frameht * (!IsZoomed(s_hwnd)) + capht);
507 }
508 }
509 else /* win95 and variants (NT 4.0, I guess) */
510 {
511 /*
512 * In case 'lines' is set in _vimrc/_gvimrc window width doesn't
513 * seem to have been set yet, so menu wraps in default window
514 * width which is very narrow. Instead just return height of a
515 * single menu item. Will still be wrong when the menu really
516 * should wrap over more than one line.
517 */
518 GetMenuItemRect(s_hwnd, s_menuBar, 0, &rc1);
519 if (gui.starting)
520 menu_height = rc1.bottom - rc1.top + 1;
521 else
522 {
523 GetMenuItemRect(s_hwnd, s_menuBar, num - 1, &rc2);
524 menu_height = rc2.bottom - rc1.top + 1;
525 }
526 }
527 }
528
529 if (fix_window && menu_height != old_menu_height)
530 {
531 old_menu_height = menu_height;
532 gui_set_shellsize(FALSE, FALSE, RESIZE_VERT);
533 }
534
535 return menu_height;
536 }
537 #endif /*FEAT_MENU*/
538
539
540 /*
541 * Setup for the Intellimouse
542 */
543 static void
544 init_mouse_wheel(void)
545 {
546
547 #ifndef SPI_GETWHEELSCROLLLINES
548 # define SPI_GETWHEELSCROLLLINES 104
549 #endif
550 #ifndef SPI_SETWHEELSCROLLLINES
551 # define SPI_SETWHEELSCROLLLINES 105
552 #endif
553
554 #define VMOUSEZ_CLASSNAME "MouseZ" /* hidden wheel window class */
555 #define VMOUSEZ_TITLE "Magellan MSWHEEL" /* hidden wheel window title */
556 #define VMSH_MOUSEWHEEL "MSWHEEL_ROLLMSG"
557 #define VMSH_SCROLL_LINES "MSH_SCROLL_LINES_MSG"
558
559 HWND hdl_mswheel;
560 UINT msh_msgscrolllines;
561
562 msh_msgmousewheel = 0;
563 mouse_scroll_lines = 3; /* reasonable default */
564
565 if ((os_version.dwPlatformId == VER_PLATFORM_WIN32_NT
566 && os_version.dwMajorVersion >= 4)
567 || (os_version.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS
568 && ((os_version.dwMajorVersion == 4
569 && os_version.dwMinorVersion >= 10)
570 || os_version.dwMajorVersion >= 5)))
571 {
572 /* if NT 4.0+ (or Win98) get scroll lines directly from system */
573 SystemParametersInfo(SPI_GETWHEELSCROLLLINES, 0,
574 &mouse_scroll_lines, 0);
575 }
576 else if (os_version.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS
577 || (os_version.dwPlatformId == VER_PLATFORM_WIN32_NT
578 && os_version.dwMajorVersion < 4))
579 { /*
580 * If Win95 or NT 3.51,
581 * try to find the hidden point32 window.
582 */
583 hdl_mswheel = FindWindow(VMOUSEZ_CLASSNAME, VMOUSEZ_TITLE);
584 if (hdl_mswheel)
585 {
586 msh_msgscrolllines = RegisterWindowMessage(VMSH_SCROLL_LINES);
587 if (msh_msgscrolllines)
588 {
589 mouse_scroll_lines = (int)SendMessage(hdl_mswheel,
590 msh_msgscrolllines, 0, 0);
591 msh_msgmousewheel = RegisterWindowMessage(VMSH_MOUSEWHEEL);
592 }
593 }
594 }
595 }
596
597
598 /* Intellimouse wheel handler */
599 static void
600 _OnMouseWheel(
601 HWND hwnd,
602 short zDelta)
603 {
604 /* Treat a mouse wheel event as if it were a scroll request */
605 int i;
606 int size;
607 HWND hwndCtl;
608
609 if (curwin->w_scrollbars[SBAR_RIGHT].id != 0)
610 {
611 hwndCtl = curwin->w_scrollbars[SBAR_RIGHT].id;
612 size = curwin->w_scrollbars[SBAR_RIGHT].size;
613 }
614 else if (curwin->w_scrollbars[SBAR_LEFT].id != 0)
615 {
616 hwndCtl = curwin->w_scrollbars[SBAR_LEFT].id;
617 size = curwin->w_scrollbars[SBAR_LEFT].size;
618 }
619 else
620 return;
621
622 size = curwin->w_height;
623 if (mouse_scroll_lines == 0)
624 init_mouse_wheel();
625
626 if (mouse_scroll_lines > 0
627 && mouse_scroll_lines < (size > 2 ? size - 2 : 1))
628 {
629 for (i = mouse_scroll_lines; i > 0; --i)
630 _OnScroll(hwnd, hwndCtl, zDelta >= 0 ? SB_LINEUP : SB_LINEDOWN, 0);
631 }
632 else
633 _OnScroll(hwnd, hwndCtl, zDelta >= 0 ? SB_PAGEUP : SB_PAGEDOWN, 0);
634 }
635
636 #ifdef USE_SYSMENU_FONT
637 /*
638 * Get Menu Font.
639 * Return OK or FAIL.
640 */
641 static int
642 gui_w32_get_menu_font(LOGFONT *lf)
643 {
644 NONCLIENTMETRICS nm;
645
646 nm.cbSize = sizeof(NONCLIENTMETRICS);
647 if (!SystemParametersInfo(
648 SPI_GETNONCLIENTMETRICS,
649 sizeof(NONCLIENTMETRICS),
650 &nm,
651 0))
652 return FAIL;
653 *lf = nm.lfMenuFont;
654 return OK;
655 }
656 #endif
657
658
659 #if defined(FEAT_GUI_TABLINE) && defined(USE_SYSMENU_FONT)
660 /*
661 * Set the GUI tabline font to the system menu font
662 */
663 static void
664 set_tabline_font(void)
665 {
666 LOGFONT lfSysmenu;
667 HFONT font;
668 HWND hwnd;
669 HDC hdc;
670 HFONT hfntOld;
671 TEXTMETRIC tm;
672
673 if (gui_w32_get_menu_font(&lfSysmenu) != OK)
674 return;
675
676 font = CreateFontIndirect(&lfSysmenu);
677
678 SendMessage(s_tabhwnd, WM_SETFONT, (WPARAM)font, TRUE);
679
680 /*
681 * Compute the height of the font used for the tab text
682 */
683 hwnd = GetDesktopWindow();
684 hdc = GetWindowDC(hwnd);
685 hfntOld = SelectFont(hdc, font);
686
687 GetTextMetrics(hdc, &tm);
688
689 SelectFont(hdc, hfntOld);
690 ReleaseDC(hwnd, hdc);
691
692 /*
693 * The space used by the tab border and the space between the tab label
694 * and the tab border is included as 7.
695 */
696 gui.tabline_height = tm.tmHeight + tm.tmInternalLeading + 7;
697 }
698 #endif
699
700 /*
701 * Invoked when a setting was changed.
702 */
703 static LRESULT CALLBACK
704 _OnSettingChange(UINT n)
705 {
706 if (n == SPI_SETWHEELSCROLLLINES)
707 SystemParametersInfo(SPI_GETWHEELSCROLLLINES, 0,
708 &mouse_scroll_lines, 0);
709 #if defined(FEAT_GUI_TABLINE) && defined(USE_SYSMENU_FONT)
710 if (n == SPI_SETNONCLIENTMETRICS)
711 set_tabline_font();
712 #endif
713 return 0;
714 }
715
716 #if 0 /* disabled, a gap appears below and beside the window, and the window
717 can be moved (in a strange way) */
718 /*
719 * Even though we have _DuringSizing() which makes the rubber band a valid
720 * size, we need this for when the user maximises the window.
721 * TODO: Doesn't seem to adjust the width though for some reason.
722 */
723 static BOOL
724 _OnWindowPosChanging(
725 HWND hwnd,
726 LPWINDOWPOS lpwpos)
727 {
728 RECT workarea_rect;
729
730 if (!(lpwpos->flags & SWP_NOSIZE))
731 {
732 if (IsMaximized(hwnd)
733 && (os_version.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS
734 || (os_version.dwPlatformId == VER_PLATFORM_WIN32_NT
735 && os_version.dwMajorVersion >= 4)))
736 {
737 SystemParametersInfo(SPI_GETWORKAREA, 0, &workarea_rect, 0);
738 lpwpos->x = workarea_rect.left;
739 lpwpos->y = workarea_rect.top;
740 lpwpos->cx = workarea_rect.right - workarea_rect.left;
741 lpwpos->cy = workarea_rect.bottom - workarea_rect.top;
742 }
743 gui_mswin_get_valid_dimensions(lpwpos->cx, lpwpos->cy,
744 &lpwpos->cx, &lpwpos->cy);
745 }
746 return 0;
747 }
748 #endif
749
750 #ifdef FEAT_NETBEANS_INTG
751 static void
752 _OnWindowPosChanged(
753 HWND hwnd,
754 const LPWINDOWPOS lpwpos)
755 {
756 static int x = 0, y = 0, cx = 0, cy = 0;
757
758 if (WSInitialized && (lpwpos->x != x || lpwpos->y != y
759 || lpwpos->cx != cx || lpwpos->cy != cy))
760 {
761 x = lpwpos->x;
762 y = lpwpos->y;
763 cx = lpwpos->cx;
764 cy = lpwpos->cy;
765 netbeans_frame_moved(x, y);
766 }
767 /* Allow to send WM_SIZE and WM_MOVE */
768 FORWARD_WM_WINDOWPOSCHANGED(hwnd, lpwpos, MyWindowProc);
769 }
770 #endif
771
772 static int
773 _DuringSizing(
774 UINT fwSide,
775 LPRECT lprc)
776 {
777 int w, h;
778 int valid_w, valid_h;
779 int w_offset, h_offset;
780
781 w = lprc->right - lprc->left;
782 h = lprc->bottom - lprc->top;
783 gui_mswin_get_valid_dimensions(w, h, &valid_w, &valid_h);
784 w_offset = w - valid_w;
785 h_offset = h - valid_h;
786
787 if (fwSide == WMSZ_LEFT || fwSide == WMSZ_TOPLEFT
788 || fwSide == WMSZ_BOTTOMLEFT)
789 lprc->left += w_offset;
790 else if (fwSide == WMSZ_RIGHT || fwSide == WMSZ_TOPRIGHT
791 || fwSide == WMSZ_BOTTOMRIGHT)
792 lprc->right -= w_offset;
793
794 if (fwSide == WMSZ_TOP || fwSide == WMSZ_TOPLEFT
795 || fwSide == WMSZ_TOPRIGHT)
796 lprc->top += h_offset;
797 else if (fwSide == WMSZ_BOTTOM || fwSide == WMSZ_BOTTOMLEFT
798 || fwSide == WMSZ_BOTTOMRIGHT)
799 lprc->bottom -= h_offset;
800 return TRUE;
801 }
802
803
804
805 static LRESULT CALLBACK
806 _WndProc(
807 HWND hwnd,
808 UINT uMsg,
809 WPARAM wParam,
810 LPARAM lParam)
811 {
812 /*
813 TRACE("WndProc: hwnd = %08x, msg = %x, wParam = %x, lParam = %x\n",
814 hwnd, uMsg, wParam, lParam);
815 */
816
817 HandleMouseHide(uMsg, lParam);
818
819 s_uMsg = uMsg;
820 s_wParam = wParam;
821 s_lParam = lParam;
822
823 switch (uMsg)
824 {
825 HANDLE_MSG(hwnd, WM_DEADCHAR, _OnDeadChar);
826 HANDLE_MSG(hwnd, WM_SYSDEADCHAR, _OnDeadChar);
827 /* HANDLE_MSG(hwnd, WM_ACTIVATE, _OnActivate); */
828 HANDLE_MSG(hwnd, WM_CLOSE, _OnClose);
829 /* HANDLE_MSG(hwnd, WM_COMMAND, _OnCommand); */
830 HANDLE_MSG(hwnd, WM_DESTROY, _OnDestroy);
831 HANDLE_MSG(hwnd, WM_DROPFILES, _OnDropFiles);
832 HANDLE_MSG(hwnd, WM_HSCROLL, _OnScroll);
833 HANDLE_MSG(hwnd, WM_KILLFOCUS, _OnKillFocus);
834 #ifdef FEAT_MENU
835 HANDLE_MSG(hwnd, WM_COMMAND, _OnMenu);
836 #endif
837 /* HANDLE_MSG(hwnd, WM_MOVE, _OnMove); */
838 /* HANDLE_MSG(hwnd, WM_NCACTIVATE, _OnNCActivate); */
839 HANDLE_MSG(hwnd, WM_SETFOCUS, _OnSetFocus);
840 HANDLE_MSG(hwnd, WM_SIZE, _OnSize);
841 /* HANDLE_MSG(hwnd, WM_SYSCOMMAND, _OnSysCommand); */
842 /* HANDLE_MSG(hwnd, WM_SYSKEYDOWN, _OnAltKey); */
843 HANDLE_MSG(hwnd, WM_VSCROLL, _OnScroll);
844 // HANDLE_MSG(hwnd, WM_WINDOWPOSCHANGING, _OnWindowPosChanging);
845 HANDLE_MSG(hwnd, WM_ACTIVATEAPP, _OnActivateApp);
846 #ifdef FEAT_NETBEANS_INTG
847 HANDLE_MSG(hwnd, WM_WINDOWPOSCHANGED, _OnWindowPosChanged);
848 #endif
849
850 #ifdef FEAT_GUI_TABLINE
851 case WM_RBUTTONUP:
852 {
853 if (gui_mch_showing_tabline())
854 {
855 POINT pt;
856 RECT rect;
857
858 /*
859 * If the cursor is on the tabline, display the tab menu
860 */
861 GetCursorPos((LPPOINT)&pt);
862 GetWindowRect(s_textArea, &rect);
863 if (pt.y < rect.top)
864 {
865 show_tabline_popup_menu();
866 return 0;
867 }
868 }
869 return MyWindowProc(hwnd, uMsg, wParam, lParam);
870 }
871 case WM_LBUTTONDBLCLK:
872 {
873 /*
874 * If the user double clicked the tabline, create a new tab
875 */
876 if (gui_mch_showing_tabline())
877 {
878 POINT pt;
879 RECT rect;
880
881 GetCursorPos((LPPOINT)&pt);
882 GetWindowRect(s_textArea, &rect);
883 if (pt.y < rect.top)
884 send_tabline_menu_event(0, TABLINE_MENU_NEW);
885 }
886 return MyWindowProc(hwnd, uMsg, wParam, lParam);
887 }
888 #endif
889
890 case WM_QUERYENDSESSION: /* System wants to go down. */
891 gui_shell_closed(); /* Will exit when no changed buffers. */
892 return FALSE; /* Do NOT allow system to go down. */
893
894 case WM_ENDSESSION:
895 if (wParam) /* system only really goes down when wParam is TRUE */
896 _OnEndSession();
897 break;
898
899 case WM_CHAR:
900 /* Don't use HANDLE_MSG() for WM_CHAR, it truncates wParam to a single
901 * byte while we want the UTF-16 character value. */
902 _OnChar(hwnd, (UINT)wParam, (int)(short)LOWORD(lParam));
903 return 0L;
904
905 case WM_SYSCHAR:
906 /*
907 * if 'winaltkeys' is "no", or it's "menu" and it's not a menu
908 * shortcut key, handle like a typed ALT key, otherwise call Windows
909 * ALT key handling.
910 */
911 #ifdef FEAT_MENU
912 if ( !gui.menu_is_active
913 || p_wak[0] == 'n'
914 || (p_wak[0] == 'm' && !gui_is_menu_shortcut((int)wParam))
915 )
916 #endif
917 {
918 _OnSysChar(hwnd, (UINT)wParam, (int)(short)LOWORD(lParam));
919 return 0L;
920 }
921 #ifdef FEAT_MENU
922 else
923 return MyWindowProc(hwnd, uMsg, wParam, lParam);
924 #endif
925
926 case WM_SYSKEYUP:
927 #ifdef FEAT_MENU
928 /* This used to be done only when menu is active: ALT key is used for
929 * that. But that caused problems when menu is disabled and using
930 * Alt-Tab-Esc: get into a strange state where no mouse-moved events
931 * are received, mouse pointer remains hidden. */
932 return MyWindowProc(hwnd, uMsg, wParam, lParam);
933 #else
934 return 0;
935 #endif
936
937 case WM_SIZING: /* HANDLE_MSG doesn't seem to handle this one */
938 return _DuringSizing((UINT)wParam, (LPRECT)lParam);
939
940 case WM_MOUSEWHEEL:
941 _OnMouseWheel(hwnd, HIWORD(wParam));
942 break;
943
944 /* Notification for change in SystemParametersInfo() */
945 case WM_SETTINGCHANGE:
946 return _OnSettingChange((UINT)wParam);
947
948 #if defined(FEAT_TOOLBAR) || defined(FEAT_GUI_TABLINE)
949 case WM_NOTIFY:
950 switch (((LPNMHDR) lParam)->code)
951 {
952 # ifdef FEAT_MBYTE
953 case TTN_GETDISPINFOW:
954 # endif
955 case TTN_GETDISPINFO:
956 {
957 LPNMHDR hdr = (LPNMHDR)lParam;
958 char_u *str = NULL;
959 static void *tt_text = NULL;
960
961 vim_free(tt_text);
962 tt_text = NULL;
963
964 # ifdef FEAT_GUI_TABLINE
965 if (gui_mch_showing_tabline()
966 && hdr->hwndFrom == TabCtrl_GetToolTips(s_tabhwnd))
967 {
968 POINT pt;
969 /*
970 * Mouse is over the GUI tabline. Display the
971 * tooltip for the tab under the cursor
972 *
973 * Get the cursor position within the tab control
974 */
975 GetCursorPos(&pt);
976 if (ScreenToClient(s_tabhwnd, &pt) != 0)
977 {
978 TCHITTESTINFO htinfo;
979 int idx;
980
981 /*
982 * Get the tab under the cursor
983 */
984 htinfo.pt.x = pt.x;
985 htinfo.pt.y = pt.y;
986 idx = TabCtrl_HitTest(s_tabhwnd, &htinfo);
987 if (idx != -1)
988 {
989 tabpage_T *tp;
990
991 tp = find_tabpage(idx + 1);
992 if (tp != NULL)
993 {
994 get_tabline_label(tp, TRUE);
995 str = NameBuff;
996 }
997 }
998 }
999 }
1000 # endif
1001 # ifdef FEAT_TOOLBAR
1002 # ifdef FEAT_GUI_TABLINE
1003 else
1004 # endif
1005 {
1006 UINT idButton;
1007 vimmenu_T *pMenu;
1008
1009 idButton = (UINT) hdr->idFrom;
1010 pMenu = gui_mswin_find_menu(root_menu, idButton);
1011 if (pMenu)
1012 str = pMenu->strings[MENU_INDEX_TIP];
1013 }
1014 # endif
1015 if (str != NULL)
1016 {
1017 # ifdef FEAT_MBYTE
1018 if (hdr->code == TTN_GETDISPINFOW)
1019 {
1020 LPNMTTDISPINFOW lpdi = (LPNMTTDISPINFOW)lParam;
1021
1022 /* Set the maximum width, this also enables using
1023 * \n for line break. */
1024 SendMessage(lpdi->hdr.hwndFrom, TTM_SETMAXTIPWIDTH,
1025 0, 500);
1026
1027 tt_text = enc_to_utf16(str, NULL);
1028 lpdi->lpszText = tt_text;
1029 /* can't show tooltip if failed */
1030 }
1031 else
1032 # endif
1033 {
1034 LPNMTTDISPINFO lpdi = (LPNMTTDISPINFO)lParam;
1035
1036 /* Set the maximum width, this also enables using
1037 * \n for line break. */
1038 SendMessage(lpdi->hdr.hwndFrom, TTM_SETMAXTIPWIDTH,
1039 0, 500);
1040
1041 if (STRLEN(str) < sizeof(lpdi->szText)
1042 || ((tt_text = vim_strsave(str)) == NULL))
1043 vim_strncpy(lpdi->szText, str,
1044 sizeof(lpdi->szText) - 1);
1045 else
1046 lpdi->lpszText = tt_text;
1047 }
1048 }
1049 }
1050 break;
1051 # ifdef FEAT_GUI_TABLINE
1052 case TCN_SELCHANGE:
1053 if (gui_mch_showing_tabline()
1054 && ((LPNMHDR)lParam)->hwndFrom == s_tabhwnd)
1055 send_tabline_event(TabCtrl_GetCurSel(s_tabhwnd) + 1);
1056 break;
1057
1058 case NM_RCLICK:
1059 if (gui_mch_showing_tabline()
1060 && ((LPNMHDR)lParam)->hwndFrom == s_tabhwnd)
1061 show_tabline_popup_menu();
1062 break;
1063 # endif
1064 default:
1065 # ifdef FEAT_GUI_TABLINE
1066 if (gui_mch_showing_tabline()
1067 && ((LPNMHDR)lParam)->hwndFrom == s_tabhwnd)
1068 return MyWindowProc(hwnd, uMsg, wParam, lParam);
1069 # endif
1070 break;
1071 }
1072 break;
1073 #endif
1074 #if defined(MENUHINTS) && defined(FEAT_MENU)
1075 case WM_MENUSELECT:
1076 if (((UINT) HIWORD(wParam)
1077 & (0xffff ^ (MF_MOUSESELECT + MF_BITMAP + MF_POPUP)))
1078 == MF_HILITE
1079 && (State & CMDLINE) == 0)
1080 {
1081 UINT idButton;
1082 vimmenu_T *pMenu;
1083 static int did_menu_tip = FALSE;
1084
1085 if (did_menu_tip)
1086 {
1087 msg_clr_cmdline();
1088 setcursor();
1089 out_flush();
1090 did_menu_tip = FALSE;
1091 }
1092
1093 idButton = (UINT)LOWORD(wParam);
1094 pMenu = gui_mswin_find_menu(root_menu, idButton);
1095 if (pMenu != NULL && pMenu->strings[MENU_INDEX_TIP] != 0
1096 && GetMenuState(s_menuBar, pMenu->id, MF_BYCOMMAND) != -1)
1097 {
1098 ++msg_hist_off;
1099 msg(pMenu->strings[MENU_INDEX_TIP]);
1100 --msg_hist_off;
1101 setcursor();
1102 out_flush();
1103 did_menu_tip = TRUE;
1104 }
1105 }
1106 break;
1107 #endif
1108 case WM_NCHITTEST:
1109 {
1110 LRESULT result;
1111 int x, y;
1112 int xPos = GET_X_LPARAM(lParam);
1113
1114 result = MyWindowProc(hwnd, uMsg, wParam, lParam);
1115 if (result == HTCLIENT)
1116 {
1117 #ifdef FEAT_GUI_TABLINE
1118 if (gui_mch_showing_tabline())
1119 {
1120 int yPos = GET_Y_LPARAM(lParam);
1121 RECT rct;
1122
1123 /* If the cursor is on the GUI tabline, don't process this
1124 * event */
1125 GetWindowRect(s_textArea, &rct);
1126 if (yPos < rct.top)
1127 return result;
1128 }
1129 #endif
1130 gui_mch_get_winpos(&x, &y);
1131 xPos -= x;
1132
1133 if (xPos < 48) /* <VN> TODO should use system metric? */
1134 return HTBOTTOMLEFT;
1135 else
1136 return HTBOTTOMRIGHT;
1137 }
1138 else
1139 return result;
1140 }
1141 /* break; notreached */
1142
1143 #ifdef FEAT_MBYTE_IME
1144 case WM_IME_NOTIFY:
1145 if (!_OnImeNotify(hwnd, (DWORD)wParam, (DWORD)lParam))
1146 return MyWindowProc(hwnd, uMsg, wParam, lParam);
1147 break;
1148 case WM_IME_COMPOSITION:
1149 if (!_OnImeComposition(hwnd, wParam, lParam))
1150 return MyWindowProc(hwnd, uMsg, wParam, lParam);
1151 break;
1152 #endif
1153
1154 default:
1155 if (uMsg == msh_msgmousewheel && msh_msgmousewheel != 0)
1156 { /* handle MSH_MOUSEWHEEL messages for Intellimouse */
1157 _OnMouseWheel(hwnd, HIWORD(wParam));
1158 break;
1159 }
1160 #ifdef MSWIN_FIND_REPLACE
1161 else if (uMsg == s_findrep_msg && s_findrep_msg != 0)
1162 {
1163 _OnFindRepl();
1164 }
1165 #endif
1166 return MyWindowProc(hwnd, uMsg, wParam, lParam);
1167 }
1168
1169 return 1;
1170 }
1171
1172 /*
1173 * End of call-back routines
1174 */
1175
1176 /* parent window, if specified with -P */
1177 HWND vim_parent_hwnd = NULL;
1178
1179 static BOOL CALLBACK
1180 FindWindowTitle(HWND hwnd, LPARAM lParam)
1181 {
1182 char buf[2048];
1183 char *title = (char *)lParam;
1184
1185 if (GetWindowText(hwnd, buf, sizeof(buf)))
1186 {
1187 if (strstr(buf, title) != NULL)
1188 {
1189 /* Found it. Store the window ref. and quit searching if MDI
1190 * works. */
1191 vim_parent_hwnd = FindWindowEx(hwnd, NULL, "MDIClient", NULL);
1192 if (vim_parent_hwnd != NULL)
1193 return FALSE;
1194 }
1195 }
1196 return TRUE; /* continue searching */
1197 }
1198
1199 /*
1200 * Invoked for '-P "title"' argument: search for parent application to open
1201 * our window in.
1202 */
1203 void
1204 gui_mch_set_parent(char *title)
1205 {
1206 EnumWindows(FindWindowTitle, (LPARAM)title);
1207 if (vim_parent_hwnd == NULL)
1208 {
1209 EMSG2(_("E671: Cannot find window title \"%s\""), title);
1210 mch_exit(2);
1211 }
1212 }
1213
1214 #ifndef FEAT_OLE
1215 static void
1216 ole_error(char *arg)
1217 {
1218 char buf[IOSIZE];
1219
1220 /* Can't use EMSG() here, we have not finished initialisation yet. */
1221 vim_snprintf(buf, IOSIZE,
1222 _("E243: Argument not supported: \"-%s\"; Use the OLE version."),
1223 arg);
1224 mch_errmsg(buf);
1225 }
1226 #endif
1227
1228 /*
1229 * Parse the GUI related command-line arguments. Any arguments used are
1230 * deleted from argv, and *argc is decremented accordingly. This is called
1231 * when vim is started, whether or not the GUI has been started.
1232 */
1233 void
1234 gui_mch_prepare(int *argc, char **argv)
1235 {
1236 int silent = FALSE;
1237 int idx;
1238
1239 /* Check for special OLE command line parameters */
1240 if ((*argc == 2 || *argc == 3) && (argv[1][0] == '-' || argv[1][0] == '/'))
1241 {
1242 /* Check for a "-silent" argument first. */
1243 if (*argc == 3 && STRICMP(argv[1] + 1, "silent") == 0
1244 && (argv[2][0] == '-' || argv[2][0] == '/'))
1245 {
1246 silent = TRUE;
1247 idx = 2;
1248 }
1249 else
1250 idx = 1;
1251
1252 /* Register Vim as an OLE Automation server */
1253 if (STRICMP(argv[idx] + 1, "register") == 0)
1254 {
1255 #ifdef FEAT_OLE
1256 RegisterMe(silent);
1257 mch_exit(0);
1258 #else
1259 if (!silent)
1260 ole_error("register");
1261 mch_exit(2);
1262 #endif
1263 }
1264
1265 /* Unregister Vim as an OLE Automation server */
1266 if (STRICMP(argv[idx] + 1, "unregister") == 0)
1267 {
1268 #ifdef FEAT_OLE
1269 UnregisterMe(!silent);
1270 mch_exit(0);
1271 #else
1272 if (!silent)
1273 ole_error("unregister");
1274 mch_exit(2);
1275 #endif
1276 }
1277
1278 /* Ignore an -embedding argument. It is only relevant if the
1279 * application wants to treat the case when it is started manually
1280 * differently from the case where it is started via automation (and
1281 * we don't).
1282 */
1283 if (STRICMP(argv[idx] + 1, "embedding") == 0)
1284 {
1285 #ifdef FEAT_OLE
1286 *argc = 1;
1287 #else
1288 ole_error("embedding");
1289 mch_exit(2);
1290 #endif
1291 }
1292 }
1293
1294 #ifdef FEAT_OLE
1295 {
1296 int bDoRestart = FALSE;
1297
1298 InitOLE(&bDoRestart);
1299 /* automatically exit after registering */
1300 if (bDoRestart)
1301 mch_exit(0);
1302 }
1303 #endif
1304
1305 #ifdef FEAT_NETBEANS_INTG
1306 {
1307 /* stolen from gui_x11.x */
1308 int arg;
1309
1310 for (arg = 1; arg < *argc; arg++)
1311 if (strncmp("-nb", argv[arg], 3) == 0)
1312 {
1313 usingNetbeans++;
1314 netbeansArg = argv[arg];
1315 mch_memmove(&argv[arg], &argv[arg + 1],
1316 (--*argc - arg) * sizeof(char *));
1317 argv[*argc] = NULL;
1318 break; /* enough? */
1319 }
1320
1321 if (usingNetbeans)
1322 {
1323 WSADATA wsaData;
1324 int wsaerr;
1325
1326 /* Init WinSock */
1327 wsaerr = WSAStartup(MAKEWORD(2, 2), &wsaData);
1328 if (wsaerr == 0)
1329 WSInitialized = TRUE;
1330 }
1331 }
1332 #endif
1333
1334 /* get the OS version info */
1335 os_version.dwOSVersionInfoSize = sizeof(os_version);
1336 GetVersionEx(&os_version); /* this call works on Win32s, Win95 and WinNT */
1337
1338 /* try and load the user32.dll library and get the entry points for
1339 * multi-monitor-support. */
1340 if ((user32_lib = LoadLibrary("User32.dll")) != NULL)
1341 {
1342 pMonitorFromWindow = (TMonitorFromWindow)GetProcAddress(user32_lib,
1343 "MonitorFromWindow");
1344
1345 /* there are ...A and ...W version of GetMonitorInfo - looking at
1346 * winuser.h, they have exactly the same declaration. */
1347 pGetMonitorInfo = (TGetMonitorInfo)GetProcAddress(user32_lib,
1348 "GetMonitorInfoA");
1349 }
1350 }
1351
1352 /*
1353 * Initialise the GUI. Create all the windows, set up all the call-backs
1354 * etc.
1355 */
1356 int
1357 gui_mch_init(void)
1358 {
1359 const char szVimWndClass[] = VIM_CLASS;
1360 const char szTextAreaClass[] = "VimTextArea";
1361 WNDCLASS wndclass;
1362 #ifdef FEAT_MBYTE
1363 const WCHAR szVimWndClassW[] = VIM_CLASSW;
1364 WNDCLASSW wndclassw;
1365 #endif
1366 #ifdef GLOBAL_IME
1367 ATOM atom;
1368 #endif
1369
1370 /* Return here if the window was already opened (happens when
1371 * gui_mch_dialog() is called early). */
1372 if (s_hwnd != NULL)
1373 goto theend;
1374
1375 /*
1376 * Load the tearoff bitmap
1377 */
1378 #ifdef FEAT_TEAROFF
1379 s_htearbitmap = LoadBitmap(s_hinst, "IDB_TEAROFF");
1380 #endif
1381
1382 gui.scrollbar_width = GetSystemMetrics(SM_CXVSCROLL);
1383 gui.scrollbar_height = GetSystemMetrics(SM_CYHSCROLL);
1384 #ifdef FEAT_MENU
1385 gui.menu_height = 0; /* Windows takes care of this */
1386 #endif
1387 gui.border_width = 0;
1388
1389 s_brush = CreateSolidBrush(GetSysColor(COLOR_BTNFACE));
1390
1391 #ifdef FEAT_MBYTE
1392 /* First try using the wide version, so that we can use any title.
1393 * Otherwise only characters in the active codepage will work. */
1394 if (GetClassInfoW(s_hinst, szVimWndClassW, &wndclassw) == 0)
1395 {
1396 wndclassw.style = CS_DBLCLKS;
1397 wndclassw.lpfnWndProc = _WndProc;
1398 wndclassw.cbClsExtra = 0;
1399 wndclassw.cbWndExtra = 0;
1400 wndclassw.hInstance = s_hinst;
1401 wndclassw.hIcon = LoadIcon(wndclassw.hInstance, "IDR_VIM");
1402 wndclassw.hCursor = LoadCursor(NULL, IDC_ARROW);
1403 wndclassw.hbrBackground = s_brush;
1404 wndclassw.lpszMenuName = NULL;
1405 wndclassw.lpszClassName = szVimWndClassW;
1406
1407 if ((
1408 #ifdef GLOBAL_IME
1409 atom =
1410 #endif
1411 RegisterClassW(&wndclassw)) == 0)
1412 {
1413 if (GetLastError() != ERROR_CALL_NOT_IMPLEMENTED)
1414 return FAIL;
1415
1416 /* Must be Windows 98, fall back to non-wide function. */
1417 }
1418 else
1419 wide_WindowProc = TRUE;
1420 }
1421
1422 if (!wide_WindowProc)
1423 #endif
1424
1425 if (GetClassInfo(s_hinst, szVimWndClass, &wndclass) == 0)
1426 {
1427 wndclass.style = CS_DBLCLKS;
1428 wndclass.lpfnWndProc = _WndProc;
1429 wndclass.cbClsExtra = 0;
1430 wndclass.cbWndExtra = 0;
1431 wndclass.hInstance = s_hinst;
1432 wndclass.hIcon = LoadIcon(wndclass.hInstance, "IDR_VIM");
1433 wndclass.hCursor = LoadCursor(NULL, IDC_ARROW);
1434 wndclass.hbrBackground = s_brush;
1435 wndclass.lpszMenuName = NULL;
1436 wndclass.lpszClassName = szVimWndClass;
1437
1438 if ((
1439 #ifdef GLOBAL_IME
1440 atom =
1441 #endif
1442 RegisterClass(&wndclass)) == 0)
1443 return FAIL;
1444 }
1445
1446 if (vim_parent_hwnd != NULL)
1447 {
1448 #ifdef HAVE_TRY_EXCEPT
1449 __try
1450 {
1451 #endif
1452 /* Open inside the specified parent window.
1453 * TODO: last argument should point to a CLIENTCREATESTRUCT
1454 * structure. */
1455 s_hwnd = CreateWindowEx(
1456 WS_EX_MDICHILD,
1457 szVimWndClass, "Vim MSWindows GUI",
1458 WS_OVERLAPPEDWINDOW | WS_CHILD | WS_CLIPSIBLINGS | 0xC000,
1459 gui_win_x == -1 ? CW_USEDEFAULT : gui_win_x,
1460 gui_win_y == -1 ? CW_USEDEFAULT : gui_win_y,
1461 100, /* Any value will do */
1462 100, /* Any value will do */
1463 vim_parent_hwnd, NULL,
1464 s_hinst, NULL);
1465 #ifdef HAVE_TRY_EXCEPT
1466 }
1467 __except(EXCEPTION_EXECUTE_HANDLER)
1468 {
1469 /* NOP */
1470 }
1471 #endif
1472 if (s_hwnd == NULL)
1473 {
1474 EMSG(_("E672: Unable to open window inside MDI application"));
1475 mch_exit(2);
1476 }
1477 }
1478 else
1479 {
1480 /* If the provided windowid is not valid reset it to zero, so that it
1481 * is ignored and we open our own window. */
1482 if (IsWindow((HWND)win_socket_id) <= 0)
1483 win_socket_id = 0;
1484
1485 /* Create a window. If win_socket_id is not zero without border and
1486 * titlebar, it will be reparented below. */
1487 s_hwnd = CreateWindow(
1488 szVimWndClass, "Vim MSWindows GUI",
1489 win_socket_id == 0 ? WS_OVERLAPPEDWINDOW : WS_POPUP,
1490 gui_win_x == -1 ? CW_USEDEFAULT : gui_win_x,
1491 gui_win_y == -1 ? CW_USEDEFAULT : gui_win_y,
1492 100, /* Any value will do */
1493 100, /* Any value will do */
1494 NULL, NULL,
1495 s_hinst, NULL);
1496 if (s_hwnd != NULL && win_socket_id != 0)
1497 {
1498 SetParent(s_hwnd, (HWND)win_socket_id);
1499 ShowWindow(s_hwnd, SW_SHOWMAXIMIZED);
1500 }
1501 }
1502
1503 if (s_hwnd == NULL)
1504 return FAIL;
1505
1506 #ifdef GLOBAL_IME
1507 global_ime_init(atom, s_hwnd);
1508 #endif
1509 #if defined(FEAT_MBYTE_IME) && defined(DYNAMIC_IME)
1510 dyn_imm_load();
1511 #endif
1512
1513 /* Create the text area window */
1514 if (GetClassInfo(s_hinst, szTextAreaClass, &wndclass) == 0)
1515 {
1516 wndclass.style = CS_OWNDC;
1517 wndclass.lpfnWndProc = _TextAreaWndProc;
1518 wndclass.cbClsExtra = 0;
1519 wndclass.cbWndExtra = 0;
1520 wndclass.hInstance = s_hinst;
1521 wndclass.hIcon = NULL;
1522 wndclass.hCursor = LoadCursor(NULL, IDC_ARROW);
1523 wndclass.hbrBackground = NULL;
1524 wndclass.lpszMenuName = NULL;
1525 wndclass.lpszClassName = szTextAreaClass;
1526
1527 if (RegisterClass(&wndclass) == 0)
1528 return FAIL;
1529 }
1530 s_textArea = CreateWindowEx(
1531 WS_EX_CLIENTEDGE,
1532 szTextAreaClass, "Vim text area",
1533 WS_CHILD | WS_VISIBLE, 0, 0,
1534 100, /* Any value will do for now */
1535 100, /* Any value will do for now */
1536 s_hwnd, NULL,
1537 s_hinst, NULL);
1538
1539 if (s_textArea == NULL)
1540 return FAIL;
1541
1542 #ifdef FEAT_MENU
1543 s_menuBar = CreateMenu();
1544 #endif
1545 s_hdc = GetDC(s_textArea);
1546
1547 #ifdef MSWIN16_FASTTEXT
1548 SetBkMode(s_hdc, OPAQUE);
1549 #endif
1550
1551 #ifdef FEAT_WINDOWS
1552 DragAcceptFiles(s_hwnd, TRUE);
1553 #endif
1554
1555 /* Do we need to bother with this? */
1556 /* m_fMouseAvail = GetSystemMetrics(SM_MOUSEPRESENT); */
1557
1558 /* Get background/foreground colors from the system */
1559 gui_mch_def_colors();
1560
1561 /* Get the colors from the "Normal" group (set in syntax.c or in a vimrc
1562 * file) */
1563 set_normal_colors();
1564
1565 /*
1566 * Check that none of the colors are the same as the background color.
1567 * Then store the current values as the defaults.
1568 */
1569 gui_check_colors();
1570 gui.def_norm_pixel = gui.norm_pixel;
1571 gui.def_back_pixel = gui.back_pixel;
1572
1573 /* Get the colors for the highlight groups (gui_check_colors() might have
1574 * changed them) */
1575 highlight_gui_started();
1576
1577 /*
1578 * Start out by adding the configured border width into the border offset
1579 */
1580 gui.border_offset = gui.border_width + 2; /*CLIENT EDGE*/
1581
1582 /*
1583 * Set up for Intellimouse processing
1584 */
1585 init_mouse_wheel();
1586
1587 /*
1588 * compute a couple of metrics used for the dialogs
1589 */
1590 get_dialog_font_metrics();
1591 #ifdef FEAT_TOOLBAR
1592 /*
1593 * Create the toolbar
1594 */
1595 initialise_toolbar();
1596 #endif
1597 #ifdef FEAT_GUI_TABLINE
1598 /*
1599 * Create the tabline
1600 */
1601 initialise_tabline();
1602 #endif
1603 #ifdef MSWIN_FIND_REPLACE
1604 /*
1605 * Initialise the dialog box stuff
1606 */
1607 s_findrep_msg = RegisterWindowMessage(FINDMSGSTRING);
1608
1609 /* Initialise the struct */
1610 s_findrep_struct.lStructSize = sizeof(s_findrep_struct);
1611 s_findrep_struct.lpstrFindWhat = alloc(MSWIN_FR_BUFSIZE);
1612 s_findrep_struct.lpstrFindWhat[0] = NUL;
1613 s_findrep_struct.lpstrReplaceWith = alloc(MSWIN_FR_BUFSIZE);
1614 s_findrep_struct.lpstrReplaceWith[0] = NUL;
1615 s_findrep_struct.wFindWhatLen = MSWIN_FR_BUFSIZE;
1616 s_findrep_struct.wReplaceWithLen = MSWIN_FR_BUFSIZE;
1617 # if defined(FEAT_MBYTE) && defined(WIN3264)
1618 s_findrep_struct_w.lStructSize = sizeof(s_findrep_struct_w);
1619 s_findrep_struct_w.lpstrFindWhat =
1620 (LPWSTR)alloc(MSWIN_FR_BUFSIZE * sizeof(WCHAR));
1621 s_findrep_struct_w.lpstrFindWhat[0] = NUL;
1622 s_findrep_struct_w.lpstrReplaceWith =
1623 (LPWSTR)alloc(MSWIN_FR_BUFSIZE * sizeof(WCHAR));
1624 s_findrep_struct_w.lpstrReplaceWith[0] = NUL;
1625 s_findrep_struct_w.wFindWhatLen = MSWIN_FR_BUFSIZE;
1626 s_findrep_struct_w.wReplaceWithLen = MSWIN_FR_BUFSIZE;
1627 # endif
1628 #endif
1629
1630 theend:
1631 /* Display any pending error messages */
1632 display_errors();
1633
1634 return OK;
1635 }
1636
1637 /*
1638 * Get the size of the screen, taking position on multiple monitors into
1639 * account (if supported).
1640 */
1641 static void
1642 get_work_area(RECT *spi_rect)
1643 {
1644 _HMONITOR mon;
1645 _MONITORINFO moninfo;
1646
1647 /* use these functions only if available */
1648 if (pMonitorFromWindow != NULL && pGetMonitorInfo != NULL)
1649 {
1650 /* work out which monitor the window is on, and get *it's* work area */
1651 mon = pMonitorFromWindow(s_hwnd, 1 /*MONITOR_DEFAULTTOPRIMARY*/);
1652 if (mon != NULL)
1653 {
1654 moninfo.cbSize = sizeof(_MONITORINFO);
1655 if (pGetMonitorInfo(mon, &moninfo))
1656 {
1657 *spi_rect = moninfo.rcWork;
1658 return;
1659 }
1660 }
1661 }
1662 /* this is the old method... */
1663 SystemParametersInfo(SPI_GETWORKAREA, 0, spi_rect, 0);
1664 }
1665
1666 /*
1667 * Set the size of the window to the given width and height in pixels.
1668 */
1669 /*ARGSUSED*/
1670 void
1671 gui_mch_set_shellsize(int width, int height,
1672 int min_width, int min_height, int base_width, int base_height,
1673 int direction)
1674 {
1675 RECT workarea_rect;
1676 int win_width, win_height;
1677 int win_xpos, win_ypos;
1678 WINDOWPLACEMENT wndpl;
1679 int workarea_left;
1680
1681 /* Try to keep window completely on screen. */
1682 /* Get position of the screen work area. This is the part that is not
1683 * used by the taskbar or appbars. */
1684 get_work_area(&workarea_rect);
1685
1686 /* Get current posision of our window. Note that the .left and .top are
1687 * relative to the work area. */
1688 wndpl.length = sizeof(WINDOWPLACEMENT);
1689 GetWindowPlacement(s_hwnd, &wndpl);
1690
1691 /* Resizing a maximized window looks very strange, unzoom it first.
1692 * But don't do it when still starting up, it may have been requested in
1693 * the shortcut. */
1694 if (wndpl.showCmd == SW_SHOWMAXIMIZED && starting == 0)
1695 {
1696 ShowWindow(s_hwnd, SW_SHOWNORMAL);
1697 /* Need to get the settings of the normal window. */
1698 GetWindowPlacement(s_hwnd, &wndpl);
1699 }
1700
1701 win_xpos = wndpl.rcNormalPosition.left;
1702 win_ypos = wndpl.rcNormalPosition.top;
1703
1704 /* compute the size of the outside of the window */
1705 win_width = width + GetSystemMetrics(SM_CXFRAME) * 2;
1706 win_height = height + GetSystemMetrics(SM_CYFRAME) * 2
1707 + get_caption_height()
1708 #ifdef FEAT_MENU
1709 + gui_mswin_get_menu_height(FALSE)
1710 #endif
1711 ;
1712
1713 /* There is an inconsistency when using two monitors and Vim is on the
1714 * second (right) one: win_xpos will be the offset from the workarea of
1715 * the left monitor. While with one monitor it's the offset from the
1716 * workarea (including a possible taskbar on the left). Detect the second
1717 * monitor by checking for the left offset to be quite big. */
1718 if (workarea_rect.left > 300)
1719 workarea_left = 0;
1720 else
1721 workarea_left = workarea_rect.left;
1722
1723 /* If the window is going off the screen, move it on to the screen.
1724 * win_xpos and win_ypos are relative to the workarea. */
1725 if ((direction & RESIZE_HOR)
1726 && workarea_left + win_xpos + win_width > workarea_rect.right)
1727 win_xpos = workarea_rect.right - win_width - workarea_left;
1728
1729 if ((direction & RESIZE_HOR) && win_xpos < 0)
1730 win_xpos = 0;
1731
1732 if ((direction & RESIZE_VERT)
1733 && workarea_rect.top + win_ypos + win_height > workarea_rect.bottom)
1734 win_ypos = workarea_rect.bottom - win_height - workarea_rect.top;
1735
1736 if ((direction & RESIZE_VERT) && win_ypos < 0)
1737 win_ypos = 0;
1738
1739 wndpl.rcNormalPosition.left = win_xpos;
1740 wndpl.rcNormalPosition.right = win_xpos + win_width;
1741 wndpl.rcNormalPosition.top = win_ypos;
1742 wndpl.rcNormalPosition.bottom = win_ypos + win_height;
1743
1744 /* set window position - we should use SetWindowPlacement rather than
1745 * SetWindowPos as the MSDN docs say the coord systems returned by
1746 * these two are not compatible. */
1747 SetWindowPlacement(s_hwnd, &wndpl);
1748
1749 SetActiveWindow(s_hwnd);
1750 SetFocus(s_hwnd);
1751
1752 #ifdef FEAT_MENU
1753 /* Menu may wrap differently now */
1754 gui_mswin_get_menu_height(!gui.starting);
1755 #endif
1756 }
1757
1758
1759 void
1760 gui_mch_set_scrollbar_thumb(
1761 scrollbar_T *sb,
1762 long val,
1763 long size,
1764 long max)
1765 {
1766 SCROLLINFO info;
1767
1768 sb->scroll_shift = 0;
1769 while (max > 32767)
1770 {
1771 max = (max + 1) >> 1;
1772 val >>= 1;
1773 size >>= 1;
1774 ++sb->scroll_shift;
1775 }
1776
1777 if (sb->scroll_shift > 0)
1778 ++size;
1779
1780 info.cbSize = sizeof(info);
1781 info.fMask = SIF_POS | SIF_RANGE | SIF_PAGE;
1782 info.nPos = val;
1783 info.nMin = 0;
1784 info.nMax = max;
1785 info.nPage = size;
1786 SetScrollInfo(sb->id, SB_CTL, &info, TRUE);
1787 }
1788
1789
1790 /*
1791 * Set the current text font.
1792 */
1793 void
1794 gui_mch_set_font(GuiFont font)
1795 {
1796 gui.currFont = font;
1797 }
1798
1799
1800 /*
1801 * Set the current text foreground color.
1802 */
1803 void
1804 gui_mch_set_fg_color(guicolor_T color)
1805 {
1806 gui.currFgColor = color;
1807 }
1808
1809 /*
1810 * Set the current text background color.
1811 */
1812 void
1813 gui_mch_set_bg_color(guicolor_T color)
1814 {
1815 gui.currBgColor = color;
1816 }
1817
1818 /*
1819 * Set the current text special color.
1820 */
1821 void
1822 gui_mch_set_sp_color(guicolor_T color)
1823 {
1824 gui.currSpColor = color;
1825 }
1826
1827 #if defined(FEAT_MBYTE) && defined(FEAT_MBYTE_IME)
1828 /*
1829 * Multi-byte handling, originally by Sung-Hoon Baek.
1830 * First static functions (no prototypes generated).
1831 */
1832 #ifdef _MSC_VER
1833 # include <ime.h> /* Apparently not needed for Cygwin, MingW or Borland. */
1834 #endif
1835 #include <imm.h>
1836
1837 /*
1838 * handle WM_IME_NOTIFY message
1839 */
1840 /*ARGSUSED*/
1841 static LRESULT
1842 _OnImeNotify(HWND hWnd, DWORD dwCommand, DWORD dwData)
1843 {
1844 LRESULT lResult = 0;
1845 HIMC hImc;
1846
1847 if (!pImmGetContext || (hImc = pImmGetContext(hWnd)) == (HIMC)0)
1848 return lResult;
1849 switch (dwCommand)
1850 {
1851 case IMN_SETOPENSTATUS:
1852 if (pImmGetOpenStatus(hImc))
1853 {
1854 pImmSetCompositionFont(hImc, &norm_logfont);
1855 im_set_position(gui.row, gui.col);
1856
1857 /* Disable langmap */
1858 State &= ~LANGMAP;
1859 if (State & INSERT)
1860 {
1861 #if defined(FEAT_WINDOWS) && defined(FEAT_KEYMAP)
1862 /* Unshown 'keymap' in status lines */
1863 if (curbuf->b_p_iminsert == B_IMODE_LMAP)
1864 {
1865 /* Save cursor position */
1866 int old_row = gui.row;
1867 int old_col = gui.col;
1868
1869 // This must be called here before
1870 // status_redraw_curbuf(), otherwise the mode
1871 // message may appear in the wrong position.
1872 showmode();
1873 status_redraw_curbuf();
1874 update_screen(0);
1875 /* Restore cursor position */
1876 gui.row = old_row;
1877 gui.col = old_col;
1878 }
1879 #endif
1880 }
1881 }
1882 gui_update_cursor(TRUE, FALSE);
1883 lResult = 0;
1884 break;
1885 }
1886 pImmReleaseContext(hWnd, hImc);
1887 return lResult;
1888 }
1889
1890 /*ARGSUSED*/
1891 static LRESULT
1892 _OnImeComposition(HWND hwnd, WPARAM dbcs, LPARAM param)
1893 {
1894 char_u *ret;
1895 int len;
1896
1897 if ((param & GCS_RESULTSTR) == 0) /* Composition unfinished. */
1898 return 0;
1899
1900 ret = GetResultStr(hwnd, GCS_RESULTSTR, &len);
1901 if (ret != NULL)
1902 {
1903 add_to_input_buf_csi(ret, len);
1904 vim_free(ret);
1905 return 1;
1906 }
1907 return 0;
1908 }
1909
1910 /*
1911 * get the current composition string, in UCS-2; *lenp is the number of
1912 * *lenp is the number of Unicode characters.
1913 */
1914 static short_u *
1915 GetCompositionString_inUCS2(HIMC hIMC, DWORD GCS, int *lenp)
1916 {
1917 LONG ret;
1918 LPWSTR wbuf = NULL;
1919 char_u *buf;
1920
1921 if (!pImmGetContext)
1922 return NULL; /* no imm32.dll */
1923
1924 /* Try Unicode; this'll always work on NT regardless of codepage. */
1925 ret = pImmGetCompositionStringW(hIMC, GCS, NULL, 0);
1926 if (ret == 0)
1927 return NULL; /* empty */
1928
1929 if (ret > 0)
1930 {
1931 /* Allocate the requested buffer plus space for the NUL character. */
1932 wbuf = (LPWSTR)alloc(ret + sizeof(WCHAR));
1933 if (wbuf != NULL)
1934 {
1935 pImmGetCompositionStringW(hIMC, GCS, wbuf, ret);
1936 *lenp = ret / sizeof(WCHAR);
1937 }
1938 return (short_u *)wbuf;
1939 }
1940
1941 /* ret < 0; we got an error, so try the ANSI version. This'll work
1942 * on 9x/ME, but only if the codepage happens to be set to whatever
1943 * we're inputting. */
1944 ret = pImmGetCompositionStringA(hIMC, GCS, NULL, 0);
1945 if (ret <= 0)
1946 return NULL; /* empty or error */
1947
1948 buf = alloc(ret);
1949 if (buf == NULL)
1950 return NULL;
1951 pImmGetCompositionStringA(hIMC, GCS, buf, ret);
1952
1953 /* convert from codepage to UCS-2 */
1954 MultiByteToWideChar_alloc(GetACP(), 0, buf, ret, &wbuf, lenp);
1955 vim_free(buf);
1956
1957 return (short_u *)wbuf;
1958 }
1959
1960 /*
1961 * void GetResultStr()
1962 *
1963 * This handles WM_IME_COMPOSITION with GCS_RESULTSTR flag on.
1964 * get complete composition string
1965 */
1966 static char_u *
1967 GetResultStr(HWND hwnd, int GCS, int *lenp)
1968 {
1969 HIMC hIMC; /* Input context handle. */
1970 short_u *buf = NULL;
1971 char_u *convbuf = NULL;
1972
1973 if (!pImmGetContext || (hIMC = pImmGetContext(hwnd)) == (HIMC)0)
1974 return NULL;
1975
1976 /* Reads in the composition string. */
1977 buf = GetCompositionString_inUCS2(hIMC, GCS, lenp);
1978 if (buf == NULL)
1979 return NULL;
1980
1981 convbuf = utf16_to_enc(buf, lenp);
1982 pImmReleaseContext(hwnd, hIMC);
1983 vim_free(buf);
1984 return convbuf;
1985 }
1986 #endif
1987
1988 /* For global functions we need prototypes. */
1989 #if (defined(FEAT_MBYTE) && defined(FEAT_MBYTE_IME)) || defined(PROTO)
1990
1991 /*
1992 * set font to IM.
1993 */
1994 void
1995 im_set_font(LOGFONT *lf)
1996 {
1997 HIMC hImc;
1998
1999 if (pImmGetContext && (hImc = pImmGetContext(s_hwnd)) != (HIMC)0)
2000 {
2001 pImmSetCompositionFont(hImc, lf);
2002 pImmReleaseContext(s_hwnd, hImc);
2003 }
2004 }
2005
2006 /*
2007 * Notify cursor position to IM.
2008 */
2009 void
2010 im_set_position(int row, int col)
2011 {
2012 HIMC hImc;
2013
2014 if (pImmGetContext && (hImc = pImmGetContext(s_hwnd)) != (HIMC)0)
2015 {
2016 COMPOSITIONFORM cfs;
2017
2018 cfs.dwStyle = CFS_POINT;
2019 cfs.ptCurrentPos.x = FILL_X(col);
2020 cfs.ptCurrentPos.y = FILL_Y(row);
2021 MapWindowPoints(s_textArea, s_hwnd, &cfs.ptCurrentPos, 1);
2022 pImmSetCompositionWindow(hImc, &cfs);
2023
2024 pImmReleaseContext(s_hwnd, hImc);
2025 }
2026 }
2027
2028 /*
2029 * Set IM status on ("active" is TRUE) or off ("active" is FALSE).
2030 */
2031 void
2032 im_set_active(int active)
2033 {
2034 HIMC hImc;
2035 static HIMC hImcOld = (HIMC)0;
2036
2037 if (pImmGetContext) /* if NULL imm32.dll wasn't loaded (yet) */
2038 {
2039 if (p_imdisable)
2040 {
2041 if (hImcOld == (HIMC)0)
2042 {
2043 hImcOld = pImmGetContext(s_hwnd);
2044 if (hImcOld)
2045 pImmAssociateContext(s_hwnd, (HIMC)0);
2046 }
2047 active = FALSE;
2048 }
2049 else if (hImcOld != (HIMC)0)
2050 {
2051 pImmAssociateContext(s_hwnd, hImcOld);
2052 hImcOld = (HIMC)0;
2053 }
2054
2055 hImc = pImmGetContext(s_hwnd);
2056 if (hImc)
2057 {
2058 /*
2059 * for Korean ime
2060 */
2061 HKL hKL = GetKeyboardLayout(0);
2062
2063 if (LOWORD(hKL) == MAKELANGID(LANG_KOREAN, SUBLANG_KOREAN))
2064 {
2065 static DWORD dwConversionSaved = 0, dwSentenceSaved = 0;
2066 static BOOL bSaved = FALSE;
2067
2068 if (active)
2069 {
2070 /* if we have a saved conversion status, restore it */
2071 if (bSaved)
2072 pImmSetConversionStatus(hImc, dwConversionSaved,
2073 dwSentenceSaved);
2074 bSaved = FALSE;
2075 }
2076 else
2077 {
2078 /* save conversion status and disable korean */
2079 if (pImmGetConversionStatus(hImc, &dwConversionSaved,
2080 &dwSentenceSaved))
2081 {
2082 bSaved = TRUE;
2083 pImmSetConversionStatus(hImc,
2084 dwConversionSaved & ~(IME_CMODE_NATIVE
2085 | IME_CMODE_FULLSHAPE),
2086 dwSentenceSaved);
2087 }
2088 }
2089 }
2090
2091 pImmSetOpenStatus(hImc, active);
2092 pImmReleaseContext(s_hwnd, hImc);
2093 }
2094 }
2095 }
2096
2097 /*
2098 * Get IM status. When IM is on, return not 0. Else return 0.
2099 */
2100 int
2101 im_get_status()
2102 {
2103 int status = 0;
2104 HIMC hImc;
2105
2106 if (pImmGetContext && (hImc = pImmGetContext(s_hwnd)) != (HIMC)0)
2107 {
2108 status = pImmGetOpenStatus(hImc) ? 1 : 0;
2109 pImmReleaseContext(s_hwnd, hImc);
2110 }
2111 return status;
2112 }
2113
2114 #endif /* FEAT_MBYTE && FEAT_MBYTE_IME */
2115
2116 #if defined(FEAT_MBYTE) && !defined(FEAT_MBYTE_IME) && defined(GLOBAL_IME)
2117 /* Win32 with GLOBAL IME */
2118
2119 /*
2120 * Notify cursor position to IM.
2121 */
2122 void
2123 im_set_position(int row, int col)
2124 {
2125 /* Win32 with GLOBAL IME */
2126 POINT p;
2127
2128 p.x = FILL_X(col);
2129 p.y = FILL_Y(row);
2130 MapWindowPoints(s_textArea, s_hwnd, &p, 1);
2131 global_ime_set_position(&p);
2132 }
2133
2134 /*
2135 * Set IM status on ("active" is TRUE) or off ("active" is FALSE).
2136 */
2137 void
2138 im_set_active(int active)
2139 {
2140 global_ime_set_status(active);
2141 }
2142
2143 /*
2144 * Get IM status. When IM is on, return not 0. Else return 0.
2145 */
2146 int
2147 im_get_status()
2148 {
2149 return global_ime_get_status();
2150 }
2151 #endif
2152
2153 #ifdef FEAT_MBYTE
2154 /*
2155 * Convert latin9 text "text[len]" to ucs-2 in "unicodebuf".
2156 */
2157 static void
2158 latin9_to_ucs(char_u *text, int len, WCHAR *unicodebuf)
2159 {
2160 int c;
2161
2162 while (--len >= 0)
2163 {
2164 c = *text++;
2165 switch (c)
2166 {
2167 case 0xa4: c = 0x20ac; break; /* euro */
2168 case 0xa6: c = 0x0160; break; /* S hat */
2169 case 0xa8: c = 0x0161; break; /* S -hat */
2170 case 0xb4: c = 0x017d; break; /* Z hat */
2171 case 0xb8: c = 0x017e; break; /* Z -hat */
2172 case 0xbc: c = 0x0152; break; /* OE */
2173 case 0xbd: c = 0x0153; break; /* oe */
2174 case 0xbe: c = 0x0178; break; /* Y */
2175 }
2176 *unicodebuf++ = c;
2177 }
2178 }
2179 #endif
2180
2181 #ifdef FEAT_RIGHTLEFT
2182 /*
2183 * What is this for? In the case where you are using Win98 or Win2K or later,
2184 * and you are using a Hebrew font (or Arabic!), Windows does you a favor and
2185 * reverses the string sent to the TextOut... family. This sucks, because we
2186 * go to a lot of effort to do the right thing, and there doesn't seem to be a
2187 * way to tell Windblows not to do this!
2188 *
2189 * The short of it is that this 'RevOut' only gets called if you are running
2190 * one of the new, "improved" MS OSes, and only if you are running in
2191 * 'rightleft' mode. It makes display take *slightly* longer, but not
2192 * noticeably so.
2193 */
2194 static void
2195 RevOut( HDC s_hdc,
2196 int col,
2197 int row,
2198 UINT foptions,
2199 CONST RECT *pcliprect,
2200 LPCTSTR text,
2201 UINT len,
2202 CONST INT *padding)
2203 {
2204 int ix;
2205 static int special = -1;
2206
2207 if (special == -1)
2208 {
2209 /* Check windows version: special treatment is needed if it is NT 5 or
2210 * Win98 or higher. */
2211 if ((os_version.dwPlatformId == VER_PLATFORM_WIN32_NT
2212 && os_version.dwMajorVersion >= 5)
2213 || (os_version.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS
2214 && (os_version.dwMajorVersion > 4
2215 || (os_version.dwMajorVersion == 4
2216 && os_version.dwMinorVersion > 0))))
2217 special = 1;
2218 else
2219 special = 0;
2220 }
2221
2222 if (special)
2223 for (ix = 0; ix < (int)len; ++ix)
2224 ExtTextOut(s_hdc, col + TEXT_X(ix), row, foptions,
2225 pcliprect, text + ix, 1, padding);
2226 else
2227 ExtTextOut(s_hdc, col, row, foptions, pcliprect, text, len, padding);
2228 }
2229 #endif
2230
2231 void
2232 gui_mch_draw_string(
2233 int row,
2234 int col,
2235 char_u *text,
2236 int len,
2237 int flags)
2238 {
2239 static int *padding = NULL;
2240 static int pad_size = 0;
2241 int i;
2242 const RECT *pcliprect = NULL;
2243 UINT foptions = 0;
2244 #ifdef FEAT_MBYTE
2245 static WCHAR *unicodebuf = NULL;
2246 static int *unicodepdy = NULL;
2247 static int unibuflen = 0;
2248 int n = 0;
2249 #endif
2250 HPEN hpen, old_pen;
2251 int y;
2252
2253 #ifndef MSWIN16_FASTTEXT
2254 /*
2255 * Italic and bold text seems to have an extra row of pixels at the bottom
2256 * (below where the bottom of the character should be). If we draw the
2257 * characters with a solid background, the top row of pixels in the
2258 * character below will be overwritten. We can fix this by filling in the
2259 * background ourselves, to the correct character proportions, and then
2260 * writing the character in transparent mode. Still have a problem when
2261 * the character is "_", which gets written on to the character below.
2262 * New fix: set gui.char_ascent to -1. This shifts all characters up one
2263 * pixel in their slots, which fixes the problem with the bottom row of
2264 * pixels. We still need this code because otherwise the top row of pixels
2265 * becomes a problem. - webb.
2266 */
2267 static HBRUSH hbr_cache[2] = {NULL, NULL};
2268 static guicolor_T brush_color[2] = {INVALCOLOR, INVALCOLOR};
2269 static int brush_lru = 0;
2270 HBRUSH hbr;
2271 RECT rc;
2272
2273 if (!(flags & DRAW_TRANSP))
2274 {
2275 /*
2276 * Clear background first.
2277 * Note: FillRect() excludes right and bottom of rectangle.
2278 */
2279 rc.left = FILL_X(col);
2280 rc.top = FILL_Y(row);
2281 #ifdef FEAT_MBYTE
2282 if (has_mbyte)
2283 {
2284 int cell_len = 0;
2285
2286 /* Compute the length in display cells. */
2287 for (n = 0; n < len; n += MB_BYTE2LEN(text[n]))
2288 cell_len += (*mb_ptr2cells)(text + n);
2289 rc.right = FILL_X(col + cell_len);
2290 }
2291 else
2292 #endif
2293 rc.right = FILL_X(col + len);
2294 rc.bottom = FILL_Y(row + 1);
2295
2296 /* Cache the created brush, that saves a lot of time. We need two:
2297 * one for cursor background and one for the normal background. */
2298 if (gui.currBgColor == brush_color[0])
2299 {
2300 hbr = hbr_cache[0];
2301 brush_lru = 1;
2302 }
2303 else if (gui.currBgColor == brush_color[1])
2304 {
2305 hbr = hbr_cache[1];
2306 brush_lru = 0;
2307 }
2308 else
2309 {
2310 if (hbr_cache[brush_lru] != NULL)
2311 DeleteBrush(hbr_cache[brush_lru]);
2312 hbr_cache[brush_lru] = CreateSolidBrush(gui.currBgColor);
2313 brush_color[brush_lru] = gui.currBgColor;
2314 hbr = hbr_cache[brush_lru];
2315 brush_lru = !brush_lru;
2316 }
2317 FillRect(s_hdc, &rc, hbr);
2318
2319 SetBkMode(s_hdc, TRANSPARENT);
2320
2321 /*
2322 * When drawing block cursor, prevent inverted character spilling
2323 * over character cell (can happen with bold/italic)
2324 */
2325 if (flags & DRAW_CURSOR)
2326 {
2327 pcliprect = &rc;
2328 foptions = ETO_CLIPPED;
2329 }
2330 }
2331 #else
2332 /*
2333 * The alternative would be to write the characters in opaque mode, but
2334 * when the text is not exactly the same proportions as normal text, too
2335 * big or too little a rectangle gets drawn for the background.
2336 */
2337 SetBkMode(s_hdc, OPAQUE);
2338 SetBkColor(s_hdc, gui.currBgColor);
2339 #endif
2340 SetTextColor(s_hdc, gui.currFgColor);
2341 SelectFont(s_hdc, gui.currFont);
2342
2343 if (pad_size != Columns || padding == NULL || padding[0] != gui.char_width)
2344 {
2345 vim_free(padding);
2346 pad_size = Columns;
2347
2348 /* Don't give an out-of-memory message here, it would call us
2349 * recursively. */
2350 padding = (int *)lalloc(pad_size * sizeof(int), FALSE);
2351 if (padding != NULL)
2352 for (i = 0; i < pad_size; i++)
2353 padding[i] = gui.char_width;
2354 }
2355
2356 /* On NT, tell the font renderer not to "help" us with Hebrew and Arabic
2357 * text. This doesn't work in 9x, so we have to deal with it manually on
2358 * those systems. */
2359 if (os_version.dwPlatformId == VER_PLATFORM_WIN32_NT)
2360 foptions |= ETO_IGNORELANGUAGE;
2361
2362 /*
2363 * We have to provide the padding argument because italic and bold versions
2364 * of fixed-width fonts are often one pixel or so wider than their normal
2365 * versions.
2366 * No check for DRAW_BOLD, Windows will have done it already.
2367 */
2368
2369 #ifdef FEAT_MBYTE
2370 /* Check if there are any UTF-8 characters. If not, use normal text
2371 * output to speed up output. */
2372 if (enc_utf8)
2373 for (n = 0; n < len; ++n)
2374 if (text[n] >= 0x80)
2375 break;
2376
2377 /* Check if the Unicode buffer exists and is big enough. Create it
2378 * with the same length as the multi-byte string, the number of wide
2379 * characters is always equal or smaller. */
2380 if ((enc_utf8
2381 || (enc_codepage > 0 && (int)GetACP() != enc_codepage)
2382 || enc_latin9)
2383 && (unicodebuf == NULL || len > unibuflen))
2384 {
2385 vim_free(unicodebuf);
2386 unicodebuf = (WCHAR *)lalloc(len * sizeof(WCHAR), FALSE);
2387
2388 vim_free(unicodepdy);
2389 unicodepdy = (int *)lalloc(len * sizeof(int), FALSE);
2390
2391 unibuflen = len;
2392 }
2393
2394 if (enc_utf8 && n < len && unicodebuf != NULL)
2395 {
2396 /* Output UTF-8 characters. Caller has already separated
2397 * composing characters. */
2398 int i;
2399 int wlen; /* string length in words */
2400 int clen; /* string length in characters */
2401 int cells; /* cell width of string up to composing char */
2402 int cw; /* width of current cell */
2403 int c;
2404
2405 wlen = 0;
2406 clen = 0;
2407 cells = 0;
2408 for (i = 0; i < len; )
2409 {
2410 c = utf_ptr2char(text + i);
2411 if (c >= 0x10000)
2412 {
2413 /* Turn into UTF-16 encoding. */
2414 unicodebuf[wlen++] = ((c - 0x10000) >> 10) + 0xD800;
2415 unicodebuf[wlen++] = ((c - 0x10000) & 0x3ff) + 0xDC00;
2416 }
2417 else
2418 {
2419 unicodebuf[wlen++] = c;
2420 }
2421 cw = utf_char2cells(c);
2422 if (cw > 2) /* don't use 4 for unprintable char */
2423 cw = 1;
2424 if (unicodepdy != NULL)
2425 {
2426 /* Use unicodepdy to make characters fit as we expect, even
2427 * when the font uses different widths (e.g., bold character
2428 * is wider). */
2429 unicodepdy[clen] = cw * gui.char_width;
2430 }
2431 cells += cw;
2432 i += utfc_ptr2len_len(text + i, len - i);
2433 ++clen;
2434 }
2435 ExtTextOutW(s_hdc, TEXT_X(col), TEXT_Y(row),
2436 foptions, pcliprect, unicodebuf, wlen, unicodepdy);
2437 len = cells; /* used for underlining */
2438 }
2439 else if ((enc_codepage > 0 && (int)GetACP() != enc_codepage) || enc_latin9)
2440 {
2441 /* If we want to display codepage data, and the current CP is not the
2442 * ANSI one, we need to go via Unicode. */
2443 if (unicodebuf != NULL)
2444 {
2445 if (enc_latin9)
2446 latin9_to_ucs(text, len, unicodebuf);
2447 else
2448 len = MultiByteToWideChar(enc_codepage,
2449 MB_PRECOMPOSED,
2450 (char *)text, len,
2451 (LPWSTR)unicodebuf, unibuflen);
2452 if (len != 0)
2453 {
2454 /* Use unicodepdy to make characters fit as we expect, even
2455 * when the font uses different widths (e.g., bold character
2456 * is wider). */
2457 if (unicodepdy != NULL)
2458 {
2459 int i;
2460 int cw;
2461
2462 for (i = 0; i < len; ++i)
2463 {
2464 cw = utf_char2cells(unicodebuf[i]);
2465 if (cw > 2)
2466 cw = 1;
2467 unicodepdy[i] = cw * gui.char_width;
2468 }
2469 }
2470 ExtTextOutW(s_hdc, TEXT_X(col), TEXT_Y(row),
2471 foptions, pcliprect, unicodebuf, len, unicodepdy);
2472 }
2473 }
2474 }
2475 else
2476 #endif
2477 {
2478 #ifdef FEAT_RIGHTLEFT
2479 /* If we can't use ETO_IGNORELANGUAGE, we can't tell Windows not to
2480 * mess up RL text, so we have to draw it character-by-character.
2481 * Only do this if RL is on, since it's slow. */
2482 if (curwin->w_p_rl && !(foptions & ETO_IGNORELANGUAGE))
2483 RevOut(s_hdc, TEXT_X(col), TEXT_Y(row),
2484 foptions, pcliprect, (char *)text, len, padding);
2485 else
2486 #endif
2487 ExtTextOut(s_hdc, TEXT_X(col), TEXT_Y(row),
2488 foptions, pcliprect, (char *)text, len, padding);
2489 }
2490
2491 /* Underline */
2492 if (flags & DRAW_UNDERL)
2493 {
2494 hpen = CreatePen(PS_SOLID, 1, gui.currFgColor);
2495 old_pen = SelectObject(s_hdc, hpen);
2496 /* When p_linespace is 0, overwrite the bottom row of pixels.
2497 * Otherwise put the line just below the character. */
2498 y = FILL_Y(row + 1) - 1;
2499 #ifndef MSWIN16_FASTTEXT
2500 if (p_linespace > 1)
2501 y -= p_linespace - 1;
2502 #endif
2503 MoveToEx(s_hdc, FILL_X(col), y, NULL);
2504 /* Note: LineTo() excludes the last pixel in the line. */
2505 LineTo(s_hdc, FILL_X(col + len), y);
2506 DeleteObject(SelectObject(s_hdc, old_pen));
2507 }
2508
2509 /* Undercurl */
2510 if (flags & DRAW_UNDERC)
2511 {
2512 int x;
2513 int offset;
2514 static const int val[8] = {1, 0, 0, 0, 1, 2, 2, 2 };
2515
2516 y = FILL_Y(row + 1) - 1;
2517 for (x = FILL_X(col); x < FILL_X(col + len); ++x)
2518 {
2519 offset = val[x % 8];
2520 SetPixel(s_hdc, x, y - offset, gui.currSpColor);
2521 }
2522 }
2523 }
2524
2525
2526 /*
2527 * Output routines.
2528 */
2529
2530 /* Flush any output to the screen */
2531 void
2532 gui_mch_flush(void)
2533 {
2534 # if defined(__BORLANDC__)
2535 /*
2536 * The GdiFlush declaration (in Borland C 5.01 <wingdi.h>) is not a
2537 * prototype declaration.
2538 * The compiler complains if __stdcall is not used in both declarations.
2539 */
2540 BOOL __stdcall GdiFlush(void);
2541 # endif
2542
2543 GdiFlush();
2544 }
2545
2546 static void
2547 clear_rect(RECT *rcp)
2548 {
2549 HBRUSH hbr;
2550
2551 hbr = CreateSolidBrush(gui.back_pixel);
2552 FillRect(s_hdc, rcp, hbr);
2553 DeleteBrush(hbr);
2554 }
2555
2556
2557 void
2558 gui_mch_get_screen_dimensions(int *screen_w, int *screen_h)
2559 {
2560 RECT workarea_rect;
2561
2562 get_work_area(&workarea_rect);
2563
2564 *screen_w = workarea_rect.right - workarea_rect.left
2565 - GetSystemMetrics(SM_CXFRAME) * 2;
2566
2567 /* FIXME: dirty trick: Because the gui_get_base_height() doesn't include
2568 * the menubar for MSwin, we subtract it from the screen height, so that
2569 * the window size can be made to fit on the screen. */
2570 *screen_h = workarea_rect.bottom - workarea_rect.top
2571 - GetSystemMetrics(SM_CYFRAME) * 2
2572 - get_caption_height()
2573 #ifdef FEAT_MENU
2574 - gui_mswin_get_menu_height(FALSE)
2575 #endif
2576 ;
2577 }
2578
2579
2580 #if defined(FEAT_MENU) || defined(PROTO)
2581 /*
2582 * Add a sub menu to the menu bar.
2583 */
2584 void
2585 gui_mch_add_menu(
2586 vimmenu_T *menu,
2587 int pos)
2588 {
2589 vimmenu_T *parent = menu->parent;
2590
2591 menu->submenu_id = CreatePopupMenu();
2592 menu->id = s_menu_id++;
2593
2594 if (menu_is_menubar(menu->name))
2595 {
2596 if (is_winnt_3())
2597 {
2598 InsertMenu((parent == NULL) ? s_menuBar : parent->submenu_id,
2599 (UINT)pos, MF_POPUP | MF_STRING | MF_BYPOSITION,
2600 (long_u)menu->submenu_id, (LPCTSTR) menu->name);
2601 }
2602 else
2603 {
2604 #ifdef FEAT_MBYTE
2605 WCHAR *wn = NULL;
2606 int n;
2607
2608 if (enc_codepage >= 0 && (int)GetACP() != enc_codepage)
2609 {
2610 /* 'encoding' differs from active codepage: convert menu name
2611 * and use wide function */
2612 wn = enc_to_utf16(menu->name, NULL);
2613 if (wn != NULL)
2614 {
2615 MENUITEMINFOW infow;
2616
2617 infow.cbSize = sizeof(infow);
2618 infow.fMask = MIIM_DATA | MIIM_TYPE | MIIM_ID
2619 | MIIM_SUBMENU;
2620 infow.dwItemData = (long_u)menu;
2621 infow.wID = menu->id;
2622 infow.fType = MFT_STRING;
2623 infow.dwTypeData = wn;
2624 infow.cch = (UINT)wcslen(wn);
2625 infow.hSubMenu = menu->submenu_id;
2626 n = InsertMenuItemW((parent == NULL)
2627 ? s_menuBar : parent->submenu_id,
2628 (UINT)pos, TRUE, &infow);
2629 vim_free(wn);
2630 if (n == 0 && GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
2631 /* Failed, try using non-wide function. */
2632 wn = NULL;
2633 }
2634 }
2635
2636 if (wn == NULL)
2637 #endif
2638 {
2639 MENUITEMINFO info;
2640
2641 info.cbSize = sizeof(info);
2642 info.fMask = MIIM_DATA | MIIM_TYPE | MIIM_ID | MIIM_SUBMENU;
2643 info.dwItemData = (long_u)menu;
2644 info.wID = menu->id;
2645 info.fType = MFT_STRING;
2646 info.dwTypeData = (LPTSTR)menu->name;
2647 info.cch = (UINT)STRLEN(menu->name);
2648 info.hSubMenu = menu->submenu_id;
2649 InsertMenuItem((parent == NULL)
2650 ? s_menuBar : parent->submenu_id,
2651 (UINT)pos, TRUE, &info);
2652 }
2653 }
2654 }
2655
2656 /* Fix window size if menu may have wrapped */
2657 if (parent == NULL)
2658 gui_mswin_get_menu_height(!gui.starting);
2659 #ifdef FEAT_TEAROFF
2660 else if (IsWindow(parent->tearoff_handle))
2661 rebuild_tearoff(parent);
2662 #endif
2663 }
2664
2665 void
2666 gui_mch_show_popupmenu(vimmenu_T *menu)
2667 {
2668 POINT mp;
2669
2670 (void)GetCursorPos((LPPOINT)&mp);
2671 gui_mch_show_popupmenu_at(menu, (int)mp.x, (int)mp.y);
2672 }
2673
2674 void
2675 gui_make_popup(char_u *path_name, int mouse_pos)
2676 {
2677 vimmenu_T *menu = gui_find_menu(path_name);
2678
2679 if (menu != NULL)
2680 {
2681 POINT p;
2682
2683 /* Find the position of the current cursor */
2684 GetDCOrgEx(s_hdc, &p);
2685 if (mouse_pos)
2686 {
2687 int mx, my;
2688
2689 gui_mch_getmouse(&mx, &my);
2690 p.x += mx;
2691 p.y += my;
2692 }
2693 else if (curwin != NULL)
2694 {
2695 p.x += TEXT_X(W_WINCOL(curwin) + curwin->w_wcol + 1);
2696 p.y += TEXT_Y(W_WINROW(curwin) + curwin->w_wrow + 1);
2697 }
2698 msg_scroll = FALSE;
2699 gui_mch_show_popupmenu_at(menu, (int)p.x, (int)p.y);
2700 }
2701 }
2702
2703 #if defined(FEAT_TEAROFF) || defined(PROTO)
2704 /*
2705 * Given a menu descriptor, e.g. "File.New", find it in the menu hierarchy and
2706 * create it as a pseudo-"tearoff menu".
2707 */
2708 void
2709 gui_make_tearoff(char_u *path_name)
2710 {
2711 vimmenu_T *menu = gui_find_menu(path_name);
2712
2713 /* Found the menu, so tear it off. */
2714 if (menu != NULL)
2715 gui_mch_tearoff(menu->dname, menu, 0xffffL, 0xffffL);
2716 }
2717 #endif
2718
2719 /*
2720 * Add a menu item to a menu
2721 */
2722 void
2723 gui_mch_add_menu_item(
2724 vimmenu_T *menu,
2725 int idx)
2726 {
2727 vimmenu_T *parent = menu->parent;
2728
2729 menu->id = s_menu_id++;
2730 menu->submenu_id = NULL;
2731
2732 #ifdef FEAT_TEAROFF
2733 if (STRNCMP(menu->name, TEAR_STRING, TEAR_LEN) == 0)
2734 {
2735 InsertMenu(parent->submenu_id, (UINT)idx, MF_BITMAP|MF_BYPOSITION,
2736 (UINT)menu->id, (LPCTSTR) s_htearbitmap);
2737 }
2738 else
2739 #endif
2740 #ifdef FEAT_TOOLBAR
2741 if (menu_is_toolbar(parent->name))
2742 {
2743 TBBUTTON newtb;
2744
2745 vim_memset(&newtb, 0, sizeof(newtb));
2746 if (menu_is_separator(menu->name))
2747 {
2748 newtb.iBitmap = 0;
2749 newtb.fsStyle = TBSTYLE_SEP;
2750 }
2751 else
2752 {
2753 newtb.iBitmap = get_toolbar_bitmap(menu);
2754 newtb.fsStyle = TBSTYLE_BUTTON;
2755 }
2756 newtb.idCommand = menu->id;
2757 newtb.fsState = TBSTATE_ENABLED;
2758 newtb.iString = 0;
2759 SendMessage(s_toolbarhwnd, TB_INSERTBUTTON, (WPARAM)idx,
2760 (LPARAM)&newtb);
2761 menu->submenu_id = (HMENU)-1;
2762 }
2763 else
2764 #endif
2765 {
2766 #ifdef FEAT_MBYTE
2767 WCHAR *wn = NULL;
2768 int n;
2769
2770 if (enc_codepage >= 0 && (int)GetACP() != enc_codepage)
2771 {
2772 /* 'encoding' differs from active codepage: convert menu item name
2773 * and use wide function */
2774 wn = enc_to_utf16(menu->name, NULL);
2775 if (wn != NULL)
2776 {
2777 n = InsertMenuW(parent->submenu_id, (UINT)idx,
2778 (menu_is_separator(menu->name)
2779 ? MF_SEPARATOR : MF_STRING) | MF_BYPOSITION,
2780 (UINT)menu->id, wn);
2781 vim_free(wn);
2782 if (n == 0 && GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
2783 /* Failed, try using non-wide function. */
2784 wn = NULL;
2785 }
2786 }
2787 if (wn == NULL)
2788 #endif
2789 InsertMenu(parent->submenu_id, (UINT)idx,
2790 (menu_is_separator(menu->name) ? MF_SEPARATOR : MF_STRING)
2791 | MF_BYPOSITION,
2792 (UINT)menu->id, (LPCTSTR)menu->name);
2793 #ifdef FEAT_TEAROFF
2794 if (IsWindow(parent->tearoff_handle))
2795 rebuild_tearoff(parent);
2796 #endif
2797 }
2798 }
2799
2800 /*
2801 * Destroy the machine specific menu widget.
2802 */
2803 void
2804 gui_mch_destroy_menu(vimmenu_T *menu)
2805 {
2806 #ifdef FEAT_TOOLBAR
2807 /*
2808 * is this a toolbar button?
2809 */
2810 if (menu->submenu_id == (HMENU)-1)
2811 {
2812 int iButton;
2813
2814 iButton = (int)SendMessage(s_toolbarhwnd, TB_COMMANDTOINDEX,
2815 (WPARAM)menu->id, 0);
2816 SendMessage(s_toolbarhwnd, TB_DELETEBUTTON, (WPARAM)iButton, 0);
2817 }
2818 else
2819 #endif
2820 {
2821 if (menu->parent != NULL
2822 && menu_is_popup(menu->parent->dname)
2823 && menu->parent->submenu_id != NULL)
2824 RemoveMenu(menu->parent->submenu_id, menu->id, MF_BYCOMMAND);
2825 else
2826 RemoveMenu(s_menuBar, menu->id, MF_BYCOMMAND);
2827 if (menu->submenu_id != NULL)
2828 DestroyMenu(menu->submenu_id);
2829 #ifdef FEAT_TEAROFF
2830 if (IsWindow(menu->tearoff_handle))
2831 DestroyWindow(menu->tearoff_handle);
2832 if (menu->parent != NULL
2833 && menu->parent->children != NULL
2834 && IsWindow(menu->parent->tearoff_handle))
2835 {
2836 /* This menu must not show up when rebuilding the tearoff window. */
2837 menu->modes = 0;
2838 rebuild_tearoff(menu->parent);
2839 }
2840 #endif
2841 }
2842 }
2843
2844 #ifdef FEAT_TEAROFF
2845 static void
2846 rebuild_tearoff(vimmenu_T *menu)
2847 {
2848 /*hackish*/
2849 char_u tbuf[128];
2850 RECT trect;
2851 RECT rct;
2852 RECT roct;
2853 int x, y;
2854
2855 HWND thwnd = menu->tearoff_handle;
2856
2857 GetWindowText(thwnd, tbuf, 127);
2858 if (GetWindowRect(thwnd, &trect)
2859 && GetWindowRect(s_hwnd, &rct)
2860 && GetClientRect(s_hwnd, &roct))
2861 {
2862 x = trect.left - rct.left;
2863 y = (trect.top - rct.bottom + roct.bottom);
2864 }
2865 else
2866 {
2867 x = y = 0xffffL;
2868 }
2869 DestroyWindow(thwnd);
2870 if (menu->children != NULL)
2871 {
2872 gui_mch_tearoff(tbuf, menu, x, y);
2873 if (IsWindow(menu->tearoff_handle))
2874 (void) SetWindowPos(menu->tearoff_handle,
2875 NULL,
2876 (int)trect.left,
2877 (int)trect.top,
2878 0, 0,
2879 SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE);
2880 }
2881 }
2882 #endif /* FEAT_TEAROFF */
2883
2884 /*
2885 * Make a menu either grey or not grey.
2886 */
2887 void
2888 gui_mch_menu_grey(
2889 vimmenu_T *menu,
2890 int grey)
2891 {
2892 #ifdef FEAT_TOOLBAR
2893 /*
2894 * is this a toolbar button?
2895 */
2896 if (menu->submenu_id == (HMENU)-1)
2897 {
2898 SendMessage(s_toolbarhwnd, TB_ENABLEBUTTON,
2899 (WPARAM)menu->id, (LPARAM) MAKELONG((grey ? FALSE : TRUE), 0) );
2900 }
2901 else
2902 #endif
2903 if (grey)
2904 EnableMenuItem(s_menuBar, menu->id, MF_BYCOMMAND | MF_GRAYED);
2905 else
2906 EnableMenuItem(s_menuBar, menu->id, MF_BYCOMMAND | MF_ENABLED);
2907
2908 #ifdef FEAT_TEAROFF
2909 if ((menu->parent != NULL) && (IsWindow(menu->parent->tearoff_handle)))
2910 {
2911 WORD menuID;
2912 HWND menuHandle;
2913
2914 /*
2915 * A tearoff button has changed state.
2916 */
2917 if (menu->children == NULL)
2918 menuID = (WORD)(menu->id);
2919 else
2920 menuID = (WORD)((long_u)(menu->submenu_id) | (DWORD)0x8000);
2921 menuHandle = GetDlgItem(menu->parent->tearoff_handle, menuID);
2922 if (menuHandle)
2923 EnableWindow(menuHandle, !grey);
2924
2925 }
2926 #endif
2927 }
2928
2929 #endif /* FEAT_MENU */
2930
2931
2932 /* define some macros used to make the dialogue creation more readable */
2933
2934 #define add_string(s) strcpy((LPSTR)p, s); (LPSTR)p += (strlen((LPSTR)p) + 1)
2935 #define add_word(x) *p++ = (x)
2936 #define add_long(x) dwp = (DWORD *)p; *dwp++ = (x); p = (WORD *)dwp
2937
2938 #if defined(FEAT_GUI_DIALOG) || defined(PROTO)
2939 /*
2940 * stuff for dialogs
2941 */
2942
2943 /*
2944 * The callback routine used by all the dialogs. Very simple. First,
2945 * acknowledges the INITDIALOG message so that Windows knows to do standard
2946 * dialog stuff (Return = default, Esc = cancel....) Second, if a button is
2947 * pressed, return that button's ID - IDCANCEL (2), which is the button's
2948 * number.
2949 */
2950 /*ARGSUSED*/
2951 static LRESULT CALLBACK
2952 dialog_callback(
2953 HWND hwnd,
2954 UINT message,
2955 WPARAM wParam,
2956 LPARAM lParam)
2957 {
2958 if (message == WM_INITDIALOG)
2959 {
2960 CenterWindow(hwnd, GetWindow(hwnd, GW_OWNER));
2961 /* Set focus to the dialog. Set the default button, if specified. */
2962 (void)SetFocus(hwnd);
2963 if (dialog_default_button > IDCANCEL)
2964 (void)SetFocus(GetDlgItem(hwnd, dialog_default_button));
2965 else
2966 /* We don't have a default, set focus on another element of the
2967 * dialog window, probably the icon */
2968 (void)SetFocus(GetDlgItem(hwnd, DLG_NONBUTTON_CONTROL));
2969 return FALSE;
2970 }
2971
2972 if (message == WM_COMMAND)
2973 {
2974 int button = LOWORD(wParam);
2975
2976 /* Don't end the dialog if something was selected that was
2977 * not a button.
2978 */
2979 if (button >= DLG_NONBUTTON_CONTROL)
2980 return TRUE;
2981
2982 /* If the edit box exists, copy the string. */
2983 if (s_textfield != NULL)
2984 {
2985 # if defined(FEAT_MBYTE) && defined(WIN3264)
2986 /* If the OS is Windows NT, and 'encoding' differs from active
2987 * codepage: use wide function and convert text. */
2988 if (os_version.dwPlatformId == VER_PLATFORM_WIN32_NT
2989 && enc_codepage >= 0 && (int)GetACP() != enc_codepage)
2990 {
2991 WCHAR *wp = (WCHAR *)alloc(IOSIZE * sizeof(WCHAR));
2992 char_u *p;
2993
2994 GetDlgItemTextW(hwnd, DLG_NONBUTTON_CONTROL + 2, wp, IOSIZE);
2995 p = utf16_to_enc(wp, NULL);
2996 vim_strncpy(s_textfield, p, IOSIZE);
2997 vim_free(p);
2998 vim_free(wp);
2999 }
3000 else
3001 # endif
3002 GetDlgItemText(hwnd, DLG_NONBUTTON_CONTROL + 2,
3003 s_textfield, IOSIZE);
3004 }
3005
3006 /*
3007 * Need to check for IDOK because if the user just hits Return to
3008 * accept the default value, some reason this is what we get.
3009 */
3010 if (button == IDOK)
3011 {
3012 if (dialog_default_button > IDCANCEL)
3013 EndDialog(hwnd, dialog_default_button);
3014 }
3015 else
3016 EndDialog(hwnd, button - IDCANCEL);
3017 return TRUE;
3018 }
3019
3020 if ((message == WM_SYSCOMMAND) && (wParam == SC_CLOSE))
3021 {
3022 EndDialog(hwnd, 0);
3023 return TRUE;
3024 }
3025 return FALSE;
3026 }
3027
3028 /*
3029 * Create a dialog dynamically from the parameter strings.
3030 * type = type of dialog (question, alert, etc.)
3031 * title = dialog title. may be NULL for default title.
3032 * message = text to display. Dialog sizes to accommodate it.
3033 * buttons = '\n' separated list of button captions, default first.
3034 * dfltbutton = number of default button.
3035 *
3036 * This routine returns 1 if the first button is pressed,
3037 * 2 for the second, etc.
3038 *
3039 * 0 indicates Esc was pressed.
3040 * -1 for unexpected error
3041 *
3042 * If stubbing out this fn, return 1.
3043 */
3044
3045 static const char_u *dlg_icons[] = /* must match names in resource file */
3046 {
3047 "IDR_VIM",
3048 "IDR_VIM_ERROR",
3049 "IDR_VIM_ALERT",
3050 "IDR_VIM_INFO",
3051 "IDR_VIM_QUESTION"
3052 };
3053
3054 int
3055 gui_mch_dialog(
3056 int type,
3057 char_u *title,
3058 char_u *message,
3059 char_u *buttons,
3060 int dfltbutton,
3061 char_u *textfield)
3062 {
3063 WORD *p, *pdlgtemplate, *pnumitems;
3064 DWORD *dwp;
3065 int numButtons;
3066 int *buttonWidths, *buttonPositions;
3067 int buttonYpos;
3068 int nchar, i;
3069 DWORD lStyle;
3070 int dlgwidth = 0;
3071 int dlgheight;
3072 int editboxheight;
3073 int horizWidth = 0;
3074 int msgheight;
3075 char_u *pstart;
3076 char_u *pend;
3077 char_u *last_white;
3078 char_u *tbuffer;
3079 RECT rect;
3080 HWND hwnd;
3081 HDC hdc;
3082 HFONT font, oldFont;
3083 TEXTMETRIC fontInfo;
3084 int fontHeight;
3085 int textWidth, minButtonWidth, messageWidth;
3086 int maxDialogWidth;
3087 int maxDialogHeight;
3088 int scroll_flag = 0;
3089 int vertical;
3090 int dlgPaddingX;
3091 int dlgPaddingY;
3092 #ifdef USE_SYSMENU_FONT
3093 LOGFONT lfSysmenu;
3094 int use_lfSysmenu = FALSE;
3095 #endif
3096 garray_T ga;
3097 int l;
3098
3099 #ifndef NO_CONSOLE
3100 /* Don't output anything in silent mode ("ex -s") */
3101 if (silent_mode)
3102 return dfltbutton; /* return default option */
3103 #endif
3104
3105 #if 0
3106 /* If there is no window yet, open it. */
3107 if (s_hwnd == NULL && gui_mch_init() == FAIL)
3108 return dfltbutton;
3109 #else
3110 if (s_hwnd == NULL)
3111 get_dialog_font_metrics();
3112 #endif
3113
3114 if ((type < 0) || (type > VIM_LAST_TYPE))
3115 type = 0;
3116
3117 /* allocate some memory for dialog template */
3118 /* TODO should compute this really */
3119 pdlgtemplate = p = (PWORD)LocalAlloc(LPTR,
3120 DLG_ALLOC_SIZE + STRLEN(message) * 2);
3121
3122 if (p == NULL)
3123 return -1;
3124
3125 /*
3126 * make a copy of 'buttons' to fiddle with it. complier grizzles because
3127 * vim_strsave() doesn't take a const arg (why not?), so cast away the
3128 * const.
3129 */
3130 tbuffer = vim_strsave(buttons);
3131 if (tbuffer == NULL)
3132 return -1;
3133
3134 --dfltbutton; /* Change from one-based to zero-based */
3135
3136 /* Count buttons */
3137 numButtons = 1;
3138 for (i = 0; tbuffer[i] != '\0'; i++)
3139 {
3140 if (tbuffer[i] == DLG_BUTTON_SEP)
3141 numButtons++;
3142 }
3143 if (dfltbutton >= numButtons)
3144 dfltbutton = -1;
3145
3146 /* Allocate array to hold the width of each button */
3147 buttonWidths = (int *)lalloc(numButtons * sizeof(int), TRUE);
3148 if (buttonWidths == NULL)
3149 return -1;
3150
3151 /* Allocate array to hold the X position of each button */
3152 buttonPositions = (int *)lalloc(numButtons * sizeof(int), TRUE);
3153 if (buttonPositions == NULL)
3154 return -1;
3155
3156 /*
3157 * Calculate how big the dialog must be.
3158 */
3159 hwnd = GetDesktopWindow();
3160 hdc = GetWindowDC(hwnd);
3161 #ifdef USE_SYSMENU_FONT
3162 if (gui_w32_get_menu_font(&lfSysmenu) == OK)
3163 {
3164 font = CreateFontIndirect(&lfSysmenu);
3165 use_lfSysmenu = TRUE;
3166 }
3167 else
3168 #endif
3169 font = CreateFont(-DLG_FONT_POINT_SIZE, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3170 VARIABLE_PITCH , DLG_FONT_NAME);
3171 if (s_usenewlook)
3172 {
3173 oldFont = SelectFont(hdc, font);
3174 dlgPaddingX = DLG_PADDING_X;
3175 dlgPaddingY = DLG_PADDING_Y;
3176 }
3177 else
3178 {
3179 oldFont = SelectFont(hdc, GetStockObject(SYSTEM_FONT));
3180 dlgPaddingX = DLG_OLD_STYLE_PADDING_X;
3181 dlgPaddingY = DLG_OLD_STYLE_PADDING_Y;
3182 }
3183 GetTextMetrics(hdc, &fontInfo);
3184 fontHeight = fontInfo.tmHeight;
3185
3186 /* Minimum width for horizontal button */
3187 minButtonWidth = GetTextWidth(hdc, "Cancel", 6);
3188
3189 /* Maximum width of a dialog, if possible */
3190 if (s_hwnd == NULL)
3191 {
3192 RECT workarea_rect;
3193
3194 /* We don't have a window, use the desktop area. */
3195 get_work_area(&workarea_rect);
3196 maxDialogWidth = workarea_rect.right - workarea_rect.left - 100;
3197 if (maxDialogWidth > 600)
3198 maxDialogWidth = 600;
3199 maxDialogHeight = workarea_rect.bottom - workarea_rect.top - 100;
3200 }
3201 else
3202 {
3203 /* Use our own window for the size, unless it's very small. */
3204 GetWindowRect(s_hwnd, &rect);
3205 maxDialogWidth = rect.right - rect.left
3206 - GetSystemMetrics(SM_CXFRAME) * 2;
3207 if (maxDialogWidth < DLG_MIN_MAX_WIDTH)
3208 maxDialogWidth = DLG_MIN_MAX_WIDTH;
3209
3210 maxDialogHeight = rect.bottom - rect.top
3211 - GetSystemMetrics(SM_CXFRAME) * 2;
3212 if (maxDialogHeight < DLG_MIN_MAX_HEIGHT)
3213 maxDialogHeight = DLG_MIN_MAX_HEIGHT;
3214 }
3215
3216 /* Set dlgwidth to width of message.
3217 * Copy the message into "ga", changing NL to CR-NL and inserting line
3218 * breaks where needed. */
3219 pstart = message;
3220 messageWidth = 0;
3221 msgheight = 0;
3222 ga_init2(&ga, sizeof(char), 500);
3223 do
3224 {
3225 msgheight += fontHeight; /* at least one line */
3226
3227 /* Need to figure out where to break the string. The system does it
3228 * at a word boundary, which would mean we can't compute the number of
3229 * wrapped lines. */
3230 textWidth = 0;
3231 last_white = NULL;
3232 for (pend = pstart; *pend != NUL && *pend != '\n'; )
3233 {
3234 #ifdef FEAT_MBYTE
3235 l = (*mb_ptr2len)(pend);
3236 #else
3237 l = 1;
3238 #endif
3239 if (l == 1 && vim_iswhite(*pend)
3240 && textWidth > maxDialogWidth * 3 / 4)
3241 last_white = pend;
3242 textWidth += GetTextWidth(hdc, pend, l);
3243 if (textWidth >= maxDialogWidth)
3244 {
3245 /* Line will wrap. */
3246 messageWidth = maxDialogWidth;
3247 msgheight += fontHeight;
3248 textWidth = 0;
3249
3250 if (last_white != NULL)
3251 {
3252 /* break the line just after a space */
3253 ga.ga_len -= (int)(pend - (last_white + 1));
3254 pend = last_white + 1;
3255 last_white = NULL;
3256 }
3257 ga_append(&ga, '\r');
3258 ga_append(&ga, '\n');
3259 continue;
3260 }
3261
3262 while (--l >= 0)
3263 ga_append(&ga, *pend++);
3264 }
3265 if (textWidth > messageWidth)
3266 messageWidth = textWidth;
3267
3268 ga_append(&ga, '\r');
3269 ga_append(&ga, '\n');
3270 pstart = pend + 1;
3271 } while (*pend != NUL);
3272
3273 if (ga.ga_data != NULL)
3274 message = ga.ga_data;
3275
3276 messageWidth += 10; /* roundoff space */
3277
3278 /* Restrict the size to a maximum. Causes a scrollbar to show up. */
3279 if (msgheight > maxDialogHeight)
3280 {
3281 msgheight = maxDialogHeight;
3282 scroll_flag = WS_VSCROLL;
3283 messageWidth += GetSystemMetrics(SM_CXVSCROLL);
3284 }
3285
3286 /* Add width of icon to dlgwidth, and some space */
3287 dlgwidth = messageWidth + DLG_ICON_WIDTH + 3 * dlgPaddingX;
3288
3289 if (msgheight < DLG_ICON_HEIGHT)
3290 msgheight = DLG_ICON_HEIGHT;
3291
3292 /*
3293 * Check button names. A long one will make the dialog wider.
3294 * When called early (-register error message) p_go isn't initialized.
3295 */
3296 vertical = (p_go != NULL && vim_strchr(p_go, GO_VERTICAL) != NULL);
3297 if (!vertical)
3298 {
3299 // Place buttons horizontally if they fit.
3300 horizWidth = dlgPaddingX;
3301 pstart = tbuffer;
3302 i = 0;
3303 do
3304 {
3305 pend = vim_strchr(pstart, DLG_BUTTON_SEP);
3306 if (pend == NULL)
3307 pend = pstart + STRLEN(pstart); // Last button name.
3308 textWidth = GetTextWidth(hdc, pstart, (int)(pend - pstart));
3309 if (textWidth < minButtonWidth)
3310 textWidth = minButtonWidth;
3311 textWidth += dlgPaddingX; /* Padding within button */
3312 buttonWidths[i] = textWidth;
3313 buttonPositions[i++] = horizWidth;
3314 horizWidth += textWidth + dlgPaddingX; /* Pad between buttons */
3315 pstart = pend + 1;
3316 } while (*pend != NUL);
3317
3318 if (horizWidth > maxDialogWidth)
3319 vertical = TRUE; // Too wide to fit on the screen.
3320 else if (horizWidth > dlgwidth)
3321 dlgwidth = horizWidth;
3322 }
3323
3324 if (vertical)
3325 {
3326 // Stack buttons vertically.
3327 pstart = tbuffer;
3328 do
3329 {
3330 pend = vim_strchr(pstart, DLG_BUTTON_SEP);
3331 if (pend == NULL)
3332 pend = pstart + STRLEN(pstart); // Last button name.
3333 textWidth = GetTextWidth(hdc, pstart, (int)(pend - pstart));
3334 textWidth += dlgPaddingX; /* Padding within button */
3335 textWidth += DLG_VERT_PADDING_X * 2; /* Padding around button */
3336 if (textWidth > dlgwidth)
3337 dlgwidth = textWidth;
3338 pstart = pend + 1;
3339 } while (*pend != NUL);
3340 }
3341
3342 if (dlgwidth < DLG_MIN_WIDTH)
3343 dlgwidth = DLG_MIN_WIDTH; /* Don't allow a really thin dialog!*/
3344
3345 /* start to fill in the dlgtemplate information. addressing by WORDs */
3346 if (s_usenewlook)
3347 lStyle = DS_MODALFRAME | WS_CAPTION |DS_3DLOOK| WS_VISIBLE |DS_SETFONT;
3348 else
3349 lStyle = DS_MODALFRAME | WS_CAPTION |DS_3DLOOK| WS_VISIBLE;
3350
3351 add_long(lStyle);
3352 add_long(0); // (lExtendedStyle)
3353 pnumitems = p; /*save where the number of items must be stored*/
3354 add_word(0); // NumberOfItems(will change later)
3355 add_word(10); // x
3356 add_word(10); // y
3357 add_word(PixelToDialogX(dlgwidth)); // cx
3358
3359 // Dialog height.
3360 if (vertical)
3361 dlgheight = msgheight + 2 * dlgPaddingY +
3362 DLG_VERT_PADDING_Y + 2 * fontHeight * numButtons;
3363 else
3364 dlgheight = msgheight + 3 * dlgPaddingY + 2 * fontHeight;
3365
3366 // Dialog needs to be taller if contains an edit box.
3367 editboxheight = fontHeight + dlgPaddingY + 4 * DLG_VERT_PADDING_Y;
3368 if (textfield != NULL)
3369 dlgheight += editboxheight;
3370
3371 add_word(PixelToDialogY(dlgheight));
3372
3373 add_word(0); // Menu
3374 add_word(0); // Class
3375
3376 /* copy the title of the dialog */
3377 nchar = nCopyAnsiToWideChar(p, (title ?
3378 (LPSTR)title :
3379 (LPSTR)("Vim "VIM_VERSION_MEDIUM)));
3380 p += nchar;
3381
3382 if (s_usenewlook)
3383 {
3384 /* do the font, since DS_3DLOOK doesn't work properly */
3385 #ifdef USE_SYSMENU_FONT
3386 if (use_lfSysmenu)
3387 {
3388 /* point size */
3389 *p++ = -MulDiv(lfSysmenu.lfHeight, 72,
3390 GetDeviceCaps(hdc, LOGPIXELSY));
3391 nchar = nCopyAnsiToWideChar(p, TEXT(lfSysmenu.lfFaceName));
3392 }
3393 else
3394 #endif
3395 {
3396 *p++ = DLG_FONT_POINT_SIZE; // point size
3397 nchar = nCopyAnsiToWideChar(p, TEXT(DLG_FONT_NAME));
3398 }
3399 p += nchar;
3400 }
3401
3402 buttonYpos = msgheight + 2 * dlgPaddingY;
3403
3404 if (textfield != NULL)
3405 buttonYpos += editboxheight;
3406
3407 pstart = tbuffer;
3408 if (!vertical)
3409 horizWidth = (dlgwidth - horizWidth) / 2; /* Now it's X offset */
3410 for (i = 0; i < numButtons; i++)
3411 {
3412 /* get end of this button. */
3413 for ( pend = pstart;
3414 *pend && (*pend != DLG_BUTTON_SEP);
3415 pend++)
3416 ;
3417
3418 if (*pend)
3419 *pend = '\0';
3420
3421 /*
3422 * old NOTE:
3423 * setting the BS_DEFPUSHBUTTON style doesn't work because Windows sets
3424 * the focus to the first tab-able button and in so doing makes that
3425 * the default!! Grrr. Workaround: Make the default button the only
3426 * one with WS_TABSTOP style. Means user can't tab between buttons, but
3427 * he/she can use arrow keys.
3428 *
3429 * new NOTE: BS_DEFPUSHBUTTON is required to be able to select the
3430 * right button when hitting <Enter>. E.g., for the ":confirm quit"
3431 * dialog. Also needed for when the textfield is the default control.
3432 * It appears to work now (perhaps not on Win95?).
3433 */
3434 if (vertical)
3435 {
3436 p = add_dialog_element(p,
3437 (i == dfltbutton
3438 ? BS_DEFPUSHBUTTON : BS_PUSHBUTTON) | WS_TABSTOP,
3439 PixelToDialogX(DLG_VERT_PADDING_X),
3440 PixelToDialogY(buttonYpos /* TBK */
3441 + 2 * fontHeight * i),
3442 PixelToDialogX(dlgwidth - 2 * DLG_VERT_PADDING_X),
3443 (WORD)(PixelToDialogY(2 * fontHeight) - 1),
3444 (WORD)(IDCANCEL + 1 + i), (WORD)0x0080, pstart);
3445 }
3446 else
3447 {
3448 p = add_dialog_element(p,
3449 (i == dfltbutton
3450 ? BS_DEFPUSHBUTTON : BS_PUSHBUTTON) | WS_TABSTOP,
3451 PixelToDialogX(horizWidth + buttonPositions[i]),
3452 PixelToDialogY(buttonYpos), /* TBK */
3453 PixelToDialogX(buttonWidths[i]),
3454 (WORD)(PixelToDialogY(2 * fontHeight) - 1),
3455 (WORD)(IDCANCEL + 1 + i), (WORD)0x0080, pstart);
3456 }
3457 pstart = pend + 1; /*next button*/
3458 }
3459 *pnumitems += numButtons;
3460
3461 /* Vim icon */
3462 p = add_dialog_element(p, SS_ICON,
3463 PixelToDialogX(dlgPaddingX),
3464 PixelToDialogY(dlgPaddingY),
3465 PixelToDialogX(DLG_ICON_WIDTH),
3466 PixelToDialogY(DLG_ICON_HEIGHT),
3467 DLG_NONBUTTON_CONTROL + 0, (WORD)0x0082,
3468 dlg_icons[type]);
3469
3470 #if 0
3471 /* Dialog message */
3472 p = add_dialog_element(p, SS_LEFT,
3473 PixelToDialogX(2 * dlgPaddingX + DLG_ICON_WIDTH),
3474 PixelToDialogY(dlgPaddingY),
3475 (WORD)(PixelToDialogX(messageWidth) + 1),
3476 PixelToDialogY(msgheight),
3477 DLG_NONBUTTON_CONTROL + 1, (WORD)0x0082, message);
3478 #else
3479 /* Dialog message */
3480 p = add_dialog_element(p, ES_LEFT|scroll_flag|ES_MULTILINE|ES_READONLY,
3481 PixelToDialogX(2 * dlgPaddingX + DLG_ICON_WIDTH),
3482 PixelToDialogY(dlgPaddingY),
3483 (WORD)(PixelToDialogX(messageWidth) + 1),
3484 PixelToDialogY(msgheight),
3485 DLG_NONBUTTON_CONTROL + 1, (WORD)0x0081, message);
3486 #endif
3487
3488 /* Edit box */
3489 if (textfield != NULL)
3490 {
3491 p = add_dialog_element(p, ES_LEFT|ES_AUTOHSCROLL|WS_TABSTOP|WS_BORDER,
3492 PixelToDialogX(2 * dlgPaddingX),
3493 PixelToDialogY(2 * dlgPaddingY + msgheight),
3494 PixelToDialogX(dlgwidth - 4 * dlgPaddingX),
3495 PixelToDialogY(fontHeight + dlgPaddingY),
3496 DLG_NONBUTTON_CONTROL + 2, (WORD)0x0081, textfield);
3497 *pnumitems += 1;
3498 }
3499
3500 *pnumitems += 2;
3501
3502 SelectFont(hdc, oldFont);
3503 DeleteObject(font);
3504 ReleaseDC(hwnd, hdc);
3505
3506 /* Let the dialog_callback() function know which button to make default
3507 * If we have an edit box, make that the default. We also need to tell
3508 * dialog_callback() if this dialog contains an edit box or not. We do
3509 * this by setting s_textfield if it does.
3510 */
3511 if (textfield != NULL)
3512 {
3513 dialog_default_button = DLG_NONBUTTON_CONTROL + 2;
3514 s_textfield = textfield;
3515 }
3516 else
3517 {
3518 dialog_default_button = IDCANCEL + 1 + dfltbutton;
3519 s_textfield = NULL;
3520 }
3521
3522 /* show the dialog box modally and get a return value */
3523 nchar = (int)DialogBoxIndirect(
3524 s_hinst,
3525 (LPDLGTEMPLATE)pdlgtemplate,
3526 s_hwnd,
3527 (DLGPROC)dialog_callback);
3528
3529 LocalFree(LocalHandle(pdlgtemplate));
3530 vim_free(tbuffer);
3531 vim_free(buttonWidths);
3532 vim_free(buttonPositions);
3533 vim_free(ga.ga_data);
3534
3535 /* Focus back to our window (for when MDI is used). */
3536 (void)SetFocus(s_hwnd);
3537
3538 return nchar;
3539 }
3540
3541 #endif /* FEAT_GUI_DIALOG */
3542
3543 /*
3544 * Put a simple element (basic class) onto a dialog template in memory.
3545 * return a pointer to where the next item should be added.
3546 *
3547 * parameters:
3548 * lStyle = additional style flags
3549 * (be careful, NT3.51 & Win32s will ignore the new ones)
3550 * x,y = x & y positions IN DIALOG UNITS
3551 * w,h = width and height IN DIALOG UNITS
3552 * Id = ID used in messages
3553 * clss = class ID, e.g 0x0080 for a button, 0x0082 for a static
3554 * caption = usually text or resource name
3555 *
3556 * TODO: use the length information noted here to enable the dialog creation
3557 * routines to work out more exactly how much memory they need to alloc.
3558 */
3559 static PWORD
3560 add_dialog_element(
3561 PWORD p,
3562 DWORD lStyle,
3563 WORD x,
3564 WORD y,
3565 WORD w,
3566 WORD h,
3567 WORD Id,
3568 WORD clss,
3569 const char *caption)
3570 {
3571 int nchar;
3572
3573 p = lpwAlign(p); /* Align to dword boundary*/
3574 lStyle = lStyle | WS_VISIBLE | WS_CHILD;
3575 *p++ = LOWORD(lStyle);
3576 *p++ = HIWORD(lStyle);
3577 *p++ = 0; // LOWORD (lExtendedStyle)
3578 *p++ = 0; // HIWORD (lExtendedStyle)
3579 *p++ = x;
3580 *p++ = y;
3581 *p++ = w;
3582 *p++ = h;
3583 *p++ = Id; //9 or 10 words in all
3584
3585 *p++ = (WORD)0xffff;
3586 *p++ = clss; //2 more here
3587
3588 nchar = nCopyAnsiToWideChar(p, (LPSTR)caption); //strlen(caption)+1
3589 p += nchar;
3590
3591 *p++ = 0; // advance pointer over nExtraStuff WORD - 2 more
3592
3593 return p; //total = 15+ (strlen(caption)) words
3594 // = 30 + 2(strlen(caption) bytes reqd
3595 }
3596
3597
3598 /*
3599 * Helper routine. Take an input pointer, return closest pointer that is
3600 * aligned on a DWORD (4 byte) boundary. Taken from the Win32SDK samples.
3601 */
3602 static LPWORD
3603 lpwAlign(
3604 LPWORD lpIn)
3605 {
3606 long_u ul;
3607
3608 ul = (long_u)lpIn;
3609 ul += 3;
3610 ul >>= 2;
3611 ul <<= 2;
3612 return (LPWORD)ul;
3613 }
3614
3615 /*
3616 * Helper routine. Takes second parameter as Ansi string, copies it to first
3617 * parameter as wide character (16-bits / char) string, and returns integer
3618 * number of wide characters (words) in string (including the trailing wide
3619 * char NULL). Partly taken from the Win32SDK samples.
3620 */
3621 static int
3622 nCopyAnsiToWideChar(
3623 LPWORD lpWCStr,
3624 LPSTR lpAnsiIn)
3625 {
3626 int nChar = 0;
3627 #ifdef FEAT_MBYTE
3628 int len = lstrlen(lpAnsiIn) + 1; /* include NUL character */
3629 int i;
3630 WCHAR *wn;
3631
3632 if (enc_codepage == 0 && (int)GetACP() != enc_codepage)
3633 {
3634 /* Not a codepage, use our own conversion function. */
3635 wn = enc_to_utf16(lpAnsiIn, NULL);
3636 if (wn != NULL)
3637 {
3638 wcscpy(lpWCStr, wn);
3639 nChar = (int)wcslen(wn) + 1;
3640 vim_free(wn);
3641 }
3642 }
3643 if (nChar == 0)
3644 /* Use Win32 conversion function. */
3645 nChar = MultiByteToWideChar(
3646 enc_codepage > 0 ? enc_codepage : CP_ACP,
3647 MB_PRECOMPOSED,
3648 lpAnsiIn, len,
3649 lpWCStr, len);
3650 for (i = 0; i < nChar; ++i)
3651 if (lpWCStr[i] == (WORD)'\t') /* replace tabs with spaces */
3652 lpWCStr[i] = (WORD)' ';
3653 #else
3654 do
3655 {
3656 if (*lpAnsiIn == '\t')
3657 *lpWCStr++ = (WORD)' ';
3658 else
3659 *lpWCStr++ = (WORD)*lpAnsiIn;
3660 nChar++;
3661 } while (*lpAnsiIn++);
3662 #endif
3663
3664 return nChar;
3665 }
3666
3667
3668 #ifdef FEAT_TEAROFF
3669 /*
3670 * The callback function for all the modeless dialogs that make up the
3671 * "tearoff menus" Very simple - forward button presses (to fool Vim into
3672 * thinking its menus have been clicked), and go away when closed.
3673 */
3674 static LRESULT CALLBACK
3675 tearoff_callback(
3676 HWND hwnd,
3677 UINT message,
3678 WPARAM wParam,
3679 LPARAM lParam)
3680 {
3681 if (message == WM_INITDIALOG)
3682 return (TRUE);
3683
3684 /* May show the mouse pointer again. */
3685 HandleMouseHide(message, lParam);
3686
3687 if (message == WM_COMMAND)
3688 {
3689 if ((WORD)(LOWORD(wParam)) & 0x8000)
3690 {
3691 POINT mp;
3692 RECT rect;
3693
3694 if (GetCursorPos(&mp) && GetWindowRect(hwnd, &rect))
3695 {
3696 (void)TrackPopupMenu(
3697 (HMENU)(long_u)(LOWORD(wParam) ^ 0x8000),
3698 TPM_LEFTALIGN | TPM_LEFTBUTTON,
3699 (int)rect.right - 8,
3700 (int)mp.y,
3701 (int)0, /*reserved param*/
3702 s_hwnd,
3703 NULL);
3704 /*
3705 * NOTE: The pop-up menu can eat the mouse up event.
3706 * We deal with this in normal.c.
3707 */
3708 }
3709 }
3710 else
3711 /* Pass on messages to the main Vim window */
3712 PostMessage(s_hwnd, WM_COMMAND, LOWORD(wParam), 0);
3713 /*
3714 * Give main window the focus back: this is so after
3715 * choosing a tearoff button you can start typing again
3716 * straight away.
3717 */
3718 (void)SetFocus(s_hwnd);
3719 return TRUE;
3720 }
3721 if ((message == WM_SYSCOMMAND) && (wParam == SC_CLOSE))
3722 {
3723 DestroyWindow(hwnd);
3724 return TRUE;
3725 }
3726
3727 /* When moved around, give main window the focus back. */
3728 if (message == WM_EXITSIZEMOVE)
3729 (void)SetActiveWindow(s_hwnd);
3730
3731 return FALSE;
3732 }
3733 #endif
3734
3735
3736 /*
3737 * Decide whether to use the "new look" (small, non-bold font) or the "old
3738 * look" (big, clanky font) for dialogs, and work out a few values for use
3739 * later accordingly.
3740 */
3741 static void
3742 get_dialog_font_metrics(void)
3743 {
3744 HDC hdc;
3745 HFONT hfontTools = 0;
3746 DWORD dlgFontSize;
3747 SIZE size;
3748 #ifdef USE_SYSMENU_FONT
3749 LOGFONT lfSysmenu;
3750 #endif
3751
3752 s_usenewlook = FALSE;
3753
3754 /*
3755 * For NT3.51 and Win32s, we stick with the old look
3756 * because it matches everything else.
3757 */
3758 if (!is_winnt_3())
3759 {
3760 #ifdef USE_SYSMENU_FONT
3761 if (gui_w32_get_menu_font(&lfSysmenu) == OK)
3762 hfontTools = CreateFontIndirect(&lfSysmenu);
3763 else
3764 #endif
3765 hfontTools = CreateFont(-DLG_FONT_POINT_SIZE, 0, 0, 0, 0, 0, 0, 0,
3766 0, 0, 0, 0, VARIABLE_PITCH , DLG_FONT_NAME);
3767
3768 if (hfontTools)
3769 {
3770 hdc = GetDC(s_hwnd);
3771 SelectObject(hdc, hfontTools);
3772 /*
3773 * GetTextMetrics() doesn't return the right value in
3774 * tmAveCharWidth, so we have to figure out the dialog base units
3775 * ourselves.
3776 */
3777 GetTextExtentPoint(hdc,
3778 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",
3779 52, &size);
3780 ReleaseDC(s_hwnd, hdc);
3781
3782 s_dlgfntwidth = (WORD)((size.cx / 26 + 1) / 2);
3783 s_dlgfntheight = (WORD)size.cy;
3784 s_usenewlook = TRUE;
3785 }
3786 }
3787
3788 if (!s_usenewlook)
3789 {
3790 dlgFontSize = GetDialogBaseUnits(); /* fall back to big old system*/
3791 s_dlgfntwidth = LOWORD(dlgFontSize);
3792 s_dlgfntheight = HIWORD(dlgFontSize);
3793 }
3794 }
3795
3796 #if defined(FEAT_MENU) && defined(FEAT_TEAROFF)
3797 /*
3798 * Create a pseudo-"tearoff menu" based on the child
3799 * items of a given menu pointer.
3800 */
3801 static void
3802 gui_mch_tearoff(
3803 char_u *title,
3804 vimmenu_T *menu,
3805 int initX,
3806 int initY)
3807 {
3808 WORD *p, *pdlgtemplate, *pnumitems, *ptrueheight;
3809 int template_len;
3810 int nchar, textWidth, submenuWidth;
3811 DWORD lStyle;
3812 DWORD lExtendedStyle;
3813 WORD dlgwidth;
3814 WORD menuID;
3815 vimmenu_T *pmenu;
3816 vimmenu_T *the_menu = menu;
3817 HWND hwnd;
3818 HDC hdc;
3819 HFONT font, oldFont;
3820 int col, spaceWidth, len;
3821 int columnWidths[2];
3822 char_u *label, *text;
3823 int acLen = 0;
3824 int nameLen;
3825 int padding0, padding1, padding2 = 0;
3826 int sepPadding=0;
3827 int x;
3828 int y;
3829 #ifdef USE_SYSMENU_FONT
3830 LOGFONT lfSysmenu;
3831 int use_lfSysmenu = FALSE;
3832 #endif
3833
3834 /*
3835 * If this menu is already torn off, move it to the mouse position.
3836 */
3837 if (IsWindow(menu->tearoff_handle))
3838 {
3839 POINT mp;
3840 if (GetCursorPos((LPPOINT)&mp))
3841 {
3842 SetWindowPos(menu->tearoff_handle, NULL, mp.x, mp.y, 0, 0,
3843 SWP_NOACTIVATE | SWP_NOSIZE | SWP_NOZORDER);
3844 }
3845 return;
3846 }
3847
3848 /*
3849 * Create a new tearoff.
3850 */
3851 if (*title == MNU_HIDDEN_CHAR)
3852 title++;
3853
3854 /* Allocate memory to store the dialog template. It's made bigger when
3855 * needed. */
3856 template_len = DLG_ALLOC_SIZE;
3857 pdlgtemplate = p = (WORD *)LocalAlloc(LPTR, template_len);
3858 if (p == NULL)
3859 return;
3860
3861 hwnd = GetDesktopWindow();
3862 hdc = GetWindowDC(hwnd);
3863 #ifdef USE_SYSMENU_FONT
3864 if (gui_w32_get_menu_font(&lfSysmenu) == OK)
3865 {
3866 font = CreateFontIndirect(&lfSysmenu);
3867 use_lfSysmenu = TRUE;
3868 }
3869 else
3870 #endif
3871 font = CreateFont(-DLG_FONT_POINT_SIZE, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3872 VARIABLE_PITCH , DLG_FONT_NAME);
3873 if (s_usenewlook)
3874 oldFont = SelectFont(hdc, font);
3875 else
3876 oldFont = SelectFont(hdc, GetStockObject(SYSTEM_FONT));
3877
3878 /* Calculate width of a single space. Used for padding columns to the
3879 * right width. */
3880 spaceWidth = GetTextWidth(hdc, " ", 1);
3881
3882 /* Figure out max width of the text column, the accelerator column and the
3883 * optional submenu column. */
3884 submenuWidth = 0;
3885 for (col = 0; col < 2; col++)
3886 {
3887 columnWidths[col] = 0;
3888 for (pmenu = menu->children; pmenu != NULL; pmenu = pmenu->next)
3889 {
3890 /* Use "dname" here to compute the width of the visible text. */
3891 text = (col == 0) ? pmenu->dname : pmenu->actext;
3892 if (text != NULL && *text != NUL)
3893 {
3894 textWidth = GetTextWidthEnc(hdc, text, (int)STRLEN(text));
3895 if (textWidth > columnWidths[col])
3896 columnWidths[col] = textWidth;
3897 }
3898 if (pmenu->children != NULL)
3899 submenuWidth = TEAROFF_COLUMN_PADDING * spaceWidth;
3900 }
3901 }
3902 if (columnWidths[1] == 0)
3903 {
3904 /* no accelerators */
3905 if (submenuWidth != 0)
3906 columnWidths[0] += submenuWidth;
3907 else
3908 columnWidths[0] += spaceWidth;
3909 }
3910 else
3911 {
3912 /* there is an accelerator column */
3913 columnWidths[0] += TEAROFF_COLUMN_PADDING * spaceWidth;
3914 columnWidths[1] += submenuWidth;
3915 }
3916
3917 /*
3918 * Now find the total width of our 'menu'.
3919 */
3920 textWidth = columnWidths[0] + columnWidths[1];
3921 if (submenuWidth != 0)
3922 {
3923 submenuWidth = GetTextWidth(hdc, TEAROFF_SUBMENU_LABEL,
3924 (int)STRLEN(TEAROFF_SUBMENU_LABEL));
3925 textWidth += submenuWidth;
3926 }
3927 dlgwidth = GetTextWidthEnc(hdc, title, (int)STRLEN(title));
3928 if (textWidth > dlgwidth)
3929 dlgwidth = textWidth;
3930 dlgwidth += 2 * TEAROFF_PADDING_X + TEAROFF_BUTTON_PAD_X;
3931
3932 /* W95 can't do thin dialogs, they look v. weird! */
3933 if (mch_windows95() && dlgwidth < TEAROFF_MIN_WIDTH)
3934 dlgwidth = TEAROFF_MIN_WIDTH;
3935
3936 /* start to fill in the dlgtemplate information. addressing by WORDs */
3937 if (s_usenewlook)
3938 lStyle = DS_MODALFRAME | WS_CAPTION| WS_SYSMENU |DS_SETFONT| WS_VISIBLE;
3939 else
3940 lStyle = DS_MODALFRAME | WS_CAPTION| WS_SYSMENU | WS_VISIBLE;
3941
3942 lExtendedStyle = WS_EX_TOOLWINDOW|WS_EX_STATICEDGE;
3943 *p++ = LOWORD(lStyle);
3944 *p++ = HIWORD(lStyle);
3945 *p++ = LOWORD(lExtendedStyle);
3946 *p++ = HIWORD(lExtendedStyle);
3947 pnumitems = p; /* save where the number of items must be stored */
3948 *p++ = 0; // NumberOfItems(will change later)
3949 gui_mch_getmouse(&x, &y);
3950 if (initX == 0xffffL)
3951 *p++ = PixelToDialogX(x); // x
3952 else
3953 *p++ = PixelToDialogX(initX); // x
3954 if (initY == 0xffffL)
3955 *p++ = PixelToDialogY(y); // y
3956 else
3957 *p++ = PixelToDialogY(initY); // y
3958 *p++ = PixelToDialogX(dlgwidth); // cx
3959 ptrueheight = p;
3960 *p++ = 0; // dialog height: changed later anyway
3961 *p++ = 0; // Menu
3962 *p++ = 0; // Class
3963
3964 /* copy the title of the dialog */
3965 nchar = nCopyAnsiToWideChar(p, ((*title)
3966 ? (LPSTR)title
3967 : (LPSTR)("Vim "VIM_VERSION_MEDIUM)));
3968 p += nchar;
3969
3970 if (s_usenewlook)
3971 {
3972 /* do the font, since DS_3DLOOK doesn't work properly */
3973 #ifdef USE_SYSMENU_FONT
3974 if (use_lfSysmenu)
3975 {
3976 /* point size */
3977 *p++ = -MulDiv(lfSysmenu.lfHeight, 72,
3978 GetDeviceCaps(hdc, LOGPIXELSY));
3979 nchar = nCopyAnsiToWideChar(p, TEXT(lfSysmenu.lfFaceName));
3980 }
3981 else
3982 #endif
3983 {
3984 *p++ = DLG_FONT_POINT_SIZE; // point size
3985 nchar = nCopyAnsiToWideChar (p, TEXT(DLG_FONT_NAME));
3986 }
3987 p += nchar;
3988 }
3989
3990 /*
3991 * Loop over all the items in the menu.
3992 * But skip over the tearbar.
3993 */
3994 if (STRCMP(menu->children->name, TEAR_STRING) == 0)
3995 menu = menu->children->next;
3996 else
3997 menu = menu->children;
3998 for ( ; menu != NULL; menu = menu->next)
3999 {
4000 if (menu->modes == 0) /* this menu has just been deleted */
4001 continue;
4002 if (menu_is_separator(menu->dname))
4003 {
4004 sepPadding += 3;
4005 continue;
4006 }
4007
4008 /* Check if there still is plenty of room in the template. Make it
4009 * larger when needed. */
4010 if (((char *)p - (char *)pdlgtemplate) + 1000 > template_len)
4011 {
4012 WORD *newp;
4013
4014 newp = (WORD *)LocalAlloc(LPTR, template_len + 4096);
4015 if (newp != NULL)
4016 {
4017 template_len += 4096;
4018 mch_memmove(newp, pdlgtemplate,
4019 (char *)p - (char *)pdlgtemplate);
4020 p = newp + (p - pdlgtemplate);
4021 pnumitems = newp + (pnumitems - pdlgtemplate);
4022 ptrueheight = newp + (ptrueheight - pdlgtemplate);
4023 LocalFree(LocalHandle(pdlgtemplate));
4024 pdlgtemplate = newp;
4025 }
4026 }
4027
4028 /* Figure out minimal length of this menu label. Use "name" for the
4029 * actual text, "dname" for estimating the displayed size. "name"
4030 * has "&a" for mnemonic and includes the accelerator. */
4031 len = nameLen = (int)STRLEN(menu->name);
4032 padding0 = (columnWidths[0] - GetTextWidthEnc(hdc, menu->dname,
4033 (int)STRLEN(menu->dname))) / spaceWidth;
4034 len += padding0;
4035
4036 if (menu->actext != NULL)
4037 {
4038 acLen = (int)STRLEN(menu->actext);
4039 len += acLen;
4040 textWidth = GetTextWidthEnc(hdc, menu->actext, acLen);
4041 }
4042 else
4043 textWidth = 0;
4044 padding1 = (columnWidths[1] - textWidth) / spaceWidth;
4045 len += padding1;
4046
4047 if (menu->children == NULL)
4048 {
4049 padding2 = submenuWidth / spaceWidth;
4050 len += padding2;
4051 menuID = (WORD)(menu->id);
4052 }
4053 else
4054 {
4055 len += (int)STRLEN(TEAROFF_SUBMENU_LABEL);
4056 menuID = (WORD)((long_u)(menu->submenu_id) | (DWORD)0x8000);
4057 }
4058
4059 /* Allocate menu label and fill it in */
4060 text = label = alloc((unsigned)len + 1);
4061 if (label == NULL)
4062 break;
4063
4064 vim_strncpy(text, menu->name, nameLen);
4065 text = vim_strchr(text, TAB); /* stop at TAB before actext */
4066 if (text == NULL)
4067 text = label + nameLen; /* no actext, use whole name */
4068 while (padding0-- > 0)
4069 *text++ = ' ';
4070 if (menu->actext != NULL)
4071 {
4072 STRNCPY(text, menu->actext, acLen);
4073 text += acLen;
4074 }
4075 while (padding1-- > 0)
4076 *text++ = ' ';
4077 if (menu->children != NULL)
4078 {
4079 STRCPY(text, TEAROFF_SUBMENU_LABEL);
4080 text += STRLEN(TEAROFF_SUBMENU_LABEL);
4081 }
4082 else
4083 {
4084 while (padding2-- > 0)
4085 *text++ = ' ';
4086 }
4087 *text = NUL;
4088
4089 /*
4090 * BS_LEFT will just be ignored on Win32s/NT3.5x - on
4091 * W95/NT4 it makes the tear-off look more like a menu.
4092 */
4093 p = add_dialog_element(p,
4094 BS_PUSHBUTTON|BS_LEFT,
4095 (WORD)PixelToDialogX(TEAROFF_PADDING_X),
4096 (WORD)(sepPadding + 1 + 13 * (*pnumitems)),
4097 (WORD)PixelToDialogX(dlgwidth - 2 * TEAROFF_PADDING_X),
4098 (WORD)12,
4099 menuID, (WORD)0x0080, label);
4100 vim_free(label);
4101 (*pnumitems)++;
4102 }
4103
4104 *ptrueheight = (WORD)(sepPadding + 1 + 13 * (*pnumitems));
4105
4106
4107 /* show modelessly */
4108 the_menu->tearoff_handle = CreateDialogIndirect(
4109 s_hinst,
4110 (LPDLGTEMPLATE)pdlgtemplate,
4111 s_hwnd,
4112 (DLGPROC)tearoff_callback);
4113
4114 LocalFree(LocalHandle(pdlgtemplate));
4115 SelectFont(hdc, oldFont);
4116 DeleteObject(font);
4117 ReleaseDC(hwnd, hdc);
4118
4119 /*
4120 * Reassert ourselves as the active window. This is so that after creating
4121 * a tearoff, the user doesn't have to click with the mouse just to start
4122 * typing again!
4123 */
4124 (void)SetActiveWindow(s_hwnd);
4125
4126 /* make sure the right buttons are enabled */
4127 force_menu_update = TRUE;
4128 }
4129 #endif
4130
4131 #if defined(FEAT_TOOLBAR) || defined(PROTO)
4132 #include "gui_w32_rc.h"
4133
4134 /* This not defined in older SDKs */
4135 # ifndef TBSTYLE_FLAT
4136 # define TBSTYLE_FLAT 0x0800
4137 # endif
4138
4139 /*
4140 * Create the toolbar, initially unpopulated.
4141 * (just like the menu, there are no defaults, it's all
4142 * set up through menu.vim)
4143 */
4144 static void
4145 initialise_toolbar(void)
4146 {
4147 InitCommonControls();
4148 s_toolbarhwnd = CreateToolbarEx(
4149 s_hwnd,
4150 WS_CHILD | TBSTYLE_TOOLTIPS | TBSTYLE_FLAT,
4151 4000, //any old big number
4152 31, //number of images in initial bitmap
4153 s_hinst,
4154 IDR_TOOLBAR1, // id of initial bitmap
4155 NULL,
4156 0, // initial number of buttons
4157 TOOLBAR_BUTTON_WIDTH, //api guide is wrong!
4158 TOOLBAR_BUTTON_HEIGHT,
4159 TOOLBAR_BUTTON_WIDTH,
4160 TOOLBAR_BUTTON_HEIGHT,
4161 sizeof(TBBUTTON)
4162 );
4163
4164 gui_mch_show_toolbar(vim_strchr(p_go, GO_TOOLBAR) != NULL);
4165 }
4166
4167 static int
4168 get_toolbar_bitmap(vimmenu_T *menu)
4169 {
4170 int i = -1;
4171
4172 /*
4173 * Check user bitmaps first, unless builtin is specified.
4174 */
4175 if (!is_winnt_3() && !menu->icon_builtin)
4176 {
4177 char_u fname[MAXPATHL];
4178 HANDLE hbitmap = NULL;
4179
4180 if (menu->iconfile != NULL)
4181 {
4182 gui_find_iconfile(menu->iconfile, fname, "bmp");
4183 hbitmap = LoadImage(
4184 NULL,
4185 fname,
4186 IMAGE_BITMAP,
4187 TOOLBAR_BUTTON_WIDTH,
4188 TOOLBAR_BUTTON_HEIGHT,
4189 LR_LOADFROMFILE |
4190 LR_LOADMAP3DCOLORS
4191 );
4192 }
4193
4194 /*
4195 * If the LoadImage call failed, or the "icon=" file
4196 * didn't exist or wasn't specified, try the menu name
4197 */
4198 if (hbitmap == NULL
4199 && (gui_find_bitmap(menu->name, fname, "bmp") == OK))
4200 hbitmap = LoadImage(
4201 NULL,
4202 fname,
4203 IMAGE_BITMAP,
4204 TOOLBAR_BUTTON_WIDTH,
4205 TOOLBAR_BUTTON_HEIGHT,
4206 LR_LOADFROMFILE |
4207 LR_LOADMAP3DCOLORS
4208 );
4209
4210 if (hbitmap != NULL)
4211 {
4212 TBADDBITMAP tbAddBitmap;
4213
4214 tbAddBitmap.hInst = NULL;
4215 tbAddBitmap.nID = (long_u)hbitmap;
4216
4217 i = (int)SendMessage(s_toolbarhwnd, TB_ADDBITMAP,
4218 (WPARAM)1, (LPARAM)&tbAddBitmap);
4219 /* i will be set to -1 if it fails */
4220 }
4221 }
4222 if (i == -1 && menu->iconidx >= 0 && menu->iconidx < TOOLBAR_BITMAP_COUNT)
4223 i = menu->iconidx;
4224
4225 return i;
4226 }
4227 #endif
4228
4229 #if defined(FEAT_GUI_TABLINE) || defined(PROTO)
4230 static void
4231 initialise_tabline(void)
4232 {
4233 InitCommonControls();
4234
4235 s_tabhwnd = CreateWindow(WC_TABCONTROL, "Vim tabline",
4236 WS_CHILD|TCS_FOCUSNEVER|TCS_TOOLTIPS,
4237 CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
4238 CW_USEDEFAULT, s_hwnd, NULL, s_hinst, NULL);
4239
4240 gui.tabline_height = TABLINE_HEIGHT;
4241
4242 # ifdef USE_SYSMENU_FONT
4243 set_tabline_font();
4244 # endif
4245 }
4246 #endif
4247
4248 #if defined(FEAT_OLE) || defined(FEAT_EVAL) || defined(PROTO)
4249 /*
4250 * Make the GUI window come to the foreground.
4251 */
4252 void
4253 gui_mch_set_foreground(void)
4254 {
4255 if (IsIconic(s_hwnd))
4256 SendMessage(s_hwnd, WM_SYSCOMMAND, SC_RESTORE, 0);
4257 SetForegroundWindow(s_hwnd);
4258 }
4259 #endif
4260
4261 #if defined(FEAT_MBYTE_IME) && defined(DYNAMIC_IME)
4262 static void
4263 dyn_imm_load(void)
4264 {
4265 hLibImm = LoadLibrary("imm32.dll");
4266 if (hLibImm == NULL)
4267 return;
4268
4269 pImmGetCompositionStringA
4270 = (void *)GetProcAddress(hLibImm, "ImmGetCompositionStringA");
4271 pImmGetCompositionStringW
4272 = (void *)GetProcAddress(hLibImm, "ImmGetCompositionStringW");
4273 pImmGetContext
4274 = (void *)GetProcAddress(hLibImm, "ImmGetContext");
4275 pImmAssociateContext
4276 = (void *)GetProcAddress(hLibImm, "ImmAssociateContext");
4277 pImmReleaseContext
4278 = (void *)GetProcAddress(hLibImm, "ImmReleaseContext");
4279 pImmGetOpenStatus
4280 = (void *)GetProcAddress(hLibImm, "ImmGetOpenStatus");
4281 pImmSetOpenStatus
4282 = (void *)GetProcAddress(hLibImm, "ImmSetOpenStatus");
4283 pImmGetCompositionFont
4284 = (void *)GetProcAddress(hLibImm, "ImmGetCompositionFontA");
4285 pImmSetCompositionFont
4286 = (void *)GetProcAddress(hLibImm, "ImmSetCompositionFontA");
4287 pImmSetCompositionWindow
4288 = (void *)GetProcAddress(hLibImm, "ImmSetCompositionWindow");
4289 pImmGetConversionStatus
4290 = (void *)GetProcAddress(hLibImm, "ImmGetConversionStatus");
4291 pImmSetConversionStatus
4292 = (void *)GetProcAddress(hLibImm, "ImmSetConversionStatus");
4293
4294 if ( pImmGetCompositionStringA == NULL
4295 || pImmGetCompositionStringW == NULL
4296 || pImmGetContext == NULL
4297 || pImmAssociateContext == NULL
4298 || pImmReleaseContext == NULL
4299 || pImmGetOpenStatus == NULL
4300 || pImmSetOpenStatus == NULL
4301 || pImmGetCompositionFont == NULL
4302 || pImmSetCompositionFont == NULL
4303 || pImmSetCompositionWindow == NULL
4304 || pImmGetConversionStatus == NULL
4305 || pImmSetConversionStatus == NULL)
4306 {
4307 FreeLibrary(hLibImm);
4308 hLibImm = NULL;
4309 pImmGetContext = NULL;
4310 return;
4311 }
4312
4313 return;
4314 }
4315
4316 # if 0 /* not used */
4317 int
4318 dyn_imm_unload(void)
4319 {
4320 if (!hLibImm)
4321 return FALSE;
4322 FreeLibrary(hLibImm);
4323 hLibImm = NULL;
4324 return TRUE;
4325 }
4326 # endif
4327
4328 #endif
4329
4330 #if defined(FEAT_SIGN_ICONS) || defined(PROTO)
4331
4332 # ifdef FEAT_XPM_W32
4333 # define IMAGE_XPM 100
4334 # endif
4335
4336 typedef struct _signicon_t
4337 {
4338 HANDLE hImage;
4339 UINT uType;
4340 #ifdef FEAT_XPM_W32
4341 HANDLE hShape; /* Mask bitmap handle */
4342 #endif
4343 } signicon_t;
4344
4345 void
4346 gui_mch_drawsign(row, col, typenr)
4347 int row;
4348 int col;
4349 int typenr;
4350 {
4351 signicon_t *sign;
4352 int x, y, w, h;
4353
4354 if (!gui.in_use || (sign = (signicon_t *)sign_get_image(typenr)) == NULL)
4355 return;
4356
4357 x = TEXT_X(col);
4358 y = TEXT_Y(row);
4359 w = gui.char_width * 2;
4360 h = gui.char_height;
4361 switch (sign->uType)
4362 {
4363 case IMAGE_BITMAP:
4364 {
4365 HDC hdcMem;
4366 HBITMAP hbmpOld;
4367
4368 hdcMem = CreateCompatibleDC(s_hdc);
4369 hbmpOld = (HBITMAP)SelectObject(hdcMem, sign->hImage);
4370 BitBlt(s_hdc, x, y, w, h, hdcMem, 0, 0, SRCCOPY);
4371 SelectObject(hdcMem, hbmpOld);
4372 DeleteDC(hdcMem);
4373 }
4374 break;
4375 case IMAGE_ICON:
4376 case IMAGE_CURSOR:
4377 DrawIconEx(s_hdc, x, y, (HICON)sign->hImage, w, h, 0, NULL, DI_NORMAL);
4378 break;
4379 #ifdef FEAT_XPM_W32
4380 case IMAGE_XPM:
4381 {
4382 HDC hdcMem;
4383 HBITMAP hbmpOld;
4384
4385 hdcMem = CreateCompatibleDC(s_hdc);
4386 hbmpOld = (HBITMAP)SelectObject(hdcMem, sign->hShape);
4387 /* Make hole */
4388 BitBlt(s_hdc, x, y, w, h, hdcMem, 0, 0, SRCAND);
4389
4390 SelectObject(hdcMem, sign->hImage);
4391 /* Paint sign */
4392 BitBlt(s_hdc, x, y, w, h, hdcMem, 0, 0, SRCPAINT);
4393 SelectObject(hdcMem, hbmpOld);
4394 DeleteDC(hdcMem);
4395 }
4396 break;
4397 #endif
4398 }
4399 }
4400
4401 static void
4402 close_signicon_image(signicon_t *sign)
4403 {
4404 if (sign)
4405 switch (sign->uType)
4406 {
4407 case IMAGE_BITMAP:
4408 DeleteObject((HGDIOBJ)sign->hImage);
4409 break;
4410 case IMAGE_CURSOR:
4411 DestroyCursor((HCURSOR)sign->hImage);
4412 break;
4413 case IMAGE_ICON:
4414 DestroyIcon((HICON)sign->hImage);
4415 break;
4416 #ifdef FEAT_XPM_W32
4417 case IMAGE_XPM:
4418 DeleteObject((HBITMAP)sign->hImage);
4419 DeleteObject((HBITMAP)sign->hShape);
4420 break;
4421 #endif
4422 }
4423 }
4424
4425 void *
4426 gui_mch_register_sign(signfile)
4427 char_u *signfile;
4428 {
4429 signicon_t sign, *psign;
4430 char_u *ext;
4431
4432 if (is_winnt_3())
4433 {
4434 EMSG(_(e_signdata));
4435 return NULL;
4436 }
4437
4438 sign.hImage = NULL;
4439 ext = signfile + STRLEN(signfile) - 4; /* get extention */
4440 if (ext > signfile)
4441 {
4442 int do_load = 1;
4443
4444 if (!STRICMP(ext, ".bmp"))
4445 sign.uType = IMAGE_BITMAP;
4446 else if (!STRICMP(ext, ".ico"))
4447 sign.uType = IMAGE_ICON;
4448 else if (!STRICMP(ext, ".cur") || !STRICMP(ext, ".ani"))
4449 sign.uType = IMAGE_CURSOR;
4450 else
4451 do_load = 0;
4452
4453 if (do_load)
4454 sign.hImage = (HANDLE)LoadImage(NULL, signfile, sign.uType,
4455 gui.char_width * 2, gui.char_height,
4456 LR_LOADFROMFILE | LR_CREATEDIBSECTION);
4457 #ifdef FEAT_XPM_W32
4458 if (!STRICMP(ext, ".xpm"))
4459 {
4460 sign.uType = IMAGE_XPM;
4461 LoadXpmImage(signfile, (HBITMAP *)&sign.hImage, (HBITMAP *)&sign.hShape);
4462 }
4463 #endif
4464 }
4465
4466 psign = NULL;
4467 if (sign.hImage && (psign = (signicon_t *)alloc(sizeof(signicon_t)))
4468 != NULL)
4469 *psign = sign;
4470
4471 if (!psign)
4472 {
4473 if (sign.hImage)
4474 close_signicon_image(&sign);
4475 EMSG(_(e_signdata));
4476 }
4477 return (void *)psign;
4478
4479 }
4480
4481 void
4482 gui_mch_destroy_sign(sign)
4483 void *sign;
4484 {
4485 if (sign)
4486 {
4487 close_signicon_image((signicon_t *)sign);
4488 vim_free(sign);
4489 }
4490 }
4491 #endif
4492
4493 #if defined(FEAT_BEVAL) || defined(PROTO)
4494
4495 /* BALLOON-EVAL IMPLEMENTATION FOR WINDOWS.
4496 * Added by Sergey Khorev <sergey.khorev@gmail.com>
4497 *
4498 * The only reused thing is gui_beval.h and get_beval_info()
4499 * from gui_beval.c (note it uses x and y of the BalloonEval struct
4500 * to get current mouse position).
4501 *
4502 * Trying to use as more Windows services as possible, and as less
4503 * IE version as possible :)).
4504 *
4505 * 1) Don't create ToolTip in gui_mch_create_beval_area, only initialize
4506 * BalloonEval struct.
4507 * 2) Enable/Disable simply create/kill BalloonEval Timer
4508 * 3) When there was enough inactivity, timer procedure posts
4509 * async request to debugger
4510 * 4) gui_mch_post_balloon (invoked from netbeans.c) creates tooltip control
4511 * and performs some actions to show it ASAP
4512 * 5) WM_NOTIFY:TTN_POP destroys created tooltip
4513 */
4514
4515 /*
4516 * determine whether installed Common Controls support multiline tooltips
4517 * (i.e. their version is >= 4.70
4518 */
4519 int
4520 multiline_balloon_available(void)
4521 {
4522 HINSTANCE hDll;
4523 static char comctl_dll[] = "comctl32.dll";
4524 static int multiline_tip = MAYBE;
4525
4526 if (multiline_tip != MAYBE)
4527 return multiline_tip;
4528
4529 hDll = GetModuleHandle(comctl_dll);
4530 if (hDll != NULL)
4531 {
4532 DLLGETVERSIONPROC pGetVer;
4533 pGetVer = (DLLGETVERSIONPROC)GetProcAddress(hDll, "DllGetVersion");
4534
4535 if (pGetVer != NULL)
4536 {
4537 DLLVERSIONINFO dvi;
4538 HRESULT hr;
4539
4540 ZeroMemory(&dvi, sizeof(dvi));
4541 dvi.cbSize = sizeof(dvi);
4542
4543 hr = (*pGetVer)(&dvi);
4544
4545 if (SUCCEEDED(hr)
4546 && (dvi.dwMajorVersion > 4
4547 || (dvi.dwMajorVersion == 4
4548 && dvi.dwMinorVersion >= 70)))
4549 {
4550 multiline_tip = TRUE;
4551 return multiline_tip;
4552 }
4553 }
4554 else
4555 {
4556 /* there is chance we have ancient CommCtl 4.70
4557 which doesn't export DllGetVersion */
4558 DWORD dwHandle = 0;
4559 DWORD len = GetFileVersionInfoSize(comctl_dll, &dwHandle);
4560 if (len > 0)
4561 {
4562 VS_FIXEDFILEINFO *ver;
4563 UINT vlen = 0;
4564 void *data = alloc(len);
4565
4566 if (data != NULL
4567 && GetFileVersionInfo(comctl_dll, 0, len, data)
4568 && VerQueryValue(data, "\\", (void **)&ver, &vlen)
4569 && vlen
4570 && HIWORD(ver->dwFileVersionMS) > 4
4571 || (HIWORD(ver->dwFileVersionMS) == 4
4572 && LOWORD(ver->dwFileVersionMS) >= 70))
4573 {
4574 vim_free(data);
4575 multiline_tip = TRUE;
4576 return multiline_tip;
4577 }
4578 vim_free(data);
4579 }
4580 }
4581 }
4582 multiline_tip = FALSE;
4583 return multiline_tip;
4584 }
4585
4586 static void
4587 make_tooltip(beval, text, pt)
4588 BalloonEval *beval;
4589 char *text;
4590 POINT pt;
4591 {
4592 TOOLINFO *pti;
4593 int ToolInfoSize;
4594
4595 if (multiline_balloon_available() == TRUE)
4596 ToolInfoSize = sizeof(TOOLINFO_NEW);
4597 else
4598 ToolInfoSize = sizeof(TOOLINFO);
4599
4600 pti = (TOOLINFO *)alloc(ToolInfoSize);
4601 if (pti == NULL)
4602 return;
4603
4604 beval->balloon = CreateWindowEx(WS_EX_TOPMOST, TOOLTIPS_CLASS,
4605 NULL, WS_POPUP | TTS_NOPREFIX | TTS_ALWAYSTIP,
4606 CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
4607 beval->target, NULL, s_hinst, NULL);
4608
4609 SetWindowPos(beval->balloon, HWND_TOPMOST, 0, 0, 0, 0,
4610 SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);
4611
4612 pti->cbSize = ToolInfoSize;
4613 pti->uFlags = TTF_SUBCLASS;
4614 pti->hwnd = beval->target;
4615 pti->hinst = 0; /* Don't use string resources */
4616 pti->uId = ID_BEVAL_TOOLTIP;
4617
4618 if (multiline_balloon_available() == TRUE)
4619 {
4620 RECT rect;
4621 TOOLINFO_NEW *ptin = (TOOLINFO_NEW *)pti;
4622 pti->lpszText = LPSTR_TEXTCALLBACK;
4623 ptin->lParam = (LPARAM)text;
4624 if (GetClientRect(s_textArea, &rect)) /* switch multiline tooltips on */
4625 SendMessage(beval->balloon, TTM_SETMAXTIPWIDTH, 0,
4626 (LPARAM)rect.right);
4627 }
4628 else
4629 pti->lpszText = text; /* do this old way */
4630
4631 /* Limit ballooneval bounding rect to CursorPos neighbourhood */
4632 pti->rect.left = pt.x - 3;
4633 pti->rect.top = pt.y - 3;
4634 pti->rect.right = pt.x + 3;
4635 pti->rect.bottom = pt.y + 3;
4636
4637 SendMessage(beval->balloon, TTM_ADDTOOL, 0, (LPARAM)pti);
4638 /* Make tooltip appear sooner */
4639 SendMessage(beval->balloon, TTM_SETDELAYTIME, TTDT_INITIAL, 10);
4640 /* I've performed some tests and it seems the longest possible life time
4641 * of tooltip is 30 seconds */
4642 SendMessage(beval->balloon, TTM_SETDELAYTIME, TTDT_AUTOPOP, 30000);
4643 /*
4644 * HACK: force tooltip to appear, because it'll not appear until
4645 * first mouse move. D*mn M$
4646 * Amazingly moving (2, 2) and then (-1, -1) the mouse doesn't move.
4647 */
4648 mouse_event(MOUSEEVENTF_MOVE, 2, 2, 0, 0);
4649 mouse_event(MOUSEEVENTF_MOVE, (DWORD)-1, (DWORD)-1, 0, 0);
4650 vim_free(pti);
4651 }
4652
4653 static void
4654 delete_tooltip(beval)
4655 BalloonEval *beval;
4656 {
4657 DestroyWindow(beval->balloon);
4658 }
4659
4660 /*ARGSUSED*/
4661 static VOID CALLBACK
4662 BevalTimerProc(hwnd, uMsg, idEvent, dwTime)
4663 HWND hwnd;
4664 UINT uMsg;
4665 UINT_PTR idEvent;
4666 DWORD dwTime;
4667 {
4668 POINT pt;
4669 RECT rect;
4670
4671 if (cur_beval == NULL || cur_beval->showState == ShS_SHOWING || !p_beval)
4672 return;
4673
4674 GetCursorPos(&pt);
4675 if (WindowFromPoint(pt) != s_textArea)
4676 return;
4677
4678 ScreenToClient(s_textArea, &pt);
4679 GetClientRect(s_textArea, &rect);
4680 if (!PtInRect(&rect, pt))
4681 return;
4682
4683 if (LastActivity > 0
4684 && (dwTime - LastActivity) >= (DWORD)p_bdlay
4685 && (cur_beval->showState != ShS_PENDING
4686 || abs(cur_beval->x - pt.x) > 3
4687 || abs(cur_beval->y - pt.y) > 3))
4688 {
4689 /* Pointer resting in one place long enough, it's time to show
4690 * the tooltip. */
4691 cur_beval->showState = ShS_PENDING;
4692 cur_beval->x = pt.x;
4693 cur_beval->y = pt.y;
4694
4695 // TRACE0("BevalTimerProc: sending request");
4696
4697 if (cur_beval->msgCB != NULL)
4698 (*cur_beval->msgCB)(cur_beval, 0);
4699 }
4700 }
4701
4702 /*ARGSUSED*/
4703 void
4704 gui_mch_disable_beval_area(beval)
4705 BalloonEval *beval;
4706 {
4707 // TRACE0("gui_mch_disable_beval_area {{{");
4708 KillTimer(s_textArea, BevalTimerId);
4709 // TRACE0("gui_mch_disable_beval_area }}}");
4710 }
4711
4712 /*ARGSUSED*/
4713 void
4714 gui_mch_enable_beval_area(beval)
4715 BalloonEval *beval;
4716 {
4717 // TRACE0("gui_mch_enable_beval_area |||");
4718 if (beval == NULL)
4719 return;
4720 // TRACE0("gui_mch_enable_beval_area {{{");
4721 BevalTimerId = SetTimer(s_textArea, 0, p_bdlay / 2, BevalTimerProc);
4722 // TRACE0("gui_mch_enable_beval_area }}}");
4723 }
4724
4725 void
4726 gui_mch_post_balloon(beval, mesg)
4727 BalloonEval *beval;
4728 char_u *mesg;
4729 {
4730 POINT pt;
4731 // TRACE0("gui_mch_post_balloon {{{");
4732 if (beval->showState == ShS_SHOWING)
4733 return;
4734 GetCursorPos(&pt);
4735 ScreenToClient(s_textArea, &pt);
4736
4737 if (abs(beval->x - pt.x) < 3 && abs(beval->y - pt.y) < 3)
4738 /* cursor is still here */
4739 {
4740 gui_mch_disable_beval_area(cur_beval);
4741 beval->showState = ShS_SHOWING;
4742 make_tooltip(beval, mesg, pt);
4743 }
4744 // TRACE0("gui_mch_post_balloon }}}");
4745 }
4746
4747 /*ARGSUSED*/
4748 BalloonEval *
4749 gui_mch_create_beval_area(target, mesg, mesgCB, clientData)
4750 void *target; /* ignored, always use s_textArea */
4751 char_u *mesg;
4752 void (*mesgCB)__ARGS((BalloonEval *, int));
4753 void *clientData;
4754 {
4755 /* partially stolen from gui_beval.c */
4756 BalloonEval *beval;
4757
4758 if (mesg != NULL && mesgCB != NULL)
4759 {
4760 EMSG(_("E232: Cannot create BalloonEval with both message and callback"));
4761 return NULL;
4762 }
4763
4764 beval = (BalloonEval *)alloc(sizeof(BalloonEval));
4765 if (beval != NULL)
4766 {
4767 beval->target = s_textArea;
4768 beval->balloon = NULL;
4769
4770 beval->showState = ShS_NEUTRAL;
4771 beval->x = 0;
4772 beval->y = 0;
4773 beval->msg = mesg;
4774 beval->msgCB = mesgCB;
4775 beval->clientData = clientData;
4776
4777 InitCommonControls();
4778 cur_beval = beval;
4779
4780 if (p_beval)
4781 gui_mch_enable_beval_area(beval);
4782
4783 }
4784 return beval;
4785 }
4786
4787 /*ARGSUSED*/
4788 static void
4789 Handle_WM_Notify(hwnd, pnmh)
4790 HWND hwnd;
4791 LPNMHDR pnmh;
4792 {
4793 if (pnmh->idFrom != ID_BEVAL_TOOLTIP) /* it is not our tooltip */
4794 return;
4795
4796 if (cur_beval != NULL)
4797 {
4798 switch (pnmh->code)
4799 {
4800 case TTN_SHOW:
4801 // TRACE0("TTN_SHOW {{{");
4802 // TRACE0("TTN_SHOW }}}");
4803 break;
4804 case TTN_POP: /* Before tooltip disappear */
4805 // TRACE0("TTN_POP {{{");
4806 delete_tooltip(cur_beval);
4807 gui_mch_enable_beval_area(cur_beval);
4808 // TRACE0("TTN_POP }}}");
4809
4810 cur_beval->showState = ShS_NEUTRAL;
4811 break;
4812 case TTN_GETDISPINFO:
4813 {
4814 /* if you get there then we have new common controls */
4815 NMTTDISPINFO_NEW *info = (NMTTDISPINFO_NEW *)pnmh;
4816 info->lpszText = (LPSTR)info->lParam;
4817 info->uFlags |= TTF_DI_SETITEM;
4818 }
4819 break;
4820 }
4821 }
4822 }
4823
4824 static void
4825 TrackUserActivity(UINT uMsg)
4826 {
4827 if ((uMsg >= WM_MOUSEFIRST && uMsg <= WM_MOUSELAST)
4828 || (uMsg >= WM_KEYFIRST && uMsg <= WM_KEYLAST))
4829 LastActivity = GetTickCount();
4830 }
4831
4832 void
4833 gui_mch_destroy_beval_area(beval)
4834 BalloonEval *beval;
4835 {
4836 vim_free(beval);
4837 }
4838 #endif /* FEAT_BEVAL */
4839
4840 #if defined(FEAT_NETBEANS_INTG) || defined(PROTO)
4841 /*
4842 * We have multiple signs to draw at the same location. Draw the
4843 * multi-sign indicator (down-arrow) instead. This is the Win32 version.
4844 */
4845 void
4846 netbeans_draw_multisign_indicator(int row)
4847 {
4848 int i;
4849 int y;
4850 int x;
4851
4852 x = 0;
4853 y = TEXT_Y(row);
4854
4855 for (i = 0; i < gui.char_height - 3; i++)
4856 SetPixel(s_hdc, x+2, y++, gui.currFgColor);
4857
4858 SetPixel(s_hdc, x+0, y, gui.currFgColor);
4859 SetPixel(s_hdc, x+2, y, gui.currFgColor);
4860 SetPixel(s_hdc, x+4, y++, gui.currFgColor);
4861 SetPixel(s_hdc, x+1, y, gui.currFgColor);
4862 SetPixel(s_hdc, x+2, y, gui.currFgColor);
4863 SetPixel(s_hdc, x+3, y++, gui.currFgColor);
4864 SetPixel(s_hdc, x+2, y, gui.currFgColor);
4865 }
4866 #endif
4867
4868 #ifdef USE_AMBIWIDTH_AUTO
4869 #define CHARWIDE_CACHESIZE 65536
4870 static GuiFont last_font = 0;
4871
4872 int
4873 gui_mch_get_charwidth(int c)
4874 {
4875 static char cache[CHARWIDE_CACHESIZE];
4876 GuiFont usingfont = gui.wide_font ? gui.wide_font : gui.norm_font;
4877
4878 /* Check validity of charwide cache */
4879 if (last_font != usingfont)
4880 {
4881 /* Update cache. -1 is mark for uninitialized cell */
4882 TRACE("Charwide cache will be updated (base=%d)\n", gui.char_width);
4883 last_font = usingfont;
4884 memset(cache, -1, sizeof(cache));
4885 }
4886 if (usingfont && 0 <= c && c < CHARWIDE_CACHESIZE)
4887 {
4888 if (cache[c] >= 0)
4889 return cache[c]; /* Use cached value */
4890 else
4891 {
4892 /*
4893 * Get true character width in dot, convert to cells and save
4894 * it.
4895 */
4896 int len;
4897 ABC fontABC;
4898 HFONT hfntOld = SelectFont(s_hdc, usingfont);
4899
4900 if (!GetCharABCWidthsW(s_hdc, c, c, &fontABC) ||
4901 (len = fontABC.abcA + fontABC.abcB + fontABC.abcC) <= 0)
4902 {
4903 TRACE("GetCharABCWidthsW() failed for %08X\n", c);
4904 cache[c] = 0;
4905 }
4906 else
4907 cache[c] = (char)((len + (gui.char_width >> 1))
4908 / gui.char_width);
4909 SelectFont(s_hdc, hfntOld);
4910
4911 return cache[c];
4912 }
4913 }
4914 else
4915 return 0;
4916 }
4917 #endif
MacVim KaoriYa