1 /* vi:set ts=8 sts=4 sw=4 noet:
2 *
3 * VIM - Vi IMproved by Bram Moolenaar
4 *
5 * Do ":help uganda" in Vim to read copying and usage conditions.
6 * Do ":help credits" in Vim to see a list of people who contributed.
7 * See README.txt for an overview of the Vim source code.
8 */
9
10 /*
11 * os_mswin.c
12 *
13 * Routines for Win32.
14 */
15
16 #include "vim.h"
17
18 #include <sys/types.h>
19 #include <signal.h>
20 #include <limits.h>
21 #ifndef PROTO
22 # include <process.h>
23 #endif
24
25 #undef chdir
26 #ifdef __GNUC__
27 # ifndef __MINGW32__
28 # include <dirent.h>
29 # endif
30 #else
31 # include <direct.h>
32 #endif
33
34 #ifndef PROTO
35 # if defined(FEAT_TITLE) && !defined(FEAT_GUI_MSWIN)
36 # include <shellapi.h>
37 # endif
38
39 # if defined(FEAT_PRINTER) && !defined(FEAT_POSTSCRIPT)
40 # include <dlgs.h>
41 # include <winspool.h>
42 # include <commdlg.h>
43 # endif
44
45 #endif // PROTO
46
47 #ifdef __MINGW32__
48 # ifndef FROM_LEFT_1ST_BUTTON_PRESSED
49 # define FROM_LEFT_1ST_BUTTON_PRESSED 0x0001
50 # endif
51 # ifndef RIGHTMOST_BUTTON_PRESSED
52 # define RIGHTMOST_BUTTON_PRESSED 0x0002
53 # endif
54 # ifndef FROM_LEFT_2ND_BUTTON_PRESSED
55 # define FROM_LEFT_2ND_BUTTON_PRESSED 0x0004
56 # endif
57 # ifndef FROM_LEFT_3RD_BUTTON_PRESSED
58 # define FROM_LEFT_3RD_BUTTON_PRESSED 0x0008
59 # endif
60 # ifndef FROM_LEFT_4TH_BUTTON_PRESSED
61 # define FROM_LEFT_4TH_BUTTON_PRESSED 0x0010
62 # endif
63
64 /*
65 * EventFlags
66 */
67 # ifndef MOUSE_MOVED
68 # define MOUSE_MOVED 0x0001
69 # endif
70 # ifndef DOUBLE_CLICK
71 # define DOUBLE_CLICK 0x0002
72 # endif
73 #endif
74
75 /*
76 * When generating prototypes for Win32 on Unix, these lines make the syntax
77 * errors disappear. They do not need to be correct.
78 */
79 #ifdef PROTO
80 # define WINAPI
81 # define WINBASEAPI
82 typedef int BOOL;
83 typedef int CALLBACK;
84 typedef int COLORREF;
85 typedef int CONSOLE_CURSOR_INFO;
86 typedef int COORD;
87 typedef int DWORD;
88 typedef int ENUMLOGFONTW;
89 typedef int HANDLE;
90 typedef int HDC;
91 typedef int HFONT;
92 typedef int HICON;
93 typedef int HWND;
94 typedef int INPUT_RECORD;
95 typedef int KEY_EVENT_RECORD;
96 typedef int LOGFONTW;
97 typedef int LPARAM;
98 typedef int LPBOOL;
99 typedef int LPCSTR;
100 typedef int LPCWSTR;
101 typedef int LPDWORD;
102 typedef int LPSTR;
103 typedef int LPTSTR;
104 typedef int LPVOID;
105 typedef int LPWSTR;
106 typedef int LRESULT;
107 typedef int MOUSE_EVENT_RECORD;
108 typedef int NEWTEXTMETRICW;
109 typedef int PACL;
110 typedef int PRINTDLGW;
111 typedef int PSECURITY_DESCRIPTOR;
112 typedef int PSID;
113 typedef int SECURITY_INFORMATION;
114 typedef int SHORT;
115 typedef int SMALL_RECT;
116 typedef int TEXTMETRIC;
117 typedef int UINT;
118 typedef int WCHAR;
119 typedef int WNDENUMPROC;
120 typedef int WORD;
121 typedef int WPARAM;
122 typedef void VOID;
123 #endif
124
125 // Record all output and all keyboard & mouse input
126 // #define MCH_WRITE_DUMP
127
128 #ifdef MCH_WRITE_DUMP
129 FILE* fdDump = NULL;
130 #endif
131
132 #if !defined(FEAT_GUI_MSWIN) || defined(VIMDLL)
133 extern char g_szOrigTitle[];
134 #endif
135
136 #ifdef FEAT_GUI
137 extern HWND s_hwnd;
138 #else
139 static HWND s_hwnd = 0; // console window handle, set by GetConsoleHwnd()
140 #endif
141
142 #ifdef FEAT_JOB_CHANNEL
143 int WSInitialized = FALSE; // WinSock is initialized
144 #endif
145
146 // Don't generate prototypes here, because some systems do have these
147 // functions.
148 #if defined(__GNUC__) && !defined(PROTO)
149 # ifndef __MINGW32__
_stricoll(char * a,char * b)150 int _stricoll(char *a, char *b)
151 {
152 // the ANSI-ish correct way is to use strxfrm():
153 char a_buff[512], b_buff[512]; // file names, so this is enough on Win32
154 strxfrm(a_buff, a, 512);
155 strxfrm(b_buff, b, 512);
156 return strcoll(a_buff, b_buff);
157 }
158
_fullpath(char * buf,char * fname,int len)159 char * _fullpath(char *buf, char *fname, int len)
160 {
161 LPTSTR toss;
162
163 return (char *)GetFullPathName(fname, len, buf, &toss);
164 }
165 # endif
166
167 # if !defined(__MINGW32__) || (__GNUC__ < 4)
_chdrive(int drive)168 int _chdrive(int drive)
169 {
170 char temp [3] = "-:";
171 temp[0] = drive + 'A' - 1;
172 return !SetCurrentDirectory(temp);
173 }
174 # endif
175 #endif
176
177
178 #ifndef PROTO
179 /*
180 * Save the instance handle of the exe/dll.
181 */
182 void
SaveInst(HINSTANCE hInst)183 SaveInst(HINSTANCE hInst)
184 {
185 g_hinst = hInst;
186 }
187 #endif
188
189 #if defined(FEAT_GUI_MSWIN) || defined(PROTO)
190 /*
191 * GUI version of mch_exit().
192 * Shut down and exit with status `r'
193 * Careful: mch_exit() may be called before mch_init()!
194 */
195 void
mch_exit_g(int r)196 mch_exit_g(int r)
197 {
198 exiting = TRUE;
199
200 display_errors();
201
202 ml_close_all(TRUE); // remove all memfiles
203
204 # ifdef FEAT_OLE
205 UninitOLE();
206 # endif
207 # ifdef FEAT_JOB_CHANNEL
208 if (WSInitialized)
209 {
210 WSInitialized = FALSE;
211 WSACleanup();
212 }
213 # endif
214 # ifdef DYNAMIC_GETTEXT
215 dyn_libintl_end();
216 # endif
217
218 if (gui.in_use)
219 gui_exit(r);
220
221 # ifdef EXITFREE
222 free_all_mem();
223 # endif
224
225 exit(r);
226 }
227
228 #endif // FEAT_GUI_MSWIN
229
230
231 /*
232 * Init the tables for toupper() and tolower().
233 */
234 void
mch_early_init(void)235 mch_early_init(void)
236 {
237 int i;
238
239 PlatformId();
240
241 // Init the tables for toupper() and tolower()
242 for (i = 0; i < 256; ++i)
243 toupper_tab[i] = tolower_tab[i] = i;
244 CharUpperBuff((LPSTR)toupper_tab, 256);
245 CharLowerBuff((LPSTR)tolower_tab, 256);
246 }
247
248
249 /*
250 * Return TRUE if the input comes from a terminal, FALSE otherwise.
251 */
252 int
mch_input_isatty(void)253 mch_input_isatty(void)
254 {
255 #ifdef FEAT_GUI_MSWIN
256 # ifdef VIMDLL
257 if (gui.in_use)
258 # endif
259 return TRUE; // GUI always has a tty
260 #endif
261 #if !defined(FEAT_GUI_MSWIN) || defined(VIMDLL)
262 if (isatty(read_cmd_fd))
263 return TRUE;
264 return FALSE;
265 #endif
266 }
267
268 #ifdef FEAT_TITLE
269 /*
270 * mch_settitle(): set titlebar of our window
271 */
272 void
mch_settitle(char_u * title,char_u * icon UNUSED)273 mch_settitle(
274 char_u *title,
275 char_u *icon UNUSED)
276 {
277 # ifdef FEAT_GUI_MSWIN
278 # ifdef VIMDLL
279 if (gui.in_use)
280 # endif
281 {
282 gui_mch_settitle(title, icon);
283 return;
284 }
285 # endif
286 # if !defined(FEAT_GUI_MSWIN) || defined(VIMDLL)
287 if (title != NULL)
288 {
289 WCHAR *wp = enc_to_utf16(title, NULL);
290
291 if (wp == NULL)
292 return;
293
294 SetConsoleTitleW(wp);
295 vim_free(wp);
296 return;
297 }
298 # endif
299 }
300
301
302 /*
303 * Restore the window/icon title.
304 * which is one of:
305 * SAVE_RESTORE_TITLE: Just restore title
306 * SAVE_RESTORE_ICON: Just restore icon (which we don't have)
307 * SAVE_RESTORE_BOTH: Restore title and icon (which we don't have)
308 */
309 void
mch_restore_title(int which UNUSED)310 mch_restore_title(int which UNUSED)
311 {
312 # if !defined(FEAT_GUI_MSWIN) || defined(VIMDLL)
313 # ifdef VIMDLL
314 if (!gui.in_use)
315 # endif
316 SetConsoleTitle(g_szOrigTitle);
317 # endif
318 }
319
320
321 /*
322 * Return TRUE if we can restore the title (we can)
323 */
324 int
mch_can_restore_title(void)325 mch_can_restore_title(void)
326 {
327 return TRUE;
328 }
329
330
331 /*
332 * Return TRUE if we can restore the icon title (we can't)
333 */
334 int
mch_can_restore_icon(void)335 mch_can_restore_icon(void)
336 {
337 return FALSE;
338 }
339 #endif // FEAT_TITLE
340
341
342 /*
343 * Get absolute file name into buffer "buf" of length "len" bytes,
344 * turning all '/'s into '\\'s and getting the correct case of each component
345 * of the file name. Append a (back)slash to a directory name.
346 * When 'shellslash' set do it the other way around.
347 * Return OK or FAIL.
348 */
349 int
mch_FullName(char_u * fname,char_u * buf,int len,int force UNUSED)350 mch_FullName(
351 char_u *fname,
352 char_u *buf,
353 int len,
354 int force UNUSED)
355 {
356 int nResult = FAIL;
357 WCHAR *wname;
358 WCHAR wbuf[MAX_PATH];
359 char_u *cname = NULL;
360
361 wname = enc_to_utf16(fname, NULL);
362 if (wname != NULL && _wfullpath(wbuf, wname, MAX_PATH) != NULL)
363 {
364 cname = utf16_to_enc((short_u *)wbuf, NULL);
365 if (cname != NULL)
366 {
367 vim_strncpy(buf, cname, len - 1);
368 nResult = OK;
369 }
370 }
371 vim_free(wname);
372 vim_free(cname);
373
374 #ifdef USE_FNAME_CASE
375 fname_case(buf, len);
376 #else
377 slash_adjust(buf);
378 #endif
379
380 return nResult;
381 }
382
383
384 /*
385 * Return TRUE if "fname" does not depend on the current directory.
386 */
387 int
mch_isFullName(char_u * fname)388 mch_isFullName(char_u *fname)
389 {
390 // A name like "d:/foo" and "//server/share" is absolute. "d:foo" is not.
391 // Another way to check is to use mch_FullName() and see if the result is
392 // the same as the name or mch_FullName() fails. However, this has quite a
393 // bit of overhead, so let's not do that.
394 return ((ASCII_ISALPHA(fname[0]) && fname[1] == ':'
395 && (fname[2] == '/' || fname[2] == '\\'))
396 || (fname[0] == fname[1] && (fname[0] == '/' || fname[0] == '\\')));
397 }
398
399 /*
400 * Replace all slashes by backslashes.
401 * This used to be the other way around, but MS-DOS sometimes has problems
402 * with slashes (e.g. in a command name). We can't have mixed slashes and
403 * backslashes, because comparing file names will not work correctly. The
404 * commands that use a file name should try to avoid the need to type a
405 * backslash twice.
406 * When 'shellslash' set do it the other way around.
407 * When the path looks like a URL leave it unmodified.
408 */
409 void
slash_adjust(char_u * p)410 slash_adjust(char_u *p)
411 {
412 if (path_with_url(p))
413 return;
414
415 if (*p == '`')
416 {
417 size_t len = STRLEN(p);
418
419 // don't replace backslash in backtick quoted strings
420 if (len > 2 && *(p + len - 1) == '`')
421 return;
422 }
423
424 while (*p)
425 {
426 if (*p == psepcN)
427 *p = psepc;
428 MB_PTR_ADV(p);
429 }
430 }
431
432 // Use 64-bit stat functions if available.
433 #ifdef HAVE_STAT64
434 # undef stat
435 # undef _stat
436 # undef _wstat
437 # undef _fstat
438 # define stat _stat64
439 # define _stat _stat64
440 # define _wstat _wstat64
441 # define _fstat _fstat64
442 #endif
443
444 #if (defined(_MSC_VER) && (_MSC_VER >= 1300)) || defined(__MINGW32__)
445 # define OPEN_OH_ARGTYPE intptr_t
446 #else
447 # define OPEN_OH_ARGTYPE long
448 #endif
449
450 static int
wstat_symlink_aware(const WCHAR * name,stat_T * stp)451 wstat_symlink_aware(const WCHAR *name, stat_T *stp)
452 {
453 #if (defined(_MSC_VER) && (_MSC_VER < 1900)) || defined(__MINGW32__)
454 // Work around for VC12 or earlier (and MinGW). _wstat() can't handle
455 // symlinks properly.
456 // VC9 or earlier: _wstat() doesn't support a symlink at all. It retrieves
457 // status of a symlink itself.
458 // VC10: _wstat() supports a symlink to a normal file, but it doesn't
459 // support a symlink to a directory (always returns an error).
460 // VC11 and VC12: _wstat() doesn't return an error for a symlink to a
461 // directory, but it doesn't set S_IFDIR flag.
462 // MinGW: Same as VC9.
463 int n;
464 BOOL is_symlink = FALSE;
465 HANDLE hFind, h;
466 DWORD attr = 0;
467 WIN32_FIND_DATAW findDataW;
468
469 hFind = FindFirstFileW(name, &findDataW);
470 if (hFind != INVALID_HANDLE_VALUE)
471 {
472 attr = findDataW.dwFileAttributes;
473 if ((attr & FILE_ATTRIBUTE_REPARSE_POINT)
474 && (findDataW.dwReserved0 == IO_REPARSE_TAG_SYMLINK))
475 is_symlink = TRUE;
476 FindClose(hFind);
477 }
478 if (is_symlink)
479 {
480 h = CreateFileW(name, FILE_READ_ATTRIBUTES,
481 FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
482 OPEN_EXISTING,
483 (attr & FILE_ATTRIBUTE_DIRECTORY)
484 ? FILE_FLAG_BACKUP_SEMANTICS : 0,
485 NULL);
486 if (h != INVALID_HANDLE_VALUE)
487 {
488 int fd;
489
490 fd = _open_osfhandle((OPEN_OH_ARGTYPE)h, _O_RDONLY);
491 n = _fstat(fd, (struct _stat *)stp);
492 if ((n == 0) && (attr & FILE_ATTRIBUTE_DIRECTORY))
493 stp->st_mode = (stp->st_mode & ~S_IFREG) | S_IFDIR;
494 _close(fd);
495 return n;
496 }
497 }
498 #endif
499 return _wstat(name, (struct _stat *)stp);
500 }
501
502 /*
503 * stat() can't handle a trailing '/' or '\', remove it first.
504 */
505 int
vim_stat(const char * name,stat_T * stp)506 vim_stat(const char *name, stat_T *stp)
507 {
508 // WinNT and later can use _MAX_PATH wide characters for a pathname, which
509 // means that the maximum pathname is _MAX_PATH * 3 bytes when 'enc' is
510 // UTF-8.
511 char_u buf[_MAX_PATH * 3 + 1];
512 char_u *p;
513 WCHAR *wp;
514 int n;
515
516 vim_strncpy((char_u *)buf, (char_u *)name, sizeof(buf) - 1);
517 p = buf + STRLEN(buf);
518 if (p > buf)
519 MB_PTR_BACK(buf, p);
520
521 // Remove trailing '\\' except root path.
522 if (p > buf && (*p == '\\' || *p == '/') && p[-1] != ':')
523 *p = NUL;
524
525 if ((buf[0] == '\\' && buf[1] == '\\') || (buf[0] == '/' && buf[1] == '/'))
526 {
527 // UNC root path must be followed by '\\'.
528 p = vim_strpbrk(buf + 2, (char_u *)"\\/");
529 if (p != NULL)
530 {
531 p = vim_strpbrk(p + 1, (char_u *)"\\/");
532 if (p == NULL)
533 STRCAT(buf, "\\");
534 }
535 }
536
537 wp = enc_to_utf16(buf, NULL);
538 if (wp == NULL)
539 return -1;
540
541 n = wstat_symlink_aware(wp, stp);
542 vim_free(wp);
543 return n;
544 }
545
546 #if (defined(FEAT_GUI_MSWIN) && !defined(VIMDLL)) || defined(PROTO)
547 void
mch_settmode(tmode_T tmode UNUSED)548 mch_settmode(tmode_T tmode UNUSED)
549 {
550 // nothing to do
551 }
552
553 int
mch_get_shellsize(void)554 mch_get_shellsize(void)
555 {
556 // never used
557 return OK;
558 }
559
560 void
mch_set_shellsize(void)561 mch_set_shellsize(void)
562 {
563 // never used
564 }
565
566 /*
567 * Rows and/or Columns has changed.
568 */
569 void
mch_new_shellsize(void)570 mch_new_shellsize(void)
571 {
572 // never used
573 }
574
575 #endif
576
577 /*
578 * We have no job control, so fake it by starting a new shell.
579 */
580 void
mch_suspend(void)581 mch_suspend(void)
582 {
583 suspend_shell();
584 }
585
586 #if defined(USE_MCH_ERRMSG) || defined(PROTO)
587
588 # ifdef display_errors
589 # undef display_errors
590 # endif
591
592 /*
593 * Display the saved error message(s).
594 */
595 void
display_errors(void)596 display_errors(void)
597 {
598 # ifdef FEAT_GUI
599 char *p;
600
601 # ifdef VIMDLL
602 if (gui.in_use || gui.starting)
603 # endif
604 {
605 if (error_ga.ga_data != NULL)
606 {
607 // avoid putting up a message box with blanks only
608 for (p = (char *)error_ga.ga_data; *p; ++p)
609 if (!isspace(*p))
610 {
611 (void)gui_mch_dialog(
612 gui.starting ? VIM_INFO :
613 VIM_ERROR,
614 gui.starting ? (char_u *)_("Message") :
615 (char_u *)_("Error"),
616 (char_u *)p, (char_u *)_("&Ok"),
617 1, NULL, FALSE);
618 break;
619 }
620 ga_clear(&error_ga);
621 }
622 return;
623 }
624 # endif
625 # if !defined(FEAT_GUI) || defined(VIMDLL)
626 FlushFileBuffers(GetStdHandle(STD_ERROR_HANDLE));
627 # endif
628 }
629 #endif
630
631
632 /*
633 * Return TRUE if "p" contain a wildcard that can be expanded by
634 * dos_expandpath().
635 */
636 int
mch_has_exp_wildcard(char_u * p)637 mch_has_exp_wildcard(char_u *p)
638 {
639 for ( ; *p; MB_PTR_ADV(p))
640 {
641 if (vim_strchr((char_u *)"?*[", *p) != NULL
642 || (*p == '~' && p[1] != NUL))
643 return TRUE;
644 }
645 return FALSE;
646 }
647
648 /*
649 * Return TRUE if "p" contain a wildcard or a "~1" kind of thing (could be a
650 * shortened file name).
651 */
652 int
mch_has_wildcard(char_u * p)653 mch_has_wildcard(char_u *p)
654 {
655 for ( ; *p; MB_PTR_ADV(p))
656 {
657 if (vim_strchr((char_u *)
658 #ifdef VIM_BACKTICK
659 "?*$[`"
660 #else
661 "?*$["
662 #endif
663 , *p) != NULL
664 || (*p == '~' && p[1] != NUL))
665 return TRUE;
666 }
667 return FALSE;
668 }
669
670
671 /*
672 * The normal _chdir() does not change the default drive. This one does.
673 * Returning 0 implies success; -1 implies failure.
674 */
675 int
mch_chdir(char * path)676 mch_chdir(char *path)
677 {
678 WCHAR *p;
679 int n;
680
681 if (path[0] == NUL) // just checking...
682 return -1;
683
684 if (p_verbose >= 5)
685 {
686 verbose_enter();
687 smsg("chdir(%s)", path);
688 verbose_leave();
689 }
690 if (isalpha(path[0]) && path[1] == ':') // has a drive name
691 {
692 // If we can change to the drive, skip that part of the path. If we
693 // can't then the current directory may be invalid, try using chdir()
694 // with the whole path.
695 if (_chdrive(TOLOWER_ASC(path[0]) - 'a' + 1) == 0)
696 path += 2;
697 }
698
699 if (*path == NUL) // drive name only
700 return 0;
701
702 p = enc_to_utf16((char_u *)path, NULL);
703 if (p == NULL)
704 return -1;
705
706 n = _wchdir(p);
707 vim_free(p);
708 return n;
709 }
710
711
712 #if defined(FEAT_GUI_MSWIN) && !defined(VIMDLL)
713 /*
714 * return non-zero if a character is available
715 */
716 int
mch_char_avail(void)717 mch_char_avail(void)
718 {
719 // never used
720 return TRUE;
721 }
722
723 # if defined(FEAT_TERMINAL) || defined(PROTO)
724 /*
725 * Check for any pending input or messages.
726 */
727 int
mch_check_messages(void)728 mch_check_messages(void)
729 {
730 // TODO: check for messages
731 return TRUE;
732 }
733 # endif
734 #endif
735
736
737 #if defined(FEAT_LIBCALL) || defined(PROTO)
738 /*
739 * Call a DLL routine which takes either a string or int param
740 * and returns an allocated string.
741 * Return OK if it worked, FAIL if not.
742 */
743 typedef LPTSTR (*MYSTRPROCSTR)(LPTSTR);
744 typedef LPTSTR (*MYINTPROCSTR)(int);
745 typedef int (*MYSTRPROCINT)(LPTSTR);
746 typedef int (*MYINTPROCINT)(int);
747
748 /*
749 * Check if a pointer points to a valid NUL terminated string.
750 * Return the length of the string, including terminating NUL.
751 * Returns 0 for an invalid pointer, 1 for an empty string.
752 */
753 static size_t
check_str_len(char_u * str)754 check_str_len(char_u *str)
755 {
756 SYSTEM_INFO si;
757 MEMORY_BASIC_INFORMATION mbi;
758 size_t length = 0;
759 size_t i;
760 const char_u *p;
761
762 // get page size
763 GetSystemInfo(&si);
764
765 // get memory information
766 if (VirtualQuery(str, &mbi, sizeof(mbi)))
767 {
768 // pre cast these (typing savers)
769 long_u dwStr = (long_u)str;
770 long_u dwBaseAddress = (long_u)mbi.BaseAddress;
771
772 // get start address of page that str is on
773 long_u strPage = dwStr - (dwStr - dwBaseAddress) % si.dwPageSize;
774
775 // get length from str to end of page
776 long_u pageLength = si.dwPageSize - (dwStr - strPage);
777
778 for (p = str; !IsBadReadPtr(p, (UINT)pageLength);
779 p += pageLength, pageLength = si.dwPageSize)
780 for (i = 0; i < pageLength; ++i, ++length)
781 if (p[i] == NUL)
782 return length + 1;
783 }
784
785 return 0;
786 }
787
788 /*
789 * Passed to do_in_runtimepath() to load a vim.ico file.
790 */
791 static void
mch_icon_load_cb(char_u * fname,void * cookie)792 mch_icon_load_cb(char_u *fname, void *cookie)
793 {
794 HANDLE *h = (HANDLE *)cookie;
795
796 *h = LoadImage(NULL,
797 (LPSTR)fname,
798 IMAGE_ICON,
799 64,
800 64,
801 LR_LOADFROMFILE | LR_LOADMAP3DCOLORS);
802 }
803
804 /*
805 * Try loading an icon file from 'runtimepath'.
806 */
807 int
mch_icon_load(HANDLE * iconp)808 mch_icon_load(HANDLE *iconp)
809 {
810 return do_in_runtimepath((char_u *)"bitmaps/vim.ico",
811 0, mch_icon_load_cb, iconp);
812 }
813
814 int
mch_libcall(char_u * libname,char_u * funcname,char_u * argstring,int argint,char_u ** string_result,int * number_result)815 mch_libcall(
816 char_u *libname,
817 char_u *funcname,
818 char_u *argstring, // NULL when using a argint
819 int argint,
820 char_u **string_result,// NULL when using number_result
821 int *number_result)
822 {
823 HINSTANCE hinstLib;
824 MYSTRPROCSTR ProcAdd;
825 MYINTPROCSTR ProcAddI;
826 char_u *retval_str = NULL;
827 int retval_int = 0;
828 size_t len;
829
830 BOOL fRunTimeLinkSuccess = FALSE;
831
832 // Get a handle to the DLL module.
833 hinstLib = vimLoadLib((char *)libname);
834
835 // If the handle is valid, try to get the function address.
836 if (hinstLib != NULL)
837 {
838 # ifdef HAVE_TRY_EXCEPT
839 __try
840 {
841 # endif
842 if (argstring != NULL)
843 {
844 // Call with string argument
845 ProcAdd = (MYSTRPROCSTR)GetProcAddress(hinstLib, (LPCSTR)funcname);
846 if ((fRunTimeLinkSuccess = (ProcAdd != NULL)) != 0)
847 {
848 if (string_result == NULL)
849 retval_int = ((MYSTRPROCINT)ProcAdd)((LPSTR)argstring);
850 else
851 retval_str = (char_u *)(ProcAdd)((LPSTR)argstring);
852 }
853 }
854 else
855 {
856 // Call with number argument
857 ProcAddI = (MYINTPROCSTR) GetProcAddress(hinstLib, (LPCSTR)funcname);
858 if ((fRunTimeLinkSuccess = (ProcAddI != NULL)) != 0)
859 {
860 if (string_result == NULL)
861 retval_int = ((MYINTPROCINT)ProcAddI)(argint);
862 else
863 retval_str = (char_u *)(ProcAddI)(argint);
864 }
865 }
866
867 // Save the string before we free the library.
868 // Assume that a "1" result is an illegal pointer.
869 if (string_result == NULL)
870 *number_result = retval_int;
871 else if (retval_str != NULL
872 && (len = check_str_len(retval_str)) > 0)
873 {
874 *string_result = alloc(len);
875 if (*string_result != NULL)
876 mch_memmove(*string_result, retval_str, len);
877 }
878
879 # ifdef HAVE_TRY_EXCEPT
880 }
881 __except(EXCEPTION_EXECUTE_HANDLER)
882 {
883 if (GetExceptionCode() == EXCEPTION_STACK_OVERFLOW)
884 RESETSTKOFLW();
885 fRunTimeLinkSuccess = 0;
886 }
887 # endif
888
889 // Free the DLL module.
890 (void)FreeLibrary(hinstLib);
891 }
892
893 if (!fRunTimeLinkSuccess)
894 {
895 semsg(_(e_libcall), funcname);
896 return FAIL;
897 }
898
899 return OK;
900 }
901 #endif
902
903 /*
904 * Debugging helper: expose the MCH_WRITE_DUMP stuff to other modules
905 */
906 void
DumpPutS(const char * psz UNUSED)907 DumpPutS(const char *psz UNUSED)
908 {
909 #ifdef MCH_WRITE_DUMP
910 if (fdDump)
911 {
912 fputs(psz, fdDump);
913 if (psz[strlen(psz) - 1] != '\n')
914 fputc('\n', fdDump);
915 fflush(fdDump);
916 }
917 #endif
918 }
919
920 #ifdef _DEBUG
921
922 void __cdecl
Trace(char * pszFormat,...)923 Trace(
924 char *pszFormat,
925 ...)
926 {
927 CHAR szBuff[2048];
928 va_list args;
929
930 va_start(args, pszFormat);
931 vsprintf(szBuff, pszFormat, args);
932 va_end(args);
933
934 OutputDebugString(szBuff);
935 }
936
937 #endif //_DEBUG
938
939 #if !defined(FEAT_GUI) || defined(VIMDLL) || defined(PROTO)
940 # ifdef FEAT_TITLE
941 extern HWND g_hWnd; // This is in os_win32.c.
942 # endif
943
944 /*
945 * Showing the printer dialog is tricky since we have no GUI
946 * window to parent it. The following routines are needed to
947 * get the window parenting and Z-order to work properly.
948 */
949 static void
GetConsoleHwnd(void)950 GetConsoleHwnd(void)
951 {
952 // Skip if it's already set.
953 if (s_hwnd != 0)
954 return;
955
956 # ifdef FEAT_TITLE
957 // Window handle may have been found by init code (Windows NT only)
958 if (g_hWnd != 0)
959 {
960 s_hwnd = g_hWnd;
961 return;
962 }
963 # endif
964
965 s_hwnd = GetConsoleWindow();
966 }
967
968 /*
969 * Console implementation of ":winpos".
970 */
971 int
mch_get_winpos(int * x,int * y)972 mch_get_winpos(int *x, int *y)
973 {
974 RECT rect;
975
976 GetConsoleHwnd();
977 GetWindowRect(s_hwnd, &rect);
978 *x = rect.left;
979 *y = rect.top;
980 return OK;
981 }
982
983 /*
984 * Console implementation of ":winpos x y".
985 */
986 void
mch_set_winpos(int x,int y)987 mch_set_winpos(int x, int y)
988 {
989 GetConsoleHwnd();
990 SetWindowPos(s_hwnd, NULL, x, y, 0, 0,
991 SWP_NOZORDER | SWP_NOSIZE | SWP_NOACTIVATE);
992 }
993 #endif
994
995 #if (defined(FEAT_PRINTER) && !defined(FEAT_POSTSCRIPT)) || defined(PROTO)
996
997 //=================================================================
998 // Win32 printer stuff
999
1000 static HFONT prt_font_handles[2][2][2];
1001 static PRINTDLGW prt_dlg;
1002 static const int boldface[2] = {FW_REGULAR, FW_BOLD};
1003 static TEXTMETRIC prt_tm;
1004 static int prt_line_height;
1005 static int prt_number_width;
1006 static int prt_left_margin;
1007 static int prt_right_margin;
1008 static int prt_top_margin;
1009 static char_u szAppName[] = TEXT("VIM");
1010 static HWND hDlgPrint;
1011 static int *bUserAbort = NULL;
1012 static char_u *prt_name = NULL;
1013
1014 // Defines which are also in vim.rc.
1015 # define IDC_BOX1 400
1016 # define IDC_PRINTTEXT1 401
1017 # define IDC_PRINTTEXT2 402
1018 # define IDC_PROGRESS 403
1019
1020 static BOOL
vimSetDlgItemText(HWND hDlg,int nIDDlgItem,char_u * s)1021 vimSetDlgItemText(HWND hDlg, int nIDDlgItem, char_u *s)
1022 {
1023 WCHAR *wp;
1024 BOOL ret;
1025
1026 wp = enc_to_utf16(s, NULL);
1027 if (wp == NULL)
1028 return FALSE;
1029
1030 ret = SetDlgItemTextW(hDlg, nIDDlgItem, wp);
1031 vim_free(wp);
1032 return ret;
1033 }
1034
1035 /*
1036 * Convert BGR to RGB for Windows GDI calls
1037 */
1038 static COLORREF
swap_me(COLORREF colorref)1039 swap_me(COLORREF colorref)
1040 {
1041 int temp;
1042 char *ptr = (char *)&colorref;
1043
1044 temp = *(ptr);
1045 *(ptr ) = *(ptr + 2);
1046 *(ptr + 2) = temp;
1047 return colorref;
1048 }
1049
1050 // Attempt to make this work for old and new compilers
1051 # if !defined(_WIN64) && (!defined(_MSC_VER) || _MSC_VER < 1300)
1052 # define PDP_RETVAL BOOL
1053 # else
1054 # define PDP_RETVAL INT_PTR
1055 # endif
1056
1057 static PDP_RETVAL CALLBACK
PrintDlgProc(HWND hDlg,UINT message,WPARAM wParam UNUSED,LPARAM lParam UNUSED)1058 PrintDlgProc(
1059 HWND hDlg,
1060 UINT message,
1061 WPARAM wParam UNUSED,
1062 LPARAM lParam UNUSED)
1063 {
1064 # ifdef FEAT_GETTEXT
1065 NONCLIENTMETRICS nm;
1066 static HFONT hfont;
1067 # endif
1068
1069 switch (message)
1070 {
1071 case WM_INITDIALOG:
1072 # ifdef FEAT_GETTEXT
1073 nm.cbSize = sizeof(NONCLIENTMETRICS);
1074 if (SystemParametersInfo(
1075 SPI_GETNONCLIENTMETRICS,
1076 sizeof(NONCLIENTMETRICS),
1077 &nm,
1078 0))
1079 {
1080 char buff[MAX_PATH];
1081 int i;
1082
1083 // Translate the dialog texts
1084 hfont = CreateFontIndirect(&nm.lfMessageFont);
1085 for (i = IDC_PRINTTEXT1; i <= IDC_PROGRESS; i++)
1086 {
1087 SendDlgItemMessage(hDlg, i, WM_SETFONT, (WPARAM)hfont, 1);
1088 if (GetDlgItemText(hDlg,i, buff, sizeof(buff)))
1089 vimSetDlgItemText(hDlg,i, (char_u *)_(buff));
1090 }
1091 SendDlgItemMessage(hDlg, IDCANCEL,
1092 WM_SETFONT, (WPARAM)hfont, 1);
1093 if (GetDlgItemText(hDlg,IDCANCEL, buff, sizeof(buff)))
1094 vimSetDlgItemText(hDlg,IDCANCEL, (char_u *)_(buff));
1095 }
1096 # endif
1097 SetWindowText(hDlg, (LPCSTR)szAppName);
1098 if (prt_name != NULL)
1099 {
1100 vimSetDlgItemText(hDlg, IDC_PRINTTEXT2, (char_u *)prt_name);
1101 VIM_CLEAR(prt_name);
1102 }
1103 EnableMenuItem(GetSystemMenu(hDlg, FALSE), SC_CLOSE, MF_GRAYED);
1104 # if !defined(FEAT_GUI) || defined(VIMDLL)
1105 # ifdef VIMDLL
1106 if (!gui.in_use)
1107 # endif
1108 BringWindowToTop(s_hwnd);
1109 # endif
1110 return TRUE;
1111
1112 case WM_COMMAND:
1113 *bUserAbort = TRUE;
1114 EnableWindow(GetParent(hDlg), TRUE);
1115 DestroyWindow(hDlg);
1116 hDlgPrint = NULL;
1117 # ifdef FEAT_GETTEXT
1118 DeleteObject(hfont);
1119 # endif
1120 return TRUE;
1121 }
1122 return FALSE;
1123 }
1124
1125 static BOOL CALLBACK
AbortProc(HDC hdcPrn UNUSED,int iCode UNUSED)1126 AbortProc(HDC hdcPrn UNUSED, int iCode UNUSED)
1127 {
1128 MSG msg;
1129
1130 while (!*bUserAbort && pPeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
1131 {
1132 if (!hDlgPrint || !pIsDialogMessage(hDlgPrint, &msg))
1133 {
1134 TranslateMessage(&msg);
1135 pDispatchMessage(&msg);
1136 }
1137 }
1138 return !*bUserAbort;
1139 }
1140
1141 # if !defined(FEAT_GUI) || defined(VIMDLL)
1142
1143 static UINT_PTR CALLBACK
PrintHookProc(HWND hDlg,UINT uiMsg,WPARAM wParam UNUSED,LPARAM lParam)1144 PrintHookProc(
1145 HWND hDlg, // handle to dialog box
1146 UINT uiMsg, // message identifier
1147 WPARAM wParam UNUSED, // message parameter
1148 LPARAM lParam // message parameter
1149 )
1150 {
1151 HWND hwndOwner;
1152 RECT rc, rcDlg, rcOwner;
1153 PRINTDLGW *pPD;
1154
1155 if (uiMsg == WM_INITDIALOG)
1156 {
1157 // Get the owner window and dialog box rectangles.
1158 if ((hwndOwner = GetParent(hDlg)) == NULL)
1159 hwndOwner = GetDesktopWindow();
1160
1161 GetWindowRect(hwndOwner, &rcOwner);
1162 GetWindowRect(hDlg, &rcDlg);
1163 CopyRect(&rc, &rcOwner);
1164
1165 // Offset the owner and dialog box rectangles so that
1166 // right and bottom values represent the width and
1167 // height, and then offset the owner again to discard
1168 // space taken up by the dialog box.
1169
1170 OffsetRect(&rcDlg, -rcDlg.left, -rcDlg.top);
1171 OffsetRect(&rc, -rc.left, -rc.top);
1172 OffsetRect(&rc, -rcDlg.right, -rcDlg.bottom);
1173
1174 // The new position is the sum of half the remaining
1175 // space and the owner's original position.
1176
1177 SetWindowPos(hDlg,
1178 HWND_TOP,
1179 rcOwner.left + (rc.right / 2),
1180 rcOwner.top + (rc.bottom / 2),
1181 0, 0, // ignores size arguments
1182 SWP_NOSIZE);
1183
1184 // tackle the printdlg copiesctrl problem
1185 pPD = (PRINTDLGW *)lParam;
1186 pPD->nCopies = (WORD)pPD->lCustData;
1187 SetDlgItemInt( hDlg, edt3, pPD->nCopies, FALSE );
1188 // Bring the window to top
1189 BringWindowToTop(GetParent(hDlg));
1190 SetForegroundWindow(hDlg);
1191 }
1192
1193 return FALSE;
1194 }
1195 # endif
1196
1197 void
mch_print_cleanup(void)1198 mch_print_cleanup(void)
1199 {
1200 int pifItalic;
1201 int pifBold;
1202 int pifUnderline;
1203
1204 for (pifBold = 0; pifBold <= 1; pifBold++)
1205 for (pifItalic = 0; pifItalic <= 1; pifItalic++)
1206 for (pifUnderline = 0; pifUnderline <= 1; pifUnderline++)
1207 DeleteObject(prt_font_handles[pifBold][pifItalic][pifUnderline]);
1208
1209 if (prt_dlg.hDC != NULL)
1210 DeleteDC(prt_dlg.hDC);
1211 if (!*bUserAbort)
1212 SendMessage(hDlgPrint, WM_COMMAND, 0, 0);
1213 }
1214
1215 static int
to_device_units(int idx,int dpi,int physsize,int offset,int def_number)1216 to_device_units(int idx, int dpi, int physsize, int offset, int def_number)
1217 {
1218 int ret = 0;
1219 int u;
1220 int nr;
1221
1222 u = prt_get_unit(idx);
1223 if (u == PRT_UNIT_NONE)
1224 {
1225 u = PRT_UNIT_PERC;
1226 nr = def_number;
1227 }
1228 else
1229 nr = printer_opts[idx].number;
1230
1231 switch (u)
1232 {
1233 case PRT_UNIT_PERC:
1234 ret = (physsize * nr) / 100;
1235 break;
1236 case PRT_UNIT_INCH:
1237 ret = (nr * dpi);
1238 break;
1239 case PRT_UNIT_MM:
1240 ret = (nr * 10 * dpi) / 254;
1241 break;
1242 case PRT_UNIT_POINT:
1243 ret = (nr * 10 * dpi) / 720;
1244 break;
1245 }
1246
1247 if (ret < offset)
1248 return 0;
1249 else
1250 return ret - offset;
1251 }
1252
1253 static int
prt_get_cpl(void)1254 prt_get_cpl(void)
1255 {
1256 int hr;
1257 int phyw;
1258 int dvoff;
1259 int rev_offset;
1260 int dpi;
1261
1262 GetTextMetrics(prt_dlg.hDC, &prt_tm);
1263 prt_line_height = prt_tm.tmHeight + prt_tm.tmExternalLeading;
1264
1265 hr = GetDeviceCaps(prt_dlg.hDC, HORZRES);
1266 phyw = GetDeviceCaps(prt_dlg.hDC, PHYSICALWIDTH);
1267 dvoff = GetDeviceCaps(prt_dlg.hDC, PHYSICALOFFSETX);
1268 dpi = GetDeviceCaps(prt_dlg.hDC, LOGPIXELSX);
1269
1270 rev_offset = phyw - (dvoff + hr);
1271
1272 prt_left_margin = to_device_units(OPT_PRINT_LEFT, dpi, phyw, dvoff, 10);
1273 if (prt_use_number())
1274 {
1275 prt_number_width = PRINT_NUMBER_WIDTH * prt_tm.tmAveCharWidth;
1276 prt_left_margin += prt_number_width;
1277 }
1278 else
1279 prt_number_width = 0;
1280
1281 prt_right_margin = hr - to_device_units(OPT_PRINT_RIGHT, dpi, phyw,
1282 rev_offset, 5);
1283
1284 return (prt_right_margin - prt_left_margin) / prt_tm.tmAveCharWidth;
1285 }
1286
1287 static int
prt_get_lpp(void)1288 prt_get_lpp(void)
1289 {
1290 int vr;
1291 int phyw;
1292 int dvoff;
1293 int rev_offset;
1294 int bottom_margin;
1295 int dpi;
1296
1297 vr = GetDeviceCaps(prt_dlg.hDC, VERTRES);
1298 phyw = GetDeviceCaps(prt_dlg.hDC, PHYSICALHEIGHT);
1299 dvoff = GetDeviceCaps(prt_dlg.hDC, PHYSICALOFFSETY);
1300 dpi = GetDeviceCaps(prt_dlg.hDC, LOGPIXELSY);
1301
1302 rev_offset = phyw - (dvoff + vr);
1303
1304 prt_top_margin = to_device_units(OPT_PRINT_TOP, dpi, phyw, dvoff, 5);
1305
1306 // adjust top margin if there is a header
1307 prt_top_margin += prt_line_height * prt_header_height();
1308
1309 bottom_margin = vr - to_device_units(OPT_PRINT_BOT, dpi, phyw,
1310 rev_offset, 5);
1311
1312 return (bottom_margin - prt_top_margin) / prt_line_height;
1313 }
1314
1315 int
mch_print_init(prt_settings_T * psettings,char_u * jobname,int forceit)1316 mch_print_init(prt_settings_T *psettings, char_u *jobname, int forceit)
1317 {
1318 static HGLOBAL stored_dm = NULL;
1319 static HGLOBAL stored_devn = NULL;
1320 static int stored_nCopies = 1;
1321 static int stored_nFlags = 0;
1322
1323 LOGFONTW fLogFont;
1324 int pifItalic;
1325 int pifBold;
1326 int pifUnderline;
1327
1328 DEVMODEW *mem;
1329 DEVNAMES *devname;
1330 int i;
1331
1332 bUserAbort = &(psettings->user_abort);
1333 CLEAR_FIELD(prt_dlg);
1334 prt_dlg.lStructSize = sizeof(PRINTDLGW);
1335 # if !defined(FEAT_GUI) || defined(VIMDLL)
1336 # ifdef VIMDLL
1337 if (!gui.in_use)
1338 # endif
1339 GetConsoleHwnd(); // get value of s_hwnd
1340 # endif
1341 prt_dlg.hwndOwner = s_hwnd;
1342 prt_dlg.Flags = PD_NOPAGENUMS | PD_NOSELECTION | PD_RETURNDC;
1343 if (!forceit)
1344 {
1345 prt_dlg.hDevMode = stored_dm;
1346 prt_dlg.hDevNames = stored_devn;
1347 prt_dlg.lCustData = stored_nCopies; // work around bug in print dialog
1348 # if !defined(FEAT_GUI) || defined(VIMDLL)
1349 # ifdef VIMDLL
1350 if (!gui.in_use)
1351 # endif
1352 {
1353 /*
1354 * Use hook to prevent console window being sent to back
1355 */
1356 prt_dlg.lpfnPrintHook = PrintHookProc;
1357 prt_dlg.Flags |= PD_ENABLEPRINTHOOK;
1358 }
1359 # endif
1360 prt_dlg.Flags |= stored_nFlags;
1361 }
1362
1363 /*
1364 * If bang present, return default printer setup with no dialog
1365 * never show dialog if we are running over telnet
1366 */
1367 if (forceit
1368 # if !defined(FEAT_GUI) || defined(VIMDLL)
1369 # ifdef VIMDLL
1370 || (!gui.in_use && !term_console)
1371 # else
1372 || !term_console
1373 # endif
1374 # endif
1375 )
1376 {
1377 prt_dlg.Flags |= PD_RETURNDEFAULT;
1378 /*
1379 * MSDN suggests setting the first parameter to WINSPOOL for
1380 * NT, but NULL appears to work just as well.
1381 */
1382 if (*p_pdev != NUL)
1383 prt_dlg.hDC = CreateDC(NULL, (LPCSTR)p_pdev, NULL, NULL);
1384 else
1385 {
1386 prt_dlg.Flags |= PD_RETURNDEFAULT;
1387 if (PrintDlgW(&prt_dlg) == 0)
1388 goto init_fail_dlg;
1389 }
1390 }
1391 else if (PrintDlgW(&prt_dlg) == 0)
1392 goto init_fail_dlg;
1393 else
1394 {
1395 /*
1396 * keep the previous driver context
1397 */
1398 stored_dm = prt_dlg.hDevMode;
1399 stored_devn = prt_dlg.hDevNames;
1400 stored_nFlags = prt_dlg.Flags;
1401 stored_nCopies = prt_dlg.nCopies;
1402 }
1403
1404 if (prt_dlg.hDC == NULL)
1405 {
1406 emsg(_("E237: Printer selection failed"));
1407 mch_print_cleanup();
1408 return FALSE;
1409 }
1410
1411 // Not all printer drivers report the support of color (or grey) in the
1412 // same way. Let's set has_color if there appears to be some way to print
1413 // more than B&W.
1414 i = GetDeviceCaps(prt_dlg.hDC, NUMCOLORS);
1415 psettings->has_color = (GetDeviceCaps(prt_dlg.hDC, BITSPIXEL) > 1
1416 || GetDeviceCaps(prt_dlg.hDC, PLANES) > 1
1417 || i > 2 || i == -1);
1418
1419 // Ensure all font styles are baseline aligned
1420 SetTextAlign(prt_dlg.hDC, TA_BASELINE|TA_LEFT);
1421
1422 /*
1423 * On some windows systems the nCopies parameter is not
1424 * passed back correctly. It must be retrieved from the
1425 * hDevMode struct.
1426 */
1427 mem = (DEVMODEW *)GlobalLock(prt_dlg.hDevMode);
1428 if (mem != NULL)
1429 {
1430 if (mem->dmCopies != 1)
1431 stored_nCopies = mem->dmCopies;
1432 if ((mem->dmFields & DM_DUPLEX) && (mem->dmDuplex & ~DMDUP_SIMPLEX))
1433 psettings->duplex = TRUE;
1434 if ((mem->dmFields & DM_COLOR) && (mem->dmColor & DMCOLOR_COLOR))
1435 psettings->has_color = TRUE;
1436 }
1437 GlobalUnlock(prt_dlg.hDevMode);
1438
1439 devname = (DEVNAMES *)GlobalLock(prt_dlg.hDevNames);
1440 if (devname != 0)
1441 {
1442 WCHAR *wprinter_name = (WCHAR *)devname + devname->wDeviceOffset;
1443 WCHAR *wport_name = (WCHAR *)devname + devname->wOutputOffset;
1444 char_u *text = (char_u *)_("to %s on %s");
1445 char_u *printer_name = utf16_to_enc(wprinter_name, NULL);
1446 char_u *port_name = utf16_to_enc(wport_name, NULL);
1447
1448 if (printer_name != NULL && port_name != NULL)
1449 prt_name = alloc(STRLEN(printer_name)
1450 + STRLEN(port_name) + STRLEN(text));
1451 if (prt_name != NULL)
1452 wsprintf((char *)prt_name, (const char *)text,
1453 printer_name, port_name);
1454 vim_free(printer_name);
1455 vim_free(port_name);
1456 }
1457 GlobalUnlock(prt_dlg.hDevNames);
1458
1459 /*
1460 * Initialise the font according to 'printfont'
1461 */
1462 CLEAR_FIELD(fLogFont);
1463 if (get_logfont(&fLogFont, p_pfn, prt_dlg.hDC, TRUE) == FAIL)
1464 {
1465 semsg(_("E613: Unknown printer font: %s"), p_pfn);
1466 mch_print_cleanup();
1467 return FALSE;
1468 }
1469
1470 for (pifBold = 0; pifBold <= 1; pifBold++)
1471 for (pifItalic = 0; pifItalic <= 1; pifItalic++)
1472 for (pifUnderline = 0; pifUnderline <= 1; pifUnderline++)
1473 {
1474 fLogFont.lfWeight = boldface[pifBold];
1475 fLogFont.lfItalic = pifItalic;
1476 fLogFont.lfUnderline = pifUnderline;
1477 prt_font_handles[pifBold][pifItalic][pifUnderline]
1478 = CreateFontIndirectW(&fLogFont);
1479 }
1480
1481 SetBkMode(prt_dlg.hDC, OPAQUE);
1482 SelectObject(prt_dlg.hDC, prt_font_handles[0][0][0]);
1483
1484 /*
1485 * Fill in the settings struct
1486 */
1487 psettings->chars_per_line = prt_get_cpl();
1488 psettings->lines_per_page = prt_get_lpp();
1489 if (prt_dlg.Flags & PD_USEDEVMODECOPIESANDCOLLATE)
1490 {
1491 psettings->n_collated_copies = (prt_dlg.Flags & PD_COLLATE)
1492 ? prt_dlg.nCopies : 1;
1493 psettings->n_uncollated_copies = (prt_dlg.Flags & PD_COLLATE)
1494 ? 1 : prt_dlg.nCopies;
1495
1496 if (psettings->n_collated_copies == 0)
1497 psettings->n_collated_copies = 1;
1498
1499 if (psettings->n_uncollated_copies == 0)
1500 psettings->n_uncollated_copies = 1;
1501 }
1502 else
1503 {
1504 psettings->n_collated_copies = 1;
1505 psettings->n_uncollated_copies = 1;
1506 }
1507
1508 psettings->jobname = jobname;
1509
1510 return TRUE;
1511
1512 init_fail_dlg:
1513 {
1514 DWORD err = CommDlgExtendedError();
1515
1516 if (err)
1517 {
1518 char_u *buf;
1519
1520 // I suspect FormatMessage() doesn't work for values returned by
1521 // CommDlgExtendedError(). What does?
1522 FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER |
1523 FORMAT_MESSAGE_FROM_SYSTEM |
1524 FORMAT_MESSAGE_IGNORE_INSERTS,
1525 NULL, err, 0, (LPTSTR)(&buf), 0, NULL);
1526 semsg(_("E238: Print error: %s"),
1527 buf == NULL ? (char_u *)_("Unknown") : buf);
1528 LocalFree((LPVOID)(buf));
1529 }
1530 else
1531 msg_clr_eos(); // Maybe canceled
1532
1533 mch_print_cleanup();
1534 return FALSE;
1535 }
1536 }
1537
1538
1539 int
mch_print_begin(prt_settings_T * psettings)1540 mch_print_begin(prt_settings_T *psettings)
1541 {
1542 int ret = 0;
1543 char szBuffer[300];
1544 WCHAR *wp;
1545
1546 hDlgPrint = CreateDialog(g_hinst, TEXT("PrintDlgBox"),
1547 prt_dlg.hwndOwner, PrintDlgProc);
1548 SetAbortProc(prt_dlg.hDC, AbortProc);
1549 wsprintf(szBuffer, _("Printing '%s'"), gettail(psettings->jobname));
1550 vimSetDlgItemText(hDlgPrint, IDC_PRINTTEXT1, (char_u *)szBuffer);
1551
1552 wp = enc_to_utf16(psettings->jobname, NULL);
1553 if (wp != NULL)
1554 {
1555 DOCINFOW di;
1556
1557 CLEAR_FIELD(di);
1558 di.cbSize = sizeof(di);
1559 di.lpszDocName = wp;
1560 ret = StartDocW(prt_dlg.hDC, &di);
1561 vim_free(wp);
1562 }
1563
1564 # ifdef FEAT_GUI
1565 // Give focus back to main window (when using MDI).
1566 # ifdef VIMDLL
1567 if (gui.in_use)
1568 # endif
1569 SetFocus(s_hwnd);
1570 # endif
1571
1572 return (ret > 0);
1573 }
1574
1575 void
mch_print_end(prt_settings_T * psettings UNUSED)1576 mch_print_end(prt_settings_T *psettings UNUSED)
1577 {
1578 EndDoc(prt_dlg.hDC);
1579 if (!*bUserAbort)
1580 SendMessage(hDlgPrint, WM_COMMAND, 0, 0);
1581 }
1582
1583 int
mch_print_end_page(void)1584 mch_print_end_page(void)
1585 {
1586 return (EndPage(prt_dlg.hDC) > 0);
1587 }
1588
1589 int
mch_print_begin_page(char_u * msg)1590 mch_print_begin_page(char_u *msg)
1591 {
1592 if (msg != NULL)
1593 vimSetDlgItemText(hDlgPrint, IDC_PROGRESS, msg);
1594 return (StartPage(prt_dlg.hDC) > 0);
1595 }
1596
1597 int
mch_print_blank_page(void)1598 mch_print_blank_page(void)
1599 {
1600 return (mch_print_begin_page(NULL) ? (mch_print_end_page()) : FALSE);
1601 }
1602
1603 static int prt_pos_x = 0;
1604 static int prt_pos_y = 0;
1605
1606 void
mch_print_start_line(int margin,int page_line)1607 mch_print_start_line(int margin, int page_line)
1608 {
1609 if (margin)
1610 prt_pos_x = -prt_number_width;
1611 else
1612 prt_pos_x = 0;
1613 prt_pos_y = page_line * prt_line_height
1614 + prt_tm.tmAscent + prt_tm.tmExternalLeading;
1615 }
1616
1617 int
mch_print_text_out(char_u * p,int len)1618 mch_print_text_out(char_u *p, int len)
1619 {
1620 SIZE sz;
1621 WCHAR *wp;
1622 int wlen = len;
1623 int ret = FALSE;
1624
1625 wp = enc_to_utf16(p, &wlen);
1626 if (wp == NULL)
1627 return FALSE;
1628
1629 TextOutW(prt_dlg.hDC, prt_pos_x + prt_left_margin,
1630 prt_pos_y + prt_top_margin, wp, wlen);
1631 GetTextExtentPoint32W(prt_dlg.hDC, wp, wlen, &sz);
1632 vim_free(wp);
1633 prt_pos_x += (sz.cx - prt_tm.tmOverhang);
1634 // This is wrong when printing spaces for a TAB.
1635 if (p[len] != NUL)
1636 {
1637 wlen = mb_ptr2len(p + len);
1638 wp = enc_to_utf16(p + len, &wlen);
1639 if (wp != NULL)
1640 {
1641 GetTextExtentPoint32W(prt_dlg.hDC, wp, 1, &sz);
1642 ret = (prt_pos_x + prt_left_margin + sz.cx > prt_right_margin);
1643 vim_free(wp);
1644 }
1645 }
1646 return ret;
1647 }
1648
1649 void
mch_print_set_font(int iBold,int iItalic,int iUnderline)1650 mch_print_set_font(int iBold, int iItalic, int iUnderline)
1651 {
1652 SelectObject(prt_dlg.hDC, prt_font_handles[iBold][iItalic][iUnderline]);
1653 }
1654
1655 void
mch_print_set_bg(long_u bgcol)1656 mch_print_set_bg(long_u bgcol)
1657 {
1658 SetBkColor(prt_dlg.hDC, GetNearestColor(prt_dlg.hDC,
1659 swap_me((COLORREF)bgcol)));
1660 /*
1661 * With a white background we can draw characters transparent, which is
1662 * good for italic characters that overlap to the next char cell.
1663 */
1664 if (bgcol == 0xffffffUL)
1665 SetBkMode(prt_dlg.hDC, TRANSPARENT);
1666 else
1667 SetBkMode(prt_dlg.hDC, OPAQUE);
1668 }
1669
1670 void
mch_print_set_fg(long_u fgcol)1671 mch_print_set_fg(long_u fgcol)
1672 {
1673 SetTextColor(prt_dlg.hDC, GetNearestColor(prt_dlg.hDC,
1674 swap_me((COLORREF)fgcol)));
1675 }
1676
1677 #endif // FEAT_PRINTER && !FEAT_POSTSCRIPT
1678
1679
1680
1681 #if defined(FEAT_SHORTCUT) || defined(PROTO)
1682 # ifndef PROTO
1683 # include <shlobj.h>
1684 # endif
1685
1686 typedef BOOL (WINAPI *pfnGetFinalPathNameByHandleW)(
1687 HANDLE hFile,
1688 LPWSTR lpszFilePath,
1689 DWORD cchFilePath,
1690 DWORD dwFlags);
1691 static pfnGetFinalPathNameByHandleW pGetFinalPathNameByHandleW = NULL;
1692
1693 # define is_path_sep(c) ((c) == L'\\' || (c) == L'/')
1694
1695 static int
is_reparse_point_included(LPCWSTR fname)1696 is_reparse_point_included(LPCWSTR fname)
1697 {
1698 LPCWSTR p = fname, q;
1699 WCHAR buf[MAX_PATH];
1700 DWORD attr;
1701
1702 if (isalpha(p[0]) && p[1] == L':' && is_path_sep(p[2]))
1703 p += 3;
1704 else if (is_path_sep(p[0]) && is_path_sep(p[1]))
1705 p += 2;
1706
1707 while (*p != L'\0')
1708 {
1709 q = wcspbrk(p, L"\\/");
1710 if (q == NULL)
1711 p = q = fname + wcslen(fname);
1712 else
1713 p = q + 1;
1714 if (q - fname >= MAX_PATH)
1715 return FALSE;
1716 wcsncpy(buf, fname, q - fname);
1717 buf[q - fname] = L'\0';
1718 attr = GetFileAttributesW(buf);
1719 if (attr != INVALID_FILE_ATTRIBUTES
1720 && (attr & FILE_ATTRIBUTE_REPARSE_POINT) != 0)
1721 return TRUE;
1722 }
1723 return FALSE;
1724 }
1725
1726 static char_u *
resolve_reparse_point(char_u * fname)1727 resolve_reparse_point(char_u *fname)
1728 {
1729 HANDLE h = INVALID_HANDLE_VALUE;
1730 DWORD size;
1731 WCHAR *p, *wp;
1732 char_u *rfname = NULL;
1733 WCHAR *buff = NULL;
1734 static BOOL loaded = FALSE;
1735
1736 if (pGetFinalPathNameByHandleW == NULL)
1737 {
1738 HMODULE hmod = GetModuleHandle("kernel32.dll");
1739
1740 if (loaded == TRUE)
1741 return NULL;
1742 pGetFinalPathNameByHandleW = (pfnGetFinalPathNameByHandleW)
1743 GetProcAddress(hmod, "GetFinalPathNameByHandleW");
1744 loaded = TRUE;
1745 if (pGetFinalPathNameByHandleW == NULL)
1746 return NULL;
1747 }
1748
1749 p = enc_to_utf16(fname, NULL);
1750 if (p == NULL)
1751 goto fail;
1752
1753 if (!is_reparse_point_included(p))
1754 {
1755 vim_free(p);
1756 goto fail;
1757 }
1758
1759 h = CreateFileW(p, 0, 0, NULL, OPEN_EXISTING,
1760 FILE_FLAG_BACKUP_SEMANTICS, NULL);
1761 vim_free(p);
1762
1763 if (h == INVALID_HANDLE_VALUE)
1764 goto fail;
1765
1766 size = pGetFinalPathNameByHandleW(h, NULL, 0, 0);
1767 if (size == 0)
1768 goto fail;
1769 buff = ALLOC_MULT(WCHAR, size);
1770 if (buff == NULL)
1771 goto fail;
1772 if (pGetFinalPathNameByHandleW(h, buff, size, 0) == 0)
1773 goto fail;
1774
1775 if (wcsncmp(buff, L"\\\\?\\UNC\\", 8) == 0)
1776 {
1777 buff[6] = L'\\';
1778 wp = buff + 6;
1779 }
1780 else if (wcsncmp(buff, L"\\\\?\\", 4) == 0)
1781 wp = buff + 4;
1782 else
1783 wp = buff;
1784
1785 rfname = utf16_to_enc(wp, NULL);
1786
1787 fail:
1788 if (h != INVALID_HANDLE_VALUE)
1789 CloseHandle(h);
1790 if (buff != NULL)
1791 vim_free(buff);
1792
1793 return rfname;
1794 }
1795
1796 /*
1797 * When "fname" is the name of a shortcut (*.lnk) resolve the file it points
1798 * to and return that name in allocated memory.
1799 * Otherwise NULL is returned.
1800 */
1801 static char_u *
resolve_shortcut(char_u * fname)1802 resolve_shortcut(char_u *fname)
1803 {
1804 HRESULT hr;
1805 IShellLink *psl = NULL;
1806 IPersistFile *ppf = NULL;
1807 OLECHAR wsz[MAX_PATH];
1808 char_u *rfname = NULL;
1809 int len;
1810 IShellLinkW *pslw = NULL;
1811 WIN32_FIND_DATAW ffdw; // we get those free of charge
1812
1813 // Check if the file name ends in ".lnk". Avoid calling
1814 // CoCreateInstance(), it's quite slow.
1815 if (fname == NULL)
1816 return rfname;
1817 len = (int)STRLEN(fname);
1818 if (len <= 4 || STRNICMP(fname + len - 4, ".lnk", 4) != 0)
1819 return rfname;
1820
1821 CoInitialize(NULL);
1822
1823 // create a link manager object and request its interface
1824 hr = CoCreateInstance(
1825 &CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER,
1826 &IID_IShellLinkW, (void**)&pslw);
1827 if (hr == S_OK)
1828 {
1829 WCHAR *p = enc_to_utf16(fname, NULL);
1830
1831 if (p != NULL)
1832 {
1833 // Get a pointer to the IPersistFile interface.
1834 hr = pslw->lpVtbl->QueryInterface(
1835 pslw, &IID_IPersistFile, (void**)&ppf);
1836 if (hr != S_OK)
1837 goto shortcut_errorw;
1838
1839 // "load" the name and resolve the link
1840 hr = ppf->lpVtbl->Load(ppf, p, STGM_READ);
1841 if (hr != S_OK)
1842 goto shortcut_errorw;
1843 # if 0 // This makes Vim wait a long time if the target does not exist.
1844 hr = pslw->lpVtbl->Resolve(pslw, NULL, SLR_NO_UI);
1845 if (hr != S_OK)
1846 goto shortcut_errorw;
1847 # endif
1848
1849 // Get the path to the link target.
1850 ZeroMemory(wsz, MAX_PATH * sizeof(WCHAR));
1851 hr = pslw->lpVtbl->GetPath(pslw, wsz, MAX_PATH, &ffdw, 0);
1852 if (hr == S_OK && wsz[0] != NUL)
1853 rfname = utf16_to_enc(wsz, NULL);
1854
1855 shortcut_errorw:
1856 vim_free(p);
1857 }
1858 }
1859
1860 // Release all interface pointers (both belong to the same object)
1861 if (ppf != NULL)
1862 ppf->lpVtbl->Release(ppf);
1863 if (psl != NULL)
1864 psl->lpVtbl->Release(psl);
1865 if (pslw != NULL)
1866 pslw->lpVtbl->Release(pslw);
1867
1868 CoUninitialize();
1869 return rfname;
1870 }
1871
1872 char_u *
mch_resolve_path(char_u * fname,int reparse_point)1873 mch_resolve_path(char_u *fname, int reparse_point)
1874 {
1875 char_u *path = resolve_shortcut(fname);
1876
1877 if (path == NULL && reparse_point)
1878 path = resolve_reparse_point(fname);
1879 return path;
1880 }
1881 #endif
1882
1883 #if (defined(FEAT_EVAL) && (!defined(FEAT_GUI) || defined(VIMDLL))) || defined(PROTO)
1884 /*
1885 * Bring ourselves to the foreground. Does work if the OS doesn't allow it.
1886 */
1887 void
win32_set_foreground(void)1888 win32_set_foreground(void)
1889 {
1890 GetConsoleHwnd(); // get value of s_hwnd
1891 if (s_hwnd != 0)
1892 SetForegroundWindow(s_hwnd);
1893 }
1894 #endif
1895
1896 #if defined(FEAT_CLIENTSERVER) || defined(PROTO)
1897 /*
1898 * Client-server code for Vim
1899 *
1900 * Originally written by Paul Moore
1901 */
1902
1903 // In order to handle inter-process messages, we need to have a window. But
1904 // the functions in this module can be called before the main GUI window is
1905 // created (and may also be called in the console version, where there is no
1906 // GUI window at all).
1907 //
1908 // So we create a hidden window, and arrange to destroy it on exit.
1909 HWND message_window = 0; // window that's handling messages
1910
1911 # define VIM_CLASSNAME "VIM_MESSAGES"
1912 # define VIM_CLASSNAME_LEN (sizeof(VIM_CLASSNAME) - 1)
1913
1914 // Communication is via WM_COPYDATA messages. The message type is send in
1915 // the dwData parameter. Types are defined here.
1916 # define COPYDATA_KEYS 0
1917 # define COPYDATA_REPLY 1
1918 # define COPYDATA_EXPR 10
1919 # define COPYDATA_RESULT 11
1920 # define COPYDATA_ERROR_RESULT 12
1921 # define COPYDATA_ENCODING 20
1922
1923 // This is a structure containing a server HWND and its name.
1924 struct server_id
1925 {
1926 HWND hwnd;
1927 char_u *name;
1928 };
1929
1930 // Last received 'encoding' that the client uses.
1931 static char_u *client_enc = NULL;
1932
1933 /*
1934 * Tell the other side what encoding we are using.
1935 * Errors are ignored.
1936 */
1937 static void
serverSendEnc(HWND target)1938 serverSendEnc(HWND target)
1939 {
1940 COPYDATASTRUCT data;
1941
1942 data.dwData = COPYDATA_ENCODING;
1943 data.cbData = (DWORD)STRLEN(p_enc) + 1;
1944 data.lpData = p_enc;
1945 (void)SendMessage(target, WM_COPYDATA, (WPARAM)message_window,
1946 (LPARAM)(&data));
1947 }
1948
1949 /*
1950 * Clean up on exit. This destroys the hidden message window.
1951 */
1952 static void
CleanUpMessaging(void)1953 CleanUpMessaging(void)
1954 {
1955 if (message_window != 0)
1956 {
1957 DestroyWindow(message_window);
1958 message_window = 0;
1959 }
1960 }
1961
1962 static int save_reply(HWND server, char_u *reply, int expr);
1963
1964 /*
1965 * The window procedure for the hidden message window.
1966 * It handles callback messages and notifications from servers.
1967 * In order to process these messages, it is necessary to run a
1968 * message loop. Code which may run before the main message loop
1969 * is started (in the GUI) is careful to pump messages when it needs
1970 * to. Features which require message delivery during normal use will
1971 * not work in the console version - this basically means those
1972 * features which allow Vim to act as a server, rather than a client.
1973 */
1974 static LRESULT CALLBACK
Messaging_WndProc(HWND hwnd,UINT msg,WPARAM wParam,LPARAM lParam)1975 Messaging_WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
1976 {
1977 if (msg == WM_COPYDATA)
1978 {
1979 // This is a message from another Vim. The dwData member of the
1980 // COPYDATASTRUCT determines the type of message:
1981 // COPYDATA_ENCODING:
1982 // The encoding that the client uses. Following messages will
1983 // use this encoding, convert if needed.
1984 // COPYDATA_KEYS:
1985 // A key sequence. We are a server, and a client wants these keys
1986 // adding to the input queue.
1987 // COPYDATA_REPLY:
1988 // A reply. We are a client, and a server has sent this message
1989 // in response to a request. (server2client())
1990 // COPYDATA_EXPR:
1991 // An expression. We are a server, and a client wants us to
1992 // evaluate this expression.
1993 // COPYDATA_RESULT:
1994 // A reply. We are a client, and a server has sent this message
1995 // in response to a COPYDATA_EXPR.
1996 // COPYDATA_ERROR_RESULT:
1997 // A reply. We are a client, and a server has sent this message
1998 // in response to a COPYDATA_EXPR that failed to evaluate.
1999 COPYDATASTRUCT *data = (COPYDATASTRUCT*)lParam;
2000 HWND sender = (HWND)wParam;
2001 COPYDATASTRUCT reply;
2002 char_u *res;
2003 int retval;
2004 char_u *str;
2005 char_u *tofree;
2006
2007 switch (data->dwData)
2008 {
2009 case COPYDATA_ENCODING:
2010 // Remember the encoding that the client uses.
2011 vim_free(client_enc);
2012 client_enc = enc_canonize((char_u *)data->lpData);
2013 return 1;
2014
2015 case COPYDATA_KEYS:
2016 // Remember who sent this, for <client>
2017 clientWindow = sender;
2018
2019 // Add the received keys to the input buffer. The loop waiting
2020 // for the user to do something should check the input buffer.
2021 str = serverConvert(client_enc, (char_u *)data->lpData, &tofree);
2022 server_to_input_buf(str);
2023 vim_free(tofree);
2024
2025 # ifdef FEAT_GUI
2026 // Wake up the main GUI loop.
2027 # ifdef VIMDLL
2028 if (gui.in_use)
2029 # endif
2030 if (s_hwnd != 0)
2031 PostMessage(s_hwnd, WM_NULL, 0, 0);
2032 # endif
2033 return 1;
2034
2035 case COPYDATA_EXPR:
2036 // Remember who sent this, for <client>
2037 clientWindow = sender;
2038
2039 str = serverConvert(client_enc, (char_u *)data->lpData, &tofree);
2040 res = eval_client_expr_to_string(str);
2041
2042 if (res == NULL)
2043 {
2044 char *err = _(e_invexprmsg);
2045 size_t len = STRLEN(str) + STRLEN(err) + 5;
2046
2047 res = alloc(len);
2048 if (res != NULL)
2049 vim_snprintf((char *)res, len, "%s: \"%s\"", err, str);
2050 reply.dwData = COPYDATA_ERROR_RESULT;
2051 }
2052 else
2053 reply.dwData = COPYDATA_RESULT;
2054 reply.lpData = res;
2055 reply.cbData = (DWORD)STRLEN(res) + 1;
2056
2057 serverSendEnc(sender);
2058 retval = (int)SendMessage(sender, WM_COPYDATA,
2059 (WPARAM)message_window, (LPARAM)(&reply));
2060 vim_free(tofree);
2061 vim_free(res);
2062 return retval;
2063
2064 case COPYDATA_REPLY:
2065 case COPYDATA_RESULT:
2066 case COPYDATA_ERROR_RESULT:
2067 if (data->lpData != NULL)
2068 {
2069 str = serverConvert(client_enc, (char_u *)data->lpData,
2070 &tofree);
2071 if (tofree == NULL)
2072 str = vim_strsave(str);
2073 if (save_reply(sender, str,
2074 (data->dwData == COPYDATA_REPLY ? 0 :
2075 (data->dwData == COPYDATA_RESULT ? 1 :
2076 2))) == FAIL)
2077 vim_free(str);
2078 else if (data->dwData == COPYDATA_REPLY)
2079 {
2080 char_u winstr[30];
2081
2082 sprintf((char *)winstr, PRINTF_HEX_LONG_U, (long_u)sender);
2083 apply_autocmds(EVENT_REMOTEREPLY, winstr, str,
2084 TRUE, curbuf);
2085 }
2086 }
2087 return 1;
2088 }
2089
2090 return 0;
2091 }
2092
2093 else if (msg == WM_ACTIVATE && wParam == WA_ACTIVE)
2094 {
2095 // When the message window is activated (brought to the foreground),
2096 // this actually applies to the text window.
2097 # if !defined(FEAT_GUI) || defined(VIMDLL)
2098 # ifdef VIMDLL
2099 if (!gui.in_use)
2100 # endif
2101 GetConsoleHwnd(); // get value of s_hwnd
2102 # endif
2103 if (s_hwnd != 0)
2104 {
2105 SetForegroundWindow(s_hwnd);
2106 return 0;
2107 }
2108 }
2109
2110 return DefWindowProc(hwnd, msg, wParam, lParam);
2111 }
2112
2113 /*
2114 * Initialise the message handling process. This involves creating a window
2115 * to handle messages - the window will not be visible.
2116 */
2117 void
serverInitMessaging(void)2118 serverInitMessaging(void)
2119 {
2120 WNDCLASS wndclass;
2121
2122 // Clean up on exit
2123 atexit(CleanUpMessaging);
2124
2125 // Register a window class - we only really care
2126 // about the window procedure
2127 wndclass.style = 0;
2128 wndclass.lpfnWndProc = Messaging_WndProc;
2129 wndclass.cbClsExtra = 0;
2130 wndclass.cbWndExtra = 0;
2131 wndclass.hInstance = g_hinst;
2132 wndclass.hIcon = NULL;
2133 wndclass.hCursor = NULL;
2134 wndclass.hbrBackground = NULL;
2135 wndclass.lpszMenuName = NULL;
2136 wndclass.lpszClassName = VIM_CLASSNAME;
2137 RegisterClass(&wndclass);
2138
2139 // Create the message window. It will be hidden, so the details don't
2140 // matter. Don't use WS_OVERLAPPEDWINDOW, it will make a shortcut remove
2141 // focus from gvim.
2142 message_window = CreateWindow(VIM_CLASSNAME, "",
2143 WS_POPUPWINDOW | WS_CAPTION,
2144 CW_USEDEFAULT, CW_USEDEFAULT,
2145 100, 100, NULL, NULL,
2146 g_hinst, NULL);
2147 }
2148
2149 // Used by serverSendToVim() to find an alternate server name.
2150 static char_u *altname_buf_ptr = NULL;
2151
2152 /*
2153 * Get the title of the window "hwnd", which is the Vim server name, in
2154 * "name[namelen]" and return the length.
2155 * Returns zero if window "hwnd" is not a Vim server.
2156 */
2157 static int
getVimServerName(HWND hwnd,char * name,int namelen)2158 getVimServerName(HWND hwnd, char *name, int namelen)
2159 {
2160 int len;
2161 char buffer[VIM_CLASSNAME_LEN + 1];
2162
2163 // Ignore windows which aren't Vim message windows
2164 len = GetClassName(hwnd, buffer, sizeof(buffer));
2165 if (len != VIM_CLASSNAME_LEN || STRCMP(buffer, VIM_CLASSNAME) != 0)
2166 return 0;
2167
2168 // Get the title of the window
2169 return GetWindowText(hwnd, name, namelen);
2170 }
2171
2172 static BOOL CALLBACK
enumWindowsGetServer(HWND hwnd,LPARAM lparam)2173 enumWindowsGetServer(HWND hwnd, LPARAM lparam)
2174 {
2175 struct server_id *id = (struct server_id *)lparam;
2176 char server[MAX_PATH];
2177
2178 // Get the title of the window
2179 if (getVimServerName(hwnd, server, sizeof(server)) == 0)
2180 return TRUE;
2181
2182 // If this is the server we're looking for, return its HWND
2183 if (STRICMP(server, id->name) == 0)
2184 {
2185 id->hwnd = hwnd;
2186 return FALSE;
2187 }
2188
2189 // If we are looking for an alternate server, remember this name.
2190 if (altname_buf_ptr != NULL
2191 && STRNICMP(server, id->name, STRLEN(id->name)) == 0
2192 && vim_isdigit(server[STRLEN(id->name)]))
2193 {
2194 STRCPY(altname_buf_ptr, server);
2195 altname_buf_ptr = NULL; // don't use another name
2196 }
2197
2198 // Otherwise, keep looking
2199 return TRUE;
2200 }
2201
2202 static BOOL CALLBACK
enumWindowsGetNames(HWND hwnd,LPARAM lparam)2203 enumWindowsGetNames(HWND hwnd, LPARAM lparam)
2204 {
2205 garray_T *ga = (garray_T *)lparam;
2206 char server[MAX_PATH];
2207
2208 // Get the title of the window
2209 if (getVimServerName(hwnd, server, sizeof(server)) == 0)
2210 return TRUE;
2211
2212 // Add the name to the list
2213 ga_concat(ga, (char_u *)server);
2214 ga_concat(ga, (char_u *)"\n");
2215 return TRUE;
2216 }
2217
2218 struct enum_windows_s
2219 {
2220 WNDENUMPROC lpEnumFunc;
2221 LPARAM lParam;
2222 };
2223
2224 static BOOL CALLBACK
enum_windows_child(HWND hwnd,LPARAM lParam)2225 enum_windows_child(HWND hwnd, LPARAM lParam)
2226 {
2227 struct enum_windows_s *ew = (struct enum_windows_s *)lParam;
2228
2229 return (ew->lpEnumFunc)(hwnd, ew->lParam);
2230 }
2231
2232 static BOOL CALLBACK
enum_windows_toplevel(HWND hwnd,LPARAM lParam)2233 enum_windows_toplevel(HWND hwnd, LPARAM lParam)
2234 {
2235 struct enum_windows_s *ew = (struct enum_windows_s *)lParam;
2236
2237 if ((ew->lpEnumFunc)(hwnd, ew->lParam))
2238 return TRUE;
2239 return EnumChildWindows(hwnd, enum_windows_child, lParam);
2240 }
2241
2242 /*
2243 * Enumerate all windows including children.
2244 */
2245 static BOOL
enum_windows(WNDENUMPROC lpEnumFunc,LPARAM lParam)2246 enum_windows(WNDENUMPROC lpEnumFunc, LPARAM lParam)
2247 {
2248 struct enum_windows_s ew;
2249
2250 ew.lpEnumFunc = lpEnumFunc;
2251 ew.lParam = lParam;
2252 return EnumWindows(enum_windows_toplevel, (LPARAM)&ew);
2253 }
2254
2255 static HWND
findServer(char_u * name)2256 findServer(char_u *name)
2257 {
2258 struct server_id id;
2259
2260 id.name = name;
2261 id.hwnd = 0;
2262
2263 enum_windows(enumWindowsGetServer, (LPARAM)(&id));
2264
2265 return id.hwnd;
2266 }
2267
2268 void
serverSetName(char_u * name)2269 serverSetName(char_u *name)
2270 {
2271 char_u *ok_name;
2272 HWND hwnd = 0;
2273 int i = 0;
2274 char_u *p;
2275
2276 // Leave enough space for a 9-digit suffix to ensure uniqueness!
2277 ok_name = alloc(STRLEN(name) + 10);
2278
2279 STRCPY(ok_name, name);
2280 p = ok_name + STRLEN(name);
2281
2282 for (;;)
2283 {
2284 // This is inefficient - we're doing an EnumWindows loop for each
2285 // possible name. It would be better to grab all names in one go,
2286 // and scan the list each time...
2287 hwnd = findServer(ok_name);
2288 if (hwnd == 0)
2289 break;
2290
2291 ++i;
2292 if (i >= 1000)
2293 break;
2294
2295 sprintf((char *)p, "%d", i);
2296 }
2297
2298 if (hwnd != 0)
2299 vim_free(ok_name);
2300 else
2301 {
2302 // Remember the name
2303 serverName = ok_name;
2304 # ifdef FEAT_TITLE
2305 need_maketitle = TRUE; // update Vim window title later
2306 # endif
2307
2308 // Update the message window title
2309 SetWindowText(message_window, (LPCSTR)ok_name);
2310
2311 # ifdef FEAT_EVAL
2312 // Set the servername variable
2313 set_vim_var_string(VV_SEND_SERVER, serverName, -1);
2314 # endif
2315 }
2316 }
2317
2318 char_u *
serverGetVimNames(void)2319 serverGetVimNames(void)
2320 {
2321 garray_T ga;
2322
2323 ga_init2(&ga, 1, 100);
2324
2325 enum_windows(enumWindowsGetNames, (LPARAM)(&ga));
2326 ga_append(&ga, NUL);
2327
2328 return ga.ga_data;
2329 }
2330
2331 int
serverSendReply(char_u * name,char_u * reply)2332 serverSendReply(
2333 char_u *name, // Where to send.
2334 char_u *reply) // What to send.
2335 {
2336 HWND target;
2337 COPYDATASTRUCT data;
2338 long_u n = 0;
2339
2340 // The "name" argument is a magic cookie obtained from expand("<client>").
2341 // It should be of the form 0xXXXXX - i.e. a C hex literal, which is the
2342 // value of the client's message window HWND.
2343 sscanf((char *)name, SCANF_HEX_LONG_U, &n);
2344 if (n == 0)
2345 return -1;
2346
2347 target = (HWND)n;
2348 if (!IsWindow(target))
2349 return -1;
2350
2351 data.dwData = COPYDATA_REPLY;
2352 data.cbData = (DWORD)STRLEN(reply) + 1;
2353 data.lpData = reply;
2354
2355 serverSendEnc(target);
2356 if (SendMessage(target, WM_COPYDATA, (WPARAM)message_window,
2357 (LPARAM)(&data)))
2358 return 0;
2359
2360 return -1;
2361 }
2362
2363 int
serverSendToVim(char_u * name,char_u * cmd,char_u ** result,void * ptarget,int asExpr,int timeout,int silent)2364 serverSendToVim(
2365 char_u *name, // Where to send.
2366 char_u *cmd, // What to send.
2367 char_u **result, // Result of eval'ed expression
2368 void *ptarget, // HWND of server
2369 int asExpr, // Expression or keys?
2370 int timeout, // timeout in seconds or zero
2371 int silent) // don't complain about no server
2372 {
2373 HWND target;
2374 COPYDATASTRUCT data;
2375 char_u *retval = NULL;
2376 int retcode = 0;
2377 char_u altname_buf[MAX_PATH];
2378
2379 // Execute locally if no display or target is ourselves
2380 if (serverName != NULL && STRICMP(name, serverName) == 0)
2381 return sendToLocalVim(cmd, asExpr, result);
2382
2383 // If the server name does not end in a digit then we look for an
2384 // alternate name. e.g. when "name" is GVIM the we may find GVIM2.
2385 if (STRLEN(name) > 1 && !vim_isdigit(name[STRLEN(name) - 1]))
2386 altname_buf_ptr = altname_buf;
2387 altname_buf[0] = NUL;
2388 target = findServer(name);
2389 altname_buf_ptr = NULL;
2390 if (target == 0 && altname_buf[0] != NUL)
2391 // Use another server name we found.
2392 target = findServer(altname_buf);
2393
2394 if (target == 0)
2395 {
2396 if (!silent)
2397 semsg(_(e_noserver), name);
2398 return -1;
2399 }
2400
2401 if (ptarget)
2402 *(HWND *)ptarget = target;
2403
2404 data.dwData = asExpr ? COPYDATA_EXPR : COPYDATA_KEYS;
2405 data.cbData = (DWORD)STRLEN(cmd) + 1;
2406 data.lpData = cmd;
2407
2408 serverSendEnc(target);
2409 if (SendMessage(target, WM_COPYDATA, (WPARAM)message_window,
2410 (LPARAM)(&data)) == 0)
2411 return -1;
2412
2413 if (asExpr)
2414 retval = serverGetReply(target, &retcode, TRUE, TRUE, timeout);
2415
2416 if (result == NULL)
2417 vim_free(retval);
2418 else
2419 *result = retval; // Caller assumes responsibility for freeing
2420
2421 return retcode;
2422 }
2423
2424 /*
2425 * Bring the server to the foreground.
2426 */
2427 void
serverForeground(char_u * name)2428 serverForeground(char_u *name)
2429 {
2430 HWND target = findServer(name);
2431
2432 if (target != 0)
2433 SetForegroundWindow(target);
2434 }
2435
2436 // Replies from server need to be stored until the client picks them up via
2437 // remote_read(). So we maintain a list of server-id/reply pairs.
2438 // Note that there could be multiple replies from one server pending if the
2439 // client is slow picking them up.
2440 // We just store the replies in a simple list. When we remove an entry, we
2441 // move list entries down to fill the gap.
2442 // The server ID is simply the HWND.
2443 typedef struct
2444 {
2445 HWND server; // server window
2446 char_u *reply; // reply string
2447 int expr_result; // 0 for REPLY, 1 for RESULT 2 for error
2448 } reply_T;
2449
2450 static garray_T reply_list = {0, 0, sizeof(reply_T), 5, 0};
2451
2452 # define REPLY_ITEM(i) ((reply_T *)(reply_list.ga_data) + (i))
2453 # define REPLY_COUNT (reply_list.ga_len)
2454
2455 // Flag which is used to wait for a reply
2456 static int reply_received = 0;
2457
2458 /*
2459 * Store a reply. "reply" must be allocated memory (or NULL).
2460 */
2461 static int
save_reply(HWND server,char_u * reply,int expr)2462 save_reply(HWND server, char_u *reply, int expr)
2463 {
2464 reply_T *rep;
2465
2466 if (ga_grow(&reply_list, 1) == FAIL)
2467 return FAIL;
2468
2469 rep = REPLY_ITEM(REPLY_COUNT);
2470 rep->server = server;
2471 rep->reply = reply;
2472 rep->expr_result = expr;
2473 if (rep->reply == NULL)
2474 return FAIL;
2475
2476 ++REPLY_COUNT;
2477 reply_received = 1;
2478 return OK;
2479 }
2480
2481 /*
2482 * Get a reply from server "server".
2483 * When "expr_res" is non NULL, get the result of an expression, otherwise a
2484 * server2client() message.
2485 * When non NULL, point to return code. 0 => OK, -1 => ERROR
2486 * If "remove" is TRUE, consume the message, the caller must free it then.
2487 * if "wait" is TRUE block until a message arrives (or the server exits).
2488 */
2489 char_u *
serverGetReply(HWND server,int * expr_res,int remove,int wait,int timeout)2490 serverGetReply(HWND server, int *expr_res, int remove, int wait, int timeout)
2491 {
2492 int i;
2493 char_u *reply;
2494 reply_T *rep;
2495 int did_process = FALSE;
2496 time_t start;
2497 time_t now;
2498
2499 // When waiting, loop until the message waiting for is received.
2500 time(&start);
2501 for (;;)
2502 {
2503 // Reset this here, in case a message arrives while we are going
2504 // through the already received messages.
2505 reply_received = 0;
2506
2507 for (i = 0; i < REPLY_COUNT; ++i)
2508 {
2509 rep = REPLY_ITEM(i);
2510 if (rep->server == server
2511 && ((rep->expr_result != 0) == (expr_res != NULL)))
2512 {
2513 // Save the values we've found for later
2514 reply = rep->reply;
2515 if (expr_res != NULL)
2516 *expr_res = rep->expr_result == 1 ? 0 : -1;
2517
2518 if (remove)
2519 {
2520 // Move the rest of the list down to fill the gap
2521 mch_memmove(rep, rep + 1,
2522 (REPLY_COUNT - i - 1) * sizeof(reply_T));
2523 --REPLY_COUNT;
2524 }
2525
2526 // Return the reply to the caller, who takes on responsibility
2527 // for freeing it if "remove" is TRUE.
2528 return reply;
2529 }
2530 }
2531
2532 // If we got here, we didn't find a reply. Return immediately if the
2533 // "wait" parameter isn't set.
2534 if (!wait)
2535 {
2536 // Process pending messages once. Without this, looping on
2537 // remote_peek() would never get the reply.
2538 if (!did_process)
2539 {
2540 did_process = TRUE;
2541 serverProcessPendingMessages();
2542 continue;
2543 }
2544 break;
2545 }
2546
2547 // We need to wait for a reply. Enter a message loop until the
2548 // "reply_received" flag gets set.
2549
2550 // Loop until we receive a reply
2551 while (reply_received == 0)
2552 {
2553 # ifdef FEAT_TIMERS
2554 // TODO: use the return value to decide how long to wait.
2555 check_due_timer();
2556 # endif
2557 time(&now);
2558 if (timeout > 0 && (now - start) >= timeout)
2559 break;
2560
2561 // Wait for a SendMessage() call to us. This could be the reply
2562 // we are waiting for. Use a timeout of a second, to catch the
2563 // situation that the server died unexpectedly.
2564 MsgWaitForMultipleObjects(0, NULL, TRUE, 1000, QS_ALLINPUT);
2565
2566 // If the server has died, give up
2567 if (!IsWindow(server))
2568 return NULL;
2569
2570 serverProcessPendingMessages();
2571 }
2572 }
2573
2574 return NULL;
2575 }
2576
2577 /*
2578 * Process any messages in the Windows message queue.
2579 */
2580 void
serverProcessPendingMessages(void)2581 serverProcessPendingMessages(void)
2582 {
2583 MSG msg;
2584
2585 while (pPeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
2586 {
2587 TranslateMessage(&msg);
2588 pDispatchMessage(&msg);
2589 }
2590 }
2591
2592 #endif // FEAT_CLIENTSERVER
2593
2594 #if defined(FEAT_GUI) || (defined(FEAT_PRINTER) && !defined(FEAT_POSTSCRIPT)) \
2595 || defined(PROTO)
2596
2597 struct charset_pair
2598 {
2599 char *name;
2600 BYTE charset;
2601 };
2602
2603 static struct charset_pair
2604 charset_pairs[] =
2605 {
2606 {"ANSI", ANSI_CHARSET},
2607 {"CHINESEBIG5", CHINESEBIG5_CHARSET},
2608 {"DEFAULT", DEFAULT_CHARSET},
2609 {"HANGEUL", HANGEUL_CHARSET},
2610 {"OEM", OEM_CHARSET},
2611 {"SHIFTJIS", SHIFTJIS_CHARSET},
2612 {"SYMBOL", SYMBOL_CHARSET},
2613 {"ARABIC", ARABIC_CHARSET},
2614 {"BALTIC", BALTIC_CHARSET},
2615 {"EASTEUROPE", EASTEUROPE_CHARSET},
2616 {"GB2312", GB2312_CHARSET},
2617 {"GREEK", GREEK_CHARSET},
2618 {"HEBREW", HEBREW_CHARSET},
2619 {"JOHAB", JOHAB_CHARSET},
2620 {"MAC", MAC_CHARSET},
2621 {"RUSSIAN", RUSSIAN_CHARSET},
2622 {"THAI", THAI_CHARSET},
2623 {"TURKISH", TURKISH_CHARSET},
2624 # ifdef VIETNAMESE_CHARSET
2625 {"VIETNAMESE", VIETNAMESE_CHARSET},
2626 # endif
2627 {NULL, 0}
2628 };
2629
2630 struct quality_pair
2631 {
2632 char *name;
2633 DWORD quality;
2634 };
2635
2636 static struct quality_pair
2637 quality_pairs[] = {
2638 # ifdef CLEARTYPE_QUALITY
2639 {"CLEARTYPE", CLEARTYPE_QUALITY},
2640 # endif
2641 # ifdef ANTIALIASED_QUALITY
2642 {"ANTIALIASED", ANTIALIASED_QUALITY},
2643 # endif
2644 # ifdef NONANTIALIASED_QUALITY
2645 {"NONANTIALIASED", NONANTIALIASED_QUALITY},
2646 # endif
2647 # ifdef PROOF_QUALITY
2648 {"PROOF", PROOF_QUALITY},
2649 # endif
2650 # ifdef DRAFT_QUALITY
2651 {"DRAFT", DRAFT_QUALITY},
2652 # endif
2653 {"DEFAULT", DEFAULT_QUALITY},
2654 {NULL, 0}
2655 };
2656
2657 /*
2658 * Convert a charset ID to a name.
2659 * Return NULL when not recognized.
2660 */
2661 char *
charset_id2name(int id)2662 charset_id2name(int id)
2663 {
2664 struct charset_pair *cp;
2665
2666 for (cp = charset_pairs; cp->name != NULL; ++cp)
2667 if ((BYTE)id == cp->charset)
2668 break;
2669 return cp->name;
2670 }
2671
2672 /*
2673 * Convert a quality ID to a name.
2674 * Return NULL when not recognized.
2675 */
2676 char *
quality_id2name(DWORD id)2677 quality_id2name(DWORD id)
2678 {
2679 struct quality_pair *qp;
2680
2681 for (qp = quality_pairs; qp->name != NULL; ++qp)
2682 if (id == qp->quality)
2683 break;
2684 return qp->name;
2685 }
2686
2687 static const LOGFONTW s_lfDefault =
2688 {
2689 -12, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, DEFAULT_CHARSET,
2690 OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
2691 PROOF_QUALITY, FIXED_PITCH | FF_DONTCARE,
2692 L"Fixedsys" // see _ReadVimIni
2693 };
2694
2695 // Initialise the "current height" to -12 (same as s_lfDefault) just
2696 // in case the user specifies a font in "guifont" with no size before a font
2697 // with an explicit size has been set. This defaults the size to this value
2698 // (-12 equates to roughly 9pt).
2699 int current_font_height = -12; // also used in gui_w32.c
2700
2701 /*
2702 * Convert a string representing a point size into pixels. The string should
2703 * be a positive decimal number, with an optional decimal point (eg, "12", or
2704 * "10.5"). The pixel value is returned, and a pointer to the next unconverted
2705 * character is stored in *end. The flag "vertical" says whether this
2706 * calculation is for a vertical (height) size or a horizontal (width) one.
2707 */
2708 static int
points_to_pixels(WCHAR * str,WCHAR ** end,int vertical,long_i pprinter_dc)2709 points_to_pixels(WCHAR *str, WCHAR **end, int vertical, long_i pprinter_dc)
2710 {
2711 int pixels;
2712 int points = 0;
2713 int divisor = 0;
2714 HWND hwnd = (HWND)0;
2715 HDC hdc;
2716 HDC printer_dc = (HDC)pprinter_dc;
2717
2718 while (*str != NUL)
2719 {
2720 if (*str == L'.' && divisor == 0)
2721 {
2722 // Start keeping a divisor, for later
2723 divisor = 1;
2724 }
2725 else
2726 {
2727 if (!VIM_ISDIGIT(*str))
2728 break;
2729
2730 points *= 10;
2731 points += *str - L'0';
2732 divisor *= 10;
2733 }
2734 ++str;
2735 }
2736
2737 if (divisor == 0)
2738 divisor = 1;
2739
2740 if (printer_dc == NULL)
2741 {
2742 hwnd = GetDesktopWindow();
2743 hdc = GetWindowDC(hwnd);
2744 }
2745 else
2746 hdc = printer_dc;
2747
2748 pixels = MulDiv(points,
2749 GetDeviceCaps(hdc, vertical ? LOGPIXELSY : LOGPIXELSX),
2750 72 * divisor);
2751
2752 if (printer_dc == NULL)
2753 ReleaseDC(hwnd, hdc);
2754
2755 *end = str;
2756 return pixels;
2757 }
2758
2759 static int CALLBACK
font_enumproc(ENUMLOGFONTW * elf,NEWTEXTMETRICW * ntm UNUSED,DWORD type UNUSED,LPARAM lparam)2760 font_enumproc(
2761 ENUMLOGFONTW *elf,
2762 NEWTEXTMETRICW *ntm UNUSED,
2763 DWORD type UNUSED,
2764 LPARAM lparam)
2765 {
2766 // Return value:
2767 // 0 = terminate now (monospace & ANSI)
2768 // 1 = continue, still no luck...
2769 // 2 = continue, but we have an acceptable LOGFONTW
2770 // (monospace, not ANSI)
2771 // We use these values, as EnumFontFamilies returns 1 if the
2772 // callback function is never called. So, we check the return as
2773 // 0 = perfect, 2 = OK, 1 = no good...
2774 // It's not pretty, but it works!
2775
2776 LOGFONTW *lf = (LOGFONTW *)(lparam);
2777
2778 # ifndef FEAT_PROPORTIONAL_FONTS
2779 // Ignore non-monospace fonts without further ado
2780 if ((ntm->tmPitchAndFamily & 1) != 0)
2781 return 1;
2782 # endif
2783
2784 // Remember this LOGFONTW as a "possible"
2785 *lf = elf->elfLogFont;
2786
2787 // Terminate the scan as soon as we find an ANSI font
2788 if (lf->lfCharSet == ANSI_CHARSET
2789 || lf->lfCharSet == OEM_CHARSET
2790 || lf->lfCharSet == DEFAULT_CHARSET)
2791 return 0;
2792
2793 // Continue the scan - we have a non-ANSI font
2794 return 2;
2795 }
2796
2797 static int
init_logfont(LOGFONTW * lf)2798 init_logfont(LOGFONTW *lf)
2799 {
2800 int n;
2801 HWND hwnd = GetDesktopWindow();
2802 HDC hdc = GetWindowDC(hwnd);
2803
2804 n = EnumFontFamiliesW(hdc,
2805 lf->lfFaceName,
2806 (FONTENUMPROCW)font_enumproc,
2807 (LPARAM)lf);
2808
2809 ReleaseDC(hwnd, hdc);
2810
2811 // If we couldn't find a usable font, return failure
2812 if (n == 1)
2813 return FAIL;
2814
2815 // Tidy up the rest of the LOGFONTW structure. We set to a basic
2816 // font - get_logfont() sets bold, italic, etc based on the user's
2817 // input.
2818 lf->lfHeight = current_font_height;
2819 lf->lfWidth = 0;
2820 lf->lfItalic = FALSE;
2821 lf->lfUnderline = FALSE;
2822 lf->lfStrikeOut = FALSE;
2823 lf->lfWeight = FW_NORMAL;
2824
2825 // Return success
2826 return OK;
2827 }
2828
2829 /*
2830 * Compare a UTF-16 string and an ASCII string literally.
2831 * Only works all the code points are inside ASCII range.
2832 */
2833 static int
utf16ascncmp(const WCHAR * w,const char * p,size_t n)2834 utf16ascncmp(const WCHAR *w, const char *p, size_t n)
2835 {
2836 size_t i;
2837
2838 for (i = 0; i < n; i++)
2839 {
2840 if (w[i] == 0 || w[i] != p[i])
2841 return w[i] - p[i];
2842 }
2843 return 0;
2844 }
2845
2846 /*
2847 * Get font info from "name" into logfont "lf".
2848 * Return OK for a valid name, FAIL otherwise.
2849 */
2850 int
get_logfont(LOGFONTW * lf,char_u * name,HDC printer_dc,int verbose)2851 get_logfont(
2852 LOGFONTW *lf,
2853 char_u *name,
2854 HDC printer_dc,
2855 int verbose)
2856 {
2857 WCHAR *p;
2858 int i;
2859 int ret = FAIL;
2860 static LOGFONTW *lastlf = NULL;
2861 WCHAR *wname;
2862
2863 *lf = s_lfDefault;
2864 if (name == NULL)
2865 return OK;
2866
2867 wname = enc_to_utf16(name, NULL);
2868 if (wname == NULL)
2869 return FAIL;
2870
2871 if (wcscmp(wname, L"*") == 0)
2872 {
2873 # if defined(FEAT_GUI_MSWIN)
2874 CHOOSEFONTW cf;
2875 // if name is "*", bring up std font dialog:
2876 CLEAR_FIELD(cf);
2877 cf.lStructSize = sizeof(cf);
2878 cf.hwndOwner = s_hwnd;
2879 cf.Flags = CF_SCREENFONTS | CF_FIXEDPITCHONLY | CF_INITTOLOGFONTSTRUCT;
2880 if (lastlf != NULL)
2881 *lf = *lastlf;
2882 cf.lpLogFont = lf;
2883 cf.nFontType = 0 ; //REGULAR_FONTTYPE;
2884 if (ChooseFontW(&cf))
2885 ret = OK;
2886 # endif
2887 goto theend;
2888 }
2889
2890 /*
2891 * Split name up, it could be <name>:h<height>:w<width> etc.
2892 */
2893 for (p = wname; *p && *p != L':'; p++)
2894 {
2895 if (p - wname + 1 >= LF_FACESIZE)
2896 goto theend; // Name too long
2897 lf->lfFaceName[p - wname] = *p;
2898 }
2899 if (p != wname)
2900 lf->lfFaceName[p - wname] = NUL;
2901
2902 // First set defaults
2903 lf->lfHeight = -12;
2904 lf->lfWidth = 0;
2905 lf->lfWeight = FW_NORMAL;
2906 lf->lfItalic = FALSE;
2907 lf->lfUnderline = FALSE;
2908 lf->lfStrikeOut = FALSE;
2909
2910 /*
2911 * If the font can't be found, try replacing '_' by ' '.
2912 */
2913 if (init_logfont(lf) == FAIL)
2914 {
2915 int did_replace = FALSE;
2916
2917 for (i = 0; lf->lfFaceName[i]; ++i)
2918 if (lf->lfFaceName[i] == L'_')
2919 {
2920 lf->lfFaceName[i] = L' ';
2921 did_replace = TRUE;
2922 }
2923 if (!did_replace || init_logfont(lf) == FAIL)
2924 goto theend;
2925 }
2926
2927 while (*p == L':')
2928 p++;
2929
2930 // Set the values found after ':'
2931 while (*p)
2932 {
2933 switch (*p++)
2934 {
2935 case L'h':
2936 lf->lfHeight = - points_to_pixels(p, &p, TRUE, (long_i)printer_dc);
2937 break;
2938 case L'w':
2939 lf->lfWidth = points_to_pixels(p, &p, FALSE, (long_i)printer_dc);
2940 break;
2941 case L'W':
2942 lf->lfWeight = wcstol(p, &p, 10);
2943 break;
2944 case L'b':
2945 lf->lfWeight = FW_BOLD;
2946 break;
2947 case L'i':
2948 lf->lfItalic = TRUE;
2949 break;
2950 case L'u':
2951 lf->lfUnderline = TRUE;
2952 break;
2953 case L's':
2954 lf->lfStrikeOut = TRUE;
2955 break;
2956 case L'c':
2957 {
2958 struct charset_pair *cp;
2959
2960 for (cp = charset_pairs; cp->name != NULL; ++cp)
2961 if (utf16ascncmp(p, cp->name, strlen(cp->name)) == 0)
2962 {
2963 lf->lfCharSet = cp->charset;
2964 p += strlen(cp->name);
2965 break;
2966 }
2967 if (cp->name == NULL && verbose)
2968 {
2969 char_u *s = utf16_to_enc(p, NULL);
2970 semsg(_("E244: Illegal charset name \"%s\" in font name \"%s\""), s, name);
2971 vim_free(s);
2972 break;
2973 }
2974 break;
2975 }
2976 case L'q':
2977 {
2978 struct quality_pair *qp;
2979
2980 for (qp = quality_pairs; qp->name != NULL; ++qp)
2981 if (utf16ascncmp(p, qp->name, strlen(qp->name)) == 0)
2982 {
2983 lf->lfQuality = qp->quality;
2984 p += strlen(qp->name);
2985 break;
2986 }
2987 if (qp->name == NULL && verbose)
2988 {
2989 char_u *s = utf16_to_enc(p, NULL);
2990 semsg(_("E244: Illegal quality name \"%s\" in font name \"%s\""), s, name);
2991 vim_free(s);
2992 break;
2993 }
2994 break;
2995 }
2996 default:
2997 if (verbose)
2998 semsg(_("E245: Illegal char '%c' in font name \"%s\""), p[-1], name);
2999 goto theend;
3000 }
3001 while (*p == L':')
3002 p++;
3003 }
3004 ret = OK;
3005
3006 theend:
3007 // ron: init lastlf
3008 if (ret == OK && printer_dc == NULL)
3009 {
3010 vim_free(lastlf);
3011 lastlf = ALLOC_ONE(LOGFONTW);
3012 if (lastlf != NULL)
3013 mch_memmove(lastlf, lf, sizeof(LOGFONTW));
3014 }
3015 vim_free(wname);
3016
3017 return ret;
3018 }
3019
3020 #endif // defined(FEAT_GUI) || defined(FEAT_PRINTER)
3021
3022 #if defined(FEAT_JOB_CHANNEL) || defined(PROTO)
3023 /*
3024 * Initialize the Winsock dll.
3025 */
3026 void
channel_init_winsock(void)3027 channel_init_winsock(void)
3028 {
3029 WSADATA wsaData;
3030 int wsaerr;
3031
3032 if (WSInitialized)
3033 return;
3034
3035 wsaerr = WSAStartup(MAKEWORD(2, 2), &wsaData);
3036 if (wsaerr == 0)
3037 WSInitialized = TRUE;
3038 }
3039 #endif
3040