Mercurial > vim

comparison src/gui_w16.c @ 7:3fc0f57ecb91 v7.0001

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
updated for version 7.0001
author vimboss
date Sun, 13 Jun 2004 20:20:40 +0000
parents
children 80000fb16feb
comparison
equal deleted inserted replaced
6:c2daee826b8f 7:3fc0f57ecb91
1 /* 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_w16.c
12 *
13 * GUI support for Microsoft Windows 3.1x
14 *
15 * George V. Reilly <george@reilly.org> wrote the original Win32 GUI.
16 * Robert Webb reworked it to use the existing GUI stuff and added menu,
17 * scrollbars, etc.
18 *
19 * Vince Negri then butchered the code to get it compiling for
20 * 16-bit windows.
21 *
22 */
23
24 /*
25 * Include the common stuff for MS-Windows GUI.
26 */
27 #include "gui_w48.c"
28
29 #include "guiw16rc.h"
30
31 /* Undocumented Windows Message - not even defined in some SDK headers */
32 #define WM_EXITSIZEMOVE 0x0232
33
34
35 #ifdef FEAT_TOOLBAR
36 # define CMD_TB_BASE (99)
37 # include <vimtbar.h>
38 #endif
39
40 #ifdef PROTO
41 # define WINAPI
42 #endif
43
44 #define HANDLE_WM_DROPFILES(hwnd, wParam, lParam, fn) \
45 ((fn)((hwnd), (HDROP)(wParam)), 0L)
46
47
48 /* Local variables: */
49
50 #ifdef FEAT_MENU
51 static UINT s_menu_id = 100;
52 #endif
53
54
55 #define VIM_NAME "vim"
56 #define VIM_CLASS "Vim"
57
58 #define DLG_ALLOC_SIZE 16 * 1024
59
60 /*
61 * stuff for dialogs, menus, tearoffs etc.
62 */
63 #if defined(FEAT_GUI_DIALOG) || defined(PROTO)
64 static BOOL CALLBACK dialog_callback(HWND, UINT, WPARAM, LPARAM);
65
66 static LPWORD
67 add_dialog_element(
68 LPWORD p,
69 DWORD lStyle,
70 WORD x,
71 WORD y,
72 WORD w,
73 WORD h,
74 WORD Id,
75 BYTE clss,
76 const char *caption);
77
78 static int dialog_default_button = -1;
79 #endif
80
81 static void get_dialog_font_metrics(void);
82
83 #ifdef FEAT_TOOLBAR
84 static void initialise_toolbar(void);
85 #endif
86
87
88 #ifdef FEAT_MENU
89 /*
90 * Figure out how high the menu bar is at the moment.
91 */
92 static int
93 gui_mswin_get_menu_height(
94 int fix_window) /* If TRUE, resize window if menu height changed */
95 {
96 static int old_menu_height = -1;
97
98 int num;
99 int menu_height;
100
101 if (gui.menu_is_active)
102 num = GetMenuItemCount(s_menuBar);
103 else
104 num = 0;
105
106 if (num == 0)
107 menu_height = 0;
108 else if (gui.starting)
109 menu_height = GetSystemMetrics(SM_CYMENU);
110 else
111 {
112 RECT r1, r2;
113 int frameht = GetSystemMetrics(SM_CYFRAME);
114 int capht = GetSystemMetrics(SM_CYCAPTION);
115
116 /* get window rect of s_hwnd
117 * get client rect of s_hwnd
118 * get cap height
119 * subtract from window rect, the sum of client height,
120 * (if not maximized)frame thickness, and caption height.
121 */
122 GetWindowRect(s_hwnd, &r1);
123 GetClientRect(s_hwnd, &r2);
124 menu_height = r1.bottom - r1.top - (r2.bottom-r2.top +
125 2 * frameht * (!IsZoomed(s_hwnd)) + capht);
126 }
127
128 if (fix_window && menu_height != old_menu_height)
129 {
130 old_menu_height = menu_height;
131 gui_set_shellsize(FALSE, FALSE);
132 }
133
134 return menu_height;
135 }
136 #endif /*FEAT_MENU*/
137
138
139 /*
140 * Even though we have _DuringSizing() which makes the rubber band a valid
141 * size, we need this for when the user maximises the window.
142 * TODO: Doesn't seem to adjust the width though for some reason.
143 */
144 static BOOL
145 _OnWindowPosChanging(
146 HWND hwnd,
147 LPWINDOWPOS lpwpos)
148 {
149
150 if (!IsIconic(hwnd) && !(lpwpos->flags & SWP_NOSIZE))
151 {
152 gui_mswin_get_valid_dimensions(lpwpos->cx, lpwpos->cy,
153 &lpwpos->cx, &lpwpos->cy);
154 }
155 return 0;
156 }
157
158
159
160
161
162 static LRESULT CALLBACK
163 _WndProc(
164 HWND hwnd,
165 UINT uMsg,
166 WPARAM wParam,
167 LPARAM lParam)
168 {
169 /*
170 TRACE("WndProc: hwnd = %08x, msg = %x, wParam = %x, lParam = %x\n",
171 hwnd, uMsg, wParam, lParam);
172 */
173
174 HandleMouseHide(uMsg, lParam);
175
176 s_uMsg = uMsg;
177 s_wParam = wParam;
178 s_lParam = lParam;
179
180 switch (uMsg)
181 {
182 HANDLE_MSG(hwnd, WM_DEADCHAR, _OnDeadChar);
183 HANDLE_MSG(hwnd, WM_SYSDEADCHAR, _OnDeadChar);
184 /* HANDLE_MSG(hwnd, WM_ACTIVATE, _OnActivate); */
185 HANDLE_MSG(hwnd, WM_CHAR, _OnChar);
186 HANDLE_MSG(hwnd, WM_CLOSE, _OnClose);
187 /* HANDLE_MSG(hwnd, WM_COMMAND, _OnCommand); */
188 HANDLE_MSG(hwnd, WM_DESTROY, _OnDestroy);
189 HANDLE_MSG(hwnd, WM_DROPFILES, _OnDropFiles);
190 HANDLE_MSG(hwnd, WM_HSCROLL, _OnScroll);
191 HANDLE_MSG(hwnd, WM_KILLFOCUS, _OnKillFocus);
192 #ifdef FEAT_MENU
193 HANDLE_MSG(hwnd, WM_COMMAND, _OnMenu);
194 #endif
195 /* HANDLE_MSG(hwnd, WM_MOVE, _OnMove); */
196 /* HANDLE_MSG(hwnd, WM_NCACTIVATE, _OnNCActivate); */
197 HANDLE_MSG(hwnd, WM_SETFOCUS, _OnSetFocus);
198 HANDLE_MSG(hwnd, WM_SIZE, _OnSize);
199 /* HANDLE_MSG(hwnd, WM_SYSCOMMAND, _OnSysCommand); */
200 /* HANDLE_MSG(hwnd, WM_SYSKEYDOWN, _OnAltKey); */
201 HANDLE_MSG(hwnd, WM_VSCROLL, _OnScroll);
202 HANDLE_MSG(hwnd, WM_WINDOWPOSCHANGING, _OnWindowPosChanging);
203 HANDLE_MSG(hwnd, WM_ACTIVATEAPP, _OnActivateApp);
204
205 case WM_QUERYENDSESSION: /* System wants to go down. */
206 gui_shell_closed(); /* Will exit when no changed buffers. */
207 return FALSE; /* Do NOT allow system to go down. */
208
209 case WM_ENDSESSION:
210 if (wParam) /* system only really goes down when wParam is TRUE */
211 _OnEndSession();
212 break;
213
214 case WM_SYSCHAR:
215 /*
216 * if 'winaltkeys' is "no", or it's "menu" and it's not a menu
217 * shortcut key, handle like a typed ALT key, otherwise call Windows
218 * ALT key handling.
219 */
220 #ifdef FEAT_MENU
221 if ( !gui.menu_is_active
222 || p_wak[0] == 'n'
223 || (p_wak[0] == 'm' && !gui_is_menu_shortcut((int)wParam))
224 )
225 #endif
226 return HANDLE_WM_SYSCHAR((hwnd), (wParam), (lParam), (_OnSysChar));
227 #ifdef FEAT_MENU
228 else
229 return MyWindowProc(hwnd, uMsg, wParam, lParam);
230 #endif
231
232 case WM_SYSKEYUP:
233 #ifdef FEAT_MENU
234 /* Only when menu is active, ALT key is used for that. */
235 if (gui.menu_is_active)
236 {
237 return MyWindowProc(hwnd, uMsg, wParam, lParam);
238 }
239 else
240 #endif
241 return 0;
242
243 #if defined(MENUHINTS) && defined(FEAT_MENU)
244 case WM_MENUSELECT:
245 if (((UINT) LOWORD(lParam)
246 & (0xffff ^ (MF_MOUSESELECT + MF_BITMAP + MF_POPUP)))
247 == MF_HILITE
248 && (State & CMDLINE) == 0)
249 {
250 UINT idButton;
251 int idx;
252 vimmenu_T *pMenu;
253
254 idButton = (UINT)LOWORD(wParam);
255 pMenu = gui_mswin_find_menu(root_menu, idButton);
256 if (pMenu)
257 {
258 idx = MENU_INDEX_TIP;
259 msg_clr_cmdline();
260 if (pMenu->strings[idx])
261 msg(pMenu->strings[idx]);
262 else
263 msg("");
264 setcursor();
265 out_flush();
266 }
267 }
268 break;
269 #endif
270 case WM_NCHITTEST:
271 {
272 LRESULT result;
273 int x, y;
274 int xPos = GET_X_LPARAM(lParam);
275
276 result = MyWindowProc(hwnd, uMsg, wParam, lParam);
277 if (result == HTCLIENT)
278 {
279 gui_mch_get_winpos(&x, &y);
280 xPos -= x;
281
282 if (xPos < 48) /*<VN> TODO should use system metric?*/
283 return HTBOTTOMLEFT;
284 else
285 return HTBOTTOMRIGHT;
286 }
287 else
288 return result;
289 }
290 /* break; */
291 default:
292 #ifdef MSWIN_FIND_REPLACE
293 if (uMsg == s_findrep_msg && s_findrep_msg != 0)
294 {
295 _OnFindRepl();
296 }
297 #endif
298 return MyWindowProc(hwnd, uMsg, wParam, lParam);
299 }
300
301 return 1;
302 }
303
304
305
306 /*
307 * End of call-back routines
308 */
309
310
311 /*
312 * Parse the GUI related command-line arguments. Any arguments used are
313 * deleted from argv, and *argc is decremented accordingly. This is called
314 * when vim is started, whether or not the GUI has been started.
315 */
316 void
317 gui_mch_prepare(int *argc, char **argv)
318 {
319 /* No special args for win16 GUI at the moment. */
320
321 }
322
323 /*
324 * Initialise the GUI. Create all the windows, set up all the call-backs
325 * etc.
326 */
327 int
328 gui_mch_init(void)
329 {
330 const char szVimWndClass[] = VIM_CLASS;
331 const char szTextAreaClass[] = "VimTextArea";
332 WNDCLASS wndclass;
333
334 #ifdef WIN16_3DLOOK
335 Ctl3dRegister(s_hinst);
336 Ctl3dAutoSubclass(s_hinst);
337 #endif
338
339 /* Display any pending error messages */
340 display_errors();
341
342 gui.scrollbar_width = GetSystemMetrics(SM_CXVSCROLL);
343 gui.scrollbar_height = GetSystemMetrics(SM_CYHSCROLL);
344 #ifdef FEAT_MENU
345 gui.menu_height = 0; /* Windows takes care of this */
346 #endif
347 gui.border_width = 0;
348
349 gui.currBgColor = INVALCOLOR;
350
351 s_brush = CreateSolidBrush(GetSysColor(COLOR_BTNFACE));
352
353 if (GetClassInfo(s_hinst, szVimWndClass, &wndclass) == 0) {
354 wndclass.style = 0;
355 wndclass.lpfnWndProc = _WndProc;
356 wndclass.cbClsExtra = 0;
357 wndclass.cbWndExtra = 0;
358 wndclass.hInstance = s_hinst;
359 wndclass.hIcon = LoadIcon(wndclass.hInstance, MAKEINTRESOURCE(IDR_VIM));
360 wndclass.hCursor = LoadCursor(NULL, IDC_ARROW);
361 wndclass.hbrBackground = s_brush;
362 wndclass.lpszMenuName = NULL;
363 wndclass.lpszClassName = szVimWndClass;
364
365 if ((
366 #ifdef GLOBAL_IME
367 atom =
368 #endif
369 RegisterClass(&wndclass)) == 0)
370 return FAIL;
371 }
372
373 s_hwnd = CreateWindow(
374 szVimWndClass, "Vim MSWindows GUI",
375 WS_OVERLAPPEDWINDOW,
376 gui_win_x == -1 ? CW_USEDEFAULT : gui_win_x,
377 gui_win_y == -1 ? CW_USEDEFAULT : gui_win_y,
378 100, /* Any value will do */
379 100, /* Any value will do */
380 NULL, NULL,
381 s_hinst, NULL);
382
383 if (s_hwnd == NULL)
384 return FAIL;
385
386 #ifdef GLOBAL_IME
387 global_ime_init(atom, s_hwnd);
388 #endif
389
390 /* Create the text area window */
391 if (GetClassInfo(s_hinst, szTextAreaClass, &wndclass) == 0) {
392 wndclass.style = CS_OWNDC;
393 wndclass.lpfnWndProc = _TextAreaWndProc;
394 wndclass.cbClsExtra = 0;
395 wndclass.cbWndExtra = 0;
396 wndclass.hInstance = s_hinst;
397 wndclass.hIcon = NULL;
398 wndclass.hCursor = LoadCursor(NULL, IDC_ARROW);
399 wndclass.hbrBackground = NULL;
400 wndclass.lpszMenuName = NULL;
401 wndclass.lpszClassName = szTextAreaClass;
402
403 if (RegisterClass(&wndclass) == 0)
404 return FAIL;
405 }
406 s_textArea = CreateWindow(
407 szTextAreaClass, "Vim text area",
408 WS_CHILD | WS_VISIBLE, 0, 0,
409 100, /* Any value will do for now */
410 100, /* Any value will do for now */
411 s_hwnd, NULL,
412 s_hinst, NULL);
413
414 if (s_textArea == NULL)
415 return FAIL;
416
417 #ifdef FEAT_MENU
418 s_menuBar = CreateMenu();
419 #endif
420 s_hdc = GetDC(s_textArea);
421
422 #ifdef MSWIN16_FASTTEXT
423 SetBkMode(s_hdc, OPAQUE);
424 #endif
425
426 DragAcceptFiles(s_hwnd, TRUE);
427
428 /* Do we need to bother with this? */
429 /* m_fMouseAvail = GetSystemMetrics(SM_MOUSEPRESENT); */
430
431 /* Get background/foreground colors from the system */
432 gui_mch_def_colors();
433
434 /* Get the colors from the "Normal" group (set in syntax.c or in a vimrc
435 * file) */
436 set_normal_colors();
437
438 /*
439 * Check that none of the colors are the same as the background color.
440 * Then store the current values as the defaults.
441 */
442 gui_check_colors();
443 gui.def_norm_pixel = gui.norm_pixel;
444 gui.def_back_pixel = gui.back_pixel;
445
446 /* Get the colors for the highlight groups (gui_check_colors() might have
447 * changed them) */
448 highlight_gui_started();
449
450 /*
451 * Start out by adding the configured border width into the border offset
452 */
453 gui.border_offset = gui.border_width;
454
455
456 /*
457 * compute a couple of metrics used for the dialogs
458 */
459 get_dialog_font_metrics();
460 #ifdef FEAT_TOOLBAR
461 /*
462 * Create the toolbar
463 */
464 initialise_toolbar();
465 #endif
466 #ifdef MSWIN_FIND_REPLACE
467 /*
468 * Initialise the dialog box stuff
469 */
470 s_findrep_msg = RegisterWindowMessage(FINDMSGSTRING);
471
472 /* Initialise the struct */
473 s_findrep_struct.lStructSize = sizeof(s_findrep_struct);
474 s_findrep_struct.lpstrFindWhat = alloc(MSWIN_FR_BUFSIZE);
475 s_findrep_struct.lpstrFindWhat[0] = NUL;
476 s_findrep_struct.lpstrReplaceWith = alloc(MSWIN_FR_BUFSIZE);
477 s_findrep_struct.lpstrReplaceWith[0] = NUL;
478 s_findrep_struct.wFindWhatLen = MSWIN_FR_BUFSIZE;
479 s_findrep_struct.wReplaceWithLen = MSWIN_FR_BUFSIZE;
480 #endif
481
482 return OK;
483 }
484
485
486 /*
487 * Set the size of the window to the given width and height in pixels.
488 */
489 void
490 gui_mch_set_shellsize(int width, int height,
491 int min_width, int min_height, int base_width, int base_height)
492 {
493 RECT workarea_rect;
494 int win_width, win_height;
495 int win_xpos, win_ypos;
496 WINDOWPLACEMENT wndpl;
497
498 /* try to keep window completely on screen */
499 /* get size of the screen work area - use SM_CYFULLSCREEN
500 * instead of SM_CYSCREEN so that we don't overlap the
501 * taskbar if someone fires us up on Win95/NT */
502 workarea_rect.left = 0;
503 workarea_rect.top = 0;
504 workarea_rect.right = GetSystemMetrics(SM_CXSCREEN);
505 workarea_rect.bottom = GetSystemMetrics(SM_CYFULLSCREEN);
506
507 /* get current posision of our window */
508 wndpl.length = sizeof(WINDOWPLACEMENT);
509 GetWindowPlacement(s_hwnd, &wndpl);
510 if (wndpl.showCmd == SW_SHOWNORMAL)
511 {
512 win_xpos = wndpl.rcNormalPosition.left;
513 win_ypos = wndpl.rcNormalPosition.top;
514 }
515 else
516 {
517 win_xpos = workarea_rect.left;
518 win_ypos = workarea_rect.top;
519 }
520
521 /* compute the size of the outside of the window */
522 win_width = width + GetSystemMetrics(SM_CXFRAME) * 2;
523 win_height = height + GetSystemMetrics(SM_CYFRAME) * 2
524 + GetSystemMetrics(SM_CYCAPTION)
525 #ifdef FEAT_MENU
526 + gui_mswin_get_menu_height(FALSE)
527 #endif
528 ;
529
530 /* if the window is going off the screen, move it on to the screen */
531 if (win_xpos + win_width > workarea_rect.right)
532 win_xpos = workarea_rect.right - win_width;
533
534 if (win_xpos < workarea_rect.left)
535 win_xpos = workarea_rect.left;
536
537 if (win_ypos + win_height > workarea_rect.bottom)
538 win_ypos = workarea_rect.bottom - win_height;
539
540 if (win_ypos < workarea_rect.top)
541 win_ypos = workarea_rect.top;
542
543 /* set window position */
544 SetWindowPos(s_hwnd, NULL, win_xpos, win_ypos, win_width, win_height,
545 SWP_NOZORDER | SWP_NOACTIVATE);
546
547 #ifdef FEAT_MENU
548 /* Menu may wrap differently now */
549 gui_mswin_get_menu_height(!gui.starting);
550 #endif
551 }
552
553 void
554 gui_mch_set_scrollbar_thumb(
555 scrollbar_T *sb,
556 long val,
557 long size,
558 long max)
559 {
560 sb->scroll_shift = 0;
561 while (max > 32767)
562 {
563 max = (max + 1) >> 1;
564 val >>= 1;
565 size >>= 1;
566 ++sb->scroll_shift;
567 }
568
569 if (sb->scroll_shift > 0)
570 ++size;
571
572 SetScrollRange(sb->id, SB_CTL, 0, (int) max, FALSE);
573 SetScrollPos(sb->id, SB_CTL, (int) val, TRUE);
574 }
575
576
577 /*
578 * Set the current text font.
579 */
580 void
581 gui_mch_set_font(GuiFont font)
582 {
583 gui.currFont = font;
584 SelectFont(s_hdc, gui.currFont);
585 }
586
587
588
589
590 /*
591 * Set the current text foreground color.
592 */
593 void
594 gui_mch_set_fg_color(guicolor_T color)
595 {
596 gui.currFgColor = color;
597 SetTextColor(s_hdc, gui.currFgColor);
598 }
599
600 /*
601 * Set the current text background color.
602 */
603 void
604 gui_mch_set_bg_color(guicolor_T color)
605 {
606 if (gui.currBgColor == color)
607 return;
608
609 gui.currBgColor = color;
610 SetBkColor(s_hdc, gui.currBgColor);
611 }
612
613
614
615 void
616 gui_mch_draw_string(
617 int row,
618 int col,
619 char_u *text,
620 int len,
621 int flags)
622 {
623 #ifndef MSWIN16_FASTTEXT
624 static int *padding = NULL;
625 static int pad_size = 0;
626 int i;
627 #endif
628 HPEN hpen, old_pen;
629 int y;
630
631 #ifndef MSWIN16_FASTTEXT
632 /*
633 * Italic and bold text seems to have an extra row of pixels at the bottom
634 * (below where the bottom of the character should be). If we draw the
635 * characters with a solid background, the top row of pixels in the
636 * character below will be overwritten. We can fix this by filling in the
637 * background ourselves, to the correct character proportions, and then
638 * writing the character in transparent mode. Still have a problem when
639 * the character is "_", which gets written on to the character below.
640 * New fix: set gui.char_ascent to -1. This shifts all characters up one
641 * pixel in their slots, which fixes the problem with the bottom row of
642 * pixels. We still need this code because otherwise the top row of pixels
643 * becomes a problem. - webb.
644 */
645 HBRUSH hbr;
646 RECT rc;
647
648 if (!(flags & DRAW_TRANSP))
649 {
650 /*
651 * Clear background first.
652 * Note: FillRect() excludes right and bottom of rectangle.
653 */
654 rc.left = FILL_X(col);
655 rc.top = FILL_Y(row);
656 #ifdef FEAT_MBYTE
657 if (has_mbyte)
658 {
659 int cell_len = 0;
660
661 /* Compute the length in display cells. */
662 for (n = 0; n < len; n += MB_BYTE2LEN(text[n]))
663 cell_len += (*mb_ptr2cells)(text + n);
664 rc.right = FILL_X(col + cell_len);
665 }
666 else
667 #endif
668 rc.right = FILL_X(col + len);
669 rc.bottom = FILL_Y(row + 1);
670 hbr = CreateSolidBrush(gui.currBgColor);
671 FillRect(s_hdc, &rc, hbr);
672 DeleteBrush(hbr);
673
674 SetBkMode(s_hdc, TRANSPARENT);
675
676 /*
677 * When drawing block cursor, prevent inverted character spilling
678 * over character cell (can happen with bold/italic)
679 */
680 if (flags & DRAW_CURSOR)
681 {
682 pcliprect = &rc;
683 foptions = ETO_CLIPPED;
684 }
685 }
686 #else
687 /*
688 * Alternative: write the characters in opaque mode, since we have blocked
689 * bold or italic fonts.
690 */
691 /* The OPAQUE mode and backcolour have already been set */
692 #endif
693 /* The forecolor and font have already been set */
694
695 #ifndef MSWIN16_FASTTEXT
696
697 if (pad_size != Columns || padding == NULL || padding[0] != gui.char_width)
698 {
699 vim_free(padding);
700 pad_size = Columns;
701
702 padding = (int *)alloc(pad_size * sizeof(int));
703 if (padding != NULL)
704 for (i = 0; i < pad_size; i++)
705 padding[i] = gui.char_width;
706 }
707 #endif
708
709 /*
710 * We have to provide the padding argument because italic and bold versions
711 * of fixed-width fonts are often one pixel or so wider than their normal
712 * versions.
713 * No check for DRAW_BOLD, Windows will have done it already.
714 */
715 #ifndef MSWIN16_FASTTEXT
716 ExtTextOut(s_hdc, TEXT_X(col), TEXT_Y(row), 0, NULL,
717 (char *)text, len, padding);
718 #else
719 TextOut(s_hdc, TEXT_X(col), TEXT_Y(row), (char *)text, len);
720 #endif
721
722 if (flags & DRAW_UNDERL)
723 {
724 hpen = CreatePen(PS_SOLID, 1, gui.currFgColor);
725 old_pen = SelectObject(s_hdc, hpen);
726 /* When p_linespace is 0, overwrite the bottom row of pixels.
727 * Otherwise put the line just below the character. */
728 y = FILL_Y(row + 1) - 1;
729 #ifndef MSWIN16_FASTTEXT
730 if (p_linespace > 1)
731 y -= p_linespace - 1;
732 #endif
733 MoveToEx(s_hdc, FILL_X(col), y, NULL);
734 /* Note: LineTo() excludes the last pixel in the line. */
735 LineTo(s_hdc, FILL_X(col + len), y);
736 DeleteObject(SelectObject(s_hdc, old_pen));
737 }
738 }
739
740
741 /*
742 * Output routines.
743 */
744
745 /* Flush any output to the screen */
746 void
747 gui_mch_flush(void)
748 {
749 /* Is anything needed here? */
750 }
751
752 static void
753 clear_rect(RECT *rcp)
754 {
755 /* Use trick for fast rect clear */
756 gui_mch_set_bg_color(gui.back_pixel);
757 ExtTextOut(s_hdc, 0, 0, ETO_CLIPPED | ETO_OPAQUE, rcp, NULL, 0, NULL);
758 }
759
760
761
762
763 #if defined(FEAT_MENU) || defined(PROTO)
764 /*
765 * Add a sub menu to the menu bar.
766 */
767 void
768 gui_mch_add_menu(
769 vimmenu_T *menu,
770 int pos)
771 {
772 vimmenu_T *parent = menu->parent;
773
774 menu->submenu_id = CreatePopupMenu();
775 menu->id = s_menu_id++;
776
777 if (menu_is_menubar(menu->name))
778 {
779 InsertMenu((parent == NULL) ? s_menuBar : parent->submenu_id,
780 (UINT)pos, MF_POPUP | MF_STRING | MF_BYPOSITION,
781 (UINT)menu->submenu_id, menu->name);
782 }
783
784 /* Fix window size if menu may have wrapped */
785 if (parent == NULL)
786 gui_mswin_get_menu_height(!gui.starting);
787 }
788
789 void
790 gui_mch_show_popupmenu(vimmenu_T *menu)
791 {
792 POINT mp;
793
794 (void)GetCursorPos((LPPOINT)&mp);
795 gui_mch_show_popupmenu_at(menu, (int)mp.x, (int)mp.y);
796 }
797
798 void
799 gui_make_popup(char_u *path_name)
800 {
801 vimmenu_T *menu = gui_find_menu(path_name);
802
803 if (menu != NULL)
804 {
805 /* Find the position of the current cursor */
806 DWORD temp_p;
807 POINT p;
808 temp_p = GetDCOrg(s_hdc);
809 p.x = LOWORD(temp_p);
810 p.y = HIWORD(temp_p);
811 if (curwin!=NULL)
812 {
813 p.x+= TEXT_X(W_WINCOL(curwin) + curwin->w_wcol +1);
814 p.y+= TEXT_Y(W_WINROW(curwin) + curwin->w_wrow +1);
815 }
816 msg_scroll = FALSE;
817 gui_mch_show_popupmenu_at(menu, (int)p.x, (int)p.y);
818 }
819 }
820
821 /*
822 * Add a menu item to a menu
823 */
824 void
825 gui_mch_add_menu_item(
826 vimmenu_T *menu,
827 int idx)
828 {
829 vimmenu_T *parent = menu->parent;
830
831 menu->id = s_menu_id++;
832 menu->submenu_id = NULL;
833
834 #ifdef FEAT_TOOLBAR
835 if (menu_is_toolbar(parent->name))
836 {
837 TBBUTTON newtb;
838
839 vim_memset(&newtb, 0, sizeof(newtb));
840 if (menu_is_separator(menu->name))
841 {
842 newtb.iBitmap = 0;
843 newtb.fsStyle = TBSTYLE_SEP;
844 }
845 else
846 {
847 if (menu->iconidx >= TOOLBAR_BITMAP_COUNT)
848 newtb.iBitmap = -1;
849 else
850 newtb.iBitmap = menu->iconidx;
851 newtb.fsStyle = TBSTYLE_BUTTON;
852 }
853 newtb.idCommand = menu->id;
854 newtb.fsState = TBSTATE_ENABLED;
855 SendMessage(s_toolbarhwnd, TB_INSERTBUTTON, (WPARAM)idx,
856 (LPARAM)&newtb);
857 menu->submenu_id = (HMENU)-1;
858 }
859 else
860 #endif
861 {
862 InsertMenu(parent->submenu_id, (UINT)idx,
863 (menu_is_separator(menu->name) ? MF_SEPARATOR : MF_STRING)
864 | MF_BYPOSITION,
865 (UINT)menu->id, menu->name);
866 }
867 }
868
869 /*
870 * Destroy the machine specific menu widget.
871 */
872 void
873 gui_mch_destroy_menu(vimmenu_T *menu)
874 {
875 UINT i, j;
876 char pants[80]; /*<VN> hack*/
877 #ifdef FEAT_TOOLBAR
878 /*
879 * is this a toolbar button?
880 */
881 if (menu->submenu_id == (HMENU)-1)
882 {
883 int iButton;
884
885 iButton = SendMessage(s_toolbarhwnd, TB_COMMANDTOINDEX, (WPARAM)menu->id, 0);
886 SendMessage(s_toolbarhwnd, TB_DELETEBUTTON, (WPARAM)iButton, 0);
887 }
888 else
889 #endif
890 {
891 /*
892 * negri: horrible API bug when running 16-bit programs under Win9x or
893 * NT means that we can't use MF_BYCOMMAND for menu items which have
894 * submenus, including the top-level headings. We have to find the menu
895 * item and use MF_BYPOSITION instead. :-p
896 */
897 if (menu->parent != NULL
898 && menu_is_popup(menu->parent->dname)
899 && menu->parent->submenu_id != NULL)
900 RemoveMenu(menu->parent->submenu_id, menu->id, MF_BYCOMMAND);
901 else if (menu->submenu_id == NULL)
902 RemoveMenu(s_menuBar, menu->id, MF_BYCOMMAND);
903 else if (menu->parent != NULL)
904 {
905 i = GetMenuItemCount(menu->parent->submenu_id);
906 for (j = 0; j < i; ++j)
907 {
908 GetMenuString(menu->parent->submenu_id, j,
909 pants, 80, MF_BYPOSITION);
910 if (strcmp(pants, menu->name) == 0)
911 {
912 RemoveMenu(menu->parent->submenu_id, j, MF_BYPOSITION);
913 break;
914 }
915 }
916 }
917 else
918 {
919 i = GetMenuItemCount(s_menuBar);
920 for (j = 0; j < i; ++j)
921 {
922 GetMenuString(s_menuBar, j, pants, 80, MF_BYPOSITION);
923 if (strcmp(pants, menu->name) == 0)
924 {
925 RemoveMenu(s_menuBar, j, MF_BYPOSITION);
926 break;
927 }
928 }
929 }
930
931 if (menu->submenu_id != NULL)
932 DestroyMenu(menu->submenu_id);
933 }
934 DrawMenuBar(s_hwnd);
935 }
936
937
938 /*
939 * Make a menu either grey or not grey.
940 */
941 void
942 gui_mch_menu_grey(
943 vimmenu_T *menu,
944 int grey)
945 {
946 #ifdef FEAT_TOOLBAR
947 /*
948 * is this a toolbar button?
949 */
950 if (menu->submenu_id == (HMENU)-1)
951 {
952 SendMessage(s_toolbarhwnd, TB_ENABLEBUTTON,
953 (WPARAM)menu->id, (LPARAM) MAKELONG((grey ? FALSE : TRUE), 0) );
954 }
955 else
956 #endif
957 if (grey)
958 EnableMenuItem(s_menuBar, menu->id, MF_BYCOMMAND | MF_GRAYED);
959 else
960 EnableMenuItem(s_menuBar, menu->id, MF_BYCOMMAND | MF_ENABLED);
961
962 }
963
964
965 #endif /*FEAT_MENU*/
966
967
968 /* define some macros used to make the dialogue creation more readable */
969
970 #define add_string(s) strcpy((LPSTR)p, s); (LPSTR)p += (strlen((LPSTR)p) + 1)
971 #define add_word(x) *p++ = (x)
972 #define add_byte(x) *((LPSTR)p)++ = (x)
973 #define add_long(x) *((LPDWORD)p)++ = (x)
974
975 #if defined(FEAT_GUI_DIALOG) || defined(PROTO)
976 /*
977 * stuff for dialogs
978 */
979
980 /*
981 * The callback routine used by all the dialogs. Very simple. First,
982 * acknowledges the INITDIALOG message so that Windows knows to do standard
983 * dialog stuff (Return = default, Esc = cancel....) Second, if a button is
984 * pressed, return that button's ID - IDCANCEL (2), which is the button's
985 * number.
986 */
987 static BOOL CALLBACK
988 dialog_callback(
989 HWND hwnd,
990 UINT message,
991 WPARAM wParam,
992 LPARAM lParam)
993 {
994 if (message == WM_INITDIALOG)
995 {
996 CenterWindow(hwnd, GetWindow(hwnd, GW_OWNER));
997 /* Set focus to the dialog. Set the default button, if specified. */
998 (void)SetFocus(hwnd);
999 if (dialog_default_button > IDCANCEL)
1000 (void)SetFocus(GetDlgItem(hwnd, dialog_default_button));
1001 // if (dialog_default_button > 0)
1002 // (void)SetFocus(GetDlgItem(hwnd, dialog_default_button + IDCANCEL));
1003 return FALSE;
1004 }
1005
1006 if (message == WM_COMMAND)
1007 {
1008 int button = LOWORD(wParam);
1009
1010 /* Don't end the dialog if something was selected that was
1011 * not a button.
1012 */
1013 if (button >= DLG_NONBUTTON_CONTROL)
1014 return TRUE;
1015
1016 /* If the edit box exists, copy the string. */
1017 if (s_textfield != NULL)
1018 GetDlgItemText(hwnd, DLG_NONBUTTON_CONTROL + 2,
1019 s_textfield, IOSIZE);
1020
1021 /*
1022 * Need to check for IDOK because if the user just hits Return to
1023 * accept the default value, some reason this is what we get.
1024 */
1025 if (button == IDOK)
1026 EndDialog(hwnd, dialog_default_button);
1027 else
1028 EndDialog(hwnd, button - IDCANCEL);
1029 return TRUE;
1030 }
1031
1032 if ((message == WM_SYSCOMMAND) && (wParam == SC_CLOSE))
1033 {
1034 EndDialog(hwnd, 0);
1035 return TRUE;
1036 }
1037 return FALSE;
1038 }
1039
1040 /*
1041 * Create a dialog dynamically from the parameter strings.
1042 * type = type of dialog (question, alert, etc.)
1043 * title = dialog title. may be NULL for default title.
1044 * message = text to display. Dialog sizes to accommodate it.
1045 * buttons = '\n' separated list of button captions, default first.
1046 * dfltbutton = number of default button.
1047 *
1048 * This routine returns 1 if the first button is pressed,
1049 * 2 for the second, etc.
1050 *
1051 * 0 indicates Esc was pressed.
1052 * -1 for unexpected error
1053 *
1054 * If stubbing out this fn, return 1.
1055 */
1056
1057 static const char_u dlg_icons[] = /* must match names in resource file */
1058 {
1059 IDR_VIM,
1060 IDR_VIM_ERROR,
1061 IDR_VIM_ALERT,
1062 IDR_VIM_INFO,
1063 IDR_VIM_QUESTION
1064 };
1065
1066 int
1067 gui_mch_dialog(
1068 int type,
1069 char_u *title,
1070 char_u *message,
1071 char_u *buttons,
1072 int dfltbutton,
1073 char_u *textfield)
1074 {
1075 FARPROC dp;
1076 LPWORD p, pnumitems;
1077 int numButtons;
1078 int *buttonWidths, *buttonPositions;
1079 int buttonYpos;
1080 int nchar, i;
1081 DWORD lStyle;
1082 int dlgwidth = 0;
1083 int dlgheight;
1084 int editboxheight;
1085 int horizWidth;
1086 int msgheight;
1087 char_u *pstart;
1088 char_u *pend;
1089 char_u *tbuffer;
1090 RECT rect;
1091 HWND hwnd;
1092 HDC hdc;
1093 HFONT oldFont;
1094 TEXTMETRIC fontInfo;
1095 int fontHeight;
1096 int textWidth, minButtonWidth, messageWidth;
1097 int maxDialogWidth;
1098 int vertical;
1099 int dlgPaddingX;
1100 int dlgPaddingY;
1101 HGLOBAL hglbDlgTemp;
1102
1103 #ifndef NO_CONSOLE
1104 /* Don't output anything in silent mode ("ex -s") */
1105 if (silent_mode)
1106 return dfltbutton; /* return default option */
1107 #endif
1108
1109 /* If there is no window yet, open it. */
1110 if (s_hwnd == NULL && gui_mch_init() == FAIL)
1111 return dfltbutton;
1112
1113 if ((type < 0) || (type > VIM_LAST_TYPE))
1114 type = 0;
1115
1116 /* allocate some memory for dialog template */
1117 /* TODO should compute this really*/
1118
1119 hglbDlgTemp = GlobalAlloc(GHND, DLG_ALLOC_SIZE);
1120 if (hglbDlgTemp == NULL)
1121 return -1;
1122
1123 p = (LPWORD) GlobalLock(hglbDlgTemp);
1124
1125 if (p == NULL)
1126 return -1;
1127
1128 /*
1129 * make a copy of 'buttons' to fiddle with it. complier grizzles because
1130 * vim_strsave() doesn't take a const arg (why not?), so cast away the
1131 * const.
1132 */
1133 tbuffer = vim_strsave(buttons);
1134 if (tbuffer == NULL)
1135 return -1;
1136
1137 --dfltbutton; /* Change from one-based to zero-based */
1138
1139 /* Count buttons */
1140 numButtons = 1;
1141 for (i = 0; tbuffer[i] != '\0'; i++)
1142 {
1143 if (tbuffer[i] == DLG_BUTTON_SEP)
1144 numButtons++;
1145 }
1146 if (dfltbutton >= numButtons)
1147 dfltbutton = 0;
1148
1149 /* Allocate array to hold the width of each button */
1150 buttonWidths = (int *) lalloc(numButtons * sizeof(int), TRUE);
1151 if (buttonWidths == NULL)
1152 return -1;
1153
1154 /* Allocate array to hold the X position of each button */
1155 buttonPositions = (int *) lalloc(numButtons * sizeof(int), TRUE);
1156 if (buttonPositions == NULL)
1157 return -1;
1158
1159 /*
1160 * Calculate how big the dialog must be.
1161 */
1162 hwnd = GetDesktopWindow();
1163 hdc = GetWindowDC(hwnd);
1164 oldFont = SelectFont(hdc, GetStockObject(SYSTEM_FONT));
1165 dlgPaddingX = DLG_OLD_STYLE_PADDING_X;
1166 dlgPaddingY = DLG_OLD_STYLE_PADDING_Y;
1167
1168 GetTextMetrics(hdc, &fontInfo);
1169 fontHeight = fontInfo.tmHeight;
1170
1171 /* Minimum width for horizontal button */
1172 minButtonWidth = GetTextWidth(hdc, "Cancel", 6);
1173
1174 /* Maximum width of a dialog, if possible */
1175 GetWindowRect(s_hwnd, &rect);
1176 maxDialogWidth = rect.right - rect.left
1177 - GetSystemMetrics(SM_CXFRAME) * 2;
1178 if (maxDialogWidth < DLG_MIN_MAX_WIDTH)
1179 maxDialogWidth = DLG_MIN_MAX_WIDTH;
1180
1181 /* Set dlgwidth to width of message */
1182 pstart = message;
1183 messageWidth = 0;
1184 msgheight = 0;
1185 do
1186 {
1187 pend = vim_strchr(pstart, DLG_BUTTON_SEP);
1188 if (pend == NULL)
1189 pend = pstart + STRLEN(pstart); /* Last line of message. */
1190 msgheight += fontHeight;
1191 textWidth = GetTextWidth(hdc, pstart, pend - pstart);
1192 if (textWidth > messageWidth)
1193 messageWidth = textWidth;
1194 pstart = pend + 1;
1195 } while (*pend != NUL);
1196 dlgwidth = messageWidth;
1197
1198 /* Add width of icon to dlgwidth, and some space */
1199 dlgwidth += DLG_ICON_WIDTH + 3 * dlgPaddingX;
1200
1201 if (msgheight < DLG_ICON_HEIGHT)
1202 msgheight = DLG_ICON_HEIGHT;
1203
1204 /*
1205 * Check button names. A long one will make the dialog wider.
1206 */
1207 vertical = (vim_strchr(p_go, GO_VERTICAL) != NULL);
1208 if (!vertical)
1209 {
1210 // Place buttons horizontally if they fit.
1211 horizWidth = dlgPaddingX;
1212 pstart = tbuffer;
1213 i = 0;
1214 do
1215 {
1216 pend = vim_strchr(pstart, DLG_BUTTON_SEP);
1217 if (pend == NULL)
1218 pend = pstart + STRLEN(pstart); // Last button name.
1219 textWidth = GetTextWidth(hdc, pstart, pend - pstart);
1220 if (textWidth < minButtonWidth)
1221 textWidth = minButtonWidth;
1222 textWidth += dlgPaddingX; /* Padding within button */
1223 buttonWidths[i] = textWidth;
1224 buttonPositions[i++] = horizWidth;
1225 horizWidth += textWidth + dlgPaddingX; /* Pad between buttons */
1226 pstart = pend + 1;
1227 } while (*pend != NUL);
1228
1229 if (horizWidth > maxDialogWidth)
1230 vertical = TRUE; // Too wide to fit on the screen.
1231 else if (horizWidth > dlgwidth)
1232 dlgwidth = horizWidth;
1233 }
1234
1235 if (vertical)
1236 {
1237 // Stack buttons vertically.
1238 pstart = tbuffer;
1239 do
1240 {
1241 pend = vim_strchr(pstart, DLG_BUTTON_SEP);
1242 if (pend == NULL)
1243 pend = pstart + STRLEN(pstart); // Last button name.
1244 textWidth = GetTextWidth(hdc, pstart, pend - pstart);
1245 textWidth += dlgPaddingX; /* Padding within button */
1246 textWidth += DLG_VERT_PADDING_X * 2; /* Padding around button */
1247 if (textWidth > dlgwidth)
1248 dlgwidth = textWidth;
1249 pstart = pend + 1;
1250 } while (*pend != NUL);
1251 }
1252
1253 if (dlgwidth < DLG_MIN_WIDTH)
1254 dlgwidth = DLG_MIN_WIDTH; /* Don't allow a really thin dialog!*/
1255
1256 /* start to fill in the dlgtemplate information. addressing by WORDs */
1257 lStyle = DS_MODALFRAME | WS_CAPTION | WS_VISIBLE ;
1258
1259 add_long(lStyle);
1260 pnumitems = p; /*save where the number of items must be stored*/
1261 add_byte(0); // NumberOfItems(will change later)
1262 add_word(10); // x
1263 add_word(10); // y
1264 add_word(PixelToDialogX(dlgwidth));
1265
1266 // Dialog height.
1267 if (vertical)
1268 dlgheight = msgheight + 2 * dlgPaddingY +
1269 DLG_VERT_PADDING_Y + 2 * fontHeight * numButtons;
1270 else
1271 dlgheight = msgheight + 3 * dlgPaddingY + 2 * fontHeight;
1272
1273 // Dialog needs to be taller if contains an edit box.
1274 editboxheight = fontHeight + dlgPaddingY + 4 * DLG_VERT_PADDING_Y;
1275 if (textfield != NULL)
1276 dlgheight += editboxheight;
1277
1278 add_word(PixelToDialogY(dlgheight));
1279
1280 add_byte(0); //menu
1281 add_byte(0); //class
1282
1283 /* copy the title of the dialog */
1284 add_string(title ? title : ("Vim"VIM_VERSION_MEDIUM));
1285
1286 buttonYpos = msgheight + 2 * dlgPaddingY;
1287
1288 if (textfield != NULL)
1289 buttonYpos += editboxheight;
1290
1291 pstart = tbuffer; //dflt_text
1292 horizWidth = (dlgwidth - horizWidth) / 2; /* Now it's X offset */
1293 for (i = 0; i < numButtons; i++)
1294 {
1295 /* get end of this button. */
1296 for ( pend = pstart;
1297 *pend && (*pend != DLG_BUTTON_SEP);
1298 pend++)
1299 ;
1300
1301 if (*pend)
1302 *pend = '\0';
1303
1304 /*
1305 * NOTE:
1306 * setting the BS_DEFPUSHBUTTON style doesn't work because Windows sets
1307 * the focus to the first tab-able button and in so doing makes that
1308 * the default!! Grrr. Workaround: Make the default button the only
1309 * one with WS_TABSTOP style. Means user can't tab between buttons, but
1310 * he/she can use arrow keys.
1311 *
1312 * NOTE (Thore): Setting BS_DEFPUSHBUTTON works fine when it's the
1313 * first one, so I changed the correct button to be this style. This
1314 * is necessary because when an edit box is added, we need a button to
1315 * be default. The edit box will be the default control, and when the
1316 * user presses enter from the edit box we want the default button to
1317 * be pressed.
1318 */
1319 if (vertical)
1320 {
1321 p = add_dialog_element(p,
1322 ((i == dfltbutton || dfltbutton < 0) && textfield != NULL
1323 ? BS_DEFPUSHBUTTON : BS_PUSHBUTTON) | WS_TABSTOP,
1324 PixelToDialogX(DLG_VERT_PADDING_X),
1325 PixelToDialogY(buttonYpos /* TBK */
1326 + 2 * fontHeight * i),
1327 PixelToDialogX(dlgwidth - 2 * DLG_VERT_PADDING_X),
1328 (WORD)(PixelToDialogY(2 * fontHeight) - 1),
1329 (WORD)(IDCANCEL + 1 + i), (BYTE)0x80, pstart);
1330 }
1331 else
1332 {
1333 p = add_dialog_element(p,
1334 ((i == dfltbutton || dfltbutton < 0) && textfield != NULL
1335 ? BS_DEFPUSHBUTTON : BS_PUSHBUTTON) | WS_TABSTOP,
1336 PixelToDialogX(horizWidth + buttonPositions[i]),
1337 PixelToDialogY(buttonYpos), /* TBK */
1338 PixelToDialogX(buttonWidths[i]),
1339 (WORD)(PixelToDialogY(2 * fontHeight) - 1),
1340 (WORD)(IDCANCEL + 1 + i), (BYTE)0x80, pstart);
1341 }
1342
1343 pstart = pend + 1; /*next button*/
1344
1345 }
1346 *pnumitems += numButtons;
1347
1348 /* Vim icon */
1349 p = add_dialog_element(p, SS_ICON,
1350 PixelToDialogX(dlgPaddingX),
1351 PixelToDialogY(dlgPaddingY),
1352 PixelToDialogX(DLG_ICON_WIDTH),
1353 PixelToDialogY(DLG_ICON_HEIGHT),
1354 DLG_NONBUTTON_CONTROL + 0, (BYTE)0x82,
1355 &dlg_icons[type]);
1356
1357
1358 /* Dialog message */
1359 p = add_dialog_element(p, SS_LEFT,
1360 PixelToDialogX(2 * dlgPaddingX + DLG_ICON_WIDTH),
1361 PixelToDialogY(dlgPaddingY),
1362 (WORD)(PixelToDialogX(messageWidth) + 1),
1363 PixelToDialogY(msgheight),
1364 DLG_NONBUTTON_CONTROL + 1, (BYTE)0x82, message);
1365
1366 /* Edit box */
1367 if (textfield != NULL)
1368 {
1369 p = add_dialog_element(p, ES_LEFT | ES_AUTOHSCROLL | WS_TABSTOP | WS_BORDER,
1370 PixelToDialogX(2 * dlgPaddingX),
1371 PixelToDialogY(2 * dlgPaddingY + msgheight),
1372 PixelToDialogX(dlgwidth - 4 * dlgPaddingX),
1373 PixelToDialogY(fontHeight + dlgPaddingY),
1374 DLG_NONBUTTON_CONTROL + 2, (BYTE)0x81, textfield);
1375 *pnumitems += 1;
1376 }
1377
1378 *pnumitems += 2;
1379
1380 SelectFont(hdc, oldFont);
1381 ReleaseDC(hwnd, hdc);
1382 dp = MakeProcInstance((FARPROC)dialog_callback, s_hinst);
1383
1384
1385 /* Let the dialog_callback() function know which button to make default
1386 * If we have an edit box, make that the default. We also need to tell
1387 * dialog_callback() if this dialog contains an edit box or not. We do
1388 * this by setting s_textfield if it does.
1389 */
1390 if (textfield != NULL)
1391 {
1392 dialog_default_button = DLG_NONBUTTON_CONTROL + 2;
1393 s_textfield = textfield;
1394 }
1395 else
1396 {
1397 dialog_default_button = IDCANCEL + 1 + dfltbutton;
1398 s_textfield = NULL;
1399 }
1400
1401 /*show the dialog box modally and get a return value*/
1402 nchar = DialogBoxIndirect(
1403 s_hinst,
1404 (HGLOBAL) hglbDlgTemp,
1405 s_hwnd,
1406 (DLGPROC)dp);
1407
1408 FreeProcInstance( dp );
1409 GlobalUnlock(hglbDlgTemp);
1410 GlobalFree(hglbDlgTemp);
1411 vim_free(tbuffer);
1412 vim_free(buttonWidths);
1413 vim_free(buttonPositions);
1414
1415
1416 return nchar;
1417 }
1418
1419 /*
1420 * Put a simple element (basic class) onto a dialog template in memory.
1421 * return a pointer to where the next item should be added.
1422 *
1423 * parameters:
1424 * lStyle = additional style flags
1425 * x,y = x & y positions IN DIALOG UNITS
1426 * w,h = width and height IN DIALOG UNITS
1427 * Id = ID used in messages
1428 * clss = class ID, e.g 0x80 for a button, 0x82 for a static
1429 * caption = usually text or resource name
1430 *
1431 * TODO: use the length information noted here to enable the dialog creation
1432 * routines to work out more exactly how much memory they need to alloc.
1433 */
1434 static LPWORD
1435 add_dialog_element(
1436 LPWORD p,
1437 DWORD lStyle,
1438 WORD x,
1439 WORD y,
1440 WORD w,
1441 WORD h,
1442 WORD Id,
1443 BYTE clss,
1444 const char *caption)
1445 {
1446
1447 lStyle = lStyle | WS_VISIBLE | WS_CHILD;
1448
1449 add_word(x);
1450 add_word(y);
1451 add_word(w);
1452 add_word(h);
1453 add_word(Id);
1454 add_long(lStyle);
1455 add_byte(clss);
1456 if (((lStyle & SS_ICON) != 0) && (clss == 0x82))
1457 {
1458 /* Use resource ID */
1459 add_byte(0xff);
1460 add_byte(*caption);
1461 }
1462 else
1463 add_string(caption);
1464
1465 add_byte(0); //# of extra bytes following
1466
1467
1468 return p;
1469 }
1470
1471 #undef add_byte
1472 #undef add_string
1473 #undef add_long
1474 #undef add_word
1475
1476 #endif /* FEAT_GUI_DIALOG */
1477
1478 static void
1479 get_dialog_font_metrics(void)
1480 {
1481 DWORD dlgFontSize;
1482 dlgFontSize = GetDialogBaseUnits(); /* fall back to big old system*/
1483 s_dlgfntwidth = LOWORD(dlgFontSize);
1484 s_dlgfntheight = HIWORD(dlgFontSize);
1485 }
1486
1487
1488 #if defined(FEAT_TOOLBAR) || defined(PROTO)
1489 #include "gui_w3~1.h"
1490 /*
1491 * Create the toolbar, initially unpopulated.
1492 * (just like the menu, there are no defaults, it's all
1493 * set up through menu.vim)
1494 */
1495 static void
1496 initialise_toolbar(void)
1497 {
1498 s_toolbarhwnd = CreateToolbar(
1499 s_hwnd,
1500 WS_CHILD | WS_VISIBLE,
1501 CMD_TB_BASE, /*<vn>*/
1502 31, //number of images in inital bitmap
1503 s_hinst,
1504 IDR_TOOLBAR1, // id of initial bitmap
1505 NULL,
1506 0 // initial number of buttons
1507 );
1508
1509 gui_mch_show_toolbar(vim_strchr(p_go, GO_TOOLBAR) != NULL);
1510 }
1511 #endif
1512
1513 #if defined(FEAT_OLE) || defined(FEAT_EVAL) || defined(PROTO)
1514 /*
1515 * Make the GUI window come to the foreground.
1516 */
1517 void
1518 gui_mch_set_foreground(void)
1519 {
1520 if (IsIconic(s_hwnd))
1521 SendMessage(s_hwnd, WM_SYSCOMMAND, SC_RESTORE, 0);
1522 SetActiveWindow(s_hwnd);
1523 }
1524 #endif