blob: 4de0c763921a5bd1e9c2ccb6c7064a5b575bd287 [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
28#ifndef __MINGW32__
29# include <shellapi.h>
30#endif
Bram Moolenaar3991dab2006-03-27 17:01:56 +000031#if defined(FEAT_TOOLBAR) || defined(FEAT_BEVAL) || defined(FEAT_GUI_TABLINE)
Bram Moolenaar071d4272004-06-13 20:20:40 +000032# include <commctrl.h>
33#endif
34#ifdef WIN16
35# include <commdlg.h>
36# include <shellapi.h>
37# ifdef WIN16_3DLOOK
38# include <ctl3d.h>
39# endif
40#endif
41#include <windowsx.h>
42
43#ifdef GLOBAL_IME
44# include "glbl_ime.h"
45#endif
46
47#ifdef FEAT_MENU
48# define MENUHINTS /* show menu hints in command line */
49#endif
50
51/* Some parameters for dialog boxes. All in pixels. */
52#define DLG_PADDING_X 10
53#define DLG_PADDING_Y 10
54#define DLG_OLD_STYLE_PADDING_X 5
55#define DLG_OLD_STYLE_PADDING_Y 5
56#define DLG_VERT_PADDING_X 4 /* For vertical buttons */
57#define DLG_VERT_PADDING_Y 4
58#define DLG_ICON_WIDTH 34
59#define DLG_ICON_HEIGHT 34
60#define DLG_MIN_WIDTH 150
61#define DLG_FONT_NAME "MS Sans Serif"
62#define DLG_FONT_POINT_SIZE 8
63#define DLG_MIN_MAX_WIDTH 400
Bram Moolenaar748bf032005-02-02 23:04:36 +000064#define DLG_MIN_MAX_HEIGHT 400
Bram Moolenaar071d4272004-06-13 20:20:40 +000065
66#define DLG_NONBUTTON_CONTROL 5000 /* First ID of non-button controls */
67
68#ifndef WM_XBUTTONDOWN /* For Win2K / winME ONLY */
69# define WM_XBUTTONDOWN 0x020B
70# define WM_XBUTTONUP 0x020C
71# define WM_XBUTTONDBLCLK 0x020D
72# define MK_XBUTTON1 0x0020
73# define MK_XBUTTON2 0x0040
74#endif
75
76#ifdef PROTO
77/*
78 * Define a few things for generating prototypes. This is just to avoid
79 * syntax errors, the defines do not need to be correct.
80 */
81# define APIENTRY
82# define CALLBACK
83# define CONST
84# define FAR
85# define NEAR
86# define _cdecl
87typedef int BOOL;
88typedef int BYTE;
89typedef int DWORD;
90typedef int WCHAR;
91typedef int ENUMLOGFONT;
92typedef int FINDREPLACE;
93typedef int HANDLE;
94typedef int HBITMAP;
95typedef int HBRUSH;
96typedef int HDROP;
97typedef int INT;
98typedef int LOGFONT[];
99typedef int LPARAM;
100typedef int LPCREATESTRUCT;
101typedef int LPCSTR;
102typedef int LPCTSTR;
103typedef int LPRECT;
104typedef int LPSTR;
105typedef int LPWINDOWPOS;
106typedef int LPWORD;
107typedef int LRESULT;
Bram Moolenaare344bea2005-09-01 20:46:49 +0000108typedef int HRESULT;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000109# undef MSG
110typedef int MSG;
111typedef int NEWTEXTMETRIC;
112typedef int OSVERSIONINFO;
113typedef int PWORD;
114typedef int RECT;
115typedef int UINT;
116typedef int WORD;
117typedef int WPARAM;
118typedef int POINT;
119typedef void *HINSTANCE;
120typedef void *HMENU;
121typedef void *HWND;
122typedef void *HDC;
123typedef void VOID;
124typedef int LPNMHDR;
125typedef int LONG;
126#endif
127
128#ifndef GET_X_LPARAM
129# define GET_X_LPARAM(lp) ((int)(short)LOWORD(lp))
130#endif
131
132static void _OnPaint( HWND hwnd);
133static void clear_rect(RECT *rcp);
134static int gui_mswin_get_menu_height(int fix_window);
135
136static WORD s_dlgfntheight; /* height of the dialog font */
137static WORD s_dlgfntwidth; /* width of the dialog font */
138
139#ifdef FEAT_MENU
140static HMENU s_menuBar = NULL;
141#endif
142#ifdef FEAT_TEAROFF
143static void rebuild_tearoff(vimmenu_T *menu);
144static HBITMAP s_htearbitmap; /* bitmap used to indicate tearoff */
145#endif
146
Bram Moolenaar48687262007-05-10 17:17:07 +0000147/* Flag that is set while processing a message that must not be interrupted by
Bram Moolenaar071d4272004-06-13 20:20:40 +0000148 * processing another message. */
149static int s_busy_processing = FALSE;
150
151static int destroying = FALSE; /* call DestroyWindow() ourselves */
152
153#ifdef MSWIN_FIND_REPLACE
154static UINT s_findrep_msg = 0; /* set in gui_w[16/32].c */
155static FINDREPLACE s_findrep_struct;
156static HWND s_findrep_hwnd = NULL;
157static int s_findrep_is_find; /* TRUE for find dialog, FALSE
158 for find/replace dialog */
159#endif
160
161static HINSTANCE s_hinst = NULL;
162#if !defined(FEAT_SNIFF) && !defined(FEAT_GUI)
163static
164#endif
165HWND s_hwnd = NULL;
166static HDC s_hdc = NULL;
167static HBRUSH s_brush = NULL;
168
169#ifdef FEAT_TOOLBAR
170static HWND s_toolbarhwnd = NULL;
171#endif
172
Bram Moolenaar3991dab2006-03-27 17:01:56 +0000173#ifdef FEAT_GUI_TABLINE
174static HWND s_tabhwnd = NULL;
175static int showing_tabline = 0;
176#endif
177
Bram Moolenaar071d4272004-06-13 20:20:40 +0000178static WPARAM s_wParam = 0;
179static LPARAM s_lParam = 0;
180
181static HWND s_textArea = NULL;
182static UINT s_uMsg = 0;
183
184static char_u *s_textfield; /* Used by dialogs to pass back strings */
185
186static int s_need_activate = FALSE;
187
188/* This variable is set when waiting for an event, which is the only moment
189 * scrollbar dragging can be done directly. It's not allowed while commands
190 * are executed, because it may move the cursor and that may cause unexpected
191 * problems (e.g., while ":s" is working).
192 */
193static int allow_scrollbar = FALSE;
194
195#ifdef GLOBAL_IME
196# define MyTranslateMessage(x) global_ime_TranslateMessage(x)
197#else
198# define MyTranslateMessage(x) TranslateMessage(x)
199#endif
200
201#if (defined(WIN3264) && defined(FEAT_MBYTE)) || defined(GLOBAL_IME)
202 /* use of WindowProc depends on wide_WindowProc */
203# define MyWindowProc vim_WindowProc
204#else
205 /* use ordinary WindowProc */
206# define MyWindowProc DefWindowProc
207#endif
208
209extern int current_font_height; /* this is in os_mswin.c */
210
211static struct
212{
213 UINT key_sym;
214 char_u vim_code0;
215 char_u vim_code1;
216} special_keys[] =
217{
218 {VK_UP, 'k', 'u'},
219 {VK_DOWN, 'k', 'd'},
220 {VK_LEFT, 'k', 'l'},
221 {VK_RIGHT, 'k', 'r'},
222
223 {VK_F1, 'k', '1'},
224 {VK_F2, 'k', '2'},
225 {VK_F3, 'k', '3'},
226 {VK_F4, 'k', '4'},
227 {VK_F5, 'k', '5'},
228 {VK_F6, 'k', '6'},
229 {VK_F7, 'k', '7'},
230 {VK_F8, 'k', '8'},
231 {VK_F9, 'k', '9'},
232 {VK_F10, 'k', ';'},
233
234 {VK_F11, 'F', '1'},
235 {VK_F12, 'F', '2'},
236 {VK_F13, 'F', '3'},
237 {VK_F14, 'F', '4'},
238 {VK_F15, 'F', '5'},
239 {VK_F16, 'F', '6'},
240 {VK_F17, 'F', '7'},
241 {VK_F18, 'F', '8'},
242 {VK_F19, 'F', '9'},
243 {VK_F20, 'F', 'A'},
244
245 {VK_F21, 'F', 'B'},
246#ifdef FEAT_NETBEANS_INTG
247 {VK_PAUSE, 'F', 'B'}, /* Pause == F21 (see gui_gtk_x11.c) */
248#endif
249 {VK_F22, 'F', 'C'},
250 {VK_F23, 'F', 'D'},
251 {VK_F24, 'F', 'E'}, /* winuser.h defines up to F24 */
252
253 {VK_HELP, '%', '1'},
254 {VK_BACK, 'k', 'b'},
255 {VK_INSERT, 'k', 'I'},
256 {VK_DELETE, 'k', 'D'},
257 {VK_HOME, 'k', 'h'},
258 {VK_END, '@', '7'},
259 {VK_PRIOR, 'k', 'P'},
260 {VK_NEXT, 'k', 'N'},
261 {VK_PRINT, '%', '9'},
262 {VK_ADD, 'K', '6'},
263 {VK_SUBTRACT, 'K', '7'},
264 {VK_DIVIDE, 'K', '8'},
265 {VK_MULTIPLY, 'K', '9'},
266 {VK_SEPARATOR, 'K', 'A'}, /* Keypad Enter */
267 {VK_DECIMAL, 'K', 'B'},
268
269 {VK_NUMPAD0, 'K', 'C'},
270 {VK_NUMPAD1, 'K', 'D'},
271 {VK_NUMPAD2, 'K', 'E'},
272 {VK_NUMPAD3, 'K', 'F'},
273 {VK_NUMPAD4, 'K', 'G'},
274 {VK_NUMPAD5, 'K', 'H'},
275 {VK_NUMPAD6, 'K', 'I'},
276 {VK_NUMPAD7, 'K', 'J'},
277 {VK_NUMPAD8, 'K', 'K'},
278 {VK_NUMPAD9, 'K', 'L'},
279
280 /* Keys that we want to be able to use any modifier with: */
281 {VK_SPACE, ' ', NUL},
282 {VK_TAB, TAB, NUL},
283 {VK_ESCAPE, ESC, NUL},
284 {NL, NL, NUL},
285 {CAR, CAR, NUL},
286
287 /* End of list marker: */
288 {0, 0, 0}
289};
290
291/* Local variables */
292static int s_button_pending = -1;
Bram Moolenaarea408882007-12-03 21:21:03 +0000293
294/* s_getting_focus is set when we got focus but didn't see mouse-up event yet,
295 * so don't reset s_button_pending. */
296static int s_getting_focus = FALSE;
297
Bram Moolenaar071d4272004-06-13 20:20:40 +0000298static int s_x_pending;
299static int s_y_pending;
300static UINT s_kFlags_pending;
301static UINT s_wait_timer = 0; /* Timer for get char from user */
302static int s_timed_out = FALSE;
303static int dead_key = 0; /* 0 - no dead key, 1 - dead key pressed */
304
305#ifdef WIN3264
306static OSVERSIONINFO os_version; /* like it says. Init in gui_mch_init() */
307#endif
308
309#ifdef FEAT_BEVAL
310/* balloon-eval WM_NOTIFY_HANDLER */
311static void Handle_WM_Notify __ARGS((HWND hwnd, LPNMHDR pnmh));
312static void TrackUserActivity __ARGS((UINT uMsg));
313#endif
314
315/*
316 * For control IME.
317 */
318#ifdef FEAT_MBYTE
319# ifdef USE_IM_CONTROL
320static LOGFONT norm_logfont;
321# endif
322#endif
323
324#ifdef FEAT_MBYTE_IME
325static LRESULT _OnImeNotify(HWND hWnd, DWORD dwCommand, DWORD dwData);
326#endif
327
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +0000328#ifdef DEBUG_PRINT_ERROR
Bram Moolenaar071d4272004-06-13 20:20:40 +0000329/*
330 * Print out the last Windows error message
331 */
332 static void
333print_windows_error(void)
334{
335 LPVOID lpMsgBuf;
336
337 FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
338 NULL, GetLastError(),
339 MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
340 (LPTSTR) &lpMsgBuf, 0, NULL);
341 TRACE1("Error: %s\n", lpMsgBuf);
342 LocalFree(lpMsgBuf);
343}
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +0000344#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +0000345
346/*
347 * Cursor blink functions.
348 *
349 * This is a simple state machine:
350 * BLINK_NONE not blinking at all
351 * BLINK_OFF blinking, cursor is not shown
352 * BLINK_ON blinking, cursor is shown
353 */
354
355#define BLINK_NONE 0
356#define BLINK_OFF 1
357#define BLINK_ON 2
358
359static int blink_state = BLINK_NONE;
360static long_u blink_waittime = 700;
361static long_u blink_ontime = 400;
362static long_u blink_offtime = 250;
363static UINT blink_timer = 0;
364
365 void
366gui_mch_set_blinking(long wait, long on, long off)
367{
368 blink_waittime = wait;
369 blink_ontime = on;
370 blink_offtime = off;
371}
372
373/* ARGSUSED */
374 static VOID CALLBACK
375_OnBlinkTimer(
376 HWND hwnd,
377 UINT uMsg,
378 UINT idEvent,
379 DWORD dwTime)
380{
381 MSG msg;
382
383 /*
384 TRACE2("Got timer event, id %d, blink_timer %d\n", idEvent, blink_timer);
385 */
386
387 KillTimer(NULL, idEvent);
388
389 /* Eat spurious WM_TIMER messages */
390 while (PeekMessage(&msg, hwnd, WM_TIMER, WM_TIMER, PM_REMOVE))
391 ;
392
393 if (blink_state == BLINK_ON)
394 {
395 gui_undraw_cursor();
396 blink_state = BLINK_OFF;
397 blink_timer = (UINT) SetTimer(NULL, 0, (UINT)blink_offtime,
398 (TIMERPROC)_OnBlinkTimer);
399 }
400 else
401 {
402 gui_update_cursor(TRUE, FALSE);
403 blink_state = BLINK_ON;
404 blink_timer = (UINT) SetTimer(NULL, 0, (UINT)blink_ontime,
405 (TIMERPROC)_OnBlinkTimer);
406 }
407}
408
409 static void
410gui_mswin_rm_blink_timer(void)
411{
412 MSG msg;
413
414 if (blink_timer != 0)
415 {
416 KillTimer(NULL, blink_timer);
417 /* Eat spurious WM_TIMER messages */
418 while (PeekMessage(&msg, s_hwnd, WM_TIMER, WM_TIMER, PM_REMOVE))
419 ;
420 blink_timer = 0;
421 }
422}
423
424/*
425 * Stop the cursor blinking. Show the cursor if it wasn't shown.
426 */
427 void
428gui_mch_stop_blink(void)
429{
430 gui_mswin_rm_blink_timer();
431 if (blink_state == BLINK_OFF)
432 gui_update_cursor(TRUE, FALSE);
433 blink_state = BLINK_NONE;
434}
435
436/*
437 * Start the cursor blinking. If it was already blinking, this restarts the
438 * waiting time and shows the cursor.
439 */
440 void
441gui_mch_start_blink(void)
442{
443 gui_mswin_rm_blink_timer();
444
445 /* Only switch blinking on if none of the times is zero */
446 if (blink_waittime && blink_ontime && blink_offtime && gui.in_focus)
447 {
448 blink_timer = (UINT)SetTimer(NULL, 0, (UINT)blink_waittime,
449 (TIMERPROC)_OnBlinkTimer);
450 blink_state = BLINK_ON;
451 gui_update_cursor(TRUE, FALSE);
452 }
453}
454
455/*
456 * Call-back routines.
457 */
458
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +0000459/*ARGSUSED*/
Bram Moolenaar071d4272004-06-13 20:20:40 +0000460 static VOID CALLBACK
461_OnTimer(
462 HWND hwnd,
463 UINT uMsg,
464 UINT idEvent,
465 DWORD dwTime)
466{
467 MSG msg;
468
469 /*
470 TRACE2("Got timer event, id %d, s_wait_timer %d\n", idEvent, s_wait_timer);
471 */
472 KillTimer(NULL, idEvent);
473 s_timed_out = TRUE;
474
475 /* Eat spurious WM_TIMER messages */
476 while (PeekMessage(&msg, hwnd, WM_TIMER, WM_TIMER, PM_REMOVE))
477 ;
478 if (idEvent == s_wait_timer)
479 s_wait_timer = 0;
480}
481
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +0000482/*ARGSUSED*/
Bram Moolenaar071d4272004-06-13 20:20:40 +0000483 static void
484_OnDeadChar(
485 HWND hwnd,
486 UINT ch,
487 int cRepeat)
488{
489 dead_key = 1;
490}
491
492/*
493 * Convert Unicode character "ch" to bytes in "string[slen]".
Bram Moolenaar85a3e5c2007-11-20 16:22:16 +0000494 * When "had_alt" is TRUE the ALT key was included in "ch".
Bram Moolenaar071d4272004-06-13 20:20:40 +0000495 * Return the length.
496 */
497 static int
Bram Moolenaar85a3e5c2007-11-20 16:22:16 +0000498char_to_string(int ch, char_u *string, int slen, int had_alt)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000499{
500 int len;
501 int i;
502#ifdef FEAT_MBYTE
503 WCHAR wstring[2];
504 char_u *ws = NULL;;
505
Bram Moolenaar293ee4d2004-12-09 21:34:53 +0000506 if (os_version.dwPlatformId != VER_PLATFORM_WIN32_NT)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000507 {
Bram Moolenaar293ee4d2004-12-09 21:34:53 +0000508 /* On Windows 95/98 we apparently get the character in the active
509 * codepage, not in UCS-2. If conversion is needed convert it to
510 * UCS-2 first. */
511 if ((int)GetACP() == enc_codepage)
512 len = 0; /* no conversion required */
Bram Moolenaar071d4272004-06-13 20:20:40 +0000513 else
514 {
Bram Moolenaar293ee4d2004-12-09 21:34:53 +0000515 string[0] = ch;
516 len = MultiByteToWideChar(GetACP(), 0, string, 1, wstring, 2);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000517 }
518 }
Bram Moolenaar293ee4d2004-12-09 21:34:53 +0000519 else
520 {
521 wstring[0] = ch;
522 len = 1;
523 }
524
525 if (len > 0)
526 {
527 /* "ch" is a UTF-16 character. Convert it to a string of bytes. When
528 * "enc_codepage" is non-zero use the standard Win32 function,
529 * otherwise use our own conversion function (e.g., for UTF-8). */
530 if (enc_codepage > 0)
Bram Moolenaar85a3e5c2007-11-20 16:22:16 +0000531 {
Bram Moolenaar293ee4d2004-12-09 21:34:53 +0000532 len = WideCharToMultiByte(enc_codepage, 0, wstring, len,
533 string, slen, 0, NULL);
Bram Moolenaar85a3e5c2007-11-20 16:22:16 +0000534 /* If we had included the ALT key into the character but now the
535 * upper bit is no longer set, that probably means the conversion
536 * failed. Convert the original character and set the upper bit
537 * afterwards. */
538 if (had_alt && len == 1 && ch >= 0x80 && string[0] < 0x80)
539 {
540 wstring[0] = ch & 0x7f;
541 len = WideCharToMultiByte(enc_codepage, 0, wstring, len,
542 string, slen, 0, NULL);
543 if (len == 1) /* safety check */
544 string[0] |= 0x80;
545 }
546 }
Bram Moolenaar293ee4d2004-12-09 21:34:53 +0000547 else
548 {
549 len = 1;
Bram Moolenaar36f692d2008-11-20 16:10:17 +0000550 ws = utf16_to_enc(wstring, &len);
Bram Moolenaar293ee4d2004-12-09 21:34:53 +0000551 if (ws == NULL)
552 len = 0;
553 else
554 {
555 if (len > slen) /* just in case */
556 len = slen;
557 mch_memmove(string, ws, len);
558 vim_free(ws);
559 }
560 }
561 }
562
Bram Moolenaar071d4272004-06-13 20:20:40 +0000563 if (len == 0)
564#endif
565 {
566 string[0] = ch;
567 len = 1;
568 }
569
570 for (i = 0; i < len; ++i)
571 if (string[i] == CSI && len <= slen - 2)
572 {
573 /* Insert CSI as K_CSI. */
574 mch_memmove(string + i + 3, string + i + 1, len - i - 1);
575 string[++i] = KS_EXTRA;
576 string[++i] = (int)KE_CSI;
577 len += 2;
578 }
579
580 return len;
581}
582
583/*
584 * Key hit, add it to the input buffer.
585 */
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +0000586/*ARGSUSED*/
Bram Moolenaar071d4272004-06-13 20:20:40 +0000587 static void
588_OnChar(
589 HWND hwnd,
590 UINT ch,
591 int cRepeat)
592{
593 char_u string[40];
594 int len = 0;
595
Bram Moolenaar85a3e5c2007-11-20 16:22:16 +0000596 len = char_to_string(ch, string, 40, FALSE);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000597 if (len == 1 && string[0] == Ctrl_C && ctrl_c_interrupts)
598 {
599 trash_input_buf();
600 got_int = TRUE;
601 }
602
603 add_to_input_buf(string, len);
604}
605
606/*
607 * Alt-Key hit, add it to the input buffer.
608 */
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +0000609/*ARGSUSED*/
Bram Moolenaar071d4272004-06-13 20:20:40 +0000610 static void
611_OnSysChar(
612 HWND hwnd,
613 UINT cch,
614 int cRepeat)
615{
616 char_u string[40]; /* Enough for multibyte character */
617 int len;
618 int modifiers;
619 int ch = cch; /* special keys are negative */
620
621 /* TRACE("OnSysChar(%d, %c)\n", ch, ch); */
622
623 /* OK, we have a character key (given by ch) which was entered with the
624 * ALT key pressed. Eg, if the user presses Alt-A, then ch == 'A'. Note
625 * that the system distinguishes Alt-a and Alt-A (Alt-Shift-a unless
626 * CAPSLOCK is pressed) at this point.
627 */
628 modifiers = MOD_MASK_ALT;
629 if (GetKeyState(VK_SHIFT) & 0x8000)
630 modifiers |= MOD_MASK_SHIFT;
631 if (GetKeyState(VK_CONTROL) & 0x8000)
632 modifiers |= MOD_MASK_CTRL;
633
634 ch = simplify_key(ch, &modifiers);
635 /* remove the SHIFT modifier for keys where it's already included, e.g.,
636 * '(' and '*' */
637 if (ch < 0x100 && !isalpha(ch) && isprint(ch))
638 modifiers &= ~MOD_MASK_SHIFT;
639
640 /* Interpret the ALT key as making the key META, include SHIFT, etc. */
641 ch = extract_modifiers(ch, &modifiers);
642 if (ch == CSI)
643 ch = K_CSI;
644
645 len = 0;
646 if (modifiers)
647 {
648 string[len++] = CSI;
649 string[len++] = KS_MODIFIER;
650 string[len++] = modifiers;
651 }
652
653 if (IS_SPECIAL((int)ch))
654 {
655 string[len++] = CSI;
656 string[len++] = K_SECOND((int)ch);
657 string[len++] = K_THIRD((int)ch);
658 }
659 else
660 {
661 /* Although the documentation isn't clear about it, we assume "ch" is
662 * a Unicode character. */
Bram Moolenaar85a3e5c2007-11-20 16:22:16 +0000663 len += char_to_string(ch, string + len, 40 - len, TRUE);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000664 }
665
666 add_to_input_buf(string, len);
667}
668
669 static void
670_OnMouseEvent(
671 int button,
672 int x,
673 int y,
674 int repeated_click,
675 UINT keyFlags)
676{
677 int vim_modifiers = 0x0;
678
Bram Moolenaarea408882007-12-03 21:21:03 +0000679 s_getting_focus = FALSE;
680
Bram Moolenaar071d4272004-06-13 20:20:40 +0000681 if (keyFlags & MK_SHIFT)
682 vim_modifiers |= MOUSE_SHIFT;
683 if (keyFlags & MK_CONTROL)
684 vim_modifiers |= MOUSE_CTRL;
685 if (GetKeyState(VK_MENU) & 0x8000)
686 vim_modifiers |= MOUSE_ALT;
687
688 gui_send_mouse_event(button, x, y, repeated_click, vim_modifiers);
689}
690
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +0000691/*ARGSUSED*/
Bram Moolenaar071d4272004-06-13 20:20:40 +0000692 static void
693_OnMouseButtonDown(
694 HWND hwnd,
695 BOOL fDoubleClick,
696 int x,
697 int y,
698 UINT keyFlags)
699{
700 static LONG s_prevTime = 0;
701
702 LONG currentTime = GetMessageTime();
703 int button = -1;
704 int repeated_click;
705
706 /* Give main window the focus: this is so the cursor isn't hollow. */
707 (void)SetFocus(s_hwnd);
708
709 if (s_uMsg == WM_LBUTTONDOWN || s_uMsg == WM_LBUTTONDBLCLK)
710 button = MOUSE_LEFT;
711 else if (s_uMsg == WM_MBUTTONDOWN || s_uMsg == WM_MBUTTONDBLCLK)
712 button = MOUSE_MIDDLE;
713 else if (s_uMsg == WM_RBUTTONDOWN || s_uMsg == WM_RBUTTONDBLCLK)
714 button = MOUSE_RIGHT;
715#ifndef WIN16 /*<VN>*/
716 else if (s_uMsg == WM_XBUTTONDOWN || s_uMsg == WM_XBUTTONDBLCLK)
717 {
718#ifndef GET_XBUTTON_WPARAM
719# define GET_XBUTTON_WPARAM(wParam) (HIWORD(wParam))
720#endif
721 button = ((GET_XBUTTON_WPARAM(s_wParam) == 1) ? MOUSE_X1 : MOUSE_X2);
722 }
723 else if (s_uMsg == WM_CAPTURECHANGED)
724 {
725 /* on W95/NT4, somehow you get in here with an odd Msg
726 * if you press one button while holding down the other..*/
727 if (s_button_pending == MOUSE_LEFT)
728 button = MOUSE_RIGHT;
729 else
730 button = MOUSE_LEFT;
731 }
732#endif
733 if (button >= 0)
734 {
735 repeated_click = ((int)(currentTime - s_prevTime) < p_mouset);
736
737 /*
738 * Holding down the left and right buttons simulates pushing the middle
739 * button.
740 */
Bram Moolenaar293ee4d2004-12-09 21:34:53 +0000741 if (repeated_click
742 && ((button == MOUSE_LEFT && s_button_pending == MOUSE_RIGHT)
743 || (button == MOUSE_RIGHT
744 && s_button_pending == MOUSE_LEFT)))
Bram Moolenaar071d4272004-06-13 20:20:40 +0000745 {
746 /*
747 * Hmm, gui.c will ignore more than one button down at a time, so
748 * pretend we let go of it first.
749 */
750 gui_send_mouse_event(MOUSE_RELEASE, x, y, FALSE, 0x0);
751 button = MOUSE_MIDDLE;
752 repeated_click = FALSE;
753 s_button_pending = -1;
754 _OnMouseEvent(button, x, y, repeated_click, keyFlags);
755 }
756 else if ((repeated_click)
757 || (mouse_model_popup() && (button == MOUSE_RIGHT)))
758 {
759 if (s_button_pending > -1)
760 {
761 _OnMouseEvent(s_button_pending, x, y, FALSE, keyFlags);
762 s_button_pending = -1;
763 }
764 /* TRACE("Button down at x %d, y %d\n", x, y); */
765 _OnMouseEvent(button, x, y, repeated_click, keyFlags);
766 }
767 else
768 {
769 /*
770 * If this is the first press (i.e. not a multiple click) don't
771 * action immediately, but store and wait for:
772 * i) button-up
773 * ii) mouse move
774 * iii) another button press
775 * before using it.
776 * This enables us to make left+right simulate middle button,
777 * without left or right being actioned first. The side-effect is
778 * that if you click and hold the mouse without dragging, the
779 * cursor doesn't move until you release the button. In practice
780 * this is hardly a problem.
781 */
782 s_button_pending = button;
783 s_x_pending = x;
784 s_y_pending = y;
785 s_kFlags_pending = keyFlags;
786 }
787
788 s_prevTime = currentTime;
789 }
790}
791
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +0000792/*ARGSUSED*/
Bram Moolenaar071d4272004-06-13 20:20:40 +0000793 static void
794_OnMouseMoveOrRelease(
795 HWND hwnd,
796 int x,
797 int y,
798 UINT keyFlags)
799{
800 int button;
801
Bram Moolenaarea408882007-12-03 21:21:03 +0000802 s_getting_focus = FALSE;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000803 if (s_button_pending > -1)
804 {
805 /* Delayed action for mouse down event */
806 _OnMouseEvent(s_button_pending, s_x_pending,
Bram Moolenaar293ee4d2004-12-09 21:34:53 +0000807 s_y_pending, FALSE, s_kFlags_pending);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000808 s_button_pending = -1;
809 }
810 if (s_uMsg == WM_MOUSEMOVE)
811 {
812 /*
813 * It's only a MOUSE_DRAG if one or more mouse buttons are being held
814 * down.
815 */
816 if (!(keyFlags & (MK_LBUTTON | MK_MBUTTON | MK_RBUTTON
817 | MK_XBUTTON1 | MK_XBUTTON2)))
818 {
819 gui_mouse_moved(x, y);
820 return;
821 }
822
823 /*
824 * While button is down, keep grabbing mouse move events when
825 * the mouse goes outside the window
826 */
827 SetCapture(s_textArea);
828 button = MOUSE_DRAG;
829 /* TRACE(" move at x %d, y %d\n", x, y); */
830 }
831 else
832 {
833 ReleaseCapture();
834 button = MOUSE_RELEASE;
835 /* TRACE(" up at x %d, y %d\n", x, y); */
836 }
837
838 _OnMouseEvent(button, x, y, FALSE, keyFlags);
839}
840
841#ifdef FEAT_MENU
842/*
843 * Find the vimmenu_T with the given id
844 */
845 static vimmenu_T *
846gui_mswin_find_menu(
847 vimmenu_T *pMenu,
848 int id)
849{
850 vimmenu_T *pChildMenu;
851
852 while (pMenu)
853 {
854 if (pMenu->id == (UINT)id)
855 break;
856 if (pMenu->children != NULL)
857 {
858 pChildMenu = gui_mswin_find_menu(pMenu->children, id);
859 if (pChildMenu)
860 {
861 pMenu = pChildMenu;
862 break;
863 }
864 }
865 pMenu = pMenu->next;
866 }
867 return pMenu;
868}
869
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +0000870/*ARGSUSED*/
Bram Moolenaar071d4272004-06-13 20:20:40 +0000871 static void
872_OnMenu(
873 HWND hwnd,
874 int id,
875 HWND hwndCtl,
876 UINT codeNotify)
877{
878 vimmenu_T *pMenu;
879
880 pMenu = gui_mswin_find_menu(root_menu, id);
881 if (pMenu)
882 gui_menu_cb(pMenu);
883}
884#endif
885
886#ifdef MSWIN_FIND_REPLACE
887/*
888 * Handle a Find/Replace window message.
889 */
890 static void
891_OnFindRepl(void)
892{
893 int flags = 0;
894 int down;
895
896 if (s_findrep_struct.Flags & FR_DIALOGTERM)
897 /* Give main window the focus back. */
898 (void)SetFocus(s_hwnd);
899
900 if (s_findrep_struct.Flags & FR_FINDNEXT)
901 {
902 flags = FRD_FINDNEXT;
903
904 /* Give main window the focus back: this is so the cursor isn't
905 * hollow. */
906 (void)SetFocus(s_hwnd);
907 }
908 else if (s_findrep_struct.Flags & FR_REPLACE)
909 {
910 flags = FRD_REPLACE;
911
912 /* Give main window the focus back: this is so the cursor isn't
913 * hollow. */
914 (void)SetFocus(s_hwnd);
915 }
916 else if (s_findrep_struct.Flags & FR_REPLACEALL)
917 {
918 flags = FRD_REPLACEALL;
919 }
920
921 if (flags != 0)
922 {
923 /* Call the generic GUI function to do the actual work. */
924 if (s_findrep_struct.Flags & FR_WHOLEWORD)
925 flags |= FRD_WHOLE_WORD;
926 if (s_findrep_struct.Flags & FR_MATCHCASE)
927 flags |= FRD_MATCH_CASE;
928 down = (s_findrep_struct.Flags & FR_DOWN) != 0;
929 gui_do_findrepl(flags, s_findrep_struct.lpstrFindWhat,
930 s_findrep_struct.lpstrReplaceWith, down);
931 }
932}
933#endif
934
935 static void
936HandleMouseHide(UINT uMsg, LPARAM lParam)
937{
938 static LPARAM last_lParam = 0L;
939
940 /* We sometimes get a mousemove when the mouse didn't move... */
941 if (uMsg == WM_MOUSEMOVE)
942 {
943 if (lParam == last_lParam)
944 return;
945 last_lParam = lParam;
946 }
947
948 /* Handle specially, to centralise coding. We need to be sure we catch all
949 * possible events which should cause us to restore the cursor (as it is a
950 * shared resource, we take full responsibility for it).
951 */
952 switch (uMsg)
953 {
954 case WM_KEYUP:
955 case WM_CHAR:
956 /*
957 * blank out the pointer if necessary
958 */
959 if (p_mh)
960 gui_mch_mousehide(TRUE);
961 break;
962
963 case WM_SYSKEYUP: /* show the pointer when a system-key is pressed */
964 case WM_SYSCHAR:
965 case WM_MOUSEMOVE: /* show the pointer on any mouse action */
966 case WM_LBUTTONDOWN:
967 case WM_LBUTTONUP:
968 case WM_MBUTTONDOWN:
969 case WM_MBUTTONUP:
970 case WM_RBUTTONDOWN:
971 case WM_RBUTTONUP:
972 case WM_XBUTTONDOWN:
973 case WM_XBUTTONUP:
974 case WM_NCMOUSEMOVE:
975 case WM_NCLBUTTONDOWN:
976 case WM_NCLBUTTONUP:
977 case WM_NCMBUTTONDOWN:
978 case WM_NCMBUTTONUP:
979 case WM_NCRBUTTONDOWN:
980 case WM_NCRBUTTONUP:
981 case WM_KILLFOCUS:
982 /*
983 * if the pointer is currently hidden, then we should show it.
984 */
985 gui_mch_mousehide(FALSE);
986 break;
987 }
988}
989
990 static LRESULT CALLBACK
991_TextAreaWndProc(
992 HWND hwnd,
993 UINT uMsg,
994 WPARAM wParam,
995 LPARAM lParam)
996{
997 /*
998 TRACE("TextAreaWndProc: hwnd = %08x, msg = %x, wParam = %x, lParam = %x\n",
999 hwnd, uMsg, wParam, lParam);
1000 */
1001
1002 HandleMouseHide(uMsg, lParam);
1003
1004 s_uMsg = uMsg;
1005 s_wParam = wParam;
1006 s_lParam = lParam;
1007
1008#ifdef FEAT_BEVAL
1009 TrackUserActivity(uMsg);
1010#endif
1011
1012 switch (uMsg)
1013 {
1014 HANDLE_MSG(hwnd, WM_LBUTTONDBLCLK,_OnMouseButtonDown);
1015 HANDLE_MSG(hwnd, WM_LBUTTONDOWN,_OnMouseButtonDown);
1016 HANDLE_MSG(hwnd, WM_LBUTTONUP, _OnMouseMoveOrRelease);
1017 HANDLE_MSG(hwnd, WM_MBUTTONDBLCLK,_OnMouseButtonDown);
1018 HANDLE_MSG(hwnd, WM_MBUTTONDOWN,_OnMouseButtonDown);
1019 HANDLE_MSG(hwnd, WM_MBUTTONUP, _OnMouseMoveOrRelease);
1020 HANDLE_MSG(hwnd, WM_MOUSEMOVE, _OnMouseMoveOrRelease);
1021 HANDLE_MSG(hwnd, WM_PAINT, _OnPaint);
1022 HANDLE_MSG(hwnd, WM_RBUTTONDBLCLK,_OnMouseButtonDown);
1023 HANDLE_MSG(hwnd, WM_RBUTTONDOWN,_OnMouseButtonDown);
1024 HANDLE_MSG(hwnd, WM_RBUTTONUP, _OnMouseMoveOrRelease);
1025#ifndef WIN16 /*<VN>*/
1026 HANDLE_MSG(hwnd, WM_XBUTTONDBLCLK,_OnMouseButtonDown);
1027 HANDLE_MSG(hwnd, WM_XBUTTONDOWN,_OnMouseButtonDown);
1028 HANDLE_MSG(hwnd, WM_XBUTTONUP, _OnMouseMoveOrRelease);
1029#endif
1030
1031#ifdef FEAT_BEVAL
1032 case WM_NOTIFY: Handle_WM_Notify(hwnd, (LPNMHDR)lParam);
1033 return TRUE;
1034#endif
1035
1036 default:
1037 return MyWindowProc(hwnd, uMsg, wParam, lParam);
1038 }
1039}
1040
1041#if (defined(WIN3264) && defined(FEAT_MBYTE)) \
1042 || defined(GLOBAL_IME) \
1043 || defined(PROTO)
1044# ifdef PROTO
1045typedef int WINAPI;
1046# endif
1047
1048 LRESULT WINAPI
1049vim_WindowProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
1050{
1051# ifdef GLOBAL_IME
1052 return global_ime_DefWindowProc(hwnd, message, wParam, lParam);
1053# else
1054 if (wide_WindowProc)
1055 return DefWindowProcW(hwnd, message, wParam, lParam);
1056 return DefWindowProc(hwnd, message, wParam, lParam);
1057#endif
1058}
1059#endif
1060
1061/*
1062 * Called when the foreground or background color has been changed.
1063 */
1064 void
1065gui_mch_new_colors(void)
1066{
1067 /* nothing to do? */
1068}
1069
1070/*
1071 * Set the colors to their default values.
1072 */
1073 void
1074gui_mch_def_colors()
1075{
1076 gui.norm_pixel = GetSysColor(COLOR_WINDOWTEXT);
1077 gui.back_pixel = GetSysColor(COLOR_WINDOW);
1078 gui.def_norm_pixel = gui.norm_pixel;
1079 gui.def_back_pixel = gui.back_pixel;
1080}
1081
1082/*
1083 * Open the GUI window which was created by a call to gui_mch_init().
1084 */
1085 int
1086gui_mch_open(void)
1087{
1088#ifndef SW_SHOWDEFAULT
1089# define SW_SHOWDEFAULT 10 /* Borland 5.0 doesn't have it */
1090#endif
1091 /* Actually open the window, if not already visible
1092 * (may be done already in gui_mch_set_shellsize) */
1093 if (!IsWindowVisible(s_hwnd))
1094 ShowWindow(s_hwnd, SW_SHOWDEFAULT);
1095
Bram Moolenaare2f98b92006-03-29 21:18:24 +00001096#ifdef MSWIN_FIND_REPLACE
1097 /* Init replace string here, so that we keep it when re-opening the
1098 * dialog. */
1099 s_findrep_struct.lpstrReplaceWith[0] = NUL;
1100#endif
1101
Bram Moolenaar071d4272004-06-13 20:20:40 +00001102 return OK;
1103}
1104
1105/*
1106 * Get the position of the top left corner of the window.
1107 */
1108 int
1109gui_mch_get_winpos(int *x, int *y)
1110{
1111 RECT rect;
1112
1113 GetWindowRect(s_hwnd, &rect);
1114 *x = rect.left;
1115 *y = rect.top;
1116 return OK;
1117}
1118
1119/*
1120 * Set the position of the top left corner of the window to the given
1121 * coordinates.
1122 */
1123 void
1124gui_mch_set_winpos(int x, int y)
1125{
1126 SetWindowPos(s_hwnd, NULL, x, y, 0, 0,
1127 SWP_NOZORDER | SWP_NOSIZE | SWP_NOACTIVATE);
1128}
1129 void
1130gui_mch_set_text_area_pos(int x, int y, int w, int h)
1131{
1132 static int oldx = 0;
1133 static int oldy = 0;
1134
1135 SetWindowPos(s_textArea, NULL, x, y, w, h, SWP_NOZORDER | SWP_NOACTIVATE);
1136
1137#ifdef FEAT_TOOLBAR
1138 if (vim_strchr(p_go, GO_TOOLBAR) != NULL)
1139 SendMessage(s_toolbarhwnd, WM_SIZE,
Bram Moolenaar5555acc2006-04-07 21:33:12 +00001140 (WPARAM)0, (LPARAM)(w + ((long)(TOOLBAR_BUTTON_HEIGHT+8)<<16)));
Bram Moolenaar071d4272004-06-13 20:20:40 +00001141#endif
Bram Moolenaar3991dab2006-03-27 17:01:56 +00001142#if defined(FEAT_GUI_TABLINE)
1143 if (showing_tabline)
1144 {
Bram Moolenaar2e2a2812006-03-27 20:55:21 +00001145 int top = 0;
Bram Moolenaarc6fe9192006-04-09 21:54:49 +00001146 RECT rect;
Bram Moolenaar3991dab2006-03-27 17:01:56 +00001147
Bram Moolenaar551dbcc2006-04-25 22:13:59 +00001148# ifdef FEAT_TOOLBAR
Bram Moolenaar3991dab2006-03-27 17:01:56 +00001149 if (vim_strchr(p_go, GO_TOOLBAR) != NULL)
1150 top = TOOLBAR_BUTTON_HEIGHT + TOOLBAR_BORDER_HEIGHT;
Bram Moolenaar551dbcc2006-04-25 22:13:59 +00001151# endif
Bram Moolenaar5555acc2006-04-07 21:33:12 +00001152 GetClientRect(s_hwnd, &rect);
Bram Moolenaar551dbcc2006-04-25 22:13:59 +00001153 MoveWindow(s_tabhwnd, 0, top, rect.right, gui.tabline_height, TRUE);
Bram Moolenaar3991dab2006-03-27 17:01:56 +00001154 }
1155#endif
1156
Bram Moolenaar071d4272004-06-13 20:20:40 +00001157 /* When side scroll bar is unshown, the size of window will change.
1158 * then, the text area move left or right. thus client rect should be
1159 * forcely redraw. (Yasuhiro Matsumoto) */
1160 if (oldx != x || oldy != y)
1161 {
1162 InvalidateRect(s_hwnd, NULL, FALSE);
1163 oldx = x;
1164 oldy = y;
1165 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00001166}
1167
1168
1169/*
1170 * Scrollbar stuff:
1171 */
1172
1173 void
1174gui_mch_enable_scrollbar(
1175 scrollbar_T *sb,
1176 int flag)
1177{
1178 ShowScrollBar(sb->id, SB_CTL, flag);
1179
1180 /* TODO: When the window is maximized, the size of the window stays the
1181 * same, thus the size of the text area changes. On Win98 it's OK, on Win
1182 * NT 4.0 it's not... */
1183}
1184
1185 void
1186gui_mch_set_scrollbar_pos(
1187 scrollbar_T *sb,
1188 int x,
1189 int y,
1190 int w,
1191 int h)
1192{
Bram Moolenaar02743632005-07-25 20:42:36 +00001193 SetWindowPos(sb->id, NULL, x, y, w, h,
1194 SWP_NOZORDER | SWP_NOACTIVATE | SWP_SHOWWINDOW);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001195}
1196
1197 void
1198gui_mch_create_scrollbar(
1199 scrollbar_T *sb,
1200 int orient) /* SBAR_VERT or SBAR_HORIZ */
1201{
1202 sb->id = CreateWindow(
1203 "SCROLLBAR", "Scrollbar",
1204 WS_CHILD | ((orient == SBAR_VERT) ? SBS_VERT : SBS_HORZ), 0, 0,
1205 10, /* Any value will do for now */
1206 10, /* Any value will do for now */
1207 s_hwnd, NULL,
1208 s_hinst, NULL);
1209}
1210
1211/*
1212 * Find the scrollbar with the given hwnd.
1213 */
1214 static scrollbar_T *
1215gui_mswin_find_scrollbar(HWND hwnd)
1216{
1217 win_T *wp;
1218
1219 if (gui.bottom_sbar.id == hwnd)
1220 return &gui.bottom_sbar;
1221 FOR_ALL_WINDOWS(wp)
1222 {
1223 if (wp->w_scrollbars[SBAR_LEFT].id == hwnd)
1224 return &wp->w_scrollbars[SBAR_LEFT];
1225 if (wp->w_scrollbars[SBAR_RIGHT].id == hwnd)
1226 return &wp->w_scrollbars[SBAR_RIGHT];
1227 }
1228 return NULL;
1229}
1230
1231/*
1232 * Get the character size of a font.
1233 */
1234 static void
1235GetFontSize(GuiFont font)
1236{
1237 HWND hwnd = GetDesktopWindow();
1238 HDC hdc = GetWindowDC(hwnd);
1239 HFONT hfntOld = SelectFont(hdc, (HFONT)font);
1240 TEXTMETRIC tm;
1241
1242 GetTextMetrics(hdc, &tm);
1243 gui.char_width = tm.tmAveCharWidth + tm.tmOverhang;
1244
1245 gui.char_height = tm.tmHeight
1246#ifndef MSWIN16_FASTTEXT
Bram Moolenaar02743632005-07-25 20:42:36 +00001247 + p_linespace
Bram Moolenaar071d4272004-06-13 20:20:40 +00001248#endif
Bram Moolenaar02743632005-07-25 20:42:36 +00001249 ;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001250
1251 SelectFont(hdc, hfntOld);
1252
1253 ReleaseDC(hwnd, hdc);
1254}
1255
Bram Moolenaar02743632005-07-25 20:42:36 +00001256/*
1257 * Adjust gui.char_height (after 'linespace' was changed).
1258 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00001259 int
Bram Moolenaar02743632005-07-25 20:42:36 +00001260gui_mch_adjust_charheight(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001261{
1262 GetFontSize(gui.norm_font);
1263 return OK;
1264}
1265
1266 static GuiFont
1267get_font_handle(LOGFONT *lf)
1268{
1269 HFONT font = NULL;
1270
1271 /* Load the font */
1272 font = CreateFontIndirect(lf);
1273
1274 if (font == NULL)
1275 return NOFONT;
1276
1277 return (GuiFont)font;
1278}
1279
1280 static int
1281pixels_to_points(int pixels, int vertical)
1282{
1283 int points;
1284 HWND hwnd;
1285 HDC hdc;
1286
1287 hwnd = GetDesktopWindow();
1288 hdc = GetWindowDC(hwnd);
1289
1290 points = MulDiv(pixels, 72,
1291 GetDeviceCaps(hdc, vertical ? LOGPIXELSY : LOGPIXELSX));
1292
1293 ReleaseDC(hwnd, hdc);
1294
1295 return points;
1296}
1297
1298 GuiFont
1299gui_mch_get_font(
1300 char_u *name,
1301 int giveErrorIfMissing)
1302{
1303 LOGFONT lf;
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00001304 GuiFont font = NOFONT;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001305
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00001306 if (get_logfont(&lf, name, NULL, giveErrorIfMissing) == OK)
1307 font = get_font_handle(&lf);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001308 if (font == NOFONT && giveErrorIfMissing)
1309 EMSG2(_(e_font), name);
1310 return font;
1311}
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00001312
Bram Moolenaardfccaf02004-12-31 20:56:11 +00001313#if defined(FEAT_EVAL) || defined(PROTO)
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00001314/*
1315 * Return the name of font "font" in allocated memory.
1316 * Don't know how to get the actual name, thus use the provided name.
1317 */
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00001318/*ARGSUSED*/
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00001319 char_u *
1320gui_mch_get_fontname(font, name)
1321 GuiFont font;
1322 char_u *name;
1323{
1324 if (name == NULL)
1325 return NULL;
1326 return vim_strsave(name);
1327}
Bram Moolenaardfccaf02004-12-31 20:56:11 +00001328#endif
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00001329
Bram Moolenaar071d4272004-06-13 20:20:40 +00001330 void
1331gui_mch_free_font(GuiFont font)
1332{
1333 if (font)
1334 DeleteObject((HFONT)font);
1335}
1336
1337 static int
1338hex_digit(int c)
1339{
1340 if (VIM_ISDIGIT(c))
1341 return c - '0';
1342 c = TOLOWER_ASC(c);
1343 if (c >= 'a' && c <= 'f')
1344 return c - 'a' + 10;
1345 return -1000;
1346}
1347/*
1348 * Return the Pixel value (color) for the given color name.
1349 * Return INVALCOLOR for error.
1350 */
1351 guicolor_T
1352gui_mch_get_color(char_u *name)
1353{
1354 typedef struct guicolor_tTable
1355 {
1356 char *name;
1357 COLORREF color;
1358 } guicolor_tTable;
1359
1360 static guicolor_tTable table[] =
1361 {
1362 {"Black", RGB(0x00, 0x00, 0x00)},
1363 {"DarkGray", RGB(0x80, 0x80, 0x80)},
1364 {"DarkGrey", RGB(0x80, 0x80, 0x80)},
1365 {"Gray", RGB(0xC0, 0xC0, 0xC0)},
1366 {"Grey", RGB(0xC0, 0xC0, 0xC0)},
1367 {"LightGray", RGB(0xE0, 0xE0, 0xE0)},
1368 {"LightGrey", RGB(0xE0, 0xE0, 0xE0)},
Bram Moolenaarb21e5842006-04-16 18:30:08 +00001369 {"Gray10", RGB(0x1A, 0x1A, 0x1A)},
1370 {"Grey10", RGB(0x1A, 0x1A, 0x1A)},
1371 {"Gray20", RGB(0x33, 0x33, 0x33)},
1372 {"Grey20", RGB(0x33, 0x33, 0x33)},
1373 {"Gray30", RGB(0x4D, 0x4D, 0x4D)},
1374 {"Grey30", RGB(0x4D, 0x4D, 0x4D)},
1375 {"Gray40", RGB(0x66, 0x66, 0x66)},
1376 {"Grey40", RGB(0x66, 0x66, 0x66)},
1377 {"Gray50", RGB(0x7F, 0x7F, 0x7F)},
1378 {"Grey50", RGB(0x7F, 0x7F, 0x7F)},
1379 {"Gray60", RGB(0x99, 0x99, 0x99)},
1380 {"Grey60", RGB(0x99, 0x99, 0x99)},
1381 {"Gray70", RGB(0xB3, 0xB3, 0xB3)},
1382 {"Grey70", RGB(0xB3, 0xB3, 0xB3)},
1383 {"Gray80", RGB(0xCC, 0xCC, 0xCC)},
1384 {"Grey80", RGB(0xCC, 0xCC, 0xCC)},
Bram Moolenaare2f98b92006-03-29 21:18:24 +00001385 {"Gray90", RGB(0xE5, 0xE5, 0xE5)},
1386 {"Grey90", RGB(0xE5, 0xE5, 0xE5)},
Bram Moolenaar071d4272004-06-13 20:20:40 +00001387 {"White", RGB(0xFF, 0xFF, 0xFF)},
1388 {"DarkRed", RGB(0x80, 0x00, 0x00)},
1389 {"Red", RGB(0xFF, 0x00, 0x00)},
1390 {"LightRed", RGB(0xFF, 0xA0, 0xA0)},
1391 {"DarkBlue", RGB(0x00, 0x00, 0x80)},
1392 {"Blue", RGB(0x00, 0x00, 0xFF)},
1393 {"LightBlue", RGB(0xA0, 0xA0, 0xFF)},
1394 {"DarkGreen", RGB(0x00, 0x80, 0x00)},
1395 {"Green", RGB(0x00, 0xFF, 0x00)},
1396 {"LightGreen", RGB(0xA0, 0xFF, 0xA0)},
1397 {"DarkCyan", RGB(0x00, 0x80, 0x80)},
1398 {"Cyan", RGB(0x00, 0xFF, 0xFF)},
1399 {"LightCyan", RGB(0xA0, 0xFF, 0xFF)},
1400 {"DarkMagenta", RGB(0x80, 0x00, 0x80)},
1401 {"Magenta", RGB(0xFF, 0x00, 0xFF)},
1402 {"LightMagenta", RGB(0xFF, 0xA0, 0xFF)},
1403 {"Brown", RGB(0x80, 0x40, 0x40)},
1404 {"Yellow", RGB(0xFF, 0xFF, 0x00)},
1405 {"LightYellow", RGB(0xFF, 0xFF, 0xA0)},
1406 {"DarkYellow", RGB(0xBB, 0xBB, 0x00)},
1407 {"SeaGreen", RGB(0x2E, 0x8B, 0x57)},
1408 {"Orange", RGB(0xFF, 0xA5, 0x00)},
1409 {"Purple", RGB(0xA0, 0x20, 0xF0)},
1410 {"SlateBlue", RGB(0x6A, 0x5A, 0xCD)},
1411 {"Violet", RGB(0xEE, 0x82, 0xEE)},
1412 };
1413
1414 typedef struct SysColorTable
1415 {
1416 char *name;
1417 int color;
1418 } SysColorTable;
1419
1420 static SysColorTable sys_table[] =
1421 {
1422#ifdef WIN3264
1423 {"SYS_3DDKSHADOW", COLOR_3DDKSHADOW},
1424 {"SYS_3DHILIGHT", COLOR_3DHILIGHT},
1425#ifndef __MINGW32__
1426 {"SYS_3DHIGHLIGHT", COLOR_3DHIGHLIGHT},
1427#endif
1428 {"SYS_BTNHILIGHT", COLOR_BTNHILIGHT},
1429 {"SYS_BTNHIGHLIGHT", COLOR_BTNHIGHLIGHT},
1430 {"SYS_3DLIGHT", COLOR_3DLIGHT},
1431 {"SYS_3DSHADOW", COLOR_3DSHADOW},
1432 {"SYS_DESKTOP", COLOR_DESKTOP},
1433 {"SYS_INFOBK", COLOR_INFOBK},
1434 {"SYS_INFOTEXT", COLOR_INFOTEXT},
1435 {"SYS_3DFACE", COLOR_3DFACE},
1436#endif
1437 {"SYS_BTNFACE", COLOR_BTNFACE},
1438 {"SYS_BTNSHADOW", COLOR_BTNSHADOW},
1439 {"SYS_ACTIVEBORDER", COLOR_ACTIVEBORDER},
1440 {"SYS_ACTIVECAPTION", COLOR_ACTIVECAPTION},
1441 {"SYS_APPWORKSPACE", COLOR_APPWORKSPACE},
1442 {"SYS_BACKGROUND", COLOR_BACKGROUND},
1443 {"SYS_BTNTEXT", COLOR_BTNTEXT},
1444 {"SYS_CAPTIONTEXT", COLOR_CAPTIONTEXT},
1445 {"SYS_GRAYTEXT", COLOR_GRAYTEXT},
1446 {"SYS_HIGHLIGHT", COLOR_HIGHLIGHT},
1447 {"SYS_HIGHLIGHTTEXT", COLOR_HIGHLIGHTTEXT},
1448 {"SYS_INACTIVEBORDER", COLOR_INACTIVEBORDER},
1449 {"SYS_INACTIVECAPTION", COLOR_INACTIVECAPTION},
1450 {"SYS_INACTIVECAPTIONTEXT", COLOR_INACTIVECAPTIONTEXT},
1451 {"SYS_MENU", COLOR_MENU},
1452 {"SYS_MENUTEXT", COLOR_MENUTEXT},
1453 {"SYS_SCROLLBAR", COLOR_SCROLLBAR},
1454 {"SYS_WINDOW", COLOR_WINDOW},
1455 {"SYS_WINDOWFRAME", COLOR_WINDOWFRAME},
1456 {"SYS_WINDOWTEXT", COLOR_WINDOWTEXT}
1457 };
1458
1459 int r, g, b;
1460 int i;
1461
1462 if (name[0] == '#' && strlen(name) == 7)
1463 {
1464 /* Name is in "#rrggbb" format */
1465 r = hex_digit(name[1]) * 16 + hex_digit(name[2]);
1466 g = hex_digit(name[3]) * 16 + hex_digit(name[4]);
1467 b = hex_digit(name[5]) * 16 + hex_digit(name[6]);
1468 if (r < 0 || g < 0 || b < 0)
1469 return INVALCOLOR;
1470 return RGB(r, g, b);
1471 }
1472 else
1473 {
1474 /* Check if the name is one of the colors we know */
1475 for (i = 0; i < sizeof(table) / sizeof(table[0]); i++)
1476 if (STRICMP(name, table[i].name) == 0)
1477 return table[i].color;
1478 }
1479
1480 /*
1481 * Try to look up a system colour.
1482 */
1483 for (i = 0; i < sizeof(sys_table) / sizeof(sys_table[0]); i++)
1484 if (STRICMP(name, sys_table[i].name) == 0)
1485 return GetSysColor(sys_table[i].color);
1486
1487 /*
1488 * Last attempt. Look in the file "$VIMRUNTIME/rgb.txt".
1489 */
1490 {
1491#define LINE_LEN 100
1492 FILE *fd;
1493 char line[LINE_LEN];
1494 char_u *fname;
1495
1496 fname = expand_env_save((char_u *)"$VIMRUNTIME/rgb.txt");
1497 if (fname == NULL)
1498 return INVALCOLOR;
1499
Bram Moolenaar5555acc2006-04-07 21:33:12 +00001500 fd = mch_fopen((char *)fname, "rt");
Bram Moolenaar071d4272004-06-13 20:20:40 +00001501 vim_free(fname);
1502 if (fd == NULL)
1503 return INVALCOLOR;
1504
1505 while (!feof(fd))
1506 {
1507 int len;
1508 int pos;
1509 char *color;
1510
1511 fgets(line, LINE_LEN, fd);
1512 len = (int)STRLEN(line);
1513
1514 if (len <= 1 || line[len-1] != '\n')
1515 continue;
1516
1517 line[len-1] = '\0';
1518
1519 i = sscanf(line, "%d %d %d %n", &r, &g, &b, &pos);
1520 if (i != 3)
1521 continue;
1522
1523 color = line + pos;
1524
1525 if (STRICMP(color, name) == 0)
1526 {
1527 fclose(fd);
1528 return (guicolor_T) RGB(r, g, b);
1529 }
1530 }
1531
1532 fclose(fd);
1533 }
1534
1535 return INVALCOLOR;
1536}
1537/*
1538 * Return OK if the key with the termcap name "name" is supported.
1539 */
1540 int
1541gui_mch_haskey(char_u *name)
1542{
1543 int i;
1544
1545 for (i = 0; special_keys[i].vim_code1 != NUL; i++)
1546 if (name[0] == special_keys[i].vim_code0 &&
1547 name[1] == special_keys[i].vim_code1)
1548 return OK;
1549 return FAIL;
1550}
1551
1552 void
1553gui_mch_beep(void)
1554{
1555 MessageBeep(MB_OK);
1556}
1557/*
1558 * Invert a rectangle from row r, column c, for nr rows and nc columns.
1559 */
1560 void
1561gui_mch_invert_rectangle(
1562 int r,
1563 int c,
1564 int nr,
1565 int nc)
1566{
1567 RECT rc;
1568
1569 /*
1570 * Note: InvertRect() excludes right and bottom of rectangle.
1571 */
1572 rc.left = FILL_X(c);
1573 rc.top = FILL_Y(r);
1574 rc.right = rc.left + nc * gui.char_width;
1575 rc.bottom = rc.top + nr * gui.char_height;
1576 InvertRect(s_hdc, &rc);
1577}
1578
1579/*
1580 * Iconify the GUI window.
1581 */
1582 void
1583gui_mch_iconify(void)
1584{
1585 ShowWindow(s_hwnd, SW_MINIMIZE);
1586}
1587
1588/*
1589 * Draw a cursor without focus.
1590 */
1591 void
1592gui_mch_draw_hollow_cursor(guicolor_T color)
1593{
1594 HBRUSH hbr;
1595 RECT rc;
1596
1597 /*
1598 * Note: FrameRect() excludes right and bottom of rectangle.
1599 */
1600 rc.left = FILL_X(gui.col);
1601 rc.top = FILL_Y(gui.row);
1602 rc.right = rc.left + gui.char_width;
1603#ifdef FEAT_MBYTE
1604 if (mb_lefthalve(gui.row, gui.col))
1605 rc.right += gui.char_width;
1606#endif
1607 rc.bottom = rc.top + gui.char_height;
1608 hbr = CreateSolidBrush(color);
1609 FrameRect(s_hdc, &rc, hbr);
1610 DeleteBrush(hbr);
1611}
1612/*
1613 * Draw part of a cursor, "w" pixels wide, and "h" pixels high, using
1614 * color "color".
1615 */
1616 void
1617gui_mch_draw_part_cursor(
1618 int w,
1619 int h,
1620 guicolor_T color)
1621{
1622 HBRUSH hbr;
1623 RECT rc;
1624
1625 /*
1626 * Note: FillRect() excludes right and bottom of rectangle.
1627 */
1628 rc.left =
1629#ifdef FEAT_RIGHTLEFT
1630 /* vertical line should be on the right of current point */
1631 CURSOR_BAR_RIGHT ? FILL_X(gui.col + 1) - w :
1632#endif
1633 FILL_X(gui.col);
1634 rc.top = FILL_Y(gui.row) + gui.char_height - h;
1635 rc.right = rc.left + w;
1636 rc.bottom = rc.top + h;
1637 hbr = CreateSolidBrush(color);
1638 FillRect(s_hdc, &rc, hbr);
1639 DeleteBrush(hbr);
1640}
1641
1642/*
1643 * Process a single Windows message.
1644 * If one is not available we hang until one is.
1645 */
1646 static void
1647process_message(void)
1648{
1649 MSG msg;
1650 UINT vk = 0; /* Virtual key */
1651 char_u string[40];
1652 int i;
1653 int modifiers = 0;
1654 int key;
Bram Moolenaar293ee4d2004-12-09 21:34:53 +00001655#ifdef FEAT_MENU
1656 static char_u k10[] = {K_SPECIAL, 'k', ';', 0};
1657#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00001658
1659 GetMessage(&msg, NULL, 0, 0);
1660
1661#ifdef FEAT_OLE
1662 /* Look after OLE Automation commands */
1663 if (msg.message == WM_OLE)
1664 {
1665 char_u *str = (char_u *)msg.lParam;
1666 add_to_input_buf(str, (int)STRLEN(str));
1667 vim_free(str);
1668 return;
1669 }
1670#endif
1671
1672#ifdef FEAT_NETBEANS_INTG
1673 if (msg.message == WM_NETBEANS)
1674 {
1675 messageFromNetbeansW32();
1676 return;
1677 }
1678#endif
1679
1680#ifdef FEAT_SNIFF
1681 if (sniff_request_waiting && want_sniff_request)
1682 {
1683 static char_u bytes[3] = {CSI, (char_u)KS_EXTRA, (char_u)KE_SNIFF};
1684 add_to_input_buf(bytes, 3); /* K_SNIFF */
1685 sniff_request_waiting = 0;
1686 want_sniff_request = 0;
1687 /* request is handled in normal.c */
1688 }
1689 if (msg.message == WM_USER)
Bram Moolenaar35c92912006-06-22 17:34:26 +00001690 {
Bram Moolenaard8a92d72006-06-23 14:44:06 +00001691 MyTranslateMessage(&msg);
Bram Moolenaar35c92912006-06-22 17:34:26 +00001692 DispatchMessage(&msg);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001693 return;
Bram Moolenaar35c92912006-06-22 17:34:26 +00001694 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00001695#endif
1696
1697#ifdef MSWIN_FIND_REPLACE
1698 /* Don't process messages used by the dialog */
1699 if (s_findrep_hwnd != NULL && IsDialogMessage(s_findrep_hwnd, &msg))
1700 {
1701 HandleMouseHide(msg.message, msg.lParam);
1702 return;
1703 }
1704#endif
1705
1706 /*
1707 * Check if it's a special key that we recognise. If not, call
1708 * TranslateMessage().
1709 */
1710 if (msg.message == WM_KEYDOWN || msg.message == WM_SYSKEYDOWN)
1711 {
1712 vk = (int) msg.wParam;
1713 /* handle key after dead key, but ignore shift, alt and control */
1714 if (dead_key && vk != VK_SHIFT && vk != VK_MENU && vk != VK_CONTROL)
1715 {
1716 dead_key = 0;
1717 /* handle non-alphabetic keys (ones that hopefully cannot generate
1718 * umlaut-characters), unless when control is down */
1719 if (vk < 'A' || vk > 'Z' || (GetKeyState(VK_CONTROL) & 0x8000))
1720 {
1721 MSG dm;
1722
1723 dm.message = msg.message;
1724 dm.hwnd = msg.hwnd;
1725 dm.wParam = VK_SPACE;
1726 MyTranslateMessage(&dm); /* generate dead character */
1727 if (vk != VK_SPACE) /* and send current character once more */
1728 PostMessage(msg.hwnd, msg.message, msg.wParam, msg.lParam);
1729 return;
1730 }
1731 }
1732
1733 /* Check for CTRL-BREAK */
1734 if (vk == VK_CANCEL)
1735 {
1736 trash_input_buf();
1737 got_int = TRUE;
1738 string[0] = Ctrl_C;
1739 add_to_input_buf(string, 1);
1740 }
1741
1742 for (i = 0; special_keys[i].key_sym != 0; i++)
1743 {
1744 /* ignore VK_SPACE when ALT key pressed: system menu */
1745 if (special_keys[i].key_sym == vk
1746 && (vk != VK_SPACE || !(GetKeyState(VK_MENU) & 0x8000)))
1747 {
1748#ifdef FEAT_MENU
Bram Moolenaar293ee4d2004-12-09 21:34:53 +00001749 /* Check for <F10>: Windows selects the menu. When <F10> is
1750 * mapped we want to use the mapping instead. */
Bram Moolenaar071d4272004-06-13 20:20:40 +00001751 if (vk == VK_F10
1752 && gui.menu_is_active
Bram Moolenaar8d6ea5e2006-03-18 21:31:46 +00001753 && check_map(k10, State, FALSE, TRUE, FALSE) == NULL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001754 break;
1755#endif
1756 if (GetKeyState(VK_SHIFT) & 0x8000)
1757 modifiers |= MOD_MASK_SHIFT;
1758 /*
1759 * Don't use caps-lock as shift, because these are special keys
1760 * being considered here, and we only want letters to get
1761 * shifted -- webb
1762 */
1763 /*
1764 if (GetKeyState(VK_CAPITAL) & 0x0001)
1765 modifiers ^= MOD_MASK_SHIFT;
1766 */
1767 if (GetKeyState(VK_CONTROL) & 0x8000)
1768 modifiers |= MOD_MASK_CTRL;
1769 if (GetKeyState(VK_MENU) & 0x8000)
1770 modifiers |= MOD_MASK_ALT;
1771
1772 if (special_keys[i].vim_code1 == NUL)
1773 key = special_keys[i].vim_code0;
1774 else
1775 key = TO_SPECIAL(special_keys[i].vim_code0,
1776 special_keys[i].vim_code1);
1777 key = simplify_key(key, &modifiers);
1778 if (key == CSI)
1779 key = K_CSI;
1780
1781 if (modifiers)
1782 {
1783 string[0] = CSI;
1784 string[1] = KS_MODIFIER;
1785 string[2] = modifiers;
1786 add_to_input_buf(string, 3);
1787 }
1788
1789 if (IS_SPECIAL(key))
1790 {
1791 string[0] = CSI;
1792 string[1] = K_SECOND(key);
1793 string[2] = K_THIRD(key);
1794 add_to_input_buf(string, 3);
1795 }
1796 else
1797 {
1798 int len;
1799
1800 /* Handle "key" as a Unicode character. */
Bram Moolenaar85a3e5c2007-11-20 16:22:16 +00001801 len = char_to_string(key, string, 40, FALSE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001802 add_to_input_buf(string, len);
1803 }
1804 break;
1805 }
1806 }
1807 if (special_keys[i].key_sym == 0)
1808 {
1809 /* Some keys need C-S- where they should only need C-.
1810 * Ignore 0xff, Windows XP sends it when NUMLOCK has changed since
1811 * system startup (Helmut Stiegler, 2003 Oct 3). */
1812 if (vk != 0xff
1813 && (GetKeyState(VK_CONTROL) & 0x8000)
1814 && !(GetKeyState(VK_SHIFT) & 0x8000)
1815 && !(GetKeyState(VK_MENU) & 0x8000))
1816 {
1817 /* CTRL-6 is '^'; Japanese keyboard maps '^' to vk == 0xDE */
1818 if (vk == '6' || MapVirtualKey(vk, 2) == (UINT)'^')
1819 {
1820 string[0] = Ctrl_HAT;
1821 add_to_input_buf(string, 1);
1822 }
1823 /* vk == 0xBD AZERTY for CTRL-'-', but CTRL-[ for * QWERTY! */
1824 else if (vk == 0xBD) /* QWERTY for CTRL-'-' */
1825 {
1826 string[0] = Ctrl__;
1827 add_to_input_buf(string, 1);
1828 }
1829 /* CTRL-2 is '@'; Japanese keyboard maps '@' to vk == 0xC0 */
1830 else if (vk == '2' || MapVirtualKey(vk, 2) == (UINT)'@')
1831 {
1832 string[0] = Ctrl_AT;
1833 add_to_input_buf(string, 1);
1834 }
1835 else
1836 MyTranslateMessage(&msg);
1837 }
1838 else
1839 MyTranslateMessage(&msg);
1840 }
1841 }
1842#ifdef FEAT_MBYTE_IME
1843 else if (msg.message == WM_IME_NOTIFY)
1844 _OnImeNotify(msg.hwnd, (DWORD)msg.wParam, (DWORD)msg.lParam);
1845 else if (msg.message == WM_KEYUP && im_get_status())
1846 /* added for non-MS IME (Yasuhiro Matsumoto) */
1847 MyTranslateMessage(&msg);
1848#endif
1849#if !defined(FEAT_MBYTE_IME) && defined(GLOBAL_IME)
1850/* GIME_TEST */
1851 else if (msg.message == WM_IME_STARTCOMPOSITION)
1852 {
1853 POINT point;
1854
1855 global_ime_set_font(&norm_logfont);
1856 point.x = FILL_X(gui.col);
1857 point.y = FILL_Y(gui.row);
1858 MapWindowPoints(s_textArea, s_hwnd, &point, 1);
1859 global_ime_set_position(&point);
1860 }
1861#endif
1862
1863#ifdef FEAT_MENU
Bram Moolenaar293ee4d2004-12-09 21:34:53 +00001864 /* Check for <F10>: Default effect is to select the menu. When <F10> is
1865 * mapped we need to stop it here to avoid strange effects (e.g., for the
1866 * key-up event) */
Bram Moolenaar8d6ea5e2006-03-18 21:31:46 +00001867 if (vk != VK_F10 || check_map(k10, State, FALSE, TRUE, FALSE) == NULL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001868#endif
1869 DispatchMessage(&msg);
1870}
1871
1872/*
1873 * Catch up with any queued events. This may put keyboard input into the
1874 * input buffer, call resize call-backs, trigger timers etc. If there is
1875 * nothing in the event queue (& no timers pending), then we return
1876 * immediately.
1877 */
1878 void
1879gui_mch_update(void)
1880{
1881 MSG msg;
1882
1883 if (!s_busy_processing)
1884 while (PeekMessage(&msg, NULL, 0, 0, PM_NOREMOVE)
1885 && !vim_is_input_buf_full())
1886 process_message();
1887}
1888
1889/*
1890 * GUI input routine called by gui_wait_for_chars(). Waits for a character
1891 * from the keyboard.
1892 * wtime == -1 Wait forever.
1893 * wtime == 0 This should never happen.
1894 * wtime > 0 Wait wtime milliseconds for a character.
1895 * Returns OK if a character was found to be available within the given time,
1896 * or FAIL otherwise.
1897 */
1898 int
1899gui_mch_wait_for_chars(int wtime)
1900{
1901 MSG msg;
1902 int focus;
1903
1904 s_timed_out = FALSE;
1905
1906 if (wtime > 0)
1907 {
1908 /* Don't do anything while processing a (scroll) message. */
1909 if (s_busy_processing)
1910 return FAIL;
1911 s_wait_timer = (UINT)SetTimer(NULL, 0, (UINT)wtime,
1912 (TIMERPROC)_OnTimer);
1913 }
1914
1915 allow_scrollbar = TRUE;
1916
1917 focus = gui.in_focus;
1918 while (!s_timed_out)
1919 {
1920 /* Stop or start blinking when focus changes */
1921 if (gui.in_focus != focus)
1922 {
1923 if (gui.in_focus)
1924 gui_mch_start_blink();
1925 else
1926 gui_mch_stop_blink();
1927 focus = gui.in_focus;
1928 }
1929
1930 if (s_need_activate)
1931 {
1932#ifdef WIN32
1933 (void)SetForegroundWindow(s_hwnd);
1934#else
1935 (void)SetActiveWindow(s_hwnd);
1936#endif
1937 s_need_activate = FALSE;
1938 }
1939
Bram Moolenaar61665aa2008-12-24 11:20:53 +00001940#ifdef FEAT_NETBEANS_INTG
1941 /* Process the queued netbeans messages. */
1942 netbeans_parse_messages();
1943#endif
1944
Bram Moolenaar071d4272004-06-13 20:20:40 +00001945 /*
1946 * Don't use gui_mch_update() because then we will spin-lock until a
1947 * char arrives, instead we use GetMessage() to hang until an
1948 * event arrives. No need to check for input_buf_full because we are
1949 * returning as soon as it contains a single char -- webb
1950 */
1951 process_message();
1952
1953 if (input_available())
1954 {
1955 if (s_wait_timer != 0 && !s_timed_out)
1956 {
1957 KillTimer(NULL, s_wait_timer);
1958
1959 /* Eat spurious WM_TIMER messages */
1960 while (PeekMessage(&msg, s_hwnd, WM_TIMER, WM_TIMER, PM_REMOVE))
1961 ;
1962 s_wait_timer = 0;
1963 }
1964 allow_scrollbar = FALSE;
Bram Moolenaar293ee4d2004-12-09 21:34:53 +00001965
1966 /* Clear pending mouse button, the release event may have been
Bram Moolenaarea408882007-12-03 21:21:03 +00001967 * taken by the dialog window. But don't do this when getting
1968 * focus, we need the mouse-up event then. */
1969 if (!s_getting_focus)
1970 s_button_pending = -1;
Bram Moolenaar293ee4d2004-12-09 21:34:53 +00001971
Bram Moolenaar071d4272004-06-13 20:20:40 +00001972 return OK;
1973 }
1974 }
1975 allow_scrollbar = FALSE;
1976 return FAIL;
1977}
1978
1979/*
1980 * Clear a rectangular region of the screen from text pos (row1, col1) to
1981 * (row2, col2) inclusive.
1982 */
1983 void
1984gui_mch_clear_block(
1985 int row1,
1986 int col1,
1987 int row2,
1988 int col2)
1989{
1990 RECT rc;
1991
1992 /*
1993 * Clear one extra pixel at the far right, for when bold characters have
1994 * spilled over to the window border.
1995 * Note: FillRect() excludes right and bottom of rectangle.
1996 */
1997 rc.left = FILL_X(col1);
1998 rc.top = FILL_Y(row1);
1999 rc.right = FILL_X(col2 + 1) + (col2 == Columns - 1);
2000 rc.bottom = FILL_Y(row2 + 1);
2001 clear_rect(&rc);
2002}
2003
2004/*
2005 * Clear the whole text window.
2006 */
2007 void
2008gui_mch_clear_all(void)
2009{
2010 RECT rc;
2011
2012 rc.left = 0;
2013 rc.top = 0;
2014 rc.right = Columns * gui.char_width + 2 * gui.border_width;
2015 rc.bottom = Rows * gui.char_height + 2 * gui.border_width;
2016 clear_rect(&rc);
2017}
2018/*
2019 * Menu stuff.
2020 */
2021
2022 void
2023gui_mch_enable_menu(int flag)
2024{
2025#ifdef FEAT_MENU
2026 SetMenu(s_hwnd, flag ? s_menuBar : NULL);
2027#endif
2028}
2029
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00002030/*ARGSUSED*/
Bram Moolenaar071d4272004-06-13 20:20:40 +00002031 void
2032gui_mch_set_menu_pos(
2033 int x,
2034 int y,
2035 int w,
2036 int h)
2037{
2038 /* It will be in the right place anyway */
2039}
2040
2041#if defined(FEAT_MENU) || defined(PROTO)
2042/*
2043 * Make menu item hidden or not hidden
2044 */
2045 void
2046gui_mch_menu_hidden(
2047 vimmenu_T *menu,
2048 int hidden)
2049{
2050 /*
2051 * This doesn't do what we want. Hmm, just grey the menu items for now.
2052 */
2053 /*
2054 if (hidden)
2055 EnableMenuItem(s_menuBar, menu->id, MF_BYCOMMAND | MF_DISABLED);
2056 else
2057 EnableMenuItem(s_menuBar, menu->id, MF_BYCOMMAND | MF_ENABLED);
2058 */
2059 gui_mch_menu_grey(menu, hidden);
2060}
2061
2062/*
2063 * This is called after setting all the menus to grey/hidden or not.
2064 */
2065 void
2066gui_mch_draw_menubar(void)
2067{
2068 DrawMenuBar(s_hwnd);
2069}
2070#endif /*FEAT_MENU*/
2071
2072#ifndef PROTO
2073void
2074#ifdef VIMDLL
2075_export
2076#endif
2077_cdecl
2078SaveInst(HINSTANCE hInst)
2079{
2080 s_hinst = hInst;
2081}
2082#endif
2083
2084/*
2085 * Return the RGB value of a pixel as a long.
2086 */
2087 long_u
2088gui_mch_get_rgb(guicolor_T pixel)
2089{
2090 return (GetRValue(pixel) << 16) + (GetGValue(pixel) << 8)
2091 + GetBValue(pixel);
2092}
2093
2094#if defined(FEAT_GUI_DIALOG) || defined(PROTO)
2095/* Convert pixels in X to dialog units */
2096 static WORD
2097PixelToDialogX(int numPixels)
2098{
2099 return (WORD)((numPixels * 4) / s_dlgfntwidth);
2100}
2101
2102/* Convert pixels in Y to dialog units */
2103 static WORD
2104PixelToDialogY(int numPixels)
2105{
2106 return (WORD)((numPixels * 8) / s_dlgfntheight);
2107}
2108
2109/* Return the width in pixels of the given text in the given DC. */
2110 static int
2111GetTextWidth(HDC hdc, char_u *str, int len)
2112{
2113 SIZE size;
2114
2115 GetTextExtentPoint(hdc, str, len, &size);
2116 return size.cx;
2117}
2118
2119#ifdef FEAT_MBYTE
2120/*
2121 * Return the width in pixels of the given text in the given DC, taking care
2122 * of 'encoding' to active codepage conversion.
2123 */
2124 static int
2125GetTextWidthEnc(HDC hdc, char_u *str, int len)
2126{
2127 SIZE size;
2128 WCHAR *wstr;
2129 int n;
2130 int wlen = len;
2131
2132 if (enc_codepage >= 0 && (int)GetACP() != enc_codepage)
2133 {
2134 /* 'encoding' differs from active codepage: convert text and use wide
2135 * function */
Bram Moolenaar36f692d2008-11-20 16:10:17 +00002136 wstr = enc_to_utf16(str, &wlen);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002137 if (wstr != NULL)
2138 {
2139 n = GetTextExtentPointW(hdc, wstr, wlen, &size);
2140 vim_free(wstr);
2141 if (n)
2142 return size.cx;
2143 }
2144 }
2145
2146 return GetTextWidth(hdc, str, len);
2147}
2148#else
2149# define GetTextWidthEnc(h, s, l) GetTextWidth((h), (s), (l))
2150#endif
2151
2152/*
2153 * A quick little routine that will center one window over another, handy for
2154 * dialog boxes. Taken from the Win32SDK samples.
2155 */
2156 static BOOL
2157CenterWindow(
2158 HWND hwndChild,
2159 HWND hwndParent)
2160{
2161 RECT rChild, rParent;
2162 int wChild, hChild, wParent, hParent;
2163 int wScreen, hScreen, xNew, yNew;
2164 HDC hdc;
2165
2166 GetWindowRect(hwndChild, &rChild);
2167 wChild = rChild.right - rChild.left;
2168 hChild = rChild.bottom - rChild.top;
2169
2170 /* If Vim is minimized put the window in the middle of the screen. */
Bram Moolenaar9e54a0e2006-04-14 20:42:25 +00002171 if (hwndParent == NULL || IsMinimized(hwndParent))
Bram Moolenaar071d4272004-06-13 20:20:40 +00002172 {
2173#ifdef WIN16
2174 rParent.left = 0;
2175 rParent.top = 0;
2176 rParent.right = GetSystemMetrics(SM_CXSCREEN);
2177 rParent.bottom = GetSystemMetrics(SM_CYFULLSCREEN);
2178#else
2179 SystemParametersInfo(SPI_GETWORKAREA, 0, &rParent, 0);
2180#endif
2181 }
2182 else
2183 GetWindowRect(hwndParent, &rParent);
2184 wParent = rParent.right - rParent.left;
2185 hParent = rParent.bottom - rParent.top;
2186
2187 hdc = GetDC(hwndChild);
2188 wScreen = GetDeviceCaps (hdc, HORZRES);
2189 hScreen = GetDeviceCaps (hdc, VERTRES);
2190 ReleaseDC(hwndChild, hdc);
2191
2192 xNew = rParent.left + ((wParent - wChild) /2);
2193 if (xNew < 0)
2194 {
2195 xNew = 0;
2196 }
2197 else if ((xNew+wChild) > wScreen)
2198 {
2199 xNew = wScreen - wChild;
2200 }
2201
2202 yNew = rParent.top + ((hParent - hChild) /2);
2203 if (yNew < 0)
2204 yNew = 0;
2205 else if ((yNew+hChild) > hScreen)
2206 yNew = hScreen - hChild;
2207
2208 return SetWindowPos(hwndChild, NULL, xNew, yNew, 0, 0,
2209 SWP_NOSIZE | SWP_NOZORDER);
2210}
2211#endif /* FEAT_GUI_DIALOG */
2212
2213void
2214gui_mch_activate_window(void)
2215{
2216 (void)SetActiveWindow(s_hwnd);
2217}
2218
2219#if defined(FEAT_TOOLBAR) || defined(PROTO)
2220 void
2221gui_mch_show_toolbar(int showit)
2222{
2223 if (s_toolbarhwnd == NULL)
2224 return;
2225
2226 if (showit)
Bram Moolenaar8f2ff9f2006-08-29 19:26:50 +00002227 {
2228# ifdef FEAT_MBYTE
2229# ifndef TB_SETUNICODEFORMAT
2230 /* For older compilers. We assume this never changes. */
2231# define TB_SETUNICODEFORMAT 0x2005
2232# endif
2233 /* Enable/disable unicode support */
2234 int uu = (enc_codepage >= 0 && (int)GetACP() != enc_codepage);
2235 SendMessage(s_toolbarhwnd, TB_SETUNICODEFORMAT, (WPARAM)uu, (LPARAM)0);
2236# endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00002237 ShowWindow(s_toolbarhwnd, SW_SHOW);
Bram Moolenaar8f2ff9f2006-08-29 19:26:50 +00002238 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00002239 else
2240 ShowWindow(s_toolbarhwnd, SW_HIDE);
2241}
2242
2243/* Then number of bitmaps is fixed. Exit is missing! */
2244#define TOOLBAR_BITMAP_COUNT 31
2245
2246#endif
2247
Bram Moolenaar3991dab2006-03-27 17:01:56 +00002248#if defined(FEAT_GUI_TABLINE) || defined(PROTO)
Bram Moolenaar2e2a2812006-03-27 20:55:21 +00002249 static void
Bram Moolenaar908d53a2006-11-07 18:05:31 +00002250add_tabline_popup_menu_entry(HMENU pmenu, UINT item_id, char_u *item_text)
2251{
2252#ifdef FEAT_MBYTE
2253 WCHAR *wn = NULL;
2254 int n;
2255
2256 if (enc_codepage >= 0 && (int)GetACP() != enc_codepage)
2257 {
2258 /* 'encoding' differs from active codepage: convert menu name
2259 * and use wide function */
Bram Moolenaar36f692d2008-11-20 16:10:17 +00002260 wn = enc_to_utf16(item_text, NULL);
Bram Moolenaar908d53a2006-11-07 18:05:31 +00002261 if (wn != NULL)
2262 {
2263 MENUITEMINFOW infow;
2264
2265 infow.cbSize = sizeof(infow);
2266 infow.fMask = MIIM_TYPE | MIIM_ID;
2267 infow.wID = item_id;
2268 infow.fType = MFT_STRING;
2269 infow.dwTypeData = wn;
2270 infow.cch = (UINT)wcslen(wn);
2271 n = InsertMenuItemW(pmenu, item_id, FALSE, &infow);
2272 vim_free(wn);
2273 if (n == 0 && GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
2274 /* Failed, try using non-wide function. */
2275 wn = NULL;
2276 }
2277 }
2278
2279 if (wn == NULL)
2280#endif
2281 {
2282 MENUITEMINFO info;
2283
2284 info.cbSize = sizeof(info);
2285 info.fMask = MIIM_TYPE | MIIM_ID;
2286 info.wID = item_id;
2287 info.fType = MFT_STRING;
2288 info.dwTypeData = item_text;
2289 info.cch = (UINT)STRLEN(item_text);
2290 InsertMenuItem(pmenu, item_id, FALSE, &info);
2291 }
2292}
2293
2294 static void
Bram Moolenaar2e2a2812006-03-27 20:55:21 +00002295show_tabline_popup_menu(void)
2296{
2297 HMENU tab_pmenu;
Bram Moolenaar2e2a2812006-03-27 20:55:21 +00002298 long rval;
2299 POINT pt;
Bram Moolenaar2e2a2812006-03-27 20:55:21 +00002300
Bram Moolenaarf193fff2006-04-27 00:02:13 +00002301 /* When ignoring events don't show the menu. */
2302 if (hold_gui_events
2303# ifdef FEAT_CMDWIN
2304 || cmdwin_type != 0
2305# endif
2306 )
2307 return;
2308
Bram Moolenaar2e2a2812006-03-27 20:55:21 +00002309 tab_pmenu = CreatePopupMenu();
2310 if (tab_pmenu == NULL)
2311 return;
2312
Bram Moolenaar908d53a2006-11-07 18:05:31 +00002313 add_tabline_popup_menu_entry(tab_pmenu, TABLINE_MENU_CLOSE, _("Close tab"));
2314 add_tabline_popup_menu_entry(tab_pmenu, TABLINE_MENU_NEW, _("New tab"));
2315 add_tabline_popup_menu_entry(tab_pmenu, TABLINE_MENU_OPEN,
2316 _("Open tab..."));
Bram Moolenaar2e2a2812006-03-27 20:55:21 +00002317
2318 GetCursorPos(&pt);
2319 rval = TrackPopupMenuEx(tab_pmenu, TPM_RETURNCMD, pt.x, pt.y, s_tabhwnd,
2320 NULL);
2321
2322 DestroyMenu(tab_pmenu);
2323
2324 /* Add the string cmd into input buffer */
2325 if (rval > 0)
2326 {
2327 TCHITTESTINFO htinfo;
2328 int idx;
2329
2330 if (ScreenToClient(s_tabhwnd, &pt) == 0)
2331 return;
2332
2333 htinfo.pt.x = pt.x;
2334 htinfo.pt.y = pt.y;
2335 idx = TabCtrl_HitTest(s_tabhwnd, &htinfo);
2336 if (idx == -1)
2337 idx = 0;
2338 else
2339 idx += 1;
2340
Bram Moolenaarc6fe9192006-04-09 21:54:49 +00002341 send_tabline_menu_event(idx, (int)rval);
Bram Moolenaar2e2a2812006-03-27 20:55:21 +00002342 }
2343}
2344
Bram Moolenaar3991dab2006-03-27 17:01:56 +00002345/*
2346 * Show or hide the tabline.
2347 */
2348 void
2349gui_mch_show_tabline(int showit)
2350{
2351 if (s_tabhwnd == NULL)
2352 return;
2353
2354 if (!showit != !showing_tabline)
2355 {
2356 if (showit)
2357 ShowWindow(s_tabhwnd, SW_SHOW);
2358 else
2359 ShowWindow(s_tabhwnd, SW_HIDE);
2360 showing_tabline = showit;
2361 }
2362}
2363
2364/*
2365 * Return TRUE when tabline is displayed.
2366 */
2367 int
2368gui_mch_showing_tabline(void)
2369{
2370 return s_tabhwnd != NULL && showing_tabline;
2371}
2372
2373/*
2374 * Update the labels of the tabline.
2375 */
2376 void
2377gui_mch_update_tabline(void)
2378{
2379 tabpage_T *tp;
2380 TCITEM tie;
2381 int nr = 0;
2382 int curtabidx = 0;
2383 RECT rc;
Bram Moolenaar8424a622006-04-19 21:23:36 +00002384#ifdef FEAT_MBYTE
Bram Moolenaarfc1421e2006-04-20 22:17:20 +00002385 static int use_unicode = FALSE;
2386 int uu;
Bram Moolenaar8424a622006-04-19 21:23:36 +00002387 WCHAR *wstr = NULL;
2388#endif
Bram Moolenaar3991dab2006-03-27 17:01:56 +00002389
2390 if (s_tabhwnd == NULL)
2391 return;
2392
Bram Moolenaarfc1421e2006-04-20 22:17:20 +00002393#if defined(FEAT_MBYTE)
2394# ifndef CCM_SETUNICODEFORMAT
2395 /* For older compilers. We assume this never changes. */
2396# define CCM_SETUNICODEFORMAT 0x2005
2397# endif
2398 uu = (enc_codepage >= 0 && (int)GetACP() != enc_codepage);
2399 if (uu != use_unicode)
2400 {
2401 /* Enable/disable unicode support */
2402 SendMessage(s_tabhwnd, CCM_SETUNICODEFORMAT, (WPARAM)uu, (LPARAM)0);
2403 use_unicode = uu;
2404 }
Bram Moolenaar8424a622006-04-19 21:23:36 +00002405#endif
2406
Bram Moolenaar3991dab2006-03-27 17:01:56 +00002407 tie.mask = TCIF_TEXT;
2408 tie.iImage = -1;
2409
2410 /* Add a label for each tab page. They all contain the same text area. */
2411 for (tp = first_tabpage; tp != NULL; tp = tp->tp_next, ++nr)
2412 {
2413 if (tp == curtab)
2414 curtabidx = nr;
2415
2416 if (!TabCtrl_GetItemRect(s_tabhwnd, nr, &rc))
2417 {
2418 /* Add the tab */
2419 tie.pszText = "-Empty-";
2420 TabCtrl_InsertItem(s_tabhwnd, nr, &tie);
2421 }
2422
Bram Moolenaar57657d82006-04-21 22:12:41 +00002423 get_tabline_label(tp, FALSE);
Bram Moolenaar3991dab2006-03-27 17:01:56 +00002424 tie.pszText = NameBuff;
Bram Moolenaar8424a622006-04-19 21:23:36 +00002425#ifdef FEAT_MBYTE
2426 wstr = NULL;
Bram Moolenaarfc1421e2006-04-20 22:17:20 +00002427 if (use_unicode)
Bram Moolenaar8424a622006-04-19 21:23:36 +00002428 {
2429 /* Need to go through Unicode. */
Bram Moolenaar36f692d2008-11-20 16:10:17 +00002430 wstr = enc_to_utf16(NameBuff, NULL);
Bram Moolenaar8424a622006-04-19 21:23:36 +00002431 if (wstr != NULL)
2432 {
2433 TCITEMW tiw;
2434
2435 tiw.mask = TCIF_TEXT;
2436 tiw.iImage = -1;
2437 tiw.pszText = wstr;
Bram Moolenaar85f868c2006-11-28 16:16:58 +00002438 SendMessage(s_tabhwnd, TCM_SETITEMW, (WPARAM)nr, (LPARAM)&tiw);
Bram Moolenaar8424a622006-04-19 21:23:36 +00002439 vim_free(wstr);
2440 }
2441 }
2442 if (wstr == NULL)
2443#endif
2444 {
2445 TabCtrl_SetItem(s_tabhwnd, nr, &tie);
2446 }
Bram Moolenaar3991dab2006-03-27 17:01:56 +00002447 }
2448
2449 /* Remove any old labels. */
2450 while (TabCtrl_GetItemRect(s_tabhwnd, nr, &rc))
2451 TabCtrl_DeleteItem(s_tabhwnd, nr);
2452
2453 if (TabCtrl_GetCurSel(s_tabhwnd) != curtabidx)
2454 TabCtrl_SetCurSel(s_tabhwnd, curtabidx);
2455}
2456
2457/*
2458 * Set the current tab to "nr". First tab is 1.
2459 */
2460 void
2461gui_mch_set_curtab(nr)
2462 int nr;
2463{
2464 if (s_tabhwnd == NULL)
2465 return;
2466
Bram Moolenaar551dbcc2006-04-25 22:13:59 +00002467 if (TabCtrl_GetCurSel(s_tabhwnd) != nr -1)
2468 TabCtrl_SetCurSel(s_tabhwnd, nr -1);
Bram Moolenaar3991dab2006-03-27 17:01:56 +00002469}
2470
2471#endif
2472
Bram Moolenaar071d4272004-06-13 20:20:40 +00002473/*
2474 * ":simalt" command.
2475 */
2476 void
2477ex_simalt(exarg_T *eap)
2478{
2479 char_u *keys = eap->arg;
2480
2481 PostMessage(s_hwnd, WM_SYSCOMMAND, (WPARAM)SC_KEYMENU, (LPARAM)0);
2482 while (*keys)
2483 {
2484 if (*keys == '~')
2485 *keys = ' '; /* for showing system menu */
2486 PostMessage(s_hwnd, WM_CHAR, (WPARAM)*keys, (LPARAM)0);
2487 keys++;
2488 }
2489}
2490
2491/*
2492 * Create the find & replace dialogs.
2493 * You can't have both at once: ":find" when replace is showing, destroys
2494 * the replace dialog first, and the other way around.
2495 */
2496#ifdef MSWIN_FIND_REPLACE
2497 static void
2498initialise_findrep(char_u *initial_string)
2499{
2500 int wword = FALSE;
2501 int mcase = !p_ic;
2502 char_u *entry_text;
2503
2504 /* Get the search string to use. */
2505 entry_text = get_find_dialog_text(initial_string, &wword, &mcase);
2506
2507 s_findrep_struct.hwndOwner = s_hwnd;
2508 s_findrep_struct.Flags = FR_DOWN;
2509 if (mcase)
2510 s_findrep_struct.Flags |= FR_MATCHCASE;
2511 if (wword)
2512 s_findrep_struct.Flags |= FR_WHOLEWORD;
2513 if (entry_text != NULL && *entry_text != NUL)
Bram Moolenaarfe3ca8d2005-07-18 21:43:02 +00002514 vim_strncpy(s_findrep_struct.lpstrFindWhat, entry_text,
2515 s_findrep_struct.wFindWhatLen - 1);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002516 vim_free(entry_text);
2517}
2518#endif
2519
Bram Moolenaar908d53a2006-11-07 18:05:31 +00002520 static void
2521set_window_title(HWND hwnd, char *title)
2522{
2523#ifdef FEAT_MBYTE
2524 if (title != NULL && enc_codepage >= 0 && enc_codepage != (int)GetACP())
2525 {
2526 WCHAR *wbuf;
2527 int n;
2528
Bram Moolenaar36f692d2008-11-20 16:10:17 +00002529 /* Convert the title from 'encoding' to UTF-16. */
2530 wbuf = (WCHAR *)enc_to_utf16((char_u *)title, NULL);
Bram Moolenaar908d53a2006-11-07 18:05:31 +00002531 if (wbuf != NULL)
2532 {
2533 n = SetWindowTextW(hwnd, wbuf);
2534 vim_free(wbuf);
2535 if (n != 0 || GetLastError() != ERROR_CALL_NOT_IMPLEMENTED)
2536 return;
2537 /* Retry with non-wide function (for Windows 98). */
2538 }
2539 }
2540#endif
2541 (void)SetWindowText(hwnd, (LPCSTR)title);
2542}
2543
Bram Moolenaar071d4272004-06-13 20:20:40 +00002544 void
2545gui_mch_find_dialog(exarg_T *eap)
2546{
2547#ifdef MSWIN_FIND_REPLACE
2548 if (s_findrep_msg != 0)
2549 {
2550 if (IsWindow(s_findrep_hwnd) && !s_findrep_is_find)
2551 DestroyWindow(s_findrep_hwnd);
2552
2553 if (!IsWindow(s_findrep_hwnd))
2554 {
2555 initialise_findrep(eap->arg);
2556 s_findrep_hwnd = FindText((LPFINDREPLACE) &s_findrep_struct);
2557 }
2558
Bram Moolenaar908d53a2006-11-07 18:05:31 +00002559 set_window_title(s_findrep_hwnd,
2560 _("Find string (use '\\\\' to find a '\\')"));
Bram Moolenaar071d4272004-06-13 20:20:40 +00002561 (void)SetFocus(s_findrep_hwnd);
2562
2563 s_findrep_is_find = TRUE;
2564 }
2565#endif
2566}
2567
2568
2569 void
2570gui_mch_replace_dialog(exarg_T *eap)
2571{
2572#ifdef MSWIN_FIND_REPLACE
2573 if (s_findrep_msg != 0)
2574 {
2575 if (IsWindow(s_findrep_hwnd) && s_findrep_is_find)
2576 DestroyWindow(s_findrep_hwnd);
2577
2578 if (!IsWindow(s_findrep_hwnd))
2579 {
2580 initialise_findrep(eap->arg);
2581 s_findrep_hwnd = ReplaceText((LPFINDREPLACE) &s_findrep_struct);
2582 }
2583
Bram Moolenaar908d53a2006-11-07 18:05:31 +00002584 set_window_title(s_findrep_hwnd,
2585 _("Find & Replace (use '\\\\' to find a '\\')"));
Bram Moolenaar071d4272004-06-13 20:20:40 +00002586 (void)SetFocus(s_findrep_hwnd);
2587
2588 s_findrep_is_find = FALSE;
2589 }
2590#endif
2591}
2592
2593
2594/*
2595 * Set visibility of the pointer.
2596 */
2597 void
2598gui_mch_mousehide(int hide)
2599{
2600 if (hide != gui.pointer_hidden)
2601 {
2602 ShowCursor(!hide);
2603 gui.pointer_hidden = hide;
2604 }
2605}
2606
2607#ifdef FEAT_MENU
2608 static void
2609gui_mch_show_popupmenu_at(vimmenu_T *menu, int x, int y)
2610{
2611 /* Unhide the mouse, we don't get move events here. */
2612 gui_mch_mousehide(FALSE);
2613
2614 (void)TrackPopupMenu(
2615 (HMENU)menu->submenu_id,
2616 TPM_LEFTALIGN | TPM_LEFTBUTTON,
2617 x, y,
2618 (int)0, /*reserved param*/
2619 s_hwnd,
2620 NULL);
2621 /*
2622 * NOTE: The pop-up menu can eat the mouse up event.
2623 * We deal with this in normal.c.
2624 */
2625}
2626#endif
2627
2628/*
2629 * Got a message when the system will go down.
2630 */
2631 static void
2632_OnEndSession(void)
2633{
2634 getout_preserve_modified(1);
2635}
2636
2637/*
2638 * Get this message when the user clicks on the cross in the top right corner
2639 * of a Windows95 window.
2640 */
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00002641/*ARGSUSED*/
Bram Moolenaar071d4272004-06-13 20:20:40 +00002642 static void
2643_OnClose(
2644 HWND hwnd)
2645{
2646 gui_shell_closed();
2647}
2648
2649/*
2650 * Get a message when the window is being destroyed.
2651 */
2652 static void
2653_OnDestroy(
2654 HWND hwnd)
2655{
2656#ifdef WIN16_3DLOOK
2657 Ctl3dUnregister(s_hinst);
2658#endif
2659 if (!destroying)
2660 _OnClose(hwnd);
2661}
2662
2663 static void
2664_OnPaint(
2665 HWND hwnd)
2666{
2667 if (!IsMinimized(hwnd))
2668 {
2669 PAINTSTRUCT ps;
2670
2671 out_flush(); /* make sure all output has been processed */
2672 (void)BeginPaint(hwnd, &ps);
2673
2674#ifdef FEAT_MBYTE
2675 /* prevent multi-byte characters from misprinting on an invalid
2676 * rectangle */
2677 if (has_mbyte)
2678 {
2679 RECT rect;
2680
2681 GetClientRect(hwnd, &rect);
2682 ps.rcPaint.left = rect.left;
2683 ps.rcPaint.right = rect.right;
2684 }
2685#endif
2686
2687 if (!IsRectEmpty(&ps.rcPaint))
2688 gui_redraw(ps.rcPaint.left, ps.rcPaint.top,
2689 ps.rcPaint.right - ps.rcPaint.left + 1,
2690 ps.rcPaint.bottom - ps.rcPaint.top + 1);
2691 EndPaint(hwnd, &ps);
2692 }
2693}
2694
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00002695/*ARGSUSED*/
Bram Moolenaar071d4272004-06-13 20:20:40 +00002696 static void
2697_OnSize(
2698 HWND hwnd,
2699 UINT state,
2700 int cx,
2701 int cy)
2702{
2703 if (!IsMinimized(hwnd))
2704 {
2705 gui_resize_shell(cx, cy);
2706
2707#ifdef FEAT_MENU
2708 /* Menu bar may wrap differently now */
2709 gui_mswin_get_menu_height(TRUE);
2710#endif
2711 }
2712}
2713
2714 static void
2715_OnSetFocus(
2716 HWND hwnd,
2717 HWND hwndOldFocus)
2718{
2719 gui_focus_change(TRUE);
Bram Moolenaarea408882007-12-03 21:21:03 +00002720 s_getting_focus = TRUE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002721 (void)MyWindowProc(hwnd, WM_SETFOCUS, (WPARAM)hwndOldFocus, 0);
2722}
2723
2724 static void
2725_OnKillFocus(
2726 HWND hwnd,
2727 HWND hwndNewFocus)
2728{
2729 gui_focus_change(FALSE);
Bram Moolenaarea408882007-12-03 21:21:03 +00002730 s_getting_focus = FALSE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002731 (void)MyWindowProc(hwnd, WM_KILLFOCUS, (WPARAM)hwndNewFocus, 0);
2732}
2733
2734/*
2735 * Get a message when the user switches back to vim
2736 */
2737#ifdef WIN16
2738 static BOOL
2739#else
2740 static LRESULT
2741#endif
2742_OnActivateApp(
2743 HWND hwnd,
2744 BOOL fActivate,
2745#ifdef WIN16
2746 HTASK dwThreadId
2747#else
2748 DWORD dwThreadId
2749#endif
2750 )
2751{
2752 /* we call gui_focus_change() in _OnSetFocus() */
2753 /* gui_focus_change((int)fActivate); */
2754 return MyWindowProc(hwnd, WM_ACTIVATEAPP, fActivate, (DWORD)dwThreadId);
2755}
2756
2757#if defined(FEAT_WINDOWS) || defined(PROTO)
2758 void
2759gui_mch_destroy_scrollbar(scrollbar_T *sb)
2760{
2761 DestroyWindow(sb->id);
2762}
2763#endif
2764
2765/*
Bram Moolenaar9588a0f2005-01-08 21:45:39 +00002766 * Get current mouse coordinates in text window.
Bram Moolenaar071d4272004-06-13 20:20:40 +00002767 */
Bram Moolenaar9588a0f2005-01-08 21:45:39 +00002768 void
Bram Moolenaara40c5002005-01-09 21:16:21 +00002769gui_mch_getmouse(int *x, int *y)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002770{
2771 RECT rct;
2772 POINT mp;
2773
2774 (void)GetWindowRect(s_textArea, &rct);
2775 (void)GetCursorPos((LPPOINT)&mp);
Bram Moolenaar9588a0f2005-01-08 21:45:39 +00002776 *x = (int)(mp.x - rct.left);
2777 *y = (int)(mp.y - rct.top);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002778}
2779
2780/*
2781 * Move mouse pointer to character at (x, y).
2782 */
2783 void
2784gui_mch_setmouse(int x, int y)
2785{
2786 RECT rct;
2787
2788 (void)GetWindowRect(s_textArea, &rct);
2789 (void)SetCursorPos(x + gui.border_offset + rct.left,
2790 y + gui.border_offset + rct.top);
2791}
2792
2793 static void
2794gui_mswin_get_valid_dimensions(
2795 int w,
2796 int h,
2797 int *valid_w,
2798 int *valid_h)
2799{
2800 int base_width, base_height;
2801
2802 base_width = gui_get_base_width()
2803 + GetSystemMetrics(SM_CXFRAME) * 2;
2804 base_height = gui_get_base_height()
2805 + GetSystemMetrics(SM_CYFRAME) * 2
2806 + GetSystemMetrics(SM_CYCAPTION)
2807#ifdef FEAT_MENU
2808 + gui_mswin_get_menu_height(FALSE)
2809#endif
2810 ;
2811 *valid_w = base_width +
2812 ((w - base_width) / gui.char_width) * gui.char_width;
2813 *valid_h = base_height +
2814 ((h - base_height) / gui.char_height) * gui.char_height;
2815}
2816
2817 void
Bram Moolenaar071d4272004-06-13 20:20:40 +00002818gui_mch_flash(int msec)
2819{
2820 RECT rc;
2821
2822 /*
2823 * Note: InvertRect() excludes right and bottom of rectangle.
2824 */
2825 rc.left = 0;
2826 rc.top = 0;
2827 rc.right = gui.num_cols * gui.char_width;
2828 rc.bottom = gui.num_rows * gui.char_height;
2829 InvertRect(s_hdc, &rc);
2830 gui_mch_flush(); /* make sure it's displayed */
2831
2832 ui_delay((long)msec, TRUE); /* wait for a few msec */
2833
2834 InvertRect(s_hdc, &rc);
2835}
2836
2837/*
2838 * Return flags used for scrolling.
2839 * The SW_INVALIDATE is required when part of the window is covered or
2840 * off-screen. Refer to MS KB Q75236.
2841 */
2842 static int
2843get_scroll_flags(void)
2844{
2845 HWND hwnd;
2846 RECT rcVim, rcOther, rcDest;
2847
2848 GetWindowRect(s_hwnd, &rcVim);
Bram Moolenaar0d406992005-05-22 22:03:39 +00002849
2850 /* Check if the window is partly above or below the screen. We don't care
2851 * about partly left or right of the screen, it is not relevant when
2852 * scrolling up or down. */
2853 if (rcVim.top < 0 || rcVim.bottom > GetSystemMetrics(SM_CYFULLSCREEN))
2854 return SW_INVALIDATE;
2855
2856 /* Check if there is an window (partly) on top of us. */
Bram Moolenaar071d4272004-06-13 20:20:40 +00002857 for (hwnd = s_hwnd; (hwnd = GetWindow(hwnd, GW_HWNDPREV)) != (HWND)0; )
2858 if (IsWindowVisible(hwnd))
2859 {
2860 GetWindowRect(hwnd, &rcOther);
2861 if (IntersectRect(&rcDest, &rcVim, &rcOther))
2862 return SW_INVALIDATE;
2863 }
2864 return 0;
2865}
2866
2867/*
2868 * Delete the given number of lines from the given row, scrolling up any
2869 * text further down within the scroll region.
2870 */
2871 void
2872gui_mch_delete_lines(
2873 int row,
2874 int num_lines)
2875{
2876 RECT rc;
2877
2878 rc.left = FILL_X(gui.scroll_region_left);
2879 rc.right = FILL_X(gui.scroll_region_right + 1);
2880 rc.top = FILL_Y(row);
2881 rc.bottom = FILL_Y(gui.scroll_region_bot + 1);
2882
2883 ScrollWindowEx(s_textArea, 0, -num_lines * gui.char_height,
2884 &rc, &rc, NULL, NULL, get_scroll_flags());
2885
2886 UpdateWindow(s_textArea);
2887 /* This seems to be required to avoid the cursor disappearing when
2888 * scrolling such that the cursor ends up in the top-left character on
2889 * the screen... But why? (Webb) */
2890 /* It's probably fixed by disabling drawing the cursor while scrolling. */
2891 /* gui.cursor_is_valid = FALSE; */
2892
2893 gui_clear_block(gui.scroll_region_bot - num_lines + 1,
2894 gui.scroll_region_left,
2895 gui.scroll_region_bot, gui.scroll_region_right);
2896}
2897
2898/*
2899 * Insert the given number of lines before the given row, scrolling down any
2900 * following text within the scroll region.
2901 */
2902 void
2903gui_mch_insert_lines(
2904 int row,
2905 int num_lines)
2906{
2907 RECT rc;
2908
2909 rc.left = FILL_X(gui.scroll_region_left);
2910 rc.right = FILL_X(gui.scroll_region_right + 1);
2911 rc.top = FILL_Y(row);
2912 rc.bottom = FILL_Y(gui.scroll_region_bot + 1);
2913 /* The SW_INVALIDATE is required when part of the window is covered or
2914 * off-screen. How do we avoid it when it's not needed? */
2915 ScrollWindowEx(s_textArea, 0, num_lines * gui.char_height,
2916 &rc, &rc, NULL, NULL, get_scroll_flags());
2917
2918 UpdateWindow(s_textArea);
2919
2920 gui_clear_block(row, gui.scroll_region_left,
2921 row + num_lines - 1, gui.scroll_region_right);
2922}
2923
2924
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00002925/*ARGSUSED*/
Bram Moolenaar071d4272004-06-13 20:20:40 +00002926 void
2927gui_mch_exit(int rc)
2928{
2929 ReleaseDC(s_textArea, s_hdc);
2930 DeleteObject(s_brush);
2931
2932#ifdef FEAT_TEAROFF
2933 /* Unload the tearoff bitmap */
2934 (void)DeleteObject((HGDIOBJ)s_htearbitmap);
2935#endif
2936
2937 /* Destroy our window (if we have one). */
2938 if (s_hwnd != NULL)
2939 {
2940 destroying = TRUE; /* ignore WM_DESTROY message now */
2941 DestroyWindow(s_hwnd);
2942 }
2943
2944#ifdef GLOBAL_IME
2945 global_ime_end();
2946#endif
2947}
2948
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00002949 static char_u *
2950logfont2name(LOGFONT lf)
2951{
2952 char *p;
2953 char *res;
2954 char *charset_name;
2955
2956 charset_name = charset_id2name((int)lf.lfCharSet);
2957 res = alloc((unsigned)(strlen(lf.lfFaceName) + 20
2958 + (charset_name == NULL ? 0 : strlen(charset_name) + 2)));
2959 if (res != NULL)
2960 {
2961 p = res;
2962 /* make a normal font string out of the lf thing:*/
2963 sprintf((char *)p, "%s:h%d", lf.lfFaceName, pixels_to_points(
2964 lf.lfHeight < 0 ? -lf.lfHeight : lf.lfHeight, TRUE));
2965 while (*p)
2966 {
2967 if (*p == ' ')
2968 *p = '_';
2969 ++p;
2970 }
2971#ifndef MSWIN16_FASTTEXT
2972 if (lf.lfItalic)
2973 STRCAT(p, ":i");
2974 if (lf.lfWeight >= FW_BOLD)
2975 STRCAT(p, ":b");
2976#endif
2977 if (lf.lfUnderline)
2978 STRCAT(p, ":u");
2979 if (lf.lfStrikeOut)
2980 STRCAT(p, ":s");
2981 if (charset_name != NULL)
2982 {
2983 STRCAT(p, ":c");
2984 STRCAT(p, charset_name);
2985 }
2986 }
2987
2988 return res;
2989}
2990
Bram Moolenaar071d4272004-06-13 20:20:40 +00002991/*
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00002992 * Initialise vim to use the font with the given name.
2993 * Return FAIL if the font could not be loaded, OK otherwise.
Bram Moolenaar071d4272004-06-13 20:20:40 +00002994 */
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00002995/*ARGSUSED*/
Bram Moolenaar071d4272004-06-13 20:20:40 +00002996 int
2997gui_mch_init_font(char_u *font_name, int fontset)
2998{
2999 LOGFONT lf;
3000 GuiFont font = NOFONT;
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00003001 char_u *p;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003002
3003 /* Load the font */
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00003004 if (get_logfont(&lf, font_name, NULL, TRUE) == OK)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003005 font = get_font_handle(&lf);
3006 if (font == NOFONT)
3007 return FAIL;
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00003008
Bram Moolenaar071d4272004-06-13 20:20:40 +00003009 if (font_name == NULL)
3010 font_name = lf.lfFaceName;
3011#if defined(FEAT_MBYTE_IME) || defined(GLOBAL_IME)
3012 norm_logfont = lf;
3013#endif
3014#ifdef FEAT_MBYTE_IME
3015 im_set_font(&lf);
3016#endif
3017 gui_mch_free_font(gui.norm_font);
3018 gui.norm_font = font;
3019 current_font_height = lf.lfHeight;
3020 GetFontSize(font);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003021
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00003022 p = logfont2name(lf);
3023 if (p != NULL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003024 {
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00003025 hl_set_font_name(p);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003026
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00003027 /* When setting 'guifont' to "*" replace it with the actual font name.
3028 * */
3029 if (STRCMP(font_name, "*") == 0 && STRCMP(p_guifont, "*") == 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003030 {
Bram Moolenaar071d4272004-06-13 20:20:40 +00003031 vim_free(p_guifont);
3032 p_guifont = p;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003033 }
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00003034 else
3035 vim_free(p);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003036 }
3037
3038#ifndef MSWIN16_FASTTEXT
3039 gui_mch_free_font(gui.ital_font);
3040 gui.ital_font = NOFONT;
3041 gui_mch_free_font(gui.bold_font);
3042 gui.bold_font = NOFONT;
3043 gui_mch_free_font(gui.boldital_font);
3044 gui.boldital_font = NOFONT;
3045
3046 if (!lf.lfItalic)
3047 {
3048 lf.lfItalic = TRUE;
3049 gui.ital_font = get_font_handle(&lf);
3050 lf.lfItalic = FALSE;
3051 }
3052 if (lf.lfWeight < FW_BOLD)
3053 {
3054 lf.lfWeight = FW_BOLD;
3055 gui.bold_font = get_font_handle(&lf);
3056 if (!lf.lfItalic)
3057 {
3058 lf.lfItalic = TRUE;
3059 gui.boldital_font = get_font_handle(&lf);
3060 }
3061 }
3062#endif
3063
3064 return OK;
3065}
3066
Bram Moolenaar85f868c2006-11-28 16:16:58 +00003067#ifndef WPF_RESTORETOMAXIMIZED
3068# define WPF_RESTORETOMAXIMIZED 2 /* just in case someone doesn't have it */
3069#endif
3070
Bram Moolenaar071d4272004-06-13 20:20:40 +00003071/*
3072 * Return TRUE if the GUI window is maximized, filling the whole screen.
3073 */
3074 int
3075gui_mch_maximized()
3076{
Bram Moolenaar85f868c2006-11-28 16:16:58 +00003077 WINDOWPLACEMENT wp;
3078
3079 wp.length = sizeof(WINDOWPLACEMENT);
3080 if (GetWindowPlacement(s_hwnd, &wp))
3081 return wp.showCmd == SW_SHOWMAXIMIZED
3082 || (wp.showCmd == SW_SHOWMINIMIZED
3083 && wp.flags == WPF_RESTORETOMAXIMIZED);
3084
3085 return 0;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003086}
3087
3088/*
3089 * Called when the font changed while the window is maximized. Compute the
3090 * new Rows and Columns. This is like resizing the window.
3091 */
3092 void
3093gui_mch_newfont()
3094{
3095 RECT rect;
3096
3097 GetWindowRect(s_hwnd, &rect);
3098 gui_resize_shell(rect.right - rect.left
3099 - GetSystemMetrics(SM_CXFRAME) * 2,
3100 rect.bottom - rect.top
3101 - GetSystemMetrics(SM_CYFRAME) * 2
3102 - GetSystemMetrics(SM_CYCAPTION)
3103#ifdef FEAT_MENU
3104 - gui_mswin_get_menu_height(FALSE)
3105#endif
3106 );
3107}
3108
3109/*
3110 * Set the window title
3111 */
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00003112/*ARGSUSED*/
Bram Moolenaar071d4272004-06-13 20:20:40 +00003113 void
3114gui_mch_settitle(
3115 char_u *title,
3116 char_u *icon)
3117{
Bram Moolenaar908d53a2006-11-07 18:05:31 +00003118 set_window_title(s_hwnd, (title == NULL ? "VIM" : (char *)title));
Bram Moolenaar071d4272004-06-13 20:20:40 +00003119}
3120
3121#ifdef FEAT_MOUSESHAPE
3122/* Table for shape IDCs. Keep in sync with the mshape_names[] table in
3123 * misc2.c! */
3124static LPCSTR mshape_idcs[] =
3125{
3126 MAKEINTRESOURCE(IDC_ARROW), /* arrow */
3127 MAKEINTRESOURCE(0), /* blank */
3128 MAKEINTRESOURCE(IDC_IBEAM), /* beam */
3129 MAKEINTRESOURCE(IDC_SIZENS), /* updown */
3130 MAKEINTRESOURCE(IDC_SIZENS), /* udsizing */
3131 MAKEINTRESOURCE(IDC_SIZEWE), /* leftright */
3132 MAKEINTRESOURCE(IDC_SIZEWE), /* lrsizing */
3133 MAKEINTRESOURCE(IDC_WAIT), /* busy */
3134#ifdef WIN3264
3135 MAKEINTRESOURCE(IDC_NO), /* no */
3136#else
3137 MAKEINTRESOURCE(IDC_ICON), /* no */
3138#endif
3139 MAKEINTRESOURCE(IDC_ARROW), /* crosshair */
3140 MAKEINTRESOURCE(IDC_ARROW), /* hand1 */
3141 MAKEINTRESOURCE(IDC_ARROW), /* hand2 */
3142 MAKEINTRESOURCE(IDC_ARROW), /* pencil */
3143 MAKEINTRESOURCE(IDC_ARROW), /* question */
3144 MAKEINTRESOURCE(IDC_ARROW), /* right-arrow */
3145 MAKEINTRESOURCE(IDC_UPARROW), /* up-arrow */
3146 MAKEINTRESOURCE(IDC_ARROW) /* last one */
3147};
3148
3149 void
3150mch_set_mouse_shape(int shape)
3151{
3152 LPCSTR idc;
3153
3154 if (shape == MSHAPE_HIDE)
3155 ShowCursor(FALSE);
3156 else
3157 {
3158 if (shape >= MSHAPE_NUMBERED)
3159 idc = MAKEINTRESOURCE(IDC_ARROW);
3160 else
3161 idc = mshape_idcs[shape];
Bram Moolenaare6a91fd2008-07-24 18:51:11 +00003162#ifdef SetClassLongPtr
3163 SetClassLongPtr(s_textArea, GCLP_HCURSOR, (__int3264)(LONG_PTR)LoadCursor(NULL, idc));
Bram Moolenaar071d4272004-06-13 20:20:40 +00003164#else
3165# ifdef WIN32
Bram Moolenaare6a91fd2008-07-24 18:51:11 +00003166 SetClassLong(s_textArea, GCL_HCURSOR, (long_u)LoadCursor(NULL, idc));
3167# else /* Win16 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00003168 SetClassWord(s_textArea, GCW_HCURSOR, (WORD)LoadCursor(NULL, idc));
3169# endif
3170#endif
3171 if (!p_mh)
3172 {
3173 POINT mp;
3174
3175 /* Set the position to make it redrawn with the new shape. */
3176 (void)GetCursorPos((LPPOINT)&mp);
3177 (void)SetCursorPos(mp.x, mp.y);
3178 ShowCursor(TRUE);
3179 }
3180 }
3181}
3182#endif
3183
3184#ifdef FEAT_BROWSE
3185/*
3186 * The file browser exists in two versions: with "W" uses wide characters,
3187 * without "W" the current codepage. When FEAT_MBYTE is defined and on
3188 * Windows NT/2000/XP the "W" functions are used.
3189 */
3190
3191# if defined(FEAT_MBYTE) && defined(WIN3264)
3192/*
3193 * Wide version of convert_filter(). Keep in sync!
3194 */
3195 static WCHAR *
3196convert_filterW(char_u *s)
3197{
3198 WCHAR *res;
3199 unsigned s_len = (unsigned)STRLEN(s);
3200 unsigned i;
3201
3202 res = (WCHAR *)alloc((s_len + 3) * sizeof(WCHAR));
3203 if (res != NULL)
3204 {
3205 for (i = 0; i < s_len; ++i)
3206 if (s[i] == '\t' || s[i] == '\n')
3207 res[i] = '\0';
3208 else
3209 res[i] = s[i];
3210 res[s_len] = NUL;
3211 /* Add two extra NULs to make sure it's properly terminated. */
3212 res[s_len + 1] = NUL;
3213 res[s_len + 2] = NUL;
3214 }
3215 return res;
3216}
3217
3218/*
3219 * Wide version of gui_mch_browse(). Keep in sync!
3220 */
3221 static char_u *
3222gui_mch_browseW(
3223 int saving,
3224 char_u *title,
3225 char_u *dflt,
3226 char_u *ext,
3227 char_u *initdir,
3228 char_u *filter)
3229{
Bram Moolenaar36f692d2008-11-20 16:10:17 +00003230 /* We always use the wide function. This means enc_to_utf16() must work,
Bram Moolenaar071d4272004-06-13 20:20:40 +00003231 * otherwise it fails miserably! */
3232 OPENFILENAMEW fileStruct;
3233 WCHAR fileBuf[MAXPATHL];
3234 WCHAR *wp;
3235 int i;
3236 WCHAR *titlep = NULL;
3237 WCHAR *extp = NULL;
3238 WCHAR *initdirp = NULL;
3239 WCHAR *filterp;
3240 char_u *p;
3241
3242 if (dflt == NULL)
3243 fileBuf[0] = NUL;
3244 else
3245 {
Bram Moolenaar36f692d2008-11-20 16:10:17 +00003246 wp = enc_to_utf16(dflt, NULL);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003247 if (wp == NULL)
3248 fileBuf[0] = NUL;
3249 else
3250 {
3251 for (i = 0; wp[i] != NUL && i < MAXPATHL - 1; ++i)
3252 fileBuf[i] = wp[i];
3253 fileBuf[i] = NUL;
3254 vim_free(wp);
3255 }
3256 }
3257
3258 /* Convert the filter to Windows format. */
3259 filterp = convert_filterW(filter);
3260
3261 memset(&fileStruct, 0, sizeof(OPENFILENAMEW));
3262#ifdef OPENFILENAME_SIZE_VERSION_400
3263 /* be compatible with Windows NT 4.0 */
3264 /* TODO: what to use for OPENFILENAMEW??? */
3265 fileStruct.lStructSize = sizeof(OPENFILENAME_SIZE_VERSION_400);
3266#else
3267 fileStruct.lStructSize = sizeof(fileStruct);
3268#endif
3269
3270 if (title != NULL)
Bram Moolenaar36f692d2008-11-20 16:10:17 +00003271 titlep = enc_to_utf16(title, NULL);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003272 fileStruct.lpstrTitle = titlep;
3273
3274 if (ext != NULL)
Bram Moolenaar36f692d2008-11-20 16:10:17 +00003275 extp = enc_to_utf16(ext, NULL);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003276 fileStruct.lpstrDefExt = extp;
3277
3278 fileStruct.lpstrFile = fileBuf;
3279 fileStruct.nMaxFile = MAXPATHL;
3280 fileStruct.lpstrFilter = filterp;
3281 fileStruct.hwndOwner = s_hwnd; /* main Vim window is owner*/
3282 /* has an initial dir been specified? */
3283 if (initdir != NULL && *initdir != NUL)
3284 {
3285 /* Must have backslashes here, no matter what 'shellslash' says */
Bram Moolenaar36f692d2008-11-20 16:10:17 +00003286 initdirp = enc_to_utf16(initdir, NULL);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003287 if (initdirp != NULL)
3288 {
3289 for (wp = initdirp; *wp != NUL; ++wp)
3290 if (*wp == '/')
3291 *wp = '\\';
3292 }
3293 fileStruct.lpstrInitialDir = initdirp;
3294 }
3295
3296 /*
3297 * TODO: Allow selection of multiple files. Needs another arg to this
3298 * function to ask for it, and need to use OFN_ALLOWMULTISELECT below.
3299 * Also, should we use OFN_FILEMUSTEXIST when opening? Vim can edit on
3300 * files that don't exist yet, so I haven't put it in. What about
3301 * OFN_PATHMUSTEXIST?
3302 * Don't use OFN_OVERWRITEPROMPT, Vim has its own ":confirm" dialog.
3303 */
3304 fileStruct.Flags = (OFN_NOCHANGEDIR | OFN_PATHMUSTEXIST | OFN_HIDEREADONLY);
3305#ifdef FEAT_SHORTCUT
3306 if (curbuf->b_p_bin)
3307 fileStruct.Flags |= OFN_NODEREFERENCELINKS;
3308#endif
3309 if (saving)
3310 {
3311 if (!GetSaveFileNameW(&fileStruct))
3312 return NULL;
3313 }
3314 else
3315 {
3316 if (!GetOpenFileNameW(&fileStruct))
3317 return NULL;
3318 }
3319
3320 vim_free(filterp);
3321 vim_free(initdirp);
3322 vim_free(titlep);
3323 vim_free(extp);
3324
3325 /* Convert from UCS2 to 'encoding'. */
Bram Moolenaar36f692d2008-11-20 16:10:17 +00003326 p = utf16_to_enc(fileBuf, NULL);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003327 if (p != NULL)
3328 /* when out of memory we get garbage for non-ASCII chars */
3329 STRCPY(fileBuf, p);
3330 vim_free(p);
3331
3332 /* Give focus back to main window (when using MDI). */
3333 SetFocus(s_hwnd);
3334
3335 /* Shorten the file name if possible */
Bram Moolenaard089d9b2007-09-30 12:02:55 +00003336 return vim_strsave(shorten_fname1((char_u *)fileBuf));
Bram Moolenaar071d4272004-06-13 20:20:40 +00003337}
3338# endif /* FEAT_MBYTE */
3339
3340
3341/*
3342 * Convert the string s to the proper format for a filter string by replacing
Bram Moolenaar12806c82008-11-12 12:36:30 +00003343 * the \t and \n delimiters with \0.
Bram Moolenaar071d4272004-06-13 20:20:40 +00003344 * Returns the converted string in allocated memory.
3345 *
3346 * Keep in sync with convert_filterW() above!
3347 */
3348 static char_u *
3349convert_filter(char_u *s)
3350{
3351 char_u *res;
3352 unsigned s_len = (unsigned)STRLEN(s);
3353 unsigned i;
3354
3355 res = alloc(s_len + 3);
3356 if (res != NULL)
3357 {
3358 for (i = 0; i < s_len; ++i)
3359 if (s[i] == '\t' || s[i] == '\n')
3360 res[i] = '\0';
3361 else
3362 res[i] = s[i];
3363 res[s_len] = NUL;
3364 /* Add two extra NULs to make sure it's properly terminated. */
3365 res[s_len + 1] = NUL;
3366 res[s_len + 2] = NUL;
3367 }
3368 return res;
3369}
3370
3371/*
Bram Moolenaar7171abe2004-10-11 10:06:20 +00003372 * Select a directory.
3373 */
3374 char_u *
3375gui_mch_browsedir(char_u *title, char_u *initdir)
3376{
3377 /* We fake this: Use a filter that doesn't select anything and a default
3378 * file name that won't be used. */
3379 return gui_mch_browse(0, title, (char_u *)_("Not Used"), NULL,
3380 initdir, (char_u *)_("Directory\t*.nothing\n"));
3381}
3382
3383/*
Bram Moolenaar071d4272004-06-13 20:20:40 +00003384 * Pop open a file browser and return the file selected, in allocated memory,
3385 * or NULL if Cancel is hit.
3386 * saving - TRUE if the file will be saved to, FALSE if it will be opened.
3387 * title - Title message for the file browser dialog.
3388 * dflt - Default name of file.
3389 * ext - Default extension to be added to files without extensions.
3390 * initdir - directory in which to open the browser (NULL = current dir)
3391 * filter - Filter for matched files to choose from.
3392 *
3393 * Keep in sync with gui_mch_browseW() above!
3394 */
3395 char_u *
3396gui_mch_browse(
3397 int saving,
3398 char_u *title,
3399 char_u *dflt,
3400 char_u *ext,
3401 char_u *initdir,
3402 char_u *filter)
3403{
3404 OPENFILENAME fileStruct;
3405 char_u fileBuf[MAXPATHL];
3406 char_u *initdirp = NULL;
3407 char_u *filterp;
3408 char_u *p;
3409
3410# if defined(FEAT_MBYTE) && defined(WIN3264)
3411 if (os_version.dwPlatformId == VER_PLATFORM_WIN32_NT)
3412 return gui_mch_browseW(saving, title, dflt, ext, initdir, filter);
3413# endif
3414
3415 if (dflt == NULL)
3416 fileBuf[0] = NUL;
3417 else
Bram Moolenaarfe3ca8d2005-07-18 21:43:02 +00003418 vim_strncpy(fileBuf, dflt, MAXPATHL - 1);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003419
3420 /* Convert the filter to Windows format. */
3421 filterp = convert_filter(filter);
3422
3423 memset(&fileStruct, 0, sizeof(OPENFILENAME));
3424#ifdef OPENFILENAME_SIZE_VERSION_400
3425 /* be compatible with Windows NT 4.0 */
3426 fileStruct.lStructSize = sizeof(OPENFILENAME_SIZE_VERSION_400);
3427#else
3428 fileStruct.lStructSize = sizeof(fileStruct);
3429#endif
3430
3431 fileStruct.lpstrTitle = title;
3432 fileStruct.lpstrDefExt = ext;
3433
3434 fileStruct.lpstrFile = fileBuf;
3435 fileStruct.nMaxFile = MAXPATHL;
3436 fileStruct.lpstrFilter = filterp;
3437 fileStruct.hwndOwner = s_hwnd; /* main Vim window is owner*/
3438 /* has an initial dir been specified? */
3439 if (initdir != NULL && *initdir != NUL)
3440 {
3441 /* Must have backslashes here, no matter what 'shellslash' says */
3442 initdirp = vim_strsave(initdir);
3443 if (initdirp != NULL)
3444 for (p = initdirp; *p != NUL; ++p)
3445 if (*p == '/')
3446 *p = '\\';
3447 fileStruct.lpstrInitialDir = initdirp;
3448 }
3449
3450 /*
3451 * TODO: Allow selection of multiple files. Needs another arg to this
3452 * function to ask for it, and need to use OFN_ALLOWMULTISELECT below.
3453 * Also, should we use OFN_FILEMUSTEXIST when opening? Vim can edit on
3454 * files that don't exist yet, so I haven't put it in. What about
3455 * OFN_PATHMUSTEXIST?
3456 * Don't use OFN_OVERWRITEPROMPT, Vim has its own ":confirm" dialog.
3457 */
3458 fileStruct.Flags = (OFN_NOCHANGEDIR | OFN_PATHMUSTEXIST | OFN_HIDEREADONLY);
3459#ifdef FEAT_SHORTCUT
3460 if (curbuf->b_p_bin)
3461 fileStruct.Flags |= OFN_NODEREFERENCELINKS;
3462#endif
3463 if (saving)
3464 {
3465 if (!GetSaveFileName(&fileStruct))
3466 return NULL;
3467 }
3468 else
3469 {
3470 if (!GetOpenFileName(&fileStruct))
3471 return NULL;
3472 }
3473
3474 vim_free(filterp);
3475 vim_free(initdirp);
3476
3477 /* Give focus back to main window (when using MDI). */
3478 SetFocus(s_hwnd);
3479
3480 /* Shorten the file name if possible */
Bram Moolenaard089d9b2007-09-30 12:02:55 +00003481 return vim_strsave(shorten_fname1((char_u *)fileBuf));
Bram Moolenaar071d4272004-06-13 20:20:40 +00003482}
3483#endif /* FEAT_BROWSE */
3484
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00003485/*ARGSUSED*/
Bram Moolenaar071d4272004-06-13 20:20:40 +00003486 static void
3487_OnDropFiles(
3488 HWND hwnd,
3489 HDROP hDrop)
3490{
3491#ifdef FEAT_WINDOWS
3492#ifdef WIN3264
3493# define BUFPATHLEN _MAX_PATH
3494# define DRAGQVAL 0xFFFFFFFF
3495#else
3496# define BUFPATHLEN MAXPATHL
3497# define DRAGQVAL 0xFFFF
3498#endif
3499#ifdef FEAT_MBYTE
3500 WCHAR wszFile[BUFPATHLEN];
3501#endif
3502 char szFile[BUFPATHLEN];
3503 UINT cFiles = DragQueryFile(hDrop, DRAGQVAL, NULL, 0);
3504 UINT i;
3505 char_u **fnames;
3506 POINT pt;
3507 int_u modifiers = 0;
3508
3509 /* TRACE("_OnDropFiles: %d files dropped\n", cFiles); */
3510
3511 /* Obtain dropped position */
3512 DragQueryPoint(hDrop, &pt);
3513 MapWindowPoints(s_hwnd, s_textArea, &pt, 1);
3514
3515# ifdef FEAT_VISUAL
3516 reset_VIsual();
3517# endif
3518
3519 fnames = (char_u **)alloc(cFiles * sizeof(char_u *));
3520
3521 if (fnames != NULL)
3522 for (i = 0; i < cFiles; ++i)
3523 {
3524#ifdef FEAT_MBYTE
3525 if (DragQueryFileW(hDrop, i, wszFile, BUFPATHLEN) > 0)
Bram Moolenaar36f692d2008-11-20 16:10:17 +00003526 fnames[i] = utf16_to_enc(wszFile, NULL);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003527 else
3528#endif
3529 {
3530 DragQueryFile(hDrop, i, szFile, BUFPATHLEN);
3531 fnames[i] = vim_strsave(szFile);
3532 }
3533 }
3534
3535 DragFinish(hDrop);
3536
3537 if (fnames != NULL)
3538 {
3539 if ((GetKeyState(VK_SHIFT) & 0x8000) != 0)
3540 modifiers |= MOUSE_SHIFT;
3541 if ((GetKeyState(VK_CONTROL) & 0x8000) != 0)
3542 modifiers |= MOUSE_CTRL;
3543 if ((GetKeyState(VK_MENU) & 0x8000) != 0)
3544 modifiers |= MOUSE_ALT;
3545
3546 gui_handle_drop(pt.x, pt.y, modifiers, fnames, cFiles);
3547
3548 s_need_activate = TRUE;
3549 }
3550#endif
3551}
3552
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00003553/*ARGSUSED*/
Bram Moolenaar071d4272004-06-13 20:20:40 +00003554 static int
3555_OnScroll(
3556 HWND hwnd,
3557 HWND hwndCtl,
3558 UINT code,
3559 int pos)
3560{
3561 static UINT prev_code = 0; /* code of previous call */
3562 scrollbar_T *sb, *sb_info;
3563 long val;
3564 int dragging = FALSE;
3565 int dont_scroll_save = dont_scroll;
3566#ifndef WIN3264
3567 int nPos;
3568#else
3569 SCROLLINFO si;
3570
3571 si.cbSize = sizeof(si);
3572 si.fMask = SIF_POS;
3573#endif
3574
3575 sb = gui_mswin_find_scrollbar(hwndCtl);
3576 if (sb == NULL)
3577 return 0;
3578
3579 if (sb->wp != NULL) /* Left or right scrollbar */
3580 {
3581 /*
3582 * Careful: need to get scrollbar info out of first (left) scrollbar
3583 * for window, but keep real scrollbar too because we must pass it to
3584 * gui_drag_scrollbar().
3585 */
3586 sb_info = &sb->wp->w_scrollbars[0];
3587 }
3588 else /* Bottom scrollbar */
3589 sb_info = sb;
3590 val = sb_info->value;
3591
3592 switch (code)
3593 {
3594 case SB_THUMBTRACK:
3595 val = pos;
3596 dragging = TRUE;
3597 if (sb->scroll_shift > 0)
3598 val <<= sb->scroll_shift;
3599 break;
3600 case SB_LINEDOWN:
3601 val++;
3602 break;
3603 case SB_LINEUP:
3604 val--;
3605 break;
3606 case SB_PAGEDOWN:
3607 val += (sb_info->size > 2 ? sb_info->size - 2 : 1);
3608 break;
3609 case SB_PAGEUP:
3610 val -= (sb_info->size > 2 ? sb_info->size - 2 : 1);
3611 break;
3612 case SB_TOP:
3613 val = 0;
3614 break;
3615 case SB_BOTTOM:
3616 val = sb_info->max;
3617 break;
3618 case SB_ENDSCROLL:
3619 if (prev_code == SB_THUMBTRACK)
3620 {
3621 /*
3622 * "pos" only gives us 16-bit data. In case of large file,
3623 * use GetScrollPos() which returns 32-bit. Unfortunately it
3624 * is not valid while the scrollbar is being dragged.
3625 */
3626 val = GetScrollPos(hwndCtl, SB_CTL);
3627 if (sb->scroll_shift > 0)
3628 val <<= sb->scroll_shift;
3629 }
3630 break;
3631
3632 default:
3633 /* TRACE("Unknown scrollbar event %d\n", code); */
3634 return 0;
3635 }
3636 prev_code = code;
3637
3638#ifdef WIN3264
3639 si.nPos = (sb->scroll_shift > 0) ? val >> sb->scroll_shift : val;
3640 SetScrollInfo(hwndCtl, SB_CTL, &si, TRUE);
3641#else
3642 nPos = (sb->scroll_shift > 0) ? val >> sb->scroll_shift : val;
3643 SetScrollPos(hwndCtl, SB_CTL, nPos, TRUE);
3644#endif
3645
3646 /*
3647 * When moving a vertical scrollbar, move the other vertical scrollbar too.
3648 */
3649 if (sb->wp != NULL)
3650 {
3651 scrollbar_T *sba = sb->wp->w_scrollbars;
3652 HWND id = sba[ (sb == sba + SBAR_LEFT) ? SBAR_RIGHT : SBAR_LEFT].id;
3653
3654#ifdef WIN3264
3655 SetScrollInfo(id, SB_CTL, &si, TRUE);
3656#else
3657 SetScrollPos(id, SB_CTL, nPos, TRUE);
3658#endif
3659 }
3660
3661 /* Don't let us be interrupted here by another message. */
3662 s_busy_processing = TRUE;
3663
3664 /* When "allow_scrollbar" is FALSE still need to remember the new
3665 * position, but don't actually scroll by setting "dont_scroll". */
3666 dont_scroll = !allow_scrollbar;
3667
3668 gui_drag_scrollbar(sb, val, dragging);
3669
3670 s_busy_processing = FALSE;
3671 dont_scroll = dont_scroll_save;
3672
3673 return 0;
3674}
3675
Bram Moolenaar3fdfa4a2004-10-07 21:02:47 +00003676
Bram Moolenaar071d4272004-06-13 20:20:40 +00003677/*
3678 * Get command line arguments.
3679 * Use "prog" as the name of the program and "cmdline" as the arguments.
3680 * Copy the arguments to allocated memory.
3681 * Return the number of arguments (including program name).
Bram Moolenaar12806c82008-11-12 12:36:30 +00003682 * Return pointers to the arguments in "argvp". Memory is allocated with
3683 * malloc(), use free() instead of vim_free().
Bram Moolenaar071d4272004-06-13 20:20:40 +00003684 * Return pointer to buffer in "tofree".
3685 * Returns zero when out of memory.
3686 */
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00003687/*ARGSUSED*/
Bram Moolenaar071d4272004-06-13 20:20:40 +00003688 int
3689get_cmd_args(char *prog, char *cmdline, char ***argvp, char **tofree)
3690{
3691 int i;
3692 char *p;
3693 char *progp;
3694 char *pnew = NULL;
3695 char *newcmdline;
3696 int inquote;
3697 int argc;
3698 char **argv = NULL;
3699 int round;
3700
Bram Moolenaar12806c82008-11-12 12:36:30 +00003701 *tofree = NULL;
3702
Bram Moolenaar3fdfa4a2004-10-07 21:02:47 +00003703#ifdef FEAT_MBYTE
3704 /* Try using the Unicode version first, it takes care of conversion when
3705 * 'encoding' is changed. */
3706 argc = get_cmd_argsW(&argv);
3707 if (argc != 0)
3708 goto done;
3709#endif
3710
Bram Moolenaar071d4272004-06-13 20:20:40 +00003711 /* Handle the program name. Remove the ".exe" extension, and find the 1st
3712 * non-space. */
3713 p = strrchr(prog, '.');
3714 if (p != NULL)
3715 *p = NUL;
3716 for (progp = prog; *progp == ' '; ++progp)
3717 ;
3718
3719 /* The command line is copied to allocated memory, so that we can change
3720 * it. Add the size of the string, the separating NUL and a terminating
3721 * NUL. */
3722 newcmdline = malloc(STRLEN(cmdline) + STRLEN(progp) + 2);
3723 if (newcmdline == NULL)
3724 return 0;
3725
3726 /*
3727 * First round: count the number of arguments ("pnew" == NULL).
3728 * Second round: produce the arguments.
3729 */
3730 for (round = 1; round <= 2; ++round)
3731 {
3732 /* First argument is the program name. */
3733 if (pnew != NULL)
3734 {
3735 argv[0] = pnew;
3736 strcpy(pnew, progp);
3737 pnew += strlen(pnew);
3738 *pnew++ = NUL;
3739 }
3740
3741 /*
3742 * Isolate each argument and put it in argv[].
3743 */
3744 p = cmdline;
3745 argc = 1;
3746 while (*p != NUL)
3747 {
3748 inquote = FALSE;
3749 if (pnew != NULL)
3750 argv[argc] = pnew;
3751 ++argc;
3752 while (*p != NUL && (inquote || (*p != ' ' && *p != '\t')))
3753 {
3754 /* Backslashes are only special when followed by a double
3755 * quote. */
Bram Moolenaara93fa7e2006-04-17 22:14:47 +00003756 i = (int)strspn(p, "\\");
Bram Moolenaar071d4272004-06-13 20:20:40 +00003757 if (p[i] == '"')
3758 {
3759 /* Halve the number of backslashes. */
3760 if (i > 1 && pnew != NULL)
3761 {
3762 memset(pnew, '\\', i / 2);
3763 pnew += i / 2;
3764 }
3765
3766 /* Even nr of backslashes toggles quoting, uneven copies
3767 * the double quote. */
3768 if ((i & 1) == 0)
3769 inquote = !inquote;
3770 else if (pnew != NULL)
3771 *pnew++ = '"';
3772 p += i + 1;
3773 }
3774 else if (i > 0)
3775 {
3776 /* Copy span of backslashes unmodified. */
3777 if (pnew != NULL)
3778 {
3779 memset(pnew, '\\', i);
3780 pnew += i;
3781 }
3782 p += i;
3783 }
3784 else
3785 {
3786 if (pnew != NULL)
3787 *pnew++ = *p;
Bram Moolenaar15d0a8c2004-09-06 17:44:46 +00003788#ifdef FEAT_MBYTE
3789 /* Can't use mb_* functions, because 'encoding' is not
3790 * initialized yet here. */
3791 if (IsDBCSLeadByte(*p))
3792 {
3793 ++p;
3794 if (pnew != NULL)
3795 *pnew++ = *p;
3796 }
3797#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00003798 ++p;
3799 }
3800 }
3801
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00003802 if (pnew != NULL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003803 *pnew++ = NUL;
3804 while (*p == ' ' || *p == '\t')
3805 ++p; /* advance until a non-space */
3806 }
3807
3808 if (round == 1)
3809 {
3810 argv = (char **)malloc((argc + 1) * sizeof(char *));
3811 if (argv == NULL )
Bram Moolenaare6b165e2005-06-30 21:56:01 +00003812 {
Bram Moolenaar12806c82008-11-12 12:36:30 +00003813 free(newcmdline);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003814 return 0; /* malloc error */
Bram Moolenaare6b165e2005-06-30 21:56:01 +00003815 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00003816 pnew = newcmdline;
Bram Moolenaar12806c82008-11-12 12:36:30 +00003817 *tofree = newcmdline;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003818 }
3819 }
3820
Bram Moolenaar3fdfa4a2004-10-07 21:02:47 +00003821done:
Bram Moolenaar3fdfa4a2004-10-07 21:02:47 +00003822 argv[argc] = NULL; /* NULL-terminated list */
Bram Moolenaar071d4272004-06-13 20:20:40 +00003823 *argvp = argv;
3824 return argc;
3825}