the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
-/* Image support (XBM, XPM, PBM, JPEG, TIFF, GIF, PNG, GS). tooltips,
- tool-bars, busy-cursor, file selection dialog added by Gerd
- Moellmann <gerd@gnu.org>. */
-
-/* Completely rewritten by Richard Stallman. */
-
-/* Rewritten for X11 by Joseph Arceneaux */
-
#include <config.h>
#include <signal.h>
#include <stdio.h>
#include "fontset.h"
#include "systime.h"
#include "termhooks.h"
+#include "atimer.h"
#ifdef HAVE_X_WINDOWS
#include <ctype.h>
+#include <sys/types.h>
+#include <sys/stat.h>
/* On some systems, the character-composition stuff is broken in X11R5. */
f = XFRAME (frame);
if (!FRAME_X_P (f) || FRAME_X_DISPLAY_INFO (f) != dpyinfo)
continue;
+ if (f->output_data.x->busy_window == wdesc)
+ return f;
#ifdef USE_X_TOOLKIT
if ((f->output_data.x->edit_widget
&& XtWindow (f->output_data.x->edit_widget) == wdesc)
int wdesc;
{
Lisp_Object tail, frame;
- struct frame *f;
+ struct frame *f, *found;
struct x_output *x;
- for (tail = Vframe_list; GC_CONSP (tail); tail = XCDR (tail))
+ found = NULL;
+ for (tail = Vframe_list; GC_CONSP (tail) && !found; tail = XCDR (tail))
{
frame = XCAR (tail);
if (!GC_FRAMEP (frame))
continue;
+
f = XFRAME (frame);
- if (!FRAME_X_P (f) || FRAME_X_DISPLAY_INFO (f) != dpyinfo)
- continue;
- x = f->output_data.x;
- /* This frame matches if the window is any of its widgets. */
- if (x->widget)
+ if (FRAME_X_P (f) && FRAME_X_DISPLAY_INFO (f) == dpyinfo)
{
- if (wdesc == XtWindow (x->widget)
- || wdesc == XtWindow (x->column_widget)
- || wdesc == XtWindow (x->edit_widget))
- return f;
- /* Match if the window is this frame's menubar. */
- if (lw_window_is_in_menubar (wdesc, x->menubar_widget))
- return f;
+ /* This frame matches if the window is any of its widgets. */
+ x = f->output_data.x;
+ if (x->busy_window == wdesc)
+ found = f;
+ else if (x->widget)
+ {
+ if (wdesc == XtWindow (x->widget)
+ || wdesc == XtWindow (x->column_widget)
+ || wdesc == XtWindow (x->edit_widget))
+ found = f;
+ /* Match if the window is this frame's menubar. */
+ else if (lw_window_is_in_menubar (wdesc, x->menubar_widget))
+ found = f;
+ }
+ else if (FRAME_X_WINDOW (f) == wdesc)
+ /* A tooltip frame. */
+ found = f;
}
- else if (FRAME_X_WINDOW (f) == wdesc)
- /* A tooltip frame. */
- return f;
}
- return 0;
+
+ return found;
}
/* Likewise, but exclude the menu bar widget. */
continue;
x = f->output_data.x;
/* This frame matches if the window is any of its widgets. */
- if (x->widget)
+ if (x->busy_window == wdesc)
+ return f;
+ else if (x->widget)
{
if (wdesc == XtWindow (x->widget)
|| wdesc == XtWindow (x->column_widget)
void (*setter) P_ ((struct frame *, Lisp_Object, Lisp_Object));
};
+static void x_create_im P_ ((struct frame *));
void x_set_foreground_color 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));
UNBLOCK_INPUT;
}
#endif
+
+
+\f
+/* Support routines for XIC (X Input Context). */
+
+#ifdef HAVE_X_I18N
+
+static XFontSet xic_create_xfontset P_ ((struct frame *, char *));
+static XIMStyle best_xim_style P_ ((XIMStyles *, XIMStyles *));
+
+
+/* Supported XIM styles, ordered by preferenc. */
+
+static XIMStyle supported_xim_styles[] =
+{
+ XIMPreeditPosition | XIMStatusArea,
+ XIMPreeditPosition | XIMStatusNothing,
+ XIMPreeditPosition | XIMStatusNone,
+ XIMPreeditNothing | XIMStatusArea,
+ XIMPreeditNothing | XIMStatusNothing,
+ XIMPreeditNothing | XIMStatusNone,
+ XIMPreeditNone | XIMStatusArea,
+ XIMPreeditNone | XIMStatusNothing,
+ XIMPreeditNone | XIMStatusNone,
+ 0,
+};
+
+
+/* Create an X fontset on frame F with base font name
+ BASE_FONTNAME.. */
+
+static XFontSet
+xic_create_xfontset (f, base_fontname)
+ struct frame *f;
+ char *base_fontname;
+{
+ XFontSet xfs;
+ char **missing_list;
+ int missing_count;
+ char *def_string;
+
+ xfs = XCreateFontSet (FRAME_X_DISPLAY (f),
+ base_fontname, &missing_list,
+ &missing_count, &def_string);
+ if (missing_list)
+ XFreeStringList (missing_list);
+
+ /* No need to free def_string. */
+ return xfs;
+}
+
+
+/* Value is the best input style, given user preferences USER (already
+ checked to be supported by Emacs), and styles supported by the
+ input method XIM. */
+
+static XIMStyle
+best_xim_style (user, xim)
+ XIMStyles *user;
+ XIMStyles *xim;
+{
+ int i, j;
+
+ for (i = 0; i < user->count_styles; ++i)
+ for (j = 0; j < xim->count_styles; ++j)
+ if (user->supported_styles[i] == xim->supported_styles[j])
+ return user->supported_styles[i];
+
+ /* Return the default style. */
+ return XIMPreeditNothing | XIMStatusNothing;
+}
+
+/* Create XIC for frame F. */
+
+void
+create_frame_xic (f)
+ struct frame *f;
+{
+#ifndef X_I18N_INHIBITED
+ XIM xim;
+ XIC xic = NULL;
+ XFontSet xfs = NULL;
+ static XIMStyle xic_style;
+
+ if (FRAME_XIC (f))
+ return;
+
+ xim = FRAME_X_XIM (f);
+ if (xim)
+ {
+ XRectangle s_area;
+ XPoint spot;
+ XVaNestedList preedit_attr;
+ XVaNestedList status_attr;
+ char *base_fontname;
+ int fontset;
+
+ s_area.x = 0; s_area.y = 0; s_area.width = 1; s_area.height = 1;
+ spot.x = 0; spot.y = 1;
+ /* Create X fontset. */
+ fontset = FRAME_FONTSET (f);
+ if (fontset < 0)
+ base_fontname = "-*-*-*-r-normal--14-*-*-*-*-*-*-*";
+ else
+ {
+ struct fontset_info *fontsetp;
+ int len = 0;
+ int i;
+
+ fontsetp = FRAME_FONTSET_DATA (f)->fontset_table[fontset];
+ for (i = 0; i <= MAX_CHARSET; i++)
+ if (fontsetp->fontname[i])
+ len += strlen (fontsetp->fontname[i]) + 1;
+ base_fontname = alloca (len);
+ strcpy (base_fontname, fontsetp->fontname[CHARSET_ASCII]);
+ for (i = MIN_CHARSET_OFFICIAL_DIMENSION1; i <= MAX_CHARSET; i++)
+ if (fontsetp->fontname[i])
+ {
+ strcat (base_fontname, ",");
+ strcat (base_fontname, fontsetp->fontname[i]);
+ }
+ }
+ xfs = xic_create_xfontset (f, base_fontname);
+
+ /* Determine XIC style. */
+ if (xic_style == 0)
+ {
+ XIMStyles supported_list;
+ supported_list.count_styles = (sizeof supported_xim_styles
+ / sizeof supported_xim_styles[0]);
+ supported_list.supported_styles = supported_xim_styles;
+ xic_style = best_xim_style (&supported_list,
+ FRAME_X_XIM_STYLES (f));
+ }
+
+ preedit_attr = XVaCreateNestedList (0,
+ XNFontSet, xfs,
+ XNForeground,
+ FRAME_FOREGROUND_PIXEL (f),
+ XNBackground,
+ FRAME_BACKGROUND_PIXEL (f),
+ (xic_style & XIMPreeditPosition
+ ? XNSpotLocation
+ : NULL),
+ &spot,
+ NULL);
+ status_attr = XVaCreateNestedList (0,
+ XNArea,
+ &s_area,
+ XNFontSet,
+ xfs,
+ XNForeground,
+ FRAME_FOREGROUND_PIXEL (f),
+ XNBackground,
+ FRAME_BACKGROUND_PIXEL (f),
+ NULL);
+
+ xic = XCreateIC (xim,
+ XNInputStyle, xic_style,
+ XNClientWindow, FRAME_X_WINDOW(f),
+ XNFocusWindow, FRAME_X_WINDOW(f),
+ XNStatusAttributes, status_attr,
+ XNPreeditAttributes, preedit_attr,
+ NULL);
+ XFree (preedit_attr);
+ XFree (status_attr);
+ }
+
+ FRAME_XIC (f) = xic;
+ FRAME_XIC_STYLE (f) = xic_style;
+ FRAME_XIC_FONTSET (f) = xfs;
+#else /* X_I18N_INHIBITED */
+ FRAME_XIC (f) = NULL;
+ FRAME_XIC_STYLE (f) = 0;
+ FRAME_XIC_FONTSET (f) = NULL;
+#endif /* X_I18N_INHIBITED */
+}
+
+
+/* Destroy XIC and free XIC fontset of frame F, if any. */
+
+void
+free_frame_xic (f)
+ struct frame *f;
+{
+ if (FRAME_XIC (f) == NULL)
+ return;
+
+ XDestroyIC (FRAME_XIC (f));
+ if (FRAME_XIC_FONTSET (f))
+ XFreeFontSet (FRAME_X_DISPLAY (f), FRAME_XIC_FONTSET (f));
+
+ FRAME_XIC (f) = NULL;
+ FRAME_XIC_FONTSET (f) = NULL;
+}
+
+
+/* Place preedit area for XIC of window W's frame to specified
+ pixel position X/Y. X and Y are relative to window W. */
+
+void
+xic_set_preeditarea (w, x, y)
+ struct window *w;
+ int x, y;
+{
+ struct frame *f = XFRAME (w->frame);
+ XVaNestedList attr;
+ XPoint spot;
+
+ spot.x = WINDOW_TO_FRAME_PIXEL_X (w, x);
+ spot.y = WINDOW_TO_FRAME_PIXEL_Y (w, y) + FONT_BASE (FRAME_FONT (f));
+ attr = XVaCreateNestedList (0, XNSpotLocation, &spot, NULL);
+ XSetICValues (FRAME_XIC (f), XNPreeditAttributes, attr, NULL);
+ XFree (attr);
+}
+
+
+/* Place status area for XIC in bottom right corner of frame F.. */
+
+void
+xic_set_statusarea (f)
+ struct frame *f;
+{
+ XIC xic = FRAME_XIC (f);
+ XVaNestedList attr;
+ XRectangle area;
+ XRectangle *needed;
+
+ /* Negotiate geometry of status area. If input method has existing
+ status area, use its current size. */
+ area.x = area.y = area.width = area.height = 0;
+ attr = XVaCreateNestedList (0, XNAreaNeeded, &area, NULL);
+ XSetICValues (xic, XNStatusAttributes, attr, NULL);
+ XFree (attr);
+
+ attr = XVaCreateNestedList (0, XNAreaNeeded, &needed, NULL);
+ XGetICValues (xic, XNStatusAttributes, attr, NULL);
+ XFree (attr);
+
+ if (needed->width == 0) /* Use XNArea instead of XNAreaNeeded */
+ {
+ attr = XVaCreateNestedList (0, XNArea, &needed, NULL);
+ XGetICValues (xic, XNStatusAttributes, attr, NULL);
+ XFree (attr);
+ }
+
+ area.width = needed->width;
+ area.height = needed->height;
+ area.x = PIXEL_WIDTH (f) - area.width - FRAME_INTERNAL_BORDER_WIDTH (f);
+ area.y = (PIXEL_HEIGHT (f) - area.height
+ - FRAME_MENUBAR_HEIGHT (f) - FRAME_INTERNAL_BORDER_WIDTH (f));
+ XFree (needed);
+
+ attr = XVaCreateNestedList (0, XNArea, &area, NULL);
+ XSetICValues(xic, XNStatusAttributes, attr, NULL);
+ XFree (attr);
+}
+
+
+/* Set X fontset for XIC of frame F, using base font name
+ BASE_FONTNAME. Called when a new Emacs fontset is chosen. */
+
+void
+xic_set_xfontset (f, base_fontname)
+ struct frame *f;
+ char *base_fontname;
+{
+ XVaNestedList attr;
+ XFontSet xfs;
+
+ xfs = xic_create_xfontset (f, base_fontname);
+
+ attr = XVaCreateNestedList (0, XNFontSet, xfs, NULL);
+ if (FRAME_XIC_STYLE (f) & XIMPreeditPosition)
+ XSetICValues (FRAME_XIC (f), XNPreeditAttributes, attr, NULL);
+ if (FRAME_XIC_STYLE (f) & XIMStatusArea)
+ XSetICValues (FRAME_XIC (f), XNStatusAttributes, attr, NULL);
+ XFree (attr);
+
+ if (FRAME_XIC_FONTSET (f))
+ XFreeFontSet (FRAME_X_DISPLAY (f), FRAME_XIC_FONTSET (f));
+ FRAME_XIC_FONTSET (f) = xfs;
+}
+
+#endif /* HAVE_X_I18N */
+
+
\f
#ifdef USE_X_TOOLKIT
shell_widget, False,
(lw_callback) NULL,
(lw_callback) NULL,
+ (lw_callback) NULL,
(lw_callback) NULL);
f->output_data.x->column_widget = pane_widget;
XSetClassHint (FRAME_X_DISPLAY (f), XtWindow (shell_widget), &class_hints);
#ifdef HAVE_X_I18N
-#ifndef X_I18N_INHIBITED
- {
- XIM xim;
- XIC xic = NULL;
-
- xim = XOpenIM (FRAME_X_DISPLAY (f), NULL, NULL, NULL);
-
- if (xim)
- {
- xic = XCreateIC (xim,
- XNInputStyle, XIMPreeditNothing | XIMStatusNothing,
- XNClientWindow, FRAME_X_WINDOW(f),
- XNFocusWindow, FRAME_X_WINDOW(f),
- NULL);
-
- if (xic == 0)
- {
- XCloseIM (xim);
- xim = NULL;
- }
- }
- FRAME_XIM (f) = xim;
- FRAME_XIC (f) = xic;
- }
-#else /* X_I18N_INHIBITED */
- FRAME_XIM (f) = 0;
- FRAME_XIC (f) = 0;
-#endif /* X_I18N_INHIBITED */
-#endif /* HAVE_X_I18N */
+ FRAME_XIC (f) = NULL;
+ create_frame_xic (f);
+#endif
f->output_data.x->wm_hints.input = True;
f->output_data.x->wm_hints.flags |= InputHint;
XA_ATOM, 32, PropModeAppend,
(unsigned char*) NULL, 0);
- /* Make all the standard events reach the Emacs frame. */
+ /* Make all the standard events reach the Emacs frame. */
attributes.event_mask = STANDARD_EVENT_SET;
+
+#ifdef HAVE_X_I18N
+ if (FRAME_XIC (f))
+ {
+ /* XIM server might require some X events. */
+ unsigned long fevent = NoEventMask;
+ XGetICValues(FRAME_XIC (f), XNFilterEvents, &fevent, NULL);
+ attributes.event_mask |= fevent;
+ }
+#endif /* HAVE_X_I18N */
+
attribute_mask = CWEventMask;
XChangeWindowAttributes (XtDisplay (shell_widget), XtWindow (shell_widget),
attribute_mask, &attributes);
InputOutput, /* class */
FRAME_X_DISPLAY_INFO (f)->visual,
attribute_mask, &attributes);
-#ifdef HAVE_X_I18N
-#ifndef X_I18N_INHIBITED
- {
- XIM xim;
- XIC xic = NULL;
-
- xim = XOpenIM (FRAME_X_DISPLAY(f), NULL, NULL, NULL);
-
- if (xim)
- {
- xic = XCreateIC (xim,
- XNInputStyle, XIMPreeditNothing | XIMStatusNothing,
- XNClientWindow, FRAME_X_WINDOW(f),
- XNFocusWindow, FRAME_X_WINDOW(f),
- NULL);
-
- if (!xic)
- {
- XCloseIM (xim);
- xim = NULL;
- }
- }
- FRAME_XIM (f) = xim;
- FRAME_XIC (f) = xic;
- }
-#else /* X_I18N_INHIBITED */
- FRAME_XIM (f) = 0;
- FRAME_XIC (f) = 0;
-#endif /* X_I18N_INHIBITED */
+#ifdef HAVE_X_I18N
+ create_frame_xic (f);
+ if (FRAME_XIC (f))
+ {
+ /* XIM server might require some X events. */
+ unsigned long fevent = NoEventMask;
+ XGetICValues(FRAME_XIC (f), XNFilterEvents, &fevent, NULL);
+ attributes.event_mask |= fevent;
+ attribute_mask = CWEventMask;
+ XChangeWindowAttributes (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
+ attribute_mask, &attributes);
+ }
#endif /* HAVE_X_I18N */
-
+
validate_x_resource_name ();
class_hints.res_name = (char *) XSTRING (Vx_resource_name)->data;
"menuBar", "MenuBar", RES_TYPE_NUMBER);
x_default_parameter (f, parms, Qtool_bar_lines, make_number (0),
"toolBar", "ToolBar", RES_TYPE_NUMBER);
- x_default_parameter (f, parms, Qscroll_bar_width, Qnil,
- "scrollBarWidth", "ScrollBarWidth",
- RES_TYPE_NUMBER);
x_default_parameter (f, parms, Qbuffer_predicate, Qnil,
"bufferPredicate", "BufferPredicate",
RES_TYPE_SYMBOL);
"autoLower", "AutoRaiseLower", RES_TYPE_BOOLEAN);
x_default_parameter (f, parms, Qcursor_type, Qbox,
"cursorType", "CursorType", RES_TYPE_SYMBOL);
+ x_default_parameter (f, parms, Qscroll_bar_width, Qnil,
+ "scrollBarWidth", "ScrollBarWidth",
+ RES_TYPE_NUMBER);
/* Dimensions, especially f->height, must be done via change_frame_size.
Change will not be effected unless different from the current
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 int x_build_heuristic_mask P_ ((struct frame *, Lisp_Object,
- struct image *, Lisp_Object));
+static int x_build_heuristic_mask P_ ((struct frame *, struct image *,
+ Lisp_Object));
/* Define a new image type from TYPE. This adds a copy of TYPE to
/* Should we built a mask heuristically? */
heuristic_mask = image_spec_value (spec, QCheuristic_mask, NULL);
if (img->pixmap && !img->mask && !NILP (heuristic_mask))
- {
- file = image_spec_value (spec, QCfile, NULL);
- x_build_heuristic_mask (f, file, img, heuristic_mask);
- }
+ x_build_heuristic_mask (f, img, heuristic_mask);
}
}
X support code
***********************************************************************/
-static int x_create_x_image_and_pixmap P_ ((struct frame *, Lisp_Object,
- int, int, int, XImage **,
- Pixmap *));
+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));
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. FILE is the name of an image file being processed, for
- error messages. Value is non-zero if successful. */
+ occurs. Value is non-zero if successful. */
static int
-x_create_x_image_and_pixmap (f, file, width, height, depth, ximg, pixmap)
+x_create_x_image_and_pixmap (f, width, height, depth, ximg, pixmap)
struct frame *f;
- Lisp_Object file;
int width, height, depth;
XImage **ximg;
Pixmap *pixmap;
depth > 16 ? 32 : depth > 8 ? 16 : 8, 0);
if (*ximg == NULL)
{
- image_error ("Unable to allocate X image for %s", file, Qnil);
+ image_error ("Unable to allocate X image", Qnil, Qnil);
return 0;
}
{
x_destroy_x_image (*ximg);
*ximg = NULL;
- image_error ("Unable to create pixmap for `%s'", file, Qnil);
+ image_error ("Unable to create X pixmap", Qnil, Qnil);
return 0;
}
file = x_find_image_file (specified_file);
if (!STRINGP (file))
{
- image_error ("Cannot find image file %s", specified_file, Qnil);
+ image_error ("Cannot find image file `%s'", specified_file, Qnil);
UNGCPRO;
return 0;
}
UNBLOCK_INPUT;
}
else
- image_error ("Error loading XBM image %s", img->spec, Qnil);
+ image_error ("Error loading XBM image `%s'", img->spec, Qnil);
UNGCPRO;
return success_p;
success_p = 1;
else
{
- image_error ("Unable to create pixmap for XBM image", Qnil, Qnil);
+ image_error ("Unable to create pixmap for XBM image `%s'",
+ img->spec, Qnil);
x_clear_image (f, img);
}
Lisp_Object file = x_find_image_file (specified_file);
if (!STRINGP (file))
{
- image_error ("Cannot find image file %s", specified_file, Qnil);
+ image_error ("Cannot find image file `%s'", specified_file, Qnil);
UNBLOCK_INPUT;
return 0;
}
out = (long *) alloca (img->width * sizeof (long));
/* Create an X image for output. */
- rc = x_create_x_image_and_pixmap (f, Qnil, img->width, img->height, 0,
+ rc = x_create_x_image_and_pixmap (f, img->width, img->height, 0,
&oimg, &pixmap);
/* Fill first two rows. */
heuristically. Value is non-zero if successful. */
static int
-x_build_heuristic_mask (f, file, img, how)
+x_build_heuristic_mask (f, img, how)
struct frame *f;
- Lisp_Object file;
struct image *img;
Lisp_Object how;
{
BLOCK_INPUT;
/* Create an image and pixmap serving as mask. */
- rc = x_create_x_image_and_pixmap (f, file, img->width, img->height, 1,
+ rc = x_create_x_image_and_pixmap (f, img->width, img->height, 1,
&mask_img, &img->mask);
if (!rc)
{
static int pbm_image_p P_ ((Lisp_Object object));
static int pbm_load P_ ((struct frame *f, struct image *img));
-static int pbm_scan_number P_ ((FILE *fp));
+static int pbm_scan_number P_ ((unsigned char **, unsigned char *));
/* The symbol `pbm' identifying images of this type. */
{
PBM_TYPE,
PBM_FILE,
+ PBM_DATA,
PBM_ASCENT,
PBM_MARGIN,
PBM_RELIEF,
static struct image_keyword pbm_format[PBM_LAST] =
{
{":type", IMAGE_SYMBOL_VALUE, 1},
- {":file", IMAGE_STRING_VALUE, 1},
+ {":file", IMAGE_STRING_VALUE, 0},
+ {":data", IMAGE_STRING_VALUE, 0},
{":ascent", IMAGE_NON_NEGATIVE_INTEGER_VALUE, 0},
{":margin", IMAGE_POSITIVE_INTEGER_VALUE, 0},
{":relief", IMAGE_INTEGER_VALUE, 0},
|| (fmt[PBM_ASCENT].count
&& XFASTINT (fmt[PBM_ASCENT].value) > 100))
return 0;
- return 1;
+
+ /* Must specify either :data or :file. */
+ return fmt[PBM_DATA].count + fmt[PBM_FILE].count == 1;
}
-/* Scan a decimal number from PBM input file FP and return it. Value
- is -1 at end of file or if an error occurs. */
+/* Scan a decimal number from *S and return it. Advance *S while
+ reading the number. END is the end of the string. Value is -1 at
+ end of input. */
static int
-pbm_scan_number (fp)
- FILE *fp;
+pbm_scan_number (s, end)
+ unsigned char **s, *end;
{
int c, val = -1;
- while (!feof (fp))
+ while (*s < end)
{
/* Skip white-space. */
- while ((c = fgetc (fp)) != EOF && isspace (c))
+ while (*s < end && (c = *(*s)++, isspace (c)))
;
if (c == '#')
{
/* Skip comment to end of line. */
- while ((c = fgetc (fp)) != EOF && c != '\n')
+ while (*s < end && (c = *(*s)++, c != '\n'))
;
}
else if (isdigit (c))
{
/* Read decimal number. */
val = c - '0';
- while ((c = fgetc (fp)) != EOF && isdigit (c))
+ while (*s < end && (c = *(*s)++, isdigit (c)))
val = 10 * val + c - '0';
break;
}
}
+/* 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. */
+
+static char *
+pbm_read_file (file, size)
+ Lisp_Object file;
+ int *size;
+{
+ FILE *fp = NULL;
+ char *buf = NULL;
+ struct stat st;
+
+ if (stat (XSTRING (file)->data, &st) == 0
+ && (fp = fopen (XSTRING (file)->data, "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;
+}
+
+
/* Load PBM image IMG for use on frame F. */
static int
struct frame *f;
struct image *img;
{
- FILE *fp;
- char magic[2];
int raw_p, x, y;
int width, height, max_color_idx = 0;
XImage *ximg;
Lisp_Object file, specified_file;
enum {PBM_MONO, PBM_GRAY, PBM_COLOR} type;
struct gcpro gcpro1;
+ unsigned char *contents = NULL;
+ unsigned char *end, *p;
+ int size;
specified_file = image_spec_value (img->spec, QCfile, NULL);
- file = x_find_image_file (specified_file);
+ file = Qnil;
GCPRO1 (file);
- if (!STRINGP (file))
- {
- image_error ("Cannot find image file %s", specified_file, Qnil);
- UNGCPRO;
- return 0;
- }
- fp = fopen (XSTRING (file)->data, "r");
- if (fp == NULL)
+ if (STRINGP (specified_file))
{
- UNGCPRO;
- return 0;
- }
+ file = x_find_image_file (specified_file);
+ if (!STRINGP (file))
+ {
+ image_error ("Cannot find image file `%s'", specified_file, Qnil);
+ UNGCPRO;
+ return 0;
+ }
+
+ contents = pbm_read_file (file, &size);
+ if (contents == NULL)
+ {
+ image_error ("Error reading `%s'", file, Qnil);
+ UNGCPRO;
+ return 0;
+ }
- /* Read first two characters. */
- if (fread (magic, sizeof *magic, 2, fp) != 2)
+ p = contents;
+ end = contents + size;
+ }
+ else
{
- fclose (fp);
- image_error ("Not a PBM image file: %s", file, Qnil);
- UNGCPRO;
- return 0;
+ Lisp_Object data;
+ data = image_spec_value (img->spec, QCdata, NULL);
+ p = XSTRING (data)->data;
+ end = p + STRING_BYTES (XSTRING (data));
}
- if (*magic != 'P')
+ /* Check magic number. */
+ if (end - p < 2 || *p++ != 'P')
{
- fclose (fp);
- image_error ("Not a PBM image file: %s", file, Qnil);
+ image_error ("Not a PBM image: `%s'", img->spec, Qnil);
+ error:
+ xfree (contents);
UNGCPRO;
return 0;
}
- switch (magic[1])
+ switch (*p++)
{
case '1':
raw_p = 0, type = PBM_MONO;
break;
default:
- fclose (fp);
- image_error ("Not a PBM image file: %s", file, Qnil);
- UNGCPRO;
- return 0;
+ image_error ("Not a PBM image: `%s'", img->spec, Qnil);
+ goto error;
}
/* Read width, height, maximum color-component. Characters
starting with `#' up to the end of a line are ignored. */
- width = pbm_scan_number (fp);
- height = pbm_scan_number (fp);
+ width = pbm_scan_number (&p, end);
+ height = pbm_scan_number (&p, end);
if (type != PBM_MONO)
{
- max_color_idx = pbm_scan_number (fp);
+ max_color_idx = pbm_scan_number (&p, end);
if (raw_p && max_color_idx > 255)
max_color_idx = 255;
}
- if (width < 0 || height < 0
+ if (width < 0
+ || height < 0
|| (type != PBM_MONO && max_color_idx < 0))
- {
- fclose (fp);
- UNGCPRO;
- return 0;
- }
+ goto error;
BLOCK_INPUT;
- if (!x_create_x_image_and_pixmap (f, file, width, height, 0,
+ if (!x_create_x_image_and_pixmap (f, width, height, 0,
&ximg, &img->pixmap))
{
- fclose (fp);
UNBLOCK_INPUT;
- UNGCPRO;
- return 0;
+ goto error;
}
/* Initialize the color hash table. */
if (raw_p)
{
if ((x & 7) == 0)
- c = fgetc (fp);
+ c = *p++;
g = c & 0x80;
c <<= 1;
}
else
- g = pbm_scan_number (fp);
+ g = pbm_scan_number (&p, end);
XPutPixel (ximg, x, y, (g
? FRAME_FOREGROUND_PIXEL (f)
int r, g, b;
if (type == PBM_GRAY)
- r = g = b = raw_p ? fgetc (fp) : pbm_scan_number (fp);
+ r = g = b = raw_p ? *p++ : pbm_scan_number (&p, end);
else if (raw_p)
{
- r = fgetc (fp);
- g = fgetc (fp);
- b = fgetc (fp);
+ r = *p++;
+ g = *p++;
+ b = *p++;
}
else
{
- r = pbm_scan_number (fp);
- g = pbm_scan_number (fp);
- b = pbm_scan_number (fp);
+ r = pbm_scan_number (&p, end);
+ g = pbm_scan_number (&p, end);
+ b = pbm_scan_number (&p, end);
}
if (r < 0 || g < 0 || b < 0)
{
- fclose (fp);
xfree (ximg->data);
ximg->data = NULL;
XDestroyImage (ximg);
UNBLOCK_INPUT;
- image_error ("Invalid pixel value in file `%s'",
- file, Qnil);
- UNGCPRO;
- return 0;
+ image_error ("Invalid pixel value in image `%s'",
+ img->spec, Qnil);
+ goto error;
}
/* RGB values are now in the range 0..max_color_idx.
}
}
- fclose (fp);
-
/* Store in IMG->colors the colors allocated for the image, and
free the color table. */
img->colors = colors_in_color_table (&img->ncolors);
img->height = height;
UNGCPRO;
+ xfree (contents);
return 1;
}
enum png_keyword_index
{
PNG_TYPE,
+ PNG_DATA,
PNG_FILE,
PNG_ASCENT,
PNG_MARGIN,
static struct image_keyword png_format[PNG_LAST] =
{
{":type", IMAGE_SYMBOL_VALUE, 1},
- {":file", IMAGE_STRING_VALUE, 1},
+ {":data", IMAGE_STRING_VALUE, 0},
+ {":file", IMAGE_STRING_VALUE, 0},
{":ascent", IMAGE_NON_NEGATIVE_INTEGER_VALUE, 0},
{":margin", IMAGE_POSITIVE_INTEGER_VALUE, 0},
{":relief", IMAGE_INTEGER_VALUE, 0},
|| (fmt[PNG_ASCENT].count
&& XFASTINT (fmt[PNG_ASCENT].value) > 100))
return 0;
- return 1;
+
+ /* Must specify either the :data or :file keyword. */
+ return fmt[PNG_FILE].count + fmt[PNG_DATA].count == 1;
}
image_error ("PNG warning: %s", build_string (msg), Qnil);
}
+/* Memory source for PNG decoding. */
+
+struct png_memory_storage
+{
+ unsigned char *bytes; /* The data */
+ size_t len; /* How big is it? */
+ int index; /* Where are we? */
+};
+
+
+/* Function set as reader function when reading PNG image from memory.
+ PNG_PTR is a pointer to the PNG control structure. Copy LENGTH
+ bytes from the input to DATA. */
+
+static void
+png_read_from_memory (png_ptr, data, length)
+ png_structp png_ptr;
+ png_bytep data;
+ png_size_t length;
+{
+ struct png_memory_storage *tbr
+ = (struct png_memory_storage *) png_get_io_ptr (png_ptr);
+
+ if (length > tbr->len - tbr->index)
+ png_error (png_ptr, "Read error");
+
+ bcopy (tbr->bytes + tbr->index, data, length);
+ tbr->index = tbr->index + length;
+}
/* Load PNG image IMG for use on frame F. Value is non-zero if
successful. */
struct image *img;
{
Lisp_Object file, specified_file;
+ Lisp_Object specified_data;
int x, y, i;
XImage *ximg, *mask_img = NULL;
struct gcpro gcpro1;
png_struct *png_ptr = NULL;
png_info *info_ptr = NULL, *end_info = NULL;
- FILE *fp;
+ FILE *fp = NULL;
png_byte sig[8];
png_byte *pixels = NULL;
png_byte **rows = NULL;
char *gamma_str;
double screen_gamma, image_gamma;
int intent;
+ struct png_memory_storage tbr; /* Data to be read */
/* Find out what file to load. */
specified_file = image_spec_value (img->spec, QCfile, NULL);
- file = x_find_image_file (specified_file);
+ specified_data = image_spec_value (img->spec, QCdata, NULL);
+ file = Qnil;
GCPRO1 (file);
- if (!STRINGP (file))
- {
- image_error ("Cannot find image file %s", specified_file, Qnil);
- UNGCPRO;
- return 0;
- }
- /* Open the image file. */
- fp = fopen (XSTRING (file)->data, "rb");
- if (!fp)
+ if (NILP (specified_data))
{
- image_error ("Cannot open image file %s", file, Qnil);
- UNGCPRO;
- fclose (fp);
- return 0;
- }
+ file = x_find_image_file (specified_file);
+ if (!STRINGP (file))
+ {
+ image_error ("Cannot find image file `%s'", specified_file, Qnil);
+ UNGCPRO;
+ return 0;
+ }
+
+ /* Open the image file. */
+ fp = fopen (XSTRING (file)->data, "rb");
+ if (!fp)
+ {
+ 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))
+ /* 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;
+ }
+ }
+ else
{
- image_error ("Not a PNG file: %s", file, Qnil);
- UNGCPRO;
- fclose (fp);
- return 0;
+ /* Read from memory. */
+ tbr.bytes = XSTRING (specified_data)->data;
+ tbr.len = STRING_BYTES (XSTRING (specified_data));
+ tbr.index = 0;
+
+ /* Check PNG signature. */
+ if (tbr.len < sizeof sig
+ || !png_check_sig (tbr.bytes, sizeof sig))
+ {
+ image_error ("Not a PNG image: `%s'", img->spec, Qnil);
+ UNGCPRO;
+ return 0;
+ }
+
+ /* Need to skip past the signature. */
+ tbr.bytes += sizeof (sig);
}
/* Initialize read and info structs for PNG lib. */
my_png_error, my_png_warning);
if (!png_ptr)
{
- fclose (fp);
+ if (fp) fclose (fp);
UNGCPRO;
return 0;
}
if (!info_ptr)
{
png_destroy_read_struct (&png_ptr, NULL, NULL);
- fclose (fp);
+ if (fp) fclose (fp);
UNGCPRO;
return 0;
}
if (!end_info)
{
png_destroy_read_struct (&png_ptr, &info_ptr, NULL);
- fclose (fp);
+ if (fp) fclose (fp);
UNGCPRO;
return 0;
}
png_destroy_read_struct (&png_ptr, &info_ptr, &end_info);
xfree (pixels);
xfree (rows);
- if (fp)
- fclose (fp);
+ if (fp) fclose (fp);
UNGCPRO;
return 0;
}
/* Read image info. */
- png_init_io (png_ptr, fp);
+ if (!NILP (specified_data))
+ png_set_read_fn (png_ptr, (void *) &tbr, png_read_from_memory);
+ else
+ 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,
/* Read the entire image. */
png_read_image (png_ptr, rows);
png_read_end (png_ptr, info_ptr);
- fclose (fp);
- fp = NULL;
+ if (fp)
+ {
+ fclose (fp);
+ fp = NULL;
+ }
BLOCK_INPUT;
/* Create the X image and pixmap. */
- if (!x_create_x_image_and_pixmap (f, file, width, height, 0, &ximg,
+ if (!x_create_x_image_and_pixmap (f, width, height, 0, &ximg,
&img->pixmap))
{
UNBLOCK_INPUT;
contains an alpha channel. */
if (channels == 4
&& !transparent_p
- && !x_create_x_image_and_pixmap (f, file, width, height, 1,
+ && !x_create_x_image_and_pixmap (f, width, height, 1,
&mask_img, &img->mask))
{
x_destroy_x_image (ximg);
enum jpeg_keyword_index
{
JPEG_TYPE,
+ JPEG_DATA,
JPEG_FILE,
JPEG_ASCENT,
JPEG_MARGIN,
static struct image_keyword jpeg_format[JPEG_LAST] =
{
{":type", IMAGE_SYMBOL_VALUE, 1},
- {":file", IMAGE_STRING_VALUE, 1},
+ {":data", IMAGE_STRING_VALUE, 0},
+ {":file", IMAGE_STRING_VALUE, 0},
{":ascent", IMAGE_NON_NEGATIVE_INTEGER_VALUE, 0},
{":margin", IMAGE_POSITIVE_INTEGER_VALUE, 0},
{":relief", IMAGE_INTEGER_VALUE, 0},
|| (fmt[JPEG_ASCENT].count
&& XFASTINT (fmt[JPEG_ASCENT].value) > 100))
return 0;
- return 1;
+
+ /* Must specify either the :data or :file keyword. */
+ return fmt[JPEG_FILE].count + fmt[JPEG_DATA].count == 1;
}
+
struct my_jpeg_error_mgr
{
struct jpeg_error_mgr pub;
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. */
+
+static void
+our_init_source (cinfo)
+ j_decompress_ptr cinfo;
+{
+}
+
+
+/* Fill input buffer method for JPEG data source manager. Called
+ whenever more data is needed. We read the whole image in one step,
+ so this only adds a fake end of input marker at the end. */
+
+static boolean
+our_fill_input_buffer (cinfo)
+ j_decompress_ptr cinfo;
+{
+ /* Insert a fake EOI marker. */
+ struct jpeg_source_mgr *src = cinfo->src;
+ static JOCTET buffer[2];
+
+ buffer[0] = (JOCTET) 0xFF;
+ buffer[1] = (JOCTET) JPEG_EOI;
+
+ src->next_input_byte = buffer;
+ src->bytes_in_buffer = 2;
+ return TRUE;
+}
+
+
+/* Method to skip over NUM_BYTES bytes in the image data. CINFO->src
+ is the JPEG data source manager. */
+
+static void
+our_skip_input_data (cinfo, num_bytes)
+ j_decompress_ptr cinfo;
+ long num_bytes;
+{
+ struct jpeg_source_mgr *src = (struct jpeg_source_mgr *) cinfo->src;
+
+ if (src)
+ {
+ if (num_bytes > src->bytes_in_buffer)
+ ERREXIT (cinfo, JERR_INPUT_EOF);
+
+ src->bytes_in_buffer -= num_bytes;
+ src->next_input_byte += num_bytes;
+ }
+}
+
+
+/* Method to terminate data source. Called by
+ jpeg_finish_decompress() after all data has been processed. */
+
+static void
+our_term_source (cinfo)
+ j_decompress_ptr cinfo;
+{
+}
+
+
+/* Set up the JPEG lib for reading an image from DATA which contains
+ LEN bytes. CINFO is the decompression info structure created for
+ reading the image. */
+
+static void
+jpeg_memory_src (cinfo, data, len)
+ j_decompress_ptr cinfo;
+ JOCTET *data;
+ unsigned int len;
+{
+ struct jpeg_source_mgr *src;
+
+ if (cinfo->src == NULL)
+ {
+ /* First time for this JPEG object? */
+ cinfo->src = (struct jpeg_source_mgr *)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
+ sizeof (struct jpeg_source_mgr));
+ 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->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. */
struct jpeg_decompress_struct cinfo;
struct my_jpeg_error_mgr mgr;
Lisp_Object file, specified_file;
- FILE *fp;
+ Lisp_Object specified_data;
+ FILE *fp = NULL;
JSAMPARRAY buffer;
int row_stride, x, y;
XImage *ximg = NULL;
/* Open the JPEG file. */
specified_file = image_spec_value (img->spec, QCfile, NULL);
- file = x_find_image_file (specified_file);
+ specified_data = image_spec_value (img->spec, QCdata, NULL);
+ file = Qnil;
GCPRO1 (file);
- if (!STRINGP (file))
+
+ if (NILP (specified_data))
{
- image_error ("Cannot find image file %s", specified_file, Qnil);
- UNGCPRO;
- return 0;
- }
+ 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");
- if (fp == NULL)
- {
- image_error ("Cannot open `%s'", file, Qnil);
- UNGCPRO;
- return 0;
+ fp = fopen (XSTRING (file)->data, "r");
+ if (fp == NULL)
+ {
+ 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. */
+ /* Customize libjpeg's error handling to call my_error_exit when an
+ error is detected. This function will perform a longjmp. */
mgr.pub.error_exit = my_error_exit;
cinfo.err = jpeg_std_error (&mgr.pub);
/* Called from my_error_exit. Display a JPEG error. */
char buffer[JMSG_LENGTH_MAX];
cinfo.err->format_message ((j_common_ptr) &cinfo, buffer);
- image_error ("Error reading JPEG file `%s': %s", file,
+ image_error ("Error reading JPEG image `%s': %s", img->spec,
build_string (buffer));
}
/* Close the input file and destroy the JPEG object. */
- fclose (fp);
+ if (fp)
+ fclose (fp);
jpeg_destroy_decompress (&cinfo);
BLOCK_INPUT;
}
/* Create the JPEG decompression object. Let it read from fp.
- Read the JPEG image header. */
+ Read the JPEG image header. */
jpeg_create_decompress (&cinfo);
- jpeg_stdio_src (&cinfo, fp);
+
+ if (NILP (specified_data))
+ jpeg_stdio_src (&cinfo, fp);
+ else
+ jpeg_memory_src (&cinfo, XSTRING (specified_data)->data,
+ STRING_BYTES (XSTRING (specified_data)));
+
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);
width = img->width = cinfo.output_width;
BLOCK_INPUT;
/* Create X image and pixmap. */
- if (!x_create_x_image_and_pixmap (f, file, width, height, 0, &ximg,
- &img->pixmap))
+ if (!x_create_x_image_and_pixmap (f, width, height, 0, &ximg, &img->pixmap))
{
UNBLOCK_INPUT;
longjmp (mgr.setjmp_buffer, 2);
/* Clean up. */
jpeg_finish_decompress (&cinfo);
jpeg_destroy_decompress (&cinfo);
- fclose (fp);
+ if (fp)
+ fclose (fp);
/* Put the image into the pixmap. */
x_put_x_image (f, ximg, img->pixmap, width, height);
enum tiff_keyword_index
{
TIFF_TYPE,
+ TIFF_DATA,
TIFF_FILE,
TIFF_ASCENT,
TIFF_MARGIN,
static struct image_keyword tiff_format[TIFF_LAST] =
{
{":type", IMAGE_SYMBOL_VALUE, 1},
- {":file", IMAGE_STRING_VALUE, 1},
+ {":data", IMAGE_STRING_VALUE, 0},
+ {":file", IMAGE_STRING_VALUE, 0},
{":ascent", IMAGE_NON_NEGATIVE_INTEGER_VALUE, 0},
{":margin", IMAGE_POSITIVE_INTEGER_VALUE, 0},
{":relief", IMAGE_INTEGER_VALUE, 0},
|| (fmt[TIFF_ASCENT].count
&& XFASTINT (fmt[TIFF_ASCENT].value) > 100))
return 0;
- return 1;
+
+ /* Must specify either the :data or :file keyword. */
+ return fmt[TIFF_FILE].count + fmt[TIFF_DATA].count == 1;
+}
+
+
+/* Reading from a memory buffer for TIFF images Based on the PNG
+ memory source, but we have to provide a lot of extra functions.
+ Blah.
+
+ We really only need to implement read and seek, but I am not
+ convinced that the TIFF library is smart enough not to destroy
+ itself if we only hand it the function pointers we need to
+ override. */
+
+typedef struct
+{
+ unsigned char *bytes;
+ size_t len;
+ int index;
+}
+tiff_memory_source;
+
+static size_t
+tiff_read_from_memory (data, buf, size)
+ thandle_t data;
+ tdata_t buf;
+ tsize_t size;
+{
+ tiff_memory_source *src = (tiff_memory_source *) data;
+
+ if (size > src->len - src->index)
+ return (size_t) -1;
+ bcopy (src->bytes + src->index, buf, size);
+ src->index += size;
+ return size;
+}
+
+static size_t
+tiff_write_from_memory (data, buf, size)
+ thandle_t data;
+ tdata_t buf;
+ tsize_t size;
+{
+ return (size_t) -1;
+}
+
+static toff_t
+tiff_seek_in_memory (data, off, whence)
+ thandle_t data;
+ toff_t off;
+ int whence;
+{
+ tiff_memory_source *src = (tiff_memory_source *) data;
+ int idx;
+
+ switch (whence)
+ {
+ 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;
+}
+
+static int
+tiff_close_memory (data)
+ thandle_t data;
+{
+ /* NOOP */
+ return 0;
}
+static int
+tiff_mmap_memory (data, pbase, psize)
+ thandle_t data;
+ tdata_t *pbase;
+ toff_t *psize;
+{
+ /* It is already _IN_ memory. */
+ return 0;
+}
+
+static void
+tiff_unmap_memory (data, base, size)
+ thandle_t data;
+ tdata_t base;
+ toff_t size;
+{
+ /* We don't need to do this. */
+}
+
+static toff_t
+tiff_size_of_memory (data)
+ thandle_t data;
+{
+ return ((tiff_memory_source *) data)->len;
+}
/* Load TIFF image IMG for use on frame F. Value is non-zero if
successful. */
struct image *img;
{
Lisp_Object file, specified_file;
+ Lisp_Object specified_data;
TIFF *tiff;
int width, height, x, y;
uint32 *buf;
int rc;
XImage *ximg;
struct gcpro gcpro1;
+ tiff_memory_source memsrc;
specified_file = image_spec_value (img->spec, QCfile, NULL);
- file = x_find_image_file (specified_file);
+ specified_data = image_spec_value (img->spec, QCdata, NULL);
+ file = Qnil;
GCPRO1 (file);
- if (!STRINGP (file))
+
+ if (NILP (specified_data))
{
- image_error ("Cannot find image file %s", file, Qnil);
- UNGCPRO;
- return 0;
+ /* 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;
+ }
+
+ /* Try to open the image file. */
+ tiff = TIFFOpen (XSTRING (file)->data, "r");
+ if (tiff == NULL)
+ {
+ image_error ("Cannot open `%s'", file, Qnil);
+ UNGCPRO;
+ return 0;
+ }
}
-
- /* Try to open the image file. */
- tiff = TIFFOpen (XSTRING (file)->data, "r");
- if (tiff == NULL)
+ else
{
- image_error ("Cannot open `%s'", file, Qnil);
- UNGCPRO;
- return 0;
+ /* Memory source! */
+ memsrc.bytes = XSTRING (specified_data)->data;
+ memsrc.len = STRING_BYTES (XSTRING (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);
+
+ if (!tiff)
+ {
+ image_error ("Cannot open memory source for `%s'", img->spec, Qnil);
+ UNGCPRO;
+ return 0;
+ }
}
/* Get width and height of the image, and allocate a raster buffer
TIFFClose (tiff);
if (!rc)
{
- image_error ("Error reading `%s'", file, Qnil);
+ image_error ("Error reading TIFF image `%s'", img->spec, Qnil);
xfree (buf);
UNGCPRO;
return 0;
BLOCK_INPUT;
/* Create the X image and pixmap. */
- if (!x_create_x_image_and_pixmap (f, file, width, height, 0, &ximg,
- &img->pixmap))
+ if (!x_create_x_image_and_pixmap (f, width, height, 0, &ximg, &img->pixmap))
{
UNBLOCK_INPUT;
xfree (buf);
enum gif_keyword_index
{
GIF_TYPE,
+ GIF_DATA,
GIF_FILE,
GIF_ASCENT,
GIF_MARGIN,
static struct image_keyword gif_format[GIF_LAST] =
{
{":type", IMAGE_SYMBOL_VALUE, 1},
- {":file", IMAGE_STRING_VALUE, 1},
+ {":data", IMAGE_STRING_VALUE, 0},
+ {":file", IMAGE_STRING_VALUE, 0},
{":ascent", IMAGE_NON_NEGATIVE_INTEGER_VALUE, 0},
{":margin", IMAGE_POSITIVE_INTEGER_VALUE, 0},
{":relief", IMAGE_INTEGER_VALUE, 0},
NULL
};
-
/* Return non-zero if OBJECT is a valid GIF image specification. */
static int
|| (fmt[GIF_ASCENT].count
&& XFASTINT (fmt[GIF_ASCENT].value) > 100))
return 0;
- return 1;
+
+ /* Must specify either the :data or :file keyword. */
+ return fmt[GIF_FILE].count + fmt[GIF_DATA].count == 1;
+}
+
+/* Reading a GIF image from memory
+ Based on the PNG memory stuff to a certain extent. */
+
+typedef struct
+{
+ unsigned char *bytes;
+ size_t len;
+ int index;
+}
+gif_memory_source;
+
+/* Make the current memory source available to gif_read_from_memory.
+ It's done this way because not all versions of libungif support
+ a UserData field in the GifFileType structure. */
+static gif_memory_source *current_gif_memory_src;
+
+static int
+gif_read_from_memory (file, buf, len)
+ GifFileType *file;
+ GifByteType *buf;
+ int len;
+{
+ gif_memory_source *src = current_gif_memory_src;
+
+ if (len > src->len - src->index)
+ return -1;
+
+ bcopy (src->bytes + src->index, buf, len);
+ src->index += len;
+ return len;
}
struct image *img;
{
Lisp_Object file, specified_file;
+ Lisp_Object specified_data;
int rc, width, height, x, y, i;
XImage *ximg;
ColorMapObject *gif_color_map;
struct gcpro gcpro1;
Lisp_Object image;
int ino, image_left, image_top, image_width, image_height;
+ gif_memory_source memsrc;
+ unsigned char *raster;
specified_file = image_spec_value (img->spec, QCfile, NULL);
- file = x_find_image_file (specified_file);
+ specified_data = image_spec_value (img->spec, QCdata, NULL);
+ file = Qnil;
GCPRO1 (file);
- if (!STRINGP (file))
+
+ if (NILP (specified_data))
{
- image_error ("Cannot find image file %s", specified_file, Qnil);
- UNGCPRO;
- return 0;
- }
+ file = x_find_image_file (specified_file);
+ if (!STRINGP (file))
+ {
+ image_error ("Cannot find image file `%s'", specified_file, Qnil);
+ UNGCPRO;
+ return 0;
+ }
- /* Open the GIF file. */
- gif = DGifOpenFileName (XSTRING (file)->data);
- if (gif == NULL)
+ /* Open the GIF file. */
+ gif = DGifOpenFileName (XSTRING (file)->data);
+ if (gif == NULL)
+ {
+ image_error ("Cannot open `%s'", file, Qnil);
+ UNGCPRO;
+ return 0;
+ }
+ }
+ else
{
- image_error ("Cannot open `%s'", file, Qnil);
- UNGCPRO;
- return 0;
+ /* Read from memory! */
+ current_gif_memory_src = &memsrc;
+ memsrc.bytes = XSTRING (specified_data)->data;
+ memsrc.len = STRING_BYTES (XSTRING (specified_data));
+ memsrc.index = 0;
+
+ gif = DGifOpen(&memsrc, gif_read_from_memory);
+ if (!gif)
+ {
+ image_error ("Cannot open memory source `%s'", img->spec, Qnil);
+ UNGCPRO;
+ return 0;
+ }
}
/* Read entire contents. */
rc = DGifSlurp (gif);
if (rc == GIF_ERROR)
{
- image_error ("Error reading `%s'", file, Qnil);
+ image_error ("Error reading `%s'", img->spec, Qnil);
DGifCloseFile (gif);
UNGCPRO;
return 0;
ino = INTEGERP (image) ? XFASTINT (image) : 0;
if (ino >= gif->ImageCount)
{
- image_error ("Invalid image number `%s'", image, Qnil);
+ image_error ("Invalid image number `%s' in image `%s'",
+ image, img->spec);
DGifCloseFile (gif);
UNGCPRO;
return 0;
BLOCK_INPUT;
/* Create the X image and pixmap. */
- if (!x_create_x_image_and_pixmap (f, file, width, height, 0, &ximg,
- &img->pixmap))
+ if (!x_create_x_image_and_pixmap (f, width, height, 0, &ximg, &img->pixmap))
{
UNBLOCK_INPUT;
DGifCloseFile (gif);
XPutPixel (ximg, x, y, FRAME_BACKGROUND_PIXEL (f));
}
- /* Read the GIF image into the X image. */
+ /* Read the GIF image into the X image. We use a local variable
+ `raster' here because RasterBits below is a char *, and invites
+ problems with bytes >= 0x80. */
+ raster = (unsigned char *) gif->SavedImages[ino].RasterBits;
+
if (gif->SavedImages[ino].ImageDesc.Interlace)
{
static int interlace_start[] = {0, 4, 2, 1};
for (x = 0; x < image_width; x++)
{
- unsigned int i
- = gif->SavedImages[ino].RasterBits[(y * image_width) + x];
+ int i = raster[(y * image_width) + x];
XPutPixel (ximg, x + image_left, row + image_top,
pixel_colors[i]);
}
for (y = 0; y < image_height; ++y)
for (x = 0; x < image_width; ++x)
{
- unsigned i = gif->SavedImages[ino].RasterBits[y * image_width + x];
+ int i = raster[y * image_width + x];
XPutPixel (ximg, x + image_left, y + image_top, pixel_colors[i]);
}
}
if (!img->pixmap)
{
- image_error ("Unable to create pixmap for `%s'",
- image_spec_value (img->spec, QCfile, NULL), Qnil);
+ image_error ("Unable to create pixmap for `%s'", img->spec, Qnil);
return 0;
}
}
else
image_error ("Cannot get X image of `%s'; colors will not be freed",
- image_spec_value (img->spec, QCfile, NULL), Qnil);
+ img->spec, Qnil);
UNBLOCK_INPUT;
}
Busy cursor
***********************************************************************/
-/* The implementation partly follows a patch from
- F.Pierresteguy@frcl.bull.fr dated 1994. */
+/* If non-null, an asynchronous timer that, when it expires, displays
+ a busy cursor on all frames. */
-/* Setting inhibit_busy_cursor to 2 inhibits busy-cursor display until
- the next X event is read and we enter XTread_socket again. Setting
- it to 1 inhibits busy-cursor display for direct commands. */
+static struct atimer *busy_cursor_atimer;
-int inhibit_busy_cursor;
+/* Non-zero means a busy cursor is currently shown. */
-/* Incremented with each call to x-display-busy-cursor.
- Decremented in x-undisplay-busy-cursor. */
+static int busy_cursor_shown_p;
-static int busy_count;
+/* Number of seconds to wait before displaying a busy cursor. */
+static Lisp_Object Vbusy_cursor_delay;
-DEFUN ("x-show-busy-cursor", Fx_show_busy_cursor,
- Sx_show_busy_cursor, 0, 0, 0,
- "Show a busy cursor, if not already shown.\n\
-Each call to this function must be matched by a call to\n\
-`x-hide-busy-cursor' to make the busy pointer disappear again.")
- ()
+/* Default number of seconds to wait before displaying a busy
+ cursor. */
+
+#define DEFAULT_BUSY_CURSOR_DELAY 1
+
+/* Function prototypes. */
+
+static void show_busy_cursor P_ ((struct atimer *));
+static void hide_busy_cursor P_ ((void));
+
+
+/* Cancel a currently active busy-cursor timer, and start a new one. */
+
+void
+start_busy_cursor ()
+{
+ EMACS_TIME delay;
+ int secs;
+
+ cancel_busy_cursor ();
+
+ if (INTEGERP (Vbusy_cursor_delay)
+ && XINT (Vbusy_cursor_delay) > 0)
+ secs = XFASTINT (Vbusy_cursor_delay);
+ else
+ secs = DEFAULT_BUSY_CURSOR_DELAY;
+
+ EMACS_SET_SECS_USECS (delay, secs, 0);
+ busy_cursor_atimer = start_atimer (ATIMER_RELATIVE, delay,
+ show_busy_cursor, NULL);
+}
+
+
+/* Cancel the busy cursor timer if active, hide a busy cursor if
+ shown. */
+
+void
+cancel_busy_cursor ()
{
- ++busy_count;
- if (busy_count == 1)
+ if (busy_cursor_atimer)
{
- Lisp_Object rest, frame;
+ cancel_atimer (busy_cursor_atimer);
+ busy_cursor_atimer = NULL;
+ }
+
+ if (busy_cursor_shown_p)
+ hide_busy_cursor ();
+}
+
+
+/* Timer function of busy_cursor_atimer. TIMER is equal to
+ busy_cursor_atimer.
+ Display a busy cursor on all frames by mapping the frames'
+ busy_window. Set the busy_p flag in the frames' output_data.x
+ structure to indicate that a busy cursor is shown on the
+ frames. */
+
+static void
+show_busy_cursor (timer)
+ struct atimer *timer;
+{
+ /* The timer implementation will cancel this timer automatically
+ after this function has run. Set busy_cursor_atimer to null
+ so that we know the timer doesn't have to be canceled. */
+ busy_cursor_atimer = NULL;
+
+ if (!busy_cursor_shown_p)
+ {
+ Lisp_Object rest, frame;
+
+ BLOCK_INPUT;
+
FOR_EACH_FRAME (rest, frame)
if (FRAME_X_P (XFRAME (frame)))
{
struct frame *f = XFRAME (frame);
-
- BLOCK_INPUT;
+
f->output_data.x->busy_p = 1;
-
+
if (!f->output_data.x->busy_window)
{
unsigned long mask = CWCursor;
XSetWindowAttributes attrs;
-
+
attrs.cursor = f->output_data.x->busy_cursor;
-
+
f->output_data.x->busy_window
= XCreateWindow (FRAME_X_DISPLAY (f),
FRAME_OUTER_WINDOW (f),
CopyFromParent,
mask, &attrs);
}
-
+
XMapRaised (FRAME_X_DISPLAY (f), f->output_data.x->busy_window);
- UNBLOCK_INPUT;
+ XFlush (FRAME_X_DISPLAY (f));
}
- }
- return Qnil;
+ busy_cursor_shown_p = 1;
+ UNBLOCK_INPUT;
+ }
}
-DEFUN ("x-hide-busy-cursor", Fx_hide_busy_cursor,
- Sx_hide_busy_cursor, 0, 1, 0,
- "Hide a busy-cursor.\n\
-A busy-cursor will actually be undisplayed when a matching\n\
-`x-hide-busy-cursor' is called for each `x-show-busy-cursor'\n\
-issued. FORCE non-nil means hide the busy-cursor forcibly,\n\
-not counting calls.")
- (force)
- Lisp_Object force;
-{
- Lisp_Object rest, frame;
+/* Hide the busy cursor on all frames, if it is currently shown. */
- if (busy_count == 0)
- return Qnil;
-
- if (!NILP (force) && busy_count != 0)
- busy_count = 1;
-
- --busy_count;
- if (busy_count != 0)
- return Qnil;
-
- FOR_EACH_FRAME (rest, frame)
+static void
+hide_busy_cursor ()
+{
+ if (busy_cursor_shown_p)
{
- struct frame *f = XFRAME (frame);
-
- if (FRAME_X_P (f)
- /* Watch out for newly created frames. */
- && f->output_data.x->busy_window)
+ Lisp_Object rest, frame;
+
+ BLOCK_INPUT;
+ FOR_EACH_FRAME (rest, frame)
{
-
- BLOCK_INPUT;
- XUnmapWindow (FRAME_X_DISPLAY (f), f->output_data.x->busy_window);
- /* Sync here because XTread_socket looks at the busy_p flag
- that is reset to zero below. */
- XSync (FRAME_X_DISPLAY (f), False);
- UNBLOCK_INPUT;
- f->output_data.x->busy_p = 0;
+ struct frame *f = XFRAME (frame);
+
+ if (FRAME_X_P (f)
+ /* Watch out for newly created frames. */
+ && f->output_data.x->busy_window)
+ {
+ XUnmapWindow (FRAME_X_DISPLAY (f), f->output_data.x->busy_window);
+ /* Sync here because XTread_socket looks at the busy_p flag
+ that is reset to zero below. */
+ XSync (FRAME_X_DISPLAY (f), False);
+ f->output_data.x->busy_p = 0;
+ }
}
- }
- return Qnil;
+ busy_cursor_shown_p = 0;
+ UNBLOCK_INPUT;
+ }
}
int i, width, height;
int root_x, root_y, win_x, win_y;
unsigned pmask;
- struct gcpro gcpro1, gcpro2, gcpro3;
+ struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
int old_windows_or_buffers_changed = windows_or_buffers_changed;
int count = specpdl_ptr - specpdl;
specbind (Qinhibit_redisplay, Qt);
- GCPRO3 (string, parms, frame);
+ GCPRO4 (string, parms, frame, timeout);
CHECK_STRING (string, 0);
f = check_x_frame (frame);
/* Let the tip disappear after timeout seconds. */
tip_timer = call3 (intern ("run-at-time"), timeout, Qnil,
intern ("x-hide-tip"));
-
+
+ UNGCPRO;
return unbind_to (count, Qnil);
}
"Non-zero means Emacs displays a busy cursor on window systems.");
display_busy_cursor_p = 1;
+ DEFVAR_LISP ("busy-cursor-delay", &Vbusy_cursor_delay,
+ "*Seconds to wait before displaying a busy-cursor.\n\
+Value must be an integer.");
+ Vbusy_cursor_delay = make_number (DEFAULT_BUSY_CURSOR_DELAY);
+
#if 0 /* This doesn't really do anything. */
DEFVAR_LISP ("x-mode-pointer-shape", &Vx_mode_pointer_shape,
"The shape of the pointer when over the mode line.\n\
defsubr (&Slookup_image);
#endif
- /* Busy-cursor. */
- defsubr (&Sx_show_busy_cursor);
- defsubr (&Sx_hide_busy_cursor);
- busy_count = 0;
- inhibit_busy_cursor = 0;
+ busy_cursor_atimer = NULL;
+ busy_cursor_shown_p = 0;
defsubr (&Sx_show_tip);
defsubr (&Sx_hide_tip);