blob: 5896dcddad3dab762a91e8e43ce68ce84f97d9d5 [file] [log] [blame]
Bram Moolenaar071d4272004-06-13 20:20:40 +00001/* 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 * gui_w48.c: This file is included in gui_w16.c and gui_w32.c.
12 *
13 * GUI support for Microsoft Windows (Win16 + Win32 = Win48 :-)
14 *
15 * The combined efforts of:
16 * George V. Reilly <george@reilly.org>
17 * Robert Webb
18 * Vince Negri
19 * ...and contributions from many others
20 *
21 */
22
23#include "vim.h"
24#include "version.h" /* used by dialog box routine for default title */
25#ifdef DEBUG
26# include <tchar.h>
27#endif
Bram Moolenaar82881492012-11-20 16:53:39 +010028
29/* cproto fails on missing include files */
30#ifndef PROTO
31
Bram Moolenaar071d4272004-06-13 20:20:40 +000032#ifndef __MINGW32__
33# include <shellapi.h>
34#endif
Bram Moolenaar3991dab2006-03-27 17:01:56 +000035#if defined(FEAT_TOOLBAR) || defined(FEAT_BEVAL) || defined(FEAT_GUI_TABLINE)
Bram Moolenaar071d4272004-06-13 20:20:40 +000036# include <commctrl.h>
37#endif
38#ifdef WIN16
39# include <commdlg.h>
40# include <shellapi.h>
41# ifdef WIN16_3DLOOK
42# include <ctl3d.h>
43# endif
44#endif
45#include <windowsx.h>
46
47#ifdef GLOBAL_IME
48# include "glbl_ime.h"
49#endif
50
Bram Moolenaar82881492012-11-20 16:53:39 +010051#endif /* PROTO */
52
Bram Moolenaar071d4272004-06-13 20:20:40 +000053#ifdef FEAT_MENU
54# define MENUHINTS /* show menu hints in command line */
55#endif
56
57/* Some parameters for dialog boxes. All in pixels. */
58#define DLG_PADDING_X 10
59#define DLG_PADDING_Y 10
60#define DLG_OLD_STYLE_PADDING_X 5
61#define DLG_OLD_STYLE_PADDING_Y 5
62#define DLG_VERT_PADDING_X 4 /* For vertical buttons */
63#define DLG_VERT_PADDING_Y 4
64#define DLG_ICON_WIDTH 34
65#define DLG_ICON_HEIGHT 34
66#define DLG_MIN_WIDTH 150
67#define DLG_FONT_NAME "MS Sans Serif"
68#define DLG_FONT_POINT_SIZE 8
69#define DLG_MIN_MAX_WIDTH 400
Bram Moolenaar748bf032005-02-02 23:04:36 +000070#define DLG_MIN_MAX_HEIGHT 400
Bram Moolenaar071d4272004-06-13 20:20:40 +000071
72#define DLG_NONBUTTON_CONTROL 5000 /* First ID of non-button controls */
73
74#ifndef WM_XBUTTONDOWN /* For Win2K / winME ONLY */
75# define WM_XBUTTONDOWN 0x020B
76# define WM_XBUTTONUP 0x020C
77# define WM_XBUTTONDBLCLK 0x020D
78# define MK_XBUTTON1 0x0020
79# define MK_XBUTTON2 0x0040
80#endif
81
82#ifdef PROTO
83/*
84 * Define a few things for generating prototypes. This is just to avoid
85 * syntax errors, the defines do not need to be correct.
86 */
87# define APIENTRY
88# define CALLBACK
89# define CONST
90# define FAR
91# define NEAR
92# define _cdecl
93typedef int BOOL;
94typedef int BYTE;
95typedef int DWORD;
96typedef int WCHAR;
97typedef int ENUMLOGFONT;
98typedef int FINDREPLACE;
99typedef int HANDLE;
100typedef int HBITMAP;
101typedef int HBRUSH;
102typedef int HDROP;
103typedef int INT;
104typedef int LOGFONT[];
105typedef int LPARAM;
106typedef int LPCREATESTRUCT;
107typedef int LPCSTR;
108typedef int LPCTSTR;
109typedef int LPRECT;
110typedef int LPSTR;
111typedef int LPWINDOWPOS;
112typedef int LPWORD;
113typedef int LRESULT;
Bram Moolenaare344bea2005-09-01 20:46:49 +0000114typedef int HRESULT;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000115# undef MSG
116typedef int MSG;
117typedef int NEWTEXTMETRIC;
118typedef int OSVERSIONINFO;
119typedef int PWORD;
120typedef int RECT;
121typedef int UINT;
122typedef int WORD;
123typedef int WPARAM;
124typedef int POINT;
125typedef void *HINSTANCE;
126typedef void *HMENU;
127typedef void *HWND;
128typedef void *HDC;
129typedef void VOID;
130typedef int LPNMHDR;
131typedef int LONG;
Bram Moolenaar3b1db362013-08-10 15:00:24 +0200132typedef int WNDPROC;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000133#endif
134
135#ifndef GET_X_LPARAM
136# define GET_X_LPARAM(lp) ((int)(short)LOWORD(lp))
137#endif
138
139static void _OnPaint( HWND hwnd);
140static void clear_rect(RECT *rcp);
141static int gui_mswin_get_menu_height(int fix_window);
142
143static WORD s_dlgfntheight; /* height of the dialog font */
144static WORD s_dlgfntwidth; /* width of the dialog font */
145
146#ifdef FEAT_MENU
147static HMENU s_menuBar = NULL;
148#endif
149#ifdef FEAT_TEAROFF
150static void rebuild_tearoff(vimmenu_T *menu);
151static HBITMAP s_htearbitmap; /* bitmap used to indicate tearoff */
152#endif
153
Bram Moolenaar48687262007-05-10 17:17:07 +0000154/* Flag that is set while processing a message that must not be interrupted by
Bram Moolenaar071d4272004-06-13 20:20:40 +0000155 * processing another message. */
156static int s_busy_processing = FALSE;
157
158static int destroying = FALSE; /* call DestroyWindow() ourselves */
159
160#ifdef MSWIN_FIND_REPLACE
161static UINT s_findrep_msg = 0; /* set in gui_w[16/32].c */
162static FINDREPLACE s_findrep_struct;
Bram Moolenaar3ca9a8a2009-01-28 20:23:17 +0000163# if defined(FEAT_MBYTE) && defined(WIN3264)
164static FINDREPLACEW s_findrep_struct_w;
165# endif
Bram Moolenaar071d4272004-06-13 20:20:40 +0000166static HWND s_findrep_hwnd = NULL;
167static int s_findrep_is_find; /* TRUE for find dialog, FALSE
168 for find/replace dialog */
169#endif
170
171static HINSTANCE s_hinst = NULL;
172#if !defined(FEAT_SNIFF) && !defined(FEAT_GUI)
173static
174#endif
175HWND s_hwnd = NULL;
176static HDC s_hdc = NULL;
177static HBRUSH s_brush = NULL;
178
179#ifdef FEAT_TOOLBAR
180static HWND s_toolbarhwnd = NULL;
Bram Moolenaar5f919ee2013-07-21 17:46:43 +0200181static WNDPROC s_toolbar_wndproc = NULL;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000182#endif
183
Bram Moolenaar3991dab2006-03-27 17:01:56 +0000184#ifdef FEAT_GUI_TABLINE
185static HWND s_tabhwnd = NULL;
Bram Moolenaar5f919ee2013-07-21 17:46:43 +0200186static WNDPROC s_tabline_wndproc = NULL;
Bram Moolenaar3991dab2006-03-27 17:01:56 +0000187static int showing_tabline = 0;
188#endif
189
Bram Moolenaar071d4272004-06-13 20:20:40 +0000190static WPARAM s_wParam = 0;
191static LPARAM s_lParam = 0;
192
193static HWND s_textArea = NULL;
194static UINT s_uMsg = 0;
195
196static char_u *s_textfield; /* Used by dialogs to pass back strings */
197
198static int s_need_activate = FALSE;
199
200/* This variable is set when waiting for an event, which is the only moment
201 * scrollbar dragging can be done directly. It's not allowed while commands
202 * are executed, because it may move the cursor and that may cause unexpected
203 * problems (e.g., while ":s" is working).
204 */
205static int allow_scrollbar = FALSE;
206
207#ifdef GLOBAL_IME
208# define MyTranslateMessage(x) global_ime_TranslateMessage(x)
209#else
210# define MyTranslateMessage(x) TranslateMessage(x)
211#endif
212
213#if (defined(WIN3264) && defined(FEAT_MBYTE)) || defined(GLOBAL_IME)
214 /* use of WindowProc depends on wide_WindowProc */
215# define MyWindowProc vim_WindowProc
216#else
217 /* use ordinary WindowProc */
218# define MyWindowProc DefWindowProc
219#endif
220
221extern int current_font_height; /* this is in os_mswin.c */
222
223static struct
224{
225 UINT key_sym;
226 char_u vim_code0;
227 char_u vim_code1;
228} special_keys[] =
229{
230 {VK_UP, 'k', 'u'},
231 {VK_DOWN, 'k', 'd'},
232 {VK_LEFT, 'k', 'l'},
233 {VK_RIGHT, 'k', 'r'},
234
235 {VK_F1, 'k', '1'},
236 {VK_F2, 'k', '2'},
237 {VK_F3, 'k', '3'},
238 {VK_F4, 'k', '4'},
239 {VK_F5, 'k', '5'},
240 {VK_F6, 'k', '6'},
241 {VK_F7, 'k', '7'},
242 {VK_F8, 'k', '8'},
243 {VK_F9, 'k', '9'},
244 {VK_F10, 'k', ';'},
245
246 {VK_F11, 'F', '1'},
247 {VK_F12, 'F', '2'},
248 {VK_F13, 'F', '3'},
249 {VK_F14, 'F', '4'},
250 {VK_F15, 'F', '5'},
251 {VK_F16, 'F', '6'},
252 {VK_F17, 'F', '7'},
253 {VK_F18, 'F', '8'},
254 {VK_F19, 'F', '9'},
255 {VK_F20, 'F', 'A'},
256
257 {VK_F21, 'F', 'B'},
258#ifdef FEAT_NETBEANS_INTG
259 {VK_PAUSE, 'F', 'B'}, /* Pause == F21 (see gui_gtk_x11.c) */
260#endif
261 {VK_F22, 'F', 'C'},
262 {VK_F23, 'F', 'D'},
263 {VK_F24, 'F', 'E'}, /* winuser.h defines up to F24 */
264
265 {VK_HELP, '%', '1'},
266 {VK_BACK, 'k', 'b'},
267 {VK_INSERT, 'k', 'I'},
268 {VK_DELETE, 'k', 'D'},
269 {VK_HOME, 'k', 'h'},
270 {VK_END, '@', '7'},
271 {VK_PRIOR, 'k', 'P'},
272 {VK_NEXT, 'k', 'N'},
273 {VK_PRINT, '%', '9'},
274 {VK_ADD, 'K', '6'},
275 {VK_SUBTRACT, 'K', '7'},
276 {VK_DIVIDE, 'K', '8'},
277 {VK_MULTIPLY, 'K', '9'},
278 {VK_SEPARATOR, 'K', 'A'}, /* Keypad Enter */
279 {VK_DECIMAL, 'K', 'B'},
280
281 {VK_NUMPAD0, 'K', 'C'},
282 {VK_NUMPAD1, 'K', 'D'},
283 {VK_NUMPAD2, 'K', 'E'},
284 {VK_NUMPAD3, 'K', 'F'},
285 {VK_NUMPAD4, 'K', 'G'},
286 {VK_NUMPAD5, 'K', 'H'},
287 {VK_NUMPAD6, 'K', 'I'},
288 {VK_NUMPAD7, 'K', 'J'},
289 {VK_NUMPAD8, 'K', 'K'},
290 {VK_NUMPAD9, 'K', 'L'},
291
292 /* Keys that we want to be able to use any modifier with: */
293 {VK_SPACE, ' ', NUL},
294 {VK_TAB, TAB, NUL},
295 {VK_ESCAPE, ESC, NUL},
296 {NL, NL, NUL},
297 {CAR, CAR, NUL},
298
299 /* End of list marker: */
300 {0, 0, 0}
301};
302
303/* Local variables */
Bram Moolenaar25b2b942016-01-17 20:53:12 +0100304static int s_button_pending = -1;
Bram Moolenaarea408882007-12-03 21:21:03 +0000305
306/* s_getting_focus is set when we got focus but didn't see mouse-up event yet,
307 * so don't reset s_button_pending. */
Bram Moolenaar25b2b942016-01-17 20:53:12 +0100308static int s_getting_focus = FALSE;
Bram Moolenaarea408882007-12-03 21:21:03 +0000309
Bram Moolenaar25b2b942016-01-17 20:53:12 +0100310static int s_x_pending;
311static int s_y_pending;
312static UINT s_kFlags_pending;
313static UINT s_wait_timer = 0; /* Timer for get char from user */
314static int s_timed_out = FALSE;
315static int dead_key = 0; /* 0: no dead key, 1: dead key pressed */
Bram Moolenaar071d4272004-06-13 20:20:40 +0000316
317#ifdef WIN3264
318static OSVERSIONINFO os_version; /* like it says. Init in gui_mch_init() */
319#endif
320
321#ifdef FEAT_BEVAL
322/* balloon-eval WM_NOTIFY_HANDLER */
Bram Moolenaard25c16e2016-01-29 22:13:30 +0100323static void Handle_WM_Notify(HWND hwnd, LPNMHDR pnmh);
324static void TrackUserActivity(UINT uMsg);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000325#endif
326
327/*
328 * For control IME.
Bram Moolenaar0f272122013-01-23 18:37:40 +0100329 *
330 * These LOGFONT used for IME.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000331 */
332#ifdef FEAT_MBYTE
333# ifdef USE_IM_CONTROL
Bram Moolenaar0f272122013-01-23 18:37:40 +0100334/* holds LOGFONT for 'guifontwide' if available, otherwise 'guifont' */
Bram Moolenaar071d4272004-06-13 20:20:40 +0000335static LOGFONT norm_logfont;
Bram Moolenaar0f272122013-01-23 18:37:40 +0100336/* holds LOGFONT for 'guifont' always. */
337static LOGFONT sub_logfont;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000338# endif
339#endif
340
341#ifdef FEAT_MBYTE_IME
342static LRESULT _OnImeNotify(HWND hWnd, DWORD dwCommand, DWORD dwData);
343#endif
344
Bram Moolenaar3ef7cdf2012-01-20 17:57:51 +0100345#if defined(FEAT_MBYTE) && defined(WIN3264)
346static char_u *convert_filter(char_u *s);
347#endif
348
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +0000349#ifdef DEBUG_PRINT_ERROR
Bram Moolenaar071d4272004-06-13 20:20:40 +0000350/*
351 * Print out the last Windows error message
352 */
353 static void
354print_windows_error(void)
355{
356 LPVOID lpMsgBuf;
357
358 FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
359 NULL, GetLastError(),
360 MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
361 (LPTSTR) &lpMsgBuf, 0, NULL);
362 TRACE1("Error: %s\n", lpMsgBuf);
363 LocalFree(lpMsgBuf);
364}
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +0000365#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +0000366
367/*
368 * Cursor blink functions.
369 *
370 * This is a simple state machine:
371 * BLINK_NONE not blinking at all
372 * BLINK_OFF blinking, cursor is not shown
373 * BLINK_ON blinking, cursor is shown
374 */
375
376#define BLINK_NONE 0
377#define BLINK_OFF 1
378#define BLINK_ON 2
379
380static int blink_state = BLINK_NONE;
381static long_u blink_waittime = 700;
382static long_u blink_ontime = 400;
383static long_u blink_offtime = 250;
384static UINT blink_timer = 0;
385
386 void
387gui_mch_set_blinking(long wait, long on, long off)
388{
389 blink_waittime = wait;
390 blink_ontime = on;
391 blink_offtime = off;
392}
393
394/* ARGSUSED */
395 static VOID CALLBACK
396_OnBlinkTimer(
397 HWND hwnd,
398 UINT uMsg,
399 UINT idEvent,
400 DWORD dwTime)
401{
402 MSG msg;
403
404 /*
405 TRACE2("Got timer event, id %d, blink_timer %d\n", idEvent, blink_timer);
406 */
407
408 KillTimer(NULL, idEvent);
409
410 /* Eat spurious WM_TIMER messages */
Bram Moolenaar8c85fa32011-08-10 17:08:03 +0200411 while (pPeekMessage(&msg, hwnd, WM_TIMER, WM_TIMER, PM_REMOVE))
Bram Moolenaar071d4272004-06-13 20:20:40 +0000412 ;
413
414 if (blink_state == BLINK_ON)
415 {
416 gui_undraw_cursor();
417 blink_state = BLINK_OFF;
418 blink_timer = (UINT) SetTimer(NULL, 0, (UINT)blink_offtime,
419 (TIMERPROC)_OnBlinkTimer);
420 }
421 else
422 {
423 gui_update_cursor(TRUE, FALSE);
424 blink_state = BLINK_ON;
425 blink_timer = (UINT) SetTimer(NULL, 0, (UINT)blink_ontime,
426 (TIMERPROC)_OnBlinkTimer);
427 }
428}
429
430 static void
431gui_mswin_rm_blink_timer(void)
432{
433 MSG msg;
434
435 if (blink_timer != 0)
436 {
437 KillTimer(NULL, blink_timer);
438 /* Eat spurious WM_TIMER messages */
Bram Moolenaar8c85fa32011-08-10 17:08:03 +0200439 while (pPeekMessage(&msg, s_hwnd, WM_TIMER, WM_TIMER, PM_REMOVE))
Bram Moolenaar071d4272004-06-13 20:20:40 +0000440 ;
441 blink_timer = 0;
442 }
443}
444
445/*
446 * Stop the cursor blinking. Show the cursor if it wasn't shown.
447 */
448 void
449gui_mch_stop_blink(void)
450{
451 gui_mswin_rm_blink_timer();
452 if (blink_state == BLINK_OFF)
453 gui_update_cursor(TRUE, FALSE);
454 blink_state = BLINK_NONE;
455}
456
457/*
458 * Start the cursor blinking. If it was already blinking, this restarts the
459 * waiting time and shows the cursor.
460 */
461 void
462gui_mch_start_blink(void)
463{
464 gui_mswin_rm_blink_timer();
465
466 /* Only switch blinking on if none of the times is zero */
467 if (blink_waittime && blink_ontime && blink_offtime && gui.in_focus)
468 {
469 blink_timer = (UINT)SetTimer(NULL, 0, (UINT)blink_waittime,
470 (TIMERPROC)_OnBlinkTimer);
471 blink_state = BLINK_ON;
472 gui_update_cursor(TRUE, FALSE);
473 }
474}
475
476/*
477 * Call-back routines.
478 */
479
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +0000480/*ARGSUSED*/
Bram Moolenaar071d4272004-06-13 20:20:40 +0000481 static VOID CALLBACK
482_OnTimer(
483 HWND hwnd,
484 UINT uMsg,
485 UINT idEvent,
486 DWORD dwTime)
487{
488 MSG msg;
489
490 /*
491 TRACE2("Got timer event, id %d, s_wait_timer %d\n", idEvent, s_wait_timer);
492 */
493 KillTimer(NULL, idEvent);
494 s_timed_out = TRUE;
495
496 /* Eat spurious WM_TIMER messages */
Bram Moolenaar8c85fa32011-08-10 17:08:03 +0200497 while (pPeekMessage(&msg, hwnd, WM_TIMER, WM_TIMER, PM_REMOVE))
Bram Moolenaar071d4272004-06-13 20:20:40 +0000498 ;
499 if (idEvent == s_wait_timer)
500 s_wait_timer = 0;
501}
502
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +0000503/*ARGSUSED*/
Bram Moolenaar071d4272004-06-13 20:20:40 +0000504 static void
505_OnDeadChar(
506 HWND hwnd,
507 UINT ch,
508 int cRepeat)
509{
510 dead_key = 1;
511}
512
513/*
514 * Convert Unicode character "ch" to bytes in "string[slen]".
Bram Moolenaar85a3e5c2007-11-20 16:22:16 +0000515 * When "had_alt" is TRUE the ALT key was included in "ch".
Bram Moolenaar071d4272004-06-13 20:20:40 +0000516 * Return the length.
517 */
518 static int
Bram Moolenaar85a3e5c2007-11-20 16:22:16 +0000519char_to_string(int ch, char_u *string, int slen, int had_alt)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000520{
521 int len;
522 int i;
523#ifdef FEAT_MBYTE
524 WCHAR wstring[2];
525 char_u *ws = NULL;;
526
Bram Moolenaar293ee4d2004-12-09 21:34:53 +0000527 if (os_version.dwPlatformId != VER_PLATFORM_WIN32_NT)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000528 {
Bram Moolenaar293ee4d2004-12-09 21:34:53 +0000529 /* On Windows 95/98 we apparently get the character in the active
530 * codepage, not in UCS-2. If conversion is needed convert it to
531 * UCS-2 first. */
532 if ((int)GetACP() == enc_codepage)
533 len = 0; /* no conversion required */
Bram Moolenaar071d4272004-06-13 20:20:40 +0000534 else
535 {
Bram Moolenaar293ee4d2004-12-09 21:34:53 +0000536 string[0] = ch;
Bram Moolenaar418f81b2016-02-16 20:12:02 +0100537 len = MultiByteToWideChar(GetACP(), 0, (LPCSTR)string,
538 1, wstring, 2);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000539 }
540 }
Bram Moolenaar293ee4d2004-12-09 21:34:53 +0000541 else
542 {
543 wstring[0] = ch;
544 len = 1;
545 }
546
547 if (len > 0)
548 {
549 /* "ch" is a UTF-16 character. Convert it to a string of bytes. When
550 * "enc_codepage" is non-zero use the standard Win32 function,
551 * otherwise use our own conversion function (e.g., for UTF-8). */
552 if (enc_codepage > 0)
Bram Moolenaar85a3e5c2007-11-20 16:22:16 +0000553 {
Bram Moolenaar293ee4d2004-12-09 21:34:53 +0000554 len = WideCharToMultiByte(enc_codepage, 0, wstring, len,
Bram Moolenaar418f81b2016-02-16 20:12:02 +0100555 (LPSTR)string, slen, 0, NULL);
Bram Moolenaar85a3e5c2007-11-20 16:22:16 +0000556 /* If we had included the ALT key into the character but now the
557 * upper bit is no longer set, that probably means the conversion
558 * failed. Convert the original character and set the upper bit
559 * afterwards. */
560 if (had_alt && len == 1 && ch >= 0x80 && string[0] < 0x80)
561 {
562 wstring[0] = ch & 0x7f;
563 len = WideCharToMultiByte(enc_codepage, 0, wstring, len,
Bram Moolenaar418f81b2016-02-16 20:12:02 +0100564 (LPSTR)string, slen, 0, NULL);
Bram Moolenaar85a3e5c2007-11-20 16:22:16 +0000565 if (len == 1) /* safety check */
566 string[0] |= 0x80;
567 }
568 }
Bram Moolenaar293ee4d2004-12-09 21:34:53 +0000569 else
570 {
571 len = 1;
Bram Moolenaar36f692d2008-11-20 16:10:17 +0000572 ws = utf16_to_enc(wstring, &len);
Bram Moolenaar293ee4d2004-12-09 21:34:53 +0000573 if (ws == NULL)
574 len = 0;
575 else
576 {
577 if (len > slen) /* just in case */
578 len = slen;
579 mch_memmove(string, ws, len);
580 vim_free(ws);
581 }
582 }
583 }
584
Bram Moolenaar071d4272004-06-13 20:20:40 +0000585 if (len == 0)
586#endif
587 {
588 string[0] = ch;
589 len = 1;
590 }
591
592 for (i = 0; i < len; ++i)
593 if (string[i] == CSI && len <= slen - 2)
594 {
595 /* Insert CSI as K_CSI. */
596 mch_memmove(string + i + 3, string + i + 1, len - i - 1);
597 string[++i] = KS_EXTRA;
598 string[++i] = (int)KE_CSI;
599 len += 2;
600 }
601
602 return len;
603}
604
605/*
606 * Key hit, add it to the input buffer.
607 */
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +0000608/*ARGSUSED*/
Bram Moolenaar071d4272004-06-13 20:20:40 +0000609 static void
610_OnChar(
611 HWND hwnd,
612 UINT ch,
613 int cRepeat)
614{
615 char_u string[40];
616 int len = 0;
617
Bram Moolenaard2e80872014-08-22 18:44:33 +0200618 dead_key = 0;
619
Bram Moolenaar85a3e5c2007-11-20 16:22:16 +0000620 len = char_to_string(ch, string, 40, FALSE);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000621 if (len == 1 && string[0] == Ctrl_C && ctrl_c_interrupts)
622 {
623 trash_input_buf();
624 got_int = TRUE;
625 }
626
627 add_to_input_buf(string, len);
628}
629
630/*
631 * Alt-Key hit, add it to the input buffer.
632 */
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +0000633/*ARGSUSED*/
Bram Moolenaar071d4272004-06-13 20:20:40 +0000634 static void
635_OnSysChar(
636 HWND hwnd,
637 UINT cch,
638 int cRepeat)
639{
640 char_u string[40]; /* Enough for multibyte character */
641 int len;
642 int modifiers;
643 int ch = cch; /* special keys are negative */
644
Bram Moolenaar25b2b942016-01-17 20:53:12 +0100645 dead_key = 0;
646
Bram Moolenaar071d4272004-06-13 20:20:40 +0000647 /* TRACE("OnSysChar(%d, %c)\n", ch, ch); */
648
649 /* OK, we have a character key (given by ch) which was entered with the
650 * ALT key pressed. Eg, if the user presses Alt-A, then ch == 'A'. Note
651 * that the system distinguishes Alt-a and Alt-A (Alt-Shift-a unless
652 * CAPSLOCK is pressed) at this point.
653 */
654 modifiers = MOD_MASK_ALT;
655 if (GetKeyState(VK_SHIFT) & 0x8000)
656 modifiers |= MOD_MASK_SHIFT;
657 if (GetKeyState(VK_CONTROL) & 0x8000)
658 modifiers |= MOD_MASK_CTRL;
659
660 ch = simplify_key(ch, &modifiers);
661 /* remove the SHIFT modifier for keys where it's already included, e.g.,
662 * '(' and '*' */
663 if (ch < 0x100 && !isalpha(ch) && isprint(ch))
664 modifiers &= ~MOD_MASK_SHIFT;
665
666 /* Interpret the ALT key as making the key META, include SHIFT, etc. */
667 ch = extract_modifiers(ch, &modifiers);
668 if (ch == CSI)
669 ch = K_CSI;
670
671 len = 0;
672 if (modifiers)
673 {
674 string[len++] = CSI;
675 string[len++] = KS_MODIFIER;
676 string[len++] = modifiers;
677 }
678
679 if (IS_SPECIAL((int)ch))
680 {
681 string[len++] = CSI;
682 string[len++] = K_SECOND((int)ch);
683 string[len++] = K_THIRD((int)ch);
684 }
685 else
686 {
687 /* Although the documentation isn't clear about it, we assume "ch" is
688 * a Unicode character. */
Bram Moolenaar85a3e5c2007-11-20 16:22:16 +0000689 len += char_to_string(ch, string + len, 40 - len, TRUE);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000690 }
691
692 add_to_input_buf(string, len);
693}
694
695 static void
696_OnMouseEvent(
697 int button,
698 int x,
699 int y,
700 int repeated_click,
701 UINT keyFlags)
702{
703 int vim_modifiers = 0x0;
704
Bram Moolenaarea408882007-12-03 21:21:03 +0000705 s_getting_focus = FALSE;
706
Bram Moolenaar071d4272004-06-13 20:20:40 +0000707 if (keyFlags & MK_SHIFT)
708 vim_modifiers |= MOUSE_SHIFT;
709 if (keyFlags & MK_CONTROL)
710 vim_modifiers |= MOUSE_CTRL;
711 if (GetKeyState(VK_MENU) & 0x8000)
712 vim_modifiers |= MOUSE_ALT;
713
714 gui_send_mouse_event(button, x, y, repeated_click, vim_modifiers);
715}
716
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +0000717/*ARGSUSED*/
Bram Moolenaar071d4272004-06-13 20:20:40 +0000718 static void
719_OnMouseButtonDown(
720 HWND hwnd,
721 BOOL fDoubleClick,
722 int x,
723 int y,
724 UINT keyFlags)
725{
726 static LONG s_prevTime = 0;
727
728 LONG currentTime = GetMessageTime();
729 int button = -1;
730 int repeated_click;
731
732 /* Give main window the focus: this is so the cursor isn't hollow. */
733 (void)SetFocus(s_hwnd);
734
735 if (s_uMsg == WM_LBUTTONDOWN || s_uMsg == WM_LBUTTONDBLCLK)
736 button = MOUSE_LEFT;
737 else if (s_uMsg == WM_MBUTTONDOWN || s_uMsg == WM_MBUTTONDBLCLK)
738 button = MOUSE_MIDDLE;
739 else if (s_uMsg == WM_RBUTTONDOWN || s_uMsg == WM_RBUTTONDBLCLK)
740 button = MOUSE_RIGHT;
741#ifndef WIN16 /*<VN>*/
742 else if (s_uMsg == WM_XBUTTONDOWN || s_uMsg == WM_XBUTTONDBLCLK)
743 {
744#ifndef GET_XBUTTON_WPARAM
745# define GET_XBUTTON_WPARAM(wParam) (HIWORD(wParam))
746#endif
747 button = ((GET_XBUTTON_WPARAM(s_wParam) == 1) ? MOUSE_X1 : MOUSE_X2);
748 }
749 else if (s_uMsg == WM_CAPTURECHANGED)
750 {
751 /* on W95/NT4, somehow you get in here with an odd Msg
752 * if you press one button while holding down the other..*/
753 if (s_button_pending == MOUSE_LEFT)
754 button = MOUSE_RIGHT;
755 else
756 button = MOUSE_LEFT;
757 }
758#endif
759 if (button >= 0)
760 {
761 repeated_click = ((int)(currentTime - s_prevTime) < p_mouset);
762
763 /*
764 * Holding down the left and right buttons simulates pushing the middle
765 * button.
766 */
Bram Moolenaar293ee4d2004-12-09 21:34:53 +0000767 if (repeated_click
768 && ((button == MOUSE_LEFT && s_button_pending == MOUSE_RIGHT)
769 || (button == MOUSE_RIGHT
770 && s_button_pending == MOUSE_LEFT)))
Bram Moolenaar071d4272004-06-13 20:20:40 +0000771 {
772 /*
773 * Hmm, gui.c will ignore more than one button down at a time, so
774 * pretend we let go of it first.
775 */
776 gui_send_mouse_event(MOUSE_RELEASE, x, y, FALSE, 0x0);
777 button = MOUSE_MIDDLE;
778 repeated_click = FALSE;
779 s_button_pending = -1;
780 _OnMouseEvent(button, x, y, repeated_click, keyFlags);
781 }
782 else if ((repeated_click)
783 || (mouse_model_popup() && (button == MOUSE_RIGHT)))
784 {
785 if (s_button_pending > -1)
786 {
787 _OnMouseEvent(s_button_pending, x, y, FALSE, keyFlags);
788 s_button_pending = -1;
789 }
790 /* TRACE("Button down at x %d, y %d\n", x, y); */
791 _OnMouseEvent(button, x, y, repeated_click, keyFlags);
792 }
793 else
794 {
795 /*
796 * If this is the first press (i.e. not a multiple click) don't
797 * action immediately, but store and wait for:
798 * i) button-up
799 * ii) mouse move
800 * iii) another button press
801 * before using it.
802 * This enables us to make left+right simulate middle button,
803 * without left or right being actioned first. The side-effect is
804 * that if you click and hold the mouse without dragging, the
805 * cursor doesn't move until you release the button. In practice
806 * this is hardly a problem.
807 */
808 s_button_pending = button;
809 s_x_pending = x;
810 s_y_pending = y;
811 s_kFlags_pending = keyFlags;
812 }
813
814 s_prevTime = currentTime;
815 }
816}
817
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +0000818/*ARGSUSED*/
Bram Moolenaar071d4272004-06-13 20:20:40 +0000819 static void
820_OnMouseMoveOrRelease(
821 HWND hwnd,
822 int x,
823 int y,
824 UINT keyFlags)
825{
826 int button;
827
Bram Moolenaarea408882007-12-03 21:21:03 +0000828 s_getting_focus = FALSE;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000829 if (s_button_pending > -1)
830 {
831 /* Delayed action for mouse down event */
832 _OnMouseEvent(s_button_pending, s_x_pending,
Bram Moolenaar293ee4d2004-12-09 21:34:53 +0000833 s_y_pending, FALSE, s_kFlags_pending);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000834 s_button_pending = -1;
835 }
836 if (s_uMsg == WM_MOUSEMOVE)
837 {
838 /*
839 * It's only a MOUSE_DRAG if one or more mouse buttons are being held
840 * down.
841 */
842 if (!(keyFlags & (MK_LBUTTON | MK_MBUTTON | MK_RBUTTON
843 | MK_XBUTTON1 | MK_XBUTTON2)))
844 {
845 gui_mouse_moved(x, y);
846 return;
847 }
848
849 /*
850 * While button is down, keep grabbing mouse move events when
851 * the mouse goes outside the window
852 */
853 SetCapture(s_textArea);
854 button = MOUSE_DRAG;
855 /* TRACE(" move at x %d, y %d\n", x, y); */
856 }
857 else
858 {
859 ReleaseCapture();
860 button = MOUSE_RELEASE;
861 /* TRACE(" up at x %d, y %d\n", x, y); */
862 }
863
864 _OnMouseEvent(button, x, y, FALSE, keyFlags);
865}
866
867#ifdef FEAT_MENU
868/*
869 * Find the vimmenu_T with the given id
870 */
871 static vimmenu_T *
872gui_mswin_find_menu(
873 vimmenu_T *pMenu,
874 int id)
875{
876 vimmenu_T *pChildMenu;
877
878 while (pMenu)
879 {
880 if (pMenu->id == (UINT)id)
881 break;
882 if (pMenu->children != NULL)
883 {
884 pChildMenu = gui_mswin_find_menu(pMenu->children, id);
885 if (pChildMenu)
886 {
887 pMenu = pChildMenu;
888 break;
889 }
890 }
891 pMenu = pMenu->next;
892 }
893 return pMenu;
894}
895
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +0000896/*ARGSUSED*/
Bram Moolenaar071d4272004-06-13 20:20:40 +0000897 static void
898_OnMenu(
899 HWND hwnd,
900 int id,
901 HWND hwndCtl,
902 UINT codeNotify)
903{
904 vimmenu_T *pMenu;
905
906 pMenu = gui_mswin_find_menu(root_menu, id);
907 if (pMenu)
908 gui_menu_cb(pMenu);
909}
910#endif
911
912#ifdef MSWIN_FIND_REPLACE
Bram Moolenaar3ca9a8a2009-01-28 20:23:17 +0000913# if defined(FEAT_MBYTE) && defined(WIN3264)
914/*
915 * copy useful data from structure LPFINDREPLACE to structure LPFINDREPLACEW
916 */
917 static void
918findrep_atow(LPFINDREPLACEW lpfrw, LPFINDREPLACE lpfr)
919{
920 WCHAR *wp;
921
922 lpfrw->hwndOwner = lpfr->hwndOwner;
923 lpfrw->Flags = lpfr->Flags;
924
Bram Moolenaar418f81b2016-02-16 20:12:02 +0100925 wp = enc_to_utf16((char_u *)lpfr->lpstrFindWhat, NULL);
Bram Moolenaar3ca9a8a2009-01-28 20:23:17 +0000926 wcsncpy(lpfrw->lpstrFindWhat, wp, lpfrw->wFindWhatLen - 1);
927 vim_free(wp);
928
929 /* the field "lpstrReplaceWith" doesn't need to be copied */
930}
931
932/*
933 * copy useful data from structure LPFINDREPLACEW to structure LPFINDREPLACE
934 */
935 static void
936findrep_wtoa(LPFINDREPLACE lpfr, LPFINDREPLACEW lpfrw)
937{
938 char_u *p;
939
940 lpfr->Flags = lpfrw->Flags;
941
Bram Moolenaar418f81b2016-02-16 20:12:02 +0100942 p = utf16_to_enc((short_u*)lpfrw->lpstrFindWhat, NULL);
943 vim_strncpy((char_u *)lpfr->lpstrFindWhat, p, lpfr->wFindWhatLen - 1);
Bram Moolenaar3ca9a8a2009-01-28 20:23:17 +0000944 vim_free(p);
945
Bram Moolenaar418f81b2016-02-16 20:12:02 +0100946 p = utf16_to_enc((short_u*)lpfrw->lpstrReplaceWith, NULL);
947 vim_strncpy((char_u *)lpfr->lpstrReplaceWith, p, lpfr->wReplaceWithLen - 1);
Bram Moolenaar3ca9a8a2009-01-28 20:23:17 +0000948 vim_free(p);
949}
950# endif
951
Bram Moolenaar071d4272004-06-13 20:20:40 +0000952/*
953 * Handle a Find/Replace window message.
954 */
955 static void
956_OnFindRepl(void)
957{
958 int flags = 0;
959 int down;
960
Bram Moolenaar3ca9a8a2009-01-28 20:23:17 +0000961# if defined(FEAT_MBYTE) && defined(WIN3264)
962 /* If the OS is Windows NT, and 'encoding' differs from active codepage:
963 * convert text from wide string. */
964 if (os_version.dwPlatformId == VER_PLATFORM_WIN32_NT
965 && enc_codepage >= 0 && (int)GetACP() != enc_codepage)
966 {
Bram Moolenaarcc448b32010-07-14 16:52:17 +0200967 findrep_wtoa(&s_findrep_struct, &s_findrep_struct_w);
Bram Moolenaar3ca9a8a2009-01-28 20:23:17 +0000968 }
969# endif
970
Bram Moolenaar071d4272004-06-13 20:20:40 +0000971 if (s_findrep_struct.Flags & FR_DIALOGTERM)
972 /* Give main window the focus back. */
973 (void)SetFocus(s_hwnd);
974
975 if (s_findrep_struct.Flags & FR_FINDNEXT)
976 {
977 flags = FRD_FINDNEXT;
978
979 /* Give main window the focus back: this is so the cursor isn't
980 * hollow. */
981 (void)SetFocus(s_hwnd);
982 }
983 else if (s_findrep_struct.Flags & FR_REPLACE)
984 {
985 flags = FRD_REPLACE;
986
987 /* Give main window the focus back: this is so the cursor isn't
988 * hollow. */
989 (void)SetFocus(s_hwnd);
990 }
991 else if (s_findrep_struct.Flags & FR_REPLACEALL)
992 {
993 flags = FRD_REPLACEALL;
994 }
995
996 if (flags != 0)
997 {
998 /* Call the generic GUI function to do the actual work. */
999 if (s_findrep_struct.Flags & FR_WHOLEWORD)
1000 flags |= FRD_WHOLE_WORD;
1001 if (s_findrep_struct.Flags & FR_MATCHCASE)
1002 flags |= FRD_MATCH_CASE;
1003 down = (s_findrep_struct.Flags & FR_DOWN) != 0;
Bram Moolenaar418f81b2016-02-16 20:12:02 +01001004 gui_do_findrepl(flags, (char_u *)s_findrep_struct.lpstrFindWhat,
1005 (char_u *)s_findrep_struct.lpstrReplaceWith, down);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001006 }
1007}
1008#endif
1009
1010 static void
1011HandleMouseHide(UINT uMsg, LPARAM lParam)
1012{
1013 static LPARAM last_lParam = 0L;
1014
1015 /* We sometimes get a mousemove when the mouse didn't move... */
Bram Moolenaar268b55b2013-09-22 15:43:37 +02001016 if (uMsg == WM_MOUSEMOVE || uMsg == WM_NCMOUSEMOVE)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001017 {
1018 if (lParam == last_lParam)
1019 return;
1020 last_lParam = lParam;
1021 }
1022
1023 /* Handle specially, to centralise coding. We need to be sure we catch all
1024 * possible events which should cause us to restore the cursor (as it is a
1025 * shared resource, we take full responsibility for it).
1026 */
1027 switch (uMsg)
1028 {
1029 case WM_KEYUP:
1030 case WM_CHAR:
1031 /*
1032 * blank out the pointer if necessary
1033 */
1034 if (p_mh)
1035 gui_mch_mousehide(TRUE);
1036 break;
1037
1038 case WM_SYSKEYUP: /* show the pointer when a system-key is pressed */
1039 case WM_SYSCHAR:
1040 case WM_MOUSEMOVE: /* show the pointer on any mouse action */
1041 case WM_LBUTTONDOWN:
1042 case WM_LBUTTONUP:
1043 case WM_MBUTTONDOWN:
1044 case WM_MBUTTONUP:
1045 case WM_RBUTTONDOWN:
1046 case WM_RBUTTONUP:
1047 case WM_XBUTTONDOWN:
1048 case WM_XBUTTONUP:
1049 case WM_NCMOUSEMOVE:
1050 case WM_NCLBUTTONDOWN:
1051 case WM_NCLBUTTONUP:
1052 case WM_NCMBUTTONDOWN:
1053 case WM_NCMBUTTONUP:
1054 case WM_NCRBUTTONDOWN:
1055 case WM_NCRBUTTONUP:
1056 case WM_KILLFOCUS:
1057 /*
1058 * if the pointer is currently hidden, then we should show it.
1059 */
1060 gui_mch_mousehide(FALSE);
1061 break;
1062 }
1063}
1064
1065 static LRESULT CALLBACK
1066_TextAreaWndProc(
1067 HWND hwnd,
1068 UINT uMsg,
1069 WPARAM wParam,
1070 LPARAM lParam)
1071{
1072 /*
1073 TRACE("TextAreaWndProc: hwnd = %08x, msg = %x, wParam = %x, lParam = %x\n",
1074 hwnd, uMsg, wParam, lParam);
1075 */
1076
1077 HandleMouseHide(uMsg, lParam);
1078
1079 s_uMsg = uMsg;
1080 s_wParam = wParam;
1081 s_lParam = lParam;
1082
1083#ifdef FEAT_BEVAL
1084 TrackUserActivity(uMsg);
1085#endif
1086
1087 switch (uMsg)
1088 {
1089 HANDLE_MSG(hwnd, WM_LBUTTONDBLCLK,_OnMouseButtonDown);
1090 HANDLE_MSG(hwnd, WM_LBUTTONDOWN,_OnMouseButtonDown);
1091 HANDLE_MSG(hwnd, WM_LBUTTONUP, _OnMouseMoveOrRelease);
1092 HANDLE_MSG(hwnd, WM_MBUTTONDBLCLK,_OnMouseButtonDown);
1093 HANDLE_MSG(hwnd, WM_MBUTTONDOWN,_OnMouseButtonDown);
1094 HANDLE_MSG(hwnd, WM_MBUTTONUP, _OnMouseMoveOrRelease);
1095 HANDLE_MSG(hwnd, WM_MOUSEMOVE, _OnMouseMoveOrRelease);
1096 HANDLE_MSG(hwnd, WM_PAINT, _OnPaint);
1097 HANDLE_MSG(hwnd, WM_RBUTTONDBLCLK,_OnMouseButtonDown);
1098 HANDLE_MSG(hwnd, WM_RBUTTONDOWN,_OnMouseButtonDown);
1099 HANDLE_MSG(hwnd, WM_RBUTTONUP, _OnMouseMoveOrRelease);
1100#ifndef WIN16 /*<VN>*/
1101 HANDLE_MSG(hwnd, WM_XBUTTONDBLCLK,_OnMouseButtonDown);
1102 HANDLE_MSG(hwnd, WM_XBUTTONDOWN,_OnMouseButtonDown);
1103 HANDLE_MSG(hwnd, WM_XBUTTONUP, _OnMouseMoveOrRelease);
1104#endif
1105
1106#ifdef FEAT_BEVAL
1107 case WM_NOTIFY: Handle_WM_Notify(hwnd, (LPNMHDR)lParam);
1108 return TRUE;
1109#endif
Bram Moolenaar4d526ad2010-02-03 12:23:24 +01001110 default:
1111 return MyWindowProc(hwnd, uMsg, wParam, lParam);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001112 }
1113}
1114
1115#if (defined(WIN3264) && defined(FEAT_MBYTE)) \
1116 || defined(GLOBAL_IME) \
1117 || defined(PROTO)
1118# ifdef PROTO
1119typedef int WINAPI;
1120# endif
1121
1122 LRESULT WINAPI
1123vim_WindowProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
1124{
1125# ifdef GLOBAL_IME
1126 return global_ime_DefWindowProc(hwnd, message, wParam, lParam);
1127# else
1128 if (wide_WindowProc)
1129 return DefWindowProcW(hwnd, message, wParam, lParam);
1130 return DefWindowProc(hwnd, message, wParam, lParam);
1131#endif
1132}
1133#endif
1134
1135/*
1136 * Called when the foreground or background color has been changed.
1137 */
1138 void
1139gui_mch_new_colors(void)
1140{
1141 /* nothing to do? */
1142}
1143
1144/*
1145 * Set the colors to their default values.
1146 */
1147 void
Bram Moolenaar68c2f632016-01-30 17:24:07 +01001148gui_mch_def_colors(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001149{
1150 gui.norm_pixel = GetSysColor(COLOR_WINDOWTEXT);
1151 gui.back_pixel = GetSysColor(COLOR_WINDOW);
1152 gui.def_norm_pixel = gui.norm_pixel;
1153 gui.def_back_pixel = gui.back_pixel;
1154}
1155
1156/*
1157 * Open the GUI window which was created by a call to gui_mch_init().
1158 */
1159 int
1160gui_mch_open(void)
1161{
1162#ifndef SW_SHOWDEFAULT
1163# define SW_SHOWDEFAULT 10 /* Borland 5.0 doesn't have it */
1164#endif
1165 /* Actually open the window, if not already visible
1166 * (may be done already in gui_mch_set_shellsize) */
1167 if (!IsWindowVisible(s_hwnd))
1168 ShowWindow(s_hwnd, SW_SHOWDEFAULT);
1169
Bram Moolenaare2f98b92006-03-29 21:18:24 +00001170#ifdef MSWIN_FIND_REPLACE
1171 /* Init replace string here, so that we keep it when re-opening the
1172 * dialog. */
1173 s_findrep_struct.lpstrReplaceWith[0] = NUL;
1174#endif
1175
Bram Moolenaar071d4272004-06-13 20:20:40 +00001176 return OK;
1177}
1178
1179/*
1180 * Get the position of the top left corner of the window.
1181 */
1182 int
1183gui_mch_get_winpos(int *x, int *y)
1184{
1185 RECT rect;
1186
1187 GetWindowRect(s_hwnd, &rect);
1188 *x = rect.left;
1189 *y = rect.top;
1190 return OK;
1191}
1192
1193/*
1194 * Set the position of the top left corner of the window to the given
1195 * coordinates.
1196 */
1197 void
1198gui_mch_set_winpos(int x, int y)
1199{
1200 SetWindowPos(s_hwnd, NULL, x, y, 0, 0,
1201 SWP_NOZORDER | SWP_NOSIZE | SWP_NOACTIVATE);
1202}
1203 void
1204gui_mch_set_text_area_pos(int x, int y, int w, int h)
1205{
1206 static int oldx = 0;
1207 static int oldy = 0;
1208
1209 SetWindowPos(s_textArea, NULL, x, y, w, h, SWP_NOZORDER | SWP_NOACTIVATE);
1210
1211#ifdef FEAT_TOOLBAR
1212 if (vim_strchr(p_go, GO_TOOLBAR) != NULL)
1213 SendMessage(s_toolbarhwnd, WM_SIZE,
Bram Moolenaar5555acc2006-04-07 21:33:12 +00001214 (WPARAM)0, (LPARAM)(w + ((long)(TOOLBAR_BUTTON_HEIGHT+8)<<16)));
Bram Moolenaar071d4272004-06-13 20:20:40 +00001215#endif
Bram Moolenaar3991dab2006-03-27 17:01:56 +00001216#if defined(FEAT_GUI_TABLINE)
1217 if (showing_tabline)
1218 {
Bram Moolenaar2e2a2812006-03-27 20:55:21 +00001219 int top = 0;
Bram Moolenaarc6fe9192006-04-09 21:54:49 +00001220 RECT rect;
Bram Moolenaar3991dab2006-03-27 17:01:56 +00001221
Bram Moolenaar551dbcc2006-04-25 22:13:59 +00001222# ifdef FEAT_TOOLBAR
Bram Moolenaar3991dab2006-03-27 17:01:56 +00001223 if (vim_strchr(p_go, GO_TOOLBAR) != NULL)
1224 top = TOOLBAR_BUTTON_HEIGHT + TOOLBAR_BORDER_HEIGHT;
Bram Moolenaar551dbcc2006-04-25 22:13:59 +00001225# endif
Bram Moolenaar5555acc2006-04-07 21:33:12 +00001226 GetClientRect(s_hwnd, &rect);
Bram Moolenaar551dbcc2006-04-25 22:13:59 +00001227 MoveWindow(s_tabhwnd, 0, top, rect.right, gui.tabline_height, TRUE);
Bram Moolenaar3991dab2006-03-27 17:01:56 +00001228 }
1229#endif
1230
Bram Moolenaar071d4272004-06-13 20:20:40 +00001231 /* When side scroll bar is unshown, the size of window will change.
1232 * then, the text area move left or right. thus client rect should be
Bram Moolenaar84a05ac2013-05-06 04:24:17 +02001233 * forcedly redrawn. (Yasuhiro Matsumoto) */
Bram Moolenaar071d4272004-06-13 20:20:40 +00001234 if (oldx != x || oldy != y)
1235 {
1236 InvalidateRect(s_hwnd, NULL, FALSE);
1237 oldx = x;
1238 oldy = y;
1239 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00001240}
1241
1242
1243/*
1244 * Scrollbar stuff:
1245 */
1246
1247 void
1248gui_mch_enable_scrollbar(
1249 scrollbar_T *sb,
1250 int flag)
1251{
1252 ShowScrollBar(sb->id, SB_CTL, flag);
1253
1254 /* TODO: When the window is maximized, the size of the window stays the
1255 * same, thus the size of the text area changes. On Win98 it's OK, on Win
1256 * NT 4.0 it's not... */
1257}
1258
1259 void
1260gui_mch_set_scrollbar_pos(
1261 scrollbar_T *sb,
1262 int x,
1263 int y,
1264 int w,
1265 int h)
1266{
Bram Moolenaar02743632005-07-25 20:42:36 +00001267 SetWindowPos(sb->id, NULL, x, y, w, h,
1268 SWP_NOZORDER | SWP_NOACTIVATE | SWP_SHOWWINDOW);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001269}
1270
1271 void
1272gui_mch_create_scrollbar(
1273 scrollbar_T *sb,
1274 int orient) /* SBAR_VERT or SBAR_HORIZ */
1275{
1276 sb->id = CreateWindow(
1277 "SCROLLBAR", "Scrollbar",
1278 WS_CHILD | ((orient == SBAR_VERT) ? SBS_VERT : SBS_HORZ), 0, 0,
1279 10, /* Any value will do for now */
1280 10, /* Any value will do for now */
1281 s_hwnd, NULL,
1282 s_hinst, NULL);
1283}
1284
1285/*
1286 * Find the scrollbar with the given hwnd.
1287 */
1288 static scrollbar_T *
1289gui_mswin_find_scrollbar(HWND hwnd)
1290{
1291 win_T *wp;
1292
1293 if (gui.bottom_sbar.id == hwnd)
1294 return &gui.bottom_sbar;
1295 FOR_ALL_WINDOWS(wp)
1296 {
1297 if (wp->w_scrollbars[SBAR_LEFT].id == hwnd)
1298 return &wp->w_scrollbars[SBAR_LEFT];
1299 if (wp->w_scrollbars[SBAR_RIGHT].id == hwnd)
1300 return &wp->w_scrollbars[SBAR_RIGHT];
1301 }
1302 return NULL;
1303}
1304
1305/*
1306 * Get the character size of a font.
1307 */
1308 static void
1309GetFontSize(GuiFont font)
1310{
1311 HWND hwnd = GetDesktopWindow();
1312 HDC hdc = GetWindowDC(hwnd);
1313 HFONT hfntOld = SelectFont(hdc, (HFONT)font);
1314 TEXTMETRIC tm;
1315
1316 GetTextMetrics(hdc, &tm);
1317 gui.char_width = tm.tmAveCharWidth + tm.tmOverhang;
1318
1319 gui.char_height = tm.tmHeight
1320#ifndef MSWIN16_FASTTEXT
Bram Moolenaar02743632005-07-25 20:42:36 +00001321 + p_linespace
Bram Moolenaar071d4272004-06-13 20:20:40 +00001322#endif
Bram Moolenaar02743632005-07-25 20:42:36 +00001323 ;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001324
1325 SelectFont(hdc, hfntOld);
1326
1327 ReleaseDC(hwnd, hdc);
1328}
1329
Bram Moolenaar02743632005-07-25 20:42:36 +00001330/*
1331 * Adjust gui.char_height (after 'linespace' was changed).
1332 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00001333 int
Bram Moolenaar02743632005-07-25 20:42:36 +00001334gui_mch_adjust_charheight(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001335{
1336 GetFontSize(gui.norm_font);
1337 return OK;
1338}
1339
1340 static GuiFont
1341get_font_handle(LOGFONT *lf)
1342{
1343 HFONT font = NULL;
1344
1345 /* Load the font */
1346 font = CreateFontIndirect(lf);
1347
1348 if (font == NULL)
1349 return NOFONT;
1350
1351 return (GuiFont)font;
1352}
1353
1354 static int
1355pixels_to_points(int pixels, int vertical)
1356{
1357 int points;
1358 HWND hwnd;
1359 HDC hdc;
1360
1361 hwnd = GetDesktopWindow();
1362 hdc = GetWindowDC(hwnd);
1363
1364 points = MulDiv(pixels, 72,
1365 GetDeviceCaps(hdc, vertical ? LOGPIXELSY : LOGPIXELSX));
1366
1367 ReleaseDC(hwnd, hdc);
1368
1369 return points;
1370}
1371
1372 GuiFont
1373gui_mch_get_font(
1374 char_u *name,
1375 int giveErrorIfMissing)
1376{
1377 LOGFONT lf;
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00001378 GuiFont font = NOFONT;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001379
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00001380 if (get_logfont(&lf, name, NULL, giveErrorIfMissing) == OK)
1381 font = get_font_handle(&lf);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001382 if (font == NOFONT && giveErrorIfMissing)
1383 EMSG2(_(e_font), name);
1384 return font;
1385}
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00001386
Bram Moolenaardfccaf02004-12-31 20:56:11 +00001387#if defined(FEAT_EVAL) || defined(PROTO)
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00001388/*
1389 * Return the name of font "font" in allocated memory.
1390 * Don't know how to get the actual name, thus use the provided name.
1391 */
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00001392/*ARGSUSED*/
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00001393 char_u *
Bram Moolenaar68c2f632016-01-30 17:24:07 +01001394gui_mch_get_fontname(GuiFont font, char_u *name)
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00001395{
1396 if (name == NULL)
1397 return NULL;
1398 return vim_strsave(name);
1399}
Bram Moolenaardfccaf02004-12-31 20:56:11 +00001400#endif
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00001401
Bram Moolenaar071d4272004-06-13 20:20:40 +00001402 void
1403gui_mch_free_font(GuiFont font)
1404{
1405 if (font)
1406 DeleteObject((HFONT)font);
1407}
1408
1409 static int
1410hex_digit(int c)
1411{
1412 if (VIM_ISDIGIT(c))
1413 return c - '0';
1414 c = TOLOWER_ASC(c);
1415 if (c >= 'a' && c <= 'f')
1416 return c - 'a' + 10;
1417 return -1000;
1418}
1419/*
1420 * Return the Pixel value (color) for the given color name.
1421 * Return INVALCOLOR for error.
1422 */
1423 guicolor_T
1424gui_mch_get_color(char_u *name)
1425{
1426 typedef struct guicolor_tTable
1427 {
1428 char *name;
1429 COLORREF color;
1430 } guicolor_tTable;
1431
1432 static guicolor_tTable table[] =
1433 {
1434 {"Black", RGB(0x00, 0x00, 0x00)},
Bram Moolenaar092e3c82011-09-07 18:58:29 +02001435 {"DarkGray", RGB(0xA9, 0xA9, 0xA9)},
1436 {"DarkGrey", RGB(0xA9, 0xA9, 0xA9)},
Bram Moolenaar071d4272004-06-13 20:20:40 +00001437 {"Gray", RGB(0xC0, 0xC0, 0xC0)},
1438 {"Grey", RGB(0xC0, 0xC0, 0xC0)},
Bram Moolenaar092e3c82011-09-07 18:58:29 +02001439 {"LightGray", RGB(0xD3, 0xD3, 0xD3)},
1440 {"LightGrey", RGB(0xD3, 0xD3, 0xD3)},
Bram Moolenaarb21e5842006-04-16 18:30:08 +00001441 {"Gray10", RGB(0x1A, 0x1A, 0x1A)},
1442 {"Grey10", RGB(0x1A, 0x1A, 0x1A)},
1443 {"Gray20", RGB(0x33, 0x33, 0x33)},
1444 {"Grey20", RGB(0x33, 0x33, 0x33)},
1445 {"Gray30", RGB(0x4D, 0x4D, 0x4D)},
1446 {"Grey30", RGB(0x4D, 0x4D, 0x4D)},
1447 {"Gray40", RGB(0x66, 0x66, 0x66)},
1448 {"Grey40", RGB(0x66, 0x66, 0x66)},
1449 {"Gray50", RGB(0x7F, 0x7F, 0x7F)},
1450 {"Grey50", RGB(0x7F, 0x7F, 0x7F)},
1451 {"Gray60", RGB(0x99, 0x99, 0x99)},
1452 {"Grey60", RGB(0x99, 0x99, 0x99)},
1453 {"Gray70", RGB(0xB3, 0xB3, 0xB3)},
1454 {"Grey70", RGB(0xB3, 0xB3, 0xB3)},
1455 {"Gray80", RGB(0xCC, 0xCC, 0xCC)},
1456 {"Grey80", RGB(0xCC, 0xCC, 0xCC)},
Bram Moolenaare2f98b92006-03-29 21:18:24 +00001457 {"Gray90", RGB(0xE5, 0xE5, 0xE5)},
1458 {"Grey90", RGB(0xE5, 0xE5, 0xE5)},
Bram Moolenaar071d4272004-06-13 20:20:40 +00001459 {"White", RGB(0xFF, 0xFF, 0xFF)},
1460 {"DarkRed", RGB(0x80, 0x00, 0x00)},
1461 {"Red", RGB(0xFF, 0x00, 0x00)},
1462 {"LightRed", RGB(0xFF, 0xA0, 0xA0)},
1463 {"DarkBlue", RGB(0x00, 0x00, 0x80)},
1464 {"Blue", RGB(0x00, 0x00, 0xFF)},
Bram Moolenaar092e3c82011-09-07 18:58:29 +02001465 {"LightBlue", RGB(0xAD, 0xD8, 0xE6)},
Bram Moolenaar071d4272004-06-13 20:20:40 +00001466 {"DarkGreen", RGB(0x00, 0x80, 0x00)},
1467 {"Green", RGB(0x00, 0xFF, 0x00)},
Bram Moolenaar092e3c82011-09-07 18:58:29 +02001468 {"LightGreen", RGB(0x90, 0xEE, 0x90)},
Bram Moolenaar071d4272004-06-13 20:20:40 +00001469 {"DarkCyan", RGB(0x00, 0x80, 0x80)},
1470 {"Cyan", RGB(0x00, 0xFF, 0xFF)},
Bram Moolenaar092e3c82011-09-07 18:58:29 +02001471 {"LightCyan", RGB(0xE0, 0xFF, 0xFF)},
Bram Moolenaar071d4272004-06-13 20:20:40 +00001472 {"DarkMagenta", RGB(0x80, 0x00, 0x80)},
1473 {"Magenta", RGB(0xFF, 0x00, 0xFF)},
1474 {"LightMagenta", RGB(0xFF, 0xA0, 0xFF)},
1475 {"Brown", RGB(0x80, 0x40, 0x40)},
1476 {"Yellow", RGB(0xFF, 0xFF, 0x00)},
Bram Moolenaar092e3c82011-09-07 18:58:29 +02001477 {"LightYellow", RGB(0xFF, 0xFF, 0xE0)},
Bram Moolenaar071d4272004-06-13 20:20:40 +00001478 {"DarkYellow", RGB(0xBB, 0xBB, 0x00)},
1479 {"SeaGreen", RGB(0x2E, 0x8B, 0x57)},
1480 {"Orange", RGB(0xFF, 0xA5, 0x00)},
1481 {"Purple", RGB(0xA0, 0x20, 0xF0)},
1482 {"SlateBlue", RGB(0x6A, 0x5A, 0xCD)},
1483 {"Violet", RGB(0xEE, 0x82, 0xEE)},
1484 };
1485
1486 typedef struct SysColorTable
1487 {
1488 char *name;
1489 int color;
1490 } SysColorTable;
1491
1492 static SysColorTable sys_table[] =
1493 {
1494#ifdef WIN3264
1495 {"SYS_3DDKSHADOW", COLOR_3DDKSHADOW},
1496 {"SYS_3DHILIGHT", COLOR_3DHILIGHT},
1497#ifndef __MINGW32__
1498 {"SYS_3DHIGHLIGHT", COLOR_3DHIGHLIGHT},
1499#endif
1500 {"SYS_BTNHILIGHT", COLOR_BTNHILIGHT},
1501 {"SYS_BTNHIGHLIGHT", COLOR_BTNHIGHLIGHT},
1502 {"SYS_3DLIGHT", COLOR_3DLIGHT},
1503 {"SYS_3DSHADOW", COLOR_3DSHADOW},
1504 {"SYS_DESKTOP", COLOR_DESKTOP},
1505 {"SYS_INFOBK", COLOR_INFOBK},
1506 {"SYS_INFOTEXT", COLOR_INFOTEXT},
1507 {"SYS_3DFACE", COLOR_3DFACE},
1508#endif
1509 {"SYS_BTNFACE", COLOR_BTNFACE},
1510 {"SYS_BTNSHADOW", COLOR_BTNSHADOW},
1511 {"SYS_ACTIVEBORDER", COLOR_ACTIVEBORDER},
1512 {"SYS_ACTIVECAPTION", COLOR_ACTIVECAPTION},
1513 {"SYS_APPWORKSPACE", COLOR_APPWORKSPACE},
1514 {"SYS_BACKGROUND", COLOR_BACKGROUND},
1515 {"SYS_BTNTEXT", COLOR_BTNTEXT},
1516 {"SYS_CAPTIONTEXT", COLOR_CAPTIONTEXT},
1517 {"SYS_GRAYTEXT", COLOR_GRAYTEXT},
1518 {"SYS_HIGHLIGHT", COLOR_HIGHLIGHT},
1519 {"SYS_HIGHLIGHTTEXT", COLOR_HIGHLIGHTTEXT},
1520 {"SYS_INACTIVEBORDER", COLOR_INACTIVEBORDER},
1521 {"SYS_INACTIVECAPTION", COLOR_INACTIVECAPTION},
1522 {"SYS_INACTIVECAPTIONTEXT", COLOR_INACTIVECAPTIONTEXT},
1523 {"SYS_MENU", COLOR_MENU},
1524 {"SYS_MENUTEXT", COLOR_MENUTEXT},
1525 {"SYS_SCROLLBAR", COLOR_SCROLLBAR},
1526 {"SYS_WINDOW", COLOR_WINDOW},
1527 {"SYS_WINDOWFRAME", COLOR_WINDOWFRAME},
1528 {"SYS_WINDOWTEXT", COLOR_WINDOWTEXT}
1529 };
1530
1531 int r, g, b;
1532 int i;
1533
Bram Moolenaar418f81b2016-02-16 20:12:02 +01001534 if (name[0] == '#' && STRLEN(name) == 7)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001535 {
1536 /* Name is in "#rrggbb" format */
1537 r = hex_digit(name[1]) * 16 + hex_digit(name[2]);
1538 g = hex_digit(name[3]) * 16 + hex_digit(name[4]);
1539 b = hex_digit(name[5]) * 16 + hex_digit(name[6]);
1540 if (r < 0 || g < 0 || b < 0)
1541 return INVALCOLOR;
1542 return RGB(r, g, b);
1543 }
1544 else
1545 {
1546 /* Check if the name is one of the colors we know */
1547 for (i = 0; i < sizeof(table) / sizeof(table[0]); i++)
1548 if (STRICMP(name, table[i].name) == 0)
1549 return table[i].color;
1550 }
1551
1552 /*
1553 * Try to look up a system colour.
1554 */
1555 for (i = 0; i < sizeof(sys_table) / sizeof(sys_table[0]); i++)
1556 if (STRICMP(name, sys_table[i].name) == 0)
1557 return GetSysColor(sys_table[i].color);
1558
1559 /*
1560 * Last attempt. Look in the file "$VIMRUNTIME/rgb.txt".
1561 */
1562 {
1563#define LINE_LEN 100
1564 FILE *fd;
1565 char line[LINE_LEN];
1566 char_u *fname;
1567
1568 fname = expand_env_save((char_u *)"$VIMRUNTIME/rgb.txt");
1569 if (fname == NULL)
1570 return INVALCOLOR;
1571
Bram Moolenaar5555acc2006-04-07 21:33:12 +00001572 fd = mch_fopen((char *)fname, "rt");
Bram Moolenaar071d4272004-06-13 20:20:40 +00001573 vim_free(fname);
1574 if (fd == NULL)
1575 return INVALCOLOR;
1576
1577 while (!feof(fd))
1578 {
1579 int len;
1580 int pos;
1581 char *color;
1582
1583 fgets(line, LINE_LEN, fd);
1584 len = (int)STRLEN(line);
1585
1586 if (len <= 1 || line[len-1] != '\n')
1587 continue;
1588
1589 line[len-1] = '\0';
1590
1591 i = sscanf(line, "%d %d %d %n", &r, &g, &b, &pos);
1592 if (i != 3)
1593 continue;
1594
1595 color = line + pos;
1596
1597 if (STRICMP(color, name) == 0)
1598 {
1599 fclose(fd);
1600 return (guicolor_T) RGB(r, g, b);
1601 }
1602 }
1603
1604 fclose(fd);
1605 }
1606
1607 return INVALCOLOR;
1608}
1609/*
1610 * Return OK if the key with the termcap name "name" is supported.
1611 */
1612 int
1613gui_mch_haskey(char_u *name)
1614{
1615 int i;
1616
1617 for (i = 0; special_keys[i].vim_code1 != NUL; i++)
1618 if (name[0] == special_keys[i].vim_code0 &&
1619 name[1] == special_keys[i].vim_code1)
1620 return OK;
1621 return FAIL;
1622}
1623
1624 void
1625gui_mch_beep(void)
1626{
1627 MessageBeep(MB_OK);
1628}
1629/*
1630 * Invert a rectangle from row r, column c, for nr rows and nc columns.
1631 */
1632 void
1633gui_mch_invert_rectangle(
1634 int r,
1635 int c,
1636 int nr,
1637 int nc)
1638{
1639 RECT rc;
1640
1641 /*
1642 * Note: InvertRect() excludes right and bottom of rectangle.
1643 */
1644 rc.left = FILL_X(c);
1645 rc.top = FILL_Y(r);
1646 rc.right = rc.left + nc * gui.char_width;
1647 rc.bottom = rc.top + nr * gui.char_height;
1648 InvertRect(s_hdc, &rc);
1649}
1650
1651/*
1652 * Iconify the GUI window.
1653 */
1654 void
1655gui_mch_iconify(void)
1656{
1657 ShowWindow(s_hwnd, SW_MINIMIZE);
1658}
1659
1660/*
1661 * Draw a cursor without focus.
1662 */
1663 void
1664gui_mch_draw_hollow_cursor(guicolor_T color)
1665{
1666 HBRUSH hbr;
1667 RECT rc;
1668
1669 /*
1670 * Note: FrameRect() excludes right and bottom of rectangle.
1671 */
1672 rc.left = FILL_X(gui.col);
1673 rc.top = FILL_Y(gui.row);
1674 rc.right = rc.left + gui.char_width;
1675#ifdef FEAT_MBYTE
1676 if (mb_lefthalve(gui.row, gui.col))
1677 rc.right += gui.char_width;
1678#endif
1679 rc.bottom = rc.top + gui.char_height;
1680 hbr = CreateSolidBrush(color);
1681 FrameRect(s_hdc, &rc, hbr);
1682 DeleteBrush(hbr);
1683}
1684/*
1685 * Draw part of a cursor, "w" pixels wide, and "h" pixels high, using
1686 * color "color".
1687 */
1688 void
1689gui_mch_draw_part_cursor(
1690 int w,
1691 int h,
1692 guicolor_T color)
1693{
1694 HBRUSH hbr;
1695 RECT rc;
1696
1697 /*
1698 * Note: FillRect() excludes right and bottom of rectangle.
1699 */
1700 rc.left =
1701#ifdef FEAT_RIGHTLEFT
1702 /* vertical line should be on the right of current point */
1703 CURSOR_BAR_RIGHT ? FILL_X(gui.col + 1) - w :
1704#endif
1705 FILL_X(gui.col);
1706 rc.top = FILL_Y(gui.row) + gui.char_height - h;
1707 rc.right = rc.left + w;
1708 rc.bottom = rc.top + h;
1709 hbr = CreateSolidBrush(color);
1710 FillRect(s_hdc, &rc, hbr);
1711 DeleteBrush(hbr);
1712}
1713
Bram Moolenaar25b2b942016-01-17 20:53:12 +01001714
1715/*
1716 * Generates a VK_SPACE when the internal dead_key flag is set to output the
1717 * dead key's nominal character and re-post the original message.
1718 */
1719 static void
1720outputDeadKey_rePost(MSG originalMsg)
1721{
1722 static MSG deadCharExpel;
1723
1724 if (!dead_key)
1725 return;
1726
1727 dead_key = 0;
1728
1729 /* Make Windows generate the dead key's character */
1730 deadCharExpel.message = originalMsg.message;
1731 deadCharExpel.hwnd = originalMsg.hwnd;
1732 deadCharExpel.wParam = VK_SPACE;
1733
1734 MyTranslateMessage(&deadCharExpel);
1735
1736 /* re-generate the current character free of the dead char influence */
1737 PostMessage(originalMsg.hwnd, originalMsg.message, originalMsg.wParam,
1738 originalMsg.lParam);
1739}
1740
1741
Bram Moolenaar071d4272004-06-13 20:20:40 +00001742/*
1743 * Process a single Windows message.
1744 * If one is not available we hang until one is.
1745 */
1746 static void
1747process_message(void)
1748{
1749 MSG msg;
1750 UINT vk = 0; /* Virtual key */
1751 char_u string[40];
1752 int i;
1753 int modifiers = 0;
1754 int key;
Bram Moolenaar293ee4d2004-12-09 21:34:53 +00001755#ifdef FEAT_MENU
1756 static char_u k10[] = {K_SPECIAL, 'k', ';', 0};
1757#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00001758
Bram Moolenaar8c85fa32011-08-10 17:08:03 +02001759 pGetMessage(&msg, NULL, 0, 0);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001760
1761#ifdef FEAT_OLE
1762 /* Look after OLE Automation commands */
1763 if (msg.message == WM_OLE)
1764 {
1765 char_u *str = (char_u *)msg.lParam;
Bram Moolenaar370feaf2009-01-28 13:18:26 +00001766 if (str == NULL || *str == NUL)
1767 {
1768 /* Message can't be ours, forward it. Fixes problem with Ultramon
1769 * 3.0.4 */
Bram Moolenaar8c85fa32011-08-10 17:08:03 +02001770 pDispatchMessage(&msg);
Bram Moolenaar370feaf2009-01-28 13:18:26 +00001771 }
1772 else
1773 {
1774 add_to_input_buf(str, (int)STRLEN(str));
1775 vim_free(str); /* was allocated in CVim::SendKeys() */
1776 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00001777 return;
1778 }
1779#endif
1780
Bram Moolenaard04a0202016-01-26 23:30:18 +01001781#ifdef FEAT_CHANNEL
Bram Moolenaar071d4272004-06-13 20:20:40 +00001782 if (msg.message == WM_NETBEANS)
1783 {
Bram Moolenaar7b3ca762016-02-14 19:13:43 +01001784 int what;
1785 channel_T *channel = channel_fd2channel((sock_T)msg.wParam, &what);
Bram Moolenaar85be35f2016-01-27 21:08:18 +01001786
Bram Moolenaar77073442016-02-13 23:23:53 +01001787 if (channel != NULL)
Bram Moolenaarbfa1ffc2016-02-13 18:40:30 +01001788 {
1789 /* Disable error messages, they can mess up the display and throw
1790 * an exception. */
1791 ++emsg_off;
Bram Moolenaar7b3ca762016-02-14 19:13:43 +01001792 channel_read(channel, what, "process_message");
Bram Moolenaarbfa1ffc2016-02-13 18:40:30 +01001793 --emsg_off;
1794 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00001795 return;
1796 }
1797#endif
1798
1799#ifdef FEAT_SNIFF
1800 if (sniff_request_waiting && want_sniff_request)
1801 {
1802 static char_u bytes[3] = {CSI, (char_u)KS_EXTRA, (char_u)KE_SNIFF};
1803 add_to_input_buf(bytes, 3); /* K_SNIFF */
1804 sniff_request_waiting = 0;
1805 want_sniff_request = 0;
1806 /* request is handled in normal.c */
1807 }
1808 if (msg.message == WM_USER)
Bram Moolenaar35c92912006-06-22 17:34:26 +00001809 {
Bram Moolenaard8a92d72006-06-23 14:44:06 +00001810 MyTranslateMessage(&msg);
Bram Moolenaar8c85fa32011-08-10 17:08:03 +02001811 pDispatchMessage(&msg);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001812 return;
Bram Moolenaar35c92912006-06-22 17:34:26 +00001813 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00001814#endif
1815
1816#ifdef MSWIN_FIND_REPLACE
1817 /* Don't process messages used by the dialog */
Bram Moolenaar8c85fa32011-08-10 17:08:03 +02001818 if (s_findrep_hwnd != NULL && pIsDialogMessage(s_findrep_hwnd, &msg))
Bram Moolenaar071d4272004-06-13 20:20:40 +00001819 {
1820 HandleMouseHide(msg.message, msg.lParam);
1821 return;
1822 }
1823#endif
1824
1825 /*
1826 * Check if it's a special key that we recognise. If not, call
1827 * TranslateMessage().
1828 */
1829 if (msg.message == WM_KEYDOWN || msg.message == WM_SYSKEYDOWN)
1830 {
1831 vk = (int) msg.wParam;
Bram Moolenaar25b2b942016-01-17 20:53:12 +01001832
Bram Moolenaard2e80872014-08-22 18:44:33 +02001833 /*
Bram Moolenaar25b2b942016-01-17 20:53:12 +01001834 * Handle dead keys in special conditions in other cases we let Windows
1835 * handle them and do not interfere.
Bram Moolenaard2e80872014-08-22 18:44:33 +02001836 *
Bram Moolenaar25b2b942016-01-17 20:53:12 +01001837 * The dead_key flag must be reset on several occasions:
1838 * - in _OnChar() (or _OnSysChar()) as any dead key was necessarily
1839 * consumed at that point (This is when we let Windows combine the
1840 * dead character on its own)
1841 *
1842 * - Before doing something special such as regenerating keypresses to
1843 * expel the dead character as this could trigger an infinite loop if
1844 * for some reason MyTranslateMessage() do not trigger a call
1845 * immediately to _OnChar() (or _OnSysChar()).
Bram Moolenaard2e80872014-08-22 18:44:33 +02001846 */
Bram Moolenaar25b2b942016-01-17 20:53:12 +01001847 if (dead_key)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001848 {
Bram Moolenaar25b2b942016-01-17 20:53:12 +01001849 /*
1850 * If a dead key was pressed and the user presses VK_SPACE,
1851 * VK_BACK, or VK_ESCAPE it means that he actually wants to deal
1852 * with the dead char now, so do nothing special and let Windows
1853 * handle it.
1854 *
1855 * Note that VK_SPACE combines with the dead_key's character and
1856 * only one WM_CHAR will be generated by TranslateMessage(), in
1857 * the two other cases two WM_CHAR will be generated: the dead
1858 * char and VK_BACK or VK_ESCAPE. That is most likely what the
1859 * user expects.
1860 */
1861 if ((vk == VK_SPACE || vk == VK_BACK || vk == VK_ESCAPE))
1862 {
1863 dead_key = 0;
1864 MyTranslateMessage(&msg);
1865 return;
1866 }
1867 /* In modes where we are not typing, dead keys should behave
1868 * normally */
1869 else if (!(get_real_state() & (INSERT | CMDLINE | SELECTMODE)))
1870 {
1871 outputDeadKey_rePost(msg);
1872 return;
1873 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00001874 }
1875
1876 /* Check for CTRL-BREAK */
1877 if (vk == VK_CANCEL)
1878 {
1879 trash_input_buf();
1880 got_int = TRUE;
1881 string[0] = Ctrl_C;
1882 add_to_input_buf(string, 1);
1883 }
1884
1885 for (i = 0; special_keys[i].key_sym != 0; i++)
1886 {
1887 /* ignore VK_SPACE when ALT key pressed: system menu */
1888 if (special_keys[i].key_sym == vk
1889 && (vk != VK_SPACE || !(GetKeyState(VK_MENU) & 0x8000)))
1890 {
Bram Moolenaar25b2b942016-01-17 20:53:12 +01001891 /*
1892 * Behave as exected if we have a dead key and the special key
1893 * is a key that would normally trigger the dead key nominal
1894 * character output (such as a NUMPAD printable character or
1895 * the TAB key, etc...).
1896 */
1897 if (dead_key && (special_keys[i].vim_code0 == 'K'
1898 || vk == VK_TAB || vk == CAR))
1899 {
1900 outputDeadKey_rePost(msg);
1901 return;
1902 }
1903
Bram Moolenaar071d4272004-06-13 20:20:40 +00001904#ifdef FEAT_MENU
Bram Moolenaar293ee4d2004-12-09 21:34:53 +00001905 /* Check for <F10>: Windows selects the menu. When <F10> is
1906 * mapped we want to use the mapping instead. */
Bram Moolenaar071d4272004-06-13 20:20:40 +00001907 if (vk == VK_F10
1908 && gui.menu_is_active
Bram Moolenaarbd743252010-10-20 21:23:33 +02001909 && check_map(k10, State, FALSE, TRUE, FALSE,
1910 NULL, NULL) == NULL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001911 break;
1912#endif
1913 if (GetKeyState(VK_SHIFT) & 0x8000)
1914 modifiers |= MOD_MASK_SHIFT;
1915 /*
1916 * Don't use caps-lock as shift, because these are special keys
1917 * being considered here, and we only want letters to get
1918 * shifted -- webb
1919 */
1920 /*
1921 if (GetKeyState(VK_CAPITAL) & 0x0001)
1922 modifiers ^= MOD_MASK_SHIFT;
1923 */
1924 if (GetKeyState(VK_CONTROL) & 0x8000)
1925 modifiers |= MOD_MASK_CTRL;
1926 if (GetKeyState(VK_MENU) & 0x8000)
1927 modifiers |= MOD_MASK_ALT;
1928
1929 if (special_keys[i].vim_code1 == NUL)
1930 key = special_keys[i].vim_code0;
1931 else
1932 key = TO_SPECIAL(special_keys[i].vim_code0,
1933 special_keys[i].vim_code1);
1934 key = simplify_key(key, &modifiers);
1935 if (key == CSI)
1936 key = K_CSI;
1937
1938 if (modifiers)
1939 {
1940 string[0] = CSI;
1941 string[1] = KS_MODIFIER;
1942 string[2] = modifiers;
1943 add_to_input_buf(string, 3);
1944 }
1945
1946 if (IS_SPECIAL(key))
1947 {
1948 string[0] = CSI;
1949 string[1] = K_SECOND(key);
1950 string[2] = K_THIRD(key);
1951 add_to_input_buf(string, 3);
1952 }
1953 else
1954 {
1955 int len;
1956
1957 /* Handle "key" as a Unicode character. */
Bram Moolenaar85a3e5c2007-11-20 16:22:16 +00001958 len = char_to_string(key, string, 40, FALSE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001959 add_to_input_buf(string, len);
1960 }
1961 break;
1962 }
1963 }
1964 if (special_keys[i].key_sym == 0)
1965 {
1966 /* Some keys need C-S- where they should only need C-.
1967 * Ignore 0xff, Windows XP sends it when NUMLOCK has changed since
1968 * system startup (Helmut Stiegler, 2003 Oct 3). */
1969 if (vk != 0xff
1970 && (GetKeyState(VK_CONTROL) & 0x8000)
1971 && !(GetKeyState(VK_SHIFT) & 0x8000)
1972 && !(GetKeyState(VK_MENU) & 0x8000))
1973 {
1974 /* CTRL-6 is '^'; Japanese keyboard maps '^' to vk == 0xDE */
1975 if (vk == '6' || MapVirtualKey(vk, 2) == (UINT)'^')
1976 {
1977 string[0] = Ctrl_HAT;
1978 add_to_input_buf(string, 1);
1979 }
1980 /* vk == 0xBD AZERTY for CTRL-'-', but CTRL-[ for * QWERTY! */
1981 else if (vk == 0xBD) /* QWERTY for CTRL-'-' */
1982 {
1983 string[0] = Ctrl__;
1984 add_to_input_buf(string, 1);
1985 }
1986 /* CTRL-2 is '@'; Japanese keyboard maps '@' to vk == 0xC0 */
1987 else if (vk == '2' || MapVirtualKey(vk, 2) == (UINT)'@')
1988 {
1989 string[0] = Ctrl_AT;
1990 add_to_input_buf(string, 1);
1991 }
1992 else
1993 MyTranslateMessage(&msg);
1994 }
1995 else
1996 MyTranslateMessage(&msg);
1997 }
1998 }
1999#ifdef FEAT_MBYTE_IME
2000 else if (msg.message == WM_IME_NOTIFY)
2001 _OnImeNotify(msg.hwnd, (DWORD)msg.wParam, (DWORD)msg.lParam);
2002 else if (msg.message == WM_KEYUP && im_get_status())
2003 /* added for non-MS IME (Yasuhiro Matsumoto) */
2004 MyTranslateMessage(&msg);
2005#endif
2006#if !defined(FEAT_MBYTE_IME) && defined(GLOBAL_IME)
2007/* GIME_TEST */
2008 else if (msg.message == WM_IME_STARTCOMPOSITION)
2009 {
2010 POINT point;
2011
2012 global_ime_set_font(&norm_logfont);
2013 point.x = FILL_X(gui.col);
2014 point.y = FILL_Y(gui.row);
2015 MapWindowPoints(s_textArea, s_hwnd, &point, 1);
2016 global_ime_set_position(&point);
2017 }
2018#endif
2019
2020#ifdef FEAT_MENU
Bram Moolenaar293ee4d2004-12-09 21:34:53 +00002021 /* Check for <F10>: Default effect is to select the menu. When <F10> is
2022 * mapped we need to stop it here to avoid strange effects (e.g., for the
2023 * key-up event) */
Bram Moolenaarbd743252010-10-20 21:23:33 +02002024 if (vk != VK_F10 || check_map(k10, State, FALSE, TRUE, FALSE,
2025 NULL, NULL) == NULL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002026#endif
Bram Moolenaar8c85fa32011-08-10 17:08:03 +02002027 pDispatchMessage(&msg);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002028}
2029
2030/*
2031 * Catch up with any queued events. This may put keyboard input into the
2032 * input buffer, call resize call-backs, trigger timers etc. If there is
2033 * nothing in the event queue (& no timers pending), then we return
2034 * immediately.
2035 */
2036 void
2037gui_mch_update(void)
2038{
2039 MSG msg;
2040
2041 if (!s_busy_processing)
Bram Moolenaar8c85fa32011-08-10 17:08:03 +02002042 while (pPeekMessage(&msg, NULL, 0, 0, PM_NOREMOVE)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002043 && !vim_is_input_buf_full())
2044 process_message();
2045}
2046
2047/*
2048 * GUI input routine called by gui_wait_for_chars(). Waits for a character
2049 * from the keyboard.
2050 * wtime == -1 Wait forever.
2051 * wtime == 0 This should never happen.
2052 * wtime > 0 Wait wtime milliseconds for a character.
2053 * Returns OK if a character was found to be available within the given time,
2054 * or FAIL otherwise.
2055 */
2056 int
2057gui_mch_wait_for_chars(int wtime)
2058{
2059 MSG msg;
2060 int focus;
2061
2062 s_timed_out = FALSE;
2063
2064 if (wtime > 0)
2065 {
2066 /* Don't do anything while processing a (scroll) message. */
2067 if (s_busy_processing)
2068 return FAIL;
2069 s_wait_timer = (UINT)SetTimer(NULL, 0, (UINT)wtime,
2070 (TIMERPROC)_OnTimer);
2071 }
2072
2073 allow_scrollbar = TRUE;
2074
2075 focus = gui.in_focus;
2076 while (!s_timed_out)
2077 {
2078 /* Stop or start blinking when focus changes */
2079 if (gui.in_focus != focus)
2080 {
2081 if (gui.in_focus)
2082 gui_mch_start_blink();
2083 else
2084 gui_mch_stop_blink();
2085 focus = gui.in_focus;
2086 }
2087
2088 if (s_need_activate)
2089 {
2090#ifdef WIN32
2091 (void)SetForegroundWindow(s_hwnd);
2092#else
2093 (void)SetActiveWindow(s_hwnd);
2094#endif
2095 s_need_activate = FALSE;
2096 }
2097
Bram Moolenaar93c88e02015-09-15 14:12:05 +02002098#ifdef MESSAGE_QUEUE
2099 parse_queued_messages();
Bram Moolenaar61665aa2008-12-24 11:20:53 +00002100#endif
2101
Bram Moolenaar071d4272004-06-13 20:20:40 +00002102 /*
2103 * Don't use gui_mch_update() because then we will spin-lock until a
2104 * char arrives, instead we use GetMessage() to hang until an
2105 * event arrives. No need to check for input_buf_full because we are
2106 * returning as soon as it contains a single char -- webb
2107 */
2108 process_message();
2109
2110 if (input_available())
2111 {
2112 if (s_wait_timer != 0 && !s_timed_out)
2113 {
2114 KillTimer(NULL, s_wait_timer);
2115
2116 /* Eat spurious WM_TIMER messages */
Bram Moolenaar8c85fa32011-08-10 17:08:03 +02002117 while (pPeekMessage(&msg, s_hwnd, WM_TIMER, WM_TIMER, PM_REMOVE))
Bram Moolenaar071d4272004-06-13 20:20:40 +00002118 ;
2119 s_wait_timer = 0;
2120 }
2121 allow_scrollbar = FALSE;
Bram Moolenaar293ee4d2004-12-09 21:34:53 +00002122
2123 /* Clear pending mouse button, the release event may have been
Bram Moolenaarea408882007-12-03 21:21:03 +00002124 * taken by the dialog window. But don't do this when getting
2125 * focus, we need the mouse-up event then. */
2126 if (!s_getting_focus)
2127 s_button_pending = -1;
Bram Moolenaar293ee4d2004-12-09 21:34:53 +00002128
Bram Moolenaar071d4272004-06-13 20:20:40 +00002129 return OK;
2130 }
2131 }
2132 allow_scrollbar = FALSE;
2133 return FAIL;
2134}
2135
2136/*
2137 * Clear a rectangular region of the screen from text pos (row1, col1) to
2138 * (row2, col2) inclusive.
2139 */
2140 void
2141gui_mch_clear_block(
2142 int row1,
2143 int col1,
2144 int row2,
2145 int col2)
2146{
2147 RECT rc;
2148
2149 /*
2150 * Clear one extra pixel at the far right, for when bold characters have
2151 * spilled over to the window border.
2152 * Note: FillRect() excludes right and bottom of rectangle.
2153 */
2154 rc.left = FILL_X(col1);
2155 rc.top = FILL_Y(row1);
2156 rc.right = FILL_X(col2 + 1) + (col2 == Columns - 1);
2157 rc.bottom = FILL_Y(row2 + 1);
2158 clear_rect(&rc);
2159}
2160
2161/*
2162 * Clear the whole text window.
2163 */
2164 void
2165gui_mch_clear_all(void)
2166{
2167 RECT rc;
2168
2169 rc.left = 0;
2170 rc.top = 0;
2171 rc.right = Columns * gui.char_width + 2 * gui.border_width;
2172 rc.bottom = Rows * gui.char_height + 2 * gui.border_width;
2173 clear_rect(&rc);
2174}
2175/*
2176 * Menu stuff.
2177 */
2178
2179 void
2180gui_mch_enable_menu(int flag)
2181{
2182#ifdef FEAT_MENU
2183 SetMenu(s_hwnd, flag ? s_menuBar : NULL);
2184#endif
2185}
2186
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00002187/*ARGSUSED*/
Bram Moolenaar071d4272004-06-13 20:20:40 +00002188 void
2189gui_mch_set_menu_pos(
2190 int x,
2191 int y,
2192 int w,
2193 int h)
2194{
2195 /* It will be in the right place anyway */
2196}
2197
2198#if defined(FEAT_MENU) || defined(PROTO)
2199/*
2200 * Make menu item hidden or not hidden
2201 */
2202 void
2203gui_mch_menu_hidden(
2204 vimmenu_T *menu,
2205 int hidden)
2206{
2207 /*
2208 * This doesn't do what we want. Hmm, just grey the menu items for now.
2209 */
2210 /*
2211 if (hidden)
2212 EnableMenuItem(s_menuBar, menu->id, MF_BYCOMMAND | MF_DISABLED);
2213 else
2214 EnableMenuItem(s_menuBar, menu->id, MF_BYCOMMAND | MF_ENABLED);
2215 */
2216 gui_mch_menu_grey(menu, hidden);
2217}
2218
2219/*
2220 * This is called after setting all the menus to grey/hidden or not.
2221 */
2222 void
2223gui_mch_draw_menubar(void)
2224{
2225 DrawMenuBar(s_hwnd);
2226}
2227#endif /*FEAT_MENU*/
2228
2229#ifndef PROTO
2230void
2231#ifdef VIMDLL
2232_export
2233#endif
2234_cdecl
2235SaveInst(HINSTANCE hInst)
2236{
2237 s_hinst = hInst;
2238}
2239#endif
2240
2241/*
2242 * Return the RGB value of a pixel as a long.
2243 */
2244 long_u
2245gui_mch_get_rgb(guicolor_T pixel)
2246{
2247 return (GetRValue(pixel) << 16) + (GetGValue(pixel) << 8)
2248 + GetBValue(pixel);
2249}
2250
2251#if defined(FEAT_GUI_DIALOG) || defined(PROTO)
2252/* Convert pixels in X to dialog units */
2253 static WORD
2254PixelToDialogX(int numPixels)
2255{
2256 return (WORD)((numPixels * 4) / s_dlgfntwidth);
2257}
2258
2259/* Convert pixels in Y to dialog units */
2260 static WORD
2261PixelToDialogY(int numPixels)
2262{
2263 return (WORD)((numPixels * 8) / s_dlgfntheight);
2264}
2265
2266/* Return the width in pixels of the given text in the given DC. */
2267 static int
2268GetTextWidth(HDC hdc, char_u *str, int len)
2269{
2270 SIZE size;
2271
Bram Moolenaar418f81b2016-02-16 20:12:02 +01002272 GetTextExtentPoint(hdc, (LPCSTR)str, len, &size);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002273 return size.cx;
2274}
2275
2276#ifdef FEAT_MBYTE
2277/*
2278 * Return the width in pixels of the given text in the given DC, taking care
2279 * of 'encoding' to active codepage conversion.
2280 */
2281 static int
2282GetTextWidthEnc(HDC hdc, char_u *str, int len)
2283{
2284 SIZE size;
2285 WCHAR *wstr;
2286 int n;
2287 int wlen = len;
2288
2289 if (enc_codepage >= 0 && (int)GetACP() != enc_codepage)
2290 {
2291 /* 'encoding' differs from active codepage: convert text and use wide
2292 * function */
Bram Moolenaar36f692d2008-11-20 16:10:17 +00002293 wstr = enc_to_utf16(str, &wlen);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002294 if (wstr != NULL)
2295 {
2296 n = GetTextExtentPointW(hdc, wstr, wlen, &size);
2297 vim_free(wstr);
2298 if (n)
2299 return size.cx;
2300 }
2301 }
2302
2303 return GetTextWidth(hdc, str, len);
2304}
2305#else
2306# define GetTextWidthEnc(h, s, l) GetTextWidth((h), (s), (l))
2307#endif
2308
2309/*
2310 * A quick little routine that will center one window over another, handy for
2311 * dialog boxes. Taken from the Win32SDK samples.
2312 */
2313 static BOOL
2314CenterWindow(
2315 HWND hwndChild,
2316 HWND hwndParent)
2317{
2318 RECT rChild, rParent;
2319 int wChild, hChild, wParent, hParent;
2320 int wScreen, hScreen, xNew, yNew;
2321 HDC hdc;
2322
2323 GetWindowRect(hwndChild, &rChild);
2324 wChild = rChild.right - rChild.left;
2325 hChild = rChild.bottom - rChild.top;
2326
2327 /* If Vim is minimized put the window in the middle of the screen. */
Bram Moolenaar9e54a0e2006-04-14 20:42:25 +00002328 if (hwndParent == NULL || IsMinimized(hwndParent))
Bram Moolenaar071d4272004-06-13 20:20:40 +00002329 {
2330#ifdef WIN16
2331 rParent.left = 0;
2332 rParent.top = 0;
2333 rParent.right = GetSystemMetrics(SM_CXSCREEN);
2334 rParent.bottom = GetSystemMetrics(SM_CYFULLSCREEN);
2335#else
2336 SystemParametersInfo(SPI_GETWORKAREA, 0, &rParent, 0);
2337#endif
2338 }
2339 else
2340 GetWindowRect(hwndParent, &rParent);
2341 wParent = rParent.right - rParent.left;
2342 hParent = rParent.bottom - rParent.top;
2343
2344 hdc = GetDC(hwndChild);
2345 wScreen = GetDeviceCaps (hdc, HORZRES);
2346 hScreen = GetDeviceCaps (hdc, VERTRES);
2347 ReleaseDC(hwndChild, hdc);
2348
2349 xNew = rParent.left + ((wParent - wChild) /2);
2350 if (xNew < 0)
2351 {
2352 xNew = 0;
2353 }
2354 else if ((xNew+wChild) > wScreen)
2355 {
2356 xNew = wScreen - wChild;
2357 }
2358
2359 yNew = rParent.top + ((hParent - hChild) /2);
2360 if (yNew < 0)
2361 yNew = 0;
2362 else if ((yNew+hChild) > hScreen)
2363 yNew = hScreen - hChild;
2364
2365 return SetWindowPos(hwndChild, NULL, xNew, yNew, 0, 0,
2366 SWP_NOSIZE | SWP_NOZORDER);
2367}
2368#endif /* FEAT_GUI_DIALOG */
2369
2370void
2371gui_mch_activate_window(void)
2372{
2373 (void)SetActiveWindow(s_hwnd);
2374}
2375
2376#if defined(FEAT_TOOLBAR) || defined(PROTO)
2377 void
2378gui_mch_show_toolbar(int showit)
2379{
2380 if (s_toolbarhwnd == NULL)
2381 return;
2382
2383 if (showit)
Bram Moolenaar8f2ff9f2006-08-29 19:26:50 +00002384 {
2385# ifdef FEAT_MBYTE
2386# ifndef TB_SETUNICODEFORMAT
2387 /* For older compilers. We assume this never changes. */
2388# define TB_SETUNICODEFORMAT 0x2005
2389# endif
2390 /* Enable/disable unicode support */
2391 int uu = (enc_codepage >= 0 && (int)GetACP() != enc_codepage);
2392 SendMessage(s_toolbarhwnd, TB_SETUNICODEFORMAT, (WPARAM)uu, (LPARAM)0);
2393# endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00002394 ShowWindow(s_toolbarhwnd, SW_SHOW);
Bram Moolenaar8f2ff9f2006-08-29 19:26:50 +00002395 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00002396 else
2397 ShowWindow(s_toolbarhwnd, SW_HIDE);
2398}
2399
2400/* Then number of bitmaps is fixed. Exit is missing! */
2401#define TOOLBAR_BITMAP_COUNT 31
2402
2403#endif
2404
Bram Moolenaar3991dab2006-03-27 17:01:56 +00002405#if defined(FEAT_GUI_TABLINE) || defined(PROTO)
Bram Moolenaar2e2a2812006-03-27 20:55:21 +00002406 static void
Bram Moolenaar908d53a2006-11-07 18:05:31 +00002407add_tabline_popup_menu_entry(HMENU pmenu, UINT item_id, char_u *item_text)
2408{
2409#ifdef FEAT_MBYTE
2410 WCHAR *wn = NULL;
2411 int n;
2412
2413 if (enc_codepage >= 0 && (int)GetACP() != enc_codepage)
2414 {
2415 /* 'encoding' differs from active codepage: convert menu name
2416 * and use wide function */
Bram Moolenaar36f692d2008-11-20 16:10:17 +00002417 wn = enc_to_utf16(item_text, NULL);
Bram Moolenaar908d53a2006-11-07 18:05:31 +00002418 if (wn != NULL)
2419 {
2420 MENUITEMINFOW infow;
2421
2422 infow.cbSize = sizeof(infow);
2423 infow.fMask = MIIM_TYPE | MIIM_ID;
2424 infow.wID = item_id;
2425 infow.fType = MFT_STRING;
2426 infow.dwTypeData = wn;
2427 infow.cch = (UINT)wcslen(wn);
2428 n = InsertMenuItemW(pmenu, item_id, FALSE, &infow);
2429 vim_free(wn);
2430 if (n == 0 && GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
2431 /* Failed, try using non-wide function. */
2432 wn = NULL;
2433 }
2434 }
2435
2436 if (wn == NULL)
2437#endif
2438 {
2439 MENUITEMINFO info;
2440
2441 info.cbSize = sizeof(info);
2442 info.fMask = MIIM_TYPE | MIIM_ID;
2443 info.wID = item_id;
2444 info.fType = MFT_STRING;
2445 info.dwTypeData = item_text;
2446 info.cch = (UINT)STRLEN(item_text);
2447 InsertMenuItem(pmenu, item_id, FALSE, &info);
2448 }
2449}
2450
2451 static void
Bram Moolenaar2e2a2812006-03-27 20:55:21 +00002452show_tabline_popup_menu(void)
2453{
2454 HMENU tab_pmenu;
Bram Moolenaar2e2a2812006-03-27 20:55:21 +00002455 long rval;
2456 POINT pt;
Bram Moolenaar2e2a2812006-03-27 20:55:21 +00002457
Bram Moolenaarf193fff2006-04-27 00:02:13 +00002458 /* When ignoring events don't show the menu. */
2459 if (hold_gui_events
2460# ifdef FEAT_CMDWIN
2461 || cmdwin_type != 0
2462# endif
2463 )
2464 return;
2465
Bram Moolenaar2e2a2812006-03-27 20:55:21 +00002466 tab_pmenu = CreatePopupMenu();
2467 if (tab_pmenu == NULL)
2468 return;
2469
Bram Moolenaar7098ee52015-06-09 19:14:24 +02002470 if (first_tabpage->tp_next != NULL)
Bram Moolenaar3b597552015-09-15 17:58:29 +02002471 add_tabline_popup_menu_entry(tab_pmenu,
Bram Moolenaar418f81b2016-02-16 20:12:02 +01002472 TABLINE_MENU_CLOSE, (char_u *)_("Close tab"));
2473 add_tabline_popup_menu_entry(tab_pmenu,
2474 TABLINE_MENU_NEW, (char_u *)_("New tab"));
2475 add_tabline_popup_menu_entry(tab_pmenu,
2476 TABLINE_MENU_OPEN, (char_u *)_("Open tab..."));
Bram Moolenaar2e2a2812006-03-27 20:55:21 +00002477
2478 GetCursorPos(&pt);
2479 rval = TrackPopupMenuEx(tab_pmenu, TPM_RETURNCMD, pt.x, pt.y, s_tabhwnd,
2480 NULL);
2481
2482 DestroyMenu(tab_pmenu);
2483
2484 /* Add the string cmd into input buffer */
2485 if (rval > 0)
2486 {
2487 TCHITTESTINFO htinfo;
2488 int idx;
2489
2490 if (ScreenToClient(s_tabhwnd, &pt) == 0)
2491 return;
2492
2493 htinfo.pt.x = pt.x;
2494 htinfo.pt.y = pt.y;
2495 idx = TabCtrl_HitTest(s_tabhwnd, &htinfo);
2496 if (idx == -1)
2497 idx = 0;
2498 else
2499 idx += 1;
2500
Bram Moolenaarc6fe9192006-04-09 21:54:49 +00002501 send_tabline_menu_event(idx, (int)rval);
Bram Moolenaar2e2a2812006-03-27 20:55:21 +00002502 }
2503}
2504
Bram Moolenaar3991dab2006-03-27 17:01:56 +00002505/*
2506 * Show or hide the tabline.
2507 */
2508 void
2509gui_mch_show_tabline(int showit)
2510{
2511 if (s_tabhwnd == NULL)
2512 return;
2513
2514 if (!showit != !showing_tabline)
2515 {
2516 if (showit)
2517 ShowWindow(s_tabhwnd, SW_SHOW);
2518 else
2519 ShowWindow(s_tabhwnd, SW_HIDE);
2520 showing_tabline = showit;
2521 }
2522}
2523
2524/*
2525 * Return TRUE when tabline is displayed.
2526 */
2527 int
2528gui_mch_showing_tabline(void)
2529{
2530 return s_tabhwnd != NULL && showing_tabline;
2531}
2532
2533/*
2534 * Update the labels of the tabline.
2535 */
2536 void
2537gui_mch_update_tabline(void)
2538{
2539 tabpage_T *tp;
2540 TCITEM tie;
2541 int nr = 0;
2542 int curtabidx = 0;
Bram Moolenaar86f931e2013-08-07 21:13:23 +02002543 int tabadded = 0;
Bram Moolenaar8424a622006-04-19 21:23:36 +00002544#ifdef FEAT_MBYTE
Bram Moolenaarfc1421e2006-04-20 22:17:20 +00002545 static int use_unicode = FALSE;
2546 int uu;
Bram Moolenaar8424a622006-04-19 21:23:36 +00002547 WCHAR *wstr = NULL;
2548#endif
Bram Moolenaar3991dab2006-03-27 17:01:56 +00002549
2550 if (s_tabhwnd == NULL)
2551 return;
2552
Bram Moolenaarfc1421e2006-04-20 22:17:20 +00002553#if defined(FEAT_MBYTE)
2554# ifndef CCM_SETUNICODEFORMAT
2555 /* For older compilers. We assume this never changes. */
2556# define CCM_SETUNICODEFORMAT 0x2005
2557# endif
2558 uu = (enc_codepage >= 0 && (int)GetACP() != enc_codepage);
2559 if (uu != use_unicode)
2560 {
2561 /* Enable/disable unicode support */
2562 SendMessage(s_tabhwnd, CCM_SETUNICODEFORMAT, (WPARAM)uu, (LPARAM)0);
2563 use_unicode = uu;
2564 }
Bram Moolenaar8424a622006-04-19 21:23:36 +00002565#endif
2566
Bram Moolenaar3991dab2006-03-27 17:01:56 +00002567 tie.mask = TCIF_TEXT;
2568 tie.iImage = -1;
2569
Bram Moolenaar4b166d02012-12-12 17:12:25 +01002570 /* Disable redraw for tab updates to eliminate O(N^2) draws. */
2571 SendMessage(s_tabhwnd, WM_SETREDRAW, (WPARAM)FALSE, 0);
2572
Bram Moolenaar3991dab2006-03-27 17:01:56 +00002573 /* Add a label for each tab page. They all contain the same text area. */
2574 for (tp = first_tabpage; tp != NULL; tp = tp->tp_next, ++nr)
2575 {
2576 if (tp == curtab)
2577 curtabidx = nr;
2578
Bram Moolenaar4b166d02012-12-12 17:12:25 +01002579 if (nr >= TabCtrl_GetItemCount(s_tabhwnd))
Bram Moolenaar3991dab2006-03-27 17:01:56 +00002580 {
2581 /* Add the tab */
2582 tie.pszText = "-Empty-";
2583 TabCtrl_InsertItem(s_tabhwnd, nr, &tie);
Bram Moolenaar86f931e2013-08-07 21:13:23 +02002584 tabadded = 1;
Bram Moolenaar3991dab2006-03-27 17:01:56 +00002585 }
2586
Bram Moolenaar57657d82006-04-21 22:12:41 +00002587 get_tabline_label(tp, FALSE);
Bram Moolenaar418f81b2016-02-16 20:12:02 +01002588 tie.pszText = (LPSTR)NameBuff;
Bram Moolenaar8424a622006-04-19 21:23:36 +00002589#ifdef FEAT_MBYTE
2590 wstr = NULL;
Bram Moolenaarfc1421e2006-04-20 22:17:20 +00002591 if (use_unicode)
Bram Moolenaar8424a622006-04-19 21:23:36 +00002592 {
2593 /* Need to go through Unicode. */
Bram Moolenaar36f692d2008-11-20 16:10:17 +00002594 wstr = enc_to_utf16(NameBuff, NULL);
Bram Moolenaar8424a622006-04-19 21:23:36 +00002595 if (wstr != NULL)
2596 {
2597 TCITEMW tiw;
2598
2599 tiw.mask = TCIF_TEXT;
2600 tiw.iImage = -1;
2601 tiw.pszText = wstr;
Bram Moolenaar85f868c2006-11-28 16:16:58 +00002602 SendMessage(s_tabhwnd, TCM_SETITEMW, (WPARAM)nr, (LPARAM)&tiw);
Bram Moolenaar8424a622006-04-19 21:23:36 +00002603 vim_free(wstr);
2604 }
2605 }
2606 if (wstr == NULL)
2607#endif
2608 {
2609 TabCtrl_SetItem(s_tabhwnd, nr, &tie);
2610 }
Bram Moolenaar3991dab2006-03-27 17:01:56 +00002611 }
2612
2613 /* Remove any old labels. */
Bram Moolenaar4b166d02012-12-12 17:12:25 +01002614 while (nr < TabCtrl_GetItemCount(s_tabhwnd))
Bram Moolenaar3991dab2006-03-27 17:01:56 +00002615 TabCtrl_DeleteItem(s_tabhwnd, nr);
2616
Bram Moolenaar86f931e2013-08-07 21:13:23 +02002617 if (!tabadded && TabCtrl_GetCurSel(s_tabhwnd) != curtabidx)
2618 TabCtrl_SetCurSel(s_tabhwnd, curtabidx);
2619
Bram Moolenaar14e28812012-12-16 12:50:39 +01002620 /* Re-enable redraw and redraw. */
Bram Moolenaar4b166d02012-12-12 17:12:25 +01002621 SendMessage(s_tabhwnd, WM_SETREDRAW, (WPARAM)TRUE, 0);
Bram Moolenaar14e28812012-12-16 12:50:39 +01002622 RedrawWindow(s_tabhwnd, NULL, NULL,
2623 RDW_ERASE | RDW_FRAME | RDW_INVALIDATE | RDW_ALLCHILDREN);
Bram Moolenaara8f96392013-07-17 21:59:13 +02002624
Bram Moolenaar86f931e2013-08-07 21:13:23 +02002625 if (tabadded && TabCtrl_GetCurSel(s_tabhwnd) != curtabidx)
Bram Moolenaara8f96392013-07-17 21:59:13 +02002626 TabCtrl_SetCurSel(s_tabhwnd, curtabidx);
Bram Moolenaar3991dab2006-03-27 17:01:56 +00002627}
2628
2629/*
2630 * Set the current tab to "nr". First tab is 1.
2631 */
2632 void
Bram Moolenaar68c2f632016-01-30 17:24:07 +01002633gui_mch_set_curtab(int nr)
Bram Moolenaar3991dab2006-03-27 17:01:56 +00002634{
2635 if (s_tabhwnd == NULL)
2636 return;
2637
Bram Moolenaara8f96392013-07-17 21:59:13 +02002638 if (TabCtrl_GetCurSel(s_tabhwnd) != nr - 1)
2639 TabCtrl_SetCurSel(s_tabhwnd, nr - 1);
Bram Moolenaar3991dab2006-03-27 17:01:56 +00002640}
2641
2642#endif
2643
Bram Moolenaar071d4272004-06-13 20:20:40 +00002644/*
2645 * ":simalt" command.
2646 */
2647 void
2648ex_simalt(exarg_T *eap)
2649{
2650 char_u *keys = eap->arg;
2651
2652 PostMessage(s_hwnd, WM_SYSCOMMAND, (WPARAM)SC_KEYMENU, (LPARAM)0);
2653 while (*keys)
2654 {
2655 if (*keys == '~')
2656 *keys = ' '; /* for showing system menu */
2657 PostMessage(s_hwnd, WM_CHAR, (WPARAM)*keys, (LPARAM)0);
2658 keys++;
2659 }
2660}
2661
2662/*
2663 * Create the find & replace dialogs.
2664 * You can't have both at once: ":find" when replace is showing, destroys
2665 * the replace dialog first, and the other way around.
2666 */
2667#ifdef MSWIN_FIND_REPLACE
2668 static void
2669initialise_findrep(char_u *initial_string)
2670{
2671 int wword = FALSE;
2672 int mcase = !p_ic;
2673 char_u *entry_text;
2674
2675 /* Get the search string to use. */
2676 entry_text = get_find_dialog_text(initial_string, &wword, &mcase);
2677
2678 s_findrep_struct.hwndOwner = s_hwnd;
2679 s_findrep_struct.Flags = FR_DOWN;
2680 if (mcase)
2681 s_findrep_struct.Flags |= FR_MATCHCASE;
2682 if (wword)
2683 s_findrep_struct.Flags |= FR_WHOLEWORD;
2684 if (entry_text != NULL && *entry_text != NUL)
Bram Moolenaar418f81b2016-02-16 20:12:02 +01002685 vim_strncpy((char_u *)s_findrep_struct.lpstrFindWhat, entry_text,
Bram Moolenaarfe3ca8d2005-07-18 21:43:02 +00002686 s_findrep_struct.wFindWhatLen - 1);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002687 vim_free(entry_text);
2688}
2689#endif
2690
Bram Moolenaar908d53a2006-11-07 18:05:31 +00002691 static void
2692set_window_title(HWND hwnd, char *title)
2693{
2694#ifdef FEAT_MBYTE
2695 if (title != NULL && enc_codepage >= 0 && enc_codepage != (int)GetACP())
2696 {
2697 WCHAR *wbuf;
2698 int n;
2699
Bram Moolenaar36f692d2008-11-20 16:10:17 +00002700 /* Convert the title from 'encoding' to UTF-16. */
2701 wbuf = (WCHAR *)enc_to_utf16((char_u *)title, NULL);
Bram Moolenaar908d53a2006-11-07 18:05:31 +00002702 if (wbuf != NULL)
2703 {
2704 n = SetWindowTextW(hwnd, wbuf);
2705 vim_free(wbuf);
2706 if (n != 0 || GetLastError() != ERROR_CALL_NOT_IMPLEMENTED)
2707 return;
2708 /* Retry with non-wide function (for Windows 98). */
2709 }
2710 }
2711#endif
2712 (void)SetWindowText(hwnd, (LPCSTR)title);
2713}
2714
Bram Moolenaar071d4272004-06-13 20:20:40 +00002715 void
2716gui_mch_find_dialog(exarg_T *eap)
2717{
2718#ifdef MSWIN_FIND_REPLACE
2719 if (s_findrep_msg != 0)
2720 {
2721 if (IsWindow(s_findrep_hwnd) && !s_findrep_is_find)
2722 DestroyWindow(s_findrep_hwnd);
2723
2724 if (!IsWindow(s_findrep_hwnd))
2725 {
2726 initialise_findrep(eap->arg);
Bram Moolenaar3ca9a8a2009-01-28 20:23:17 +00002727# if defined(FEAT_MBYTE) && defined(WIN3264)
2728 /* If the OS is Windows NT, and 'encoding' differs from active
2729 * codepage: convert text and use wide function. */
2730 if (os_version.dwPlatformId == VER_PLATFORM_WIN32_NT
2731 && enc_codepage >= 0 && (int)GetACP() != enc_codepage)
2732 {
Bram Moolenaarcc448b32010-07-14 16:52:17 +02002733 findrep_atow(&s_findrep_struct_w, &s_findrep_struct);
Bram Moolenaar3ca9a8a2009-01-28 20:23:17 +00002734 s_findrep_hwnd = FindTextW(
2735 (LPFINDREPLACEW) &s_findrep_struct_w);
2736 }
2737 else
2738# endif
2739 s_findrep_hwnd = FindText((LPFINDREPLACE) &s_findrep_struct);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002740 }
2741
Bram Moolenaar908d53a2006-11-07 18:05:31 +00002742 set_window_title(s_findrep_hwnd,
2743 _("Find string (use '\\\\' to find a '\\')"));
Bram Moolenaar071d4272004-06-13 20:20:40 +00002744 (void)SetFocus(s_findrep_hwnd);
2745
2746 s_findrep_is_find = TRUE;
2747 }
2748#endif
2749}
2750
2751
2752 void
2753gui_mch_replace_dialog(exarg_T *eap)
2754{
2755#ifdef MSWIN_FIND_REPLACE
2756 if (s_findrep_msg != 0)
2757 {
2758 if (IsWindow(s_findrep_hwnd) && s_findrep_is_find)
2759 DestroyWindow(s_findrep_hwnd);
2760
2761 if (!IsWindow(s_findrep_hwnd))
2762 {
2763 initialise_findrep(eap->arg);
Bram Moolenaar3ca9a8a2009-01-28 20:23:17 +00002764# if defined(FEAT_MBYTE) && defined(WIN3264)
2765 if (os_version.dwPlatformId == VER_PLATFORM_WIN32_NT
2766 && enc_codepage >= 0 && (int)GetACP() != enc_codepage)
2767 {
2768 findrep_atow(&s_findrep_struct_w, &s_findrep_struct);
2769 s_findrep_hwnd = ReplaceTextW(
2770 (LPFINDREPLACEW) &s_findrep_struct_w);
2771 }
2772 else
2773# endif
2774 s_findrep_hwnd = ReplaceText(
2775 (LPFINDREPLACE) &s_findrep_struct);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002776 }
2777
Bram Moolenaar908d53a2006-11-07 18:05:31 +00002778 set_window_title(s_findrep_hwnd,
2779 _("Find & Replace (use '\\\\' to find a '\\')"));
Bram Moolenaar071d4272004-06-13 20:20:40 +00002780 (void)SetFocus(s_findrep_hwnd);
2781
2782 s_findrep_is_find = FALSE;
2783 }
2784#endif
2785}
2786
2787
2788/*
2789 * Set visibility of the pointer.
2790 */
2791 void
2792gui_mch_mousehide(int hide)
2793{
2794 if (hide != gui.pointer_hidden)
2795 {
2796 ShowCursor(!hide);
2797 gui.pointer_hidden = hide;
2798 }
2799}
2800
2801#ifdef FEAT_MENU
2802 static void
2803gui_mch_show_popupmenu_at(vimmenu_T *menu, int x, int y)
2804{
2805 /* Unhide the mouse, we don't get move events here. */
2806 gui_mch_mousehide(FALSE);
2807
2808 (void)TrackPopupMenu(
2809 (HMENU)menu->submenu_id,
2810 TPM_LEFTALIGN | TPM_LEFTBUTTON,
2811 x, y,
2812 (int)0, /*reserved param*/
2813 s_hwnd,
2814 NULL);
2815 /*
2816 * NOTE: The pop-up menu can eat the mouse up event.
2817 * We deal with this in normal.c.
2818 */
2819}
2820#endif
2821
2822/*
2823 * Got a message when the system will go down.
2824 */
2825 static void
2826_OnEndSession(void)
2827{
2828 getout_preserve_modified(1);
2829}
2830
2831/*
2832 * Get this message when the user clicks on the cross in the top right corner
2833 * of a Windows95 window.
2834 */
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00002835/*ARGSUSED*/
Bram Moolenaar071d4272004-06-13 20:20:40 +00002836 static void
2837_OnClose(
2838 HWND hwnd)
2839{
2840 gui_shell_closed();
2841}
2842
2843/*
2844 * Get a message when the window is being destroyed.
2845 */
2846 static void
2847_OnDestroy(
2848 HWND hwnd)
2849{
2850#ifdef WIN16_3DLOOK
2851 Ctl3dUnregister(s_hinst);
2852#endif
2853 if (!destroying)
2854 _OnClose(hwnd);
2855}
2856
2857 static void
2858_OnPaint(
2859 HWND hwnd)
2860{
2861 if (!IsMinimized(hwnd))
2862 {
2863 PAINTSTRUCT ps;
2864
2865 out_flush(); /* make sure all output has been processed */
2866 (void)BeginPaint(hwnd, &ps);
Bram Moolenaarb5a7a8b2014-08-06 14:52:30 +02002867#if defined(FEAT_DIRECTX)
2868 if (IS_ENABLE_DIRECTX())
2869 DWriteContext_BeginDraw(s_dwc);
2870#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00002871
2872#ifdef FEAT_MBYTE
2873 /* prevent multi-byte characters from misprinting on an invalid
2874 * rectangle */
2875 if (has_mbyte)
2876 {
2877 RECT rect;
2878
2879 GetClientRect(hwnd, &rect);
2880 ps.rcPaint.left = rect.left;
2881 ps.rcPaint.right = rect.right;
2882 }
2883#endif
2884
2885 if (!IsRectEmpty(&ps.rcPaint))
Bram Moolenaarb5a7a8b2014-08-06 14:52:30 +02002886 {
2887#if defined(FEAT_DIRECTX)
2888 if (IS_ENABLE_DIRECTX())
2889 DWriteContext_BindDC(s_dwc, s_hdc, &ps.rcPaint);
2890#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00002891 gui_redraw(ps.rcPaint.left, ps.rcPaint.top,
2892 ps.rcPaint.right - ps.rcPaint.left + 1,
2893 ps.rcPaint.bottom - ps.rcPaint.top + 1);
Bram Moolenaarb5a7a8b2014-08-06 14:52:30 +02002894 }
2895
2896#if defined(FEAT_DIRECTX)
2897 if (IS_ENABLE_DIRECTX())
2898 DWriteContext_EndDraw(s_dwc);
2899#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00002900 EndPaint(hwnd, &ps);
2901 }
2902}
2903
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00002904/*ARGSUSED*/
Bram Moolenaar071d4272004-06-13 20:20:40 +00002905 static void
2906_OnSize(
2907 HWND hwnd,
2908 UINT state,
2909 int cx,
2910 int cy)
2911{
2912 if (!IsMinimized(hwnd))
2913 {
2914 gui_resize_shell(cx, cy);
2915
2916#ifdef FEAT_MENU
2917 /* Menu bar may wrap differently now */
2918 gui_mswin_get_menu_height(TRUE);
2919#endif
2920 }
2921}
2922
2923 static void
2924_OnSetFocus(
2925 HWND hwnd,
2926 HWND hwndOldFocus)
2927{
2928 gui_focus_change(TRUE);
Bram Moolenaarea408882007-12-03 21:21:03 +00002929 s_getting_focus = TRUE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002930 (void)MyWindowProc(hwnd, WM_SETFOCUS, (WPARAM)hwndOldFocus, 0);
2931}
2932
2933 static void
2934_OnKillFocus(
2935 HWND hwnd,
2936 HWND hwndNewFocus)
2937{
2938 gui_focus_change(FALSE);
Bram Moolenaarea408882007-12-03 21:21:03 +00002939 s_getting_focus = FALSE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002940 (void)MyWindowProc(hwnd, WM_KILLFOCUS, (WPARAM)hwndNewFocus, 0);
2941}
2942
2943/*
2944 * Get a message when the user switches back to vim
2945 */
2946#ifdef WIN16
2947 static BOOL
2948#else
2949 static LRESULT
2950#endif
2951_OnActivateApp(
2952 HWND hwnd,
2953 BOOL fActivate,
2954#ifdef WIN16
2955 HTASK dwThreadId
2956#else
2957 DWORD dwThreadId
2958#endif
2959 )
2960{
2961 /* we call gui_focus_change() in _OnSetFocus() */
2962 /* gui_focus_change((int)fActivate); */
2963 return MyWindowProc(hwnd, WM_ACTIVATEAPP, fActivate, (DWORD)dwThreadId);
2964}
2965
2966#if defined(FEAT_WINDOWS) || defined(PROTO)
2967 void
2968gui_mch_destroy_scrollbar(scrollbar_T *sb)
2969{
2970 DestroyWindow(sb->id);
2971}
2972#endif
2973
2974/*
Bram Moolenaar9588a0f2005-01-08 21:45:39 +00002975 * Get current mouse coordinates in text window.
Bram Moolenaar071d4272004-06-13 20:20:40 +00002976 */
Bram Moolenaar9588a0f2005-01-08 21:45:39 +00002977 void
Bram Moolenaara40c5002005-01-09 21:16:21 +00002978gui_mch_getmouse(int *x, int *y)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002979{
2980 RECT rct;
2981 POINT mp;
2982
2983 (void)GetWindowRect(s_textArea, &rct);
2984 (void)GetCursorPos((LPPOINT)&mp);
Bram Moolenaar9588a0f2005-01-08 21:45:39 +00002985 *x = (int)(mp.x - rct.left);
2986 *y = (int)(mp.y - rct.top);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002987}
2988
2989/*
2990 * Move mouse pointer to character at (x, y).
2991 */
2992 void
2993gui_mch_setmouse(int x, int y)
2994{
2995 RECT rct;
2996
2997 (void)GetWindowRect(s_textArea, &rct);
2998 (void)SetCursorPos(x + gui.border_offset + rct.left,
2999 y + gui.border_offset + rct.top);
3000}
3001
3002 static void
3003gui_mswin_get_valid_dimensions(
3004 int w,
3005 int h,
3006 int *valid_w,
3007 int *valid_h)
3008{
3009 int base_width, base_height;
3010
3011 base_width = gui_get_base_width()
Bram Moolenaar9d488952013-07-21 17:53:58 +02003012 + (GetSystemMetrics(SM_CXFRAME) +
Bram Moolenaar3b597552015-09-15 17:58:29 +02003013 GetSystemMetrics(SM_CXPADDEDBORDER)) * 2;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003014 base_height = gui_get_base_height()
Bram Moolenaar9d488952013-07-21 17:53:58 +02003015 + (GetSystemMetrics(SM_CYFRAME) +
Bram Moolenaar3b597552015-09-15 17:58:29 +02003016 GetSystemMetrics(SM_CXPADDEDBORDER)) * 2
Bram Moolenaar071d4272004-06-13 20:20:40 +00003017 + GetSystemMetrics(SM_CYCAPTION)
3018#ifdef FEAT_MENU
3019 + gui_mswin_get_menu_height(FALSE)
3020#endif
3021 ;
3022 *valid_w = base_width +
3023 ((w - base_width) / gui.char_width) * gui.char_width;
3024 *valid_h = base_height +
3025 ((h - base_height) / gui.char_height) * gui.char_height;
3026}
3027
3028 void
Bram Moolenaar071d4272004-06-13 20:20:40 +00003029gui_mch_flash(int msec)
3030{
3031 RECT rc;
3032
3033 /*
3034 * Note: InvertRect() excludes right and bottom of rectangle.
3035 */
3036 rc.left = 0;
3037 rc.top = 0;
3038 rc.right = gui.num_cols * gui.char_width;
3039 rc.bottom = gui.num_rows * gui.char_height;
3040 InvertRect(s_hdc, &rc);
3041 gui_mch_flush(); /* make sure it's displayed */
3042
3043 ui_delay((long)msec, TRUE); /* wait for a few msec */
3044
3045 InvertRect(s_hdc, &rc);
3046}
3047
3048/*
3049 * Return flags used for scrolling.
3050 * The SW_INVALIDATE is required when part of the window is covered or
3051 * off-screen. Refer to MS KB Q75236.
3052 */
3053 static int
3054get_scroll_flags(void)
3055{
3056 HWND hwnd;
3057 RECT rcVim, rcOther, rcDest;
3058
3059 GetWindowRect(s_hwnd, &rcVim);
Bram Moolenaar0d406992005-05-22 22:03:39 +00003060
3061 /* Check if the window is partly above or below the screen. We don't care
3062 * about partly left or right of the screen, it is not relevant when
3063 * scrolling up or down. */
3064 if (rcVim.top < 0 || rcVim.bottom > GetSystemMetrics(SM_CYFULLSCREEN))
3065 return SW_INVALIDATE;
3066
3067 /* Check if there is an window (partly) on top of us. */
Bram Moolenaar071d4272004-06-13 20:20:40 +00003068 for (hwnd = s_hwnd; (hwnd = GetWindow(hwnd, GW_HWNDPREV)) != (HWND)0; )
3069 if (IsWindowVisible(hwnd))
3070 {
3071 GetWindowRect(hwnd, &rcOther);
3072 if (IntersectRect(&rcDest, &rcVim, &rcOther))
3073 return SW_INVALIDATE;
3074 }
3075 return 0;
3076}
3077
3078/*
Bram Moolenaar3b597552015-09-15 17:58:29 +02003079 * On some Intel GPUs, the regions drawn just prior to ScrollWindowEx()
3080 * may not be scrolled out properly.
3081 * For gVim, when _OnScroll() is repeated, the character at the
3082 * previous cursor position may be left drawn after scroll.
3083 * The problem can be avoided by calling GetPixel() to get a pixel in
3084 * the region before ScrollWindowEx().
3085 */
3086 static void
3087intel_gpu_workaround(void)
3088{
3089 GetPixel(s_hdc, FILL_X(gui.col), FILL_Y(gui.row));
3090}
3091
3092/*
Bram Moolenaar071d4272004-06-13 20:20:40 +00003093 * Delete the given number of lines from the given row, scrolling up any
3094 * text further down within the scroll region.
3095 */
3096 void
3097gui_mch_delete_lines(
3098 int row,
3099 int num_lines)
3100{
3101 RECT rc;
3102
Bram Moolenaar3b597552015-09-15 17:58:29 +02003103 intel_gpu_workaround();
3104
Bram Moolenaar071d4272004-06-13 20:20:40 +00003105 rc.left = FILL_X(gui.scroll_region_left);
3106 rc.right = FILL_X(gui.scroll_region_right + 1);
3107 rc.top = FILL_Y(row);
3108 rc.bottom = FILL_Y(gui.scroll_region_bot + 1);
3109
3110 ScrollWindowEx(s_textArea, 0, -num_lines * gui.char_height,
3111 &rc, &rc, NULL, NULL, get_scroll_flags());
3112
3113 UpdateWindow(s_textArea);
3114 /* This seems to be required to avoid the cursor disappearing when
3115 * scrolling such that the cursor ends up in the top-left character on
3116 * the screen... But why? (Webb) */
3117 /* It's probably fixed by disabling drawing the cursor while scrolling. */
3118 /* gui.cursor_is_valid = FALSE; */
3119
3120 gui_clear_block(gui.scroll_region_bot - num_lines + 1,
3121 gui.scroll_region_left,
3122 gui.scroll_region_bot, gui.scroll_region_right);
3123}
3124
3125/*
3126 * Insert the given number of lines before the given row, scrolling down any
3127 * following text within the scroll region.
3128 */
3129 void
3130gui_mch_insert_lines(
3131 int row,
3132 int num_lines)
3133{
3134 RECT rc;
3135
Bram Moolenaar3b597552015-09-15 17:58:29 +02003136 intel_gpu_workaround();
3137
Bram Moolenaar071d4272004-06-13 20:20:40 +00003138 rc.left = FILL_X(gui.scroll_region_left);
3139 rc.right = FILL_X(gui.scroll_region_right + 1);
3140 rc.top = FILL_Y(row);
3141 rc.bottom = FILL_Y(gui.scroll_region_bot + 1);
3142 /* The SW_INVALIDATE is required when part of the window is covered or
3143 * off-screen. How do we avoid it when it's not needed? */
3144 ScrollWindowEx(s_textArea, 0, num_lines * gui.char_height,
3145 &rc, &rc, NULL, NULL, get_scroll_flags());
3146
3147 UpdateWindow(s_textArea);
3148
3149 gui_clear_block(row, gui.scroll_region_left,
3150 row + num_lines - 1, gui.scroll_region_right);
3151}
3152
3153
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00003154/*ARGSUSED*/
Bram Moolenaar071d4272004-06-13 20:20:40 +00003155 void
3156gui_mch_exit(int rc)
3157{
Bram Moolenaarb5a7a8b2014-08-06 14:52:30 +02003158#if defined(FEAT_DIRECTX)
3159 DWriteContext_Close(s_dwc);
3160 DWrite_Final();
3161 s_dwc = NULL;
3162#endif
3163
Bram Moolenaar071d4272004-06-13 20:20:40 +00003164 ReleaseDC(s_textArea, s_hdc);
3165 DeleteObject(s_brush);
3166
3167#ifdef FEAT_TEAROFF
3168 /* Unload the tearoff bitmap */
3169 (void)DeleteObject((HGDIOBJ)s_htearbitmap);
3170#endif
3171
3172 /* Destroy our window (if we have one). */
3173 if (s_hwnd != NULL)
3174 {
3175 destroying = TRUE; /* ignore WM_DESTROY message now */
3176 DestroyWindow(s_hwnd);
3177 }
3178
3179#ifdef GLOBAL_IME
3180 global_ime_end();
3181#endif
3182}
3183
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00003184 static char_u *
3185logfont2name(LOGFONT lf)
3186{
3187 char *p;
3188 char *res;
3189 char *charset_name;
Bram Moolenaarb1692e22014-03-12 19:24:37 +01003190 char *font_name = lf.lfFaceName;
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00003191
3192 charset_name = charset_id2name((int)lf.lfCharSet);
Bram Moolenaarb1692e22014-03-12 19:24:37 +01003193#ifdef FEAT_MBYTE
3194 /* Convert a font name from the current codepage to 'encoding'.
3195 * TODO: Use Wide APIs (including LOGFONTW) instead of ANSI APIs. */
3196 if (enc_codepage >= 0 && (int)GetACP() != enc_codepage)
3197 {
3198 int len;
Bram Moolenaar418f81b2016-02-16 20:12:02 +01003199 acp_to_enc((char_u *)lf.lfFaceName, (int)strlen(lf.lfFaceName),
Bram Moolenaarb1692e22014-03-12 19:24:37 +01003200 (char_u **)&font_name, &len);
3201 }
3202#endif
Bram Moolenaar418f81b2016-02-16 20:12:02 +01003203 res = (char *)alloc((unsigned)(strlen(font_name) + 20
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00003204 + (charset_name == NULL ? 0 : strlen(charset_name) + 2)));
3205 if (res != NULL)
3206 {
3207 p = res;
3208 /* make a normal font string out of the lf thing:*/
Bram Moolenaarb1692e22014-03-12 19:24:37 +01003209 sprintf((char *)p, "%s:h%d", font_name, pixels_to_points(
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00003210 lf.lfHeight < 0 ? -lf.lfHeight : lf.lfHeight, TRUE));
3211 while (*p)
3212 {
3213 if (*p == ' ')
3214 *p = '_';
3215 ++p;
3216 }
3217#ifndef MSWIN16_FASTTEXT
3218 if (lf.lfItalic)
3219 STRCAT(p, ":i");
3220 if (lf.lfWeight >= FW_BOLD)
3221 STRCAT(p, ":b");
3222#endif
3223 if (lf.lfUnderline)
3224 STRCAT(p, ":u");
3225 if (lf.lfStrikeOut)
3226 STRCAT(p, ":s");
3227 if (charset_name != NULL)
3228 {
3229 STRCAT(p, ":c");
3230 STRCAT(p, charset_name);
3231 }
3232 }
3233
Bram Moolenaarb1692e22014-03-12 19:24:37 +01003234#ifdef FEAT_MBYTE
3235 if (font_name != lf.lfFaceName)
3236 vim_free(font_name);
3237#endif
Bram Moolenaar418f81b2016-02-16 20:12:02 +01003238 return (char_u *)res;
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00003239}
3240
Bram Moolenaar0f272122013-01-23 18:37:40 +01003241
3242#ifdef FEAT_MBYTE_IME
3243/*
3244 * Set correct LOGFONT to IME. Use 'guifontwide' if available, otherwise use
3245 * 'guifont'
3246 */
3247 static void
Bram Moolenaarfb97f282013-07-09 17:42:46 +02003248update_im_font(void)
Bram Moolenaar0f272122013-01-23 18:37:40 +01003249{
3250 LOGFONT lf_wide;
3251
3252 if (p_guifontwide != NULL && *p_guifontwide != NUL
Bram Moolenaar826763f2013-01-25 19:28:38 +01003253 && gui.wide_font != NOFONT
3254 && GetObject((HFONT)gui.wide_font, sizeof(lf_wide), &lf_wide))
Bram Moolenaar0f272122013-01-23 18:37:40 +01003255 norm_logfont = lf_wide;
3256 else
3257 norm_logfont = sub_logfont;
3258 im_set_font(&norm_logfont);
3259}
3260#endif
3261
3262#ifdef FEAT_MBYTE
3263/*
3264 * Handler of gui.wide_font (p_guifontwide) changed notification.
3265 */
3266 void
Bram Moolenaar68c2f632016-01-30 17:24:07 +01003267gui_mch_wide_font_changed(void)
Bram Moolenaar0f272122013-01-23 18:37:40 +01003268{
Bram Moolenaardb250522013-06-17 22:43:25 +02003269# ifndef MSWIN16_FASTTEXT
3270 LOGFONT lf;
3271# endif
3272
Bram Moolenaar0f272122013-01-23 18:37:40 +01003273# ifdef FEAT_MBYTE_IME
3274 update_im_font();
3275# endif
Bram Moolenaardb250522013-06-17 22:43:25 +02003276
3277# ifndef MSWIN16_FASTTEXT
3278 gui_mch_free_font(gui.wide_ital_font);
3279 gui.wide_ital_font = NOFONT;
3280 gui_mch_free_font(gui.wide_bold_font);
3281 gui.wide_bold_font = NOFONT;
3282 gui_mch_free_font(gui.wide_boldital_font);
3283 gui.wide_boldital_font = NOFONT;
3284
3285 if (gui.wide_font
3286 && GetObject((HFONT)gui.wide_font, sizeof(lf), &lf))
3287 {
3288 if (!lf.lfItalic)
3289 {
3290 lf.lfItalic = TRUE;
3291 gui.wide_ital_font = get_font_handle(&lf);
3292 lf.lfItalic = FALSE;
3293 }
3294 if (lf.lfWeight < FW_BOLD)
3295 {
3296 lf.lfWeight = FW_BOLD;
3297 gui.wide_bold_font = get_font_handle(&lf);
3298 if (!lf.lfItalic)
3299 {
3300 lf.lfItalic = TRUE;
3301 gui.wide_boldital_font = get_font_handle(&lf);
3302 }
3303 }
3304 }
3305# endif
Bram Moolenaar0f272122013-01-23 18:37:40 +01003306}
3307#endif
3308
Bram Moolenaar071d4272004-06-13 20:20:40 +00003309/*
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00003310 * Initialise vim to use the font with the given name.
3311 * Return FAIL if the font could not be loaded, OK otherwise.
Bram Moolenaar071d4272004-06-13 20:20:40 +00003312 */
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00003313/*ARGSUSED*/
Bram Moolenaar071d4272004-06-13 20:20:40 +00003314 int
3315gui_mch_init_font(char_u *font_name, int fontset)
3316{
3317 LOGFONT lf;
3318 GuiFont font = NOFONT;
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00003319 char_u *p;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003320
3321 /* Load the font */
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00003322 if (get_logfont(&lf, font_name, NULL, TRUE) == OK)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003323 font = get_font_handle(&lf);
3324 if (font == NOFONT)
3325 return FAIL;
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00003326
Bram Moolenaar071d4272004-06-13 20:20:40 +00003327 if (font_name == NULL)
Bram Moolenaar418f81b2016-02-16 20:12:02 +01003328 font_name = (char_u *)lf.lfFaceName;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003329#if defined(FEAT_MBYTE_IME) || defined(GLOBAL_IME)
3330 norm_logfont = lf;
Bram Moolenaar0f272122013-01-23 18:37:40 +01003331 sub_logfont = lf;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003332#endif
3333#ifdef FEAT_MBYTE_IME
Bram Moolenaar0f272122013-01-23 18:37:40 +01003334 update_im_font();
Bram Moolenaar071d4272004-06-13 20:20:40 +00003335#endif
3336 gui_mch_free_font(gui.norm_font);
3337 gui.norm_font = font;
3338 current_font_height = lf.lfHeight;
3339 GetFontSize(font);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003340
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00003341 p = logfont2name(lf);
3342 if (p != NULL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003343 {
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00003344 hl_set_font_name(p);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003345
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00003346 /* When setting 'guifont' to "*" replace it with the actual font name.
3347 * */
3348 if (STRCMP(font_name, "*") == 0 && STRCMP(p_guifont, "*") == 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003349 {
Bram Moolenaar071d4272004-06-13 20:20:40 +00003350 vim_free(p_guifont);
3351 p_guifont = p;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003352 }
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00003353 else
3354 vim_free(p);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003355 }
3356
3357#ifndef MSWIN16_FASTTEXT
3358 gui_mch_free_font(gui.ital_font);
3359 gui.ital_font = NOFONT;
3360 gui_mch_free_font(gui.bold_font);
3361 gui.bold_font = NOFONT;
3362 gui_mch_free_font(gui.boldital_font);
3363 gui.boldital_font = NOFONT;
3364
3365 if (!lf.lfItalic)
3366 {
3367 lf.lfItalic = TRUE;
3368 gui.ital_font = get_font_handle(&lf);
3369 lf.lfItalic = FALSE;
3370 }
3371 if (lf.lfWeight < FW_BOLD)
3372 {
3373 lf.lfWeight = FW_BOLD;
3374 gui.bold_font = get_font_handle(&lf);
3375 if (!lf.lfItalic)
3376 {
3377 lf.lfItalic = TRUE;
3378 gui.boldital_font = get_font_handle(&lf);
3379 }
3380 }
3381#endif
3382
3383 return OK;
3384}
3385
Bram Moolenaar85f868c2006-11-28 16:16:58 +00003386#ifndef WPF_RESTORETOMAXIMIZED
3387# define WPF_RESTORETOMAXIMIZED 2 /* just in case someone doesn't have it */
3388#endif
3389
Bram Moolenaar071d4272004-06-13 20:20:40 +00003390/*
3391 * Return TRUE if the GUI window is maximized, filling the whole screen.
3392 */
3393 int
Bram Moolenaar68c2f632016-01-30 17:24:07 +01003394gui_mch_maximized(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003395{
Bram Moolenaar85f868c2006-11-28 16:16:58 +00003396 WINDOWPLACEMENT wp;
3397
3398 wp.length = sizeof(WINDOWPLACEMENT);
3399 if (GetWindowPlacement(s_hwnd, &wp))
3400 return wp.showCmd == SW_SHOWMAXIMIZED
3401 || (wp.showCmd == SW_SHOWMINIMIZED
3402 && wp.flags == WPF_RESTORETOMAXIMIZED);
3403
3404 return 0;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003405}
3406
3407/*
3408 * Called when the font changed while the window is maximized. Compute the
3409 * new Rows and Columns. This is like resizing the window.
3410 */
3411 void
Bram Moolenaar68c2f632016-01-30 17:24:07 +01003412gui_mch_newfont(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003413{
3414 RECT rect;
3415
3416 GetWindowRect(s_hwnd, &rect);
Bram Moolenaar89195542015-09-25 15:00:31 +02003417 if (win_socket_id == 0)
3418 {
3419 gui_resize_shell(rect.right - rect.left
3420 - (GetSystemMetrics(SM_CXFRAME) +
3421 GetSystemMetrics(SM_CXPADDEDBORDER)) * 2,
3422 rect.bottom - rect.top
3423 - (GetSystemMetrics(SM_CYFRAME) +
3424 GetSystemMetrics(SM_CXPADDEDBORDER)) * 2
3425 - GetSystemMetrics(SM_CYCAPTION)
3426#ifdef FEAT_MENU
3427 - gui_mswin_get_menu_height(FALSE)
3428#endif
3429 );
3430 }
3431 else
3432 {
3433 /* Inside another window, don't use the frame and border. */
3434 gui_resize_shell(rect.right - rect.left,
3435 rect.bottom - rect.top
Bram Moolenaar071d4272004-06-13 20:20:40 +00003436#ifdef FEAT_MENU
3437 - gui_mswin_get_menu_height(FALSE)
3438#endif
Bram Moolenaar89195542015-09-25 15:00:31 +02003439 );
3440 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00003441}
3442
3443/*
3444 * Set the window title
3445 */
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00003446/*ARGSUSED*/
Bram Moolenaar071d4272004-06-13 20:20:40 +00003447 void
3448gui_mch_settitle(
3449 char_u *title,
3450 char_u *icon)
3451{
Bram Moolenaar908d53a2006-11-07 18:05:31 +00003452 set_window_title(s_hwnd, (title == NULL ? "VIM" : (char *)title));
Bram Moolenaar071d4272004-06-13 20:20:40 +00003453}
3454
3455#ifdef FEAT_MOUSESHAPE
3456/* Table for shape IDCs. Keep in sync with the mshape_names[] table in
3457 * misc2.c! */
3458static LPCSTR mshape_idcs[] =
3459{
Bram Moolenaaraf62ff32013-03-19 14:48:29 +01003460 IDC_ARROW, /* arrow */
3461 MAKEINTRESOURCE(0), /* blank */
3462 IDC_IBEAM, /* beam */
3463 IDC_SIZENS, /* updown */
3464 IDC_SIZENS, /* udsizing */
3465 IDC_SIZEWE, /* leftright */
3466 IDC_SIZEWE, /* lrsizing */
3467 IDC_WAIT, /* busy */
Bram Moolenaar071d4272004-06-13 20:20:40 +00003468#ifdef WIN3264
Bram Moolenaaraf62ff32013-03-19 14:48:29 +01003469 IDC_NO, /* no */
Bram Moolenaar071d4272004-06-13 20:20:40 +00003470#else
Bram Moolenaaraf62ff32013-03-19 14:48:29 +01003471 IDC_ICON, /* no */
Bram Moolenaar071d4272004-06-13 20:20:40 +00003472#endif
Bram Moolenaaraf62ff32013-03-19 14:48:29 +01003473 IDC_ARROW, /* crosshair */
3474 IDC_ARROW, /* hand1 */
3475 IDC_ARROW, /* hand2 */
3476 IDC_ARROW, /* pencil */
3477 IDC_ARROW, /* question */
3478 IDC_ARROW, /* right-arrow */
3479 IDC_UPARROW, /* up-arrow */
3480 IDC_ARROW /* last one */
Bram Moolenaar071d4272004-06-13 20:20:40 +00003481};
3482
3483 void
3484mch_set_mouse_shape(int shape)
3485{
3486 LPCSTR idc;
3487
3488 if (shape == MSHAPE_HIDE)
3489 ShowCursor(FALSE);
3490 else
3491 {
3492 if (shape >= MSHAPE_NUMBERED)
Bram Moolenaaraf62ff32013-03-19 14:48:29 +01003493 idc = IDC_ARROW;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003494 else
3495 idc = mshape_idcs[shape];
Bram Moolenaare6a91fd2008-07-24 18:51:11 +00003496#ifdef SetClassLongPtr
3497 SetClassLongPtr(s_textArea, GCLP_HCURSOR, (__int3264)(LONG_PTR)LoadCursor(NULL, idc));
Bram Moolenaar071d4272004-06-13 20:20:40 +00003498#else
3499# ifdef WIN32
Bram Moolenaare6a91fd2008-07-24 18:51:11 +00003500 SetClassLong(s_textArea, GCL_HCURSOR, (long_u)LoadCursor(NULL, idc));
3501# else /* Win16 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00003502 SetClassWord(s_textArea, GCW_HCURSOR, (WORD)LoadCursor(NULL, idc));
3503# endif
3504#endif
3505 if (!p_mh)
3506 {
3507 POINT mp;
3508
3509 /* Set the position to make it redrawn with the new shape. */
3510 (void)GetCursorPos((LPPOINT)&mp);
3511 (void)SetCursorPos(mp.x, mp.y);
3512 ShowCursor(TRUE);
3513 }
3514 }
3515}
3516#endif
3517
3518#ifdef FEAT_BROWSE
3519/*
3520 * The file browser exists in two versions: with "W" uses wide characters,
3521 * without "W" the current codepage. When FEAT_MBYTE is defined and on
3522 * Windows NT/2000/XP the "W" functions are used.
3523 */
3524
3525# if defined(FEAT_MBYTE) && defined(WIN3264)
3526/*
Bram Moolenaar3ef7cdf2012-01-20 17:57:51 +01003527 * Wide version of convert_filter().
Bram Moolenaar071d4272004-06-13 20:20:40 +00003528 */
3529 static WCHAR *
3530convert_filterW(char_u *s)
3531{
Bram Moolenaar3ef7cdf2012-01-20 17:57:51 +01003532 char_u *tmp;
3533 int len;
Bram Moolenaar90b28002012-01-20 20:54:19 +01003534 WCHAR *res;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003535
Bram Moolenaar3ef7cdf2012-01-20 17:57:51 +01003536 tmp = convert_filter(s);
3537 if (tmp == NULL)
3538 return NULL;
3539 len = (int)STRLEN(s) + 3;
3540 res = enc_to_utf16(tmp, &len);
3541 vim_free(tmp);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003542 return res;
3543}
3544
3545/*
3546 * Wide version of gui_mch_browse(). Keep in sync!
3547 */
3548 static char_u *
3549gui_mch_browseW(
3550 int saving,
3551 char_u *title,
3552 char_u *dflt,
3553 char_u *ext,
3554 char_u *initdir,
3555 char_u *filter)
3556{
Bram Moolenaar36f692d2008-11-20 16:10:17 +00003557 /* We always use the wide function. This means enc_to_utf16() must work,
Bram Moolenaar071d4272004-06-13 20:20:40 +00003558 * otherwise it fails miserably! */
3559 OPENFILENAMEW fileStruct;
3560 WCHAR fileBuf[MAXPATHL];
3561 WCHAR *wp;
3562 int i;
3563 WCHAR *titlep = NULL;
3564 WCHAR *extp = NULL;
3565 WCHAR *initdirp = NULL;
3566 WCHAR *filterp;
3567 char_u *p;
3568
3569 if (dflt == NULL)
3570 fileBuf[0] = NUL;
3571 else
3572 {
Bram Moolenaar36f692d2008-11-20 16:10:17 +00003573 wp = enc_to_utf16(dflt, NULL);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003574 if (wp == NULL)
3575 fileBuf[0] = NUL;
3576 else
3577 {
3578 for (i = 0; wp[i] != NUL && i < MAXPATHL - 1; ++i)
3579 fileBuf[i] = wp[i];
3580 fileBuf[i] = NUL;
3581 vim_free(wp);
3582 }
3583 }
3584
3585 /* Convert the filter to Windows format. */
3586 filterp = convert_filterW(filter);
3587
Bram Moolenaar7db5fc82010-05-24 11:59:29 +02003588 vim_memset(&fileStruct, 0, sizeof(OPENFILENAMEW));
Bram Moolenaar071d4272004-06-13 20:20:40 +00003589#ifdef OPENFILENAME_SIZE_VERSION_400
3590 /* be compatible with Windows NT 4.0 */
3591 /* TODO: what to use for OPENFILENAMEW??? */
Bram Moolenaar8c83ac32010-02-17 17:34:43 +01003592 fileStruct.lStructSize = OPENFILENAME_SIZE_VERSION_400;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003593#else
3594 fileStruct.lStructSize = sizeof(fileStruct);
3595#endif
3596
3597 if (title != NULL)
Bram Moolenaar36f692d2008-11-20 16:10:17 +00003598 titlep = enc_to_utf16(title, NULL);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003599 fileStruct.lpstrTitle = titlep;
3600
3601 if (ext != NULL)
Bram Moolenaar36f692d2008-11-20 16:10:17 +00003602 extp = enc_to_utf16(ext, NULL);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003603 fileStruct.lpstrDefExt = extp;
3604
3605 fileStruct.lpstrFile = fileBuf;
3606 fileStruct.nMaxFile = MAXPATHL;
3607 fileStruct.lpstrFilter = filterp;
3608 fileStruct.hwndOwner = s_hwnd; /* main Vim window is owner*/
3609 /* has an initial dir been specified? */
3610 if (initdir != NULL && *initdir != NUL)
3611 {
3612 /* Must have backslashes here, no matter what 'shellslash' says */
Bram Moolenaar36f692d2008-11-20 16:10:17 +00003613 initdirp = enc_to_utf16(initdir, NULL);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003614 if (initdirp != NULL)
3615 {
3616 for (wp = initdirp; *wp != NUL; ++wp)
3617 if (*wp == '/')
3618 *wp = '\\';
3619 }
3620 fileStruct.lpstrInitialDir = initdirp;
3621 }
3622
3623 /*
3624 * TODO: Allow selection of multiple files. Needs another arg to this
3625 * function to ask for it, and need to use OFN_ALLOWMULTISELECT below.
3626 * Also, should we use OFN_FILEMUSTEXIST when opening? Vim can edit on
3627 * files that don't exist yet, so I haven't put it in. What about
3628 * OFN_PATHMUSTEXIST?
3629 * Don't use OFN_OVERWRITEPROMPT, Vim has its own ":confirm" dialog.
3630 */
3631 fileStruct.Flags = (OFN_NOCHANGEDIR | OFN_PATHMUSTEXIST | OFN_HIDEREADONLY);
3632#ifdef FEAT_SHORTCUT
3633 if (curbuf->b_p_bin)
3634 fileStruct.Flags |= OFN_NODEREFERENCELINKS;
3635#endif
3636 if (saving)
3637 {
3638 if (!GetSaveFileNameW(&fileStruct))
3639 return NULL;
3640 }
3641 else
3642 {
3643 if (!GetOpenFileNameW(&fileStruct))
3644 return NULL;
3645 }
3646
3647 vim_free(filterp);
3648 vim_free(initdirp);
3649 vim_free(titlep);
3650 vim_free(extp);
3651
3652 /* Convert from UCS2 to 'encoding'. */
Bram Moolenaar36f692d2008-11-20 16:10:17 +00003653 p = utf16_to_enc(fileBuf, NULL);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003654 if (p != NULL)
3655 /* when out of memory we get garbage for non-ASCII chars */
3656 STRCPY(fileBuf, p);
3657 vim_free(p);
3658
3659 /* Give focus back to main window (when using MDI). */
3660 SetFocus(s_hwnd);
3661
3662 /* Shorten the file name if possible */
Bram Moolenaard089d9b2007-09-30 12:02:55 +00003663 return vim_strsave(shorten_fname1((char_u *)fileBuf));
Bram Moolenaar071d4272004-06-13 20:20:40 +00003664}
3665# endif /* FEAT_MBYTE */
3666
3667
3668/*
3669 * Convert the string s to the proper format for a filter string by replacing
Bram Moolenaar12806c82008-11-12 12:36:30 +00003670 * the \t and \n delimiters with \0.
Bram Moolenaar071d4272004-06-13 20:20:40 +00003671 * Returns the converted string in allocated memory.
3672 *
3673 * Keep in sync with convert_filterW() above!
3674 */
3675 static char_u *
3676convert_filter(char_u *s)
3677{
3678 char_u *res;
3679 unsigned s_len = (unsigned)STRLEN(s);
3680 unsigned i;
3681
3682 res = alloc(s_len + 3);
3683 if (res != NULL)
3684 {
3685 for (i = 0; i < s_len; ++i)
3686 if (s[i] == '\t' || s[i] == '\n')
3687 res[i] = '\0';
3688 else
3689 res[i] = s[i];
3690 res[s_len] = NUL;
3691 /* Add two extra NULs to make sure it's properly terminated. */
3692 res[s_len + 1] = NUL;
3693 res[s_len + 2] = NUL;
3694 }
3695 return res;
3696}
3697
3698/*
Bram Moolenaar7171abe2004-10-11 10:06:20 +00003699 * Select a directory.
3700 */
3701 char_u *
3702gui_mch_browsedir(char_u *title, char_u *initdir)
3703{
3704 /* We fake this: Use a filter that doesn't select anything and a default
3705 * file name that won't be used. */
3706 return gui_mch_browse(0, title, (char_u *)_("Not Used"), NULL,
3707 initdir, (char_u *)_("Directory\t*.nothing\n"));
3708}
3709
3710/*
Bram Moolenaar071d4272004-06-13 20:20:40 +00003711 * Pop open a file browser and return the file selected, in allocated memory,
3712 * or NULL if Cancel is hit.
3713 * saving - TRUE if the file will be saved to, FALSE if it will be opened.
3714 * title - Title message for the file browser dialog.
3715 * dflt - Default name of file.
3716 * ext - Default extension to be added to files without extensions.
3717 * initdir - directory in which to open the browser (NULL = current dir)
3718 * filter - Filter for matched files to choose from.
3719 *
3720 * Keep in sync with gui_mch_browseW() above!
3721 */
3722 char_u *
3723gui_mch_browse(
3724 int saving,
3725 char_u *title,
3726 char_u *dflt,
3727 char_u *ext,
3728 char_u *initdir,
3729 char_u *filter)
3730{
3731 OPENFILENAME fileStruct;
3732 char_u fileBuf[MAXPATHL];
3733 char_u *initdirp = NULL;
3734 char_u *filterp;
3735 char_u *p;
3736
3737# if defined(FEAT_MBYTE) && defined(WIN3264)
3738 if (os_version.dwPlatformId == VER_PLATFORM_WIN32_NT)
3739 return gui_mch_browseW(saving, title, dflt, ext, initdir, filter);
3740# endif
3741
3742 if (dflt == NULL)
3743 fileBuf[0] = NUL;
3744 else
Bram Moolenaarfe3ca8d2005-07-18 21:43:02 +00003745 vim_strncpy(fileBuf, dflt, MAXPATHL - 1);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003746
3747 /* Convert the filter to Windows format. */
3748 filterp = convert_filter(filter);
3749
Bram Moolenaar7db5fc82010-05-24 11:59:29 +02003750 vim_memset(&fileStruct, 0, sizeof(OPENFILENAME));
Bram Moolenaar071d4272004-06-13 20:20:40 +00003751#ifdef OPENFILENAME_SIZE_VERSION_400
3752 /* be compatible with Windows NT 4.0 */
Bram Moolenaar8c83ac32010-02-17 17:34:43 +01003753 fileStruct.lStructSize = OPENFILENAME_SIZE_VERSION_400;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003754#else
3755 fileStruct.lStructSize = sizeof(fileStruct);
3756#endif
3757
Bram Moolenaar418f81b2016-02-16 20:12:02 +01003758 fileStruct.lpstrTitle = (LPSTR)title;
3759 fileStruct.lpstrDefExt = (LPSTR)ext;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003760
Bram Moolenaar418f81b2016-02-16 20:12:02 +01003761 fileStruct.lpstrFile = (LPSTR)fileBuf;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003762 fileStruct.nMaxFile = MAXPATHL;
Bram Moolenaar418f81b2016-02-16 20:12:02 +01003763 fileStruct.lpstrFilter = (LPSTR)filterp;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003764 fileStruct.hwndOwner = s_hwnd; /* main Vim window is owner*/
3765 /* has an initial dir been specified? */
3766 if (initdir != NULL && *initdir != NUL)
3767 {
3768 /* Must have backslashes here, no matter what 'shellslash' says */
3769 initdirp = vim_strsave(initdir);
3770 if (initdirp != NULL)
3771 for (p = initdirp; *p != NUL; ++p)
3772 if (*p == '/')
3773 *p = '\\';
Bram Moolenaar418f81b2016-02-16 20:12:02 +01003774 fileStruct.lpstrInitialDir = (LPSTR)initdirp;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003775 }
3776
3777 /*
3778 * TODO: Allow selection of multiple files. Needs another arg to this
3779 * function to ask for it, and need to use OFN_ALLOWMULTISELECT below.
3780 * Also, should we use OFN_FILEMUSTEXIST when opening? Vim can edit on
3781 * files that don't exist yet, so I haven't put it in. What about
3782 * OFN_PATHMUSTEXIST?
3783 * Don't use OFN_OVERWRITEPROMPT, Vim has its own ":confirm" dialog.
3784 */
3785 fileStruct.Flags = (OFN_NOCHANGEDIR | OFN_PATHMUSTEXIST | OFN_HIDEREADONLY);
3786#ifdef FEAT_SHORTCUT
3787 if (curbuf->b_p_bin)
3788 fileStruct.Flags |= OFN_NODEREFERENCELINKS;
3789#endif
3790 if (saving)
3791 {
3792 if (!GetSaveFileName(&fileStruct))
3793 return NULL;
3794 }
3795 else
3796 {
3797 if (!GetOpenFileName(&fileStruct))
3798 return NULL;
3799 }
3800
3801 vim_free(filterp);
3802 vim_free(initdirp);
3803
3804 /* Give focus back to main window (when using MDI). */
3805 SetFocus(s_hwnd);
3806
3807 /* Shorten the file name if possible */
Bram Moolenaard089d9b2007-09-30 12:02:55 +00003808 return vim_strsave(shorten_fname1((char_u *)fileBuf));
Bram Moolenaar071d4272004-06-13 20:20:40 +00003809}
3810#endif /* FEAT_BROWSE */
3811
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00003812/*ARGSUSED*/
Bram Moolenaar071d4272004-06-13 20:20:40 +00003813 static void
3814_OnDropFiles(
3815 HWND hwnd,
3816 HDROP hDrop)
3817{
3818#ifdef FEAT_WINDOWS
3819#ifdef WIN3264
3820# define BUFPATHLEN _MAX_PATH
3821# define DRAGQVAL 0xFFFFFFFF
3822#else
3823# define BUFPATHLEN MAXPATHL
3824# define DRAGQVAL 0xFFFF
3825#endif
3826#ifdef FEAT_MBYTE
3827 WCHAR wszFile[BUFPATHLEN];
3828#endif
3829 char szFile[BUFPATHLEN];
3830 UINT cFiles = DragQueryFile(hDrop, DRAGQVAL, NULL, 0);
3831 UINT i;
3832 char_u **fnames;
3833 POINT pt;
3834 int_u modifiers = 0;
3835
3836 /* TRACE("_OnDropFiles: %d files dropped\n", cFiles); */
3837
3838 /* Obtain dropped position */
3839 DragQueryPoint(hDrop, &pt);
3840 MapWindowPoints(s_hwnd, s_textArea, &pt, 1);
3841
Bram Moolenaar071d4272004-06-13 20:20:40 +00003842 reset_VIsual();
Bram Moolenaar071d4272004-06-13 20:20:40 +00003843
3844 fnames = (char_u **)alloc(cFiles * sizeof(char_u *));
3845
3846 if (fnames != NULL)
3847 for (i = 0; i < cFiles; ++i)
3848 {
3849#ifdef FEAT_MBYTE
3850 if (DragQueryFileW(hDrop, i, wszFile, BUFPATHLEN) > 0)
Bram Moolenaar36f692d2008-11-20 16:10:17 +00003851 fnames[i] = utf16_to_enc(wszFile, NULL);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003852 else
3853#endif
3854 {
3855 DragQueryFile(hDrop, i, szFile, BUFPATHLEN);
Bram Moolenaar418f81b2016-02-16 20:12:02 +01003856 fnames[i] = vim_strsave((char_u *)szFile);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003857 }
3858 }
3859
3860 DragFinish(hDrop);
3861
3862 if (fnames != NULL)
3863 {
3864 if ((GetKeyState(VK_SHIFT) & 0x8000) != 0)
3865 modifiers |= MOUSE_SHIFT;
3866 if ((GetKeyState(VK_CONTROL) & 0x8000) != 0)
3867 modifiers |= MOUSE_CTRL;
3868 if ((GetKeyState(VK_MENU) & 0x8000) != 0)
3869 modifiers |= MOUSE_ALT;
3870
3871 gui_handle_drop(pt.x, pt.y, modifiers, fnames, cFiles);
3872
3873 s_need_activate = TRUE;
3874 }
3875#endif
3876}
3877
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00003878/*ARGSUSED*/
Bram Moolenaar071d4272004-06-13 20:20:40 +00003879 static int
3880_OnScroll(
3881 HWND hwnd,
3882 HWND hwndCtl,
3883 UINT code,
3884 int pos)
3885{
3886 static UINT prev_code = 0; /* code of previous call */
3887 scrollbar_T *sb, *sb_info;
3888 long val;
3889 int dragging = FALSE;
3890 int dont_scroll_save = dont_scroll;
3891#ifndef WIN3264
3892 int nPos;
3893#else
3894 SCROLLINFO si;
3895
3896 si.cbSize = sizeof(si);
3897 si.fMask = SIF_POS;
3898#endif
3899
3900 sb = gui_mswin_find_scrollbar(hwndCtl);
3901 if (sb == NULL)
3902 return 0;
3903
3904 if (sb->wp != NULL) /* Left or right scrollbar */
3905 {
3906 /*
3907 * Careful: need to get scrollbar info out of first (left) scrollbar
3908 * for window, but keep real scrollbar too because we must pass it to
3909 * gui_drag_scrollbar().
3910 */
3911 sb_info = &sb->wp->w_scrollbars[0];
3912 }
3913 else /* Bottom scrollbar */
3914 sb_info = sb;
3915 val = sb_info->value;
3916
3917 switch (code)
3918 {
3919 case SB_THUMBTRACK:
3920 val = pos;
3921 dragging = TRUE;
3922 if (sb->scroll_shift > 0)
3923 val <<= sb->scroll_shift;
3924 break;
3925 case SB_LINEDOWN:
3926 val++;
3927 break;
3928 case SB_LINEUP:
3929 val--;
3930 break;
3931 case SB_PAGEDOWN:
3932 val += (sb_info->size > 2 ? sb_info->size - 2 : 1);
3933 break;
3934 case SB_PAGEUP:
3935 val -= (sb_info->size > 2 ? sb_info->size - 2 : 1);
3936 break;
3937 case SB_TOP:
3938 val = 0;
3939 break;
3940 case SB_BOTTOM:
3941 val = sb_info->max;
3942 break;
3943 case SB_ENDSCROLL:
3944 if (prev_code == SB_THUMBTRACK)
3945 {
3946 /*
3947 * "pos" only gives us 16-bit data. In case of large file,
3948 * use GetScrollPos() which returns 32-bit. Unfortunately it
3949 * is not valid while the scrollbar is being dragged.
3950 */
3951 val = GetScrollPos(hwndCtl, SB_CTL);
3952 if (sb->scroll_shift > 0)
3953 val <<= sb->scroll_shift;
3954 }
3955 break;
3956
3957 default:
3958 /* TRACE("Unknown scrollbar event %d\n", code); */
3959 return 0;
3960 }
3961 prev_code = code;
3962
3963#ifdef WIN3264
3964 si.nPos = (sb->scroll_shift > 0) ? val >> sb->scroll_shift : val;
3965 SetScrollInfo(hwndCtl, SB_CTL, &si, TRUE);
3966#else
3967 nPos = (sb->scroll_shift > 0) ? val >> sb->scroll_shift : val;
3968 SetScrollPos(hwndCtl, SB_CTL, nPos, TRUE);
3969#endif
3970
3971 /*
3972 * When moving a vertical scrollbar, move the other vertical scrollbar too.
3973 */
3974 if (sb->wp != NULL)
3975 {
3976 scrollbar_T *sba = sb->wp->w_scrollbars;
3977 HWND id = sba[ (sb == sba + SBAR_LEFT) ? SBAR_RIGHT : SBAR_LEFT].id;
3978
3979#ifdef WIN3264
3980 SetScrollInfo(id, SB_CTL, &si, TRUE);
3981#else
3982 SetScrollPos(id, SB_CTL, nPos, TRUE);
3983#endif
3984 }
3985
3986 /* Don't let us be interrupted here by another message. */
3987 s_busy_processing = TRUE;
3988
3989 /* When "allow_scrollbar" is FALSE still need to remember the new
3990 * position, but don't actually scroll by setting "dont_scroll". */
3991 dont_scroll = !allow_scrollbar;
3992
3993 gui_drag_scrollbar(sb, val, dragging);
3994
3995 s_busy_processing = FALSE;
3996 dont_scroll = dont_scroll_save;
3997
3998 return 0;
3999}
4000
Bram Moolenaar3fdfa4a2004-10-07 21:02:47 +00004001
Bram Moolenaar071d4272004-06-13 20:20:40 +00004002/*
4003 * Get command line arguments.
4004 * Use "prog" as the name of the program and "cmdline" as the arguments.
4005 * Copy the arguments to allocated memory.
4006 * Return the number of arguments (including program name).
Bram Moolenaar12806c82008-11-12 12:36:30 +00004007 * Return pointers to the arguments in "argvp". Memory is allocated with
4008 * malloc(), use free() instead of vim_free().
Bram Moolenaar071d4272004-06-13 20:20:40 +00004009 * Return pointer to buffer in "tofree".
4010 * Returns zero when out of memory.
4011 */
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00004012/*ARGSUSED*/
Bram Moolenaar071d4272004-06-13 20:20:40 +00004013 int
4014get_cmd_args(char *prog, char *cmdline, char ***argvp, char **tofree)
4015{
4016 int i;
4017 char *p;
4018 char *progp;
4019 char *pnew = NULL;
4020 char *newcmdline;
4021 int inquote;
4022 int argc;
4023 char **argv = NULL;
4024 int round;
4025
Bram Moolenaar12806c82008-11-12 12:36:30 +00004026 *tofree = NULL;
4027
Bram Moolenaar3fdfa4a2004-10-07 21:02:47 +00004028#ifdef FEAT_MBYTE
4029 /* Try using the Unicode version first, it takes care of conversion when
4030 * 'encoding' is changed. */
4031 argc = get_cmd_argsW(&argv);
4032 if (argc != 0)
4033 goto done;
4034#endif
4035
Bram Moolenaar071d4272004-06-13 20:20:40 +00004036 /* Handle the program name. Remove the ".exe" extension, and find the 1st
4037 * non-space. */
4038 p = strrchr(prog, '.');
4039 if (p != NULL)
4040 *p = NUL;
4041 for (progp = prog; *progp == ' '; ++progp)
4042 ;
4043
4044 /* The command line is copied to allocated memory, so that we can change
4045 * it. Add the size of the string, the separating NUL and a terminating
4046 * NUL. */
4047 newcmdline = malloc(STRLEN(cmdline) + STRLEN(progp) + 2);
4048 if (newcmdline == NULL)
4049 return 0;
4050
4051 /*
4052 * First round: count the number of arguments ("pnew" == NULL).
4053 * Second round: produce the arguments.
4054 */
4055 for (round = 1; round <= 2; ++round)
4056 {
4057 /* First argument is the program name. */
4058 if (pnew != NULL)
4059 {
4060 argv[0] = pnew;
4061 strcpy(pnew, progp);
4062 pnew += strlen(pnew);
4063 *pnew++ = NUL;
4064 }
4065
4066 /*
4067 * Isolate each argument and put it in argv[].
4068 */
4069 p = cmdline;
4070 argc = 1;
4071 while (*p != NUL)
4072 {
4073 inquote = FALSE;
4074 if (pnew != NULL)
4075 argv[argc] = pnew;
4076 ++argc;
4077 while (*p != NUL && (inquote || (*p != ' ' && *p != '\t')))
4078 {
4079 /* Backslashes are only special when followed by a double
4080 * quote. */
Bram Moolenaara93fa7e2006-04-17 22:14:47 +00004081 i = (int)strspn(p, "\\");
Bram Moolenaar071d4272004-06-13 20:20:40 +00004082 if (p[i] == '"')
4083 {
4084 /* Halve the number of backslashes. */
4085 if (i > 1 && pnew != NULL)
4086 {
Bram Moolenaar7db5fc82010-05-24 11:59:29 +02004087 vim_memset(pnew, '\\', i / 2);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004088 pnew += i / 2;
4089 }
4090
4091 /* Even nr of backslashes toggles quoting, uneven copies
4092 * the double quote. */
4093 if ((i & 1) == 0)
4094 inquote = !inquote;
4095 else if (pnew != NULL)
4096 *pnew++ = '"';
4097 p += i + 1;
4098 }
4099 else if (i > 0)
4100 {
4101 /* Copy span of backslashes unmodified. */
4102 if (pnew != NULL)
4103 {
Bram Moolenaar7db5fc82010-05-24 11:59:29 +02004104 vim_memset(pnew, '\\', i);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004105 pnew += i;
4106 }
4107 p += i;
4108 }
4109 else
4110 {
4111 if (pnew != NULL)
4112 *pnew++ = *p;
Bram Moolenaar15d0a8c2004-09-06 17:44:46 +00004113#ifdef FEAT_MBYTE
4114 /* Can't use mb_* functions, because 'encoding' is not
4115 * initialized yet here. */
4116 if (IsDBCSLeadByte(*p))
4117 {
4118 ++p;
4119 if (pnew != NULL)
4120 *pnew++ = *p;
4121 }
4122#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00004123 ++p;
4124 }
4125 }
4126
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00004127 if (pnew != NULL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004128 *pnew++ = NUL;
4129 while (*p == ' ' || *p == '\t')
4130 ++p; /* advance until a non-space */
4131 }
4132
4133 if (round == 1)
4134 {
4135 argv = (char **)malloc((argc + 1) * sizeof(char *));
4136 if (argv == NULL )
Bram Moolenaare6b165e2005-06-30 21:56:01 +00004137 {
Bram Moolenaar12806c82008-11-12 12:36:30 +00004138 free(newcmdline);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004139 return 0; /* malloc error */
Bram Moolenaare6b165e2005-06-30 21:56:01 +00004140 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00004141 pnew = newcmdline;
Bram Moolenaar12806c82008-11-12 12:36:30 +00004142 *tofree = newcmdline;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004143 }
4144 }
4145
Bram Moolenaar8765a4a2010-07-27 22:41:43 +02004146#ifdef FEAT_MBYTE
Bram Moolenaar3fdfa4a2004-10-07 21:02:47 +00004147done:
Bram Moolenaar8765a4a2010-07-27 22:41:43 +02004148#endif
Bram Moolenaar3fdfa4a2004-10-07 21:02:47 +00004149 argv[argc] = NULL; /* NULL-terminated list */
Bram Moolenaar071d4272004-06-13 20:20:40 +00004150 *argvp = argv;
4151 return argc;
4152}