xemacs-beta: src/glyphs.c comparison

comparison src/glyphs.c @ 173:8eaf7971accc r20-3b13

Import from CVS: tag r20-3b13

author	cvs
date	Mon, 13 Aug 2007 09:49:09 +0200
parents	15872534500d
children	3d6bfa290dbd

comparison

equal deleted inserted replaced

-:a38aed19690b
+:8eaf7971accc
 /* Generic glyph/image implementation + display tables
 Copyright (C) 1994, 1995 Board of Trustees, University of Illinois.
 Copyright (C) 1995 Tinker Systems
 Copyright (C) 1995, 1996 Ben Wing
 Copyright (C) 1995 Sun Microsystems
 This file is part of XEmacs.
 XEmacs is free software; you can redistribute it and/or modify it
 under the terms of the GNU General Public License as published by the
 Free Software Foundation; either version 2, or (at your option) any
 	  if (!NILP (XCDR (XCDR (mapping))))
 	    {
 	      pos = XCAR (XCDR (XCDR (mapping)));
 	      CHECK_INT (pos);
 	      if (XINT (pos) < 0 ||
-		  XINT (pos) >= vector_length (XVECTOR (typevec)))
+		  XINT (pos) >= XVECTOR_LENGTH (typevec))
 		args_out_of_range_3
-		  (pos, Qzero, make_int
+		  (pos, Qzero, make_int (XVECTOR_LENGTH (typevec) - 1));
-		   (vector_length (XVECTOR (typevec)) - 1));
 	    }
 	  newvec = Fcopy_sequence (typevec);
 	  if (INTP (pos))
-	    vector_data (XVECTOR (newvec))[XINT (pos)] = exp;
+	    XVECTOR_DATA (newvec)[XINT (pos)] = exp;
 	  GCPRO1 (newvec);
 	  image_validate (newvec);
 	  UNGCPRO;
 	}
 }
 /* if the result is of a type that can't be instantiated
 	 (e.g. a string when we're dealing with a pointer glyph),
 	 skip it. */
 if (!(dest_mask &
 	    IIFORMAT_METH (decode_image_instantiator_format
-			   (vector_data (XVECTOR (typevec))[0], ERROR_ME),
+			   (XVECTOR_DATA (typevec)[0], ERROR_ME),
 			   possible_dest_types, ())))
 	continue;
 if (fast_string_match (exp, 0, data, 0, -1, 0, ERROR_ME, 0) >= 0)
 	{
 	  if (!NILP (XCDR (XCDR (mapping))))
 	    {
 	      int pos = XINT (XCAR (XCDR (XCDR (mapping))));
 	      Lisp_Object newvec = Fcopy_sequence (typevec);
-	      vector_data (XVECTOR (newvec))[pos] = data;
+	      XVECTOR_DATA (newvec)[pos] = data;
 	      return newvec;
 	    }
 	  else
 	    return typevec;
 	}
 }
 /* Oh well. */
 signal_simple_error ("Unable to interpret glyph instantiator",
 		       data);
 return Qnil;
 }
 Lisp_Object
 find_keyword_in_vector_or_given (Lisp_Object vector, Lisp_Object keyword,
-				 Lisp_Object defalt)
+				 Lisp_Object default_)
 {
 Lisp_Object *elt;
 int instantiator_len;
-elt = vector_data (XVECTOR (vector));
+elt = XVECTOR_DATA (vector);
-instantiator_len = vector_length (XVECTOR (vector));
+instantiator_len = XVECTOR_LENGTH (vector);
 elt++;
 instantiator_len--;
 while (instantiator_len > 0)
 	return elt[1];
 elt += 2;
 instantiator_len -= 2;
 }
-return defalt;
+return default_;
 }
 Lisp_Object
 find_keyword_in_vector (Lisp_Object vector, Lisp_Object keyword)
 {
 /* This function can call lisp */
 int count = specpdl_depth ();
 Lisp_Object temp_buffer;
 struct gcpro gcpro1;
 Lisp_Object data;
 specbind (Qinhibit_quit, Qt);
 record_unwind_protect (Fset_buffer, Fcurrent_buffer ());
 temp_buffer = Fget_buffer_create (build_string (" *pixmap conversion*"));
 GCPRO1 (temp_buffer);
 set_buffer_internal (XBUFFER (temp_buffer));
 the normalization process.) */
 Lisp_Object
 tagged_vector_to_alist (Lisp_Object vector)
 {
-Lisp_Object *elt = vector_data (XVECTOR (vector));
+Lisp_Object *elt = XVECTOR_DATA (vector);
-int len = vector_length (XVECTOR (vector));
+int len = XVECTOR_LENGTH (vector);
 Lisp_Object result = Qnil;
 assert (len & 1);
 for (len -= 2; len >= 1; len -= 2)
 result = Fcons (Fcons (elt[len], elt[len+1]), result);
 do this because it is quite possible that we will need to
 instantiate a new instance of the pixmap and the file will no
 longer exist (e.g. w3 pixmaps are almost always from temporary
 files). */
 instantiator = IIFORMAT_METH_OR_GIVEN
-(decode_image_instantiator_format
+(decode_image_instantiator_format (XVECTOR_DATA (instantiator)[0],
-(vector_data (XVECTOR (instantiator))[0], ERROR_ME),
+				       ERROR_ME),
 normalize, (instantiator, contype), instantiator);
 return instantiator;
 }
 ii = allocate_image_instance (device);
 GCPRO1 (ii);
 {
 struct image_instantiator_methods *meths =
-decode_image_instantiator_format
+decode_image_instantiator_format (XVECTOR_DATA (instantiator)[0],
-	(vector_data (XVECTOR (instantiator))[0], ERROR_ME);
+					ERROR_ME);
 if (!HAS_IIFORMAT_METH_P (meths, instantiate))
 signal_simple_error
 	("Don't know how to instantiate this image instantiator?",
 	 instantiator);
 break;
 }
 MAYBE_DEVMETH (XDEVICE (i->device), mark_image_instance, (i, markobj));
-return (i->device);
+return i->device;
 }
 static void
 print_image_instance (Lisp_Object obj, Lisp_Object printcharfun,
 		      int escapeflag)
 	  !NILP (IMAGE_INSTANCE_PIXMAP_HOTSPOT_Y (ii)))
 	{
 	  write_c_string (" @", printcharfun);
 	  if (!NILP (IMAGE_INSTANCE_PIXMAP_HOTSPOT_X (ii)))
 	    {
-	      sprintf (buf, "%d", XINT (IMAGE_INSTANCE_PIXMAP_HOTSPOT_X (ii)));
+	      sprintf (buf, "%ld",
+		       (long) XINT (IMAGE_INSTANCE_PIXMAP_HOTSPOT_X (ii)));
 	      write_c_string (buf, printcharfun);
 	    }
 	  else
 	    write_c_string ("??", printcharfun);
 	  write_c_string (",", printcharfun);
 	  if (!NILP (IMAGE_INSTANCE_PIXMAP_HOTSPOT_Y (ii)))
 	    {
-	      sprintf (buf, "%d", XINT (IMAGE_INSTANCE_PIXMAP_HOTSPOT_Y (ii)));
+	      sprintf (buf, "%ld",
+		       (long) XINT (IMAGE_INSTANCE_PIXMAP_HOTSPOT_Y (ii)));
 	      write_c_string (buf, printcharfun);
 	    }
 	  else
 	    write_c_string ("??", printcharfun);
 	}
 image_validate (data);
 dest_mask = decode_image_instance_type_list (dest_types);
 data = normalize_image_instantiator (data, DEVICE_TYPE (XDEVICE (device)),
 				       make_int (dest_mask));
 GCPRO1 (data);
-if (VECTORP (data)
+if (VECTORP (data) && EQ (XVECTOR_DATA (data)[0], Qinherit))
-	   && EQ (vector_data (XVECTOR (data))[0], Qinherit))
 signal_simple_error ("inheritance not allowed here", data);
 ii = instantiate_image_instantiator (device, device, data,
 				       Qnil, Qnil, dest_mask);
 RETURN_UNGCPRO (ii);
 }
 DEFUN ("image-instance-p", Fimage_instance_p, 1, 1, 0, /*
 Return non-nil if OBJECT is an image instance.
 */
 (object))
 {
-return (IMAGE_INSTANCEP (object) ? Qt : Qnil);
+return IMAGE_INSTANCEP (object) ? Qt : Qnil;
 }
 DEFUN ("image-instance-type", Fimage_instance_type, 1, 1, 0, /*
 Return the type of the given image instance.
 The return value will be one of 'nothing, 'text, 'mono-pixmap,
 Return the name of the given image instance.
 */
 (image_instance))
 {
 CHECK_IMAGE_INSTANCE (image_instance);
-return (XIMAGE_INSTANCE_NAME (image_instance));
+return XIMAGE_INSTANCE_NAME (image_instance);
 }
 DEFUN ("image-instance-string", Fimage_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))
 {
 CHECK_IMAGE_INSTANCE (image_instance);
 if (XIMAGE_INSTANCE_TYPE (image_instance) == IMAGE_TEXT)
-return (XIMAGE_INSTANCE_TEXT_STRING (image_instance));
+return XIMAGE_INSTANCE_TEXT_STRING (image_instance);
 else
 return Qnil;
 }
 DEFUN ("image-instance-file-name", Fimage_instance_file_name, 1, 1, 0, /*
 switch (XIMAGE_INSTANCE_TYPE (image_instance))
 {
 case IMAGE_MONO_PIXMAP:
 case IMAGE_COLOR_PIXMAP:
 case IMAGE_POINTER:
-return (make_int (XIMAGE_INSTANCE_PIXMAP_DEPTH (image_instance)));
+return make_int (XIMAGE_INSTANCE_PIXMAP_DEPTH (image_instance));
 default:
 return Qnil;
 }
 }
 switch (XIMAGE_INSTANCE_TYPE (image_instance))
 {
 case IMAGE_MONO_PIXMAP:
 case IMAGE_COLOR_PIXMAP:
 case IMAGE_POINTER:
-return (make_int (XIMAGE_INSTANCE_PIXMAP_HEIGHT (image_instance)));
+return make_int (XIMAGE_INSTANCE_PIXMAP_HEIGHT (image_instance));
 default:
 return Qnil;
 }
 }
 switch (XIMAGE_INSTANCE_TYPE (image_instance))
 {
 case IMAGE_MONO_PIXMAP:
 case IMAGE_COLOR_PIXMAP:
 case IMAGE_POINTER:
-return (make_int (XIMAGE_INSTANCE_PIXMAP_WIDTH (image_instance)));
+return make_int (XIMAGE_INSTANCE_PIXMAP_WIDTH (image_instance));
 default:
 return Qnil;
 }
 }
 static Lisp_Object
 inherit_normalize (Lisp_Object inst, Lisp_Object console_type)
 {
 Lisp_Object face;
-assert (XVECTOR (inst)->size == 3);
+assert (XVECTOR_LENGTH (inst) == 3);
-face = vector_data (XVECTOR (inst))[2];
+face = XVECTOR_DATA (inst)[2];
 if (!FACEP (face))
 inst = vector3 (Qinherit, Q_face, Fget_face (face));
 return inst;
 }
 else
 	signal_simple_error_2 ("Wrong device for image instance",
 			       instantiator, device);
 }
 else if (VECTORP (instantiator)
-	   && EQ (vector_data (XVECTOR (instantiator))[0], Qinherit))
+	   && EQ (XVECTOR_DATA (instantiator)[0], Qinherit))
 {
-assert (XVECTOR (instantiator)->size == 3);
+assert (XVECTOR_LENGTH (instantiator) == 3);
 return (FACE_PROPERTY_INSTANCE
-	      (Fget_face (vector_data (XVECTOR (instantiator))[2]),
+	      (Fget_face (XVECTOR_DATA (instantiator)[2]),
 	       Qbackground_pixmap, domain, 0, depth));
 }
 else
 {
 Lisp_Object instance;
 {
 if (IMAGE_INSTANCEP (instantiator) || STRINGP (instantiator))
 return;
 else if (VECTORP (instantiator))
 {
-Lisp_Object *elt = vector_data (XVECTOR (instantiator));
+Lisp_Object *elt = XVECTOR_DATA (instantiator);
-int instantiator_len = XVECTOR (instantiator)->size;
+int instantiator_len = XVECTOR_LENGTH (instantiator);
 struct image_instantiator_methods *meths;
 Lisp_Object already_seen = Qnil;
 struct gcpro gcpro1;
 int i;
 not need to exist at any other time (e.g. it may safely be a temporary
 file).
 */
 (object))
 {
-return (IMAGE_SPECIFIERP (object) ? Qt : Qnil);
+return IMAGE_SPECIFIERP (object) ? Qt : Qnil;
 }
 /****************************************************************************
 *                             Glyph Object                                 *
 ((markobj) (glyph->image));
 ((markobj) (glyph->contrib_p));
 ((markobj) (glyph->baseline));
 ((markobj) (glyph->face));
-return (glyph->plist);
+return glyph->plist;
 }
 static void
 print_glyph (Lisp_Object obj, Lisp_Object printcharfun, int escapeflag)
 {
 				      Lisp_Object locale))
 {
 Lisp_Object obj = Qnil;
 struct Lisp_Glyph *g =
 alloc_lcrecord (sizeof (struct Lisp_Glyph), lrecord_glyph);
 g->type = type;
 g->image = Fmake_specifier (Qimage);
 switch (g->type)
 {
 case GLYPH_BUFFER:
 {
 	Lisp_Object str = XIMAGE_INSTANCE_TEXT_STRING (instance);
 Lisp_Object private_face = XGLYPH_FACE(glyph);
 	if (!NILP (private_face))
-	  return (redisplay_frame_text_width_string (XFRAME (frame),
+	  return redisplay_frame_text_width_string (XFRAME (frame),
-						     private_face,
+						    private_face,
-						     0, str, 0, -1));
+						    0, str, 0, -1);
 	else
 	if (!NILP (frame_face))
-	  return (redisplay_frame_text_width_string (XFRAME (frame),
+	  return redisplay_frame_text_width_string (XFRAME (frame),
-						     frame_face,
+						    frame_face,
-						     0, str, 0, -1));
+						    0, str, 0, -1);
 	else
-	  return (redisplay_text_width_string (XWINDOW (window),
+	  return redisplay_text_width_string (XWINDOW (window),
-					       window_findex,
+					      window_findex,
-					       0, str, 0, -1));
+					      0, str, 0, -1);
 }
 case IMAGE_MONO_PIXMAP:
 case IMAGE_COLOR_PIXMAP:
 case IMAGE_POINTER:
 (glyph, window))
 {
 XSETWINDOW (window, decode_window (window));
 CHECK_GLYPH (glyph);
-return (make_int (glyph_width (glyph, Qnil, DEFAULT_INDEX, window)));
+return make_int (glyph_width (glyph, Qnil, DEFAULT_INDEX, window));
 }
 #define RETURN_ASCENT	0
 #define RETURN_DESCENT	1
 #define RETURN_HEIGHT	2
 	else
 	  cachel = WINDOW_FACE_CACHEL (XWINDOW (window), window_findex);
 	ensure_face_cachel_complete (cachel, window, charsets);
 	face_cachel_charset_font_metric_info (cachel, charsets, &fm);
 	if (function == RETURN_ASCENT)
 	  return fm.ascent;
 	else if (function == RETURN_DESCENT)
 	  return fm.descent;
 	else if (function == RETURN_HEIGHT)
 (glyph, window))
 {
 XSETWINDOW (window, decode_window (window));
 CHECK_GLYPH (glyph);
-return (make_int (glyph_ascent (glyph, Qnil, DEFAULT_INDEX, window)));
+return make_int (glyph_ascent (glyph, Qnil, DEFAULT_INDEX, window));
 }
 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
 (glyph, window))
 {
 XSETWINDOW (window, decode_window (window));
 CHECK_GLYPH (glyph);
-return (make_int (glyph_descent (glyph, Qnil, DEFAULT_INDEX, window)));
+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, 1, 2, 0, /*
 Return the height of GLYPH on WINDOW.
 (glyph, window))
 {
 XSETWINDOW (window, decode_window (window));
 CHECK_GLYPH (glyph);
-return (make_int (glyph_height (glyph, Qnil, DEFAULT_INDEX, window)));
+return make_int (glyph_height (glyph, Qnil, DEFAULT_INDEX, window));
 }
 #undef RETURN_ASCENT
 #undef RETURN_DESCENT
 #undef RETURN_HEIGHT
 glyph_contrib_p (Lisp_Object glyph, Lisp_Object domain)
 {
 if (!GLYPHP (glyph))
 return 0;
 else
-return (!NILP (specifier_instance_no_quit
+return !NILP (specifier_instance_no_quit
-		   (GLYPH_CONTRIB_P (XGLYPH (glyph)), Qunbound, domain,
+		  (GLYPH_CONTRIB_P (XGLYPH (glyph)), Qunbound, domain,
-		    /* #### look into ERROR_ME_NOT */
+		   /* #### look into ERROR_ME_NOT */
-		    ERROR_ME_NOT, 0, Qzero)));
+		   ERROR_ME_NOT, 0, Qzero));
 }
 static void
 glyph_property_was_changed (Lisp_Object glyph, Lisp_Object property,
 			    Lisp_Object locale)
 get_display_table (struct window *w, face_index findex)
 {
 Lisp_Object tem = Qnil;
 tem = WINDOW_FACE_CACHEL_DISPLAY_TABLE (w, findex);
-if (VECTORP (tem) && XVECTOR (tem)->size == DISP_TABLE_SIZE)
+if (VECTORP (tem) && XVECTOR_LENGTH (tem) == DISP_TABLE_SIZE)
 return XVECTOR (tem);
 tem = w->display_table;
-if (VECTORP (tem) && XVECTOR (tem)->size == DISP_TABLE_SIZE)
+if (VECTORP (tem) && XVECTOR_LENGTH (tem) == DISP_TABLE_SIZE)
 return XVECTOR (tem);
 return 0;
 }

Mercurial > hg > xemacs-beta

comparison src/glyphs.c @ 173:8eaf7971accc r20-3b13