blob: 6bafa8e0e467d357055035eec174dbd643f052b2 [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;
537 len = MultiByteToWideChar(GetACP(), 0, string, 1, wstring, 2);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000538 }
539 }
Bram Moolenaar293ee4d2004-12-09 21:34:53 +0000540 else
541 {
542 wstring[0] = ch;
543 len = 1;
544 }
545
546 if (len > 0)
547 {
548 /* "ch" is a UTF-16 character. Convert it to a string of bytes. When
549 * "enc_codepage" is non-zero use the standard Win32 function,
550 * otherwise use our own conversion function (e.g., for UTF-8). */
551 if (enc_codepage > 0)
Bram Moolenaar85a3e5c2007-11-20 16:22:16 +0000552 {
Bram Moolenaar293ee4d2004-12-09 21:34:53 +0000553 len = WideCharToMultiByte(enc_codepage, 0, wstring, len,
554 string, slen, 0, NULL);
Bram Moolenaar85a3e5c2007-11-20 16:22:16 +0000555 /* If we had included the ALT key into the character but now the
556 * upper bit is no longer set, that probably means the conversion
557 * failed. Convert the original character and set the upper bit
558 * afterwards. */
559 if (had_alt && len == 1 && ch >= 0x80 && string[0] < 0x80)
560 {
561 wstring[0] = ch & 0x7f;
562 len = WideCharToMultiByte(enc_codepage, 0, wstring, len,
563 string, slen, 0, NULL);
564 if (len == 1) /* safety check */
565 string[0] |= 0x80;
566 }
567 }
Bram Moolenaar293ee4d2004-12-09 21:34:53 +0000568 else
569 {
570 len = 1;
Bram Moolenaar36f692d2008-11-20 16:10:17 +0000571 ws = utf16_to_enc(wstring, &len);
Bram Moolenaar293ee4d2004-12-09 21:34:53 +0000572 if (ws == NULL)
573 len = 0;
574 else
575 {
576 if (len > slen) /* just in case */
577 len = slen;
578 mch_memmove(string, ws, len);
579 vim_free(ws);
580 }
581 }
582 }
583
Bram Moolenaar071d4272004-06-13 20:20:40 +0000584 if (len == 0)
585#endif
586 {
587 string[0] = ch;
588 len = 1;
589 }
590
591 for (i = 0; i < len; ++i)
592 if (string[i] == CSI && len <= slen - 2)
593 {
594 /* Insert CSI as K_CSI. */
595 mch_memmove(string + i + 3, string + i + 1, len - i - 1);
596 string[++i] = KS_EXTRA;
597 string[++i] = (int)KE_CSI;
598 len += 2;
599 }
600
601 return len;
602}
603
604/*
605 * Key hit, add it to the input buffer.
606 */
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +0000607/*ARGSUSED*/
Bram Moolenaar071d4272004-06-13 20:20:40 +0000608 static void
609_OnChar(
610 HWND hwnd,
611 UINT ch,
612 int cRepeat)
613{
614 char_u string[40];
615 int len = 0;
616
Bram Moolenaard2e80872014-08-22 18:44:33 +0200617 dead_key = 0;
618
Bram Moolenaar85a3e5c2007-11-20 16:22:16 +0000619 len = char_to_string(ch, string, 40, FALSE);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000620 if (len == 1 && string[0] == Ctrl_C && ctrl_c_interrupts)
621 {
622 trash_input_buf();
623 got_int = TRUE;
624 }
625
626 add_to_input_buf(string, len);
627}
628
629/*
630 * Alt-Key hit, add it to the input buffer.
631 */
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +0000632/*ARGSUSED*/
Bram Moolenaar071d4272004-06-13 20:20:40 +0000633 static void
634_OnSysChar(
635 HWND hwnd,
636 UINT cch,
637 int cRepeat)
638{
639 char_u string[40]; /* Enough for multibyte character */
640 int len;
641 int modifiers;
642 int ch = cch; /* special keys are negative */
643
Bram Moolenaar25b2b942016-01-17 20:53:12 +0100644 dead_key = 0;
645
Bram Moolenaar071d4272004-06-13 20:20:40 +0000646 /* TRACE("OnSysChar(%d, %c)\n", ch, ch); */
647
648 /* OK, we have a character key (given by ch) which was entered with the
649 * ALT key pressed. Eg, if the user presses Alt-A, then ch == 'A'. Note
650 * that the system distinguishes Alt-a and Alt-A (Alt-Shift-a unless
651 * CAPSLOCK is pressed) at this point.
652 */
653 modifiers = MOD_MASK_ALT;
654 if (GetKeyState(VK_SHIFT) & 0x8000)
655 modifiers |= MOD_MASK_SHIFT;
656 if (GetKeyState(VK_CONTROL) & 0x8000)
657 modifiers |= MOD_MASK_CTRL;
658
659 ch = simplify_key(ch, &modifiers);
660 /* remove the SHIFT modifier for keys where it's already included, e.g.,
661 * '(' and '*' */
662 if (ch < 0x100 && !isalpha(ch) && isprint(ch))
663 modifiers &= ~MOD_MASK_SHIFT;
664
665 /* Interpret the ALT key as making the key META, include SHIFT, etc. */
666 ch = extract_modifiers(ch, &modifiers);
667 if (ch == CSI)
668 ch = K_CSI;
669
670 len = 0;
671 if (modifiers)
672 {
673 string[len++] = CSI;
674 string[len++] = KS_MODIFIER;
675 string[len++] = modifiers;
676 }
677
678 if (IS_SPECIAL((int)ch))
679 {
680 string[len++] = CSI;
681 string[len++] = K_SECOND((int)ch);
682 string[len++] = K_THIRD((int)ch);
683 }
684 else
685 {
686 /* Although the documentation isn't clear about it, we assume "ch" is
687 * a Unicode character. */
Bram Moolenaar85a3e5c2007-11-20 16:22:16 +0000688 len += char_to_string(ch, string + len, 40 - len, TRUE);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000689 }
690
691 add_to_input_buf(string, len);
692}
693
694 static void
695_OnMouseEvent(
696 int button,
697 int x,
698 int y,
699 int repeated_click,
700 UINT keyFlags)
701{
702 int vim_modifiers = 0x0;
703
Bram Moolenaarea408882007-12-03 21:21:03 +0000704 s_getting_focus = FALSE;
705
Bram Moolenaar071d4272004-06-13 20:20:40 +0000706 if (keyFlags & MK_SHIFT)
707 vim_modifiers |= MOUSE_SHIFT;
708 if (keyFlags & MK_CONTROL)
709 vim_modifiers |= MOUSE_CTRL;
710 if (GetKeyState(VK_MENU) & 0x8000)
711 vim_modifiers |= MOUSE_ALT;
712
713 gui_send_mouse_event(button, x, y, repeated_click, vim_modifiers);
714}
715
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +0000716/*ARGSUSED*/
Bram Moolenaar071d4272004-06-13 20:20:40 +0000717 static void
718_OnMouseButtonDown(
719 HWND hwnd,
720 BOOL fDoubleClick,
721 int x,
722 int y,
723 UINT keyFlags)
724{
725 static LONG s_prevTime = 0;
726
727 LONG currentTime = GetMessageTime();
728 int button = -1;
729 int repeated_click;
730
731 /* Give main window the focus: this is so the cursor isn't hollow. */
732 (void)SetFocus(s_hwnd);
733
734 if (s_uMsg == WM_LBUTTONDOWN || s_uMsg == WM_LBUTTONDBLCLK)
735 button = MOUSE_LEFT;
736 else if (s_uMsg == WM_MBUTTONDOWN || s_uMsg == WM_MBUTTONDBLCLK)
737 button = MOUSE_MIDDLE;
738 else if (s_uMsg == WM_RBUTTONDOWN || s_uMsg == WM_RBUTTONDBLCLK)
739 button = MOUSE_RIGHT;
740#ifndef WIN16 /*<VN>*/
741 else if (s_uMsg == WM_XBUTTONDOWN || s_uMsg == WM_XBUTTONDBLCLK)
742 {
743#ifndef GET_XBUTTON_WPARAM
744# define GET_XBUTTON_WPARAM(wParam) (HIWORD(wParam))
745#endif
746 button = ((GET_XBUTTON_WPARAM(s_wParam) == 1) ? MOUSE_X1 : MOUSE_X2);
747 }
748 else if (s_uMsg == WM_CAPTURECHANGED)
749 {
750 /* on W95/NT4, somehow you get in here with an odd Msg
751 * if you press one button while holding down the other..*/
752 if (s_button_pending == MOUSE_LEFT)
753 button = MOUSE_RIGHT;
754 else
755 button = MOUSE_LEFT;
756 }
757#endif
758 if (button >= 0)
759 {
760 repeated_click = ((int)(currentTime - s_prevTime) < p_mouset);
761
762 /*
763 * Holding down the left and right buttons simulates pushing the middle
764 * button.
765 */
Bram Moolenaar293ee4d2004-12-09 21:34:53 +0000766 if (repeated_click
767 && ((button == MOUSE_LEFT && s_button_pending == MOUSE_RIGHT)
768 || (button == MOUSE_RIGHT
769 && s_button_pending == MOUSE_LEFT)))
Bram Moolenaar071d4272004-06-13 20:20:40 +0000770 {
771 /*
772 * Hmm, gui.c will ignore more than one button down at a time, so
773 * pretend we let go of it first.
774 */
775 gui_send_mouse_event(MOUSE_RELEASE, x, y, FALSE, 0x0);
776 button = MOUSE_MIDDLE;
777 repeated_click = FALSE;
778 s_button_pending = -1;
779 _OnMouseEvent(button, x, y, repeated_click, keyFlags);
780 }
781 else if ((repeated_click)
782 || (mouse_model_popup() && (button == MOUSE_RIGHT)))
783 {
784 if (s_button_pending > -1)
785 {
786 _OnMouseEvent(s_button_pending, x, y, FALSE, keyFlags);
787 s_button_pending = -1;
788 }
789 /* TRACE("Button down at x %d, y %d\n", x, y); */
790 _OnMouseEvent(button, x, y, repeated_click, keyFlags);
791 }
792 else
793 {
794 /*
795 * If this is the first press (i.e. not a multiple click) don't
796 * action immediately, but store and wait for:
797 * i) button-up
798 * ii) mouse move
799 * iii) another button press
800 * before using it.
801 * This enables us to make left+right simulate middle button,
802 * without left or right being actioned first. The side-effect is
803 * that if you click and hold the mouse without dragging, the
804 * cursor doesn't move until you release the button. In practice
805 * this is hardly a problem.
806 */
807 s_button_pending = button;
808 s_x_pending = x;
809 s_y_pending = y;
810 s_kFlags_pending = keyFlags;
811 }
812
813 s_prevTime = currentTime;
814 }
815}
816
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +0000817/*ARGSUSED*/
Bram Moolenaar071d4272004-06-13 20:20:40 +0000818 static void
819_OnMouseMoveOrRelease(
820 HWND hwnd,
821 int x,
822 int y,
823 UINT keyFlags)
824{
825 int button;
826
Bram Moolenaarea408882007-12-03 21:21:03 +0000827 s_getting_focus = FALSE;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000828 if (s_button_pending > -1)
829 {
830 /* Delayed action for mouse down event */
831 _OnMouseEvent(s_button_pending, s_x_pending,
Bram Moolenaar293ee4d2004-12-09 21:34:53 +0000832 s_y_pending, FALSE, s_kFlags_pending);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000833 s_button_pending = -1;
834 }
835 if (s_uMsg == WM_MOUSEMOVE)
836 {
837 /*
838 * It's only a MOUSE_DRAG if one or more mouse buttons are being held
839 * down.
840 */
841 if (!(keyFlags & (MK_LBUTTON | MK_MBUTTON | MK_RBUTTON
842 | MK_XBUTTON1 | MK_XBUTTON2)))
843 {
844 gui_mouse_moved(x, y);
845 return;
846 }
847
848 /*
849 * While button is down, keep grabbing mouse move events when
850 * the mouse goes outside the window
851 */
852 SetCapture(s_textArea);
853 button = MOUSE_DRAG;
854 /* TRACE(" move at x %d, y %d\n", x, y); */
855 }
856 else
857 {
858 ReleaseCapture();
859 button = MOUSE_RELEASE;
860 /* TRACE(" up at x %d, y %d\n", x, y); */
861 }
862
863 _OnMouseEvent(button, x, y, FALSE, keyFlags);
864}
865
866#ifdef FEAT_MENU
867/*
868 * Find the vimmenu_T with the given id
869 */
870 static vimmenu_T *
871gui_mswin_find_menu(
872 vimmenu_T *pMenu,
873 int id)
874{
875 vimmenu_T *pChildMenu;
876
877 while (pMenu)
878 {
879 if (pMenu->id == (UINT)id)
880 break;
881 if (pMenu->children != NULL)
882 {
883 pChildMenu = gui_mswin_find_menu(pMenu->children, id);
884 if (pChildMenu)
885 {
886 pMenu = pChildMenu;
887 break;
888 }
889 }
890 pMenu = pMenu->next;
891 }
892 return pMenu;
893}
894
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +0000895/*ARGSUSED*/
Bram Moolenaar071d4272004-06-13 20:20:40 +0000896 static void
897_OnMenu(
898 HWND hwnd,
899 int id,
900 HWND hwndCtl,
901 UINT codeNotify)
902{
903 vimmenu_T *pMenu;
904
905 pMenu = gui_mswin_find_menu(root_menu, id);
906 if (pMenu)
907 gui_menu_cb(pMenu);
908}
909#endif
910
911#ifdef MSWIN_FIND_REPLACE
Bram Moolenaar3ca9a8a2009-01-28 20:23:17 +0000912# if defined(FEAT_MBYTE) && defined(WIN3264)
913/*
914 * copy useful data from structure LPFINDREPLACE to structure LPFINDREPLACEW
915 */
916 static void
917findrep_atow(LPFINDREPLACEW lpfrw, LPFINDREPLACE lpfr)
918{
919 WCHAR *wp;
920
921 lpfrw->hwndOwner = lpfr->hwndOwner;
922 lpfrw->Flags = lpfr->Flags;
923
924 wp = enc_to_utf16(lpfr->lpstrFindWhat, NULL);
925 wcsncpy(lpfrw->lpstrFindWhat, wp, lpfrw->wFindWhatLen - 1);
926 vim_free(wp);
927
928 /* the field "lpstrReplaceWith" doesn't need to be copied */
929}
930
931/*
932 * copy useful data from structure LPFINDREPLACEW to structure LPFINDREPLACE
933 */
934 static void
935findrep_wtoa(LPFINDREPLACE lpfr, LPFINDREPLACEW lpfrw)
936{
937 char_u *p;
938
939 lpfr->Flags = lpfrw->Flags;
940
941 p = utf16_to_enc(lpfrw->lpstrFindWhat, NULL);
942 vim_strncpy(lpfr->lpstrFindWhat, p, lpfr->wFindWhatLen - 1);
943 vim_free(p);
944
945 p = utf16_to_enc(lpfrw->lpstrReplaceWith, NULL);
946 vim_strncpy(lpfr->lpstrReplaceWith, p, lpfr->wReplaceWithLen - 1);
947 vim_free(p);
948}
949# endif
950
Bram Moolenaar071d4272004-06-13 20:20:40 +0000951/*
952 * Handle a Find/Replace window message.
953 */
954 static void
955_OnFindRepl(void)
956{
957 int flags = 0;
958 int down;
959
Bram Moolenaar3ca9a8a2009-01-28 20:23:17 +0000960# if defined(FEAT_MBYTE) && defined(WIN3264)
961 /* If the OS is Windows NT, and 'encoding' differs from active codepage:
962 * convert text from wide string. */
963 if (os_version.dwPlatformId == VER_PLATFORM_WIN32_NT
964 && enc_codepage >= 0 && (int)GetACP() != enc_codepage)
965 {
Bram Moolenaarcc448b32010-07-14 16:52:17 +0200966 findrep_wtoa(&s_findrep_struct, &s_findrep_struct_w);
Bram Moolenaar3ca9a8a2009-01-28 20:23:17 +0000967 }
968# endif
969
Bram Moolenaar071d4272004-06-13 20:20:40 +0000970 if (s_findrep_struct.Flags & FR_DIALOGTERM)
971 /* Give main window the focus back. */
972 (void)SetFocus(s_hwnd);
973
974 if (s_findrep_struct.Flags & FR_FINDNEXT)
975 {
976 flags = FRD_FINDNEXT;
977
978 /* Give main window the focus back: this is so the cursor isn't
979 * hollow. */
980 (void)SetFocus(s_hwnd);
981 }
982 else if (s_findrep_struct.Flags & FR_REPLACE)
983 {
984 flags = FRD_REPLACE;
985
986 /* Give main window the focus back: this is so the cursor isn't
987 * hollow. */
988 (void)SetFocus(s_hwnd);
989 }
990 else if (s_findrep_struct.Flags & FR_REPLACEALL)
991 {
992 flags = FRD_REPLACEALL;
993 }
994
995 if (flags != 0)
996 {
997 /* Call the generic GUI function to do the actual work. */
998 if (s_findrep_struct.Flags & FR_WHOLEWORD)
999 flags |= FRD_WHOLE_WORD;
1000 if (s_findrep_struct.Flags & FR_MATCHCASE)
1001 flags |= FRD_MATCH_CASE;
1002 down = (s_findrep_struct.Flags & FR_DOWN) != 0;
1003 gui_do_findrepl(flags, s_findrep_struct.lpstrFindWhat,
1004 s_findrep_struct.lpstrReplaceWith, down);
1005 }
1006}
1007#endif
1008
1009 static void
1010HandleMouseHide(UINT uMsg, LPARAM lParam)
1011{
1012 static LPARAM last_lParam = 0L;
1013
1014 /* We sometimes get a mousemove when the mouse didn't move... */
Bram Moolenaar268b55b2013-09-22 15:43:37 +02001015 if (uMsg == WM_MOUSEMOVE || uMsg == WM_NCMOUSEMOVE)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001016 {
1017 if (lParam == last_lParam)
1018 return;
1019 last_lParam = lParam;
1020 }
1021
1022 /* Handle specially, to centralise coding. We need to be sure we catch all
1023 * possible events which should cause us to restore the cursor (as it is a
1024 * shared resource, we take full responsibility for it).
1025 */
1026 switch (uMsg)
1027 {
1028 case WM_KEYUP:
1029 case WM_CHAR:
1030 /*
1031 * blank out the pointer if necessary
1032 */
1033 if (p_mh)
1034 gui_mch_mousehide(TRUE);
1035 break;
1036
1037 case WM_SYSKEYUP: /* show the pointer when a system-key is pressed */
1038 case WM_SYSCHAR:
1039 case WM_MOUSEMOVE: /* show the pointer on any mouse action */
1040 case WM_LBUTTONDOWN:
1041 case WM_LBUTTONUP:
1042 case WM_MBUTTONDOWN:
1043 case WM_MBUTTONUP:
1044 case WM_RBUTTONDOWN:
1045 case WM_RBUTTONUP:
1046 case WM_XBUTTONDOWN:
1047 case WM_XBUTTONUP:
1048 case WM_NCMOUSEMOVE:
1049 case WM_NCLBUTTONDOWN:
1050 case WM_NCLBUTTONUP:
1051 case WM_NCMBUTTONDOWN:
1052 case WM_NCMBUTTONUP:
1053 case WM_NCRBUTTONDOWN:
1054 case WM_NCRBUTTONUP:
1055 case WM_KILLFOCUS:
1056 /*
1057 * if the pointer is currently hidden, then we should show it.
1058 */
1059 gui_mch_mousehide(FALSE);
1060 break;
1061 }
1062}
1063
1064 static LRESULT CALLBACK
1065_TextAreaWndProc(
1066 HWND hwnd,
1067 UINT uMsg,
1068 WPARAM wParam,
1069 LPARAM lParam)
1070{
1071 /*
1072 TRACE("TextAreaWndProc: hwnd = %08x, msg = %x, wParam = %x, lParam = %x\n",
1073 hwnd, uMsg, wParam, lParam);
1074 */
1075
1076 HandleMouseHide(uMsg, lParam);
1077
1078 s_uMsg = uMsg;
1079 s_wParam = wParam;
1080 s_lParam = lParam;
1081
1082#ifdef FEAT_BEVAL
1083 TrackUserActivity(uMsg);
1084#endif
1085
1086 switch (uMsg)
1087 {
1088 HANDLE_MSG(hwnd, WM_LBUTTONDBLCLK,_OnMouseButtonDown);
1089 HANDLE_MSG(hwnd, WM_LBUTTONDOWN,_OnMouseButtonDown);
1090 HANDLE_MSG(hwnd, WM_LBUTTONUP, _OnMouseMoveOrRelease);
1091 HANDLE_MSG(hwnd, WM_MBUTTONDBLCLK,_OnMouseButtonDown);
1092 HANDLE_MSG(hwnd, WM_MBUTTONDOWN,_OnMouseButtonDown);
1093 HANDLE_MSG(hwnd, WM_MBUTTONUP, _OnMouseMoveOrRelease);
1094 HANDLE_MSG(hwnd, WM_MOUSEMOVE, _OnMouseMoveOrRelease);
1095 HANDLE_MSG(hwnd, WM_PAINT, _OnPaint);
1096 HANDLE_MSG(hwnd, WM_RBUTTONDBLCLK,_OnMouseButtonDown);
1097 HANDLE_MSG(hwnd, WM_RBUTTONDOWN,_OnMouseButtonDown);
1098 HANDLE_MSG(hwnd, WM_RBUTTONUP, _OnMouseMoveOrRelease);
1099#ifndef WIN16 /*<VN>*/
1100 HANDLE_MSG(hwnd, WM_XBUTTONDBLCLK,_OnMouseButtonDown);
1101 HANDLE_MSG(hwnd, WM_XBUTTONDOWN,_OnMouseButtonDown);
1102 HANDLE_MSG(hwnd, WM_XBUTTONUP, _OnMouseMoveOrRelease);
1103#endif
1104
1105#ifdef FEAT_BEVAL
1106 case WM_NOTIFY: Handle_WM_Notify(hwnd, (LPNMHDR)lParam);
1107 return TRUE;
1108#endif
Bram Moolenaar4d526ad2010-02-03 12:23:24 +01001109 default:
1110 return MyWindowProc(hwnd, uMsg, wParam, lParam);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001111 }
1112}
1113
1114#if (defined(WIN3264) && defined(FEAT_MBYTE)) \
1115 || defined(GLOBAL_IME) \
1116 || defined(PROTO)
1117# ifdef PROTO
1118typedef int WINAPI;
1119# endif
1120
1121 LRESULT WINAPI
1122vim_WindowProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
1123{
1124# ifdef GLOBAL_IME
1125 return global_ime_DefWindowProc(hwnd, message, wParam, lParam);
1126# else
1127 if (wide_WindowProc)
1128 return DefWindowProcW(hwnd, message, wParam, lParam);
1129 return DefWindowProc(hwnd, message, wParam, lParam);
1130#endif
1131}
1132#endif
1133
1134/*
1135 * Called when the foreground or background color has been changed.
1136 */
1137 void
1138gui_mch_new_colors(void)
1139{
1140 /* nothing to do? */
1141}
1142
1143/*
1144 * Set the colors to their default values.
1145 */
1146 void
Bram Moolenaar68c2f632016-01-30 17:24:07 +01001147gui_mch_def_colors(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001148{
1149 gui.norm_pixel = GetSysColor(COLOR_WINDOWTEXT);
1150 gui.back_pixel = GetSysColor(COLOR_WINDOW);
1151 gui.def_norm_pixel = gui.norm_pixel;
1152 gui.def_back_pixel = gui.back_pixel;
1153}
1154
1155/*
1156 * Open the GUI window which was created by a call to gui_mch_init().
1157 */
1158 int
1159gui_mch_open(void)
1160{
1161#ifndef SW_SHOWDEFAULT
1162# define SW_SHOWDEFAULT 10 /* Borland 5.0 doesn't have it */
1163#endif
1164 /* Actually open the window, if not already visible
1165 * (may be done already in gui_mch_set_shellsize) */
1166 if (!IsWindowVisible(s_hwnd))
1167 ShowWindow(s_hwnd, SW_SHOWDEFAULT);
1168
Bram Moolenaare2f98b92006-03-29 21:18:24 +00001169#ifdef MSWIN_FIND_REPLACE
1170 /* Init replace string here, so that we keep it when re-opening the
1171 * dialog. */
1172 s_findrep_struct.lpstrReplaceWith[0] = NUL;
1173#endif
1174
Bram Moolenaar071d4272004-06-13 20:20:40 +00001175 return OK;
1176}
1177
1178/*
1179 * Get the position of the top left corner of the window.
1180 */
1181 int
1182gui_mch_get_winpos(int *x, int *y)
1183{
1184 RECT rect;
1185
1186 GetWindowRect(s_hwnd, &rect);
1187 *x = rect.left;
1188 *y = rect.top;
1189 return OK;
1190}
1191
1192/*
1193 * Set the position of the top left corner of the window to the given
1194 * coordinates.
1195 */
1196 void
1197gui_mch_set_winpos(int x, int y)
1198{
1199 SetWindowPos(s_hwnd, NULL, x, y, 0, 0,
1200 SWP_NOZORDER | SWP_NOSIZE | SWP_NOACTIVATE);
1201}
1202 void
1203gui_mch_set_text_area_pos(int x, int y, int w, int h)
1204{
1205 static int oldx = 0;
1206 static int oldy = 0;
1207
1208 SetWindowPos(s_textArea, NULL, x, y, w, h, SWP_NOZORDER | SWP_NOACTIVATE);
1209
1210#ifdef FEAT_TOOLBAR
1211 if (vim_strchr(p_go, GO_TOOLBAR) != NULL)
1212 SendMessage(s_toolbarhwnd, WM_SIZE,
Bram Moolenaar5555acc2006-04-07 21:33:12 +00001213 (WPARAM)0, (LPARAM)(w + ((long)(TOOLBAR_BUTTON_HEIGHT+8)<<16)));
Bram Moolenaar071d4272004-06-13 20:20:40 +00001214#endif
Bram Moolenaar3991dab2006-03-27 17:01:56 +00001215#if defined(FEAT_GUI_TABLINE)
1216 if (showing_tabline)
1217 {
Bram Moolenaar2e2a2812006-03-27 20:55:21 +00001218 int top = 0;
Bram Moolenaarc6fe9192006-04-09 21:54:49 +00001219 RECT rect;
Bram Moolenaar3991dab2006-03-27 17:01:56 +00001220
Bram Moolenaar551dbcc2006-04-25 22:13:59 +00001221# ifdef FEAT_TOOLBAR
Bram Moolenaar3991dab2006-03-27 17:01:56 +00001222 if (vim_strchr(p_go, GO_TOOLBAR) != NULL)
1223 top = TOOLBAR_BUTTON_HEIGHT + TOOLBAR_BORDER_HEIGHT;
Bram Moolenaar551dbcc2006-04-25 22:13:59 +00001224# endif
Bram Moolenaar5555acc2006-04-07 21:33:12 +00001225 GetClientRect(s_hwnd, &rect);
Bram Moolenaar551dbcc2006-04-25 22:13:59 +00001226 MoveWindow(s_tabhwnd, 0, top, rect.right, gui.tabline_height, TRUE);
Bram Moolenaar3991dab2006-03-27 17:01:56 +00001227 }
1228#endif
1229
Bram Moolenaar071d4272004-06-13 20:20:40 +00001230 /* When side scroll bar is unshown, the size of window will change.
1231 * then, the text area move left or right. thus client rect should be
Bram Moolenaar84a05ac2013-05-06 04:24:17 +02001232 * forcedly redrawn. (Yasuhiro Matsumoto) */
Bram Moolenaar071d4272004-06-13 20:20:40 +00001233 if (oldx != x || oldy != y)
1234 {
1235 InvalidateRect(s_hwnd, NULL, FALSE);
1236 oldx = x;
1237 oldy = y;
1238 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00001239}
1240
1241
1242/*
1243 * Scrollbar stuff:
1244 */
1245
1246 void
1247gui_mch_enable_scrollbar(
1248 scrollbar_T *sb,
1249 int flag)
1250{
1251 ShowScrollBar(sb->id, SB_CTL, flag);
1252
1253 /* TODO: When the window is maximized, the size of the window stays the
1254 * same, thus the size of the text area changes. On Win98 it's OK, on Win
1255 * NT 4.0 it's not... */
1256}
1257
1258 void
1259gui_mch_set_scrollbar_pos(
1260 scrollbar_T *sb,
1261 int x,
1262 int y,
1263 int w,
1264 int h)
1265{
Bram Moolenaar02743632005-07-25 20:42:36 +00001266 SetWindowPos(sb->id, NULL, x, y, w, h,
1267 SWP_NOZORDER | SWP_NOACTIVATE | SWP_SHOWWINDOW);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001268}
1269
1270 void
1271gui_mch_create_scrollbar(
1272 scrollbar_T *sb,
1273 int orient) /* SBAR_VERT or SBAR_HORIZ */
1274{
1275 sb->id = CreateWindow(
1276 "SCROLLBAR", "Scrollbar",
1277 WS_CHILD | ((orient == SBAR_VERT) ? SBS_VERT : SBS_HORZ), 0, 0,
1278 10, /* Any value will do for now */
1279 10, /* Any value will do for now */
1280 s_hwnd, NULL,
1281 s_hinst, NULL);
1282}
1283
1284/*
1285 * Find the scrollbar with the given hwnd.
1286 */
1287 static scrollbar_T *
1288gui_mswin_find_scrollbar(HWND hwnd)
1289{
1290 win_T *wp;
1291
1292 if (gui.bottom_sbar.id == hwnd)
1293 return &gui.bottom_sbar;
1294 FOR_ALL_WINDOWS(wp)
1295 {
1296 if (wp->w_scrollbars[SBAR_LEFT].id == hwnd)
1297 return &wp->w_scrollbars[SBAR_LEFT];
1298 if (wp->w_scrollbars[SBAR_RIGHT].id == hwnd)
1299 return &wp->w_scrollbars[SBAR_RIGHT];
1300 }
1301 return NULL;
1302}
1303
1304/*
1305 * Get the character size of a font.
1306 */
1307 static void
1308GetFontSize(GuiFont font)
1309{
1310 HWND hwnd = GetDesktopWindow();
1311 HDC hdc = GetWindowDC(hwnd);
1312 HFONT hfntOld = SelectFont(hdc, (HFONT)font);
1313 TEXTMETRIC tm;
1314
1315 GetTextMetrics(hdc, &tm);
1316 gui.char_width = tm.tmAveCharWidth + tm.tmOverhang;
1317
1318 gui.char_height = tm.tmHeight
1319#ifndef MSWIN16_FASTTEXT
Bram Moolenaar02743632005-07-25 20:42:36 +00001320 + p_linespace
Bram Moolenaar071d4272004-06-13 20:20:40 +00001321#endif
Bram Moolenaar02743632005-07-25 20:42:36 +00001322 ;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001323
1324 SelectFont(hdc, hfntOld);
1325
1326 ReleaseDC(hwnd, hdc);
1327}
1328
Bram Moolenaar02743632005-07-25 20:42:36 +00001329/*
1330 * Adjust gui.char_height (after 'linespace' was changed).
1331 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00001332 int
Bram Moolenaar02743632005-07-25 20:42:36 +00001333gui_mch_adjust_charheight(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001334{
1335 GetFontSize(gui.norm_font);
1336 return OK;
1337}
1338
1339 static GuiFont
1340get_font_handle(LOGFONT *lf)
1341{
1342 HFONT font = NULL;
1343
1344 /* Load the font */
1345 font = CreateFontIndirect(lf);
1346
1347 if (font == NULL)
1348 return NOFONT;
1349
1350 return (GuiFont)font;
1351}
1352
1353 static int
1354pixels_to_points(int pixels, int vertical)
1355{
1356 int points;
1357 HWND hwnd;
1358 HDC hdc;
1359
1360 hwnd = GetDesktopWindow();
1361 hdc = GetWindowDC(hwnd);
1362
1363 points = MulDiv(pixels, 72,
1364 GetDeviceCaps(hdc, vertical ? LOGPIXELSY : LOGPIXELSX));
1365
1366 ReleaseDC(hwnd, hdc);
1367
1368 return points;
1369}
1370
1371 GuiFont
1372gui_mch_get_font(
1373 char_u *name,
1374 int giveErrorIfMissing)
1375{
1376 LOGFONT lf;
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00001377 GuiFont font = NOFONT;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001378
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00001379 if (get_logfont(&lf, name, NULL, giveErrorIfMissing) == OK)
1380 font = get_font_handle(&lf);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001381 if (font == NOFONT && giveErrorIfMissing)
1382 EMSG2(_(e_font), name);
1383 return font;
1384}
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00001385
Bram Moolenaardfccaf02004-12-31 20:56:11 +00001386#if defined(FEAT_EVAL) || defined(PROTO)
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00001387/*
1388 * Return the name of font "font" in allocated memory.
1389 * Don't know how to get the actual name, thus use the provided name.
1390 */
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00001391/*ARGSUSED*/
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00001392 char_u *
Bram Moolenaar68c2f632016-01-30 17:24:07 +01001393gui_mch_get_fontname(GuiFont font, char_u *name)
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00001394{
1395 if (name == NULL)
1396 return NULL;
1397 return vim_strsave(name);
1398}
Bram Moolenaardfccaf02004-12-31 20:56:11 +00001399#endif
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00001400
Bram Moolenaar071d4272004-06-13 20:20:40 +00001401 void
1402gui_mch_free_font(GuiFont font)
1403{
1404 if (font)
1405 DeleteObject((HFONT)font);
1406}
1407
1408 static int
1409hex_digit(int c)
1410{
1411 if (VIM_ISDIGIT(c))
1412 return c - '0';
1413 c = TOLOWER_ASC(c);
1414 if (c >= 'a' && c <= 'f')
1415 return c - 'a' + 10;
1416 return -1000;
1417}
1418/*
1419 * Return the Pixel value (color) for the given color name.
1420 * Return INVALCOLOR for error.
1421 */
1422 guicolor_T
1423gui_mch_get_color(char_u *name)
1424{
1425 typedef struct guicolor_tTable
1426 {
1427 char *name;
1428 COLORREF color;
1429 } guicolor_tTable;
1430
1431 static guicolor_tTable table[] =
1432 {
1433 {"Black", RGB(0x00, 0x00, 0x00)},
Bram Moolenaar092e3c82011-09-07 18:58:29 +02001434 {"DarkGray", RGB(0xA9, 0xA9, 0xA9)},
1435 {"DarkGrey", RGB(0xA9, 0xA9, 0xA9)},
Bram Moolenaar071d4272004-06-13 20:20:40 +00001436 {"Gray", RGB(0xC0, 0xC0, 0xC0)},
1437 {"Grey", RGB(0xC0, 0xC0, 0xC0)},
Bram Moolenaar092e3c82011-09-07 18:58:29 +02001438 {"LightGray", RGB(0xD3, 0xD3, 0xD3)},
1439 {"LightGrey", RGB(0xD3, 0xD3, 0xD3)},
Bram Moolenaarb21e5842006-04-16 18:30:08 +00001440 {"Gray10", RGB(0x1A, 0x1A, 0x1A)},
1441 {"Grey10", RGB(0x1A, 0x1A, 0x1A)},
1442 {"Gray20", RGB(0x33, 0x33, 0x33)},
1443 {"Grey20", RGB(0x33, 0x33, 0x33)},
1444 {"Gray30", RGB(0x4D, 0x4D, 0x4D)},
1445 {"Grey30", RGB(0x4D, 0x4D, 0x4D)},
1446 {"Gray40", RGB(0x66, 0x66, 0x66)},
1447 {"Grey40", RGB(0x66, 0x66, 0x66)},
1448 {"Gray50", RGB(0x7F, 0x7F, 0x7F)},
1449 {"Grey50", RGB(0x7F, 0x7F, 0x7F)},
1450 {"Gray60", RGB(0x99, 0x99, 0x99)},
1451 {"Grey60", RGB(0x99, 0x99, 0x99)},
1452 {"Gray70", RGB(0xB3, 0xB3, 0xB3)},
1453 {"Grey70", RGB(0xB3, 0xB3, 0xB3)},
1454 {"Gray80", RGB(0xCC, 0xCC, 0xCC)},
1455 {"Grey80", RGB(0xCC, 0xCC, 0xCC)},
Bram Moolenaare2f98b92006-03-29 21:18:24 +00001456 {"Gray90", RGB(0xE5, 0xE5, 0xE5)},
1457 {"Grey90", RGB(0xE5, 0xE5, 0xE5)},
Bram Moolenaar071d4272004-06-13 20:20:40 +00001458 {"White", RGB(0xFF, 0xFF, 0xFF)},
1459 {"DarkRed", RGB(0x80, 0x00, 0x00)},
1460 {"Red", RGB(0xFF, 0x00, 0x00)},
1461 {"LightRed", RGB(0xFF, 0xA0, 0xA0)},
1462 {"DarkBlue", RGB(0x00, 0x00, 0x80)},
1463 {"Blue", RGB(0x00, 0x00, 0xFF)},
Bram Moolenaar092e3c82011-09-07 18:58:29 +02001464 {"LightBlue", RGB(0xAD, 0xD8, 0xE6)},
Bram Moolenaar071d4272004-06-13 20:20:40 +00001465 {"DarkGreen", RGB(0x00, 0x80, 0x00)},
1466 {"Green", RGB(0x00, 0xFF, 0x00)},
Bram Moolenaar092e3c82011-09-07 18:58:29 +02001467 {"LightGreen", RGB(0x90, 0xEE, 0x90)},
Bram Moolenaar071d4272004-06-13 20:20:40 +00001468 {"DarkCyan", RGB(0x00, 0x80, 0x80)},
1469 {"Cyan", RGB(0x00, 0xFF, 0xFF)},
Bram Moolenaar092e3c82011-09-07 18:58:29 +02001470 {"LightCyan", RGB(0xE0, 0xFF, 0xFF)},
Bram Moolenaar071d4272004-06-13 20:20:40 +00001471 {"DarkMagenta", RGB(0x80, 0x00, 0x80)},
1472 {"Magenta", RGB(0xFF, 0x00, 0xFF)},
1473 {"LightMagenta", RGB(0xFF, 0xA0, 0xFF)},
1474 {"Brown", RGB(0x80, 0x40, 0x40)},
1475 {"Yellow", RGB(0xFF, 0xFF, 0x00)},
Bram Moolenaar092e3c82011-09-07 18:58:29 +02001476 {"LightYellow", RGB(0xFF, 0xFF, 0xE0)},
Bram Moolenaar071d4272004-06-13 20:20:40 +00001477 {"DarkYellow", RGB(0xBB, 0xBB, 0x00)},
1478 {"SeaGreen", RGB(0x2E, 0x8B, 0x57)},
1479 {"Orange", RGB(0xFF, 0xA5, 0x00)},
1480 {"Purple", RGB(0xA0, 0x20, 0xF0)},
1481 {"SlateBlue", RGB(0x6A, 0x5A, 0xCD)},
1482 {"Violet", RGB(0xEE, 0x82, 0xEE)},
1483 };
1484
1485 typedef struct SysColorTable
1486 {
1487 char *name;
1488 int color;
1489 } SysColorTable;
1490
1491 static SysColorTable sys_table[] =
1492 {
1493#ifdef WIN3264
1494 {"SYS_3DDKSHADOW", COLOR_3DDKSHADOW},
1495 {"SYS_3DHILIGHT", COLOR_3DHILIGHT},
1496#ifndef __MINGW32__
1497 {"SYS_3DHIGHLIGHT", COLOR_3DHIGHLIGHT},
1498#endif
1499 {"SYS_BTNHILIGHT", COLOR_BTNHILIGHT},
1500 {"SYS_BTNHIGHLIGHT", COLOR_BTNHIGHLIGHT},
1501 {"SYS_3DLIGHT", COLOR_3DLIGHT},
1502 {"SYS_3DSHADOW", COLOR_3DSHADOW},
1503 {"SYS_DESKTOP", COLOR_DESKTOP},
1504 {"SYS_INFOBK", COLOR_INFOBK},
1505 {"SYS_INFOTEXT", COLOR_INFOTEXT},
1506 {"SYS_3DFACE", COLOR_3DFACE},
1507#endif
1508 {"SYS_BTNFACE", COLOR_BTNFACE},
1509 {"SYS_BTNSHADOW", COLOR_BTNSHADOW},
1510 {"SYS_ACTIVEBORDER", COLOR_ACTIVEBORDER},
1511 {"SYS_ACTIVECAPTION", COLOR_ACTIVECAPTION},
1512 {"SYS_APPWORKSPACE", COLOR_APPWORKSPACE},
1513 {"SYS_BACKGROUND", COLOR_BACKGROUND},
1514 {"SYS_BTNTEXT", COLOR_BTNTEXT},
1515 {"SYS_CAPTIONTEXT", COLOR_CAPTIONTEXT},
1516 {"SYS_GRAYTEXT", COLOR_GRAYTEXT},
1517 {"SYS_HIGHLIGHT", COLOR_HIGHLIGHT},
1518 {"SYS_HIGHLIGHTTEXT", COLOR_HIGHLIGHTTEXT},
1519 {"SYS_INACTIVEBORDER", COLOR_INACTIVEBORDER},
1520 {"SYS_INACTIVECAPTION", COLOR_INACTIVECAPTION},
1521 {"SYS_INACTIVECAPTIONTEXT", COLOR_INACTIVECAPTIONTEXT},
1522 {"SYS_MENU", COLOR_MENU},
1523 {"SYS_MENUTEXT", COLOR_MENUTEXT},
1524 {"SYS_SCROLLBAR", COLOR_SCROLLBAR},
1525 {"SYS_WINDOW", COLOR_WINDOW},
1526 {"SYS_WINDOWFRAME", COLOR_WINDOWFRAME},
1527 {"SYS_WINDOWTEXT", COLOR_WINDOWTEXT}
1528 };
1529
1530 int r, g, b;
1531 int i;
1532
1533 if (name[0] == '#' && strlen(name) == 7)
1534 {
1535 /* Name is in "#rrggbb" format */
1536 r = hex_digit(name[1]) * 16 + hex_digit(name[2]);
1537 g = hex_digit(name[3]) * 16 + hex_digit(name[4]);
1538 b = hex_digit(name[5]) * 16 + hex_digit(name[6]);
1539 if (r < 0 || g < 0 || b < 0)
1540 return INVALCOLOR;
1541 return RGB(r, g, b);
1542 }
1543 else
1544 {
1545 /* Check if the name is one of the colors we know */
1546 for (i = 0; i < sizeof(table) / sizeof(table[0]); i++)
1547 if (STRICMP(name, table[i].name) == 0)
1548 return table[i].color;
1549 }
1550
1551 /*
1552 * Try to look up a system colour.
1553 */
1554 for (i = 0; i < sizeof(sys_table) / sizeof(sys_table[0]); i++)
1555 if (STRICMP(name, sys_table[i].name) == 0)
1556 return GetSysColor(sys_table[i].color);
1557
1558 /*
1559 * Last attempt. Look in the file "$VIMRUNTIME/rgb.txt".
1560 */
1561 {
1562#define LINE_LEN 100
1563 FILE *fd;
1564 char line[LINE_LEN];
1565 char_u *fname;
1566
1567 fname = expand_env_save((char_u *)"$VIMRUNTIME/rgb.txt");
1568 if (fname == NULL)
1569 return INVALCOLOR;
1570
Bram Moolenaar5555acc2006-04-07 21:33:12 +00001571 fd = mch_fopen((char *)fname, "rt");
Bram Moolenaar071d4272004-06-13 20:20:40 +00001572 vim_free(fname);
1573 if (fd == NULL)
1574 return INVALCOLOR;
1575
1576 while (!feof(fd))
1577 {
1578 int len;
1579 int pos;
1580 char *color;
1581
1582 fgets(line, LINE_LEN, fd);
1583 len = (int)STRLEN(line);
1584
1585 if (len <= 1 || line[len-1] != '\n')
1586 continue;
1587
1588 line[len-1] = '\0';
1589
1590 i = sscanf(line, "%d %d %d %n", &r, &g, &b, &pos);
1591 if (i != 3)
1592 continue;
1593
1594 color = line + pos;
1595
1596 if (STRICMP(color, name) == 0)
1597 {
1598 fclose(fd);
1599 return (guicolor_T) RGB(r, g, b);
1600 }
1601 }
1602
1603 fclose(fd);
1604 }
1605
1606 return INVALCOLOR;
1607}
1608/*
1609 * Return OK if the key with the termcap name "name" is supported.
1610 */
1611 int
1612gui_mch_haskey(char_u *name)
1613{
1614 int i;
1615
1616 for (i = 0; special_keys[i].vim_code1 != NUL; i++)
1617 if (name[0] == special_keys[i].vim_code0 &&
1618 name[1] == special_keys[i].vim_code1)
1619 return OK;
1620 return FAIL;
1621}
1622
1623 void
1624gui_mch_beep(void)
1625{
1626 MessageBeep(MB_OK);
1627}
1628/*
1629 * Invert a rectangle from row r, column c, for nr rows and nc columns.
1630 */
1631 void
1632gui_mch_invert_rectangle(
1633 int r,
1634 int c,
1635 int nr,
1636 int nc)
1637{
1638 RECT rc;
1639
1640 /*
1641 * Note: InvertRect() excludes right and bottom of rectangle.
1642 */
1643 rc.left = FILL_X(c);
1644 rc.top = FILL_Y(r);
1645 rc.right = rc.left + nc * gui.char_width;
1646 rc.bottom = rc.top + nr * gui.char_height;
1647 InvertRect(s_hdc, &rc);
1648}
1649
1650/*
1651 * Iconify the GUI window.
1652 */
1653 void
1654gui_mch_iconify(void)
1655{
1656 ShowWindow(s_hwnd, SW_MINIMIZE);
1657}
1658
1659/*
1660 * Draw a cursor without focus.
1661 */
1662 void
1663gui_mch_draw_hollow_cursor(guicolor_T color)
1664{
1665 HBRUSH hbr;
1666 RECT rc;
1667
1668 /*
1669 * Note: FrameRect() excludes right and bottom of rectangle.
1670 */
1671 rc.left = FILL_X(gui.col);
1672 rc.top = FILL_Y(gui.row);
1673 rc.right = rc.left + gui.char_width;
1674#ifdef FEAT_MBYTE
1675 if (mb_lefthalve(gui.row, gui.col))
1676 rc.right += gui.char_width;
1677#endif
1678 rc.bottom = rc.top + gui.char_height;
1679 hbr = CreateSolidBrush(color);
1680 FrameRect(s_hdc, &rc, hbr);
1681 DeleteBrush(hbr);
1682}
1683/*
1684 * Draw part of a cursor, "w" pixels wide, and "h" pixels high, using
1685 * color "color".
1686 */
1687 void
1688gui_mch_draw_part_cursor(
1689 int w,
1690 int h,
1691 guicolor_T color)
1692{
1693 HBRUSH hbr;
1694 RECT rc;
1695
1696 /*
1697 * Note: FillRect() excludes right and bottom of rectangle.
1698 */
1699 rc.left =
1700#ifdef FEAT_RIGHTLEFT
1701 /* vertical line should be on the right of current point */
1702 CURSOR_BAR_RIGHT ? FILL_X(gui.col + 1) - w :
1703#endif
1704 FILL_X(gui.col);
1705 rc.top = FILL_Y(gui.row) + gui.char_height - h;
1706 rc.right = rc.left + w;
1707 rc.bottom = rc.top + h;
1708 hbr = CreateSolidBrush(color);
1709 FillRect(s_hdc, &rc, hbr);
1710 DeleteBrush(hbr);
1711}
1712
Bram Moolenaar25b2b942016-01-17 20:53:12 +01001713
1714/*
1715 * Generates a VK_SPACE when the internal dead_key flag is set to output the
1716 * dead key's nominal character and re-post the original message.
1717 */
1718 static void
1719outputDeadKey_rePost(MSG originalMsg)
1720{
1721 static MSG deadCharExpel;
1722
1723 if (!dead_key)
1724 return;
1725
1726 dead_key = 0;
1727
1728 /* Make Windows generate the dead key's character */
1729 deadCharExpel.message = originalMsg.message;
1730 deadCharExpel.hwnd = originalMsg.hwnd;
1731 deadCharExpel.wParam = VK_SPACE;
1732
1733 MyTranslateMessage(&deadCharExpel);
1734
1735 /* re-generate the current character free of the dead char influence */
1736 PostMessage(originalMsg.hwnd, originalMsg.message, originalMsg.wParam,
1737 originalMsg.lParam);
1738}
1739
1740
Bram Moolenaar071d4272004-06-13 20:20:40 +00001741/*
1742 * Process a single Windows message.
1743 * If one is not available we hang until one is.
1744 */
1745 static void
1746process_message(void)
1747{
1748 MSG msg;
1749 UINT vk = 0; /* Virtual key */
1750 char_u string[40];
1751 int i;
1752 int modifiers = 0;
1753 int key;
Bram Moolenaar293ee4d2004-12-09 21:34:53 +00001754#ifdef FEAT_MENU
1755 static char_u k10[] = {K_SPECIAL, 'k', ';', 0};
1756#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00001757
Bram Moolenaar8c85fa32011-08-10 17:08:03 +02001758 pGetMessage(&msg, NULL, 0, 0);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001759
1760#ifdef FEAT_OLE
1761 /* Look after OLE Automation commands */
1762 if (msg.message == WM_OLE)
1763 {
1764 char_u *str = (char_u *)msg.lParam;
Bram Moolenaar370feaf2009-01-28 13:18:26 +00001765 if (str == NULL || *str == NUL)
1766 {
1767 /* Message can't be ours, forward it. Fixes problem with Ultramon
1768 * 3.0.4 */
Bram Moolenaar8c85fa32011-08-10 17:08:03 +02001769 pDispatchMessage(&msg);
Bram Moolenaar370feaf2009-01-28 13:18:26 +00001770 }
1771 else
1772 {
1773 add_to_input_buf(str, (int)STRLEN(str));
1774 vim_free(str); /* was allocated in CVim::SendKeys() */
1775 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00001776 return;
1777 }
1778#endif
1779
Bram Moolenaard04a0202016-01-26 23:30:18 +01001780#ifdef FEAT_CHANNEL
Bram Moolenaar071d4272004-06-13 20:20:40 +00001781 if (msg.message == WM_NETBEANS)
1782 {
Bram Moolenaar7b3ca762016-02-14 19:13:43 +01001783 int what;
1784 channel_T *channel = channel_fd2channel((sock_T)msg.wParam, &what);
Bram Moolenaar85be35f2016-01-27 21:08:18 +01001785
Bram Moolenaar77073442016-02-13 23:23:53 +01001786 if (channel != NULL)
Bram Moolenaarbfa1ffc2016-02-13 18:40:30 +01001787 {
1788 /* Disable error messages, they can mess up the display and throw
1789 * an exception. */
1790 ++emsg_off;
Bram Moolenaar7b3ca762016-02-14 19:13:43 +01001791 channel_read(channel, what, "process_message");
Bram Moolenaarbfa1ffc2016-02-13 18:40:30 +01001792 --emsg_off;
1793 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00001794 return;
1795 }
1796#endif
1797
1798#ifdef FEAT_SNIFF
1799 if (sniff_request_waiting && want_sniff_request)
1800 {
1801 static char_u bytes[3] = {CSI, (char_u)KS_EXTRA, (char_u)KE_SNIFF};
1802 add_to_input_buf(bytes, 3); /* K_SNIFF */
1803 sniff_request_waiting = 0;
1804 want_sniff_request = 0;
1805 /* request is handled in normal.c */
1806 }
1807 if (msg.message == WM_USER)
Bram Moolenaar35c92912006-06-22 17:34:26 +00001808 {
Bram Moolenaard8a92d72006-06-23 14:44:06 +00001809 MyTranslateMessage(&msg);
Bram Moolenaar8c85fa32011-08-10 17:08:03 +02001810 pDispatchMessage(&msg);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001811 return;
Bram Moolenaar35c92912006-06-22 17:34:26 +00001812 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00001813#endif
1814
1815#ifdef MSWIN_FIND_REPLACE
1816 /* Don't process messages used by the dialog */
Bram Moolenaar8c85fa32011-08-10 17:08:03 +02001817 if (s_findrep_hwnd != NULL && pIsDialogMessage(s_findrep_hwnd, &msg))
Bram Moolenaar071d4272004-06-13 20:20:40 +00001818 {
1819 HandleMouseHide(msg.message, msg.lParam);
1820 return;
1821 }
1822#endif
1823
1824 /*
1825 * Check if it's a special key that we recognise. If not, call
1826 * TranslateMessage().
1827 */
1828 if (msg.message == WM_KEYDOWN || msg.message == WM_SYSKEYDOWN)
1829 {
1830 vk = (int) msg.wParam;
Bram Moolenaar25b2b942016-01-17 20:53:12 +01001831
Bram Moolenaard2e80872014-08-22 18:44:33 +02001832 /*
Bram Moolenaar25b2b942016-01-17 20:53:12 +01001833 * Handle dead keys in special conditions in other cases we let Windows
1834 * handle them and do not interfere.
Bram Moolenaard2e80872014-08-22 18:44:33 +02001835 *
Bram Moolenaar25b2b942016-01-17 20:53:12 +01001836 * The dead_key flag must be reset on several occasions:
1837 * - in _OnChar() (or _OnSysChar()) as any dead key was necessarily
1838 * consumed at that point (This is when we let Windows combine the
1839 * dead character on its own)
1840 *
1841 * - Before doing something special such as regenerating keypresses to
1842 * expel the dead character as this could trigger an infinite loop if
1843 * for some reason MyTranslateMessage() do not trigger a call
1844 * immediately to _OnChar() (or _OnSysChar()).
Bram Moolenaard2e80872014-08-22 18:44:33 +02001845 */
Bram Moolenaar25b2b942016-01-17 20:53:12 +01001846 if (dead_key)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001847 {
Bram Moolenaar25b2b942016-01-17 20:53:12 +01001848 /*
1849 * If a dead key was pressed and the user presses VK_SPACE,
1850 * VK_BACK, or VK_ESCAPE it means that he actually wants to deal
1851 * with the dead char now, so do nothing special and let Windows
1852 * handle it.
1853 *
1854 * Note that VK_SPACE combines with the dead_key's character and
1855 * only one WM_CHAR will be generated by TranslateMessage(), in
1856 * the two other cases two WM_CHAR will be generated: the dead
1857 * char and VK_BACK or VK_ESCAPE. That is most likely what the
1858 * user expects.
1859 */
1860 if ((vk == VK_SPACE || vk == VK_BACK || vk == VK_ESCAPE))
1861 {
1862 dead_key = 0;
1863 MyTranslateMessage(&msg);
1864 return;
1865 }
1866 /* In modes where we are not typing, dead keys should behave
1867 * normally */
1868 else if (!(get_real_state() & (INSERT | CMDLINE | SELECTMODE)))
1869 {
1870 outputDeadKey_rePost(msg);
1871 return;
1872 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00001873 }
1874
1875 /* Check for CTRL-BREAK */
1876 if (vk == VK_CANCEL)
1877 {
1878 trash_input_buf();
1879 got_int = TRUE;
1880 string[0] = Ctrl_C;
1881 add_to_input_buf(string, 1);
1882 }
1883
1884 for (i = 0; special_keys[i].key_sym != 0; i++)
1885 {
1886 /* ignore VK_SPACE when ALT key pressed: system menu */
1887 if (special_keys[i].key_sym == vk
1888 && (vk != VK_SPACE || !(GetKeyState(VK_MENU) & 0x8000)))
1889 {
Bram Moolenaar25b2b942016-01-17 20:53:12 +01001890 /*
1891 * Behave as exected if we have a dead key and the special key
1892 * is a key that would normally trigger the dead key nominal
1893 * character output (such as a NUMPAD printable character or
1894 * the TAB key, etc...).
1895 */
1896 if (dead_key && (special_keys[i].vim_code0 == 'K'
1897 || vk == VK_TAB || vk == CAR))
1898 {
1899 outputDeadKey_rePost(msg);
1900 return;
1901 }
1902
Bram Moolenaar071d4272004-06-13 20:20:40 +00001903#ifdef FEAT_MENU
Bram Moolenaar293ee4d2004-12-09 21:34:53 +00001904 /* Check for <F10>: Windows selects the menu. When <F10> is
1905 * mapped we want to use the mapping instead. */
Bram Moolenaar071d4272004-06-13 20:20:40 +00001906 if (vk == VK_F10
1907 && gui.menu_is_active
Bram Moolenaarbd743252010-10-20 21:23:33 +02001908 && check_map(k10, State, FALSE, TRUE, FALSE,
1909 NULL, NULL) == NULL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001910 break;
1911#endif
1912 if (GetKeyState(VK_SHIFT) & 0x8000)
1913 modifiers |= MOD_MASK_SHIFT;
1914 /*
1915 * Don't use caps-lock as shift, because these are special keys
1916 * being considered here, and we only want letters to get
1917 * shifted -- webb
1918 */
1919 /*
1920 if (GetKeyState(VK_CAPITAL) & 0x0001)
1921 modifiers ^= MOD_MASK_SHIFT;
1922 */
1923 if (GetKeyState(VK_CONTROL) & 0x8000)
1924 modifiers |= MOD_MASK_CTRL;
1925 if (GetKeyState(VK_MENU) & 0x8000)
1926 modifiers |= MOD_MASK_ALT;
1927
1928 if (special_keys[i].vim_code1 == NUL)
1929 key = special_keys[i].vim_code0;
1930 else
1931 key = TO_SPECIAL(special_keys[i].vim_code0,
1932 special_keys[i].vim_code1);
1933 key = simplify_key(key, &modifiers);
1934 if (key == CSI)
1935 key = K_CSI;
1936
1937 if (modifiers)
1938 {
1939 string[0] = CSI;
1940 string[1] = KS_MODIFIER;
1941 string[2] = modifiers;
1942 add_to_input_buf(string, 3);
1943 }
1944
1945 if (IS_SPECIAL(key))
1946 {
1947 string[0] = CSI;
1948 string[1] = K_SECOND(key);
1949 string[2] = K_THIRD(key);
1950 add_to_input_buf(string, 3);
1951 }
1952 else
1953 {
1954 int len;
1955
1956 /* Handle "key" as a Unicode character. */
Bram Moolenaar85a3e5c2007-11-20 16:22:16 +00001957 len = char_to_string(key, string, 40, FALSE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001958 add_to_input_buf(string, len);
1959 }
1960 break;
1961 }
1962 }
1963 if (special_keys[i].key_sym == 0)
1964 {
1965 /* Some keys need C-S- where they should only need C-.
1966 * Ignore 0xff, Windows XP sends it when NUMLOCK has changed since
1967 * system startup (Helmut Stiegler, 2003 Oct 3). */
1968 if (vk != 0xff
1969 && (GetKeyState(VK_CONTROL) & 0x8000)
1970 && !(GetKeyState(VK_SHIFT) & 0x8000)
1971 && !(GetKeyState(VK_MENU) & 0x8000))
1972 {
1973 /* CTRL-6 is '^'; Japanese keyboard maps '^' to vk == 0xDE */
1974 if (vk == '6' || MapVirtualKey(vk, 2) == (UINT)'^')
1975 {
1976 string[0] = Ctrl_HAT;
1977 add_to_input_buf(string, 1);
1978 }
1979 /* vk == 0xBD AZERTY for CTRL-'-', but CTRL-[ for * QWERTY! */
1980 else if (vk == 0xBD) /* QWERTY for CTRL-'-' */
1981 {
1982 string[0] = Ctrl__;
1983 add_to_input_buf(string, 1);
1984 }
1985 /* CTRL-2 is '@'; Japanese keyboard maps '@' to vk == 0xC0 */
1986 else if (vk == '2' || MapVirtualKey(vk, 2) == (UINT)'@')
1987 {
1988 string[0] = Ctrl_AT;
1989 add_to_input_buf(string, 1);
1990 }
1991 else
1992 MyTranslateMessage(&msg);
1993 }
1994 else
1995 MyTranslateMessage(&msg);
1996 }
1997 }
1998#ifdef FEAT_MBYTE_IME
1999 else if (msg.message == WM_IME_NOTIFY)
2000 _OnImeNotify(msg.hwnd, (DWORD)msg.wParam, (DWORD)msg.lParam);
2001 else if (msg.message == WM_KEYUP && im_get_status())
2002 /* added for non-MS IME (Yasuhiro Matsumoto) */
2003 MyTranslateMessage(&msg);
2004#endif
2005#if !defined(FEAT_MBYTE_IME) && defined(GLOBAL_IME)
2006/* GIME_TEST */
2007 else if (msg.message == WM_IME_STARTCOMPOSITION)
2008 {
2009 POINT point;
2010
2011 global_ime_set_font(&norm_logfont);
2012 point.x = FILL_X(gui.col);
2013 point.y = FILL_Y(gui.row);
2014 MapWindowPoints(s_textArea, s_hwnd, &point, 1);
2015 global_ime_set_position(&point);
2016 }
2017#endif
2018
2019#ifdef FEAT_MENU
Bram Moolenaar293ee4d2004-12-09 21:34:53 +00002020 /* Check for <F10>: Default effect is to select the menu. When <F10> is
2021 * mapped we need to stop it here to avoid strange effects (e.g., for the
2022 * key-up event) */
Bram Moolenaarbd743252010-10-20 21:23:33 +02002023 if (vk != VK_F10 || check_map(k10, State, FALSE, TRUE, FALSE,
2024 NULL, NULL) == NULL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002025#endif
Bram Moolenaar8c85fa32011-08-10 17:08:03 +02002026 pDispatchMessage(&msg);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002027}
2028
2029/*
2030 * Catch up with any queued events. This may put keyboard input into the
2031 * input buffer, call resize call-backs, trigger timers etc. If there is
2032 * nothing in the event queue (& no timers pending), then we return
2033 * immediately.
2034 */
2035 void
2036gui_mch_update(void)
2037{
2038 MSG msg;
2039
2040 if (!s_busy_processing)
Bram Moolenaar8c85fa32011-08-10 17:08:03 +02002041 while (pPeekMessage(&msg, NULL, 0, 0, PM_NOREMOVE)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002042 && !vim_is_input_buf_full())
2043 process_message();
2044}
2045
2046/*
2047 * GUI input routine called by gui_wait_for_chars(). Waits for a character
2048 * from the keyboard.
2049 * wtime == -1 Wait forever.
2050 * wtime == 0 This should never happen.
2051 * wtime > 0 Wait wtime milliseconds for a character.
2052 * Returns OK if a character was found to be available within the given time,
2053 * or FAIL otherwise.
2054 */
2055 int
2056gui_mch_wait_for_chars(int wtime)
2057{
2058 MSG msg;
2059 int focus;
2060
2061 s_timed_out = FALSE;
2062
2063 if (wtime > 0)
2064 {
2065 /* Don't do anything while processing a (scroll) message. */
2066 if (s_busy_processing)
2067 return FAIL;
2068 s_wait_timer = (UINT)SetTimer(NULL, 0, (UINT)wtime,
2069 (TIMERPROC)_OnTimer);
2070 }
2071
2072 allow_scrollbar = TRUE;
2073
2074 focus = gui.in_focus;
2075 while (!s_timed_out)
2076 {
2077 /* Stop or start blinking when focus changes */
2078 if (gui.in_focus != focus)
2079 {
2080 if (gui.in_focus)
2081 gui_mch_start_blink();
2082 else
2083 gui_mch_stop_blink();
2084 focus = gui.in_focus;
2085 }
2086
2087 if (s_need_activate)
2088 {
2089#ifdef WIN32
2090 (void)SetForegroundWindow(s_hwnd);
2091#else
2092 (void)SetActiveWindow(s_hwnd);
2093#endif
2094 s_need_activate = FALSE;
2095 }
2096
Bram Moolenaar93c88e02015-09-15 14:12:05 +02002097#ifdef MESSAGE_QUEUE
2098 parse_queued_messages();
Bram Moolenaar61665aa2008-12-24 11:20:53 +00002099#endif
2100
Bram Moolenaar071d4272004-06-13 20:20:40 +00002101 /*
2102 * Don't use gui_mch_update() because then we will spin-lock until a
2103 * char arrives, instead we use GetMessage() to hang until an
2104 * event arrives. No need to check for input_buf_full because we are
2105 * returning as soon as it contains a single char -- webb
2106 */
2107 process_message();
2108
2109 if (input_available())
2110 {
2111 if (s_wait_timer != 0 && !s_timed_out)
2112 {
2113 KillTimer(NULL, s_wait_timer);
2114
2115 /* Eat spurious WM_TIMER messages */
Bram Moolenaar8c85fa32011-08-10 17:08:03 +02002116 while (pPeekMessage(&msg, s_hwnd, WM_TIMER, WM_TIMER, PM_REMOVE))
Bram Moolenaar071d4272004-06-13 20:20:40 +00002117 ;
2118 s_wait_timer = 0;
2119 }
2120 allow_scrollbar = FALSE;
Bram Moolenaar293ee4d2004-12-09 21:34:53 +00002121
2122 /* Clear pending mouse button, the release event may have been
Bram Moolenaarea408882007-12-03 21:21:03 +00002123 * taken by the dialog window. But don't do this when getting
2124 * focus, we need the mouse-up event then. */
2125 if (!s_getting_focus)
2126 s_button_pending = -1;
Bram Moolenaar293ee4d2004-12-09 21:34:53 +00002127
Bram Moolenaar071d4272004-06-13 20:20:40 +00002128 return OK;
2129 }
2130 }
2131 allow_scrollbar = FALSE;
2132 return FAIL;
2133}
2134
2135/*
2136 * Clear a rectangular region of the screen from text pos (row1, col1) to
2137 * (row2, col2) inclusive.
2138 */
2139 void
2140gui_mch_clear_block(
2141 int row1,
2142 int col1,
2143 int row2,
2144 int col2)
2145{
2146 RECT rc;
2147
2148 /*
2149 * Clear one extra pixel at the far right, for when bold characters have
2150 * spilled over to the window border.
2151 * Note: FillRect() excludes right and bottom of rectangle.
2152 */
2153 rc.left = FILL_X(col1);
2154 rc.top = FILL_Y(row1);
2155 rc.right = FILL_X(col2 + 1) + (col2 == Columns - 1);
2156 rc.bottom = FILL_Y(row2 + 1);
2157 clear_rect(&rc);
2158}
2159
2160/*
2161 * Clear the whole text window.
2162 */
2163 void
2164gui_mch_clear_all(void)
2165{
2166 RECT rc;
2167
2168 rc.left = 0;
2169 rc.top = 0;
2170 rc.right = Columns * gui.char_width + 2 * gui.border_width;
2171 rc.bottom = Rows * gui.char_height + 2 * gui.border_width;
2172 clear_rect(&rc);
2173}
2174/*
2175 * Menu stuff.
2176 */
2177
2178 void
2179gui_mch_enable_menu(int flag)
2180{
2181#ifdef FEAT_MENU
2182 SetMenu(s_hwnd, flag ? s_menuBar : NULL);
2183#endif
2184}
2185
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00002186/*ARGSUSED*/
Bram Moolenaar071d4272004-06-13 20:20:40 +00002187 void
2188gui_mch_set_menu_pos(
2189 int x,
2190 int y,
2191 int w,
2192 int h)
2193{
2194 /* It will be in the right place anyway */
2195}
2196
2197#if defined(FEAT_MENU) || defined(PROTO)
2198/*
2199 * Make menu item hidden or not hidden
2200 */
2201 void
2202gui_mch_menu_hidden(
2203 vimmenu_T *menu,
2204 int hidden)
2205{
2206 /*
2207 * This doesn't do what we want. Hmm, just grey the menu items for now.
2208 */
2209 /*
2210 if (hidden)
2211 EnableMenuItem(s_menuBar, menu->id, MF_BYCOMMAND | MF_DISABLED);
2212 else
2213 EnableMenuItem(s_menuBar, menu->id, MF_BYCOMMAND | MF_ENABLED);
2214 */
2215 gui_mch_menu_grey(menu, hidden);
2216}
2217
2218/*
2219 * This is called after setting all the menus to grey/hidden or not.
2220 */
2221 void
2222gui_mch_draw_menubar(void)
2223{
2224 DrawMenuBar(s_hwnd);
2225}
2226#endif /*FEAT_MENU*/
2227
2228#ifndef PROTO
2229void
2230#ifdef VIMDLL
2231_export
2232#endif
2233_cdecl
2234SaveInst(HINSTANCE hInst)
2235{
2236 s_hinst = hInst;
2237}
2238#endif
2239
2240/*
2241 * Return the RGB value of a pixel as a long.
2242 */
2243 long_u
2244gui_mch_get_rgb(guicolor_T pixel)
2245{
2246 return (GetRValue(pixel) << 16) + (GetGValue(pixel) << 8)
2247 + GetBValue(pixel);
2248}
2249
2250#if defined(FEAT_GUI_DIALOG) || defined(PROTO)
2251/* Convert pixels in X to dialog units */
2252 static WORD
2253PixelToDialogX(int numPixels)
2254{
2255 return (WORD)((numPixels * 4) / s_dlgfntwidth);
2256}
2257
2258/* Convert pixels in Y to dialog units */
2259 static WORD
2260PixelToDialogY(int numPixels)
2261{
2262 return (WORD)((numPixels * 8) / s_dlgfntheight);
2263}
2264
2265/* Return the width in pixels of the given text in the given DC. */
2266 static int
2267GetTextWidth(HDC hdc, char_u *str, int len)
2268{
2269 SIZE size;
2270
2271 GetTextExtentPoint(hdc, str, len, &size);
2272 return size.cx;
2273}
2274
2275#ifdef FEAT_MBYTE
2276/*
2277 * Return the width in pixels of the given text in the given DC, taking care
2278 * of 'encoding' to active codepage conversion.
2279 */
2280 static int
2281GetTextWidthEnc(HDC hdc, char_u *str, int len)
2282{
2283 SIZE size;
2284 WCHAR *wstr;
2285 int n;
2286 int wlen = len;
2287
2288 if (enc_codepage >= 0 && (int)GetACP() != enc_codepage)
2289 {
2290 /* 'encoding' differs from active codepage: convert text and use wide
2291 * function */
Bram Moolenaar36f692d2008-11-20 16:10:17 +00002292 wstr = enc_to_utf16(str, &wlen);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002293 if (wstr != NULL)
2294 {
2295 n = GetTextExtentPointW(hdc, wstr, wlen, &size);
2296 vim_free(wstr);
2297 if (n)
2298 return size.cx;
2299 }
2300 }
2301
2302 return GetTextWidth(hdc, str, len);
2303}
2304#else
2305# define GetTextWidthEnc(h, s, l) GetTextWidth((h), (s), (l))
2306#endif
2307
2308/*
2309 * A quick little routine that will center one window over another, handy for
2310 * dialog boxes. Taken from the Win32SDK samples.
2311 */
2312 static BOOL
2313CenterWindow(
2314 HWND hwndChild,
2315 HWND hwndParent)
2316{
2317 RECT rChild, rParent;
2318 int wChild, hChild, wParent, hParent;
2319 int wScreen, hScreen, xNew, yNew;
2320 HDC hdc;
2321
2322 GetWindowRect(hwndChild, &rChild);
2323 wChild = rChild.right - rChild.left;
2324 hChild = rChild.bottom - rChild.top;
2325
2326 /* If Vim is minimized put the window in the middle of the screen. */
Bram Moolenaar9e54a0e2006-04-14 20:42:25 +00002327 if (hwndParent == NULL || IsMinimized(hwndParent))
Bram Moolenaar071d4272004-06-13 20:20:40 +00002328 {
2329#ifdef WIN16
2330 rParent.left = 0;
2331 rParent.top = 0;
2332 rParent.right = GetSystemMetrics(SM_CXSCREEN);
2333 rParent.bottom = GetSystemMetrics(SM_CYFULLSCREEN);
2334#else
2335 SystemParametersInfo(SPI_GETWORKAREA, 0, &rParent, 0);
2336#endif
2337 }
2338 else
2339 GetWindowRect(hwndParent, &rParent);
2340 wParent = rParent.right - rParent.left;
2341 hParent = rParent.bottom - rParent.top;
2342
2343 hdc = GetDC(hwndChild);
2344 wScreen = GetDeviceCaps (hdc, HORZRES);
2345 hScreen = GetDeviceCaps (hdc, VERTRES);
2346 ReleaseDC(hwndChild, hdc);
2347
2348 xNew = rParent.left + ((wParent - wChild) /2);
2349 if (xNew < 0)
2350 {
2351 xNew = 0;
2352 }
2353 else if ((xNew+wChild) > wScreen)
2354 {
2355 xNew = wScreen - wChild;
2356 }
2357
2358 yNew = rParent.top + ((hParent - hChild) /2);
2359 if (yNew < 0)
2360 yNew = 0;
2361 else if ((yNew+hChild) > hScreen)
2362 yNew = hScreen - hChild;
2363
2364 return SetWindowPos(hwndChild, NULL, xNew, yNew, 0, 0,
2365 SWP_NOSIZE | SWP_NOZORDER);
2366}
2367#endif /* FEAT_GUI_DIALOG */
2368
2369void
2370gui_mch_activate_window(void)
2371{
2372 (void)SetActiveWindow(s_hwnd);
2373}
2374
2375#if defined(FEAT_TOOLBAR) || defined(PROTO)
2376 void
2377gui_mch_show_toolbar(int showit)
2378{
2379 if (s_toolbarhwnd == NULL)
2380 return;
2381
2382 if (showit)
Bram Moolenaar8f2ff9f2006-08-29 19:26:50 +00002383 {
2384# ifdef FEAT_MBYTE
2385# ifndef TB_SETUNICODEFORMAT
2386 /* For older compilers. We assume this never changes. */
2387# define TB_SETUNICODEFORMAT 0x2005
2388# endif
2389 /* Enable/disable unicode support */
2390 int uu = (enc_codepage >= 0 && (int)GetACP() != enc_codepage);
2391 SendMessage(s_toolbarhwnd, TB_SETUNICODEFORMAT, (WPARAM)uu, (LPARAM)0);
2392# endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00002393 ShowWindow(s_toolbarhwnd, SW_SHOW);
Bram Moolenaar8f2ff9f2006-08-29 19:26:50 +00002394 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00002395 else
2396 ShowWindow(s_toolbarhwnd, SW_HIDE);
2397}
2398
2399/* Then number of bitmaps is fixed. Exit is missing! */
2400#define TOOLBAR_BITMAP_COUNT 31
2401
2402#endif
2403
Bram Moolenaar3991dab2006-03-27 17:01:56 +00002404#if defined(FEAT_GUI_TABLINE) || defined(PROTO)
Bram Moolenaar2e2a2812006-03-27 20:55:21 +00002405 static void
Bram Moolenaar908d53a2006-11-07 18:05:31 +00002406add_tabline_popup_menu_entry(HMENU pmenu, UINT item_id, char_u *item_text)
2407{
2408#ifdef FEAT_MBYTE
2409 WCHAR *wn = NULL;
2410 int n;
2411
2412 if (enc_codepage >= 0 && (int)GetACP() != enc_codepage)
2413 {
2414 /* 'encoding' differs from active codepage: convert menu name
2415 * and use wide function */
Bram Moolenaar36f692d2008-11-20 16:10:17 +00002416 wn = enc_to_utf16(item_text, NULL);
Bram Moolenaar908d53a2006-11-07 18:05:31 +00002417 if (wn != NULL)
2418 {
2419 MENUITEMINFOW infow;
2420
2421 infow.cbSize = sizeof(infow);
2422 infow.fMask = MIIM_TYPE | MIIM_ID;
2423 infow.wID = item_id;
2424 infow.fType = MFT_STRING;
2425 infow.dwTypeData = wn;
2426 infow.cch = (UINT)wcslen(wn);
2427 n = InsertMenuItemW(pmenu, item_id, FALSE, &infow);
2428 vim_free(wn);
2429 if (n == 0 && GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
2430 /* Failed, try using non-wide function. */
2431 wn = NULL;
2432 }
2433 }
2434
2435 if (wn == NULL)
2436#endif
2437 {
2438 MENUITEMINFO info;
2439
2440 info.cbSize = sizeof(info);
2441 info.fMask = MIIM_TYPE | MIIM_ID;
2442 info.wID = item_id;
2443 info.fType = MFT_STRING;
2444 info.dwTypeData = item_text;
2445 info.cch = (UINT)STRLEN(item_text);
2446 InsertMenuItem(pmenu, item_id, FALSE, &info);
2447 }
2448}
2449
2450 static void
Bram Moolenaar2e2a2812006-03-27 20:55:21 +00002451show_tabline_popup_menu(void)
2452{
2453 HMENU tab_pmenu;
Bram Moolenaar2e2a2812006-03-27 20:55:21 +00002454 long rval;
2455 POINT pt;
Bram Moolenaar2e2a2812006-03-27 20:55:21 +00002456
Bram Moolenaarf193fff2006-04-27 00:02:13 +00002457 /* When ignoring events don't show the menu. */
2458 if (hold_gui_events
2459# ifdef FEAT_CMDWIN
2460 || cmdwin_type != 0
2461# endif
2462 )
2463 return;
2464
Bram Moolenaar2e2a2812006-03-27 20:55:21 +00002465 tab_pmenu = CreatePopupMenu();
2466 if (tab_pmenu == NULL)
2467 return;
2468
Bram Moolenaar7098ee52015-06-09 19:14:24 +02002469 if (first_tabpage->tp_next != NULL)
Bram Moolenaar3b597552015-09-15 17:58:29 +02002470 add_tabline_popup_menu_entry(tab_pmenu,
Bram Moolenaar7098ee52015-06-09 19:14:24 +02002471 TABLINE_MENU_CLOSE, _("Close tab"));
Bram Moolenaar908d53a2006-11-07 18:05:31 +00002472 add_tabline_popup_menu_entry(tab_pmenu, TABLINE_MENU_NEW, _("New tab"));
2473 add_tabline_popup_menu_entry(tab_pmenu, TABLINE_MENU_OPEN,
2474 _("Open tab..."));
Bram Moolenaar2e2a2812006-03-27 20:55:21 +00002475
2476 GetCursorPos(&pt);
2477 rval = TrackPopupMenuEx(tab_pmenu, TPM_RETURNCMD, pt.x, pt.y, s_tabhwnd,
2478 NULL);
2479
2480 DestroyMenu(tab_pmenu);
2481
2482 /* Add the string cmd into input buffer */
2483 if (rval > 0)
2484 {
2485 TCHITTESTINFO htinfo;
2486 int idx;
2487
2488 if (ScreenToClient(s_tabhwnd, &pt) == 0)
2489 return;
2490
2491 htinfo.pt.x = pt.x;
2492 htinfo.pt.y = pt.y;
2493 idx = TabCtrl_HitTest(s_tabhwnd, &htinfo);
2494 if (idx == -1)
2495 idx = 0;
2496 else
2497 idx += 1;
2498
Bram Moolenaarc6fe9192006-04-09 21:54:49 +00002499 send_tabline_menu_event(idx, (int)rval);
Bram Moolenaar2e2a2812006-03-27 20:55:21 +00002500 }
2501}
2502
Bram Moolenaar3991dab2006-03-27 17:01:56 +00002503/*
2504 * Show or hide the tabline.
2505 */
2506 void
2507gui_mch_show_tabline(int showit)
2508{
2509 if (s_tabhwnd == NULL)
2510 return;
2511
2512 if (!showit != !showing_tabline)
2513 {
2514 if (showit)
2515 ShowWindow(s_tabhwnd, SW_SHOW);
2516 else
2517 ShowWindow(s_tabhwnd, SW_HIDE);
2518 showing_tabline = showit;
2519 }
2520}
2521
2522/*
2523 * Return TRUE when tabline is displayed.
2524 */
2525 int
2526gui_mch_showing_tabline(void)
2527{
2528 return s_tabhwnd != NULL && showing_tabline;
2529}
2530
2531/*
2532 * Update the labels of the tabline.
2533 */
2534 void
2535gui_mch_update_tabline(void)
2536{
2537 tabpage_T *tp;
2538 TCITEM tie;
2539 int nr = 0;
2540 int curtabidx = 0;
Bram Moolenaar86f931e2013-08-07 21:13:23 +02002541 int tabadded = 0;
Bram Moolenaar8424a622006-04-19 21:23:36 +00002542#ifdef FEAT_MBYTE
Bram Moolenaarfc1421e2006-04-20 22:17:20 +00002543 static int use_unicode = FALSE;
2544 int uu;
Bram Moolenaar8424a622006-04-19 21:23:36 +00002545 WCHAR *wstr = NULL;
2546#endif
Bram Moolenaar3991dab2006-03-27 17:01:56 +00002547
2548 if (s_tabhwnd == NULL)
2549 return;
2550
Bram Moolenaarfc1421e2006-04-20 22:17:20 +00002551#if defined(FEAT_MBYTE)
2552# ifndef CCM_SETUNICODEFORMAT
2553 /* For older compilers. We assume this never changes. */
2554# define CCM_SETUNICODEFORMAT 0x2005
2555# endif
2556 uu = (enc_codepage >= 0 && (int)GetACP() != enc_codepage);
2557 if (uu != use_unicode)
2558 {
2559 /* Enable/disable unicode support */
2560 SendMessage(s_tabhwnd, CCM_SETUNICODEFORMAT, (WPARAM)uu, (LPARAM)0);
2561 use_unicode = uu;
2562 }
Bram Moolenaar8424a622006-04-19 21:23:36 +00002563#endif
2564
Bram Moolenaar3991dab2006-03-27 17:01:56 +00002565 tie.mask = TCIF_TEXT;
2566 tie.iImage = -1;
2567
Bram Moolenaar4b166d02012-12-12 17:12:25 +01002568 /* Disable redraw for tab updates to eliminate O(N^2) draws. */
2569 SendMessage(s_tabhwnd, WM_SETREDRAW, (WPARAM)FALSE, 0);
2570
Bram Moolenaar3991dab2006-03-27 17:01:56 +00002571 /* Add a label for each tab page. They all contain the same text area. */
2572 for (tp = first_tabpage; tp != NULL; tp = tp->tp_next, ++nr)
2573 {
2574 if (tp == curtab)
2575 curtabidx = nr;
2576
Bram Moolenaar4b166d02012-12-12 17:12:25 +01002577 if (nr >= TabCtrl_GetItemCount(s_tabhwnd))
Bram Moolenaar3991dab2006-03-27 17:01:56 +00002578 {
2579 /* Add the tab */
2580 tie.pszText = "-Empty-";
2581 TabCtrl_InsertItem(s_tabhwnd, nr, &tie);
Bram Moolenaar86f931e2013-08-07 21:13:23 +02002582 tabadded = 1;
Bram Moolenaar3991dab2006-03-27 17:01:56 +00002583 }
2584
Bram Moolenaar57657d82006-04-21 22:12:41 +00002585 get_tabline_label(tp, FALSE);
Bram Moolenaar3991dab2006-03-27 17:01:56 +00002586 tie.pszText = NameBuff;
Bram Moolenaar8424a622006-04-19 21:23:36 +00002587#ifdef FEAT_MBYTE
2588 wstr = NULL;
Bram Moolenaarfc1421e2006-04-20 22:17:20 +00002589 if (use_unicode)
Bram Moolenaar8424a622006-04-19 21:23:36 +00002590 {
2591 /* Need to go through Unicode. */
Bram Moolenaar36f692d2008-11-20 16:10:17 +00002592 wstr = enc_to_utf16(NameBuff, NULL);
Bram Moolenaar8424a622006-04-19 21:23:36 +00002593 if (wstr != NULL)
2594 {
2595 TCITEMW tiw;
2596
2597 tiw.mask = TCIF_TEXT;
2598 tiw.iImage = -1;
2599 tiw.pszText = wstr;
Bram Moolenaar85f868c2006-11-28 16:16:58 +00002600 SendMessage(s_tabhwnd, TCM_SETITEMW, (WPARAM)nr, (LPARAM)&tiw);
Bram Moolenaar8424a622006-04-19 21:23:36 +00002601 vim_free(wstr);
2602 }
2603 }
2604 if (wstr == NULL)
2605#endif
2606 {
2607 TabCtrl_SetItem(s_tabhwnd, nr, &tie);
2608 }
Bram Moolenaar3991dab2006-03-27 17:01:56 +00002609 }
2610
2611 /* Remove any old labels. */
Bram Moolenaar4b166d02012-12-12 17:12:25 +01002612 while (nr < TabCtrl_GetItemCount(s_tabhwnd))
Bram Moolenaar3991dab2006-03-27 17:01:56 +00002613 TabCtrl_DeleteItem(s_tabhwnd, nr);
2614
Bram Moolenaar86f931e2013-08-07 21:13:23 +02002615 if (!tabadded && TabCtrl_GetCurSel(s_tabhwnd) != curtabidx)
2616 TabCtrl_SetCurSel(s_tabhwnd, curtabidx);
2617
Bram Moolenaar14e28812012-12-16 12:50:39 +01002618 /* Re-enable redraw and redraw. */
Bram Moolenaar4b166d02012-12-12 17:12:25 +01002619 SendMessage(s_tabhwnd, WM_SETREDRAW, (WPARAM)TRUE, 0);
Bram Moolenaar14e28812012-12-16 12:50:39 +01002620 RedrawWindow(s_tabhwnd, NULL, NULL,
2621 RDW_ERASE | RDW_FRAME | RDW_INVALIDATE | RDW_ALLCHILDREN);
Bram Moolenaara8f96392013-07-17 21:59:13 +02002622
Bram Moolenaar86f931e2013-08-07 21:13:23 +02002623 if (tabadded && TabCtrl_GetCurSel(s_tabhwnd) != curtabidx)
Bram Moolenaara8f96392013-07-17 21:59:13 +02002624 TabCtrl_SetCurSel(s_tabhwnd, curtabidx);
Bram Moolenaar3991dab2006-03-27 17:01:56 +00002625}
2626
2627/*
2628 * Set the current tab to "nr". First tab is 1.
2629 */
2630 void
Bram Moolenaar68c2f632016-01-30 17:24:07 +01002631gui_mch_set_curtab(int nr)
Bram Moolenaar3991dab2006-03-27 17:01:56 +00002632{
2633 if (s_tabhwnd == NULL)
2634 return;
2635
Bram Moolenaara8f96392013-07-17 21:59:13 +02002636 if (TabCtrl_GetCurSel(s_tabhwnd) != nr - 1)
2637 TabCtrl_SetCurSel(s_tabhwnd, nr - 1);
Bram Moolenaar3991dab2006-03-27 17:01:56 +00002638}
2639
2640#endif
2641
Bram Moolenaar071d4272004-06-13 20:20:40 +00002642/*
2643 * ":simalt" command.
2644 */
2645 void
2646ex_simalt(exarg_T *eap)
2647{
2648 char_u *keys = eap->arg;
2649
2650 PostMessage(s_hwnd, WM_SYSCOMMAND, (WPARAM)SC_KEYMENU, (LPARAM)0);
2651 while (*keys)
2652 {
2653 if (*keys == '~')
2654 *keys = ' '; /* for showing system menu */
2655 PostMessage(s_hwnd, WM_CHAR, (WPARAM)*keys, (LPARAM)0);
2656 keys++;
2657 }
2658}
2659
2660/*
2661 * Create the find & replace dialogs.
2662 * You can't have both at once: ":find" when replace is showing, destroys
2663 * the replace dialog first, and the other way around.
2664 */
2665#ifdef MSWIN_FIND_REPLACE
2666 static void
2667initialise_findrep(char_u *initial_string)
2668{
2669 int wword = FALSE;
2670 int mcase = !p_ic;
2671 char_u *entry_text;
2672
2673 /* Get the search string to use. */
2674 entry_text = get_find_dialog_text(initial_string, &wword, &mcase);
2675
2676 s_findrep_struct.hwndOwner = s_hwnd;
2677 s_findrep_struct.Flags = FR_DOWN;
2678 if (mcase)
2679 s_findrep_struct.Flags |= FR_MATCHCASE;
2680 if (wword)
2681 s_findrep_struct.Flags |= FR_WHOLEWORD;
2682 if (entry_text != NULL && *entry_text != NUL)
Bram Moolenaarfe3ca8d2005-07-18 21:43:02 +00002683 vim_strncpy(s_findrep_struct.lpstrFindWhat, entry_text,
2684 s_findrep_struct.wFindWhatLen - 1);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002685 vim_free(entry_text);
2686}
2687#endif
2688
Bram Moolenaar908d53a2006-11-07 18:05:31 +00002689 static void
2690set_window_title(HWND hwnd, char *title)
2691{
2692#ifdef FEAT_MBYTE
2693 if (title != NULL && enc_codepage >= 0 && enc_codepage != (int)GetACP())
2694 {
2695 WCHAR *wbuf;
2696 int n;
2697
Bram Moolenaar36f692d2008-11-20 16:10:17 +00002698 /* Convert the title from 'encoding' to UTF-16. */
2699 wbuf = (WCHAR *)enc_to_utf16((char_u *)title, NULL);
Bram Moolenaar908d53a2006-11-07 18:05:31 +00002700 if (wbuf != NULL)
2701 {
2702 n = SetWindowTextW(hwnd, wbuf);
2703 vim_free(wbuf);
2704 if (n != 0 || GetLastError() != ERROR_CALL_NOT_IMPLEMENTED)
2705 return;
2706 /* Retry with non-wide function (for Windows 98). */
2707 }
2708 }
2709#endif
2710 (void)SetWindowText(hwnd, (LPCSTR)title);
2711}
2712
Bram Moolenaar071d4272004-06-13 20:20:40 +00002713 void
2714gui_mch_find_dialog(exarg_T *eap)
2715{
2716#ifdef MSWIN_FIND_REPLACE
2717 if (s_findrep_msg != 0)
2718 {
2719 if (IsWindow(s_findrep_hwnd) && !s_findrep_is_find)
2720 DestroyWindow(s_findrep_hwnd);
2721
2722 if (!IsWindow(s_findrep_hwnd))
2723 {
2724 initialise_findrep(eap->arg);
Bram Moolenaar3ca9a8a2009-01-28 20:23:17 +00002725# if defined(FEAT_MBYTE) && defined(WIN3264)
2726 /* If the OS is Windows NT, and 'encoding' differs from active
2727 * codepage: convert text and use wide function. */
2728 if (os_version.dwPlatformId == VER_PLATFORM_WIN32_NT
2729 && enc_codepage >= 0 && (int)GetACP() != enc_codepage)
2730 {
Bram Moolenaarcc448b32010-07-14 16:52:17 +02002731 findrep_atow(&s_findrep_struct_w, &s_findrep_struct);
Bram Moolenaar3ca9a8a2009-01-28 20:23:17 +00002732 s_findrep_hwnd = FindTextW(
2733 (LPFINDREPLACEW) &s_findrep_struct_w);
2734 }
2735 else
2736# endif
2737 s_findrep_hwnd = FindText((LPFINDREPLACE) &s_findrep_struct);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002738 }
2739
Bram Moolenaar908d53a2006-11-07 18:05:31 +00002740 set_window_title(s_findrep_hwnd,
2741 _("Find string (use '\\\\' to find a '\\')"));
Bram Moolenaar071d4272004-06-13 20:20:40 +00002742 (void)SetFocus(s_findrep_hwnd);
2743
2744 s_findrep_is_find = TRUE;
2745 }
2746#endif
2747}
2748
2749
2750 void
2751gui_mch_replace_dialog(exarg_T *eap)
2752{
2753#ifdef MSWIN_FIND_REPLACE
2754 if (s_findrep_msg != 0)
2755 {
2756 if (IsWindow(s_findrep_hwnd) && s_findrep_is_find)
2757 DestroyWindow(s_findrep_hwnd);
2758
2759 if (!IsWindow(s_findrep_hwnd))
2760 {
2761 initialise_findrep(eap->arg);
Bram Moolenaar3ca9a8a2009-01-28 20:23:17 +00002762# if defined(FEAT_MBYTE) && defined(WIN3264)
2763 if (os_version.dwPlatformId == VER_PLATFORM_WIN32_NT
2764 && enc_codepage >= 0 && (int)GetACP() != enc_codepage)
2765 {
2766 findrep_atow(&s_findrep_struct_w, &s_findrep_struct);
2767 s_findrep_hwnd = ReplaceTextW(
2768 (LPFINDREPLACEW) &s_findrep_struct_w);
2769 }
2770 else
2771# endif
2772 s_findrep_hwnd = ReplaceText(
2773 (LPFINDREPLACE) &s_findrep_struct);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002774 }
2775
Bram Moolenaar908d53a2006-11-07 18:05:31 +00002776 set_window_title(s_findrep_hwnd,
2777 _("Find & Replace (use '\\\\' to find a '\\')"));
Bram Moolenaar071d4272004-06-13 20:20:40 +00002778 (void)SetFocus(s_findrep_hwnd);
2779
2780 s_findrep_is_find = FALSE;
2781 }
2782#endif
2783}
2784
2785
2786/*
2787 * Set visibility of the pointer.
2788 */
2789 void
2790gui_mch_mousehide(int hide)
2791{
2792 if (hide != gui.pointer_hidden)
2793 {
2794 ShowCursor(!hide);
2795 gui.pointer_hidden = hide;
2796 }
2797}
2798
2799#ifdef FEAT_MENU
2800 static void
2801gui_mch_show_popupmenu_at(vimmenu_T *menu, int x, int y)
2802{
2803 /* Unhide the mouse, we don't get move events here. */
2804 gui_mch_mousehide(FALSE);
2805
2806 (void)TrackPopupMenu(
2807 (HMENU)menu->submenu_id,
2808 TPM_LEFTALIGN | TPM_LEFTBUTTON,
2809 x, y,
2810 (int)0, /*reserved param*/
2811 s_hwnd,
2812 NULL);
2813 /*
2814 * NOTE: The pop-up menu can eat the mouse up event.
2815 * We deal with this in normal.c.
2816 */
2817}
2818#endif
2819
2820/*
2821 * Got a message when the system will go down.
2822 */
2823 static void
2824_OnEndSession(void)
2825{
2826 getout_preserve_modified(1);
2827}
2828
2829/*
2830 * Get this message when the user clicks on the cross in the top right corner
2831 * of a Windows95 window.
2832 */
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00002833/*ARGSUSED*/
Bram Moolenaar071d4272004-06-13 20:20:40 +00002834 static void
2835_OnClose(
2836 HWND hwnd)
2837{
2838 gui_shell_closed();
2839}
2840
2841/*
2842 * Get a message when the window is being destroyed.
2843 */
2844 static void
2845_OnDestroy(
2846 HWND hwnd)
2847{
2848#ifdef WIN16_3DLOOK
2849 Ctl3dUnregister(s_hinst);
2850#endif
2851 if (!destroying)
2852 _OnClose(hwnd);
2853}
2854
2855 static void
2856_OnPaint(
2857 HWND hwnd)
2858{
2859 if (!IsMinimized(hwnd))
2860 {
2861 PAINTSTRUCT ps;
2862
2863 out_flush(); /* make sure all output has been processed */
2864 (void)BeginPaint(hwnd, &ps);
Bram Moolenaarb5a7a8b2014-08-06 14:52:30 +02002865#if defined(FEAT_DIRECTX)
2866 if (IS_ENABLE_DIRECTX())
2867 DWriteContext_BeginDraw(s_dwc);
2868#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00002869
2870#ifdef FEAT_MBYTE
2871 /* prevent multi-byte characters from misprinting on an invalid
2872 * rectangle */
2873 if (has_mbyte)
2874 {
2875 RECT rect;
2876
2877 GetClientRect(hwnd, &rect);
2878 ps.rcPaint.left = rect.left;
2879 ps.rcPaint.right = rect.right;
2880 }
2881#endif
2882
2883 if (!IsRectEmpty(&ps.rcPaint))
Bram Moolenaarb5a7a8b2014-08-06 14:52:30 +02002884 {
2885#if defined(FEAT_DIRECTX)
2886 if (IS_ENABLE_DIRECTX())
2887 DWriteContext_BindDC(s_dwc, s_hdc, &ps.rcPaint);
2888#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00002889 gui_redraw(ps.rcPaint.left, ps.rcPaint.top,
2890 ps.rcPaint.right - ps.rcPaint.left + 1,
2891 ps.rcPaint.bottom - ps.rcPaint.top + 1);
Bram Moolenaarb5a7a8b2014-08-06 14:52:30 +02002892 }
2893
2894#if defined(FEAT_DIRECTX)
2895 if (IS_ENABLE_DIRECTX())
2896 DWriteContext_EndDraw(s_dwc);
2897#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00002898 EndPaint(hwnd, &ps);
2899 }
2900}
2901
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00002902/*ARGSUSED*/
Bram Moolenaar071d4272004-06-13 20:20:40 +00002903 static void
2904_OnSize(
2905 HWND hwnd,
2906 UINT state,
2907 int cx,
2908 int cy)
2909{
2910 if (!IsMinimized(hwnd))
2911 {
2912 gui_resize_shell(cx, cy);
2913
2914#ifdef FEAT_MENU
2915 /* Menu bar may wrap differently now */
2916 gui_mswin_get_menu_height(TRUE);
2917#endif
2918 }
2919}
2920
2921 static void
2922_OnSetFocus(
2923 HWND hwnd,
2924 HWND hwndOldFocus)
2925{
2926 gui_focus_change(TRUE);
Bram Moolenaarea408882007-12-03 21:21:03 +00002927 s_getting_focus = TRUE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002928 (void)MyWindowProc(hwnd, WM_SETFOCUS, (WPARAM)hwndOldFocus, 0);
2929}
2930
2931 static void
2932_OnKillFocus(
2933 HWND hwnd,
2934 HWND hwndNewFocus)
2935{
2936 gui_focus_change(FALSE);
Bram Moolenaarea408882007-12-03 21:21:03 +00002937 s_getting_focus = FALSE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002938 (void)MyWindowProc(hwnd, WM_KILLFOCUS, (WPARAM)hwndNewFocus, 0);
2939}
2940
2941/*
2942 * Get a message when the user switches back to vim
2943 */
2944#ifdef WIN16
2945 static BOOL
2946#else
2947 static LRESULT
2948#endif
2949_OnActivateApp(
2950 HWND hwnd,
2951 BOOL fActivate,
2952#ifdef WIN16
2953 HTASK dwThreadId
2954#else
2955 DWORD dwThreadId
2956#endif
2957 )
2958{
2959 /* we call gui_focus_change() in _OnSetFocus() */
2960 /* gui_focus_change((int)fActivate); */
2961 return MyWindowProc(hwnd, WM_ACTIVATEAPP, fActivate, (DWORD)dwThreadId);
2962}
2963
2964#if defined(FEAT_WINDOWS) || defined(PROTO)
2965 void
2966gui_mch_destroy_scrollbar(scrollbar_T *sb)
2967{
2968 DestroyWindow(sb->id);
2969}
2970#endif
2971
2972/*
Bram Moolenaar9588a0f2005-01-08 21:45:39 +00002973 * Get current mouse coordinates in text window.
Bram Moolenaar071d4272004-06-13 20:20:40 +00002974 */
Bram Moolenaar9588a0f2005-01-08 21:45:39 +00002975 void
Bram Moolenaara40c5002005-01-09 21:16:21 +00002976gui_mch_getmouse(int *x, int *y)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002977{
2978 RECT rct;
2979 POINT mp;
2980
2981 (void)GetWindowRect(s_textArea, &rct);
2982 (void)GetCursorPos((LPPOINT)&mp);
Bram Moolenaar9588a0f2005-01-08 21:45:39 +00002983 *x = (int)(mp.x - rct.left);
2984 *y = (int)(mp.y - rct.top);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002985}
2986
2987/*
2988 * Move mouse pointer to character at (x, y).
2989 */
2990 void
2991gui_mch_setmouse(int x, int y)
2992{
2993 RECT rct;
2994
2995 (void)GetWindowRect(s_textArea, &rct);
2996 (void)SetCursorPos(x + gui.border_offset + rct.left,
2997 y + gui.border_offset + rct.top);
2998}
2999
3000 static void
3001gui_mswin_get_valid_dimensions(
3002 int w,
3003 int h,
3004 int *valid_w,
3005 int *valid_h)
3006{
3007 int base_width, base_height;
3008
3009 base_width = gui_get_base_width()
Bram Moolenaar9d488952013-07-21 17:53:58 +02003010 + (GetSystemMetrics(SM_CXFRAME) +
Bram Moolenaar3b597552015-09-15 17:58:29 +02003011 GetSystemMetrics(SM_CXPADDEDBORDER)) * 2;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003012 base_height = gui_get_base_height()
Bram Moolenaar9d488952013-07-21 17:53:58 +02003013 + (GetSystemMetrics(SM_CYFRAME) +
Bram Moolenaar3b597552015-09-15 17:58:29 +02003014 GetSystemMetrics(SM_CXPADDEDBORDER)) * 2
Bram Moolenaar071d4272004-06-13 20:20:40 +00003015 + GetSystemMetrics(SM_CYCAPTION)
3016#ifdef FEAT_MENU
3017 + gui_mswin_get_menu_height(FALSE)
3018#endif
3019 ;
3020 *valid_w = base_width +
3021 ((w - base_width) / gui.char_width) * gui.char_width;
3022 *valid_h = base_height +
3023 ((h - base_height) / gui.char_height) * gui.char_height;
3024}
3025
3026 void
Bram Moolenaar071d4272004-06-13 20:20:40 +00003027gui_mch_flash(int msec)
3028{
3029 RECT rc;
3030
3031 /*
3032 * Note: InvertRect() excludes right and bottom of rectangle.
3033 */
3034 rc.left = 0;
3035 rc.top = 0;
3036 rc.right = gui.num_cols * gui.char_width;
3037 rc.bottom = gui.num_rows * gui.char_height;
3038 InvertRect(s_hdc, &rc);
3039 gui_mch_flush(); /* make sure it's displayed */
3040
3041 ui_delay((long)msec, TRUE); /* wait for a few msec */
3042
3043 InvertRect(s_hdc, &rc);
3044}
3045
3046/*
3047 * Return flags used for scrolling.
3048 * The SW_INVALIDATE is required when part of the window is covered or
3049 * off-screen. Refer to MS KB Q75236.
3050 */
3051 static int
3052get_scroll_flags(void)
3053{
3054 HWND hwnd;
3055 RECT rcVim, rcOther, rcDest;
3056
3057 GetWindowRect(s_hwnd, &rcVim);
Bram Moolenaar0d406992005-05-22 22:03:39 +00003058
3059 /* Check if the window is partly above or below the screen. We don't care
3060 * about partly left or right of the screen, it is not relevant when
3061 * scrolling up or down. */
3062 if (rcVim.top < 0 || rcVim.bottom > GetSystemMetrics(SM_CYFULLSCREEN))
3063 return SW_INVALIDATE;
3064
3065 /* Check if there is an window (partly) on top of us. */
Bram Moolenaar071d4272004-06-13 20:20:40 +00003066 for (hwnd = s_hwnd; (hwnd = GetWindow(hwnd, GW_HWNDPREV)) != (HWND)0; )
3067 if (IsWindowVisible(hwnd))
3068 {
3069 GetWindowRect(hwnd, &rcOther);
3070 if (IntersectRect(&rcDest, &rcVim, &rcOther))
3071 return SW_INVALIDATE;
3072 }
3073 return 0;
3074}
3075
3076/*
Bram Moolenaar3b597552015-09-15 17:58:29 +02003077 * On some Intel GPUs, the regions drawn just prior to ScrollWindowEx()
3078 * may not be scrolled out properly.
3079 * For gVim, when _OnScroll() is repeated, the character at the
3080 * previous cursor position may be left drawn after scroll.
3081 * The problem can be avoided by calling GetPixel() to get a pixel in
3082 * the region before ScrollWindowEx().
3083 */
3084 static void
3085intel_gpu_workaround(void)
3086{
3087 GetPixel(s_hdc, FILL_X(gui.col), FILL_Y(gui.row));
3088}
3089
3090/*
Bram Moolenaar071d4272004-06-13 20:20:40 +00003091 * Delete the given number of lines from the given row, scrolling up any
3092 * text further down within the scroll region.
3093 */
3094 void
3095gui_mch_delete_lines(
3096 int row,
3097 int num_lines)
3098{
3099 RECT rc;
3100
Bram Moolenaar3b597552015-09-15 17:58:29 +02003101 intel_gpu_workaround();
3102
Bram Moolenaar071d4272004-06-13 20:20:40 +00003103 rc.left = FILL_X(gui.scroll_region_left);
3104 rc.right = FILL_X(gui.scroll_region_right + 1);
3105 rc.top = FILL_Y(row);
3106 rc.bottom = FILL_Y(gui.scroll_region_bot + 1);
3107
3108 ScrollWindowEx(s_textArea, 0, -num_lines * gui.char_height,
3109 &rc, &rc, NULL, NULL, get_scroll_flags());
3110
3111 UpdateWindow(s_textArea);
3112 /* This seems to be required to avoid the cursor disappearing when
3113 * scrolling such that the cursor ends up in the top-left character on
3114 * the screen... But why? (Webb) */
3115 /* It's probably fixed by disabling drawing the cursor while scrolling. */
3116 /* gui.cursor_is_valid = FALSE; */
3117
3118 gui_clear_block(gui.scroll_region_bot - num_lines + 1,
3119 gui.scroll_region_left,
3120 gui.scroll_region_bot, gui.scroll_region_right);
3121}
3122
3123/*
3124 * Insert the given number of lines before the given row, scrolling down any
3125 * following text within the scroll region.
3126 */
3127 void
3128gui_mch_insert_lines(
3129 int row,
3130 int num_lines)
3131{
3132 RECT rc;
3133
Bram Moolenaar3b597552015-09-15 17:58:29 +02003134 intel_gpu_workaround();
3135
Bram Moolenaar071d4272004-06-13 20:20:40 +00003136 rc.left = FILL_X(gui.scroll_region_left);
3137 rc.right = FILL_X(gui.scroll_region_right + 1);
3138 rc.top = FILL_Y(row);
3139 rc.bottom = FILL_Y(gui.scroll_region_bot + 1);
3140 /* The SW_INVALIDATE is required when part of the window is covered or
3141 * off-screen. How do we avoid it when it's not needed? */
3142 ScrollWindowEx(s_textArea, 0, num_lines * gui.char_height,
3143 &rc, &rc, NULL, NULL, get_scroll_flags());
3144
3145 UpdateWindow(s_textArea);
3146
3147 gui_clear_block(row, gui.scroll_region_left,
3148 row + num_lines - 1, gui.scroll_region_right);
3149}
3150
3151
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00003152/*ARGSUSED*/
Bram Moolenaar071d4272004-06-13 20:20:40 +00003153 void
3154gui_mch_exit(int rc)
3155{
Bram Moolenaarb5a7a8b2014-08-06 14:52:30 +02003156#if defined(FEAT_DIRECTX)
3157 DWriteContext_Close(s_dwc);
3158 DWrite_Final();
3159 s_dwc = NULL;
3160#endif
3161
Bram Moolenaar071d4272004-06-13 20:20:40 +00003162 ReleaseDC(s_textArea, s_hdc);
3163 DeleteObject(s_brush);
3164
3165#ifdef FEAT_TEAROFF
3166 /* Unload the tearoff bitmap */
3167 (void)DeleteObject((HGDIOBJ)s_htearbitmap);
3168#endif
3169
3170 /* Destroy our window (if we have one). */
3171 if (s_hwnd != NULL)
3172 {
3173 destroying = TRUE; /* ignore WM_DESTROY message now */
3174 DestroyWindow(s_hwnd);
3175 }
3176
3177#ifdef GLOBAL_IME
3178 global_ime_end();
3179#endif
3180}
3181
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00003182 static char_u *
3183logfont2name(LOGFONT lf)
3184{
3185 char *p;
3186 char *res;
3187 char *charset_name;
Bram Moolenaarb1692e22014-03-12 19:24:37 +01003188 char *font_name = lf.lfFaceName;
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00003189
3190 charset_name = charset_id2name((int)lf.lfCharSet);
Bram Moolenaarb1692e22014-03-12 19:24:37 +01003191#ifdef FEAT_MBYTE
3192 /* Convert a font name from the current codepage to 'encoding'.
3193 * TODO: Use Wide APIs (including LOGFONTW) instead of ANSI APIs. */
3194 if (enc_codepage >= 0 && (int)GetACP() != enc_codepage)
3195 {
3196 int len;
Bram Moolenaara0844a12014-03-19 12:37:22 +01003197 acp_to_enc(lf.lfFaceName, (int)strlen(lf.lfFaceName),
Bram Moolenaarb1692e22014-03-12 19:24:37 +01003198 (char_u **)&font_name, &len);
3199 }
3200#endif
3201 res = alloc((unsigned)(strlen(font_name) + 20
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00003202 + (charset_name == NULL ? 0 : strlen(charset_name) + 2)));
3203 if (res != NULL)
3204 {
3205 p = res;
3206 /* make a normal font string out of the lf thing:*/
Bram Moolenaarb1692e22014-03-12 19:24:37 +01003207 sprintf((char *)p, "%s:h%d", font_name, pixels_to_points(
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00003208 lf.lfHeight < 0 ? -lf.lfHeight : lf.lfHeight, TRUE));
3209 while (*p)
3210 {
3211 if (*p == ' ')
3212 *p = '_';
3213 ++p;
3214 }
3215#ifndef MSWIN16_FASTTEXT
3216 if (lf.lfItalic)
3217 STRCAT(p, ":i");
3218 if (lf.lfWeight >= FW_BOLD)
3219 STRCAT(p, ":b");
3220#endif
3221 if (lf.lfUnderline)
3222 STRCAT(p, ":u");
3223 if (lf.lfStrikeOut)
3224 STRCAT(p, ":s");
3225 if (charset_name != NULL)
3226 {
3227 STRCAT(p, ":c");
3228 STRCAT(p, charset_name);
3229 }
3230 }
3231
Bram Moolenaarb1692e22014-03-12 19:24:37 +01003232#ifdef FEAT_MBYTE
3233 if (font_name != lf.lfFaceName)
3234 vim_free(font_name);
3235#endif
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00003236 return res;
3237}
3238
Bram Moolenaar0f272122013-01-23 18:37:40 +01003239
3240#ifdef FEAT_MBYTE_IME
3241/*
3242 * Set correct LOGFONT to IME. Use 'guifontwide' if available, otherwise use
3243 * 'guifont'
3244 */
3245 static void
Bram Moolenaarfb97f282013-07-09 17:42:46 +02003246update_im_font(void)
Bram Moolenaar0f272122013-01-23 18:37:40 +01003247{
3248 LOGFONT lf_wide;
3249
3250 if (p_guifontwide != NULL && *p_guifontwide != NUL
Bram Moolenaar826763f2013-01-25 19:28:38 +01003251 && gui.wide_font != NOFONT
3252 && GetObject((HFONT)gui.wide_font, sizeof(lf_wide), &lf_wide))
Bram Moolenaar0f272122013-01-23 18:37:40 +01003253 norm_logfont = lf_wide;
3254 else
3255 norm_logfont = sub_logfont;
3256 im_set_font(&norm_logfont);
3257}
3258#endif
3259
3260#ifdef FEAT_MBYTE
3261/*
3262 * Handler of gui.wide_font (p_guifontwide) changed notification.
3263 */
3264 void
Bram Moolenaar68c2f632016-01-30 17:24:07 +01003265gui_mch_wide_font_changed(void)
Bram Moolenaar0f272122013-01-23 18:37:40 +01003266{
Bram Moolenaardb250522013-06-17 22:43:25 +02003267# ifndef MSWIN16_FASTTEXT
3268 LOGFONT lf;
3269# endif
3270
Bram Moolenaar0f272122013-01-23 18:37:40 +01003271# ifdef FEAT_MBYTE_IME
3272 update_im_font();
3273# endif
Bram Moolenaardb250522013-06-17 22:43:25 +02003274
3275# ifndef MSWIN16_FASTTEXT
3276 gui_mch_free_font(gui.wide_ital_font);
3277 gui.wide_ital_font = NOFONT;
3278 gui_mch_free_font(gui.wide_bold_font);
3279 gui.wide_bold_font = NOFONT;
3280 gui_mch_free_font(gui.wide_boldital_font);
3281 gui.wide_boldital_font = NOFONT;
3282
3283 if (gui.wide_font
3284 && GetObject((HFONT)gui.wide_font, sizeof(lf), &lf))
3285 {
3286 if (!lf.lfItalic)
3287 {
3288 lf.lfItalic = TRUE;
3289 gui.wide_ital_font = get_font_handle(&lf);
3290 lf.lfItalic = FALSE;
3291 }
3292 if (lf.lfWeight < FW_BOLD)
3293 {
3294 lf.lfWeight = FW_BOLD;
3295 gui.wide_bold_font = get_font_handle(&lf);
3296 if (!lf.lfItalic)
3297 {
3298 lf.lfItalic = TRUE;
3299 gui.wide_boldital_font = get_font_handle(&lf);
3300 }
3301 }
3302 }
3303# endif
Bram Moolenaar0f272122013-01-23 18:37:40 +01003304}
3305#endif
3306
Bram Moolenaar071d4272004-06-13 20:20:40 +00003307/*
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00003308 * Initialise vim to use the font with the given name.
3309 * Return FAIL if the font could not be loaded, OK otherwise.
Bram Moolenaar071d4272004-06-13 20:20:40 +00003310 */
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00003311/*ARGSUSED*/
Bram Moolenaar071d4272004-06-13 20:20:40 +00003312 int
3313gui_mch_init_font(char_u *font_name, int fontset)
3314{
3315 LOGFONT lf;
3316 GuiFont font = NOFONT;
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00003317 char_u *p;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003318
3319 /* Load the font */
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00003320 if (get_logfont(&lf, font_name, NULL, TRUE) == OK)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003321 font = get_font_handle(&lf);
3322 if (font == NOFONT)
3323 return FAIL;
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00003324
Bram Moolenaar071d4272004-06-13 20:20:40 +00003325 if (font_name == NULL)
3326 font_name = lf.lfFaceName;
3327#if defined(FEAT_MBYTE_IME) || defined(GLOBAL_IME)
3328 norm_logfont = lf;
Bram Moolenaar0f272122013-01-23 18:37:40 +01003329 sub_logfont = lf;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003330#endif
3331#ifdef FEAT_MBYTE_IME
Bram Moolenaar0f272122013-01-23 18:37:40 +01003332 update_im_font();
Bram Moolenaar071d4272004-06-13 20:20:40 +00003333#endif
3334 gui_mch_free_font(gui.norm_font);
3335 gui.norm_font = font;
3336 current_font_height = lf.lfHeight;
3337 GetFontSize(font);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003338
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00003339 p = logfont2name(lf);
3340 if (p != NULL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003341 {
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00003342 hl_set_font_name(p);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003343
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00003344 /* When setting 'guifont' to "*" replace it with the actual font name.
3345 * */
3346 if (STRCMP(font_name, "*") == 0 && STRCMP(p_guifont, "*") == 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003347 {
Bram Moolenaar071d4272004-06-13 20:20:40 +00003348 vim_free(p_guifont);
3349 p_guifont = p;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003350 }
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00003351 else
3352 vim_free(p);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003353 }
3354
3355#ifndef MSWIN16_FASTTEXT
3356 gui_mch_free_font(gui.ital_font);
3357 gui.ital_font = NOFONT;
3358 gui_mch_free_font(gui.bold_font);
3359 gui.bold_font = NOFONT;
3360 gui_mch_free_font(gui.boldital_font);
3361 gui.boldital_font = NOFONT;
3362
3363 if (!lf.lfItalic)
3364 {
3365 lf.lfItalic = TRUE;
3366 gui.ital_font = get_font_handle(&lf);
3367 lf.lfItalic = FALSE;
3368 }
3369 if (lf.lfWeight < FW_BOLD)
3370 {
3371 lf.lfWeight = FW_BOLD;
3372 gui.bold_font = get_font_handle(&lf);
3373 if (!lf.lfItalic)
3374 {
3375 lf.lfItalic = TRUE;
3376 gui.boldital_font = get_font_handle(&lf);
3377 }
3378 }
3379#endif
3380
3381 return OK;
3382}
3383
Bram Moolenaar85f868c2006-11-28 16:16:58 +00003384#ifndef WPF_RESTORETOMAXIMIZED
3385# define WPF_RESTORETOMAXIMIZED 2 /* just in case someone doesn't have it */
3386#endif
3387
Bram Moolenaar071d4272004-06-13 20:20:40 +00003388/*
3389 * Return TRUE if the GUI window is maximized, filling the whole screen.
3390 */
3391 int
Bram Moolenaar68c2f632016-01-30 17:24:07 +01003392gui_mch_maximized(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003393{
Bram Moolenaar85f868c2006-11-28 16:16:58 +00003394 WINDOWPLACEMENT wp;
3395
3396 wp.length = sizeof(WINDOWPLACEMENT);
3397 if (GetWindowPlacement(s_hwnd, &wp))
3398 return wp.showCmd == SW_SHOWMAXIMIZED
3399 || (wp.showCmd == SW_SHOWMINIMIZED
3400 && wp.flags == WPF_RESTORETOMAXIMIZED);
3401
3402 return 0;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003403}
3404
3405/*
3406 * Called when the font changed while the window is maximized. Compute the
3407 * new Rows and Columns. This is like resizing the window.
3408 */
3409 void
Bram Moolenaar68c2f632016-01-30 17:24:07 +01003410gui_mch_newfont(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003411{
3412 RECT rect;
3413
3414 GetWindowRect(s_hwnd, &rect);
Bram Moolenaar89195542015-09-25 15:00:31 +02003415 if (win_socket_id == 0)
3416 {
3417 gui_resize_shell(rect.right - rect.left
3418 - (GetSystemMetrics(SM_CXFRAME) +
3419 GetSystemMetrics(SM_CXPADDEDBORDER)) * 2,
3420 rect.bottom - rect.top
3421 - (GetSystemMetrics(SM_CYFRAME) +
3422 GetSystemMetrics(SM_CXPADDEDBORDER)) * 2
3423 - GetSystemMetrics(SM_CYCAPTION)
3424#ifdef FEAT_MENU
3425 - gui_mswin_get_menu_height(FALSE)
3426#endif
3427 );
3428 }
3429 else
3430 {
3431 /* Inside another window, don't use the frame and border. */
3432 gui_resize_shell(rect.right - rect.left,
3433 rect.bottom - rect.top
Bram Moolenaar071d4272004-06-13 20:20:40 +00003434#ifdef FEAT_MENU
3435 - gui_mswin_get_menu_height(FALSE)
3436#endif
Bram Moolenaar89195542015-09-25 15:00:31 +02003437 );
3438 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00003439}
3440
3441/*
3442 * Set the window title
3443 */
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00003444/*ARGSUSED*/
Bram Moolenaar071d4272004-06-13 20:20:40 +00003445 void
3446gui_mch_settitle(
3447 char_u *title,
3448 char_u *icon)
3449{
Bram Moolenaar908d53a2006-11-07 18:05:31 +00003450 set_window_title(s_hwnd, (title == NULL ? "VIM" : (char *)title));
Bram Moolenaar071d4272004-06-13 20:20:40 +00003451}
3452
3453#ifdef FEAT_MOUSESHAPE
3454/* Table for shape IDCs. Keep in sync with the mshape_names[] table in
3455 * misc2.c! */
3456static LPCSTR mshape_idcs[] =
3457{
Bram Moolenaaraf62ff32013-03-19 14:48:29 +01003458 IDC_ARROW, /* arrow */
3459 MAKEINTRESOURCE(0), /* blank */
3460 IDC_IBEAM, /* beam */
3461 IDC_SIZENS, /* updown */
3462 IDC_SIZENS, /* udsizing */
3463 IDC_SIZEWE, /* leftright */
3464 IDC_SIZEWE, /* lrsizing */
3465 IDC_WAIT, /* busy */
Bram Moolenaar071d4272004-06-13 20:20:40 +00003466#ifdef WIN3264
Bram Moolenaaraf62ff32013-03-19 14:48:29 +01003467 IDC_NO, /* no */
Bram Moolenaar071d4272004-06-13 20:20:40 +00003468#else
Bram Moolenaaraf62ff32013-03-19 14:48:29 +01003469 IDC_ICON, /* no */
Bram Moolenaar071d4272004-06-13 20:20:40 +00003470#endif
Bram Moolenaaraf62ff32013-03-19 14:48:29 +01003471 IDC_ARROW, /* crosshair */
3472 IDC_ARROW, /* hand1 */
3473 IDC_ARROW, /* hand2 */
3474 IDC_ARROW, /* pencil */
3475 IDC_ARROW, /* question */
3476 IDC_ARROW, /* right-arrow */
3477 IDC_UPARROW, /* up-arrow */
3478 IDC_ARROW /* last one */
Bram Moolenaar071d4272004-06-13 20:20:40 +00003479};
3480
3481 void
3482mch_set_mouse_shape(int shape)
3483{
3484 LPCSTR idc;
3485
3486 if (shape == MSHAPE_HIDE)
3487 ShowCursor(FALSE);
3488 else
3489 {
3490 if (shape >= MSHAPE_NUMBERED)
Bram Moolenaaraf62ff32013-03-19 14:48:29 +01003491 idc = IDC_ARROW;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003492 else
3493 idc = mshape_idcs[shape];
Bram Moolenaare6a91fd2008-07-24 18:51:11 +00003494#ifdef SetClassLongPtr
3495 SetClassLongPtr(s_textArea, GCLP_HCURSOR, (__int3264)(LONG_PTR)LoadCursor(NULL, idc));
Bram Moolenaar071d4272004-06-13 20:20:40 +00003496#else
3497# ifdef WIN32
Bram Moolenaare6a91fd2008-07-24 18:51:11 +00003498 SetClassLong(s_textArea, GCL_HCURSOR, (long_u)LoadCursor(NULL, idc));
3499# else /* Win16 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00003500 SetClassWord(s_textArea, GCW_HCURSOR, (WORD)LoadCursor(NULL, idc));
3501# endif
3502#endif
3503 if (!p_mh)
3504 {
3505 POINT mp;
3506
3507 /* Set the position to make it redrawn with the new shape. */
3508 (void)GetCursorPos((LPPOINT)&mp);
3509 (void)SetCursorPos(mp.x, mp.y);
3510 ShowCursor(TRUE);
3511 }
3512 }
3513}
3514#endif
3515
3516#ifdef FEAT_BROWSE
3517/*
3518 * The file browser exists in two versions: with "W" uses wide characters,
3519 * without "W" the current codepage. When FEAT_MBYTE is defined and on
3520 * Windows NT/2000/XP the "W" functions are used.
3521 */
3522
3523# if defined(FEAT_MBYTE) && defined(WIN3264)
3524/*
Bram Moolenaar3ef7cdf2012-01-20 17:57:51 +01003525 * Wide version of convert_filter().
Bram Moolenaar071d4272004-06-13 20:20:40 +00003526 */
3527 static WCHAR *
3528convert_filterW(char_u *s)
3529{
Bram Moolenaar3ef7cdf2012-01-20 17:57:51 +01003530 char_u *tmp;
3531 int len;
Bram Moolenaar90b28002012-01-20 20:54:19 +01003532 WCHAR *res;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003533
Bram Moolenaar3ef7cdf2012-01-20 17:57:51 +01003534 tmp = convert_filter(s);
3535 if (tmp == NULL)
3536 return NULL;
3537 len = (int)STRLEN(s) + 3;
3538 res = enc_to_utf16(tmp, &len);
3539 vim_free(tmp);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003540 return res;
3541}
3542
3543/*
3544 * Wide version of gui_mch_browse(). Keep in sync!
3545 */
3546 static char_u *
3547gui_mch_browseW(
3548 int saving,
3549 char_u *title,
3550 char_u *dflt,
3551 char_u *ext,
3552 char_u *initdir,
3553 char_u *filter)
3554{
Bram Moolenaar36f692d2008-11-20 16:10:17 +00003555 /* We always use the wide function. This means enc_to_utf16() must work,
Bram Moolenaar071d4272004-06-13 20:20:40 +00003556 * otherwise it fails miserably! */
3557 OPENFILENAMEW fileStruct;
3558 WCHAR fileBuf[MAXPATHL];
3559 WCHAR *wp;
3560 int i;
3561 WCHAR *titlep = NULL;
3562 WCHAR *extp = NULL;
3563 WCHAR *initdirp = NULL;
3564 WCHAR *filterp;
3565 char_u *p;
3566
3567 if (dflt == NULL)
3568 fileBuf[0] = NUL;
3569 else
3570 {
Bram Moolenaar36f692d2008-11-20 16:10:17 +00003571 wp = enc_to_utf16(dflt, NULL);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003572 if (wp == NULL)
3573 fileBuf[0] = NUL;
3574 else
3575 {
3576 for (i = 0; wp[i] != NUL && i < MAXPATHL - 1; ++i)
3577 fileBuf[i] = wp[i];
3578 fileBuf[i] = NUL;
3579 vim_free(wp);
3580 }
3581 }
3582
3583 /* Convert the filter to Windows format. */
3584 filterp = convert_filterW(filter);
3585
Bram Moolenaar7db5fc82010-05-24 11:59:29 +02003586 vim_memset(&fileStruct, 0, sizeof(OPENFILENAMEW));
Bram Moolenaar071d4272004-06-13 20:20:40 +00003587#ifdef OPENFILENAME_SIZE_VERSION_400
3588 /* be compatible with Windows NT 4.0 */
3589 /* TODO: what to use for OPENFILENAMEW??? */
Bram Moolenaar8c83ac32010-02-17 17:34:43 +01003590 fileStruct.lStructSize = OPENFILENAME_SIZE_VERSION_400;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003591#else
3592 fileStruct.lStructSize = sizeof(fileStruct);
3593#endif
3594
3595 if (title != NULL)
Bram Moolenaar36f692d2008-11-20 16:10:17 +00003596 titlep = enc_to_utf16(title, NULL);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003597 fileStruct.lpstrTitle = titlep;
3598
3599 if (ext != NULL)
Bram Moolenaar36f692d2008-11-20 16:10:17 +00003600 extp = enc_to_utf16(ext, NULL);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003601 fileStruct.lpstrDefExt = extp;
3602
3603 fileStruct.lpstrFile = fileBuf;
3604 fileStruct.nMaxFile = MAXPATHL;
3605 fileStruct.lpstrFilter = filterp;
3606 fileStruct.hwndOwner = s_hwnd; /* main Vim window is owner*/
3607 /* has an initial dir been specified? */
3608 if (initdir != NULL && *initdir != NUL)
3609 {
3610 /* Must have backslashes here, no matter what 'shellslash' says */
Bram Moolenaar36f692d2008-11-20 16:10:17 +00003611 initdirp = enc_to_utf16(initdir, NULL);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003612 if (initdirp != NULL)
3613 {
3614 for (wp = initdirp; *wp != NUL; ++wp)
3615 if (*wp == '/')
3616 *wp = '\\';
3617 }
3618 fileStruct.lpstrInitialDir = initdirp;
3619 }
3620
3621 /*
3622 * TODO: Allow selection of multiple files. Needs another arg to this
3623 * function to ask for it, and need to use OFN_ALLOWMULTISELECT below.
3624 * Also, should we use OFN_FILEMUSTEXIST when opening? Vim can edit on
3625 * files that don't exist yet, so I haven't put it in. What about
3626 * OFN_PATHMUSTEXIST?
3627 * Don't use OFN_OVERWRITEPROMPT, Vim has its own ":confirm" dialog.
3628 */
3629 fileStruct.Flags = (OFN_NOCHANGEDIR | OFN_PATHMUSTEXIST | OFN_HIDEREADONLY);
3630#ifdef FEAT_SHORTCUT
3631 if (curbuf->b_p_bin)
3632 fileStruct.Flags |= OFN_NODEREFERENCELINKS;
3633#endif
3634 if (saving)
3635 {
3636 if (!GetSaveFileNameW(&fileStruct))
3637 return NULL;
3638 }
3639 else
3640 {
3641 if (!GetOpenFileNameW(&fileStruct))
3642 return NULL;
3643 }
3644
3645 vim_free(filterp);
3646 vim_free(initdirp);
3647 vim_free(titlep);
3648 vim_free(extp);
3649
3650 /* Convert from UCS2 to 'encoding'. */
Bram Moolenaar36f692d2008-11-20 16:10:17 +00003651 p = utf16_to_enc(fileBuf, NULL);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003652 if (p != NULL)
3653 /* when out of memory we get garbage for non-ASCII chars */
3654 STRCPY(fileBuf, p);
3655 vim_free(p);
3656
3657 /* Give focus back to main window (when using MDI). */
3658 SetFocus(s_hwnd);
3659
3660 /* Shorten the file name if possible */
Bram Moolenaard089d9b2007-09-30 12:02:55 +00003661 return vim_strsave(shorten_fname1((char_u *)fileBuf));
Bram Moolenaar071d4272004-06-13 20:20:40 +00003662}
3663# endif /* FEAT_MBYTE */
3664
3665
3666/*
3667 * Convert the string s to the proper format for a filter string by replacing
Bram Moolenaar12806c82008-11-12 12:36:30 +00003668 * the \t and \n delimiters with \0.
Bram Moolenaar071d4272004-06-13 20:20:40 +00003669 * Returns the converted string in allocated memory.
3670 *
3671 * Keep in sync with convert_filterW() above!
3672 */
3673 static char_u *
3674convert_filter(char_u *s)
3675{
3676 char_u *res;
3677 unsigned s_len = (unsigned)STRLEN(s);
3678 unsigned i;
3679
3680 res = alloc(s_len + 3);
3681 if (res != NULL)
3682 {
3683 for (i = 0; i < s_len; ++i)
3684 if (s[i] == '\t' || s[i] == '\n')
3685 res[i] = '\0';
3686 else
3687 res[i] = s[i];
3688 res[s_len] = NUL;
3689 /* Add two extra NULs to make sure it's properly terminated. */
3690 res[s_len + 1] = NUL;
3691 res[s_len + 2] = NUL;
3692 }
3693 return res;
3694}
3695
3696/*
Bram Moolenaar7171abe2004-10-11 10:06:20 +00003697 * Select a directory.
3698 */
3699 char_u *
3700gui_mch_browsedir(char_u *title, char_u *initdir)
3701{
3702 /* We fake this: Use a filter that doesn't select anything and a default
3703 * file name that won't be used. */
3704 return gui_mch_browse(0, title, (char_u *)_("Not Used"), NULL,
3705 initdir, (char_u *)_("Directory\t*.nothing\n"));
3706}
3707
3708/*
Bram Moolenaar071d4272004-06-13 20:20:40 +00003709 * Pop open a file browser and return the file selected, in allocated memory,
3710 * or NULL if Cancel is hit.
3711 * saving - TRUE if the file will be saved to, FALSE if it will be opened.
3712 * title - Title message for the file browser dialog.
3713 * dflt - Default name of file.
3714 * ext - Default extension to be added to files without extensions.
3715 * initdir - directory in which to open the browser (NULL = current dir)
3716 * filter - Filter for matched files to choose from.
3717 *
3718 * Keep in sync with gui_mch_browseW() above!
3719 */
3720 char_u *
3721gui_mch_browse(
3722 int saving,
3723 char_u *title,
3724 char_u *dflt,
3725 char_u *ext,
3726 char_u *initdir,
3727 char_u *filter)
3728{
3729 OPENFILENAME fileStruct;
3730 char_u fileBuf[MAXPATHL];
3731 char_u *initdirp = NULL;
3732 char_u *filterp;
3733 char_u *p;
3734
3735# if defined(FEAT_MBYTE) && defined(WIN3264)
3736 if (os_version.dwPlatformId == VER_PLATFORM_WIN32_NT)
3737 return gui_mch_browseW(saving, title, dflt, ext, initdir, filter);
3738# endif
3739
3740 if (dflt == NULL)
3741 fileBuf[0] = NUL;
3742 else
Bram Moolenaarfe3ca8d2005-07-18 21:43:02 +00003743 vim_strncpy(fileBuf, dflt, MAXPATHL - 1);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003744
3745 /* Convert the filter to Windows format. */
3746 filterp = convert_filter(filter);
3747
Bram Moolenaar7db5fc82010-05-24 11:59:29 +02003748 vim_memset(&fileStruct, 0, sizeof(OPENFILENAME));
Bram Moolenaar071d4272004-06-13 20:20:40 +00003749#ifdef OPENFILENAME_SIZE_VERSION_400
3750 /* be compatible with Windows NT 4.0 */
Bram Moolenaar8c83ac32010-02-17 17:34:43 +01003751 fileStruct.lStructSize = OPENFILENAME_SIZE_VERSION_400;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003752#else
3753 fileStruct.lStructSize = sizeof(fileStruct);
3754#endif
3755
3756 fileStruct.lpstrTitle = title;
3757 fileStruct.lpstrDefExt = ext;
3758
3759 fileStruct.lpstrFile = fileBuf;
3760 fileStruct.nMaxFile = MAXPATHL;
3761 fileStruct.lpstrFilter = filterp;
3762 fileStruct.hwndOwner = s_hwnd; /* main Vim window is owner*/
3763 /* has an initial dir been specified? */
3764 if (initdir != NULL && *initdir != NUL)
3765 {
3766 /* Must have backslashes here, no matter what 'shellslash' says */
3767 initdirp = vim_strsave(initdir);
3768 if (initdirp != NULL)
3769 for (p = initdirp; *p != NUL; ++p)
3770 if (*p == '/')
3771 *p = '\\';
3772 fileStruct.lpstrInitialDir = initdirp;
3773 }
3774
3775 /*
3776 * TODO: Allow selection of multiple files. Needs another arg to this
3777 * function to ask for it, and need to use OFN_ALLOWMULTISELECT below.
3778 * Also, should we use OFN_FILEMUSTEXIST when opening? Vim can edit on
3779 * files that don't exist yet, so I haven't put it in. What about
3780 * OFN_PATHMUSTEXIST?
3781 * Don't use OFN_OVERWRITEPROMPT, Vim has its own ":confirm" dialog.
3782 */
3783 fileStruct.Flags = (OFN_NOCHANGEDIR | OFN_PATHMUSTEXIST | OFN_HIDEREADONLY);
3784#ifdef FEAT_SHORTCUT
3785 if (curbuf->b_p_bin)
3786 fileStruct.Flags |= OFN_NODEREFERENCELINKS;
3787#endif
3788 if (saving)
3789 {
3790 if (!GetSaveFileName(&fileStruct))
3791 return NULL;
3792 }
3793 else
3794 {
3795 if (!GetOpenFileName(&fileStruct))
3796 return NULL;
3797 }
3798
3799 vim_free(filterp);
3800 vim_free(initdirp);
3801
3802 /* Give focus back to main window (when using MDI). */
3803 SetFocus(s_hwnd);
3804
3805 /* Shorten the file name if possible */
Bram Moolenaard089d9b2007-09-30 12:02:55 +00003806 return vim_strsave(shorten_fname1((char_u *)fileBuf));
Bram Moolenaar071d4272004-06-13 20:20:40 +00003807}
3808#endif /* FEAT_BROWSE */
3809
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00003810/*ARGSUSED*/
Bram Moolenaar071d4272004-06-13 20:20:40 +00003811 static void
3812_OnDropFiles(
3813 HWND hwnd,
3814 HDROP hDrop)
3815{
3816#ifdef FEAT_WINDOWS
3817#ifdef WIN3264
3818# define BUFPATHLEN _MAX_PATH
3819# define DRAGQVAL 0xFFFFFFFF
3820#else
3821# define BUFPATHLEN MAXPATHL
3822# define DRAGQVAL 0xFFFF
3823#endif
3824#ifdef FEAT_MBYTE
3825 WCHAR wszFile[BUFPATHLEN];
3826#endif
3827 char szFile[BUFPATHLEN];
3828 UINT cFiles = DragQueryFile(hDrop, DRAGQVAL, NULL, 0);
3829 UINT i;
3830 char_u **fnames;
3831 POINT pt;
3832 int_u modifiers = 0;
3833
3834 /* TRACE("_OnDropFiles: %d files dropped\n", cFiles); */
3835
3836 /* Obtain dropped position */
3837 DragQueryPoint(hDrop, &pt);
3838 MapWindowPoints(s_hwnd, s_textArea, &pt, 1);
3839
Bram Moolenaar071d4272004-06-13 20:20:40 +00003840 reset_VIsual();
Bram Moolenaar071d4272004-06-13 20:20:40 +00003841
3842 fnames = (char_u **)alloc(cFiles * sizeof(char_u *));
3843
3844 if (fnames != NULL)
3845 for (i = 0; i < cFiles; ++i)
3846 {
3847#ifdef FEAT_MBYTE
3848 if (DragQueryFileW(hDrop, i, wszFile, BUFPATHLEN) > 0)
Bram Moolenaar36f692d2008-11-20 16:10:17 +00003849 fnames[i] = utf16_to_enc(wszFile, NULL);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003850 else
3851#endif
3852 {
3853 DragQueryFile(hDrop, i, szFile, BUFPATHLEN);
3854 fnames[i] = vim_strsave(szFile);
3855 }
3856 }
3857
3858 DragFinish(hDrop);
3859
3860 if (fnames != NULL)
3861 {
3862 if ((GetKeyState(VK_SHIFT) & 0x8000) != 0)
3863 modifiers |= MOUSE_SHIFT;
3864 if ((GetKeyState(VK_CONTROL) & 0x8000) != 0)
3865 modifiers |= MOUSE_CTRL;
3866 if ((GetKeyState(VK_MENU) & 0x8000) != 0)
3867 modifiers |= MOUSE_ALT;
3868
3869 gui_handle_drop(pt.x, pt.y, modifiers, fnames, cFiles);
3870
3871 s_need_activate = TRUE;
3872 }
3873#endif
3874}
3875
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00003876/*ARGSUSED*/
Bram Moolenaar071d4272004-06-13 20:20:40 +00003877 static int
3878_OnScroll(
3879 HWND hwnd,
3880 HWND hwndCtl,
3881 UINT code,
3882 int pos)
3883{
3884 static UINT prev_code = 0; /* code of previous call */
3885 scrollbar_T *sb, *sb_info;
3886 long val;
3887 int dragging = FALSE;
3888 int dont_scroll_save = dont_scroll;
3889#ifndef WIN3264
3890 int nPos;
3891#else
3892 SCROLLINFO si;
3893
3894 si.cbSize = sizeof(si);
3895 si.fMask = SIF_POS;
3896#endif
3897
3898 sb = gui_mswin_find_scrollbar(hwndCtl);
3899 if (sb == NULL)
3900 return 0;
3901
3902 if (sb->wp != NULL) /* Left or right scrollbar */
3903 {
3904 /*
3905 * Careful: need to get scrollbar info out of first (left) scrollbar
3906 * for window, but keep real scrollbar too because we must pass it to
3907 * gui_drag_scrollbar().
3908 */
3909 sb_info = &sb->wp->w_scrollbars[0];
3910 }
3911 else /* Bottom scrollbar */
3912 sb_info = sb;
3913 val = sb_info->value;
3914
3915 switch (code)
3916 {
3917 case SB_THUMBTRACK:
3918 val = pos;
3919 dragging = TRUE;
3920 if (sb->scroll_shift > 0)
3921 val <<= sb->scroll_shift;
3922 break;
3923 case SB_LINEDOWN:
3924 val++;
3925 break;
3926 case SB_LINEUP:
3927 val--;
3928 break;
3929 case SB_PAGEDOWN:
3930 val += (sb_info->size > 2 ? sb_info->size - 2 : 1);
3931 break;
3932 case SB_PAGEUP:
3933 val -= (sb_info->size > 2 ? sb_info->size - 2 : 1);
3934 break;
3935 case SB_TOP:
3936 val = 0;
3937 break;
3938 case SB_BOTTOM:
3939 val = sb_info->max;
3940 break;
3941 case SB_ENDSCROLL:
3942 if (prev_code == SB_THUMBTRACK)
3943 {
3944 /*
3945 * "pos" only gives us 16-bit data. In case of large file,
3946 * use GetScrollPos() which returns 32-bit. Unfortunately it
3947 * is not valid while the scrollbar is being dragged.
3948 */
3949 val = GetScrollPos(hwndCtl, SB_CTL);
3950 if (sb->scroll_shift > 0)
3951 val <<= sb->scroll_shift;
3952 }
3953 break;
3954
3955 default:
3956 /* TRACE("Unknown scrollbar event %d\n", code); */
3957 return 0;
3958 }
3959 prev_code = code;
3960
3961#ifdef WIN3264
3962 si.nPos = (sb->scroll_shift > 0) ? val >> sb->scroll_shift : val;
3963 SetScrollInfo(hwndCtl, SB_CTL, &si, TRUE);
3964#else
3965 nPos = (sb->scroll_shift > 0) ? val >> sb->scroll_shift : val;
3966 SetScrollPos(hwndCtl, SB_CTL, nPos, TRUE);
3967#endif
3968
3969 /*
3970 * When moving a vertical scrollbar, move the other vertical scrollbar too.
3971 */
3972 if (sb->wp != NULL)
3973 {
3974 scrollbar_T *sba = sb->wp->w_scrollbars;
3975 HWND id = sba[ (sb == sba + SBAR_LEFT) ? SBAR_RIGHT : SBAR_LEFT].id;
3976
3977#ifdef WIN3264
3978 SetScrollInfo(id, SB_CTL, &si, TRUE);
3979#else
3980 SetScrollPos(id, SB_CTL, nPos, TRUE);
3981#endif
3982 }
3983
3984 /* Don't let us be interrupted here by another message. */
3985 s_busy_processing = TRUE;
3986
3987 /* When "allow_scrollbar" is FALSE still need to remember the new
3988 * position, but don't actually scroll by setting "dont_scroll". */
3989 dont_scroll = !allow_scrollbar;
3990
3991 gui_drag_scrollbar(sb, val, dragging);
3992
3993 s_busy_processing = FALSE;
3994 dont_scroll = dont_scroll_save;
3995
3996 return 0;
3997}
3998
Bram Moolenaar3fdfa4a2004-10-07 21:02:47 +00003999
Bram Moolenaar071d4272004-06-13 20:20:40 +00004000/*
4001 * Get command line arguments.
4002 * Use "prog" as the name of the program and "cmdline" as the arguments.
4003 * Copy the arguments to allocated memory.
4004 * Return the number of arguments (including program name).
Bram Moolenaar12806c82008-11-12 12:36:30 +00004005 * Return pointers to the arguments in "argvp". Memory is allocated with
4006 * malloc(), use free() instead of vim_free().
Bram Moolenaar071d4272004-06-13 20:20:40 +00004007 * Return pointer to buffer in "tofree".
4008 * Returns zero when out of memory.
4009 */
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00004010/*ARGSUSED*/
Bram Moolenaar071d4272004-06-13 20:20:40 +00004011 int
4012get_cmd_args(char *prog, char *cmdline, char ***argvp, char **tofree)
4013{
4014 int i;
4015 char *p;
4016 char *progp;
4017 char *pnew = NULL;
4018 char *newcmdline;
4019 int inquote;
4020 int argc;
4021 char **argv = NULL;
4022 int round;
4023
Bram Moolenaar12806c82008-11-12 12:36:30 +00004024 *tofree = NULL;
4025
Bram Moolenaar3fdfa4a2004-10-07 21:02:47 +00004026#ifdef FEAT_MBYTE
4027 /* Try using the Unicode version first, it takes care of conversion when
4028 * 'encoding' is changed. */
4029 argc = get_cmd_argsW(&argv);
4030 if (argc != 0)
4031 goto done;
4032#endif
4033
Bram Moolenaar071d4272004-06-13 20:20:40 +00004034 /* Handle the program name. Remove the ".exe" extension, and find the 1st
4035 * non-space. */
4036 p = strrchr(prog, '.');
4037 if (p != NULL)
4038 *p = NUL;
4039 for (progp = prog; *progp == ' '; ++progp)
4040 ;
4041
4042 /* The command line is copied to allocated memory, so that we can change
4043 * it. Add the size of the string, the separating NUL and a terminating
4044 * NUL. */
4045 newcmdline = malloc(STRLEN(cmdline) + STRLEN(progp) + 2);
4046 if (newcmdline == NULL)
4047 return 0;
4048
4049 /*
4050 * First round: count the number of arguments ("pnew" == NULL).
4051 * Second round: produce the arguments.
4052 */
4053 for (round = 1; round <= 2; ++round)
4054 {
4055 /* First argument is the program name. */
4056 if (pnew != NULL)
4057 {
4058 argv[0] = pnew;
4059 strcpy(pnew, progp);
4060 pnew += strlen(pnew);
4061 *pnew++ = NUL;
4062 }
4063
4064 /*
4065 * Isolate each argument and put it in argv[].
4066 */
4067 p = cmdline;
4068 argc = 1;
4069 while (*p != NUL)
4070 {
4071 inquote = FALSE;
4072 if (pnew != NULL)
4073 argv[argc] = pnew;
4074 ++argc;
4075 while (*p != NUL && (inquote || (*p != ' ' && *p != '\t')))
4076 {
4077 /* Backslashes are only special when followed by a double
4078 * quote. */
Bram Moolenaara93fa7e2006-04-17 22:14:47 +00004079 i = (int)strspn(p, "\\");
Bram Moolenaar071d4272004-06-13 20:20:40 +00004080 if (p[i] == '"')
4081 {
4082 /* Halve the number of backslashes. */
4083 if (i > 1 && pnew != NULL)
4084 {
Bram Moolenaar7db5fc82010-05-24 11:59:29 +02004085 vim_memset(pnew, '\\', i / 2);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004086 pnew += i / 2;
4087 }
4088
4089 /* Even nr of backslashes toggles quoting, uneven copies
4090 * the double quote. */
4091 if ((i & 1) == 0)
4092 inquote = !inquote;
4093 else if (pnew != NULL)
4094 *pnew++ = '"';
4095 p += i + 1;
4096 }
4097 else if (i > 0)
4098 {
4099 /* Copy span of backslashes unmodified. */
4100 if (pnew != NULL)
4101 {
Bram Moolenaar7db5fc82010-05-24 11:59:29 +02004102 vim_memset(pnew, '\\', i);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004103 pnew += i;
4104 }
4105 p += i;
4106 }
4107 else
4108 {
4109 if (pnew != NULL)
4110 *pnew++ = *p;
Bram Moolenaar15d0a8c2004-09-06 17:44:46 +00004111#ifdef FEAT_MBYTE
4112 /* Can't use mb_* functions, because 'encoding' is not
4113 * initialized yet here. */
4114 if (IsDBCSLeadByte(*p))
4115 {
4116 ++p;
4117 if (pnew != NULL)
4118 *pnew++ = *p;
4119 }
4120#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00004121 ++p;
4122 }
4123 }
4124
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00004125 if (pnew != NULL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004126 *pnew++ = NUL;
4127 while (*p == ' ' || *p == '\t')
4128 ++p; /* advance until a non-space */
4129 }
4130
4131 if (round == 1)
4132 {
4133 argv = (char **)malloc((argc + 1) * sizeof(char *));
4134 if (argv == NULL )
Bram Moolenaare6b165e2005-06-30 21:56:01 +00004135 {
Bram Moolenaar12806c82008-11-12 12:36:30 +00004136 free(newcmdline);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004137 return 0; /* malloc error */
Bram Moolenaare6b165e2005-06-30 21:56:01 +00004138 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00004139 pnew = newcmdline;
Bram Moolenaar12806c82008-11-12 12:36:30 +00004140 *tofree = newcmdline;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004141 }
4142 }
4143
Bram Moolenaar8765a4a2010-07-27 22:41:43 +02004144#ifdef FEAT_MBYTE
Bram Moolenaar3fdfa4a2004-10-07 21:02:47 +00004145done:
Bram Moolenaar8765a4a2010-07-27 22:41:43 +02004146#endif
Bram Moolenaar3fdfa4a2004-10-07 21:02:47 +00004147 argv[argc] = NULL; /* NULL-terminated list */
Bram Moolenaar071d4272004-06-13 20:20:40 +00004148 *argvp = argv;
4149 return argc;
4150}