procyberian/emacs
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Merge cygw32

Browse source
This commit is contained in:
Daniel Colascione 2012-10-08 00:23:13 -08:00
commit 7148eba270
58 changed files with 1928 additions and 826 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

9
ChangeLog
View file

@ -1,3 +1,12 @@
2012-10-08 Daniel Colascione <dancol@dancol.org>
* configure.ac: Add --with-w32 as a window system option. Limit
it to Cygwin for now. Integrate w32 into the refactored window
system configuration and set TERM_HEADER to w32term.h when w32 is
configured.
(CYGWIN_OBJ): Add cygw32.o.
2012-10-07 Jan Djärv <jan.h.d@swipnet.se>
* configure.ac: Check that OSX is 10.4 or newer.

82
configure.ac
View file

@ -177,6 +177,7 @@ OPTION_DEFAULT_ON([toolkit-scroll-bars],[don't use Motif or Xaw3d scroll bars])
OPTION_DEFAULT_ON([xaw3d],[don't use Xaw3d])
OPTION_DEFAULT_ON([xim],[don't use X11 XIM])
OPTION_DEFAULT_OFF([ns],[use NeXTstep (Cocoa or GNUstep) windowing system])
OPTION_DEFAULT_OFF([w32], [use native Windows GUI])
OPTION_DEFAULT_ON([gpm],[don't use -lgpm for mouse support on a GNU/Linux console])
OPTION_DEFAULT_ON([dbus],[don't compile with D-Bus support])
@ -1534,6 +1535,7 @@ fail;
AC_DEFINE(NS_HAVE_NSINTEGER, 1, [Define to 1 if `NSInteger' is defined.])
fi
fi
AC_SUBST(TEMACS_LDFLAGS2)
INSTALL_ARCH_INDEP_EXTRA=install-etc
@ -1574,6 +1576,30 @@ AC_SUBST(NS_OBJ)
AC_SUBST(NS_OBJC_OBJ)
AC_SUBST(LIB_STANDARD)
HAVE_W32=no
W32_OBJ=
W32_LIBS=
if test "${with_w32}" != no; then
if test "${opsys}" != "cygwin"; then
AC_MSG_ERROR([Using w32 with an autotools build is only supported for Cygwin.])
fi
AC_CHECK_HEADER([windows.h], [HAVE_W32=yes],
[AC_MSG_ERROR([`--with-w32' was specified, but windows.h
cannot be found.])])
AC_DEFINE(HAVE_NTGUI, 1, [Define to use native Windows GUI.])
W32_OBJ="w32fns.o w32menu.o w32reg.o w32font.o w32term.o"
W32_OBJ="$W32_OBJ w32xfns.o w32select.o w32uniscribe.o"
W32_LIBS="$W32_LIBS -lkernel32 -luser32 -lgdi32 -lole32 -lcomdlg32"
W32_LIBS="$W32_LIBS -lusp10 -lcomctl32 -lwinspool"
fi
AC_SUBST(W32_OBJ)
AC_SUBST(W32_LIBS)
if test "${HAVE_W32}" = "yes"; then
window_system=w32
with_xft=no
fi
## $window_system is now set to the window system we will
## ultimately use.
@ -1610,6 +1636,9 @@ dnl use the toolkit if we have gtk, or X11R5 or newer.
nextstep )
term_header=nsterm.h
;;
w32 )
term_header=w32term.h
;;
esac
if test -n "${term_header}"; then
@ -2310,6 +2339,9 @@ if test "${with_toolkit_scroll_bars}" != "no"; then
elif test "${HAVE_NS}" = "yes"; then
AC_DEFINE(USE_TOOLKIT_SCROLL_BARS)
USE_TOOLKIT_SCROLL_BARS=yes
elif test "${HAVE_W32}" = "yes"; then
AC_DEFINE(USE_TOOLKIT_SCROLL_BARS)
USE_TOOLKIT_SCROLL_BARS=yes
fi
fi
@ -2476,6 +2508,41 @@ AC_SUBST(M17N_FLT_LIBS)
### Use -lXpm if available, unless `--with-xpm=no'.
HAVE_XPM=no
LIBXPM=
if test "${HAVE_W32}" = "yes"; then
if test "${with_xpm}" != "no"; then
SAVE_CPPFLAGS="$CPPFLAGS"
SAVE_LDFLAGS="$LDFLAGS"
CPPFLAGS="$CPPFLAGS -I/usr/include/noX"
LDFLAGS="$LDFLAGS -L/usr/lib/noX"
AC_CHECK_HEADER(X11/xpm.h,
[AC_CHECK_LIB(Xpm, XpmReadFileToImage, HAVE_XPM=yes)])
if test "${HAVE_XPM}" = "yes"; then
AC_MSG_CHECKING(for XpmReturnAllocPixels preprocessor define)
AC_EGREP_CPP(no_return_alloc_pixels,
[#include "X11/xpm.h"
#ifndef XpmReturnAllocPixels
no_return_alloc_pixels
#endif
], HAVE_XPM=no, HAVE_XPM=yes)
if test "${HAVE_XPM}" = "yes"; then
REAL_CPPFLAGS="$REAL_CPPFLAGS -I/usr/include/noX"
AC_MSG_RESULT(yes)
else
AC_MSG_RESULT(no)
CPPFLAGS="$SAVE_CPPFLAGS"
LDFLAGS="$SAVE_LDFLAGS"
fi
fi
fi
if test "${HAVE_XPM}" = "yes"; then
AC_DEFINE(HAVE_XPM, 1, [Define to 1 if you have the Xpm libary (-lXpm).])
LIBXPM=-lXpm
fi
fi
if test "${HAVE_X11}" = "yes"; then
if test "${with_xpm}" != "no"; then
AC_CHECK_HEADER(X11/xpm.h,
@ -2502,12 +2569,13 @@ no_return_alloc_pixels
LIBXPM=-lXpm
fi
fi
AC_SUBST(LIBXPM)
### Use -ljpeg if available, unless `--with-jpeg=no'.
HAVE_JPEG=no
LIBJPEG=
if test "${HAVE_X11}" = "yes"; then
if test "${HAVE_X11}" = "yes" || test "${HAVE_W32}" = "yes"; then
if test "${with_jpeg}" != "no"; then
dnl Checking for jpeglib.h can lose because of a redefinition of
dnl HAVE_STDLIB_H.
@ -2535,7 +2603,7 @@ AC_SUBST(LIBJPEG)
### Use -lpng if available, unless `--with-png=no'.
HAVE_PNG=no
LIBPNG=
if test "${HAVE_X11}" = "yes"; then
if test "${HAVE_X11}" = "yes" || test "${HAVE_W32}" = "yes"; then
if test "${with_png}" != "no"; then
# Debian unstable as of July 2003 has multiple libpngs, and puts png.h
# in /usr/include/libpng.
@ -2568,7 +2636,7 @@ AC_SUBST(LIBPNG)
### Use -ltiff if available, unless `--with-tiff=no'.
HAVE_TIFF=no
LIBTIFF=
if test "${HAVE_X11}" = "yes"; then
if test "${HAVE_X11}" = "yes" || test "${HAVE_W32}" = "yes"; then
if test "${with_tiff}" != "no"; then
AC_CHECK_HEADER(tiffio.h,
[tifflibs="-lz -lm"
@ -2588,7 +2656,8 @@ AC_SUBST(LIBTIFF)
### Use -lgif or -lungif if available, unless `--with-gif=no'.
HAVE_GIF=no
LIBGIF=
if test "${HAVE_X11}" = "yes" && test "${with_gif}" != "no"; then
if test "${HAVE_X11}" = "yes" && test "${with_gif}" != "no" \
|| test "${HAVE_W32}" = "yes"; then
AC_CHECK_HEADER(gif_lib.h,
# EGifPutExtensionLast only exists from version libungif-4.1.0b1.
# Earlier versions can crash Emacs.
@ -2670,6 +2739,9 @@ if test "${HAVE_NS}" = "yes"; then
OTHER_FILES=ns-app
fi
if test "${HAVE_W32}" = "yes"; then
HAVE_MENUS=yes
fi
### Use session management (-lSM -lICE) if available
HAVE_X_SM=no
@ -4205,7 +4277,7 @@ fi
AC_SUBST(RALLOC_OBJ)
if test "$opsys" = "cygwin"; then
CYGWIN_OBJ="sheap.o"
CYGWIN_OBJ="sheap.o cygw32.o"
## Cygwin differs because of its unexec().
PRE_ALLOC_OBJ=
POST_ALLOC_OBJ=lastfile.o

10
etc/NEWS
View file

@ -78,6 +78,11 @@ directories to the search path. You must add them yourself if you want them.
(from the bin and libexec directories, respectively). The former is
no longer relevant, the latter is replaced by lisp (in vc-sccs.el).
---
** The native Windows user interface is available for Cygwin. Passing
--with-w32 will configure a Cygwin emacs to use the Windows user
interface instead of the default, X11.
* Startup Changes in Emacs 24.3
@ -882,6 +887,11 @@ is detected.
Emacs now supports mouse highlight, help-echo (in the echo area), and
mouse-autoselect-window.
** Two new functions are available in Cygwin builds of Emacs:
cygwin-convert-path-from-windows and cygwin-convert-path-to-windows.
These functions allows lisp code to access the Cygwin path mapping
machinery to convert between Cygwin and Windows-native paths.
** On MS-Windows Vista and later Emacs now supports symbolic links.
* Changes in Emacs 24.2

13
lib-src/ChangeLog
View file

@ -1,3 +1,16 @@
2012-10-08 Daniel Colascione <dancol@dancol.org>
* emacsclient.c: Include windows.h when HAVE_NTGUI.
(alt_display): New variable. We send the display held by this
variable when the primary display is either unsupported or not
present.
(longopts): Allow display everywhere.
(w32_set_user_model_id): Move lower in file, inside HAVE_NTGUI
section.
(decode_options): Use alt_display. Explain why.
(main): Retry connection with alt_display if connection with main
display fails.
2012-10-01 Fabrice Popineau <fabrice.popineau@gmail.com>
* make-docfile.c (write_globals): Special-case

198
lib-src/emacsclient.c
View file

@ -44,6 +44,10 @@ char *w32_getenv (char *);
#else /* !WINDOWSNT */
# ifdef HAVE_NTGUI
# include <windows.h>
# endif /* HAVE_NTGUI */
# include "syswait.h"
# ifdef HAVE_INET_SOCKETS
@ -140,6 +144,9 @@ int current_frame = 1;
/* The display on which Emacs should work. --display. */
const char *display = NULL;
/* The alternate display we should try if Emacs does not support display. */
const char *alt_display = NULL;
/* The parent window ID, if we are opening a frame via XEmbed. */
char *parent_id = NULL;
@ -182,9 +189,7 @@ struct option longopts[] =
{ "socket-name", required_argument, NULL, 's' },
#endif
{ "server-file", required_argument, NULL, 'f' },
#ifndef WINDOWSNT
{ "display", required_argument, NULL, 'd' },
#endif
{ "parent-id", required_argument, NULL, 'p' },
{ 0, 0, 0, 0 }
};
@ -385,32 +390,6 @@ w32_getenv (char *envvar)
return NULL;
}
void
w32_set_user_model_id (void)
{
HMODULE shell;
HRESULT (WINAPI * set_user_model) (wchar_t * id);
/* On Windows 7 and later, we need to set the user model ID
to associate emacsclient launched files with Emacs frames
in the UI. */
shell = LoadLibrary ("shell32.dll");
if (shell)
{
set_user_model
= (void *) GetProcAddress (shell,
"SetCurrentProcessExplicitAppUserModelID");
/* If the function is defined, then we are running on Windows 7
or newer, and the UI uses this to group related windows
together. Since emacs, runemacs, emacsclient are related, we
want them grouped even though the executables are different,
so we need to set a consistent ID between them. */
if (set_user_model)
set_user_model (L"GNU.Emacs");
FreeLibrary (shell);
}
}
int
w32_window_app (void)
@ -605,16 +584,29 @@ decode_options (int argc, char **argv)
Without the -c option, we used to set `display' to $DISPLAY by
default, but this changed the default behavior and is sometimes
inconvenient. So we force users to use "--display $DISPLAY" if
they want Emacs to connect to their current display. */
they want Emacs to connect to their current display.
Some window systems have a notion of default display not
reflected in the DISPLAY variable. If the user didn't give us an
explicit display, try this platform-specific after trying the
display in DISPLAY (if any). */
if (!current_frame && !tty && !display)
{
display = egetenv ("DISPLAY");
#ifdef NS_IMPL_COCOA
/* Under Cocoa, we don't really use displays the same way as in X,
so provide a dummy. */
if (!display || strlen (display) == 0)
display = "ns";
/* Set these here so we use a default_display only when the user
didn't give us an explicit display. */
#if defined (NS_IMPL_COCOA)
alt_display = "ns";
#elif defined (HAVE_NTGUI)
alt_display = "w32";
#endif
display = egetenv ("DISPLAY");
}
if (!display)
{
display = alt_display;
alt_display = NULL;
}
/* A null-string display is invalid. */
@ -1415,10 +1407,37 @@ set_socket (int no_exit_if_error)
exit (EXIT_FAILURE);
}
#ifdef WINDOWSNT
#ifdef HAVE_NTGUI
FARPROC set_fg; /* Pointer to AllowSetForegroundWindow. */
FARPROC get_wc; /* Pointer to RealGetWindowClassA. */
void
w32_set_user_model_id (void)
{
HMODULE shell;
HRESULT (WINAPI * set_user_model) (wchar_t * id);
/* On Windows 7 and later, we need to set the user model ID
to associate emacsclient launched files with Emacs frames
in the UI. */
shell = LoadLibrary ("shell32.dll");
if (shell)
{
set_user_model
= (void *) GetProcAddress (shell,
"SetCurrentProcessExplicitAppUserModelID");
/* If the function is defined, then we are running on Windows 7
or newer, and the UI uses this to group related windows
together. Since emacs, runemacs, emacsclient are related, we
want them grouped even though the executables are different,
so we need to set a consistent ID between them. */
if (set_user_model)
set_user_model (L"GNU.Emacs");
FreeLibrary (shell);
}
}
BOOL CALLBACK
w32_find_emacs_process (HWND hWnd, LPARAM lParam)
{
@ -1467,7 +1486,7 @@ w32_give_focus (void)
&& (get_wc = GetProcAddress (user32, "RealGetWindowClassA")))
EnumWindows (w32_find_emacs_process, (LPARAM) 0);
}
#endif
#endif /* HAVE_NTGUI */
/* Start the emacs daemon and try to connect to it. */
@ -1537,11 +1556,13 @@ main (int argc, char **argv)
main_argv = argv;
progname = argv[0];
#ifdef WINDOWSNT
/* On Windows 7 and later, we need to explicitly associate emacsclient
with emacs so the UI behaves sensibly. */
#ifdef HAVE_NTGUI
/* On Windows 7 and later, we need to explicitly associate
emacsclient with emacs so the UI behaves sensibly. This
association does no harm if we're not actually connecting to an
Emacs using a window display. */
w32_set_user_model_id ();
#endif
#endif /* HAVE_NTGUI */
/* Process options. */
decode_options (argc, argv);
@ -1577,9 +1598,10 @@ main (int argc, char **argv)
fail ();
}
#ifdef WINDOWSNT
#ifdef HAVE_NTGUI
if (display && !strcmp (display, "w32"))
w32_give_focus ();
#endif
#endif /* HAVE_NTGUI */
/* Send over our environment and current directory. */
if (!current_frame)
@ -1748,46 +1770,56 @@ main (int argc, char **argv)
if (end_p != NULL)
*end_p++ = '\0';
if (strprefix ("-emacs-pid ", p))
{
/* -emacs-pid PID: The process id of the Emacs process. */
emacs_pid = strtol (p + strlen ("-emacs-pid"), NULL, 10);
}
else if (strprefix ("-window-system-unsupported ", p))
{
/* -window-system-unsupported: Emacs was compiled without X
support. Try again on the terminal. */
nowait = 0;
tty = 1;
goto retry;
}
else if (strprefix ("-print ", p))
{
/* -print STRING: Print STRING on the terminal. */
str = unquote_argument (p + strlen ("-print "));
if (needlf)
printf ("\n");
printf ("%s", str);
needlf = str[0] == '\0' ? needlf : str[strlen (str) - 1] != '\n';
}
else if (strprefix ("-print-nonl ", p))
{
/* -print-nonl STRING: Print STRING on the terminal.
Used to continue a preceding -print command. */
str = unquote_argument (p + strlen ("-print-nonl "));
printf ("%s", str);
needlf = str[0] == '\0' ? needlf : str[strlen (str) - 1] != '\n';
}
else if (strprefix ("-error ", p))
{
/* -error DESCRIPTION: Signal an error on the terminal. */
str = unquote_argument (p + strlen ("-error "));
if (needlf)
printf ("\n");
fprintf (stderr, "*ERROR*: %s", str);
needlf = str[0] == '\0' ? needlf : str[strlen (str) - 1] != '\n';
exit_status = EXIT_FAILURE;
}
if (strprefix ("-emacs-pid ", p))
{
/* -emacs-pid PID: The process id of the Emacs process. */
emacs_pid = strtol (p + strlen ("-emacs-pid"), NULL, 10);
}
else if (strprefix ("-window-system-unsupported ", p))
{
/* -window-system-unsupported: Emacs was compiled without support
for whatever window system we tried. Try the alternate
display, or, failing that, try the terminal. */
if (alt_display)
{
display = alt_display;
alt_display = NULL;
}
else
{
nowait = 0;
tty = 1;
}
goto retry;
}
else if (strprefix ("-print ", p))
{
/* -print STRING: Print STRING on the terminal. */
str = unquote_argument (p + strlen ("-print "));
if (needlf)
printf ("\n");
printf ("%s", str);
needlf = str[0] == '\0' ? needlf : str[strlen (str) - 1] != '\n';
}
else if (strprefix ("-print-nonl ", p))
{
/* -print-nonl STRING: Print STRING on the terminal.
Used to continue a preceding -print command. */
str = unquote_argument (p + strlen ("-print-nonl "));
printf ("%s", str);
needlf = str[0] == '\0' ? needlf : str[strlen (str) - 1] != '\n';
}
else if (strprefix ("-error ", p))
{
/* -error DESCRIPTION: Signal an error on the terminal. */
str = unquote_argument (p + strlen ("-error "));
if (needlf)
printf ("\n");
fprintf (stderr, "*ERROR*: %s", str);
needlf = str[0] == '\0' ? needlf : str[strlen (str) - 1] != '\n';
exit_status = EXIT_FAILURE;
}
#ifdef SIGSTOP
else if (strprefix ("-suspend ", p))
{

67
lisp/ChangeLog
View file

@ -30,6 +30,73 @@
* comint.el (comint-preinput-scroll-to-bottom): Preserve the
frame-selected-windows.
2012-10-08 Daniel Colascione <dancol@dancol.org>
* battery.el (battery-status-function): Check for
w32-battery-status itself, not system-time windows-nt.
* frame.el: Require cl-lib.
(display-format-alist): New variable mapping frame types to
functions that initialize them.
(window-system-for-display): New function: interprets
display-format-alist.
(make-frame-on-display): Remove existing display-selection logic
and just forward to make-frame, which will now DTRT.
(make-frame): Restructure to use window-system-for-display to
figure out how to create a frame on a given display.
(display-mouse-p): Look for frame-type w32, not a particular
system-type.
* loadup.el: Load w32 lisp code when we have the w32 feature.
* mouse.el (mouse-yank-primarY): Look for frame-type w32, not
system-type windows-nt.
* server.el (server-create-window-system-frame): Look for window
type.
(server-proces-filter): Only force a window system when windows-nt
_and_ w32. Explain why.
* simple.el (normal-erase-is-backspace-mode): Add w32 to the list
of window systems we configure for the mode.
* startup.el (command-line): Mark window system is initialized
after we've done it.
* common-win.el (x-select-text): Look for w32, not windows-nt.
* ns-win.el: Require cl-lib. Add ourselves to
display-format-alist.
(ns-initialize-window-system): Assert we're not initialized twice.
* w32-win.el: Enable lexical binding; require cl-lib; add
ourselves to display-format-alist.
(w32-handle-dropped-file): Convert incoming dropped files from
Windows paths to Cygwin ones before passing them on to the rest of
Emacs.
(w32-drag-n-drop): New paramter new-frame. Simplify logic.
(w32-initialize-window-system): Assert we're not initialized twice.
* x-win.el: Require cl-lib; add ourselves to display-format-alist.
(x-initialize-window-system): Assert we're not initialized twice.
* w32-common-fns.el: New File.
(w32-version, w32-using-nt, w32-get-clipboard-data)
(w32-set-clipboard-data, x-set-selection, x-get-selection)
(w32-charset-info-alist, x-last-selected, text)
(x-get-selection-value, x-selection-value): Move here.
* w32-fns.el: Require w32-common-fns.
(w32-version, w32-using-nt, w32-get-clipboard-data)
(w32-set-clipboard-data, x-set-selection, x-get-selection)
(w32-charset-info-alist, x-last-selected, text)
(x-get-selection-value, x-selection-value): Move to
w32-common-fns.
* w32-vars.el:
(w32-allow-system-shell, w32-system-shells): Define only in
non-cygwin case.
2012-10-07 Stefan Monnier <monnier@iro.umontreal.ca>
* subr.el (read-passwd-map): Don't use `defconst' (bug#12597).

2
lisp/battery.el
View file

@ -60,7 +60,7 @@
(> (buffer-size) 0)))
(error nil)))
'battery-pmset)
((eq system-type 'windows-nt)
((fboundp 'w32-battery-status)
'w32-battery-status))
"Function for getting battery status information.
The function has to return an alist of conversion definitions.

2
lisp/faces.el
View file

@ -96,7 +96,7 @@ ALTERNATIVE2 etc."
;; This is defined originally in xfaces.c.
(defcustom face-font-registry-alternatives
(mapcar (lambda (arg) (mapcar 'purecopy arg))
(if (eq system-type 'windows-nt)
(if (featurep 'w32)
'(("iso8859-1" "ms-oemlatin")
("gb2312.1980" "gb2312" "gbk" "gb18030")
("jisx0208.1990" "jisx0208.1983" "jisx0208.1978")

55
lisp/frame.el
View file

@ -25,6 +25,8 @@
;;; Commentary:
;;; Code:
(eval-when-compile (require 'cl-lib))
(defvar frame-creation-function-alist
(list (cons nil
(if (fboundp 'tty-create-frame-with-faces)
@ -45,6 +47,12 @@ Then, for frames on WINDOW-SYSTEM, any parameters specified in
ALIST supersede the corresponding parameters specified in
`default-frame-alist'.")
(defvar display-format-alist nil
"Alist of patterns to decode display names.
The car of each entry is a regular expression matching a display
name string. The cdr is a symbol giving the window-system that
handles the corresponding kind of display.")
;; The initial value given here used to ask for a minibuffer.
;; But that's not necessary, because the default is to have one.
;; By not specifying it here, we let an X resource specify it.
@ -510,31 +518,19 @@ is not considered (see `next-frame')."
0))
(select-frame-set-input-focus (selected-frame)))
(declare-function x-initialize-window-system "term/x-win" ())
(declare-function ns-initialize-window-system "term/ns-win" ())
(defvar x-display-name) ; term/x-win
(defun window-system-for-display (display)
"Return the window system for DISPLAY.
Return nil if we don't know how to interpret DISPLAY."
(cl-loop for descriptor in display-format-alist
for pattern = (car descriptor)
for system = (cdr descriptor)
when (string-match-p pattern display) return system))
(defun make-frame-on-display (display &optional parameters)
"Make a frame on display DISPLAY.
The optional argument PARAMETERS specifies additional frame parameters."
(interactive "sMake frame on display: ")
(cond ((featurep 'ns)
(when (and (boundp 'ns-initialized) (not ns-initialized))
(setq x-display-name display)
(ns-initialize-window-system))
(make-frame `((window-system . ns)
(display . ,display) . ,parameters)))
((eq system-type 'windows-nt)
;; On Windows, ignore DISPLAY.
(make-frame parameters))
(t
(unless (string-match-p "\\`[^:]*:[0-9]+\\(\\.[0-9]+\\)?\\'" display)
(error "Invalid display, not HOST:SERVER or HOST:SERVER.SCREEN"))
(when (and (boundp 'x-initialized) (not x-initialized))
(setq x-display-name display)
(x-initialize-window-system))
(make-frame `((window-system . x)
(display . ,display) . ,parameters)))))
(make-frame (cons (cons 'display display) parameters)))
(declare-function x-close-connection "xfns.c" (terminal))
@ -616,6 +612,8 @@ neither or both.
(window-system . nil) The frame should be displayed on a terminal device.
(window-system . x) The frame should be displayed in an X window.
(display . \":0\") The frame should appear on display :0.
(terminal . TERMINAL) The frame should use the terminal object TERMINAL.
In addition, any parameter specified in `default-frame-alist',
@ -626,11 +624,15 @@ this function runs the hook `before-make-frame-hook'. After
creating the frame, it runs the hook `after-make-frame-functions'
with one arg, the newly created frame.
If a display parameter is supplied and a window-system is not,
guess the window-system from the display.
On graphical displays, this function does not itself make the new
frame the selected frame. However, the window system may select
the new frame according to its own rules."
(interactive)
(let* ((w (cond
(let* ((display (cdr (assq 'display parameters)))
(w (cond
((assq 'terminal parameters)
(let ((type (terminal-live-p (cdr (assq 'terminal parameters)))))
(cond
@ -640,6 +642,10 @@ the new frame according to its own rules."
(t type))))
((assq 'window-system parameters)
(cdr (assq 'window-system parameters)))
(display
(or (window-system-for-display display)
(error "Don't know how to interpret display \"%S\""
display)))
(t window-system)))
(frame-creation-function (cdr (assq w frame-creation-function-alist)))
(oldframe (selected-frame))
@ -647,6 +653,11 @@ the new frame according to its own rules."
frame)
(unless frame-creation-function
(error "Don't know how to create a frame on window system %s" w))
(unless (get w 'window-system-initialized)
(funcall (cdr (assq w window-system-initialization-alist)))
(put w 'window-system-initialized t))
;; Add parameters from `window-system-default-frame-alist'.
(dolist (p (cdr (assq w window-system-default-frame-alist)))
(unless (assq (car p) params)
@ -1260,7 +1271,7 @@ frame's display)."
(cond
((eq frame-type 'pc)
(msdos-mouse-p))
((eq system-type 'windows-nt)
((eq frame-type 'w32)
(with-no-warnings
(> w32-num-mouse-buttons 0)))
((memq frame-type '(x ns))

3
lisp/international/mule-cmds.el
View file

@ -2670,7 +2670,8 @@ See also `locale-charset-language-names', `locale-language-names',
;; On Windows, override locale-coding-system,
;; default-file-name-coding-system, keyboard-coding-system,
;; terminal-coding-system with system codepage.
(when (boundp 'w32-ansi-code-page)
(when (and (eq system-type 'windows-nt)
(boundp 'w32-ansi-code-page))
(let ((code-page-coding (intern (format "cp%d" w32-ansi-code-page))))
(when (coding-system-p code-page-coding)
(unless frame (setq locale-coding-system code-page-coding))

13
lisp/loadup.el
View file

@ -237,15 +237,18 @@
(load "term/common-win")
(load "term/x-win")))
(if (eq system-type 'windows-nt)
(if (or (eq system-type 'windows-nt)
(featurep 'w32))
(progn
(load "w32-vars")
(load "term/common-win")
(load "w32-vars")
(load "term/w32-win")
(load "ls-lisp")
(load "disp-table")
(load "dos-w32")
(load "w32-fns")))
(load "w32-common-fns")
(when (eq system-type 'windows-nt)
(load "w32-fns")
(load "ls-lisp")
(load "dos-w32"))))
(if (eq system-type 'ms-dos)
(progn
(load "dos-w32")

2
lisp/mouse.el
View file

@ -1151,7 +1151,7 @@ regardless of where you click."
(or mouse-yank-at-point (mouse-set-point click))
(let ((primary
(cond
((eq system-type 'windows-nt)
((eq (framep (selected-frame)) 'w32)
;; MS-Windows emulates PRIMARY in x-get-selection, but not
;; in x-get-selection-value (the latter only accesses the
;; clipboard). So try PRIMARY first, in case they selected

73
lisp/server.el
View file

@ -833,35 +833,40 @@ This handles splitting the command if it would be bigger than
(defun server-create-window-system-frame (display nowait proc parent-id
&optional parameters)
(add-to-list 'frame-inherited-parameters 'client)
(if (not (fboundp 'make-frame-on-display))
(progn
;; This emacs does not support X.
(server-log "Window system unsupported" proc)
(server-send-string proc "-window-system-unsupported \n")
nil)
;; Flag frame as client-created, but use a dummy client.
;; This will prevent the frame from being deleted when
;; emacsclient quits while also preventing
;; `server-save-buffers-kill-terminal' from unexpectedly
;; killing emacs on that frame.
(let* ((params `((client . ,(if nowait 'nowait proc))
;; This is a leftover, see above.
(environment . ,(process-get proc 'env))
,@parameters))
(display (or display
(frame-parameter nil 'display)
(getenv "DISPLAY")
(error "Please specify display")))
frame)
(if parent-id
(push (cons 'parent-id (string-to-number parent-id)) params))
(setq frame (make-frame-on-display display params))
(server-log (format "%s created" frame) proc)
(select-frame frame)
(process-put proc 'frame frame)
(process-put proc 'terminal (frame-terminal frame))
frame)))
(let* ((display (or display
(frame-parameter nil 'display)
(error "Please specify display.")))
(w (or (cdr (assq 'window-system parameters))
(window-system-for-display display))))
(unless (assq w window-system-initialization-alist)
(setq w nil))
(cond (w
;; Flag frame as client-created, but use a dummy client.
;; This will prevent the frame from being deleted when
;; emacsclient quits while also preventing
;; `server-save-buffers-kill-terminal' from unexpectedly
;; killing emacs on that frame.
(let* ((params `((client . ,(if nowait 'nowait proc))
;; This is a leftover, see above.
(environment . ,(process-get proc 'env))
,@parameters))
frame)
(if parent-id
(push (cons 'parent-id (string-to-number parent-id)) params))
(add-to-list 'frame-inherited-parameters 'client)
(setq frame (make-frame-on-display display params))
(server-log (format "%s created" frame) proc)
(select-frame frame)
(process-put proc 'frame frame)
(process-put proc 'terminal (frame-terminal frame))
frame))
(t
(server-log "Window system unsupported" proc)
(server-send-string proc "-window-system-unsupported \n")
nil))))
(defun server-goto-toplevel (proc)
(condition-case nil
@ -1121,9 +1126,13 @@ The following commands are accepted by the client:
tty-type (pop args-left)
dontkill (or dontkill
(not use-current-frame)))
;; On Windows, emacsclient always asks for a tty frame.
;; If running a GUI server, force the frame type to GUI.
(when (eq window-system 'w32)
;; On Windows, emacsclient always asks for a tty
;; frame. If running a GUI server, force the frame
;; type to GUI. (Cygwin is perfectly happy with
;; multi-tty support, so don't override the user's
;; choice there.)
(when (and (eq system-type 'windows-nt)
(eq window-system 'w32))
(push "-window-system" args-left)))
;; -position LINE[:COLUMN]: Set point to the given

2
lisp/simple.el
View file

@ -6872,7 +6872,7 @@ call `normal-erase-is-backspace-mode' (which see) instead."
(if (if (eq normal-erase-is-backspace 'maybe)
(and (not noninteractive)
(or (memq system-type '(ms-dos windows-nt))
(memq window-system '(ns))
(memq window-system '(w32 ns))
(and (memq window-system '(x))
(fboundp 'x-backspace-delete-keys-p)
(x-backspace-delete-keys-p))

3
lisp/startup.el
View file

@ -890,7 +890,8 @@ Amongst another things, it parses the command-line arguments."
;; Initialize the window system. (Open connection, etc.)
(funcall
(or (cdr (assq initial-window-system window-system-initialization-alist))
(error "Unsupported window system `%s'" initial-window-system))))
(error "Unsupported window system `%s'" initial-window-system)))
(put initial-window-system 'window-system-initialized t))
;; If there was an error, print the error message and exit.
(error
(princ

2
lisp/term/common-win.el
View file

@ -57,7 +57,7 @@ clipboard as well.
On Nextstep, put TEXT in the pasteboard (`x-select-enable-clipboard'
is not used)."
(cond ((eq system-type 'windows-nt)
(cond ((eq (framep (selected-frame)) 'w32)
(if x-select-enable-clipboard
(w32-set-clipboard-data text))
(setq x-last-selected-text text))

4
lisp/term/ns-win.el
View file

@ -39,7 +39,7 @@
;; this file, which works in close coordination with src/nsfns.m.
;;; Code:
(eval-when-compile (require 'cl-lib))
(or (featurep 'ns)
(error "%s: Loading ns-win.el but not compiled for GNUstep/MacOS"
(invocation-name)))
@ -909,6 +909,7 @@ See the documentation of `create-fontset-from-fontset-spec' for the format.")
;; defines functions and variables that we use now.
(defun ns-initialize-window-system ()
"Initialize Emacs for Nextstep (Cocoa / GNUstep) windowing."
(cl-assert (not ns-initialized))
;; PENDING: not needed?
(setq command-line-args (x-handle-args command-line-args))
@ -936,6 +937,7 @@ See the documentation of `create-fontset-from-fontset-spec' for the format.")
(x-apply-session-resources)
(setq ns-initialized t))
(add-to-list 'display-format-alist '("\\`ns\\'" . ns))
(add-to-list 'handle-args-function-alist '(ns . x-handle-args))
(add-to-list 'frame-creation-function-alist '(ns . x-create-frame-with-faces))
(add-to-list 'window-system-initialization-alist '(ns . ns-initialize-window-system))

49
lisp/term/w32-win.el
View file

@ -1,4 +1,4 @@
;;; w32-win.el --- parse switches controlling interface with W32 window system
;;; w32-win.el --- parse switches controlling interface with W32 window system -*- lexical-binding: t -*-
;; Copyright (C) 1993-1994, 2001-2012 Free Software Foundation, Inc.
@ -68,6 +68,7 @@
;; (if (not (eq window-system 'w32))
;; (error "%s: Loading w32-win.el but not compiled for w32" (invocation-name)))
(eval-when-compile (require 'cl-lib))
(require 'frame)
(require 'mouse)
(require 'scroll-bar)
@ -102,7 +103,22 @@
;; (interactive "e")
;; (princ event))
(defun w32-drag-n-drop (event)
(defun w32-handle-dropped-file (window file-name)
(let ((f (if (eq system-type 'cygwin)
(cygwin-convert-path-from-windows file-name t)
(subst-char-in-string ?\\ ?/ file-name)))
(coding (or file-name-coding-system
default-file-name-coding-system)))
(setq file-name
(mapconcat 'url-hexify-string
(split-string (encode-coding-string f coding)
"/")
"/")))
(dnd-handle-one-url window 'private
(concat "file:" file-name)))
(defun w32-drag-n-drop (event &optional new-frame)
"Edit the files listed in the drag-n-drop EVENT.
Switch to a buffer editing the last file dropped."
(interactive "e")
@ -116,26 +132,21 @@ Switch to a buffer editing the last file dropped."
(y (cdr coords)))
(if (and (> x 0) (> y 0))
(set-frame-selected-window nil window))
(mapc (lambda (file-name)
(let ((f (subst-char-in-string ?\\ ?/ file-name))
(coding (or file-name-coding-system
default-file-name-coding-system)))
(setq file-name
(mapconcat 'url-hexify-string
(split-string (encode-coding-string f coding)
"/")
"/")))
(dnd-handle-one-url window 'private
(concat "file:" file-name)))
(car (cdr (cdr event)))))
(raise-frame)))
(when new-frame
(select-frame (make-frame)))
(raise-frame)
(setq window (selected-window))
(mapc (apply-partially #'w32-handle-dropped-file window)
(car (cdr (cdr event)))))))
(defun w32-drag-n-drop-other-frame (event)
"Edit the files listed in the drag-n-drop EVENT, in other frames.
May create new frames, or reuse existing ones. The frame editing
the last file dropped is selected."
(interactive "e")
(mapcar 'find-file-other-frame (car (cdr (cdr event)))))
(w32-drag-n-drop event t))
;; Bind the drag-n-drop event.
(global-set-key [drag-n-drop] 'w32-drag-n-drop)
@ -230,6 +241,7 @@ See the documentation of `create-fontset-from-fontset-spec' for the format.")
(defun w32-initialize-window-system ()
"Initialize Emacs for W32 GUI frames."
(cl-assert (not w32-initialized))
;; Do the actual Windows setup here; the above code just defines
;; functions and variables that we use now.
@ -243,7 +255,7 @@ See the documentation of `create-fontset-from-fontset-spec' for the format.")
;; so as not to choke when we use it in X resource queries.
(replace-regexp-in-string "[.*]" "-" (invocation-name))))
(x-open-connection "" x-command-line-resources
(x-open-connection "w32" x-command-line-resources
;; Exit with a fatal error if this fails and we
;; are the initial display
(eq initial-window-system 'w32))
@ -294,7 +306,7 @@ See the documentation of `create-fontset-from-fontset-spec' for the format.")
(setq default-frame-alist
(cons '(reverse . t) default-frame-alist)))))
;; Don't let Emacs suspend under w32 gui
;; Don't let Emacs suspend under Windows.
(add-hook 'suspend-hook 'x-win-suspend-error)
;; Turn off window-splitting optimization; w32 is usually fast enough
@ -312,6 +324,7 @@ See the documentation of `create-fontset-from-fontset-spec' for the format.")
(x-apply-session-resources)
(setq w32-initialized t))
(add-to-list 'display-format-alist '("\\`w32\\'" . w32))
(add-to-list 'handle-args-function-alist '(w32 . x-handle-args))
(add-to-list 'frame-creation-function-alist '(w32 . x-create-frame-with-faces))
(add-to-list 'window-system-initialization-alist '(w32 . w32-initialize-window-system))

5
lisp/term/x-win.el
View file

@ -67,6 +67,8 @@
;; An alist of X options and the function which handles them. See
;; ../startup.el.
(eval-when-compile (require 'cl-lib))
(if (not (fboundp 'x-create-frame))
(error "%s: Loading x-win.el but not compiled for X" (invocation-name)))
@ -1338,6 +1340,8 @@ Request data types in the order specified by `x-select-request-type'."
(defun x-initialize-window-system ()
"Initialize Emacs for X frames and open the first connection to an X server."
(cl-assert (not x-initialized))
;; Make sure we have a valid resource name.
(or (stringp x-resource-name)
(let (i)
@ -1451,6 +1455,7 @@ Request data types in the order specified by `x-select-request-type'."
(x-apply-session-resources)
(setq x-initialized t))
(add-to-list 'display-format-alist '("\\`[^:]*:[0-9]+\\(\\.[0-9]+\\)?\\'" . x))
(add-to-list 'handle-args-function-alist '(x . x-handle-args))
(add-to-list 'frame-creation-function-alist '(x . x-create-frame-with-faces))
(add-to-list 'window-system-initialization-alist '(x . x-initialize-window-system))

130
lisp/w32-common-fns.el Normal file
View file

@ -0,0 +1,130 @@
;;; w32-common-fns.el --- Lisp routines for Windows and Cygwin-w32
;; Copyright (C) 1994, 2001-2012 Free Software Foundation, Inc.
;; This file is part of GNU Emacs.
;; GNU Emacs is free software: you can redistribute it and/or modify
;; it under the terms of the GNU General Public License as published by
;; the Free Software Foundation, either version 3 of the License, or
;; (at your option) any later version.
;; GNU Emacs is distributed in the hope that it will be useful,
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;; GNU General Public License for more details.
;; You should have received a copy of the GNU General Public License
;; along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>.
;;; Commentary:
;;;
;;; This file contains functions that are used by both native NT Emacs
;;; and Cygwin Emacs compiled to use the native Windows widget
;;; library.
(defun w32-version ()
"Return the MS-Windows version numbers.
The value is a list of three integers: the major and minor version
numbers, and the build number."
(x-server-version))
(defun w32-using-nt ()
"Return non-nil if running on a Windows NT descendant.
That includes all Windows systems except for 9X/Me."
(getenv "SystemRoot"))
(declare-function w32-get-clipboard-data "w32select.c")
(declare-function w32-set-clipboard-data "w32select.c")
(declare-function x-server-version "w32fns.c" (&optional display))
;;; Fix interface to (X-specific) mouse.el
(defun x-set-selection (type data)
"Make an X selection of type TYPE and value DATA.
The argument TYPE (nil means `PRIMARY') says which selection, and
DATA specifies the contents. TYPE must be a symbol. \(It can also
be a string, which stands for the symbol with that name, but this
is considered obsolete.) DATA may be a string, a symbol, an
integer (or a cons of two integers or list of two integers).
The selection may also be a cons of two markers pointing to the same buffer,
or an overlay. In these cases, the selection is considered to be the text
between the markers *at whatever time the selection is examined*.
Thus, editing done in the buffer after you specify the selection
can alter the effective value of the selection.
The data may also be a vector of valid non-vector selection values.
The return value is DATA.
Interactively, this command sets the primary selection. Without
prefix argument, it reads the selection in the minibuffer. With
prefix argument, it uses the text of the region as the selection value.
Note that on MS-Windows, primary and secondary selections set by Emacs
are not available to other programs."
(put 'x-selections (or type 'PRIMARY) data))
(defun x-get-selection (&optional type _data-type)
"Return the value of an X Windows selection.
The argument TYPE (default `PRIMARY') says which selection,
and the argument DATA-TYPE (default `STRING') says
how to convert the data.
TYPE may be any symbol \(but nil stands for `PRIMARY'). However,
only a few symbols are commonly used. They conventionally have
all upper-case names. The most often used ones, in addition to
`PRIMARY', are `SECONDARY' and `CLIPBOARD'.
DATA-TYPE is usually `STRING', but can also be one of the symbols
in `selection-converter-alist', which see."
(get 'x-selections (or type 'PRIMARY)))
;; x-selection-owner-p is used in simple.el
(defun x-selection-owner-p (&optional type)
(and (memq type '(nil PRIMARY SECONDARY))
(get 'x-selections (or type 'PRIMARY))))
;; The "Windows" keys on newer keyboards bring up the Start menu
;; whether you want it or not - make Emacs ignore these keystrokes
;; rather than beep.
(global-set-key [lwindow] 'ignore)
(global-set-key [rwindow] 'ignore)
(defvar w32-charset-info-alist) ; w32font.c
;;;; Selections
;; We keep track of the last text selected here, so we can check the
;; current selection against it, and avoid passing back our own text
;; from x-selection-value.
(defvar x-last-selected-text nil)
(defun x-get-selection-value ()
"Return the value of the current selection.
Consult the selection. Treat empty strings as if they were unset."
(if x-select-enable-clipboard
(let (text)
;; Don't die if x-get-selection signals an error.
(condition-case c
(setq text (w32-get-clipboard-data))
(error (message "w32-get-clipboard-data:%s" c)))
(if (string= text "") (setq text nil))
(cond
((not text) nil)
((eq text x-last-selected-text) nil)
((string= text x-last-selected-text)
;; Record the newer string, so subsequent calls can use the 'eq' test.
(setq x-last-selected-text text)
nil)
(t
(setq x-last-selected-text text))))))
(defalias 'x-selection-value 'x-get-selection-value)
;; Arrange for the kill and yank functions to set and check the clipboard.
(setq interprogram-cut-function 'x-select-text)
(setq interprogram-paste-function 'x-get-selection-value)
(provide 'w32-common-fns)

105
lisp/w32-fns.el
View file

@ -26,34 +26,20 @@
;;; Code:
(require 'w32-vars)
(require 'w32-common-fns)
(defvar explicit-shell-file-name)
;;;; Function keys
(declare-function set-message-beep "w32console.c")
(declare-function w32-get-clipboard-data "w32select.c")
(declare-function w32-get-locale-info "w32proc.c")
(declare-function w32-get-valid-locale-ids "w32proc.c")
(declare-function w32-set-clipboard-data "w32select.c")
;; Map all versions of a filename (8.3, longname, mixed case) to the
;; same buffer.
(setq find-file-visit-truename t)
(declare-function x-server-version "w32fns.c" (&optional display))
(defun w32-version ()
"Return the MS-Windows version numbers.
The value is a list of three integers: the major and minor version
numbers, and the build number."
(x-server-version))
(defun w32-using-nt ()
"Return non-nil if running on a Windows NT descendant.
That includes all Windows systems except for 9X/Me."
(and (eq system-type 'windows-nt) (getenv "SystemRoot")))
(defun w32-shell-name ()
"Return the name of the shell being used."
(or (bound-and-true-p shell-file-name)
@ -240,53 +226,6 @@ requires it (see `w32-shell-dos-semantics')."
(setq start (match-end 0))))
name)))
;;; Fix interface to (X-specific) mouse.el
(defun x-set-selection (type data)
"Make an X selection of type TYPE and value DATA.
The argument TYPE (nil means `PRIMARY') says which selection, and
DATA specifies the contents. TYPE must be a symbol. \(It can also
be a string, which stands for the symbol with that name, but this
is considered obsolete.) DATA may be a string, a symbol, an
integer (or a cons of two integers or list of two integers).
The selection may also be a cons of two markers pointing to the same buffer,
or an overlay. In these cases, the selection is considered to be the text
between the markers *at whatever time the selection is examined*.
Thus, editing done in the buffer after you specify the selection
can alter the effective value of the selection.
The data may also be a vector of valid non-vector selection values.
The return value is DATA.
Interactively, this command sets the primary selection. Without
prefix argument, it reads the selection in the minibuffer. With
prefix argument, it uses the text of the region as the selection value.
Note that on MS-Windows, primary and secondary selections set by Emacs
are not available to other programs."
(put 'x-selections (or type 'PRIMARY) data))
(defun x-get-selection (&optional type _data-type)
"Return the value of an X Windows selection.
The argument TYPE (default `PRIMARY') says which selection,
and the argument DATA-TYPE (default `STRING') says
how to convert the data.
TYPE may be any symbol \(but nil stands for `PRIMARY'). However,
only a few symbols are commonly used. They conventionally have
all upper-case names. The most often used ones, in addition to
`PRIMARY', are `SECONDARY' and `CLIPBOARD'.
DATA-TYPE is usually `STRING', but can also be one of the symbols
in `selection-converter-alist', which see."
(get 'x-selections (or type 'PRIMARY)))
;; x-selection-owner-p is used in simple.el
(defun x-selection-owner-p (&optional type)
(and (memq type '(nil PRIMARY SECONDARY))
(get 'x-selections (or type 'PRIMARY))))
(defun set-w32-system-coding-system (coding-system)
"Set the coding system used by the Windows system to CODING-SYSTEM.
This is used for things like passing font names with non-ASCII
@ -311,14 +250,6 @@ This function is provided for backward compatibility, since
;; Set to a system sound if you want a fancy bell.
(set-message-beep nil)
;; The "Windows" keys on newer keyboards bring up the Start menu
;; whether you want it or not - make Emacs ignore these keystrokes
;; rather than beep.
(global-set-key [lwindow] 'ignore)
(global-set-key [rwindow] 'ignore)
(defvar w32-charset-info-alist) ; w32font.c
(defun w32-add-charset-info (xlfd-charset windows-charset codepage)
"Function to add character sets to display with Windows fonts.
Creates entries in `w32-charset-info-alist'.
@ -379,40 +310,6 @@ bit output with no translation."
(make-obsolete-variable 'w32-charset-to-codepage-alist
'w32-charset-info-alist "21.1")
;;;; Selections
;; We keep track of the last text selected here, so we can check the
;; current selection against it, and avoid passing back our own text
;; from x-selection-value.
(defvar x-last-selected-text nil)
(defun x-get-selection-value ()
"Return the value of the current selection.
Consult the selection. Treat empty strings as if they were unset."
(if x-select-enable-clipboard
(let (text)
;; Don't die if x-get-selection signals an error.
(condition-case c
(setq text (w32-get-clipboard-data))
(error (message "w32-get-clipboard-data:%s" c)))
(if (string= text "") (setq text nil))
(cond
((not text) nil)
((eq text x-last-selected-text) nil)
((string= text x-last-selected-text)
;; Record the newer string, so subsequent calls can use the 'eq' test.
(setq x-last-selected-text text)
nil)
(t
(setq x-last-selected-text text))))))
(defalias 'x-selection-value 'x-get-selection-value)
;; Arrange for the kill and yank functions to set and check the clipboard.
(setq interprogram-cut-function 'x-select-text)
(setq interprogram-paste-function 'x-get-selection-value)
;;;; Support for build process

22
lisp/w32-vars.el
View file

@ -44,17 +44,19 @@ X does. See `w32-fixed-font-alist' for the font menu definition."
"Include proportional fonts in the default font dialog.")
(make-obsolete-variable 'w32-list-proportional-fonts "no longer used." "23.1")
(defcustom w32-allow-system-shell nil
"Disable startup warning when using \"system\" shells."
:type 'boolean
:group 'w32)
(unless (eq system-type 'cygwin)
(defcustom w32-allow-system-shell nil
"Disable startup warning when using \"system\" shells."
:type 'boolean
:group 'w32))
(defcustom w32-system-shells '("cmd" "cmd.exe" "command" "command.com"
"4nt" "4nt.exe" "4dos" "4dos.exe"
"tcc" "tcc.exe" "ndos" "ndos.exe")
"List of strings recognized as Windows system shells."
:type '(repeat string)
:group 'w32)
(unless (eq system-type 'cygwin)
(defcustom w32-system-shells '("cmd" "cmd.exe" "command" "command.com"
"4nt" "4nt.exe" "4dos" "4dos.exe"
"tcc" "tcc.exe" "ndos" "ndos.exe")
"List of strings recognized as Windows system shells."
:type '(repeat string)
:group 'w32))
;; Want "menu" custom type for this.
(defcustom w32-fixed-font-alist

138
src/ChangeLog
View file

@ -1,3 +1,141 @@
2012-10-08 Daniel Colascione <dancol@dancol.org>
* xfaces.c, xdisp.c, window.c, w32xfns.c, w32term.h, w32term.c,
w32select.h w32select.c, w32proc.c, w32menu.c, w32inevt.c,
w32help.c, w32font.c, w32font.c, w32fns.c, w32console.c, w32.h,
w32.c, unexw32.c, termhooks.h, process.c, menu.c, keyboard.h,
keyboard.c, image.c, frame.h, frame.c, fontset.c, font.h, font.c,
emacs.c, dispextern.h, cygw32.h, cygw32.c, conf_post.h,
Makefile.in: use HAVE_NTGUI for W32 GUI and WINDOWSNT for the
operating system. defined(HAVE_NTGUI) && !defined(WINDOWSNT) is
now a supported configuration.
* Makefile.in: consolidate image variables into LIBIMAGE; add
W32_OBJ and W32_LIBS. Compile new files.
* conf_post.h:
(_DebPrint) declare tracing facility for W32 debugging. We need
to unify tracing later.
(NTGUI_UNICODE) Define when compiling for Cygwin to allow the
unconditional use of W32 Unicode functions. Cygwin runs only on
100% Unicode operating systems.
* cygw32.c: New file. Define Cygwin-specific facilities.
(Fcygwin_convert_path_to_windows)
(Fcygwin_convert_path_from_windows): New user functions for
accessing Cygwin path-munging routines.
* cygw32.h: New file.
(WCSDATA, to_unicode, from_unicode): Define facilities for storing
UTF-16LE strings temporarily inside non-Lisp-visible string
objects.
(w32_strerror): Just what it says on the tin.
* emacs.c: Make the NS fork-then-exec code for daemon-launching
also run for Cygwin; both systems have the same problem with using
GUI facilities in a forked child. Also call syms_of_cygw32,
syms_of_w32select in correct places.
(DAEMON_MUST_EXEC): new macro defined to signal that a platform
needs fork-then-exec for daemon launching.
* font.h: Include frame.h.
* image.c: Use the image library cache machinery only when we're
compiling for native WINDOWSNT; Cygwin can use shared libraries
like any other Unixlike system.
* keyboard.c: Clarify a comment regarding the input loop.
* menu.c: When NTGUI_UNICODE is defined, use Unicode menu
functions directly instead of trying to detect at runtime that our
host operating system supports them. We make this change for two
reasons: Cygwin lacks support for the multibyte character
conversion functions used by the legacy menu code, and Cygwin
never needs to rely on non-Unicode APIs.
* unexw32.c (hinst): Declare extern.
* w32.c: Change header order;
(w32_strerror): Move to w32fns.c because we need it for
non-WINDOWSNT builds.
* w32.h: Add #error macro to make sure we don't include w32.h for
Cygwin builds. Remove w32select declarations.
* w32console.c (w32_sys_ring_bell, Fset_message_beep): Move to
w32fns.c. w32console.c is WINDOWSNT-only.
* w32fns.c: Include cygw32.h or w32.h depending on CYGWIN; more
NTGUI_UNICODE tweaks. (See above.) Change _snprintf to the more
POSIXy alternative.
(faked_key, sysinfo_cache, osinfo_cahce, syspage_mask)
(w32_major_version, w32_minor_version, w32_build_number)
(os_subtype, sound_type): Define here
(w32_defined_color): Make color parameter const for consistency
with other _defined_color functions.
(w32_createwindow): Unconditionally call w32_init_class instead of
doing so only when hprevinst is non-NULL. Plumbing hprevinst
through the code is complex and unnecessary because class
registration is practically free.
(w32_name_of_message): New EMACSDEBUG-only function.
(Fset_message_beep): Move here
(Fx_open_connection): Require that the display name for Windows be
"w32" for consistency, emacsclient disambiguation, and maybe, one
day, multi-window-system support.
(file_dialog_callback): NTGUI_UNICODE changes; encode and decode
Cygwin files for W32 GUI facilities, since these clearly don't
expect Cygwin names.
(_DebPrint): Define.
(w32_strerror, w32_console_toggle_lock_key, w32_kbd_mods_to_emacs)
(w32_kbd_patch_key, w32_sys_ring_bell): Move here.
(Ssystem_move_file_to_trash): Define only for native WINDOWSNT.
(w32_last_error): Remove.
* w32font.c: Define _strlwr to strlwr for non-WINDOWSNT builds.
* w32heap.c (syspage_mask): Declare here.
(cache_system_info): Remove.
* w32inevt.c (faked_key): Define globally, not statically.
(w32_kbd_mods_to_emacs, w32_kbd_patch_key, faked_key)
(w32_console_toggle_lock_key): Move to w32fns.c.
* w32menu.c: Include setjmp.h. NTGUI_UNICODE changes throughout.
* w32proc.c (_DebPrint): Move to w32fns.c.
* w32select.c: Include string.h, stdio.h for Cygwin.
* w32select.h: New File.
* w32term.c: Include io.h for non-CYGWIN builds; needed for
get_osfhandle.
(w32_message_fd): New variable. Under Cygwin, holds the file
descriptor the system used to tell us about pending thread
messages.
(w32_init_term): Remove incorrect calls to fcntl and init_sigio
that prevented compilation under non-WINDOWSNT systems.
(w32_initialize): Open /dev/windows and assign it to
w32_message_fd. Provide w32 feature.
* w32term.h: Include frame.h, atimer.h. Declare various frame functions.
(WM_EMACS_INPUT_READY): add.
(prepend_msg, w32_message_fd): Declare globally.
* w32xfns.c:
(keyboard_handle): Use only when WINDOWSNT.
(notify_msg_ready): New function. Posts a message to the main
thread's message queue under CYGWIN, which wakes up the main
thread from select(2) by making the /dev/windows file descriptor
ready. Under WINDOWSNT, it sets an event the same way the old
code did.
(post, prepend_msg): Actually call notify_msg_ready instead of
setting the input event directly.
2012-10-07 Eli Zaretskii <eliz@gnu.org>
* ralloc.c (relinquish): If a heap is ready to be relinquished,

30
src/Makefile.in
View file

@ -135,13 +135,10 @@ LIB_MATH=@LIB_MATH@
## -lpthreads, or empty.
LIB_PTHREAD=@LIB_PTHREAD@
LIBTIFF=@LIBTIFF@
LIBJPEG=@LIBJPEG@
LIBPNG=@LIBPNG@
LIBGIF=@LIBGIF@
LIBXPM=@LIBXPM@
LIBIMAGE=@LIBTIFF@ @LIBJPEG@ @LIBPNG@ @LIBGIF@ @LIBXPM@
XFT_LIBS=@XFT_LIBS@
LIBX_EXTRA=$(LIBTIFF) $(LIBJPEG) $(LIBPNG) $(LIBGIF) $(LIBXPM) -lX11 $(XFT_LIBS)
LIBX_EXTRA=-lX11 $(XFT_LIBS)
FONTCONFIG_CFLAGS = @FONTCONFIG_CFLAGS@
FONTCONFIG_LIBS = @FONTCONFIG_LIBS@
@ -261,6 +258,13 @@ NS_OBJ=@NS_OBJ@
NS_OBJC_OBJ=@NS_OBJC_OBJ@
## Only set if NS_IMPL_GNUSTEP.
GNU_OBJC_CFLAGS=@GNU_OBJC_CFLAGS@
## w32fns.o w32menu.c w32reg.o fringe.o fontset.o w32font.o w32term.o
## w32xfns.o w32select.o image.o w32uniscribe.o if HAVE_W32, else
## empty.
W32_OBJ=@W32_OBJ@
## -lkernel32 -luser32 -lgdi32 -lole32 -lcomdlg32 lusp10 -lcomctl32
## --lwinspool if HAVE_W32, else empty.
W32_LIBS=@W32_LIBS@
## Empty if !HAVE_X_WINDOWS
## xfont.o ftfont.o xftfont.o ftxfont.o if HAVE_XFT
@ -342,7 +346,7 @@ base_obj = dispnew.o frame.o scroll.o xdisp.o menu.o $(XMENU_OBJ) window.o \
doprnt.o intervals.o textprop.o composite.o xml.o \
profiler.o \
$(MSDOS_OBJ) $(MSDOS_X_OBJ) $(NS_OBJ) $(CYGWIN_OBJ) $(FONT_OBJ) \
$(WINDOW_SYSTEM_OBJ)
$(W32_OBJ) $(WINDOW_SYSTEM_OBJ)
obj = $(base_obj) $(NS_OBJC_OBJ)
## Object files used on some machine or other.
@ -351,9 +355,9 @@ obj = $(base_obj) $(NS_OBJC_OBJ)
## in the list, in case they ever add any such entries.
SOME_MACHINE_OBJECTS = dosfns.o msdos.o \
xterm.o xfns.o xmenu.o xselect.o xrdb.o xsmfns.o fringe.o image.o \
fontset.o dbusbind.o \
fontset.o dbusbind.o cygw32.o \
nsterm.o nsfns.o nsmenu.o nsselect.o nsimage.o nsfont.o \
w32.o w32console.o w32fns.o w32heap.o w32inevt.o \
w32.o w32console.o w32fns.o w32heap.o \
w32menu.o w32proc.o w32reg.o w32select.o w32term.o w32xfns.o \
w16select.o widget.o xfont.o ftfont.o xftfont.o ftxfont.o gtkutil.o \
xsettings.o xgselect.o termcap.o
@ -385,9 +389,11 @@ otherobj= $(TERMCAP_OBJ) $(PRE_ALLOC_OBJ) $(GMALLOC_OBJ) $(RALLOC_OBJ) \
## Note that SunOS needs -lm to come before -lc; otherwise, you get
## duplicated symbols. If the standard libraries were compiled
## with GCC, we might need LIB_GCC again after them.
LIBES = $(LIBS) $(LIBX_BASE) $(LIBX_OTHER) $(LIBSOUND) \
$(RSVG_LIBS) $(IMAGEMAGICK_LIBS) $(LIB_CLOCK_GETTIME) $(LIB_TIMER_TIME) \
$(DBUS_LIBS) $(LIB_EXECINFO) \
LIBES = $(LIBS) $(W32_LIBS) $(LIBX_BASE) $(LIBIMAGE) \
$(LIBX_OTHER) $(LIBSOUND) \
$(RSVG_LIBS) $(IMAGEMAGICK_LIBS) $(LIB_CLOCK_GETTIME) \
$(LIB_TIMER_TIME) $(DBUS_LIBS) \
$(LIB_EXECINFO) \
$(LIBXML2_LIBS) $(LIBGPM) $(LIBRESOLV) $(LIBS_SYSTEM) \
$(LIBS_TERMCAP) $(GETLOADAVG_LIBS) $(SETTINGS_LIBS) $(LIBSELINUX_LIBS) \
$(FREETYPE_LIBS) $(FONTCONFIG_LIBS) $(LIBOTF_LIBS) $(M17N_FLT_LIBS) \

14
src/conf_post.h
View file

@ -142,6 +142,20 @@ You lose; /* Emacs for DOS must be compiled with DJGPP */
#endif
#endif
#if defined(HAVE_NTGUI) && !defined(DebPrint)
# if defined(EMACSDEBUG)
extern void _DebPrint (const char *fmt, ...);
# define DebPrint(stuff) _DebPrint stuff
# else
# define DebPrint(stuff)
# endif /* EMACSDEBUG */
#endif /* DebPrint */
#if defined(CYGWIN) && defined(HAVE_NTGUI)
#define NTGUI_UNICODE /* Cygwin runs only on UNICODE-supporting systems */
#define _WIN32_WINNT 0x500 /* Win2k */
#endif /* CYGWIN && HAVE_NTGUI */
#ifdef emacs /* Don't do this for lib-src. */
/* Tell regex.c to use a type compatible with Emacs. */
#define RE_TRANSLATE_TYPE Lisp_Object

169
src/cygw32.c Normal file
View file

@ -0,0 +1,169 @@
/* Cygwin support routines.
Copyright (C) 2011 Free Software Foundation, Inc.
This file is part of GNU Emacs.
GNU Emacs is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
GNU Emacs is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
#include "cygw32.h"
#include "character.h"
#include "buffer.h"
#include <unistd.h>
#include <fcntl.h>
static Lisp_Object Qutf_16_le;
static Lisp_Object
fchdir_unwind (Lisp_Object dir_fd)
{
(void) fchdir (XFASTINT (dir_fd));
(void) close (XFASTINT (dir_fd));
return Qnil;
}
static void
chdir_to_default_directory ()
{
Lisp_Object new_cwd;
int old_cwd_fd = open (".", O_RDONLY | O_DIRECTORY);
if (old_cwd_fd == -1)
error ("could not open current directory: %s", strerror (errno));
record_unwind_protect (fchdir_unwind, make_number (old_cwd_fd));
new_cwd = Funhandled_file_name_directory (
Fexpand_file_name (build_string ("."), Qnil));
if (!STRINGP (new_cwd))
new_cwd = build_string ("/");
if (chdir (SDATA (ENCODE_FILE (new_cwd))))
error ("could not chdir: %s", strerror (errno));
}
static Lisp_Object
conv_filename_to_w32_unicode (Lisp_Object in, int absolute_p)
{
ssize_t converted_len;
Lisp_Object converted;
unsigned flags;
int count = SPECPDL_INDEX ();
chdir_to_default_directory ();
flags = CCP_POSIX_TO_WIN_W;
if (!absolute_p) {
flags |= CCP_RELATIVE;
}
in = ENCODE_FILE (in);
converted_len = cygwin_conv_path (flags, SDATA (in), NULL, 0);
if (converted_len < 2)
error ("cygwin_conv_path: %s", strerror (errno));
converted = make_uninit_string (converted_len - 1);
if (cygwin_conv_path (flags, SDATA (in),
SDATA (converted), converted_len))
error ("cygwin_conv_path: %s", strerror (errno));
return unbind_to (count, converted);
}
static Lisp_Object
conv_filename_from_w32_unicode (const wchar_t* in, int absolute_p)
{
ssize_t converted_len;
Lisp_Object converted;
unsigned flags;
int count = SPECPDL_INDEX ();
chdir_to_default_directory ();
flags = CCP_WIN_W_TO_POSIX;
if (!absolute_p) {
flags |= CCP_RELATIVE;
}
converted_len = cygwin_conv_path (flags, in, NULL, 0);
if (converted_len < 1)
error ("cygwin_conv_path: %s", strerror (errno));
converted = make_uninit_string (converted_len - 1 /*subtract terminator*/);
if (cygwin_conv_path (flags, in, SDATA (converted), converted_len))
error ("cygwin_conv_path: %s", strerror (errno));
return unbind_to (count, DECODE_FILE (converted));
}
Lisp_Object
from_unicode (Lisp_Object str)
{
CHECK_STRING (str);
if (!STRING_MULTIBYTE (str) &&
SBYTES (str) & 1)
{
str = Fsubstring (str, make_number (0), make_number (-1));
}
return code_convert_string_norecord (str, Qutf_16_le, 0);
}
wchar_t *
to_unicode (Lisp_Object str, Lisp_Object *buf)
{
*buf = code_convert_string_norecord (str, Qutf_16_le, 1);
/* We need to make a another copy (in addition to the one made by
code_convert_string_norecord) to ensure that the final string is
_doubly_ zero terminated --- that is, that the string is
terminated by two zero bytes and one utf-16le null character.
Because strings are already terminated with a single zero byte,
we just add one additional zero. */
str = make_uninit_string (SBYTES (*buf) + 1);
memcpy (SDATA (str), SDATA (*buf), SBYTES (*buf));
SDATA (str) [SBYTES (*buf)] = '\0';
*buf = str;
return WCSDATA (*buf);
}
DEFUN ("cygwin-convert-path-to-windows",
Fcygwin_convert_path_to_windows, Scygwin_convert_path_to_windows,
1, 2, 0,
doc: /* Convert PATH to a Windows path. If ABSOLUTE-P if
non-nil, return an absolute path.*/)
(Lisp_Object path, Lisp_Object absolute_p)
{
return from_unicode (
conv_filename_to_w32_unicode (path, absolute_p == Qnil ? 0 : 1));
}
DEFUN ("cygwin-convert-path-from-windows",
Fcygwin_convert_path_from_windows, Scygwin_convert_path_from_windows,
1, 2, 0,
doc: /* Convert a Windows path to a Cygwin path. If ABSOLUTE-P
if non-nil, return an absolute path.*/)
(Lisp_Object path, Lisp_Object absolute_p)
{
return conv_filename_from_w32_unicode (to_unicode (path, &path),
absolute_p == Qnil ? 0 : 1);
}
void
syms_of_cygw32 (void)
{
/* No, not utf-16-le: that one has a BOM. */
DEFSYM (Qutf_16_le, "utf-16le");
defsubr (&Scygwin_convert_path_from_windows);
defsubr (&Scygwin_convert_path_to_windows);
}

59
src/cygw32.h Normal file
View file

@ -0,0 +1,59 @@
/* Header for Cygwin support routines.
Copyright (C) 2011 Free Software Foundation, Inc.
This file is part of GNU Emacs.
GNU Emacs is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
GNU Emacs is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
#ifndef CYGW32_H
#define CYGW32_H
#include <config.h>
#include <windef.h>
#include <sys/cygwin.h>
#include <wchar.h>
#include <signal.h>
#include <stdio.h>
#include <limits.h>
#include <errno.h>
#include <math.h>
#include <setjmp.h>
#include "lisp.h"
#include "coding.h"
/* *** Character conversion *** */
/* Access the wide-character string stored in a Lisp string object. */
#define WCSDATA(x) ((wchar_t *) SDATA (x))
/* Convert the Emacs string in STR to UTF-16LE and store a new string
containing the encoded version of STR into *BUF. BUF may safely
point to STR on entry. */
extern wchar_t *to_unicode (Lisp_Object str, Lisp_Object *buf);
/* Convert STR, a UTF-16LE encoded string embedded in an Emacs string
object, to a normal Emacs string and return it. */
extern Lisp_Object from_unicode (Lisp_Object str);
/* *** Path conversion. *** */
EXFUN (Fcygwin_convert_path_to_windows, 2);
EXFUN (Fcygwin_convert_path_from_windows, 2);
/* *** Misc *** */
extern void syms_of_cygw32 (void);
extern char * w32_strerror (int error_no);
#endif /* CYGW32_H */

4
src/dispextern.h
View file

@ -3144,7 +3144,7 @@ int draw_window_fringes (struct window *, int);
int update_window_fringes (struct window *, int);
void compute_fringe_widths (struct frame *, int);
#ifdef WINDOWSNT
#ifdef HAVE_NTGUI
void w32_init_fringe (struct redisplay_interface *);
void w32_reset_fringes (void);
#endif
@ -3247,7 +3247,7 @@ extern char unspecified_fg[], unspecified_bg[];
#ifdef HAVE_X_WINDOWS
void gamma_correct (struct frame *, XColor *);
#endif
#ifdef WINDOWSNT
#ifdef HAVE_NTGUI
void gamma_correct (struct frame *, COLORREF *);
#endif

66
src/emacs.c
View file

@ -33,9 +33,20 @@ along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
#ifdef WINDOWSNT
#include <fcntl.h>
#include <windows.h> /* just for w32.h */
#include "w32.h"
#include "w32heap.h" /* for prototype of sbrk */
#endif
#if defined (WINDOWSNT)
#include "w32heap.h"
#endif
#if defined (WINDOWSNT) || defined (HAVE_NTGUI)
#include "w32select.h"
#include "w32font.h"
#endif
#if defined (HAVE_NTGUI) && defined (CYGWIN)
#include "cygw32.h"
#endif
#ifdef HAVE_WINDOW_SYSTEM
@ -156,6 +167,22 @@ static void *my_heap_start;
static uprintmax_t heap_bss_diff;
#endif
/* To run as a daemon under Cocoa or Windows, we must do a fork+exec,
not a simple fork.
On Cocoa, CoreFoundation lib fails in forked process:
http://developer.apple.com/ReleaseNotes/
CoreFoundation/CoreFoundation.html)
On Windows, a Cygwin fork child cannot access the USER subsystem.
We mark being in the exec'd process by a daemon name argument of
form "--daemon=\nFD0,FD1\nNAME" where FD are the pipe file descriptors,
NAME is the original daemon name, if any. */
#if defined (NS_IMPL_COCOA) || defined (HAVE_NTGUI)
# define DAEMON_MUST_EXEC
#endif
/* True means running Emacs without interactive terminal. */
bool noninteractive;
@ -669,9 +696,9 @@ main (int argc, char **argv)
bool no_loadup = 0;
char *junk = 0;
char *dname_arg = 0;
#ifdef NS_IMPL_COCOA
#ifdef DAEMON_MUST_EXEC
char dname_arg2[80];
#endif
#endif /* DAEMON_MUST_EXEC */
char *ch_to_dir;
#if GC_MARK_STACK
@ -964,25 +991,19 @@ main (int argc, char **argv)
exit (1);
}
#ifndef NS_IMPL_COCOA
#ifndef DAEMON_MUST_EXEC
#ifdef USE_GTK
fprintf (stderr, "\nWarning: due to a long standing Gtk+ bug\nhttp://bugzilla.gnome.org/show_bug.cgi?id=85715\n\
Emacs might crash when run in daemon mode and the X11 connection is unexpectedly lost.\n\
Using an Emacs configured with --with-x-toolkit=lucid does not have this problem.\n");
#endif
#endif /* USE_GTK */
f = fork ();
#else /* NS_IMPL_COCOA */
/* Under Cocoa we must do fork+exec as CoreFoundation lib fails in
forked process: http://developer.apple.com/ReleaseNotes/
CoreFoundation/CoreFoundation.html)
We mark being in the exec'd process by a daemon name argument of
form "--daemon=\nFD0,FD1\nNAME" where FD are the pipe file descriptors,
NAME is the original daemon name, if any. */
#else /* DAEMON_MUST_EXEC */
if (!dname_arg || !strchr (dname_arg, '\n'))
f = fork (); /* in orig */
else
f = 0; /* in exec'd */
#endif /* NS_IMPL_COCOA */
#endif /* !DAEMON_MUST_EXEC */
if (f > 0)
{
int retval;
@ -1018,7 +1039,7 @@ Using an Emacs configured with --with-x-toolkit=lucid does not have this problem
exit (1);
}
#ifdef NS_IMPL_COCOA
#ifdef DAEMON_MUST_EXEC
{
/* In orig process, forked as child, OR in exec'd. */
if (!dname_arg || !strchr (dname_arg, '\n'))
@ -1054,7 +1075,7 @@ Using an Emacs configured with --with-x-toolkit=lucid does not have this problem
dname_arg2);
dname_arg = *dname_arg2 ? dname_arg2 : NULL;
}
#endif /* NS_IMPL_COCOA */
#endif /* DAEMON_MUST_EXEC */
if (dname_arg)
daemon_name = xstrdup (dname_arg);
@ -1357,6 +1378,9 @@ Using an Emacs configured with --with-x-toolkit=lucid does not have this problem
#ifdef WINDOWSNT
syms_of_ntproc ();
#endif /* WINDOWSNT */
#if defined (CYGWIN) && defined (HAVE_NTGUI)
syms_of_cygw32 ();
#endif /* defined(CYGWIN) && defined (HAVE_NTGUI) */
syms_of_window ();
syms_of_xdisp ();
syms_of_font ();
@ -1387,11 +1411,14 @@ Using an Emacs configured with --with-x-toolkit=lucid does not have this problem
#ifdef HAVE_NTGUI
syms_of_w32term ();
syms_of_w32fns ();
syms_of_w32select ();
syms_of_w32menu ();
syms_of_fontset ();
#endif /* HAVE_NTGUI */
#ifdef HAVE_W32SELECT
syms_of_w32select ();
#endif /* HAVE_W32SELECT */
#ifdef MSDOS
syms_of_xmenu ();
syms_of_dosfns ();
@ -1436,8 +1463,11 @@ Using an Emacs configured with --with-x-toolkit=lucid does not have this problem
globals_of_w32font ();
globals_of_w32fns ();
globals_of_w32menu ();
globals_of_w32select ();
#endif /* HAVE_NTGUI */
#ifdef HAVE_W32SELECT
globals_of_w32select ();
#endif /* HAVE_W32SELECT */
}
init_charset ();

4
src/font.c
View file

@ -5208,9 +5208,9 @@ EMACS_FONT_LOG is set. Otherwise, it is set to t. */);
#ifdef HAVE_BDFFONT
syms_of_bdffont ();
#endif /* HAVE_BDFFONT */
#ifdef WINDOWSNT
#ifdef HAVE_NTGUI
syms_of_w32font ();
#endif /* WINDOWSNT */
#endif /* HAVE_NTGUI */
#ifdef HAVE_NS
syms_of_nsfont ();
#endif /* HAVE_NS */

5
src/font.h
View file

@ -23,6 +23,7 @@ along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
#define EMACS_FONT_H
#include "ccl.h"
#include "frame.h"
/* We have three types of Lisp objects related to font.
@ -818,11 +819,11 @@ extern struct font_driver ftxfont_driver;
extern void syms_of_bdffont (void);
#endif /* HAVE_BDFFONT */
#endif /* HAVE_X_WINDOWS */
#ifdef WINDOWSNT
#ifdef HAVE_NTGUI
extern struct font_driver w32font_driver;
extern struct font_driver uniscribe_font_driver;
extern void syms_of_w32font (void);
#endif /* WINDOWSNT */
#endif /* HAVE_NTGUI */
#ifdef HAVE_NS
extern Lisp_Object Qfontsize;
extern struct font_driver nsfont_driver;

2
src/fontset.c
View file

@ -42,7 +42,7 @@ along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
#ifdef HAVE_X_WINDOWS
#include "xterm.h"
#endif
#ifdef WINDOWSNT
#ifdef HAVE_NTGUI
#include "w32term.h"
#endif
#ifdef HAVE_NS

4
src/frame.c
View file

@ -2697,7 +2697,7 @@ static const struct frame_parm_table frame_parms[] =
{"tool-bar-position", &Qtool_bar_position},
};
#ifdef WINDOWSNT
#ifdef HAVE_NTGUI
/* Calculate fullscreen size. Return in *TOP_POS and *LEFT_POS the
wanted positions of the WM window (not Emacs window).
@ -2741,7 +2741,7 @@ x_fullscreen_adjust (struct frame *f, int *width, int *height, int *top_pos, int
*height = newheight;
}
#endif /* WINDOWSNT */
#endif /* HAVE_NTGUI */
#ifdef HAVE_WINDOW_SYSTEM

5
src/frame.h
View file

@ -618,7 +618,7 @@ typedef struct frame *FRAME_PTR;
#define FRAME_INITIAL_P(f) ((f)->output_method == output_initial)
#define FRAME_TERMCAP_P(f) ((f)->output_method == output_termcap)
#define FRAME_X_P(f) ((f)->output_method == output_x_window)
#ifndef WINDOWSNT
#ifndef HAVE_NTGUI
#define FRAME_W32_P(f) (0)
#else
#define FRAME_W32_P(f) ((f)->output_method == output_w32)
@ -1210,7 +1210,7 @@ extern Lisp_Object x_new_font (struct frame *, Lisp_Object, int);
extern Lisp_Object Qface_set_after_frame_default;
#ifdef WINDOWSNT
#ifdef HAVE_NTGUI
extern void x_fullscreen_adjust (struct frame *f, int *, int *,
int *, int *);
#endif
@ -1282,6 +1282,7 @@ extern char *x_get_resource_string (const char *, const char *);
#endif
extern void x_query_colors (struct frame *f, XColor *, int);
extern void x_query_color (struct frame *f, XColor *);
#endif /* HAVE_WINDOW_SYSTEM */

76
src/image.c
View file

@ -75,7 +75,11 @@ typedef struct x_bitmap_record Bitmap_Record;
#endif /* HAVE_X_WINDOWS */
#ifdef HAVE_NTGUI
#include "w32.h"
# ifdef WINDOWSNT
/* We only need (or want) w32.h when we're _not_
* compiling for Cygwin */
# include "w32.h"
# endif /* WINDOWSNT */
/* W32_TODO : Color tables on W32. */
#undef COLOR_TABLE_SUPPORT
@ -560,13 +564,14 @@ static struct image_type *lookup_image_type (Lisp_Object);
static void x_laplace (struct frame *, struct image *);
static void x_emboss (struct frame *, struct image *);
static void x_build_heuristic_mask (struct frame *, struct image *,
Lisp_Object);
#ifdef HAVE_NTGUI
Lisp_Object);
#ifdef WINDOWSNT
extern Lisp_Object Vlibrary_cache;
#define CACHE_IMAGE_TYPE(type, status) \
do { Vlibrary_cache = Fcons (Fcons (type, status), Vlibrary_cache); } while (0)
#else
#define CACHE_IMAGE_TYPE(type, status)
#endif
#endif /* WINDOWSNT */
#define ADD_IMAGE_TYPE(type) \
do { Vimage_types = Fcons (type, Vimage_types); } while (0)
@ -589,7 +594,7 @@ define_image_type (struct image_type *type)
if (type->init)
{
#ifdef HAVE_NTGUI
#if defined (HAVE_NTGUI) && defined (WINDOWSNT)
/* If we failed to load the library before, don't try again. */
Lisp_Object tested = Fassq (target_type, Vlibrary_cache);
if (CONSP (tested) && NILP (XCDR (tested)))
@ -1834,7 +1839,7 @@ mark_image_cache (struct image_cache *c)
X / NS / W32 support code
***********************************************************************/
#ifdef HAVE_NTGUI
#ifdef WINDOWSNT
/* Macro for defining functions that will be loaded from image DLLs. */
#define DEF_IMGLIB_FN(rettype,func,args) static rettype (FAR CDECL *fn_##func)args
@ -1845,7 +1850,7 @@ mark_image_cache (struct image_cache *c)
if (!fn_##func) return 0; \
}
#endif /* HAVE_NTGUI */
#endif /* WINDOWSNT */
/* Return true if XIMG's size WIDTH x HEIGHT doesn't break the
windowing system.
@ -2897,7 +2902,7 @@ xbm_load (struct frame *f, struct image *img)
else
bits = (char *) XBOOL_VECTOR (data)->data;
#ifdef WINDOWSNT
#ifdef HAVE_NTGUI
{
char *invertedBits;
int nbytes, i;
@ -3008,7 +3013,7 @@ static const struct image_keyword xpm_format[XPM_LAST] =
{":background", IMAGE_STRING_OR_NIL_VALUE, 0}
};
#ifdef HAVE_NTGUI
#if defined(HAVE_NTGUI) && defined(WINDOWSNT)
static bool init_xpm_functions (void);
#else
#define init_xpm_functions NULL
@ -3207,7 +3212,7 @@ xpm_free_colors (Display *dpy, Colormap cmap, Pixel *pixels, int npixels, void *
#endif /* ALLOC_XPM_COLORS */
#ifdef HAVE_NTGUI
#ifdef WINDOWSNT
/* XPM library details. */
@ -3233,8 +3238,15 @@ init_xpm_functions (void)
return 1;
}
#endif /* HAVE_NTGUI */
#endif /* WINDOWSNT */
#ifdef HAVE_NTGUI
/* Glue for code below */
#define fn_XpmReadFileToImage XpmReadFileToImage
#define fn_XpmCreateImageFromBuffer XpmCreateImageFromBuffer
#define fn_XImageFree XImageFree
#define fn_XpmFreeAttributes XpmFreeAttributes
#endif /* HAVE_NTGUI */
/* Value is true if COLOR_SYMBOLS is a valid color symbols list
for XPM images. Such a list must consist of conses whose car and
@ -5340,7 +5352,7 @@ static const struct image_keyword png_format[PNG_LAST] =
{":background", IMAGE_STRING_OR_NIL_VALUE, 0}
};
#ifdef HAVE_NTGUI
#if defined(HAVE_NTGUI) && defined (WINDOWSNT)
static bool init_png_functions (void);
#else
#define init_png_functions NULL
@ -5378,7 +5390,7 @@ png_image_p (Lisp_Object object)
#ifdef HAVE_PNG
#ifdef HAVE_NTGUI
#ifdef WINDOWSNT
/* PNG library details. */
DEF_IMGLIB_FN (png_voidp, png_get_io_ptr, (png_structp));
@ -5478,7 +5490,7 @@ init_png_functions (void)
#define fn_png_set_longjmp_fn png_set_longjmp_fn
#endif /* libpng version >= 1.5 */
#endif /* HAVE_NTGUI */
#endif /* WINDOWSNT */
/* Possibly inefficient/inexact substitutes for _setjmp and _longjmp.
Do not use sys_setjmp, as PNG supports only jmp_buf. The _longjmp
@ -5999,7 +6011,7 @@ static const struct image_keyword jpeg_format[JPEG_LAST] =
{":background", IMAGE_STRING_OR_NIL_VALUE, 0}
};
#ifdef HAVE_NTGUI
#if defined(HAVE_NTGUI) && defined(WINDOWSNT)
static bool init_jpeg_functions (void);
#else
#define init_jpeg_functions NULL
@ -6049,14 +6061,20 @@ jpeg_image_p (Lisp_Object object)
#define __WIN32__ 1
#endif
/* Work around conflict between jpeg boolean and rpcndr.h
under Windows. */
#define boolean jpeg_boolean
#include <jpeglib.h>
#include <jerror.h>
/* Don't undefine boolean --- use the JPEG boolean
through the rest of the file. */
#ifdef HAVE_STLIB_H_1
#define HAVE_STDLIB_H 1
#endif
#ifdef HAVE_NTGUI
#ifdef WINDOWSNT
/* JPEG library details. */
DEF_IMGLIB_FN (void, jpeg_CreateDecompress, (j_decompress_ptr, int, size_t));
@ -6106,7 +6124,7 @@ jpeg_resync_to_restart_wrapper (j_decompress_ptr cinfo, int desired)
#define fn_jpeg_std_error jpeg_std_error
#define jpeg_resync_to_restart_wrapper jpeg_resync_to_restart
#endif /* HAVE_NTGUI */
#endif /* WINDOWSNT */
struct my_jpeg_error_mgr
{
@ -6630,7 +6648,7 @@ tiff_image_p (Lisp_Object object)
#include <tiffio.h>
#ifdef HAVE_NTGUI
#ifdef WINDOWSNT
/* TIFF library details. */
DEF_IMGLIB_FN (TIFFErrorHandler, TIFFSetErrorHandler, (TIFFErrorHandler));
@ -6674,7 +6692,7 @@ init_tiff_functions (void)
#define fn_TIFFReadRGBAImage TIFFReadRGBAImage
#define fn_TIFFClose TIFFClose
#define fn_TIFFSetDirectory TIFFSetDirectory
#endif /* HAVE_NTGUI */
#endif /* WINDOWSNT */
/* Reading from a memory buffer for TIFF images Based on the PNG
@ -7046,7 +7064,7 @@ static const struct image_keyword gif_format[GIF_LAST] =
{":background", IMAGE_STRING_OR_NIL_VALUE, 0}
};
#ifdef HAVE_NTGUI
#if defined(HAVE_NTGUI) && defined(WINDOWSNT)
static bool init_gif_functions (void);
#else
#define init_gif_functions NULL
@ -7110,7 +7128,7 @@ gif_image_p (Lisp_Object object)
#endif /* HAVE_NTGUI */
#ifdef HAVE_NTGUI
#ifdef WINDOWSNT
/* GIF library details. */
DEF_IMGLIB_FN (int, DGifCloseFile, (GifFileType *));
@ -7140,7 +7158,7 @@ init_gif_functions (void)
#define fn_DGifOpen DGifOpen
#define fn_DGifOpenFileName DGifOpenFileName
#endif /* HAVE_NTGUI */
#endif /* WINDOWSNT */
/* Reading a GIF image from memory
Based on the PNG memory stuff to a certain extent. */
@ -8137,7 +8155,7 @@ svg_image_p (Lisp_Object object)
#include <librsvg/rsvg.h>
#ifdef HAVE_NTGUI
#ifdef WINDOWSNT
/* SVG library functions. */
DEF_IMGLIB_FN (RsvgHandle *, rsvg_handle_new);
@ -8215,7 +8233,7 @@ init_svg_functions (void)
#define fn_g_type_init g_type_init
#define fn_g_object_unref g_object_unref
#define fn_g_error_free g_error_free
#endif /* !HAVE_NTGUI */
#endif /* !WINDOWSNT */
/* Load SVG image IMG for use on frame F. Value is true if
successful. */
@ -8763,6 +8781,16 @@ DEFUN ("lookup-image", Flookup_image, Slookup_image, 1, 1, 0, "")
Initialization
***********************************************************************/
#ifdef WINDOWSNT
/* Image types that rely on external libraries are loaded dynamically
if the library is available. */
#define CHECK_LIB_AVAILABLE(image_type, init_lib_fn, libraries) \
define_image_type (image_type, init_lib_fn (libraries))
#else
#define CHECK_LIB_AVAILABLE(image_type, init_lib_fn, libraries) \
define_image_type (image_type, 1)
#endif /* WINDOWSNT */
DEFUN ("init-image-library", Finit_image_library, Sinit_image_library, 1, 1, 0,
doc: /* Initialize image library implementing image type TYPE.
Return non-nil if TYPE is a supported image type.

12
src/keyboard.c
View file

@ -313,7 +313,7 @@ static Lisp_Object Qmouse_fixup_help_message;
/* Symbols to denote kinds of events. */
static Lisp_Object Qfunction_key;
Lisp_Object Qmouse_click;
#if defined (WINDOWSNT)
#if defined (HAVE_NTGUI)
Lisp_Object Qlanguage_change;
#endif
static Lisp_Object Qdrag_n_drop;
@ -3766,8 +3766,8 @@ kbd_buffer_get_event (KBOARD **kbp,
#ifdef subprocesses
if (kbd_on_hold_p () && kbd_buffer_nr_stored () < KBD_BUFFER_SIZE/4)
{
/* Start reading input again, we have processed enough so we can
accept new events again. */
/* Start reading input again because we have processed enough to
be able to accept new events again. */
unhold_keyboard_input ();
start_polling ();
}
@ -3947,7 +3947,7 @@ kbd_buffer_get_event (KBOARD **kbp,
x_activate_menubar (XFRAME (event->frame_or_window));
}
#endif
#if defined (WINDOWSNT)
#if defined (HAVE_NTGUI)
else if (event->kind == LANGUAGE_CHANGE_EVENT)
{
/* Make an event (language-change (FRAME CODEPAGE LANGUAGE-ID)). */
@ -5417,7 +5417,7 @@ make_lispy_event (struct input_event *event)
(sizeof (lispy_function_keys)
/ sizeof (lispy_function_keys[0])));
#ifdef WINDOWSNT
#ifdef HAVE_NTGUI
case MULTIMEDIA_KEY_EVENT:
if (event->code < (sizeof (lispy_multimedia_keys)
/ sizeof (lispy_multimedia_keys[0]))
@ -11394,7 +11394,7 @@ syms_of_keyboard (void)
DEFSYM (Qconfig_changed_event, "config-changed-event");
DEFSYM (Qmenu_enable, "menu-enable");
#if defined (WINDOWSNT)
#if defined (HAVE_NTGUI)
DEFSYM (Qlanguage_change, "language-change");
#endif

2
src/keyboard.h
View file

@ -551,7 +551,7 @@ extern int tty_read_avail_input (struct terminal *, struct input_event *);
extern EMACS_TIME timer_check (void);
extern void mark_kboards (void);
#ifdef WINDOWSNT
#ifdef HAVE_NTGUI
extern const char *const lispy_function_keys[];
#endif

4
src/menu.c
View file

@ -40,7 +40,11 @@ along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
#endif /* HAVE_WINDOW_SYSTEM */
#ifdef HAVE_NTGUI
# ifdef NTGUI_UNICODE
# define unicode_append_menu AppendMenuW
# else /* !NTGUI_UNICODE */
extern AppendMenuW_Proc unicode_append_menu;
# endif /* NTGUI_UNICODE */
extern HMENU current_popup_menu;
#endif /* HAVE_NTGUI */

1
src/process.c
View file

@ -4646,6 +4646,7 @@ wait_reading_process_output (intmax_t time_limit, int nsecs, int read_kbd,
process_output_skip = 0;
}
#endif
#if defined (USE_GTK) || defined (HAVE_GCONF) || defined (HAVE_GSETTINGS)
nfds = xg_select
#elif defined (HAVE_NS)

6
src/termhooks.h
View file

@ -107,9 +107,9 @@ enum event_kind
HORIZ_WHEEL_EVENT, /* A wheel event generated by a second
horizontal wheel that is present on some
mice. See WHEEL_EVENT. */
#if defined (WINDOWSNT)
#if defined (HAVE_NTGUI)
LANGUAGE_CHANGE_EVENT, /* A LANGUAGE_CHANGE_EVENT is
generated on WINDOWSNT or Mac OS
generated when HAVE_NTGUI or on Mac OS
when the keyboard layout or input
language is changed by the
user. */
@ -188,7 +188,7 @@ enum event_kind
, CONFIG_CHANGED_EVENT
#ifdef WINDOWSNT
#ifdef HAVE_NTGUI
/* Generated when an APPCOMMAND event is received, in response to
Multimedia or Internet buttons on some keyboards.
Such keys are available as normal function keys on X through the

2
src/unexw32.c
View file

@ -83,7 +83,7 @@ DWORD_PTR extra_bss_size_static = 0;
PIMAGE_SECTION_HEADER heap_section;
#ifdef HAVE_NTGUI
HINSTANCE hinst = NULL;
extern HINSTANCE hinst;
HINSTANCE hprevinst = NULL;
LPSTR lpCmdLine = "";
int nCmdShow = 0;

19
src/w32.c
View file

@ -31,13 +31,13 @@ along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
#include <sys/file.h>
#include <sys/time.h>
#include <sys/utime.h>
#include <mbstring.h> /* for _mbspbrk */
#include <math.h>
#include <time.h>
/* must include CRT headers *before* config.h */
#include <config.h>
#include <mbstring.h> /* for _mbspbrk */
#undef access
#undef chdir
@ -866,23 +866,6 @@ create_symbolic_link (LPTSTR lpSymlinkFilename,
return retval;
}
/* Equivalent of strerror for W32 error codes. */
char *
w32_strerror (int error_no)
{
static char buf[500];
if (error_no == 0)
error_no = GetLastError ();
buf[0] = '\0';
if (!FormatMessage (FORMAT_MESSAGE_FROM_SYSTEM, NULL,
error_no,
0, /* choose most suitable language */
buf, sizeof (buf), NULL))
sprintf (buf, "w32 error %u", error_no);
return buf;
}
/* Return 1 if P is a valid pointer to an object of size SIZE. Return
0 if P is NOT a valid pointer. Return -1 if we cannot validate P.

17
src/w32.h
View file

@ -19,6 +19,12 @@ GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
#ifdef CYGWIN
#error "w32.h is not compatible with Cygwin"
#endif
#include <windows.h>
/* File descriptor set emulation. */
@ -130,17 +136,6 @@ extern LPBYTE w32_get_resource (char * key, LPDWORD type);
extern void init_ntproc (int);
extern void term_ntproc (int);
extern void globals_of_w32 (void);
extern void syms_of_w32term (void);
extern void syms_of_w32fns (void);
extern void globals_of_w32fns (void);
extern void syms_of_w32select (void);
extern void globals_of_w32select (void);
extern void term_w32select (void);
extern void syms_of_w32menu (void);
extern void globals_of_w32menu (void);
extern void syms_of_fontset (void);
extern void syms_of_w32font (void);
extern void check_windows_init_file (void);
extern void term_timers (void);
extern void init_timers (void);

49
src/w32console.c
View file

@ -36,6 +36,7 @@ along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
#include "termhooks.h"
#include "termchar.h"
#include "dispextern.h"
#include "w32term.h"
#include "w32heap.h" /* for os_subtype */
#include "w32inevt.h"
@ -430,53 +431,6 @@ w32con_delete_glyphs (struct frame *f, int n)
scroll_line (f, n, LEFT);
}
static unsigned int sound_type = 0xFFFFFFFF;
#define MB_EMACS_SILENT (0xFFFFFFFF - 1)
void
w32_sys_ring_bell (struct frame *f)
{
if (sound_type == 0xFFFFFFFF)
{
Beep (666, 100);
}
else if (sound_type == MB_EMACS_SILENT)
{
/* Do nothing. */
}
else
MessageBeep (sound_type);
}
DEFUN ("set-message-beep", Fset_message_beep, Sset_message_beep, 1, 1, 0,
doc: /* Set the sound generated when the bell is rung.
SOUND is 'asterisk, 'exclamation, 'hand, 'question, 'ok, or 'silent
to use the corresponding system sound for the bell. The 'silent sound
prevents Emacs from making any sound at all.
SOUND is nil to use the normal beep. */)
(Lisp_Object sound)
{
CHECK_SYMBOL (sound);
if (NILP (sound))
sound_type = 0xFFFFFFFF;
else if (EQ (sound, intern ("asterisk")))
sound_type = MB_ICONASTERISK;
else if (EQ (sound, intern ("exclamation")))
sound_type = MB_ICONEXCLAMATION;
else if (EQ (sound, intern ("hand")))
sound_type = MB_ICONHAND;
else if (EQ (sound, intern ("question")))
sound_type = MB_ICONQUESTION;
else if (EQ (sound, intern ("ok")))
sound_type = MB_OK;
else if (EQ (sound, intern ("silent")))
sound_type = MB_EMACS_SILENT;
else
sound_type = 0xFFFFFFFF;
return sound;
}
static void
w32con_reset_terminal_modes (struct terminal *t)
@ -850,5 +804,4 @@ scroll-back buffer. */);
defsubr (&Sset_screen_color);
defsubr (&Sget_screen_color);
defsubr (&Sset_cursor_size);
defsubr (&Sset_message_beep);
}

757
src/w32fns.c
View file

@ -44,8 +44,14 @@ along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
#include "fontset.h"
#include "systime.h"
#include "termhooks.h"
#include "w32heap.h"
#if CYGWIN
#include "cygw32.h"
#else
#include "w32.h"
#endif
#include "bitmaps/gray.xbm"
@ -58,9 +64,6 @@ along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
#include <dlgs.h>
#include <imm.h>
#define FILE_NAME_TEXT_FIELD edt1
#define FILE_NAME_COMBO_BOX cmb13
#define FILE_NAME_LIST lst1
#include "font.h"
#include "w32font.h"
@ -78,6 +81,7 @@ extern int w32_console_toggle_lock_key (int, Lisp_Object);
extern void w32_menu_display_help (HWND, HMENU, UINT, UINT);
extern void w32_free_menu_strings (HWND);
extern const char *map_w32_filename (const char *, const char **);
extern char * w32_strerror (int error_no);
/* If non-NULL, a handle to a frame where to display the hourglass cursor. */
static HWND hourglass_hwnd = NULL;
@ -161,7 +165,11 @@ ImmSetCompositionWindow_Proc set_ime_composition_window_fn = NULL;
MonitorFromPoint_Proc monitor_from_point_fn = NULL;
GetMonitorInfo_Proc get_monitor_info_fn = NULL;
#ifdef NTGUI_UNICODE
#define unicode_append_menu AppendMenuW
#else /* !NTGUI_UNICODE */
extern AppendMenuW_Proc unicode_append_menu;
#endif /* NTGUI_UNICODE */
/* Flag to selectively ignore WM_IME_CHAR messages. */
static int ignore_ime_char = 0;
@ -198,6 +206,33 @@ extern int uniscribe_available;
static void w32_show_hourglass (struct frame *);
static void w32_hide_hourglass (void);
#ifdef WINDOWSNT
/* From w32inevet.c */
extern int faked_key;
#endif /* WINDOWSNT */
/* This gives us the page size and the size of the allocation unit on NT. */
SYSTEM_INFO sysinfo_cache;
/* This gives us version, build, and platform identification. */
OSVERSIONINFO osinfo_cache;
unsigned long syspage_mask = 0;
/* The major and minor versions of NT. */
int w32_major_version;
int w32_minor_version;
int w32_build_number;
/* Distinguish between Windows NT and Windows 95. */
int os_subtype;
#ifdef HAVE_NTGUI
HINSTANCE hinst = NULL;
#endif
static unsigned int sound_type = 0xFFFFFFFF;
#define MB_EMACS_SILENT (0xFFFFFFFF - 1)
/* Error if we are not connected to MS-Windows. */
@ -1068,7 +1103,7 @@ gamma_correct (struct frame *f, COLORREF *color)
If ALLOC is nonzero, allocate a new colormap cell. */
int
w32_defined_color (FRAME_PTR f, char *color, XColor *color_def, int alloc)
w32_defined_color (FRAME_PTR f, const char *color, XColor *color_def, int alloc)
{
register Lisp_Object tem;
COLORREF w32_color_ref;
@ -1843,10 +1878,7 @@ w32_createwindow (struct frame *f)
/* Do first time app init */
if (!hprevinst)
{
w32_init_class (hinst);
}
w32_init_class (hinst);
if (f->size_hint_flags & USPosition || f->size_hint_flags & PPosition)
{
@ -2246,6 +2278,58 @@ unregister_hot_keys (HWND hwnd)
}
}
#if EMACSDEBUG
const char*
w32_name_of_message (UINT msg)
{
unsigned i;
static char buf[64];
static const struct {
UINT msg;
const char* name;
} msgnames[] = {
#define M(msg) { msg, # msg }
M (WM_PAINT),
M (WM_TIMER),
M (WM_USER),
M (WM_MOUSEMOVE),
M (WM_LBUTTONUP),
M (WM_KEYDOWN),
M (WM_EMACS_KILL),
M (WM_EMACS_CREATEWINDOW),
M (WM_EMACS_DONE),
M (WM_EMACS_CREATESCROLLBAR),
M (WM_EMACS_SHOWWINDOW),
M (WM_EMACS_SETWINDOWPOS),
M (WM_EMACS_DESTROYWINDOW),
M (WM_EMACS_TRACKPOPUPMENU),
M (WM_EMACS_SETFOCUS),
M (WM_EMACS_SETFOREGROUND),
M (WM_EMACS_SETLOCALE),
M (WM_EMACS_SETKEYBOARDLAYOUT),
M (WM_EMACS_REGISTER_HOT_KEY),
M (WM_EMACS_UNREGISTER_HOT_KEY),
M (WM_EMACS_TOGGLE_LOCK_KEY),
M (WM_EMACS_TRACK_CARET),
M (WM_EMACS_DESTROY_CARET),
M (WM_EMACS_SHOW_CARET),
M (WM_EMACS_HIDE_CARET),
M (WM_EMACS_SETCURSOR),
M (WM_EMACS_PAINT),
M (WM_CHAR),
#undef M
{ 0, 0 }
};
for (i = 0; msgnames[i].name; ++i)
if (msgnames[i].msg == msg)
return msgnames[i].name;
sprintf (buf, "message 0x%04x", (unsigned)msg);
return buf;
}
#endif /* EMACSDEBUG */
/* Here's an overview of how Emacs input works on MS-Windows.
System messages are read and processed by w32_msg_pump below. This
@ -2265,7 +2349,12 @@ unregister_hot_keys (HWND hwnd)
messages immediately, or converts them into Emacs input events and
stuffs them into kbd_buffer, where kbd_buffer_get_event can get at
them and process them when read_char and its callers require
input. */
input.
Under Cygwin with the W32 toolkit, the use of /dev/windows with
select(2) takes the place of w32_read_socket.
*/
/* Main message dispatch loop. */
@ -2280,6 +2369,10 @@ w32_msg_pump (deferred_msg * msg_buf)
while ((w32_unicode_gui ? GetMessageW : GetMessageA) (&msg, NULL, 0, 0))
{
/* DebPrint (("w32_msg_pump: %s time:%u\n", */
/* w32_name_of_message (msg.message), msg.time)); */
if (msg.hwnd == NULL)
{
switch (msg.message)
@ -2367,7 +2460,7 @@ w32_msg_pump (deferred_msg * msg_buf)
/* Broadcast messages make it here, so you need to be looking
for something in particular for this to be useful. */
default:
DebPrint (("msg %x not expected by w32_msg_pump\n", msg.message));
DebPrint (("msg %x not expected by w32_msg_pump\n", msg.message));
#endif
}
}
@ -4703,6 +4796,37 @@ If omitted or nil, that stands for the selected frame's display. */)
{
return Qnil;
}
DEFUN ("set-message-beep", Fset_message_beep, Sset_message_beep, 1, 1, 0,
doc: /* Set the sound generated when the bell is rung.
SOUND is 'asterisk, 'exclamation, 'hand, 'question, 'ok, or 'silent
to use the corresponding system sound for the bell. The 'silent sound
prevents Emacs from making any sound at all.
SOUND is nil to use the normal beep. */)
(Lisp_Object sound)
{
CHECK_SYMBOL (sound);
if (NILP (sound))
sound_type = 0xFFFFFFFF;
else if (EQ (sound, intern ("asterisk")))
sound_type = MB_ICONASTERISK;
else if (EQ (sound, intern ("exclamation")))
sound_type = MB_ICONEXCLAMATION;
else if (EQ (sound, intern ("hand")))
sound_type = MB_ICONHAND;
else if (EQ (sound, intern ("question")))
sound_type = MB_ICONQUESTION;
else if (EQ (sound, intern ("ok")))
sound_type = MB_OK;
else if (EQ (sound, intern ("silent")))
sound_type = MB_EMACS_SILENT;
else
sound_type = 0xFFFFFFFF;
return sound;
}
int
x_pixel_width (register struct frame *f)
@ -4784,12 +4908,21 @@ terminate Emacs if we can't open the connection.
unsigned char *xrm_option;
struct w32_display_info *dpyinfo;
CHECK_STRING (display);
/* Signal an error in order to encourage correct use from callers.
* If we ever support multiple window systems in the same Emacs,
* we'll need callers to be precise about what window system they
* want. */
if (strcmp (SSDATA (display), "w32") != 0)
error ("The name of the display in this Emacs must be \"w32\"");
/* If initialization has already been done, return now to avoid
overwriting critical parts of one_w32_display_info. */
if (w32_in_use)
return Qnil;
CHECK_STRING (display);
if (! NILP (xrm_string))
CHECK_STRING (xrm_string);
@ -5860,6 +5993,18 @@ Value is t if tooltip was open, nil otherwise. */)
File selection dialog
***********************************************************************/
#define FILE_NAME_TEXT_FIELD edt1
#define FILE_NAME_COMBO_BOX cmb13
#define FILE_NAME_LIST lst1
#ifdef NTGUI_UNICODE
#define GUISTR(x) (L ## x)
typedef wchar_t guichar_t;
#else /* !NTGUI_UNICODE */
#define GUISTR(x) x
typedef char guichar_t;
#endif /* NTGUI_UNICODE */
/* Callback for altering the behavior of the Open File dialog.
Makes the Filename text field contain "Current Directory" and be
read-only when "Directories" is selected in the filter. This
@ -5870,7 +6015,11 @@ file_dialog_callback (HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
if (msg == WM_NOTIFY)
{
OFNOTIFY * notify = (OFNOTIFY *)lParam;
#ifdef NTGUI_UNICODE
OFNOTIFYW * notify = (OFNOTIFYW *)lParam;
#else /* !NTGUI_UNICODE */
OFNOTIFYA * notify = (OFNOTIFYA *)lParam;
#endif /* NTGUI_UNICODE */
/* Detect when the Filter dropdown is changed. */
if (notify->hdr.code == CDN_TYPECHANGE
|| notify->hdr.code == CDN_INITDONE)
@ -5898,7 +6047,7 @@ file_dialog_callback (HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
if (notify->lpOFN->nFilterIndex == 2)
{
CommDlg_OpenSave_SetControlText (dialog, FILE_NAME_TEXT_FIELD,
"Current Directory");
GUISTR ("Current Directory"));
EnableWindow (edit_control, FALSE);
/* Note that at least on Windows 7, the above call to EnableWindow
disables the window that would ordinarily have focus. If we
@ -5914,7 +6063,8 @@ file_dialog_callback (HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
/* Don't override default filename on init done. */
if (notify->hdr.code == CDN_TYPECHANGE)
CommDlg_OpenSave_SetControlText (dialog,
FILE_NAME_TEXT_FIELD, "");
FILE_NAME_TEXT_FIELD,
GUISTR (""));
EnableWindow (edit_control, TRUE);
}
}
@ -5922,19 +6072,6 @@ file_dialog_callback (HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
return 0;
}
/* Since we compile with _WIN32_WINNT set to 0x0400 (for NT4 compatibility)
we end up with the old file dialogs. Define a big enough struct for the
new dialog to trick GetOpenFileName into giving us the new dialogs on
Windows 2000 and XP. */
typedef struct
{
OPENFILENAME real_details;
void * pReserved;
DWORD dwReserved;
DWORD FlagsEx;
} NEWOPENFILENAME;
DEFUN ("x-file-dialog", Fx_file_dialog, Sx_file_dialog, 2, 5, 0,
doc: /* Read file name, prompting with PROMPT in directory DIR.
Use a file selection dialog. Select DEFAULT-FILENAME in the dialog's file
@ -5946,134 +6083,203 @@ Motif or Gtk toolkits. With the Motif toolkit, ONLY-DIR-P is ignored.
Otherwise, if ONLY-DIR-P is non-nil, the user can only select directories. */)
(Lisp_Object prompt, Lisp_Object dir, Lisp_Object default_filename, Lisp_Object mustmatch, Lisp_Object only_dir_p)
{
/* Filter index: 1: All Files, 2: Directories only */
static const guichar_t filter[] =
GUISTR ("All Files (*.*)\0*.*\0Directories\0*|*\0");
Lisp_Object filename = default_filename;
struct frame *f = SELECTED_FRAME ();
Lisp_Object file = Qnil;
ptrdiff_t count = SPECPDL_INDEX ();
BOOL file_opened = FALSE;
Lisp_Object orig_dir = dir;
Lisp_Object orig_prompt = prompt;
/* If we compile with _WIN32_WINNT set to 0x0400 (for NT4
compatibility) we end up with the old file dialogs. Define a big
enough struct for the new dialog to trick GetOpenFileName into
giving us the new dialogs on newer versions of Windows. */
struct {
#ifdef NTGUI_UNICODE
OPENFILENAMEW details;
#else /* !NTGUI_UNICODE */
OPENFILENAMEA details;
#endif /* NTGUI_UNICODE */
#if _WIN32_WINNT < 0x500 /* < win2k */
PVOID pvReserved;
DWORD dwReserved;
DWORD FlagsEx;
#endif /* < win2k */
} new_file_details;
#ifdef NTGUI_UNICODE
wchar_t filename_buf[MAX_PATH + 1];
OPENFILENAMEW * file_details = &new_file_details.details;
#else /* not NTGUI_UNICODE */
char filename_buf[MAX_PATH + 1];
OPENFILENAMEA * file_details = &new_file_details.details;
#endif /* NTGUI_UNICODE */
struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5, gcpro6;
char filename[MAX_PATH + 1];
char init_dir[MAX_PATH + 1];
int default_filter_index = 1; /* 1: All Files, 2: Directories only */
GCPRO6 (prompt, dir, default_filename, mustmatch, only_dir_p, file);
CHECK_STRING (prompt);
CHECK_STRING (dir);
/* Create the dialog with PROMPT as title, using DIR as initial
directory and using "*" as pattern. */
dir = Fexpand_file_name (dir, Qnil);
strncpy (init_dir, SDATA (ENCODE_FILE (dir)), MAX_PATH);
init_dir[MAX_PATH] = '\0';
unixtodos_filename (init_dir);
if (STRINGP (default_filename))
{
char *file_name_only;
char *full_path_name = SDATA (ENCODE_FILE (default_filename));
unixtodos_filename (full_path_name);
file_name_only = strrchr (full_path_name, '\\');
if (!file_name_only)
file_name_only = full_path_name;
else
file_name_only++;
strncpy (filename, file_name_only, MAX_PATH);
filename[MAX_PATH] = '\0';
}
else
filename[0] = '\0';
/* The code in file_dialog_callback that attempts to set the text
of the file name edit window when handling the CDN_INITDONE
WM_NOTIFY message does not work. Setting filename to "Current
Directory" in the only_dir_p case here does work however. */
if (filename[0] == 0 && ! NILP (only_dir_p))
strcpy (filename, "Current Directory");
GCPRO6 (prompt, dir, default_filename, mustmatch, only_dir_p, filename);
{
NEWOPENFILENAME new_file_details;
BOOL file_opened = FALSE;
OPENFILENAME * file_details = &new_file_details.real_details;
struct gcpro gcpro1, gcpro2;
GCPRO2 (orig_dir, orig_prompt); /* There is no GCPRON, N>6. */
/* Prevent redisplay. */
specbind (Qinhibit_redisplay, Qt);
block_input ();
/* Note: under NTGUI_UNICODE, we do _NOT_ use ENCODE_FILE: the
system file encoding expected by the platform APIs (e.g. Cygwin's
POSIX implementation) may not the same as the encoding expected
by the Windows API! */
memset (&new_file_details, 0, sizeof (new_file_details));
/* Apparently NT4 crashes if you give it an unexpected size.
I'm not sure about Windows 9x, so play it safe. */
if (w32_major_version > 4 && w32_major_version < 95)
file_details->lStructSize = sizeof (NEWOPENFILENAME);
CHECK_STRING (prompt);
CHECK_STRING (dir);
dir = Fexpand_file_name (dir, Qnil);
if (STRINGP (filename))
filename = Ffile_name_nondirectory (filename);
else
file_details->lStructSize = sizeof (OPENFILENAME);
filename = empty_unibyte_string;
#ifdef CYGWIN
dir = Fcygwin_convert_path_to_windows (dir, Qt);
if (SCHARS (filename) > 0)
filename = Fcygwin_convert_path_to_windows (filename, Qnil);
#endif
CHECK_STRING (dir);
CHECK_STRING (filename);
/* The code in file_dialog_callback that attempts to set the text
of the file name edit window when handling the CDN_INITDONE
WM_NOTIFY message does not work. Setting filename to "Current
Directory" in the only_dir_p case here does work however. */
if (SCHARS (filename) == 0 && ! NILP (only_dir_p))
filename = build_string ("Current Directory");
/* Convert the values we've computed so far to system form. */
#ifdef NTGUI_UNICODE
to_unicode (prompt, &prompt);
to_unicode (dir, &dir);
to_unicode (filename, &filename);
#else /* !NTGUI_UNICODE */
prompt = ENCODE_FILE (prompt);
dir = ENCODE_FILE (dir);
filename = ENCODE_FILE (filename);
/* We modify these in-place, so make copies for safety. */
dir = Fcopy_sequence (dir);
unixtodos_filename (SDATA (dir));
filename = Fcopy_sequence (filename);
unixtodos_filename (SDATA (filename));
#endif /* NTGUI_UNICODE */
/* Fill in the structure for the call to GetOpenFileName below. For
NTGUI_UNICODE builds (which run only on NT), we just use the
actual size of the structure. For non-NTGUI_UNICODE builds, we
tell the OS we're using an old version of the structure if it's not
new enough to support the newer version. */
memset (&new_file_details, 0, sizeof (new_file_details));
if (w32_major_version > 4 && w32_major_version < 95)
file_details->lStructSize = sizeof (new_file_details);
else
file_details->lStructSize = sizeof (*file_details);
/* Set up the inout parameter for the selected file name. */
if (SBYTES (filename) + 1 > sizeof (filename_buf))
error ("filename too long");
memcpy (filename_buf, SDATA (filename), SBYTES (filename) + 1);
file_details->lpstrFile = filename_buf;
file_details->nMaxFile = sizeof (filename_buf) / sizeof (*filename_buf);
file_details->hwndOwner = FRAME_W32_WINDOW (f);
/* Undocumented Bug in Common File Dialog:
If a filter is not specified, shell links are not resolved. */
file_details->lpstrFilter = "All Files (*.*)\0*.*\0Directories\0*|*\0\0";
file_details->lpstrFile = filename;
file_details->nMaxFile = sizeof (filename);
file_details->lpstrInitialDir = init_dir;
file_details->lpstrTitle = SDATA (prompt);
if (! NILP (only_dir_p))
default_filter_index = 2;
file_details->nFilterIndex = default_filter_index;
file_details->lpstrFilter = filter;
file_details->lpstrInitialDir = (guichar_t*) SDATA (dir);
file_details->lpstrTitle = (guichar_t*) SDATA (prompt);
file_details->nFilterIndex = NILP (only_dir_p) ? 1 : 2;
file_details->Flags = (OFN_HIDEREADONLY | OFN_NOCHANGEDIR
| OFN_EXPLORER | OFN_ENABLEHOOK);
| OFN_EXPLORER | OFN_ENABLEHOOK);
if (!NILP (mustmatch))
{
/* Require that the path to the parent directory exists. */
file_details->Flags |= OFN_PATHMUSTEXIST;
/* If we are looking for a file, require that it exists. */
if (NILP (only_dir_p))
file_details->Flags |= OFN_FILEMUSTEXIST;
/* Require that the path to the parent directory exists. */
file_details->Flags |= OFN_PATHMUSTEXIST;
/* If we are looking for a file, require that it exists. */
if (NILP (only_dir_p))
file_details->Flags |= OFN_FILEMUSTEXIST;
}
file_details->lpfnHook = (LPOFNHOOKPROC) file_dialog_callback;
{
int count = SPECPDL_INDEX ();
specbind (Qinhibit_redisplay, Qt);
block_input ();
file_details->lpfnHook = file_dialog_callback;
file_opened = GetOpenFileName (file_details);
unblock_input ();
#ifdef NTGUI_UNICODE
file_opened = GetOpenFileNameW (file_details);
#else /* !NTGUI_UNICODE */
file_opened = GetOpenFileNameA (file_details);
#endif /* NTGUI_UNICODE */
unblock_input ();
unbind_to (count, Qnil);
}
if (file_opened)
{
dostounix_filename (filename);
/* Get an Emacs string from the value Windows gave us. */
#ifdef NTGUI_UNICODE
filename = from_unicode (
make_unibyte_string (
(char*) filename_buf,
/* we get one of the two final 0 bytes for free. */
1 + sizeof (wchar_t) * wcslen (filename_buf)));
#else /* !NTGUI_UNICODE */
dostounix_filename (filename_buf);
filename = DECODE_FILE (build_string (filename_buf));
#endif /* NTGUI_UNICODE */
if (file_details->nFilterIndex == 2)
{
/* "Directories" selected - strip dummy file name. */
char * last = strrchr (filename, '/');
*last = '\0';
}
#ifdef CYGWIN
filename = Fcygwin_convert_path_from_windows (filename, Qt);
#endif /* CYGWIN */
file = DECODE_FILE (build_string (filename));
/* Strip the dummy filename off the end of the string if we
added it to select a directory. */
if (file_details->nFilterIndex == 2)
{
filename = Ffile_name_directory (filename);
}
}
/* User canceled the dialog without making a selection. */
else if (!CommDlgExtendedError ())
file = Qnil;
filename = Qnil;
/* An error occurred, fallback on reading from the mini-buffer. */
else
file = Fcompleting_read (prompt, intern ("read-file-name-internal"),
dir, mustmatch, dir, Qfile_name_history,
default_filename, Qnil);
filename = Fcompleting_read (
orig_prompt,
intern ("read-file-name-internal"),
orig_dir,
mustmatch,
orig_dir,
Qfile_name_history,
default_filename,
Qnil);
file = unbind_to (count, file);
UNGCPRO;
}
UNGCPRO;
/* Make "Cancel" equivalent to C-g. */
if (NILP (file))
if (NILP (filename))
Fsignal (Qquit, Qnil);
return unbind_to (count, file);
RETURN_UNGCPRO (filename);
}
#ifdef WINDOWSNT
/* Moving files to the system recycle bin.
Used by `move-file-to-trash' instead of the default moving to ~/.Trash */
DEFUN ("system-move-file-to-trash", Fsystem_move_file_to_trash,
@ -6127,6 +6333,8 @@ DEFUN ("system-move-file-to-trash", Fsystem_move_file_to_trash,
return Qnil;
}
#endif /* WINDOWSNT */
/***********************************************************************
w32 specialized functions
@ -6544,7 +6752,7 @@ The following %-sequences are provided:
else
{
char buffer[16];
_snprintf (buffer, 16, "%d", system_status.BatteryLifePercent);
snprintf (buffer, 16, "%d", system_status.BatteryLifePercent);
load_percentage = build_string (buffer);
}
@ -6555,18 +6763,18 @@ The following %-sequences are provided:
long m;
float h;
char buffer[16];
_snprintf (buffer, 16, "%ld", seconds_left);
snprintf (buffer, 16, "%ld", seconds_left);
seconds = build_string (buffer);
m = seconds_left / 60;
_snprintf (buffer, 16, "%ld", m);
snprintf (buffer, 16, "%ld", m);
minutes = build_string (buffer);
h = seconds_left / 3600.0;
_snprintf (buffer, 16, "%3.1f", h);
snprintf (buffer, 16, "%3.1f", h);
hours = build_string (buffer);
_snprintf (buffer, 16, "%ld:%02ld", m / 60, m % 60);
snprintf (buffer, 16, "%ld:%02ld", m / 60, m % 60);
remain = build_string (buffer);
}
@ -6728,10 +6936,10 @@ DEFUN ("default-printer-name", Fdefault_printer_name, Sdefault_printer_name,
{
/* a remote printer */
if (*ppi2->pServerName == '\\')
_snprintf (pname_buf, sizeof (pname_buf), "%s\\%s", ppi2->pServerName,
snprintf (pname_buf, sizeof (pname_buf), "%s\\%s", ppi2->pServerName,
ppi2->pShareName);
else
_snprintf (pname_buf, sizeof (pname_buf), "\\\\%s\\%s", ppi2->pServerName,
snprintf (pname_buf, sizeof (pname_buf), "\\\\%s\\%s", ppi2->pServerName,
ppi2->pShareName);
pname_buf[sizeof (pname_buf) - 1] = '\0';
}
@ -6749,6 +6957,292 @@ DEFUN ("default-printer-name", Fdefault_printer_name, Sdefault_printer_name,
return build_string (pname_buf);
}
/* Equivalent of strerror for W32 error codes. */
char *
w32_strerror (int error_no)
{
static char buf[500];
DWORD ret;
if (error_no == 0)
error_no = GetLastError ();
ret = FormatMessage (FORMAT_MESSAGE_FROM_SYSTEM |
FORMAT_MESSAGE_IGNORE_INSERTS,
NULL,
error_no,
0, /* choose most suitable language */
buf, sizeof (buf), NULL);
while (ret > 0 && (buf[ret - 1] == '\n' ||
buf[ret - 1] == '\r' ))
--ret;
buf[ret] = '\0';
if (!ret)
sprintf (buf, "w32 error %u", error_no);
return buf;
}
/* For convenience when debugging. */
int
w32_last_error (void)
{
return GetLastError ();
}
/* Cache information describing the NT system for later use. */
void
cache_system_info (void)
{
union
{
struct info
{
char major;
char minor;
short platform;
} info;
DWORD data;
} version;
/* Cache the version of the operating system. */
version.data = GetVersion ();
w32_major_version = version.info.major;
w32_minor_version = version.info.minor;
if (version.info.platform & 0x8000)
os_subtype = OS_9X;
else
os_subtype = OS_NT;
/* Cache page size, allocation unit, processor type, etc. */
GetSystemInfo (&sysinfo_cache);
syspage_mask = sysinfo_cache.dwPageSize - 1;
/* Cache os info. */
osinfo_cache.dwOSVersionInfoSize = sizeof (OSVERSIONINFO);
GetVersionEx (&osinfo_cache);
w32_build_number = osinfo_cache.dwBuildNumber;
if (os_subtype == OS_9X)
w32_build_number &= 0xffff;
w32_num_mouse_buttons = GetSystemMetrics (SM_CMOUSEBUTTONS);
}
#ifdef EMACSDEBUG
void
_DebPrint (const char *fmt, ...)
{
char buf[1024];
va_list args;
va_start (args, fmt);
vsprintf (buf, fmt, args);
va_end (args);
#if CYGWIN
fprintf (stderr, "%s", buf);
#endif
OutputDebugString (buf);
}
#endif
int
w32_console_toggle_lock_key (int vk_code, Lisp_Object new_state)
{
int cur_state = (GetKeyState (vk_code) & 1);
if (NILP (new_state)
|| (NUMBERP (new_state)
&& ((XUINT (new_state)) & 1) != cur_state))
{
#ifdef WINDOWSNT
faked_key = vk_code;
#endif /* WINDOWSNT */
keybd_event ((BYTE) vk_code,
(BYTE) MapVirtualKey (vk_code, 0),
KEYEVENTF_EXTENDEDKEY | KEYEVENTF_KEYUP, 0);
keybd_event ((BYTE) vk_code,
(BYTE) MapVirtualKey (vk_code, 0),
KEYEVENTF_EXTENDEDKEY | 0, 0);
keybd_event ((BYTE) vk_code,
(BYTE) MapVirtualKey (vk_code, 0),
KEYEVENTF_EXTENDEDKEY | KEYEVENTF_KEYUP, 0);
cur_state = !cur_state;
}
return cur_state;
}
/* Translate console modifiers to emacs modifiers.
German keyboard support (Kai Morgan Zeise 2/18/95). */
int
w32_kbd_mods_to_emacs (DWORD mods, WORD key)
{
int retval = 0;
/* If we recognize right-alt and left-ctrl as AltGr, and it has been
pressed, first remove those modifiers. */
if (!NILP (Vw32_recognize_altgr)
&& (mods & (RIGHT_ALT_PRESSED | LEFT_CTRL_PRESSED))
== (RIGHT_ALT_PRESSED | LEFT_CTRL_PRESSED))
mods &= ~ (RIGHT_ALT_PRESSED | LEFT_CTRL_PRESSED);
if (mods & (RIGHT_ALT_PRESSED | LEFT_ALT_PRESSED))
retval = ((NILP (Vw32_alt_is_meta)) ? alt_modifier : meta_modifier);
if (mods & (RIGHT_CTRL_PRESSED | LEFT_CTRL_PRESSED))
{
retval |= ctrl_modifier;
if ((mods & (RIGHT_CTRL_PRESSED | LEFT_CTRL_PRESSED))
== (RIGHT_CTRL_PRESSED | LEFT_CTRL_PRESSED))
retval |= meta_modifier;
}
if (mods & LEFT_WIN_PRESSED)
retval |= w32_key_to_modifier (VK_LWIN);
if (mods & RIGHT_WIN_PRESSED)
retval |= w32_key_to_modifier (VK_RWIN);
if (mods & APPS_PRESSED)
retval |= w32_key_to_modifier (VK_APPS);
if (mods & SCROLLLOCK_ON)
retval |= w32_key_to_modifier (VK_SCROLL);
/* Just in case someone wanted the original behavior, make it
optional by setting w32-capslock-is-shiftlock to t. */
if (NILP (Vw32_capslock_is_shiftlock)
/* Keys that should _not_ be affected by CapsLock. */
&& ( (key == VK_BACK)
|| (key == VK_TAB)
|| (key == VK_CLEAR)
|| (key == VK_RETURN)
|| (key == VK_ESCAPE)
|| ((key >= VK_SPACE) && (key <= VK_HELP))
|| ((key >= VK_NUMPAD0) && (key <= VK_F24))
|| ((key >= VK_NUMPAD_CLEAR) && (key <= VK_NUMPAD_DELETE))
))
{
/* Only consider shift state. */
if ((mods & SHIFT_PRESSED) != 0)
retval |= shift_modifier;
}
else
{
/* Ignore CapsLock state if not enabled. */
if (NILP (Vw32_enable_caps_lock))
mods &= ~CAPSLOCK_ON;
if ((mods & (SHIFT_PRESSED | CAPSLOCK_ON)) != 0)
retval |= shift_modifier;
}
return retval;
}
/* The return code indicates key code size. cpID is the codepage to
use for translation to Unicode; -1 means use the current console
input codepage. */
int
w32_kbd_patch_key (KEY_EVENT_RECORD *event, int cpId)
{
unsigned int key_code = event->wVirtualKeyCode;
unsigned int mods = event->dwControlKeyState;
BYTE keystate[256];
static BYTE ansi_code[4];
static int isdead = 0;
if (isdead == 2)
{
event->uChar.AsciiChar = ansi_code[2];
isdead = 0;
return 1;
}
if (event->uChar.AsciiChar != 0)
return 1;
memset (keystate, 0, sizeof (keystate));
keystate[key_code] = 0x80;
if (mods & SHIFT_PRESSED)
keystate[VK_SHIFT] = 0x80;
if (mods & CAPSLOCK_ON)
keystate[VK_CAPITAL] = 1;
/* If we recognize right-alt and left-ctrl as AltGr, set the key
states accordingly before invoking ToAscii. */
if (!NILP (Vw32_recognize_altgr)
&& (mods & LEFT_CTRL_PRESSED) && (mods & RIGHT_ALT_PRESSED))
{
keystate[VK_CONTROL] = 0x80;
keystate[VK_LCONTROL] = 0x80;
keystate[VK_MENU] = 0x80;
keystate[VK_RMENU] = 0x80;
}
#if 0
/* Because of an OS bug, ToAscii corrupts the stack when called to
convert a dead key in console mode on NT4. Unfortunately, trying
to check for dead keys using MapVirtualKey doesn't work either -
these functions apparently use internal information about keyboard
layout which doesn't get properly updated in console programs when
changing layout (though apparently it gets partly updated,
otherwise ToAscii wouldn't crash). */
if (is_dead_key (event->wVirtualKeyCode))
return 0;
#endif
/* On NT, call ToUnicode instead and then convert to the current
console input codepage. */
if (os_subtype == OS_NT)
{
WCHAR buf[128];
isdead = ToUnicode (event->wVirtualKeyCode, event->wVirtualScanCode,
keystate, buf, 128, 0);
if (isdead > 0)
{
/* When we are called from the GUI message processing code,
we are passed the current keyboard codepage, a positive
number, to use below. */
if (cpId == -1)
cpId = GetConsoleCP ();
event->uChar.UnicodeChar = buf[isdead - 1];
isdead = WideCharToMultiByte (cpId, 0, buf, isdead,
ansi_code, 4, NULL, NULL);
}
else
isdead = 0;
}
else
{
isdead = ToAscii (event->wVirtualKeyCode, event->wVirtualScanCode,
keystate, (LPWORD) ansi_code, 0);
}
if (isdead == 0)
return 0;
event->uChar.AsciiChar = ansi_code[0];
return isdead;
}
void
w32_sys_ring_bell (struct frame *f)
{
if (sound_type == 0xFFFFFFFF)
{
Beep (666, 100);
}
else if (sound_type == MB_EMACS_SILENT)
{
/* Do nothing. */
}
else
MessageBeep (sound_type);
}
/***********************************************************************
Initialization
@ -7116,6 +7610,7 @@ only be necessary if the default setting causes problems. */);
defsubr (&Sfile_system_info);
defsubr (&Sdefault_printer_name);
defsubr (&Sset_message_beep);
check_window_system_func = check_w32;
@ -7132,7 +7627,9 @@ only be necessary if the default setting causes problems. */);
staticpro (&last_show_tip_args);
defsubr (&Sx_file_dialog);
#ifdef WINDOWSNT
defsubr (&Ssystem_move_file_to_trash);
#endif
}
@ -7214,9 +7711,3 @@ emacs_abort (void)
}
}
/* For convenience when debugging. */
int
w32_last_error (void)
{
return GetLastError ();
}

4
src/w32font.c
View file

@ -18,6 +18,7 @@ along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
#include <config.h>
#include <windows.h>
#include <stdio.h>
#include <math.h>
#include <ctype.h>
#include <commdlg.h>
@ -1434,6 +1435,9 @@ w32font_coverage_ok (FONTSIGNATURE * coverage, BYTE charset)
return 1;
}
#ifndef WINDOWSNT
#define _strlwr strlwr
#endif /* !WINDOWSNT */
static int
check_face_name (LOGFONT *font, char *full_name)

41
src/w32heap.c
View file

@ -32,10 +32,9 @@ along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
SYSTEM_INFO sysinfo_cache;
/* This gives us version, build, and platform identification. */
extern unsigned long syspage_mask;
OSVERSIONINFO osinfo_cache;
size_t syspage_mask = 0;
/* The major and minor versions of NT. */
int w32_major_version;
int w32_minor_version;
@ -44,44 +43,6 @@ int w32_build_number;
/* Distinguish between Windows NT and Windows 95. */
int os_subtype;
/* Cache information describing the NT system for later use. */
void
cache_system_info (void)
{
union
{
struct info
{
char major;
char minor;
short platform;
} info;
DWORD data;
} version;
/* Cache the version of the operating system. */
version.data = GetVersion ();
w32_major_version = version.info.major;
w32_minor_version = version.info.minor;
if (version.info.platform & 0x8000)
os_subtype = OS_9X;
else
os_subtype = OS_NT;
/* Cache page size, allocation unit, processor type, etc. */
GetSystemInfo (&sysinfo_cache);
syspage_mask = sysinfo_cache.dwPageSize - 1;
/* Cache os info. */
osinfo_cache.dwOSVersionInfoSize = sizeof (OSVERSIONINFO);
GetVersionEx (&osinfo_cache);
w32_build_number = osinfo_cache.dwBuildNumber;
if (os_subtype == OS_9X)
w32_build_number &= 0xffff;
}
/* Emulate getpagesize. */
int
getpagesize (void)

172
src/w32inevt.c
View file

@ -70,6 +70,9 @@ w32_read_console_input (HANDLE h, INPUT_RECORD *rec, DWORD recsize,
: ReadConsoleInputA (h, rec, recsize, waiting));
}
/* Set by w32_console_toggle_lock_key. */
int faked_key;
static int
fill_queue (BOOL block)
{
@ -110,67 +113,7 @@ get_frame (void)
/* Translate console modifiers to emacs modifiers.
German keyboard support (Kai Morgan Zeise 2/18/95). */
int
w32_kbd_mods_to_emacs (DWORD mods, WORD key)
{
int retval = 0;
/* If we recognize right-alt and left-ctrl as AltGr, and it has been
pressed, first remove those modifiers. */
if (!NILP (Vw32_recognize_altgr)
&& (mods & (RIGHT_ALT_PRESSED | LEFT_CTRL_PRESSED))
== (RIGHT_ALT_PRESSED | LEFT_CTRL_PRESSED))
mods &= ~ (RIGHT_ALT_PRESSED | LEFT_CTRL_PRESSED);
if (mods & (RIGHT_ALT_PRESSED | LEFT_ALT_PRESSED))
retval = ((NILP (Vw32_alt_is_meta)) ? alt_modifier : meta_modifier);
if (mods & (RIGHT_CTRL_PRESSED | LEFT_CTRL_PRESSED))
{
retval |= ctrl_modifier;
if ((mods & (RIGHT_CTRL_PRESSED | LEFT_CTRL_PRESSED))
== (RIGHT_CTRL_PRESSED | LEFT_CTRL_PRESSED))
retval |= meta_modifier;
}
if (mods & LEFT_WIN_PRESSED)
retval |= w32_key_to_modifier (VK_LWIN);
if (mods & RIGHT_WIN_PRESSED)
retval |= w32_key_to_modifier (VK_RWIN);
if (mods & APPS_PRESSED)
retval |= w32_key_to_modifier (VK_APPS);
if (mods & SCROLLLOCK_ON)
retval |= w32_key_to_modifier (VK_SCROLL);
/* Just in case someone wanted the original behavior, make it
optional by setting w32-capslock-is-shiftlock to t. */
if (NILP (Vw32_capslock_is_shiftlock)
/* Keys that should _not_ be affected by CapsLock. */
&& ( (key == VK_BACK)
|| (key == VK_TAB)
|| (key == VK_CLEAR)
|| (key == VK_RETURN)
|| (key == VK_ESCAPE)
|| ((key >= VK_SPACE) && (key <= VK_HELP))
|| ((key >= VK_NUMPAD0) && (key <= VK_F24))
|| ((key >= VK_NUMPAD_CLEAR) && (key <= VK_NUMPAD_DELETE))
))
{
/* Only consider shift state. */
if ((mods & SHIFT_PRESSED) != 0)
retval |= shift_modifier;
}
else
{
/* Ignore CapsLock state if not enabled. */
if (NILP (Vw32_enable_caps_lock))
mods &= ~CAPSLOCK_ON;
if ((mods & (SHIFT_PRESSED | CAPSLOCK_ON)) != 0)
retval |= shift_modifier;
}
return retval;
}
#if 0
/* Return nonzero if the virtual key is a dead key. */
@ -187,90 +130,7 @@ is_dead_key (int wparam)
/* The return code indicates key code size. cpID is the codepage to
use for translation to Unicode; -1 means use the current console
input codepage. */
int
w32_kbd_patch_key (KEY_EVENT_RECORD *event, int cpId)
{
unsigned int key_code = event->wVirtualKeyCode;
unsigned int mods = event->dwControlKeyState;
BYTE keystate[256];
static BYTE ansi_code[4];
static int isdead = 0;
if (isdead == 2)
{
event->uChar.AsciiChar = ansi_code[2];
isdead = 0;
return 1;
}
if (event->uChar.AsciiChar != 0)
return 1;
memset (keystate, 0, sizeof (keystate));
keystate[key_code] = 0x80;
if (mods & SHIFT_PRESSED)
keystate[VK_SHIFT] = 0x80;
if (mods & CAPSLOCK_ON)
keystate[VK_CAPITAL] = 1;
/* If we recognize right-alt and left-ctrl as AltGr, set the key
states accordingly before invoking ToAscii. */
if (!NILP (Vw32_recognize_altgr)
&& (mods & LEFT_CTRL_PRESSED) && (mods & RIGHT_ALT_PRESSED))
{
keystate[VK_CONTROL] = 0x80;
keystate[VK_LCONTROL] = 0x80;
keystate[VK_MENU] = 0x80;
keystate[VK_RMENU] = 0x80;
}
#if 0
/* Because of an OS bug, ToAscii corrupts the stack when called to
convert a dead key in console mode on NT4. Unfortunately, trying
to check for dead keys using MapVirtualKey doesn't work either -
these functions apparently use internal information about keyboard
layout which doesn't get properly updated in console programs when
changing layout (though apparently it gets partly updated,
otherwise ToAscii wouldn't crash). */
if (is_dead_key (event->wVirtualKeyCode))
return 0;
#endif
/* On NT, call ToUnicode instead and then convert to the current
console input codepage. */
if (os_subtype == OS_NT)
{
WCHAR buf[128];
isdead = ToUnicode (event->wVirtualKeyCode, event->wVirtualScanCode,
keystate, buf, 128, 0);
if (isdead > 0)
{
/* When we are called from the GUI message processing code,
we are passed the current keyboard codepage, a positive
number, to use below. */
if (cpId == -1)
cpId = GetConsoleCP ();
event->uChar.UnicodeChar = buf[isdead - 1];
isdead = WideCharToMultiByte (cpId, 0, buf, isdead,
ansi_code, 4, NULL, NULL);
}
else
isdead = 0;
}
else
{
isdead = ToAscii (event->wVirtualKeyCode, event->wVirtualScanCode,
keystate, (LPWORD) ansi_code, 0);
}
if (isdead == 0)
return 0;
event->uChar.AsciiChar = ansi_code[0];
return isdead;
}
static int faked_key = 0;
/* return code -1 means that event_queue_ptr won't be incremented.
In other word, this event makes two key codes. (by himi) */
@ -531,32 +391,6 @@ key_event (KEY_EVENT_RECORD *event, struct input_event *emacs_ev, int *isdead)
return 1;
}
int
w32_console_toggle_lock_key (int vk_code, Lisp_Object new_state)
{
int cur_state = (GetKeyState (vk_code) & 1);
if (NILP (new_state)
|| (NUMBERP (new_state)
&& ((XUINT (new_state)) & 1) != cur_state))
{
faked_key = vk_code;
keybd_event ((BYTE) vk_code,
(BYTE) MapVirtualKey (vk_code, 0),
KEYEVENTF_EXTENDEDKEY | KEYEVENTF_KEYUP, 0);
keybd_event ((BYTE) vk_code,
(BYTE) MapVirtualKey (vk_code, 0),
KEYEVENTF_EXTENDEDKEY | 0, 0);
keybd_event ((BYTE) vk_code,
(BYTE) MapVirtualKey (vk_code, 0),
KEYEVENTF_EXTENDEDKEY | KEYEVENTF_KEYUP, 0);
cur_state = !cur_state;
}
return cur_state;
}
/* Mouse position hook. */
void
w32_console_mouse_position (FRAME_PTR *f,

27
src/w32menu.c
View file

@ -21,7 +21,7 @@ along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
#include <signal.h>
#include <stdio.h>
#include <mbstring.h>
#include <setjmp.h>
#include "lisp.h"
#include "keyboard.h"
@ -40,6 +40,14 @@ along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
if this is not done before the other system files. */
#include "w32term.h"
/* Cygwin does not support the multibyte string functions declared in
* mbstring.h below --- but that's okay: because Cygwin is
* UNICODE-only, we don't need to use these functions anyway. */
#ifndef NTGUI_UNICODE
#include <mbstring.h>
#endif /* !NTGUI_UNICODE */
/* Load sys/types.h if not already loaded.
In some systems loading it twice is suicidal. */
#ifndef makedev
@ -78,10 +86,17 @@ typedef int (WINAPI * MessageBoxW_Proc) (
IN WCHAR *caption,
IN UINT type);
#ifdef NTGUI_UNICODE
#define get_menu_item_info GetMenuItemInfoA
#define set_menu_item_info SetMenuItemInfoA
#define unicode_append_menu AppendMenuW
#define unicode_message_box MessageBoxW
#else /* !NTGUI_UNICODE */
GetMenuItemInfoA_Proc get_menu_item_info = NULL;
SetMenuItemInfoA_Proc set_menu_item_info = NULL;
AppendMenuW_Proc unicode_append_menu = NULL;
MessageBoxW_Proc unicode_message_box = NULL;
#endif /* NTGUI_UNICODE */
Lisp_Object Qdebug_on_next_call;
@ -98,6 +113,7 @@ static void utf8to16 (unsigned char *, int, WCHAR *);
static int fill_in_menu (HMENU, widget_value *);
void w32_free_menu_strings (HWND);
/* This is set nonzero after the user activates the menu bar, and set
@ -1405,6 +1421,7 @@ add_menu_item (HMENU menu, widget_value *wv, HMENU item)
nlen++;
}
}
#ifndef NTGUI_UNICODE
else
{
/* If encoded with the system codepage, use multibyte string
@ -1415,6 +1432,7 @@ add_menu_item (HMENU menu, widget_value *wv, HMENU item)
nlen++;
}
}
#endif /* !NTGUI_UNICODE */
if (nlen > orig_len)
{
@ -1429,6 +1447,7 @@ add_menu_item (HMENU menu, widget_value *wv, HMENU item)
*q++ = *p;
*q++ = *p++;
}
#ifndef NTGUI_UNICODE
else
{
if (_mbsnextc (p) == '&')
@ -1440,6 +1459,7 @@ add_menu_item (HMENU menu, widget_value *wv, HMENU item)
p = _mbsinc (p);
q = _mbsinc (q);
}
#endif /* !NTGUI_UNICODE */
}
*q = '\0';
}
@ -1486,6 +1506,8 @@ add_menu_item (HMENU menu, widget_value *wv, HMENU item)
item != NULL ? (UINT_PTR) item
: (UINT_PTR) wv->call_data,
utf16_string);
#ifndef NTGUI_UNICODE /* Fallback does not apply when always UNICODE */
if (!return_value)
{
/* On W9x/ME, Unicode menus are not supported, though AppendMenuW
@ -1504,6 +1526,7 @@ add_menu_item (HMENU menu, widget_value *wv, HMENU item)
if (osinfo_cache.dwPlatformId != VER_PLATFORM_WIN32_NT)
unicode_append_menu = NULL;
}
#endif /* NTGUI_UNICODE */
if (unicode_append_menu && (fuFlags & MF_OWNERDRAW))
local_free (out_string);
@ -1723,10 +1746,12 @@ syms_of_w32menu (void)
void
globals_of_w32menu (void)
{
#ifndef NTGUI_UNICODE
/* See if Get/SetMenuItemInfo functions are available. */
HMODULE user32 = GetModuleHandle ("user32.dll");
get_menu_item_info = (GetMenuItemInfoA_Proc) GetProcAddress (user32, "GetMenuItemInfoA");
set_menu_item_info = (SetMenuItemInfoA_Proc) GetProcAddress (user32, "SetMenuItemInfoA");
unicode_append_menu = (AppendMenuW_Proc) GetProcAddress (user32, "AppendMenuW");
unicode_message_box = (MessageBoxW_Proc) GetProcAddress (user32, "MessageBoxW");
#endif /* !NTGUI_UNICODE */
}

14
src/w32proc.c
View file

@ -67,20 +67,6 @@ extern BOOL WINAPI IsValidLocale (LCID, DWORD);
Lisp_Object Qhigh, Qlow;
#ifdef EMACSDEBUG
void
_DebPrint (const char *fmt, ...)
{
char buf[1024];
va_list args;
va_start (args, fmt);
vsprintf (buf, fmt, args);
va_end (args);
OutputDebugString (buf);
}
#endif
typedef void (_CALLBACK_ *signal_handler) (int);
/* Signal handlers...SIG_DFL == 0 so this is initialized correctly. */

5
src/w32select.c
View file

@ -81,6 +81,11 @@ along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
#include "coding.h"
#include "composite.h"
#ifdef CYGWIN
#include <string.h>
#include <stdio.h>
#define _memccpy memccpy
#endif
static HGLOBAL convert_to_handle_as_ascii (void);
static HGLOBAL convert_to_handle_as_coded (Lisp_Object coding_system);

30
src/w32select.h Normal file
View file

@ -0,0 +1,30 @@
/* Selection processing for Emacs on the Microsoft W32 API.
Copyright (C) 1993-1994, 2001-2011 Free Software Foundation, Inc.
This file is part of GNU Emacs.
GNU Emacs is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
GNU Emacs is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
#ifndef W32SELECT_H
#define W32SELECT_H
#include <windows.h>
#define HAVE_W32SELECT 1
extern void syms_of_w32select (void);
extern void globals_of_w32select (void);
extern void term_w32select (void);
#endif

50
src/w32term.c
View file

@ -51,7 +51,14 @@ along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
#include "atimer.h"
#include "keymap.h"
#ifdef WINDOWSNT
#include "w32heap.h"
#endif
#ifndef WINDOWSNT
#include <io.h> /* for get_osfhandle */
#endif
#include <shellapi.h>
#include "font.h"
@ -121,7 +128,7 @@ typedef struct tagGLYPHSET
WCRANGE ranges[1];
} GLYPHSET;
#endif
#endif /* compiling for pre-Win2k */
/* Dynamic linking to SetLayeredWindowAttribute (only since 2000). */
BOOL (WINAPI *pfnSetLayeredWindowAttributes) (HWND, COLORREF, BYTE, DWORD);
@ -190,6 +197,13 @@ static int volatile input_signal_count;
static int input_signal_count;
#endif
#ifdef CYGWIN
int w32_message_fd = -1;
#endif /* CYGWIN */
/* Keyboard code page - may be changed by language-change events. */
static int keyboard_codepage;
static void x_update_window_end (struct window *, int, int);
static void w32_handle_tool_bar_click (struct frame *,
struct input_event *);
@ -4163,18 +4177,26 @@ w32_read_socket (struct terminal *terminal,
struct frame *f;
struct w32_display_info *dpyinfo = &one_w32_display_info;
Mouse_HLInfo *hlinfo = &dpyinfo->mouse_highlight;
static char buf[1];
block_input ();
/* So people can tell when we have read the available input. */
input_signal_count++;
/* Process any incoming thread messages. */
drain_message_queue ();
/* TODO: ghostscript integration. */
while (get_next_msg (&msg, FALSE))
{
struct input_event inev;
int do_help = 0;
/* DebPrint (("w32_read_socket: %s time:%u\n", */
/* w32_name_of_message (msg.msg.message), */
/* msg.msg.time)); */
EVENT_INIT (inev);
inev.kind = NO_EVENT;
inev.arg = Qnil;
@ -6307,8 +6329,15 @@ w32_term_init (Lisp_Object display_name, char *xrm_option, char *resource_name)
w32_defined_color (0, "black", &color, 1);
}
/* Add the default keyboard. */
#ifdef WINDOWSNT
/* Add the default keyboard. When !WINDOWSNT, we're using the
standard Emacs console handling machinery and don't need an
explicit FD here. */
add_keyboard_wait_descriptor (0);
#elif CYGWIN
/* /dev/windows wakes us up when we have a thread message pending. */
add_keyboard_wait_descriptor (w32_message_fd);
#endif
/* Create Fringe Bitmaps and store them for later use.
@ -6319,15 +6348,6 @@ w32_term_init (Lisp_Object display_name, char *xrm_option, char *resource_name)
the bitmaps. */
w32_init_fringe (terminal->rif);
#ifdef F_SETOWN
fcntl (connection, F_SETOWN, getpid ());
#endif /* ! defined (F_SETOWN) */
#ifdef SIGIO
if (interrupt_input)
init_sigio (connection);
#endif /* ! defined (SIGIO) */
unblock_input ();
return dpyinfo;
@ -6377,6 +6397,7 @@ x_delete_display (struct w32_display_info *dpyinfo)
w32_reset_fringes ();
}
/* Set up use of W32. */
@ -6414,6 +6435,11 @@ w32_initialize (void)
set_user_model (L"GNU.Emacs");
}
#ifdef CYGWIN
if ((w32_message_fd = open ("/dev/windows", O_RDWR | O_CLOEXEC)) == -1)
fatal ("opening /dev/windows: %s", strerror (errno));
#endif /* CYGWIN */
/* Initialize w32_use_visible_system_caret based on whether a screen
reader is in use. */
if (!SystemParametersInfo (SPI_GETSCREENREADER, 0,
@ -6574,4 +6600,6 @@ With MS Windows or Nextstep, the value is t. */);
staticpro (&last_mouse_motion_frame);
last_mouse_motion_frame = Qnil;
Fprovide (intern_c_string ("w32"), Qnil);
}

61
src/w32term.h
View file

@ -19,6 +19,8 @@ along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
/* Added by Kevin Gallo */
#include "w32gui.h"
#include "frame.h"
#include "atimer.h"
#define BLACK_PIX_DEFAULT(f) PALETTERGB(0,0,0)
@ -195,11 +197,45 @@ Lisp_Object display_x_get_resource (struct w32_display_info *,
Lisp_Object, Lisp_Object,
Lisp_Object, Lisp_Object);
extern void x_focus_on_frame (struct frame *f);
/* also defined in xterm.h XXX: factor out to common header */
extern struct w32_display_info *w32_term_init (Lisp_Object,
char *, char *);
extern void check_w32 (void);
extern int w32_defined_color (FRAME_PTR f, const char *color,
XColor *color_def, int alloc);
extern void x_set_window_size (struct frame *f, int change_grav,
int cols, int rows);
extern int x_display_pixel_height (struct w32_display_info *);
extern int x_display_pixel_width (struct w32_display_info *);
extern void x_sync (struct frame *);
extern Lisp_Object x_get_focus_frame (struct frame *);
extern void x_set_mouse_position (struct frame *f, int h, int v);
extern void x_set_mouse_pixel_position (struct frame *f, int pix_x, int pix_y);
extern void x_make_frame_visible (struct frame *f);
extern void x_make_frame_invisible (struct frame *f);
extern void x_iconify_frame (struct frame *f);
extern int x_char_width (struct frame *f);
extern int x_char_height (struct frame *f);
extern int x_pixel_width (struct frame *f);
extern int x_pixel_height (struct frame *f);
extern void x_set_frame_alpha (struct frame *f);
extern void x_set_menu_bar_lines (struct frame *, Lisp_Object, Lisp_Object);
extern void x_set_tool_bar_lines (struct frame *f,
Lisp_Object value,
Lisp_Object oldval);
extern void x_activate_menubar (struct frame *);
extern int x_bitmap_icon (struct frame *, Lisp_Object);
extern void initialize_frame_menubar (struct frame *);
extern void x_free_frame_resources (struct frame *);
extern void x_real_positions (struct frame *, int *, int *);
/* w32inevt.c */
extern int w32_kbd_patch_key (KEY_EVENT_RECORD *event, int cpId);
extern int w32_kbd_mods_to_emacs (DWORD mods, WORD key);
extern Lisp_Object x_get_focus_frame (struct frame *);
@ -583,8 +619,9 @@ do { \
#define WM_EMACS_HIDE_CARET (WM_EMACS_START + 18)
#define WM_EMACS_SETCURSOR (WM_EMACS_START + 19)
#define WM_EMACS_PAINT (WM_EMACS_START + 20)
#define WM_EMACS_BRINGTOTOP (WM_EMACS_START + 21)
#define WM_EMACS_END (WM_EMACS_START + 22)
#define WM_EMACS_BRINGTOTOP (WM_EMACS_START + 22)
#define WM_EMACS_INPUT_READY (WM_EMACS_START + 23)
#define WM_EMACS_END (WM_EMACS_START + 24)
#define WND_FONTWIDTH_INDEX (0)
#define WND_LINEHEIGHT_INDEX (4)
@ -606,6 +643,8 @@ typedef struct W32Msg {
RECT rect;
} W32Msg;
extern BOOL prepend_msg (W32Msg *lpmsg);
/* Structure for recording message when input thread must return a
result that depends on lisp thread to compute. Lisp thread can
complete deferred messages out of order. */
@ -709,3 +748,19 @@ extern HWND w32_system_caret_hwnd;
extern int w32_system_caret_height;
extern int w32_system_caret_x;
extern int w32_system_caret_y;
#if EMACSDEBUG
extern const char*
w32_name_of_message (UINT msg);
#endif /* EMACSDEBUG */
extern void syms_of_w32term (void);
extern void syms_of_w32menu (void);
extern void syms_of_w32fns (void);
extern void globals_of_w32menu (void);
extern void globals_of_w32fns (void);
#ifdef CYGWIN
extern int w32_message_fd;
#endif /* CYGWIN */

32
src/w32xfns.c
View file

@ -19,6 +19,7 @@ along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
#include <config.h>
#include <signal.h>
#include <stdio.h>
#include "lisp.h"
#include "keyboard.h"
#include "frame.h"
@ -32,7 +33,11 @@ along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
#define myfree(lp) GlobalFreePtr (lp)
CRITICAL_SECTION critsect;
#ifdef WINDOWSNT
extern HANDLE keyboard_handle;
#endif /* WINDOWSNT */
HANDLE input_available = NULL;
HANDLE interrupt_handle = NULL;
@ -43,7 +48,11 @@ init_crit (void)
/* For safety, input_available should only be reset by get_next_msg
when the input queue is empty, so make it a manual reset event. */
keyboard_handle = input_available = CreateEvent (NULL, TRUE, FALSE, NULL);
input_available = CreateEvent (NULL, TRUE, FALSE, NULL);
#ifdef WINDOWSNT
keyboard_handle = input_available;
#endif /* WINDOWSNT */
/* interrupt_handle is signaled when quit (C-g) is detected, so that
blocking system calls can be interrupted. We make it a manual
@ -240,6 +249,22 @@ get_next_msg (W32Msg * lpmsg, BOOL bWait)
return (bRet);
}
extern char * w32_strerror (int error_no);
/* Tell the main thread that we have input available; if the main
thread is blocked in select(), we wake it up here. */
static void
notify_msg_ready (void)
{
SetEvent (input_available);
#ifdef CYGWIN
/* Wakes up the main thread, which is blocked select()ing for /dev/windows,
among other files. */
(void) PostThreadMessage (dwMainThreadId, WM_EMACS_INPUT_READY, 0, 0);
#endif /* CYGWIN */
}
BOOL
post_msg (W32Msg * lpmsg)
{
@ -263,8 +288,7 @@ post_msg (W32Msg * lpmsg)
}
lpTail = lpNew;
SetEvent (input_available);
notify_msg_ready ();
leave_crit ();
return (TRUE);
@ -285,7 +309,7 @@ prepend_msg (W32Msg *lpmsg)
nQueue++;
lpNew->lpNext = lpHead;
lpHead = lpNew;
notify_msg_ready ();
leave_crit ();
return (TRUE);

2
src/window.c
View file

@ -43,7 +43,7 @@ along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
#ifdef HAVE_X_WINDOWS
#include "xterm.h"
#endif /* HAVE_X_WINDOWS */
#ifdef WINDOWSNT
#ifdef HAVE_NTGUI
#include "w32term.h"
#endif
#ifdef MSDOS

2
src/xdisp.c
View file

@ -302,7 +302,7 @@ along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
#ifdef HAVE_X_WINDOWS
#include "xterm.h"
#endif
#ifdef WINDOWSNT
#ifdef HAVE_NTGUI
#include "w32term.h"
#endif
#ifdef HAVE_NS

18
src/xfaces.c
View file

@ -227,13 +227,13 @@ along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
#ifdef HAVE_WINDOW_SYSTEM
#include TERM_HEADER
#include "fontset.h"
#ifdef WINDOWSNT
#ifdef HAVE_NTGUI
#undef FRAME_X_DISPLAY_INFO
#define FRAME_X_DISPLAY_INFO FRAME_W32_DISPLAY_INFO
#define x_display_info w32_display_info
#define check_x check_w32
#define GCGraphicsExposures 0
#endif /* WINDOWSNT */
#endif /* HAVE_NTGUI */
#ifdef HAVE_NS
#undef FRAME_X_DISPLAY_INFO
@ -625,7 +625,7 @@ x_free_gc (struct frame *f, GC gc)
#endif /* HAVE_X_WINDOWS */
#ifdef WINDOWSNT
#ifdef HAVE_NTGUI
/* W32 emulation of GCs */
static GC
@ -649,7 +649,7 @@ x_free_gc (struct frame *f, GC gc)
xfree (gc);
}
#endif /* WINDOWSNT */
#endif /* HAVE_NTGUI */
#ifdef HAVE_NS
/* NS emulation of GCs */
@ -719,7 +719,7 @@ init_frame_faces (struct frame *f)
#ifdef HAVE_X_WINDOWS
if (!FRAME_X_P (f) || FRAME_X_WINDOW (f))
#endif
#ifdef WINDOWSNT
#ifdef HAVE_NTGUI
if (!FRAME_WINDOW_P (f) || FRAME_W32_WINDOW (f))
#endif
#ifdef HAVE_NS
@ -1098,7 +1098,7 @@ defined_color (struct frame *f, const char *color_name, XColor *color_def,
else if (FRAME_X_P (f))
return x_defined_color (f, color_name, color_def, alloc);
#endif
#ifdef WINDOWSNT
#ifdef HAVE_NTGUI
else if (FRAME_W32_P (f))
return w32_defined_color (f, color_name, color_def, alloc);
#endif
@ -3245,7 +3245,7 @@ FRAME 0 means change the face on all frames, and change the default
param = Qbackground_color;
}
#ifdef HAVE_WINDOW_SYSTEM
#ifndef WINDOWSNT
#ifndef HAVE_NTGUI
else if (EQ (face, Qscroll_bar))
{
/* Changing the colors of `scroll-bar' sets frame parameters
@ -3255,7 +3255,7 @@ FRAME 0 means change the face on all frames, and change the default
else if (EQ (attr, QCbackground))
param = Qscroll_bar_background;
}
#endif /* not WINDOWSNT */
#endif /* not HAVE_NTGUI */
else if (EQ (face, Qborder))
{
/* Changing background color of `border' sets frame parameter
@ -6362,7 +6362,7 @@ where R,G,B are numbers between 0 and 255 and name is an arbitrary string. */)
if (num >= 0 && name[num] == '\n')
name[num] = 0;
cmap = Fcons (Fcons (build_string (name),
#ifdef WINDOWSNT
#ifdef HAVE_NTGUI
make_number (RGB (red, green, blue))),
#else
make_number ((red << 16) | (green << 8) | blue)),