blob: bff67a813103d041e0eeaee08626d1e2856cb19a [file] [log] [blame]
Bram Moolenaar071d4272004-06-13 20:20:40 +00001/* vi:set ts=8 sts=4 sw=4:
2 *
3 * VIM - Vi IMproved by Bram Moolenaar
4 * GUI support by Robert Webb
5 *
6 * Do ":help uganda" in Vim to read copying and usage conditions.
7 * Do ":help credits" in Vim to see a list of people who contributed.
8 * See README.txt for an overview of the Vim source code.
9 */
10/*
11 * gui_w48.c: This file is included in gui_w16.c and gui_w32.c.
12 *
13 * GUI support for Microsoft Windows (Win16 + Win32 = Win48 :-)
14 *
15 * The combined efforts of:
16 * George V. Reilly <george@reilly.org>
17 * Robert Webb
18 * Vince Negri
19 * ...and contributions from many others
20 *
21 */
22
23#include "vim.h"
24#include "version.h" /* used by dialog box routine for default title */
25#ifdef DEBUG
26# include <tchar.h>
27#endif
Bram Moolenaar82881492012-11-20 16:53:39 +010028
29/* cproto fails on missing include files */
30#ifndef PROTO
31
Bram Moolenaar071d4272004-06-13 20:20:40 +000032#ifndef __MINGW32__
33# include <shellapi.h>
34#endif
Bram Moolenaar3991dab2006-03-27 17:01:56 +000035#if defined(FEAT_TOOLBAR) || defined(FEAT_BEVAL) || defined(FEAT_GUI_TABLINE)
Bram Moolenaar071d4272004-06-13 20:20:40 +000036# include <commctrl.h>
37#endif
38#ifdef WIN16
39# include <commdlg.h>
40# include <shellapi.h>
41# ifdef WIN16_3DLOOK
42# include <ctl3d.h>
43# endif
44#endif
45#include <windowsx.h>
46
47#ifdef GLOBAL_IME
48# include "glbl_ime.h"
49#endif
50
Bram Moolenaar82881492012-11-20 16:53:39 +010051#endif /* PROTO */
52
Bram Moolenaar071d4272004-06-13 20:20:40 +000053#ifdef FEAT_MENU
54# define MENUHINTS /* show menu hints in command line */
55#endif
56
57/* Some parameters for dialog boxes. All in pixels. */
58#define DLG_PADDING_X 10
59#define DLG_PADDING_Y 10
60#define DLG_OLD_STYLE_PADDING_X 5
61#define DLG_OLD_STYLE_PADDING_Y 5
62#define DLG_VERT_PADDING_X 4 /* For vertical buttons */
63#define DLG_VERT_PADDING_Y 4
64#define DLG_ICON_WIDTH 34
65#define DLG_ICON_HEIGHT 34
66#define DLG_MIN_WIDTH 150
67#define DLG_FONT_NAME "MS Sans Serif"
68#define DLG_FONT_POINT_SIZE 8
69#define DLG_MIN_MAX_WIDTH 400
Bram Moolenaar748bf032005-02-02 23:04:36 +000070#define DLG_MIN_MAX_HEIGHT 400
Bram Moolenaar071d4272004-06-13 20:20:40 +000071
72#define DLG_NONBUTTON_CONTROL 5000 /* First ID of non-button controls */
73
74#ifndef WM_XBUTTONDOWN /* For Win2K / winME ONLY */
75# define WM_XBUTTONDOWN 0x020B
76# define WM_XBUTTONUP 0x020C
77# define WM_XBUTTONDBLCLK 0x020D
78# define MK_XBUTTON1 0x0020
79# define MK_XBUTTON2 0x0040
80#endif
81
82#ifdef PROTO
83/*
84 * Define a few things for generating prototypes. This is just to avoid
85 * syntax errors, the defines do not need to be correct.
86 */
87# define APIENTRY
88# define CALLBACK
89# define CONST
90# define FAR
91# define NEAR
92# define _cdecl
93typedef int BOOL;
94typedef int BYTE;
95typedef int DWORD;
96typedef int WCHAR;
97typedef int ENUMLOGFONT;
98typedef int FINDREPLACE;
99typedef int HANDLE;
100typedef int HBITMAP;
101typedef int HBRUSH;
102typedef int HDROP;
103typedef int INT;
104typedef int LOGFONT[];
105typedef int LPARAM;
106typedef int LPCREATESTRUCT;
107typedef int LPCSTR;
108typedef int LPCTSTR;
109typedef int LPRECT;
110typedef int LPSTR;
111typedef int LPWINDOWPOS;
112typedef int LPWORD;
113typedef int LRESULT;
Bram Moolenaare344bea2005-09-01 20:46:49 +0000114typedef int HRESULT;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000115# undef MSG
116typedef int MSG;
117typedef int NEWTEXTMETRIC;
118typedef int OSVERSIONINFO;
119typedef int PWORD;
120typedef int RECT;
121typedef int UINT;
122typedef int WORD;
123typedef int WPARAM;
124typedef int POINT;
125typedef void *HINSTANCE;
126typedef void *HMENU;
127typedef void *HWND;
128typedef void *HDC;
129typedef void VOID;
130typedef int LPNMHDR;
131typedef int LONG;
Bram Moolenaar3b1db362013-08-10 15:00:24 +0200132typedef int WNDPROC;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000133#endif
134
135#ifndef GET_X_LPARAM
136# define GET_X_LPARAM(lp) ((int)(short)LOWORD(lp))
137#endif
138
139static void _OnPaint( HWND hwnd);
140static void clear_rect(RECT *rcp);
141static int gui_mswin_get_menu_height(int fix_window);
142
143static WORD s_dlgfntheight; /* height of the dialog font */
144static WORD s_dlgfntwidth; /* width of the dialog font */
145
146#ifdef FEAT_MENU
147static HMENU s_menuBar = NULL;
148#endif
149#ifdef FEAT_TEAROFF
150static void rebuild_tearoff(vimmenu_T *menu);
151static HBITMAP s_htearbitmap; /* bitmap used to indicate tearoff */
152#endif
153
Bram Moolenaar48687262007-05-10 17:17:07 +0000154/* Flag that is set while processing a message that must not be interrupted by
Bram Moolenaar071d4272004-06-13 20:20:40 +0000155 * processing another message. */
156static int s_busy_processing = FALSE;
157
158static int destroying = FALSE; /* call DestroyWindow() ourselves */
159
160#ifdef MSWIN_FIND_REPLACE
161static UINT s_findrep_msg = 0; /* set in gui_w[16/32].c */
162static FINDREPLACE s_findrep_struct;
Bram Moolenaar3ca9a8a2009-01-28 20:23:17 +0000163# if defined(FEAT_MBYTE) && defined(WIN3264)
164static FINDREPLACEW s_findrep_struct_w;
165# endif
Bram Moolenaar071d4272004-06-13 20:20:40 +0000166static HWND s_findrep_hwnd = NULL;
167static int s_findrep_is_find; /* TRUE for find dialog, FALSE
168 for find/replace dialog */
169#endif
170
171static HINSTANCE s_hinst = NULL;
172#if !defined(FEAT_SNIFF) && !defined(FEAT_GUI)
173static
174#endif
175HWND s_hwnd = NULL;
176static HDC s_hdc = NULL;
177static HBRUSH s_brush = NULL;
178
179#ifdef FEAT_TOOLBAR
180static HWND s_toolbarhwnd = NULL;
Bram Moolenaar5f919ee2013-07-21 17:46:43 +0200181static WNDPROC s_toolbar_wndproc = NULL;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000182#endif
183
Bram Moolenaar3991dab2006-03-27 17:01:56 +0000184#ifdef FEAT_GUI_TABLINE
185static HWND s_tabhwnd = NULL;
Bram Moolenaar5f919ee2013-07-21 17:46:43 +0200186static WNDPROC s_tabline_wndproc = NULL;
Bram Moolenaar3991dab2006-03-27 17:01:56 +0000187static int showing_tabline = 0;
188#endif
189
Bram Moolenaar071d4272004-06-13 20:20:40 +0000190static WPARAM s_wParam = 0;
191static LPARAM s_lParam = 0;
192
193static HWND s_textArea = NULL;
194static UINT s_uMsg = 0;
195
196static char_u *s_textfield; /* Used by dialogs to pass back strings */
197
198static int s_need_activate = FALSE;
199
200/* This variable is set when waiting for an event, which is the only moment
201 * scrollbar dragging can be done directly. It's not allowed while commands
202 * are executed, because it may move the cursor and that may cause unexpected
203 * problems (e.g., while ":s" is working).
204 */
205static int allow_scrollbar = FALSE;
206
207#ifdef GLOBAL_IME
208# define MyTranslateMessage(x) global_ime_TranslateMessage(x)
209#else
210# define MyTranslateMessage(x) TranslateMessage(x)
211#endif
212
213#if (defined(WIN3264) && defined(FEAT_MBYTE)) || defined(GLOBAL_IME)
214 /* use of WindowProc depends on wide_WindowProc */
215# define MyWindowProc vim_WindowProc
216#else
217 /* use ordinary WindowProc */
218# define MyWindowProc DefWindowProc
219#endif
220
221extern int current_font_height; /* this is in os_mswin.c */
222
223static struct
224{
225 UINT key_sym;
226 char_u vim_code0;
227 char_u vim_code1;
228} special_keys[] =
229{
230 {VK_UP, 'k', 'u'},
231 {VK_DOWN, 'k', 'd'},
232 {VK_LEFT, 'k', 'l'},
233 {VK_RIGHT, 'k', 'r'},
234
235 {VK_F1, 'k', '1'},
236 {VK_F2, 'k', '2'},
237 {VK_F3, 'k', '3'},
238 {VK_F4, 'k', '4'},
239 {VK_F5, 'k', '5'},
240 {VK_F6, 'k', '6'},
241 {VK_F7, 'k', '7'},
242 {VK_F8, 'k', '8'},
243 {VK_F9, 'k', '9'},
244 {VK_F10, 'k', ';'},
245
246 {VK_F11, 'F', '1'},
247 {VK_F12, 'F', '2'},
248 {VK_F13, 'F', '3'},
249 {VK_F14, 'F', '4'},
250 {VK_F15, 'F', '5'},
251 {VK_F16, 'F', '6'},
252 {VK_F17, 'F', '7'},
253 {VK_F18, 'F', '8'},
254 {VK_F19, 'F', '9'},
255 {VK_F20, 'F', 'A'},
256
257 {VK_F21, 'F', 'B'},
258#ifdef FEAT_NETBEANS_INTG
259 {VK_PAUSE, 'F', 'B'}, /* Pause == F21 (see gui_gtk_x11.c) */
260#endif
261 {VK_F22, 'F', 'C'},
262 {VK_F23, 'F', 'D'},
263 {VK_F24, 'F', 'E'}, /* winuser.h defines up to F24 */
264
265 {VK_HELP, '%', '1'},
266 {VK_BACK, 'k', 'b'},
267 {VK_INSERT, 'k', 'I'},
268 {VK_DELETE, 'k', 'D'},
269 {VK_HOME, 'k', 'h'},
270 {VK_END, '@', '7'},
271 {VK_PRIOR, 'k', 'P'},
272 {VK_NEXT, 'k', 'N'},
273 {VK_PRINT, '%', '9'},
274 {VK_ADD, 'K', '6'},
275 {VK_SUBTRACT, 'K', '7'},
276 {VK_DIVIDE, 'K', '8'},
277 {VK_MULTIPLY, 'K', '9'},
278 {VK_SEPARATOR, 'K', 'A'}, /* Keypad Enter */
279 {VK_DECIMAL, 'K', 'B'},
280
281 {VK_NUMPAD0, 'K', 'C'},
282 {VK_NUMPAD1, 'K', 'D'},
283 {VK_NUMPAD2, 'K', 'E'},
284 {VK_NUMPAD3, 'K', 'F'},
285 {VK_NUMPAD4, 'K', 'G'},
286 {VK_NUMPAD5, 'K', 'H'},
287 {VK_NUMPAD6, 'K', 'I'},
288 {VK_NUMPAD7, 'K', 'J'},
289 {VK_NUMPAD8, 'K', 'K'},
290 {VK_NUMPAD9, 'K', 'L'},
291
292 /* Keys that we want to be able to use any modifier with: */
293 {VK_SPACE, ' ', NUL},
294 {VK_TAB, TAB, NUL},
295 {VK_ESCAPE, ESC, NUL},
296 {NL, NL, NUL},
297 {CAR, CAR, NUL},
298
299 /* End of list marker: */
300 {0, 0, 0}
301};
302
303/* Local variables */
304static int s_button_pending = -1;
Bram Moolenaarea408882007-12-03 21:21:03 +0000305
306/* s_getting_focus is set when we got focus but didn't see mouse-up event yet,
307 * so don't reset s_button_pending. */
308static int s_getting_focus = FALSE;
309
Bram Moolenaar071d4272004-06-13 20:20:40 +0000310static int s_x_pending;
311static int s_y_pending;
312static UINT s_kFlags_pending;
313static UINT s_wait_timer = 0; /* Timer for get char from user */
314static int s_timed_out = FALSE;
315static int dead_key = 0; /* 0 - no dead key, 1 - dead key pressed */
316
317#ifdef WIN3264
318static OSVERSIONINFO os_version; /* like it says. Init in gui_mch_init() */
319#endif
320
321#ifdef FEAT_BEVAL
322/* balloon-eval WM_NOTIFY_HANDLER */
323static void Handle_WM_Notify __ARGS((HWND hwnd, LPNMHDR pnmh));
324static void TrackUserActivity __ARGS((UINT uMsg));
325#endif
326
327/*
328 * For control IME.
Bram Moolenaar0f272122013-01-23 18:37:40 +0100329 *
330 * These LOGFONT used for IME.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000331 */
332#ifdef FEAT_MBYTE
333# ifdef USE_IM_CONTROL
Bram Moolenaar0f272122013-01-23 18:37:40 +0100334/* holds LOGFONT for 'guifontwide' if available, otherwise 'guifont' */
Bram Moolenaar071d4272004-06-13 20:20:40 +0000335static LOGFONT norm_logfont;
Bram Moolenaar0f272122013-01-23 18:37:40 +0100336/* holds LOGFONT for 'guifont' always. */
337static LOGFONT sub_logfont;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000338# endif
339#endif
340
341#ifdef FEAT_MBYTE_IME
342static LRESULT _OnImeNotify(HWND hWnd, DWORD dwCommand, DWORD dwData);
343#endif
344
Bram Moolenaar3ef7cdf2012-01-20 17:57:51 +0100345#if defined(FEAT_MBYTE) && defined(WIN3264)
346static char_u *convert_filter(char_u *s);
347#endif
348
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +0000349#ifdef DEBUG_PRINT_ERROR
Bram Moolenaar071d4272004-06-13 20:20:40 +0000350/*
351 * Print out the last Windows error message
352 */
353 static void
354print_windows_error(void)
355{
356 LPVOID lpMsgBuf;
357
358 FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
359 NULL, GetLastError(),
360 MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
361 (LPTSTR) &lpMsgBuf, 0, NULL);
362 TRACE1("Error: %s\n", lpMsgBuf);
363 LocalFree(lpMsgBuf);
364}
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +0000365#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +0000366
367/*
368 * Cursor blink functions.
369 *
370 * This is a simple state machine:
371 * BLINK_NONE not blinking at all
372 * BLINK_OFF blinking, cursor is not shown
373 * BLINK_ON blinking, cursor is shown
374 */
375
376#define BLINK_NONE 0
377#define BLINK_OFF 1
378#define BLINK_ON 2
379
380static int blink_state = BLINK_NONE;
381static long_u blink_waittime = 700;
382static long_u blink_ontime = 400;
383static long_u blink_offtime = 250;
384static UINT blink_timer = 0;
385
386 void
387gui_mch_set_blinking(long wait, long on, long off)
388{
389 blink_waittime = wait;
390 blink_ontime = on;
391 blink_offtime = off;
392}
393
394/* ARGSUSED */
395 static VOID CALLBACK
396_OnBlinkTimer(
397 HWND hwnd,
398 UINT uMsg,
399 UINT idEvent,
400 DWORD dwTime)
401{
402 MSG msg;
403
404 /*
405 TRACE2("Got timer event, id %d, blink_timer %d\n", idEvent, blink_timer);
406 */
407
408 KillTimer(NULL, idEvent);
409
410 /* Eat spurious WM_TIMER messages */
Bram Moolenaar8c85fa32011-08-10 17:08:03 +0200411 while (pPeekMessage(&msg, hwnd, WM_TIMER, WM_TIMER, PM_REMOVE))
Bram Moolenaar071d4272004-06-13 20:20:40 +0000412 ;
413
414 if (blink_state == BLINK_ON)
415 {
416 gui_undraw_cursor();
417 blink_state = BLINK_OFF;
418 blink_timer = (UINT) SetTimer(NULL, 0, (UINT)blink_offtime,
419 (TIMERPROC)_OnBlinkTimer);
420 }
421 else
422 {
423 gui_update_cursor(TRUE, FALSE);
424 blink_state = BLINK_ON;
425 blink_timer = (UINT) SetTimer(NULL, 0, (UINT)blink_ontime,
426 (TIMERPROC)_OnBlinkTimer);
427 }
428}
429
430 static void
431gui_mswin_rm_blink_timer(void)
432{
433 MSG msg;
434
435 if (blink_timer != 0)
436 {
437 KillTimer(NULL, blink_timer);
438 /* Eat spurious WM_TIMER messages */
Bram Moolenaar8c85fa32011-08-10 17:08:03 +0200439 while (pPeekMessage(&msg, s_hwnd, WM_TIMER, WM_TIMER, PM_REMOVE))
Bram Moolenaar071d4272004-06-13 20:20:40 +0000440 ;
441 blink_timer = 0;
442 }
443}
444
445/*
446 * Stop the cursor blinking. Show the cursor if it wasn't shown.
447 */
448 void
449gui_mch_stop_blink(void)
450{
451 gui_mswin_rm_blink_timer();
452 if (blink_state == BLINK_OFF)
453 gui_update_cursor(TRUE, FALSE);
454 blink_state = BLINK_NONE;
455}
456
457/*
458 * Start the cursor blinking. If it was already blinking, this restarts the
459 * waiting time and shows the cursor.
460 */
461 void
462gui_mch_start_blink(void)
463{
464 gui_mswin_rm_blink_timer();
465
466 /* Only switch blinking on if none of the times is zero */
467 if (blink_waittime && blink_ontime && blink_offtime && gui.in_focus)
468 {
469 blink_timer = (UINT)SetTimer(NULL, 0, (UINT)blink_waittime,
470 (TIMERPROC)_OnBlinkTimer);
471 blink_state = BLINK_ON;
472 gui_update_cursor(TRUE, FALSE);
473 }
474}
475
476/*
477 * Call-back routines.
478 */
479
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +0000480/*ARGSUSED*/
Bram Moolenaar071d4272004-06-13 20:20:40 +0000481 static VOID CALLBACK
482_OnTimer(
483 HWND hwnd,
484 UINT uMsg,
485 UINT idEvent,
486 DWORD dwTime)
487{
488 MSG msg;
489
490 /*
491 TRACE2("Got timer event, id %d, s_wait_timer %d\n", idEvent, s_wait_timer);
492 */
493 KillTimer(NULL, idEvent);
494 s_timed_out = TRUE;
495
496 /* Eat spurious WM_TIMER messages */
Bram Moolenaar8c85fa32011-08-10 17:08:03 +0200497 while (pPeekMessage(&msg, hwnd, WM_TIMER, WM_TIMER, PM_REMOVE))
Bram Moolenaar071d4272004-06-13 20:20:40 +0000498 ;
499 if (idEvent == s_wait_timer)
500 s_wait_timer = 0;
501}
502
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +0000503/*ARGSUSED*/
Bram Moolenaar071d4272004-06-13 20:20:40 +0000504 static void
505_OnDeadChar(
506 HWND hwnd,
507 UINT ch,
508 int cRepeat)
509{
510 dead_key = 1;
511}
512
513/*
514 * Convert Unicode character "ch" to bytes in "string[slen]".
Bram Moolenaar85a3e5c2007-11-20 16:22:16 +0000515 * When "had_alt" is TRUE the ALT key was included in "ch".
Bram Moolenaar071d4272004-06-13 20:20:40 +0000516 * Return the length.
517 */
518 static int
Bram Moolenaar85a3e5c2007-11-20 16:22:16 +0000519char_to_string(int ch, char_u *string, int slen, int had_alt)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000520{
521 int len;
522 int i;
523#ifdef FEAT_MBYTE
524 WCHAR wstring[2];
525 char_u *ws = NULL;;
526
Bram Moolenaar293ee4d2004-12-09 21:34:53 +0000527 if (os_version.dwPlatformId != VER_PLATFORM_WIN32_NT)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000528 {
Bram Moolenaar293ee4d2004-12-09 21:34:53 +0000529 /* On Windows 95/98 we apparently get the character in the active
530 * codepage, not in UCS-2. If conversion is needed convert it to
531 * UCS-2 first. */
532 if ((int)GetACP() == enc_codepage)
533 len = 0; /* no conversion required */
Bram Moolenaar071d4272004-06-13 20:20:40 +0000534 else
535 {
Bram Moolenaar293ee4d2004-12-09 21:34:53 +0000536 string[0] = ch;
537 len = MultiByteToWideChar(GetACP(), 0, string, 1, wstring, 2);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000538 }
539 }
Bram Moolenaar293ee4d2004-12-09 21:34:53 +0000540 else
541 {
542 wstring[0] = ch;
543 len = 1;
544 }
545
546 if (len > 0)
547 {
548 /* "ch" is a UTF-16 character. Convert it to a string of bytes. When
549 * "enc_codepage" is non-zero use the standard Win32 function,
550 * otherwise use our own conversion function (e.g., for UTF-8). */
551 if (enc_codepage > 0)
Bram Moolenaar85a3e5c2007-11-20 16:22:16 +0000552 {
Bram Moolenaar293ee4d2004-12-09 21:34:53 +0000553 len = WideCharToMultiByte(enc_codepage, 0, wstring, len,
554 string, slen, 0, NULL);
Bram Moolenaar85a3e5c2007-11-20 16:22:16 +0000555 /* If we had included the ALT key into the character but now the
556 * upper bit is no longer set, that probably means the conversion
557 * failed. Convert the original character and set the upper bit
558 * afterwards. */
559 if (had_alt && len == 1 && ch >= 0x80 && string[0] < 0x80)
560 {
561 wstring[0] = ch & 0x7f;
562 len = WideCharToMultiByte(enc_codepage, 0, wstring, len,
563 string, slen, 0, NULL);
564 if (len == 1) /* safety check */
565 string[0] |= 0x80;
566 }
567 }
Bram Moolenaar293ee4d2004-12-09 21:34:53 +0000568 else
569 {
570 len = 1;
Bram Moolenaar36f692d2008-11-20 16:10:17 +0000571 ws = utf16_to_enc(wstring, &len);
Bram Moolenaar293ee4d2004-12-09 21:34:53 +0000572 if (ws == NULL)
573 len = 0;
574 else
575 {
576 if (len > slen) /* just in case */
577 len = slen;
578 mch_memmove(string, ws, len);
579 vim_free(ws);
580 }
581 }
582 }
583
Bram Moolenaar071d4272004-06-13 20:20:40 +0000584 if (len == 0)
585#endif
586 {
587 string[0] = ch;
588 len = 1;
589 }
590
591 for (i = 0; i < len; ++i)
592 if (string[i] == CSI && len <= slen - 2)
593 {
594 /* Insert CSI as K_CSI. */
595 mch_memmove(string + i + 3, string + i + 1, len - i - 1);
596 string[++i] = KS_EXTRA;
597 string[++i] = (int)KE_CSI;
598 len += 2;
599 }
600
601 return len;
602}
603
604/*
605 * Key hit, add it to the input buffer.
606 */
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +0000607/*ARGSUSED*/
Bram Moolenaar071d4272004-06-13 20:20:40 +0000608 static void
609_OnChar(
610 HWND hwnd,
611 UINT ch,
612 int cRepeat)
613{
614 char_u string[40];
615 int len = 0;
616
Bram Moolenaard2e80872014-08-22 18:44:33 +0200617 dead_key = 0;
618
Bram Moolenaar85a3e5c2007-11-20 16:22:16 +0000619 len = char_to_string(ch, string, 40, FALSE);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000620 if (len == 1 && string[0] == Ctrl_C && ctrl_c_interrupts)
621 {
622 trash_input_buf();
623 got_int = TRUE;
624 }
625
626 add_to_input_buf(string, len);
627}
628
629/*
630 * Alt-Key hit, add it to the input buffer.
631 */
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +0000632/*ARGSUSED*/
Bram Moolenaar071d4272004-06-13 20:20:40 +0000633 static void
634_OnSysChar(
635 HWND hwnd,
636 UINT cch,
637 int cRepeat)
638{
639 char_u string[40]; /* Enough for multibyte character */
640 int len;
641 int modifiers;
642 int ch = cch; /* special keys are negative */
643
644 /* TRACE("OnSysChar(%d, %c)\n", ch, ch); */
645
646 /* OK, we have a character key (given by ch) which was entered with the
647 * ALT key pressed. Eg, if the user presses Alt-A, then ch == 'A'. Note
648 * that the system distinguishes Alt-a and Alt-A (Alt-Shift-a unless
649 * CAPSLOCK is pressed) at this point.
650 */
651 modifiers = MOD_MASK_ALT;
652 if (GetKeyState(VK_SHIFT) & 0x8000)
653 modifiers |= MOD_MASK_SHIFT;
654 if (GetKeyState(VK_CONTROL) & 0x8000)
655 modifiers |= MOD_MASK_CTRL;
656
657 ch = simplify_key(ch, &modifiers);
658 /* remove the SHIFT modifier for keys where it's already included, e.g.,
659 * '(' and '*' */
660 if (ch < 0x100 && !isalpha(ch) && isprint(ch))
661 modifiers &= ~MOD_MASK_SHIFT;
662
663 /* Interpret the ALT key as making the key META, include SHIFT, etc. */
664 ch = extract_modifiers(ch, &modifiers);
665 if (ch == CSI)
666 ch = K_CSI;
667
668 len = 0;
669 if (modifiers)
670 {
671 string[len++] = CSI;
672 string[len++] = KS_MODIFIER;
673 string[len++] = modifiers;
674 }
675
676 if (IS_SPECIAL((int)ch))
677 {
678 string[len++] = CSI;
679 string[len++] = K_SECOND((int)ch);
680 string[len++] = K_THIRD((int)ch);
681 }
682 else
683 {
684 /* Although the documentation isn't clear about it, we assume "ch" is
685 * a Unicode character. */
Bram Moolenaar85a3e5c2007-11-20 16:22:16 +0000686 len += char_to_string(ch, string + len, 40 - len, TRUE);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000687 }
688
689 add_to_input_buf(string, len);
690}
691
692 static void
693_OnMouseEvent(
694 int button,
695 int x,
696 int y,
697 int repeated_click,
698 UINT keyFlags)
699{
700 int vim_modifiers = 0x0;
701
Bram Moolenaarea408882007-12-03 21:21:03 +0000702 s_getting_focus = FALSE;
703
Bram Moolenaar071d4272004-06-13 20:20:40 +0000704 if (keyFlags & MK_SHIFT)
705 vim_modifiers |= MOUSE_SHIFT;
706 if (keyFlags & MK_CONTROL)
707 vim_modifiers |= MOUSE_CTRL;
708 if (GetKeyState(VK_MENU) & 0x8000)
709 vim_modifiers |= MOUSE_ALT;
710
711 gui_send_mouse_event(button, x, y, repeated_click, vim_modifiers);
712}
713
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +0000714/*ARGSUSED*/
Bram Moolenaar071d4272004-06-13 20:20:40 +0000715 static void
716_OnMouseButtonDown(
717 HWND hwnd,
718 BOOL fDoubleClick,
719 int x,
720 int y,
721 UINT keyFlags)
722{
723 static LONG s_prevTime = 0;
724
725 LONG currentTime = GetMessageTime();
726 int button = -1;
727 int repeated_click;
728
729 /* Give main window the focus: this is so the cursor isn't hollow. */
730 (void)SetFocus(s_hwnd);
731
732 if (s_uMsg == WM_LBUTTONDOWN || s_uMsg == WM_LBUTTONDBLCLK)
733 button = MOUSE_LEFT;
734 else if (s_uMsg == WM_MBUTTONDOWN || s_uMsg == WM_MBUTTONDBLCLK)
735 button = MOUSE_MIDDLE;
736 else if (s_uMsg == WM_RBUTTONDOWN || s_uMsg == WM_RBUTTONDBLCLK)
737 button = MOUSE_RIGHT;
738#ifndef WIN16 /*<VN>*/
739 else if (s_uMsg == WM_XBUTTONDOWN || s_uMsg == WM_XBUTTONDBLCLK)
740 {
741#ifndef GET_XBUTTON_WPARAM
742# define GET_XBUTTON_WPARAM(wParam) (HIWORD(wParam))
743#endif
744 button = ((GET_XBUTTON_WPARAM(s_wParam) == 1) ? MOUSE_X1 : MOUSE_X2);
745 }
746 else if (s_uMsg == WM_CAPTURECHANGED)
747 {
748 /* on W95/NT4, somehow you get in here with an odd Msg
749 * if you press one button while holding down the other..*/
750 if (s_button_pending == MOUSE_LEFT)
751 button = MOUSE_RIGHT;
752 else
753 button = MOUSE_LEFT;
754 }
755#endif
756 if (button >= 0)
757 {
758 repeated_click = ((int)(currentTime - s_prevTime) < p_mouset);
759
760 /*
761 * Holding down the left and right buttons simulates pushing the middle
762 * button.
763 */
Bram Moolenaar293ee4d2004-12-09 21:34:53 +0000764 if (repeated_click
765 && ((button == MOUSE_LEFT && s_button_pending == MOUSE_RIGHT)
766 || (button == MOUSE_RIGHT
767 && s_button_pending == MOUSE_LEFT)))
Bram Moolenaar071d4272004-06-13 20:20:40 +0000768 {
769 /*
770 * Hmm, gui.c will ignore more than one button down at a time, so
771 * pretend we let go of it first.
772 */
773 gui_send_mouse_event(MOUSE_RELEASE, x, y, FALSE, 0x0);
774 button = MOUSE_MIDDLE;
775 repeated_click = FALSE;
776 s_button_pending = -1;
777 _OnMouseEvent(button, x, y, repeated_click, keyFlags);
778 }
779 else if ((repeated_click)
780 || (mouse_model_popup() && (button == MOUSE_RIGHT)))
781 {
782 if (s_button_pending > -1)
783 {
784 _OnMouseEvent(s_button_pending, x, y, FALSE, keyFlags);
785 s_button_pending = -1;
786 }
787 /* TRACE("Button down at x %d, y %d\n", x, y); */
788 _OnMouseEvent(button, x, y, repeated_click, keyFlags);
789 }
790 else
791 {
792 /*
793 * If this is the first press (i.e. not a multiple click) don't
794 * action immediately, but store and wait for:
795 * i) button-up
796 * ii) mouse move
797 * iii) another button press
798 * before using it.
799 * This enables us to make left+right simulate middle button,
800 * without left or right being actioned first. The side-effect is
801 * that if you click and hold the mouse without dragging, the
802 * cursor doesn't move until you release the button. In practice
803 * this is hardly a problem.
804 */
805 s_button_pending = button;
806 s_x_pending = x;
807 s_y_pending = y;
808 s_kFlags_pending = keyFlags;
809 }
810
811 s_prevTime = currentTime;
812 }
813}
814
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +0000815/*ARGSUSED*/
Bram Moolenaar071d4272004-06-13 20:20:40 +0000816 static void
817_OnMouseMoveOrRelease(
818 HWND hwnd,
819 int x,
820 int y,
821 UINT keyFlags)
822{
823 int button;
824
Bram Moolenaarea408882007-12-03 21:21:03 +0000825 s_getting_focus = FALSE;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000826 if (s_button_pending > -1)
827 {
828 /* Delayed action for mouse down event */
829 _OnMouseEvent(s_button_pending, s_x_pending,
Bram Moolenaar293ee4d2004-12-09 21:34:53 +0000830 s_y_pending, FALSE, s_kFlags_pending);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000831 s_button_pending = -1;
832 }
833 if (s_uMsg == WM_MOUSEMOVE)
834 {
835 /*
836 * It's only a MOUSE_DRAG if one or more mouse buttons are being held
837 * down.
838 */
839 if (!(keyFlags & (MK_LBUTTON | MK_MBUTTON | MK_RBUTTON
840 | MK_XBUTTON1 | MK_XBUTTON2)))
841 {
842 gui_mouse_moved(x, y);
843 return;
844 }
845
846 /*
847 * While button is down, keep grabbing mouse move events when
848 * the mouse goes outside the window
849 */
850 SetCapture(s_textArea);
851 button = MOUSE_DRAG;
852 /* TRACE(" move at x %d, y %d\n", x, y); */
853 }
854 else
855 {
856 ReleaseCapture();
857 button = MOUSE_RELEASE;
858 /* TRACE(" up at x %d, y %d\n", x, y); */
859 }
860
861 _OnMouseEvent(button, x, y, FALSE, keyFlags);
862}
863
864#ifdef FEAT_MENU
865/*
866 * Find the vimmenu_T with the given id
867 */
868 static vimmenu_T *
869gui_mswin_find_menu(
870 vimmenu_T *pMenu,
871 int id)
872{
873 vimmenu_T *pChildMenu;
874
875 while (pMenu)
876 {
877 if (pMenu->id == (UINT)id)
878 break;
879 if (pMenu->children != NULL)
880 {
881 pChildMenu = gui_mswin_find_menu(pMenu->children, id);
882 if (pChildMenu)
883 {
884 pMenu = pChildMenu;
885 break;
886 }
887 }
888 pMenu = pMenu->next;
889 }
890 return pMenu;
891}
892
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +0000893/*ARGSUSED*/
Bram Moolenaar071d4272004-06-13 20:20:40 +0000894 static void
895_OnMenu(
896 HWND hwnd,
897 int id,
898 HWND hwndCtl,
899 UINT codeNotify)
900{
901 vimmenu_T *pMenu;
902
903 pMenu = gui_mswin_find_menu(root_menu, id);
904 if (pMenu)
905 gui_menu_cb(pMenu);
906}
907#endif
908
909#ifdef MSWIN_FIND_REPLACE
Bram Moolenaar3ca9a8a2009-01-28 20:23:17 +0000910# if defined(FEAT_MBYTE) && defined(WIN3264)
911/*
912 * copy useful data from structure LPFINDREPLACE to structure LPFINDREPLACEW
913 */
914 static void
915findrep_atow(LPFINDREPLACEW lpfrw, LPFINDREPLACE lpfr)
916{
917 WCHAR *wp;
918
919 lpfrw->hwndOwner = lpfr->hwndOwner;
920 lpfrw->Flags = lpfr->Flags;
921
922 wp = enc_to_utf16(lpfr->lpstrFindWhat, NULL);
923 wcsncpy(lpfrw->lpstrFindWhat, wp, lpfrw->wFindWhatLen - 1);
924 vim_free(wp);
925
926 /* the field "lpstrReplaceWith" doesn't need to be copied */
927}
928
929/*
930 * copy useful data from structure LPFINDREPLACEW to structure LPFINDREPLACE
931 */
932 static void
933findrep_wtoa(LPFINDREPLACE lpfr, LPFINDREPLACEW lpfrw)
934{
935 char_u *p;
936
937 lpfr->Flags = lpfrw->Flags;
938
939 p = utf16_to_enc(lpfrw->lpstrFindWhat, NULL);
940 vim_strncpy(lpfr->lpstrFindWhat, p, lpfr->wFindWhatLen - 1);
941 vim_free(p);
942
943 p = utf16_to_enc(lpfrw->lpstrReplaceWith, NULL);
944 vim_strncpy(lpfr->lpstrReplaceWith, p, lpfr->wReplaceWithLen - 1);
945 vim_free(p);
946}
947# endif
948
Bram Moolenaar071d4272004-06-13 20:20:40 +0000949/*
950 * Handle a Find/Replace window message.
951 */
952 static void
953_OnFindRepl(void)
954{
955 int flags = 0;
956 int down;
957
Bram Moolenaar3ca9a8a2009-01-28 20:23:17 +0000958# if defined(FEAT_MBYTE) && defined(WIN3264)
959 /* If the OS is Windows NT, and 'encoding' differs from active codepage:
960 * convert text from wide string. */
961 if (os_version.dwPlatformId == VER_PLATFORM_WIN32_NT
962 && enc_codepage >= 0 && (int)GetACP() != enc_codepage)
963 {
Bram Moolenaarcc448b32010-07-14 16:52:17 +0200964 findrep_wtoa(&s_findrep_struct, &s_findrep_struct_w);
Bram Moolenaar3ca9a8a2009-01-28 20:23:17 +0000965 }
966# endif
967
Bram Moolenaar071d4272004-06-13 20:20:40 +0000968 if (s_findrep_struct.Flags & FR_DIALOGTERM)
969 /* Give main window the focus back. */
970 (void)SetFocus(s_hwnd);
971
972 if (s_findrep_struct.Flags & FR_FINDNEXT)
973 {
974 flags = FRD_FINDNEXT;
975
976 /* Give main window the focus back: this is so the cursor isn't
977 * hollow. */
978 (void)SetFocus(s_hwnd);
979 }
980 else if (s_findrep_struct.Flags & FR_REPLACE)
981 {
982 flags = FRD_REPLACE;
983
984 /* Give main window the focus back: this is so the cursor isn't
985 * hollow. */
986 (void)SetFocus(s_hwnd);
987 }
988 else if (s_findrep_struct.Flags & FR_REPLACEALL)
989 {
990 flags = FRD_REPLACEALL;
991 }
992
993 if (flags != 0)
994 {
995 /* Call the generic GUI function to do the actual work. */
996 if (s_findrep_struct.Flags & FR_WHOLEWORD)
997 flags |= FRD_WHOLE_WORD;
998 if (s_findrep_struct.Flags & FR_MATCHCASE)
999 flags |= FRD_MATCH_CASE;
1000 down = (s_findrep_struct.Flags & FR_DOWN) != 0;
1001 gui_do_findrepl(flags, s_findrep_struct.lpstrFindWhat,
1002 s_findrep_struct.lpstrReplaceWith, down);
1003 }
1004}
1005#endif
1006
1007 static void
1008HandleMouseHide(UINT uMsg, LPARAM lParam)
1009{
1010 static LPARAM last_lParam = 0L;
1011
1012 /* We sometimes get a mousemove when the mouse didn't move... */
Bram Moolenaar268b55b2013-09-22 15:43:37 +02001013 if (uMsg == WM_MOUSEMOVE || uMsg == WM_NCMOUSEMOVE)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001014 {
1015 if (lParam == last_lParam)
1016 return;
1017 last_lParam = lParam;
1018 }
1019
1020 /* Handle specially, to centralise coding. We need to be sure we catch all
1021 * possible events which should cause us to restore the cursor (as it is a
1022 * shared resource, we take full responsibility for it).
1023 */
1024 switch (uMsg)
1025 {
1026 case WM_KEYUP:
1027 case WM_CHAR:
1028 /*
1029 * blank out the pointer if necessary
1030 */
1031 if (p_mh)
1032 gui_mch_mousehide(TRUE);
1033 break;
1034
1035 case WM_SYSKEYUP: /* show the pointer when a system-key is pressed */
1036 case WM_SYSCHAR:
1037 case WM_MOUSEMOVE: /* show the pointer on any mouse action */
1038 case WM_LBUTTONDOWN:
1039 case WM_LBUTTONUP:
1040 case WM_MBUTTONDOWN:
1041 case WM_MBUTTONUP:
1042 case WM_RBUTTONDOWN:
1043 case WM_RBUTTONUP:
1044 case WM_XBUTTONDOWN:
1045 case WM_XBUTTONUP:
1046 case WM_NCMOUSEMOVE:
1047 case WM_NCLBUTTONDOWN:
1048 case WM_NCLBUTTONUP:
1049 case WM_NCMBUTTONDOWN:
1050 case WM_NCMBUTTONUP:
1051 case WM_NCRBUTTONDOWN:
1052 case WM_NCRBUTTONUP:
1053 case WM_KILLFOCUS:
1054 /*
1055 * if the pointer is currently hidden, then we should show it.
1056 */
1057 gui_mch_mousehide(FALSE);
1058 break;
1059 }
1060}
1061
1062 static LRESULT CALLBACK
1063_TextAreaWndProc(
1064 HWND hwnd,
1065 UINT uMsg,
1066 WPARAM wParam,
1067 LPARAM lParam)
1068{
1069 /*
1070 TRACE("TextAreaWndProc: hwnd = %08x, msg = %x, wParam = %x, lParam = %x\n",
1071 hwnd, uMsg, wParam, lParam);
1072 */
1073
1074 HandleMouseHide(uMsg, lParam);
1075
1076 s_uMsg = uMsg;
1077 s_wParam = wParam;
1078 s_lParam = lParam;
1079
1080#ifdef FEAT_BEVAL
1081 TrackUserActivity(uMsg);
1082#endif
1083
1084 switch (uMsg)
1085 {
1086 HANDLE_MSG(hwnd, WM_LBUTTONDBLCLK,_OnMouseButtonDown);
1087 HANDLE_MSG(hwnd, WM_LBUTTONDOWN,_OnMouseButtonDown);
1088 HANDLE_MSG(hwnd, WM_LBUTTONUP, _OnMouseMoveOrRelease);
1089 HANDLE_MSG(hwnd, WM_MBUTTONDBLCLK,_OnMouseButtonDown);
1090 HANDLE_MSG(hwnd, WM_MBUTTONDOWN,_OnMouseButtonDown);
1091 HANDLE_MSG(hwnd, WM_MBUTTONUP, _OnMouseMoveOrRelease);
1092 HANDLE_MSG(hwnd, WM_MOUSEMOVE, _OnMouseMoveOrRelease);
1093 HANDLE_MSG(hwnd, WM_PAINT, _OnPaint);
1094 HANDLE_MSG(hwnd, WM_RBUTTONDBLCLK,_OnMouseButtonDown);
1095 HANDLE_MSG(hwnd, WM_RBUTTONDOWN,_OnMouseButtonDown);
1096 HANDLE_MSG(hwnd, WM_RBUTTONUP, _OnMouseMoveOrRelease);
1097#ifndef WIN16 /*<VN>*/
1098 HANDLE_MSG(hwnd, WM_XBUTTONDBLCLK,_OnMouseButtonDown);
1099 HANDLE_MSG(hwnd, WM_XBUTTONDOWN,_OnMouseButtonDown);
1100 HANDLE_MSG(hwnd, WM_XBUTTONUP, _OnMouseMoveOrRelease);
1101#endif
1102
1103#ifdef FEAT_BEVAL
1104 case WM_NOTIFY: Handle_WM_Notify(hwnd, (LPNMHDR)lParam);
1105 return TRUE;
1106#endif
Bram Moolenaar4d526ad2010-02-03 12:23:24 +01001107 default:
1108 return MyWindowProc(hwnd, uMsg, wParam, lParam);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001109 }
1110}
1111
1112#if (defined(WIN3264) && defined(FEAT_MBYTE)) \
1113 || defined(GLOBAL_IME) \
1114 || defined(PROTO)
1115# ifdef PROTO
1116typedef int WINAPI;
1117# endif
1118
1119 LRESULT WINAPI
1120vim_WindowProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
1121{
1122# ifdef GLOBAL_IME
1123 return global_ime_DefWindowProc(hwnd, message, wParam, lParam);
1124# else
1125 if (wide_WindowProc)
1126 return DefWindowProcW(hwnd, message, wParam, lParam);
1127 return DefWindowProc(hwnd, message, wParam, lParam);
1128#endif
1129}
1130#endif
1131
1132/*
1133 * Called when the foreground or background color has been changed.
1134 */
1135 void
1136gui_mch_new_colors(void)
1137{
1138 /* nothing to do? */
1139}
1140
1141/*
1142 * Set the colors to their default values.
1143 */
1144 void
1145gui_mch_def_colors()
1146{
1147 gui.norm_pixel = GetSysColor(COLOR_WINDOWTEXT);
1148 gui.back_pixel = GetSysColor(COLOR_WINDOW);
1149 gui.def_norm_pixel = gui.norm_pixel;
1150 gui.def_back_pixel = gui.back_pixel;
1151}
1152
1153/*
1154 * Open the GUI window which was created by a call to gui_mch_init().
1155 */
1156 int
1157gui_mch_open(void)
1158{
1159#ifndef SW_SHOWDEFAULT
1160# define SW_SHOWDEFAULT 10 /* Borland 5.0 doesn't have it */
1161#endif
1162 /* Actually open the window, if not already visible
1163 * (may be done already in gui_mch_set_shellsize) */
1164 if (!IsWindowVisible(s_hwnd))
1165 ShowWindow(s_hwnd, SW_SHOWDEFAULT);
1166
Bram Moolenaare2f98b92006-03-29 21:18:24 +00001167#ifdef MSWIN_FIND_REPLACE
1168 /* Init replace string here, so that we keep it when re-opening the
1169 * dialog. */
1170 s_findrep_struct.lpstrReplaceWith[0] = NUL;
1171#endif
1172
Bram Moolenaar071d4272004-06-13 20:20:40 +00001173 return OK;
1174}
1175
1176/*
1177 * Get the position of the top left corner of the window.
1178 */
1179 int
1180gui_mch_get_winpos(int *x, int *y)
1181{
1182 RECT rect;
1183
1184 GetWindowRect(s_hwnd, &rect);
1185 *x = rect.left;
1186 *y = rect.top;
1187 return OK;
1188}
1189
1190/*
1191 * Set the position of the top left corner of the window to the given
1192 * coordinates.
1193 */
1194 void
1195gui_mch_set_winpos(int x, int y)
1196{
1197 SetWindowPos(s_hwnd, NULL, x, y, 0, 0,
1198 SWP_NOZORDER | SWP_NOSIZE | SWP_NOACTIVATE);
1199}
1200 void
1201gui_mch_set_text_area_pos(int x, int y, int w, int h)
1202{
1203 static int oldx = 0;
1204 static int oldy = 0;
1205
1206 SetWindowPos(s_textArea, NULL, x, y, w, h, SWP_NOZORDER | SWP_NOACTIVATE);
1207
1208#ifdef FEAT_TOOLBAR
1209 if (vim_strchr(p_go, GO_TOOLBAR) != NULL)
1210 SendMessage(s_toolbarhwnd, WM_SIZE,
Bram Moolenaar5555acc2006-04-07 21:33:12 +00001211 (WPARAM)0, (LPARAM)(w + ((long)(TOOLBAR_BUTTON_HEIGHT+8)<<16)));
Bram Moolenaar071d4272004-06-13 20:20:40 +00001212#endif
Bram Moolenaar3991dab2006-03-27 17:01:56 +00001213#if defined(FEAT_GUI_TABLINE)
1214 if (showing_tabline)
1215 {
Bram Moolenaar2e2a2812006-03-27 20:55:21 +00001216 int top = 0;
Bram Moolenaarc6fe9192006-04-09 21:54:49 +00001217 RECT rect;
Bram Moolenaar3991dab2006-03-27 17:01:56 +00001218
Bram Moolenaar551dbcc2006-04-25 22:13:59 +00001219# ifdef FEAT_TOOLBAR
Bram Moolenaar3991dab2006-03-27 17:01:56 +00001220 if (vim_strchr(p_go, GO_TOOLBAR) != NULL)
1221 top = TOOLBAR_BUTTON_HEIGHT + TOOLBAR_BORDER_HEIGHT;
Bram Moolenaar551dbcc2006-04-25 22:13:59 +00001222# endif
Bram Moolenaar5555acc2006-04-07 21:33:12 +00001223 GetClientRect(s_hwnd, &rect);
Bram Moolenaar551dbcc2006-04-25 22:13:59 +00001224 MoveWindow(s_tabhwnd, 0, top, rect.right, gui.tabline_height, TRUE);
Bram Moolenaar3991dab2006-03-27 17:01:56 +00001225 }
1226#endif
1227
Bram Moolenaar071d4272004-06-13 20:20:40 +00001228 /* When side scroll bar is unshown, the size of window will change.
1229 * then, the text area move left or right. thus client rect should be
Bram Moolenaar84a05ac2013-05-06 04:24:17 +02001230 * forcedly redrawn. (Yasuhiro Matsumoto) */
Bram Moolenaar071d4272004-06-13 20:20:40 +00001231 if (oldx != x || oldy != y)
1232 {
1233 InvalidateRect(s_hwnd, NULL, FALSE);
1234 oldx = x;
1235 oldy = y;
1236 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00001237}
1238
1239
1240/*
1241 * Scrollbar stuff:
1242 */
1243
1244 void
1245gui_mch_enable_scrollbar(
1246 scrollbar_T *sb,
1247 int flag)
1248{
1249 ShowScrollBar(sb->id, SB_CTL, flag);
1250
1251 /* TODO: When the window is maximized, the size of the window stays the
1252 * same, thus the size of the text area changes. On Win98 it's OK, on Win
1253 * NT 4.0 it's not... */
1254}
1255
1256 void
1257gui_mch_set_scrollbar_pos(
1258 scrollbar_T *sb,
1259 int x,
1260 int y,
1261 int w,
1262 int h)
1263{
Bram Moolenaar02743632005-07-25 20:42:36 +00001264 SetWindowPos(sb->id, NULL, x, y, w, h,
1265 SWP_NOZORDER | SWP_NOACTIVATE | SWP_SHOWWINDOW);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001266}
1267
1268 void
1269gui_mch_create_scrollbar(
1270 scrollbar_T *sb,
1271 int orient) /* SBAR_VERT or SBAR_HORIZ */
1272{
1273 sb->id = CreateWindow(
1274 "SCROLLBAR", "Scrollbar",
1275 WS_CHILD | ((orient == SBAR_VERT) ? SBS_VERT : SBS_HORZ), 0, 0,
1276 10, /* Any value will do for now */
1277 10, /* Any value will do for now */
1278 s_hwnd, NULL,
1279 s_hinst, NULL);
1280}
1281
1282/*
1283 * Find the scrollbar with the given hwnd.
1284 */
1285 static scrollbar_T *
1286gui_mswin_find_scrollbar(HWND hwnd)
1287{
1288 win_T *wp;
1289
1290 if (gui.bottom_sbar.id == hwnd)
1291 return &gui.bottom_sbar;
1292 FOR_ALL_WINDOWS(wp)
1293 {
1294 if (wp->w_scrollbars[SBAR_LEFT].id == hwnd)
1295 return &wp->w_scrollbars[SBAR_LEFT];
1296 if (wp->w_scrollbars[SBAR_RIGHT].id == hwnd)
1297 return &wp->w_scrollbars[SBAR_RIGHT];
1298 }
1299 return NULL;
1300}
1301
1302/*
1303 * Get the character size of a font.
1304 */
1305 static void
1306GetFontSize(GuiFont font)
1307{
1308 HWND hwnd = GetDesktopWindow();
1309 HDC hdc = GetWindowDC(hwnd);
1310 HFONT hfntOld = SelectFont(hdc, (HFONT)font);
1311 TEXTMETRIC tm;
1312
1313 GetTextMetrics(hdc, &tm);
1314 gui.char_width = tm.tmAveCharWidth + tm.tmOverhang;
1315
1316 gui.char_height = tm.tmHeight
1317#ifndef MSWIN16_FASTTEXT
Bram Moolenaar02743632005-07-25 20:42:36 +00001318 + p_linespace
Bram Moolenaar071d4272004-06-13 20:20:40 +00001319#endif
Bram Moolenaar02743632005-07-25 20:42:36 +00001320 ;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001321
1322 SelectFont(hdc, hfntOld);
1323
1324 ReleaseDC(hwnd, hdc);
1325}
1326
Bram Moolenaar02743632005-07-25 20:42:36 +00001327/*
1328 * Adjust gui.char_height (after 'linespace' was changed).
1329 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00001330 int
Bram Moolenaar02743632005-07-25 20:42:36 +00001331gui_mch_adjust_charheight(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001332{
1333 GetFontSize(gui.norm_font);
1334 return OK;
1335}
1336
1337 static GuiFont
1338get_font_handle(LOGFONT *lf)
1339{
1340 HFONT font = NULL;
1341
1342 /* Load the font */
1343 font = CreateFontIndirect(lf);
1344
1345 if (font == NULL)
1346 return NOFONT;
1347
1348 return (GuiFont)font;
1349}
1350
1351 static int
1352pixels_to_points(int pixels, int vertical)
1353{
1354 int points;
1355 HWND hwnd;
1356 HDC hdc;
1357
1358 hwnd = GetDesktopWindow();
1359 hdc = GetWindowDC(hwnd);
1360
1361 points = MulDiv(pixels, 72,
1362 GetDeviceCaps(hdc, vertical ? LOGPIXELSY : LOGPIXELSX));
1363
1364 ReleaseDC(hwnd, hdc);
1365
1366 return points;
1367}
1368
1369 GuiFont
1370gui_mch_get_font(
1371 char_u *name,
1372 int giveErrorIfMissing)
1373{
1374 LOGFONT lf;
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00001375 GuiFont font = NOFONT;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001376
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00001377 if (get_logfont(&lf, name, NULL, giveErrorIfMissing) == OK)
1378 font = get_font_handle(&lf);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001379 if (font == NOFONT && giveErrorIfMissing)
1380 EMSG2(_(e_font), name);
1381 return font;
1382}
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00001383
Bram Moolenaardfccaf02004-12-31 20:56:11 +00001384#if defined(FEAT_EVAL) || defined(PROTO)
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00001385/*
1386 * Return the name of font "font" in allocated memory.
1387 * Don't know how to get the actual name, thus use the provided name.
1388 */
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00001389/*ARGSUSED*/
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00001390 char_u *
1391gui_mch_get_fontname(font, name)
1392 GuiFont font;
1393 char_u *name;
1394{
1395 if (name == NULL)
1396 return NULL;
1397 return vim_strsave(name);
1398}
Bram Moolenaardfccaf02004-12-31 20:56:11 +00001399#endif
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00001400
Bram Moolenaar071d4272004-06-13 20:20:40 +00001401 void
1402gui_mch_free_font(GuiFont font)
1403{
1404 if (font)
1405 DeleteObject((HFONT)font);
1406}
1407
1408 static int
1409hex_digit(int c)
1410{
1411 if (VIM_ISDIGIT(c))
1412 return c - '0';
1413 c = TOLOWER_ASC(c);
1414 if (c >= 'a' && c <= 'f')
1415 return c - 'a' + 10;
1416 return -1000;
1417}
1418/*
1419 * Return the Pixel value (color) for the given color name.
1420 * Return INVALCOLOR for error.
1421 */
1422 guicolor_T
1423gui_mch_get_color(char_u *name)
1424{
1425 typedef struct guicolor_tTable
1426 {
1427 char *name;
1428 COLORREF color;
1429 } guicolor_tTable;
1430
1431 static guicolor_tTable table[] =
1432 {
1433 {"Black", RGB(0x00, 0x00, 0x00)},
Bram Moolenaar092e3c82011-09-07 18:58:29 +02001434 {"DarkGray", RGB(0xA9, 0xA9, 0xA9)},
1435 {"DarkGrey", RGB(0xA9, 0xA9, 0xA9)},
Bram Moolenaar071d4272004-06-13 20:20:40 +00001436 {"Gray", RGB(0xC0, 0xC0, 0xC0)},
1437 {"Grey", RGB(0xC0, 0xC0, 0xC0)},
Bram Moolenaar092e3c82011-09-07 18:58:29 +02001438 {"LightGray", RGB(0xD3, 0xD3, 0xD3)},
1439 {"LightGrey", RGB(0xD3, 0xD3, 0xD3)},
Bram Moolenaarb21e5842006-04-16 18:30:08 +00001440 {"Gray10", RGB(0x1A, 0x1A, 0x1A)},
1441 {"Grey10", RGB(0x1A, 0x1A, 0x1A)},
1442 {"Gray20", RGB(0x33, 0x33, 0x33)},
1443 {"Grey20", RGB(0x33, 0x33, 0x33)},
1444 {"Gray30", RGB(0x4D, 0x4D, 0x4D)},
1445 {"Grey30", RGB(0x4D, 0x4D, 0x4D)},
1446 {"Gray40", RGB(0x66, 0x66, 0x66)},
1447 {"Grey40", RGB(0x66, 0x66, 0x66)},
1448 {"Gray50", RGB(0x7F, 0x7F, 0x7F)},
1449 {"Grey50", RGB(0x7F, 0x7F, 0x7F)},
1450 {"Gray60", RGB(0x99, 0x99, 0x99)},
1451 {"Grey60", RGB(0x99, 0x99, 0x99)},
1452 {"Gray70", RGB(0xB3, 0xB3, 0xB3)},
1453 {"Grey70", RGB(0xB3, 0xB3, 0xB3)},
1454 {"Gray80", RGB(0xCC, 0xCC, 0xCC)},
1455 {"Grey80", RGB(0xCC, 0xCC, 0xCC)},
Bram Moolenaare2f98b92006-03-29 21:18:24 +00001456 {"Gray90", RGB(0xE5, 0xE5, 0xE5)},
1457 {"Grey90", RGB(0xE5, 0xE5, 0xE5)},
Bram Moolenaar071d4272004-06-13 20:20:40 +00001458 {"White", RGB(0xFF, 0xFF, 0xFF)},
1459 {"DarkRed", RGB(0x80, 0x00, 0x00)},
1460 {"Red", RGB(0xFF, 0x00, 0x00)},
1461 {"LightRed", RGB(0xFF, 0xA0, 0xA0)},
1462 {"DarkBlue", RGB(0x00, 0x00, 0x80)},
1463 {"Blue", RGB(0x00, 0x00, 0xFF)},
Bram Moolenaar092e3c82011-09-07 18:58:29 +02001464 {"LightBlue", RGB(0xAD, 0xD8, 0xE6)},
Bram Moolenaar071d4272004-06-13 20:20:40 +00001465 {"DarkGreen", RGB(0x00, 0x80, 0x00)},
1466 {"Green", RGB(0x00, 0xFF, 0x00)},
Bram Moolenaar092e3c82011-09-07 18:58:29 +02001467 {"LightGreen", RGB(0x90, 0xEE, 0x90)},
Bram Moolenaar071d4272004-06-13 20:20:40 +00001468 {"DarkCyan", RGB(0x00, 0x80, 0x80)},
1469 {"Cyan", RGB(0x00, 0xFF, 0xFF)},
Bram Moolenaar092e3c82011-09-07 18:58:29 +02001470 {"LightCyan", RGB(0xE0, 0xFF, 0xFF)},
Bram Moolenaar071d4272004-06-13 20:20:40 +00001471 {"DarkMagenta", RGB(0x80, 0x00, 0x80)},
1472 {"Magenta", RGB(0xFF, 0x00, 0xFF)},
1473 {"LightMagenta", RGB(0xFF, 0xA0, 0xFF)},
1474 {"Brown", RGB(0x80, 0x40, 0x40)},
1475 {"Yellow", RGB(0xFF, 0xFF, 0x00)},
Bram Moolenaar092e3c82011-09-07 18:58:29 +02001476 {"LightYellow", RGB(0xFF, 0xFF, 0xE0)},
Bram Moolenaar071d4272004-06-13 20:20:40 +00001477 {"DarkYellow", RGB(0xBB, 0xBB, 0x00)},
1478 {"SeaGreen", RGB(0x2E, 0x8B, 0x57)},
1479 {"Orange", RGB(0xFF, 0xA5, 0x00)},
1480 {"Purple", RGB(0xA0, 0x20, 0xF0)},
1481 {"SlateBlue", RGB(0x6A, 0x5A, 0xCD)},
1482 {"Violet", RGB(0xEE, 0x82, 0xEE)},
1483 };
1484
1485 typedef struct SysColorTable
1486 {
1487 char *name;
1488 int color;
1489 } SysColorTable;
1490
1491 static SysColorTable sys_table[] =
1492 {
1493#ifdef WIN3264
1494 {"SYS_3DDKSHADOW", COLOR_3DDKSHADOW},
1495 {"SYS_3DHILIGHT", COLOR_3DHILIGHT},
1496#ifndef __MINGW32__
1497 {"SYS_3DHIGHLIGHT", COLOR_3DHIGHLIGHT},
1498#endif
1499 {"SYS_BTNHILIGHT", COLOR_BTNHILIGHT},
1500 {"SYS_BTNHIGHLIGHT", COLOR_BTNHIGHLIGHT},
1501 {"SYS_3DLIGHT", COLOR_3DLIGHT},
1502 {"SYS_3DSHADOW", COLOR_3DSHADOW},
1503 {"SYS_DESKTOP", COLOR_DESKTOP},
1504 {"SYS_INFOBK", COLOR_INFOBK},
1505 {"SYS_INFOTEXT", COLOR_INFOTEXT},
1506 {"SYS_3DFACE", COLOR_3DFACE},
1507#endif
1508 {"SYS_BTNFACE", COLOR_BTNFACE},
1509 {"SYS_BTNSHADOW", COLOR_BTNSHADOW},
1510 {"SYS_ACTIVEBORDER", COLOR_ACTIVEBORDER},
1511 {"SYS_ACTIVECAPTION", COLOR_ACTIVECAPTION},
1512 {"SYS_APPWORKSPACE", COLOR_APPWORKSPACE},
1513 {"SYS_BACKGROUND", COLOR_BACKGROUND},
1514 {"SYS_BTNTEXT", COLOR_BTNTEXT},
1515 {"SYS_CAPTIONTEXT", COLOR_CAPTIONTEXT},
1516 {"SYS_GRAYTEXT", COLOR_GRAYTEXT},
1517 {"SYS_HIGHLIGHT", COLOR_HIGHLIGHT},
1518 {"SYS_HIGHLIGHTTEXT", COLOR_HIGHLIGHTTEXT},
1519 {"SYS_INACTIVEBORDER", COLOR_INACTIVEBORDER},
1520 {"SYS_INACTIVECAPTION", COLOR_INACTIVECAPTION},
1521 {"SYS_INACTIVECAPTIONTEXT", COLOR_INACTIVECAPTIONTEXT},
1522 {"SYS_MENU", COLOR_MENU},
1523 {"SYS_MENUTEXT", COLOR_MENUTEXT},
1524 {"SYS_SCROLLBAR", COLOR_SCROLLBAR},
1525 {"SYS_WINDOW", COLOR_WINDOW},
1526 {"SYS_WINDOWFRAME", COLOR_WINDOWFRAME},
1527 {"SYS_WINDOWTEXT", COLOR_WINDOWTEXT}
1528 };
1529
1530 int r, g, b;
1531 int i;
1532
1533 if (name[0] == '#' && strlen(name) == 7)
1534 {
1535 /* Name is in "#rrggbb" format */
1536 r = hex_digit(name[1]) * 16 + hex_digit(name[2]);
1537 g = hex_digit(name[3]) * 16 + hex_digit(name[4]);
1538 b = hex_digit(name[5]) * 16 + hex_digit(name[6]);
1539 if (r < 0 || g < 0 || b < 0)
1540 return INVALCOLOR;
1541 return RGB(r, g, b);
1542 }
1543 else
1544 {
1545 /* Check if the name is one of the colors we know */
1546 for (i = 0; i < sizeof(table) / sizeof(table[0]); i++)
1547 if (STRICMP(name, table[i].name) == 0)
1548 return table[i].color;
1549 }
1550
1551 /*
1552 * Try to look up a system colour.
1553 */
1554 for (i = 0; i < sizeof(sys_table) / sizeof(sys_table[0]); i++)
1555 if (STRICMP(name, sys_table[i].name) == 0)
1556 return GetSysColor(sys_table[i].color);
1557
1558 /*
1559 * Last attempt. Look in the file "$VIMRUNTIME/rgb.txt".
1560 */
1561 {
1562#define LINE_LEN 100
1563 FILE *fd;
1564 char line[LINE_LEN];
1565 char_u *fname;
1566
1567 fname = expand_env_save((char_u *)"$VIMRUNTIME/rgb.txt");
1568 if (fname == NULL)
1569 return INVALCOLOR;
1570
Bram Moolenaar5555acc2006-04-07 21:33:12 +00001571 fd = mch_fopen((char *)fname, "rt");
Bram Moolenaar071d4272004-06-13 20:20:40 +00001572 vim_free(fname);
1573 if (fd == NULL)
1574 return INVALCOLOR;
1575
1576 while (!feof(fd))
1577 {
1578 int len;
1579 int pos;
1580 char *color;
1581
1582 fgets(line, LINE_LEN, fd);
1583 len = (int)STRLEN(line);
1584
1585 if (len <= 1 || line[len-1] != '\n')
1586 continue;
1587
1588 line[len-1] = '\0';
1589
1590 i = sscanf(line, "%d %d %d %n", &r, &g, &b, &pos);
1591 if (i != 3)
1592 continue;
1593
1594 color = line + pos;
1595
1596 if (STRICMP(color, name) == 0)
1597 {
1598 fclose(fd);
1599 return (guicolor_T) RGB(r, g, b);
1600 }
1601 }
1602
1603 fclose(fd);
1604 }
1605
1606 return INVALCOLOR;
1607}
1608/*
1609 * Return OK if the key with the termcap name "name" is supported.
1610 */
1611 int
1612gui_mch_haskey(char_u *name)
1613{
1614 int i;
1615
1616 for (i = 0; special_keys[i].vim_code1 != NUL; i++)
1617 if (name[0] == special_keys[i].vim_code0 &&
1618 name[1] == special_keys[i].vim_code1)
1619 return OK;
1620 return FAIL;
1621}
1622
1623 void
1624gui_mch_beep(void)
1625{
1626 MessageBeep(MB_OK);
1627}
1628/*
1629 * Invert a rectangle from row r, column c, for nr rows and nc columns.
1630 */
1631 void
1632gui_mch_invert_rectangle(
1633 int r,
1634 int c,
1635 int nr,
1636 int nc)
1637{
1638 RECT rc;
1639
1640 /*
1641 * Note: InvertRect() excludes right and bottom of rectangle.
1642 */
1643 rc.left = FILL_X(c);
1644 rc.top = FILL_Y(r);
1645 rc.right = rc.left + nc * gui.char_width;
1646 rc.bottom = rc.top + nr * gui.char_height;
1647 InvertRect(s_hdc, &rc);
1648}
1649
1650/*
1651 * Iconify the GUI window.
1652 */
1653 void
1654gui_mch_iconify(void)
1655{
1656 ShowWindow(s_hwnd, SW_MINIMIZE);
1657}
1658
1659/*
1660 * Draw a cursor without focus.
1661 */
1662 void
1663gui_mch_draw_hollow_cursor(guicolor_T color)
1664{
1665 HBRUSH hbr;
1666 RECT rc;
1667
1668 /*
1669 * Note: FrameRect() excludes right and bottom of rectangle.
1670 */
1671 rc.left = FILL_X(gui.col);
1672 rc.top = FILL_Y(gui.row);
1673 rc.right = rc.left + gui.char_width;
1674#ifdef FEAT_MBYTE
1675 if (mb_lefthalve(gui.row, gui.col))
1676 rc.right += gui.char_width;
1677#endif
1678 rc.bottom = rc.top + gui.char_height;
1679 hbr = CreateSolidBrush(color);
1680 FrameRect(s_hdc, &rc, hbr);
1681 DeleteBrush(hbr);
1682}
1683/*
1684 * Draw part of a cursor, "w" pixels wide, and "h" pixels high, using
1685 * color "color".
1686 */
1687 void
1688gui_mch_draw_part_cursor(
1689 int w,
1690 int h,
1691 guicolor_T color)
1692{
1693 HBRUSH hbr;
1694 RECT rc;
1695
1696 /*
1697 * Note: FillRect() excludes right and bottom of rectangle.
1698 */
1699 rc.left =
1700#ifdef FEAT_RIGHTLEFT
1701 /* vertical line should be on the right of current point */
1702 CURSOR_BAR_RIGHT ? FILL_X(gui.col + 1) - w :
1703#endif
1704 FILL_X(gui.col);
1705 rc.top = FILL_Y(gui.row) + gui.char_height - h;
1706 rc.right = rc.left + w;
1707 rc.bottom = rc.top + h;
1708 hbr = CreateSolidBrush(color);
1709 FillRect(s_hdc, &rc, hbr);
1710 DeleteBrush(hbr);
1711}
1712
1713/*
1714 * Process a single Windows message.
1715 * If one is not available we hang until one is.
1716 */
1717 static void
1718process_message(void)
1719{
1720 MSG msg;
1721 UINT vk = 0; /* Virtual key */
1722 char_u string[40];
1723 int i;
1724 int modifiers = 0;
1725 int key;
Bram Moolenaar293ee4d2004-12-09 21:34:53 +00001726#ifdef FEAT_MENU
1727 static char_u k10[] = {K_SPECIAL, 'k', ';', 0};
1728#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00001729
Bram Moolenaar8c85fa32011-08-10 17:08:03 +02001730 pGetMessage(&msg, NULL, 0, 0);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001731
1732#ifdef FEAT_OLE
1733 /* Look after OLE Automation commands */
1734 if (msg.message == WM_OLE)
1735 {
1736 char_u *str = (char_u *)msg.lParam;
Bram Moolenaar370feaf2009-01-28 13:18:26 +00001737 if (str == NULL || *str == NUL)
1738 {
1739 /* Message can't be ours, forward it. Fixes problem with Ultramon
1740 * 3.0.4 */
Bram Moolenaar8c85fa32011-08-10 17:08:03 +02001741 pDispatchMessage(&msg);
Bram Moolenaar370feaf2009-01-28 13:18:26 +00001742 }
1743 else
1744 {
1745 add_to_input_buf(str, (int)STRLEN(str));
1746 vim_free(str); /* was allocated in CVim::SendKeys() */
1747 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00001748 return;
1749 }
1750#endif
1751
1752#ifdef FEAT_NETBEANS_INTG
1753 if (msg.message == WM_NETBEANS)
1754 {
Bram Moolenaar67c53842010-05-22 18:28:27 +02001755 netbeans_read();
Bram Moolenaar071d4272004-06-13 20:20:40 +00001756 return;
1757 }
1758#endif
1759
1760#ifdef FEAT_SNIFF
1761 if (sniff_request_waiting && want_sniff_request)
1762 {
1763 static char_u bytes[3] = {CSI, (char_u)KS_EXTRA, (char_u)KE_SNIFF};
1764 add_to_input_buf(bytes, 3); /* K_SNIFF */
1765 sniff_request_waiting = 0;
1766 want_sniff_request = 0;
1767 /* request is handled in normal.c */
1768 }
1769 if (msg.message == WM_USER)
Bram Moolenaar35c92912006-06-22 17:34:26 +00001770 {
Bram Moolenaard8a92d72006-06-23 14:44:06 +00001771 MyTranslateMessage(&msg);
Bram Moolenaar8c85fa32011-08-10 17:08:03 +02001772 pDispatchMessage(&msg);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001773 return;
Bram Moolenaar35c92912006-06-22 17:34:26 +00001774 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00001775#endif
1776
1777#ifdef MSWIN_FIND_REPLACE
1778 /* Don't process messages used by the dialog */
Bram Moolenaar8c85fa32011-08-10 17:08:03 +02001779 if (s_findrep_hwnd != NULL && pIsDialogMessage(s_findrep_hwnd, &msg))
Bram Moolenaar071d4272004-06-13 20:20:40 +00001780 {
1781 HandleMouseHide(msg.message, msg.lParam);
1782 return;
1783 }
1784#endif
1785
1786 /*
1787 * Check if it's a special key that we recognise. If not, call
1788 * TranslateMessage().
1789 */
1790 if (msg.message == WM_KEYDOWN || msg.message == WM_SYSKEYDOWN)
1791 {
1792 vk = (int) msg.wParam;
Bram Moolenaard2e80872014-08-22 18:44:33 +02001793 /*
1794 * If a dead key was pressed and the user presses VK_SPACE, VK_BACK, or
1795 * VK_ESCAPE it means that he actually wants to deal with the dead char
1796 * now, so do nothing special and let Windows handle it.
1797 *
1798 * Note that VK_SPACE combines with the dead_key's character and only
1799 * one WM_CHAR will be generated by TranslateMessage(), in the two
1800 * other cases two WM_CHAR will be generated: the dead char and VK_BACK
1801 * or VK_ESCAPE. That is most likely what the user expects.
1802 */
1803 if (dead_key && (vk == VK_SPACE || vk == VK_BACK || vk == VK_ESCAPE))
Bram Moolenaar071d4272004-06-13 20:20:40 +00001804 {
1805 dead_key = 0;
Bram Moolenaard2e80872014-08-22 18:44:33 +02001806 MyTranslateMessage(&msg);
1807 return;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001808 }
1809
1810 /* Check for CTRL-BREAK */
1811 if (vk == VK_CANCEL)
1812 {
1813 trash_input_buf();
1814 got_int = TRUE;
1815 string[0] = Ctrl_C;
1816 add_to_input_buf(string, 1);
1817 }
1818
1819 for (i = 0; special_keys[i].key_sym != 0; i++)
1820 {
1821 /* ignore VK_SPACE when ALT key pressed: system menu */
1822 if (special_keys[i].key_sym == vk
1823 && (vk != VK_SPACE || !(GetKeyState(VK_MENU) & 0x8000)))
1824 {
1825#ifdef FEAT_MENU
Bram Moolenaar293ee4d2004-12-09 21:34:53 +00001826 /* Check for <F10>: Windows selects the menu. When <F10> is
1827 * mapped we want to use the mapping instead. */
Bram Moolenaar071d4272004-06-13 20:20:40 +00001828 if (vk == VK_F10
1829 && gui.menu_is_active
Bram Moolenaarbd743252010-10-20 21:23:33 +02001830 && check_map(k10, State, FALSE, TRUE, FALSE,
1831 NULL, NULL) == NULL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001832 break;
1833#endif
1834 if (GetKeyState(VK_SHIFT) & 0x8000)
1835 modifiers |= MOD_MASK_SHIFT;
1836 /*
1837 * Don't use caps-lock as shift, because these are special keys
1838 * being considered here, and we only want letters to get
1839 * shifted -- webb
1840 */
1841 /*
1842 if (GetKeyState(VK_CAPITAL) & 0x0001)
1843 modifiers ^= MOD_MASK_SHIFT;
1844 */
1845 if (GetKeyState(VK_CONTROL) & 0x8000)
1846 modifiers |= MOD_MASK_CTRL;
1847 if (GetKeyState(VK_MENU) & 0x8000)
1848 modifiers |= MOD_MASK_ALT;
1849
1850 if (special_keys[i].vim_code1 == NUL)
1851 key = special_keys[i].vim_code0;
1852 else
1853 key = TO_SPECIAL(special_keys[i].vim_code0,
1854 special_keys[i].vim_code1);
1855 key = simplify_key(key, &modifiers);
1856 if (key == CSI)
1857 key = K_CSI;
1858
1859 if (modifiers)
1860 {
1861 string[0] = CSI;
1862 string[1] = KS_MODIFIER;
1863 string[2] = modifiers;
1864 add_to_input_buf(string, 3);
1865 }
1866
1867 if (IS_SPECIAL(key))
1868 {
1869 string[0] = CSI;
1870 string[1] = K_SECOND(key);
1871 string[2] = K_THIRD(key);
1872 add_to_input_buf(string, 3);
1873 }
1874 else
1875 {
1876 int len;
1877
1878 /* Handle "key" as a Unicode character. */
Bram Moolenaar85a3e5c2007-11-20 16:22:16 +00001879 len = char_to_string(key, string, 40, FALSE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001880 add_to_input_buf(string, len);
1881 }
1882 break;
1883 }
1884 }
1885 if (special_keys[i].key_sym == 0)
1886 {
1887 /* Some keys need C-S- where they should only need C-.
1888 * Ignore 0xff, Windows XP sends it when NUMLOCK has changed since
1889 * system startup (Helmut Stiegler, 2003 Oct 3). */
1890 if (vk != 0xff
1891 && (GetKeyState(VK_CONTROL) & 0x8000)
1892 && !(GetKeyState(VK_SHIFT) & 0x8000)
1893 && !(GetKeyState(VK_MENU) & 0x8000))
1894 {
1895 /* CTRL-6 is '^'; Japanese keyboard maps '^' to vk == 0xDE */
1896 if (vk == '6' || MapVirtualKey(vk, 2) == (UINT)'^')
1897 {
1898 string[0] = Ctrl_HAT;
1899 add_to_input_buf(string, 1);
1900 }
1901 /* vk == 0xBD AZERTY for CTRL-'-', but CTRL-[ for * QWERTY! */
1902 else if (vk == 0xBD) /* QWERTY for CTRL-'-' */
1903 {
1904 string[0] = Ctrl__;
1905 add_to_input_buf(string, 1);
1906 }
1907 /* CTRL-2 is '@'; Japanese keyboard maps '@' to vk == 0xC0 */
1908 else if (vk == '2' || MapVirtualKey(vk, 2) == (UINT)'@')
1909 {
1910 string[0] = Ctrl_AT;
1911 add_to_input_buf(string, 1);
1912 }
1913 else
1914 MyTranslateMessage(&msg);
1915 }
1916 else
1917 MyTranslateMessage(&msg);
1918 }
1919 }
1920#ifdef FEAT_MBYTE_IME
1921 else if (msg.message == WM_IME_NOTIFY)
1922 _OnImeNotify(msg.hwnd, (DWORD)msg.wParam, (DWORD)msg.lParam);
1923 else if (msg.message == WM_KEYUP && im_get_status())
1924 /* added for non-MS IME (Yasuhiro Matsumoto) */
1925 MyTranslateMessage(&msg);
1926#endif
1927#if !defined(FEAT_MBYTE_IME) && defined(GLOBAL_IME)
1928/* GIME_TEST */
1929 else if (msg.message == WM_IME_STARTCOMPOSITION)
1930 {
1931 POINT point;
1932
1933 global_ime_set_font(&norm_logfont);
1934 point.x = FILL_X(gui.col);
1935 point.y = FILL_Y(gui.row);
1936 MapWindowPoints(s_textArea, s_hwnd, &point, 1);
1937 global_ime_set_position(&point);
1938 }
1939#endif
1940
1941#ifdef FEAT_MENU
Bram Moolenaar293ee4d2004-12-09 21:34:53 +00001942 /* Check for <F10>: Default effect is to select the menu. When <F10> is
1943 * mapped we need to stop it here to avoid strange effects (e.g., for the
1944 * key-up event) */
Bram Moolenaarbd743252010-10-20 21:23:33 +02001945 if (vk != VK_F10 || check_map(k10, State, FALSE, TRUE, FALSE,
1946 NULL, NULL) == NULL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001947#endif
Bram Moolenaar8c85fa32011-08-10 17:08:03 +02001948 pDispatchMessage(&msg);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001949}
1950
1951/*
1952 * Catch up with any queued events. This may put keyboard input into the
1953 * input buffer, call resize call-backs, trigger timers etc. If there is
1954 * nothing in the event queue (& no timers pending), then we return
1955 * immediately.
1956 */
1957 void
1958gui_mch_update(void)
1959{
1960 MSG msg;
1961
1962 if (!s_busy_processing)
Bram Moolenaar8c85fa32011-08-10 17:08:03 +02001963 while (pPeekMessage(&msg, NULL, 0, 0, PM_NOREMOVE)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001964 && !vim_is_input_buf_full())
1965 process_message();
1966}
1967
1968/*
1969 * GUI input routine called by gui_wait_for_chars(). Waits for a character
1970 * from the keyboard.
1971 * wtime == -1 Wait forever.
1972 * wtime == 0 This should never happen.
1973 * wtime > 0 Wait wtime milliseconds for a character.
1974 * Returns OK if a character was found to be available within the given time,
1975 * or FAIL otherwise.
1976 */
1977 int
1978gui_mch_wait_for_chars(int wtime)
1979{
1980 MSG msg;
1981 int focus;
1982
1983 s_timed_out = FALSE;
1984
1985 if (wtime > 0)
1986 {
1987 /* Don't do anything while processing a (scroll) message. */
1988 if (s_busy_processing)
1989 return FAIL;
1990 s_wait_timer = (UINT)SetTimer(NULL, 0, (UINT)wtime,
1991 (TIMERPROC)_OnTimer);
1992 }
1993
1994 allow_scrollbar = TRUE;
1995
1996 focus = gui.in_focus;
1997 while (!s_timed_out)
1998 {
1999 /* Stop or start blinking when focus changes */
2000 if (gui.in_focus != focus)
2001 {
2002 if (gui.in_focus)
2003 gui_mch_start_blink();
2004 else
2005 gui_mch_stop_blink();
2006 focus = gui.in_focus;
2007 }
2008
2009 if (s_need_activate)
2010 {
2011#ifdef WIN32
2012 (void)SetForegroundWindow(s_hwnd);
2013#else
2014 (void)SetActiveWindow(s_hwnd);
2015#endif
2016 s_need_activate = FALSE;
2017 }
2018
Bram Moolenaar93c88e02015-09-15 14:12:05 +02002019#ifdef MESSAGE_QUEUE
2020 parse_queued_messages();
Bram Moolenaar61665aa2008-12-24 11:20:53 +00002021#endif
2022
Bram Moolenaar071d4272004-06-13 20:20:40 +00002023 /*
2024 * Don't use gui_mch_update() because then we will spin-lock until a
2025 * char arrives, instead we use GetMessage() to hang until an
2026 * event arrives. No need to check for input_buf_full because we are
2027 * returning as soon as it contains a single char -- webb
2028 */
2029 process_message();
2030
2031 if (input_available())
2032 {
2033 if (s_wait_timer != 0 && !s_timed_out)
2034 {
2035 KillTimer(NULL, s_wait_timer);
2036
2037 /* Eat spurious WM_TIMER messages */
Bram Moolenaar8c85fa32011-08-10 17:08:03 +02002038 while (pPeekMessage(&msg, s_hwnd, WM_TIMER, WM_TIMER, PM_REMOVE))
Bram Moolenaar071d4272004-06-13 20:20:40 +00002039 ;
2040 s_wait_timer = 0;
2041 }
2042 allow_scrollbar = FALSE;
Bram Moolenaar293ee4d2004-12-09 21:34:53 +00002043
2044 /* Clear pending mouse button, the release event may have been
Bram Moolenaarea408882007-12-03 21:21:03 +00002045 * taken by the dialog window. But don't do this when getting
2046 * focus, we need the mouse-up event then. */
2047 if (!s_getting_focus)
2048 s_button_pending = -1;
Bram Moolenaar293ee4d2004-12-09 21:34:53 +00002049
Bram Moolenaar071d4272004-06-13 20:20:40 +00002050 return OK;
2051 }
2052 }
2053 allow_scrollbar = FALSE;
2054 return FAIL;
2055}
2056
2057/*
2058 * Clear a rectangular region of the screen from text pos (row1, col1) to
2059 * (row2, col2) inclusive.
2060 */
2061 void
2062gui_mch_clear_block(
2063 int row1,
2064 int col1,
2065 int row2,
2066 int col2)
2067{
2068 RECT rc;
2069
2070 /*
2071 * Clear one extra pixel at the far right, for when bold characters have
2072 * spilled over to the window border.
2073 * Note: FillRect() excludes right and bottom of rectangle.
2074 */
2075 rc.left = FILL_X(col1);
2076 rc.top = FILL_Y(row1);
2077 rc.right = FILL_X(col2 + 1) + (col2 == Columns - 1);
2078 rc.bottom = FILL_Y(row2 + 1);
2079 clear_rect(&rc);
2080}
2081
2082/*
2083 * Clear the whole text window.
2084 */
2085 void
2086gui_mch_clear_all(void)
2087{
2088 RECT rc;
2089
2090 rc.left = 0;
2091 rc.top = 0;
2092 rc.right = Columns * gui.char_width + 2 * gui.border_width;
2093 rc.bottom = Rows * gui.char_height + 2 * gui.border_width;
2094 clear_rect(&rc);
2095}
2096/*
2097 * Menu stuff.
2098 */
2099
2100 void
2101gui_mch_enable_menu(int flag)
2102{
2103#ifdef FEAT_MENU
2104 SetMenu(s_hwnd, flag ? s_menuBar : NULL);
2105#endif
2106}
2107
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00002108/*ARGSUSED*/
Bram Moolenaar071d4272004-06-13 20:20:40 +00002109 void
2110gui_mch_set_menu_pos(
2111 int x,
2112 int y,
2113 int w,
2114 int h)
2115{
2116 /* It will be in the right place anyway */
2117}
2118
2119#if defined(FEAT_MENU) || defined(PROTO)
2120/*
2121 * Make menu item hidden or not hidden
2122 */
2123 void
2124gui_mch_menu_hidden(
2125 vimmenu_T *menu,
2126 int hidden)
2127{
2128 /*
2129 * This doesn't do what we want. Hmm, just grey the menu items for now.
2130 */
2131 /*
2132 if (hidden)
2133 EnableMenuItem(s_menuBar, menu->id, MF_BYCOMMAND | MF_DISABLED);
2134 else
2135 EnableMenuItem(s_menuBar, menu->id, MF_BYCOMMAND | MF_ENABLED);
2136 */
2137 gui_mch_menu_grey(menu, hidden);
2138}
2139
2140/*
2141 * This is called after setting all the menus to grey/hidden or not.
2142 */
2143 void
2144gui_mch_draw_menubar(void)
2145{
2146 DrawMenuBar(s_hwnd);
2147}
2148#endif /*FEAT_MENU*/
2149
2150#ifndef PROTO
2151void
2152#ifdef VIMDLL
2153_export
2154#endif
2155_cdecl
2156SaveInst(HINSTANCE hInst)
2157{
2158 s_hinst = hInst;
2159}
2160#endif
2161
2162/*
2163 * Return the RGB value of a pixel as a long.
2164 */
2165 long_u
2166gui_mch_get_rgb(guicolor_T pixel)
2167{
2168 return (GetRValue(pixel) << 16) + (GetGValue(pixel) << 8)
2169 + GetBValue(pixel);
2170}
2171
2172#if defined(FEAT_GUI_DIALOG) || defined(PROTO)
2173/* Convert pixels in X to dialog units */
2174 static WORD
2175PixelToDialogX(int numPixels)
2176{
2177 return (WORD)((numPixels * 4) / s_dlgfntwidth);
2178}
2179
2180/* Convert pixels in Y to dialog units */
2181 static WORD
2182PixelToDialogY(int numPixels)
2183{
2184 return (WORD)((numPixels * 8) / s_dlgfntheight);
2185}
2186
2187/* Return the width in pixels of the given text in the given DC. */
2188 static int
2189GetTextWidth(HDC hdc, char_u *str, int len)
2190{
2191 SIZE size;
2192
2193 GetTextExtentPoint(hdc, str, len, &size);
2194 return size.cx;
2195}
2196
2197#ifdef FEAT_MBYTE
2198/*
2199 * Return the width in pixels of the given text in the given DC, taking care
2200 * of 'encoding' to active codepage conversion.
2201 */
2202 static int
2203GetTextWidthEnc(HDC hdc, char_u *str, int len)
2204{
2205 SIZE size;
2206 WCHAR *wstr;
2207 int n;
2208 int wlen = len;
2209
2210 if (enc_codepage >= 0 && (int)GetACP() != enc_codepage)
2211 {
2212 /* 'encoding' differs from active codepage: convert text and use wide
2213 * function */
Bram Moolenaar36f692d2008-11-20 16:10:17 +00002214 wstr = enc_to_utf16(str, &wlen);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002215 if (wstr != NULL)
2216 {
2217 n = GetTextExtentPointW(hdc, wstr, wlen, &size);
2218 vim_free(wstr);
2219 if (n)
2220 return size.cx;
2221 }
2222 }
2223
2224 return GetTextWidth(hdc, str, len);
2225}
2226#else
2227# define GetTextWidthEnc(h, s, l) GetTextWidth((h), (s), (l))
2228#endif
2229
2230/*
2231 * A quick little routine that will center one window over another, handy for
2232 * dialog boxes. Taken from the Win32SDK samples.
2233 */
2234 static BOOL
2235CenterWindow(
2236 HWND hwndChild,
2237 HWND hwndParent)
2238{
2239 RECT rChild, rParent;
2240 int wChild, hChild, wParent, hParent;
2241 int wScreen, hScreen, xNew, yNew;
2242 HDC hdc;
2243
2244 GetWindowRect(hwndChild, &rChild);
2245 wChild = rChild.right - rChild.left;
2246 hChild = rChild.bottom - rChild.top;
2247
2248 /* If Vim is minimized put the window in the middle of the screen. */
Bram Moolenaar9e54a0e2006-04-14 20:42:25 +00002249 if (hwndParent == NULL || IsMinimized(hwndParent))
Bram Moolenaar071d4272004-06-13 20:20:40 +00002250 {
2251#ifdef WIN16
2252 rParent.left = 0;
2253 rParent.top = 0;
2254 rParent.right = GetSystemMetrics(SM_CXSCREEN);
2255 rParent.bottom = GetSystemMetrics(SM_CYFULLSCREEN);
2256#else
2257 SystemParametersInfo(SPI_GETWORKAREA, 0, &rParent, 0);
2258#endif
2259 }
2260 else
2261 GetWindowRect(hwndParent, &rParent);
2262 wParent = rParent.right - rParent.left;
2263 hParent = rParent.bottom - rParent.top;
2264
2265 hdc = GetDC(hwndChild);
2266 wScreen = GetDeviceCaps (hdc, HORZRES);
2267 hScreen = GetDeviceCaps (hdc, VERTRES);
2268 ReleaseDC(hwndChild, hdc);
2269
2270 xNew = rParent.left + ((wParent - wChild) /2);
2271 if (xNew < 0)
2272 {
2273 xNew = 0;
2274 }
2275 else if ((xNew+wChild) > wScreen)
2276 {
2277 xNew = wScreen - wChild;
2278 }
2279
2280 yNew = rParent.top + ((hParent - hChild) /2);
2281 if (yNew < 0)
2282 yNew = 0;
2283 else if ((yNew+hChild) > hScreen)
2284 yNew = hScreen - hChild;
2285
2286 return SetWindowPos(hwndChild, NULL, xNew, yNew, 0, 0,
2287 SWP_NOSIZE | SWP_NOZORDER);
2288}
2289#endif /* FEAT_GUI_DIALOG */
2290
2291void
2292gui_mch_activate_window(void)
2293{
2294 (void)SetActiveWindow(s_hwnd);
2295}
2296
2297#if defined(FEAT_TOOLBAR) || defined(PROTO)
2298 void
2299gui_mch_show_toolbar(int showit)
2300{
2301 if (s_toolbarhwnd == NULL)
2302 return;
2303
2304 if (showit)
Bram Moolenaar8f2ff9f2006-08-29 19:26:50 +00002305 {
2306# ifdef FEAT_MBYTE
2307# ifndef TB_SETUNICODEFORMAT
2308 /* For older compilers. We assume this never changes. */
2309# define TB_SETUNICODEFORMAT 0x2005
2310# endif
2311 /* Enable/disable unicode support */
2312 int uu = (enc_codepage >= 0 && (int)GetACP() != enc_codepage);
2313 SendMessage(s_toolbarhwnd, TB_SETUNICODEFORMAT, (WPARAM)uu, (LPARAM)0);
2314# endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00002315 ShowWindow(s_toolbarhwnd, SW_SHOW);
Bram Moolenaar8f2ff9f2006-08-29 19:26:50 +00002316 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00002317 else
2318 ShowWindow(s_toolbarhwnd, SW_HIDE);
2319}
2320
2321/* Then number of bitmaps is fixed. Exit is missing! */
2322#define TOOLBAR_BITMAP_COUNT 31
2323
2324#endif
2325
Bram Moolenaar3991dab2006-03-27 17:01:56 +00002326#if defined(FEAT_GUI_TABLINE) || defined(PROTO)
Bram Moolenaar2e2a2812006-03-27 20:55:21 +00002327 static void
Bram Moolenaar908d53a2006-11-07 18:05:31 +00002328add_tabline_popup_menu_entry(HMENU pmenu, UINT item_id, char_u *item_text)
2329{
2330#ifdef FEAT_MBYTE
2331 WCHAR *wn = NULL;
2332 int n;
2333
2334 if (enc_codepage >= 0 && (int)GetACP() != enc_codepage)
2335 {
2336 /* 'encoding' differs from active codepage: convert menu name
2337 * and use wide function */
Bram Moolenaar36f692d2008-11-20 16:10:17 +00002338 wn = enc_to_utf16(item_text, NULL);
Bram Moolenaar908d53a2006-11-07 18:05:31 +00002339 if (wn != NULL)
2340 {
2341 MENUITEMINFOW infow;
2342
2343 infow.cbSize = sizeof(infow);
2344 infow.fMask = MIIM_TYPE | MIIM_ID;
2345 infow.wID = item_id;
2346 infow.fType = MFT_STRING;
2347 infow.dwTypeData = wn;
2348 infow.cch = (UINT)wcslen(wn);
2349 n = InsertMenuItemW(pmenu, item_id, FALSE, &infow);
2350 vim_free(wn);
2351 if (n == 0 && GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
2352 /* Failed, try using non-wide function. */
2353 wn = NULL;
2354 }
2355 }
2356
2357 if (wn == NULL)
2358#endif
2359 {
2360 MENUITEMINFO info;
2361
2362 info.cbSize = sizeof(info);
2363 info.fMask = MIIM_TYPE | MIIM_ID;
2364 info.wID = item_id;
2365 info.fType = MFT_STRING;
2366 info.dwTypeData = item_text;
2367 info.cch = (UINT)STRLEN(item_text);
2368 InsertMenuItem(pmenu, item_id, FALSE, &info);
2369 }
2370}
2371
2372 static void
Bram Moolenaar2e2a2812006-03-27 20:55:21 +00002373show_tabline_popup_menu(void)
2374{
2375 HMENU tab_pmenu;
Bram Moolenaar2e2a2812006-03-27 20:55:21 +00002376 long rval;
2377 POINT pt;
Bram Moolenaar2e2a2812006-03-27 20:55:21 +00002378
Bram Moolenaarf193fff2006-04-27 00:02:13 +00002379 /* When ignoring events don't show the menu. */
2380 if (hold_gui_events
2381# ifdef FEAT_CMDWIN
2382 || cmdwin_type != 0
2383# endif
2384 )
2385 return;
2386
Bram Moolenaar2e2a2812006-03-27 20:55:21 +00002387 tab_pmenu = CreatePopupMenu();
2388 if (tab_pmenu == NULL)
2389 return;
2390
Bram Moolenaar7098ee52015-06-09 19:14:24 +02002391 if (first_tabpage->tp_next != NULL)
Bram Moolenaar3b597552015-09-15 17:58:29 +02002392 add_tabline_popup_menu_entry(tab_pmenu,
Bram Moolenaar7098ee52015-06-09 19:14:24 +02002393 TABLINE_MENU_CLOSE, _("Close tab"));
Bram Moolenaar908d53a2006-11-07 18:05:31 +00002394 add_tabline_popup_menu_entry(tab_pmenu, TABLINE_MENU_NEW, _("New tab"));
2395 add_tabline_popup_menu_entry(tab_pmenu, TABLINE_MENU_OPEN,
2396 _("Open tab..."));
Bram Moolenaar2e2a2812006-03-27 20:55:21 +00002397
2398 GetCursorPos(&pt);
2399 rval = TrackPopupMenuEx(tab_pmenu, TPM_RETURNCMD, pt.x, pt.y, s_tabhwnd,
2400 NULL);
2401
2402 DestroyMenu(tab_pmenu);
2403
2404 /* Add the string cmd into input buffer */
2405 if (rval > 0)
2406 {
2407 TCHITTESTINFO htinfo;
2408 int idx;
2409
2410 if (ScreenToClient(s_tabhwnd, &pt) == 0)
2411 return;
2412
2413 htinfo.pt.x = pt.x;
2414 htinfo.pt.y = pt.y;
2415 idx = TabCtrl_HitTest(s_tabhwnd, &htinfo);
2416 if (idx == -1)
2417 idx = 0;
2418 else
2419 idx += 1;
2420
Bram Moolenaarc6fe9192006-04-09 21:54:49 +00002421 send_tabline_menu_event(idx, (int)rval);
Bram Moolenaar2e2a2812006-03-27 20:55:21 +00002422 }
2423}
2424
Bram Moolenaar3991dab2006-03-27 17:01:56 +00002425/*
2426 * Show or hide the tabline.
2427 */
2428 void
2429gui_mch_show_tabline(int showit)
2430{
2431 if (s_tabhwnd == NULL)
2432 return;
2433
2434 if (!showit != !showing_tabline)
2435 {
2436 if (showit)
2437 ShowWindow(s_tabhwnd, SW_SHOW);
2438 else
2439 ShowWindow(s_tabhwnd, SW_HIDE);
2440 showing_tabline = showit;
2441 }
2442}
2443
2444/*
2445 * Return TRUE when tabline is displayed.
2446 */
2447 int
2448gui_mch_showing_tabline(void)
2449{
2450 return s_tabhwnd != NULL && showing_tabline;
2451}
2452
2453/*
2454 * Update the labels of the tabline.
2455 */
2456 void
2457gui_mch_update_tabline(void)
2458{
2459 tabpage_T *tp;
2460 TCITEM tie;
2461 int nr = 0;
2462 int curtabidx = 0;
Bram Moolenaar86f931e2013-08-07 21:13:23 +02002463 int tabadded = 0;
Bram Moolenaar8424a622006-04-19 21:23:36 +00002464#ifdef FEAT_MBYTE
Bram Moolenaarfc1421e2006-04-20 22:17:20 +00002465 static int use_unicode = FALSE;
2466 int uu;
Bram Moolenaar8424a622006-04-19 21:23:36 +00002467 WCHAR *wstr = NULL;
2468#endif
Bram Moolenaar3991dab2006-03-27 17:01:56 +00002469
2470 if (s_tabhwnd == NULL)
2471 return;
2472
Bram Moolenaarfc1421e2006-04-20 22:17:20 +00002473#if defined(FEAT_MBYTE)
2474# ifndef CCM_SETUNICODEFORMAT
2475 /* For older compilers. We assume this never changes. */
2476# define CCM_SETUNICODEFORMAT 0x2005
2477# endif
2478 uu = (enc_codepage >= 0 && (int)GetACP() != enc_codepage);
2479 if (uu != use_unicode)
2480 {
2481 /* Enable/disable unicode support */
2482 SendMessage(s_tabhwnd, CCM_SETUNICODEFORMAT, (WPARAM)uu, (LPARAM)0);
2483 use_unicode = uu;
2484 }
Bram Moolenaar8424a622006-04-19 21:23:36 +00002485#endif
2486
Bram Moolenaar3991dab2006-03-27 17:01:56 +00002487 tie.mask = TCIF_TEXT;
2488 tie.iImage = -1;
2489
Bram Moolenaar4b166d02012-12-12 17:12:25 +01002490 /* Disable redraw for tab updates to eliminate O(N^2) draws. */
2491 SendMessage(s_tabhwnd, WM_SETREDRAW, (WPARAM)FALSE, 0);
2492
Bram Moolenaar3991dab2006-03-27 17:01:56 +00002493 /* Add a label for each tab page. They all contain the same text area. */
2494 for (tp = first_tabpage; tp != NULL; tp = tp->tp_next, ++nr)
2495 {
2496 if (tp == curtab)
2497 curtabidx = nr;
2498
Bram Moolenaar4b166d02012-12-12 17:12:25 +01002499 if (nr >= TabCtrl_GetItemCount(s_tabhwnd))
Bram Moolenaar3991dab2006-03-27 17:01:56 +00002500 {
2501 /* Add the tab */
2502 tie.pszText = "-Empty-";
2503 TabCtrl_InsertItem(s_tabhwnd, nr, &tie);
Bram Moolenaar86f931e2013-08-07 21:13:23 +02002504 tabadded = 1;
Bram Moolenaar3991dab2006-03-27 17:01:56 +00002505 }
2506
Bram Moolenaar57657d82006-04-21 22:12:41 +00002507 get_tabline_label(tp, FALSE);
Bram Moolenaar3991dab2006-03-27 17:01:56 +00002508 tie.pszText = NameBuff;
Bram Moolenaar8424a622006-04-19 21:23:36 +00002509#ifdef FEAT_MBYTE
2510 wstr = NULL;
Bram Moolenaarfc1421e2006-04-20 22:17:20 +00002511 if (use_unicode)
Bram Moolenaar8424a622006-04-19 21:23:36 +00002512 {
2513 /* Need to go through Unicode. */
Bram Moolenaar36f692d2008-11-20 16:10:17 +00002514 wstr = enc_to_utf16(NameBuff, NULL);
Bram Moolenaar8424a622006-04-19 21:23:36 +00002515 if (wstr != NULL)
2516 {
2517 TCITEMW tiw;
2518
2519 tiw.mask = TCIF_TEXT;
2520 tiw.iImage = -1;
2521 tiw.pszText = wstr;
Bram Moolenaar85f868c2006-11-28 16:16:58 +00002522 SendMessage(s_tabhwnd, TCM_SETITEMW, (WPARAM)nr, (LPARAM)&tiw);
Bram Moolenaar8424a622006-04-19 21:23:36 +00002523 vim_free(wstr);
2524 }
2525 }
2526 if (wstr == NULL)
2527#endif
2528 {
2529 TabCtrl_SetItem(s_tabhwnd, nr, &tie);
2530 }
Bram Moolenaar3991dab2006-03-27 17:01:56 +00002531 }
2532
2533 /* Remove any old labels. */
Bram Moolenaar4b166d02012-12-12 17:12:25 +01002534 while (nr < TabCtrl_GetItemCount(s_tabhwnd))
Bram Moolenaar3991dab2006-03-27 17:01:56 +00002535 TabCtrl_DeleteItem(s_tabhwnd, nr);
2536
Bram Moolenaar86f931e2013-08-07 21:13:23 +02002537 if (!tabadded && TabCtrl_GetCurSel(s_tabhwnd) != curtabidx)
2538 TabCtrl_SetCurSel(s_tabhwnd, curtabidx);
2539
Bram Moolenaar14e28812012-12-16 12:50:39 +01002540 /* Re-enable redraw and redraw. */
Bram Moolenaar4b166d02012-12-12 17:12:25 +01002541 SendMessage(s_tabhwnd, WM_SETREDRAW, (WPARAM)TRUE, 0);
Bram Moolenaar14e28812012-12-16 12:50:39 +01002542 RedrawWindow(s_tabhwnd, NULL, NULL,
2543 RDW_ERASE | RDW_FRAME | RDW_INVALIDATE | RDW_ALLCHILDREN);
Bram Moolenaara8f96392013-07-17 21:59:13 +02002544
Bram Moolenaar86f931e2013-08-07 21:13:23 +02002545 if (tabadded && TabCtrl_GetCurSel(s_tabhwnd) != curtabidx)
Bram Moolenaara8f96392013-07-17 21:59:13 +02002546 TabCtrl_SetCurSel(s_tabhwnd, curtabidx);
Bram Moolenaar3991dab2006-03-27 17:01:56 +00002547}
2548
2549/*
2550 * Set the current tab to "nr". First tab is 1.
2551 */
2552 void
2553gui_mch_set_curtab(nr)
2554 int nr;
2555{
2556 if (s_tabhwnd == NULL)
2557 return;
2558
Bram Moolenaara8f96392013-07-17 21:59:13 +02002559 if (TabCtrl_GetCurSel(s_tabhwnd) != nr - 1)
2560 TabCtrl_SetCurSel(s_tabhwnd, nr - 1);
Bram Moolenaar3991dab2006-03-27 17:01:56 +00002561}
2562
2563#endif
2564
Bram Moolenaar071d4272004-06-13 20:20:40 +00002565/*
2566 * ":simalt" command.
2567 */
2568 void
2569ex_simalt(exarg_T *eap)
2570{
2571 char_u *keys = eap->arg;
2572
2573 PostMessage(s_hwnd, WM_SYSCOMMAND, (WPARAM)SC_KEYMENU, (LPARAM)0);
2574 while (*keys)
2575 {
2576 if (*keys == '~')
2577 *keys = ' '; /* for showing system menu */
2578 PostMessage(s_hwnd, WM_CHAR, (WPARAM)*keys, (LPARAM)0);
2579 keys++;
2580 }
2581}
2582
2583/*
2584 * Create the find & replace dialogs.
2585 * You can't have both at once: ":find" when replace is showing, destroys
2586 * the replace dialog first, and the other way around.
2587 */
2588#ifdef MSWIN_FIND_REPLACE
2589 static void
2590initialise_findrep(char_u *initial_string)
2591{
2592 int wword = FALSE;
2593 int mcase = !p_ic;
2594 char_u *entry_text;
2595
2596 /* Get the search string to use. */
2597 entry_text = get_find_dialog_text(initial_string, &wword, &mcase);
2598
2599 s_findrep_struct.hwndOwner = s_hwnd;
2600 s_findrep_struct.Flags = FR_DOWN;
2601 if (mcase)
2602 s_findrep_struct.Flags |= FR_MATCHCASE;
2603 if (wword)
2604 s_findrep_struct.Flags |= FR_WHOLEWORD;
2605 if (entry_text != NULL && *entry_text != NUL)
Bram Moolenaarfe3ca8d2005-07-18 21:43:02 +00002606 vim_strncpy(s_findrep_struct.lpstrFindWhat, entry_text,
2607 s_findrep_struct.wFindWhatLen - 1);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002608 vim_free(entry_text);
2609}
2610#endif
2611
Bram Moolenaar908d53a2006-11-07 18:05:31 +00002612 static void
2613set_window_title(HWND hwnd, char *title)
2614{
2615#ifdef FEAT_MBYTE
2616 if (title != NULL && enc_codepage >= 0 && enc_codepage != (int)GetACP())
2617 {
2618 WCHAR *wbuf;
2619 int n;
2620
Bram Moolenaar36f692d2008-11-20 16:10:17 +00002621 /* Convert the title from 'encoding' to UTF-16. */
2622 wbuf = (WCHAR *)enc_to_utf16((char_u *)title, NULL);
Bram Moolenaar908d53a2006-11-07 18:05:31 +00002623 if (wbuf != NULL)
2624 {
2625 n = SetWindowTextW(hwnd, wbuf);
2626 vim_free(wbuf);
2627 if (n != 0 || GetLastError() != ERROR_CALL_NOT_IMPLEMENTED)
2628 return;
2629 /* Retry with non-wide function (for Windows 98). */
2630 }
2631 }
2632#endif
2633 (void)SetWindowText(hwnd, (LPCSTR)title);
2634}
2635
Bram Moolenaar071d4272004-06-13 20:20:40 +00002636 void
2637gui_mch_find_dialog(exarg_T *eap)
2638{
2639#ifdef MSWIN_FIND_REPLACE
2640 if (s_findrep_msg != 0)
2641 {
2642 if (IsWindow(s_findrep_hwnd) && !s_findrep_is_find)
2643 DestroyWindow(s_findrep_hwnd);
2644
2645 if (!IsWindow(s_findrep_hwnd))
2646 {
2647 initialise_findrep(eap->arg);
Bram Moolenaar3ca9a8a2009-01-28 20:23:17 +00002648# if defined(FEAT_MBYTE) && defined(WIN3264)
2649 /* If the OS is Windows NT, and 'encoding' differs from active
2650 * codepage: convert text and use wide function. */
2651 if (os_version.dwPlatformId == VER_PLATFORM_WIN32_NT
2652 && enc_codepage >= 0 && (int)GetACP() != enc_codepage)
2653 {
Bram Moolenaarcc448b32010-07-14 16:52:17 +02002654 findrep_atow(&s_findrep_struct_w, &s_findrep_struct);
Bram Moolenaar3ca9a8a2009-01-28 20:23:17 +00002655 s_findrep_hwnd = FindTextW(
2656 (LPFINDREPLACEW) &s_findrep_struct_w);
2657 }
2658 else
2659# endif
2660 s_findrep_hwnd = FindText((LPFINDREPLACE) &s_findrep_struct);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002661 }
2662
Bram Moolenaar908d53a2006-11-07 18:05:31 +00002663 set_window_title(s_findrep_hwnd,
2664 _("Find string (use '\\\\' to find a '\\')"));
Bram Moolenaar071d4272004-06-13 20:20:40 +00002665 (void)SetFocus(s_findrep_hwnd);
2666
2667 s_findrep_is_find = TRUE;
2668 }
2669#endif
2670}
2671
2672
2673 void
2674gui_mch_replace_dialog(exarg_T *eap)
2675{
2676#ifdef MSWIN_FIND_REPLACE
2677 if (s_findrep_msg != 0)
2678 {
2679 if (IsWindow(s_findrep_hwnd) && s_findrep_is_find)
2680 DestroyWindow(s_findrep_hwnd);
2681
2682 if (!IsWindow(s_findrep_hwnd))
2683 {
2684 initialise_findrep(eap->arg);
Bram Moolenaar3ca9a8a2009-01-28 20:23:17 +00002685# if defined(FEAT_MBYTE) && defined(WIN3264)
2686 if (os_version.dwPlatformId == VER_PLATFORM_WIN32_NT
2687 && enc_codepage >= 0 && (int)GetACP() != enc_codepage)
2688 {
2689 findrep_atow(&s_findrep_struct_w, &s_findrep_struct);
2690 s_findrep_hwnd = ReplaceTextW(
2691 (LPFINDREPLACEW) &s_findrep_struct_w);
2692 }
2693 else
2694# endif
2695 s_findrep_hwnd = ReplaceText(
2696 (LPFINDREPLACE) &s_findrep_struct);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002697 }
2698
Bram Moolenaar908d53a2006-11-07 18:05:31 +00002699 set_window_title(s_findrep_hwnd,
2700 _("Find & Replace (use '\\\\' to find a '\\')"));
Bram Moolenaar071d4272004-06-13 20:20:40 +00002701 (void)SetFocus(s_findrep_hwnd);
2702
2703 s_findrep_is_find = FALSE;
2704 }
2705#endif
2706}
2707
2708
2709/*
2710 * Set visibility of the pointer.
2711 */
2712 void
2713gui_mch_mousehide(int hide)
2714{
2715 if (hide != gui.pointer_hidden)
2716 {
2717 ShowCursor(!hide);
2718 gui.pointer_hidden = hide;
2719 }
2720}
2721
2722#ifdef FEAT_MENU
2723 static void
2724gui_mch_show_popupmenu_at(vimmenu_T *menu, int x, int y)
2725{
2726 /* Unhide the mouse, we don't get move events here. */
2727 gui_mch_mousehide(FALSE);
2728
2729 (void)TrackPopupMenu(
2730 (HMENU)menu->submenu_id,
2731 TPM_LEFTALIGN | TPM_LEFTBUTTON,
2732 x, y,
2733 (int)0, /*reserved param*/
2734 s_hwnd,
2735 NULL);
2736 /*
2737 * NOTE: The pop-up menu can eat the mouse up event.
2738 * We deal with this in normal.c.
2739 */
2740}
2741#endif
2742
2743/*
2744 * Got a message when the system will go down.
2745 */
2746 static void
2747_OnEndSession(void)
2748{
2749 getout_preserve_modified(1);
2750}
2751
2752/*
2753 * Get this message when the user clicks on the cross in the top right corner
2754 * of a Windows95 window.
2755 */
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00002756/*ARGSUSED*/
Bram Moolenaar071d4272004-06-13 20:20:40 +00002757 static void
2758_OnClose(
2759 HWND hwnd)
2760{
2761 gui_shell_closed();
2762}
2763
2764/*
2765 * Get a message when the window is being destroyed.
2766 */
2767 static void
2768_OnDestroy(
2769 HWND hwnd)
2770{
2771#ifdef WIN16_3DLOOK
2772 Ctl3dUnregister(s_hinst);
2773#endif
2774 if (!destroying)
2775 _OnClose(hwnd);
2776}
2777
2778 static void
2779_OnPaint(
2780 HWND hwnd)
2781{
2782 if (!IsMinimized(hwnd))
2783 {
2784 PAINTSTRUCT ps;
2785
2786 out_flush(); /* make sure all output has been processed */
2787 (void)BeginPaint(hwnd, &ps);
Bram Moolenaarb5a7a8b2014-08-06 14:52:30 +02002788#if defined(FEAT_DIRECTX)
2789 if (IS_ENABLE_DIRECTX())
2790 DWriteContext_BeginDraw(s_dwc);
2791#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00002792
2793#ifdef FEAT_MBYTE
2794 /* prevent multi-byte characters from misprinting on an invalid
2795 * rectangle */
2796 if (has_mbyte)
2797 {
2798 RECT rect;
2799
2800 GetClientRect(hwnd, &rect);
2801 ps.rcPaint.left = rect.left;
2802 ps.rcPaint.right = rect.right;
2803 }
2804#endif
2805
2806 if (!IsRectEmpty(&ps.rcPaint))
Bram Moolenaarb5a7a8b2014-08-06 14:52:30 +02002807 {
2808#if defined(FEAT_DIRECTX)
2809 if (IS_ENABLE_DIRECTX())
2810 DWriteContext_BindDC(s_dwc, s_hdc, &ps.rcPaint);
2811#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00002812 gui_redraw(ps.rcPaint.left, ps.rcPaint.top,
2813 ps.rcPaint.right - ps.rcPaint.left + 1,
2814 ps.rcPaint.bottom - ps.rcPaint.top + 1);
Bram Moolenaarb5a7a8b2014-08-06 14:52:30 +02002815 }
2816
2817#if defined(FEAT_DIRECTX)
2818 if (IS_ENABLE_DIRECTX())
2819 DWriteContext_EndDraw(s_dwc);
2820#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00002821 EndPaint(hwnd, &ps);
2822 }
2823}
2824
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00002825/*ARGSUSED*/
Bram Moolenaar071d4272004-06-13 20:20:40 +00002826 static void
2827_OnSize(
2828 HWND hwnd,
2829 UINT state,
2830 int cx,
2831 int cy)
2832{
2833 if (!IsMinimized(hwnd))
2834 {
2835 gui_resize_shell(cx, cy);
2836
2837#ifdef FEAT_MENU
2838 /* Menu bar may wrap differently now */
2839 gui_mswin_get_menu_height(TRUE);
2840#endif
2841 }
2842}
2843
2844 static void
2845_OnSetFocus(
2846 HWND hwnd,
2847 HWND hwndOldFocus)
2848{
2849 gui_focus_change(TRUE);
Bram Moolenaarea408882007-12-03 21:21:03 +00002850 s_getting_focus = TRUE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002851 (void)MyWindowProc(hwnd, WM_SETFOCUS, (WPARAM)hwndOldFocus, 0);
2852}
2853
2854 static void
2855_OnKillFocus(
2856 HWND hwnd,
2857 HWND hwndNewFocus)
2858{
2859 gui_focus_change(FALSE);
Bram Moolenaarea408882007-12-03 21:21:03 +00002860 s_getting_focus = FALSE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002861 (void)MyWindowProc(hwnd, WM_KILLFOCUS, (WPARAM)hwndNewFocus, 0);
2862}
2863
2864/*
2865 * Get a message when the user switches back to vim
2866 */
2867#ifdef WIN16
2868 static BOOL
2869#else
2870 static LRESULT
2871#endif
2872_OnActivateApp(
2873 HWND hwnd,
2874 BOOL fActivate,
2875#ifdef WIN16
2876 HTASK dwThreadId
2877#else
2878 DWORD dwThreadId
2879#endif
2880 )
2881{
2882 /* we call gui_focus_change() in _OnSetFocus() */
2883 /* gui_focus_change((int)fActivate); */
2884 return MyWindowProc(hwnd, WM_ACTIVATEAPP, fActivate, (DWORD)dwThreadId);
2885}
2886
2887#if defined(FEAT_WINDOWS) || defined(PROTO)
2888 void
2889gui_mch_destroy_scrollbar(scrollbar_T *sb)
2890{
2891 DestroyWindow(sb->id);
2892}
2893#endif
2894
2895/*
Bram Moolenaar9588a0f2005-01-08 21:45:39 +00002896 * Get current mouse coordinates in text window.
Bram Moolenaar071d4272004-06-13 20:20:40 +00002897 */
Bram Moolenaar9588a0f2005-01-08 21:45:39 +00002898 void
Bram Moolenaara40c5002005-01-09 21:16:21 +00002899gui_mch_getmouse(int *x, int *y)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002900{
2901 RECT rct;
2902 POINT mp;
2903
2904 (void)GetWindowRect(s_textArea, &rct);
2905 (void)GetCursorPos((LPPOINT)&mp);
Bram Moolenaar9588a0f2005-01-08 21:45:39 +00002906 *x = (int)(mp.x - rct.left);
2907 *y = (int)(mp.y - rct.top);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002908}
2909
2910/*
2911 * Move mouse pointer to character at (x, y).
2912 */
2913 void
2914gui_mch_setmouse(int x, int y)
2915{
2916 RECT rct;
2917
2918 (void)GetWindowRect(s_textArea, &rct);
2919 (void)SetCursorPos(x + gui.border_offset + rct.left,
2920 y + gui.border_offset + rct.top);
2921}
2922
2923 static void
2924gui_mswin_get_valid_dimensions(
2925 int w,
2926 int h,
2927 int *valid_w,
2928 int *valid_h)
2929{
2930 int base_width, base_height;
2931
2932 base_width = gui_get_base_width()
Bram Moolenaar9d488952013-07-21 17:53:58 +02002933 + (GetSystemMetrics(SM_CXFRAME) +
Bram Moolenaar3b597552015-09-15 17:58:29 +02002934 GetSystemMetrics(SM_CXPADDEDBORDER)) * 2;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002935 base_height = gui_get_base_height()
Bram Moolenaar9d488952013-07-21 17:53:58 +02002936 + (GetSystemMetrics(SM_CYFRAME) +
Bram Moolenaar3b597552015-09-15 17:58:29 +02002937 GetSystemMetrics(SM_CXPADDEDBORDER)) * 2
Bram Moolenaar071d4272004-06-13 20:20:40 +00002938 + GetSystemMetrics(SM_CYCAPTION)
2939#ifdef FEAT_MENU
2940 + gui_mswin_get_menu_height(FALSE)
2941#endif
2942 ;
2943 *valid_w = base_width +
2944 ((w - base_width) / gui.char_width) * gui.char_width;
2945 *valid_h = base_height +
2946 ((h - base_height) / gui.char_height) * gui.char_height;
2947}
2948
2949 void
Bram Moolenaar071d4272004-06-13 20:20:40 +00002950gui_mch_flash(int msec)
2951{
2952 RECT rc;
2953
2954 /*
2955 * Note: InvertRect() excludes right and bottom of rectangle.
2956 */
2957 rc.left = 0;
2958 rc.top = 0;
2959 rc.right = gui.num_cols * gui.char_width;
2960 rc.bottom = gui.num_rows * gui.char_height;
2961 InvertRect(s_hdc, &rc);
2962 gui_mch_flush(); /* make sure it's displayed */
2963
2964 ui_delay((long)msec, TRUE); /* wait for a few msec */
2965
2966 InvertRect(s_hdc, &rc);
2967}
2968
2969/*
2970 * Return flags used for scrolling.
2971 * The SW_INVALIDATE is required when part of the window is covered or
2972 * off-screen. Refer to MS KB Q75236.
2973 */
2974 static int
2975get_scroll_flags(void)
2976{
2977 HWND hwnd;
2978 RECT rcVim, rcOther, rcDest;
2979
2980 GetWindowRect(s_hwnd, &rcVim);
Bram Moolenaar0d406992005-05-22 22:03:39 +00002981
2982 /* Check if the window is partly above or below the screen. We don't care
2983 * about partly left or right of the screen, it is not relevant when
2984 * scrolling up or down. */
2985 if (rcVim.top < 0 || rcVim.bottom > GetSystemMetrics(SM_CYFULLSCREEN))
2986 return SW_INVALIDATE;
2987
2988 /* Check if there is an window (partly) on top of us. */
Bram Moolenaar071d4272004-06-13 20:20:40 +00002989 for (hwnd = s_hwnd; (hwnd = GetWindow(hwnd, GW_HWNDPREV)) != (HWND)0; )
2990 if (IsWindowVisible(hwnd))
2991 {
2992 GetWindowRect(hwnd, &rcOther);
2993 if (IntersectRect(&rcDest, &rcVim, &rcOther))
2994 return SW_INVALIDATE;
2995 }
2996 return 0;
2997}
2998
2999/*
Bram Moolenaar3b597552015-09-15 17:58:29 +02003000 * On some Intel GPUs, the regions drawn just prior to ScrollWindowEx()
3001 * may not be scrolled out properly.
3002 * For gVim, when _OnScroll() is repeated, the character at the
3003 * previous cursor position may be left drawn after scroll.
3004 * The problem can be avoided by calling GetPixel() to get a pixel in
3005 * the region before ScrollWindowEx().
3006 */
3007 static void
3008intel_gpu_workaround(void)
3009{
3010 GetPixel(s_hdc, FILL_X(gui.col), FILL_Y(gui.row));
3011}
3012
3013/*
Bram Moolenaar071d4272004-06-13 20:20:40 +00003014 * Delete the given number of lines from the given row, scrolling up any
3015 * text further down within the scroll region.
3016 */
3017 void
3018gui_mch_delete_lines(
3019 int row,
3020 int num_lines)
3021{
3022 RECT rc;
3023
Bram Moolenaar3b597552015-09-15 17:58:29 +02003024 intel_gpu_workaround();
3025
Bram Moolenaar071d4272004-06-13 20:20:40 +00003026 rc.left = FILL_X(gui.scroll_region_left);
3027 rc.right = FILL_X(gui.scroll_region_right + 1);
3028 rc.top = FILL_Y(row);
3029 rc.bottom = FILL_Y(gui.scroll_region_bot + 1);
3030
3031 ScrollWindowEx(s_textArea, 0, -num_lines * gui.char_height,
3032 &rc, &rc, NULL, NULL, get_scroll_flags());
3033
3034 UpdateWindow(s_textArea);
3035 /* This seems to be required to avoid the cursor disappearing when
3036 * scrolling such that the cursor ends up in the top-left character on
3037 * the screen... But why? (Webb) */
3038 /* It's probably fixed by disabling drawing the cursor while scrolling. */
3039 /* gui.cursor_is_valid = FALSE; */
3040
3041 gui_clear_block(gui.scroll_region_bot - num_lines + 1,
3042 gui.scroll_region_left,
3043 gui.scroll_region_bot, gui.scroll_region_right);
3044}
3045
3046/*
3047 * Insert the given number of lines before the given row, scrolling down any
3048 * following text within the scroll region.
3049 */
3050 void
3051gui_mch_insert_lines(
3052 int row,
3053 int num_lines)
3054{
3055 RECT rc;
3056
Bram Moolenaar3b597552015-09-15 17:58:29 +02003057 intel_gpu_workaround();
3058
Bram Moolenaar071d4272004-06-13 20:20:40 +00003059 rc.left = FILL_X(gui.scroll_region_left);
3060 rc.right = FILL_X(gui.scroll_region_right + 1);
3061 rc.top = FILL_Y(row);
3062 rc.bottom = FILL_Y(gui.scroll_region_bot + 1);
3063 /* The SW_INVALIDATE is required when part of the window is covered or
3064 * off-screen. How do we avoid it when it's not needed? */
3065 ScrollWindowEx(s_textArea, 0, num_lines * gui.char_height,
3066 &rc, &rc, NULL, NULL, get_scroll_flags());
3067
3068 UpdateWindow(s_textArea);
3069
3070 gui_clear_block(row, gui.scroll_region_left,
3071 row + num_lines - 1, gui.scroll_region_right);
3072}
3073
3074
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00003075/*ARGSUSED*/
Bram Moolenaar071d4272004-06-13 20:20:40 +00003076 void
3077gui_mch_exit(int rc)
3078{
Bram Moolenaarb5a7a8b2014-08-06 14:52:30 +02003079#if defined(FEAT_DIRECTX)
3080 DWriteContext_Close(s_dwc);
3081 DWrite_Final();
3082 s_dwc = NULL;
3083#endif
3084
Bram Moolenaar071d4272004-06-13 20:20:40 +00003085 ReleaseDC(s_textArea, s_hdc);
3086 DeleteObject(s_brush);
3087
3088#ifdef FEAT_TEAROFF
3089 /* Unload the tearoff bitmap */
3090 (void)DeleteObject((HGDIOBJ)s_htearbitmap);
3091#endif
3092
3093 /* Destroy our window (if we have one). */
3094 if (s_hwnd != NULL)
3095 {
3096 destroying = TRUE; /* ignore WM_DESTROY message now */
3097 DestroyWindow(s_hwnd);
3098 }
3099
3100#ifdef GLOBAL_IME
3101 global_ime_end();
3102#endif
3103}
3104
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00003105 static char_u *
3106logfont2name(LOGFONT lf)
3107{
3108 char *p;
3109 char *res;
3110 char *charset_name;
Bram Moolenaarb1692e22014-03-12 19:24:37 +01003111 char *font_name = lf.lfFaceName;
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00003112
3113 charset_name = charset_id2name((int)lf.lfCharSet);
Bram Moolenaarb1692e22014-03-12 19:24:37 +01003114#ifdef FEAT_MBYTE
3115 /* Convert a font name from the current codepage to 'encoding'.
3116 * TODO: Use Wide APIs (including LOGFONTW) instead of ANSI APIs. */
3117 if (enc_codepage >= 0 && (int)GetACP() != enc_codepage)
3118 {
3119 int len;
Bram Moolenaara0844a12014-03-19 12:37:22 +01003120 acp_to_enc(lf.lfFaceName, (int)strlen(lf.lfFaceName),
Bram Moolenaarb1692e22014-03-12 19:24:37 +01003121 (char_u **)&font_name, &len);
3122 }
3123#endif
3124 res = alloc((unsigned)(strlen(font_name) + 20
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00003125 + (charset_name == NULL ? 0 : strlen(charset_name) + 2)));
3126 if (res != NULL)
3127 {
3128 p = res;
3129 /* make a normal font string out of the lf thing:*/
Bram Moolenaarb1692e22014-03-12 19:24:37 +01003130 sprintf((char *)p, "%s:h%d", font_name, pixels_to_points(
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00003131 lf.lfHeight < 0 ? -lf.lfHeight : lf.lfHeight, TRUE));
3132 while (*p)
3133 {
3134 if (*p == ' ')
3135 *p = '_';
3136 ++p;
3137 }
3138#ifndef MSWIN16_FASTTEXT
3139 if (lf.lfItalic)
3140 STRCAT(p, ":i");
3141 if (lf.lfWeight >= FW_BOLD)
3142 STRCAT(p, ":b");
3143#endif
3144 if (lf.lfUnderline)
3145 STRCAT(p, ":u");
3146 if (lf.lfStrikeOut)
3147 STRCAT(p, ":s");
3148 if (charset_name != NULL)
3149 {
3150 STRCAT(p, ":c");
3151 STRCAT(p, charset_name);
3152 }
3153 }
3154
Bram Moolenaarb1692e22014-03-12 19:24:37 +01003155#ifdef FEAT_MBYTE
3156 if (font_name != lf.lfFaceName)
3157 vim_free(font_name);
3158#endif
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00003159 return res;
3160}
3161
Bram Moolenaar0f272122013-01-23 18:37:40 +01003162
3163#ifdef FEAT_MBYTE_IME
3164/*
3165 * Set correct LOGFONT to IME. Use 'guifontwide' if available, otherwise use
3166 * 'guifont'
3167 */
3168 static void
Bram Moolenaarfb97f282013-07-09 17:42:46 +02003169update_im_font(void)
Bram Moolenaar0f272122013-01-23 18:37:40 +01003170{
3171 LOGFONT lf_wide;
3172
3173 if (p_guifontwide != NULL && *p_guifontwide != NUL
Bram Moolenaar826763f2013-01-25 19:28:38 +01003174 && gui.wide_font != NOFONT
3175 && GetObject((HFONT)gui.wide_font, sizeof(lf_wide), &lf_wide))
Bram Moolenaar0f272122013-01-23 18:37:40 +01003176 norm_logfont = lf_wide;
3177 else
3178 norm_logfont = sub_logfont;
3179 im_set_font(&norm_logfont);
3180}
3181#endif
3182
3183#ifdef FEAT_MBYTE
3184/*
3185 * Handler of gui.wide_font (p_guifontwide) changed notification.
3186 */
3187 void
3188gui_mch_wide_font_changed()
3189{
Bram Moolenaardb250522013-06-17 22:43:25 +02003190# ifndef MSWIN16_FASTTEXT
3191 LOGFONT lf;
3192# endif
3193
Bram Moolenaar0f272122013-01-23 18:37:40 +01003194# ifdef FEAT_MBYTE_IME
3195 update_im_font();
3196# endif
Bram Moolenaardb250522013-06-17 22:43:25 +02003197
3198# ifndef MSWIN16_FASTTEXT
3199 gui_mch_free_font(gui.wide_ital_font);
3200 gui.wide_ital_font = NOFONT;
3201 gui_mch_free_font(gui.wide_bold_font);
3202 gui.wide_bold_font = NOFONT;
3203 gui_mch_free_font(gui.wide_boldital_font);
3204 gui.wide_boldital_font = NOFONT;
3205
3206 if (gui.wide_font
3207 && GetObject((HFONT)gui.wide_font, sizeof(lf), &lf))
3208 {
3209 if (!lf.lfItalic)
3210 {
3211 lf.lfItalic = TRUE;
3212 gui.wide_ital_font = get_font_handle(&lf);
3213 lf.lfItalic = FALSE;
3214 }
3215 if (lf.lfWeight < FW_BOLD)
3216 {
3217 lf.lfWeight = FW_BOLD;
3218 gui.wide_bold_font = get_font_handle(&lf);
3219 if (!lf.lfItalic)
3220 {
3221 lf.lfItalic = TRUE;
3222 gui.wide_boldital_font = get_font_handle(&lf);
3223 }
3224 }
3225 }
3226# endif
Bram Moolenaar0f272122013-01-23 18:37:40 +01003227}
3228#endif
3229
Bram Moolenaar071d4272004-06-13 20:20:40 +00003230/*
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00003231 * Initialise vim to use the font with the given name.
3232 * Return FAIL if the font could not be loaded, OK otherwise.
Bram Moolenaar071d4272004-06-13 20:20:40 +00003233 */
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00003234/*ARGSUSED*/
Bram Moolenaar071d4272004-06-13 20:20:40 +00003235 int
3236gui_mch_init_font(char_u *font_name, int fontset)
3237{
3238 LOGFONT lf;
3239 GuiFont font = NOFONT;
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00003240 char_u *p;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003241
3242 /* Load the font */
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00003243 if (get_logfont(&lf, font_name, NULL, TRUE) == OK)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003244 font = get_font_handle(&lf);
3245 if (font == NOFONT)
3246 return FAIL;
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00003247
Bram Moolenaar071d4272004-06-13 20:20:40 +00003248 if (font_name == NULL)
3249 font_name = lf.lfFaceName;
3250#if defined(FEAT_MBYTE_IME) || defined(GLOBAL_IME)
3251 norm_logfont = lf;
Bram Moolenaar0f272122013-01-23 18:37:40 +01003252 sub_logfont = lf;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003253#endif
3254#ifdef FEAT_MBYTE_IME
Bram Moolenaar0f272122013-01-23 18:37:40 +01003255 update_im_font();
Bram Moolenaar071d4272004-06-13 20:20:40 +00003256#endif
3257 gui_mch_free_font(gui.norm_font);
3258 gui.norm_font = font;
3259 current_font_height = lf.lfHeight;
3260 GetFontSize(font);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003261
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00003262 p = logfont2name(lf);
3263 if (p != NULL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003264 {
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00003265 hl_set_font_name(p);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003266
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00003267 /* When setting 'guifont' to "*" replace it with the actual font name.
3268 * */
3269 if (STRCMP(font_name, "*") == 0 && STRCMP(p_guifont, "*") == 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003270 {
Bram Moolenaar071d4272004-06-13 20:20:40 +00003271 vim_free(p_guifont);
3272 p_guifont = p;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003273 }
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00003274 else
3275 vim_free(p);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003276 }
3277
3278#ifndef MSWIN16_FASTTEXT
3279 gui_mch_free_font(gui.ital_font);
3280 gui.ital_font = NOFONT;
3281 gui_mch_free_font(gui.bold_font);
3282 gui.bold_font = NOFONT;
3283 gui_mch_free_font(gui.boldital_font);
3284 gui.boldital_font = NOFONT;
3285
3286 if (!lf.lfItalic)
3287 {
3288 lf.lfItalic = TRUE;
3289 gui.ital_font = get_font_handle(&lf);
3290 lf.lfItalic = FALSE;
3291 }
3292 if (lf.lfWeight < FW_BOLD)
3293 {
3294 lf.lfWeight = FW_BOLD;
3295 gui.bold_font = get_font_handle(&lf);
3296 if (!lf.lfItalic)
3297 {
3298 lf.lfItalic = TRUE;
3299 gui.boldital_font = get_font_handle(&lf);
3300 }
3301 }
3302#endif
3303
3304 return OK;
3305}
3306
Bram Moolenaar85f868c2006-11-28 16:16:58 +00003307#ifndef WPF_RESTORETOMAXIMIZED
3308# define WPF_RESTORETOMAXIMIZED 2 /* just in case someone doesn't have it */
3309#endif
3310
Bram Moolenaar071d4272004-06-13 20:20:40 +00003311/*
3312 * Return TRUE if the GUI window is maximized, filling the whole screen.
3313 */
3314 int
3315gui_mch_maximized()
3316{
Bram Moolenaar85f868c2006-11-28 16:16:58 +00003317 WINDOWPLACEMENT wp;
3318
3319 wp.length = sizeof(WINDOWPLACEMENT);
3320 if (GetWindowPlacement(s_hwnd, &wp))
3321 return wp.showCmd == SW_SHOWMAXIMIZED
3322 || (wp.showCmd == SW_SHOWMINIMIZED
3323 && wp.flags == WPF_RESTORETOMAXIMIZED);
3324
3325 return 0;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003326}
3327
3328/*
3329 * Called when the font changed while the window is maximized. Compute the
3330 * new Rows and Columns. This is like resizing the window.
3331 */
3332 void
3333gui_mch_newfont()
3334{
3335 RECT rect;
3336
3337 GetWindowRect(s_hwnd, &rect);
3338 gui_resize_shell(rect.right - rect.left
Bram Moolenaar9d488952013-07-21 17:53:58 +02003339 - (GetSystemMetrics(SM_CXFRAME) +
Bram Moolenaar3b597552015-09-15 17:58:29 +02003340 GetSystemMetrics(SM_CXPADDEDBORDER)) * 2,
Bram Moolenaar071d4272004-06-13 20:20:40 +00003341 rect.bottom - rect.top
Bram Moolenaar9d488952013-07-21 17:53:58 +02003342 - (GetSystemMetrics(SM_CYFRAME) +
Bram Moolenaar3b597552015-09-15 17:58:29 +02003343 GetSystemMetrics(SM_CXPADDEDBORDER)) * 2
Bram Moolenaar071d4272004-06-13 20:20:40 +00003344 - GetSystemMetrics(SM_CYCAPTION)
3345#ifdef FEAT_MENU
3346 - gui_mswin_get_menu_height(FALSE)
3347#endif
3348 );
3349}
3350
3351/*
3352 * Set the window title
3353 */
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00003354/*ARGSUSED*/
Bram Moolenaar071d4272004-06-13 20:20:40 +00003355 void
3356gui_mch_settitle(
3357 char_u *title,
3358 char_u *icon)
3359{
Bram Moolenaar908d53a2006-11-07 18:05:31 +00003360 set_window_title(s_hwnd, (title == NULL ? "VIM" : (char *)title));
Bram Moolenaar071d4272004-06-13 20:20:40 +00003361}
3362
3363#ifdef FEAT_MOUSESHAPE
3364/* Table for shape IDCs. Keep in sync with the mshape_names[] table in
3365 * misc2.c! */
3366static LPCSTR mshape_idcs[] =
3367{
Bram Moolenaaraf62ff32013-03-19 14:48:29 +01003368 IDC_ARROW, /* arrow */
3369 MAKEINTRESOURCE(0), /* blank */
3370 IDC_IBEAM, /* beam */
3371 IDC_SIZENS, /* updown */
3372 IDC_SIZENS, /* udsizing */
3373 IDC_SIZEWE, /* leftright */
3374 IDC_SIZEWE, /* lrsizing */
3375 IDC_WAIT, /* busy */
Bram Moolenaar071d4272004-06-13 20:20:40 +00003376#ifdef WIN3264
Bram Moolenaaraf62ff32013-03-19 14:48:29 +01003377 IDC_NO, /* no */
Bram Moolenaar071d4272004-06-13 20:20:40 +00003378#else
Bram Moolenaaraf62ff32013-03-19 14:48:29 +01003379 IDC_ICON, /* no */
Bram Moolenaar071d4272004-06-13 20:20:40 +00003380#endif
Bram Moolenaaraf62ff32013-03-19 14:48:29 +01003381 IDC_ARROW, /* crosshair */
3382 IDC_ARROW, /* hand1 */
3383 IDC_ARROW, /* hand2 */
3384 IDC_ARROW, /* pencil */
3385 IDC_ARROW, /* question */
3386 IDC_ARROW, /* right-arrow */
3387 IDC_UPARROW, /* up-arrow */
3388 IDC_ARROW /* last one */
Bram Moolenaar071d4272004-06-13 20:20:40 +00003389};
3390
3391 void
3392mch_set_mouse_shape(int shape)
3393{
3394 LPCSTR idc;
3395
3396 if (shape == MSHAPE_HIDE)
3397 ShowCursor(FALSE);
3398 else
3399 {
3400 if (shape >= MSHAPE_NUMBERED)
Bram Moolenaaraf62ff32013-03-19 14:48:29 +01003401 idc = IDC_ARROW;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003402 else
3403 idc = mshape_idcs[shape];
Bram Moolenaare6a91fd2008-07-24 18:51:11 +00003404#ifdef SetClassLongPtr
3405 SetClassLongPtr(s_textArea, GCLP_HCURSOR, (__int3264)(LONG_PTR)LoadCursor(NULL, idc));
Bram Moolenaar071d4272004-06-13 20:20:40 +00003406#else
3407# ifdef WIN32
Bram Moolenaare6a91fd2008-07-24 18:51:11 +00003408 SetClassLong(s_textArea, GCL_HCURSOR, (long_u)LoadCursor(NULL, idc));
3409# else /* Win16 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00003410 SetClassWord(s_textArea, GCW_HCURSOR, (WORD)LoadCursor(NULL, idc));
3411# endif
3412#endif
3413 if (!p_mh)
3414 {
3415 POINT mp;
3416
3417 /* Set the position to make it redrawn with the new shape. */
3418 (void)GetCursorPos((LPPOINT)&mp);
3419 (void)SetCursorPos(mp.x, mp.y);
3420 ShowCursor(TRUE);
3421 }
3422 }
3423}
3424#endif
3425
3426#ifdef FEAT_BROWSE
3427/*
3428 * The file browser exists in two versions: with "W" uses wide characters,
3429 * without "W" the current codepage. When FEAT_MBYTE is defined and on
3430 * Windows NT/2000/XP the "W" functions are used.
3431 */
3432
3433# if defined(FEAT_MBYTE) && defined(WIN3264)
3434/*
Bram Moolenaar3ef7cdf2012-01-20 17:57:51 +01003435 * Wide version of convert_filter().
Bram Moolenaar071d4272004-06-13 20:20:40 +00003436 */
3437 static WCHAR *
3438convert_filterW(char_u *s)
3439{
Bram Moolenaar3ef7cdf2012-01-20 17:57:51 +01003440 char_u *tmp;
3441 int len;
Bram Moolenaar90b28002012-01-20 20:54:19 +01003442 WCHAR *res;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003443
Bram Moolenaar3ef7cdf2012-01-20 17:57:51 +01003444 tmp = convert_filter(s);
3445 if (tmp == NULL)
3446 return NULL;
3447 len = (int)STRLEN(s) + 3;
3448 res = enc_to_utf16(tmp, &len);
3449 vim_free(tmp);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003450 return res;
3451}
3452
3453/*
3454 * Wide version of gui_mch_browse(). Keep in sync!
3455 */
3456 static char_u *
3457gui_mch_browseW(
3458 int saving,
3459 char_u *title,
3460 char_u *dflt,
3461 char_u *ext,
3462 char_u *initdir,
3463 char_u *filter)
3464{
Bram Moolenaar36f692d2008-11-20 16:10:17 +00003465 /* We always use the wide function. This means enc_to_utf16() must work,
Bram Moolenaar071d4272004-06-13 20:20:40 +00003466 * otherwise it fails miserably! */
3467 OPENFILENAMEW fileStruct;
3468 WCHAR fileBuf[MAXPATHL];
3469 WCHAR *wp;
3470 int i;
3471 WCHAR *titlep = NULL;
3472 WCHAR *extp = NULL;
3473 WCHAR *initdirp = NULL;
3474 WCHAR *filterp;
3475 char_u *p;
3476
3477 if (dflt == NULL)
3478 fileBuf[0] = NUL;
3479 else
3480 {
Bram Moolenaar36f692d2008-11-20 16:10:17 +00003481 wp = enc_to_utf16(dflt, NULL);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003482 if (wp == NULL)
3483 fileBuf[0] = NUL;
3484 else
3485 {
3486 for (i = 0; wp[i] != NUL && i < MAXPATHL - 1; ++i)
3487 fileBuf[i] = wp[i];
3488 fileBuf[i] = NUL;
3489 vim_free(wp);
3490 }
3491 }
3492
3493 /* Convert the filter to Windows format. */
3494 filterp = convert_filterW(filter);
3495
Bram Moolenaar7db5fc82010-05-24 11:59:29 +02003496 vim_memset(&fileStruct, 0, sizeof(OPENFILENAMEW));
Bram Moolenaar071d4272004-06-13 20:20:40 +00003497#ifdef OPENFILENAME_SIZE_VERSION_400
3498 /* be compatible with Windows NT 4.0 */
3499 /* TODO: what to use for OPENFILENAMEW??? */
Bram Moolenaar8c83ac32010-02-17 17:34:43 +01003500 fileStruct.lStructSize = OPENFILENAME_SIZE_VERSION_400;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003501#else
3502 fileStruct.lStructSize = sizeof(fileStruct);
3503#endif
3504
3505 if (title != NULL)
Bram Moolenaar36f692d2008-11-20 16:10:17 +00003506 titlep = enc_to_utf16(title, NULL);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003507 fileStruct.lpstrTitle = titlep;
3508
3509 if (ext != NULL)
Bram Moolenaar36f692d2008-11-20 16:10:17 +00003510 extp = enc_to_utf16(ext, NULL);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003511 fileStruct.lpstrDefExt = extp;
3512
3513 fileStruct.lpstrFile = fileBuf;
3514 fileStruct.nMaxFile = MAXPATHL;
3515 fileStruct.lpstrFilter = filterp;
3516 fileStruct.hwndOwner = s_hwnd; /* main Vim window is owner*/
3517 /* has an initial dir been specified? */
3518 if (initdir != NULL && *initdir != NUL)
3519 {
3520 /* Must have backslashes here, no matter what 'shellslash' says */
Bram Moolenaar36f692d2008-11-20 16:10:17 +00003521 initdirp = enc_to_utf16(initdir, NULL);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003522 if (initdirp != NULL)
3523 {
3524 for (wp = initdirp; *wp != NUL; ++wp)
3525 if (*wp == '/')
3526 *wp = '\\';
3527 }
3528 fileStruct.lpstrInitialDir = initdirp;
3529 }
3530
3531 /*
3532 * TODO: Allow selection of multiple files. Needs another arg to this
3533 * function to ask for it, and need to use OFN_ALLOWMULTISELECT below.
3534 * Also, should we use OFN_FILEMUSTEXIST when opening? Vim can edit on
3535 * files that don't exist yet, so I haven't put it in. What about
3536 * OFN_PATHMUSTEXIST?
3537 * Don't use OFN_OVERWRITEPROMPT, Vim has its own ":confirm" dialog.
3538 */
3539 fileStruct.Flags = (OFN_NOCHANGEDIR | OFN_PATHMUSTEXIST | OFN_HIDEREADONLY);
3540#ifdef FEAT_SHORTCUT
3541 if (curbuf->b_p_bin)
3542 fileStruct.Flags |= OFN_NODEREFERENCELINKS;
3543#endif
3544 if (saving)
3545 {
3546 if (!GetSaveFileNameW(&fileStruct))
3547 return NULL;
3548 }
3549 else
3550 {
3551 if (!GetOpenFileNameW(&fileStruct))
3552 return NULL;
3553 }
3554
3555 vim_free(filterp);
3556 vim_free(initdirp);
3557 vim_free(titlep);
3558 vim_free(extp);
3559
3560 /* Convert from UCS2 to 'encoding'. */
Bram Moolenaar36f692d2008-11-20 16:10:17 +00003561 p = utf16_to_enc(fileBuf, NULL);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003562 if (p != NULL)
3563 /* when out of memory we get garbage for non-ASCII chars */
3564 STRCPY(fileBuf, p);
3565 vim_free(p);
3566
3567 /* Give focus back to main window (when using MDI). */
3568 SetFocus(s_hwnd);
3569
3570 /* Shorten the file name if possible */
Bram Moolenaard089d9b2007-09-30 12:02:55 +00003571 return vim_strsave(shorten_fname1((char_u *)fileBuf));
Bram Moolenaar071d4272004-06-13 20:20:40 +00003572}
3573# endif /* FEAT_MBYTE */
3574
3575
3576/*
3577 * Convert the string s to the proper format for a filter string by replacing
Bram Moolenaar12806c82008-11-12 12:36:30 +00003578 * the \t and \n delimiters with \0.
Bram Moolenaar071d4272004-06-13 20:20:40 +00003579 * Returns the converted string in allocated memory.
3580 *
3581 * Keep in sync with convert_filterW() above!
3582 */
3583 static char_u *
3584convert_filter(char_u *s)
3585{
3586 char_u *res;
3587 unsigned s_len = (unsigned)STRLEN(s);
3588 unsigned i;
3589
3590 res = alloc(s_len + 3);
3591 if (res != NULL)
3592 {
3593 for (i = 0; i < s_len; ++i)
3594 if (s[i] == '\t' || s[i] == '\n')
3595 res[i] = '\0';
3596 else
3597 res[i] = s[i];
3598 res[s_len] = NUL;
3599 /* Add two extra NULs to make sure it's properly terminated. */
3600 res[s_len + 1] = NUL;
3601 res[s_len + 2] = NUL;
3602 }
3603 return res;
3604}
3605
3606/*
Bram Moolenaar7171abe2004-10-11 10:06:20 +00003607 * Select a directory.
3608 */
3609 char_u *
3610gui_mch_browsedir(char_u *title, char_u *initdir)
3611{
3612 /* We fake this: Use a filter that doesn't select anything and a default
3613 * file name that won't be used. */
3614 return gui_mch_browse(0, title, (char_u *)_("Not Used"), NULL,
3615 initdir, (char_u *)_("Directory\t*.nothing\n"));
3616}
3617
3618/*
Bram Moolenaar071d4272004-06-13 20:20:40 +00003619 * Pop open a file browser and return the file selected, in allocated memory,
3620 * or NULL if Cancel is hit.
3621 * saving - TRUE if the file will be saved to, FALSE if it will be opened.
3622 * title - Title message for the file browser dialog.
3623 * dflt - Default name of file.
3624 * ext - Default extension to be added to files without extensions.
3625 * initdir - directory in which to open the browser (NULL = current dir)
3626 * filter - Filter for matched files to choose from.
3627 *
3628 * Keep in sync with gui_mch_browseW() above!
3629 */
3630 char_u *
3631gui_mch_browse(
3632 int saving,
3633 char_u *title,
3634 char_u *dflt,
3635 char_u *ext,
3636 char_u *initdir,
3637 char_u *filter)
3638{
3639 OPENFILENAME fileStruct;
3640 char_u fileBuf[MAXPATHL];
3641 char_u *initdirp = NULL;
3642 char_u *filterp;
3643 char_u *p;
3644
3645# if defined(FEAT_MBYTE) && defined(WIN3264)
3646 if (os_version.dwPlatformId == VER_PLATFORM_WIN32_NT)
3647 return gui_mch_browseW(saving, title, dflt, ext, initdir, filter);
3648# endif
3649
3650 if (dflt == NULL)
3651 fileBuf[0] = NUL;
3652 else
Bram Moolenaarfe3ca8d2005-07-18 21:43:02 +00003653 vim_strncpy(fileBuf, dflt, MAXPATHL - 1);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003654
3655 /* Convert the filter to Windows format. */
3656 filterp = convert_filter(filter);
3657
Bram Moolenaar7db5fc82010-05-24 11:59:29 +02003658 vim_memset(&fileStruct, 0, sizeof(OPENFILENAME));
Bram Moolenaar071d4272004-06-13 20:20:40 +00003659#ifdef OPENFILENAME_SIZE_VERSION_400
3660 /* be compatible with Windows NT 4.0 */
Bram Moolenaar8c83ac32010-02-17 17:34:43 +01003661 fileStruct.lStructSize = OPENFILENAME_SIZE_VERSION_400;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003662#else
3663 fileStruct.lStructSize = sizeof(fileStruct);
3664#endif
3665
3666 fileStruct.lpstrTitle = title;
3667 fileStruct.lpstrDefExt = ext;
3668
3669 fileStruct.lpstrFile = fileBuf;
3670 fileStruct.nMaxFile = MAXPATHL;
3671 fileStruct.lpstrFilter = filterp;
3672 fileStruct.hwndOwner = s_hwnd; /* main Vim window is owner*/
3673 /* has an initial dir been specified? */
3674 if (initdir != NULL && *initdir != NUL)
3675 {
3676 /* Must have backslashes here, no matter what 'shellslash' says */
3677 initdirp = vim_strsave(initdir);
3678 if (initdirp != NULL)
3679 for (p = initdirp; *p != NUL; ++p)
3680 if (*p == '/')
3681 *p = '\\';
3682 fileStruct.lpstrInitialDir = initdirp;
3683 }
3684
3685 /*
3686 * TODO: Allow selection of multiple files. Needs another arg to this
3687 * function to ask for it, and need to use OFN_ALLOWMULTISELECT below.
3688 * Also, should we use OFN_FILEMUSTEXIST when opening? Vim can edit on
3689 * files that don't exist yet, so I haven't put it in. What about
3690 * OFN_PATHMUSTEXIST?
3691 * Don't use OFN_OVERWRITEPROMPT, Vim has its own ":confirm" dialog.
3692 */
3693 fileStruct.Flags = (OFN_NOCHANGEDIR | OFN_PATHMUSTEXIST | OFN_HIDEREADONLY);
3694#ifdef FEAT_SHORTCUT
3695 if (curbuf->b_p_bin)
3696 fileStruct.Flags |= OFN_NODEREFERENCELINKS;
3697#endif
3698 if (saving)
3699 {
3700 if (!GetSaveFileName(&fileStruct))
3701 return NULL;
3702 }
3703 else
3704 {
3705 if (!GetOpenFileName(&fileStruct))
3706 return NULL;
3707 }
3708
3709 vim_free(filterp);
3710 vim_free(initdirp);
3711
3712 /* Give focus back to main window (when using MDI). */
3713 SetFocus(s_hwnd);
3714
3715 /* Shorten the file name if possible */
Bram Moolenaard089d9b2007-09-30 12:02:55 +00003716 return vim_strsave(shorten_fname1((char_u *)fileBuf));
Bram Moolenaar071d4272004-06-13 20:20:40 +00003717}
3718#endif /* FEAT_BROWSE */
3719
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00003720/*ARGSUSED*/
Bram Moolenaar071d4272004-06-13 20:20:40 +00003721 static void
3722_OnDropFiles(
3723 HWND hwnd,
3724 HDROP hDrop)
3725{
3726#ifdef FEAT_WINDOWS
3727#ifdef WIN3264
3728# define BUFPATHLEN _MAX_PATH
3729# define DRAGQVAL 0xFFFFFFFF
3730#else
3731# define BUFPATHLEN MAXPATHL
3732# define DRAGQVAL 0xFFFF
3733#endif
3734#ifdef FEAT_MBYTE
3735 WCHAR wszFile[BUFPATHLEN];
3736#endif
3737 char szFile[BUFPATHLEN];
3738 UINT cFiles = DragQueryFile(hDrop, DRAGQVAL, NULL, 0);
3739 UINT i;
3740 char_u **fnames;
3741 POINT pt;
3742 int_u modifiers = 0;
3743
3744 /* TRACE("_OnDropFiles: %d files dropped\n", cFiles); */
3745
3746 /* Obtain dropped position */
3747 DragQueryPoint(hDrop, &pt);
3748 MapWindowPoints(s_hwnd, s_textArea, &pt, 1);
3749
Bram Moolenaar071d4272004-06-13 20:20:40 +00003750 reset_VIsual();
Bram Moolenaar071d4272004-06-13 20:20:40 +00003751
3752 fnames = (char_u **)alloc(cFiles * sizeof(char_u *));
3753
3754 if (fnames != NULL)
3755 for (i = 0; i < cFiles; ++i)
3756 {
3757#ifdef FEAT_MBYTE
3758 if (DragQueryFileW(hDrop, i, wszFile, BUFPATHLEN) > 0)
Bram Moolenaar36f692d2008-11-20 16:10:17 +00003759 fnames[i] = utf16_to_enc(wszFile, NULL);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003760 else
3761#endif
3762 {
3763 DragQueryFile(hDrop, i, szFile, BUFPATHLEN);
3764 fnames[i] = vim_strsave(szFile);
3765 }
3766 }
3767
3768 DragFinish(hDrop);
3769
3770 if (fnames != NULL)
3771 {
3772 if ((GetKeyState(VK_SHIFT) & 0x8000) != 0)
3773 modifiers |= MOUSE_SHIFT;
3774 if ((GetKeyState(VK_CONTROL) & 0x8000) != 0)
3775 modifiers |= MOUSE_CTRL;
3776 if ((GetKeyState(VK_MENU) & 0x8000) != 0)
3777 modifiers |= MOUSE_ALT;
3778
3779 gui_handle_drop(pt.x, pt.y, modifiers, fnames, cFiles);
3780
3781 s_need_activate = TRUE;
3782 }
3783#endif
3784}
3785
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00003786/*ARGSUSED*/
Bram Moolenaar071d4272004-06-13 20:20:40 +00003787 static int
3788_OnScroll(
3789 HWND hwnd,
3790 HWND hwndCtl,
3791 UINT code,
3792 int pos)
3793{
3794 static UINT prev_code = 0; /* code of previous call */
3795 scrollbar_T *sb, *sb_info;
3796 long val;
3797 int dragging = FALSE;
3798 int dont_scroll_save = dont_scroll;
3799#ifndef WIN3264
3800 int nPos;
3801#else
3802 SCROLLINFO si;
3803
3804 si.cbSize = sizeof(si);
3805 si.fMask = SIF_POS;
3806#endif
3807
3808 sb = gui_mswin_find_scrollbar(hwndCtl);
3809 if (sb == NULL)
3810 return 0;
3811
3812 if (sb->wp != NULL) /* Left or right scrollbar */
3813 {
3814 /*
3815 * Careful: need to get scrollbar info out of first (left) scrollbar
3816 * for window, but keep real scrollbar too because we must pass it to
3817 * gui_drag_scrollbar().
3818 */
3819 sb_info = &sb->wp->w_scrollbars[0];
3820 }
3821 else /* Bottom scrollbar */
3822 sb_info = sb;
3823 val = sb_info->value;
3824
3825 switch (code)
3826 {
3827 case SB_THUMBTRACK:
3828 val = pos;
3829 dragging = TRUE;
3830 if (sb->scroll_shift > 0)
3831 val <<= sb->scroll_shift;
3832 break;
3833 case SB_LINEDOWN:
3834 val++;
3835 break;
3836 case SB_LINEUP:
3837 val--;
3838 break;
3839 case SB_PAGEDOWN:
3840 val += (sb_info->size > 2 ? sb_info->size - 2 : 1);
3841 break;
3842 case SB_PAGEUP:
3843 val -= (sb_info->size > 2 ? sb_info->size - 2 : 1);
3844 break;
3845 case SB_TOP:
3846 val = 0;
3847 break;
3848 case SB_BOTTOM:
3849 val = sb_info->max;
3850 break;
3851 case SB_ENDSCROLL:
3852 if (prev_code == SB_THUMBTRACK)
3853 {
3854 /*
3855 * "pos" only gives us 16-bit data. In case of large file,
3856 * use GetScrollPos() which returns 32-bit. Unfortunately it
3857 * is not valid while the scrollbar is being dragged.
3858 */
3859 val = GetScrollPos(hwndCtl, SB_CTL);
3860 if (sb->scroll_shift > 0)
3861 val <<= sb->scroll_shift;
3862 }
3863 break;
3864
3865 default:
3866 /* TRACE("Unknown scrollbar event %d\n", code); */
3867 return 0;
3868 }
3869 prev_code = code;
3870
3871#ifdef WIN3264
3872 si.nPos = (sb->scroll_shift > 0) ? val >> sb->scroll_shift : val;
3873 SetScrollInfo(hwndCtl, SB_CTL, &si, TRUE);
3874#else
3875 nPos = (sb->scroll_shift > 0) ? val >> sb->scroll_shift : val;
3876 SetScrollPos(hwndCtl, SB_CTL, nPos, TRUE);
3877#endif
3878
3879 /*
3880 * When moving a vertical scrollbar, move the other vertical scrollbar too.
3881 */
3882 if (sb->wp != NULL)
3883 {
3884 scrollbar_T *sba = sb->wp->w_scrollbars;
3885 HWND id = sba[ (sb == sba + SBAR_LEFT) ? SBAR_RIGHT : SBAR_LEFT].id;
3886
3887#ifdef WIN3264
3888 SetScrollInfo(id, SB_CTL, &si, TRUE);
3889#else
3890 SetScrollPos(id, SB_CTL, nPos, TRUE);
3891#endif
3892 }
3893
3894 /* Don't let us be interrupted here by another message. */
3895 s_busy_processing = TRUE;
3896
3897 /* When "allow_scrollbar" is FALSE still need to remember the new
3898 * position, but don't actually scroll by setting "dont_scroll". */
3899 dont_scroll = !allow_scrollbar;
3900
3901 gui_drag_scrollbar(sb, val, dragging);
3902
3903 s_busy_processing = FALSE;
3904 dont_scroll = dont_scroll_save;
3905
3906 return 0;
3907}
3908
Bram Moolenaar3fdfa4a2004-10-07 21:02:47 +00003909
Bram Moolenaar071d4272004-06-13 20:20:40 +00003910/*
3911 * Get command line arguments.
3912 * Use "prog" as the name of the program and "cmdline" as the arguments.
3913 * Copy the arguments to allocated memory.
3914 * Return the number of arguments (including program name).
Bram Moolenaar12806c82008-11-12 12:36:30 +00003915 * Return pointers to the arguments in "argvp". Memory is allocated with
3916 * malloc(), use free() instead of vim_free().
Bram Moolenaar071d4272004-06-13 20:20:40 +00003917 * Return pointer to buffer in "tofree".
3918 * Returns zero when out of memory.
3919 */
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00003920/*ARGSUSED*/
Bram Moolenaar071d4272004-06-13 20:20:40 +00003921 int
3922get_cmd_args(char *prog, char *cmdline, char ***argvp, char **tofree)
3923{
3924 int i;
3925 char *p;
3926 char *progp;
3927 char *pnew = NULL;
3928 char *newcmdline;
3929 int inquote;
3930 int argc;
3931 char **argv = NULL;
3932 int round;
3933
Bram Moolenaar12806c82008-11-12 12:36:30 +00003934 *tofree = NULL;
3935
Bram Moolenaar3fdfa4a2004-10-07 21:02:47 +00003936#ifdef FEAT_MBYTE
3937 /* Try using the Unicode version first, it takes care of conversion when
3938 * 'encoding' is changed. */
3939 argc = get_cmd_argsW(&argv);
3940 if (argc != 0)
3941 goto done;
3942#endif
3943
Bram Moolenaar071d4272004-06-13 20:20:40 +00003944 /* Handle the program name. Remove the ".exe" extension, and find the 1st
3945 * non-space. */
3946 p = strrchr(prog, '.');
3947 if (p != NULL)
3948 *p = NUL;
3949 for (progp = prog; *progp == ' '; ++progp)
3950 ;
3951
3952 /* The command line is copied to allocated memory, so that we can change
3953 * it. Add the size of the string, the separating NUL and a terminating
3954 * NUL. */
3955 newcmdline = malloc(STRLEN(cmdline) + STRLEN(progp) + 2);
3956 if (newcmdline == NULL)
3957 return 0;
3958
3959 /*
3960 * First round: count the number of arguments ("pnew" == NULL).
3961 * Second round: produce the arguments.
3962 */
3963 for (round = 1; round <= 2; ++round)
3964 {
3965 /* First argument is the program name. */
3966 if (pnew != NULL)
3967 {
3968 argv[0] = pnew;
3969 strcpy(pnew, progp);
3970 pnew += strlen(pnew);
3971 *pnew++ = NUL;
3972 }
3973
3974 /*
3975 * Isolate each argument and put it in argv[].
3976 */
3977 p = cmdline;
3978 argc = 1;
3979 while (*p != NUL)
3980 {
3981 inquote = FALSE;
3982 if (pnew != NULL)
3983 argv[argc] = pnew;
3984 ++argc;
3985 while (*p != NUL && (inquote || (*p != ' ' && *p != '\t')))
3986 {
3987 /* Backslashes are only special when followed by a double
3988 * quote. */
Bram Moolenaara93fa7e2006-04-17 22:14:47 +00003989 i = (int)strspn(p, "\\");
Bram Moolenaar071d4272004-06-13 20:20:40 +00003990 if (p[i] == '"')
3991 {
3992 /* Halve the number of backslashes. */
3993 if (i > 1 && pnew != NULL)
3994 {
Bram Moolenaar7db5fc82010-05-24 11:59:29 +02003995 vim_memset(pnew, '\\', i / 2);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003996 pnew += i / 2;
3997 }
3998
3999 /* Even nr of backslashes toggles quoting, uneven copies
4000 * the double quote. */
4001 if ((i & 1) == 0)
4002 inquote = !inquote;
4003 else if (pnew != NULL)
4004 *pnew++ = '"';
4005 p += i + 1;
4006 }
4007 else if (i > 0)
4008 {
4009 /* Copy span of backslashes unmodified. */
4010 if (pnew != NULL)
4011 {
Bram Moolenaar7db5fc82010-05-24 11:59:29 +02004012 vim_memset(pnew, '\\', i);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004013 pnew += i;
4014 }
4015 p += i;
4016 }
4017 else
4018 {
4019 if (pnew != NULL)
4020 *pnew++ = *p;
Bram Moolenaar15d0a8c2004-09-06 17:44:46 +00004021#ifdef FEAT_MBYTE
4022 /* Can't use mb_* functions, because 'encoding' is not
4023 * initialized yet here. */
4024 if (IsDBCSLeadByte(*p))
4025 {
4026 ++p;
4027 if (pnew != NULL)
4028 *pnew++ = *p;
4029 }
4030#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00004031 ++p;
4032 }
4033 }
4034
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00004035 if (pnew != NULL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004036 *pnew++ = NUL;
4037 while (*p == ' ' || *p == '\t')
4038 ++p; /* advance until a non-space */
4039 }
4040
4041 if (round == 1)
4042 {
4043 argv = (char **)malloc((argc + 1) * sizeof(char *));
4044 if (argv == NULL )
Bram Moolenaare6b165e2005-06-30 21:56:01 +00004045 {
Bram Moolenaar12806c82008-11-12 12:36:30 +00004046 free(newcmdline);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004047 return 0; /* malloc error */
Bram Moolenaare6b165e2005-06-30 21:56:01 +00004048 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00004049 pnew = newcmdline;
Bram Moolenaar12806c82008-11-12 12:36:30 +00004050 *tofree = newcmdline;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004051 }
4052 }
4053
Bram Moolenaar8765a4a2010-07-27 22:41:43 +02004054#ifdef FEAT_MBYTE
Bram Moolenaar3fdfa4a2004-10-07 21:02:47 +00004055done:
Bram Moolenaar8765a4a2010-07-27 22:41:43 +02004056#endif
Bram Moolenaar3fdfa4a2004-10-07 21:02:47 +00004057 argv[argc] = NULL; /* NULL-terminated list */
Bram Moolenaar071d4272004-06-13 20:20:40 +00004058 *argvp = argv;
4059 return argc;
4060}