blob: f4473f62c82d20adcd39525dc82c278a3f4687e6 [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 Moolenaar85a3e5c2007-11-20 16:22:16 +0000617 len = char_to_string(ch, string, 40, FALSE);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000618 if (len == 1 && string[0] == Ctrl_C && ctrl_c_interrupts)
619 {
620 trash_input_buf();
621 got_int = TRUE;
622 }
623
624 add_to_input_buf(string, len);
625}
626
627/*
628 * Alt-Key hit, add it to the input buffer.
629 */
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +0000630/*ARGSUSED*/
Bram Moolenaar071d4272004-06-13 20:20:40 +0000631 static void
632_OnSysChar(
633 HWND hwnd,
634 UINT cch,
635 int cRepeat)
636{
637 char_u string[40]; /* Enough for multibyte character */
638 int len;
639 int modifiers;
640 int ch = cch; /* special keys are negative */
641
642 /* TRACE("OnSysChar(%d, %c)\n", ch, ch); */
643
644 /* OK, we have a character key (given by ch) which was entered with the
645 * ALT key pressed. Eg, if the user presses Alt-A, then ch == 'A'. Note
646 * that the system distinguishes Alt-a and Alt-A (Alt-Shift-a unless
647 * CAPSLOCK is pressed) at this point.
648 */
649 modifiers = MOD_MASK_ALT;
650 if (GetKeyState(VK_SHIFT) & 0x8000)
651 modifiers |= MOD_MASK_SHIFT;
652 if (GetKeyState(VK_CONTROL) & 0x8000)
653 modifiers |= MOD_MASK_CTRL;
654
655 ch = simplify_key(ch, &modifiers);
656 /* remove the SHIFT modifier for keys where it's already included, e.g.,
657 * '(' and '*' */
658 if (ch < 0x100 && !isalpha(ch) && isprint(ch))
659 modifiers &= ~MOD_MASK_SHIFT;
660
661 /* Interpret the ALT key as making the key META, include SHIFT, etc. */
662 ch = extract_modifiers(ch, &modifiers);
663 if (ch == CSI)
664 ch = K_CSI;
665
666 len = 0;
667 if (modifiers)
668 {
669 string[len++] = CSI;
670 string[len++] = KS_MODIFIER;
671 string[len++] = modifiers;
672 }
673
674 if (IS_SPECIAL((int)ch))
675 {
676 string[len++] = CSI;
677 string[len++] = K_SECOND((int)ch);
678 string[len++] = K_THIRD((int)ch);
679 }
680 else
681 {
682 /* Although the documentation isn't clear about it, we assume "ch" is
683 * a Unicode character. */
Bram Moolenaar85a3e5c2007-11-20 16:22:16 +0000684 len += char_to_string(ch, string + len, 40 - len, TRUE);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000685 }
686
687 add_to_input_buf(string, len);
688}
689
690 static void
691_OnMouseEvent(
692 int button,
693 int x,
694 int y,
695 int repeated_click,
696 UINT keyFlags)
697{
698 int vim_modifiers = 0x0;
699
Bram Moolenaarea408882007-12-03 21:21:03 +0000700 s_getting_focus = FALSE;
701
Bram Moolenaar071d4272004-06-13 20:20:40 +0000702 if (keyFlags & MK_SHIFT)
703 vim_modifiers |= MOUSE_SHIFT;
704 if (keyFlags & MK_CONTROL)
705 vim_modifiers |= MOUSE_CTRL;
706 if (GetKeyState(VK_MENU) & 0x8000)
707 vim_modifiers |= MOUSE_ALT;
708
709 gui_send_mouse_event(button, x, y, repeated_click, vim_modifiers);
710}
711
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +0000712/*ARGSUSED*/
Bram Moolenaar071d4272004-06-13 20:20:40 +0000713 static void
714_OnMouseButtonDown(
715 HWND hwnd,
716 BOOL fDoubleClick,
717 int x,
718 int y,
719 UINT keyFlags)
720{
721 static LONG s_prevTime = 0;
722
723 LONG currentTime = GetMessageTime();
724 int button = -1;
725 int repeated_click;
726
727 /* Give main window the focus: this is so the cursor isn't hollow. */
728 (void)SetFocus(s_hwnd);
729
730 if (s_uMsg == WM_LBUTTONDOWN || s_uMsg == WM_LBUTTONDBLCLK)
731 button = MOUSE_LEFT;
732 else if (s_uMsg == WM_MBUTTONDOWN || s_uMsg == WM_MBUTTONDBLCLK)
733 button = MOUSE_MIDDLE;
734 else if (s_uMsg == WM_RBUTTONDOWN || s_uMsg == WM_RBUTTONDBLCLK)
735 button = MOUSE_RIGHT;
736#ifndef WIN16 /*<VN>*/
737 else if (s_uMsg == WM_XBUTTONDOWN || s_uMsg == WM_XBUTTONDBLCLK)
738 {
739#ifndef GET_XBUTTON_WPARAM
740# define GET_XBUTTON_WPARAM(wParam) (HIWORD(wParam))
741#endif
742 button = ((GET_XBUTTON_WPARAM(s_wParam) == 1) ? MOUSE_X1 : MOUSE_X2);
743 }
744 else if (s_uMsg == WM_CAPTURECHANGED)
745 {
746 /* on W95/NT4, somehow you get in here with an odd Msg
747 * if you press one button while holding down the other..*/
748 if (s_button_pending == MOUSE_LEFT)
749 button = MOUSE_RIGHT;
750 else
751 button = MOUSE_LEFT;
752 }
753#endif
754 if (button >= 0)
755 {
756 repeated_click = ((int)(currentTime - s_prevTime) < p_mouset);
757
758 /*
759 * Holding down the left and right buttons simulates pushing the middle
760 * button.
761 */
Bram Moolenaar293ee4d2004-12-09 21:34:53 +0000762 if (repeated_click
763 && ((button == MOUSE_LEFT && s_button_pending == MOUSE_RIGHT)
764 || (button == MOUSE_RIGHT
765 && s_button_pending == MOUSE_LEFT)))
Bram Moolenaar071d4272004-06-13 20:20:40 +0000766 {
767 /*
768 * Hmm, gui.c will ignore more than one button down at a time, so
769 * pretend we let go of it first.
770 */
771 gui_send_mouse_event(MOUSE_RELEASE, x, y, FALSE, 0x0);
772 button = MOUSE_MIDDLE;
773 repeated_click = FALSE;
774 s_button_pending = -1;
775 _OnMouseEvent(button, x, y, repeated_click, keyFlags);
776 }
777 else if ((repeated_click)
778 || (mouse_model_popup() && (button == MOUSE_RIGHT)))
779 {
780 if (s_button_pending > -1)
781 {
782 _OnMouseEvent(s_button_pending, x, y, FALSE, keyFlags);
783 s_button_pending = -1;
784 }
785 /* TRACE("Button down at x %d, y %d\n", x, y); */
786 _OnMouseEvent(button, x, y, repeated_click, keyFlags);
787 }
788 else
789 {
790 /*
791 * If this is the first press (i.e. not a multiple click) don't
792 * action immediately, but store and wait for:
793 * i) button-up
794 * ii) mouse move
795 * iii) another button press
796 * before using it.
797 * This enables us to make left+right simulate middle button,
798 * without left or right being actioned first. The side-effect is
799 * that if you click and hold the mouse without dragging, the
800 * cursor doesn't move until you release the button. In practice
801 * this is hardly a problem.
802 */
803 s_button_pending = button;
804 s_x_pending = x;
805 s_y_pending = y;
806 s_kFlags_pending = keyFlags;
807 }
808
809 s_prevTime = currentTime;
810 }
811}
812
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +0000813/*ARGSUSED*/
Bram Moolenaar071d4272004-06-13 20:20:40 +0000814 static void
815_OnMouseMoveOrRelease(
816 HWND hwnd,
817 int x,
818 int y,
819 UINT keyFlags)
820{
821 int button;
822
Bram Moolenaarea408882007-12-03 21:21:03 +0000823 s_getting_focus = FALSE;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000824 if (s_button_pending > -1)
825 {
826 /* Delayed action for mouse down event */
827 _OnMouseEvent(s_button_pending, s_x_pending,
Bram Moolenaar293ee4d2004-12-09 21:34:53 +0000828 s_y_pending, FALSE, s_kFlags_pending);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000829 s_button_pending = -1;
830 }
831 if (s_uMsg == WM_MOUSEMOVE)
832 {
833 /*
834 * It's only a MOUSE_DRAG if one or more mouse buttons are being held
835 * down.
836 */
837 if (!(keyFlags & (MK_LBUTTON | MK_MBUTTON | MK_RBUTTON
838 | MK_XBUTTON1 | MK_XBUTTON2)))
839 {
840 gui_mouse_moved(x, y);
841 return;
842 }
843
844 /*
845 * While button is down, keep grabbing mouse move events when
846 * the mouse goes outside the window
847 */
848 SetCapture(s_textArea);
849 button = MOUSE_DRAG;
850 /* TRACE(" move at x %d, y %d\n", x, y); */
851 }
852 else
853 {
854 ReleaseCapture();
855 button = MOUSE_RELEASE;
856 /* TRACE(" up at x %d, y %d\n", x, y); */
857 }
858
859 _OnMouseEvent(button, x, y, FALSE, keyFlags);
860}
861
862#ifdef FEAT_MENU
863/*
864 * Find the vimmenu_T with the given id
865 */
866 static vimmenu_T *
867gui_mswin_find_menu(
868 vimmenu_T *pMenu,
869 int id)
870{
871 vimmenu_T *pChildMenu;
872
873 while (pMenu)
874 {
875 if (pMenu->id == (UINT)id)
876 break;
877 if (pMenu->children != NULL)
878 {
879 pChildMenu = gui_mswin_find_menu(pMenu->children, id);
880 if (pChildMenu)
881 {
882 pMenu = pChildMenu;
883 break;
884 }
885 }
886 pMenu = pMenu->next;
887 }
888 return pMenu;
889}
890
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +0000891/*ARGSUSED*/
Bram Moolenaar071d4272004-06-13 20:20:40 +0000892 static void
893_OnMenu(
894 HWND hwnd,
895 int id,
896 HWND hwndCtl,
897 UINT codeNotify)
898{
899 vimmenu_T *pMenu;
900
901 pMenu = gui_mswin_find_menu(root_menu, id);
902 if (pMenu)
903 gui_menu_cb(pMenu);
904}
905#endif
906
907#ifdef MSWIN_FIND_REPLACE
Bram Moolenaar3ca9a8a2009-01-28 20:23:17 +0000908# if defined(FEAT_MBYTE) && defined(WIN3264)
909/*
910 * copy useful data from structure LPFINDREPLACE to structure LPFINDREPLACEW
911 */
912 static void
913findrep_atow(LPFINDREPLACEW lpfrw, LPFINDREPLACE lpfr)
914{
915 WCHAR *wp;
916
917 lpfrw->hwndOwner = lpfr->hwndOwner;
918 lpfrw->Flags = lpfr->Flags;
919
920 wp = enc_to_utf16(lpfr->lpstrFindWhat, NULL);
921 wcsncpy(lpfrw->lpstrFindWhat, wp, lpfrw->wFindWhatLen - 1);
922 vim_free(wp);
923
924 /* the field "lpstrReplaceWith" doesn't need to be copied */
925}
926
927/*
928 * copy useful data from structure LPFINDREPLACEW to structure LPFINDREPLACE
929 */
930 static void
931findrep_wtoa(LPFINDREPLACE lpfr, LPFINDREPLACEW lpfrw)
932{
933 char_u *p;
934
935 lpfr->Flags = lpfrw->Flags;
936
937 p = utf16_to_enc(lpfrw->lpstrFindWhat, NULL);
938 vim_strncpy(lpfr->lpstrFindWhat, p, lpfr->wFindWhatLen - 1);
939 vim_free(p);
940
941 p = utf16_to_enc(lpfrw->lpstrReplaceWith, NULL);
942 vim_strncpy(lpfr->lpstrReplaceWith, p, lpfr->wReplaceWithLen - 1);
943 vim_free(p);
944}
945# endif
946
Bram Moolenaar071d4272004-06-13 20:20:40 +0000947/*
948 * Handle a Find/Replace window message.
949 */
950 static void
951_OnFindRepl(void)
952{
953 int flags = 0;
954 int down;
955
Bram Moolenaar3ca9a8a2009-01-28 20:23:17 +0000956# if defined(FEAT_MBYTE) && defined(WIN3264)
957 /* If the OS is Windows NT, and 'encoding' differs from active codepage:
958 * convert text from wide string. */
959 if (os_version.dwPlatformId == VER_PLATFORM_WIN32_NT
960 && enc_codepage >= 0 && (int)GetACP() != enc_codepage)
961 {
Bram Moolenaarcc448b32010-07-14 16:52:17 +0200962 findrep_wtoa(&s_findrep_struct, &s_findrep_struct_w);
Bram Moolenaar3ca9a8a2009-01-28 20:23:17 +0000963 }
964# endif
965
Bram Moolenaar071d4272004-06-13 20:20:40 +0000966 if (s_findrep_struct.Flags & FR_DIALOGTERM)
967 /* Give main window the focus back. */
968 (void)SetFocus(s_hwnd);
969
970 if (s_findrep_struct.Flags & FR_FINDNEXT)
971 {
972 flags = FRD_FINDNEXT;
973
974 /* Give main window the focus back: this is so the cursor isn't
975 * hollow. */
976 (void)SetFocus(s_hwnd);
977 }
978 else if (s_findrep_struct.Flags & FR_REPLACE)
979 {
980 flags = FRD_REPLACE;
981
982 /* Give main window the focus back: this is so the cursor isn't
983 * hollow. */
984 (void)SetFocus(s_hwnd);
985 }
986 else if (s_findrep_struct.Flags & FR_REPLACEALL)
987 {
988 flags = FRD_REPLACEALL;
989 }
990
991 if (flags != 0)
992 {
993 /* Call the generic GUI function to do the actual work. */
994 if (s_findrep_struct.Flags & FR_WHOLEWORD)
995 flags |= FRD_WHOLE_WORD;
996 if (s_findrep_struct.Flags & FR_MATCHCASE)
997 flags |= FRD_MATCH_CASE;
998 down = (s_findrep_struct.Flags & FR_DOWN) != 0;
999 gui_do_findrepl(flags, s_findrep_struct.lpstrFindWhat,
1000 s_findrep_struct.lpstrReplaceWith, down);
1001 }
1002}
1003#endif
1004
1005 static void
1006HandleMouseHide(UINT uMsg, LPARAM lParam)
1007{
1008 static LPARAM last_lParam = 0L;
1009
1010 /* We sometimes get a mousemove when the mouse didn't move... */
Bram Moolenaar268b55b2013-09-22 15:43:37 +02001011 if (uMsg == WM_MOUSEMOVE || uMsg == WM_NCMOUSEMOVE)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001012 {
1013 if (lParam == last_lParam)
1014 return;
1015 last_lParam = lParam;
1016 }
1017
1018 /* Handle specially, to centralise coding. We need to be sure we catch all
1019 * possible events which should cause us to restore the cursor (as it is a
1020 * shared resource, we take full responsibility for it).
1021 */
1022 switch (uMsg)
1023 {
1024 case WM_KEYUP:
1025 case WM_CHAR:
1026 /*
1027 * blank out the pointer if necessary
1028 */
1029 if (p_mh)
1030 gui_mch_mousehide(TRUE);
1031 break;
1032
1033 case WM_SYSKEYUP: /* show the pointer when a system-key is pressed */
1034 case WM_SYSCHAR:
1035 case WM_MOUSEMOVE: /* show the pointer on any mouse action */
1036 case WM_LBUTTONDOWN:
1037 case WM_LBUTTONUP:
1038 case WM_MBUTTONDOWN:
1039 case WM_MBUTTONUP:
1040 case WM_RBUTTONDOWN:
1041 case WM_RBUTTONUP:
1042 case WM_XBUTTONDOWN:
1043 case WM_XBUTTONUP:
1044 case WM_NCMOUSEMOVE:
1045 case WM_NCLBUTTONDOWN:
1046 case WM_NCLBUTTONUP:
1047 case WM_NCMBUTTONDOWN:
1048 case WM_NCMBUTTONUP:
1049 case WM_NCRBUTTONDOWN:
1050 case WM_NCRBUTTONUP:
1051 case WM_KILLFOCUS:
1052 /*
1053 * if the pointer is currently hidden, then we should show it.
1054 */
1055 gui_mch_mousehide(FALSE);
1056 break;
1057 }
1058}
1059
1060 static LRESULT CALLBACK
1061_TextAreaWndProc(
1062 HWND hwnd,
1063 UINT uMsg,
1064 WPARAM wParam,
1065 LPARAM lParam)
1066{
1067 /*
1068 TRACE("TextAreaWndProc: hwnd = %08x, msg = %x, wParam = %x, lParam = %x\n",
1069 hwnd, uMsg, wParam, lParam);
1070 */
1071
1072 HandleMouseHide(uMsg, lParam);
1073
1074 s_uMsg = uMsg;
1075 s_wParam = wParam;
1076 s_lParam = lParam;
1077
1078#ifdef FEAT_BEVAL
1079 TrackUserActivity(uMsg);
1080#endif
1081
1082 switch (uMsg)
1083 {
1084 HANDLE_MSG(hwnd, WM_LBUTTONDBLCLK,_OnMouseButtonDown);
1085 HANDLE_MSG(hwnd, WM_LBUTTONDOWN,_OnMouseButtonDown);
1086 HANDLE_MSG(hwnd, WM_LBUTTONUP, _OnMouseMoveOrRelease);
1087 HANDLE_MSG(hwnd, WM_MBUTTONDBLCLK,_OnMouseButtonDown);
1088 HANDLE_MSG(hwnd, WM_MBUTTONDOWN,_OnMouseButtonDown);
1089 HANDLE_MSG(hwnd, WM_MBUTTONUP, _OnMouseMoveOrRelease);
1090 HANDLE_MSG(hwnd, WM_MOUSEMOVE, _OnMouseMoveOrRelease);
1091 HANDLE_MSG(hwnd, WM_PAINT, _OnPaint);
1092 HANDLE_MSG(hwnd, WM_RBUTTONDBLCLK,_OnMouseButtonDown);
1093 HANDLE_MSG(hwnd, WM_RBUTTONDOWN,_OnMouseButtonDown);
1094 HANDLE_MSG(hwnd, WM_RBUTTONUP, _OnMouseMoveOrRelease);
1095#ifndef WIN16 /*<VN>*/
1096 HANDLE_MSG(hwnd, WM_XBUTTONDBLCLK,_OnMouseButtonDown);
1097 HANDLE_MSG(hwnd, WM_XBUTTONDOWN,_OnMouseButtonDown);
1098 HANDLE_MSG(hwnd, WM_XBUTTONUP, _OnMouseMoveOrRelease);
1099#endif
1100
1101#ifdef FEAT_BEVAL
1102 case WM_NOTIFY: Handle_WM_Notify(hwnd, (LPNMHDR)lParam);
1103 return TRUE;
1104#endif
Bram Moolenaar4d526ad2010-02-03 12:23:24 +01001105 default:
1106 return MyWindowProc(hwnd, uMsg, wParam, lParam);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001107 }
1108}
1109
1110#if (defined(WIN3264) && defined(FEAT_MBYTE)) \
1111 || defined(GLOBAL_IME) \
1112 || defined(PROTO)
1113# ifdef PROTO
1114typedef int WINAPI;
1115# endif
1116
1117 LRESULT WINAPI
1118vim_WindowProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
1119{
1120# ifdef GLOBAL_IME
1121 return global_ime_DefWindowProc(hwnd, message, wParam, lParam);
1122# else
1123 if (wide_WindowProc)
1124 return DefWindowProcW(hwnd, message, wParam, lParam);
1125 return DefWindowProc(hwnd, message, wParam, lParam);
1126#endif
1127}
1128#endif
1129
1130/*
1131 * Called when the foreground or background color has been changed.
1132 */
1133 void
1134gui_mch_new_colors(void)
1135{
1136 /* nothing to do? */
1137}
1138
1139/*
1140 * Set the colors to their default values.
1141 */
1142 void
1143gui_mch_def_colors()
1144{
1145 gui.norm_pixel = GetSysColor(COLOR_WINDOWTEXT);
1146 gui.back_pixel = GetSysColor(COLOR_WINDOW);
1147 gui.def_norm_pixel = gui.norm_pixel;
1148 gui.def_back_pixel = gui.back_pixel;
1149}
1150
1151/*
1152 * Open the GUI window which was created by a call to gui_mch_init().
1153 */
1154 int
1155gui_mch_open(void)
1156{
1157#ifndef SW_SHOWDEFAULT
1158# define SW_SHOWDEFAULT 10 /* Borland 5.0 doesn't have it */
1159#endif
1160 /* Actually open the window, if not already visible
1161 * (may be done already in gui_mch_set_shellsize) */
1162 if (!IsWindowVisible(s_hwnd))
1163 ShowWindow(s_hwnd, SW_SHOWDEFAULT);
1164
Bram Moolenaare2f98b92006-03-29 21:18:24 +00001165#ifdef MSWIN_FIND_REPLACE
1166 /* Init replace string here, so that we keep it when re-opening the
1167 * dialog. */
1168 s_findrep_struct.lpstrReplaceWith[0] = NUL;
1169#endif
1170
Bram Moolenaar071d4272004-06-13 20:20:40 +00001171 return OK;
1172}
1173
1174/*
1175 * Get the position of the top left corner of the window.
1176 */
1177 int
1178gui_mch_get_winpos(int *x, int *y)
1179{
1180 RECT rect;
1181
1182 GetWindowRect(s_hwnd, &rect);
1183 *x = rect.left;
1184 *y = rect.top;
1185 return OK;
1186}
1187
1188/*
1189 * Set the position of the top left corner of the window to the given
1190 * coordinates.
1191 */
1192 void
1193gui_mch_set_winpos(int x, int y)
1194{
1195 SetWindowPos(s_hwnd, NULL, x, y, 0, 0,
1196 SWP_NOZORDER | SWP_NOSIZE | SWP_NOACTIVATE);
1197}
1198 void
1199gui_mch_set_text_area_pos(int x, int y, int w, int h)
1200{
1201 static int oldx = 0;
1202 static int oldy = 0;
1203
1204 SetWindowPos(s_textArea, NULL, x, y, w, h, SWP_NOZORDER | SWP_NOACTIVATE);
1205
1206#ifdef FEAT_TOOLBAR
1207 if (vim_strchr(p_go, GO_TOOLBAR) != NULL)
1208 SendMessage(s_toolbarhwnd, WM_SIZE,
Bram Moolenaar5555acc2006-04-07 21:33:12 +00001209 (WPARAM)0, (LPARAM)(w + ((long)(TOOLBAR_BUTTON_HEIGHT+8)<<16)));
Bram Moolenaar071d4272004-06-13 20:20:40 +00001210#endif
Bram Moolenaar3991dab2006-03-27 17:01:56 +00001211#if defined(FEAT_GUI_TABLINE)
1212 if (showing_tabline)
1213 {
Bram Moolenaar2e2a2812006-03-27 20:55:21 +00001214 int top = 0;
Bram Moolenaarc6fe9192006-04-09 21:54:49 +00001215 RECT rect;
Bram Moolenaar3991dab2006-03-27 17:01:56 +00001216
Bram Moolenaar551dbcc2006-04-25 22:13:59 +00001217# ifdef FEAT_TOOLBAR
Bram Moolenaar3991dab2006-03-27 17:01:56 +00001218 if (vim_strchr(p_go, GO_TOOLBAR) != NULL)
1219 top = TOOLBAR_BUTTON_HEIGHT + TOOLBAR_BORDER_HEIGHT;
Bram Moolenaar551dbcc2006-04-25 22:13:59 +00001220# endif
Bram Moolenaar5555acc2006-04-07 21:33:12 +00001221 GetClientRect(s_hwnd, &rect);
Bram Moolenaar551dbcc2006-04-25 22:13:59 +00001222 MoveWindow(s_tabhwnd, 0, top, rect.right, gui.tabline_height, TRUE);
Bram Moolenaar3991dab2006-03-27 17:01:56 +00001223 }
1224#endif
1225
Bram Moolenaar071d4272004-06-13 20:20:40 +00001226 /* When side scroll bar is unshown, the size of window will change.
1227 * then, the text area move left or right. thus client rect should be
Bram Moolenaar84a05ac2013-05-06 04:24:17 +02001228 * forcedly redrawn. (Yasuhiro Matsumoto) */
Bram Moolenaar071d4272004-06-13 20:20:40 +00001229 if (oldx != x || oldy != y)
1230 {
1231 InvalidateRect(s_hwnd, NULL, FALSE);
1232 oldx = x;
1233 oldy = y;
1234 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00001235}
1236
1237
1238/*
1239 * Scrollbar stuff:
1240 */
1241
1242 void
1243gui_mch_enable_scrollbar(
1244 scrollbar_T *sb,
1245 int flag)
1246{
1247 ShowScrollBar(sb->id, SB_CTL, flag);
1248
1249 /* TODO: When the window is maximized, the size of the window stays the
1250 * same, thus the size of the text area changes. On Win98 it's OK, on Win
1251 * NT 4.0 it's not... */
1252}
1253
1254 void
1255gui_mch_set_scrollbar_pos(
1256 scrollbar_T *sb,
1257 int x,
1258 int y,
1259 int w,
1260 int h)
1261{
Bram Moolenaar02743632005-07-25 20:42:36 +00001262 SetWindowPos(sb->id, NULL, x, y, w, h,
1263 SWP_NOZORDER | SWP_NOACTIVATE | SWP_SHOWWINDOW);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001264}
1265
1266 void
1267gui_mch_create_scrollbar(
1268 scrollbar_T *sb,
1269 int orient) /* SBAR_VERT or SBAR_HORIZ */
1270{
1271 sb->id = CreateWindow(
1272 "SCROLLBAR", "Scrollbar",
1273 WS_CHILD | ((orient == SBAR_VERT) ? SBS_VERT : SBS_HORZ), 0, 0,
1274 10, /* Any value will do for now */
1275 10, /* Any value will do for now */
1276 s_hwnd, NULL,
1277 s_hinst, NULL);
1278}
1279
1280/*
1281 * Find the scrollbar with the given hwnd.
1282 */
1283 static scrollbar_T *
1284gui_mswin_find_scrollbar(HWND hwnd)
1285{
1286 win_T *wp;
1287
1288 if (gui.bottom_sbar.id == hwnd)
1289 return &gui.bottom_sbar;
1290 FOR_ALL_WINDOWS(wp)
1291 {
1292 if (wp->w_scrollbars[SBAR_LEFT].id == hwnd)
1293 return &wp->w_scrollbars[SBAR_LEFT];
1294 if (wp->w_scrollbars[SBAR_RIGHT].id == hwnd)
1295 return &wp->w_scrollbars[SBAR_RIGHT];
1296 }
1297 return NULL;
1298}
1299
1300/*
1301 * Get the character size of a font.
1302 */
1303 static void
1304GetFontSize(GuiFont font)
1305{
1306 HWND hwnd = GetDesktopWindow();
1307 HDC hdc = GetWindowDC(hwnd);
1308 HFONT hfntOld = SelectFont(hdc, (HFONT)font);
1309 TEXTMETRIC tm;
1310
1311 GetTextMetrics(hdc, &tm);
1312 gui.char_width = tm.tmAveCharWidth + tm.tmOverhang;
1313
1314 gui.char_height = tm.tmHeight
1315#ifndef MSWIN16_FASTTEXT
Bram Moolenaar02743632005-07-25 20:42:36 +00001316 + p_linespace
Bram Moolenaar071d4272004-06-13 20:20:40 +00001317#endif
Bram Moolenaar02743632005-07-25 20:42:36 +00001318 ;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001319
1320 SelectFont(hdc, hfntOld);
1321
1322 ReleaseDC(hwnd, hdc);
1323}
1324
Bram Moolenaar02743632005-07-25 20:42:36 +00001325/*
1326 * Adjust gui.char_height (after 'linespace' was changed).
1327 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00001328 int
Bram Moolenaar02743632005-07-25 20:42:36 +00001329gui_mch_adjust_charheight(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001330{
1331 GetFontSize(gui.norm_font);
1332 return OK;
1333}
1334
1335 static GuiFont
1336get_font_handle(LOGFONT *lf)
1337{
1338 HFONT font = NULL;
1339
1340 /* Load the font */
1341 font = CreateFontIndirect(lf);
1342
1343 if (font == NULL)
1344 return NOFONT;
1345
1346 return (GuiFont)font;
1347}
1348
1349 static int
1350pixels_to_points(int pixels, int vertical)
1351{
1352 int points;
1353 HWND hwnd;
1354 HDC hdc;
1355
1356 hwnd = GetDesktopWindow();
1357 hdc = GetWindowDC(hwnd);
1358
1359 points = MulDiv(pixels, 72,
1360 GetDeviceCaps(hdc, vertical ? LOGPIXELSY : LOGPIXELSX));
1361
1362 ReleaseDC(hwnd, hdc);
1363
1364 return points;
1365}
1366
1367 GuiFont
1368gui_mch_get_font(
1369 char_u *name,
1370 int giveErrorIfMissing)
1371{
1372 LOGFONT lf;
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00001373 GuiFont font = NOFONT;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001374
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00001375 if (get_logfont(&lf, name, NULL, giveErrorIfMissing) == OK)
1376 font = get_font_handle(&lf);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001377 if (font == NOFONT && giveErrorIfMissing)
1378 EMSG2(_(e_font), name);
1379 return font;
1380}
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00001381
Bram Moolenaardfccaf02004-12-31 20:56:11 +00001382#if defined(FEAT_EVAL) || defined(PROTO)
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00001383/*
1384 * Return the name of font "font" in allocated memory.
1385 * Don't know how to get the actual name, thus use the provided name.
1386 */
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00001387/*ARGSUSED*/
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00001388 char_u *
1389gui_mch_get_fontname(font, name)
1390 GuiFont font;
1391 char_u *name;
1392{
1393 if (name == NULL)
1394 return NULL;
1395 return vim_strsave(name);
1396}
Bram Moolenaardfccaf02004-12-31 20:56:11 +00001397#endif
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00001398
Bram Moolenaar071d4272004-06-13 20:20:40 +00001399 void
1400gui_mch_free_font(GuiFont font)
1401{
1402 if (font)
1403 DeleteObject((HFONT)font);
1404}
1405
1406 static int
1407hex_digit(int c)
1408{
1409 if (VIM_ISDIGIT(c))
1410 return c - '0';
1411 c = TOLOWER_ASC(c);
1412 if (c >= 'a' && c <= 'f')
1413 return c - 'a' + 10;
1414 return -1000;
1415}
1416/*
1417 * Return the Pixel value (color) for the given color name.
1418 * Return INVALCOLOR for error.
1419 */
1420 guicolor_T
1421gui_mch_get_color(char_u *name)
1422{
1423 typedef struct guicolor_tTable
1424 {
1425 char *name;
1426 COLORREF color;
1427 } guicolor_tTable;
1428
1429 static guicolor_tTable table[] =
1430 {
1431 {"Black", RGB(0x00, 0x00, 0x00)},
Bram Moolenaar092e3c82011-09-07 18:58:29 +02001432 {"DarkGray", RGB(0xA9, 0xA9, 0xA9)},
1433 {"DarkGrey", RGB(0xA9, 0xA9, 0xA9)},
Bram Moolenaar071d4272004-06-13 20:20:40 +00001434 {"Gray", RGB(0xC0, 0xC0, 0xC0)},
1435 {"Grey", RGB(0xC0, 0xC0, 0xC0)},
Bram Moolenaar092e3c82011-09-07 18:58:29 +02001436 {"LightGray", RGB(0xD3, 0xD3, 0xD3)},
1437 {"LightGrey", RGB(0xD3, 0xD3, 0xD3)},
Bram Moolenaarb21e5842006-04-16 18:30:08 +00001438 {"Gray10", RGB(0x1A, 0x1A, 0x1A)},
1439 {"Grey10", RGB(0x1A, 0x1A, 0x1A)},
1440 {"Gray20", RGB(0x33, 0x33, 0x33)},
1441 {"Grey20", RGB(0x33, 0x33, 0x33)},
1442 {"Gray30", RGB(0x4D, 0x4D, 0x4D)},
1443 {"Grey30", RGB(0x4D, 0x4D, 0x4D)},
1444 {"Gray40", RGB(0x66, 0x66, 0x66)},
1445 {"Grey40", RGB(0x66, 0x66, 0x66)},
1446 {"Gray50", RGB(0x7F, 0x7F, 0x7F)},
1447 {"Grey50", RGB(0x7F, 0x7F, 0x7F)},
1448 {"Gray60", RGB(0x99, 0x99, 0x99)},
1449 {"Grey60", RGB(0x99, 0x99, 0x99)},
1450 {"Gray70", RGB(0xB3, 0xB3, 0xB3)},
1451 {"Grey70", RGB(0xB3, 0xB3, 0xB3)},
1452 {"Gray80", RGB(0xCC, 0xCC, 0xCC)},
1453 {"Grey80", RGB(0xCC, 0xCC, 0xCC)},
Bram Moolenaare2f98b92006-03-29 21:18:24 +00001454 {"Gray90", RGB(0xE5, 0xE5, 0xE5)},
1455 {"Grey90", RGB(0xE5, 0xE5, 0xE5)},
Bram Moolenaar071d4272004-06-13 20:20:40 +00001456 {"White", RGB(0xFF, 0xFF, 0xFF)},
1457 {"DarkRed", RGB(0x80, 0x00, 0x00)},
1458 {"Red", RGB(0xFF, 0x00, 0x00)},
1459 {"LightRed", RGB(0xFF, 0xA0, 0xA0)},
1460 {"DarkBlue", RGB(0x00, 0x00, 0x80)},
1461 {"Blue", RGB(0x00, 0x00, 0xFF)},
Bram Moolenaar092e3c82011-09-07 18:58:29 +02001462 {"LightBlue", RGB(0xAD, 0xD8, 0xE6)},
Bram Moolenaar071d4272004-06-13 20:20:40 +00001463 {"DarkGreen", RGB(0x00, 0x80, 0x00)},
1464 {"Green", RGB(0x00, 0xFF, 0x00)},
Bram Moolenaar092e3c82011-09-07 18:58:29 +02001465 {"LightGreen", RGB(0x90, 0xEE, 0x90)},
Bram Moolenaar071d4272004-06-13 20:20:40 +00001466 {"DarkCyan", RGB(0x00, 0x80, 0x80)},
1467 {"Cyan", RGB(0x00, 0xFF, 0xFF)},
Bram Moolenaar092e3c82011-09-07 18:58:29 +02001468 {"LightCyan", RGB(0xE0, 0xFF, 0xFF)},
Bram Moolenaar071d4272004-06-13 20:20:40 +00001469 {"DarkMagenta", RGB(0x80, 0x00, 0x80)},
1470 {"Magenta", RGB(0xFF, 0x00, 0xFF)},
1471 {"LightMagenta", RGB(0xFF, 0xA0, 0xFF)},
1472 {"Brown", RGB(0x80, 0x40, 0x40)},
1473 {"Yellow", RGB(0xFF, 0xFF, 0x00)},
Bram Moolenaar092e3c82011-09-07 18:58:29 +02001474 {"LightYellow", RGB(0xFF, 0xFF, 0xE0)},
Bram Moolenaar071d4272004-06-13 20:20:40 +00001475 {"DarkYellow", RGB(0xBB, 0xBB, 0x00)},
1476 {"SeaGreen", RGB(0x2E, 0x8B, 0x57)},
1477 {"Orange", RGB(0xFF, 0xA5, 0x00)},
1478 {"Purple", RGB(0xA0, 0x20, 0xF0)},
1479 {"SlateBlue", RGB(0x6A, 0x5A, 0xCD)},
1480 {"Violet", RGB(0xEE, 0x82, 0xEE)},
1481 };
1482
1483 typedef struct SysColorTable
1484 {
1485 char *name;
1486 int color;
1487 } SysColorTable;
1488
1489 static SysColorTable sys_table[] =
1490 {
1491#ifdef WIN3264
1492 {"SYS_3DDKSHADOW", COLOR_3DDKSHADOW},
1493 {"SYS_3DHILIGHT", COLOR_3DHILIGHT},
1494#ifndef __MINGW32__
1495 {"SYS_3DHIGHLIGHT", COLOR_3DHIGHLIGHT},
1496#endif
1497 {"SYS_BTNHILIGHT", COLOR_BTNHILIGHT},
1498 {"SYS_BTNHIGHLIGHT", COLOR_BTNHIGHLIGHT},
1499 {"SYS_3DLIGHT", COLOR_3DLIGHT},
1500 {"SYS_3DSHADOW", COLOR_3DSHADOW},
1501 {"SYS_DESKTOP", COLOR_DESKTOP},
1502 {"SYS_INFOBK", COLOR_INFOBK},
1503 {"SYS_INFOTEXT", COLOR_INFOTEXT},
1504 {"SYS_3DFACE", COLOR_3DFACE},
1505#endif
1506 {"SYS_BTNFACE", COLOR_BTNFACE},
1507 {"SYS_BTNSHADOW", COLOR_BTNSHADOW},
1508 {"SYS_ACTIVEBORDER", COLOR_ACTIVEBORDER},
1509 {"SYS_ACTIVECAPTION", COLOR_ACTIVECAPTION},
1510 {"SYS_APPWORKSPACE", COLOR_APPWORKSPACE},
1511 {"SYS_BACKGROUND", COLOR_BACKGROUND},
1512 {"SYS_BTNTEXT", COLOR_BTNTEXT},
1513 {"SYS_CAPTIONTEXT", COLOR_CAPTIONTEXT},
1514 {"SYS_GRAYTEXT", COLOR_GRAYTEXT},
1515 {"SYS_HIGHLIGHT", COLOR_HIGHLIGHT},
1516 {"SYS_HIGHLIGHTTEXT", COLOR_HIGHLIGHTTEXT},
1517 {"SYS_INACTIVEBORDER", COLOR_INACTIVEBORDER},
1518 {"SYS_INACTIVECAPTION", COLOR_INACTIVECAPTION},
1519 {"SYS_INACTIVECAPTIONTEXT", COLOR_INACTIVECAPTIONTEXT},
1520 {"SYS_MENU", COLOR_MENU},
1521 {"SYS_MENUTEXT", COLOR_MENUTEXT},
1522 {"SYS_SCROLLBAR", COLOR_SCROLLBAR},
1523 {"SYS_WINDOW", COLOR_WINDOW},
1524 {"SYS_WINDOWFRAME", COLOR_WINDOWFRAME},
1525 {"SYS_WINDOWTEXT", COLOR_WINDOWTEXT}
1526 };
1527
1528 int r, g, b;
1529 int i;
1530
1531 if (name[0] == '#' && strlen(name) == 7)
1532 {
1533 /* Name is in "#rrggbb" format */
1534 r = hex_digit(name[1]) * 16 + hex_digit(name[2]);
1535 g = hex_digit(name[3]) * 16 + hex_digit(name[4]);
1536 b = hex_digit(name[5]) * 16 + hex_digit(name[6]);
1537 if (r < 0 || g < 0 || b < 0)
1538 return INVALCOLOR;
1539 return RGB(r, g, b);
1540 }
1541 else
1542 {
1543 /* Check if the name is one of the colors we know */
1544 for (i = 0; i < sizeof(table) / sizeof(table[0]); i++)
1545 if (STRICMP(name, table[i].name) == 0)
1546 return table[i].color;
1547 }
1548
1549 /*
1550 * Try to look up a system colour.
1551 */
1552 for (i = 0; i < sizeof(sys_table) / sizeof(sys_table[0]); i++)
1553 if (STRICMP(name, sys_table[i].name) == 0)
1554 return GetSysColor(sys_table[i].color);
1555
1556 /*
1557 * Last attempt. Look in the file "$VIMRUNTIME/rgb.txt".
1558 */
1559 {
1560#define LINE_LEN 100
1561 FILE *fd;
1562 char line[LINE_LEN];
1563 char_u *fname;
1564
1565 fname = expand_env_save((char_u *)"$VIMRUNTIME/rgb.txt");
1566 if (fname == NULL)
1567 return INVALCOLOR;
1568
Bram Moolenaar5555acc2006-04-07 21:33:12 +00001569 fd = mch_fopen((char *)fname, "rt");
Bram Moolenaar071d4272004-06-13 20:20:40 +00001570 vim_free(fname);
1571 if (fd == NULL)
1572 return INVALCOLOR;
1573
1574 while (!feof(fd))
1575 {
1576 int len;
1577 int pos;
1578 char *color;
1579
1580 fgets(line, LINE_LEN, fd);
1581 len = (int)STRLEN(line);
1582
1583 if (len <= 1 || line[len-1] != '\n')
1584 continue;
1585
1586 line[len-1] = '\0';
1587
1588 i = sscanf(line, "%d %d %d %n", &r, &g, &b, &pos);
1589 if (i != 3)
1590 continue;
1591
1592 color = line + pos;
1593
1594 if (STRICMP(color, name) == 0)
1595 {
1596 fclose(fd);
1597 return (guicolor_T) RGB(r, g, b);
1598 }
1599 }
1600
1601 fclose(fd);
1602 }
1603
1604 return INVALCOLOR;
1605}
1606/*
1607 * Return OK if the key with the termcap name "name" is supported.
1608 */
1609 int
1610gui_mch_haskey(char_u *name)
1611{
1612 int i;
1613
1614 for (i = 0; special_keys[i].vim_code1 != NUL; i++)
1615 if (name[0] == special_keys[i].vim_code0 &&
1616 name[1] == special_keys[i].vim_code1)
1617 return OK;
1618 return FAIL;
1619}
1620
1621 void
1622gui_mch_beep(void)
1623{
1624 MessageBeep(MB_OK);
1625}
1626/*
1627 * Invert a rectangle from row r, column c, for nr rows and nc columns.
1628 */
1629 void
1630gui_mch_invert_rectangle(
1631 int r,
1632 int c,
1633 int nr,
1634 int nc)
1635{
1636 RECT rc;
1637
1638 /*
1639 * Note: InvertRect() excludes right and bottom of rectangle.
1640 */
1641 rc.left = FILL_X(c);
1642 rc.top = FILL_Y(r);
1643 rc.right = rc.left + nc * gui.char_width;
1644 rc.bottom = rc.top + nr * gui.char_height;
1645 InvertRect(s_hdc, &rc);
1646}
1647
1648/*
1649 * Iconify the GUI window.
1650 */
1651 void
1652gui_mch_iconify(void)
1653{
1654 ShowWindow(s_hwnd, SW_MINIMIZE);
1655}
1656
1657/*
1658 * Draw a cursor without focus.
1659 */
1660 void
1661gui_mch_draw_hollow_cursor(guicolor_T color)
1662{
1663 HBRUSH hbr;
1664 RECT rc;
1665
1666 /*
1667 * Note: FrameRect() excludes right and bottom of rectangle.
1668 */
1669 rc.left = FILL_X(gui.col);
1670 rc.top = FILL_Y(gui.row);
1671 rc.right = rc.left + gui.char_width;
1672#ifdef FEAT_MBYTE
1673 if (mb_lefthalve(gui.row, gui.col))
1674 rc.right += gui.char_width;
1675#endif
1676 rc.bottom = rc.top + gui.char_height;
1677 hbr = CreateSolidBrush(color);
1678 FrameRect(s_hdc, &rc, hbr);
1679 DeleteBrush(hbr);
1680}
1681/*
1682 * Draw part of a cursor, "w" pixels wide, and "h" pixels high, using
1683 * color "color".
1684 */
1685 void
1686gui_mch_draw_part_cursor(
1687 int w,
1688 int h,
1689 guicolor_T color)
1690{
1691 HBRUSH hbr;
1692 RECT rc;
1693
1694 /*
1695 * Note: FillRect() excludes right and bottom of rectangle.
1696 */
1697 rc.left =
1698#ifdef FEAT_RIGHTLEFT
1699 /* vertical line should be on the right of current point */
1700 CURSOR_BAR_RIGHT ? FILL_X(gui.col + 1) - w :
1701#endif
1702 FILL_X(gui.col);
1703 rc.top = FILL_Y(gui.row) + gui.char_height - h;
1704 rc.right = rc.left + w;
1705 rc.bottom = rc.top + h;
1706 hbr = CreateSolidBrush(color);
1707 FillRect(s_hdc, &rc, hbr);
1708 DeleteBrush(hbr);
1709}
1710
1711/*
1712 * Process a single Windows message.
1713 * If one is not available we hang until one is.
1714 */
1715 static void
1716process_message(void)
1717{
1718 MSG msg;
1719 UINT vk = 0; /* Virtual key */
1720 char_u string[40];
1721 int i;
1722 int modifiers = 0;
1723 int key;
Bram Moolenaar293ee4d2004-12-09 21:34:53 +00001724#ifdef FEAT_MENU
1725 static char_u k10[] = {K_SPECIAL, 'k', ';', 0};
1726#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00001727
Bram Moolenaar8c85fa32011-08-10 17:08:03 +02001728 pGetMessage(&msg, NULL, 0, 0);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001729
1730#ifdef FEAT_OLE
1731 /* Look after OLE Automation commands */
1732 if (msg.message == WM_OLE)
1733 {
1734 char_u *str = (char_u *)msg.lParam;
Bram Moolenaar370feaf2009-01-28 13:18:26 +00001735 if (str == NULL || *str == NUL)
1736 {
1737 /* Message can't be ours, forward it. Fixes problem with Ultramon
1738 * 3.0.4 */
Bram Moolenaar8c85fa32011-08-10 17:08:03 +02001739 pDispatchMessage(&msg);
Bram Moolenaar370feaf2009-01-28 13:18:26 +00001740 }
1741 else
1742 {
1743 add_to_input_buf(str, (int)STRLEN(str));
1744 vim_free(str); /* was allocated in CVim::SendKeys() */
1745 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00001746 return;
1747 }
1748#endif
1749
1750#ifdef FEAT_NETBEANS_INTG
1751 if (msg.message == WM_NETBEANS)
1752 {
Bram Moolenaar67c53842010-05-22 18:28:27 +02001753 netbeans_read();
Bram Moolenaar071d4272004-06-13 20:20:40 +00001754 return;
1755 }
1756#endif
1757
1758#ifdef FEAT_SNIFF
1759 if (sniff_request_waiting && want_sniff_request)
1760 {
1761 static char_u bytes[3] = {CSI, (char_u)KS_EXTRA, (char_u)KE_SNIFF};
1762 add_to_input_buf(bytes, 3); /* K_SNIFF */
1763 sniff_request_waiting = 0;
1764 want_sniff_request = 0;
1765 /* request is handled in normal.c */
1766 }
1767 if (msg.message == WM_USER)
Bram Moolenaar35c92912006-06-22 17:34:26 +00001768 {
Bram Moolenaard8a92d72006-06-23 14:44:06 +00001769 MyTranslateMessage(&msg);
Bram Moolenaar8c85fa32011-08-10 17:08:03 +02001770 pDispatchMessage(&msg);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001771 return;
Bram Moolenaar35c92912006-06-22 17:34:26 +00001772 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00001773#endif
1774
1775#ifdef MSWIN_FIND_REPLACE
1776 /* Don't process messages used by the dialog */
Bram Moolenaar8c85fa32011-08-10 17:08:03 +02001777 if (s_findrep_hwnd != NULL && pIsDialogMessage(s_findrep_hwnd, &msg))
Bram Moolenaar071d4272004-06-13 20:20:40 +00001778 {
1779 HandleMouseHide(msg.message, msg.lParam);
1780 return;
1781 }
1782#endif
1783
1784 /*
1785 * Check if it's a special key that we recognise. If not, call
1786 * TranslateMessage().
1787 */
1788 if (msg.message == WM_KEYDOWN || msg.message == WM_SYSKEYDOWN)
1789 {
1790 vk = (int) msg.wParam;
1791 /* handle key after dead key, but ignore shift, alt and control */
1792 if (dead_key && vk != VK_SHIFT && vk != VK_MENU && vk != VK_CONTROL)
1793 {
1794 dead_key = 0;
1795 /* handle non-alphabetic keys (ones that hopefully cannot generate
1796 * umlaut-characters), unless when control is down */
1797 if (vk < 'A' || vk > 'Z' || (GetKeyState(VK_CONTROL) & 0x8000))
1798 {
1799 MSG dm;
1800
1801 dm.message = msg.message;
1802 dm.hwnd = msg.hwnd;
1803 dm.wParam = VK_SPACE;
1804 MyTranslateMessage(&dm); /* generate dead character */
1805 if (vk != VK_SPACE) /* and send current character once more */
1806 PostMessage(msg.hwnd, msg.message, msg.wParam, msg.lParam);
1807 return;
1808 }
1809 }
1810
1811 /* Check for CTRL-BREAK */
1812 if (vk == VK_CANCEL)
1813 {
1814 trash_input_buf();
1815 got_int = TRUE;
1816 string[0] = Ctrl_C;
1817 add_to_input_buf(string, 1);
1818 }
1819
1820 for (i = 0; special_keys[i].key_sym != 0; i++)
1821 {
1822 /* ignore VK_SPACE when ALT key pressed: system menu */
1823 if (special_keys[i].key_sym == vk
1824 && (vk != VK_SPACE || !(GetKeyState(VK_MENU) & 0x8000)))
1825 {
1826#ifdef FEAT_MENU
Bram Moolenaar293ee4d2004-12-09 21:34:53 +00001827 /* Check for <F10>: Windows selects the menu. When <F10> is
1828 * mapped we want to use the mapping instead. */
Bram Moolenaar071d4272004-06-13 20:20:40 +00001829 if (vk == VK_F10
1830 && gui.menu_is_active
Bram Moolenaarbd743252010-10-20 21:23:33 +02001831 && check_map(k10, State, FALSE, TRUE, FALSE,
1832 NULL, NULL) == NULL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001833 break;
1834#endif
1835 if (GetKeyState(VK_SHIFT) & 0x8000)
1836 modifiers |= MOD_MASK_SHIFT;
1837 /*
1838 * Don't use caps-lock as shift, because these are special keys
1839 * being considered here, and we only want letters to get
1840 * shifted -- webb
1841 */
1842 /*
1843 if (GetKeyState(VK_CAPITAL) & 0x0001)
1844 modifiers ^= MOD_MASK_SHIFT;
1845 */
1846 if (GetKeyState(VK_CONTROL) & 0x8000)
1847 modifiers |= MOD_MASK_CTRL;
1848 if (GetKeyState(VK_MENU) & 0x8000)
1849 modifiers |= MOD_MASK_ALT;
1850
1851 if (special_keys[i].vim_code1 == NUL)
1852 key = special_keys[i].vim_code0;
1853 else
1854 key = TO_SPECIAL(special_keys[i].vim_code0,
1855 special_keys[i].vim_code1);
1856 key = simplify_key(key, &modifiers);
1857 if (key == CSI)
1858 key = K_CSI;
1859
1860 if (modifiers)
1861 {
1862 string[0] = CSI;
1863 string[1] = KS_MODIFIER;
1864 string[2] = modifiers;
1865 add_to_input_buf(string, 3);
1866 }
1867
1868 if (IS_SPECIAL(key))
1869 {
1870 string[0] = CSI;
1871 string[1] = K_SECOND(key);
1872 string[2] = K_THIRD(key);
1873 add_to_input_buf(string, 3);
1874 }
1875 else
1876 {
1877 int len;
1878
1879 /* Handle "key" as a Unicode character. */
Bram Moolenaar85a3e5c2007-11-20 16:22:16 +00001880 len = char_to_string(key, string, 40, FALSE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001881 add_to_input_buf(string, len);
1882 }
1883 break;
1884 }
1885 }
1886 if (special_keys[i].key_sym == 0)
1887 {
1888 /* Some keys need C-S- where they should only need C-.
1889 * Ignore 0xff, Windows XP sends it when NUMLOCK has changed since
1890 * system startup (Helmut Stiegler, 2003 Oct 3). */
1891 if (vk != 0xff
1892 && (GetKeyState(VK_CONTROL) & 0x8000)
1893 && !(GetKeyState(VK_SHIFT) & 0x8000)
1894 && !(GetKeyState(VK_MENU) & 0x8000))
1895 {
1896 /* CTRL-6 is '^'; Japanese keyboard maps '^' to vk == 0xDE */
1897 if (vk == '6' || MapVirtualKey(vk, 2) == (UINT)'^')
1898 {
1899 string[0] = Ctrl_HAT;
1900 add_to_input_buf(string, 1);
1901 }
1902 /* vk == 0xBD AZERTY for CTRL-'-', but CTRL-[ for * QWERTY! */
1903 else if (vk == 0xBD) /* QWERTY for CTRL-'-' */
1904 {
1905 string[0] = Ctrl__;
1906 add_to_input_buf(string, 1);
1907 }
1908 /* CTRL-2 is '@'; Japanese keyboard maps '@' to vk == 0xC0 */
1909 else if (vk == '2' || MapVirtualKey(vk, 2) == (UINT)'@')
1910 {
1911 string[0] = Ctrl_AT;
1912 add_to_input_buf(string, 1);
1913 }
1914 else
1915 MyTranslateMessage(&msg);
1916 }
1917 else
1918 MyTranslateMessage(&msg);
1919 }
1920 }
1921#ifdef FEAT_MBYTE_IME
1922 else if (msg.message == WM_IME_NOTIFY)
1923 _OnImeNotify(msg.hwnd, (DWORD)msg.wParam, (DWORD)msg.lParam);
1924 else if (msg.message == WM_KEYUP && im_get_status())
1925 /* added for non-MS IME (Yasuhiro Matsumoto) */
1926 MyTranslateMessage(&msg);
1927#endif
1928#if !defined(FEAT_MBYTE_IME) && defined(GLOBAL_IME)
1929/* GIME_TEST */
1930 else if (msg.message == WM_IME_STARTCOMPOSITION)
1931 {
1932 POINT point;
1933
1934 global_ime_set_font(&norm_logfont);
1935 point.x = FILL_X(gui.col);
1936 point.y = FILL_Y(gui.row);
1937 MapWindowPoints(s_textArea, s_hwnd, &point, 1);
1938 global_ime_set_position(&point);
1939 }
1940#endif
1941
1942#ifdef FEAT_MENU
Bram Moolenaar293ee4d2004-12-09 21:34:53 +00001943 /* Check for <F10>: Default effect is to select the menu. When <F10> is
1944 * mapped we need to stop it here to avoid strange effects (e.g., for the
1945 * key-up event) */
Bram Moolenaarbd743252010-10-20 21:23:33 +02001946 if (vk != VK_F10 || check_map(k10, State, FALSE, TRUE, FALSE,
1947 NULL, NULL) == NULL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001948#endif
Bram Moolenaar8c85fa32011-08-10 17:08:03 +02001949 pDispatchMessage(&msg);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001950}
1951
1952/*
1953 * Catch up with any queued events. This may put keyboard input into the
1954 * input buffer, call resize call-backs, trigger timers etc. If there is
1955 * nothing in the event queue (& no timers pending), then we return
1956 * immediately.
1957 */
1958 void
1959gui_mch_update(void)
1960{
1961 MSG msg;
1962
1963 if (!s_busy_processing)
Bram Moolenaar8c85fa32011-08-10 17:08:03 +02001964 while (pPeekMessage(&msg, NULL, 0, 0, PM_NOREMOVE)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001965 && !vim_is_input_buf_full())
1966 process_message();
1967}
1968
1969/*
1970 * GUI input routine called by gui_wait_for_chars(). Waits for a character
1971 * from the keyboard.
1972 * wtime == -1 Wait forever.
1973 * wtime == 0 This should never happen.
1974 * wtime > 0 Wait wtime milliseconds for a character.
1975 * Returns OK if a character was found to be available within the given time,
1976 * or FAIL otherwise.
1977 */
1978 int
1979gui_mch_wait_for_chars(int wtime)
1980{
1981 MSG msg;
1982 int focus;
1983
1984 s_timed_out = FALSE;
1985
1986 if (wtime > 0)
1987 {
1988 /* Don't do anything while processing a (scroll) message. */
1989 if (s_busy_processing)
1990 return FAIL;
1991 s_wait_timer = (UINT)SetTimer(NULL, 0, (UINT)wtime,
1992 (TIMERPROC)_OnTimer);
1993 }
1994
1995 allow_scrollbar = TRUE;
1996
1997 focus = gui.in_focus;
1998 while (!s_timed_out)
1999 {
2000 /* Stop or start blinking when focus changes */
2001 if (gui.in_focus != focus)
2002 {
2003 if (gui.in_focus)
2004 gui_mch_start_blink();
2005 else
2006 gui_mch_stop_blink();
2007 focus = gui.in_focus;
2008 }
2009
2010 if (s_need_activate)
2011 {
2012#ifdef WIN32
2013 (void)SetForegroundWindow(s_hwnd);
2014#else
2015 (void)SetActiveWindow(s_hwnd);
2016#endif
2017 s_need_activate = FALSE;
2018 }
2019
Bram Moolenaar61665aa2008-12-24 11:20:53 +00002020#ifdef FEAT_NETBEANS_INTG
2021 /* Process the queued netbeans messages. */
Bram Moolenaarcc448b32010-07-14 16:52:17 +02002022 netbeans_parse_messages();
Bram Moolenaar61665aa2008-12-24 11:20:53 +00002023#endif
2024
Bram Moolenaar071d4272004-06-13 20:20:40 +00002025 /*
2026 * Don't use gui_mch_update() because then we will spin-lock until a
2027 * char arrives, instead we use GetMessage() to hang until an
2028 * event arrives. No need to check for input_buf_full because we are
2029 * returning as soon as it contains a single char -- webb
2030 */
2031 process_message();
2032
2033 if (input_available())
2034 {
2035 if (s_wait_timer != 0 && !s_timed_out)
2036 {
2037 KillTimer(NULL, s_wait_timer);
2038
2039 /* Eat spurious WM_TIMER messages */
Bram Moolenaar8c85fa32011-08-10 17:08:03 +02002040 while (pPeekMessage(&msg, s_hwnd, WM_TIMER, WM_TIMER, PM_REMOVE))
Bram Moolenaar071d4272004-06-13 20:20:40 +00002041 ;
2042 s_wait_timer = 0;
2043 }
2044 allow_scrollbar = FALSE;
Bram Moolenaar293ee4d2004-12-09 21:34:53 +00002045
2046 /* Clear pending mouse button, the release event may have been
Bram Moolenaarea408882007-12-03 21:21:03 +00002047 * taken by the dialog window. But don't do this when getting
2048 * focus, we need the mouse-up event then. */
2049 if (!s_getting_focus)
2050 s_button_pending = -1;
Bram Moolenaar293ee4d2004-12-09 21:34:53 +00002051
Bram Moolenaar071d4272004-06-13 20:20:40 +00002052 return OK;
2053 }
2054 }
2055 allow_scrollbar = FALSE;
2056 return FAIL;
2057}
2058
2059/*
2060 * Clear a rectangular region of the screen from text pos (row1, col1) to
2061 * (row2, col2) inclusive.
2062 */
2063 void
2064gui_mch_clear_block(
2065 int row1,
2066 int col1,
2067 int row2,
2068 int col2)
2069{
2070 RECT rc;
2071
2072 /*
2073 * Clear one extra pixel at the far right, for when bold characters have
2074 * spilled over to the window border.
2075 * Note: FillRect() excludes right and bottom of rectangle.
2076 */
2077 rc.left = FILL_X(col1);
2078 rc.top = FILL_Y(row1);
2079 rc.right = FILL_X(col2 + 1) + (col2 == Columns - 1);
2080 rc.bottom = FILL_Y(row2 + 1);
2081 clear_rect(&rc);
2082}
2083
2084/*
2085 * Clear the whole text window.
2086 */
2087 void
2088gui_mch_clear_all(void)
2089{
2090 RECT rc;
2091
2092 rc.left = 0;
2093 rc.top = 0;
2094 rc.right = Columns * gui.char_width + 2 * gui.border_width;
2095 rc.bottom = Rows * gui.char_height + 2 * gui.border_width;
2096 clear_rect(&rc);
2097}
2098/*
2099 * Menu stuff.
2100 */
2101
2102 void
2103gui_mch_enable_menu(int flag)
2104{
2105#ifdef FEAT_MENU
2106 SetMenu(s_hwnd, flag ? s_menuBar : NULL);
2107#endif
2108}
2109
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00002110/*ARGSUSED*/
Bram Moolenaar071d4272004-06-13 20:20:40 +00002111 void
2112gui_mch_set_menu_pos(
2113 int x,
2114 int y,
2115 int w,
2116 int h)
2117{
2118 /* It will be in the right place anyway */
2119}
2120
2121#if defined(FEAT_MENU) || defined(PROTO)
2122/*
2123 * Make menu item hidden or not hidden
2124 */
2125 void
2126gui_mch_menu_hidden(
2127 vimmenu_T *menu,
2128 int hidden)
2129{
2130 /*
2131 * This doesn't do what we want. Hmm, just grey the menu items for now.
2132 */
2133 /*
2134 if (hidden)
2135 EnableMenuItem(s_menuBar, menu->id, MF_BYCOMMAND | MF_DISABLED);
2136 else
2137 EnableMenuItem(s_menuBar, menu->id, MF_BYCOMMAND | MF_ENABLED);
2138 */
2139 gui_mch_menu_grey(menu, hidden);
2140}
2141
2142/*
2143 * This is called after setting all the menus to grey/hidden or not.
2144 */
2145 void
2146gui_mch_draw_menubar(void)
2147{
2148 DrawMenuBar(s_hwnd);
2149}
2150#endif /*FEAT_MENU*/
2151
2152#ifndef PROTO
2153void
2154#ifdef VIMDLL
2155_export
2156#endif
2157_cdecl
2158SaveInst(HINSTANCE hInst)
2159{
2160 s_hinst = hInst;
2161}
2162#endif
2163
2164/*
2165 * Return the RGB value of a pixel as a long.
2166 */
2167 long_u
2168gui_mch_get_rgb(guicolor_T pixel)
2169{
2170 return (GetRValue(pixel) << 16) + (GetGValue(pixel) << 8)
2171 + GetBValue(pixel);
2172}
2173
2174#if defined(FEAT_GUI_DIALOG) || defined(PROTO)
2175/* Convert pixels in X to dialog units */
2176 static WORD
2177PixelToDialogX(int numPixels)
2178{
2179 return (WORD)((numPixels * 4) / s_dlgfntwidth);
2180}
2181
2182/* Convert pixels in Y to dialog units */
2183 static WORD
2184PixelToDialogY(int numPixels)
2185{
2186 return (WORD)((numPixels * 8) / s_dlgfntheight);
2187}
2188
2189/* Return the width in pixels of the given text in the given DC. */
2190 static int
2191GetTextWidth(HDC hdc, char_u *str, int len)
2192{
2193 SIZE size;
2194
2195 GetTextExtentPoint(hdc, str, len, &size);
2196 return size.cx;
2197}
2198
2199#ifdef FEAT_MBYTE
2200/*
2201 * Return the width in pixels of the given text in the given DC, taking care
2202 * of 'encoding' to active codepage conversion.
2203 */
2204 static int
2205GetTextWidthEnc(HDC hdc, char_u *str, int len)
2206{
2207 SIZE size;
2208 WCHAR *wstr;
2209 int n;
2210 int wlen = len;
2211
2212 if (enc_codepage >= 0 && (int)GetACP() != enc_codepage)
2213 {
2214 /* 'encoding' differs from active codepage: convert text and use wide
2215 * function */
Bram Moolenaar36f692d2008-11-20 16:10:17 +00002216 wstr = enc_to_utf16(str, &wlen);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002217 if (wstr != NULL)
2218 {
2219 n = GetTextExtentPointW(hdc, wstr, wlen, &size);
2220 vim_free(wstr);
2221 if (n)
2222 return size.cx;
2223 }
2224 }
2225
2226 return GetTextWidth(hdc, str, len);
2227}
2228#else
2229# define GetTextWidthEnc(h, s, l) GetTextWidth((h), (s), (l))
2230#endif
2231
2232/*
2233 * A quick little routine that will center one window over another, handy for
2234 * dialog boxes. Taken from the Win32SDK samples.
2235 */
2236 static BOOL
2237CenterWindow(
2238 HWND hwndChild,
2239 HWND hwndParent)
2240{
2241 RECT rChild, rParent;
2242 int wChild, hChild, wParent, hParent;
2243 int wScreen, hScreen, xNew, yNew;
2244 HDC hdc;
2245
2246 GetWindowRect(hwndChild, &rChild);
2247 wChild = rChild.right - rChild.left;
2248 hChild = rChild.bottom - rChild.top;
2249
2250 /* If Vim is minimized put the window in the middle of the screen. */
Bram Moolenaar9e54a0e2006-04-14 20:42:25 +00002251 if (hwndParent == NULL || IsMinimized(hwndParent))
Bram Moolenaar071d4272004-06-13 20:20:40 +00002252 {
2253#ifdef WIN16
2254 rParent.left = 0;
2255 rParent.top = 0;
2256 rParent.right = GetSystemMetrics(SM_CXSCREEN);
2257 rParent.bottom = GetSystemMetrics(SM_CYFULLSCREEN);
2258#else
2259 SystemParametersInfo(SPI_GETWORKAREA, 0, &rParent, 0);
2260#endif
2261 }
2262 else
2263 GetWindowRect(hwndParent, &rParent);
2264 wParent = rParent.right - rParent.left;
2265 hParent = rParent.bottom - rParent.top;
2266
2267 hdc = GetDC(hwndChild);
2268 wScreen = GetDeviceCaps (hdc, HORZRES);
2269 hScreen = GetDeviceCaps (hdc, VERTRES);
2270 ReleaseDC(hwndChild, hdc);
2271
2272 xNew = rParent.left + ((wParent - wChild) /2);
2273 if (xNew < 0)
2274 {
2275 xNew = 0;
2276 }
2277 else if ((xNew+wChild) > wScreen)
2278 {
2279 xNew = wScreen - wChild;
2280 }
2281
2282 yNew = rParent.top + ((hParent - hChild) /2);
2283 if (yNew < 0)
2284 yNew = 0;
2285 else if ((yNew+hChild) > hScreen)
2286 yNew = hScreen - hChild;
2287
2288 return SetWindowPos(hwndChild, NULL, xNew, yNew, 0, 0,
2289 SWP_NOSIZE | SWP_NOZORDER);
2290}
2291#endif /* FEAT_GUI_DIALOG */
2292
2293void
2294gui_mch_activate_window(void)
2295{
2296 (void)SetActiveWindow(s_hwnd);
2297}
2298
2299#if defined(FEAT_TOOLBAR) || defined(PROTO)
2300 void
2301gui_mch_show_toolbar(int showit)
2302{
2303 if (s_toolbarhwnd == NULL)
2304 return;
2305
2306 if (showit)
Bram Moolenaar8f2ff9f2006-08-29 19:26:50 +00002307 {
2308# ifdef FEAT_MBYTE
2309# ifndef TB_SETUNICODEFORMAT
2310 /* For older compilers. We assume this never changes. */
2311# define TB_SETUNICODEFORMAT 0x2005
2312# endif
2313 /* Enable/disable unicode support */
2314 int uu = (enc_codepage >= 0 && (int)GetACP() != enc_codepage);
2315 SendMessage(s_toolbarhwnd, TB_SETUNICODEFORMAT, (WPARAM)uu, (LPARAM)0);
2316# endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00002317 ShowWindow(s_toolbarhwnd, SW_SHOW);
Bram Moolenaar8f2ff9f2006-08-29 19:26:50 +00002318 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00002319 else
2320 ShowWindow(s_toolbarhwnd, SW_HIDE);
2321}
2322
2323/* Then number of bitmaps is fixed. Exit is missing! */
2324#define TOOLBAR_BITMAP_COUNT 31
2325
2326#endif
2327
Bram Moolenaar3991dab2006-03-27 17:01:56 +00002328#if defined(FEAT_GUI_TABLINE) || defined(PROTO)
Bram Moolenaar2e2a2812006-03-27 20:55:21 +00002329 static void
Bram Moolenaar908d53a2006-11-07 18:05:31 +00002330add_tabline_popup_menu_entry(HMENU pmenu, UINT item_id, char_u *item_text)
2331{
2332#ifdef FEAT_MBYTE
2333 WCHAR *wn = NULL;
2334 int n;
2335
2336 if (enc_codepage >= 0 && (int)GetACP() != enc_codepage)
2337 {
2338 /* 'encoding' differs from active codepage: convert menu name
2339 * and use wide function */
Bram Moolenaar36f692d2008-11-20 16:10:17 +00002340 wn = enc_to_utf16(item_text, NULL);
Bram Moolenaar908d53a2006-11-07 18:05:31 +00002341 if (wn != NULL)
2342 {
2343 MENUITEMINFOW infow;
2344
2345 infow.cbSize = sizeof(infow);
2346 infow.fMask = MIIM_TYPE | MIIM_ID;
2347 infow.wID = item_id;
2348 infow.fType = MFT_STRING;
2349 infow.dwTypeData = wn;
2350 infow.cch = (UINT)wcslen(wn);
2351 n = InsertMenuItemW(pmenu, item_id, FALSE, &infow);
2352 vim_free(wn);
2353 if (n == 0 && GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
2354 /* Failed, try using non-wide function. */
2355 wn = NULL;
2356 }
2357 }
2358
2359 if (wn == NULL)
2360#endif
2361 {
2362 MENUITEMINFO info;
2363
2364 info.cbSize = sizeof(info);
2365 info.fMask = MIIM_TYPE | MIIM_ID;
2366 info.wID = item_id;
2367 info.fType = MFT_STRING;
2368 info.dwTypeData = item_text;
2369 info.cch = (UINT)STRLEN(item_text);
2370 InsertMenuItem(pmenu, item_id, FALSE, &info);
2371 }
2372}
2373
2374 static void
Bram Moolenaar2e2a2812006-03-27 20:55:21 +00002375show_tabline_popup_menu(void)
2376{
2377 HMENU tab_pmenu;
Bram Moolenaar2e2a2812006-03-27 20:55:21 +00002378 long rval;
2379 POINT pt;
Bram Moolenaar2e2a2812006-03-27 20:55:21 +00002380
Bram Moolenaarf193fff2006-04-27 00:02:13 +00002381 /* When ignoring events don't show the menu. */
2382 if (hold_gui_events
2383# ifdef FEAT_CMDWIN
2384 || cmdwin_type != 0
2385# endif
2386 )
2387 return;
2388
Bram Moolenaar2e2a2812006-03-27 20:55:21 +00002389 tab_pmenu = CreatePopupMenu();
2390 if (tab_pmenu == NULL)
2391 return;
2392
Bram Moolenaar908d53a2006-11-07 18:05:31 +00002393 add_tabline_popup_menu_entry(tab_pmenu, TABLINE_MENU_CLOSE, _("Close tab"));
2394 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);
2788
2789#ifdef FEAT_MBYTE
2790 /* prevent multi-byte characters from misprinting on an invalid
2791 * rectangle */
2792 if (has_mbyte)
2793 {
2794 RECT rect;
2795
2796 GetClientRect(hwnd, &rect);
2797 ps.rcPaint.left = rect.left;
2798 ps.rcPaint.right = rect.right;
2799 }
2800#endif
2801
2802 if (!IsRectEmpty(&ps.rcPaint))
2803 gui_redraw(ps.rcPaint.left, ps.rcPaint.top,
2804 ps.rcPaint.right - ps.rcPaint.left + 1,
2805 ps.rcPaint.bottom - ps.rcPaint.top + 1);
2806 EndPaint(hwnd, &ps);
2807 }
2808}
2809
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00002810/*ARGSUSED*/
Bram Moolenaar071d4272004-06-13 20:20:40 +00002811 static void
2812_OnSize(
2813 HWND hwnd,
2814 UINT state,
2815 int cx,
2816 int cy)
2817{
2818 if (!IsMinimized(hwnd))
2819 {
2820 gui_resize_shell(cx, cy);
2821
2822#ifdef FEAT_MENU
2823 /* Menu bar may wrap differently now */
2824 gui_mswin_get_menu_height(TRUE);
2825#endif
2826 }
2827}
2828
2829 static void
2830_OnSetFocus(
2831 HWND hwnd,
2832 HWND hwndOldFocus)
2833{
2834 gui_focus_change(TRUE);
Bram Moolenaarea408882007-12-03 21:21:03 +00002835 s_getting_focus = TRUE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002836 (void)MyWindowProc(hwnd, WM_SETFOCUS, (WPARAM)hwndOldFocus, 0);
2837}
2838
2839 static void
2840_OnKillFocus(
2841 HWND hwnd,
2842 HWND hwndNewFocus)
2843{
2844 gui_focus_change(FALSE);
Bram Moolenaarea408882007-12-03 21:21:03 +00002845 s_getting_focus = FALSE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002846 (void)MyWindowProc(hwnd, WM_KILLFOCUS, (WPARAM)hwndNewFocus, 0);
2847}
2848
2849/*
2850 * Get a message when the user switches back to vim
2851 */
2852#ifdef WIN16
2853 static BOOL
2854#else
2855 static LRESULT
2856#endif
2857_OnActivateApp(
2858 HWND hwnd,
2859 BOOL fActivate,
2860#ifdef WIN16
2861 HTASK dwThreadId
2862#else
2863 DWORD dwThreadId
2864#endif
2865 )
2866{
2867 /* we call gui_focus_change() in _OnSetFocus() */
2868 /* gui_focus_change((int)fActivate); */
2869 return MyWindowProc(hwnd, WM_ACTIVATEAPP, fActivate, (DWORD)dwThreadId);
2870}
2871
2872#if defined(FEAT_WINDOWS) || defined(PROTO)
2873 void
2874gui_mch_destroy_scrollbar(scrollbar_T *sb)
2875{
2876 DestroyWindow(sb->id);
2877}
2878#endif
2879
2880/*
Bram Moolenaar9588a0f2005-01-08 21:45:39 +00002881 * Get current mouse coordinates in text window.
Bram Moolenaar071d4272004-06-13 20:20:40 +00002882 */
Bram Moolenaar9588a0f2005-01-08 21:45:39 +00002883 void
Bram Moolenaara40c5002005-01-09 21:16:21 +00002884gui_mch_getmouse(int *x, int *y)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002885{
2886 RECT rct;
2887 POINT mp;
2888
2889 (void)GetWindowRect(s_textArea, &rct);
2890 (void)GetCursorPos((LPPOINT)&mp);
Bram Moolenaar9588a0f2005-01-08 21:45:39 +00002891 *x = (int)(mp.x - rct.left);
2892 *y = (int)(mp.y - rct.top);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002893}
2894
2895/*
2896 * Move mouse pointer to character at (x, y).
2897 */
2898 void
2899gui_mch_setmouse(int x, int y)
2900{
2901 RECT rct;
2902
2903 (void)GetWindowRect(s_textArea, &rct);
2904 (void)SetCursorPos(x + gui.border_offset + rct.left,
2905 y + gui.border_offset + rct.top);
2906}
2907
2908 static void
2909gui_mswin_get_valid_dimensions(
2910 int w,
2911 int h,
2912 int *valid_w,
2913 int *valid_h)
2914{
2915 int base_width, base_height;
2916
2917 base_width = gui_get_base_width()
Bram Moolenaar9d488952013-07-21 17:53:58 +02002918 + (GetSystemMetrics(SM_CXFRAME) +
2919 GetSystemMetrics(SM_CXPADDEDBORDER)) * 2;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002920 base_height = gui_get_base_height()
Bram Moolenaar9d488952013-07-21 17:53:58 +02002921 + (GetSystemMetrics(SM_CYFRAME) +
2922 GetSystemMetrics(SM_CXPADDEDBORDER)) * 2
Bram Moolenaar071d4272004-06-13 20:20:40 +00002923 + GetSystemMetrics(SM_CYCAPTION)
2924#ifdef FEAT_MENU
2925 + gui_mswin_get_menu_height(FALSE)
2926#endif
2927 ;
2928 *valid_w = base_width +
2929 ((w - base_width) / gui.char_width) * gui.char_width;
2930 *valid_h = base_height +
2931 ((h - base_height) / gui.char_height) * gui.char_height;
2932}
2933
2934 void
Bram Moolenaar071d4272004-06-13 20:20:40 +00002935gui_mch_flash(int msec)
2936{
2937 RECT rc;
2938
2939 /*
2940 * Note: InvertRect() excludes right and bottom of rectangle.
2941 */
2942 rc.left = 0;
2943 rc.top = 0;
2944 rc.right = gui.num_cols * gui.char_width;
2945 rc.bottom = gui.num_rows * gui.char_height;
2946 InvertRect(s_hdc, &rc);
2947 gui_mch_flush(); /* make sure it's displayed */
2948
2949 ui_delay((long)msec, TRUE); /* wait for a few msec */
2950
2951 InvertRect(s_hdc, &rc);
2952}
2953
2954/*
2955 * Return flags used for scrolling.
2956 * The SW_INVALIDATE is required when part of the window is covered or
2957 * off-screen. Refer to MS KB Q75236.
2958 */
2959 static int
2960get_scroll_flags(void)
2961{
2962 HWND hwnd;
2963 RECT rcVim, rcOther, rcDest;
2964
2965 GetWindowRect(s_hwnd, &rcVim);
Bram Moolenaar0d406992005-05-22 22:03:39 +00002966
2967 /* Check if the window is partly above or below the screen. We don't care
2968 * about partly left or right of the screen, it is not relevant when
2969 * scrolling up or down. */
2970 if (rcVim.top < 0 || rcVim.bottom > GetSystemMetrics(SM_CYFULLSCREEN))
2971 return SW_INVALIDATE;
2972
2973 /* Check if there is an window (partly) on top of us. */
Bram Moolenaar071d4272004-06-13 20:20:40 +00002974 for (hwnd = s_hwnd; (hwnd = GetWindow(hwnd, GW_HWNDPREV)) != (HWND)0; )
2975 if (IsWindowVisible(hwnd))
2976 {
2977 GetWindowRect(hwnd, &rcOther);
2978 if (IntersectRect(&rcDest, &rcVim, &rcOther))
2979 return SW_INVALIDATE;
2980 }
2981 return 0;
2982}
2983
2984/*
2985 * Delete the given number of lines from the given row, scrolling up any
2986 * text further down within the scroll region.
2987 */
2988 void
2989gui_mch_delete_lines(
2990 int row,
2991 int num_lines)
2992{
2993 RECT rc;
2994
2995 rc.left = FILL_X(gui.scroll_region_left);
2996 rc.right = FILL_X(gui.scroll_region_right + 1);
2997 rc.top = FILL_Y(row);
2998 rc.bottom = FILL_Y(gui.scroll_region_bot + 1);
2999
3000 ScrollWindowEx(s_textArea, 0, -num_lines * gui.char_height,
3001 &rc, &rc, NULL, NULL, get_scroll_flags());
3002
3003 UpdateWindow(s_textArea);
3004 /* This seems to be required to avoid the cursor disappearing when
3005 * scrolling such that the cursor ends up in the top-left character on
3006 * the screen... But why? (Webb) */
3007 /* It's probably fixed by disabling drawing the cursor while scrolling. */
3008 /* gui.cursor_is_valid = FALSE; */
3009
3010 gui_clear_block(gui.scroll_region_bot - num_lines + 1,
3011 gui.scroll_region_left,
3012 gui.scroll_region_bot, gui.scroll_region_right);
3013}
3014
3015/*
3016 * Insert the given number of lines before the given row, scrolling down any
3017 * following text within the scroll region.
3018 */
3019 void
3020gui_mch_insert_lines(
3021 int row,
3022 int num_lines)
3023{
3024 RECT rc;
3025
3026 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 /* The SW_INVALIDATE is required when part of the window is covered or
3031 * off-screen. How do we avoid it when it's not needed? */
3032 ScrollWindowEx(s_textArea, 0, num_lines * gui.char_height,
3033 &rc, &rc, NULL, NULL, get_scroll_flags());
3034
3035 UpdateWindow(s_textArea);
3036
3037 gui_clear_block(row, gui.scroll_region_left,
3038 row + num_lines - 1, gui.scroll_region_right);
3039}
3040
3041
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00003042/*ARGSUSED*/
Bram Moolenaar071d4272004-06-13 20:20:40 +00003043 void
3044gui_mch_exit(int rc)
3045{
3046 ReleaseDC(s_textArea, s_hdc);
3047 DeleteObject(s_brush);
3048
3049#ifdef FEAT_TEAROFF
3050 /* Unload the tearoff bitmap */
3051 (void)DeleteObject((HGDIOBJ)s_htearbitmap);
3052#endif
3053
3054 /* Destroy our window (if we have one). */
3055 if (s_hwnd != NULL)
3056 {
3057 destroying = TRUE; /* ignore WM_DESTROY message now */
3058 DestroyWindow(s_hwnd);
3059 }
3060
3061#ifdef GLOBAL_IME
3062 global_ime_end();
3063#endif
3064}
3065
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00003066 static char_u *
3067logfont2name(LOGFONT lf)
3068{
3069 char *p;
3070 char *res;
3071 char *charset_name;
Bram Moolenaarb1692e22014-03-12 19:24:37 +01003072 char *font_name = lf.lfFaceName;
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00003073
3074 charset_name = charset_id2name((int)lf.lfCharSet);
Bram Moolenaarb1692e22014-03-12 19:24:37 +01003075#ifdef FEAT_MBYTE
3076 /* Convert a font name from the current codepage to 'encoding'.
3077 * TODO: Use Wide APIs (including LOGFONTW) instead of ANSI APIs. */
3078 if (enc_codepage >= 0 && (int)GetACP() != enc_codepage)
3079 {
3080 int len;
3081 acp_to_enc(lf.lfFaceName, strlen(lf.lfFaceName),
3082 (char_u **)&font_name, &len);
3083 }
3084#endif
3085 res = alloc((unsigned)(strlen(font_name) + 20
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00003086 + (charset_name == NULL ? 0 : strlen(charset_name) + 2)));
3087 if (res != NULL)
3088 {
3089 p = res;
3090 /* make a normal font string out of the lf thing:*/
Bram Moolenaarb1692e22014-03-12 19:24:37 +01003091 sprintf((char *)p, "%s:h%d", font_name, pixels_to_points(
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00003092 lf.lfHeight < 0 ? -lf.lfHeight : lf.lfHeight, TRUE));
3093 while (*p)
3094 {
3095 if (*p == ' ')
3096 *p = '_';
3097 ++p;
3098 }
3099#ifndef MSWIN16_FASTTEXT
3100 if (lf.lfItalic)
3101 STRCAT(p, ":i");
3102 if (lf.lfWeight >= FW_BOLD)
3103 STRCAT(p, ":b");
3104#endif
3105 if (lf.lfUnderline)
3106 STRCAT(p, ":u");
3107 if (lf.lfStrikeOut)
3108 STRCAT(p, ":s");
3109 if (charset_name != NULL)
3110 {
3111 STRCAT(p, ":c");
3112 STRCAT(p, charset_name);
3113 }
3114 }
3115
Bram Moolenaarb1692e22014-03-12 19:24:37 +01003116#ifdef FEAT_MBYTE
3117 if (font_name != lf.lfFaceName)
3118 vim_free(font_name);
3119#endif
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00003120 return res;
3121}
3122
Bram Moolenaar0f272122013-01-23 18:37:40 +01003123
3124#ifdef FEAT_MBYTE_IME
3125/*
3126 * Set correct LOGFONT to IME. Use 'guifontwide' if available, otherwise use
3127 * 'guifont'
3128 */
3129 static void
Bram Moolenaarfb97f282013-07-09 17:42:46 +02003130update_im_font(void)
Bram Moolenaar0f272122013-01-23 18:37:40 +01003131{
3132 LOGFONT lf_wide;
3133
3134 if (p_guifontwide != NULL && *p_guifontwide != NUL
Bram Moolenaar826763f2013-01-25 19:28:38 +01003135 && gui.wide_font != NOFONT
3136 && GetObject((HFONT)gui.wide_font, sizeof(lf_wide), &lf_wide))
Bram Moolenaar0f272122013-01-23 18:37:40 +01003137 norm_logfont = lf_wide;
3138 else
3139 norm_logfont = sub_logfont;
3140 im_set_font(&norm_logfont);
3141}
3142#endif
3143
3144#ifdef FEAT_MBYTE
3145/*
3146 * Handler of gui.wide_font (p_guifontwide) changed notification.
3147 */
3148 void
3149gui_mch_wide_font_changed()
3150{
Bram Moolenaardb250522013-06-17 22:43:25 +02003151# ifndef MSWIN16_FASTTEXT
3152 LOGFONT lf;
3153# endif
3154
Bram Moolenaar0f272122013-01-23 18:37:40 +01003155# ifdef FEAT_MBYTE_IME
3156 update_im_font();
3157# endif
Bram Moolenaardb250522013-06-17 22:43:25 +02003158
3159# ifndef MSWIN16_FASTTEXT
3160 gui_mch_free_font(gui.wide_ital_font);
3161 gui.wide_ital_font = NOFONT;
3162 gui_mch_free_font(gui.wide_bold_font);
3163 gui.wide_bold_font = NOFONT;
3164 gui_mch_free_font(gui.wide_boldital_font);
3165 gui.wide_boldital_font = NOFONT;
3166
3167 if (gui.wide_font
3168 && GetObject((HFONT)gui.wide_font, sizeof(lf), &lf))
3169 {
3170 if (!lf.lfItalic)
3171 {
3172 lf.lfItalic = TRUE;
3173 gui.wide_ital_font = get_font_handle(&lf);
3174 lf.lfItalic = FALSE;
3175 }
3176 if (lf.lfWeight < FW_BOLD)
3177 {
3178 lf.lfWeight = FW_BOLD;
3179 gui.wide_bold_font = get_font_handle(&lf);
3180 if (!lf.lfItalic)
3181 {
3182 lf.lfItalic = TRUE;
3183 gui.wide_boldital_font = get_font_handle(&lf);
3184 }
3185 }
3186 }
3187# endif
Bram Moolenaar0f272122013-01-23 18:37:40 +01003188}
3189#endif
3190
Bram Moolenaar071d4272004-06-13 20:20:40 +00003191/*
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00003192 * Initialise vim to use the font with the given name.
3193 * Return FAIL if the font could not be loaded, OK otherwise.
Bram Moolenaar071d4272004-06-13 20:20:40 +00003194 */
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00003195/*ARGSUSED*/
Bram Moolenaar071d4272004-06-13 20:20:40 +00003196 int
3197gui_mch_init_font(char_u *font_name, int fontset)
3198{
3199 LOGFONT lf;
3200 GuiFont font = NOFONT;
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00003201 char_u *p;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003202
3203 /* Load the font */
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00003204 if (get_logfont(&lf, font_name, NULL, TRUE) == OK)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003205 font = get_font_handle(&lf);
3206 if (font == NOFONT)
3207 return FAIL;
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00003208
Bram Moolenaar071d4272004-06-13 20:20:40 +00003209 if (font_name == NULL)
3210 font_name = lf.lfFaceName;
3211#if defined(FEAT_MBYTE_IME) || defined(GLOBAL_IME)
3212 norm_logfont = lf;
Bram Moolenaar0f272122013-01-23 18:37:40 +01003213 sub_logfont = lf;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003214#endif
3215#ifdef FEAT_MBYTE_IME
Bram Moolenaar0f272122013-01-23 18:37:40 +01003216 update_im_font();
Bram Moolenaar071d4272004-06-13 20:20:40 +00003217#endif
3218 gui_mch_free_font(gui.norm_font);
3219 gui.norm_font = font;
3220 current_font_height = lf.lfHeight;
3221 GetFontSize(font);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003222
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00003223 p = logfont2name(lf);
3224 if (p != NULL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003225 {
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00003226 hl_set_font_name(p);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003227
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00003228 /* When setting 'guifont' to "*" replace it with the actual font name.
3229 * */
3230 if (STRCMP(font_name, "*") == 0 && STRCMP(p_guifont, "*") == 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003231 {
Bram Moolenaar071d4272004-06-13 20:20:40 +00003232 vim_free(p_guifont);
3233 p_guifont = p;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003234 }
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00003235 else
3236 vim_free(p);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003237 }
3238
3239#ifndef MSWIN16_FASTTEXT
3240 gui_mch_free_font(gui.ital_font);
3241 gui.ital_font = NOFONT;
3242 gui_mch_free_font(gui.bold_font);
3243 gui.bold_font = NOFONT;
3244 gui_mch_free_font(gui.boldital_font);
3245 gui.boldital_font = NOFONT;
3246
3247 if (!lf.lfItalic)
3248 {
3249 lf.lfItalic = TRUE;
3250 gui.ital_font = get_font_handle(&lf);
3251 lf.lfItalic = FALSE;
3252 }
3253 if (lf.lfWeight < FW_BOLD)
3254 {
3255 lf.lfWeight = FW_BOLD;
3256 gui.bold_font = get_font_handle(&lf);
3257 if (!lf.lfItalic)
3258 {
3259 lf.lfItalic = TRUE;
3260 gui.boldital_font = get_font_handle(&lf);
3261 }
3262 }
3263#endif
3264
3265 return OK;
3266}
3267
Bram Moolenaar85f868c2006-11-28 16:16:58 +00003268#ifndef WPF_RESTORETOMAXIMIZED
3269# define WPF_RESTORETOMAXIMIZED 2 /* just in case someone doesn't have it */
3270#endif
3271
Bram Moolenaar071d4272004-06-13 20:20:40 +00003272/*
3273 * Return TRUE if the GUI window is maximized, filling the whole screen.
3274 */
3275 int
3276gui_mch_maximized()
3277{
Bram Moolenaar85f868c2006-11-28 16:16:58 +00003278 WINDOWPLACEMENT wp;
3279
3280 wp.length = sizeof(WINDOWPLACEMENT);
3281 if (GetWindowPlacement(s_hwnd, &wp))
3282 return wp.showCmd == SW_SHOWMAXIMIZED
3283 || (wp.showCmd == SW_SHOWMINIMIZED
3284 && wp.flags == WPF_RESTORETOMAXIMIZED);
3285
3286 return 0;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003287}
3288
3289/*
3290 * Called when the font changed while the window is maximized. Compute the
3291 * new Rows and Columns. This is like resizing the window.
3292 */
3293 void
3294gui_mch_newfont()
3295{
3296 RECT rect;
3297
3298 GetWindowRect(s_hwnd, &rect);
3299 gui_resize_shell(rect.right - rect.left
Bram Moolenaar9d488952013-07-21 17:53:58 +02003300 - (GetSystemMetrics(SM_CXFRAME) +
3301 GetSystemMetrics(SM_CXPADDEDBORDER)) * 2,
Bram Moolenaar071d4272004-06-13 20:20:40 +00003302 rect.bottom - rect.top
Bram Moolenaar9d488952013-07-21 17:53:58 +02003303 - (GetSystemMetrics(SM_CYFRAME) +
3304 GetSystemMetrics(SM_CXPADDEDBORDER)) * 2
Bram Moolenaar071d4272004-06-13 20:20:40 +00003305 - GetSystemMetrics(SM_CYCAPTION)
3306#ifdef FEAT_MENU
3307 - gui_mswin_get_menu_height(FALSE)
3308#endif
3309 );
3310}
3311
3312/*
3313 * Set the window title
3314 */
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00003315/*ARGSUSED*/
Bram Moolenaar071d4272004-06-13 20:20:40 +00003316 void
3317gui_mch_settitle(
3318 char_u *title,
3319 char_u *icon)
3320{
Bram Moolenaar908d53a2006-11-07 18:05:31 +00003321 set_window_title(s_hwnd, (title == NULL ? "VIM" : (char *)title));
Bram Moolenaar071d4272004-06-13 20:20:40 +00003322}
3323
3324#ifdef FEAT_MOUSESHAPE
3325/* Table for shape IDCs. Keep in sync with the mshape_names[] table in
3326 * misc2.c! */
3327static LPCSTR mshape_idcs[] =
3328{
Bram Moolenaaraf62ff32013-03-19 14:48:29 +01003329 IDC_ARROW, /* arrow */
3330 MAKEINTRESOURCE(0), /* blank */
3331 IDC_IBEAM, /* beam */
3332 IDC_SIZENS, /* updown */
3333 IDC_SIZENS, /* udsizing */
3334 IDC_SIZEWE, /* leftright */
3335 IDC_SIZEWE, /* lrsizing */
3336 IDC_WAIT, /* busy */
Bram Moolenaar071d4272004-06-13 20:20:40 +00003337#ifdef WIN3264
Bram Moolenaaraf62ff32013-03-19 14:48:29 +01003338 IDC_NO, /* no */
Bram Moolenaar071d4272004-06-13 20:20:40 +00003339#else
Bram Moolenaaraf62ff32013-03-19 14:48:29 +01003340 IDC_ICON, /* no */
Bram Moolenaar071d4272004-06-13 20:20:40 +00003341#endif
Bram Moolenaaraf62ff32013-03-19 14:48:29 +01003342 IDC_ARROW, /* crosshair */
3343 IDC_ARROW, /* hand1 */
3344 IDC_ARROW, /* hand2 */
3345 IDC_ARROW, /* pencil */
3346 IDC_ARROW, /* question */
3347 IDC_ARROW, /* right-arrow */
3348 IDC_UPARROW, /* up-arrow */
3349 IDC_ARROW /* last one */
Bram Moolenaar071d4272004-06-13 20:20:40 +00003350};
3351
3352 void
3353mch_set_mouse_shape(int shape)
3354{
3355 LPCSTR idc;
3356
3357 if (shape == MSHAPE_HIDE)
3358 ShowCursor(FALSE);
3359 else
3360 {
3361 if (shape >= MSHAPE_NUMBERED)
Bram Moolenaaraf62ff32013-03-19 14:48:29 +01003362 idc = IDC_ARROW;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003363 else
3364 idc = mshape_idcs[shape];
Bram Moolenaare6a91fd2008-07-24 18:51:11 +00003365#ifdef SetClassLongPtr
3366 SetClassLongPtr(s_textArea, GCLP_HCURSOR, (__int3264)(LONG_PTR)LoadCursor(NULL, idc));
Bram Moolenaar071d4272004-06-13 20:20:40 +00003367#else
3368# ifdef WIN32
Bram Moolenaare6a91fd2008-07-24 18:51:11 +00003369 SetClassLong(s_textArea, GCL_HCURSOR, (long_u)LoadCursor(NULL, idc));
3370# else /* Win16 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00003371 SetClassWord(s_textArea, GCW_HCURSOR, (WORD)LoadCursor(NULL, idc));
3372# endif
3373#endif
3374 if (!p_mh)
3375 {
3376 POINT mp;
3377
3378 /* Set the position to make it redrawn with the new shape. */
3379 (void)GetCursorPos((LPPOINT)&mp);
3380 (void)SetCursorPos(mp.x, mp.y);
3381 ShowCursor(TRUE);
3382 }
3383 }
3384}
3385#endif
3386
3387#ifdef FEAT_BROWSE
3388/*
3389 * The file browser exists in two versions: with "W" uses wide characters,
3390 * without "W" the current codepage. When FEAT_MBYTE is defined and on
3391 * Windows NT/2000/XP the "W" functions are used.
3392 */
3393
3394# if defined(FEAT_MBYTE) && defined(WIN3264)
3395/*
Bram Moolenaar3ef7cdf2012-01-20 17:57:51 +01003396 * Wide version of convert_filter().
Bram Moolenaar071d4272004-06-13 20:20:40 +00003397 */
3398 static WCHAR *
3399convert_filterW(char_u *s)
3400{
Bram Moolenaar3ef7cdf2012-01-20 17:57:51 +01003401 char_u *tmp;
3402 int len;
Bram Moolenaar90b28002012-01-20 20:54:19 +01003403 WCHAR *res;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003404
Bram Moolenaar3ef7cdf2012-01-20 17:57:51 +01003405 tmp = convert_filter(s);
3406 if (tmp == NULL)
3407 return NULL;
3408 len = (int)STRLEN(s) + 3;
3409 res = enc_to_utf16(tmp, &len);
3410 vim_free(tmp);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003411 return res;
3412}
3413
3414/*
3415 * Wide version of gui_mch_browse(). Keep in sync!
3416 */
3417 static char_u *
3418gui_mch_browseW(
3419 int saving,
3420 char_u *title,
3421 char_u *dflt,
3422 char_u *ext,
3423 char_u *initdir,
3424 char_u *filter)
3425{
Bram Moolenaar36f692d2008-11-20 16:10:17 +00003426 /* We always use the wide function. This means enc_to_utf16() must work,
Bram Moolenaar071d4272004-06-13 20:20:40 +00003427 * otherwise it fails miserably! */
3428 OPENFILENAMEW fileStruct;
3429 WCHAR fileBuf[MAXPATHL];
3430 WCHAR *wp;
3431 int i;
3432 WCHAR *titlep = NULL;
3433 WCHAR *extp = NULL;
3434 WCHAR *initdirp = NULL;
3435 WCHAR *filterp;
3436 char_u *p;
3437
3438 if (dflt == NULL)
3439 fileBuf[0] = NUL;
3440 else
3441 {
Bram Moolenaar36f692d2008-11-20 16:10:17 +00003442 wp = enc_to_utf16(dflt, NULL);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003443 if (wp == NULL)
3444 fileBuf[0] = NUL;
3445 else
3446 {
3447 for (i = 0; wp[i] != NUL && i < MAXPATHL - 1; ++i)
3448 fileBuf[i] = wp[i];
3449 fileBuf[i] = NUL;
3450 vim_free(wp);
3451 }
3452 }
3453
3454 /* Convert the filter to Windows format. */
3455 filterp = convert_filterW(filter);
3456
Bram Moolenaar7db5fc82010-05-24 11:59:29 +02003457 vim_memset(&fileStruct, 0, sizeof(OPENFILENAMEW));
Bram Moolenaar071d4272004-06-13 20:20:40 +00003458#ifdef OPENFILENAME_SIZE_VERSION_400
3459 /* be compatible with Windows NT 4.0 */
3460 /* TODO: what to use for OPENFILENAMEW??? */
Bram Moolenaar8c83ac32010-02-17 17:34:43 +01003461 fileStruct.lStructSize = OPENFILENAME_SIZE_VERSION_400;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003462#else
3463 fileStruct.lStructSize = sizeof(fileStruct);
3464#endif
3465
3466 if (title != NULL)
Bram Moolenaar36f692d2008-11-20 16:10:17 +00003467 titlep = enc_to_utf16(title, NULL);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003468 fileStruct.lpstrTitle = titlep;
3469
3470 if (ext != NULL)
Bram Moolenaar36f692d2008-11-20 16:10:17 +00003471 extp = enc_to_utf16(ext, NULL);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003472 fileStruct.lpstrDefExt = extp;
3473
3474 fileStruct.lpstrFile = fileBuf;
3475 fileStruct.nMaxFile = MAXPATHL;
3476 fileStruct.lpstrFilter = filterp;
3477 fileStruct.hwndOwner = s_hwnd; /* main Vim window is owner*/
3478 /* has an initial dir been specified? */
3479 if (initdir != NULL && *initdir != NUL)
3480 {
3481 /* Must have backslashes here, no matter what 'shellslash' says */
Bram Moolenaar36f692d2008-11-20 16:10:17 +00003482 initdirp = enc_to_utf16(initdir, NULL);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003483 if (initdirp != NULL)
3484 {
3485 for (wp = initdirp; *wp != NUL; ++wp)
3486 if (*wp == '/')
3487 *wp = '\\';
3488 }
3489 fileStruct.lpstrInitialDir = initdirp;
3490 }
3491
3492 /*
3493 * TODO: Allow selection of multiple files. Needs another arg to this
3494 * function to ask for it, and need to use OFN_ALLOWMULTISELECT below.
3495 * Also, should we use OFN_FILEMUSTEXIST when opening? Vim can edit on
3496 * files that don't exist yet, so I haven't put it in. What about
3497 * OFN_PATHMUSTEXIST?
3498 * Don't use OFN_OVERWRITEPROMPT, Vim has its own ":confirm" dialog.
3499 */
3500 fileStruct.Flags = (OFN_NOCHANGEDIR | OFN_PATHMUSTEXIST | OFN_HIDEREADONLY);
3501#ifdef FEAT_SHORTCUT
3502 if (curbuf->b_p_bin)
3503 fileStruct.Flags |= OFN_NODEREFERENCELINKS;
3504#endif
3505 if (saving)
3506 {
3507 if (!GetSaveFileNameW(&fileStruct))
3508 return NULL;
3509 }
3510 else
3511 {
3512 if (!GetOpenFileNameW(&fileStruct))
3513 return NULL;
3514 }
3515
3516 vim_free(filterp);
3517 vim_free(initdirp);
3518 vim_free(titlep);
3519 vim_free(extp);
3520
3521 /* Convert from UCS2 to 'encoding'. */
Bram Moolenaar36f692d2008-11-20 16:10:17 +00003522 p = utf16_to_enc(fileBuf, NULL);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003523 if (p != NULL)
3524 /* when out of memory we get garbage for non-ASCII chars */
3525 STRCPY(fileBuf, p);
3526 vim_free(p);
3527
3528 /* Give focus back to main window (when using MDI). */
3529 SetFocus(s_hwnd);
3530
3531 /* Shorten the file name if possible */
Bram Moolenaard089d9b2007-09-30 12:02:55 +00003532 return vim_strsave(shorten_fname1((char_u *)fileBuf));
Bram Moolenaar071d4272004-06-13 20:20:40 +00003533}
3534# endif /* FEAT_MBYTE */
3535
3536
3537/*
3538 * Convert the string s to the proper format for a filter string by replacing
Bram Moolenaar12806c82008-11-12 12:36:30 +00003539 * the \t and \n delimiters with \0.
Bram Moolenaar071d4272004-06-13 20:20:40 +00003540 * Returns the converted string in allocated memory.
3541 *
3542 * Keep in sync with convert_filterW() above!
3543 */
3544 static char_u *
3545convert_filter(char_u *s)
3546{
3547 char_u *res;
3548 unsigned s_len = (unsigned)STRLEN(s);
3549 unsigned i;
3550
3551 res = alloc(s_len + 3);
3552 if (res != NULL)
3553 {
3554 for (i = 0; i < s_len; ++i)
3555 if (s[i] == '\t' || s[i] == '\n')
3556 res[i] = '\0';
3557 else
3558 res[i] = s[i];
3559 res[s_len] = NUL;
3560 /* Add two extra NULs to make sure it's properly terminated. */
3561 res[s_len + 1] = NUL;
3562 res[s_len + 2] = NUL;
3563 }
3564 return res;
3565}
3566
3567/*
Bram Moolenaar7171abe2004-10-11 10:06:20 +00003568 * Select a directory.
3569 */
3570 char_u *
3571gui_mch_browsedir(char_u *title, char_u *initdir)
3572{
3573 /* We fake this: Use a filter that doesn't select anything and a default
3574 * file name that won't be used. */
3575 return gui_mch_browse(0, title, (char_u *)_("Not Used"), NULL,
3576 initdir, (char_u *)_("Directory\t*.nothing\n"));
3577}
3578
3579/*
Bram Moolenaar071d4272004-06-13 20:20:40 +00003580 * Pop open a file browser and return the file selected, in allocated memory,
3581 * or NULL if Cancel is hit.
3582 * saving - TRUE if the file will be saved to, FALSE if it will be opened.
3583 * title - Title message for the file browser dialog.
3584 * dflt - Default name of file.
3585 * ext - Default extension to be added to files without extensions.
3586 * initdir - directory in which to open the browser (NULL = current dir)
3587 * filter - Filter for matched files to choose from.
3588 *
3589 * Keep in sync with gui_mch_browseW() above!
3590 */
3591 char_u *
3592gui_mch_browse(
3593 int saving,
3594 char_u *title,
3595 char_u *dflt,
3596 char_u *ext,
3597 char_u *initdir,
3598 char_u *filter)
3599{
3600 OPENFILENAME fileStruct;
3601 char_u fileBuf[MAXPATHL];
3602 char_u *initdirp = NULL;
3603 char_u *filterp;
3604 char_u *p;
3605
3606# if defined(FEAT_MBYTE) && defined(WIN3264)
3607 if (os_version.dwPlatformId == VER_PLATFORM_WIN32_NT)
3608 return gui_mch_browseW(saving, title, dflt, ext, initdir, filter);
3609# endif
3610
3611 if (dflt == NULL)
3612 fileBuf[0] = NUL;
3613 else
Bram Moolenaarfe3ca8d2005-07-18 21:43:02 +00003614 vim_strncpy(fileBuf, dflt, MAXPATHL - 1);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003615
3616 /* Convert the filter to Windows format. */
3617 filterp = convert_filter(filter);
3618
Bram Moolenaar7db5fc82010-05-24 11:59:29 +02003619 vim_memset(&fileStruct, 0, sizeof(OPENFILENAME));
Bram Moolenaar071d4272004-06-13 20:20:40 +00003620#ifdef OPENFILENAME_SIZE_VERSION_400
3621 /* be compatible with Windows NT 4.0 */
Bram Moolenaar8c83ac32010-02-17 17:34:43 +01003622 fileStruct.lStructSize = OPENFILENAME_SIZE_VERSION_400;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003623#else
3624 fileStruct.lStructSize = sizeof(fileStruct);
3625#endif
3626
3627 fileStruct.lpstrTitle = title;
3628 fileStruct.lpstrDefExt = ext;
3629
3630 fileStruct.lpstrFile = fileBuf;
3631 fileStruct.nMaxFile = MAXPATHL;
3632 fileStruct.lpstrFilter = filterp;
3633 fileStruct.hwndOwner = s_hwnd; /* main Vim window is owner*/
3634 /* has an initial dir been specified? */
3635 if (initdir != NULL && *initdir != NUL)
3636 {
3637 /* Must have backslashes here, no matter what 'shellslash' says */
3638 initdirp = vim_strsave(initdir);
3639 if (initdirp != NULL)
3640 for (p = initdirp; *p != NUL; ++p)
3641 if (*p == '/')
3642 *p = '\\';
3643 fileStruct.lpstrInitialDir = initdirp;
3644 }
3645
3646 /*
3647 * TODO: Allow selection of multiple files. Needs another arg to this
3648 * function to ask for it, and need to use OFN_ALLOWMULTISELECT below.
3649 * Also, should we use OFN_FILEMUSTEXIST when opening? Vim can edit on
3650 * files that don't exist yet, so I haven't put it in. What about
3651 * OFN_PATHMUSTEXIST?
3652 * Don't use OFN_OVERWRITEPROMPT, Vim has its own ":confirm" dialog.
3653 */
3654 fileStruct.Flags = (OFN_NOCHANGEDIR | OFN_PATHMUSTEXIST | OFN_HIDEREADONLY);
3655#ifdef FEAT_SHORTCUT
3656 if (curbuf->b_p_bin)
3657 fileStruct.Flags |= OFN_NODEREFERENCELINKS;
3658#endif
3659 if (saving)
3660 {
3661 if (!GetSaveFileName(&fileStruct))
3662 return NULL;
3663 }
3664 else
3665 {
3666 if (!GetOpenFileName(&fileStruct))
3667 return NULL;
3668 }
3669
3670 vim_free(filterp);
3671 vim_free(initdirp);
3672
3673 /* Give focus back to main window (when using MDI). */
3674 SetFocus(s_hwnd);
3675
3676 /* Shorten the file name if possible */
Bram Moolenaard089d9b2007-09-30 12:02:55 +00003677 return vim_strsave(shorten_fname1((char_u *)fileBuf));
Bram Moolenaar071d4272004-06-13 20:20:40 +00003678}
3679#endif /* FEAT_BROWSE */
3680
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00003681/*ARGSUSED*/
Bram Moolenaar071d4272004-06-13 20:20:40 +00003682 static void
3683_OnDropFiles(
3684 HWND hwnd,
3685 HDROP hDrop)
3686{
3687#ifdef FEAT_WINDOWS
3688#ifdef WIN3264
3689# define BUFPATHLEN _MAX_PATH
3690# define DRAGQVAL 0xFFFFFFFF
3691#else
3692# define BUFPATHLEN MAXPATHL
3693# define DRAGQVAL 0xFFFF
3694#endif
3695#ifdef FEAT_MBYTE
3696 WCHAR wszFile[BUFPATHLEN];
3697#endif
3698 char szFile[BUFPATHLEN];
3699 UINT cFiles = DragQueryFile(hDrop, DRAGQVAL, NULL, 0);
3700 UINT i;
3701 char_u **fnames;
3702 POINT pt;
3703 int_u modifiers = 0;
3704
3705 /* TRACE("_OnDropFiles: %d files dropped\n", cFiles); */
3706
3707 /* Obtain dropped position */
3708 DragQueryPoint(hDrop, &pt);
3709 MapWindowPoints(s_hwnd, s_textArea, &pt, 1);
3710
3711# ifdef FEAT_VISUAL
3712 reset_VIsual();
3713# endif
3714
3715 fnames = (char_u **)alloc(cFiles * sizeof(char_u *));
3716
3717 if (fnames != NULL)
3718 for (i = 0; i < cFiles; ++i)
3719 {
3720#ifdef FEAT_MBYTE
3721 if (DragQueryFileW(hDrop, i, wszFile, BUFPATHLEN) > 0)
Bram Moolenaar36f692d2008-11-20 16:10:17 +00003722 fnames[i] = utf16_to_enc(wszFile, NULL);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003723 else
3724#endif
3725 {
3726 DragQueryFile(hDrop, i, szFile, BUFPATHLEN);
3727 fnames[i] = vim_strsave(szFile);
3728 }
3729 }
3730
3731 DragFinish(hDrop);
3732
3733 if (fnames != NULL)
3734 {
3735 if ((GetKeyState(VK_SHIFT) & 0x8000) != 0)
3736 modifiers |= MOUSE_SHIFT;
3737 if ((GetKeyState(VK_CONTROL) & 0x8000) != 0)
3738 modifiers |= MOUSE_CTRL;
3739 if ((GetKeyState(VK_MENU) & 0x8000) != 0)
3740 modifiers |= MOUSE_ALT;
3741
3742 gui_handle_drop(pt.x, pt.y, modifiers, fnames, cFiles);
3743
3744 s_need_activate = TRUE;
3745 }
3746#endif
3747}
3748
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00003749/*ARGSUSED*/
Bram Moolenaar071d4272004-06-13 20:20:40 +00003750 static int
3751_OnScroll(
3752 HWND hwnd,
3753 HWND hwndCtl,
3754 UINT code,
3755 int pos)
3756{
3757 static UINT prev_code = 0; /* code of previous call */
3758 scrollbar_T *sb, *sb_info;
3759 long val;
3760 int dragging = FALSE;
3761 int dont_scroll_save = dont_scroll;
3762#ifndef WIN3264
3763 int nPos;
3764#else
3765 SCROLLINFO si;
3766
3767 si.cbSize = sizeof(si);
3768 si.fMask = SIF_POS;
3769#endif
3770
3771 sb = gui_mswin_find_scrollbar(hwndCtl);
3772 if (sb == NULL)
3773 return 0;
3774
3775 if (sb->wp != NULL) /* Left or right scrollbar */
3776 {
3777 /*
3778 * Careful: need to get scrollbar info out of first (left) scrollbar
3779 * for window, but keep real scrollbar too because we must pass it to
3780 * gui_drag_scrollbar().
3781 */
3782 sb_info = &sb->wp->w_scrollbars[0];
3783 }
3784 else /* Bottom scrollbar */
3785 sb_info = sb;
3786 val = sb_info->value;
3787
3788 switch (code)
3789 {
3790 case SB_THUMBTRACK:
3791 val = pos;
3792 dragging = TRUE;
3793 if (sb->scroll_shift > 0)
3794 val <<= sb->scroll_shift;
3795 break;
3796 case SB_LINEDOWN:
3797 val++;
3798 break;
3799 case SB_LINEUP:
3800 val--;
3801 break;
3802 case SB_PAGEDOWN:
3803 val += (sb_info->size > 2 ? sb_info->size - 2 : 1);
3804 break;
3805 case SB_PAGEUP:
3806 val -= (sb_info->size > 2 ? sb_info->size - 2 : 1);
3807 break;
3808 case SB_TOP:
3809 val = 0;
3810 break;
3811 case SB_BOTTOM:
3812 val = sb_info->max;
3813 break;
3814 case SB_ENDSCROLL:
3815 if (prev_code == SB_THUMBTRACK)
3816 {
3817 /*
3818 * "pos" only gives us 16-bit data. In case of large file,
3819 * use GetScrollPos() which returns 32-bit. Unfortunately it
3820 * is not valid while the scrollbar is being dragged.
3821 */
3822 val = GetScrollPos(hwndCtl, SB_CTL);
3823 if (sb->scroll_shift > 0)
3824 val <<= sb->scroll_shift;
3825 }
3826 break;
3827
3828 default:
3829 /* TRACE("Unknown scrollbar event %d\n", code); */
3830 return 0;
3831 }
3832 prev_code = code;
3833
3834#ifdef WIN3264
3835 si.nPos = (sb->scroll_shift > 0) ? val >> sb->scroll_shift : val;
3836 SetScrollInfo(hwndCtl, SB_CTL, &si, TRUE);
3837#else
3838 nPos = (sb->scroll_shift > 0) ? val >> sb->scroll_shift : val;
3839 SetScrollPos(hwndCtl, SB_CTL, nPos, TRUE);
3840#endif
3841
3842 /*
3843 * When moving a vertical scrollbar, move the other vertical scrollbar too.
3844 */
3845 if (sb->wp != NULL)
3846 {
3847 scrollbar_T *sba = sb->wp->w_scrollbars;
3848 HWND id = sba[ (sb == sba + SBAR_LEFT) ? SBAR_RIGHT : SBAR_LEFT].id;
3849
3850#ifdef WIN3264
3851 SetScrollInfo(id, SB_CTL, &si, TRUE);
3852#else
3853 SetScrollPos(id, SB_CTL, nPos, TRUE);
3854#endif
3855 }
3856
3857 /* Don't let us be interrupted here by another message. */
3858 s_busy_processing = TRUE;
3859
3860 /* When "allow_scrollbar" is FALSE still need to remember the new
3861 * position, but don't actually scroll by setting "dont_scroll". */
3862 dont_scroll = !allow_scrollbar;
3863
3864 gui_drag_scrollbar(sb, val, dragging);
3865
3866 s_busy_processing = FALSE;
3867 dont_scroll = dont_scroll_save;
3868
3869 return 0;
3870}
3871
Bram Moolenaar3fdfa4a2004-10-07 21:02:47 +00003872
Bram Moolenaar071d4272004-06-13 20:20:40 +00003873/*
3874 * Get command line arguments.
3875 * Use "prog" as the name of the program and "cmdline" as the arguments.
3876 * Copy the arguments to allocated memory.
3877 * Return the number of arguments (including program name).
Bram Moolenaar12806c82008-11-12 12:36:30 +00003878 * Return pointers to the arguments in "argvp". Memory is allocated with
3879 * malloc(), use free() instead of vim_free().
Bram Moolenaar071d4272004-06-13 20:20:40 +00003880 * Return pointer to buffer in "tofree".
3881 * Returns zero when out of memory.
3882 */
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00003883/*ARGSUSED*/
Bram Moolenaar071d4272004-06-13 20:20:40 +00003884 int
3885get_cmd_args(char *prog, char *cmdline, char ***argvp, char **tofree)
3886{
3887 int i;
3888 char *p;
3889 char *progp;
3890 char *pnew = NULL;
3891 char *newcmdline;
3892 int inquote;
3893 int argc;
3894 char **argv = NULL;
3895 int round;
3896
Bram Moolenaar12806c82008-11-12 12:36:30 +00003897 *tofree = NULL;
3898
Bram Moolenaar3fdfa4a2004-10-07 21:02:47 +00003899#ifdef FEAT_MBYTE
3900 /* Try using the Unicode version first, it takes care of conversion when
3901 * 'encoding' is changed. */
3902 argc = get_cmd_argsW(&argv);
3903 if (argc != 0)
3904 goto done;
3905#endif
3906
Bram Moolenaar071d4272004-06-13 20:20:40 +00003907 /* Handle the program name. Remove the ".exe" extension, and find the 1st
3908 * non-space. */
3909 p = strrchr(prog, '.');
3910 if (p != NULL)
3911 *p = NUL;
3912 for (progp = prog; *progp == ' '; ++progp)
3913 ;
3914
3915 /* The command line is copied to allocated memory, so that we can change
3916 * it. Add the size of the string, the separating NUL and a terminating
3917 * NUL. */
3918 newcmdline = malloc(STRLEN(cmdline) + STRLEN(progp) + 2);
3919 if (newcmdline == NULL)
3920 return 0;
3921
3922 /*
3923 * First round: count the number of arguments ("pnew" == NULL).
3924 * Second round: produce the arguments.
3925 */
3926 for (round = 1; round <= 2; ++round)
3927 {
3928 /* First argument is the program name. */
3929 if (pnew != NULL)
3930 {
3931 argv[0] = pnew;
3932 strcpy(pnew, progp);
3933 pnew += strlen(pnew);
3934 *pnew++ = NUL;
3935 }
3936
3937 /*
3938 * Isolate each argument and put it in argv[].
3939 */
3940 p = cmdline;
3941 argc = 1;
3942 while (*p != NUL)
3943 {
3944 inquote = FALSE;
3945 if (pnew != NULL)
3946 argv[argc] = pnew;
3947 ++argc;
3948 while (*p != NUL && (inquote || (*p != ' ' && *p != '\t')))
3949 {
3950 /* Backslashes are only special when followed by a double
3951 * quote. */
Bram Moolenaara93fa7e2006-04-17 22:14:47 +00003952 i = (int)strspn(p, "\\");
Bram Moolenaar071d4272004-06-13 20:20:40 +00003953 if (p[i] == '"')
3954 {
3955 /* Halve the number of backslashes. */
3956 if (i > 1 && pnew != NULL)
3957 {
Bram Moolenaar7db5fc82010-05-24 11:59:29 +02003958 vim_memset(pnew, '\\', i / 2);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003959 pnew += i / 2;
3960 }
3961
3962 /* Even nr of backslashes toggles quoting, uneven copies
3963 * the double quote. */
3964 if ((i & 1) == 0)
3965 inquote = !inquote;
3966 else if (pnew != NULL)
3967 *pnew++ = '"';
3968 p += i + 1;
3969 }
3970 else if (i > 0)
3971 {
3972 /* Copy span of backslashes unmodified. */
3973 if (pnew != NULL)
3974 {
Bram Moolenaar7db5fc82010-05-24 11:59:29 +02003975 vim_memset(pnew, '\\', i);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003976 pnew += i;
3977 }
3978 p += i;
3979 }
3980 else
3981 {
3982 if (pnew != NULL)
3983 *pnew++ = *p;
Bram Moolenaar15d0a8c2004-09-06 17:44:46 +00003984#ifdef FEAT_MBYTE
3985 /* Can't use mb_* functions, because 'encoding' is not
3986 * initialized yet here. */
3987 if (IsDBCSLeadByte(*p))
3988 {
3989 ++p;
3990 if (pnew != NULL)
3991 *pnew++ = *p;
3992 }
3993#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00003994 ++p;
3995 }
3996 }
3997
Bram Moolenaar9ba0eb82005-06-13 22:28:56 +00003998 if (pnew != NULL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003999 *pnew++ = NUL;
4000 while (*p == ' ' || *p == '\t')
4001 ++p; /* advance until a non-space */
4002 }
4003
4004 if (round == 1)
4005 {
4006 argv = (char **)malloc((argc + 1) * sizeof(char *));
4007 if (argv == NULL )
Bram Moolenaare6b165e2005-06-30 21:56:01 +00004008 {
Bram Moolenaar12806c82008-11-12 12:36:30 +00004009 free(newcmdline);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004010 return 0; /* malloc error */
Bram Moolenaare6b165e2005-06-30 21:56:01 +00004011 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00004012 pnew = newcmdline;
Bram Moolenaar12806c82008-11-12 12:36:30 +00004013 *tofree = newcmdline;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004014 }
4015 }
4016
Bram Moolenaar8765a4a2010-07-27 22:41:43 +02004017#ifdef FEAT_MBYTE
Bram Moolenaar3fdfa4a2004-10-07 21:02:47 +00004018done:
Bram Moolenaar8765a4a2010-07-27 22:41:43 +02004019#endif
Bram Moolenaar3fdfa4a2004-10-07 21:02:47 +00004020 argv[argc] = NULL; /* NULL-terminated list */
Bram Moolenaar071d4272004-06-13 20:20:40 +00004021 *argvp = argv;
4022 return argc;
4023}