src/os_mswin.c

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