#include <shellapi.h>
#include <ctype.h>
+#include <dlgs.h>
+#define FILE_NAME_TEXT_FIELD edt1
+
+void syms_of_w32fns ();
+void globals_of_w32fns ();
+
extern void free_frame_menubar ();
extern void x_compute_fringe_widths P_ ((struct frame *, int));
extern double atof ();
extern int quit_char;
-/* A definition of XColor for non-X frames. */
-#ifndef HAVE_X_WINDOWS
-typedef struct {
- unsigned long pixel;
- unsigned short red, green, blue;
- char flags;
- char pad;
-} XColor;
-#endif
-
extern char *lispy_function_keys[];
/* The gray bitmap `bitmaps/gray'. This is done because w32term.c uses
Lisp_Object Qauto_raise;
Lisp_Object Qauto_lower;
-Lisp_Object Qbar;
Lisp_Object Qborder_color;
Lisp_Object Qborder_width;
-Lisp_Object Qbox;
+extern Lisp_Object Qbox;
Lisp_Object Qcursor_color;
Lisp_Object Qcursor_type;
Lisp_Object Qgeometry;
extern Lisp_Object Qtop;
extern Lisp_Object Qdisplay;
-extern Lisp_Object Qtool_bar_lines;
/* State variables for emulating a three button mouse. */
#define LMOUSE 1
/* Window that is tracking the mouse. */
static HWND track_mouse_window;
-FARPROC track_mouse_event_fn;
+
+typedef BOOL (WINAPI * TrackMouseEvent_Proc) (
+ IN OUT LPTRACKMOUSEEVENT lpEventTrack
+ );
+
+TrackMouseEvent_Proc track_mouse_event_fn=NULL;
/* W95 mousewheel handler */
-unsigned int msh_mousewheel = 0;
+unsigned int msh_mousewheel = 0;
/* Timers */
#define MOUSE_BUTTON_ID 1
/* Nonzero if we can use mouse menus.
You should not call this unless HAVE_MENUS is defined. */
-
+
int
have_menus_p ()
{
return f;
}
-/* Let the user specify an display with a frame.
+/* Let the user specify a display with a frame.
nil stands for the selected frame--or, if that is not a w32 frame,
the first display on the list. */
if (NILP (frame))
{
struct frame *sf = XFRAME (selected_frame);
-
+
if (FRAME_W32_P (sf) && FRAME_LIVE_P (sf))
return FRAME_W32_DISPLAY_INFO (sf);
else
{
if (dpyinfo->bitmaps[id].refcount
&& dpyinfo->bitmaps[id].file
- && !strcmp (dpyinfo->bitmaps[id].file, (char *) XSTRING (file)->data))
+ && !strcmp (dpyinfo->bitmaps[id].file, (char *) SDATA (file)))
{
++dpyinfo->bitmaps[id].refcount;
return id + 1;
}
/* Search bitmap-file-path for the file, if appropriate. */
- fd = openp (Vx_bitmap_file_path, file, Qnil, &found, 0);
+ fd = openp (Vx_bitmap_file_path, file, Qnil, &found, Qnil);
if (fd < 0)
return -1;
emacs_close (fd);
- filename = (char *) XSTRING (found)->data;
+ filename = (char *) SDATA (found);
hinst = LoadLibraryEx (filename, NULL, LOAD_LIBRARY_AS_DATAFILE);
if (hinst == NULL)
return -1;
-
+
result = XReadBitmapFile (FRAME_W32_DISPLAY (f), FRAME_W32_WINDOW (f),
filename, &width, &height, &bitmap, &xhot, &yhot);
if (result != BitmapSuccess)
id = x_allocate_bitmap_record (f);
dpyinfo->bitmaps[id - 1].pixmap = bitmap;
dpyinfo->bitmaps[id - 1].refcount = 1;
- dpyinfo->bitmaps[id - 1].file = (char *) xmalloc (XSTRING (file)->size + 1);
+ dpyinfo->bitmaps[id - 1].file = (char *) xmalloc (SCHARS (file) + 1);
dpyinfo->bitmaps[id - 1].depth = 1;
dpyinfo->bitmaps[id - 1].height = height;
dpyinfo->bitmaps[id - 1].width = width;
- strcpy (dpyinfo->bitmaps[id - 1].file, XSTRING (file)->data);
+ strcpy (dpyinfo->bitmaps[id - 1].file, SDATA (file));
return id;
#endif /* TODO */
They are independent of other properties, but other properties (e.g.,
cursor_color) are dependent upon them. */
/* Process default font as well, since fringe widths depends on it. */
- for (p = 0; p < i; p++)
+ for (p = 0; p < i; p++)
{
Lisp_Object prop, val;
if (NILP (Fequal (val, old_value)))
{
store_frame_param (f, prop, val);
-
+
param_index = Fget (prop, Qx_frame_parameter);
if (NATNUMP (param_index)
&& (XFASTINT (param_index)
position. Resize of the frame is taken care of in the code after
this if-statement. */
int new_left, new_top;
-
+
x_fullscreen_adjust (f, &width, &height, &new_top, &new_left);
x_fullscreen_move (f, new_top, new_left);
}
CHECK_STRING (filename);
abspath = Fexpand_file_name (filename, Qnil);
- fp = fopen (XSTRING (filename)->data, "rt");
+ fp = fopen (SDATA (filename), "rt");
if (fp)
{
char buf[512];
}
/* The default colors for the w32 color map */
-typedef struct colormap_t
+typedef struct colormap_t
{
char *name;
COLORREF colorref;
} colormap_t;
-colormap_t w32_color_map[] =
+colormap_t w32_color_map[] =
{
{"snow" , PALETTERGB (255,250,250)},
{"ghost white" , PALETTERGB (248,248,255)},
int i;
colormap_t *pc = w32_color_map;
Lisp_Object cmap;
-
+
BLOCK_INPUT;
-
+
cmap = Qnil;
-
- for (i = 0; i < sizeof (w32_color_map) / sizeof (w32_color_map[0]);
+
+ for (i = 0; i < sizeof (w32_color_map) / sizeof (w32_color_map[0]);
pc++, i++)
cmap = Fcons (Fcons (build_string (pc->name),
make_number (pc->colorref)),
cmap);
-
+
UNBLOCK_INPUT;
-
+
return (cmap);
}
-Lisp_Object
+Lisp_Object
w32_to_x_color (rgb)
Lisp_Object rgb;
{
Lisp_Object color;
-
+
CHECK_NUMBER (rgb);
-
+
BLOCK_INPUT;
-
+
color = Frassq (rgb, Vw32_color_map);
-
+
UNBLOCK_INPUT;
-
+
if (!NILP (color))
return (Fcar (color));
else
tem = Fcar (elt);
- if (lstrcmpi (XSTRING (tem)->data, colorname) == 0)
+ if (lstrcmpi (SDATA (tem), colorname) == 0)
{
ret = XUINT (Fcdr (elt));
break;
return ret;
}
-COLORREF
+COLORREF
x_to_w32_color (colorname)
char * colorname;
{
char *color;
int size;
color = colorname + 1;
-
+
size = strlen(color);
if (size == 3 || size == 6 || size == 9 || size == 12)
{
pos = 0;
size /= 3;
colorval = 0;
-
+
for (i = 0; i < 3; i++)
{
char *end;
{
char *end;
unsigned long value;
-
+
/* The check for 'x' in the following conditional takes into
account the fact that strtol allows a "0x" in front of
our numbers, and we don't. */
if (value < 0.0 || value > 1.0)
break;
val = (UINT)(0x100 * value);
- /* We used 0x100 instead of 0xFF to give an continuous
+ /* We used 0x100 instead of 0xFF to give a continuous
range between 0.0 and 1.0 inclusive. The next statement
fixes the 1.0 case. */
if (val == 0x100)
RGB. */
/* If we fail to lookup the color name in w32_color_map, then check the
- colorname to see if it can be crudely approximated: If the X color
+ colorname to see if it can be crudely approximated: If the X color
ends in a number (e.g., "darkseagreen2"), strip the number and
return the result of looking up the base color name. */
ret = w32_color_map_lookup (colorname);
- if (NILP (ret))
+ if (NILP (ret))
{
int len = strlen (colorname);
- if (isdigit (colorname[len - 1]))
+ if (isdigit (colorname[len - 1]))
{
char *ptr, *approx = alloca (len + 1);
strcpy (approx, colorname);
ptr = &approx[len - 1];
- while (ptr > approx && isdigit (*ptr))
+ while (ptr > approx && isdigit (*ptr))
*ptr-- = '\0';
ret = w32_color_map_lookup (approx);
}
}
-
+
UNBLOCK_INPUT;
return ret;
}
tem = x_to_w32_color (color);
- if (!NILP (tem))
+ if (!NILP (tem))
{
if (f)
{
one_w32_display_info.color_list;
struct w32_palette_entry ** prev =
&one_w32_display_info.color_list;
-
+
/* check if color is already mapped */
while (entry)
{
w32_color_ref = XUINT (tem) | 0x2000000;
color_def->pixel = w32_color_ref;
- color_def->red = GetRValue (w32_color_ref);
- color_def->green = GetGValue (w32_color_ref);
- color_def->blue = GetBValue (w32_color_ref);
+ color_def->red = GetRValue (w32_color_ref) * 256;
+ color_def->green = GetGValue (w32_color_ref) * 256;
+ color_def->blue = GetBValue (w32_color_ref) * 256;
return 1;
}
- else
+ else
{
return 0;
}
CHECK_STRING (arg);
- if (strcmp (XSTRING (arg)->data, "black") == 0)
+ if (strcmp (SDATA (arg), "black") == 0)
return BLACK_PIX_DEFAULT (f);
- else if (strcmp (XSTRING (arg)->data, "white") == 0)
+ else if (strcmp (SDATA (arg), "white") == 0)
return WHITE_PIX_DEFAULT (f);
if ((FRAME_W32_DISPLAY_INFO (f)->n_planes * FRAME_W32_DISPLAY_INFO (f)->n_cbits) == 1)
/* w32_defined_color is responsible for coping with failures
by looking for a near-miss. */
- if (w32_defined_color (f, XSTRING (arg)->data, &cdef, 1))
+ if (w32_defined_color (f, SDATA (arg), &cdef, 1))
return cdef.pixel;
/* defined_color failed; return an ultimate default. */
else
hourglass_cursor = XCreateFontCursor (FRAME_W32_DISPLAY (f), XC_watch);
x_check_errors (FRAME_W32_DISPLAY (f), "bad busy pointer cursor: %s");
-
+
x_check_errors (FRAME_W32_DISPLAY (f), "bad nontext pointer cursor: %s");
if (!EQ (Qnil, Vx_mode_pointer_shape))
{
&& f->output_data.w32->modeline_cursor != 0)
XFreeCursor (FRAME_W32_DISPLAY (f), f->output_data.w32->modeline_cursor);
f->output_data.w32->modeline_cursor = mode_cursor;
-
+
if (cross_cursor != f->output_data.w32->cross_cursor
&& f->output_data.w32->cross_cursor != 0)
XFreeCursor (FRAME_W32_DISPLAY (f), f->output_data.w32->cross_cursor);
fore_pixel = FRAME_BACKGROUND_PIXEL (f);
pixel = x_decode_color (f, arg, BLACK_PIX_DEFAULT (f));
-
+
/* Make sure that the cursor color differs from the background color. */
if (pixel == FRAME_BACKGROUND_PIXEL (f))
{
if (FRAME_W32_WINDOW (f) != 0)
{
+ BLOCK_INPUT;
+ /* Update frame's cursor_gc. */
+ f->output_data.w32->cursor_gc->foreground = fore_pixel;
+ f->output_data.w32->cursor_gc->background = pixel;
+
+ UNBLOCK_INPUT;
+
if (FRAME_VISIBLE_P (f))
{
x_update_cursor (f, 0);
/* Set the border-color of frame F to pixel value PIX.
Note that this does not fully take effect if done before
- F has an window. */
+ F has a window. */
void
x_set_border_pixel (f, pix)
struct frame *f;
update_face_from_frame_parameter (f, Qborder_color, arg);
}
-/* Value is the internal representation of the specified cursor type
- ARG. If type is BAR_CURSOR, return in *WIDTH the specified width
- of the bar cursor. */
-
-enum text_cursor_kinds
-x_specified_cursor_type (arg, width)
- Lisp_Object arg;
- int *width;
-{
- enum text_cursor_kinds type;
-
- if (EQ (arg, Qbar))
- {
- type = BAR_CURSOR;
- *width = 2;
- }
- else if (CONSP (arg)
- && EQ (XCAR (arg), Qbar)
- && INTEGERP (XCDR (arg))
- && XINT (XCDR (arg)) >= 0)
- {
- type = BAR_CURSOR;
- *width = XINT (XCDR (arg));
- }
- else if (NILP (arg))
- type = NO_CURSOR;
- else
- /* Treat anything unknown as "box cursor".
- It was bad to signal an error; people have trouble fixing
- .Xdefaults with Emacs, when it has something bad in it. */
- type = FILLED_BOX_CURSOR;
-
- return type;
-}
void
x_set_cursor_type (f, arg, oldval)
FRAME_PTR f;
Lisp_Object arg, oldval;
{
- int width;
-
- FRAME_DESIRED_CURSOR (f) = x_specified_cursor_type (arg, &width);
- f->output_data.w32->cursor_width = width;
+ set_frame_cursor_types (f, arg);
/* Make sure the cursor gets redrawn. This is overkill, but how
often do people change cursor types? */
if (NILP (arg) && NILP (oldval))
return;
- if (STRINGP (arg) && STRINGP (oldval)
+ if (STRINGP (arg) && STRINGP (oldval)
&& EQ (Fstring_equal (oldval, arg), Qt))
return;
BLOCK_INPUT;
result = x_text_icon (f,
- (char *) XSTRING ((!NILP (f->icon_name)
- ? f->icon_name
- : !NILP (f->title)
- ? f->title
- : f->name))->data);
+ (char *) SDATA ((!NILP (f->icon_name)
+ ? f->icon_name
+ : !NILP (f->title)
+ ? f->title
+ : f->name)));
if (result)
{
BLOCK_INPUT;
result = (STRINGP (fontset_name)
- ? x_new_fontset (f, XSTRING (fontset_name)->data)
- : x_new_font (f, XSTRING (arg)->data));
+ ? x_new_fontset (f, SDATA (fontset_name))
+ : x_new_font (f, SDATA (arg)));
UNBLOCK_INPUT;
-
+
if (EQ (result, Qnil))
- error ("Font `%s' is not defined", XSTRING (arg)->data);
+ error ("Font `%s' is not defined", SDATA (arg));
else if (EQ (result, Qt))
error ("The characters of the given font have varying widths");
else if (STRINGP (result))
Lisp_Object name;
int explicit;
{
- /* Make sure that requests from lisp code override requests from
+ /* Make sure that requests from lisp code override requests from
Emacs redisplay code. */
if (explicit)
{
/* Check for no change needed in this very common case
before we do any consing. */
if (!strcmp (FRAME_W32_DISPLAY_INFO (f)->w32_id_name,
- XSTRING (f->name)->data))
+ SDATA (f->name)))
return;
name = build_string (FRAME_W32_DISPLAY_INFO (f)->w32_id_name);
}
name = ENCODE_SYSTEM (name);
BLOCK_INPUT;
- SetWindowText(FRAME_W32_WINDOW (f), XSTRING (name)->data);
+ SetWindowText(FRAME_W32_WINDOW (f), SDATA (name));
UNBLOCK_INPUT;
}
}
name = ENCODE_SYSTEM (name);
BLOCK_INPUT;
- SetWindowText(FRAME_W32_WINDOW (f), XSTRING (name)->data);
+ SetWindowText(FRAME_W32_WINDOW (f), SDATA (name));
UNBLOCK_INPUT;
}
}
/* Put scroll bars on the right by default, as is conventional
on MS-Windows. */
EQ (Qleft, arg)
- ? vertical_scroll_bar_left
+ ? vertical_scroll_bar_left
: vertical_scroll_bar_right;
/* We set this parameter before creating the window for the
}
change_frame_size (f, 0, FRAME_WIDTH (f), 0, 0, 0);
XWINDOW (FRAME_SELECTED_WINDOW (f))->cursor.hpos = 0;
- XWINDOW (FRAME_SELECTED_WINDOW (f))->cursor.x = 0;
+ XWINDOW (FRAME_SELECTED_WINDOW (f))->cursor.x = 0;
}
\f
-/* Subroutines of creating an frame. */
+/* Subroutines of creating a frame. */
/* Make sure that Vx_resource_name is set to a reasonable value.
Fix it up, or set it to `emacs' if it is too hopeless. */
if (STRINGP (Vx_resource_name))
{
- unsigned char *p = XSTRING (Vx_resource_name)->data;
+ unsigned char *p = SDATA (Vx_resource_name);
int i;
- len = STRING_BYTES (XSTRING (Vx_resource_name));
+ len = SBYTES (Vx_resource_name);
/* Only letters, digits, - and _ are valid in resource names.
Count the valid characters and count the invalid ones. */
for (i = 0; i < len; i++)
{
- int c = XSTRING (new)->data[i];
+ int c = SREF (new, i);
if (! ((c >= 'a' && c <= 'z')
|| (c >= 'A' && c <= 'Z')
|| (c >= '0' && c <= '9')
|| c == '-' || c == '_'))
- XSTRING (new)->data[i] = '_';
+ SSET (new, i, '_');
}
}
/* Allocate space for the components, the dots which separate them,
and the final '\0'. Make them big enough for the worst case. */
- name_key = (char *) alloca (STRING_BYTES (XSTRING (Vx_resource_name))
+ name_key = (char *) alloca (SBYTES (Vx_resource_name)
+ (STRINGP (component)
- ? STRING_BYTES (XSTRING (component)) : 0)
- + STRING_BYTES (XSTRING (attribute))
+ ? SBYTES (component) : 0)
+ + SBYTES (attribute)
+ 3);
class_key = (char *) alloca ((sizeof (EMACS_CLASS) - 1)
- + STRING_BYTES (XSTRING (class))
+ + SBYTES (class)
+ (STRINGP (subclass)
- ? STRING_BYTES (XSTRING (subclass)) : 0)
+ ? SBYTES (subclass) : 0)
+ 3);
/* Start with emacs.FRAMENAME for the name (the specific one)
and with `Emacs' for the class key (the general one). */
- strcpy (name_key, XSTRING (Vx_resource_name)->data);
+ strcpy (name_key, SDATA (Vx_resource_name));
strcpy (class_key, EMACS_CLASS);
strcat (class_key, ".");
- strcat (class_key, XSTRING (class)->data);
+ strcat (class_key, SDATA (class));
if (!NILP (component))
{
strcat (class_key, ".");
- strcat (class_key, XSTRING (subclass)->data);
+ strcat (class_key, SDATA (subclass));
strcat (name_key, ".");
- strcat (name_key, XSTRING (component)->data);
+ strcat (name_key, SDATA (component));
}
strcat (name_key, ".");
- strcat (name_key, XSTRING (attribute)->data);
+ strcat (name_key, SDATA (attribute));
value = x_get_string_resource (Qnil,
name_key, class_key);
/* Allocate space for the components, the dots which separate them,
and the final '\0'. */
- name_key = (char *) alloca (STRING_BYTES (XSTRING (Vinvocation_name))
+ name_key = (char *) alloca (SBYTES (Vinvocation_name)
+ strlen (attribute) + 2);
class_key = (char *) alloca ((sizeof (EMACS_CLASS) - 1)
+ strlen (class) + 2);
sprintf (name_key, "%s.%s",
- XSTRING (Vinvocation_name)->data,
+ SDATA (Vinvocation_name),
attribute);
sprintf (class_key, "%s.%s", EMACS_CLASS, class);
switch (type)
{
case RES_TYPE_NUMBER:
- return make_number (atoi (XSTRING (tem)->data));
+ return make_number (atoi (SDATA (tem)));
case RES_TYPE_FLOAT:
- return make_float (atof (XSTRING (tem)->data));
+ return make_float (atof (SDATA (tem)));
case RES_TYPE_BOOLEAN:
tem = Fdowncase (tem);
- if (!strcmp (XSTRING (tem)->data, "on")
- || !strcmp (XSTRING (tem)->data, "true"))
+ if (!strcmp (SDATA (tem), "on")
+ || !strcmp (SDATA (tem), "true"))
return Qt;
- else
+ else
return Qnil;
case RES_TYPE_STRING:
{
Lisp_Object lower;
lower = Fdowncase (tem);
- if (!strcmp (XSTRING (lower)->data, "on")
- || !strcmp (XSTRING (lower)->data, "true"))
+ if (!strcmp (SDATA (lower), "on")
+ || !strcmp (SDATA (lower), "true"))
return Qt;
- else if (!strcmp (XSTRING (lower)->data, "off")
- || !strcmp (XSTRING (lower)->data, "false"))
+ else if (!strcmp (SDATA (lower), "off")
+ || !strcmp (SDATA (lower), "false"))
return Qnil;
else
return Fintern (tem, Qnil);
CHECK_STRING (string);
- geometry = XParseGeometry ((char *) XSTRING (string)->data,
+ geometry = XParseGeometry ((char *) SDATA (string),
&x, &y, &width, &height);
result = Qnil;
extern LRESULT CALLBACK w32_wnd_proc ();
-BOOL
+BOOL
w32_init_class (hinst)
HINSTANCE hinst;
{
return (RegisterClass (&wc));
}
-HWND
+HWND
w32_createscrollbar (f, bar)
struct frame *f;
struct scroll_bar * bar;
return (CreateWindow ("SCROLLBAR", "", SBS_VERT | WS_CHILD | WS_VISIBLE,
/* Position and size of scroll bar. */
XINT(bar->left) + VERTICAL_SCROLL_BAR_WIDTH_TRIM,
- XINT(bar->top),
+ XINT(bar->top),
XINT(bar->width) - VERTICAL_SCROLL_BAR_WIDTH_TRIM * 2,
XINT(bar->height),
FRAME_W32_WINDOW (f),
NULL));
}
-void
+void
w32_createwindow (f)
struct frame *f;
{
rect.left = rect.top = 0;
rect.right = PIXEL_WIDTH (f);
rect.bottom = PIXEL_HEIGHT (f);
-
+
AdjustWindowRect (&rect, f->output_data.w32->dwStyle,
FRAME_EXTERNAL_MENU_BAR (f));
-
+
/* Do first time app init */
-
+
if (!hprevinst)
{
w32_init_class (hinst);
}
-
+
FRAME_W32_WINDOW (f) = hwnd
= CreateWindow (EMACS_CLASS,
f->namebuf,
/* Enable drag-n-drop. */
DragAcceptFiles (hwnd, TRUE);
-
+
/* Do this to discard the default setting specified by our parent. */
ShowWindow (hwnd, SW_HIDE);
}
}
-void
+void
my_post_msg (wmsg, hwnd, msg, wParam, lParam)
W32Msg * wmsg;
HWND hwnd;
}
/* Emacs can lose focus while a modifier key has been pressed. When
- it regains focus, be conservative and clear all modifiers since
+ it regains focus, be conservative and clear all modifiers since
we cannot reconstruct the left and right modifier state. */
static void
reset_modifiers ()
if (!modifiers_recorded)
return;
- if (!(GetKeyState (VK_CONTROL) & 0x8000))
+ if (!(GetKeyState (VK_CONTROL) & 0x8000))
modifiers[EMACS_RCONTROL] = modifiers[EMACS_LCONTROL] = 0;
- if (!(GetKeyState (VK_MENU) & 0x8000))
+ if (!(GetKeyState (VK_MENU) & 0x8000))
modifiers[EMACS_RMENU] = modifiers[EMACS_LMENU] = 0;
}
HWND focus_window;
msh_mousewheel = RegisterWindowMessage (MSH_MOUSEWHEEL);
-
+
while (GetMessage (&msg, NULL, 0, 0))
{
if (msg.hwnd == NULL)
PostThreadMessage (dwWindowsThreadId, WM_NULL, 0, 0);
}
-DWORD
+DWORD
w32_msg_worker (dw)
DWORD dw;
{
deferred_msg dummy_buf;
/* Ensure our message queue is created */
-
+
PeekMessage (&msg, NULL, 0, 0, PM_NOREMOVE);
-
+
if (!PostThreadMessage (dwMainThreadId, WM_EMACS_DONE, 0, 0))
abort ();
/* Main window procedure */
-LRESULT CALLBACK
+LRESULT CALLBACK
w32_wnd_proc (hwnd, msg, wParam, lParam)
HWND hwnd;
UINT msg;
w32_clear_rect, because these functions must obtain a DC handle
from the frame struct using get_frame_dc which is thread-aware. */
- switch (msg)
+ switch (msg)
{
case WM_ERASEBKGND:
f = x_window_to_frame (dpyinfo, hwnd);
leave_crit ();
my_post_msg (&wmsg, hwnd, msg, wParam, lParam);
-
+
return 0;
}
return 0;
break;
case VK_MENU:
- if (NILP (Vw32_pass_alt_to_system))
+ if (NILP (Vw32_pass_alt_to_system))
/* Prevent DefWindowProc from activating the menu bar if an
Alt key is pressed and released by itself. */
return 0;
windows_translate = 1;
break;
- case VK_CAPITAL:
+ case VK_CAPITAL:
/* Decide whether to treat as modifier or function key. */
if (NILP (Vw32_enable_caps_lock))
goto disable_lock_key;
w32_get_key_modifiers (wParam, lParam));
windows_translate = 1;
break;
- case VK_CONTROL:
+ case VK_CONTROL:
case VK_SHIFT:
case VK_PROCESSKEY: /* Generated by IME. */
windows_translate = 1;
int add;
int isdead = 0;
KEY_EVENT_RECORD key;
-
+
key.bKeyDown = TRUE;
key.wRepeatCount = 1;
key.wVirtualKeyCode = wParam;
}
/* Fall through */
-
+
case WM_SYSCHAR:
case WM_CHAR:
post_character_message (hwnd, msg, wParam, lParam,
{
if (up) ReleaseCapture ();
else SetCapture (hwnd);
- button = (button == 0) ? LMOUSE :
+ button = (button == 0) ? LMOUSE :
((button == 1) ? MMOUSE : RMOUSE);
if (up)
button_state &= ~button;
button_state |= button;
}
}
-
+
wmsg.dwModifiers = w32_get_modifiers ();
my_post_msg (&wmsg, hwnd, msg, wParam, lParam);
my_post_msg (&wmsg, hwnd, msg, wParam, lParam);
return 0;
}
-
+
/* Hang onto mouse move and scroll messages for a bit, to avoid
sending such events to Emacs faster than it can process them.
If we get more events before the timer from the first message
saved_mouse_move_msg.msg.lParam = lParam;
saved_mouse_move_msg.msg.time = GetMessageTime ();
saved_mouse_move_msg.dwModifiers = w32_get_modifiers ();
-
+
return 0;
case WM_MOUSEWHEEL:
}
}
return 0;
-
+
case WM_NCACTIVATE:
/* Windows doesn't send us focus messages when putting up and
taking down a system popup dialog as for Ctrl-Alt-Del on Windows 95.
if (menu_free_timer)
{
KillTimer (hwnd, menu_free_timer);
- menu_free_timer = 0;
+ menu_free_timer = 0;
}
}
case WM_MOVE:
wp.length = sizeof (WINDOWPLACEMENT);
GetWindowPlacement (hwnd, &wp);
-
+
if (wp.showCmd != SW_SHOWMINIMIZED && (lppos->flags & SWP_NOSIZE) == 0)
{
RECT rect;
DWORD internal_border;
DWORD scrollbar_extra;
RECT wr;
-
+
wp.length = sizeof(wp);
GetWindowRect (hwnd, &wr);
-
+
enter_crit ();
-
+
font_width = GetWindowLong (hwnd, WND_FONTWIDTH_INDEX);
line_height = GetWindowLong (hwnd, WND_LINEHEIGHT_INDEX);
internal_border = GetWindowLong (hwnd, WND_BORDER_INDEX);
scrollbar_extra = GetWindowLong (hwnd, WND_SCROLLBAR_INDEX);
-
+
leave_crit ();
-
+
memset (&rect, 0, sizeof (rect));
- AdjustWindowRect (&rect, GetWindowLong (hwnd, GWL_STYLE),
+ AdjustWindowRect (&rect, GetWindowLong (hwnd, GWL_STYLE),
GetMenu (hwnd) != NULL);
/* Force width and height of client area to be exact
hdiff = (lppos->cy - (rect.bottom - rect.top)
- 2 * internal_border)
% line_height;
-
+
if (wdiff || hdiff)
{
- /* For right/bottom sizing we can just fix the sizes.
- However for top/left sizing we will need to fix the X
+ /* For right/bottom sizing we can just fix the sizes.
+ However for top/left sizing we will need to fix the X
and Y positions as well. */
-
+
lppos->cx -= wdiff;
lppos->cy -= hdiff;
-
- if (wp.showCmd != SW_SHOWMAXIMIZED
+
+ if (wp.showCmd != SW_SHOWMAXIMIZED
&& (lppos->flags & SWP_NOMOVE) == 0)
{
if (lppos->x != wr.left || lppos->y != wr.top)
lppos->flags |= SWP_NOMOVE;
}
}
-
+
return 0;
}
}
}
-
+
goto dflt;
case WM_GETMINMAXINFO:
CreateCaret (hwnd, NULL, 0,
w32_system_caret_height);
}
-
+
if (!SetCaretPos (w32_system_caret_x, w32_system_caret_y))
return 0;
/* Ensure visible caret gets turned on when requested. */
flags |= TPM_LEFTBUTTON;
else if (button_state & RMOUSE)
flags |= TPM_RIGHTBUTTON;
-
+
/* Remember we did a SetCapture on the initial mouse down event,
so for safety, we make sure the capture is cancelled now. */
ReleaseCapture ();
f = x_window_to_frame (dpyinfo, hwnd);
if (f)
f->output_data.w32->menubar_active = 1;
-
- if (TrackPopupMenu ((HMENU)wParam, flags, pos->x, pos->y,
+
+ if (TrackPopupMenu ((HMENU)wParam, flags, pos->x, pos->y,
0, hwnd, NULL))
{
MSG amsg;
my_post_msg (&wmsg, hwnd, msg, wParam, lParam);
return 0;
}
-
+
dflt:
return DefWindowProc (hwnd, msg, wParam, lParam);
}
-
+
/* The most common default return code for handled messages is 0. */
return 0;
}
-void
+void
my_create_window (f)
struct frame * f;
{
indirectly via the Window thread, as we do not need to process Window
messages for the tooltip. Creating tooltips indirectly also creates
deadlocks when tooltips are created for menu items. */
-void
+void
my_create_tip_window (f)
struct frame *f;
{
for the window manager, so GC relocation won't bother it.
Elsewhere we specify the window name for the window manager. */
-
+
{
- char *str = (char *) XSTRING (Vx_resource_name)->data;
+ char *str = (char *) SDATA (Vx_resource_name);
f->namebuf = (char *) xmalloc (strlen (str) + 1);
strcpy (f->namebuf, str);
}
? IconicState
: NormalState));
- x_text_icon (f, (char *) XSTRING ((!NILP (f->icon_name)
+ x_text_icon (f, (char *) SDATA ((!NILP (f->icon_name)
? f->icon_name
- : f->name))->data);
+ : f->name)));
#endif
UNBLOCK_INPUT;
#ifdef GLYPH_DEBUG
struct w32_display_info *dpyinfo = FRAME_W32_DISPLAY_INFO (f);
#endif
-
+
x_free_frame_resources (f);
/* Check that reference counts are indeed correct. */
return Qt;
}
-
+
return Qnil;
}
int minibuffer_only = 0;
long window_prompting = 0;
int width, height;
- int count = BINDING_STACK_SIZE ();
+ int count = SPECPDL_INDEX ();
struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
Lisp_Object display;
struct w32_display_info *dpyinfo = NULL;
{
tem = Fquery_fontset (font, Qnil);
if (STRINGP (tem))
- font = x_new_fontset (f, XSTRING (tem)->data);
+ font = x_new_fontset (f, SDATA (tem));
else
- font = x_new_font (f, XSTRING (font)->data);
+ font = x_new_font (f, SDATA (font));
}
/* Try out a font which we hope has bold and italic variations. */
if (!STRINGP (font))
if (! STRINGP (font))
font = build_string ("Fixedsys");
- x_default_parameter (f, parms, Qfont, font,
+ x_default_parameter (f, parms, Qfont, font,
"font", "Font", RES_TYPE_STRING);
}
end up in init_iterator with a null face cache, which should not
happen. */
init_frame_faces (f);
-
+
x_default_parameter (f, parms, Qmenu_bar_lines, make_number (1),
"menuBar", "MenuBar", RES_TYPE_NUMBER);
- x_default_parameter (f, parms, Qtool_bar_lines, make_number (0),
+ x_default_parameter (f, parms, Qtool_bar_lines, make_number (1),
"toolBar", "ToolBar", RES_TYPE_NUMBER);
+
x_default_parameter (f, parms, Qbuffer_predicate, Qnil,
"bufferPredicate", "BufferPredicate", RES_TYPE_SYMBOL);
x_default_parameter (f, parms, Qtitle, Qnil,
if (FRAME_TOOL_BAR_LINES (f))
{
int margin, relief, bar_height;
-
+
relief = (tool_bar_button_relief >= 0
? tool_bar_button_relief
: DEFAULT_TOOL_BAR_BUTTON_RELIEF);
margin = XFASTINT (XCDR (Vtool_bar_button_margin));
else
margin = 0;
-
+
bar_height = DEFAULT_TOOL_BAR_IMAGE_HEIGHT + 2 * margin + 2 * relief;
f->height += (bar_height + CANON_Y_UNIT (f) - 1) / CANON_Y_UNIT (f);
}
;
}
UNGCPRO;
-
+
/* Make sure windows on this frame appear in calls to next-window
and similar functions. */
Vwindow_list = Qnil;
-
+
return unbind_to (count, frame);
}
for (tail = font_names; CONSP (tail); tail = XCDR (tail))
if (dpyinfo->font_table[i].name
&& (!strcmp (dpyinfo->font_table[i].name,
- XSTRING (XCAR (tail))->data)
+ SDATA (XCAR (tail)))
|| !strcmp (dpyinfo->font_table[i].full_name,
- XSTRING (XCAR (tail))->data)))
+ SDATA (XCAR (tail)))))
return (dpyinfo->font_table + i);
- fontname = (char *) XSTRING (XCAR (font_names))->data;
+ fontname = (char *) SDATA (XCAR (font_names));
}
else if (w32_strict_fontnames)
{
ended up with. */
return NULL;
- /* Specify anti-aliasing to prevent Cleartype fonts being used,
- since those fonts leave garbage behind. */
- lf.lfQuality = ANTIALIASED_QUALITY;
+ lf.lfQuality = DEFAULT_QUALITY;
font = (XFontStruct *) xmalloc (sizeof (XFontStruct));
bzero (font, sizeof (*font));
font->hfont = CreateFontIndirect (&lf);
- if (font->hfont == NULL)
+ if (font->hfont == NULL)
{
ok = FALSE;
- }
- else
+ }
+ else
{
HDC hdc;
HANDLE oldobj;
char *bdf_name, *bdf_file;
Lisp_Object bdf_pair;
- bdf_name = XSTRING (XCAR (bdf_fonts))->data;
+ bdf_name = SDATA (XCAR (bdf_fonts));
bdf_pair = Fassoc (XCAR (bdf_fonts), Vw32_bdf_filename_alist);
- bdf_file = XSTRING (XCDR (bdf_pair))->data;
+ bdf_file = SDATA (XCDR (bdf_pair));
retval = w32_load_bdf_font (f, bdf_name, size, bdf_file);
}
-void
+void
w32_unload_font (dpyinfo, font)
struct w32_display_info *dpyinfo;
XFontStruct * font;
{
- if (font)
+ if (font)
{
if (font->per_char) xfree (font->per_char);
if (font->bdf) w32_free_bdf_font (font->bdf);
* )
*/
-static LONG
+static LONG
x_to_w32_weight (lpw)
char * lpw;
{
}
-static char *
+static char *
w32_to_x_weight (fnweight)
int fnweight;
{
sprintf (buf, "*-#%u", fncharset);
return buf;
}
-
+
{
Lisp_Object rest;
char * best_match = NULL;
|| !SYMBOLP (XCAR (XCDR (this_entry))))
continue;
- x_charset = XSTRING (XCAR (this_entry))->data;
+ x_charset = SDATA (XCAR (this_entry));
w32_charset = XCAR (XCDR (this_entry));
codepage = XCDR (XCDR (this_entry));
int this_enc = atoi (x_charset + 8);
if (this_enc > 0 && this_enc < best_enc)
best_match = x_charset;
- }
+ }
}
}
sprintf (buf, "*-#%u", fncharset);
return Fcons (build_string (buf), Qnil);
}
-
+
{
Lisp_Object rest;
/* Look through w32-charset-info-alist for the character set.
/* Get the Windows codepage corresponding to the specified font. The
charset info in the font name is used to look up
w32-charset-to-codepage-alist. */
-int
+int
w32_codepage_for_font (char *fontname)
{
Lisp_Object codepage, entry;
}
-static BOOL
+static BOOL
w32_to_x_font (lplogfont, lpxstr, len, specific_charset)
LOGFONT * lplogfont;
char * lpxstr;
coding.src_multibyte = 0;
coding.dst_multibyte = 1;
coding.mode |= CODING_MODE_LAST_BLOCK;
+ /* We explicitely disable composition handling because selection
+ data should not contain any composition sequence. */
+ coding.composing = COMPOSITION_DISABLED;
bufsz = decoding_buffer_size (&coding, LF_FACESIZE);
fontname = alloca(sizeof(*fontname) * bufsz);
? 'p' : 'c', /* spacing */
width_pixels, /* avg width */
specific_charset ? specific_charset
- : w32_to_x_charset (lplogfont->lfCharSet)
+ : w32_to_x_charset (lplogfont->lfCharSet)
/* charset registry and encoding */
);
return (TRUE);
}
-static BOOL
+static BOOL
x_to_w32_font (lpxstr, lplogfont)
char * lpxstr;
LOGFONT * lplogfont;
* format:
* "<font name>[:height in pixels[:width in pixels[:weight]]]"
*/
-
+
if (*lpxstr == '-')
{
int fields, tem;
}
/* Assume parameter 1 is fully qualified, no wildcards. */
-static BOOL
+static BOOL
w32_font_match (fontname, pattern)
char * fontname;
char * pattern;
font from each family, the second pass lists all the fonts from
each family. */
-typedef struct enumfont_t
+typedef struct enumfont_t
{
HDC hdc;
int numFonts;
LOGFONT logfont;
XFontStruct *size_ref;
- Lisp_Object *pattern;
+ Lisp_Object pattern;
Lisp_Object list;
- Lisp_Object *tail;
} enumfont_t;
enum_font_maybe_add_to_list (enumfont_t *, LOGFONT *, char *, Lisp_Object);
-static int CALLBACK
+static int CALLBACK
enum_font_cb2 (lplf, lptm, FontType, lpef)
ENUMLOGFONT * lplf;
NEWTEXTMETRIC * lptm;
lplf->elfLogFont.lfCharSet != lpef->logfont.lfCharSet)
return 1;
+ if (FontType == RASTER_FONTTYPE)
+ {
+ /* DBCS raster fonts have problems displaying, so skip them. */
+ int charset = lplf->elfLogFont.lfCharSet;
+ if (charset == SHIFTJIS_CHARSET
+ || charset == HANGEUL_CHARSET
+ || charset == CHINESEBIG5_CHARSET
+ || charset == GB2312_CHARSET
+#ifdef JOHAB_CHARSET
+ || charset == JOHAB_CHARSET
+#endif
+ )
+ return 1;
+ }
+
{
char buf[100];
Lisp_Object width = Qnil;
/* Truetype fonts do not report their true metrics until loaded */
if (FontType != RASTER_FONTTYPE)
{
- if (!NILP (*(lpef->pattern)))
+ if (!NILP (lpef->pattern))
{
/* Scalable fonts are as big as you want them to be. */
lplf->elfLogFont.lfHeight = lpef->logfont.lfHeight;
lplf->elfLogFont.lfHeight = -lplf->elfLogFont.lfHeight;
}
- if (!NILP (*(lpef->pattern)))
+ if (!NILP (lpef->pattern))
{
- charset = xlfd_charset_of_font (XSTRING(*(lpef->pattern))->data);
+ charset = xlfd_charset_of_font (SDATA (lpef->pattern));
/* We already checked charsets above, but DEFAULT_CHARSET
slipped through. So only allow exact matches for DEFAULT_CHARSET. */
for ( ; CONSP (charset_list); charset_list = Fcdr (charset_list))
{
Lisp_Object this_charset = Fcar (charset_list);
- charset = XSTRING (this_charset)->data;
+ charset = SDATA (this_charset);
/* List bold and italic variations if w32-enable-synthesized-fonts
is non-nil and this is a plain font. */
if (!w32_to_x_font (logfont, buf, 100, match_charset))
return;
- if (NILP (*(lpef->pattern))
- || w32_font_match (buf, XSTRING (*(lpef->pattern))->data))
+ if (NILP (lpef->pattern)
+ || w32_font_match (buf, SDATA (lpef->pattern)))
{
/* Check if we already listed this font. This may happen if
w32_enable_synthesized_fonts is non-nil, and there are real
Lisp_Object font_name = build_string (buf);
if (NILP (Fmember (font_name, lpef->list)))
{
- *lpef->tail = Fcons (Fcons (build_string (buf), width), Qnil);
- lpef->tail = &(XCDR (*lpef->tail));
+ Lisp_Object entry = Fcons (font_name, width);
+ lpef->list = Fcons (entry, lpef->list);
lpef->numFonts++;
}
}
}
-static int CALLBACK
+static int CALLBACK
enum_font_cb1 (lplf, lptm, FontType, lpef)
ENUMLOGFONT * lplf;
NEWTEXTMETRIC * lptm;
int n_fonts = 0;
list = Vw32_bdf_filename_alist;
- ptnstr = XSTRING (pattern)->data;
+ ptnstr = SDATA (pattern);
for ( ; CONSP (list); list = XCDR (list))
{
tem = XCAR (list);
if (CONSP (tem))
- fontname = XSTRING (XCAR (tem))->data;
+ fontname = SDATA (XCAR (tem));
else if (STRINGP (tem))
- fontname = XSTRING (tem)->data;
+ fontname = SDATA (tem);
else
continue;
/* Avoid expensive EnumFontFamilies functions if we are not
going to be able to output one of these anyway. */
- codepage = w32_codepage_for_font (XSTRING (tpat)->data);
+ codepage = w32_codepage_for_font (SDATA (tpat));
if (codepage != CP_8BIT && codepage != CP_UNICODE
&& codepage != CP_DEFAULT && codepage != CP_UNKNOWN
&& !IsValidCodePage(codepage))
BLOCK_INPUT;
/* At first, put PATTERN in the cache. */
- list = Qnil;
- ef.pattern = &tpat;
- ef.list = list;
- ef.tail = &list;
+ ef.pattern = tpat;
+ ef.list = Qnil;
ef.numFonts = 0;
/* Use EnumFontFamiliesEx where it is available, as it knows
about character sets. Fall back to EnumFontFamilies for
older versions of NT that don't support the 'Ex function. */
- x_to_w32_font (XSTRING (tpat)->data, &ef.logfont);
+ x_to_w32_font (SDATA (tpat), &ef.logfont);
{
LOGFONT font_match_pattern;
HMODULE gdi32 = GetModuleHandle ("gdi32.dll");
}
UNBLOCK_INPUT;
+ list = ef.list;
/* Make a list of the fonts we got back.
Store that in the font cache for the display. */
newlist = second_best = Qnil;
- /* Make a list of the fonts that have the right width. */
+ /* Make a list of the fonts that have the right width. */
for (; CONSP (list); list = XCDR (list))
{
int found_size;
HDC hdc;
HANDLE oldobj;
- if (!x_to_w32_font (XSTRING (XCAR (tem))->data, &lf))
+ if (!x_to_w32_font (SDATA (XCAR (tem)), &lf))
continue;
BLOCK_INPUT;
{
if (NILP (second_best))
second_best = tem;
-
+
else if (found_size < size)
{
if (XINT (XCDR (second_best)) > size
for ( ; CONSP(filelist); filelist = XCDR (filelist))
{
Lisp_Object filename = XCAR (filelist);
- if (w32_BDF_to_x_font (XSTRING (filename)->data, fontname, 100))
+ if (w32_BDF_to_x_font (SDATA (filename), fontname, 100))
store_in_alist (&list, build_string (fontname), filename);
}
return list;
CHECK_STRING (color);
- if (w32_defined_color (f, XSTRING (color)->data, &foo, 0))
+ if (w32_defined_color (f, SDATA (color), &foo, 0))
return Qt;
else
return Qnil;
CHECK_STRING (color);
- if (w32_defined_color (f, XSTRING (color)->data, &foo, 0))
+ if (w32_defined_color (f, SDATA (color), &foo, 0))
{
Lisp_Object rgb[3];
and because probably is more meaningful on Windows anyway */
if (cap < 0)
cap = 1 << min(dpyinfo->n_planes * dpyinfo->n_cbits, 24);
-
+
ReleaseDC (dpyinfo->root_window, hdc);
-
+
return make_number (cap);
}
int cap;
hdc = GetDC (dpyinfo->root_window);
-
+
cap = GetDeviceCaps (hdc, VERTSIZE);
-
+
ReleaseDC (dpyinfo->root_window, hdc);
-
+
return make_number (cap);
}
int cap;
hdc = GetDC (dpyinfo->root_window);
-
+
cap = GetDeviceCaps (hdc, HORZSIZE);
-
+
ReleaseDC (dpyinfo->root_window, hdc);
-
+
return make_number (cap);
}
validate_x_resource_name ();
dpyinfo = w32_term_init (name, (unsigned char *)0,
- (char *) XSTRING (Vx_resource_name)->data);
+ (char *) SDATA (Vx_resource_name));
if (dpyinfo == 0)
- error ("Cannot connect to server %s", XSTRING (name)->data);
+ error ("Cannot connect to server %s", SDATA (name));
w32_in_use = 1;
XSETFASTINT (Vwindow_system_version, 3);
Vw32_color_map = Fw32_default_color_map ();
if (! NILP (xrm_string))
- xrm_option = (unsigned char *) XSTRING (xrm_string)->data;
+ xrm_option = (unsigned char *) SDATA (xrm_string);
else
xrm_option = (unsigned char *) 0;
{
char basename[ MAX_PATH ], *str;
- strcpy (basename, XSTRING (Vinvocation_name)->data);
+ strcpy (basename, SDATA (Vinvocation_name));
str = strrchr (basename, '.');
if (str) *str = 0;
Vinvocation_name = build_string (basename);
/* This is what opens the connection and sets x_current_display.
This also initializes many symbols, such as those used for input. */
dpyinfo = w32_term_init (display, xrm_option,
- (char *) XSTRING (Vx_resource_name)->data);
+ (char *) SDATA (Vx_resource_name));
if (dpyinfo == 0)
{
if (!NILP (must_succeed))
fatal ("Cannot connect to server %s.\n",
- XSTRING (display)->data);
+ SDATA (display));
else
- error ("Cannot connect to server %s", XSTRING (display)->data);
+ error ("Cannot connect to server %s", SDATA (display));
}
w32_in_use = 1;
return Qnil;
}
-\f
\f
/***********************************************************************
Image types
Lisp_Object object;
{
int valid_p = 0;
-
+
if (CONSP (object) && EQ (XCAR (object), Qimage))
{
Lisp_Object tem;
/* Find key in KEYWORDS. Error if not found. */
for (i = 0; i < nkeywords; ++i)
- if (strcmp (keywords[i].name, XSYMBOL (key)->name->data) == 0)
+ if (strcmp (keywords[i].name, SDATA (SYMBOL_NAME (key))) == 0)
break;
if (i == nkeywords)
was found more than once, it's an error. */
keywords[i].value = value;
++keywords[i].count;
-
+
if (keywords[i].count > 1)
return 0;
case IMAGE_FUNCTION_VALUE:
value = indirect_function (value);
- if (SUBRP (value)
+ if (SUBRP (value)
|| COMPILEDP (value)
|| (CONSP (value) && EQ (XCAR (value), Qlambda)))
break;
int *found;
{
Lisp_Object tail;
-
+
xassert (valid_image_p (spec));
for (tail = XCDR (spec);
return XCAR (XCDR (tail));
}
}
-
+
if (found)
*found = 0;
return Qnil;
}
-
-#ifdef HAVE_IMAGES
+
DEFUN ("image-size", Fimage_size, Simage_size, 1, 3, 0,
doc: /* Return the size of image SPEC as pair (WIDTH . HEIGHT).
PIXELS non-nil means return the size in pixels, otherwise return the
struct image *img = IMAGE_FROM_ID (f, id);
int width = img->width + 2 * img->hmargin;
int height = img->height + 2 * img->vmargin;
-
+
if (NILP (pixels))
size = Fcons (make_float ((double) width / CANON_X_UNIT (f)),
make_float ((double) height / CANON_Y_UNIT (f)));
return mask;
}
-#endif
\f
/***********************************************************************
static struct image *make_image P_ ((Lisp_Object spec, unsigned hash));
static void free_image P_ ((struct frame *f, struct image *img));
+static void x_destroy_x_image P_ ((XImage *));
/* Allocate and return a new image structure for image specification
unsigned hash;
{
struct image *img = (struct image *) xmalloc (sizeof *img);
-
+
xassert (valid_image_p (spec));
bzero (img, sizeof *img);
img->type = lookup_image_type (image_spec_value (spec, QCtype, NULL));
if (img->pixmap == 0 && !img->load_failed_p)
img->load_failed_p = img->type->load (f, img) == 0;
}
-
+
/* Value is the number of pixels for the ascent of image IMG when
drawn in face FACE. */
/* Find the "best" corner color of a bitmap. XIMG is assumed to a device
context with the bitmap selected. */
static COLORREF
-four_corners_best (ximg, width, height)
- HDC ximg;
+four_corners_best (img_dc, width, height)
+ HDC img_dc;
unsigned long width, height;
{
COLORREF corners[4], best;
int i, best_count;
- /* Get the colors at the corners of ximg. */
- corners[0] = GetPixel (ximg, 0, 0);
- corners[1] = GetPixel (ximg, width - 1, 0);
- corners[2] = GetPixel (ximg, width - 1, height - 1);
- corners[3] = GetPixel (ximg, 0, height - 1);
+ /* Get the colors at the corners of img_dc. */
+ corners[0] = GetPixel (img_dc, 0, 0);
+ corners[1] = GetPixel (img_dc, width - 1, 0);
+ corners[2] = GetPixel (img_dc, width - 1, height - 1);
+ corners[3] = GetPixel (img_dc, 0, height - 1);
/* Choose the most frequently found color as background. */
for (i = best_count = 0; i < 4; ++i)
{
int j, n;
-
+
for (j = n = 0; j < 4; ++j)
if (corners[i] == corners[j])
++n;
}
/* Return the `background' field of IMG. If IMG doesn't have one yet,
- it is guessed heuristically. If non-zero, XIMG is an existing XImage
- object to use for the heuristic. */
+ it is guessed heuristically. If non-zero, IMG_DC is an existing
+ device context with the image selected to use for the heuristic. */
unsigned long
-image_background (img, f, ximg)
+image_background (img, f, img_dc)
struct image *img;
struct frame *f;
- XImage *ximg;
+ HDC img_dc;
{
if (! img->background_valid)
/* IMG doesn't have a background yet, try to guess a reasonable value. */
{
-#if 0 /* TODO: Image support. */
- int free_ximg = !ximg;
+ int free_ximg = !img_dc;
+ HGDIOBJ prev;
- if (! ximg)
- ximg = XGetImage (FRAME_X_DISPLAY (f), img->pixmap,
- 0, 0, img->width, img->height, ~0, ZPixmap);
+ if (free_ximg)
+ {
+ HDC frame_dc = get_frame_dc (f);
+ img_dc = CreateCompatibleDC (frame_dc);
+ release_frame_dc (f, frame_dc);
+
+ prev = SelectObject (img_dc, img->pixmap);
+ }
- img->background = four_corners_best (ximg, img->width, img->height);
+ img->background = four_corners_best (img_dc, img->width, img->height);
if (free_ximg)
- XDestroyImage (ximg);
+ {
+ SelectObject (img_dc, prev);
+ DeleteDC (img_dc);
+ }
img->background_valid = 1;
-#endif
}
return img->background;
image_background_transparent (img, f, mask)
struct image *img;
struct frame *f;
- XImage *mask;
+ HDC mask;
{
if (! img->background_transparent_valid)
/* IMG doesn't have a background yet, try to guess a reasonable value. */
{
-#if 0 /* TODO: Image support. */
if (img->mask)
{
int free_mask = !mask;
+ HGDIOBJ prev;
- if (! mask)
- mask = XGetImage (FRAME_X_DISPLAY (f), img->mask,
- 0, 0, img->width, img->height, ~0, ZPixmap);
+ if (free_mask)
+ {
+ HDC frame_dc = get_frame_dc (f);
+ mask = CreateCompatibleDC (frame_dc);
+ release_frame_dc (f, frame_dc);
+
+ prev = SelectObject (mask, img->mask);
+ }
img->background_transparent
= !four_corners_best (mask, img->width, img->height);
if (free_mask)
- XDestroyImage (mask);
+ {
+ SelectObject (mask, prev);
+ DeleteDC (mask);
+ }
}
else
-#endif
img->background_transparent = 0;
img->background_transparent_valid = 1;
img->mask = NULL;
img->background_transparent_valid = 0;
}
-
+
if (colors_p && img->ncolors)
{
+#if 0 /* TODO: color table support. */
x_free_colors (f, img->colors, img->ncolors);
+#endif
xfree (img->colors);
img->colors = NULL;
img->ncolors = 0;
#if 0 /* TODO: color table support */
int class = FRAME_W32_DISPLAY_INFO (f)->visual->class;
-
+
/* If display has an immutable color map, freeing colors is not
necessary and some servers don't allow it. So don't do it. */
if (class != StaticColor
UNBLOCK_INPUT;
}
#endif
-
+
xfree (img->colors);
img->colors = NULL;
img->ncolors = 0;
xassert (STRINGP (color_name));
- if (w32_defined_color (f, XSTRING (color_name)->data, &color, 1))
+ if (w32_defined_color (f, SDATA (color_name), &color, 1))
{
/* This isn't called frequently so we get away with simply
reallocating the color vector to the needed size, here. */
static void cache_image P_ ((struct frame *f, struct image *img));
static void postprocess_image P_ ((struct frame *, struct image *));
+static void x_disable_image P_ ((struct frame *, struct image *));
/* Return a new, initialized image cache that is allocated from the
{
struct image_cache *c = (struct image_cache *) xmalloc (sizeof *c);
int size;
-
+
bzero (c, sizeof *c);
c->size = 50;
c->images = (struct image **) xmalloc (c->size * sizeof *c->images);
/* Cache should not be referenced by any frame when freed. */
xassert (c->refcount == 0);
-
+
for (i = 0; i < c->used; ++i)
free_image (f, c->images[i]);
xfree (c->images);
{
EMACS_TIME t;
unsigned long old;
- int i, any_freed_p = 0;
+ int i, nfreed;
EMACS_GET_TIME (t);
old = EMACS_SECS (t) - XFASTINT (Vimage_cache_eviction_delay);
-
- for (i = 0; i < c->used; ++i)
+
+ /* Block input so that we won't be interrupted by a SIGIO
+ while being in an inconsistent state. */
+ BLOCK_INPUT;
+
+ for (i = nfreed = 0; i < c->used; ++i)
{
struct image *img = c->images[i];
if (img != NULL
- && (force_p
- || (img->timestamp > old)))
+ && (force_p || (img->timestamp < old)))
{
free_image (f, img);
- any_freed_p = 1;
+ ++nfreed;
}
}
Emacs was iconified for a longer period of time. In that
case, current matrices may still contain references to
images freed above. So, clear these matrices. */
- if (any_freed_p)
+ if (nfreed)
{
- clear_current_matrices (f);
+ Lisp_Object tail, frame;
+
+ FOR_EACH_FRAME (tail, frame)
+ {
+ struct frame *f = XFRAME (frame);
+ if (FRAME_W32_P (f)
+ && FRAME_X_IMAGE_CACHE (f) == c)
+ clear_current_matrices (f);
+ }
+
++windows_or_buffers_changed;
}
+
+ UNBLOCK_INPUT;
}
}
if (EQ (frame, Qt))
{
Lisp_Object tail;
-
+
FOR_EACH_FRAME (tail, frame)
if (FRAME_W32_P (XFRAME (frame)))
clear_image_cache (XFRAME (frame), 1);
struct frame *f;
struct image *img;
{
-#if 0 /* TODO: image support. */
/* Manipulation of the image's mask. */
if (img->pixmap)
{
Lisp_Object mask;
spec = img->spec;
-
+
/* `:heuristic-mask t'
`:mask heuristic'
means build a mask heuristically.
image.
`:mask nil'
means remove a mask, if any. */
-
+
mask = image_spec_value (spec, QCheuristic_mask, NULL);
if (!NILP (mask))
x_build_heuristic_mask (f, img, mask);
else
{
int found_p;
-
+
mask = image_spec_value (spec, QCmask, &found_p);
-
+
if (EQ (mask, Qheuristic))
x_build_heuristic_mask (f, img, Qt);
else if (CONSP (mask)
img->mask = NULL;
}
}
-
-
+
+
/* Should we apply an image transformation algorithm? */
conversion = image_spec_value (spec, QCconversion, NULL);
if (EQ (conversion, Qdisabled))
Fplist_get (tem, QCcolor_adjustment));
}
}
-#endif
}
specification. */
xassert (FRAME_WINDOW_P (f));
xassert (valid_image_p (spec));
-
+
GCPRO1 (spec);
/* Look up SPEC in the hash table of the image cache. */
else
{
/* Handle image type independent image attributes
- `:ascent PERCENT', `:margin MARGIN', `:relief RELIEF',
+ `:ascent ASCENT', `:margin MARGIN', `:relief RELIEF',
`:background COLOR'. */
Lisp_Object ascent, margin, relief, bg;
if (XINT (XCDR (margin)) > 0)
img->vmargin = XFASTINT (XCDR (margin));
}
-
+
relief = image_spec_value (spec, QCrelief, NULL);
if (INTEGERP (relief))
{
/* We're using IMG, so set its timestamp to `now'. */
EMACS_GET_TIME (now);
img->timestamp = EMACS_SECS (now);
-
+
UNGCPRO;
-
+
/* Value is the image id. */
return img->id;
}
static int x_create_x_image_and_pixmap P_ ((struct frame *, int, int, int,
XImage **, Pixmap *));
-static void x_destroy_x_image P_ ((XImage *));
static void x_put_x_image P_ ((struct frame *, XImage *, Pixmap, int, int));
header->biCompression = BI_RGB;
header->biClrUsed = palette_colors;
+ /* TODO: fill in palette. */
+ if (depth == 1)
+ {
+ (*ximg)->info.bmiColors[0].rgbBlue = 0;
+ (*ximg)->info.bmiColors[0].rgbGreen = 0;
+ (*ximg)->info.bmiColors[0].rgbRed = 0;
+ (*ximg)->info.bmiColors[0].rgbReserved = 0;
+ (*ximg)->info.bmiColors[1].rgbBlue = 255;
+ (*ximg)->info.bmiColors[1].rgbGreen = 255;
+ (*ximg)->info.bmiColors[1].rgbRed = 255;
+ (*ximg)->info.bmiColors[1].rgbReserved = 0;
+ }
+
hdc = get_frame_dc (f);
/* Create a DIBSection and raster array for the bitmap,
and store its handle in *pixmap. */
- *pixmap = CreateDIBSection (hdc, &((*ximg)->info), DIB_RGB_COLORS,
+ *pixmap = CreateDIBSection (hdc, &((*ximg)->info),
+ (depth < 16) ? DIB_PAL_COLORS : DIB_RGB_COLORS,
&((*ximg)->data), NULL, 0);
/* Realize display palette and garbage all frames. */
XImage *ximg;
Pixmap pixmap;
{
-
-#if TODO /* W32 specific image code. */
- GC gc;
-
- xassert (interrupt_input_blocked);
- gc = XCreateGC (NULL, pixmap, 0, NULL);
- XPutImage (NULL, pixmap, gc, ximg, 0, 0, 0, 0, width, height);
- XFreeGC (NULL, gc);
+#if 0 /* I don't think this is necessary looking at where it is used. */
+ HDC hdc = get_frame_dc (f);
+ SetDIBits (hdc, pixmap, 0, height, ximg->data, &(ximg->info), DIB_RGB_COLORS);
+ release_frame_dc (f, hdc);
#endif
}
GCPRO2 (file_found, search_path);
/* Try to find FILE in data-directory, then x-bitmap-file-path. */
- fd = openp (search_path, file, Qnil, &file_found, 0);
-
+ fd = openp (search_path, file, Qnil, &file_found, Qnil);
+
if (fd == -1)
file_found = Qnil;
else
buf = NULL;
}
}
-
+
return buf;
}
XBM images
***********************************************************************/
+static int xbm_scan P_ ((char **, char *, char *, int *));
static int xbm_load P_ ((struct frame *f, struct image *img));
-static int xbm_load_image_from_file P_ ((struct frame *f, struct image *img,
- Lisp_Object file));
+static int xbm_load_image P_ ((struct frame *f, struct image *img,
+ char *, char *));
static int xbm_image_p P_ ((Lisp_Object object));
-static int xbm_read_bitmap_file_data P_ ((char *, int *, int *,
- unsigned char **));
+static int xbm_read_bitmap_data P_ ((char *, char *, int *, int *,
+ unsigned char **));
+static int xbm_file_p P_ ((Lisp_Object));
/* Indices of image specification fields in xbm_format, below. */
{":width", IMAGE_POSITIVE_INTEGER_VALUE, 0},
{":height", IMAGE_POSITIVE_INTEGER_VALUE, 0},
{":data", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
- {":foreground", IMAGE_STRING_OR_NIL_VALUE, 0},
- {":background", IMAGE_STRING_OR_NIL_VALUE, 0},
- {":ascent", IMAGE_NON_NEGATIVE_INTEGER_VALUE, 0},
+ {":foreground", IMAGE_STRING_OR_NIL_VALUE, 0},
+ {":background", IMAGE_STRING_OR_NIL_VALUE, 0},
+ {":ascent", IMAGE_ASCENT_VALUE, 0},
{":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR, 0},
{":relief", IMAGE_INTEGER_VALUE, 0},
{":conversion", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
- {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE, 0}
+ {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
+ {":mask", IMAGE_DONT_CHECK_VALUE_TYPE, 0}
};
/* Structure describing the image type XBM. */
XBM_TK_NUMBER
};
-
+
/* Return non-zero if OBJECT is a valid XBM-type image specification.
A valid specification is a list starting with the symbol `image'
The rest of the list is a property list which must contain an
3. a vector of strings or bool-vectors, one for each line of the
bitmap.
+ 4. A string containing an in-memory XBM file. WIDTH and HEIGHT
+ may not be specified in this case because they are defined in the
+ XBM file.
+
Both the file and data forms may contain the additional entries
`:background COLOR' and `:foreground COLOR'. If not present,
foreground and background of the frame on which the image is
- displayed, is used. */
+ displayed is used. */
static int
xbm_image_p (object)
Lisp_Object object;
{
struct image_keyword kw[XBM_LAST];
-
+
bcopy (xbm_format, kw, sizeof kw);
if (!parse_image_spec (object, kw, XBM_LAST, Qxbm))
return 0;
if (kw[XBM_WIDTH].count || kw[XBM_HEIGHT].count || kw[XBM_DATA].count)
return 0;
}
+ else if (kw[XBM_DATA].count && xbm_file_p (kw[XBM_DATA].value))
+ {
+ /* In-memory XBM file. */
+ if (kw[XBM_WIDTH].count || kw[XBM_HEIGHT].count || kw[XBM_FILE].count)
+ return 0;
+ }
else
{
Lisp_Object data;
data = kw[XBM_DATA].value;
width = XFASTINT (kw[XBM_WIDTH].value);
height = XFASTINT (kw[XBM_HEIGHT].value);
-
+
/* Check type of data, and width and height against contents of
data. */
if (VECTORP (data))
{
int i;
-
+
/* Number of elements of the vector must be >= height. */
if (XVECTOR (data)->size < height)
return 0;
if (STRINGP (elt))
{
- if (XSTRING (elt)->size
+ if (SCHARS (elt)
< (width + BITS_PER_CHAR - 1) / BITS_PER_CHAR)
return 0;
}
}
else if (STRINGP (data))
{
- if (XSTRING (data)->size
+ if (SCHARS (data)
< (width + BITS_PER_CHAR - 1) / BITS_PER_CHAR * height)
return 0;
}
return 0;
}
- /* Baseline must be a value between 0 and 100 (a percentage). */
- if (kw[XBM_ASCENT].count
- && XFASTINT (kw[XBM_ASCENT].value) > 100)
- return 0;
-
return 1;
}
loop:
/* Skip white space. */
- while (*s < end &&(c = *(*s)++, isspace (c)))
+ while (*s < end && (c = *(*s)++, isspace (c)))
;
if (*s >= end)
else if (isdigit (c))
{
int value = 0, digit;
-
+
if (c == '0' && *s < end)
{
c = *(*s)++;
}
+/* XBM bits seem to be backward within bytes compared with how
+ Windows does things. */
+static unsigned char reflect_byte (unsigned char orig)
+{
+ int i;
+ unsigned char reflected = 0x00;
+ for (i = 0; i < 8; i++)
+ {
+ if (orig & (0x01 << i))
+ reflected |= 0x80 >> i;
+ }
+ return reflected;
+}
+
+
+/* Create a Windows bitmap from X bitmap data. */
+static HBITMAP
+w32_create_pixmap_from_bitmap_data (int width, int height, char *data)
+{
+ int i, j, w1, w2;
+ char *bits, *p;
+ HBITMAP bmp;
+
+ w1 = (width + 7) / 8; /* nb of 8bits elt in X bitmap */
+ w2 = ((width + 15) / 16) * 2; /* nb of 16bits elt in W32 bitmap */
+ bits = (char *) xmalloc (height * w2);
+ bzero (bits, height * w2);
+ for (i = 0; i < height; i++)
+ {
+ p = bits + i*w2;
+ for (j = 0; j < w1; j++)
+ *p++ = reflect_byte(*data++);
+ }
+ bmp = CreateBitmap (width, height, 1, 1, bits);
+ xfree (bits);
+
+ return bmp;
+}
+
+
/* Replacement for XReadBitmapFileData which isn't available under old
X versions. CONTENTS is a pointer to a buffer to parse; END is the
buffer's end. Set *WIDTH and *HEIGHT to the width and height of
int LA1;
#define match() \
- LA1 = xbm_scan (contents, end, buffer, &value)
+ LA1 = xbm_scan (&s, end, buffer, &value)
#define expect(TOKEN) \
if (LA1 != (TOKEN)) \
goto failure; \
else \
- match ()
+ match ()
#define expect_ident(IDENT) \
if (LA1 == XBM_TK_IDENT && strcmp (buffer, (IDENT)) == 0) \
{
if (strcmp (buffer, "unsigned") == 0)
{
- match ();
+ match ();
expect_ident ("char");
}
else if (strcmp (buffer, "short") == 0)
else
goto failure;
}
- else
+ else
goto failure;
expect (XBM_TK_IDENT);
if (v10)
{
-
for (i = 0; i < nbytes; i += 2)
{
int val = value;
expect (XBM_TK_NUMBER);
- *p++ = val;
+ *p++ = ~ val;
if (!padding_p || ((i + 2) % bytes_per_line))
- *p++ = value >> 8;
-
+ *p++ = ~ (value >> 8);
+
if (LA1 == ',' || LA1 == '}')
match ();
else
{
int val = value;
expect (XBM_TK_NUMBER);
-
- *p++ = val;
-
+
+ *p++ = ~ val;
+
if (LA1 == ',' || LA1 == '}')
match ();
else
#undef expect_ident
}
+static void convert_mono_to_color_image (f, img, foreground, background)
+ struct frame *f;
+ struct image *img;
+ COLORREF foreground, background;
+{
+ HDC hdc, old_img_dc, new_img_dc;
+ HGDIOBJ old_prev, new_prev;
+ HBITMAP new_pixmap;
+
+ hdc = get_frame_dc (f);
+ old_img_dc = CreateCompatibleDC (hdc);
+ new_img_dc = CreateCompatibleDC (hdc);
+ new_pixmap = CreateCompatibleBitmap (hdc, img->width, img->height);
+ release_frame_dc (f, hdc);
+ old_prev = SelectObject (old_img_dc, img->pixmap);
+ new_prev = SelectObject (new_img_dc, new_pixmap);
+ SetTextColor (new_img_dc, foreground);
+ SetBkColor (new_img_dc, background);
+
+ BitBlt (new_img_dc, 0, 0, img->width, img->height, old_img_dc,
+ 0, 0, SRCCOPY);
+
+ SelectObject (old_img_dc, old_prev);
+ SelectObject (new_img_dc, new_prev);
+ DeleteDC (old_img_dc);
+ DeleteDC (new_img_dc);
+ DeleteObject (img->pixmap);
+ if (new_pixmap == 0)
+ fprintf (stderr, "Failed to convert image to color.\n");
+ else
+ img->pixmap = new_pixmap;
+}
/* Load XBM image IMG which will be displayed on frame F from buffer
CONTENTS. END is the end of the buffer. Value is non-zero if
int rc;
unsigned char *data;
int success_p = 0;
-
+
rc = xbm_read_bitmap_data (contents, end, &img->width, &img->height, &data);
if (rc)
{
- int depth = one_w32_display_info.n_cbits;
- int planes = one_w32_display_info.n_planes;
-
unsigned long foreground = FRAME_FOREGROUND_PIXEL (f);
unsigned long background = FRAME_BACKGROUND_PIXEL (f);
+ int non_default_colors = 0;
Lisp_Object value;
-
+
xassert (img->width > 0 && img->height > 0);
/* Get foreground and background colors, maybe allocate colors. */
value = image_spec_value (img->spec, QCforeground, NULL);
if (!NILP (value))
- foreground = x_alloc_image_color (f, img, value, foreground);
+ {
+ foreground = x_alloc_image_color (f, img, value, foreground);
+ non_default_colors = 1;
+ }
value = image_spec_value (img->spec, QCbackground, NULL);
if (!NILP (value))
{
background = x_alloc_image_color (f, img, value, background);
img->background = background;
img->background_valid = 1;
+ non_default_colors = 1;
}
img->pixmap
- = CreateBitmap (img->width, img->height, planes, depth, data);
+ = w32_create_pixmap_from_bitmap_data (img->width, img->height, data);
+
+ /* If colors were specified, transfer the bitmap to a color one. */
+ if (non_default_colors)
+ convert_mono_to_color_image (f, img, foreground, background);
xfree (data);
{
int w, h;
return (STRINGP (data)
- && xbm_read_bitmap_data (XSTRING (data)->data,
- (XSTRING (data)->data
- + STRING_BYTES (XSTRING (data))),
+ && xbm_read_bitmap_data (SDATA (data),
+ (SDATA (data)
+ + SBYTES (data)),
&w, &h, NULL));
}
-
+
/* Fill image IMG which is used on frame F with pixmap data. Value is
non-zero if successful. */
return 0;
}
- contents = slurp_file (XSTRING (file)->data, &size);
+ contents = slurp_file (SDATA (file), &size);
if (contents == NULL)
{
image_error ("Error loading XBM image `%s'", img->spec, Qnil);
{
struct image_keyword fmt[XBM_LAST];
Lisp_Object data;
- int depth;
unsigned long foreground = FRAME_FOREGROUND_PIXEL (f);
unsigned long background = FRAME_BACKGROUND_PIXEL (f);
+ int non_default_colors = 0;
char *bits;
int parsed_p;
int in_memory_file_p = 0;
data = image_spec_value (img->spec, QCdata, NULL);
in_memory_file_p = xbm_file_p (data);
- /* Parse the list specification. */
+ /* Parse the image specification. */
bcopy (xbm_format, fmt, sizeof fmt);
parsed_p = parse_image_spec (img->spec, fmt, XBM_LAST, Qxbm);
xassert (parsed_p);
img->height = XFASTINT (fmt[XBM_HEIGHT].value);
xassert (img->width > 0 && img->height > 0);
}
+
/* Get foreground and background colors, maybe allocate colors. */
if (fmt[XBM_FOREGROUND].count
&& STRINGP (fmt[XBM_FOREGROUND].value))
- foreground = x_alloc_image_color (f, img, fmt[XBM_FOREGROUND].value,
- foreground);
+ {
+ foreground = x_alloc_image_color (f, img, fmt[XBM_FOREGROUND].value,
+ foreground);
+ non_default_colors = 1;
+ }
+
if (fmt[XBM_BACKGROUND].count
&& STRINGP (fmt[XBM_BACKGROUND].value))
- background = x_alloc_image_color (f, img, fmt[XBM_BACKGROUND].value,
- background);
+ {
+ background = x_alloc_image_color (f, img, fmt[XBM_BACKGROUND].value,
+ background);
+ non_default_colors = 1;
+ }
if (in_memory_file_p)
- success_p = xbm_load_image (f, img, XSTRING (data)->data,
- (XSTRING (data)->data
- + STRING_BYTES (XSTRING (data))));
+ success_p = xbm_load_image (f, img, SDATA (data),
+ (SDATA (data)
+ + SBYTES (data)));
else
{
if (VECTORP (data))
int i;
char *p;
int nbytes = (img->width + BITS_PER_CHAR - 1) / BITS_PER_CHAR;
-
+
p = bits = (char *) alloca (nbytes * img->height);
for (i = 0; i < img->height; ++i, p += nbytes)
{
Lisp_Object line = XVECTOR (data)->contents[i];
if (STRINGP (line))
- bcopy (XSTRING (line)->data, p, nbytes);
+ bcopy (SDATA (line), p, nbytes);
else
bcopy (XBOOL_VECTOR (line)->data, p, nbytes);
}
}
else if (STRINGP (data))
- bits = XSTRING (data)->data;
+ bits = SDATA (data);
else
bits = XBOOL_VECTOR (data)->data;
-#ifdef TODO /* image support. */
+
/* Create the pixmap. */
- depth = one_w32_display_info.n_cbits;
img->pixmap
- = XCreatePixmapFromBitmapData (FRAME_X_DISPLAY (f),
- FRAME_X_WINDOW (f),
- bits,
- img->width, img->height,
- foreground, background,
- depth);
-#endif
+ = w32_create_pixmap_from_bitmap_data (img->width, img->height,
+ bits);
+
+ /* If colors were specified, transfer the bitmap to a color one. */
+ if (non_default_colors)
+ convert_mono_to_color_image (f, img, foreground, background);
+
if (img->pixmap)
success_p = 1;
else
return success_p;
}
-
+
\f
/***********************************************************************
XPM images
***********************************************************************/
-#if HAVE_XPM
+#if HAVE_XPM
static int xpm_image_p P_ ((Lisp_Object object));
static int xpm_load P_ ((struct frame *f, struct image *img));
{":type", IMAGE_SYMBOL_VALUE, 1},
{":file", IMAGE_STRING_VALUE, 0},
{":data", IMAGE_STRING_VALUE, 0},
- {":ascent", IMAGE_NON_NEGATIVE_INTEGER_VALUE, 0},
+ {":ascent", IMAGE_ASCENT_VALUE, 0},
{":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR, 0},
{":relief", IMAGE_INTEGER_VALUE, 0},
{":conversion", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
{":background", IMAGE_STRING_OR_NIL_VALUE, 0}
};
-/* Structure describing the image type XBM. */
+/* Structure describing the image type XPM. */
static struct image_type xpm_type =
{
/* Either no `:color-symbols' or it's a list of conses
whose car and cdr are strings. */
&& (fmt[XPM_COLOR_SYMBOLS].count == 0
- || xpm_valid_color_symbols_p (fmt[XPM_COLOR_SYMBOLS].value))
- && (fmt[XPM_ASCENT].count == 0
- || XFASTINT (fmt[XPM_ASCENT].value) < 100));
+ || xpm_valid_color_symbols_p (fmt[XPM_COLOR_SYMBOLS].value)));
}
Lisp_Object tail;
XpmColorSymbol *xpm_syms;
int i, size;
-
+
attrs.valuemask |= XpmColorSymbols;
/* Count number of symbols. */
{
Lisp_Object name = XCAR (XCAR (tail));
Lisp_Object color = XCDR (XCAR (tail));
- xpm_syms[i].name = (char *) alloca (XSTRING (name)->size + 1);
- strcpy (xpm_syms[i].name, XSTRING (name)->data);
- xpm_syms[i].value = (char *) alloca (XSTRING (color)->size + 1);
- strcpy (xpm_syms[i].value, XSTRING (color)->data);
+ xpm_syms[i].name = (char *) alloca (SCHARS (name) + 1);
+ strcpy (xpm_syms[i].name, SDATA (name));
+ xpm_syms[i].value = (char *) alloca (SCHARS (color) + 1);
+ strcpy (xpm_syms[i].value, SDATA (color));
}
}
UNBLOCK_INPUT;
return 0;
}
-
+
rc = XpmReadFileToPixmap (NULL, FRAME_W32_WINDOW (f),
- XSTRING (file)->data, &img->pixmap, &img->mask,
+ SDATA (file), &img->pixmap, &img->mask,
&attrs);
}
else
{
Lisp_Object buffer = image_spec_value (img->spec, QCdata, NULL);
rc = XpmCreatePixmapFromBuffer (NULL, FRAME_W32_WINDOW (f),
- XSTRING (buffer)->data,
+ SDATA (buffer),
&img->pixmap, &img->mask,
&attrs);
}
case XpmOpenFailed:
image_error ("Error opening XPM file (%s)", img->spec, Qnil);
break;
-
+
case XpmFileInvalid:
image_error ("Invalid XPM file (%s)", img->spec, Qnil);
break;
-
+
case XpmNoMemory:
image_error ("Out of memory (%s)", img->spec, Qnil);
break;
-
+
case XpmColorFailed:
image_error ("Color allocation error (%s)", img->spec, Qnil);
break;
-
+
default:
image_error ("Unknown error (%s)", img->spec, Qnil);
break;
int rc;
BLOCK_INPUT;
-
+
cmap = DefaultColormapOfScreen (FRAME_X_SCREEN (f));
color.pixel = pixel;
XQueryColor (NULL, cmap, &color);
if (rc)
{
++ct_colors_allocated;
-
+
p = (struct ct_color *) xmalloc (sizeof *p);
p->r = color.red;
p->g = color.green;
colors = (unsigned long *) xmalloc (ct_colors_allocated
* sizeof *colors);
*n = ct_colors_allocated;
-
+
for (i = j = 0; i < CT_SIZE; ++i)
for (p = ct_table[i]; p; p = p->next)
colors[j++] = p->pixel;
#endif /* TODO */
\f
-#ifdef HAVE_IMAGES /* TODO */
/***********************************************************************
Algorithms
***********************************************************************/
{
int x, y;
XColor *colors, *p;
- XImage *ximg;
+ HDC hdc, bmpdc;
+ HGDIOBJ prev;
colors = (XColor *) xmalloc (img->width * img->height * sizeof *colors);
-#if 0 /* TODO: implement image colors. */
- /* Get the X image IMG->pixmap. */
- ximg = XGetImage (FRAME_X_DISPLAY (f), img->pixmap,
- 0, 0, img->width, img->height, ~0, ZPixmap);
+
+ /* Load the image into a memory device context. */
+ hdc = get_frame_dc (f);
+ bmpdc = CreateCompatibleDC (hdc);
+ release_frame_dc (f, hdc);
+ prev = SelectObject (bmpdc, img->pixmap);
/* Fill the `pixel' members of the XColor array. I wished there
were an easy and portable way to circumvent XGetPixel. */
for (y = 0; y < img->height; ++y)
{
XColor *row = p;
-
+
for (x = 0; x < img->width; ++x, ++p)
- p->pixel = XGetPixel (ximg, x, y);
+ {
+ /* TODO: palette support needed here? */
+ p->pixel = GetPixel (bmpdc, x, y);
- if (rgb_p)
- x_query_colors (f, row, img->width);
+ if (rgb_p)
+ {
+ p->red = 256 * GetRValue (p->pixel);
+ p->green = 256 * GetGValue (p->pixel);
+ p->blue = 256 * GetBValue (p->pixel);
+ }
+ }
}
- XDestroyImage (ximg);
-#endif
+ SelectObject (bmpdc, prev);
+ DeleteDC (bmpdc);
+
return colors;
}
rowbytes += 4 - (rowbytes % 4);
pixel = ximg->data + y * rowbytes + x * 3;
- *pixel = 255 - GetRValue (color);
- *(pixel + 1) = 255 - GetGValue (color);
- *(pixel + 2) = 255 - GetBValue (color);
+ /* Windows bitmaps are in BGR order. */
+ *pixel = GetBValue (color);
+ *(pixel + 1) = GetGValue (color);
+ *(pixel + 2) = GetRValue (color);
}
#if 0 /* TODO: color tables. */
pixel = lookup_rgb_color (f, p->red, p->green, p->blue);
#else
- pixel = PALETTERGB (p->red, p->green, p->blue);
+ pixel = PALETTERGB (p->red / 256, p->green / 256, p->blue / 256);
#endif
XPutPixel (oimg, x, y, pixel);
}
MATRIX is a nine-element array specifying the transformation
matrix. See emboss_matrix for an example.
-
+
COLOR_ADJUST is a color adjustment added to each pixel of the
outgoing image. */
p = COLOR (new, img->width - 1, y);
p->red = p->green = p->blue = 0xffff/2;
}
-
+
for (x = 1; x < img->width - 1; ++x)
{
p = COLOR (new, x, 0);
for (y = 1; y < img->height - 1; ++y)
{
p = COLOR (new, 1, y);
-
+
for (x = 1; x < img->width - 1; ++x, ++p)
{
int r, g, b, y1, x1;
{
int i = 0;
int trans[9];
-
+
if (CONSP (matrix))
{
for (i = 0;
should. */
if (dpyinfo->n_planes * dpyinfo->n_cbits < 2 || cross_disabled_images)
{
-#if 0 /* TODO: full image support */
- Display *dpy = FRAME_X_DISPLAY (f);
- GC gc;
+ HDC hdc, bmpdc;
+ HGDIOBJ prev;
- gc = XCreateGC (dpy, img->pixmap, 0, NULL);
- XSetForeground (dpy, gc, BLACK_PIX_DEFAULT (f));
- XDrawLine (dpy, img->pixmap, gc, 0, 0,
- img->width - 1, img->height - 1);
- XDrawLine (dpy, img->pixmap, gc, 0, img->height - 1,
- img->width - 1, 0);
- XFreeGC (dpy, gc);
+ hdc = get_frame_dc (f);
+ bmpdc = CreateCompatibleDC (hdc);
+ release_frame_dc (f, hdc);
+
+ prev = SelectObject (bmpdc, img->pixmap);
+
+ SetTextColor (bmpdc, BLACK_PIX_DEFAULT (f));
+ MoveToEx (bmpdc, 0, 0, NULL);
+ LineTo (bmpdc, img->width - 1, img->height - 1);
+ MoveToEx (bmpdc, 0, img->height - 1, NULL);
+ LineTo (bmpdc, img->width - 1, 0);
if (img->mask)
{
- gc = XCreateGC (dpy, img->mask, 0, NULL);
- XSetForeground (dpy, gc, WHITE_PIX_DEFAULT (f));
- XDrawLine (dpy, img->mask, gc, 0, 0,
- img->width - 1, img->height - 1);
- XDrawLine (dpy, img->mask, gc, 0, img->height - 1,
- img->width - 1, 0);
- XFreeGC (dpy, gc);
+ SelectObject (bmpdc, img->mask);
+ SetTextColor (bmpdc, WHITE_PIX_DEFAULT (f));
+ MoveToEx (bmpdc, 0, 0, NULL);
+ LineTo (bmpdc, img->width - 1, img->height - 1);
+ MoveToEx (bmpdc, 0, img->height - 1, NULL);
+ LineTo (bmpdc, img->width - 1, 0);
}
-#endif
+ SelectObject (bmpdc, prev);
+ DeleteDC (bmpdc);
}
}
struct image *img;
Lisp_Object how;
{
-#if 0 /* TODO: full image support. */
- Display *dpy = FRAME_W32_DISPLAY (f);
- XImage *ximg, *mask_img;
+ HDC img_dc, frame_dc;
+ HGDIOBJ prev;
+ char *mask_img;
int x, y, rc, use_img_background;
unsigned long bg = 0;
+ int row_width;
if (img->mask)
{
- XFreePixmap (FRAME_X_DISPLAY (f), img->mask);
- img->mask = None;
+ DeleteObject (img->mask);
+ img->mask = NULL;
img->background_transparent_valid = 0;
}
- /* Create an image and pixmap serving as mask. */
- rc = x_create_x_image_and_pixmap (f, img->width, img->height, 1,
- &mask_img, &img->mask);
- if (!rc)
- return 0;
+ /* Create the bit array serving as mask. */
+ row_width = (img->width + 7) / 8;
+ mask_img = xmalloc (row_width * img->height);
+ bzero (mask_img, row_width * img->height);
- /* Get the X image of IMG->pixmap. */
- ximg = XGetImage (dpy, img->pixmap, 0, 0, img->width, img->height,
- ~0, ZPixmap);
+ /* Create a memory device context for IMG->pixmap. */
+ frame_dc = get_frame_dc (f);
+ img_dc = CreateCompatibleDC (frame_dc);
+ release_frame_dc (f, frame_dc);
+ prev = SelectObject (img_dc, img->pixmap);
- /* Determine the background color of ximg. If HOW is `(R G B)'
+ /* Determine the background color of img_dc. If HOW is `(R G B)'
take that as color. Otherwise, use the image's background color. */
use_img_background = 1;
-
+
if (CONSP (how))
{
int rgb[3], i;
{
char color_name[30];
sprintf (color_name, "#%04x%04x%04x", rgb[0], rgb[1], rgb[2]);
- bg = x_alloc_image_color (f, img, build_string (color_name), 0);
+ bg = x_alloc_image_color (f, img, build_string (color_name), 0)
+ & 0x00ffffff; /* Filter out palette info. */
use_img_background = 0;
}
}
-
+
if (use_img_background)
- bg = four_corners_best (ximg, img->width, img->height);
+ bg = four_corners_best (img_dc, img->width, img->height);
/* Set all bits in mask_img to 1 whose color in ximg is different
from the background color bg. */
for (y = 0; y < img->height; ++y)
for (x = 0; x < img->width; ++x)
- XPutPixel (mask_img, x, y, XGetPixel (ximg, x, y) != bg);
+ {
+ COLORREF p = GetPixel (img_dc, x, y);
+ if (p != bg)
+ mask_img[y * row_width + x / 8] |= 1 << (x % 8);
+ }
+
+ /* Create the mask image. */
+ img->mask = w32_create_pixmap_from_bitmap_data (img->width, img->height,
+ mask_img);
/* Fill in the background_transparent field while we have the mask handy. */
- image_background_transparent (img, f, mask_img);
+ SelectObject (img_dc, img->mask);
+
+ image_background_transparent (img, f, img_dc);
/* Put mask_img into img->mask. */
- x_put_x_image (f, mask_img, img->mask, img->width, img->height);
x_destroy_x_image (mask_img);
- XDestroyImage (ximg);
+ SelectObject (img_dc, prev);
+ DeleteDC (img_dc);
return 1;
-#else
- return 0;
-#endif
}
-#endif
+
\f
/***********************************************************************
PBM (mono, gray, color)
***********************************************************************/
-#ifdef HAVE_PBM
static int pbm_image_p P_ ((Lisp_Object object));
static int pbm_load P_ ((struct frame *f, struct image *img));
{":type", IMAGE_SYMBOL_VALUE, 1},
{":file", IMAGE_STRING_VALUE, 0},
{":data", IMAGE_STRING_VALUE, 0},
- {":ascent", IMAGE_NON_NEGATIVE_INTEGER_VALUE, 0},
+ {":ascent", IMAGE_ASCENT_VALUE, 0},
{":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR, 0},
{":relief", IMAGE_INTEGER_VALUE, 0},
{":conversion", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
Lisp_Object object;
{
struct image_keyword fmt[PBM_LAST];
-
+
bcopy (pbm_format, fmt, sizeof fmt);
-
- if (!parse_image_spec (object, fmt, PBM_LAST, Qpbm)
- || (fmt[PBM_ASCENT].count
- && XFASTINT (fmt[PBM_ASCENT].value) > 100))
+
+ if (!parse_image_spec (object, fmt, PBM_LAST, Qpbm))
return 0;
/* Must specify either :data or :file. */
/* Read FILE into memory. Value is a pointer to a buffer allocated
with xmalloc holding FILE's contents. Value is null if an error
- occured. *SIZE is set to the size of the file. */
+ occurred. *SIZE is set to the size of the file. */
static char *
pbm_read_file (file, size)
char *buf = NULL;
struct stat st;
- if (stat (XSTRING (file)->data, &st) == 0
- && (fp = fopen (XSTRING (file)->data, "r")) != NULL
+ if (stat (SDATA (file), &st) == 0
+ && (fp = fopen (SDATA (file), "r")) != NULL
&& (buf = (char *) xmalloc (st.st_size),
fread (buf, 1, st.st_size, fp) == st.st_size))
{
buf = NULL;
}
}
-
+
return buf;
}
/* Load PBM image IMG for use on frame F. */
-static int
+static int
pbm_load (f, img)
struct frame *f;
struct image *img;
return 0;
}
- contents = slurp_file (XSTRING (file)->data, &size);
+ contents = slurp_file (SDATA (file), &size);
if (contents == NULL)
{
image_error ("Error reading `%s'", file, Qnil);
{
Lisp_Object data;
data = image_spec_value (img->spec, QCdata, NULL);
- p = XSTRING (data)->data;
- end = p + STRING_BYTES (XSTRING (data));
+ p = SDATA (data);
+ end = p + SBYTES (data);
}
/* Check magic number. */
case '1':
raw_p = 0, type = PBM_MONO;
break;
-
+
case '2':
raw_p = 0, type = PBM_GRAY;
break;
case '4':
raw_p = 1, type = PBM_MONO;
break;
-
+
case '5':
raw_p = 1, type = PBM_GRAY;
break;
-
+
case '6':
raw_p = 1, type = PBM_COLOR;
break;
if (raw_p && max_color_idx > 255)
max_color_idx = 255;
}
-
+
if (width < 0
|| height < 0
|| (type != PBM_MONO && max_color_idx < 0))
/* Parse the image specification. */
bcopy (pbm_format, fmt, sizeof fmt);
parse_image_spec (img->spec, fmt, PBM_LAST, Qpbm);
-
+
/* Get foreground and background colors, maybe allocate colors. */
if (fmt[PBM_FOREGROUND].count
&& STRINGP (fmt[PBM_FOREGROUND].value))
for (x = 0; x < width; ++x)
{
int r, g, b;
-
+
if (type == PBM_GRAY)
r = g = b = raw_p ? *p++ : pbm_scan_number (&p, end);
else if (raw_p)
g = pbm_scan_number (&p, end);
b = pbm_scan_number (&p, end);
}
-
+
if (r < 0 || g < 0 || b < 0)
{
x_destroy_x_image (ximg);
img->spec, Qnil);
goto error;
}
-
+
/* RGB values are now in the range 0..max_color_idx.
Scale this to the range 0..0xff supported by W32. */
r = (int) ((double) r * 255 / max_color_idx);
/* Maybe fill in the background field while we have ximg handy. */
if (NILP (image_spec_value (img->spec, QCbackground, NULL)))
IMAGE_BACKGROUND (img, f, ximg);
-
+
/* Put the image into a pixmap. */
x_put_x_image (f, ximg, img->pixmap, width, height);
x_destroy_x_image (ximg);
-
+
img->width = width;
img->height = height;
xfree (contents);
return 1;
}
-#endif /* HAVE_PBM */
\f
/***********************************************************************
{":type", IMAGE_SYMBOL_VALUE, 1},
{":data", IMAGE_STRING_VALUE, 0},
{":file", IMAGE_STRING_VALUE, 0},
- {":ascent", IMAGE_NON_NEGATIVE_INTEGER_VALUE, 0},
+ {":ascent", IMAGE_ASCENT_VALUE, 0},
{":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR, 0},
{":relief", IMAGE_INTEGER_VALUE, 0},
{":conversion", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
{
struct image_keyword fmt[PNG_LAST];
bcopy (png_format, fmt, sizeof fmt);
-
- if (!parse_image_spec (object, fmt, PNG_LAST, Qpng)
- || (fmt[PNG_ASCENT].count
- && XFASTINT (fmt[PNG_ASCENT].value) > 100))
+
+ if (!parse_image_spec (object, fmt, PNG_LAST, Qpng))
return 0;
/* Must specify either the :data or :file keyword. */
if (length > tbr->len - tbr->index)
png_error (png_ptr, "Read error");
-
+
bcopy (tbr->bytes + tbr->index, data, length);
tbr->index = tbr->index + length;
}
}
/* Open the image file. */
- fp = fopen (XSTRING (file)->data, "rb");
+ fp = fopen (SDATA (file), "rb");
if (!fp)
{
image_error ("Cannot open image file `%s'", file, Qnil);
else
{
/* Read from memory. */
- tbr.bytes = XSTRING (specified_data)->data;
- tbr.len = STRING_BYTES (XSTRING (specified_data));
+ tbr.bytes = SDATA (specified_data);
+ tbr.len = SBYTES (specified_data);
tbr.index = 0;
/* Check PNG signature. */
png_get_IHDR (png_ptr, info_ptr, &width, &height, &bit_depth, &color_type,
&interlace_type, NULL, NULL);
- /* If image contains simply transparency data, we prefer to
+ /* If image contains simply transparency data, we prefer to
construct a clipping mask. */
if (png_get_valid (png_ptr, info_ptr, PNG_INFO_tRNS))
transparent_p = 1;
else
transparent_p = 0;
- /* This function is easier to write if we only have to handle
+ /* This function is easier to write if we only have to handle
one data format: RGB or RGBA with 8 bits per channel. Let's
transform other formats into that format. */
png_set_expand (png_ptr);
/* Convert grayscale images to RGB. */
- if (color_type == PNG_COLOR_TYPE_GRAY
+ if (color_type == PNG_COLOR_TYPE_GRAY
|| color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
png_set_gray_to_rgb (png_ptr);
/* The user specified `:background', use that. */
{
COLORREF color;
- if (w32_defined_color (f, XSTRING (specified_bg)->data, &color, 0))
+ if (w32_defined_color (f, SDATA (specified_bg), &color, 0))
{
png_color_16 user_bg;
}
}
else if (png_get_bKGD (png_ptr, info_ptr, &image_background))
- /* Image contains a background color with which to
+ /* Image contains a background color with which to
combine the image. */
png_set_background (png_ptr, image_background,
PNG_BACKGROUND_GAMMA_FILE, 1, 1.0);
else
{
/* Image does not contain a background color with which
- to combine the image data via an alpha channel. Use
+ to combine the image data via an alpha channel. Use
the frame's background instead. */
XColor color;
Colormap cmap;
if (!x_create_x_image_and_pixmap (f, width, height, 0, &ximg,
&img->pixmap))
goto error;
-
+
/* Create an image and pixmap serving as mask if the PNG image
contains an alpha channel. */
if (channels == 4
XPutPixel (ximg, x, y, lookup_rgb_color (f, r, g, b));
/* An alpha channel, aka mask channel, associates variable
- transparency with an image. Where other image formats
- support binary transparency---fully transparent or fully
+ transparency with an image. Where other image formats
+ support binary transparency---fully transparent or fully
opaque---PNG allows up to 254 levels of partial transparency.
The PNG library implements partial transparency by combining
the image with a specified background color.
I'm not sure how to handle this here nicely: because the
background on which the image is displayed may change, for
- real alpha channel support, it would be necessary to create
- a new image for each possible background.
+ real alpha channel support, it would be necessary to create
+ a new image for each possible background.
What I'm doing now is that a mask is created if we have
boolean transparency information. Otherwise I'm using
{":type", IMAGE_SYMBOL_VALUE, 1},
{":data", IMAGE_STRING_VALUE, 0},
{":file", IMAGE_STRING_VALUE, 0},
- {":ascent", IMAGE_NON_NEGATIVE_INTEGER_VALUE, 0},
+ {":ascent", IMAGE_ASCENT_VALUE, 0},
{":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR, 0},
{":relief", IMAGE_INTEGER_VALUE, 0},
{":conversions", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
Lisp_Object object;
{
struct image_keyword fmt[JPEG_LAST];
-
+
bcopy (jpeg_format, fmt, sizeof fmt);
-
- if (!parse_image_spec (object, fmt, JPEG_LAST, Qjpeg)
- || (fmt[JPEG_ASCENT].count
- && XFASTINT (fmt[JPEG_ASCENT].value) > 100))
+
+ if (!parse_image_spec (object, fmt, JPEG_LAST, Qjpeg))
return 0;
/* Must specify either the :data or :file keyword. */
{
if (num_bytes > src->bytes_in_buffer)
ERREXIT (cinfo, JERR_INPUT_EOF);
-
+
src->bytes_in_buffer -= num_bytes;
src->next_input_byte += num_bytes;
}
src = (struct jpeg_source_mgr *) cinfo->src;
src->next_input_byte = data;
}
-
+
src = (struct jpeg_source_mgr *) cinfo->src;
src->init_source = our_init_source;
src->fill_input_buffer = our_fill_input_buffer;
/* Load image IMG for use on frame F. Patterned after example.c
from the JPEG lib. */
-static int
+static int
jpeg_load (f, img)
struct frame *f;
struct image *img;
UNGCPRO;
return 0;
}
-
- fp = fopen (XSTRING (file)->data, "r");
+
+ fp = fopen (SDATA (file), "r");
if (fp == NULL)
{
image_error ("Cannot open `%s'", file, Qnil);
return 0;
}
}
-
+
/* Customize libjpeg's error handling to call my_error_exit when an
error is detected. This function will perform a longjmp. */
cinfo.err = jpeg_std_error (&mgr.pub);
mgr.pub.error_exit = my_error_exit;
-
+
if ((rc = setjmp (mgr.setjmp_buffer)) != 0)
{
if (rc == 1)
image_error ("Error reading JPEG image `%s': %s", img->spec,
build_string (buffer));
}
-
+
/* Close the input file and destroy the JPEG object. */
if (fp)
fclose (fp);
jpeg_destroy_decompress (&cinfo);
-
+
/* If we already have an XImage, free that. */
x_destroy_x_image (ximg);
/* Free pixmap and colors. */
x_clear_image (f, img);
-
+
UNGCPRO;
return 0;
}
if (NILP (specified_data))
jpeg_stdio_src (&cinfo, fp);
else
- jpeg_memory_src (&cinfo, XSTRING (specified_data)->data,
- STRING_BYTES (XSTRING (specified_data)));
+ jpeg_memory_src (&cinfo, SDATA (specified_data),
+ SBYTES (specified_data));
jpeg_read_header (&cinfo, TRUE);
init_color_table ();
colors = (unsigned long *) alloca (cinfo.actual_number_of_colors
* sizeof *colors);
-
+
for (i = 0; i < cinfo.actual_number_of_colors; ++i)
{
/* Multiply RGB values with 255 because X expects RGB values
jpeg_destroy_decompress (&cinfo);
if (fp)
fclose (fp);
-
+
/* Maybe fill in the background field while we have ximg handy. */
if (NILP (image_spec_value (img->spec, QCbackground, NULL)))
IMAGE_BACKGROUND (img, f, ximg);
-
+
/* Put the image into the pixmap. */
x_put_x_image (f, ximg, img->pixmap, width, height);
x_destroy_x_image (ximg);
{":type", IMAGE_SYMBOL_VALUE, 1},
{":data", IMAGE_STRING_VALUE, 0},
{":file", IMAGE_STRING_VALUE, 0},
- {":ascent", IMAGE_NON_NEGATIVE_INTEGER_VALUE, 0},
+ {":ascent", IMAGE_ASCENT_VALUE, 0},
{":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR, 0},
{":relief", IMAGE_INTEGER_VALUE, 0},
{":conversions", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
{
struct image_keyword fmt[TIFF_LAST];
bcopy (tiff_format, fmt, sizeof fmt);
-
- if (!parse_image_spec (object, fmt, TIFF_LAST, Qtiff)
- || (fmt[TIFF_ASCENT].count
- && XFASTINT (fmt[TIFF_ASCENT].value) > 100))
+
+ if (!parse_image_spec (object, fmt, TIFF_LAST, Qtiff))
return 0;
-
+
/* Must specify either the :data or :file keyword. */
return fmt[TIFF_FILE].count + fmt[TIFF_DATA].count == 1;
}
case SEEK_SET: /* Go from beginning of source. */
idx = off;
break;
-
+
case SEEK_END: /* Go from end of source. */
idx = src->len + off;
break;
-
+
case SEEK_CUR: /* Go from current position. */
idx = src->index + off;
break;
-
+
default: /* Invalid `whence'. */
return -1;
}
-
+
if (idx > src->len || idx < 0)
return -1;
-
+
src->index = idx;
return src->index;
}
{
char buf[512];
int len;
-
+
len = sprintf (buf, "TIFF error: %s ", title);
vsprintf (buf + len, format, ap);
add_to_log (buf, Qnil, Qnil);
{
char buf[512];
int len;
-
+
len = sprintf (buf, "TIFF warning: %s ", title);
vsprintf (buf + len, format, ap);
add_to_log (buf, Qnil, Qnil);
UNGCPRO;
return 0;
}
-
+
/* Try to open the image file. */
- tiff = TIFFOpen (XSTRING (file)->data, "r");
+ tiff = TIFFOpen (SDATA (file), "r");
if (tiff == NULL)
{
image_error ("Cannot open `%s'", file, Qnil);
else
{
/* Memory source! */
- memsrc.bytes = XSTRING (specified_data)->data;
- memsrc.len = STRING_BYTES (XSTRING (specified_data));
+ memsrc.bytes = SDATA (specified_data);
+ memsrc.len = SBYTES (specified_data);
memsrc.index = 0;
tiff = TIFFClientOpen ("memory_source", "r", &memsrc,
TIFFGetField (tiff, TIFFTAG_IMAGEWIDTH, &width);
TIFFGetField (tiff, TIFFTAG_IMAGELENGTH, &height);
buf = (uint32 *) xmalloc (width * height * sizeof *buf);
-
+
rc = TIFFReadRGBAImage (tiff, width, height, buf, 0);
TIFFClose (tiff);
if (!rc)
for (y = 0; y < height; ++y)
{
uint32 *row = buf + y * width;
-
+
for (x = 0; x < width; ++x)
{
uint32 abgr = row[x];
int r = TIFFGetR (abgr) << 8;
int g = TIFFGetG (abgr) << 8;
int b = TIFFGetB (abgr) << 8;
- XPutPixel (ximg, x, height - 1 - y, lookup_rgb_color (f, r, g, b));
+ XPutPixel (ximg, x, height - 1 - y, lookup_rgb_color (f, r, g, b));
}
}
{":type", IMAGE_SYMBOL_VALUE, 1},
{":data", IMAGE_STRING_VALUE, 0},
{":file", IMAGE_STRING_VALUE, 0},
- {":ascent", IMAGE_NON_NEGATIVE_INTEGER_VALUE, 0},
+ {":ascent", IMAGE_ASCENT_VALUE, 0},
{":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR, 0},
{":relief", IMAGE_INTEGER_VALUE, 0},
{":conversion", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
{
struct image_keyword fmt[GIF_LAST];
bcopy (gif_format, fmt, sizeof fmt);
-
- if (!parse_image_spec (object, fmt, GIF_LAST, Qgif)
- || (fmt[GIF_ASCENT].count
- && XFASTINT (fmt[GIF_ASCENT].value) > 100))
+
+ if (!parse_image_spec (object, fmt, GIF_LAST, Qgif))
return 0;
-
+
/* Must specify either the :data or :file keyword. */
return fmt[GIF_FILE].count + fmt[GIF_DATA].count == 1;
}
UNGCPRO;
return 0;
}
-
+
/* Open the GIF file. */
- gif = DGifOpenFileName (XSTRING (file)->data);
+ gif = DGifOpenFileName (SDATA (file));
if (gif == NULL)
{
image_error ("Cannot open `%s'", file, Qnil);
{
/* Read from memory! */
current_gif_memory_src = &memsrc;
- memsrc.bytes = XSTRING (specified_data)->data;
- memsrc.len = STRING_BYTES (XSTRING (specified_data));
+ memsrc.bytes = SDATA (specified_data);
+ memsrc.len = SBYTES (specified_data);
memsrc.index = 0;
gif = DGifOpen(&memsrc, gif_read_from_memory);
UNGCPRO;
return 0;
}
-
+
/* Allocate colors. */
gif_color_map = gif->SavedImages[ino].ImageDesc.ColorMap;
if (!gif_color_map)
gif_color_map = gif->SColorMap;
init_color_table ();
bzero (pixel_colors, sizeof pixel_colors);
-
+
for (i = 0; i < gif_color_map->ColorCount; ++i)
{
int r = gif_color_map->Colors[i].Red << 8;
free_color_table ();
/* Clear the part of the screen image that are not covered by
- the image from the GIF file. Full animated GIF support
+ the image from the GIF file. Full animated GIF support
requires more than can be done here (see the gif89 spec,
disposal methods). Let's simply assume that the part
not covered by a sub-image is in the frame's background color. */
while (row >= image_height)
row = interlace_start[++pass];
}
-
+
for (x = 0; x < image_width; x++)
{
int i = raster[(y * image_width) + x];
XPutPixel (ximg, x + image_left, row + image_top,
pixel_colors[i]);
}
-
+
row += interlace_increment[pass];
}
}
XPutPixel (ximg, x + image_left, y + image_top, pixel_colors[i]);
}
}
-
+
DGifCloseFile (gif);
/* Maybe fill in the background field while we have ximg handy. */
/* Put the image into the pixmap, then free the X image and its buffer. */
x_put_x_image (f, ximg, img->pixmap, width, height);
x_destroy_x_image (ximg);
-
+
UNGCPRO;
return 1;
}
{":file", IMAGE_STRING_VALUE, 1},
{":loader", IMAGE_FUNCTION_VALUE, 0},
{":bounding-box", IMAGE_DONT_CHECK_VALUE_TYPE, 1},
- {":ascent", IMAGE_NON_NEGATIVE_INTEGER_VALUE, 0},
+ {":ascent", IMAGE_ASCENT_VALUE, 0},
{":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR, 0},
{":relief", IMAGE_INTEGER_VALUE, 0},
{":conversion", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
struct image_keyword fmt[GS_LAST];
Lisp_Object tem;
int i;
-
+
bcopy (gs_format, fmt, sizeof fmt);
-
- if (!parse_image_spec (object, fmt, GS_LAST, Qpostscript)
- || (fmt[GS_ASCENT].count
- && XFASTINT (fmt[GS_ASCENT].value) > 100))
+
+ if (!parse_image_spec (object, fmt, GS_LAST, Qpostscript))
return 0;
/* Bounding box must be a list or vector containing 4 integers. */
image_error ("Unable to create pixmap for `%s'", img->spec, Qnil);
return 0;
}
-
+
/* Call the loader to fill the pixmap. It returns a process object
if successful. We do not record_unwind_protect here because
other places in redisplay like calling window scroll functions
(unsigned long) FRAME_W32_WINDOW (f),
(unsigned long) img->pixmap);
window_and_pixmap_id = build_string (buffer);
-
+
sprintf (buffer, "%lu %lu",
FRAME_FOREGROUND_PIXEL (f),
FRAME_BACKGROUND_PIXEL (f));
pixel_colors = build_string (buffer);
-
+
XSETFRAME (frame, f);
loader = image_spec_value (img->spec, QCloader, NULL);
if (NILP (loader))
if (ximg)
{
int x, y;
-
+
/* Initialize the color table. */
init_color_table ();
-
+
/* For each pixel of the image, look its color up in the
color table. After having done so, the color table will
contain an entry for each color used by the image. */
else
image_error ("Cannot get X image of `%s'; colors will not be freed",
img->spec, Qnil);
-
+
UNBLOCK_INPUT;
}
CHECK_STRING (value);
BLOCK_INPUT;
- prop_atom = XInternAtom (FRAME_W32_DISPLAY (f), XSTRING (prop)->data, False);
+ prop_atom = XInternAtom (FRAME_W32_DISPLAY (f), SDATA (prop), False);
XChangeProperty (FRAME_W32_DISPLAY (f), FRAME_W32_WINDOW (f),
prop_atom, XA_STRING, 8, PropModeReplace,
- XSTRING (value)->data, XSTRING (value)->size);
+ SDATA (value), SCHARS (value));
/* Make sure the property is set when we return. */
XFlush (FRAME_W32_DISPLAY (f));
CHECK_STRING (prop);
BLOCK_INPUT;
- prop_atom = XInternAtom (FRAME_W32_DISPLAY (f), XSTRING (prop)->data, False);
+ prop_atom = XInternAtom (FRAME_W32_DISPLAY (f), SDATA (prop), False);
XDeleteProperty (FRAME_W32_DISPLAY (f), FRAME_W32_WINDOW (f), prop_atom);
/* Make sure the property is removed when we return. */
CHECK_STRING (prop);
BLOCK_INPUT;
- prop_atom = XInternAtom (FRAME_W32_DISPLAY (f), XSTRING (prop)->data, False);
+ prop_atom = XInternAtom (FRAME_W32_DISPLAY (f), SDATA (prop), False);
rc = XGetWindowProperty (FRAME_W32_DISPLAY (f), FRAME_W32_WINDOW (f),
prop_atom, 0, 0, False, XA_STRING,
&actual_type, &actual_format, &actual_size,
rc = XGetWindowProperty (FRAME_W32_DISPLAY (f), FRAME_W32_WINDOW (f),
prop_atom, 0, bytes_remaining,
False, XA_STRING,
- &actual_type, &actual_format,
- &actual_size, &bytes_remaining,
+ &actual_type, &actual_format,
+ &actual_size, &bytes_remaining,
(unsigned char **) &tmp_data);
if (rc == Success)
prop_value = make_string (tmp_data, size);
#if 0 /* TODO: cursor shape changes. */
EMACS_TIME delay;
int secs, usecs = 0;
-
+
cancel_hourglass ();
if (INTEGERP (Vhourglass_delay)
}
else
secs = DEFAULT_HOURGLASS_DELAY;
-
+
EMACS_SET_SECS_USECS (delay, secs, usecs);
hourglass_atimer = start_atimer (ATIMER_RELATIVE, delay,
show_hourglass, NULL);
cancel_atimer (hourglass_atimer);
hourglass_atimer = NULL;
}
-
+
if (hourglass_shown_p)
hide_hourglass ();
}
if (!hourglass_shown_p)
{
Lisp_Object rest, frame;
-
+
BLOCK_INPUT;
-
+
FOR_EACH_FRAME (rest, frame)
if (FRAME_W32_P (XFRAME (frame)))
{
struct frame *f = XFRAME (frame);
-
+
f->output_data.w32->hourglass_p = 1;
-
+
if (!f->output_data.w32->hourglass_window)
{
unsigned long mask = CWCursor;
XSetWindowAttributes attrs;
-
+
attrs.cursor = f->output_data.w32->hourglass_cursor;
-
+
f->output_data.w32->hourglass_window
= XCreateWindow (FRAME_X_DISPLAY (f),
FRAME_OUTER_WINDOW (f),
CopyFromParent,
mask, &attrs);
}
-
+
XMapRaised (FRAME_X_DISPLAY (f),
f->output_data.w32->hourglass_window);
XFlush (FRAME_X_DISPLAY (f));
FOR_EACH_FRAME (rest, frame)
{
struct frame *f = XFRAME (frame);
-
+
if (FRAME_W32_P (f)
/* Watch out for newly created frames. */
&& f->output_data.x->hourglass_window)
Lisp_Object, Lisp_Object));
static void compute_tip_xy P_ ((struct frame *, Lisp_Object, Lisp_Object,
Lisp_Object, int, int, int *, int *));
-
+
/* The frame of a currently visible tooltip. */
Lisp_Object tip_frame;
tip_window = NULL;
tip_frame = Qnil;
}
-
+
return deleted;
}
Lisp_Object name;
long window_prompting = 0;
int width, height;
- int count = BINDING_STACK_SIZE ();
+ int count = SPECPDL_INDEX ();
struct gcpro gcpro1, gcpro2, gcpro3;
struct kboard *kb;
int face_change_count_before = face_change_count;
Ferase_buffer ();
Finsert (1, &text);
set_buffer_internal_1 (old_buffer);
-
+
FRAME_CAN_HAVE_SCROLL_BARS (f) = 0;
record_unwind_protect (unwind_create_tip_frame, frame);
{
tem = Fquery_fontset (font, Qnil);
if (STRINGP (tem))
- font = x_new_fontset (f, XSTRING (tem)->data);
+ font = x_new_fontset (f, SDATA (tem));
else
- font = x_new_font (f, XSTRING (font)->data);
+ font = x_new_font (f, SDATA (font));
}
-
+
/* Try out a font which we hope has bold and italic variations. */
if (!STRINGP (font))
font = x_new_font (f, "-*-Courier New-normal-r-*-*-*-100-*-*-c-*-iso8859-1");
SET_FRAME_WIDTH (f, 0);
change_frame_size (f, height, width, 1, 0, 0);
+ /* Add `tooltip' frame parameter's default value. */
+ if (NILP (Fframe_parameter (frame, intern ("tooltip"))))
+ Fmodify_frame_parameters (frame, Fcons (Fcons (intern ("tooltip"), Qt),
+ Qnil));
+
/* Set up faces after all frame parameters are known. This call
also merges in face attributes specified for new frames.
/* Set tip_frame here, so that */
tip_frame = frame;
call1 (Qface_set_after_frame_default, frame);
-
+
if (!EQ (bg, Fframe_parameter (frame, Qbackground_color)))
Fmodify_frame_parameters (frame, Fcons (Fcons (Qbackground_color, bg),
Qnil));
}
-
+
f->no_split = 1;
UNGCPRO;
int *root_x, *root_y;
{
Lisp_Object left, top;
-
+
/* User-specified position? */
left = Fcdr (Fassq (Qleft, parms));
top = Fcdr (Fassq (Qtop, parms));
-
+
/* Move the tooltip window where the mouse pointer is. Resize and
show it. */
if (!INTEGERP (left) || !INTEGERP (top))
int i, width, height;
struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
int old_windows_or_buffers_changed = windows_or_buffers_changed;
- int count = BINDING_STACK_SIZE ();
-
+ int count = SPECPDL_INDEX ();
+
specbind (Qinhibit_redisplay, Qt);
GCPRO4 (string, parms, frame, timeout);
dx = make_number (5);
else
CHECK_NUMBER (dx);
-
+
if (NILP (dy))
dy = make_number (-10);
else
&& !NILP (Fequal (last_parms, parms)))
{
struct frame *f = XFRAME (tip_frame);
-
+
/* Only DX and DY have changed. */
if (!NILP (tip_timer))
{
w->width = make_number (80);
w->height = make_number (40);
}
-
+
f->window_width = XINT (w->width);
adjust_glyphs (f);
w->pseudo_window_p = 1;
else
#endif
row_width = row->pixel_width;
-
+
/* TODO: find why tips do not draw along baseline as instructed. */
height += row->height;
width = max (width, row_width);
/* Return quickly if nothing to do. */
if (NILP (tip_timer) && NILP (tip_frame))
return Qnil;
-
+
frame = tip_frame;
timer = tip_timer;
GCPRO2 (frame, timer);
tip_frame = tip_timer = deleted = Qnil;
-
- count = BINDING_STACK_SIZE ();
+
+ count = SPECPDL_INDEX ();
specbind (Qinhibit_redisplay, Qt);
specbind (Qinhibit_quit, Qt);
-
+
if (!NILP (timer))
call1 (Qcancel_timer, timer);
/***********************************************************************
File selection dialog
***********************************************************************/
-
extern Lisp_Object Qfile_name_history;
+/* Callback for altering the behaviour 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
+ allows us to work around the fact that the standard Open File
+ dialog does not support directories. */
+UINT CALLBACK
+file_dialog_callback (hwnd, msg, wParam, lParam)
+ HWND hwnd;
+ UINT msg;
+ WPARAM wParam;
+ LPARAM lParam;
+{
+ if (msg == WM_NOTIFY)
+ {
+ OFNOTIFY * notify = (OFNOTIFY *)lParam;
+ /* Detect when the Filter dropdown is changed. */
+ if (notify->hdr.code == CDN_TYPECHANGE)
+ {
+ HWND dialog = GetParent (hwnd);
+ HWND edit_control = GetDlgItem (dialog, FILE_NAME_TEXT_FIELD);
+
+ /* Directories is in index 2. */
+ if (notify->lpOFN->nFilterIndex == 2)
+ {
+ CommDlg_OpenSave_SetControlText (dialog, FILE_NAME_TEXT_FIELD,
+ "Current Directory");
+ EnableWindow (edit_control, FALSE);
+ }
+ else
+ {
+ CommDlg_OpenSave_SetControlText (dialog, FILE_NAME_TEXT_FIELD,
+ "");
+ EnableWindow (edit_control, TRUE);
+ }
+ }
+ }
+ return 0;
+}
+
DEFUN ("x-file-dialog", Fx_file_dialog, Sx_file_dialog, 2, 4, 0,
doc: /* Read file name, prompting with PROMPT in directory DIR.
Use a file selection dialog.
{
struct frame *f = SELECTED_FRAME ();
Lisp_Object file = Qnil;
- int count = specpdl_ptr - specpdl;
+ int count = SPECPDL_INDEX ();
struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5;
char filename[MAX_PATH + 1];
char init_dir[MAX_PATH + 1];
- int use_dialog_p = 1;
GCPRO5 (prompt, dir, default_filename, mustmatch, file);
CHECK_STRING (prompt);
/* 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, XSTRING (dir)->data, MAX_PATH);
+ strncpy (init_dir, SDATA (dir), MAX_PATH);
init_dir[MAX_PATH] = '\0';
unixtodos_filename (init_dir);
if (STRINGP (default_filename))
{
char *file_name_only;
- char *full_path_name = XSTRING (default_filename)->data;
+ char *full_path_name = SDATA (default_filename);
unixtodos_filename (full_path_name);
else
{
file_name_only++;
-
- /* If default_file_name is a directory, don't use the open
- file dialog, as it does not support selecting
- directories. */
- if (!(*file_name_only))
- use_dialog_p = 0;
}
strncpy (filename, file_name_only, MAX_PATH);
else
filename[0] = '\0';
- if (use_dialog_p)
- {
- OPENFILENAME file_details;
+ {
+ OPENFILENAME file_details;
- /* Prevent redisplay. */
- specbind (Qinhibit_redisplay, Qt);
- BLOCK_INPUT;
+ /* Prevent redisplay. */
+ specbind (Qinhibit_redisplay, Qt);
+ BLOCK_INPUT;
- bzero (&file_details, sizeof (file_details));
- file_details.lStructSize = sizeof (file_details);
- 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*.*\0\0";
- file_details.lpstrFile = filename;
- file_details.nMaxFile = sizeof (filename);
- file_details.lpstrInitialDir = init_dir;
- file_details.lpstrTitle = XSTRING (prompt)->data;
- file_details.Flags = OFN_HIDEREADONLY | OFN_NOCHANGEDIR;
-
- if (!NILP (mustmatch))
- file_details.Flags |= OFN_FILEMUSTEXIST | OFN_PATHMUSTEXIST;
-
- if (GetOpenFileName (&file_details))
- {
- dostounix_filename (filename);
- file = build_string (filename);
- }
- else
- file = Qnil;
+ bzero (&file_details, sizeof (file_details));
+ file_details.lStructSize = sizeof (file_details);
+ 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);
+ file_details.Flags = (OFN_HIDEREADONLY | OFN_NOCHANGEDIR
+ | OFN_EXPLORER | OFN_ENABLEHOOK);
+ if (!NILP (mustmatch))
+ file_details.Flags |= OFN_FILEMUSTEXIST | OFN_PATHMUSTEXIST;
+
+ file_details.lpfnHook = (LPOFNHOOKPROC) file_dialog_callback;
+
+ if (GetOpenFileName (&file_details))
+ {
+ dostounix_filename (filename);
+ if (file_details.nFilterIndex == 2)
+ {
+ /* "Folder Only" selected - strip dummy file name. */
+ char * last = strrchr (filename, '/');
+ *last = '\0';
+ }
- UNBLOCK_INPUT;
- file = unbind_to (count, file);
- }
- /* Open File dialog will not allow folders to be selected, so resort
- to minibuffer completing reads for directories. */
- else
- file = Fcompleting_read (prompt, intern ("read-file-name-internal"),
- dir, mustmatch, dir, Qfile_name_history,
- default_filename, Qnil);
+ file = DECODE_FILE(build_string (filename));
+ }
+ /* User cancelled the dialog without making a selection. */
+ else if (!CommDlgExtendedError ())
+ file = 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);
+
+ UNBLOCK_INPUT;
+ file = unbind_to (count, file);
+ }
UNGCPRO;
document = ENCODE_FILE (document);
if ((int) ShellExecute (NULL,
(STRINGP (operation) ?
- XSTRING (operation)->data : NULL),
- XSTRING (document)->data,
+ SDATA (operation) : NULL),
+ SDATA (document),
(STRINGP (parameters) ?
- XSTRING (parameters)->data : NULL),
- XSTRING (current_dir)->data,
+ SDATA (parameters) : NULL),
+ SDATA (current_dir),
(INTEGERP (show_flag) ?
XINT (show_flag) : SW_SHOWDEFAULT))
> 32)
c = Fcar (c);
if (!SYMBOLP (c))
abort ();
- vk_code = lookup_vk_code (XSYMBOL (c)->name->data);
+ vk_code = lookup_vk_code (SDATA (SYMBOL_NAME (c)));
}
else if (INTEGERP (c))
{
/* On Windows, we may need to specify the root directory of the
volume holding FILENAME. */
char rootname[MAX_PATH];
- char *name = XSTRING (encoded)->data;
+ char *name = SDATA (encoded);
/* find the root name of the volume if given */
if (isalpha (name[0]) && name[1] == ':')
void
syms_of_w32fns ()
{
- HMODULE user32_lib = GetModuleHandle ("user32.dll");
-
- /* This is zero if not using MS-Windows. */
+ globals_of_w32fns ();
+ /* This is zero if not using MS-Windows. */
w32_in_use = 0;
-
- /* TrackMouseEvent not available in all versions of Windows, so must load
- it dynamically. Do it once, here, instead of every time it is used. */
- track_mouse_event_fn = GetProcAddress (user32_lib, "TrackMouseEvent");
track_mouse_window = NULL;
w32_visible_system_caret_hwnd = NULL;
staticpro (&Qauto_raise);
Qauto_lower = intern ("auto-lower");
staticpro (&Qauto_lower);
- Qbar = intern ("bar");
- staticpro (&Qbar);
Qborder_color = intern ("border-color");
staticpro (&Qborder_color);
Qborder_width = intern ("border-width");
staticpro (&Qborder_width);
- Qbox = intern ("box");
- staticpro (&Qbox);
Qcursor_color = intern ("cursor-color");
staticpro (&Qcursor_color);
Qcursor_type = intern ("cursor-type");
doc: /* If non-zero, the virtual key code for an alternative quit key. */);
XSETINT (Vw32_quit_key, 0);
- DEFVAR_LISP ("w32-pass-lwindow-to-system",
+ DEFVAR_LISP ("w32-pass-lwindow-to-system",
&Vw32_pass_lwindow_to_system,
doc: /* Non-nil if the left \"Windows\" key is passed on to Windows.
When non-nil, the Start menu is opened by tapping the key. */);
Vw32_pass_lwindow_to_system = Qt;
- DEFVAR_LISP ("w32-pass-rwindow-to-system",
+ DEFVAR_LISP ("w32-pass-rwindow-to-system",
&Vw32_pass_rwindow_to_system,
doc: /* Non-nil if the right \"Windows\" key is passed on to Windows.
When non-nil, the Start menu is opened by tapping the key. */);
means that this hack won't interfere with any real key code. */
Vw32_phantom_key_code = 255;
- DEFVAR_LISP ("w32-enable-num-lock",
+ DEFVAR_LISP ("w32-enable-num-lock",
&Vw32_enable_num_lock,
doc: /* Non-nil if Num Lock should act normally.
Set to nil to see Num Lock as the key `kp-numlock'. */);
Vw32_enable_num_lock = Qt;
- DEFVAR_LISP ("w32-enable-caps-lock",
+ DEFVAR_LISP ("w32-enable-caps-lock",
&Vw32_enable_caps_lock,
doc: /* Non-nil if Caps Lock should act normally.
Set to nil to see Caps Lock as the key `capslock'. */);
init_x_parm_symbols ();
DEFVAR_LISP ("x-bitmap-file-path", &Vx_bitmap_file_path,
- doc: /* List of directories to search for bitmap files for w32. */);
+ doc: /* List of directories to search for window system bitmap files. */);
Vx_bitmap_file_path = decode_env_path ((char *) 0, "PATH");
DEFVAR_LISP ("x-pointer-shape", &Vx_pointer_shape,
DEFVAR_BOOL ("display-hourglass", &display_hourglass_p,
doc: /* Non-zero means Emacs displays an hourglass pointer on window systems. */);
display_hourglass_p = 1;
-
+
DEFVAR_LISP ("hourglass-delay", &Vhourglass_delay,
doc: /* *Seconds to wait before displaying an hourglass pointer.
Value must be an integer or float. */);
doc: /* Maximum size for tooltips.
Value is a pair (COLUMNS . ROWS). Text larger than this is clipped. */);
Vx_max_tooltip_size = Fcons (make_number (80), make_number (40));
-
+
DEFVAR_LISP ("x-no-window-manager", &Vx_no_window_manager,
doc: /* Non-nil if no window manager is in use.
Emacs doesn't try to figure this out; this is always nil
set_frame_fontset_func = x_set_font;
check_window_system_func = check_w32;
-#ifdef IMAGES
/* Images. */
Qxbm = intern ("xbm");
staticpro (&Qxbm);
staticpro (&QCindex);
Qpbm = intern ("pbm");
staticpro (&Qpbm);
-#endif
#if HAVE_XPM
Qxpm = intern ("xpm");
staticpro (&Qxpm);
#endif
-
+
#if HAVE_JPEG
Qjpeg = intern ("jpeg");
staticpro (&Qjpeg);
-#endif
+#endif
#if HAVE_TIFF
Qtiff = intern ("tiff");
staticpro (&Qtiff);
-#endif
+#endif
#if HAVE_GIF
Qgif = intern ("gif");
staticpro (&Qpng);
#endif
-#ifdef HAVE_IMAGES
defsubr (&Sclear_image_cache);
defsubr (&Simage_size);
defsubr (&Simage_mask_p);
-#endif
#if GLYPH_DEBUG
defsubr (&Simagep);
defsubr (&Sx_file_dialog);
}
+
+/*
+ globals_of_w32fns is used to initialize those global variables that
+ must always be initialized on startup even when the global variable
+ initialized is non zero (see the function main in emacs.c).
+ globals_of_w32fns is called from syms_of_w32fns when the global
+ variable initialized is 0 and directly from main when initialized
+ is non zero.
+ */
+void globals_of_w32fns ()
+{
+ HMODULE user32_lib = GetModuleHandle ("user32.dll");
+ /*
+ TrackMouseEvent not available in all versions of Windows, so must load
+ it dynamically. Do it once, here, instead of every time it is used.
+ */
+ track_mouse_event_fn = (TrackMouseEvent_Proc) GetProcAddress (user32_lib, "TrackMouseEvent");
+}
+
void
init_xfns ()
{
image_types = NULL;
Vimage_types = Qnil;
-#if HAVE_PBM
define_image_type (&pbm_type);
-#endif
-
-#if 0 /* TODO : Image support for W32 */
define_image_type (&xbm_type);
+#if 0 /* TODO : Image support for W32 */
define_image_type (&gs_type);
#endif
-
+
#if HAVE_XPM
define_image_type (&xpm_type);
#endif
-
+
#if HAVE_JPEG
define_image_type (&jpeg_type);
#endif
-
+
#if HAVE_TIFF
define_image_type (&tiff_type);
#endif
-
+
#if HAVE_GIF
define_image_type (&gif_type);
#endif
-
+
#if HAVE_PNG
define_image_type (&png_type);
#endif
#undef abort
-void
+void
w32_abort()
{
int button;