#include <shellapi.h>
#include <ctype.h>
-#define max(a, b) ((a) > (b) ? (a) : (b))
+#include <dlgs.h>
+#define FILE_NAME_TEXT_FIELD edt1
+
+void syms_of_w32fns ();
+void globals_of_w32fns ();
+static void init_external_image_libraries ();
extern void free_frame_menubar ();
+extern void x_compute_fringe_widths P_ ((struct frame *, int));
extern double atof ();
-extern int w32_console_toggle_lock_key (int vk_code, Lisp_Object new_state);
-extern int quit_char;
+extern int w32_console_toggle_lock_key P_ ((int, Lisp_Object));
+extern void w32_menu_display_help P_ ((HWND, HMENU, UINT, UINT));
+extern void w32_free_menu_strings P_ ((HWND));
-/* 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 int quit_char;
extern char *lispy_function_keys[];
/* Switch to control whether we inhibit requests for synthesized bold
and italic versions of fonts. */
-Lisp_Object Vw32_enable_synthesized_fonts;
+int w32_enable_synthesized_fonts;
/* Enable palette management. */
Lisp_Object Vw32_enable_palette;
events that are passed on to the event loop. */
Lisp_Object Vw32_mouse_move_interval;
+/* Flag to indicate if XBUTTON events should be passed on to Windows. */
+int w32_pass_extra_mouse_buttons_to_system;
+
/* The name we're using in resource queries. */
Lisp_Object Vx_resource_name;
over text or in the modeline. */
Lisp_Object Vx_pointer_shape, Vx_nontext_pointer_shape, Vx_mode_pointer_shape;
-Lisp_Object Vx_hourglass_pointer_shape, Vx_window_horizontal_drag_shape;
+Lisp_Object Vx_hourglass_pointer_shape, Vx_window_horizontal_drag_shape, Vx_hand_shape;
/* The shape when over mouse-sensitive text. */
Lisp_Object Vx_sensitive_text_pointer_shape;
+#ifndef IDC_HAND
+#define IDC_HAND MAKEINTRESOURCE(32649)
+#endif
+
/* Color of chars displayed in cursor box. */
Lisp_Object Vx_cursor_fore_pixel;
/* Alist of bdf fonts and the files that define them. */
Lisp_Object Vw32_bdf_filename_alist;
-Lisp_Object Vw32_system_coding_system;
-
/* A flag to control whether fonts are matched strictly or not. */
int w32_strict_fontnames;
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;
Lisp_Object Qw32_charset_unicode;
#endif
+Lisp_Object Qfullscreen;
+Lisp_Object Qfullwidth;
+Lisp_Object Qfullheight;
+Lisp_Object Qfullboth;
+
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
static int button_state = 0;
static W32Msg saved_mouse_button_msg;
-static unsigned mouse_button_timer; /* non-zero when timer is active */
+static unsigned mouse_button_timer = 0; /* non-zero when timer is active */
static W32Msg saved_mouse_move_msg;
-static unsigned mouse_move_timer;
+static unsigned mouse_move_timer = 0;
+
+/* Window that is tracking the mouse. */
+static HWND track_mouse_window;
+
+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
#define MOUSE_MOVE_ID 2
+#define MENU_FREE_ID 3
+/* The delay (milliseconds) before a menu is freed after WM_EXITMENULOOP
+ is received. */
+#define MENU_FREE_DELAY 1000
+static unsigned menu_free_timer = 0;
/* The below are defined in frame.c. */
extern Lisp_Object Vw32_num_mouse_buttons;
extern Lisp_Object Vw32_recognize_altgr;
+extern HWND w32_system_caret_hwnd;
+
+extern int w32_system_caret_height;
+extern int w32_system_caret_x;
+extern int w32_system_caret_y;
+extern int w32_use_visible_system_caret;
+
+static HWND w32_visible_system_caret_hwnd;
+
\f
/* Error if we are not connected to MS-Windows. */
void
/* Nonzero if we can use mouse menus.
You should not call this unless HAVE_MENUS is defined. */
-
+
int
have_menus_p ()
{
if (NILP (frame))
frame = selected_frame;
- CHECK_LIVE_FRAME (frame, 0);
+ CHECK_LIVE_FRAME (frame);
f = XFRAME (frame);
if (! FRAME_W32_P (f))
error ("non-w32 frame used");
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
{
FRAME_PTR f;
- CHECK_LIVE_FRAME (frame, 0);
+ CHECK_LIVE_FRAME (frame);
f = XFRAME (frame);
if (! FRAME_W32_P (f))
error ("non-w32 frame used");
if (f->output_data.w32->hourglass_window == wdesc)
return f;
- /* TODO: Check tooltips when supported. */
if (FRAME_W32_WINDOW (f) == wdesc)
return f;
}
{
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, "", &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 */
void (*setter) P_ ((struct frame *, Lisp_Object, Lisp_Object));
};
+BOOL my_show_window P_ ((struct frame *, HWND, int));
+void my_set_window_pos P_ ((HWND, HWND, int, int, int, int, UINT));
static Lisp_Object unwind_create_frame P_ ((Lisp_Object));
static Lisp_Object unwind_create_tip_frame P_ ((Lisp_Object));
static void x_change_window_heights P_ ((Lisp_Object, int));
/* TODO: Native Input Method support; see x_create_im. */
void x_set_foreground_color P_ ((struct frame *, Lisp_Object, Lisp_Object));
static void x_set_line_spacing P_ ((struct frame *, Lisp_Object, Lisp_Object));
+static void x_set_fullscreen P_ ((struct frame *, Lisp_Object, Lisp_Object));
void x_set_background_color P_ ((struct frame *, Lisp_Object, Lisp_Object));
void x_set_mouse_color P_ ((struct frame *, Lisp_Object, Lisp_Object));
void x_set_cursor_color P_ ((struct frame *, Lisp_Object, Lisp_Object));
void x_set_icon_type P_ ((struct frame *, Lisp_Object, Lisp_Object));
void x_set_icon_name P_ ((struct frame *, Lisp_Object, Lisp_Object));
void x_set_font P_ ((struct frame *, Lisp_Object, Lisp_Object));
+static void x_set_fringe_width P_ ((struct frame *, Lisp_Object, Lisp_Object));
void x_set_border_width P_ ((struct frame *, Lisp_Object, Lisp_Object));
void x_set_internal_border_width P_ ((struct frame *, Lisp_Object,
Lisp_Object));
void x_set_unsplittable P_ ((struct frame *, Lisp_Object, Lisp_Object));
void x_set_tool_bar_lines P_ ((struct frame *, Lisp_Object, Lisp_Object));
static void x_set_screen_gamma P_ ((struct frame *, Lisp_Object, Lisp_Object));
+static void x_edge_detection P_ ((struct frame *, struct image *, Lisp_Object,
+ Lisp_Object));
static struct x_frame_parm_table x_frame_parms[] =
{
- "auto-raise", x_set_autoraise,
- "auto-lower", x_set_autolower,
- "background-color", x_set_background_color,
- "border-color", x_set_border_color,
- "border-width", x_set_border_width,
- "cursor-color", x_set_cursor_color,
- "cursor-type", x_set_cursor_type,
- "font", x_set_font,
- "foreground-color", x_set_foreground_color,
- "icon-name", x_set_icon_name,
- "icon-type", x_set_icon_type,
- "internal-border-width", x_set_internal_border_width,
- "menu-bar-lines", x_set_menu_bar_lines,
- "mouse-color", x_set_mouse_color,
- "name", x_explicitly_set_name,
- "scroll-bar-width", x_set_scroll_bar_width,
- "title", x_set_title,
- "unsplittable", x_set_unsplittable,
- "vertical-scroll-bars", x_set_vertical_scroll_bars,
- "visibility", x_set_visibility,
- "tool-bar-lines", x_set_tool_bar_lines,
- "screen-gamma", x_set_screen_gamma,
- "line-spacing", x_set_line_spacing
+ {"auto-raise", x_set_autoraise},
+ {"auto-lower", x_set_autolower},
+ {"background-color", x_set_background_color},
+ {"border-color", x_set_border_color},
+ {"border-width", x_set_border_width},
+ {"cursor-color", x_set_cursor_color},
+ {"cursor-type", x_set_cursor_type},
+ {"font", x_set_font},
+ {"foreground-color", x_set_foreground_color},
+ {"icon-name", x_set_icon_name},
+ {"icon-type", x_set_icon_type},
+ {"internal-border-width", x_set_internal_border_width},
+ {"menu-bar-lines", x_set_menu_bar_lines},
+ {"mouse-color", x_set_mouse_color},
+ {"name", x_explicitly_set_name},
+ {"scroll-bar-width", x_set_scroll_bar_width},
+ {"title", x_set_title},
+ {"unsplittable", x_set_unsplittable},
+ {"vertical-scroll-bars", x_set_vertical_scroll_bars},
+ {"visibility", x_set_visibility},
+ {"tool-bar-lines", x_set_tool_bar_lines},
+ {"screen-gamma", x_set_screen_gamma},
+ {"line-spacing", x_set_line_spacing},
+ {"left-fringe", x_set_fringe_width},
+ {"right-fringe", x_set_fringe_width},
+ {"fullscreen", x_set_fullscreen},
};
/* Attach the `x-frame-parameter' properties to
make_number (i));
}
\f
+/* Really try to move where we want to be in case of fullscreen. Some WMs
+ moves the window where we tell them. Some (mwm, twm) moves the outer
+ window manager window there instead.
+ Try to compensate for those WM here. */
+static void
+x_fullscreen_move (f, new_top, new_left)
+ struct frame *f;
+ int new_top;
+ int new_left;
+{
+ if (new_top != f->output_data.w32->top_pos
+ || new_left != f->output_data.w32->left_pos)
+ {
+ int move_x = new_left;
+ int move_y = new_top;
+
+ f->output_data.w32->want_fullscreen |= FULLSCREEN_MOVE_WAIT;
+ x_set_offset (f, move_x, move_y, 1);
+ }
+}
+
/* Change the parameters of frame F as specified by ALIST.
If a parameter is not specially recognized, do nothing;
otherwise call the `x_set_...' function for that parameter. */
int i, p;
int left_no_change = 0, top_no_change = 0;
int icon_left_no_change = 0, icon_top_no_change = 0;
+ int fullscreen_is_being_set = 0;
struct gcpro gcpro1, gcpro2;
/* Process foreground_color and background_color before anything else.
They are independent of other properties, but other properties (e.g.,
cursor_color) are dependent upon them. */
- for (p = 0; p < i; p++)
+ /* Process default font as well, since fringe widths depends on it. */
+ for (p = 0; p < i; p++)
{
Lisp_Object prop, val;
prop = parms[p];
val = values[p];
- if (EQ (prop, Qforeground_color) || EQ (prop, Qbackground_color))
+ if (EQ (prop, Qforeground_color)
+ || EQ (prop, Qbackground_color)
+ || EQ (prop, Qfont)
+ || EQ (prop, Qfullscreen))
{
register Lisp_Object param_index, old_value;
- param_index = Fget (prop, Qx_frame_parameter);
old_value = get_frame_param (f, prop);
- store_frame_param (f, prop, val);
- if (NATNUMP (param_index)
- && (XFASTINT (param_index)
- < sizeof (x_frame_parms)/sizeof (x_frame_parms[0])))
- (*x_frame_parms[XINT (param_index)].setter)(f, val, old_value);
+ fullscreen_is_being_set |= EQ (prop, Qfullscreen);
+
+ 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)
+ < sizeof (x_frame_parms)/sizeof (x_frame_parms[0])))
+ (*x_frame_parms[XINT (param_index)].setter)(f, val, old_value);
+ }
}
}
icon_top = val;
else if (EQ (prop, Qicon_left))
icon_left = val;
- else if (EQ (prop, Qforeground_color) || EQ (prop, Qbackground_color))
+ else if (EQ (prop, Qforeground_color)
+ || EQ (prop, Qbackground_color)
+ || EQ (prop, Qfont)
+ || EQ (prop, Qfullscreen))
/* Processed above. */
continue;
else
{
register Lisp_Object param_index, old_value;
- param_index = Fget (prop, Qx_frame_parameter);
old_value = get_frame_param (f, prop);
+
store_frame_param (f, prop, val);
+
+ param_index = Fget (prop, Qx_frame_parameter);
if (NATNUMP (param_index)
&& (XFASTINT (param_index)
< sizeof (x_frame_parms)/sizeof (x_frame_parms[0])))
XSETINT (icon_top, 0);
}
+ if (FRAME_VISIBLE_P (f) && fullscreen_is_being_set)
+ {
+ /* If the frame is visible already and the fullscreen parameter is
+ being set, it is too late to set WM manager hints to specify
+ size and position.
+ Here we first get the width, height and position that applies to
+ fullscreen. We then move the frame to the appropriate
+ 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);
+ }
+
/* Don't set these parameters unless they've been explicitly
specified. The window might be mapped or resized while we're in
this function, and we don't want to override that unless the lisp
int *xptr, *yptr;
{
POINT pt;
+ RECT rect;
- {
- RECT rect;
-
- GetClientRect(FRAME_W32_WINDOW(f), &rect);
- AdjustWindowRect(&rect, f->output_data.w32->dwStyle, FRAME_EXTERNAL_MENU_BAR(f));
-
- pt.x = rect.left;
- pt.y = rect.top;
- }
+ GetClientRect(FRAME_W32_WINDOW(f), &rect);
+ AdjustWindowRect(&rect, f->output_data.w32->dwStyle, FRAME_EXTERNAL_MENU_BAR(f));
+
+ pt.x = rect.left;
+ pt.y = rect.top;
ClientToScreen (FRAME_W32_WINDOW(f), &pt);
+ /* Remember x_pixels_diff and y_pixels_diff. */
+ f->output_data.w32->x_pixels_diff = pt.x - rect.left;
+ f->output_data.w32->y_pixels_diff = pt.y - rect.top;
+
*xptr = pt.x;
*yptr = pt.y;
}
make_number (f->output_data.w32->border_width));
store_in_alist (alistptr, Qinternal_border_width,
make_number (f->output_data.w32->internal_border_width));
+ store_in_alist (alistptr, Qleft_fringe,
+ make_number (f->output_data.w32->left_fringe_width));
+ store_in_alist (alistptr, Qright_fringe,
+ make_number (f->output_data.w32->right_fringe_width));
+ store_in_alist (alistptr, Qscroll_bar_width,
+ make_number (FRAME_HAS_VERTICAL_SCROLL_BARS (f)
+ ? FRAME_SCROLL_BAR_PIXEL_WIDTH(f)
+ : 0));
sprintf (buf, "%ld", (long) FRAME_W32_WINDOW (f));
store_in_alist (alistptr, Qwindow_id,
build_string (buf));
}
\f
-DEFUN ("w32-define-rgb-color", Fw32_define_rgb_color, Sw32_define_rgb_color, 4, 4, 0,
- "Convert RGB numbers to a windows color reference and associate with NAME (a string).\n\
-This adds or updates a named color to w32-color-map, making it available for use.\n\
-The original entry's RGB ref is returned, or nil if the entry is new.")
+DEFUN ("w32-define-rgb-color", Fw32_define_rgb_color,
+ Sw32_define_rgb_color, 4, 4, 0,
+ doc: /* Convert RGB numbers to a windows color reference and associate with NAME.
+This adds or updates a named color to w32-color-map, making it
+available for use. The original entry's RGB ref is returned, or nil
+if the entry is new. */)
(red, green, blue, name)
Lisp_Object red, green, blue, name;
{
Lisp_Object oldrgb = Qnil;
Lisp_Object entry;
- CHECK_NUMBER (red, 0);
- CHECK_NUMBER (green, 0);
- CHECK_NUMBER (blue, 0);
- CHECK_STRING (name, 0);
+ CHECK_NUMBER (red);
+ CHECK_NUMBER (green);
+ CHECK_NUMBER (blue);
+ CHECK_STRING (name);
XSET (rgb, Lisp_Int, RGB(XUINT (red), XUINT (green), XUINT (blue)));
return (oldrgb);
}
-DEFUN ("w32-load-color-file", Fw32_load_color_file, Sw32_load_color_file, 1, 1, 0,
- "Create an alist of color entries from an external file (ie. rgb.txt).\n\
-Assign this value to w32-color-map to replace the existing color map.\n\
-\
-The file should define one named RGB color per line like so:\
- R G B name\n\
-where R,G,B are numbers between 0 and 255 and name is an arbitrary string.")
+DEFUN ("w32-load-color-file", Fw32_load_color_file,
+ Sw32_load_color_file, 1, 1, 0,
+ doc: /* Create an alist of color entries from an external file.
+Assign this value to w32-color-map to replace the existing color map.
+
+The file should define one named RGB color per line like so:
+ R G B name
+where R,G,B are numbers between 0 and 255 and name is an arbitrary string. */)
(filename)
Lisp_Object filename;
{
Lisp_Object cmap = Qnil;
Lisp_Object abspath;
- CHECK_STRING (filename, 0);
+ 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)},
};
DEFUN ("w32-default-color-map", Fw32_default_color_map, Sw32_default_color_map,
- 0, 0, 0, "Return the default color map.")
+ 0, 0, 0, doc: /* Return the default color map. */)
()
{
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, 0);
-
+
+ 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;
}
{
XColor cdef;
- CHECK_STRING (arg, 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. */
}
+/* Change the `fullscreen' frame parameter of frame F. OLD_VALUE is
+ the previous value of that parameter, NEW_VALUE is the new value. */
+
+static void
+x_set_fullscreen (f, new_value, old_value)
+ struct frame *f;
+ Lisp_Object new_value, old_value;
+{
+ if (NILP (new_value))
+ f->output_data.w32->want_fullscreen = FULLSCREEN_NONE;
+ else if (EQ (new_value, Qfullboth))
+ f->output_data.w32->want_fullscreen = FULLSCREEN_BOTH;
+ else if (EQ (new_value, Qfullwidth))
+ f->output_data.w32->want_fullscreen = FULLSCREEN_WIDTH;
+ else if (EQ (new_value, Qfullheight))
+ f->output_data.w32->want_fullscreen = FULLSCREEN_HEIGHT;
+}
+
+
/* Change the `screen-gamma' frame parameter of frame F. OLD_VALUE is
the previous value of that parameter, NEW_VALUE is the new value. */
struct frame *f;
Lisp_Object arg, oldval;
{
- FRAME_FOREGROUND_PIXEL (f)
- = x_decode_color (f, arg, BLACK_PIX_DEFAULT (f));
+ struct w32_output *x = f->output_data.w32;
+ PIX_TYPE fg, old_fg;
+
+ fg = x_decode_color (f, arg, BLACK_PIX_DEFAULT (f));
+ old_fg = FRAME_FOREGROUND_PIXEL (f);
+ FRAME_FOREGROUND_PIXEL (f) = fg;
if (FRAME_W32_WINDOW (f) != 0)
{
+ if (x->cursor_pixel == old_fg)
+ x->cursor_pixel = fg;
+
update_face_from_frame_parameter (f, Qforeground_color, arg);
if (FRAME_VISIBLE_P (f))
redraw_frame (f);
if (!EQ (Qnil, Vx_pointer_shape))
{
- CHECK_NUMBER (Vx_pointer_shape, 0);
+ CHECK_NUMBER (Vx_pointer_shape);
cursor = XCreateFontCursor (FRAME_W32_DISPLAY (f), XINT (Vx_pointer_shape));
}
else
if (!EQ (Qnil, Vx_nontext_pointer_shape))
{
- CHECK_NUMBER (Vx_nontext_pointer_shape, 0);
+ CHECK_NUMBER (Vx_nontext_pointer_shape);
nontext_cursor = XCreateFontCursor (FRAME_W32_DISPLAY (f),
XINT (Vx_nontext_pointer_shape));
}
if (!EQ (Qnil, Vx_hourglass_pointer_shape))
{
- CHECK_NUMBER (Vx_hourglass_pointer_shape, 0);
+ CHECK_NUMBER (Vx_hourglass_pointer_shape);
hourglass_cursor = XCreateFontCursor (FRAME_W32_DISPLAY (f),
XINT (Vx_hourglass_pointer_shape));
}
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))
{
- CHECK_NUMBER (Vx_mode_pointer_shape, 0);
+ CHECK_NUMBER (Vx_mode_pointer_shape);
mode_cursor = XCreateFontCursor (FRAME_W32_DISPLAY (f),
XINT (Vx_mode_pointer_shape));
}
if (!EQ (Qnil, Vx_sensitive_text_pointer_shape))
{
- CHECK_NUMBER (Vx_sensitive_text_pointer_shape, 0);
+ CHECK_NUMBER (Vx_sensitive_text_pointer_shape);
cross_cursor
= XCreateFontCursor (FRAME_W32_DISPLAY (f),
XINT (Vx_sensitive_text_pointer_shape));
if (!NILP (Vx_window_horizontal_drag_shape))
{
- CHECK_NUMBER (Vx_window_horizontal_drag_shape, 0);
+ CHECK_NUMBER (Vx_window_horizontal_drag_shape);
horizontal_drag_cursor
= XCreateFontCursor (FRAME_X_DISPLAY (f),
XINT (Vx_window_horizontal_drag_shape));
else
horizontal_drag_cursor
= XCreateFontCursor (FRAME_X_DISPLAY (f), XC_sb_h_double_arrow);
+ /* TODO: hand_cursor */
/* Check and report errors with the above calls. */
x_check_errors (FRAME_W32_DISPLAY (f), "can't set cursor shape: %s");
&fore_color, &back_color);
XRecolorCursor (FRAME_W32_DISPLAY (f), hourglass_cursor,
&fore_color, &back_color);
+ /* TODO: hand_cursor */
}
if (FRAME_W32_WINDOW (f) != 0)
&& 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);
f->output_data.w32->cross_cursor = cross_cursor;
+ /* TODO: hand_cursor */
XFlush (FRAME_W32_DISPLAY (f));
UNBLOCK_INPUT;
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))
{
fore_pixel = FRAME_BACKGROUND_PIXEL (f);
}
- FRAME_FOREGROUND_PIXEL (f) = fore_pixel;
+ f->output_data.w32->cursor_foreground_pixel = fore_pixel;
f->output_data.w32->cursor_pixel = pixel;
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;
{
int pix;
- CHECK_STRING (arg, 0);
+ CHECK_STRING (arg);
pix = x_decode_color (f, arg, BLACK_PIX_DEFAULT (f));
x_set_border_pixel (f, pix);
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? */
- update_mode_lines++;
+ /* Make sure the cursor gets redrawn. */
+ cursor_type_changed = 1;
}
\f
void
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)
{
Lisp_Object result;
Lisp_Object fontset_name;
Lisp_Object frame;
+ int old_fontset = FRAME_FONTSET(f);
- CHECK_STRING (arg, 1);
+ CHECK_STRING (arg);
fontset_name = Fquery_fontset (arg, Qnil);
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))
{
- if (!NILP (Fequal (result, oldval)))
+ if (STRINGP (fontset_name))
+ {
+ /* Fontset names are built from ASCII font names, so the
+ names may be equal despite there was a change. */
+ if (old_fontset == FRAME_FONTSET (f))
+ return;
+ }
+ else if (!NILP (Fequal (result, oldval)))
return;
+
store_frame_param (f, Qfont, result);
recompute_basic_faces (f);
}
}
}
+static void
+x_set_fringe_width (f, new_value, old_value)
+ struct frame *f;
+ Lisp_Object new_value, old_value;
+{
+ x_compute_fringe_widths (f, 1);
+}
+
void
x_set_border_width (f, arg, oldval)
struct frame *f;
Lisp_Object arg, oldval;
{
- CHECK_NUMBER (arg, 0);
+ CHECK_NUMBER (arg);
if (XINT (arg) == f->output_data.w32->border_width)
return;
{
int old = f->output_data.w32->internal_border_width;
- CHECK_NUMBER (arg, 0);
+ CHECK_NUMBER (arg);
f->output_data.w32->internal_border_width = XINT (arg);
if (f->output_data.w32->internal_border_width < 0)
f->output_data.w32->internal_border_width = 0;
SET_FRAME_GARBAGED (f);
do_pending_window_change (0);
}
+ else
+ SET_FRAME_GARBAGED (f);
}
void
release_frame_dc (f, hdc);
}
UNBLOCK_INPUT;
+
+ if (WINDOWP (f->tool_bar_window))
+ clear_glyph_matrix (XWINDOW (f->tool_bar_window)->current_matrix);
}
}
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);
}
else
- CHECK_STRING (name, 0);
+ CHECK_STRING (name);
/* Don't change the name if it's already NAME. */
if (! NILP (Fstring_equal (name, f->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, '_');
}
}
extern char *x_get_string_resource ();
DEFUN ("x-get-resource", Fx_get_resource, Sx_get_resource, 2, 4, 0,
- "Return the value of ATTRIBUTE, of class CLASS, from the X defaults database.\n\
-This uses `INSTANCE.ATTRIBUTE' as the key and `Emacs.CLASS' as the\n\
-class, where INSTANCE is the name under which Emacs was invoked, or\n\
-the name specified by the `-name' or `-rn' command-line arguments.\n\
-\n\
-The optional arguments COMPONENT and SUBCLASS add to the key and the\n\
-class, respectively. You must specify both of them or neither.\n\
-If you specify them, the key is `INSTANCE.COMPONENT.ATTRIBUTE'\n\
-and the class is `Emacs.CLASS.SUBCLASS'.")
+ doc: /* Return the value of ATTRIBUTE, of class CLASS, from the X defaults database.
+This uses `INSTANCE.ATTRIBUTE' as the key and `Emacs.CLASS' as the
+class, where INSTANCE is the name under which Emacs was invoked, or
+the name specified by the `-name' or `-rn' command-line arguments.
+
+The optional arguments COMPONENT and SUBCLASS add to the key and the
+class, respectively. You must specify both of them or neither.
+If you specify them, the key is `INSTANCE.COMPONENT.ATTRIBUTE'
+and the class is `Emacs.CLASS.SUBCLASS'. */)
(attribute, class, component, subclass)
Lisp_Object attribute, class, component, subclass;
{
char *name_key;
char *class_key;
- CHECK_STRING (attribute, 0);
- CHECK_STRING (class, 0);
+ CHECK_STRING (attribute);
+ CHECK_STRING (class);
if (!NILP (component))
- CHECK_STRING (component, 1);
+ CHECK_STRING (component);
if (!NILP (subclass))
- CHECK_STRING (subclass, 2);
+ CHECK_STRING (subclass);
if (NILP (component) != NILP (subclass))
error ("x-get-resource: must specify both COMPONENT and SUBCLASS or neither");
/* 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,
+ value = x_get_string_resource (check_x_display_info (Qnil)->xrdb,
name_key, class_key);
if (value != (char *) 0)
/* 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);
- return x_get_string_resource (sf, name_key, class_key);
+ return x_get_string_resource (FRAME_X_DISPLAY_INFO (sf)->xrdb,
+ name_key, class_key);
}
/* Types we might convert a resource string into. */
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);
}
\f
DEFUN ("x-parse-geometry", Fx_parse_geometry, Sx_parse_geometry, 1, 1, 0,
- "Parse an X-style geometry string STRING.\n\
-Returns an alist of the form ((top . TOP), (left . LEFT) ... ).\n\
-The properties returned may include `top', `left', `height', and `width'.\n\
-The value of `left' or `top' may be an integer,\n\
-or a list (+ N) meaning N pixels relative to top/left corner,\n\
-or a list (- N) meaning -N pixels relative to bottom/right corner.")
+ doc: /* Parse an X-style geometry string STRING.
+Returns an alist of the form ((top . TOP), (left . LEFT) ... ).
+The properties returned may include `top', `left', `height', and `width'.
+The value of `left' or `top' may be an integer,
+or a list (+ N) meaning N pixels relative to top/left corner,
+or a list (- N) meaning -N pixels relative to bottom/right corner. */)
(string)
Lisp_Object string;
{
unsigned int width, height;
Lisp_Object result;
- CHECK_STRING (string, 0);
+ CHECK_STRING (string);
- geometry = XParseGeometry ((char *) XSTRING (string)->data,
+ geometry = XParseGeometry ((char *) SDATA (string),
&x, &y, &width, &height);
result = Qnil;
{
if (!EQ (tem0, Qunbound))
{
- CHECK_NUMBER (tem0, 0);
+ CHECK_NUMBER (tem0);
f->height = XINT (tem0);
}
if (!EQ (tem1, Qunbound))
{
- CHECK_NUMBER (tem1, 0);
+ CHECK_NUMBER (tem1);
SET_FRAME_WIDTH (f, XINT (tem1));
}
if (!NILP (tem2) && !EQ (tem2, Qunbound))
: FRAME_SCROLL_BAR_PIXEL_WIDTH (f) > 0
? FRAME_SCROLL_BAR_PIXEL_WIDTH (f)
: (FRAME_SCROLL_BAR_COLS (f) * FONT_WIDTH (f->output_data.w32->font)));
- f->output_data.w32->flags_areas_extra
- = FRAME_FLAGS_AREA_WIDTH (f);
+
+ x_compute_fringe_widths (f, 0);
+
f->output_data.w32->pixel_width = CHAR_TO_PIXEL_WIDTH (f, f->width);
f->output_data.w32->pixel_height = CHAR_TO_PIXEL_HEIGHT (f, f->height);
f->output_data.w32->top_pos = 0;
else
{
- CHECK_NUMBER (tem0, 0);
+ CHECK_NUMBER (tem0);
f->output_data.w32->top_pos = XINT (tem0);
if (f->output_data.w32->top_pos < 0)
window_prompting |= YNegative;
f->output_data.w32->left_pos = 0;
else
{
- CHECK_NUMBER (tem1, 0);
+ CHECK_NUMBER (tem1);
f->output_data.w32->left_pos = XINT (tem1);
if (f->output_data.w32->left_pos < 0)
window_prompting |= XNegative;
window_prompting |= PPosition;
}
+ if (f->output_data.w32->want_fullscreen != FULLSCREEN_NONE)
+ {
+ int left, top;
+ int width, height;
+
+ /* It takes both for some WM:s to place it where we want */
+ window_prompting = USPosition | PPosition;
+ x_fullscreen_adjust (f, &width, &height, &top, &left);
+ f->width = width;
+ f->height = height;
+ f->output_data.w32->pixel_width = CHAR_TO_PIXEL_WIDTH (f, f->width);
+ f->output_data.w32->pixel_height = CHAR_TO_PIXEL_HEIGHT (f, f->height);
+ f->output_data.w32->left_pos = left;
+ f->output_data.w32->top_pos = top;
+ }
+
return window_prompting;
}
\f
+Cursor
+w32_load_cursor (LPCTSTR name)
+{
+ /* Try first to load cursor from application resource. */
+ Cursor cursor = LoadImage ((HINSTANCE) GetModuleHandle(NULL),
+ name, IMAGE_CURSOR, 0, 0,
+ LR_DEFAULTCOLOR | LR_DEFAULTSIZE | LR_SHARED);
+ if (!cursor)
+ {
+ /* Then try to load a shared predefined cursor. */
+ cursor = LoadImage (NULL, name, IMAGE_CURSOR, 0, 0,
+ LR_DEFAULTCOLOR | LR_DEFAULTSIZE | LR_SHARED);
+ }
+ return cursor;
+}
extern LRESULT CALLBACK w32_wnd_proc ();
-BOOL
+BOOL
w32_init_class (hinst)
HINSTANCE hinst;
{
wc.cbWndExtra = WND_EXTRA_BYTES;
wc.hInstance = hinst;
wc.hIcon = LoadIcon (hinst, EMACS_CLASS);
- wc.hCursor = LoadCursor (NULL, IDC_ARROW);
+ wc.hCursor = w32_load_cursor (IDC_ARROW);
wc.hbrBackground = NULL; /* GetStockObject (WHITE_BRUSH); */
wc.lpszMenuName = NULL;
wc.lpszClassName = EMACS_CLASS;
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)
thread-safe. The next line is okay because the cons
cell is never made into garbage and is not relocated by
GC. */
- XCAR ((Lisp_Object) msg.lParam) = Qnil;
+ XSETCAR ((Lisp_Object) msg.lParam, Qnil);
if (!PostThreadMessage (dwMainThreadId, WM_EMACS_DONE, 0, 0))
abort ();
break;
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);
{
PAINTSTRUCT paintStruct;
RECT update_rect;
+ bzero (&update_rect, sizeof (update_rect));
f = x_window_to_frame (dpyinfo, hwnd);
if (f == 0)
/* MSDN Docs say not to call BeginPaint if GetUpdateRect
fails. Apparently this can happen under some
circumstances. */
- if (!w32_strict_painting || GetUpdateRect (hwnd, &update_rect, FALSE))
+ if (GetUpdateRect (hwnd, &update_rect, FALSE) || !w32_strict_painting)
{
enter_crit ();
BeginPaint (hwnd, &paintStruct);
- if (w32_strict_painting)
- /* The rectangles returned by GetUpdateRect and BeginPaint
- do not always match. GetUpdateRect seems to be the
- more reliable of the two. */
- wmsg.rect = update_rect;
- else
- wmsg.rect = paintStruct.rcPaint;
+ /* The rectangles returned by GetUpdateRect and BeginPaint
+ do not always match. Play it safe by assuming both areas
+ are invalid. */
+ UnionRect (&(wmsg.rect), &update_rect, &(paintStruct.rcPaint));
#if defined (W32_DEBUG_DISPLAY)
DebPrint (("WM_PAINT (frame %p): painting %d,%d-%d,%d\n",
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,
}
return 0;
+ case WM_XBUTTONDOWN:
+ case WM_XBUTTONUP:
+ if (w32_pass_extra_mouse_buttons_to_system)
+ goto dflt;
+ /* else fall through and process them. */
case WM_MBUTTONDOWN:
case WM_MBUTTONUP:
handle_plain_button:
BOOL up;
int button;
- if (parse_button (msg, &button, &up))
+ if (parse_button (msg, HIWORD (wParam), &button, &up))
{
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);
- return 0;
- case WM_VSCROLL:
+ /* Need to return true for XBUTTON messages, false for others,
+ to indicate that we processed the message. */
+ return (msg == WM_XBUTTONDOWN || msg == WM_XBUTTONUP);
+
case WM_MOUSEMOVE:
+ /* If the mouse has just moved into the frame, start tracking
+ it, so we will be notified when it leaves the frame. Mouse
+ tracking only works under W98 and NT4 and later. On earlier
+ versions, there is no way of telling when the mouse leaves the
+ frame, so we just have to put up with help-echo and mouse
+ highlighting remaining while the frame is not active. */
+ if (track_mouse_event_fn && !track_mouse_window)
+ {
+ TRACKMOUSEEVENT tme;
+ tme.cbSize = sizeof (tme);
+ tme.dwFlags = TME_LEAVE;
+ tme.hwndTrack = hwnd;
+
+ track_mouse_event_fn (&tme);
+ track_mouse_window = hwnd;
+ }
+ case WM_VSCROLL:
if (XINT (Vw32_mouse_move_interval) <= 0
|| (msg == WM_MOUSEMOVE && button_state == 0))
{
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:
KillTimer (hwnd, mouse_move_timer);
mouse_move_timer = 0;
}
+ else if (wParam == menu_free_timer)
+ {
+ KillTimer (hwnd, menu_free_timer);
+ menu_free_timer = 0;
+ f = x_window_to_frame (dpyinfo, hwnd);
+ if (!f->output_data.w32->menu_command_in_progress)
+ {
+ /* Free memory used by owner-drawn and help-echo strings. */
+ w32_free_menu_strings (hwnd);
+ f->output_data.w32->menubar_active = 0;
+ }
+ }
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.
case WM_EXITMENULOOP:
f = x_window_to_frame (dpyinfo, hwnd);
- /* Indicate that menubar can be modified again. */
- if (f)
- f->output_data.w32->menubar_active = 0;
+ /* If a menu command is not already in progress, check again
+ after a short delay, since Windows often (always?) sends the
+ WM_EXITMENULOOP before the corresponding WM_COMMAND message. */
+ if (f && !f->output_data.w32->menu_command_in_progress)
+ menu_free_timer = SetTimer (hwnd, MENU_FREE_ID, MENU_FREE_DELAY, NULL);
goto dflt;
case WM_MENUSELECT:
- wmsg.dwModifiers = w32_get_modifiers ();
- my_post_msg (&wmsg, hwnd, msg, wParam, lParam);
+ /* Direct handling of help_echo in menus. Should be safe now
+ that we generate the help_echo by placing a help event in the
+ keyboard buffer. */
+ {
+ HMENU menu = (HMENU) lParam;
+ UINT menu_item = (UINT) LOWORD (wParam);
+ UINT flags = (UINT) HIWORD (wParam);
+
+ w32_menu_display_help (hwnd, menu, menu_item, flags);
+ }
return 0;
case WM_MEASUREITEM:
goto dflt;
#endif
+ case WM_MOUSELEAVE:
+ /* No longer tracking mouse. */
+ track_mouse_window = NULL;
+
case WM_ACTIVATEAPP:
case WM_ACTIVATE:
case WM_WINDOWPOSCHANGED:
unregister_hot_keys (hwnd);
button_state = 0;
ReleaseCapture ();
+ /* Relinquish the system caret. */
+ if (w32_system_caret_hwnd)
+ {
+ w32_visible_system_caret_hwnd = NULL;
+ w32_system_caret_hwnd = NULL;
+ DestroyCaret ();
+ }
+ goto command;
+ case WM_COMMAND:
+ f = x_window_to_frame (dpyinfo, hwnd);
+ if (f && HIWORD (wParam) == 0)
+ {
+ f->output_data.w32->menu_command_in_progress = 1;
+ if (menu_free_timer)
+ {
+ KillTimer (hwnd, menu_free_timer);
+ menu_free_timer = 0;
+ }
+ }
case WM_MOVE:
case WM_SIZE:
- case WM_COMMAND:
command:
wmsg.dwModifiers = w32_get_modifiers ();
my_post_msg (&wmsg, hwnd, msg, wParam, lParam);
return 0;
case WM_WINDOWPOSCHANGING:
+ /* Don't restrict the sizing of tip frames. */
+ if (hwnd == tip_window)
+ return 0;
{
WINDOWPLACEMENT wp;
LPWINDOWPOS lppos = (WINDOWPOS *) lParam;
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:
((LPMINMAXINFO) lParam)->ptMaxTrackSize.y = 32767;
return 0;
+ case WM_SETCURSOR:
+ if (LOWORD (lParam) == HTCLIENT)
+ return 0;
+
+ goto dflt;
+
+ case WM_EMACS_SETCURSOR:
+ {
+ Cursor cursor = (Cursor) wParam;
+ if (cursor)
+ SetCursor (cursor);
+ return 0;
+ }
+
case WM_EMACS_CREATESCROLLBAR:
return (LRESULT) w32_createscrollbar ((struct frame *) wParam,
(struct scroll_bar *) lParam);
DragAcceptFiles ((HWND) wParam, FALSE);
return DestroyWindow ((HWND) wParam);
+ case WM_EMACS_HIDE_CARET:
+ return HideCaret (hwnd);
+
+ case WM_EMACS_SHOW_CARET:
+ return ShowCaret (hwnd);
+
+ case WM_EMACS_DESTROY_CARET:
+ w32_system_caret_hwnd = NULL;
+ w32_visible_system_caret_hwnd = NULL;
+ return DestroyCaret ();
+
+ case WM_EMACS_TRACK_CARET:
+ /* If there is currently no system caret, create one. */
+ if (w32_system_caret_hwnd == NULL)
+ {
+ /* Use the default caret width, and avoid changing it
+ unneccesarily, as it confuses screen reader software. */
+ w32_system_caret_hwnd = hwnd;
+ 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. */
+ else if (w32_use_visible_system_caret
+ && w32_visible_system_caret_hwnd != hwnd)
+ {
+ w32_visible_system_caret_hwnd = hwnd;
+ return ShowCaret (hwnd);
+ }
+ /* Ensure visible caret gets turned off when requested. */
+ else if (!w32_use_visible_system_caret
+ && w32_visible_system_caret_hwnd)
+ {
+ w32_visible_system_caret_hwnd = NULL;
+ return HideCaret (hwnd);
+ }
+ else
+ return 1;
+
case WM_EMACS_TRACKPOPUPMENU:
{
UINT flags;
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;
{
GetMessage (&msg, NULL, WM_EMACS_DONE, WM_EMACS_DONE);
}
+
+/* Create a tooltip window. Unlike my_create_window, we do not do this
+ 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
+my_create_tip_window (f)
+ struct frame *f;
+{
+ RECT rect;
+
+ 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));
+
+ tip_window = FRAME_W32_WINDOW (f)
+ = CreateWindow (EMACS_CLASS,
+ f->namebuf,
+ f->output_data.w32->dwStyle,
+ f->output_data.w32->left_pos,
+ f->output_data.w32->top_pos,
+ rect.right - rect.left,
+ rect.bottom - rect.top,
+ FRAME_W32_WINDOW (SELECTED_FRAME ()), /* owner */
+ NULL,
+ hinst,
+ NULL);
+
+ if (tip_window)
+ {
+ SetWindowLong (tip_window, WND_FONTWIDTH_INDEX, FONT_WIDTH (f->output_data.w32->font));
+ SetWindowLong (tip_window, WND_LINEHEIGHT_INDEX, f->output_data.w32->line_height);
+ SetWindowLong (tip_window, WND_BORDER_INDEX, f->output_data.w32->internal_border_width);
+ SetWindowLong (tip_window, WND_BACKGROUND_INDEX, FRAME_BACKGROUND_PIXEL (f));
+
+ /* Tip frames have no scrollbars. */
+ SetWindowLong (tip_window, WND_SCROLLBAR_INDEX, 0);
+
+ /* Do this to discard the default setting specified by our parent. */
+ ShowWindow (tip_window, SW_HIDE);
+ }
+}
+
+
/* Create and set up the w32 window for frame F. */
static void
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);
}
icon_y = w32_get_arg (parms, Qicon_top, 0, 0, RES_TYPE_NUMBER);
if (!EQ (icon_x, Qunbound) && !EQ (icon_y, Qunbound))
{
- CHECK_NUMBER (icon_x, 0);
- CHECK_NUMBER (icon_y, 0);
+ CHECK_NUMBER (icon_x);
+ CHECK_NUMBER (icon_y);
}
else if (!EQ (icon_x, Qunbound) || !EQ (icon_y, Qunbound))
error ("Both left and top icon corners of icon must be specified");
? 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;
}
DEFUN ("x-create-frame", Fx_create_frame, Sx_create_frame,
1, 1, 0,
- "Make a new window, which is called a \"frame\" in Emacs terms.\n\
-Returns an Emacs frame object.\n\
-ALIST is an alist of frame parameters.\n\
-If the parameters specify that the frame should not have a minibuffer,\n\
-and do not specify a specific minibuffer window to use,\n\
-then `default-minibuffer-frame' must be a frame whose minibuffer can\n\
-be shared by the new frame.\n\
-\n\
-This function is an internal primitive--use `make-frame' instead.")
+ doc: /* Make a new window, which is called a \"frame\" in Emacs terms.
+Returns an Emacs frame object.
+ALIST is an alist of frame parameters.
+If the parameters specify that the frame should not have a minibuffer,
+and do not specify a specific minibuffer window to use,
+then `default-minibuffer-frame' must be a frame whose minibuffer can
+be shared by the new frame.
+
+This function is an internal primitive--use `make-frame' instead. */)
(parms)
Lisp_Object parms;
{
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;
if (EQ (parent, Qunbound))
parent = Qnil;
if (! NILP (parent))
- CHECK_NUMBER (parent, 0);
+ CHECK_NUMBER (parent);
/* make_frame_without_minibuffer can run Lisp code and garbage collect. */
/* No need to protect DISPLAY because that's not used after passing
{
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);
}
"screenGamma", "ScreenGamma", RES_TYPE_FLOAT);
x_default_parameter (f, parms, Qline_spacing, Qnil,
"lineSpacing", "LineSpacing", RES_TYPE_NUMBER);
+ x_default_parameter (f, parms, Qleft_fringe, Qnil,
+ "leftFringe", "LeftFringe", RES_TYPE_NUMBER);
+ x_default_parameter (f, parms, Qright_fringe, Qnil,
+ "rightFringe", "RightFringe", RES_TYPE_NUMBER);
/* Init faces before x_default_parameter is called for scroll-bar
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,
"title", "Title", RES_TYPE_STRING);
+ x_default_parameter (f, parms, Qfullscreen, Qnil,
+ "fullscreen", "Fullscreen", RES_TYPE_SYMBOL);
f->output_data.w32->dwStyle = WS_OVERLAPPEDWINDOW;
f->output_data.w32->parent_desc = FRAME_W32_DISPLAY_INFO (f)->root_window;
- window_prompting = x_figure_window_size (f, parms);
- if (window_prompting & XNegative)
+ f->output_data.w32->text_cursor = w32_load_cursor (IDC_IBEAM);
+ f->output_data.w32->nontext_cursor = w32_load_cursor (IDC_ARROW);
+ f->output_data.w32->modeline_cursor = w32_load_cursor (IDC_ARROW);
+ f->output_data.w32->cross_cursor = w32_load_cursor (IDC_CROSS);
+ f->output_data.w32->hourglass_cursor = w32_load_cursor (IDC_WAIT);
+ f->output_data.w32->horizontal_drag_cursor = w32_load_cursor (IDC_SIZEWE);
+ f->output_data.w32->hand_cursor = w32_load_cursor (IDC_HAND);
+
+ /* Add the tool-bar height to the initial frame height so that the
+ user gets a text display area of the size he specified with -g or
+ via .Xdefaults. Later changes of the tool-bar height don't
+ change the frame size. This is done so that users can create
+ tall Emacs frames without having to guess how tall the tool-bar
+ will get. */
+ 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);
+
+ if (INTEGERP (Vtool_bar_button_margin)
+ && XINT (Vtool_bar_button_margin) > 0)
+ margin = XFASTINT (Vtool_bar_button_margin);
+ else if (CONSP (Vtool_bar_button_margin)
+ && INTEGERP (XCDR (Vtool_bar_button_margin))
+ && XINT (XCDR (Vtool_bar_button_margin)) > 0)
+ 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);
+ }
+
+ window_prompting = x_figure_window_size (f, parms);
+
+ if (window_prompting & XNegative)
{
if (window_prompting & YNegative)
f->output_data.w32->win_gravity = SouthEastGravity;
width = f->width;
height = f->height;
- /* Add the tool-bar height to the initial frame height so that the
- user gets a text display area of the size he specified with -g or
- via .Xdefaults. Later changes of the tool-bar height don't
- change the frame size. This is done so that users can create
- tall Emacs frames without having to guess how tall the tool-bar
- will get. */
- 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);
-
- if (INTEGERP (Vtool_bar_button_margin)
- && XINT (Vtool_bar_button_margin) > 0)
- margin = XFASTINT (Vtool_bar_button_margin);
- else if (CONSP (Vtool_bar_button_margin)
- && INTEGERP (XCDR (Vtool_bar_button_margin))
- && XINT (XCDR (Vtool_bar_button_margin)) > 0)
- margin = XFASTINT (XCDR (Vtool_bar_button_margin));
- else
- margin = 0;
-
- bar_height = DEFAULT_TOOL_BAR_IMAGE_HEIGHT + 2 * margin + 2 * relief;
- height += (bar_height + CANON_Y_UNIT (f) - 1) / CANON_Y_UNIT (f);
- }
-
f->height = 0;
SET_FRAME_WIDTH (f, 0);
change_frame_size (f, height, width, 1, 0, 0);
x_wm_set_size_hint (f, window_prompting, 0);
UNBLOCK_INPUT;
+ /* Avoid a bug that causes the new frame to never become visible if
+ an echo area message is displayed during the following call1. */
+ specbind(Qredisplay_dont_pause, Qt);
+
/* Set up faces after all frame parameters are known. This call
also merges in face attributes specified for new frames. If we
don't do this, the `menu' face for instance won't have the right
;
}
UNGCPRO;
-
+
/* Make sure windows on this frame appear in calls to next-window
and similar functions. */
Vwindow_list = Qnil;
-
+
return unbind_to (count, frame);
}
}
DEFUN ("w32-focus-frame", Fw32_focus_frame, Sw32_focus_frame, 1, 1, 0,
- "Give FRAME input focus, raising to foreground if necessary.")
+ doc: /* Give FRAME input focus, raising to foreground if necessary. */)
(frame)
Lisp_Object 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)
{
struct font_info *fontp;
LOGFONT lf;
BOOL ok;
+ int codepage;
int i;
if (!fontname || !x_to_w32_font (fontname, &lf))
ended up with. */
return NULL;
+ 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;
- int codepage = w32_codepage_for_font (fontname);
+
+ codepage = w32_codepage_for_font (fontname);
hdc = GetDC (dpyinfo->root_window);
oldobj = SelectObject (hdc, font->hfont);
charset = xlfd_charset_of_font (fontname);
+ /* Cache the W32 codepage for a font. This makes w32_encode_char
+ (called for every glyph during redisplay) much faster. */
+ fontp->codepage = codepage;
+
/* Work out the font's full name. */
full_name = (char *)xmalloc (100);
if (full_name && w32_to_x_font (&lf, full_name, 100, charset))
/* SJIS fonts need to be set to type 4, all others seem to work as
type FONT_ENCODING_NOT_DECIDED. */
encoding = strrchr (fontp->name, '-');
- if (encoding && stricmp (encoding+1, "sjis") == 0)
+ if (encoding && strnicmp (encoding+1, "sjis", 4) == 0)
fontp->encoding[1] = 4;
else
fontp->encoding[1] = FONT_ENCODING_NOT_DECIDED;
/* Set global flag fonts_changed_p to non-zero if the font loaded
has a character with a smaller width than any other character
- before, or if the font loaded has a smalle>r height than any
+ before, or if the font loaded has a smaller height than any
other font loaded before. If this happens, it will make a
glyph matrix reallocation necessary. */
- fonts_changed_p = x_compute_min_glyph_bounds (f);
+ fonts_changed_p |= x_compute_min_glyph_bounds (f);
UNBLOCK_INPUT;
return fontp;
}
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;
{
w32_charset = Fcar (Fcdr (this_entry));
- // Translate Lisp symbol to number.
+ /* Translate Lisp symbol to number. */
if (w32_charset == Qw32_charset_ansi)
return ANSI_CHARSET;
if (w32_charset == Qw32_charset_symbol)
w32_to_x_charset (fncharset)
int fncharset;
{
- static char buf[16];
+ static char buf[32];
Lisp_Object charset_type;
switch (fncharset)
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));
best_match = x_charset;
/* If this is an ISO codepage, and the best so far isn't,
then this is better. */
- else if (stricmp (best_match, "iso") != 0
- && stricmp (x_charset, "iso") == 0)
+ else if (strnicmp (best_match, "iso", 3) != 0
+ && strnicmp (x_charset, "iso", 3) == 0)
best_match = x_charset;
/* If both are ISO8859 codepages, choose the one with the
lowest number in the encoding field. */
- else if (stricmp (best_match, "iso8859-") == 0
- && stricmp (x_charset, "iso8859-") == 0)
+ else if (strnicmp (best_match, "iso8859-", 8) == 0
+ && strnicmp (x_charset, "iso8859-", 8) == 0)
{
int best_enc = atoi (best_match + 8);
int this_enc = atoi (x_charset + 8);
if (this_enc > 0 && this_enc < best_enc)
best_match = x_charset;
- }
+ }
}
}
return buf;
}
- strncpy(buf, best_match, 15);
- buf[15] = '\0';
+ strncpy(buf, best_match, 31);
+ buf[31] = '\0';
return buf;
}
}
+/* Return all the X charsets that map to a font. */
+static Lisp_Object
+w32_to_all_x_charsets (fncharset)
+ int fncharset;
+{
+ static char buf[32];
+ Lisp_Object charset_type;
+ Lisp_Object retval = Qnil;
+
+ switch (fncharset)
+ {
+ case ANSI_CHARSET:
+ /* Handle startup case of w32-charset-info-alist not
+ being set up yet. */
+ if (NILP(Vw32_charset_info_alist))
+ return Fcons (build_string ("iso8859-1"), Qnil);
+
+ charset_type = Qw32_charset_ansi;
+ break;
+ case DEFAULT_CHARSET:
+ charset_type = Qw32_charset_default;
+ break;
+ case SYMBOL_CHARSET:
+ charset_type = Qw32_charset_symbol;
+ break;
+ case SHIFTJIS_CHARSET:
+ charset_type = Qw32_charset_shiftjis;
+ break;
+ case HANGEUL_CHARSET:
+ charset_type = Qw32_charset_hangeul;
+ break;
+ case GB2312_CHARSET:
+ charset_type = Qw32_charset_gb2312;
+ break;
+ case CHINESEBIG5_CHARSET:
+ charset_type = Qw32_charset_chinesebig5;
+ break;
+ case OEM_CHARSET:
+ charset_type = Qw32_charset_oem;
+ break;
+
+ /* More recent versions of Windows (95 and NT4.0) define more
+ character sets. */
+#ifdef EASTEUROPE_CHARSET
+ case EASTEUROPE_CHARSET:
+ charset_type = Qw32_charset_easteurope;
+ break;
+ case TURKISH_CHARSET:
+ charset_type = Qw32_charset_turkish;
+ break;
+ case BALTIC_CHARSET:
+ charset_type = Qw32_charset_baltic;
+ break;
+ case RUSSIAN_CHARSET:
+ charset_type = Qw32_charset_russian;
+ break;
+ case ARABIC_CHARSET:
+ charset_type = Qw32_charset_arabic;
+ break;
+ case GREEK_CHARSET:
+ charset_type = Qw32_charset_greek;
+ break;
+ case HEBREW_CHARSET:
+ charset_type = Qw32_charset_hebrew;
+ break;
+ case VIETNAMESE_CHARSET:
+ charset_type = Qw32_charset_vietnamese;
+ break;
+ case THAI_CHARSET:
+ charset_type = Qw32_charset_thai;
+ break;
+ case MAC_CHARSET:
+ charset_type = Qw32_charset_mac;
+ break;
+ case JOHAB_CHARSET:
+ charset_type = Qw32_charset_johab;
+ break;
+#endif
+
+#ifdef UNICODE_CHARSET
+ case UNICODE_CHARSET:
+ charset_type = Qw32_charset_unicode;
+ break;
+#endif
+ default:
+ /* Encode numerical value of unknown charset. */
+ sprintf (buf, "*-#%u", fncharset);
+ return Fcons (build_string (buf), Qnil);
+ }
+
+ {
+ Lisp_Object rest;
+ /* Look through w32-charset-info-alist for the character set.
+ Only return charsets for codepages which are installed.
+
+ Format of each entry in Vw32_charset_info_alist is
+ (CHARSET_NAME . (WINDOWS_CHARSET . CODEPAGE)).
+ */
+ for (rest = Vw32_charset_info_alist; CONSP (rest); rest = XCDR (rest))
+ {
+ Lisp_Object x_charset;
+ Lisp_Object w32_charset;
+ Lisp_Object codepage;
+
+ Lisp_Object this_entry = XCAR (rest);
+
+ /* Skip invalid entries in alist. */
+ if (!CONSP (this_entry) || !STRINGP (XCAR (this_entry))
+ || !CONSP (XCDR (this_entry))
+ || !SYMBOLP (XCAR (XCDR (this_entry))))
+ continue;
+
+ x_charset = XCAR (this_entry);
+ w32_charset = XCAR (XCDR (this_entry));
+ codepage = XCDR (XCDR (this_entry));
+
+ /* Look for Same charset and a valid codepage (or non-int
+ which means ignore). */
+ if (w32_charset == charset_type
+ && (!INTEGERP (codepage) || codepage == CP_DEFAULT
+ || IsValidCodePage (XINT (codepage))))
+ {
+ retval = Fcons (x_charset, retval);
+ }
+ }
+
+ /* If no match, encode the numeric value. */
+ if (NILP (retval))
+ {
+ sprintf (buf, "*-#%u", fncharset);
+ return Fcons (build_string (buf), Qnil);
+ }
+
+ return retval;
+ }
+}
+
/* 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;
char height_dpi[8];
char width_pixels[8];
char *fontname_dash;
- int display_resy = one_w32_display_info.resy;
- int display_resx = one_w32_display_info.resx;
+ int display_resy = (int) one_w32_display_info.resy;
+ int display_resx = (int) one_w32_display_info.resx;
int bufsz;
struct coding_system coding;
else
fonttype = "unknown";
- setup_coding_system (Fcheck_coding_system (Vw32_system_coding_system),
+ setup_coding_system (Fcheck_coding_system (Vlocale_coding_system),
&coding);
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;
char name[50], weight[20], slant, pitch, pixels[10], height[10],
width[10], resy[10], remainder[50];
char * encoding;
- int dpi = one_w32_display_info.resy;
+ int dpi = (int) one_w32_display_info.resy;
fields = sscanf (lpxstr,
"-%*[^-]-%49[^-]-%19[^-]-%c-%*[^-]-%*[^-]-%9[^-]-%9[^-]-%*[^-]-%9[^-]-%c-%9[^-]-%49s",
unsigned char *buf;
setup_coding_system
- (Fcheck_coding_system (Vw32_system_coding_system), &coding);
+ (Fcheck_coding_system (Vlocale_coding_system), &coding);
coding.src_multibyte = 1;
coding.dst_multibyte = 1;
bufsize = encoding_buffer_size (&coding, strlen (name));
}
/* 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 *tail;
+ Lisp_Object pattern;
+ Lisp_Object list;
} enumfont_t;
-static int CALLBACK
+
+static void
+enum_font_maybe_add_to_list (enumfont_t *, LOGFONT *, char *, Lisp_Object);
+
+
+static int CALLBACK
enum_font_cb2 (lplf, lptm, FontType, lpef)
ENUMLOGFONT * lplf;
NEWTEXTMETRIC * lptm;
int FontType;
enumfont_t * lpef;
{
+ /* Ignore struck out and underlined versions of fonts. */
if (lplf->elfLogFont.lfStrikeOut || lplf->elfLogFont.lfUnderline)
- return (1);
-
+ return 1;
+
+ /* Only return fonts with names starting with @ if they were
+ explicitly specified, since Microsoft uses an initial @ to
+ denote fonts for vertical writing, without providing a more
+ convenient way of identifying them. */
+ if (lplf->elfLogFont.lfFaceName[0] == '@'
+ && lpef->logfont.lfFaceName[0] != '@')
+ return 1;
+
/* Check that the character set matches if it was specified */
if (lpef->logfont.lfCharSet != DEFAULT_CHARSET &&
lplf->elfLogFont.lfCharSet != lpef->logfont.lfCharSet)
- return (1);
+ 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;
+ Lisp_Object charset_list = Qnil;
char *charset = NULL;
/* 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);
-
- /* Ensure that charset is valid for this font. */
- if (charset
- && (x_to_w32_charset (charset) != lplf->elfLogFont.lfCharSet))
- charset = NULL;
+ 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. */
+ if (charset
+ && strncmp (charset, "*-*", 3) != 0
+ && lpef->logfont.lfCharSet == DEFAULT_CHARSET
+ && strcmp (charset, w32_to_x_charset (DEFAULT_CHARSET)) != 0)
+ return 1;
}
- /* TODO: List all relevant charsets if charset not specified. */
- if (!w32_to_x_font (&(lplf->elfLogFont), buf, 100, charset))
- return (0);
+ if (charset)
+ charset_list = Fcons (build_string (charset), Qnil);
+ else
+ charset_list = w32_to_all_x_charsets (lplf->elfLogFont.lfCharSet);
- if (NILP (*(lpef->pattern))
- || w32_font_match (buf, XSTRING (*(lpef->pattern))->data))
+ /* Loop through the charsets. */
+ for ( ; CONSP (charset_list); charset_list = Fcdr (charset_list))
{
- *lpef->tail = Fcons (Fcons (build_string (buf), width), Qnil);
- lpef->tail = &(XCDR (*lpef->tail));
- lpef->numFonts++;
+ Lisp_Object this_charset = Fcar (charset_list);
+ 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_enable_synthesized_fonts
+ && lplf->elfLogFont.lfWeight == FW_NORMAL
+ && lplf->elfLogFont.lfItalic == FALSE)
+ {
+ enum_font_maybe_add_to_list (lpef, &(lplf->elfLogFont),
+ charset, width);
+ /* bold. */
+ lplf->elfLogFont.lfWeight = FW_BOLD;
+ enum_font_maybe_add_to_list (lpef, &(lplf->elfLogFont),
+ charset, width);
+ /* bold italic. */
+ lplf->elfLogFont.lfItalic = TRUE;
+ enum_font_maybe_add_to_list (lpef, &(lplf->elfLogFont),
+ charset, width);
+ /* italic. */
+ lplf->elfLogFont.lfWeight = FW_NORMAL;
+ enum_font_maybe_add_to_list (lpef, &(lplf->elfLogFont),
+ charset, width);
+ }
+ else
+ enum_font_maybe_add_to_list (lpef, &(lplf->elfLogFont),
+ charset, width);
}
}
- return (1);
+ return 1;
+}
+
+static void
+enum_font_maybe_add_to_list (lpef, logfont, match_charset, width)
+ enumfont_t * lpef;
+ LOGFONT * logfont;
+ char * match_charset;
+ Lisp_Object width;
+{
+ char buf[100];
+
+ if (!w32_to_x_font (logfont, buf, 100, match_charset))
+ return;
+
+ 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
+ bold and italic versions of the font. */
+ Lisp_Object font_name = build_string (buf);
+ if (NILP (Fmember (font_name, lpef->list)))
+ {
+ 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;
{
newlist = Fcons (XCAR (tem), newlist);
n_fonts++;
- if (n_fonts >= max_names)
+ if (max_names >= 0 && n_fonts >= max_names)
break;
}
}
return newlist;
}
-static Lisp_Object w32_list_synthesized_fonts (FRAME_PTR f,
- Lisp_Object pattern,
- int size, int max_names);
/* Return a list of names of available fonts matching PATTERN on frame
F. If SIZE is not 0, it is the size (maximum bound width) of fonts
to be listed. Frame F NULL means we have not yet created any
frame, which means we can't get proper size info, as we don't have
a device context to use for GetTextMetrics.
- MAXNAMES sets a limit on how many fonts to match. */
+ MAXNAMES sets a limit on how many fonts to match. If MAXNAMES is
+ negative, then all matching fonts are returned. */
Lisp_Object
w32_list_fonts (f, pattern, size, maxnames)
/* 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.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. */
- XCDR (dpyinfo->name_list_element)
- = Fcons (Fcons (tpat, list),
- XCDR (dpyinfo->name_list_element));
+ XSETCDR (dpyinfo->name_list_element,
+ Fcons (Fcons (tpat, list),
+ XCDR (dpyinfo->name_list_element)));
label_cached:
if (NILP (list)) continue; /* Try the remaining alternatives. */
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;
{
newlist = Fcons (XCAR (tem), newlist);
n_fonts++;
- if (n_fonts >= maxnames)
+ if (maxnames >= 0 && n_fonts >= maxnames)
break;
else
continue;
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;
hdc = GetDC (dpyinfo->root_window);
oldobj = SelectObject (hdc, thisinfo.hfont);
if (GetTextMetrics (hdc, &thisinfo.tm))
- XCDR (tem) = make_number (FONT_WIDTH (&thisinfo));
+ XSETCDR (tem, make_number (FONT_WIDTH (&thisinfo)));
else
- XCDR (tem) = make_number (0);
+ XSETCDR (tem, make_number (0));
SelectObject (hdc, oldobj);
ReleaseDC (dpyinfo->root_window, hdc);
DeleteObject(thisinfo.hfont);
{
newlist = Fcons (XCAR (tem), newlist);
n_fonts++;
- if (n_fonts >= maxnames)
+ if (maxnames >= 0 && n_fonts >= maxnames)
break;
}
/* keep track of the closest matching size in case
{
if (NILP (second_best))
second_best = tem;
-
+
else if (found_size < size)
{
if (XINT (XCDR (second_best)) > size
}
/* Include any bdf fonts. */
- if (n_fonts < maxnames)
+ if (n_fonts < maxnames || maxnames < 0)
{
Lisp_Object combined[2];
combined[0] = w32_list_bdf_fonts (pattern, maxnames - n_fonts);
newlist = Fnconc(2, combined);
}
- /* If we can't find a font that matches, check if Windows would be
- able to synthesize it from a different style. */
- if (NILP (newlist) && !NILP (Vw32_enable_synthesized_fonts))
- newlist = w32_list_synthesized_fonts (f, pattern, size, maxnames);
-
return newlist;
}
-static Lisp_Object
-w32_list_synthesized_fonts (f, pattern, size, max_names)
- FRAME_PTR f;
- Lisp_Object pattern;
- int size;
- int max_names;
-{
- int fields;
- char *full_pattn, *new_pattn, foundary[50], family[50], *pattn_part2;
- char style[20], slant;
- Lisp_Object matches, tem, synthed_matches = Qnil;
-
- full_pattn = XSTRING (pattern)->data;
-
- pattn_part2 = alloca (XSTRING (pattern)->size + 1);
- /* Allow some space for wildcard expansion. */
- new_pattn = alloca (XSTRING (pattern)->size + 100);
-
- fields = sscanf (full_pattn, "-%49[^-]-%49[^-]-%19[^-]-%c-%s",
- foundary, family, style, &slant, pattn_part2);
- if (fields == EOF || fields < 5)
- return Qnil;
-
- /* If the style and slant are wildcards already there is no point
- checking again (and we don't want to keep recursing). */
- if (*style == '*' && slant == '*')
- return Qnil;
-
- sprintf (new_pattn, "-%s-%s-*-*-%s", foundary, family, pattn_part2);
-
- matches = w32_list_fonts (f, build_string (new_pattn), size, max_names);
-
- for ( ; CONSP (matches); matches = XCDR (matches))
- {
- tem = XCAR (matches);
- if (!STRINGP (tem))
- continue;
-
- full_pattn = XSTRING (tem)->data;
- fields = sscanf (full_pattn, "-%49[^-]-%49[^-]-%*[^-]-%*c-%s",
- foundary, family, pattn_part2);
- if (fields == EOF || fields < 3)
- continue;
-
- sprintf (new_pattn, "-%s-%s-%s-%c-%s", foundary, family, style,
- slant, pattn_part2);
-
- synthed_matches = Fcons (build_string (new_pattn),
- synthed_matches);
- }
-
- return synthed_matches;
-}
-
/* Return a pointer to struct font_info of font FONT_IDX of frame F. */
struct font_info *
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;
DEFUN ("w32-find-bdf-fonts", Fw32_find_bdf_fonts, Sw32_find_bdf_fonts,
1, 1, 0,
- "Return a list of BDF fonts in DIR, suitable for appending to\n\
-w32-bdf-filename-alist. Fonts which do not contain an xlfd description\n\
-will not be included in the list. DIR may be a list of directories.")
+ doc: /* Return a list of BDF fonts in DIR.
+The list is suitable for appending to w32-bdf-filename-alist. Fonts
+which do not contain an xlfd description will not be included in the
+list. DIR may be a list of directories. */)
(directory)
Lisp_Object directory;
{
\f
DEFUN ("xw-color-defined-p", Fxw_color_defined_p, Sxw_color_defined_p, 1, 2, 0,
- "Internal function called by `color-defined-p', which see.")
+ doc: /* Internal function called by `color-defined-p', which see. */)
(color, frame)
Lisp_Object color, frame;
{
XColor foo;
FRAME_PTR f = check_x_frame (frame);
- CHECK_STRING (color, 1);
+ 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;
}
DEFUN ("xw-color-values", Fxw_color_values, Sxw_color_values, 1, 2, 0,
- "Internal function called by `color-values', which see.")
+ doc: /* Internal function called by `color-values', which see. */)
(color, frame)
Lisp_Object color, frame;
{
XColor foo;
FRAME_PTR f = check_x_frame (frame);
- CHECK_STRING (color, 1);
+ 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];
}
DEFUN ("xw-display-color-p", Fxw_display_color_p, Sxw_display_color_p, 0, 1, 0,
- "Internal function called by `display-color-p', which see.")
+ doc: /* Internal function called by `display-color-p', which see. */)
(display)
Lisp_Object display;
{
return Qt;
}
-DEFUN ("x-display-grayscale-p", Fx_display_grayscale_p, Sx_display_grayscale_p,
- 0, 1, 0,
- "Return t if the X display supports shades of gray.\n\
-Note that color displays do support shades of gray.\n\
-The optional argument DISPLAY specifies which display to ask about.\n\
-DISPLAY should be either a frame or a display name (a string).\n\
-If omitted or nil, that stands for the selected frame's display.")
+DEFUN ("x-display-grayscale-p", Fx_display_grayscale_p,
+ Sx_display_grayscale_p, 0, 1, 0,
+ doc: /* Return t if the X display supports shades of gray.
+Note that color displays do support shades of gray.
+The optional argument DISPLAY specifies which display to ask about.
+DISPLAY should be either a frame or a display name (a string).
+If omitted or nil, that stands for the selected frame's display. */)
(display)
Lisp_Object display;
{
return Qt;
}
-DEFUN ("x-display-pixel-width", Fx_display_pixel_width, Sx_display_pixel_width,
- 0, 1, 0,
- "Returns the width in pixels of the X display DISPLAY.\n\
-The optional argument DISPLAY specifies which display to ask about.\n\
-DISPLAY should be either a frame or a display name (a string).\n\
-If omitted or nil, that stands for the selected frame's display.")
+DEFUN ("x-display-pixel-width", Fx_display_pixel_width,
+ Sx_display_pixel_width, 0, 1, 0,
+ doc: /* Returns the width in pixels of DISPLAY.
+The optional argument DISPLAY specifies which display to ask about.
+DISPLAY should be either a frame or a display name (a string).
+If omitted or nil, that stands for the selected frame's display. */)
(display)
Lisp_Object display;
{
}
DEFUN ("x-display-pixel-height", Fx_display_pixel_height,
- Sx_display_pixel_height, 0, 1, 0,
- "Returns the height in pixels of the X display DISPLAY.\n\
-The optional argument DISPLAY specifies which display to ask about.\n\
-DISPLAY should be either a frame or a display name (a string).\n\
-If omitted or nil, that stands for the selected frame's display.")
+ Sx_display_pixel_height, 0, 1, 0,
+ doc: /* Returns the height in pixels of DISPLAY.
+The optional argument DISPLAY specifies which display to ask about.
+DISPLAY should be either a frame or a display name (a string).
+If omitted or nil, that stands for the selected frame's display. */)
(display)
Lisp_Object display;
{
}
DEFUN ("x-display-planes", Fx_display_planes, Sx_display_planes,
- 0, 1, 0,
- "Returns the number of bitplanes of the display DISPLAY.\n\
-The optional argument DISPLAY specifies which display to ask about.\n\
-DISPLAY should be either a frame or a display name (a string).\n\
-If omitted or nil, that stands for the selected frame's display.")
+ 0, 1, 0,
+ doc: /* Returns the number of bitplanes of DISPLAY.
+The optional argument DISPLAY specifies which display to ask about.
+DISPLAY should be either a frame or a display name (a string).
+If omitted or nil, that stands for the selected frame's display. */)
(display)
Lisp_Object display;
{
}
DEFUN ("x-display-color-cells", Fx_display_color_cells, Sx_display_color_cells,
- 0, 1, 0,
- "Returns the number of color cells of the display DISPLAY.\n\
-The optional argument DISPLAY specifies which display to ask about.\n\
-DISPLAY should be either a frame or a display name (a string).\n\
-If omitted or nil, that stands for the selected frame's display.")
+ 0, 1, 0,
+ doc: /* Returns the number of color cells of DISPLAY.
+The optional argument DISPLAY specifies which display to ask about.
+DISPLAY should be either a frame or a display name (a string).
+If omitted or nil, that stands for the selected frame's display. */)
(display)
Lisp_Object display;
{
else
cap = GetDeviceCaps (hdc,NUMCOLORS);
+ /* We force 24+ bit depths to 24-bit, both to prevent an overflow
+ and because probably is more meaningful on Windows anyway */
if (cap < 0)
- cap = 1 << (dpyinfo->n_planes * dpyinfo->n_cbits);
-
+ cap = 1 << min(dpyinfo->n_planes * dpyinfo->n_cbits, 24);
+
ReleaseDC (dpyinfo->root_window, hdc);
-
+
return make_number (cap);
}
DEFUN ("x-server-max-request-size", Fx_server_max_request_size,
Sx_server_max_request_size,
- 0, 1, 0,
- "Returns the maximum request size of the server of display DISPLAY.\n\
-The optional argument DISPLAY specifies which display to ask about.\n\
-DISPLAY should be either a frame or a display name (a string).\n\
-If omitted or nil, that stands for the selected frame's display.")
+ 0, 1, 0,
+ doc: /* Returns the maximum request size of the server of DISPLAY.
+The optional argument DISPLAY specifies which display to ask about.
+DISPLAY should be either a frame or a display name (a string).
+If omitted or nil, that stands for the selected frame's display. */)
(display)
Lisp_Object display;
{
}
DEFUN ("x-server-vendor", Fx_server_vendor, Sx_server_vendor, 0, 1, 0,
- "Returns the vendor ID string of the W32 system (Microsoft).\n\
-The optional argument DISPLAY specifies which display to ask about.\n\
-DISPLAY should be either a frame or a display name (a string).\n\
-If omitted or nil, that stands for the selected frame's display.")
+ doc: /* Returns the vendor ID string of the W32 system (Microsoft).
+The optional argument DISPLAY specifies which display to ask about.
+DISPLAY should be either a frame or a display name (a string).
+If omitted or nil, that stands for the selected frame's display. */)
(display)
Lisp_Object display;
{
}
DEFUN ("x-server-version", Fx_server_version, Sx_server_version, 0, 1, 0,
- "Returns the version numbers of the server of display DISPLAY.\n\
-The value is a list of three integers: the major and minor\n\
-version numbers, and the vendor-specific release\n\
-number. See also the function `x-server-vendor'.\n\n\
-The optional argument DISPLAY specifies which display to ask about.\n\
-DISPLAY should be either a frame or a display name (a string).\n\
-If omitted or nil, that stands for the selected frame's display.")
+ doc: /* Returns the version numbers of the server of DISPLAY.
+The value is a list of three integers: the major and minor
+version numbers, and the vendor-specific release
+number. See also the function `x-server-vendor'.
+
+The optional argument DISPLAY specifies which display to ask about.
+DISPLAY should be either a frame or a display name (a string).
+If omitted or nil, that stands for the selected frame's display. */)
(display)
Lisp_Object display;
{
}
DEFUN ("x-display-screens", Fx_display_screens, Sx_display_screens, 0, 1, 0,
- "Returns the number of screens on the server of display DISPLAY.\n\
-The optional argument DISPLAY specifies which display to ask about.\n\
-DISPLAY should be either a frame or a display name (a string).\n\
-If omitted or nil, that stands for the selected frame's display.")
+ doc: /* Returns the number of screens on the server of DISPLAY.
+The optional argument DISPLAY specifies which display to ask about.
+DISPLAY should be either a frame or a display name (a string).
+If omitted or nil, that stands for the selected frame's display. */)
(display)
Lisp_Object display;
{
return make_number (1);
}
-DEFUN ("x-display-mm-height", Fx_display_mm_height, Sx_display_mm_height, 0, 1, 0,
- "Returns the height in millimeters of the X display DISPLAY.\n\
-The optional argument DISPLAY specifies which display to ask about.\n\
-DISPLAY should be either a frame or a display name (a string).\n\
-If omitted or nil, that stands for the selected frame's display.")
+DEFUN ("x-display-mm-height", Fx_display_mm_height,
+ Sx_display_mm_height, 0, 1, 0,
+ doc: /* Returns the height in millimeters of DISPLAY.
+The optional argument DISPLAY specifies which display to ask about.
+DISPLAY should be either a frame or a display name (a string).
+If omitted or nil, that stands for the selected frame's display. */)
(display)
Lisp_Object display;
{
int cap;
hdc = GetDC (dpyinfo->root_window);
-
+
cap = GetDeviceCaps (hdc, VERTSIZE);
-
+
ReleaseDC (dpyinfo->root_window, hdc);
-
+
return make_number (cap);
}
DEFUN ("x-display-mm-width", Fx_display_mm_width, Sx_display_mm_width, 0, 1, 0,
- "Returns the width in millimeters of the X display DISPLAY.\n\
-The optional argument DISPLAY specifies which display to ask about.\n\
-DISPLAY should be either a frame or a display name (a string).\n\
-If omitted or nil, that stands for the selected frame's display.")
+ doc: /* Returns the width in millimeters of DISPLAY.
+The optional argument DISPLAY specifies which display to ask about.
+DISPLAY should be either a frame or a display name (a string).
+If omitted or nil, that stands for the selected frame's display. */)
(display)
Lisp_Object display;
{
int cap;
hdc = GetDC (dpyinfo->root_window);
-
+
cap = GetDeviceCaps (hdc, HORZSIZE);
-
+
ReleaseDC (dpyinfo->root_window, hdc);
-
+
return make_number (cap);
}
DEFUN ("x-display-backing-store", Fx_display_backing_store,
- Sx_display_backing_store, 0, 1, 0,
- "Returns an indication of whether display DISPLAY does backing store.\n\
-The value may be `always', `when-mapped', or `not-useful'.\n\
-The optional argument DISPLAY specifies which display to ask about.\n\
-DISPLAY should be either a frame or a display name (a string).\n\
-If omitted or nil, that stands for the selected frame's display.")
+ Sx_display_backing_store, 0, 1, 0,
+ doc: /* Returns an indication of whether DISPLAY does backing store.
+The value may be `always', `when-mapped', or `not-useful'.
+The optional argument DISPLAY specifies which display to ask about.
+DISPLAY should be either a frame or a display name (a string).
+If omitted or nil, that stands for the selected frame's display. */)
(display)
Lisp_Object display;
{
}
DEFUN ("x-display-visual-class", Fx_display_visual_class,
- Sx_display_visual_class, 0, 1, 0,
- "Returns the visual class of the display DISPLAY.\n\
-The value is one of the symbols `static-gray', `gray-scale',\n\
-`static-color', `pseudo-color', `true-color', or `direct-color'.\n\n\
-The optional argument DISPLAY specifies which display to ask about.\n\
-DISPLAY should be either a frame or a display name (a string).\n\
-If omitted or nil, that stands for the selected frame's display.")
+ Sx_display_visual_class, 0, 1, 0,
+ doc: /* Returns the visual class of DISPLAY.
+The value is one of the symbols `static-gray', `gray-scale',
+`static-color', `pseudo-color', `true-color', or `direct-color'.
+
+The optional argument DISPLAY specifies which display to ask about.
+DISPLAY should be either a frame or a display name (a string).
+If omitted or nil, that stands for the selected frame's display. */)
(display)
Lisp_Object display;
{
}
DEFUN ("x-display-save-under", Fx_display_save_under,
- Sx_display_save_under, 0, 1, 0,
- "Returns t if the display DISPLAY supports the save-under feature.\n\
-The optional argument DISPLAY specifies which display to ask about.\n\
-DISPLAY should be either a frame or a display name (a string).\n\
-If omitted or nil, that stands for the selected frame's display.")
+ Sx_display_save_under, 0, 1, 0,
+ doc: /* Returns t if DISPLAY supports the save-under feature.
+The optional argument DISPLAY specifies which display to ask about.
+DISPLAY should be either a frame or a display name (a string).
+If omitted or nil, that stands for the selected frame's display. */)
(display)
Lisp_Object display;
{
Lisp_Object names;
struct w32_display_info *dpyinfo;
- CHECK_STRING (name, 0);
+ CHECK_STRING (name);
for (dpyinfo = &one_w32_display_info, names = w32_display_name_list;
dpyinfo;
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);
}
DEFUN ("x-open-connection", Fx_open_connection, Sx_open_connection,
- 1, 3, 0, "Open a connection to a server.\n\
-DISPLAY is the name of the display to connect to.\n\
-Optional second arg XRM-STRING is a string of resources in xrdb format.\n\
-If the optional third arg MUST-SUCCEED is non-nil,\n\
-terminate Emacs if we can't open the connection.")
+ 1, 3, 0, doc: /* Open a connection to a server.
+DISPLAY is the name of the display to connect to.
+Optional second arg XRM-STRING is a string of resources in xrdb format.
+If the optional third arg MUST-SUCCEED is non-nil,
+terminate Emacs if we can't open the connection. */)
(display, xrm_string, must_succeed)
Lisp_Object display, xrm_string, must_succeed;
{
unsigned char *xrm_option;
struct w32_display_info *dpyinfo;
- CHECK_STRING (display, 0);
- if (! NILP (xrm_string))
- CHECK_STRING (xrm_string, 1);
+ /* If initialization has already been done, return now to avoid
+ overwriting critical parts of one_w32_display_info. */
+ if (w32_in_use)
+ return Qnil;
+
+ CHECK_STRING (display);
+ if (! NILP (xrm_string))
+ CHECK_STRING (xrm_string);
if (! EQ (Vwindow_system, intern ("w32")))
error ("Not using Microsoft Windows");
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;
DEFUN ("x-close-connection", Fx_close_connection,
Sx_close_connection, 1, 1, 0,
- "Close the connection to DISPLAY's server.\n\
-For DISPLAY, specify either a frame or a display name (a string).\n\
-If DISPLAY is nil, that stands for the selected frame's display.")
+ doc: /* Close the connection to DISPLAY's server.
+For DISPLAY, specify either a frame or a display name (a string).
+If DISPLAY is nil, that stands for the selected frame's display. */)
(display)
Lisp_Object display;
{
}
DEFUN ("x-display-list", Fx_display_list, Sx_display_list, 0, 0, 0,
- "Return the list of display names that Emacs has connections to.")
+ doc: /* Return the list of display names that Emacs has connections to. */)
()
{
Lisp_Object tail, result;
}
DEFUN ("x-synchronize", Fx_synchronize, Sx_synchronize, 1, 2, 0,
- "If ON is non-nil, report errors as soon as the erring request is made.\n\
-If ON is nil, allow buffering of requests.\n\
-This is a noop on W32 systems.\n\
-The optional second argument DISPLAY specifies which display to act on.\n\
-DISPLAY should be either a frame or a display name (a string).\n\
-If DISPLAY is omitted or nil, that stands for the selected frame's display.")
- (on, display)
- Lisp_Object display, on;
+ doc: /* This is a noop on W32 systems. */)
+ (on, display)
+ Lisp_Object display, on;
{
return Qnil;
}
\f
-\f
/***********************************************************************
Image types
***********************************************************************/
/* Keywords. */
extern Lisp_Object QCwidth, QCheight, QCforeground, QCbackground, QCfile;
-extern Lisp_Object QCdata;
-Lisp_Object QCtype, QCascent, QCmargin, QCrelief;
+extern Lisp_Object QCdata, QCtype;
+Lisp_Object QCascent, QCmargin, QCrelief;
Lisp_Object QCconversion, QCcolor_symbols, QCheuristic_mask;
-Lisp_Object QCindex;
+Lisp_Object QCindex, QCmatrix, QCcolor_adjustment, QCmask;
/* Other symbols. */
-Lisp_Object Qlaplace;
+Lisp_Object Qlaplace, Qemboss, Qedge_detection, Qheuristic;
/* Time in seconds after which images should be removed from the cache
if not displayed. */
static struct image_type *lookup_image_type P_ ((Lisp_Object symbol));
static void image_error P_ ((char *format, Lisp_Object, Lisp_Object));
static void x_laplace P_ ((struct frame *, struct image *));
+static void x_emboss P_ ((struct frame *, struct image *));
static int x_build_heuristic_mask P_ ((struct frame *, struct image *,
Lisp_Object));
Lisp_Object object;
{
int valid_p = 0;
-
+
if (CONSP (object) && EQ (XCAR (object), Qimage))
{
- Lisp_Object symbol = Fplist_get (XCDR (object), QCtype);
- struct image_type *type = lookup_image_type (symbol);
-
- if (type)
- valid_p = type->valid_p (object);
+ Lisp_Object tem;
+
+ for (tem = XCDR (object); CONSP (tem); tem = XCDR (tem))
+ if (EQ (XCAR (tem), QCtype))
+ {
+ tem = XCDR (tem);
+ if (CONSP (tem) && SYMBOLP (XCAR (tem)))
+ {
+ struct image_type *type;
+ type = lookup_image_type (XCAR (tem));
+ if (type)
+ valid_p = type->valid_p (object);
+ }
+
+ break;
+ }
}
return valid_p;
{
IMAGE_DONT_CHECK_VALUE_TYPE,
IMAGE_STRING_VALUE,
+ IMAGE_STRING_OR_NIL_VALUE,
IMAGE_SYMBOL_VALUE,
IMAGE_POSITIVE_INTEGER_VALUE,
IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR,
/* 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;
return 0;
break;
+ case IMAGE_STRING_OR_NIL_VALUE:
+ if (!STRINGP (value) && !NILP (value))
+ return 0;
+ break;
+
case IMAGE_SYMBOL_VALUE:
if (!SYMBOLP (value))
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;
}
-
+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
+size in canonical character units.
+FRAME is the frame on which the image will be displayed. FRAME nil
+or omitted means use the selected frame. */)
+ (spec, pixels, frame)
+ Lisp_Object spec, pixels, frame;
+{
+ Lisp_Object size;
+
+ size = Qnil;
+ if (valid_image_p (spec))
+ {
+ struct frame *f = check_x_frame (frame);
+ int id = lookup_image (f, spec);
+ 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)));
+ else
+ size = Fcons (make_number (width), make_number (height));
+ }
+ else
+ error ("Invalid image specification");
+
+ return size;
+}
+
+
+DEFUN ("image-mask-p", Fimage_mask_p, Simage_mask_p, 1, 2, 0,
+ doc: /* Return t if image SPEC has a mask bitmap.
+FRAME is the frame on which the image will be displayed. FRAME nil
+or omitted means use the selected frame. */)
+ (spec, frame)
+ Lisp_Object spec, frame;
+{
+ Lisp_Object mask;
+
+ mask = Qnil;
+ if (valid_image_p (spec))
+ {
+ struct frame *f = check_x_frame (frame);
+ int id = lookup_image (f, spec);
+ struct image *img = IMAGE_FROM_ID (f, id);
+ if (img->mask)
+ mask = Qt;
+ }
+ else
+ error ("Invalid image specification");
+
+ return mask;
+}
+
\f
/***********************************************************************
Image type independent image structures
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. */
ascent = height / 2;
}
else
- ascent = height * img->ascent / 100.0;
+ ascent = (int) (height * img->ascent / 100.0);
return ascent;
}
\f
+/* Image background colors. */
+
+/* Find the "best" corner color of a bitmap. XIMG is assumed to a device
+ context with the bitmap selected. */
+static COLORREF
+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 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;
+
+ if (n > best_count)
+ best = corners[i], best_count = n;
+ }
+
+ return best;
+}
+
+/* Return the `background' field of IMG. If IMG doesn't have one yet,
+ 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, img_dc)
+ struct image *img;
+ struct frame *f;
+ HDC img_dc;
+{
+ if (! img->background_valid)
+ /* IMG doesn't have a background yet, try to guess a reasonable value. */
+ {
+ int free_ximg = !img_dc;
+ HGDIOBJ prev;
+
+ 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 (img_dc, img->width, img->height);
+
+ if (free_ximg)
+ {
+ SelectObject (img_dc, prev);
+ DeleteDC (img_dc);
+ }
+
+ img->background_valid = 1;
+ }
+
+ return img->background;
+}
+
+/* Return the `background_transparent' field of IMG. If IMG doesn't
+ have one yet, it is guessed heuristically. If non-zero, MASK is an
+ existing XImage object to use for the heuristic. */
+
+int
+image_background_transparent (img, f, mask)
+ struct image *img;
+ struct frame *f;
+ HDC mask;
+{
+ if (! img->background_transparent_valid)
+ /* IMG doesn't have a background yet, try to guess a reasonable value. */
+ {
+ if (img->mask)
+ {
+ int free_mask = !mask;
+ HGDIOBJ prev;
+
+ 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)
+ {
+ SelectObject (mask, prev);
+ DeleteDC (mask);
+ }
+ }
+ else
+ img->background_transparent = 0;
+
+ img->background_transparent_valid = 1;
+ }
+
+ return img->background_transparent;
+}
+
+\f
/***********************************************************************
Helper functions for X image types
***********************************************************************/
+static void x_clear_image_1 P_ ((struct frame *, struct image *, int,
+ int, int));
static void x_clear_image P_ ((struct frame *f, struct image *img));
static unsigned long x_alloc_image_color P_ ((struct frame *f,
struct image *img,
Lisp_Object color_name,
unsigned long dflt));
+
+/* Clear X resources of image IMG on frame F. PIXMAP_P non-zero means
+ free the pixmap if any. MASK_P non-zero means clear the mask
+ pixmap if any. COLORS_P non-zero means free colors allocated for
+ the image, if any. */
+
+static void
+x_clear_image_1 (f, img, pixmap_p, mask_p, colors_p)
+ struct frame *f;
+ struct image *img;
+ int pixmap_p, mask_p, colors_p;
+{
+ if (pixmap_p && img->pixmap)
+ {
+ DeleteObject (img->pixmap);
+ img->pixmap = NULL;
+ img->background_valid = 0;
+ }
+
+ if (mask_p && img->mask)
+ {
+ DeleteObject (img->mask);
+ 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;
+ }
+}
+
/* Free X resources of image IMG which is used on frame F. */
static void
struct frame *f;
struct image *img;
{
-#if 0 /* TODO: W32 image support */
-
if (img->pixmap)
{
BLOCK_INPUT;
- XFreePixmap (NULL, img->pixmap);
+ DeleteObject (img->pixmap);
img->pixmap = 0;
UNBLOCK_INPUT;
}
if (img->ncolors)
{
+#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
img->ncolors, 0);
UNBLOCK_INPUT;
}
-
+#endif
+
xfree (img->colors);
img->colors = NULL;
img->ncolors = 0;
}
-#endif
}
Lisp_Object color_name;
unsigned long dflt;
{
-#if 0 /* TODO: allocing colors. */
XColor color;
unsigned long result;
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. */
else
result = dflt;
return result;
-#endif
- return 0;
}
***********************************************************************/
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;
}
}
DEFUN ("clear-image-cache", Fclear_image_cache, Sclear_image_cache,
0, 1, 0,
- "Clear the image cache of FRAME.\n\
-FRAME nil or omitted means use the selected frame.\n\
-FRAME t means clear the image caches of all frames.")
+ doc: /* Clear the image cache of FRAME.
+FRAME nil or omitted means use the selected frame.
+FRAME t means clear the image caches of all frames. */)
(frame)
Lisp_Object frame;
{
if (EQ (frame, Qt))
{
Lisp_Object tail;
-
+
FOR_EACH_FRAME (tail, frame)
if (FRAME_W32_P (XFRAME (frame)))
clear_image_cache (XFRAME (frame), 1);
}
+/* Compute masks and transform image IMG on frame F, as specified
+ by the image's specification, */
+
+static void
+postprocess_image (f, img)
+ struct frame *f;
+ struct image *img;
+{
+ /* Manipulation of the image's mask. */
+ if (img->pixmap)
+ {
+ Lisp_Object conversion, spec;
+ Lisp_Object mask;
+
+ spec = img->spec;
+
+ /* `:heuristic-mask t'
+ `:mask heuristic'
+ means build a mask heuristically.
+ `:heuristic-mask (R G B)'
+ `:mask (heuristic (R G B))'
+ means build a mask from color (R G B) in the
+ 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)
+ && EQ (XCAR (mask), Qheuristic))
+ {
+ if (CONSP (XCDR (mask)))
+ x_build_heuristic_mask (f, img, XCAR (XCDR (mask)));
+ else
+ x_build_heuristic_mask (f, img, XCDR (mask));
+ }
+ else if (NILP (mask) && found_p && img->mask)
+ {
+ DeleteObject (img->mask);
+ img->mask = NULL;
+ }
+ }
+
+
+ /* Should we apply an image transformation algorithm? */
+ conversion = image_spec_value (spec, QCconversion, NULL);
+ if (EQ (conversion, Qdisabled))
+ x_disable_image (f, img);
+ else if (EQ (conversion, Qlaplace))
+ x_laplace (f, img);
+ else if (EQ (conversion, Qemboss))
+ x_emboss (f, img);
+ else if (CONSP (conversion)
+ && EQ (XCAR (conversion), Qedge_detection))
+ {
+ Lisp_Object tem;
+ tem = XCDR (conversion);
+ if (CONSP (tem))
+ x_edge_detection (f, img,
+ Fplist_get (tem, QCmatrix),
+ Fplist_get (tem, QCcolor_adjustment));
+ }
+ }
+}
+
+
/* Return the id of image with Lisp specification SPEC on frame F.
SPEC must be a valid Lisp image specification (see valid_image_p). */
specification. */
xassert (FRAME_WINDOW_P (f));
xassert (valid_image_p (spec));
-
+
GCPRO1 (spec);
/* Look up SPEC in the hash table of the image cache. */
/* If not found, create a new image and cache it. */
if (img == NULL)
{
+ extern Lisp_Object Qpostscript;
+
BLOCK_INPUT;
img = make_image (spec, hash);
cache_image (f, img);
else
{
/* Handle image type independent image attributes
- `:ascent PERCENT', `:margin MARGIN', `:relief RELIEF'. */
- Lisp_Object ascent, margin, relief;
+ `:ascent ASCENT', `:margin MARGIN', `:relief RELIEF',
+ `:background COLOR'. */
+ Lisp_Object ascent, margin, relief, bg;
ascent = image_spec_value (spec, QCascent, NULL);
if (INTEGERP (ascent))
if (XINT (XCDR (margin)) > 0)
img->vmargin = XFASTINT (XCDR (margin));
}
-
+
relief = image_spec_value (spec, QCrelief, NULL);
if (INTEGERP (relief))
{
img->vmargin += abs (img->relief);
}
-#if 0 /* TODO: image mask and algorithm. */
- /* Manipulation of the image's mask. */
- if (img->pixmap)
- {
- /* `:heuristic-mask t'
- `:mask heuristic'
- means build a mask heuristically.
- `:heuristic-mask (R G B)'
- `:mask (heuristic (R G B))'
- means build a mask from color (R G B) in the
- image.
- `:mask nil'
- means remove a mask, if any. */
-
- Lisp_Object mask;
-
- 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)
- && EQ (XCAR (mask), Qheuristic))
- {
- if (CONSP (XCDR (mask)))
- x_build_heuristic_mask (f, img, XCAR (XCDR (mask)));
- else
- x_build_heuristic_mask (f, img, XCDR (mask));
- }
- else if (NILP (mask) && found_p && img->mask)
- {
- XFreePixmap (FRAME_X_DISPLAY (f), img->mask);
- img->mask = None;
- }
- }
- }
-
- /* Should we apply an image transformation algorithm? */
- if (img->pixmap)
+ if (! img->background_valid)
{
- Lisp_Object conversion;
-
- algorithm = image_spec_value (spec, QCconversion, NULL);
- if (EQ (conversion, Qdisabled))
- x_disable_image (f, img);
- else if (EQ (conversion, Qlaplace))
- x_laplace (f, img);
- else if (EQ (conversion, Qemboss))
- x_emboss (f, img);
- else if (CONSP (conversion)
- && EQ (XCAR (conversion), Qedge_detection))
+ bg = image_spec_value (img->spec, QCbackground, NULL);
+ if (!NILP (bg))
{
- Lisp_Object tem;
- tem = XCDR (conversion);
- if (CONSP (tem))
- x_edge_detection (f, img,
- Fplist_get (tem, QCmatrix),
- Fplist_get (tem, QCcolor_adjustment));
+ img->background
+ = x_alloc_image_color (f, img, bg,
+ FRAME_BACKGROUND_PIXEL (f));
+ img->background_valid = 1;
}
}
-#endif /* TODO. */
+
+ /* Do image transformations and compute masks, unless we
+ don't have the image yet. */
+ if (!EQ (*img->type->type, Qpostscript))
+ postprocess_image (f, img);
}
+
UNBLOCK_INPUT;
xassert (!interrupt_input_blocked);
}
/* 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;
}
W32 support code
***********************************************************************/
-#if 0 /* TODO: W32 specific image code. */
+/* Macro for defining functions that will be loaded from image DLLs. */
+#define DEF_IMGLIB_FN(func) FARPROC fn_##func
+
+/* Macro for loading those image functions from the library. */
+#define LOAD_IMGLIB_FN(lib,func) { \
+ fn_##func = (void *) GetProcAddress (lib, #func); \
+ if (!fn_##func) return 0; \
+ }
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));
/* Create an XImage and a pixmap of size WIDTH x HEIGHT for use on
frame F. Set *XIMG and *PIXMAP to the XImage and Pixmap created.
Set (*XIMG)->data to a raster of WIDTH x HEIGHT pixels allocated
- via xmalloc. Print error messages via image_error if an error
- occurs. Value is non-zero if successful. */
+ via xmalloc. DEPTH of zero signifies a 24 bit image, otherwise
+ DEPTH should indicate the bit depth of the image. Print error
+ messages via image_error if an error occurs. Value is non-zero if
+ successful. */
static int
x_create_x_image_and_pixmap (f, width, height, depth, ximg, pixmap)
XImage **ximg;
Pixmap *pixmap;
{
-#if 0 /* TODO: Image support for W32 */
- Display *display = FRAME_W32_DISPLAY (f);
- Screen *screen = FRAME_X_SCREEN (f);
- Window window = FRAME_W32_WINDOW (f);
+ BITMAPINFOHEADER *header;
+ HDC hdc;
+ int scanline_width_bits;
+ int remainder;
+ int palette_colors = 0;
- xassert (interrupt_input_blocked);
+ if (depth == 0)
+ depth = 24;
+
+ if (depth != 1 && depth != 4 && depth != 8
+ && depth != 16 && depth != 24 && depth != 32)
+ {
+ image_error ("Invalid image bit depth specified", Qnil, Qnil);
+ return 0;
+ }
- if (depth <= 0)
- depth = DefaultDepthOfScreen (screen);
- *ximg = XCreateImage (display, DefaultVisualOfScreen (screen),
- depth, ZPixmap, 0, NULL, width, height,
- depth > 16 ? 32 : depth > 8 ? 16 : 8, 0);
+ scanline_width_bits = width * depth;
+ remainder = scanline_width_bits % 32;
+
+ if (remainder)
+ scanline_width_bits += 32 - remainder;
+
+ /* Bitmaps with a depth less than 16 need a palette. */
+ /* BITMAPINFO structure already contains the first RGBQUAD. */
+ if (depth < 16)
+ palette_colors = 1 << depth - 1;
+
+ *ximg = xmalloc (sizeof (XImage) + palette_colors * sizeof (RGBQUAD));
if (*ximg == NULL)
{
- image_error ("Unable to allocate X image", Qnil, Qnil);
+ image_error ("Unable to allocate memory for XImage", Qnil, Qnil);
return 0;
}
- /* Allocate image raster. */
- (*ximg)->data = (char *) xmalloc ((*ximg)->bytes_per_line * height);
+ header = &((*ximg)->info.bmiHeader);
+ bzero (&((*ximg)->info), sizeof (BITMAPINFO));
+ header->biSize = sizeof (*header);
+ header->biWidth = width;
+ header->biHeight = -height; /* negative indicates a top-down bitmap. */
+ header->biPlanes = 1;
+ header->biBitCount = depth;
+ 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),
+ (depth < 16) ? DIB_PAL_COLORS : DIB_RGB_COLORS,
+ &((*ximg)->data), NULL, 0);
- /* Allocate a pixmap of the same size. */
- *pixmap = XCreatePixmap (display, window, width, height, depth);
- if (*pixmap == 0)
+ /* Realize display palette and garbage all frames. */
+ release_frame_dc (f, hdc);
+
+ if (*pixmap == NULL)
{
+ DWORD err = GetLastError();
+ Lisp_Object errcode;
+ /* All system errors are < 10000, so the following is safe. */
+ XSETINT (errcode, (int) err);
+ image_error ("Unable to create bitmap, error code %d", errcode, Qnil);
x_destroy_x_image (*ximg);
- *ximg = NULL;
- image_error ("Unable to create X pixmap", Qnil, Qnil);
return 0;
}
-#endif
+
return 1;
}
xassert (interrupt_input_blocked);
if (ximg)
{
- xfree (ximg->data);
+ /* Data will be freed by DestroyObject. */
ximg->data = NULL;
- XDestroyImage (ximg);
+ xfree (ximg);
}
}
struct frame *f;
XImage *ximg;
Pixmap pixmap;
+ int width, height;
{
- 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
+}
\f
/***********************************************************************
- Searching files
+ File Handling
***********************************************************************/
static Lisp_Object x_find_image_file P_ ((Lisp_Object));
+static char *slurp_file P_ ((char *, int *));
+
/* Find image file FILE. Look in data-directory, then
x-bitmap-file-path. Value is the full name of the file found, or
GCPRO2 (file_found, search_path);
/* Try to find FILE in data-directory, then x-bitmap-file-path. */
- fd = openp (search_path, file, "", &file_found, 0);
-
+ fd = openp (search_path, file, Qnil, &file_found, Qnil);
+
if (fd == -1)
file_found = Qnil;
else
}
+/* Read FILE into memory. Value is a pointer to a buffer allocated
+ with xmalloc holding FILE's contents. Value is null if an error
+ occurred. *SIZE is set to the size of the file. */
+
+static char *
+slurp_file (file, size)
+ char *file;
+ int *size;
+{
+ FILE *fp = NULL;
+ char *buf = NULL;
+ struct stat st;
+
+ if (stat (file, &st) == 0
+ && (fp = fopen (file, "r")) != NULL
+ && (buf = (char *) xmalloc (st.st_size),
+ fread (buf, 1, st.st_size, fp) == st.st_size))
+ {
+ *size = st.st_size;
+ fclose (fp);
+ }
+ else
+ {
+ if (fp)
+ fclose (fp);
+ if (buf)
+ {
+ xfree (buf);
+ buf = NULL;
+ }
+ }
+
+ return buf;
+}
+
+
\f
/***********************************************************************
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. */
XBM_RELIEF,
XBM_ALGORITHM,
XBM_HEURISTIC_MASK,
+ XBM_MASK,
XBM_LAST
};
{":width", IMAGE_POSITIVE_INTEGER_VALUE, 0},
{":height", IMAGE_POSITIVE_INTEGER_VALUE, 0},
{":data", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
- {":foreground", IMAGE_STRING_VALUE, 0},
- {":background", IMAGE_STRING_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;
}
scanning a number, store its value in *IVAL. */
static int
-xbm_scan (fp, sval, ival)
- FILE *fp;
+xbm_scan (s, end, sval, ival)
+ char **s, *end;
char *sval;
int *ival;
{
int c;
-
+
+ loop:
+
/* Skip white space. */
- while ((c = fgetc (fp)) != EOF && isspace (c))
+ while (*s < end && (c = *(*s)++, isspace (c)))
;
- if (c == EOF)
+ if (*s >= end)
c = 0;
else if (isdigit (c))
{
int value = 0, digit;
-
- if (c == '0')
+
+ if (c == '0' && *s < end)
{
- c = fgetc (fp);
+ c = *(*s)++;
if (c == 'x' || c == 'X')
{
- while ((c = fgetc (fp)) != EOF)
+ while (*s < end)
{
+ c = *(*s)++;
if (isdigit (c))
digit = c - '0';
else if (c >= 'a' && c <= 'f')
else if (isdigit (c))
{
value = c - '0';
- while ((c = fgetc (fp)) != EOF
- && isdigit (c))
+ while (*s < end
+ && (c = *(*s)++, isdigit (c)))
value = 8 * value + c - '0';
}
}
else
{
value = c - '0';
- while ((c = fgetc (fp)) != EOF
- && isdigit (c))
+ while (*s < end
+ && (c = *(*s)++, isdigit (c)))
value = 10 * value + c - '0';
}
- if (c != EOF)
- ungetc (c, fp);
+ if (*s < end)
+ *s = *s - 1;
*ival = value;
c = XBM_TK_NUMBER;
}
else if (isalpha (c) || c == '_')
{
*sval++ = c;
- while ((c = fgetc (fp)) != EOF
- && (isalnum (c) || c == '_'))
+ while (*s < end
+ && (c = *(*s)++, (isalnum (c) || c == '_')))
*sval++ = c;
*sval = 0;
- if (c != EOF)
- ungetc (c, fp);
+ if (*s < end)
+ *s = *s - 1;
c = XBM_TK_IDENT;
}
-
+ else if (c == '/' && **s == '*')
+ {
+ /* C-style comment. */
+ ++*s;
+ while (**s && (**s != '*' || *(*s + 1) != '/'))
+ ++*s;
+ if (**s)
+ {
+ *s += 2;
+ goto loop;
+ }
+ }
+
return c;
}
+/* 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 *) alloca (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);
+
+ return bmp;
+}
+
+
/* Replacement for XReadBitmapFileData which isn't available under old
- X versions. FILE is the name of the bitmap file to read. Set
- *WIDTH and *HEIGHT to the width and height of the image. Return in
- *DATA the bitmap data allocated with xmalloc. Value is non-zero if
- successful. */
+ 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
+ the image. Return in *DATA the bitmap data allocated with xmalloc.
+ Value is non-zero if successful. DATA null means just test if
+ CONTENTS looks like an in-memory XBM file. */
static int
-xbm_read_bitmap_file_data (file, width, height, data)
- char *file;
+xbm_read_bitmap_data (contents, end, width, height, data)
+ char *contents, *end;
int *width, *height;
unsigned char **data;
{
- FILE *fp;
+ char *s = contents;
char buffer[BUFSIZ];
int padding_p = 0;
int v10 = 0;
int LA1;
#define match() \
- LA1 = xbm_scan (fp, 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) \
else \
goto failure
- fp = fopen (file, "r");
- if (fp == NULL)
- return 0;
-
*width = *height = -1;
- *data = NULL;
- LA1 = xbm_scan (fp, buffer, &value);
+ if (data)
+ *data = NULL;
+ LA1 = xbm_scan (&s, end, buffer, &value);
/* Parse defines for width, height and hot-spots. */
while (LA1 == '#')
if (*width < 0 || *height < 0)
goto failure;
+ else if (data == NULL)
+ goto success;
/* Parse bits. Must start with `static'. */
expect_ident ("static");
{
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
}
}
- fclose (fp);
+ success:
return 1;
failure:
-
- fclose (fp);
- if (*data)
+
+ if (data && *data)
{
xfree (*data);
*data = NULL;
#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 file
- SPECIFIED_FILE. Value is non-zero if successful. */
+/* 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
+ successful. */
static int
-xbm_load_image_from_file (f, img, specified_file)
+xbm_load_image (f, img, contents, end)
struct frame *f;
struct image *img;
- Lisp_Object specified_file;
+ char *contents, *end;
{
int rc;
unsigned char *data;
int success_p = 0;
- Lisp_Object file;
- struct gcpro gcpro1;
-
- xassert (STRINGP (specified_file));
- file = Qnil;
- GCPRO1 (file);
- file = x_find_image_file (specified_file);
- if (!STRINGP (file))
- {
- image_error ("Cannot find image file `%s'", specified_file, Qnil);
- UNGCPRO;
- return 0;
- }
-
- rc = xbm_read_bitmap_file_data (XSTRING (file)->data, &img->width,
- &img->height, &data);
+ rc = xbm_read_bitmap_data (contents, end, &img->width, &img->height, &data);
if (rc)
{
- int depth = one_w32_display_info.n_cbits;
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);
-
-#if 0 /* TODO : Port image display to W32 */
- BLOCK_INPUT;
+ {
+ background = x_alloc_image_color (f, img, value, background);
+ img->background = background;
+ img->background_valid = 1;
+ non_default_colors = 1;
+ }
img->pixmap
- = XCreatePixmapFromBitmapData (FRAME_W32_DISPLAY (f),
- FRAME_W32_WINDOW (f),
- data,
- img->width, img->height,
- foreground, background,
- depth);
+ = 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);
if (img->pixmap == 0)
{
x_clear_image (f, img);
- image_error ("Unable to create X pixmap for `%s'", file, Qnil);
+ image_error ("Unable to create X pixmap for `%s'", img->spec, Qnil);
}
else
success_p = 1;
-
- UNBLOCK_INPUT;
-#endif
}
else
image_error ("Error loading XBM image `%s'", img->spec, Qnil);
- UNGCPRO;
return success_p;
}
+/* Value is non-zero if DATA looks like an in-memory XBM file. */
+
+static int
+xbm_file_p (data)
+ Lisp_Object data;
+{
+ int w, h;
+ return (STRINGP (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. */
/* If IMG->spec specifies a file name, create a non-file spec from it. */
file_name = image_spec_value (img->spec, QCfile, NULL);
if (STRINGP (file_name))
- success_p = xbm_load_image_from_file (f, img, file_name);
+ {
+ Lisp_Object file;
+ char *contents;
+ int size;
+ struct gcpro gcpro1;
+
+ file = x_find_image_file (file_name);
+ GCPRO1 (file);
+ if (!STRINGP (file))
+ {
+ image_error ("Cannot find image file `%s'", file_name, Qnil);
+ UNGCPRO;
+ return 0;
+ }
+
+ contents = slurp_file (SDATA (file), &size);
+ if (contents == NULL)
+ {
+ image_error ("Error loading XBM image `%s'", img->spec, Qnil);
+ UNGCPRO;
+ return 0;
+ }
+
+ success_p = xbm_load_image (f, img, contents, contents + size);
+ UNGCPRO;
+ }
else
{
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;
- /* Parse the list specification. */
+ /* See if data looks like an in-memory XBM file. */
+ data = image_spec_value (img->spec, QCdata, NULL);
+ in_memory_file_p = xbm_file_p (data);
+
+ /* Parse the image specification. */
bcopy (xbm_format, fmt, sizeof fmt);
parsed_p = parse_image_spec (img->spec, fmt, XBM_LAST, Qxbm);
xassert (parsed_p);
/* Get specified width, and height. */
- img->width = XFASTINT (fmt[XBM_WIDTH].value);
- img->height = XFASTINT (fmt[XBM_HEIGHT].value);
- xassert (img->width > 0 && img->height > 0);
-
- BLOCK_INPUT;
-
- if (fmt[XBM_ASCENT].count)
- img->ascent = XFASTINT (fmt[XBM_ASCENT].value);
+ if (!in_memory_file_p)
+ {
+ img->width = XFASTINT (fmt[XBM_WIDTH].value);
+ 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)
- foreground = x_alloc_image_color (f, img, fmt[XBM_FOREGROUND].value,
- foreground);
- if (fmt[XBM_BACKGROUND].count)
- background = x_alloc_image_color (f, img, fmt[XBM_BACKGROUND].value,
- background);
-
- /* Set bits to the bitmap image data. */
- data = fmt[XBM_DATA].value;
- if (VECTORP (data))
+ if (fmt[XBM_FOREGROUND].count
+ && STRINGP (fmt[XBM_FOREGROUND].value))
{
- 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);
- else
- bcopy (XBOOL_VECTOR (line)->data, p, nbytes);
- }
+ foreground = x_alloc_image_color (f, img, fmt[XBM_FOREGROUND].value,
+ foreground);
+ non_default_colors = 1;
}
- else if (STRINGP (data))
- bits = XSTRING (data)->data;
- else
- bits = XBOOL_VECTOR (data)->data;
-#if 0 /* TODO : W32 XPM code */
- /* Create the pixmap. */
- depth = DefaultDepthOfScreen (FRAME_X_SCREEN (f));
- img->pixmap
- = XCreatePixmapFromBitmapData (FRAME_W32_DISPLAY (f),
- FRAME_W32_WINDOW (f),
- bits,
- img->width, img->height,
- foreground, background,
- depth);
-#endif /* TODO */
+ if (fmt[XBM_BACKGROUND].count
+ && STRINGP (fmt[XBM_BACKGROUND].value))
+ {
+ background = x_alloc_image_color (f, img, fmt[XBM_BACKGROUND].value,
+ background);
+ non_default_colors = 1;
+ }
- if (img->pixmap)
- success_p = 1;
+ if (in_memory_file_p)
+ success_p = xbm_load_image (f, img, SDATA (data),
+ (SDATA (data)
+ + SBYTES (data)));
else
{
- image_error ("Unable to create pixmap for XBM image `%s'",
- img->spec, Qnil);
- x_clear_image (f, img);
- }
+ if (VECTORP (data))
+ {
+ int i;
+ char *p;
+ int nbytes = (img->width + BITS_PER_CHAR - 1) / BITS_PER_CHAR;
- UNBLOCK_INPUT;
+ 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 (SDATA (line), p, nbytes);
+ else
+ bcopy (XBOOL_VECTOR (line)->data, p, nbytes);
+ }
+ }
+ else if (STRINGP (data))
+ bits = SDATA (data);
+ else
+ bits = XBOOL_VECTOR (data)->data;
+
+ /* Create the pixmap. */
+ img->pixmap
+ = 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
+ {
+ image_error ("Unable to create pixmap for XBM image `%s'",
+ img->spec, Qnil);
+ x_clear_image (f, img);
+ }
+ }
}
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));
static int xpm_valid_color_symbols_p P_ ((Lisp_Object));
+/* Indicate to xpm.h that we don't have Xlib. */
+#define FOR_MSW
+/* simx.h in xpm defines XColor and XImage differently than Emacs. */
+#define XColor xpm_XColor
+#define XImage xpm_XImage
+#define PIXEL_ALREADY_TYPEDEFED
#include "X11/xpm.h"
+#undef FOR_MSW
+#undef XColor
+#undef XImage
+#undef PIXEL_ALREADY_TYPEDEFED
/* The symbol `xpm' identifying XPM-format images. */
XPM_RELIEF,
XPM_ALGORITHM,
XPM_HEURISTIC_MASK,
+ XPM_MASK,
XPM_COLOR_SYMBOLS,
+ XPM_BACKGROUND,
XPM_LAST
};
{":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},
{":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
- {":color-symbols", IMAGE_DONT_CHECK_VALUE_TYPE, 0}
+ {":mask", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
+ {":color-symbols", 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 =
{
};
+/* XPM library details. */
+
+DEF_IMGLIB_FN (XpmFreeAttributes);
+DEF_IMGLIB_FN (XpmCreateImageFromBuffer);
+DEF_IMGLIB_FN (XpmReadFileToImage);
+DEF_IMGLIB_FN (XImageFree);
+
+
+static int
+init_xpm_functions (library)
+ HMODULE library;
+{
+ LOAD_IMGLIB_FN (library, XpmFreeAttributes);
+ LOAD_IMGLIB_FN (library, XpmCreateImageFromBuffer);
+ LOAD_IMGLIB_FN (library, XpmReadFileToImage);
+ LOAD_IMGLIB_FN (library, XImageFree);
+
+ return 1;
+}
+
/* Value is non-zero if COLOR_SYMBOLS is a valid color symbols list
for XPM images. Such a list must consist of conses whose car and
cdr are strings. */
/* 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)));
}
struct frame *f;
struct image *img;
{
- int rc, i;
+ HDC hdc;
+ int rc;
XpmAttributes attrs;
Lisp_Object specified_file, color_symbols;
+ xpm_XImage * xpm_image, * xpm_mask;
/* Configure the XPM lib. Use the visual of frame F. Allocate
close colors. Return colors allocated. */
bzero (&attrs, sizeof attrs);
+ xpm_image = xpm_mask = NULL;
+
+#if 0
attrs.visual = FRAME_X_VISUAL (f);
attrs.colormap = FRAME_X_COLORMAP (f);
attrs.valuemask |= XpmVisual;
attrs.valuemask |= XpmColormap;
+#endif
attrs.valuemask |= XpmReturnAllocPixels;
#ifdef XpmAllocCloseColors
attrs.alloc_close_colors = 1;
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));
}
}
/* Create a pixmap for the image, either from a file, or from a
string buffer containing data in the same format as an XPM file. */
- BLOCK_INPUT;
+
specified_file = image_spec_value (img->spec, QCfile, NULL);
+
+ {
+ HDC frame_dc = get_frame_dc (f);
+ hdc = CreateCompatibleDC (frame_dc);
+ release_frame_dc (f, frame_dc);
+ }
+
if (STRINGP (specified_file))
{
Lisp_Object file = x_find_image_file (specified_file);
if (!STRINGP (file))
{
image_error ("Cannot find image file `%s'", specified_file, Qnil);
- UNBLOCK_INPUT;
return 0;
}
-
- rc = XpmReadFileToPixmap (NULL, FRAME_W32_WINDOW (f),
- XSTRING (file)->data, &img->pixmap, &img->mask,
- &attrs);
+
+ /* XpmReadFileToPixmap is not available in the Windows port of
+ libxpm. But XpmReadFileToImage almost does what we want. */
+ rc = fn_XpmReadFileToImage (&hdc, SDATA (file),
+ &xpm_image, &xpm_mask,
+ &attrs);
}
else
{
Lisp_Object buffer = image_spec_value (img->spec, QCdata, NULL);
- rc = XpmCreatePixmapFromBuffer (NULL, FRAME_W32_WINDOW (f),
- XSTRING (buffer)->data,
- &img->pixmap, &img->mask,
- &attrs);
+ /* XpmCreatePixmapFromBuffer is not available in the Windows port
+ of libxpm. But XpmCreateImageFromBuffer almost does what we want. */
+ rc = fn_XpmCreateImageFromBuffer (&hdc, SDATA (buffer),
+ &xpm_image, &xpm_mask,
+ &attrs);
}
- UNBLOCK_INPUT;
if (rc == XpmSuccess)
{
+ int i;
+
+ /* W32 XPM uses XImage to wrap what W32 Emacs calls a Pixmap,
+ plus some duplicate attributes. */
+ if (xpm_image && xpm_image->bitmap)
+ {
+ img->pixmap = xpm_image->bitmap;
+ /* XImageFree in libXpm frees XImage struct without destroying
+ the bitmap, which is what we want. */
+ fn_XImageFree (xpm_image);
+ }
+ if (xpm_mask && xpm_mask->bitmap)
+ {
+ /* The mask appears to be inverted compared with what we expect.
+ TODO: invert our expectations. See other places where we
+ have to invert bits because our idea of masks is backwards. */
+ HGDIOBJ old_obj;
+ old_obj = SelectObject (hdc, xpm_mask->bitmap);
+
+ PatBlt (hdc, 0, 0, xpm_mask->width, xpm_mask->height, DSTINVERT);
+ SelectObject (hdc, old_obj);
+
+ img->mask = xpm_mask->bitmap;
+ fn_XImageFree (xpm_mask);
+ DeleteDC (hdc);
+ }
+
+ DeleteDC (hdc);
+
/* Remember allocated colors. */
img->ncolors = attrs.nalloc_pixels;
img->colors = (unsigned long *) xmalloc (img->ncolors
xassert (img->width > 0 && img->height > 0);
/* The call to XpmFreeAttributes below frees attrs.alloc_pixels. */
- BLOCK_INPUT;
- XpmFreeAttributes (&attrs);
- UNBLOCK_INPUT;
+ fn_XpmFreeAttributes (&attrs);
}
else
{
+ DeleteDC (hdc);
+
switch (rc)
{
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;
/***********************************************************************
Algorithms
***********************************************************************/
+static XColor *x_to_xcolors P_ ((struct frame *, struct image *, int));
+static void x_from_xcolors P_ ((struct frame *, struct image *, XColor *));
+static void x_detect_edges P_ ((struct frame *, struct image *, int[9], int));
+static void XPutPixel (XImage *, int, int, COLORREF);
+
+/* Non-zero means draw a cross on images having `:conversion
+ disabled'. */
+
+int cross_disabled_images;
+
+/* Edge detection matrices for different edge-detection
+ strategies. */
+
+static int emboss_matrix[9] = {
+ /* x - 1 x x + 1 */
+ 2, -1, 0, /* y - 1 */
+ -1, 0, 1, /* y */
+ 0, 1, -2 /* y + 1 */
+};
+
+static int laplace_matrix[9] = {
+ /* x - 1 x x + 1 */
+ 1, 0, 0, /* y - 1 */
+ 0, 0, 0, /* y */
+ 0, 0, -1 /* y + 1 */
+};
+
+/* Value is the intensity of the color whose red/green/blue values
+ are R, G, and B. */
+
+#define COLOR_INTENSITY(R, G, B) ((2 * (R) + 3 * (G) + (B)) / 6)
+
+
+/* On frame F, return an array of XColor structures describing image
+ IMG->pixmap. Each XColor structure has its pixel color set. RGB_P
+ non-zero means also fill the red/green/blue members of the XColor
+ structures. Value is a pointer to the array of XColors structures,
+ allocated with xmalloc; it must be freed by the caller. */
+
+static XColor *
+x_to_xcolors (f, img, rgb_p)
+ struct frame *f;
+ struct image *img;
+ int rgb_p;
+{
+ int x, y;
+ XColor *colors, *p;
+ HDC hdc, bmpdc;
+ HGDIOBJ prev;
-#if 0 /* TODO : W32 versions of low level algorithms */
-static void x_laplace_write_row P_ ((struct frame *, long *,
- int, XImage *, int));
-static void x_laplace_read_row P_ ((struct frame *, Colormap,
- XColor *, int, XImage *, int));
+ colors = (XColor *) xmalloc (img->width * img->height * sizeof *colors);
+ /* 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. */
+ p = colors;
+ for (y = 0; y < img->height; ++y)
+ {
+ XColor *row = p;
+
+ for (x = 0; x < img->width; ++x, ++p)
+ {
+ /* TODO: palette support needed here? */
+ p->pixel = GetPixel (bmpdc, x, y);
+
+ if (rgb_p)
+ {
+ p->red = 256 * GetRValue (p->pixel);
+ p->green = 256 * GetGValue (p->pixel);
+ p->blue = 256 * GetBValue (p->pixel);
+ }
+ }
+ }
-/* Fill COLORS with RGB colors from row Y of image XIMG. F is the
- frame we operate on, CMAP is the color-map in effect, and WIDTH is
- the width of one row in the image. */
+ SelectObject (bmpdc, prev);
+ DeleteDC (bmpdc);
+
+ return colors;
+}
+
+/* Put a pixel of COLOR at position X, Y in XIMG. XIMG must have been
+ created with CreateDIBSection, with the pointer to the bit values
+ stored in ximg->data. */
+
+static void XPutPixel (ximg, x, y, color)
+ XImage * ximg;
+ int x, y;
+ COLORREF color;
+{
+ int width = ximg->info.bmiHeader.biWidth;
+ int height = ximg->info.bmiHeader.biHeight;
+ unsigned char * pixel;
+
+ /* True color images. */
+ if (ximg->info.bmiHeader.biBitCount == 24)
+ {
+ int rowbytes = width * 3;
+ /* Ensure scanlines are aligned on 4 byte boundaries. */
+ if (rowbytes % 4)
+ rowbytes += 4 - (rowbytes % 4);
+
+ pixel = ximg->data + y * rowbytes + x * 3;
+ /* Windows bitmaps are in BGR order. */
+ *pixel = GetBValue (color);
+ *(pixel + 1) = GetGValue (color);
+ *(pixel + 2) = GetRValue (color);
+ }
+ /* Monochrome images. */
+ else if (ximg->info.bmiHeader.biBitCount == 1)
+ {
+ int rowbytes = width / 8;
+ /* Ensure scanlines are aligned on 4 byte boundaries. */
+ if (rowbytes % 4)
+ rowbytes += 4 - (rowbytes % 4);
+ pixel = ximg->data + y * rowbytes + x / 8;
+ /* Filter out palette info. */
+ if (color & 0x00ffffff)
+ *pixel = *pixel | (1 << x % 8);
+ else
+ *pixel = *pixel & ~(1 << x % 8);
+ }
+ else
+ image_error ("XPutPixel: palette image not supported.", Qnil, Qnil);
+}
+
+/* Create IMG->pixmap from an array COLORS of XColor structures, whose
+ RGB members are set. F is the frame on which this all happens.
+ COLORS will be freed; an existing IMG->pixmap will be freed, too. */
static void
-x_laplace_read_row (f, cmap, colors, width, ximg, y)
+x_from_xcolors (f, img, colors)
struct frame *f;
- Colormap cmap;
+ struct image *img;
XColor *colors;
- int width;
- XImage *ximg;
- int y;
{
- int x;
+ int x, y;
+ XImage *oimg;
+ Pixmap pixmap;
+ XColor *p;
+#if 0 /* TODO: color tables. */
+ init_color_table ();
+#endif
+ x_create_x_image_and_pixmap (f, img->width, img->height, 0,
+ &oimg, &pixmap);
+ p = colors;
+ for (y = 0; y < img->height; ++y)
+ for (x = 0; x < img->width; ++x, ++p)
+ {
+ unsigned long pixel;
+#if 0 /* TODO: color tables. */
+ pixel = lookup_rgb_color (f, p->red, p->green, p->blue);
+#else
+ pixel = PALETTERGB (p->red / 256, p->green / 256, p->blue / 256);
+#endif
+ XPutPixel (oimg, x, y, pixel);
+ }
- for (x = 0; x < width; ++x)
- colors[x].pixel = XGetPixel (ximg, x, y);
+ xfree (colors);
+ x_clear_image_1 (f, img, 1, 0, 1);
- XQueryColors (NULL, cmap, colors, width);
+ x_put_x_image (f, oimg, pixmap, img->width, img->height);
+ x_destroy_x_image (oimg);
+ img->pixmap = pixmap;
+#if 0 /* TODO: color tables. */
+ img->colors = colors_in_color_table (&img->ncolors);
+ free_color_table ();
+#endif
}
-/* Write row Y of image XIMG. PIXELS is an array of WIDTH longs
- containing the pixel colors to write. F is the frame we are
- working on. */
+/* On frame F, perform edge-detection on image IMG.
+
+ 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. */
static void
-x_laplace_write_row (f, pixels, width, ximg, y)
+x_detect_edges (f, img, matrix, color_adjust)
struct frame *f;
- long *pixels;
- int width;
- XImage *ximg;
- int y;
+ struct image *img;
+ int matrix[9], color_adjust;
+{
+ XColor *colors = x_to_xcolors (f, img, 1);
+ XColor *new, *p;
+ int x, y, i, sum;
+
+ for (i = sum = 0; i < 9; ++i)
+ sum += abs (matrix[i]);
+
+#define COLOR(A, X, Y) ((A) + (Y) * img->width + (X))
+
+ new = (XColor *) xmalloc (img->width * img->height * sizeof *new);
+
+ for (y = 0; y < img->height; ++y)
+ {
+ p = COLOR (new, 0, y);
+ p->red = p->green = p->blue = 0xffff/2;
+ 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);
+ p->red = p->green = p->blue = 0xffff/2;
+ p = COLOR (new, x, img->height - 1);
+ p->red = p->green = p->blue = 0xffff/2;
+ }
+
+ 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;
+
+ r = g = b = i = 0;
+ for (y1 = y - 1; y1 < y + 2; ++y1)
+ for (x1 = x - 1; x1 < x + 2; ++x1, ++i)
+ if (matrix[i])
+ {
+ XColor *t = COLOR (colors, x1, y1);
+ r += matrix[i] * t->red;
+ g += matrix[i] * t->green;
+ b += matrix[i] * t->blue;
+ }
+
+ r = (r / sum + color_adjust) & 0xffff;
+ g = (g / sum + color_adjust) & 0xffff;
+ b = (b / sum + color_adjust) & 0xffff;
+ p->red = p->green = p->blue = COLOR_INTENSITY (r, g, b);
+ }
+ }
+
+ xfree (colors);
+ x_from_xcolors (f, img, new);
+
+#undef COLOR
+}
+
+
+/* Perform the pre-defined `emboss' edge-detection on image IMG
+ on frame F. */
+
+static void
+x_emboss (f, img)
+ struct frame *f;
+ struct image *img;
{
- int x;
-
- for (x = 0; x < width; ++x)
- XPutPixel (ximg, x, y, pixels[x]);
+ x_detect_edges (f, img, emboss_matrix, 0xffff / 2);
}
-#endif
+
/* Transform image IMG which is used on frame F with a Laplace
edge-detection algorithm. The result is an image that can be used
struct frame *f;
struct image *img;
{
-#if 0 /* TODO : W32 version */
- Colormap cmap = DefaultColormapOfScreen (FRAME_X_SCREEN (f));
- XImage *ximg, *oimg;
- XColor *in[3];
- long *out;
- Pixmap pixmap;
- int x, y, i;
- long pixel;
- int in_y, out_y, rc;
- int mv2 = 45000;
+ x_detect_edges (f, img, laplace_matrix, 45000);
+}
- BLOCK_INPUT;
- /* Get the X image IMG->pixmap. */
- ximg = XGetImage (NULL, img->pixmap,
- 0, 0, img->width, img->height, ~0, ZPixmap);
+/* Perform edge-detection on image IMG on frame F, with specified
+ transformation matrix MATRIX and color-adjustment COLOR_ADJUST.
- /* Allocate 3 input rows, and one output row of colors. */
- for (i = 0; i < 3; ++i)
- in[i] = (XColor *) alloca (img->width * sizeof (XColor));
- out = (long *) alloca (img->width * sizeof (long));
+ MATRIX must be either
- /* Create an X image for output. */
- rc = x_create_x_image_and_pixmap (f, img->width, img->height, 0,
- &oimg, &pixmap);
+ - a list of at least 9 numbers in row-major form
+ - a vector of at least 9 numbers
- /* Fill first two rows. */
- x_laplace_read_row (f, cmap, in[0], img->width, ximg, 0);
- x_laplace_read_row (f, cmap, in[1], img->width, ximg, 1);
- in_y = 2;
+ COLOR_ADJUST nil means use a default; otherwise it must be a
+ number. */
- /* Write first row, all zeros. */
- init_color_table ();
- pixel = lookup_rgb_color (f, 0, 0, 0);
- for (x = 0; x < img->width; ++x)
- out[x] = pixel;
- x_laplace_write_row (f, out, img->width, oimg, 0);
- out_y = 1;
+static void
+x_edge_detection (f, img, matrix, color_adjust)
+ struct frame *f;
+ struct image *img;
+ Lisp_Object matrix, color_adjust;
+{
+ int i = 0;
+ int trans[9];
- for (y = 2; y < img->height; ++y)
+ if (CONSP (matrix))
{
- int rowa = y % 3;
- int rowb = (y + 2) % 3;
+ for (i = 0;
+ i < 9 && CONSP (matrix) && NUMBERP (XCAR (matrix));
+ ++i, matrix = XCDR (matrix))
+ trans[i] = XFLOATINT (XCAR (matrix));
+ }
+ else if (VECTORP (matrix) && ASIZE (matrix) >= 9)
+ {
+ for (i = 0; i < 9 && NUMBERP (AREF (matrix, i)); ++i)
+ trans[i] = XFLOATINT (AREF (matrix, i));
+ }
- x_laplace_read_row (f, cmap, in[rowa], img->width, ximg, in_y++);
+ if (NILP (color_adjust))
+ color_adjust = make_number (0xffff / 2);
- for (x = 0; x < img->width - 2; ++x)
+ if (i == 9 && NUMBERP (color_adjust))
+ x_detect_edges (f, img, trans, (int) XFLOATINT (color_adjust));
+}
+
+
+/* Transform image IMG on frame F so that it looks disabled. */
+
+static void
+x_disable_image (f, img)
+ struct frame *f;
+ struct image *img;
+{
+ struct w32_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
+
+ if (dpyinfo->n_planes * dpyinfo->n_cbits >= 2)
+ {
+ /* Color (or grayscale). Convert to gray, and equalize. Just
+ drawing such images with a stipple can look very odd, so
+ we're using this method instead. */
+ XColor *colors = x_to_xcolors (f, img, 1);
+ XColor *p, *end;
+ const int h = 15000;
+ const int l = 30000;
+
+ for (p = colors, end = colors + img->width * img->height;
+ p < end;
+ ++p)
{
- int r = in[rowa][x].red + mv2 - in[rowb][x + 2].red;
- int g = in[rowa][x].green + mv2 - in[rowb][x + 2].green;
- int b = in[rowa][x].blue + mv2 - in[rowb][x + 2].blue;
-
- out[x + 1] = lookup_rgb_color (f, r & 0xffff, g & 0xffff,
- b & 0xffff);
+ int i = COLOR_INTENSITY (p->red, p->green, p->blue);
+ int i2 = (0xffff - h - l) * i / 0xffff + l;
+ p->red = p->green = p->blue = i2;
}
- x_laplace_write_row (f, out, img->width, oimg, out_y++);
+ x_from_xcolors (f, img, colors);
}
- /* Write last line, all zeros. */
- for (x = 0; x < img->width; ++x)
- out[x] = pixel;
- x_laplace_write_row (f, out, img->width, oimg, out_y);
+ /* Draw a cross over the disabled image, if we must or if we
+ should. */
+ if (dpyinfo->n_planes * dpyinfo->n_cbits < 2 || cross_disabled_images)
+ {
+ HDC hdc, bmpdc;
+ HGDIOBJ prev;
- /* Free the input image, and free resources of IMG. */
- XDestroyImage (ximg);
- x_clear_image (f, img);
-
- /* Put the output image into pixmap, and destroy it. */
- x_put_x_image (f, oimg, pixmap, img->width, img->height);
- x_destroy_x_image (oimg);
+ hdc = get_frame_dc (f);
+ bmpdc = CreateCompatibleDC (hdc);
+ release_frame_dc (f, hdc);
- /* Remember new pixmap and colors in IMG. */
- img->pixmap = pixmap;
- img->colors = colors_in_color_table (&img->ncolors);
- free_color_table ();
+ prev = SelectObject (bmpdc, img->pixmap);
- UNBLOCK_INPUT;
-#endif /* TODO */
+ 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)
+ {
+ 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);
+ }
+ SelectObject (bmpdc, prev);
+ DeleteDC (bmpdc);
+ }
}
struct image *img;
Lisp_Object how;
{
-#if 0 /* TODO : W32 version */
- Display *dpy = FRAME_W32_DISPLAY (f);
- XImage *ximg, *mask_img;
- int x, y, rc, look_at_corners_p;
- unsigned long bg;
+ HDC img_dc, frame_dc;
+ HGDIOBJ prev;
+ char *mask_img;
+ int x, y, rc, use_img_background;
+ unsigned long bg = 0;
+ int row_width;
- BLOCK_INPUT;
-
- /* 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)
+ if (img->mask)
{
- UNBLOCK_INPUT;
- return 0;
+ DeleteObject (img->mask);
+ img->mask = NULL;
+ img->background_transparent_valid = 0;
}
- /* Get the X image of IMG->pixmap. */
- ximg = XGetImage (dpy, img->pixmap, 0, 0, img->width, img->height,
- ~0, ZPixmap);
+ /* 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);
+
+ /* 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 img_dc. If HOW is `(R G B)'
+ take that as color. Otherwise, use the image's background color. */
+ use_img_background = 1;
- /* Determine the background color of ximg. If HOW is `(R G B)'
- take that as color. Otherwise, try to determine the color
- heuristically. */
- look_at_corners_p = 1;
-
if (CONSP (how))
{
- int rgb[3], i = 0;
+ int rgb[3], i;
- while (i < 3
- && CONSP (how)
- && NATNUMP (XCAR (how)))
+ for (i = 0; i < 3 && CONSP (how) && NATNUMP (XCAR (how)); ++i)
{
rgb[i] = XFASTINT (XCAR (how)) & 0xffff;
how = XCDR (how);
if (i == 3 && NILP (how))
{
char color_name[30];
- XColor exact, color;
- Colormap cmap;
-
sprintf (color_name, "#%04x%04x%04x", rgb[0], rgb[1], rgb[2]);
-
- cmap = DefaultColormapOfScreen (FRAME_X_SCREEN (f));
- if (XLookupColor (dpy, cmap, color_name, &exact, &color))
- {
- bg = color.pixel;
- look_at_corners_p = 0;
- }
+ bg = x_alloc_image_color (f, img, build_string (color_name), 0)
+ & 0x00ffffff; /* Filter out palette info. */
+ use_img_background = 0;
}
}
-
- if (look_at_corners_p)
- {
- unsigned long corners[4];
- int i, best_count;
- /* Get the colors at the corners of ximg. */
- corners[0] = XGetPixel (ximg, 0, 0);
- corners[1] = XGetPixel (ximg, img->width - 1, 0);
- corners[2] = XGetPixel (ximg, img->width - 1, img->height - 1);
- corners[3] = XGetPixel (ximg, 0, img->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;
-
- if (n > best_count)
- bg = corners[i], best_count = n;
- }
- }
+ if (use_img_background)
+ 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. */
+ 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);
-
- UNBLOCK_INPUT;
-#endif /* TODO */
+ x_destroy_x_image ((XImage *)mask_img);
+ SelectObject (img_dc, prev);
+ DeleteDC (img_dc);
return 1;
}
-
\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));
PBM_RELIEF,
PBM_ALGORITHM,
PBM_HEURISTIC_MASK,
+ PBM_MASK,
+ PBM_FOREGROUND,
+ PBM_BACKGROUND,
PBM_LAST
};
{":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},
- {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE, 0}
+ {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
+ {":mask", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
+ {":foreground", IMAGE_STRING_OR_NIL_VALUE, 0},
+ {":background", IMAGE_STRING_OR_NIL_VALUE, 0}
};
/* Structure describing the image type `pbm'. */
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 = pbm_read_file (file, &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))
goto error;
- BLOCK_INPUT;
- if (!x_create_x_image_and_pixmap (f, width, height, 0,
- &ximg, &img->pixmap))
- {
- UNBLOCK_INPUT;
- goto error;
- }
-
+ if (!x_create_x_image_and_pixmap (f, width, height, 0, &ximg, &img->pixmap))
+ goto error;
+
+#if 0 /* TODO: color tables. */
/* Initialize the color hash table. */
init_color_table ();
+#endif
if (type == PBM_MONO)
{
int c = 0, g;
-
+ struct image_keyword fmt[PBM_LAST];
+ unsigned long fg = FRAME_FOREGROUND_PIXEL (f);
+ unsigned long bg = FRAME_BACKGROUND_PIXEL (f);
+
+ /* 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))
+ fg = x_alloc_image_color (f, img, fmt[PBM_FOREGROUND].value, fg);
+ if (fmt[PBM_BACKGROUND].count
+ && STRINGP (fmt[PBM_BACKGROUND].value))
+ {
+ bg = x_alloc_image_color (f, img, fmt[PBM_BACKGROUND].value, bg);
+ img->background = bg;
+ img->background_valid = 1;
+ }
+
for (y = 0; y < height; ++y)
for (x = 0; x < width; ++x)
{
else
g = pbm_scan_number (&p, end);
- XPutPixel (ximg, x, y, (g
- ? FRAME_FOREGROUND_PIXEL (f)
- : FRAME_BACKGROUND_PIXEL (f)));
+ XPutPixel (ximg, x, y, g ? fg : bg);
}
}
else
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)
{
- xfree (ximg->data);
- ximg->data = NULL;
- XDestroyImage (ximg);
- UNBLOCK_INPUT;
+ x_destroy_x_image (ximg);
image_error ("Invalid pixel value in image `%s'",
img->spec, Qnil);
goto error;
}
-
+
/* RGB values are now in the range 0..max_color_idx.
- Scale this to the range 0..0xffff supported by X. */
- r = (double) r * 65535 / max_color_idx;
- g = (double) g * 65535 / max_color_idx;
- b = (double) b * 65535 / max_color_idx;
- XPutPixel (ximg, x, y, lookup_rgb_color (f, r, g, b));
+ Scale this to the range 0..0xff supported by W32. */
+ r = (int) ((double) r * 255 / max_color_idx);
+ g = (int) ((double) g * 255 / max_color_idx);
+ b = (int) ((double) b * 255 / max_color_idx);
+ XPutPixel (ximg, x, y,
+#if 0 /* TODO: color tables. */
+ lookup_rgb_color (f, r, g, b));
+#else
+ PALETTERGB (r, g, b));
+#endif
}
}
-
+
+#if 0 /* TODO: color tables. */
/* Store in IMG->colors the colors allocated for the image, and
free the color table. */
img->colors = colors_in_color_table (&img->ncolors);
free_color_table ();
-
+#endif
+ /* 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);
- UNBLOCK_INPUT;
-
+
img->width = width;
img->height = height;
xfree (contents);
return 1;
}
-#endif /* HAVE_PBM */
\f
/***********************************************************************
PNG_RELIEF,
PNG_ALGORITHM,
PNG_HEURISTIC_MASK,
+ PNG_MASK,
+ PNG_BACKGROUND,
PNG_LAST
};
{":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},
- {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE, 0}
+ {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
+ {":mask", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
+ {":background", IMAGE_STRING_OR_NIL_VALUE, 0}
};
/* Structure describing the image type `png'. */
NULL
};
+/* PNG library details. */
+
+DEF_IMGLIB_FN (png_get_io_ptr);
+DEF_IMGLIB_FN (png_check_sig);
+DEF_IMGLIB_FN (png_create_read_struct);
+DEF_IMGLIB_FN (png_create_info_struct);
+DEF_IMGLIB_FN (png_destroy_read_struct);
+DEF_IMGLIB_FN (png_set_read_fn);
+DEF_IMGLIB_FN (png_init_io);
+DEF_IMGLIB_FN (png_set_sig_bytes);
+DEF_IMGLIB_FN (png_read_info);
+DEF_IMGLIB_FN (png_get_IHDR);
+DEF_IMGLIB_FN (png_get_valid);
+DEF_IMGLIB_FN (png_set_strip_16);
+DEF_IMGLIB_FN (png_set_expand);
+DEF_IMGLIB_FN (png_set_gray_to_rgb);
+DEF_IMGLIB_FN (png_set_background);
+DEF_IMGLIB_FN (png_get_bKGD);
+DEF_IMGLIB_FN (png_read_update_info);
+DEF_IMGLIB_FN (png_get_channels);
+DEF_IMGLIB_FN (png_get_rowbytes);
+DEF_IMGLIB_FN (png_read_image);
+DEF_IMGLIB_FN (png_read_end);
+DEF_IMGLIB_FN (png_error);
+
+static int
+init_png_functions (library)
+ HMODULE library;
+{
+ LOAD_IMGLIB_FN (library, png_get_io_ptr);
+ LOAD_IMGLIB_FN (library, png_check_sig);
+ LOAD_IMGLIB_FN (library, png_create_read_struct);
+ LOAD_IMGLIB_FN (library, png_create_info_struct);
+ LOAD_IMGLIB_FN (library, png_destroy_read_struct);
+ LOAD_IMGLIB_FN (library, png_set_read_fn);
+ LOAD_IMGLIB_FN (library, png_init_io);
+ LOAD_IMGLIB_FN (library, png_set_sig_bytes);
+ LOAD_IMGLIB_FN (library, png_read_info);
+ LOAD_IMGLIB_FN (library, png_get_IHDR);
+ LOAD_IMGLIB_FN (library, png_get_valid);
+ LOAD_IMGLIB_FN (library, png_set_strip_16);
+ LOAD_IMGLIB_FN (library, png_set_expand);
+ LOAD_IMGLIB_FN (library, png_set_gray_to_rgb);
+ LOAD_IMGLIB_FN (library, png_set_background);
+ LOAD_IMGLIB_FN (library, png_get_bKGD);
+ LOAD_IMGLIB_FN (library, png_read_update_info);
+ LOAD_IMGLIB_FN (library, png_get_channels);
+ LOAD_IMGLIB_FN (library, png_get_rowbytes);
+ LOAD_IMGLIB_FN (library, png_read_image);
+ LOAD_IMGLIB_FN (library, png_read_end);
+ LOAD_IMGLIB_FN (library, png_error);
+ return 1;
+}
/* Return non-zero if OBJECT is a valid PNG image specification. */
{
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. */
png_size_t length;
{
struct png_memory_storage *tbr
- = (struct png_memory_storage *) png_get_io_ptr (png_ptr);
+ = (struct png_memory_storage *) fn_png_get_io_ptr (png_ptr);
if (length > tbr->len - tbr->index)
- png_error (png_ptr, "Read error");
-
+ fn_png_error (png_ptr, "Read error");
+
bcopy (tbr->bytes + tbr->index, data, length);
tbr->index = tbr->index + length;
}
struct gcpro gcpro1;
png_struct *png_ptr = NULL;
png_info *info_ptr = NULL, *end_info = NULL;
- FILE *fp = NULL;
+ FILE *volatile fp = NULL;
png_byte sig[8];
- png_byte *pixels = NULL;
- png_byte **rows = NULL;
+ png_byte * volatile pixels = NULL;
+ png_byte ** volatile rows = NULL;
png_uint_32 width, height;
int bit_depth, color_type, interlace_type;
png_byte channels;
png_uint_32 row_bytes;
int transparent_p;
- char *gamma_str;
double screen_gamma, image_gamma;
int intent;
struct png_memory_storage tbr; /* Data to be read */
{
file = x_find_image_file (specified_file);
if (!STRINGP (file))
- {
- image_error ("Cannot find image file `%s'", specified_file, Qnil);
- UNGCPRO;
- return 0;
- }
+ {
+ image_error ("Cannot find image file `%s'", specified_file, Qnil);
+ UNGCPRO;
+ return 0;
+ }
/* 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);
- UNGCPRO;
- fclose (fp);
- return 0;
- }
+ {
+ image_error ("Cannot open image file `%s'", file, Qnil);
+ UNGCPRO;
+ fclose (fp);
+ return 0;
+ }
/* Check PNG signature. */
if (fread (sig, 1, sizeof sig, fp) != sizeof sig
- || !png_check_sig (sig, sizeof sig))
- {
- image_error ("Not a PNG file:` %s'", file, Qnil);
- UNGCPRO;
- fclose (fp);
- return 0;
- }
+ || !fn_png_check_sig (sig, sizeof sig))
+ {
+ image_error ("Not a PNG file: `%s'", file, Qnil);
+ UNGCPRO;
+ fclose (fp);
+ return 0;
+ }
}
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. */
if (tbr.len < sizeof sig
- || !png_check_sig (tbr.bytes, sizeof sig))
+ || !fn_png_check_sig (tbr.bytes, sizeof sig))
{
image_error ("Not a PNG image: `%s'", img->spec, Qnil);
UNGCPRO;
}
/* Initialize read and info structs for PNG lib. */
- png_ptr = png_create_read_struct (PNG_LIBPNG_VER_STRING, NULL,
- my_png_error, my_png_warning);
+ png_ptr = fn_png_create_read_struct (PNG_LIBPNG_VER_STRING, NULL,
+ my_png_error, my_png_warning);
if (!png_ptr)
{
if (fp) fclose (fp);
return 0;
}
- info_ptr = png_create_info_struct (png_ptr);
+ info_ptr = fn_png_create_info_struct (png_ptr);
if (!info_ptr)
{
- png_destroy_read_struct (&png_ptr, NULL, NULL);
+ fn_png_destroy_read_struct (&png_ptr, NULL, NULL);
if (fp) fclose (fp);
UNGCPRO;
return 0;
}
- end_info = png_create_info_struct (png_ptr);
+ end_info = fn_png_create_info_struct (png_ptr);
if (!end_info)
{
- png_destroy_read_struct (&png_ptr, &info_ptr, NULL);
+ fn_png_destroy_read_struct (&png_ptr, &info_ptr, NULL);
if (fp) fclose (fp);
UNGCPRO;
return 0;
{
error:
if (png_ptr)
- png_destroy_read_struct (&png_ptr, &info_ptr, &end_info);
+ fn_png_destroy_read_struct (&png_ptr, &info_ptr, &end_info);
xfree (pixels);
xfree (rows);
if (fp) fclose (fp);
/* Read image info. */
if (!NILP (specified_data))
- png_set_read_fn (png_ptr, (void *) &tbr, png_read_from_memory);
+ fn_png_set_read_fn (png_ptr, (void *) &tbr, png_read_from_memory);
else
- png_init_io (png_ptr, fp);
+ fn_png_init_io (png_ptr, fp);
- png_set_sig_bytes (png_ptr, sizeof sig);
- png_read_info (png_ptr, info_ptr);
- png_get_IHDR (png_ptr, info_ptr, &width, &height, &bit_depth, &color_type,
- &interlace_type, NULL, NULL);
+ fn_png_set_sig_bytes (png_ptr, sizeof sig);
+ fn_png_read_info (png_ptr, info_ptr);
+ fn_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))
+ if (fn_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. */
/* Strip more than 8 bits per channel. */
if (bit_depth == 16)
- png_set_strip_16 (png_ptr);
+ fn_png_set_strip_16 (png_ptr);
/* Expand data to 24 bit RGB, or 8 bit grayscale, with alpha channel
if available. */
- png_set_expand (png_ptr);
+ fn_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);
+ fn_png_set_gray_to_rgb (png_ptr);
- /* The value 2.2 is a guess for PC monitors from PNG example.c. */
- gamma_str = getenv ("SCREEN_GAMMA");
- screen_gamma = gamma_str ? atof (gamma_str) : 2.2;
+ screen_gamma = (f->gamma ? 1 / f->gamma / 0.45455 : 2.2);
+#if 0 /* Avoid double gamma correction for PNG images. */
/* Tell the PNG lib to handle gamma correction for us. */
-
#if defined(PNG_READ_sRGB_SUPPORTED) || defined(PNG_WRITE_sRGB_SUPPORTED)
if (png_get_sRGB (png_ptr, info_ptr, &intent))
- /* There is a special chunk in the image specifying the gamma. */
- png_set_sRGB (png_ptr, info_ptr, intent);
+ /* The libpng documentation says this is right in this case. */
+ png_set_gamma (png_ptr, screen_gamma, 0.45455);
else
#endif
if (png_get_gAMA (png_ptr, info_ptr, &image_gamma))
/* Image contains gamma information. */
png_set_gamma (png_ptr, screen_gamma, image_gamma);
else
- /* Use a default of 0.5 for the image gamma. */
- png_set_gamma (png_ptr, screen_gamma, 0.5);
+ /* Use the standard default for the image gamma. */
+ png_set_gamma (png_ptr, screen_gamma, 0.45455);
+#endif /* if 0 */
/* Handle alpha channel by combining the image with a background
color. Do this only if a real alpha channel is supplied. For
simple transparency, we prefer a clipping mask. */
if (!transparent_p)
{
- png_color_16 *image_background;
+ png_color_16 *image_bg;
+ Lisp_Object specified_bg
+ = image_spec_value (img->spec, QCbackground, NULL);
+
+ if (STRINGP (specified_bg))
+ /* The user specified `:background', use that. */
+ {
+ COLORREF color;
+ if (w32_defined_color (f, SDATA (specified_bg), &color, 0))
+ {
+ png_color_16 user_bg;
+
+ bzero (&user_bg, sizeof user_bg);
+ user_bg.red = 256 * GetRValue (color);
+ user_bg.green = 256 * GetGValue (color);
+ user_bg.blue = 256 * GetBValue (color);
- if (png_get_bKGD (png_ptr, info_ptr, &image_background))
- /* Image contains a background color with which to
+ fn_png_set_background (png_ptr, &user_bg,
+ PNG_BACKGROUND_GAMMA_SCREEN, 0, 1.0);
+ }
+ }
+ else if (fn_png_get_bKGD (png_ptr, info_ptr, &image_bg))
+ /* 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);
+ fn_png_set_background (png_ptr, image_bg,
+ 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;
+ COLORREF color;
png_color_16 frame_background;
+ color = FRAME_BACKGROUND_PIXEL (f);
+#if 0 /* TODO : Colormap support. */
+ Colormap cmap;
- BLOCK_INPUT;
- cmap = DefaultColormapOfScreen (FRAME_X_SCREEN (f));
- color.pixel = FRAME_BACKGROUND_PIXEL (f);
- XQueryColor (FRAME_W32_DISPLAY (f), cmap, &color);
- UNBLOCK_INPUT;
+ cmap = FRAME_X_COLORMAP (f);
+ x_query_color (f, &color);
+#endif
bzero (&frame_background, sizeof frame_background);
- frame_background.red = color.red;
- frame_background.green = color.green;
- frame_background.blue = color.blue;
+ frame_background.red = 256 * GetRValue (color);
+ frame_background.green = 256 * GetGValue (color);
+ frame_background.blue = 256 * GetBValue (color);
- png_set_background (png_ptr, &frame_background,
- PNG_BACKGROUND_GAMMA_SCREEN, 0, 1.0);
+ fn_png_set_background (png_ptr, &frame_background,
+ PNG_BACKGROUND_GAMMA_SCREEN, 0, 1.0);
}
}
/* Update info structure. */
- png_read_update_info (png_ptr, info_ptr);
+ fn_png_read_update_info (png_ptr, info_ptr);
/* Get number of channels. Valid values are 1 for grayscale images
and images with a palette, 2 for grayscale images with transparency
information (alpha channel), 3 for RGB images, and 4 for RGB
images with alpha channel, i.e. RGBA. If conversions above were
sufficient we should only have 3 or 4 channels here. */
- channels = png_get_channels (png_ptr, info_ptr);
+ channels = fn_png_get_channels (png_ptr, info_ptr);
xassert (channels == 3 || channels == 4);
/* Number of bytes needed for one row of the image. */
- row_bytes = png_get_rowbytes (png_ptr, info_ptr);
+ row_bytes = fn_png_get_rowbytes (png_ptr, info_ptr);
/* Allocate memory for the image. */
pixels = (png_byte *) xmalloc (row_bytes * height * sizeof *pixels);
rows[i] = pixels + i * row_bytes;
/* Read the entire image. */
- png_read_image (png_ptr, rows);
- png_read_end (png_ptr, info_ptr);
+ fn_png_read_image (png_ptr, rows);
+ fn_png_read_end (png_ptr, info_ptr);
if (fp)
{
fclose (fp);
fp = NULL;
}
- BLOCK_INPUT;
-
/* Create the X image and pixmap. */
if (!x_create_x_image_and_pixmap (f, width, height, 0, &ximg,
&img->pixmap))
- {
- UNBLOCK_INPUT;
- goto error;
- }
-
+ goto error;
+
/* Create an image and pixmap serving as mask if the PNG image
contains an alpha channel. */
if (channels == 4
&mask_img, &img->mask))
{
x_destroy_x_image (ximg);
- XFreePixmap (FRAME_W32_DISPLAY (f), img->pixmap);
+ DeleteObject (img->pixmap);
img->pixmap = 0;
- UNBLOCK_INPUT;
goto error;
}
-
/* Fill the X image and mask from PNG data. */
+#if 0 /* TODO: Color tables. */
init_color_table ();
+#endif
for (y = 0; y < height; ++y)
{
{
unsigned r, g, b;
- r = *p++ << 8;
- g = *p++ << 8;
- b = *p++ << 8;
+ r = *p++;
+ g = *p++;
+ b = *p++;
+#if 0 /* TODO: Color tables. */
XPutPixel (ximg, x, y, lookup_rgb_color (f, r, g, b));
-
+#else
+ XPutPixel (ximg, x, y, PALETTERGB (r, g, b));
+#endif
/* 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
}
}
+ if (NILP (image_spec_value (img->spec, QCbackground, NULL)))
+ /* Set IMG's background color from the PNG image, unless the user
+ overrode it. */
+ {
+ png_color_16 *bg;
+ if (fn_png_get_bKGD (png_ptr, info_ptr, &bg))
+ {
+#if 0 /* TODO: Color tables. */
+ img->background = lookup_rgb_color (f, bg->red, bg->green, bg->blue);
+#else
+ img->background = PALETTERGB (bg->red / 256, bg->green / 256,
+ bg->blue / 256);
+#endif
+ img->background_valid = 1;
+ }
+ }
+
+#if 0 /* TODO: Color tables. */
/* Remember colors allocated for this image. */
img->colors = colors_in_color_table (&img->ncolors);
free_color_table ();
+#endif
/* Clean up. */
- png_destroy_read_struct (&png_ptr, &info_ptr, &end_info);
+ fn_png_destroy_read_struct (&png_ptr, &info_ptr, &end_info);
xfree (rows);
xfree (pixels);
img->width = width;
img->height = height;
+ /* Maybe fill in the background field while we have ximg handy. */
+ IMAGE_BACKGROUND (img, f, ximg);
+
/* 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);
/* Same for the mask. */
if (mask_img)
{
+ /* Fill in the background_transparent field while we have the mask
+ handy. */
+ image_background_transparent (img, f, mask_img);
+
x_put_x_image (f, mask_img, img->mask, img->width, img->height);
x_destroy_x_image (mask_img);
}
- UNBLOCK_INPUT;
UNGCPRO;
return 1;
}
JPEG_RELIEF,
JPEG_ALGORITHM,
JPEG_HEURISTIC_MASK,
+ JPEG_MASK,
+ JPEG_BACKGROUND,
JPEG_LAST
};
{":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},
- {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE, 0}
+ {":conversions", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
+ {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
+ {":mask", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
+ {":background", IMAGE_STRING_OR_NIL_VALUE, 0}
};
/* Structure describing the image type `jpeg'. */
};
+/* JPEG library details. */
+DEF_IMGLIB_FN (jpeg_CreateDecompress);
+DEF_IMGLIB_FN (jpeg_start_decompress);
+DEF_IMGLIB_FN (jpeg_finish_decompress);
+DEF_IMGLIB_FN (jpeg_destroy_decompress);
+DEF_IMGLIB_FN (jpeg_read_header);
+DEF_IMGLIB_FN (jpeg_read_scanlines);
+DEF_IMGLIB_FN (jpeg_stdio_src);
+DEF_IMGLIB_FN (jpeg_std_error);
+DEF_IMGLIB_FN (jpeg_resync_to_restart);
+
+static int
+init_jpeg_functions (library)
+ HMODULE library;
+{
+ LOAD_IMGLIB_FN (library, jpeg_finish_decompress);
+ LOAD_IMGLIB_FN (library, jpeg_read_scanlines);
+ LOAD_IMGLIB_FN (library, jpeg_start_decompress);
+ LOAD_IMGLIB_FN (library, jpeg_read_header);
+ LOAD_IMGLIB_FN (library, jpeg_stdio_src);
+ LOAD_IMGLIB_FN (library, jpeg_CreateDecompress);
+ LOAD_IMGLIB_FN (library, jpeg_destroy_decompress);
+ LOAD_IMGLIB_FN (library, jpeg_std_error);
+ LOAD_IMGLIB_FN (library, jpeg_resync_to_restart);
+ return 1;
+}
+
+/* Wrapper since we can't directly assign the function pointer
+ to another function pointer that was declared more completely easily. */
+static boolean
+jpeg_resync_to_restart_wrapper(cinfo, desired)
+ j_decompress_ptr cinfo;
+ int desired;
+{
+ return fn_jpeg_resync_to_restart (cinfo, desired);
+}
+
+
/* Return non-zero if OBJECT is a valid JPEG image specification. */
static int
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. */
jmp_buf setjmp_buffer;
};
+
static void
my_error_exit (cinfo)
j_common_ptr cinfo;
longjmp (mgr->setjmp_buffer, 1);
}
+
/* Init source method for JPEG data source manager. Called by
jpeg_read_header() before any data is actually read. See
libjpeg.doc from the JPEG lib distribution. */
{
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;
src->skip_input_data = our_skip_input_data;
- src->resync_to_restart = jpeg_resync_to_restart; /* Use default method. */
+ src->resync_to_restart = jpeg_resync_to_restart_wrapper; /* Use default method. */
src->term_source = our_term_source;
src->bytes_in_buffer = len;
src->next_input_byte = data;
/* 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;
struct my_jpeg_error_mgr mgr;
Lisp_Object file, specified_file;
Lisp_Object specified_data;
- FILE *fp = NULL;
+ FILE * volatile fp = NULL;
JSAMPARRAY buffer;
int row_stride, x, y;
XImage *ximg = NULL;
{
file = x_find_image_file (specified_file);
if (!STRINGP (file))
- {
- image_error ("Cannot find image file `%s'", specified_file, Qnil);
- UNGCPRO;
- return 0;
- }
-
- fp = fopen (XSTRING (file)->data, "r");
+ {
+ image_error ("Cannot find image file `%s'", specified_file, Qnil);
+ UNGCPRO;
+ return 0;
+ }
+
+ fp = fopen (SDATA (file), "r");
if (fp == NULL)
- {
- image_error ("Cannot open `%s'", file, Qnil);
- UNGCPRO;
- return 0;
- }
+ {
+ image_error ("Cannot open `%s'", file, Qnil);
+ UNGCPRO;
+ return 0;
+ }
}
-
+
/* Customize libjpeg's error handling to call my_error_exit when an
- error is detected. This function will perform a longjmp. */
+ error is detected. This function will perform a longjmp. */
+ cinfo.err = fn_jpeg_std_error (&mgr.pub);
mgr.pub.error_exit = my_error_exit;
- cinfo.err = jpeg_std_error (&mgr.pub);
-
+
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);
+ fclose ((FILE *) fp);
+ fn_jpeg_destroy_decompress (&cinfo);
- BLOCK_INPUT;
-
/* If we already have an XImage, free that. */
x_destroy_x_image (ximg);
/* Free pixmap and colors. */
x_clear_image (f, img);
-
- UNBLOCK_INPUT;
+
UNGCPRO;
return 0;
}
/* Create the JPEG decompression object. Let it read from fp.
- Read the JPEG image header. */
- jpeg_create_decompress (&cinfo);
+ Read the JPEG image header. */
+ fn_jpeg_CreateDecompress (&cinfo, JPEG_LIB_VERSION, sizeof (cinfo));
if (NILP (specified_data))
- jpeg_stdio_src (&cinfo, fp);
+ fn_jpeg_stdio_src (&cinfo, (FILE *) 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);
+ fn_jpeg_read_header (&cinfo, TRUE);
/* Customize decompression so that color quantization will be used.
- Start decompression. */
+ Start decompression. */
cinfo.quantize_colors = TRUE;
- jpeg_start_decompress (&cinfo);
+ fn_jpeg_start_decompress (&cinfo);
width = img->width = cinfo.output_width;
height = img->height = cinfo.output_height;
- BLOCK_INPUT;
-
/* Create X image and pixmap. */
- if (!x_create_x_image_and_pixmap (f, width, height, 0, &ximg,
- &img->pixmap))
- {
- UNBLOCK_INPUT;
- longjmp (mgr.setjmp_buffer, 2);
- }
+ if (!x_create_x_image_and_pixmap (f, width, height, 0, &ximg, &img->pixmap))
+ longjmp (mgr.setjmp_buffer, 2);
/* Allocate colors. When color quantization is used,
cinfo.actual_number_of_colors has been set with the number of
else
ir = 0, ig = 0, ib = 0;
+#if 0 /* TODO: Color tables. */
/* Use the color table mechanism because it handles colors that
cannot be allocated nicely. Such colors will be replaced with
a default color, and we don't have to care about which colors
can be freed safely, and which can't. */
init_color_table ();
+#endif
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
- in the range 0..0xffff. */
- int r = cinfo.colormap[ir][i] << 8;
- int g = cinfo.colormap[ig][i] << 8;
- int b = cinfo.colormap[ib][i] << 8;
+ int r = cinfo.colormap[ir][i];
+ int g = cinfo.colormap[ig][i];
+ int b = cinfo.colormap[ib][i];
+#if 0 /* TODO: Color tables. */
colors[i] = lookup_rgb_color (f, r, g, b);
+#else
+ colors[i] = PALETTERGB (r, g, b);
+#endif
}
+#if 0 /* TODO: Color tables. */
/* Remember those colors actually allocated. */
img->colors = colors_in_color_table (&img->ncolors);
free_color_table ();
+#endif
}
/* Read pixels. */
row_stride, 1);
for (y = 0; y < height; ++y)
{
- jpeg_read_scanlines (&cinfo, buffer, 1);
+ fn_jpeg_read_scanlines (&cinfo, buffer, 1);
for (x = 0; x < cinfo.output_width; ++x)
XPutPixel (ximg, x, y, colors[buffer[0][x]]);
}
/* Clean up. */
- jpeg_finish_decompress (&cinfo);
- jpeg_destroy_decompress (&cinfo);
+ fn_jpeg_finish_decompress (&cinfo);
+ fn_jpeg_destroy_decompress (&cinfo);
if (fp)
- fclose (fp);
-
+ fclose ((FILE *) 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);
- UNBLOCK_INPUT;
UNGCPRO;
return 1;
}
TIFF_RELIEF,
TIFF_ALGORITHM,
TIFF_HEURISTIC_MASK,
+ TIFF_MASK,
+ TIFF_BACKGROUND,
TIFF_LAST
};
{":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},
- {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE, 0}
+ {":conversions", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
+ {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
+ {":mask", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
+ {":background", IMAGE_STRING_OR_NIL_VALUE, 0}
};
/* Structure describing the image type `tiff'. */
NULL
};
+/* TIFF library details. */
+DEF_IMGLIB_FN (TIFFSetErrorHandler);
+DEF_IMGLIB_FN (TIFFSetWarningHandler);
+DEF_IMGLIB_FN (TIFFOpen);
+DEF_IMGLIB_FN (TIFFClientOpen);
+DEF_IMGLIB_FN (TIFFGetField);
+DEF_IMGLIB_FN (TIFFReadRGBAImage);
+DEF_IMGLIB_FN (TIFFClose);
+
+static int
+init_tiff_functions (library)
+ HMODULE library;
+{
+ LOAD_IMGLIB_FN (library, TIFFSetErrorHandler);
+ LOAD_IMGLIB_FN (library, TIFFSetWarningHandler);
+ LOAD_IMGLIB_FN (library, TIFFOpen);
+ LOAD_IMGLIB_FN (library, TIFFClientOpen);
+ LOAD_IMGLIB_FN (library, TIFFGetField);
+ LOAD_IMGLIB_FN (library, TIFFReadRGBAImage);
+ LOAD_IMGLIB_FN (library, TIFFClose);
+ return 1;
+}
/* Return non-zero if OBJECT is a valid TIFF image specification. */
{
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;
}
return ((tiff_memory_source *) data)->len;
}
+
+static void
+tiff_error_handler (title, format, ap)
+ const char *title, *format;
+ va_list ap;
+{
+ char buf[512];
+ int len;
+
+ len = sprintf (buf, "TIFF error: %s ", title);
+ vsprintf (buf + len, format, ap);
+ add_to_log (buf, Qnil, Qnil);
+}
+
+
+static void
+tiff_warning_handler (title, format, ap)
+ const char *title, *format;
+ va_list ap;
+{
+ char buf[512];
+ int len;
+
+ len = sprintf (buf, "TIFF warning: %s ", title);
+ vsprintf (buf + len, format, ap);
+ add_to_log (buf, Qnil, Qnil);
+}
+
+
/* Load TIFF image IMG for use on frame F. Value is non-zero if
successful. */
file = Qnil;
GCPRO1 (file);
+ fn_TIFFSetErrorHandler (tiff_error_handler);
+ fn_TIFFSetWarningHandler (tiff_warning_handler);
+
if (NILP (specified_data))
{
/* Read from a file */
file = x_find_image_file (specified_file);
if (!STRINGP (file))
- {
- image_error ("Cannot find image file `%s'", file, Qnil);
- UNGCPRO;
- return 0;
- }
-
+ {
+ image_error ("Cannot find image file `%s'", file, Qnil);
+ UNGCPRO;
+ return 0;
+ }
+
/* Try to open the image file. */
- tiff = TIFFOpen (XSTRING (file)->data, "r");
+ tiff = fn_TIFFOpen (SDATA (file), "r");
if (tiff == NULL)
- {
- image_error ("Cannot open `%s'", file, Qnil);
- UNGCPRO;
- return 0;
- }
+ {
+ image_error ("Cannot open `%s'", file, Qnil);
+ UNGCPRO;
+ return 0;
+ }
}
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,
- (TIFFReadWriteProc) tiff_read_from_memory,
- (TIFFReadWriteProc) tiff_write_from_memory,
- tiff_seek_in_memory,
- tiff_close_memory,
- tiff_size_of_memory,
- tiff_mmap_memory,
- tiff_unmap_memory);
+ tiff = fn_TIFFClientOpen ("memory_source", "r", &memsrc,
+ (TIFFReadWriteProc) tiff_read_from_memory,
+ (TIFFReadWriteProc) tiff_write_from_memory,
+ tiff_seek_in_memory,
+ tiff_close_memory,
+ tiff_size_of_memory,
+ tiff_mmap_memory,
+ tiff_unmap_memory);
if (!tiff)
{
/* Get width and height of the image, and allocate a raster buffer
of width x height 32-bit values. */
- TIFFGetField (tiff, TIFFTAG_IMAGEWIDTH, &width);
- TIFFGetField (tiff, TIFFTAG_IMAGELENGTH, &height);
+ fn_TIFFGetField (tiff, TIFFTAG_IMAGEWIDTH, &width);
+ fn_TIFFGetField (tiff, TIFFTAG_IMAGELENGTH, &height);
buf = (uint32 *) xmalloc (width * height * sizeof *buf);
-
- rc = TIFFReadRGBAImage (tiff, width, height, buf, 0);
- TIFFClose (tiff);
+
+ rc = fn_TIFFReadRGBAImage (tiff, width, height, buf, 0);
+ fn_TIFFClose (tiff);
if (!rc)
{
image_error ("Error reading TIFF image `%s'", img->spec, Qnil);
return 0;
}
- BLOCK_INPUT;
-
/* Create the X image and pixmap. */
if (!x_create_x_image_and_pixmap (f, width, height, 0, &ximg, &img->pixmap))
{
- UNBLOCK_INPUT;
xfree (buf);
UNGCPRO;
return 0;
}
+#if 0 /* TODO: Color tables. */
/* Initialize the color table. */
init_color_table ();
+#endif
/* Process the pixel raster. Origin is in the lower-left corner. */
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));
+ int r = TIFFGetR (abgr);
+ int g = TIFFGetG (abgr);
+ int b = TIFFGetB (abgr);
+#if 0 /* TODO: Color tables. */
+ XPutPixel (ximg, x, height - 1 - y, lookup_rgb_color (f, r, g, b));
+#else
+ XPutPixel (ximg, x, height - 1 - y, PALETTERGB (r, g, b));
+#endif
}
}
+#if 0 /* TODO: Color tables. */
/* Remember the colors allocated for the image. Free the color table. */
img->colors = colors_in_color_table (&img->ncolors);
free_color_table ();
+#endif
+
+ img->width = width;
+ img->height = height;
+
+ /* 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, then free the X image and its buffer. */
x_put_x_image (f, ximg, img->pixmap, width, height);
x_destroy_x_image (ximg);
xfree (buf);
- UNBLOCK_INPUT;
-
- img->width = width;
- img->height = height;
UNGCPRO;
return 1;
#if HAVE_GIF
+#define DrawText gif_DrawText
#include <gif_lib.h>
+#undef DrawText
static int gif_image_p P_ ((Lisp_Object object));
static int gif_load P_ ((struct frame *f, struct image *img));
GIF_RELIEF,
GIF_ALGORITHM,
GIF_HEURISTIC_MASK,
+ GIF_MASK,
GIF_IMAGE,
+ GIF_BACKGROUND,
GIF_LAST
};
{":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},
{":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
- {":image", IMAGE_NON_NEGATIVE_INTEGER_VALUE, 0}
+ {":mask", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
+ {":image", IMAGE_NON_NEGATIVE_INTEGER_VALUE, 0},
+ {":background", IMAGE_STRING_OR_NIL_VALUE, 0}
};
/* Structure describing the image type `gif'. */
NULL
};
+
+/* GIF library details. */
+DEF_IMGLIB_FN (DGifCloseFile);
+DEF_IMGLIB_FN (DGifSlurp);
+DEF_IMGLIB_FN (DGifOpen);
+DEF_IMGLIB_FN (DGifOpenFileName);
+
+static int
+init_gif_functions (library)
+ HMODULE library;
+{
+ LOAD_IMGLIB_FN (library, DGifCloseFile);
+ LOAD_IMGLIB_FN (library, DGifSlurp);
+ LOAD_IMGLIB_FN (library, DGifOpen);
+ LOAD_IMGLIB_FN (library, DGifOpenFileName);
+ return 1;
+}
+
+
/* Return non-zero if OBJECT is a valid GIF image specification. */
static int
{
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 = fn_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);
+ gif = fn_DGifOpen(&memsrc, gif_read_from_memory);
if (!gif)
{
image_error ("Cannot open memory source `%s'", img->spec, Qnil);
}
/* Read entire contents. */
- rc = DGifSlurp (gif);
+ rc = fn_DGifSlurp (gif);
if (rc == GIF_ERROR)
{
image_error ("Error reading `%s'", img->spec, Qnil);
- DGifCloseFile (gif);
+ fn_DGifCloseFile (gif);
UNGCPRO;
return 0;
}
{
image_error ("Invalid image number `%s' in image `%s'",
image, img->spec);
- DGifCloseFile (gif);
+ fn_DGifCloseFile (gif);
UNGCPRO;
return 0;
}
- width = img->width = gif->SWidth;
- height = img->height = gif->SHeight;
-
- BLOCK_INPUT;
+ width = img->width = max (gif->SWidth, gif->Image.Left + gif->Image.Width);
+ height = img->height = max (gif->SHeight, gif->Image.Top + gif->Image.Height);
/* Create the X image and pixmap. */
if (!x_create_x_image_and_pixmap (f, width, height, 0, &ximg, &img->pixmap))
{
- UNBLOCK_INPUT;
- DGifCloseFile (gif);
+ fn_DGifCloseFile (gif);
UNGCPRO;
return 0;
}
-
+
/* Allocate colors. */
gif_color_map = gif->SavedImages[ino].ImageDesc.ColorMap;
if (!gif_color_map)
gif_color_map = gif->SColorMap;
+#if 0 /* TODO: Color tables */
init_color_table ();
+#endif
bzero (pixel_colors, sizeof pixel_colors);
-
+
for (i = 0; i < gif_color_map->ColorCount; ++i)
{
- int r = gif_color_map->Colors[i].Red << 8;
- int g = gif_color_map->Colors[i].Green << 8;
- int b = gif_color_map->Colors[i].Blue << 8;
+ int r = gif_color_map->Colors[i].Red;
+ int g = gif_color_map->Colors[i].Green;
+ int b = gif_color_map->Colors[i].Blue;
+#if 0 /* TODO: Color tables */
pixel_colors[i] = lookup_rgb_color (f, r, g, b);
+#else
+ pixel_colors[i] = PALETTERGB (r, g, b);
+#endif
}
+#if 0 /* TODO: Color tables */
img->colors = colors_in_color_table (&img->ncolors);
free_color_table ();
+#endif
/* 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. */
{
static int interlace_start[] = {0, 4, 2, 1};
static int interlace_increment[] = {8, 8, 4, 2};
- int pass, inc;
+ int pass;
int row = interlace_start[0];
pass = 0;
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);
-
+
+ fn_DGifCloseFile (gif);
+
+ /* 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, then free the X image and its buffer. */
x_put_x_image (f, ximg, img->pixmap, width, height);
x_destroy_x_image (ximg);
- UNBLOCK_INPUT;
-
+
UNGCPRO;
return 1;
}
Ghostscript
***********************************************************************/
+Lisp_Object Qpostscript;
+
+/* Keyword symbols. */
+
+Lisp_Object QCloader, QCbounding_box, QCpt_width, QCpt_height;
+
#ifdef HAVE_GHOSTSCRIPT
static int gs_image_p P_ ((Lisp_Object object));
static int gs_load P_ ((struct frame *f, struct image *img));
/* The symbol `postscript' identifying images of this type. */
-Lisp_Object Qpostscript;
-
/* Keyword symbols. */
Lisp_Object QCloader, QCbounding_box, QCpt_width, QCpt_height;
GS_RELIEF,
GS_ALGORITHM,
GS_HEURISTIC_MASK,
+ GS_MASK,
+ GS_BACKGROUND,
GS_LAST
};
{":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},
- {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE, 0}
+ {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
+ {":mask", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
+ {":background", IMAGE_STRING_OR_NIL_VALUE, 0}
};
/* Structure describing the image type `ghostscript'. */
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. */
xassert (img->pixmap == 0);
img->pixmap = XCreatePixmap (FRAME_W32_DISPLAY (f), FRAME_W32_WINDOW (f),
img->width, img->height,
- DefaultDepthOfScreen (FRAME_X_SCREEN (f)));
+ one_w32_display_info.n_cbits);
UNBLOCK_INPUT;
if (!img->pixmap)
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 (c->images[i]->pixmap == pixmap)
break;
+ /* Should someone in between have cleared the image cache, for
+ instance, give up. */
+ if (i == c->used)
+ return;
+
/* Kill the GS process. We should have found PIXMAP in the image
cache and its image should contain a process object. */
- xassert (i < c->used);
img = c->images[i];
xassert (PROCESSP (img->data.lisp_val));
Fkill_process (img->data.lisp_val, Qnil);
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. */
allocated colors on behalf of us. So, to get the
reference counts right, free them once. */
if (img->ncolors)
- {
- Colormap cmap = DefaultColormapOfScreen (FRAME_X_SCREEN (f));
- XFreeColors (FRAME_W32_DISPLAY (f), cmap,
+ x_free_colors (FRAME_W32_DISPLAY (f), cmap,
img->colors, img->ncolors, 0);
- }
#endif
}
else
image_error ("Cannot get X image of `%s'; colors will not be freed",
img->spec, Qnil);
-
+
UNBLOCK_INPUT;
}
+
+ /* Now that we have the pixmap, compute mask and transform the
+ image if requested. */
+ BLOCK_INPUT;
+ postprocess_image (f, img);
+ UNBLOCK_INPUT;
}
#endif /* HAVE_GHOSTSCRIPT */
DEFUN ("x-change-window-property", Fx_change_window_property,
Sx_change_window_property, 2, 3, 0,
- "Change window property PROP to VALUE on the X window of FRAME.\n\
-PROP and VALUE must be strings. FRAME nil or omitted means use the\n\
-selected frame. Value is VALUE.")
+ doc: /* Change window property PROP to VALUE on the X window of FRAME.
+PROP and VALUE must be strings. FRAME nil or omitted means use the
+selected frame. Value is VALUE. */)
(prop, value, frame)
Lisp_Object frame, prop, value;
{
struct frame *f = check_x_frame (frame);
Atom prop_atom;
- CHECK_STRING (prop, 1);
- CHECK_STRING (value, 2);
+ CHECK_STRING (prop);
+ 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));
DEFUN ("x-delete-window-property", Fx_delete_window_property,
Sx_delete_window_property, 1, 2, 0,
- "Remove window property PROP from X window of FRAME.\n\
-FRAME nil or omitted means use the selected frame. Value is PROP.")
+ doc: /* Remove window property PROP from X window of FRAME.
+FRAME nil or omitted means use the selected frame. Value is PROP. */)
(prop, frame)
Lisp_Object prop, frame;
{
struct frame *f = check_x_frame (frame);
Atom prop_atom;
- CHECK_STRING (prop, 1);
+ 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. */
DEFUN ("x-window-property", Fx_window_property, Sx_window_property,
1, 2, 0,
- "Value is the value of window property PROP on FRAME.\n\
-If FRAME is nil or omitted, use the selected frame. Value is nil\n\
-if FRAME hasn't a property with name PROP or if PROP has no string\n\
-value.")
+ doc: /* Value is the value of window property PROP on FRAME.
+If FRAME is nil or omitted, use the selected frame. Value is nil
+if FRAME hasn't a property with name PROP or if PROP has no string
+value. */)
(prop, frame)
Lisp_Object prop, frame;
{
int actual_format;
unsigned long actual_size, bytes_remaining;
- CHECK_STRING (prop, 1);
+ 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)
***********************************************************************/
static Lisp_Object x_create_tip_frame P_ ((struct w32_display_info *,
- Lisp_Object));
-
-/* The frame of a currently visible tooltip, or null. */
+ 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;
Lisp_Object tip_timer;
Window tip_window;
+/* If non-nil, a vector of 3 elements containing the last args
+ with which x-show-tip was called. See there. */
+
+Lisp_Object last_show_tip_args;
+
+/* Maximum size for tooltips; a cons (COLUMNS . ROWS). */
+
+Lisp_Object Vx_max_tooltip_size;
+
+
static Lisp_Object
unwind_create_tip_frame (frame)
Lisp_Object frame;
tip_window = NULL;
tip_frame = Qnil;
}
-
+
return deleted;
}
/* Create a frame for a tooltip on the display described by DPYINFO.
- PARMS is a list of frame parameters. Value is the frame.
+ PARMS is a list of frame parameters. TEXT is the string to
+ display in the tip frame. Value is the frame.
Note that functions called here, esp. x_default_parameter can
signal errors, for instance when a specified color name is
when this happens. */
static Lisp_Object
-x_create_tip_frame (dpyinfo, parms)
+x_create_tip_frame (dpyinfo, parms, text)
struct w32_display_info *dpyinfo;
- Lisp_Object parms;
+ Lisp_Object parms, text;
{
-#if 0 /* TODO : w32 version */
struct frame *f;
Lisp_Object frame, tem;
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;
+ Lisp_Object buffer;
+ struct buffer *old_buffer;
- check_x ();
+ check_w32 ();
/* Use this general default value to start with until we know if
this frame has a specified name. */
frame = Qnil;
GCPRO3 (parms, name, frame);
- f = make_frame (1);
+ /* Make a frame without minibuffer nor mode-line. */
+ f = make_frame (0);
+ f->wants_modeline = 0;
XSETFRAME (frame, f);
+
+ buffer = Fget_buffer_create (build_string (" *tip*"));
+ Fset_window_buffer (FRAME_ROOT_WINDOW (f), buffer);
+ old_buffer = current_buffer;
+ set_buffer_internal_1 (XBUFFER (buffer));
+ current_buffer->truncate_lines = Qnil;
+ 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);
+ /* By setting the output method, we're essentially saying that
+ the frame is live, as per FRAME_LIVE_P. If we get a signal
+ from this point on, x_destroy_window might screw up reference
+ counts etc. */
f->output_method = output_w32;
f->output_data.w32 =
(struct w32_output *) xmalloc (sizeof (struct w32_output));
bzero (f->output_data.w32, sizeof (struct w32_output));
-#if 0
- f->output_data.w32->icon_bitmap = -1;
-#endif
- f->output_data.w32->fontset = -1;
+
+ FRAME_FONTSET (f) = -1;
f->icon_name = Qnil;
-#ifdef GLYPH_DEBUG
+#if 0 /* GLYPH_DEBUG TODO: image support. */
image_cache_refcount = FRAME_X_IMAGE_CACHE (f)->refcount;
dpyinfo_refcount = dpyinfo->reference_count;
#endif /* GLYPH_DEBUG */
be set. */
if (EQ (name, Qunbound) || NILP (name))
{
- f->name = build_string (dpyinfo->x_id_name);
+ f->name = build_string (dpyinfo->w32_id_name);
f->explicit_name = 0;
}
else
{
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-*-*-*-*-iso8859-1");
- if (!STRINGP (font))
- font = x_new_font (f, "-misc-fixed-medium-r-normal-*-*-140-*-*-c-*-iso8859-1");
- if (! STRINGP (font))
- font = x_new_font (f, "-*-*-medium-r-normal-*-*-140-*-*-c-*-iso8859-1");
+ font = x_new_font (f, "-*-Courier New-normal-r-*-*-*-100-*-*-c-*-iso8859-1");
if (! STRINGP (font))
- /* This was formerly the first thing tried, but it finds too many fonts
- and takes too long. */
- font = x_new_font (f, "-*-*-medium-r-*-*-*-*-*-*-c-*-iso8859-1");
+ font = x_new_font (f, "-*-Courier-normal-r-*-*-13-*-*-*-c-*-iso8859-1");
/* If those didn't work, look for something which will at least work. */
if (! STRINGP (font))
- font = x_new_font (f, "-*-fixed-*-*-*-*-*-140-*-*-c-*-iso8859-1");
+ font = x_new_font (f, "-*-Fixedsys-normal-r-*-*-12-*-*-*-c-*-iso8859-1");
UNBLOCK_INPUT;
if (! STRINGP (font))
- font = build_string ("fixed");
+ font = build_string ("Fixedsys");
x_default_parameter (f, parms, Qfont, font,
"font", "Font", RES_TYPE_STRING);
x_default_parameter (f, parms, Qborder_width, make_number (2),
"borderWidth", "BorderWidth", RES_TYPE_NUMBER);
-
/* This defaults to 2 in order to match xterm. We recognize either
internalBorderWidth or internalBorder (which is what xterm calls
it). */
parms = Fcons (Fcons (Qinternal_border_width, value),
parms);
}
-
x_default_parameter (f, parms, Qinternal_border_width, make_number (1),
"internalBorderWidth", "internalBorderWidth",
RES_TYPE_NUMBER);
end up in init_iterator with a null face cache, which should not
happen. */
init_frame_faces (f);
-
+
+ f->output_data.w32->dwStyle = WS_BORDER | WS_POPUP | WS_DISABLED;
f->output_data.w32->parent_desc = FRAME_W32_DISPLAY_INFO (f)->root_window;
+
window_prompting = x_figure_window_size (f, parms);
+ /* No fringes on tip frame. */
+ f->output_data.w32->fringes_extra = 0;
+ f->output_data.w32->fringe_cols = 0;
+ f->output_data.w32->left_fringe_width = 0;
+ f->output_data.w32->right_fringe_width = 0;
+
if (window_prompting & XNegative)
{
if (window_prompting & YNegative)
}
f->output_data.w32->size_hint_flags = window_prompting;
- {
- XSetWindowAttributes attrs;
- unsigned long mask;
-
- BLOCK_INPUT;
- mask = CWBackPixel | CWOverrideRedirect | CWSaveUnder | CWEventMask;
- /* Window managers looks at the override-redirect flag to
- determine whether or net to give windows a decoration (Xlib
- 3.2.8). */
- attrs.override_redirect = True;
- attrs.save_under = True;
- attrs.background_pixel = FRAME_BACKGROUND_PIXEL (f);
- /* Arrange for getting MapNotify and UnmapNotify events. */
- attrs.event_mask = StructureNotifyMask;
- tip_window
- = FRAME_W32_WINDOW (f)
- = XCreateWindow (FRAME_W32_DISPLAY (f),
- FRAME_W32_DISPLAY_INFO (f)->root_window,
- /* x, y, width, height */
- 0, 0, 1, 1,
- /* Border. */
- 1,
- CopyFromParent, InputOutput, CopyFromParent,
- mask, &attrs);
- UNBLOCK_INPUT;
- }
+
+ BLOCK_INPUT;
+ my_create_tip_window (f);
+ UNBLOCK_INPUT;
x_make_gc (f);
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.
+
+ Frame parameters may be changed if .Xdefaults contains
+ specifications for the default font. For example, if there is an
+ `Emacs.default.attributeBackground: pink', the `background-color'
+ attribute of the frame get's set, which let's the internal border
+ of the tooltip frame appear in pink. Prevent this. */
+ {
+ Lisp_Object bg = Fframe_parameter (frame, Qbackground_color);
+
+ /* 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;
below. And the frame needs to be on Vframe_list or making it
visible won't work. */
Vframe_list = Fcons (frame, Vframe_list);
- tip_frame = frame;
/* Now that the frame is official, it counts as a reference to
its display. */
FRAME_W32_DISPLAY_INFO (f)->reference_count++;
+ /* Setting attributes of faces of the tooltip frame from resources
+ and similar will increment face_change_count, which leads to the
+ clearing of all current matrices. Since this isn't necessary
+ here, avoid it by resetting face_change_count to the value it
+ had before we created the tip frame. */
+ face_change_count = face_change_count_before;
+
+ /* Discard the unwind_protect. */
return unbind_to (count, frame);
-#endif /* TODO */
- return Qnil;
}
-#ifdef TODO /* Tooltip support not complete. */
+
+/* Compute where to display tip frame F. PARMS is the list of frame
+ parameters for F. DX and DY are specified offsets from the current
+ location of the mouse. WIDTH and HEIGHT are the width and height
+ of the tooltip. Return coordinates relative to the root window of
+ the display in *ROOT_X, and *ROOT_Y. */
+
+static void
+compute_tip_xy (f, parms, dx, dy, width, height, root_x, root_y)
+ struct frame *f;
+ Lisp_Object parms, dx, dy;
+ int width, height;
+ 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))
+ {
+ POINT pt;
+
+ BLOCK_INPUT;
+ GetCursorPos (&pt);
+ *root_x = pt.x;
+ *root_y = pt.y;
+ UNBLOCK_INPUT;
+ }
+
+ if (INTEGERP (top))
+ *root_y = XINT (top);
+ else if (*root_y + XINT (dy) - height < 0)
+ *root_y -= XINT (dy);
+ else
+ {
+ *root_y -= height;
+ *root_y += XINT (dy);
+ }
+
+ if (INTEGERP (left))
+ *root_x = XINT (left);
+ else if (*root_x + XINT (dx) + width <= FRAME_W32_DISPLAY_INFO (f)->width)
+ /* It fits to the right of the pointer. */
+ *root_x += XINT (dx);
+ else if (width + XINT (dx) <= *root_x)
+ /* It fits to the left of the pointer. */
+ *root_x -= width + XINT (dx);
+ else
+ /* Put it left justified on the screen -- it ought to fit that way. */
+ *root_x = 0;
+}
+
+
DEFUN ("x-show-tip", Fx_show_tip, Sx_show_tip, 1, 6, 0,
- "Show STRING in a \"tooltip\" window on frame FRAME.\n\
-A tooltip window is a small window displaying a string.\n\
-\n\
-FRAME nil or omitted means use the selected frame.\n\
-\n\
-PARMS is an optional list of frame parameters which can be\n\
-used to change the tooltip's appearance.\n\
-\n\
-Automatically hide the tooltip after TIMEOUT seconds.\n\
-TIMEOUT nil means use the default timeout of 5 seconds.\n\
-\n\
-If the list of frame parameters PARAMS contains a `left' parameters,\n\
-the tooltip is displayed at that x-position. Otherwise it is\n\
-displayed at the mouse position, with offset DX added (default is 5 if\n\
-DX isn't specified). Likewise for the y-position; if a `top' frame\n\
-parameter is specified, it determines the y-position of the tooltip\n\
-window, otherwise it is displayed at the mouse position, with offset\n\
-DY added (default is 10).")
+ doc: /* Show STRING in a \"tooltip\" window on frame FRAME.
+A tooltip window is a small window displaying a string.
+
+FRAME nil or omitted means use the selected frame.
+
+PARMS is an optional list of frame parameters which can be
+used to change the tooltip's appearance.
+
+Automatically hide the tooltip after TIMEOUT seconds. TIMEOUT nil
+means use the default timeout of 5 seconds.
+
+If the list of frame parameters PARAMS contains a `left' parameter,
+the tooltip is displayed at that x-position. Otherwise it is
+displayed at the mouse position, with offset DX added (default is 5 if
+DX isn't specified). Likewise for the y-position; if a `top' frame
+parameter is specified, it determines the y-position of the tooltip
+window, otherwise it is displayed at the mouse position, with offset
+DY added (default is -10).
+
+A tooltip's maximum size is specified by `x-max-tooltip-size'.
+Text larger than the specified size is clipped. */)
(string, frame, parms, timeout, dx, dy)
Lisp_Object string, frame, parms, timeout, dx, dy;
{
struct frame *f;
struct window *w;
- Window root, child;
- Lisp_Object buffer, top, left;
+ int root_x, root_y;
struct buffer *old_buffer;
struct text_pos pos;
int i, width, height;
- int root_x, root_y, win_x, win_y;
- unsigned pmask;
struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
int old_windows_or_buffers_changed = windows_or_buffers_changed;
- int count = specpdl_ptr - specpdl;
-
+ int count = SPECPDL_INDEX ();
+
specbind (Qinhibit_redisplay, Qt);
GCPRO4 (string, parms, frame, timeout);
- CHECK_STRING (string, 0);
+ CHECK_STRING (string);
f = check_x_frame (frame);
if (NILP (timeout))
timeout = make_number (5);
else
- CHECK_NATNUM (timeout, 2);
+ CHECK_NATNUM (timeout);
if (NILP (dx))
dx = make_number (5);
else
- CHECK_NUMBER (dx, 5);
-
+ CHECK_NUMBER (dx);
+
if (NILP (dy))
dy = make_number (-10);
else
- CHECK_NUMBER (dy, 6);
+ CHECK_NUMBER (dy);
if (NILP (last_show_tip_args))
last_show_tip_args = Fmake_vector (make_number (3), Qnil);
&& !NILP (Fequal (last_parms, parms)))
{
struct frame *f = XFRAME (tip_frame);
-
+
/* Only DX and DY have changed. */
if (!NILP (tip_timer))
{
}
BLOCK_INPUT;
- compute_tip_xy (f, parms, dx, dy, &root_x, &root_y);
- XMoveWindow (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
- root_x, root_y - PIXEL_HEIGHT (f));
+ compute_tip_xy (f, parms, dx, dy, PIXEL_WIDTH (f),
+ PIXEL_HEIGHT (f), &root_x, &root_y);
+
+ /* Put tooltip in topmost group and in position. */
+ SetWindowPos (FRAME_W32_WINDOW (f), HWND_TOPMOST,
+ root_x, root_y, 0, 0,
+ SWP_NOSIZE | SWP_NOACTIVATE);
+
+ /* Ensure tooltip is on top of other topmost windows (eg menus). */
+ SetWindowPos (FRAME_W32_WINDOW (f), HWND_TOP,
+ 0, 0, 0, 0,
+ SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);
+
UNBLOCK_INPUT;
goto start_timer;
}
parms = Fcons (Fcons (Qbackground_color, build_string ("lightyellow")),
parms);
+ /* Block input until the tip has been fully drawn, to avoid crashes
+ when drawing tips in menus. */
+ BLOCK_INPUT;
+
/* Create a frame for the tooltip, and record it in the global
variable tip_frame. */
- frame = x_create_tip_frame (FRAME_W32_DISPLAY_INFO (f), parms);
+ frame = x_create_tip_frame (FRAME_W32_DISPLAY_INFO (f), parms, string);
f = XFRAME (frame);
- /* Set up the frame's root window. Currently we use a size of 80
- columns x 40 lines. If someone wants to show a larger tip, he
- will loose. I don't think this is a realistic case. */
+ /* Set up the frame's root window. */
w = XWINDOW (FRAME_ROOT_WINDOW (f));
w->left = w->top = make_number (0);
- w->width = make_number (80);
- w->height = make_number (40);
+
+ if (CONSP (Vx_max_tooltip_size)
+ && INTEGERP (XCAR (Vx_max_tooltip_size))
+ && XINT (XCAR (Vx_max_tooltip_size)) > 0
+ && INTEGERP (XCDR (Vx_max_tooltip_size))
+ && XINT (XCDR (Vx_max_tooltip_size)) > 0)
+ {
+ w->width = XCAR (Vx_max_tooltip_size);
+ w->height = XCDR (Vx_max_tooltip_size);
+ }
+ else
+ {
+ w->width = make_number (80);
+ w->height = make_number (40);
+ }
+
+ f->window_width = XINT (w->width);
adjust_glyphs (f);
w->pseudo_window_p = 1;
/* Display the tooltip text in a temporary buffer. */
- buffer = Fget_buffer_create (build_string (" *tip*"));
- Fset_window_buffer (FRAME_ROOT_WINDOW (f), buffer);
old_buffer = current_buffer;
- set_buffer_internal_1 (XBUFFER (buffer));
- Ferase_buffer ();
- Finsert (1, &string);
+ set_buffer_internal_1 (XBUFFER (XWINDOW (FRAME_ROOT_WINDOW (f))->buffer));
+ current_buffer->truncate_lines = Qnil;
clear_glyph_matrix (w->desired_matrix);
clear_glyph_matrix (w->current_matrix);
SET_TEXT_POS (pos, BEGV, BEGV_BYTE);
/* Let the row go over the full width of the frame. */
row->full_width_p = 1;
+#ifdef TODO /* Investigate why some fonts need more width than is
+ calculated for some tooltips. */
/* There's a glyph at the end of rows that is use to place
the cursor there. Don't include the width of this glyph. */
if (row->used[TEXT_AREA])
row_width = row->pixel_width - last->pixel_width;
}
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);
}
/* Move the tooltip window where the mouse pointer is. Resize and
show it. */
- compute_tip_xy (f, parms, dx, dy, &root_x, &root_y);
+ compute_tip_xy (f, parms, dx, dy, width, height, &root_x, &root_y);
-#if 0 /* TODO : W32 specifics */
- BLOCK_INPUT;
- XMoveResizeWindow (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
- root_x, root_y - height, width, height);
- XMapRaised (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f));
- UNBLOCK_INPUT;
-#endif /* TODO */
+ {
+ /* Adjust Window size to take border into account. */
+ RECT rect;
+ rect.left = rect.top = 0;
+ rect.right = width;
+ rect.bottom = height;
+ AdjustWindowRect (&rect, f->output_data.w32->dwStyle,
+ FRAME_EXTERNAL_MENU_BAR (f));
+
+ /* Position and size tooltip, and put it in the topmost group. */
+ SetWindowPos (FRAME_W32_WINDOW (f), HWND_TOPMOST,
+ root_x, root_y, rect.right - rect.left,
+ rect.bottom - rect.top, SWP_NOACTIVATE);
+
+ /* Ensure tooltip is on top of other topmost windows (eg menus). */
+ SetWindowPos (FRAME_W32_WINDOW (f), HWND_TOP,
+ 0, 0, 0, 0,
+ SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);
+
+ /* Let redisplay know that we have made the frame visible already. */
+ f->async_visible = 1;
+
+ ShowWindow (FRAME_W32_WINDOW (f), SW_SHOWNOACTIVATE);
+ }
/* Draw into the window. */
w->must_be_updated_p = 1;
update_single_window (w, 1);
+ UNBLOCK_INPUT;
+
/* Restore original current buffer. */
set_buffer_internal_1 (old_buffer);
windows_or_buffers_changed = old_windows_or_buffers_changed;
DEFUN ("x-hide-tip", Fx_hide_tip, Sx_hide_tip, 0, 0, 0,
- "Hide the current tooltip window, if there is any.\n\
-Value is t is tooltip was open, nil otherwise.")
+ doc: /* Hide the current tooltip window, if there is any.
+Value is t if tooltip was open, nil otherwise. */)
()
{
int count;
/* 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);
UNGCPRO;
return unbind_to (count, deleted);
}
-#endif
\f
/***********************************************************************
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,
- "Read file name, prompting with PROMPT in directory DIR.\n\
-Use a file selection dialog.\n\
-Select DEFAULT-FILENAME in the dialog's file selection box, if\n\
-specified. Don't let the user enter a file name in the file\n\
-selection dialog's entry field, if MUSTMATCH is non-nil.")
+ doc: /* Read file name, prompting with PROMPT in directory DIR.
+Use a file selection dialog.
+Select DEFAULT-FILENAME in the dialog's file selection box, if
+specified. Ensure that file exists if MUSTMATCH is non-nil. */)
(prompt, dir, default_filename, mustmatch)
Lisp_Object prompt, dir, default_filename, mustmatch;
{
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, 0);
- CHECK_STRING (dir, 1);
+ CHECK_STRING (prompt);
+ CHECK_STRING (dir);
/* Create the dialog with PROMPT as title, using DIR as initial
directory and using "*" as pattern. */
dir = Fexpand_file_name (dir, Qnil);
- strncpy (init_dir, 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;
-
- /* Prevent redisplay. */
- specbind (Qinhibit_redisplay, Qt);
- BLOCK_INPUT;
+ {
+ OPENFILENAME file_details;
- bzero (&file_details, sizeof (file_details));
- file_details.lStructSize = sizeof (file_details);
- file_details.hwndOwner = FRAME_W32_WINDOW (f);
- 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;
+ /* Prevent redisplay. */
+ specbind (Qinhibit_redisplay, Qt);
+ BLOCK_INPUT;
- if (!NILP (mustmatch))
- file_details.Flags |= OFN_FILEMUSTEXIST | OFN_PATHMUSTEXIST;
+ 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';
+ }
- if (GetOpenFileName (&file_details))
- {
- dostounix_filename (filename);
- file = build_string (filename);
- }
- else
- file = 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);
- }
- /* 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);
+ UNBLOCK_INPUT;
+ file = unbind_to (count, file);
+ }
UNGCPRO;
\f
-/***********************************************************************
- Tests
- ***********************************************************************/
-
-#if GLYPH_DEBUG
-
-DEFUN ("imagep", Fimagep, Simagep, 1, 1, 0,
- "Value is non-nil if SPEC is a valid image specification.")
- (spec)
- Lisp_Object spec;
-{
- return valid_image_p (spec) ? Qt : Qnil;
-}
-
-
-DEFUN ("lookup-image", Flookup_image, Slookup_image, 1, 1, 0, "")
- (spec)
- Lisp_Object spec;
-{
- int id = -1;
-
- if (valid_image_p (spec))
- id = lookup_image (SELECTED_FRAME (), spec);
-
- debug_print (spec);
- return make_number (id);
-}
-
-#endif /* GLYPH_DEBUG != 0 */
-
-
-\f
/***********************************************************************
w32 specialized functions
***********************************************************************/
-DEFUN ("w32-select-font", Fw32_select_font, Sw32_select_font, 0, 1, 0,
- "This will display the W32 font dialog and return an X font string corresponding to the selection.")
- (frame)
- Lisp_Object frame;
+DEFUN ("w32-select-font", Fw32_select_font, Sw32_select_font, 0, 2, 0,
+ doc: /* Select a font using the W32 font dialog.
+Returns an X font string corresponding to the selection. */)
+ (frame, include_proportional)
+ Lisp_Object frame, include_proportional;
{
FRAME_PTR f = check_x_frame (frame);
CHOOSEFONT cf;
cf.lStructSize = sizeof (cf);
cf.hwndOwner = FRAME_W32_WINDOW (f);
- cf.Flags = CF_FORCEFONTEXIST | CF_SCREENFONTS;
+ cf.Flags = CF_FORCEFONTEXIST | CF_SCREENFONTS | CF_NOVERTFONTS;
+
+ /* Unless include_proportional is non-nil, limit the selection to
+ monospaced fonts. */
+ if (NILP (include_proportional))
+ cf.Flags |= CF_FIXEDPITCHONLY;
+
cf.lpLogFont = &lf;
/* Initialize as much of the font details as we can from the current
return build_string (buf);
}
-DEFUN ("w32-send-sys-command", Fw32_send_sys_command, Sw32_send_sys_command, 1, 2, 0,
- "Send frame a Windows WM_SYSCOMMAND message of type COMMAND.\n\
-Some useful values for command are 0xf030 to maximise frame (0xf020\n\
-to minimize), 0xf120 to restore frame to original size, and 0xf100\n\
-to activate the menubar for keyboard access. 0xf140 activates the\n\
-screen saver if defined.\n\
-\n\
-If optional parameter FRAME is not specified, use selected frame.")
+DEFUN ("w32-send-sys-command", Fw32_send_sys_command,
+ Sw32_send_sys_command, 1, 2, 0,
+ doc: /* Send frame a Windows WM_SYSCOMMAND message of type COMMAND.
+Some useful values for command are #xf030 to maximise frame (#xf020
+to minimize), #xf120 to restore frame to original size, and #xf100
+to activate the menubar for keyboard access. #xf140 activates the
+screen saver if defined.
+
+If optional parameter FRAME is not specified, use selected frame. */)
(command, frame)
Lisp_Object command, frame;
{
FRAME_PTR f = check_x_frame (frame);
- CHECK_NUMBER (command, 0);
+ CHECK_NUMBER (command);
PostMessage (FRAME_W32_WINDOW (f), WM_SYSCOMMAND, XINT (command), 0);
}
DEFUN ("w32-shell-execute", Fw32_shell_execute, Sw32_shell_execute, 2, 4, 0,
- "Get Windows to perform OPERATION on DOCUMENT.\n\
-This is a wrapper around the ShellExecute system function, which\n\
-invokes the application registered to handle OPERATION for DOCUMENT.\n\
-OPERATION is typically \"open\", \"print\" or \"explore\" (but can be\n\
-nil for the default action), and DOCUMENT is typically the name of a\n\
-document file or URL, but can also be a program executable to run or\n\
-a directory to open in the Windows Explorer.\n\
-\n\
-If DOCUMENT is a program executable, PARAMETERS can be a string\n\
-containing command line parameters, but otherwise should be nil.\n\
-\n\
-SHOW-FLAG can be used to control whether the invoked application is hidden\n\
-or minimized. If SHOW-FLAG is nil, the application is displayed normally,\n\
-otherwise it is an integer representing a ShowWindow flag:\n\
-\n\
- 0 - start hidden\n\
- 1 - start normally\n\
- 3 - start maximized\n\
- 6 - start minimized")
+ doc: /* Get Windows to perform OPERATION on DOCUMENT.
+This is a wrapper around the ShellExecute system function, which
+invokes the application registered to handle OPERATION for DOCUMENT.
+OPERATION is typically \"open\", \"print\" or \"explore\" (but can be
+nil for the default action), and DOCUMENT is typically the name of a
+document file or URL, but can also be a program executable to run or
+a directory to open in the Windows Explorer.
+
+If DOCUMENT is a program executable, PARAMETERS can be a string
+containing command line parameters, but otherwise should be nil.
+
+SHOW-FLAG can be used to control whether the invoked application is hidden
+or minimized. If SHOW-FLAG is nil, the application is displayed normally,
+otherwise it is an integer representing a ShowWindow flag:
+
+ 0 - start hidden
+ 1 - start normally
+ 3 - start maximized
+ 6 - start minimized */)
(operation, document, parameters, show_flag)
Lisp_Object operation, document, parameters, show_flag;
{
Lisp_Object current_dir;
- CHECK_STRING (document, 0);
+ CHECK_STRING (document);
/* Encode filename and current directory. */
current_dir = ENCODE_FILE (current_buffer->directory);
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)
int w32_modifiers;
struct gcpro gcpro1;
- CHECK_VECTOR (key, 0);
+ CHECK_VECTOR (key);
if (XFASTINT (Flength (key)) != 1)
return Qnil;
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))
{
return HOTKEY (vk_code, w32_modifiers);
}
-DEFUN ("w32-register-hot-key", Fw32_register_hot_key, Sw32_register_hot_key, 1, 1, 0,
- "Register KEY as a hot-key combination.\n\
-Certain key combinations like Alt-Tab are reserved for system use on\n\
-Windows, and therefore are normally intercepted by the system. However,\n\
-most of these key combinations can be received by registering them as\n\
-hot-keys, overriding their special meaning.\n\
-\n\
-KEY must be a one element key definition in vector form that would be\n\
-acceptable to `define-key' (e.g. [A-tab] for Alt-Tab). The meta\n\
-modifier is interpreted as Alt if `w32-alt-is-meta' is t, and hyper\n\
-is always interpreted as the Windows modifier keys.\n\
-\n\
-The return value is the hotkey-id if registered, otherwise nil.")
+DEFUN ("w32-register-hot-key", Fw32_register_hot_key,
+ Sw32_register_hot_key, 1, 1, 0,
+ doc: /* Register KEY as a hot-key combination.
+Certain key combinations like Alt-Tab are reserved for system use on
+Windows, and therefore are normally intercepted by the system. However,
+most of these key combinations can be received by registering them as
+hot-keys, overriding their special meaning.
+
+KEY must be a one element key definition in vector form that would be
+acceptable to `define-key' (e.g. [A-tab] for Alt-Tab). The meta
+modifier is interpreted as Alt if `w32-alt-is-meta' is t, and hyper
+is always interpreted as the Windows modifier keys.
+
+The return value is the hotkey-id if registered, otherwise nil. */)
(key)
Lisp_Object key;
{
if (NILP (item))
w32_grabbed_keys = Fcons (key, w32_grabbed_keys);
else
- XCAR (item) = key;
+ XSETCAR (item, key);
/* Notify input thread about new hot-key definition, so that it
takes effect without needing to switch focus. */
return key;
}
-DEFUN ("w32-unregister-hot-key", Fw32_unregister_hot_key, Sw32_unregister_hot_key, 1, 1, 0,
- "Unregister HOTKEY as a hot-key combination.")
+DEFUN ("w32-unregister-hot-key", Fw32_unregister_hot_key,
+ Sw32_unregister_hot_key, 1, 1, 0,
+ doc: /* Unregister HOTKEY as a hot-key combination. */)
(key)
Lisp_Object key;
{
return Qnil;
}
-DEFUN ("w32-registered-hot-keys", Fw32_registered_hot_keys, Sw32_registered_hot_keys, 0, 0, 0,
- "Return list of registered hot-key IDs.")
+DEFUN ("w32-registered-hot-keys", Fw32_registered_hot_keys,
+ Sw32_registered_hot_keys, 0, 0, 0,
+ doc: /* Return list of registered hot-key IDs. */)
()
{
return Fcopy_sequence (w32_grabbed_keys);
}
-DEFUN ("w32-reconstruct-hot-key", Fw32_reconstruct_hot_key, Sw32_reconstruct_hot_key, 1, 1, 0,
- "Convert hot-key ID to a lisp key combination.")
+DEFUN ("w32-reconstruct-hot-key", Fw32_reconstruct_hot_key,
+ Sw32_reconstruct_hot_key, 1, 1, 0,
+ doc: /* Convert hot-key ID to a lisp key combination. */)
(hotkeyid)
Lisp_Object hotkeyid;
{
int vk_code, w32_modifiers;
Lisp_Object key;
- CHECK_NUMBER (hotkeyid, 0);
+ CHECK_NUMBER (hotkeyid);
vk_code = HOTKEY_VK_CODE (hotkeyid);
w32_modifiers = HOTKEY_MODIFIERS (hotkeyid);
return key;
}
-DEFUN ("w32-toggle-lock-key", Fw32_toggle_lock_key, Sw32_toggle_lock_key, 1, 2, 0,
- "Toggle the state of the lock key KEY.\n\
-KEY can be `capslock', `kp-numlock', or `scroll'.\n\
-If the optional parameter NEW-STATE is a number, then the state of KEY\n\
-is set to off if the low bit of NEW-STATE is zero, otherwise on.")
+DEFUN ("w32-toggle-lock-key", Fw32_toggle_lock_key,
+ Sw32_toggle_lock_key, 1, 2, 0,
+ doc: /* Toggle the state of the lock key KEY.
+KEY can be `capslock', `kp-numlock', or `scroll'.
+If the optional parameter NEW-STATE is a number, then the state of KEY
+is set to off if the low bit of NEW-STATE is zero, otherwise on. */)
(key, new_state)
Lisp_Object key, new_state;
{
}
\f
DEFUN ("file-system-info", Ffile_system_info, Sfile_system_info, 1, 1, 0,
- "Return storage information about the file system FILENAME is on.\n\
-Value is a list of floats (TOTAL FREE AVAIL), where TOTAL is the total\n\
-storage of the file system, FREE is the free storage, and AVAIL is the\n\
-storage available to a non-superuser. All 3 numbers are in bytes.\n\
-If the underlying system call fails, value is nil.")
+ doc: /* Return storage information about the file system FILENAME is on.
+Value is a list of floats (TOTAL FREE AVAIL), where TOTAL is the total
+storage of the file system, FREE is the free storage, and AVAIL is the
+storage available to a non-superuser. All 3 numbers are in bytes.
+If the underlying system call fails, value is nil. */)
(filename)
Lisp_Object filename;
{
Lisp_Object encoded, value;
- CHECK_STRING (filename, 0);
+ CHECK_STRING (filename);
filename = Fexpand_file_name (filename, Qnil);
encoded = ENCODE_FILE (filename);
/* 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] == ':')
if (pfn_GetDiskFreeSpaceEx)
{
+ /* Unsigned large integers cannot be cast to double, so
+ use signed ones instead. */
LARGE_INTEGER availbytes;
LARGE_INTEGER freebytes;
LARGE_INTEGER totalbytes;
if (pfn_GetDiskFreeSpaceEx(rootname,
- &availbytes,
- &totalbytes,
- &freebytes))
+ (ULARGE_INTEGER *)&availbytes,
+ (ULARGE_INTEGER *)&totalbytes,
+ (ULARGE_INTEGER *)&freebytes))
value = list3 (make_float ((double) totalbytes.QuadPart),
make_float ((double) freebytes.QuadPart),
make_float ((double) availbytes.QuadPart));
return value;
}
\f
+/***********************************************************************
+ Initialization
+ ***********************************************************************/
+
+void
syms_of_w32fns ()
{
+ globals_of_w32fns ();
/* This is zero if not using MS-Windows. */
w32_in_use = 0;
+ track_mouse_window = NULL;
+
+ w32_visible_system_caret_hwnd = NULL;
- /* The section below is built by the lisp expression at the top of the file,
- just above where these variables are declared. */
- /*&&& init symbols here &&&*/
Qauto_raise = intern ("auto-raise");
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");
staticpro (&Qcenter);
Qcancel_timer = intern ("cancel-timer");
staticpro (&Qcancel_timer);
- /* This is the end of symbol initialization. */
+ Qfullscreen = intern ("fullscreen");
+ staticpro (&Qfullscreen);
+ Qfullwidth = intern ("fullwidth");
+ staticpro (&Qfullwidth);
+ Qfullheight = intern ("fullheight");
+ staticpro (&Qfullheight);
+ Qfullboth = intern ("fullboth");
+ staticpro (&Qfullboth);
Qhyper = intern ("hyper");
staticpro (&Qhyper);
staticpro (&Qcontrol);
Qshift = intern ("shift");
staticpro (&Qshift);
+ /* This is the end of symbol initialization. */
/* Text property `display' should be nonsticky by default. */
Vtext_property_default_nonsticky
Qlaplace = intern ("laplace");
staticpro (&Qlaplace);
+ Qemboss = intern ("emboss");
+ staticpro (&Qemboss);
+ Qedge_detection = intern ("edge-detection");
+ staticpro (&Qedge_detection);
+ Qheuristic = intern ("heuristic");
+ staticpro (&Qheuristic);
+ QCmatrix = intern (":matrix");
+ staticpro (&QCmatrix);
+ QCcolor_adjustment = intern (":color-adjustment");
+ staticpro (&QCcolor_adjustment);
+ QCmask = intern (":mask");
+ staticpro (&QCmask);
Qface_set_after_frame_default = intern ("face-set-after-frame-default");
staticpro (&Qface_set_after_frame_default);
w32_grabbed_keys = Qnil;
DEFVAR_LISP ("w32-color-map", &Vw32_color_map,
- "An array of color name mappings for windows.");
+ doc: /* An array of color name mappings for windows. */);
Vw32_color_map = Qnil;
DEFVAR_LISP ("w32-pass-alt-to-system", &Vw32_pass_alt_to_system,
- "Non-nil if alt key presses are passed on to Windows.\n\
-When non-nil, for example, alt pressed and released and then space will\n\
-open the System menu. When nil, Emacs silently swallows alt key events.");
+ doc: /* Non-nil if alt key presses are passed on to Windows.
+When non-nil, for example, alt pressed and released and then space will
+open the System menu. When nil, Emacs silently swallows alt key events. */);
Vw32_pass_alt_to_system = Qnil;
DEFVAR_LISP ("w32-alt-is-meta", &Vw32_alt_is_meta,
- "Non-nil if the alt key is to be considered the same as the meta key.\n\
-When nil, Emacs will translate the alt key to the Alt modifier, and not Meta.");
+ doc: /* Non-nil if the alt key is to be considered the same as the meta key.
+When nil, Emacs will translate the alt key to the Alt modifier, and not Meta. */);
Vw32_alt_is_meta = Qt;
DEFVAR_INT ("w32-quit-key", &Vw32_quit_key,
- "If non-zero, the virtual key code for an alternative quit key.");
+ 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,
- "Non-nil if the left \"Windows\" key is passed on to Windows.\n\
-When non-nil, the Start menu is opened by tapping the key.");
+ 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,
- "Non-nil if the right \"Windows\" key is passed on to Windows.\n\
-When non-nil, the Start menu is opened by tapping the key.");
+ 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. */);
Vw32_pass_rwindow_to_system = Qt;
DEFVAR_INT ("w32-phantom-key-code",
&Vw32_phantom_key_code,
- "Virtual key code used to generate \"phantom\" key presses.\n\
-Value is a number between 0 and 255.\n\
-\n\
-Phantom key presses are generated in order to stop the system from\n\
-acting on \"Windows\" key events when `w32-pass-lwindow-to-system' or\n\
-`w32-pass-rwindow-to-system' is nil.");
+ doc: /* Virtual key code used to generate \"phantom\" key presses.
+Value is a number between 0 and 255.
+
+Phantom key presses are generated in order to stop the system from
+acting on \"Windows\" key events when `w32-pass-lwindow-to-system' or
+`w32-pass-rwindow-to-system' is nil. */);
/* Although 255 is technically not a valid key code, it works and
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,
- "Non-nil if Num Lock should act normally.\n\
-Set to nil to see Num Lock as the key `kp-numlock'.");
+ 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,
- "Non-nil if Caps Lock should act normally.\n\
-Set to nil to see Caps Lock as the key `capslock'.");
+ doc: /* Non-nil if Caps Lock should act normally.
+Set to nil to see Caps Lock as the key `capslock'. */);
Vw32_enable_caps_lock = Qt;
DEFVAR_LISP ("w32-scroll-lock-modifier",
&Vw32_scroll_lock_modifier,
- "Modifier to use for the Scroll Lock on state.\n\
-The value can be hyper, super, meta, alt, control or shift for the\n\
-respective modifier, or nil to see Scroll Lock as the key `scroll'.\n\
-Any other value will cause the key to be ignored.");
+ doc: /* Modifier to use for the Scroll Lock on state.
+The value can be hyper, super, meta, alt, control or shift for the
+respective modifier, or nil to see Scroll Lock as the key `scroll'.
+Any other value will cause the key to be ignored. */);
Vw32_scroll_lock_modifier = Qt;
DEFVAR_LISP ("w32-lwindow-modifier",
&Vw32_lwindow_modifier,
- "Modifier to use for the left \"Windows\" key.\n\
-The value can be hyper, super, meta, alt, control or shift for the\n\
-respective modifier, or nil to appear as the key `lwindow'.\n\
-Any other value will cause the key to be ignored.");
+ doc: /* Modifier to use for the left \"Windows\" key.
+The value can be hyper, super, meta, alt, control or shift for the
+respective modifier, or nil to appear as the key `lwindow'.
+Any other value will cause the key to be ignored. */);
Vw32_lwindow_modifier = Qnil;
DEFVAR_LISP ("w32-rwindow-modifier",
&Vw32_rwindow_modifier,
- "Modifier to use for the right \"Windows\" key.\n\
-The value can be hyper, super, meta, alt, control or shift for the\n\
-respective modifier, or nil to appear as the key `rwindow'.\n\
-Any other value will cause the key to be ignored.");
+ doc: /* Modifier to use for the right \"Windows\" key.
+The value can be hyper, super, meta, alt, control or shift for the
+respective modifier, or nil to appear as the key `rwindow'.
+Any other value will cause the key to be ignored. */);
Vw32_rwindow_modifier = Qnil;
DEFVAR_LISP ("w32-apps-modifier",
&Vw32_apps_modifier,
- "Modifier to use for the \"Apps\" key.\n\
-The value can be hyper, super, meta, alt, control or shift for the\n\
-respective modifier, or nil to appear as the key `apps'.\n\
-Any other value will cause the key to be ignored.");
+ doc: /* Modifier to use for the \"Apps\" key.
+The value can be hyper, super, meta, alt, control or shift for the
+respective modifier, or nil to appear as the key `apps'.
+Any other value will cause the key to be ignored. */);
Vw32_apps_modifier = Qnil;
- DEFVAR_LISP ("w32-enable-synthesized-fonts", &Vw32_enable_synthesized_fonts,
- "Non-nil enables selection of artificially italicized and bold fonts.");
- Vw32_enable_synthesized_fonts = Qnil;
+ DEFVAR_BOOL ("w32-enable-synthesized-fonts", &w32_enable_synthesized_fonts,
+ doc: /* Non-nil enables selection of artificially italicized and bold fonts. */);
+ w32_enable_synthesized_fonts = 0;
DEFVAR_LISP ("w32-enable-palette", &Vw32_enable_palette,
- "Non-nil enables Windows palette management to map colors exactly.");
+ doc: /* Non-nil enables Windows palette management to map colors exactly. */);
Vw32_enable_palette = Qt;
DEFVAR_INT ("w32-mouse-button-tolerance",
&Vw32_mouse_button_tolerance,
- "Analogue of double click interval for faking middle mouse events.\n\
-The value is the minimum time in milliseconds that must elapse between\n\
-left/right button down events before they are considered distinct events.\n\
-If both mouse buttons are depressed within this interval, a middle mouse\n\
-button down event is generated instead.");
+ doc: /* Analogue of double click interval for faking middle mouse events.
+The value is the minimum time in milliseconds that must elapse between
+left/right button down events before they are considered distinct events.
+If both mouse buttons are depressed within this interval, a middle mouse
+button down event is generated instead. */);
XSETINT (Vw32_mouse_button_tolerance, GetDoubleClickTime () / 2);
DEFVAR_INT ("w32-mouse-move-interval",
&Vw32_mouse_move_interval,
- "Minimum interval between mouse move events.\n\
-The value is the minimum time in milliseconds that must elapse between\n\
-successive mouse move (or scroll bar drag) events before they are\n\
-reported as lisp events.");
+ doc: /* Minimum interval between mouse move events.
+The value is the minimum time in milliseconds that must elapse between
+successive mouse move (or scroll bar drag) events before they are
+reported as lisp events. */);
XSETINT (Vw32_mouse_move_interval, 0);
+ DEFVAR_BOOL ("w32-pass-extra-mouse-buttons-to-system",
+ &w32_pass_extra_mouse_buttons_to_system,
+ doc: /* Non-nil if the fourth and fifth mouse buttons are passed to Windows.
+Recent versions of Windows support mice with up to five buttons.
+Since most applications don't support these extra buttons, most mouse
+drivers will allow you to map them to functions at the system level.
+If this variable is non-nil, Emacs will pass them on, allowing the
+system to handle them. */);
+ w32_pass_extra_mouse_buttons_to_system = 0;
+
init_x_parm_symbols ();
DEFVAR_LISP ("x-bitmap-file-path", &Vx_bitmap_file_path,
- "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,
- "The shape of the pointer when over text.\n\
-Changing the value does not affect existing frames\n\
-unless you set the mouse color.");
+ doc: /* The shape of the pointer when over text.
+Changing the value does not affect existing frames
+unless you set the mouse color. */);
Vx_pointer_shape = Qnil;
DEFVAR_LISP ("x-resource-name", &Vx_resource_name,
- "The name Emacs uses to look up resources; for internal use only.\n\
-`x-get-resource' uses this as the first component of the instance name\n\
-when requesting resource values.\n\
-Emacs initially sets `x-resource-name' to the name under which Emacs\n\
-was invoked, or to the value specified with the `-name' or `-rn'\n\
-switches, if present.");
+ doc: /* The name Emacs uses to look up resources; for internal use only.
+`x-get-resource' uses this as the first component of the instance name
+when requesting resource values.
+Emacs initially sets `x-resource-name' to the name under which Emacs
+was invoked, or to the value specified with the `-name' or `-rn'
+switches, if present. */);
Vx_resource_name = Qnil;
Vx_nontext_pointer_shape = Qnil;
Vx_mode_pointer_shape = Qnil;
DEFVAR_LISP ("x-hourglass-pointer-shape", &Vx_hourglass_pointer_shape,
- "The shape of the pointer when Emacs is busy.\n\
-This variable takes effect when you create a new frame\n\
-or when you set the mouse color.");
+ doc: /* The shape of the pointer when Emacs is busy.
+This variable takes effect when you create a new frame
+or when you set the mouse color. */);
Vx_hourglass_pointer_shape = Qnil;
DEFVAR_BOOL ("display-hourglass", &display_hourglass_p,
- "Non-zero means Emacs displays an hourglass pointer on window systems.");
+ doc: /* Non-zero means Emacs displays an hourglass pointer on window systems. */);
display_hourglass_p = 1;
-
+
DEFVAR_LISP ("hourglass-delay", &Vhourglass_delay,
- "*Seconds to wait before displaying an hourglass pointer.\n\
-Value must be an integer or float.");
+ doc: /* *Seconds to wait before displaying an hourglass pointer.
+Value must be an integer or float. */);
Vhourglass_delay = make_number (DEFAULT_HOURGLASS_DELAY);
DEFVAR_LISP ("x-sensitive-text-pointer-shape",
&Vx_sensitive_text_pointer_shape,
- "The shape of the pointer when over mouse-sensitive text.\n\
-This variable takes effect when you create a new frame\n\
-or when you set the mouse color.");
+ doc: /* The shape of the pointer when over mouse-sensitive text.
+This variable takes effect when you create a new frame
+or when you set the mouse color. */);
Vx_sensitive_text_pointer_shape = Qnil;
DEFVAR_LISP ("x-window-horizontal-drag-cursor",
&Vx_window_horizontal_drag_shape,
- "Pointer shape to use for indicating a window can be dragged horizontally.\n\
-This variable takes effect when you create a new frame\n\
-or when you set the mouse color.");
+ doc: /* Pointer shape to use for indicating a window can be dragged horizontally.
+This variable takes effect when you create a new frame
+or when you set the mouse color. */);
Vx_window_horizontal_drag_shape = Qnil;
DEFVAR_LISP ("x-cursor-fore-pixel", &Vx_cursor_fore_pixel,
- "A string indicating the foreground color of the cursor box.");
+ doc: /* A string indicating the foreground color of the cursor box. */);
Vx_cursor_fore_pixel = Qnil;
+ DEFVAR_LISP ("x-max-tooltip-size", &Vx_max_tooltip_size,
+ 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,
- "Non-nil if no window manager is in use.\n\
-Emacs doesn't try to figure this out; this is always nil\n\
-unless you set it to something else.");
+ doc: /* Non-nil if no window manager is in use.
+Emacs doesn't try to figure this out; this is always nil
+unless you set it to something else. */);
/* We don't have any way to find this out, so set it to nil
and maybe the user would like to set it to t. */
Vx_no_window_manager = Qnil;
DEFVAR_LISP ("x-pixel-size-width-font-regexp",
&Vx_pixel_size_width_font_regexp,
- "Regexp matching a font name whose width is the same as `PIXEL_SIZE'.\n\
-\n\
-Since Emacs gets width of a font matching with this regexp from\n\
-PIXEL_SIZE field of the name, font finding mechanism gets faster for\n\
-such a font. This is especially effective for such large fonts as\n\
-Chinese, Japanese, and Korean.");
+ doc: /* Regexp matching a font name whose width is the same as `PIXEL_SIZE'.
+
+Since Emacs gets width of a font matching with this regexp from
+PIXEL_SIZE field of the name, font finding mechanism gets faster for
+such a font. This is especially effective for such large fonts as
+Chinese, Japanese, and Korean. */);
Vx_pixel_size_width_font_regexp = Qnil;
DEFVAR_LISP ("image-cache-eviction-delay", &Vimage_cache_eviction_delay,
- "Time after which cached images are removed from the cache.\n\
-When an image has not been displayed this many seconds, remove it\n\
-from the image cache. Value must be an integer or nil with nil\n\
-meaning don't clear the cache.");
+ doc: /* Time after which cached images are removed from the cache.
+When an image has not been displayed this many seconds, remove it
+from the image cache. Value must be an integer or nil with nil
+meaning don't clear the cache. */);
Vimage_cache_eviction_delay = make_number (30 * 60);
DEFVAR_LISP ("w32-bdf-filename-alist",
&Vw32_bdf_filename_alist,
- "List of bdf fonts and their corresponding filenames.");
+ doc: /* List of bdf fonts and their corresponding filenames. */);
Vw32_bdf_filename_alist = Qnil;
DEFVAR_BOOL ("w32-strict-fontnames",
&w32_strict_fontnames,
- "Non-nil means only use fonts that are exact matches for those requested.\n\
-Default is nil, which allows old fontnames that are not XLFD compliant,\n\
-and allows third-party CJK display to work by specifying false charset\n\
-fields to trick Emacs into translating to Big5, SJIS etc.\n\
-Setting this to t will prevent wrong fonts being selected when\n\
-fontsets are automatically created.");
+ doc: /* Non-nil means only use fonts that are exact matches for those requested.
+Default is nil, which allows old fontnames that are not XLFD compliant,
+and allows third-party CJK display to work by specifying false charset
+fields to trick Emacs into translating to Big5, SJIS etc.
+Setting this to t will prevent wrong fonts being selected when
+fontsets are automatically created. */);
w32_strict_fontnames = 0;
DEFVAR_BOOL ("w32-strict-painting",
&w32_strict_painting,
- "Non-nil means use strict rules for repainting frames.\n\
-Set this to nil to get the old behaviour for repainting; this should\n\
-only be necessary if the default setting causes problems.");
+ doc: /* Non-nil means use strict rules for repainting frames.
+Set this to nil to get the old behaviour for repainting; this should
+only be necessary if the default setting causes problems. */);
w32_strict_painting = 1;
- DEFVAR_LISP ("w32-system-coding-system",
- &Vw32_system_coding_system,
- "Coding system used by Windows system functions, such as for font names.");
- Vw32_system_coding_system = Qnil;
-
DEFVAR_LISP ("w32-charset-info-alist",
&Vw32_charset_info_alist,
- "Alist linking Emacs character sets to Windows fonts\n\
-and codepages. Each entry should be of the form:\n\
-\n\
- (CHARSET_NAME . (WINDOWS_CHARSET . CODEPAGE))\n\
-\n\
-where CHARSET_NAME is a string used in font names to identify the charset,\n\
-WINDOWS_CHARSET is a symbol that can be one of:\n\
-w32-charset-ansi, w32-charset-default, w32-charset-symbol,\n\
-w32-charset-shiftjis, w32-charset-hangeul, w32-charset-gb2312,\n\
-w32-charset-chinesebig5, "
+ doc: /* Alist linking Emacs character sets to Windows fonts and codepages.
+Each entry should be of the form:
+
+ (CHARSET_NAME . (WINDOWS_CHARSET . CODEPAGE))
+
+where CHARSET_NAME is a string used in font names to identify the charset,
+WINDOWS_CHARSET is a symbol that can be one of:
+w32-charset-ansi, w32-charset-default, w32-charset-symbol,
+w32-charset-shiftjis, w32-charset-hangeul, w32-charset-gb2312,
+w32-charset-chinesebig5,
#ifdef JOHAB_CHARSET
-"w32-charset-johab, w32-charset-hebrew,\n\
-w32-charset-arabic, w32-charset-greek, w32-charset-turkish,\n\
-w32-charset-vietnamese, w32-charset-thai, w32-charset-easteurope,\n\
-w32-charset-russian, w32-charset-mac, w32-charset-baltic,\n"
+w32-charset-johab, w32-charset-hebrew,
+w32-charset-arabic, w32-charset-greek, w32-charset-turkish,
+w32-charset-vietnamese, w32-charset-thai, w32-charset-easteurope,
+w32-charset-russian, w32-charset-mac, w32-charset-baltic,
#endif
#ifdef UNICODE_CHARSET
-"w32-charset-unicode, "
+w32-charset-unicode,
#endif
-"or w32-charset-oem.\n\
-CODEPAGE should be an integer specifying the codepage that should be used\n\
-to display the character set, t to do no translation and output as Unicode,\n\
-or nil to do no translation and output as 8 bit (or multibyte on far-east\n\
-versions of Windows) characters.");
+or w32-charset-oem.
+CODEPAGE should be an integer specifying the codepage that should be used
+to display the character set, t to do no translation and output as Unicode,
+or nil to do no translation and output as 8 bit (or multibyte on far-east
+versions of Windows) characters. */);
Vw32_charset_info_alist = Qnil;
staticpro (&Qw32_charset_ansi);
#ifdef JOHAB_CHARSET
{
static int w32_extra_charsets_defined = 1;
- DEFVAR_BOOL ("w32-extra-charsets-defined", &w32_extra_charsets_defined, "");
+ DEFVAR_BOOL ("w32-extra-charsets-defined", &w32_extra_charsets_defined,
+ doc: /* Internal variable. */);
staticpro (&Qw32_charset_johab);
Qw32_charset_johab = intern ("w32-charset-johab");
{
static int w32_unicode_charset_defined = 1;
DEFVAR_BOOL ("w32-unicode-charset-defined",
- &w32_unicode_charset_defined, "");
+ &w32_unicode_charset_defined,
+ doc: /* Internal variable. */);
staticpro (&Qw32_charset_unicode);
Qw32_charset_unicode = intern ("w32-charset-unicode");
set_frame_fontset_func = x_set_font;
check_window_system_func = check_w32;
-#if 0 /* TODO Image support for W32 */
/* Images. */
Qxbm = intern ("xbm");
staticpro (&Qxbm);
- QCtype = intern (":type");
- staticpro (&QCtype);
QCconversion = intern (":conversion");
staticpro (&QCconversion);
QCheuristic_mask = intern (":heuristic-mask");
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");
#endif
defsubr (&Sclear_image_cache);
+ defsubr (&Simage_size);
+ defsubr (&Simage_mask_p);
#if GLYPH_DEBUG
defsubr (&Simagep);
defsubr (&Slookup_image);
#endif
-#endif /* TODO */
hourglass_atimer = NULL;
hourglass_shown_p = 0;
-#ifdef TODO /* Tooltip support not complete. */
defsubr (&Sx_show_tip);
defsubr (&Sx_hide_tip);
-#endif
tip_timer = Qnil;
staticpro (&tip_timer);
tip_frame = Qnil;
staticpro (&tip_frame);
+ last_show_tip_args = Qnil;
+ staticpro (&last_show_tip_args);
+
defsubr (&Sx_file_dialog);
}
-void
-init_xfns ()
+/*
+ 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 ()
{
- image_types = NULL;
- Vimage_types = Qnil;
+ 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");
+}
+
+/* Initialize image types. Based on which libraries are available. */
+static void
+init_external_image_libraries ()
+{
+ HINSTANCE library;
-#if 0 /* TODO : Image support for W32 */
- define_image_type (&xbm_type);
- define_image_type (&gs_type);
- define_image_type (&pbm_type);
-
#if HAVE_XPM
- define_image_type (&xpm_type);
+ if ((library = LoadLibrary ("libXpm.dll")))
+ {
+ if (init_xpm_functions (library))
+ define_image_type (&xpm_type);
+ }
+
#endif
-
+
#if HAVE_JPEG
- define_image_type (&jpeg_type);
+ /* Try loading jpeg library under probable names. */
+ if ((library = LoadLibrary ("libjpeg.dll"))
+ || (library = LoadLibrary ("jpeg-62.dll"))
+ || (library = LoadLibrary ("jpeg.dll")))
+ {
+ if (init_jpeg_functions (library))
+ define_image_type (&jpeg_type);
+ }
#endif
-
+
#if HAVE_TIFF
- define_image_type (&tiff_type);
+ if (library = LoadLibrary ("libtiff.dll"))
+ {
+ if (init_tiff_functions (library))
+ define_image_type (&tiff_type);
+ }
#endif
-
+
#if HAVE_GIF
- define_image_type (&gif_type);
+ if (library = LoadLibrary ("libungif.dll"))
+ {
+ if (init_gif_functions (library))
+ define_image_type (&gif_type);
+ }
#endif
-
+
#if HAVE_PNG
- define_image_type (&png_type);
+ /* Ensure zlib is loaded. Try debug version first. */
+ if (!LoadLibrary ("zlibd.dll"))
+ LoadLibrary ("zlib.dll");
+
+ /* Try loading libpng under probable names. */
+ if ((library = LoadLibrary ("libpng13d.dll"))
+ || (library = LoadLibrary ("libpng13.dll"))
+ || (library = LoadLibrary ("libpng12d.dll"))
+ || (library = LoadLibrary ("libpng12.dll"))
+ || (library = LoadLibrary ("libpng.dll")))
+ {
+ if (init_png_functions (library))
+ define_image_type (&png_type);
+ }
#endif
-#endif /* TODO */
+}
+
+void
+init_xfns ()
+{
+ image_types = NULL;
+ Vimage_types = Qnil;
+
+ define_image_type (&pbm_type);
+ define_image_type (&xbm_type);
+
+#if 0 /* TODO : Ghostscript support for W32 */
+ define_image_type (&gs_type);
+#endif
+
+ /* Image types that rely on external libraries are loaded dynamically
+ if the library is available. */
+ init_external_image_libraries ();
}
#undef abort
-void
+void
w32_abort()
{
int button;
HCoop / bpt / emacs.git / blobdiff