Commit ee78dc32 authored by Geoff Voelker's avatar Geoff Voelker

Initial revision

parent e80af09c
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
/* Definitions and headers for communication with Win32 GUI.
Copyright (C) 1995 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 2, 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; see the file COPYING. If not, write to
the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
#ifndef __WIN32_H__
#define __WIN32_H__
#include <windows.h>
typedef struct W32FontStruct {
TEXTMETRIC tm;
HFONT hfont;
} W32FontStruct;
typedef HBITMAP Pixmap;
typedef HBITMAP Bitmap;
typedef struct W32FontStruct XFontStruct;
typedef HDC GC;
typedef COLORREF Color;
typedef DWORD Time;
typedef HWND Window;
typedef HCURSOR Cursor;
#define FACE_DEFAULT (~0)
extern HINSTANCE hinst;
extern HINSTANCE hprevinst;
extern LPSTR lpCmdLine;
extern int nCmdShow;
/* Bit Gravity */
#define ForgetGravity 0
#define NorthWestGravity 1
#define NorthGravity 2
#define NorthEastGravity 3
#define WestGravity 4
#define CenterGravity 5
#define EastGravity 6
#define SouthWestGravity 7
#define SouthGravity 8
#define SouthEastGravity 9
#define StaticGravity 10
#define NoValue 0x0000
#define XValue 0x0001
#define YValue 0x0002
#define WidthValue 0x0004
#define HeightValue 0x0008
#define AllValues 0x000F
#define XNegative 0x0010
#define YNegative 0x0020
#define USPosition (1L << 0) /* user specified x, y */
#define USSize (1L << 1) /* user specified width, height */
#define PPosition (1L << 2) /* program specified position */
#define PSize (1L << 3) /* program specified size */
#define PMinSize (1L << 4) /* program specified minimum size */
#define PMaxSize (1L << 5) /* program specified maximum size */
#define PResizeInc (1L << 6) /* program specified resize increments */
#define PAspect (1L << 7) /* program specified min and max aspect ratios */
#define PBaseSize (1L << 8) /* program specified base for incrementing */
#define PWinGravity (1L << 9) /* program specified window gravity */
extern int XParseGeometry ();
#endif
This diff is collapsed.
/* Emulate the X Resource Manager through the registry.
Copyright (C) 1990, 1993, 1994 Free Software Foundation.
This program 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 2, or (at your option)
any later version.
This program 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 this program; see the file COPYING. If not, write to
the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
/* Written by Kevin Gallo */
#include <config.h>
#include "lisp.h"
#include "w32term.h"
#include "blockinput.h"
#include <stdio.h>
#include <string.h>
#define REG_ROOT "SOFTWARE\\GNU\\Emacs\\"
LPBYTE
win32_get_string_resource (name, class, dwexptype)
char *name, *class;
DWORD dwexptype;
{
LPBYTE lpvalue = NULL;
HKEY hrootkey = NULL;
DWORD dwType;
DWORD cbData;
BOOL ok = FALSE;
BLOCK_INPUT;
/* Check both the current user and the local machine to see if we have any resources */
if (RegOpenKeyEx (HKEY_CURRENT_USER, REG_ROOT, 0, KEY_READ, &hrootkey) == ERROR_SUCCESS
|| RegOpenKeyEx (HKEY_LOCAL_MACHINE, REG_ROOT, 0, KEY_READ, &hrootkey) == ERROR_SUCCESS)
{
char *keyname;
if (RegQueryValueEx (hrootkey, name, NULL, &dwType, NULL, &cbData) == ERROR_SUCCESS
&& dwType == dwexptype)
{
keyname = name;
}
else if (RegQueryValueEx (hrootkey, class, NULL, &dwType, NULL, &cbData) == ERROR_SUCCESS
&& dwType == dwexptype)
{
keyname = class;
}
else
{
keyname = NULL;
}
ok = (keyname
&& (lpvalue = (LPBYTE) xmalloc (cbData)) != NULL
&& RegQueryValueEx (hrootkey, keyname, NULL, NULL, lpvalue, &cbData) == ERROR_SUCCESS);
RegCloseKey (hrootkey);
}
UNBLOCK_INPUT;
if (!ok)
{
if (lpvalue) xfree (lpvalue);
return (NULL);
}
else
{
return (lpvalue);
}
}
/* Retrieve the string resource specified by NAME with CLASS from
database RDB. */
char *
x_get_string_resource (rdb, name, class)
int rdb;
char *name, *class;
{
return (win32_get_string_resource (name, class, REG_SZ));
}
/* Win32 Selection processing for emacs
Copyright (C) 1993, 1994 Free Software Foundation.
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 2, 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; see the file COPYING. If not, write to
the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
/* Written by Kevin Gallo */
#include <config.h>
#include "lisp.h"
#include "w32term.h" /* for all of the win32 includes */
#include "dispextern.h" /* frame.h seems to want this */
#include "frame.h" /* Need this to get the X window of selected_frame */
#include "blockinput.h"
#if 0
DEFUN ("win32-open-clipboard", Fwin32_open_clipboard, Swin32_open_clipboard, 0, 1, 0,
"This opens the clipboard with the given frame pointer.")
(frame)
Lisp_Object frame;
{
BOOL ok = FALSE;
if (!NILP (frame))
CHECK_LIVE_FRAME (frame, 0);
BLOCK_INPUT;
ok = OpenClipboard ((!NILP (frame) && FRAME_WIN32_P (XFRAME (frame))) ? FRAME_WIN32_WINDOW (XFRAME (frame)) : NULL);
UNBLOCK_INPUT;
return (ok ? frame : Qnil);
}
DEFUN ("win32-empty-clipboard", Fwin32_empty_clipboard, Swin32_empty_clipboard, 0, 0, 0,
"This empties the clipboard and assigns ownership to the window which opened the clipboard.")
()
{
BOOL ok = FALSE;
BLOCK_INPUT;
ok = EmptyClipboard ();
UNBLOCK_INPUT;
return (ok ? Qt : Qnil);
}
DEFUN ("win32-close-clipboard", Fwin32_close_clipboard, Swin32_close_clipboard, 0, 0, 0,
"This closes the clipboard.")
()
{
BOOL ok = FALSE;
BLOCK_INPUT;
ok = CloseClipboard ();
UNBLOCK_INPUT;
return (ok ? Qt : Qnil);
}
#endif
DEFUN ("win32-set-clipboard-data", Fwin32_set_clipboard_data, Swin32_set_clipboard_data, 1, 2, 0,
"This sets the clipboard data to the given text.")
(string, frame)
Lisp_Object string, frame;
{
BOOL ok = TRUE;
HANDLE htext;
CHECK_STRING (string, 0);
if (!NILP (frame))
CHECK_LIVE_FRAME (frame, 0);
BLOCK_INPUT;
/* Allocate twice the amount so we can convert lf to cr-lf */
if ((htext = GlobalAlloc (GMEM_MOVEABLE | GMEM_DDESHARE, (2 * XSTRING (string)->size) + 1)) == NULL)
goto error;
{
unsigned char *lptext;
if ((lptext = (unsigned char *)GlobalLock (htext)) == NULL)
goto error;
{
int i = XSTRING (string)->size;
int newsize = XSTRING (string)->size;
register char *p1 = XSTRING (string)->data;
register char *p2 = lptext;
while (i--)
{
if (*p1 == '\n')
{
newsize++;
*p2++ = '\r';
}
*p2++ = *p1++;
}
*p2 = 0;
}
GlobalUnlock (htext);
}
if (!OpenClipboard ((!NILP (frame) && FRAME_WIN32_P (XFRAME (frame))) ? FRAME_WIN32_WINDOW (XFRAME (frame)) : NULL))
goto error;
ok = EmptyClipboard () && SetClipboardData (CF_TEXT, htext);
CloseClipboard ();
if (ok) goto done;
error:
ok = FALSE;
if (htext) GlobalFree (htext);
done:
UNBLOCK_INPUT;
return (ok ? string : Qnil);
}
DEFUN ("win32-get-clipboard-data", Fwin32_get_clipboard_data, Swin32_get_clipboard_data, 0, 1, 0,
"This gets the clipboard data in text format.")
(frame)
Lisp_Object frame;
{
HANDLE htext;
Lisp_Object ret = Qnil;
if (!NILP (frame))
CHECK_LIVE_FRAME (frame, 0);
BLOCK_INPUT;
if (!OpenClipboard ((!NILP (frame) && FRAME_WIN32_P (XFRAME (frame))) ? FRAME_WIN32_WINDOW (XFRAME (frame)) : NULL))
goto done;
if ((htext = GetClipboardData (CF_TEXT)) == NULL)
goto closeclip;
{
unsigned char *lptext;
int nbytes;
if ((lptext = (unsigned char *)GlobalLock (htext)) == NULL)
goto closeclip;
nbytes = strlen (lptext);
{
char *buf = (char *) xmalloc (nbytes);
register char *p1 = lptext;
register char *p2 = buf;
int i = nbytes;
if (buf == NULL) goto closeclip;
while (i--)
{
if (p1[0] == '\r' && i && p1[1] == '\n')
{
p1++;
i--;
nbytes--;
}
*p2++ = *p1++;
}
ret = make_string (buf, nbytes);
xfree (buf);
}
GlobalUnlock (htext);
}
closeclip:
CloseClipboard ();
done:
UNBLOCK_INPUT;
return (ret);
}
void
syms_of_win32select ()
{
#if 0
defsubr (&Swin32_open_clipboard);
defsubr (&Swin32_empty_clipboard);
defsubr (&Swin32_close_clipboard);
#endif
defsubr (&Swin32_set_clipboard_data);
defsubr (&Swin32_get_clipboard_data);
}
This diff is collapsed.
/* Functions taken directly from X sources
Copyright (C) 1989, 1992, 1993, 1994, 1995 Free Software Foundation.
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 2, 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; see the file COPYING. If not, write to
the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
#include <signal.h>
#include <config.h>
#include <stdio.h>
#include "lisp.h"
#include "blockinput.h"
#include "w32term.h"
#include "windowsx.h"
#define myalloc(cb) GlobalAllocPtr (GPTR, cb)
#define myfree(lp) GlobalFreePtr (lp)
CRITICAL_SECTION critsect;
extern HANDLE keyboard_handle;
HANDLE hEvent = NULL;
void
init_crit ()
{
InitializeCriticalSection (&critsect);
keyboard_handle = hEvent = CreateEvent (NULL, FALSE, FALSE, NULL);
}
void
enter_crit ()
{
EnterCriticalSection (&critsect);
}
void
leave_crit ()
{
LeaveCriticalSection (&critsect);
}
void
delete_crit ()
{
DeleteCriticalSection (&critsect);
if (hEvent)
{
CloseHandle (hEvent);
hEvent = NULL;
}
}
typedef struct int_msg
{
Win32Msg w32msg;
struct int_msg *lpNext;
} int_msg;
int_msg *lpHead = NULL;
int_msg *lpTail = NULL;
int nQueue = 0;
BOOL
get_next_msg (lpmsg, bWait)
Win32Msg * lpmsg;
BOOL bWait;
{
BOOL bRet = FALSE;
enter_crit ();
/* The while loop takes care of multiple sets */
while (!nQueue && bWait)
{
leave_crit ();
WaitForSingleObject (hEvent, INFINITE);
enter_crit ();
}
if (nQueue)
{
bcopy (&(lpHead->w32msg), lpmsg, sizeof (Win32Msg));
{
int_msg * lpCur = lpHead;
lpHead = lpHead->lpNext;
myfree (lpCur);
}
nQueue--;
bRet = TRUE;
}
leave_crit ();
return (bRet);
}
BOOL
post_msg (lpmsg)
Win32Msg * lpmsg;
{
int_msg * lpNew = (int_msg *) myalloc (sizeof (int_msg));
if (!lpNew) return (FALSE);
bcopy (lpmsg, &(lpNew->w32msg), sizeof (Win32Msg));
lpNew->lpNext = NULL;
enter_crit ();
if (nQueue++)
{
lpTail->lpNext = lpNew;
}
else
{
lpHead = lpNew;
SetEvent (hEvent);
}
lpTail = lpNew;
leave_crit ();
return (TRUE);
}
/*
* XParseGeometry parses strings of the form
* "=<width>x<height>{+-}<xoffset>{+-}<yoffset>", where
* width, height, xoffset, and yoffset are unsigned integers.
* Example: "=80x24+300-49"
* The equal sign is optional.
* It returns a bitmask that indicates which of the four values
* were actually found in the string. For each value found,
* the corresponding argument is updated; for each value
* not found, the corresponding argument is left unchanged.
*/
static int
read_integer (string, NextString)
register char *string;
char **NextString;
{
register int Result = 0;
int Sign = 1;
if (*string == '+')
string++;
else if (*string == '-')
{
string++;
Sign = -1;
}
for (; (*string >= '0') && (*string <= '9'); string++)
{
Result = (Result * 10) + (*string - '0');
}
*NextString = string;
if (Sign >= 0)
return (Result);
else
return (-Result);
}
int
XParseGeometry (string, x, y, width, height)
char *string;
int *x, *y;
unsigned int *width, *height; /* RETURN */
{
int mask = NoValue;
register char *strind;
unsigned int tempWidth, tempHeight;
int tempX, tempY;
char *nextCharacter;
if ((string == NULL) || (*string == '\0')) return (mask);
if (*string == '=')
string++; /* ignore possible '=' at beg of geometry spec */
strind = (char *)string;
if (*strind != '+' && *strind != '-' && *strind != 'x')
{
tempWidth = read_integer (strind, &nextCharacter);
if (strind == nextCharacter)
return (0);
strind = nextCharacter;
mask |= WidthValue;
}
if (*strind == 'x' || *strind == 'X')
{
strind++;
tempHeight = read_integer (strind, &nextCharacter);
if (strind == nextCharacter)
return (0);
strind = nextCharacter;
mask |= HeightValue;
}
if ((*strind == '+') || (*strind == '-'))
{
if (*strind == '-')
{
strind++;
tempX = -read_integer (strind, &nextCharacter);
if (strind == nextCharacter)
return (0);
strind = nextCharacter;
mask |= XNegative;
}
else
{
strind++;
tempX = read_integer (strind, &nextCharacter);
if (strind == nextCharacter)
return (0);
strind = nextCharacter;
}
mask |= XValue;
if ((*strind == '+') || (*strind == '-'))
{
if (*strind == '-')
{
strind++;
tempY = -read_integer (strind, &nextCharacter);
if (strind == nextCharacter)
return (0);
strind = nextCharacter;
mask |= YNegative;
}
else
{
strind++;
tempY = read_integer (strind, &nextCharacter);
if (strind == nextCharacter)
return (0);
strind = nextCharacter;
}
mask |= YValue;
}
}
/* If strind isn't at the end of the string the it's an invalid
geometry specification. */
if (*strind != '\0') return (0);
if (mask & XValue)
*x = tempX;
if (mask & YValue)
*y = tempY;
if (mask & WidthValue)
*width = tempWidth;
if (mask & HeightValue)
*height = tempHeight;
return (mask);
}
/* The semantics of the use of using_x_p is really using_a_window_system. */
int
using_x_p (void)
{
return 1;
}
/* x_sync is a no-op on Win32. */
void
x_sync (f)
void *f;
{
}
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment