xemacs-beta: src/glyphs.c comparison

comparison src/glyphs.c @ 20:859a2309aef8 r19-15b93

Import from CVS: tag r19-15b93

author	cvs
date	Mon, 13 Aug 2007 08:50:05 +0200
parents	0293115a14e9
children	8d2a9b52c682

comparison

equal deleted inserted replaced

-:ac1f612d5250
+:859a2309aef8
 if (decode_image_instantiator_format (format, ERROR_ME_NOT))
 return 1;
 return 0;
 }
-DEFUN ("valid-image-instantiator-format-p", Fvalid_image_instantiator_format_p,
+DEFUN ("valid-image-instantiator-format-p",
-Svalid_image_instantiator_format_p, 1, 1, 0 /*
+Fvalid_image_instantiator_format_p, 1, 1, 0, /*
 Given an IMAGE-INSTANTIATOR-FORMAT, return non-nil if it is valid.
 Valid formats are some subset of 'nothing, 'string, 'formatted-string, 'xpm,
 'xbm, 'xface, 'gif, 'jpeg, 'png, 'tiff, 'cursor-font, 'font, 'autodetect,
 and 'subwindow, depending on how XEmacs was compiled.
-*/ )
+*/
-(image_instantiator_format)
+(image_instantiator_format))
-Lisp_Object image_instantiator_format;
 {
 if (valid_image_instantiator_format_p (image_instantiator_format))
 return Qt;
 else
 return Qnil;
 }
-DEFUN ("image-instantiator-format-list", Fimage_instantiator_format_list,
+DEFUN ("image-instantiator-format-list",
-Simage_instantiator_format_list,
+Fimage_instantiator_format_list, 0, 0, 0, /*
-0, 0, 0 /*
 Return a list of valid image-instantiator formats.
-*/ )
+*/
-()
+())
 {
 return Fcopy_sequence (Vimage_instantiator_format_list);
 }
 void
 {
 return &decode_console_type (console_type, ERROR_ME)->image_conversion_list;
 }
 DEFUN ("set-console-type-image-conversion-list",
-Fset_console_type_image_conversion_list,
+Fset_console_type_image_conversion_list, 2, 2, 0, /*
-Sset_console_type_image_conversion_list, 2, 2, 0 /*
 Set the image-conversion-list for consoles of the given TYPE.
 The image-conversion-list specifies how image instantiators that
 are strings should be interpreted.  Each element of the list should be
 a list of two elements (a regular expression string and a vector) or
 a list of three elements (the preceding two plus an integer index into
 Note: The conversion above is applied when the image instantiator is
 added to an image specifier, not when the specifier is actually
 instantiated.  Therefore, changing the image-conversion-list only affects
 newly-added instantiators.  Existing instantiators in glyphs and image
 specifiers will not be affected.
-*/ )
+*/
-(console_type, list)
+(console_type, list))
-Lisp_Object console_type, list;
 {
 Lisp_Object tail;
 Lisp_Object *imlist = get_image_conversion_list (console_type);
 /* Check the list to make sure that it only has valid entries. */
 *imlist = Fcopy_tree (list, Qt);
 return list;
 }
 DEFUN ("console-type-image-conversion-list",
-Fconsole_type_image_conversion_list,
+Fconsole_type_image_conversion_list, 1, 1, 0, /*
-Sconsole_type_image_conversion_list, 1, 1, 0 /*
 Return the image-conversion-list for devices of the given TYPE.
 The image-conversion-list specifies how to interpret image string
 instantiators for the specified console type.  See
 `set-console-type-image-conversion-list' for a description of its syntax.
-*/ )
+*/
-(console_type)
+(console_type))
-Lisp_Object console_type;
 {
 return Fcopy_tree (*get_image_conversion_list (console_type), Qt);
 }
 /* Process an string instantiator according to the image-conversion-list for
 if (!NILP (memq_no_quit (type, Vimage_instance_type_list)))
 return 1;
 return 0;
 }
-DEFUN ("valid-image-instance-type-p", Fvalid_image_instance_type_p,
+DEFUN ("valid-image-instance-type-p", Fvalid_image_instance_type_p, 1, 1, 0, /*
-Svalid_image_instance_type_p, 1, 1, 0 /*
 Given an IMAGE-INSTANCE-TYPE, return non-nil if it is valid.
 Valid types are some subset of 'nothing, 'text, 'mono-pixmap, 'color-pixmap,
 'pointer, and 'subwindow, depending on how XEmacs was compiled.
-*/ )
+*/
-(image_instance_type)
+(image_instance_type))
-Lisp_Object image_instance_type;
 {
 if (valid_image_instance_type_p (image_instance_type))
 return Qt;
 else
 return Qnil;
 }
-DEFUN ("image-instance-type-list", Fimage_instance_type_list,
+DEFUN ("image-instance-type-list", Fimage_instance_type_list, 0, 0, 0, /*
-Simage_instance_type_list,
-0, 0, 0 /*
 Return a list of valid image-instance types.
-*/ )
+*/
-()
+())
 {
 return Fcopy_sequence (Vimage_instance_type_list);
 }
 Error_behavior
 signal_simple_error ("inheritance not allowed here", data);
 ii = instantiate_image_instantiator (device, data, Qnil, Qnil, dest_mask);
 RETURN_UNGCPRO (ii);
 }
-DEFUN ("make-image-instance", Fmake_image_instance, Smake_image_instance,
+DEFUN ("make-image-instance", Fmake_image_instance, 1, 4, 0, /*
-1, 4, 0 /*
 Create a new `image-instance' object.
 Image-instance objects encapsulate the way a particular image (pixmap,
 etc.) is displayed on a particular device.  In most circumstances, you
 do not need to directly create image instances; use a glyph instead.
 NO-ERROR controls what happens when the image cannot be generated.
 If nil, an error message is generated.  If t, no messages are
 generated and this function returns nil.  If anything else, a warning
 message is generated and this function returns nil.
-*/ )
+*/
-(data, device, dest_types, no_error)
+(data, device, dest_types, no_error))
-Lisp_Object data, device, dest_types, no_error;
 {
 Error_behavior errb = decode_error_behavior_flag (no_error);
 return call_with_suspended_errors ((lisp_fn_t) make_image_instance_1,
 				     Qnil, Qimage, errb,
 				     3, data, device, dest_types);
 }
-DEFUN ("image-instance-p", Fimage_instance_p, Simage_instance_p, 1, 1, 0 /*
+DEFUN ("image-instance-p", Fimage_instance_p, 1, 1, 0, /*
 Return non-nil if OBJECT is an image instance.
-*/ )
+*/
-(object)
+(object))
-Lisp_Object object;
 {
 return (IMAGE_INSTANCEP (object) ? Qt : Qnil);
 }
-DEFUN ("image-instance-type", Fimage_instance_type, Simage_instance_type,
+DEFUN ("image-instance-type", Fimage_instance_type, 1, 1, 0, /*
-1, 1, 0 /*
 Return the type of the given image instance.
 The return value will be one of 'nothing, 'text, 'mono-pixmap,
 'color-pixmap, 'pointer, or 'subwindow.
-*/ )
+*/
-(image_instance)
+(image_instance))
-Lisp_Object image_instance;
 {
 CHECK_IMAGE_INSTANCE (image_instance);
 return encode_image_instance_type (XIMAGE_INSTANCE_TYPE (image_instance));
 }
-DEFUN ("image-instance-name", Fimage_instance_name,
+DEFUN ("image-instance-name", Fimage_instance_name, 1, 1, 0, /*
-Simage_instance_name, 1, 1, 0 /*
 Return the name of the given image instance.
-*/ )
+*/
-(image_instance)
+(image_instance))
-Lisp_Object image_instance;
 {
 CHECK_IMAGE_INSTANCE (image_instance);
 return (XIMAGE_INSTANCE_NAME (image_instance));
 }
-DEFUN ("image-instance-string", Fimage_instance_string,
+DEFUN ("image-instance-string", Fimage_instance_string, 1, 1, 0, /*
-Simage_instance_string, 1, 1, 0 /*
 Return the string of the given image instance.
 This will only be non-nil for text image instances.
-*/ )
+*/
-(image_instance)
+(image_instance))
-Lisp_Object image_instance;
 {
 CHECK_IMAGE_INSTANCE (image_instance);
 if (XIMAGE_INSTANCE_TYPE (image_instance) == IMAGE_TEXT)
 return (XIMAGE_INSTANCE_TEXT_STRING (image_instance));
 else
 return Qnil;
 }
-DEFUN ("image-instance-file-name", Fimage_instance_file_name,
+DEFUN ("image-instance-file-name", Fimage_instance_file_name, 1, 1, 0, /*
-Simage_instance_file_name, 1, 1, 0 /*
 Return the file name from which IMAGE-INSTANCE was read, if known.
-*/ )
+*/
-(image_instance)
+(image_instance))
-Lisp_Object image_instance;
 {
 CHECK_IMAGE_INSTANCE (image_instance);
 switch (XIMAGE_INSTANCE_TYPE (image_instance))
 {
 default:
 return Qnil;
 }
 }
-DEFUN ("image-instance-mask-file-name", Fimage_instance_mask_file_name,
+DEFUN ("image-instance-mask-file-name", Fimage_instance_mask_file_name, 1, 1, 0, /*
-Simage_instance_mask_file_name, 1, 1, 0 /*
 Return the file name from which IMAGE-INSTANCE's mask was read, if known.
-*/ )
+*/
-(image_instance)
+(image_instance))
-Lisp_Object image_instance;
 {
 CHECK_IMAGE_INSTANCE (image_instance);
 switch (XIMAGE_INSTANCE_TYPE (image_instance))
 {
 default:
 return Qnil;
 }
 }
-DEFUN ("image-instance-depth", Fimage_instance_depth,
+DEFUN ("image-instance-depth", Fimage_instance_depth, 1, 1, 0, /*
-Simage_instance_depth, 1, 1, 0 /*
 Return the depth of the image instance.
 This is 0 for a bitmap, or a positive integer for a pixmap.
-*/ )
+*/
-(image_instance)
+(image_instance))
-Lisp_Object image_instance;
 {
 CHECK_IMAGE_INSTANCE (image_instance);
 switch (XIMAGE_INSTANCE_TYPE (image_instance))
 {
 default:
 return Qnil;
 }
 }
-DEFUN ("image-instance-height", Fimage_instance_height,
+DEFUN ("image-instance-height", Fimage_instance_height, 1, 1, 0, /*
-Simage_instance_height, 1, 1, 0 /*
 Return the height of the image instance, in pixels.
-*/ )
+*/
-(image_instance)
+(image_instance))
-Lisp_Object image_instance;
 {
 CHECK_IMAGE_INSTANCE (image_instance);
 switch (XIMAGE_INSTANCE_TYPE (image_instance))
 {
 default:
 return Qnil;
 }
 }
-DEFUN ("image-instance-width", Fimage_instance_width,
+DEFUN ("image-instance-width", Fimage_instance_width, 1, 1, 0, /*
-Simage_instance_width, 1, 1, 0 /*
 Return the width of the image instance, in pixels.
-*/ )
+*/
-(image_instance)
+(image_instance))
-Lisp_Object image_instance;
 {
 CHECK_IMAGE_INSTANCE (image_instance);
 switch (XIMAGE_INSTANCE_TYPE (image_instance))
 {
 default:
 return Qnil;
 }
 }
-DEFUN ("image-instance-hotspot-x", Fimage_instance_hotspot_x,
+DEFUN ("image-instance-hotspot-x", Fimage_instance_hotspot_x, 1, 1, 0, /*
-Simage_instance_hotspot_x, 1, 1, 0 /*
 Return the X coordinate of the image instance's hotspot, if known.
 This is a point relative to the origin of the pixmap.  When an image is
 used as a mouse pointer, the hotspot is the point on the image that sits
 over the location that the pointer points to.  This is, for example, the
 tip of the arrow or the center of the crosshairs.
 This will always be nil for a non-pointer image instance.
-*/ )
+*/
-(image_instance)
+(image_instance))
-Lisp_Object image_instance;
 {
 CHECK_IMAGE_INSTANCE (image_instance);
 switch (XIMAGE_INSTANCE_TYPE (image_instance))
 {
 default:
 return Qnil;
 }
 }
-DEFUN ("image-instance-hotspot-y", Fimage_instance_hotspot_y,
+DEFUN ("image-instance-hotspot-y", Fimage_instance_hotspot_y, 1, 1, 0, /*
-Simage_instance_hotspot_y, 1, 1, 0 /*
 Return the Y coordinate of the image instance's hotspot, if known.
 This is a point relative to the origin of the pixmap.  When an image is
 used as a mouse pointer, the hotspot is the point on the image that sits
 over the location that the pointer points to.  This is, for example, the
 tip of the arrow or the center of the crosshairs.
 This will always be nil for a non-pointer image instance.
-*/ )
+*/
-(image_instance)
+(image_instance))
-Lisp_Object image_instance;
 {
 CHECK_IMAGE_INSTANCE (image_instance);
 switch (XIMAGE_INSTANCE_TYPE (image_instance))
 {
 default:
 return Qnil;
 }
 }
-DEFUN ("image-instance-foreground", Fimage_instance_foreground,
+DEFUN ("image-instance-foreground", Fimage_instance_foreground, 1, 1, 0, /*
-Simage_instance_foreground, 1, 1, 0 /*
 Return the foreground color of IMAGE-INSTANCE, if applicable.
 This will be a color instance or nil. (It will only be non-nil for
 colorized mono pixmaps and for pointers.)
-*/ )
+*/
-(image_instance)
+(image_instance))
-Lisp_Object image_instance;
 {
 CHECK_IMAGE_INSTANCE (image_instance);
 switch (XIMAGE_INSTANCE_TYPE (image_instance))
 {
 default:
 return Qnil;
 }
 }
-DEFUN ("image-instance-background", Fimage_instance_background,
+DEFUN ("image-instance-background", Fimage_instance_background, 1, 1, 0, /*
-Simage_instance_background, 1, 1, 0 /*
 Return the background color of IMAGE-INSTANCE, if applicable.
 This will be a color instance or nil. (It will only be non-nil for
 colorized mono pixmaps and for pointers.)
-*/ )
+*/
-(image_instance)
+(image_instance))
-Lisp_Object image_instance;
 {
 CHECK_IMAGE_INSTANCE (image_instance);
 switch (XIMAGE_INSTANCE_TYPE (image_instance))
 {
 return Qnil;
 }
 }
-DEFUN ("colorize-image-instance", Fcolorize_image_instance,
+DEFUN ("colorize-image-instance", Fcolorize_image_instance, 3, 3, 0, /*
-Scolorize_image_instance, 3, 3, 0 /*
 Make the image instance be displayed in the given colors.
 This function returns a new image instance that is exactly like the
 specified one except that (if possible) the foreground and background
 colors and as specified.  Currently, this only does anything if the image
 instance is a mono pixmap; otherwise, the same image instance is returned.
-*/ )
+*/
-(image_instance, foreground, background)
+(image_instance, foreground, background))
-Lisp_Object image_instance, foreground, background;
 {
 Lisp_Object new;
 Lisp_Object device;
 CHECK_IMAGE_INSTANCE (image_instance);
 UNGCPRO;
 return retlist;
 }
-DEFUN ("image-specifier-p", Fimage_specifier_p, Simage_specifier_p, 1, 1, 0 /*
+DEFUN ("image-specifier-p", Fimage_specifier_p, 1, 1, 0, /*
 Return non-nil if OBJECT is an image specifier.
 An image specifier is used for images (pixmaps and the like).  It is used
 to describe the actual image in a glyph.  It is instanced as an image-
 instance.
 instantiator will be converted into one of the inline-data forms, with
 the filename retained using a :file keyword.  This implies that the
 file must exist when the instantiator is added to the image, but does
 not need to exist at any other time (e.g. it may safely be a temporary
 file).
-*/ )
+*/
-(object)
+(object))
-Lisp_Object object;
 {
 return (IMAGE_SPECIFIERP (object) ? Qt : Qnil);
 }
 if (!NILP (memq_no_quit (type, Vglyph_type_list)))
 return 1;
 return 0;
 }
-DEFUN ("valid-glyph-type-p", Fvalid_glyph_type_p,
+DEFUN ("valid-glyph-type-p", Fvalid_glyph_type_p, 1, 1, 0, /*
-Svalid_glyph_type_p, 1, 1, 0 /*
 Given a GLYPH-TYPE, return non-nil if it is valid.
 Valid types are `buffer', `pointer', and `icon'.
-*/ )
+*/
-(glyph_type)
+(glyph_type))
-Lisp_Object glyph_type;
 {
 if (valid_glyph_type_p (glyph_type))
 return Qt;
 else
 return Qnil;
 }
-DEFUN ("glyph-type-list", Fglyph_type_list,
+DEFUN ("glyph-type-list", Fglyph_type_list, 0, 0, 0, /*
-Sglyph_type_list,
-0, 0, 0 /*
 Return a list of valid glyph types.
-*/ )
+*/
-()
+())
 {
 return Fcopy_sequence (Vglyph_type_list);
 }
-DEFUN ("make-glyph-internal", Fmake_glyph_internal, Smake_glyph_internal,
+DEFUN ("make-glyph-internal", Fmake_glyph_internal, 0, 1, 0, /*
-0, 1, 0 /*
 Create a new, uninitialized glyph.
 TYPE specifies the type of the glyph; this should be one of `buffer',
 `pointer', or `icon', and defaults to `buffer'.  The type of the glyph
 specifies in which contexts the glyph can be used, and controls the
 image can be instantiated as `pointer'.
 `icon' glyphs can be used to specify the icon used when a frame is
 iconified.  Their image can be instantiated as `mono-pixmap' and
 `color-pixmap'.
-*/ )
+*/
-(type)
+(type))
-Lisp_Object type;
 {
 enum glyph_type typeval = decode_glyph_type (type, ERROR_ME);
 return allocate_glyph (typeval, 0);
 }
-DEFUN ("glyphp", Fglyphp, Sglyphp, 1, 1, 0 /*
+DEFUN ("glyphp", Fglyphp, 1, 1, 0, /*
 Return non-nil if OBJECT is a glyph.
 A glyph is an object used for pixmaps and the like.  It is used
 in begin-glyphs and end-glyphs attached to extents, in marginal and textual
 annotations, in overlay arrows (overlay-arrow-* variables), in toolbar
 buttons, and the like.  Its image is described using an image specifier --
 see `image-specifier-p'.
-*/ )
+*/
-(object)
+(object))
-Lisp_Object object;
 {
 return GLYPHP (object) ? Qt : Qnil;
 }
-DEFUN ("glyph-type", Fglyph_type, Sglyph_type,
+DEFUN ("glyph-type", Fglyph_type, 1, 1, 0, /*
-1, 1, 0 /*
 Return the type of the given glyph.
 The return value will be one of 'buffer, 'pointer, or 'icon.
-*/ )
+*/
-(glyph)
+(glyph))
-Lisp_Object glyph;
 {
 CHECK_GLYPH (glyph);
 switch (XGLYPH_TYPE (glyph))
 {
 case GLYPH_BUFFER:
 abort ();
 return 0;
 }
 }
-DEFUN ("glyph-width", Fglyph_width, Sglyph_width, 1, 2, 0 /*
+DEFUN ("glyph-width", Fglyph_width, 1, 2, 0, /*
 Return the width of GLYPH on WINDOW.
 This may not be exact as it does not take into account all of the context
 that redisplay will.
-*/ )
+*/
-(glyph, window)
+(glyph, window))
-Lisp_Object glyph, window;
 {
 XSETWINDOW (window, decode_window (window));
 CHECK_GLYPH (glyph);
 return (make_int (glyph_width (glyph, Qnil, DEFAULT_INDEX, window)));
 {
 return glyph_height_internal (glyph, frame_face, window_findex, window,
 				RETURN_HEIGHT);
 }
-DEFUN ("glyph-ascent", Fglyph_ascent, Sglyph_ascent, 1, 2, 0 /*
+DEFUN ("glyph-ascent", Fglyph_ascent, 1, 2, 0, /*
 Return the ascent value of GLYPH on WINDOW.
 This may not be exact as it does not take into account all of the context
 that redisplay will.
-*/ )
+*/
-(glyph, window)
+(glyph, window))
-Lisp_Object glyph, window;
 {
 XSETWINDOW (window, decode_window (window));
 CHECK_GLYPH (glyph);
 return (make_int (glyph_ascent (glyph, Qnil, DEFAULT_INDEX, window)));
 }
-DEFUN ("glyph-descent", Fglyph_descent, Sglyph_descent, 1, 2, 0 /*
+DEFUN ("glyph-descent", Fglyph_descent, 1, 2, 0, /*
 Return the descent value of GLYPH on WINDOW.
 This may not be exact as it does not take into account all of the context
 that redisplay will.
-*/ )
+*/
-(glyph, window)
+(glyph, window))
-Lisp_Object glyph, window;
 {
 XSETWINDOW (window, decode_window (window));
 CHECK_GLYPH (glyph);
 return (make_int (glyph_descent (glyph, Qnil, DEFAULT_INDEX, window)));
 }
 /* This is redundant but I bet a lot of people expect it to exist. */
-DEFUN ("glyph-height", Fglyph_height, Sglyph_height, 1, 2, 0 /*
+DEFUN ("glyph-height", Fglyph_height, 1, 2, 0, /*
 Return the height of GLYPH on WINDOW.
 This may not be exact as it does not take into account all of the context
 that redisplay will.
-*/ )
+*/
-(glyph, window)
+(glyph, window))
-Lisp_Object glyph, window;
 {
 XSETWINDOW (window, decode_window (window));
 CHECK_GLYPH (glyph);
 return (make_int (glyph_height (glyph, Qnil, DEFAULT_INDEX, window)));
 void
 syms_of_glyphs (void)
 {
 /* image instantiators */
-defsubr (&Simage_instantiator_format_list);
+DEFSUBR (Fimage_instantiator_format_list);
-defsubr (&Svalid_image_instantiator_format_p);
+DEFSUBR (Fvalid_image_instantiator_format_p);
-defsubr (&Sset_console_type_image_conversion_list);
+DEFSUBR (Fset_console_type_image_conversion_list);
-defsubr (&Sconsole_type_image_conversion_list);
+DEFSUBR (Fconsole_type_image_conversion_list);
 defkeyword (&Q_file, ":file");
 defkeyword (&Q_data, ":data");
 defkeyword (&Q_face, ":face");
 /* image specifiers */
-defsubr (&Simage_specifier_p);
+DEFSUBR (Fimage_specifier_p);
 /* Qimage in general.c */
 /* image instances */
 defsymbol (&Qimage_instancep, "image-instance-p");
 defsymbol (&Qmono_pixmap_image_instance_p, "mono-pixmap-image-instance-p");
 defsymbol (&Qcolor_pixmap_image_instance_p, "color-pixmap-image-instance-p");
 defsymbol (&Qpointer_image_instance_p, "pointer-image-instance-p");
 defsymbol (&Qsubwindow_image_instance_p, "subwindow-image-instance-p");
-defsubr (&Smake_image_instance);
+DEFSUBR (Fmake_image_instance);
-defsubr (&Simage_instance_p);
+DEFSUBR (Fimage_instance_p);
-defsubr (&Simage_instance_type);
+DEFSUBR (Fimage_instance_type);
-defsubr (&Svalid_image_instance_type_p);
+DEFSUBR (Fvalid_image_instance_type_p);
-defsubr (&Simage_instance_type_list);
+DEFSUBR (Fimage_instance_type_list);
-defsubr (&Simage_instance_name);
+DEFSUBR (Fimage_instance_name);
-defsubr (&Simage_instance_string);
+DEFSUBR (Fimage_instance_string);
-defsubr (&Simage_instance_file_name);
+DEFSUBR (Fimage_instance_file_name);
-defsubr (&Simage_instance_mask_file_name);
+DEFSUBR (Fimage_instance_mask_file_name);
-defsubr (&Simage_instance_depth);
+DEFSUBR (Fimage_instance_depth);
-defsubr (&Simage_instance_height);
+DEFSUBR (Fimage_instance_height);
-defsubr (&Simage_instance_width);
+DEFSUBR (Fimage_instance_width);
-defsubr (&Simage_instance_hotspot_x);
+DEFSUBR (Fimage_instance_hotspot_x);
-defsubr (&Simage_instance_hotspot_y);
+DEFSUBR (Fimage_instance_hotspot_y);
-defsubr (&Simage_instance_foreground);
+DEFSUBR (Fimage_instance_foreground);
-defsubr (&Simage_instance_background);
+DEFSUBR (Fimage_instance_background);
-defsubr (&Scolorize_image_instance);
+DEFSUBR (Fcolorize_image_instance);
 /* Qnothing defined as part of the "nothing" image-instantiator
 type. */
 /* Qtext defined in general.c */
 defsymbol (&Qmono_pixmap, "mono-pixmap");
 defsymbol (&Qpointer_glyph_p, "pointer-glyph-p");
 defsymbol (&Qicon_glyph_p, "icon-glyph-p");
 defsymbol (&Qconst_glyph_variable, "const-glyph-variable");
-defsubr (&Sglyph_type);
+DEFSUBR (Fglyph_type);
-defsubr (&Svalid_glyph_type_p);
+DEFSUBR (Fvalid_glyph_type_p);
-defsubr (&Sglyph_type_list);
+DEFSUBR (Fglyph_type_list);
-defsubr (&Sglyphp);
+DEFSUBR (Fglyphp);
-defsubr (&Smake_glyph_internal);
+DEFSUBR (Fmake_glyph_internal);
-defsubr (&Sglyph_width);
+DEFSUBR (Fglyph_width);
-defsubr (&Sglyph_ascent);
+DEFSUBR (Fglyph_ascent);
-defsubr (&Sglyph_descent);
+DEFSUBR (Fglyph_descent);
-defsubr (&Sglyph_height);
+DEFSUBR (Fglyph_height);
 /* Qbuffer defined in general.c. */
 /* Qpointer defined above */
 defsymbol (&Qicon, "icon");
 }

Mercurial > hg > xemacs-beta

comparison src/glyphs.c @ 20:859a2309aef8 r19-15b93