Emacs and Microsoft Windows/MS-DOS
**********************************

This section describes peculiarities of using Emacs on Microsoft Windows.  Some of these peculiarities are also relevant to Microsoft's older MS-DOS ``operating system'' (also known as ``MS-DOG''). However, Emacs features that are relevant only to MS-DOS are described in a separate section (see MS-DOS).

The behavior of Emacs on MS-Windows is reasonably similar to what is documented in the rest of the manual, including support for long file names, multiple frames, scroll bars, mouse menus, and subprocesses. However, a few special considerations apply, and they are described here.

Text Files and Binary Files
===========================

GNU Emacs uses newline characters to separate text lines.  This is the convention used on GNU, Unix, and other Posix-compliant systems.

By contrast, MS-DOS and MS-Windows normally use carriage-return linefeed, a two-character sequence, to separate text lines.  (Linefeed is the same character as newline.)  Therefore, convenient editing of typical files with Emacs requires conversion of these end-of-line (EOL) sequences. And that is what Emacs normally does: it converts carriage-return linefeed into newline when reading files, and converts newline into carriage-return linefeed when writing files.  The same mechanism that handles conversion of international character codes does this conversion also (see Coding Systems).

One consequence of this special format-conversion of most files is that character positions as reported by Emacs (see Position Info) do not agree with the file size information known to the operating system.

In addition, if Emacs recognizes from a file's contents that it uses newline rather than carriage-return linefeed as its line separator, it does not perform EOL conversion when reading or writing that file. Thus, you can read and edit files from GNU and Unix systems on MS-DOS with no special effort, and they will retain their Unix-style end-of-line convention after you edit them.

The mode line indicates whether end-of-line translation was used for the current buffer.  If MS-DOS end-of-line translation is in use for the buffer, the MS-Windows build of Emacs displays a backslash \ after the coding system mnemonic near the beginning of the mode line (see Mode Line).  If no EOL translation was performed, the string (Unix) is displayed instead of the backslash, to alert you that the file's EOL format is not the usual carriage-return linefeed.

To visit a file and specify whether it uses DOS-style or Unix-style end-of-line, specify a coding system (see Text Coding).  For example, C-x RET c unix RET C-x C-f foobar.txt visits the file foobar.txt without converting the EOLs; if some line ends with a carriage-return linefeed pair, Emacs will display ^M at the end of that line.  Similarly, you can direct Emacs to save a buffer in a specified EOL format with the C-x RET f command.  For example, to save a buffer with Unix EOL format, type C-x RET f unix RET C-x C-s.  If you visit a file with DOS EOL conversion, then save it with Unix EOL format, that effectively converts the file to Unix EOL style, like dos2unix.

When you use NFS, Samba, or some other similar method to access file systems that reside on computers using GNU or Unix systems, Emacs should not perform end-of-line translation on any files in these file systems---not even when you create a new file.  To request this, designate these file systems as untranslated file systems by calling the function add-untranslated-filesystem.  It takes one argument: the file system name, including a drive letter and optionally a directory.  For example,

     (add-untranslated-filesystem "Z:")

designates drive Z as an untranslated file system, and

     (add-untranslated-filesystem "Z:\\foo")

designates directory \foo on drive Z as an untranslated file system.

Most often you would use add-untranslated-filesystem in your .emacs file, or in site-start.el so that all the users at your site get the benefit of it.

To countermand the effect of add-untranslated-filesystem, use the function remove-untranslated-filesystem.  This function takes one argument, which should be a string just like the one that was used previously with add-untranslated-filesystem.

Designating a file system as untranslated does not affect character set conversion, only end-of-line conversion.  Essentially, it directs Emacs to create new files with the Unix-style convention of using newline at the end of a line.  See Coding Systems.

Some kinds of files should not be converted at all, because their contents are not really text.  Therefore, Emacs on MS-Windows distinguishes certain files as binary files.  (This distinction is not part of MS-Windows; it is made by Emacs only.)  Binary files include executable programs, compressed archives, etc.  Emacs uses the file name to decide whether to treat a file as binary: the variable file-name-buffer-file-type-alist defines the file-name patterns that indicate binary files.  If a file name matches one of the patterns for binary files (those whose associations are of the type (PATTERN . t), Emacs reads and writes that file using the no-conversion coding system (see Coding Systems) which turns off all coding-system conversions, not only the EOL conversion. file-name-buffer-file-type-alist also includes file-name patterns for files which are known to be Windows-style text files with carriage-return linefeed EOL format, such as CONFIG.SYS; Emacs always writes those files with Windows-style EOLs.

If a file which belongs to an untranslated file system matches one of the file-name patterns in file-name-buffer-file-type-alist, the EOL conversion is determined by file-name-buffer-file-type-alist.

File Names on MS-Windows
========================

MS-Windows and MS-DOS normally use a backslash, \, to separate name units within a file name, instead of the slash used on other systems.  Emacs on MS-DOS/MS-Windows permits use of either slash or backslash, and also knows about drive letters in file names.

On MS-DOS/MS-Windows, file names are case-insensitive, so Emacs by default ignores letter-case in file names during completion.

The variable w32-get-true-file-attributes controls whether Emacs should issue additional system calls to determine more accurately file attributes in primitives like file-attributes and directory-files-and-attributes.  These additional calls are needed to report correct file ownership, link counts and file types for special files such as pipes.  Without these system calls, file ownership will be attributed to the current user, link counts will be always reported as 1, and special files will be reported as regular files.

If the value of this variable is local (the default), Emacs will issue these additional system calls only for files on local fixed drives.  Any other non-nil value means do this even for removable and remote volumes, where this could potentially slow down Dired and other related features.  The value of nil means never issue those system calls.  Non-nil values are more useful on NTFS volumes, which support hard links and file security, than on FAT, FAT32, and XFAT volumes.

Emulation of ls on MS-Windows
=============================

Dired normally uses the external program ls (or its close work-alike) to produce the directory listing displayed in Dired buffers (see Dired).  However, MS-Windows and MS-DOS systems don't come with such a program, although several ports of GNU ls are available.  Therefore, Emacs on those systems emulates ls in Lisp, by using the ls-lisp.el package.  While ls-lisp.el provides a reasonably full emulation of ls, there are some options and features peculiar to that emulation; they are described in this section.

The ls emulation supports many of the ls switches, but it doesn't support all of them.  Here's the list of the switches it does support: -A, -a, -B, -C, -c, -i, -G, -g, -R, -r, -S, -s, -t, -U, -u, and -X.  The -F switch is partially supported (it appends the character that classifies the file, but does not prevent symlink following).

On MS-Windows and MS-DOS, ls-lisp.el is preloaded when Emacs is built, so the Lisp emulation of ls is always used on those platforms.  If you have a ported ls, setting ls-lisp-use-insert-directory-program to a non-nil value will revert to using an external program named by the variable insert-directory-program.

By default, ls-lisp.el uses a case-sensitive sort order for the directory listing it produces; this is so the listing looks the same as on other platforms.  If you wish that the files be sorted in case-insensitive order, set the variable ls-lisp-ignore-case to a non-nil value.

By default, files and subdirectories are sorted together, to emulate the behavior of ls.  However, native MS-Windows/MS-DOS file managers list the directories before the files; if you want that behavior, customize the option ls-lisp-dirs-first to a non-nil value.

The variable ls-lisp-verbosity controls the file attributes that ls-lisp.el displays.  The value should be a list that contains one or more of the symbols links, uid, and gid.  links means display the count of different file names that are associated with (a.k.a. links to) the file's data; this is only useful on NTFS volumes.  uid means display the numerical identifier of the user who owns the file.  gid means display the numerical identifier of the file owner's group.  The default value is (links uid gid) i.e. all the 3 optional attributes are displayed.

The variable ls-lisp-emulation controls the flavour of the ls emulation by setting the defaults for the 3 options described above: ls-lisp-ignore-case, ls-lisp-dirs-first, and ls-lisp-verbosity.  The value of this option can be one of the following symbols:

GNU
nil
     Emulate GNU systems; this is the default.  This sets ls-lisp-ignore-case and ls-lisp-dirs-first to nil, and ls-lisp-verbosity to (links uid gid).

UNIX
     Emulate Unix systems.  Like GNU, but sets ls-lisp-verbosity to (links uid).

MacOS
     Emulate MacOS.  Sets ls-lisp-ignore-case to t, and ls-lisp-dirs-first and ls-lisp-verbosity to nil.

MS-Windows
     Emulate MS-Windows.  Sets ls-lisp-ignore-case and ls-lisp-dirs-first to t, and ls-lisp-verbosity to (links) on Windows NT/2K/XP/2K3 and to nil on Windows 9X. Note that the default emulation is not MS-Windows, even on Windows, since many users of Emacs on those platforms prefer the GNU defaults.

Any other value of ls-lisp-emulation means the same as GNU. Customizing this option calls the function ls-lisp-set-options to update the 3 dependent options as needed.  If you change the value of this variable without using customize after ls-lisp.el is loaded (note that it is preloaded on MS-Windows and MS-DOS), you can call that function manually for the same result.

The variable ls-lisp-support-shell-wildcards controls how file-name patterns are supported: if it is non-nil (the default), they are treated as shell-style wildcards; otherwise they are treated as Emacs regular expressions.

The variable ls-lisp-format-time-list defines how to format the date and time of files.  The value of this variable is ignored, unless Emacs cannot determine the current locale.  (However, if the value of ls-lisp-use-localized-time-format is non-nil, Emacs obeys ls-lisp-format-time-list even if the current locale is available; see below.)

The value of ls-lisp-format-time-list is a list of 2 strings. The first string is used if the file was modified within the current year, while the second string is used for older files.  In each of these two strings you can use %-sequences to substitute parts of the time.  For example:

     ("%b %e %H:%M" "%b %e  %Y")

Note that the strings substituted for these %-sequences depend on the current locale.  See Time Parsing (The Emacs Lisp Reference Manual), for more about format time specs.

Normally, Emacs formats the file time stamps in either traditional or ISO-style time format.  However, if the value of the variable ls-lisp-use-localized-time-format is non-nil, Emacs formats file time stamps according to what ls-lisp-format-time-list specifies.  The %-sequences in ls-lisp-format-time-list produce locale-dependent month and day names, which might cause misalignment of columns in Dired display.

HOME and Startup Directories on MS-Windows
==========================================

The Windows equivalent of the HOME directory is the user-specific application data directory.  The actual location depends on your Windows version and system configuration; typical values are C:\Documents and Settings\USERNAME\Application Data on Windows 2K/XP and later, and either C:\WINDOWS\Application Data or C:\WINDOWS\Profiles\USERNAME\Application Data on the older Windows 9X/ME systems.

The home directory is where your init file .emacs is stored. When Emacs starts, it first checks whether the environment variable HOME is set.  If it is, it looks for the init file in the directory pointed by HOME.  If HOME is not defined, Emacs checks for an existing .emacs file in C:\, the root directory of drive C: (The check in C:\ is for compatibility with older versions of Emacs, which didn't check the application data directory.).  If there's no such file in C:\, Emacs next uses the Windows system calls to find out the exact location of your application data directory.  If that system call fails, Emacs falls back to C:\.

Whatever the final place is, Emacs sets the value of the HOME environment variable to point to it, and it will use that location for other files and directories it normally creates in the user's home directory.

You can always find out where Emacs thinks is your home directory's location by typing C-x d ~/ RET.  This should present the list of files in the home directory, and show its full name on the first line.  Likewise, to visit your init file, type C-x C-f ~/.emacs RET.

Because MS-DOS does not allow file names with leading dots, and because older Windows systems made it hard to create files with such names, the Windows port of Emacs supports an alternative name _emacs as a fallback, if such a file exists in the home directory, whereas .emacs does not.

If you use a Windows desktop shortcut to start Emacs, it starts in the directory specified by the shortcut.  To control where that is, right-click on the shortcut, select ``Properties'', and in the ``Shortcut'' tab modify the ``Start in'' field to your liking.

Keyboard Usage on MS-Windows
============================

This section describes the Windows-specific features related to keyboard input in Emacs.

Many key combinations (known as ``keyboard shortcuts'') that have conventional uses in MS-Windows programs conflict with traditional Emacs key bindings.  (These Emacs key bindings were established years before Microsoft was founded.)  Examples of conflicts include C-c, C-x, C-z, C-a, and W-SPC. You can redefine some of them with meanings more like the MS-Windows meanings by enabling CUA Mode (see CUA Bindings).

The F10 key on Windows activates the menu bar in a way that makes it possible to use the menus without a mouse.  In this mode, the arrow keys traverse the menus, RET selects a highlighted menu item, and ESC closes the menu.

By default, the key labeled Alt is mapped as the META key.  If you wish it to produce the Alt modifier instead, set the variable w32-alt-is-meta to a nil value.

MS-Windows reserves certain key combinations, such as Alt-TAB, for its own use.  These key combinations are intercepted by the system before Emacs can see them.  You can use the w32-register-hot-key function to allow a key sequence to be seen by Emacs instead of being grabbed by Windows.  This functions registers a key sequence as a hot key, overriding the special meaning of that key sequence for Windows.  (MS-Windows is told that the key sequence is a hot key only when one of the Emacs windows has focus, so that the special keys still have their usual meaning for other Windows applications.)

The argument to w32-register-hot-key must be a single key, with or without modifiers, in vector form that would be acceptable to define-key.  The meta modifier is interpreted as the ALT key if w32-alt-is-meta is t (the default), and the hyper modifier is always interpreted as the Windows key (usually labeled with start and the Windows logo).  If the function succeeds in registering the key sequence, it returns the hotkey ID, a number; otherwise it returns nil.

For example, (w32-register-hot-key [M-tab]) lets you use M-TAB normally in Emacs, for instance, to complete the word or symbol at point at top level, or to complete the current search string against previously sought strings during incremental search.

The function w32-unregister-hot-key reverses the effect of w32-register-hot-key for its argument key sequence.

By default, the CapsLock key only affects normal character keys (it converts lower-case characters to their upper-case variants).  However, if you set the variable w32-capslock-is-shiftlock to a non-nil value, the CapsLock key will affect non-character keys as well, as if you pressed the Shift key while typing the non-character key.

If the variable w32-enable-caps-lock is set to a nil value, the CapsLock key produces the symbol capslock instead of the shifted version of they keys.  The default value is t.

Similarly, if w32-enable-num-lock is nil, the NumLock key will produce the symbol kp-numlock.  The default is t, which causes NumLock to work as expected: toggle the meaning of the keys on the numeric keypad.

The variable w32-apps-modifier controls the effect of the Apps key (usually located between the right Alt and the right Ctrl keys).  Its value can be one of the symbols hyper, super, meta, alt, control, or shift for the respective modifier, or nil to appear as the key apps.  The default is nil.

The variable w32-lwindow-modifier determines the effect of the left Windows key (usually labeled with start and the Windows logo).  If its value is nil (the default), the key will produce the symbol lwindow.  Setting it to one of the symbols hyper, super, meta, alt, control, or shift will produce the respective modifier.  A similar variable w32-rwindow-modifier controls the effect of the right Windows key, and w32-scroll-lock-modifier does the same for the ScrLock key.  If these variables are set to nil, the right Windows key produces the symbol rwindow and ScrLock produces the symbol scroll.

Emacs compiled as a native Windows application normally turns off the Windows feature that tapping the ALT key invokes the Windows menu.  The reason is that the ALT serves as META in Emacs. When using Emacs, users often press the META key temporarily and then change their minds; if this has the effect of bringing up the Windows menu, it alters the meaning of subsequent commands.  Many users find this frustrating.

You can re-enable Windows' default handling of tapping the ALT key by setting w32-pass-alt-to-system to a non-nil value.

The variables w32-pass-lwindow-to-system and w32-pass-rwindow-to-system determine whether the respective keys are passed to Windows or swallowed by Emacs.  If the value is nil, the respective key is silently swallowed by Emacs, otherwise it is passed to Windows.  The default is t for both of these variables.  Passing each of these keys to Windows produces its normal effect: for example, Lwindow opens the Start menu, etc. (Some combinations of the ``Windows'' keys with other keys are caught by Windows at low level in a way that Emacs currently cannot prevent. For example, Lwindow r always pops up the Windows Run dialog.  Customizing the value of w32-phantom-key-code might help in some cases, though.)

The variable w32-recognize-altgr controls whether the AltGr key (if it exists on your keyboard), or its equivalent, the combination of the right Alt and left Ctrl keys pressed together, is recognized as the AltGr key.  The default is t, which means these keys produce AltGr; setting it to nil causes AltGr or the equivalent key combination to be interpreted as the combination of CTRL and META modifiers.

Mouse Usage on MS-Windows
=========================

This section describes the Windows-specific variables related to mouse.

The variable w32-mouse-button-tolerance specifies the time interval, in milliseconds, for faking middle mouse button press on 2-button mice.  If both mouse buttons are depressed within this time interval, Emacs generates a middle mouse button click event instead of a double click on one of the buttons.

If the variable w32-pass-extra-mouse-buttons-to-system is non-nil, Emacs passes the fourth and fifth mouse buttons to Windows.

The variable w32-swap-mouse-buttons controls which of the 3 mouse buttons generates the mouse-2 events.  When it is nil (the default), the middle button generates mouse-2 and the right button generates mouse-3 events.  If this variable is non-nil, the roles of these two buttons are reversed.

Subprocesses on Windows 9X/ME and Windows NT/2K/XP
==================================================

Emacs compiled as a native Windows application (as opposed to the DOS version) includes full support for asynchronous subprocesses. In the Windows version, synchronous and asynchronous subprocesses work fine on both Windows 9X/ME and Windows NT/2K/XP as long as you run only 32-bit Windows applications.  However, when you run a DOS application in a subprocess, you may encounter problems or be unable to run the application at all; and if you run two DOS applications at the same time in two subprocesses, you may have to reboot your system.

Since the standard command interpreter (and most command line utilities) on Windows 9X are DOS applications, these problems are significant when using that system.  But there's nothing we can do about them; only Microsoft can fix them.

If you run just one DOS application subprocess, the subprocess should work as expected as long as it is ``well-behaved'' and does not perform direct screen access or other unusual actions.  If you have a CPU monitor application, your machine will appear to be 100% busy even when the DOS application is idle, but this is only an artifact of the way CPU monitors measure processor load.

You must terminate the DOS application before you start any other DOS application in a different subprocess.  Emacs is unable to interrupt or terminate a DOS subprocess.  The only way you can terminate such a subprocess is by giving it a command that tells its program to exit.

If you attempt to run two DOS applications at the same time in separate subprocesses, the second one that is started will be suspended until the first one finishes, even if either or both of them are asynchronous.

If you can go to the first subprocess, and tell it to exit, the second subprocess should continue normally.  However, if the second subprocess is synchronous, Emacs itself will be hung until the first subprocess finishes.  If it will not finish without user input, then you have no choice but to reboot if you are running on Windows 9X.  If you are running on Windows NT/2K/XP, you can use a process viewer application to kill the appropriate instance of NTVDM instead (this will terminate both DOS subprocesses).

If you have to reboot Windows 9X in this situation, do not use the Shutdown command on the Start menu; that usually hangs the system.  Instead, type CTL-ALT-DEL and then choose Shutdown.  That usually works, although it may take a few minutes to do its job.

The variable w32-quote-process-args controls how Emacs quotes the process arguments.  Non-nil means quote with the " character.  If the value is a character, use that character to escape any quote characters that appear; otherwise chose a suitable escape character based on the type of the program.

The function w32-shell-execute can be useful for writing customized commands that run MS-Windows applications registered to handle a certain standard Windows operation for a specific type of document or file.  This function is a wrapper around the Windows ShellExecute API.  See the MS-Windows API documentation for more details.

Printing and MS-Windows
=======================

Printing commands, such as lpr-buffer (see Printing) and ps-print-buffer (see PostScript) work in MS-DOS and MS-Windows by sending the output to one of the printer ports, if a Posix-style lpr program is unavailable.  The same Emacs variables control printing on all systems, but in some cases they have different default values on MS-DOS and MS-Windows.

Emacs on Windows automatically determines your default printer and sets the variable printer-name to that printer's name.  But in some rare cases this can fail, or you may wish to use a different printer from within Emacs.  The rest of this section explains how to tell Emacs which printer to use.

If you want to use your local printer, then set the Lisp variable lpr-command to "" (its default value on Windows) and printer-name to the name of the printer port---for example, "PRN", the usual local printer port or "LPT2", or "COM1" for a serial printer.  You can also set printer-name to a file name, in which case ``printed'' output is actually appended to that file.  If you set printer-name to "NUL", printed output is silently discarded (sent to the system null device).

You can also use a printer shared by another machine by setting printer-name to the UNC share name for that printer---for example, "//joes_pc/hp4si".  (It doesn't matter whether you use forward slashes or backslashes here.)  To find out the names of shared printers, run the command net view from the command prompt to obtain a list of servers, and net view SERVER-NAME to see the names of printers (and directories) shared by that server. Alternatively, click the Network Neighborhood icon on your desktop, and look for machines which share their printers via the network.

If the printer doesn't appear in the output of net view, or if setting printer-name to the UNC share name doesn't produce a hardcopy on that printer, you can use the net use command to connect a local print port such as "LPT2" to the networked printer.  For example, typing net use LPT2: \\joes_pc\hp4si (Note that the net use command requires the UNC share name to be typed with the Windows-style backslashes, while the value of printer-name can be set with either forward- or backslashes.) causes Windows to capture the LPT2 port and redirect the printed material to the printer connected to the machine joes_pc. After this command, setting printer-name to "LPT2" should produce the hardcopy on the networked printer.

With some varieties of Windows network software, you can instruct Windows to capture a specific printer port such as "LPT2", and redirect it to a networked printer via the Control Panel->Printers applet instead of net use.

If you set printer-name to a file name, it's best to use an absolute file name.  Emacs changes the working directory according to the default directory of the current buffer, so if the file name in printer-name is relative, you will end up with several such files, each one in the directory of the buffer from which the printing was done.

If the value of printer-name is correct, but printing does not produce the hardcopy on your printer, it is possible that your printer does not support printing plain text (some cheap printers omit this functionality).  In that case, try the PostScript print commands, described below.

The commands print-buffer and print-region call the pr program, or use special switches to the lpr program, to produce headers on each printed page.  MS-DOS and MS-Windows don't normally have these programs, so by default, the variable lpr-headers-switches is set so that the requests to print page headers are silently ignored.  Thus, print-buffer and print-region produce the same output as lpr-buffer and lpr-region, respectively.  If you do have a suitable pr program (for example, from GNU Coreutils), set lpr-headers-switches to nil; Emacs will then call pr to produce the page headers, and print the resulting output as specified by printer-name.

Finally, if you do have an lpr work-alike, you can set the variable lpr-command to "lpr".  Then Emacs will use lpr for printing, as on other systems.  (If the name of the program isn't lpr, set lpr-command to specify where to find it.)  The variable lpr-switches has its standard meaning when lpr-command is not "".  If the variable printer-name has a string value, it is used as the value for the -P option to lpr, as on Unix.

A parallel set of variables, ps-lpr-command, ps-lpr-switches, and ps-printer-name (see PostScript Variables), defines how PostScript files should be printed.  These variables are used in the same way as the corresponding variables described above for non-PostScript printing.  Thus, the value of ps-printer-name is used as the name of the device (or file) to which PostScript output is sent, just as printer-name is used for non-PostScript printing.  (There are two distinct sets of variables in case you have two printers attached to two different ports, and only one of them is a PostScript printer.)

The default value of the variable ps-lpr-command is "", which causes PostScript output to be sent to the printer port specified by ps-printer-name, but ps-lpr-command can also be set to the name of a program which will accept PostScript files.  Thus, if you have a non-PostScript printer, you can set this variable to the name of a PostScript interpreter program (such as Ghostscript).  Any switches that need to be passed to the interpreter program are specified using ps-lpr-switches.  (If the value of ps-printer-name is a string, it will be added to the list of switches as the value for the -P option.  This is probably only useful if you are using lpr, so when using an interpreter typically you would set ps-printer-name to something other than a string so it is ignored.)

For example, to use Ghostscript for printing on the system's default printer, put this in your .emacs file:

     (setq ps-printer-name t)
     (setq ps-lpr-command "D:/gs6.01/bin/gswin32c.exe")
     (setq ps-lpr-switches '("-q" "-dNOPAUSE" "-dBATCH"
                             "-sDEVICE=mswinpr2"
                             "-sPAPERSIZE=a4"))

(This assumes that Ghostscript is installed in the D:/gs6.01 directory.)

Specifying Fonts on MS-Windows
==============================

Starting with Emacs 23, fonts are specified by their name, size and optional properties.  The format for specifying fonts comes from the fontconfig library used in modern Free desktops:

       [Family[-PointSize]][:Option1=Value1[:Option2=Value2[...]]]

The old XLFD based format is also supported for backwards compatibility.

Emacs 23 supports a number of backends.  Currently, the gdi and uniscribe font backends are supported on Windows.  The gdi font backend is available on all versions of Windows, and supports all fonts that are natively supported by Windows.  The uniscribe font backend is available on Windows 2000 and later, and supports Truetype and Opentype fonts.  Some languages requiring complex layout can only be properly supported by the uniscribe backend.  By default, both backends are enabled if supported, with uniscribe taking priority over gdi.

Optional properties common to all font backends on MS-Windows are:

weight
     Specifies the weight of the font.  Special values light, medium, demibold, bold, and black can be specified without weight= (e.g., Courier New-12:bold).  Otherwise, the weight should be a numeric value between 100 and 900, or one of the named weights in font-weight-table.  If unspecified, a regular font is assumed.

slant
     Specifies whether the font is italic.  Special values roman, italic and oblique can be specified without slant= (e.g., Courier New-12:italic). Otherwise, the slant should be a numeric value, or one of the named slants in font-slant-table.  On Windows, any slant above 150 is treated as italics, and anything below as roman.

family
     Specifies the font family, but normally this will be specified at the start of the font name.

pixelsize
     Specifies the font size in pixels.  This can be used instead of the point size specified after the family name.

adstyle
     Specifies additional style information for the font. On MS-Windows, the values mono, sans, serif, script and decorative are recognized.  These are most useful as a fallback with the font family left unspecified.

registry
     Specifies the character set registry that the font is expected to cover.  Most Truetype and Opentype fonts will be unicode fonts that cover several national character sets, but you can narrow down the selection of fonts to those that support a particular character set by using a specific registry from w32-charset-info-alist here.

spacing
     Specifies how the font is spaced.  The p spacing specifies a proportional font, and m or c specify a monospaced font.

foundry
     Not used on Windows, but for informational purposes and to prevent problems with code that expects it to be set, is set internally to raster for bitmapped fonts, outline for scalable fonts, or unknown if the type cannot be determined as one of those.

Options specific to GDI fonts:

script
     Specifies a unicode subrange the font should support.

     The following scripts are recognized on Windows: latin, greek, coptic, cyrillic, armenian, hebrew, arabic, syriac, nko, thaana, devanagari, bengali, gurmukhi, gujarati, oriya, tamil, telugu, kannada, malayam, sinhala, thai, lao, tibetan, myanmar, georgian, hangul, ethiopic, cherokee, canadian-aboriginal, ogham, runic, khmer, mongolian, symbol, braille, han, ideographic-description, cjk-misc, kana, bopomofo, kanbun, yi, byzantine-musical-symbol, musical-symbol, and mathematical.

antialias
     Specifies the antialiasing to use for the font.  The value none means no antialiasing, standard means use standard antialiasing, subpixel means use subpixel antialiasing (known as Cleartype on Windows), and natural means use subpixel antialiasing with adjusted spacing between letters.  If unspecified, the font will use the system default antialiasing.

Miscellaneous Windows-specific features
=======================================

This section describes miscellaneous Windows-specific features.

The variable w32-use-visible-system-caret is a flag that determines whether to make the system caret visible.  The default when no screen reader software is in use is nil, which means Emacs draws its own cursor to indicate the position of point.  A non-nil value means Emacs will indicate point location by the system caret; this facilitates use of screen reader software, and is the default when such software is detected when running Emacs. When this variable is non-nil, other variables affecting the cursor display have no effect.

The variable w32-grab-focus-on-raise, if set to a non-nil value causes a frame to grab focus when it is raised. The default is t, which fits well with the Windows default click-to-focus policy.

     [file msdog-xtra.texi not included]