emacs: src/w32fns.c comparison

comparison src/w32fns.c @ 35288:912ea0b8e09b

(x_to_w32_color, x_set_icon_name, xlfd_strip_height) (w32_list_synthesized_fonts, lookup_image, Fx_file_dialog) (Fw32_send_sys_command): Remove unused variables. (w32_msg_pump): Add parentheses. (Fimage_size, image_ascent, lookup_image) (IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR, parse_image_spec) (xbm_format, xpm_format, pbm_format, png_format, jpeg_format) (tiff_format, gif_format, gs_format): Adapt to change of image margins.

author	Jason Rumney <jasonr@gnu.org>
date	Sat, 13 Jan 2001 00:03:17 +0000
parents	5091928844df
children	b5a2207901e0

comparison

equal deleted inserted replaced

-:28e0cac22fbd
+:912ea0b8e09b
 COLORREF
 x_to_w32_color (colorname)
 char * colorname;
 {
-register Lisp_Object tail, ret = Qnil;
+register Lisp_Object ret = Qnil;
 BLOCK_INPUT;
 if (colorname[0] == '#')
 {
 /* Could be an old-style RGB Device specification.  */
 void
 x_set_icon_name (f, arg, oldval)
 struct frame *f;
 Lisp_Object arg, oldval;
 {
-int result;
 if (STRINGP (arg))
 {
 if (STRINGP (oldval) && EQ (Fstring_equal (oldval, arg), Qt))
 	return;
 }
 and pointer here is not touched by GC (so the markbit
 can't be set).  Numbers are safe because they are
 immediate values.  */
 		if (NILP (new_state)
 		    || (NUMBERP (new_state)
-			&& (XUINT (new_state)) & 1 != cur_state))
+			&& ((XUINT (new_state)) & 1) != cur_state))
 		  {
 		    one_w32_display_info.faked_key = vk_code;
 		    keybd_event ((BYTE) vk_code,
 				 (BYTE) MapVirtualKey (vk_code, 0),
 return charset + 1;
 }
 struct font_info *w32_load_bdf_font (struct frame *f, char *fontname,
 int size, char* filename);
+static Lisp_Object w32_list_bdf_fonts (Lisp_Object pattern, int max_names);
 BOOL w32_to_x_font (LOGFONT * lplf, char * lpxstr, int len, char * charset);
-struct font_info *
+static struct font_info *
 w32_load_system_font (f,fontname,size)
 struct frame *f;
 char * fontname;
 int size;
 {
 int size;
 {
 Lisp_Object bdf_fonts;
 struct font_info *retval = NULL;
-bdf_fonts = w32_list_bdf_fonts (build_string (fontname));
+bdf_fonts = w32_list_bdf_fonts (build_string (fontname), 1);
 while (!retval && CONSP (bdf_fonts))
 {
 char *bdf_name, *bdf_file;
 Lisp_Object bdf_pair;
 *      (registry	"[^-]+")
 *      (encoding	"[^-]+")
 *      )
 */
-LONG
+static LONG
 x_to_w32_weight (lpw)
 char * lpw;
 {
 if (!lpw) return (FW_DONTCARE);
 else
 return FW_DONTCARE;
 }
-char *
+static char *
 w32_to_x_weight (fnweight)
 int fnweight;
 {
 if (fnweight >= FW_HEAVY)      return "heavy";
 if (fnweight >= FW_EXTRABOLD)  return "extrabold";
 if (fnweight >= FW_THIN)       return "thin";
 else
 return "*";
 }
-LONG
+static LONG
 x_to_w32_charset (lpcs)
 char * lpcs;
 {
 Lisp_Object this_entry, w32_charset;
 return DEFAULT_CHARSET;
 }
-char *
+static char *
 w32_to_x_charset (fncharset)
 int fncharset;
 {
 static char buf[16];
 Lisp_Object charset_type;
 else
 return CP_UNKNOWN;
 }
-BOOL
+static BOOL
 w32_to_x_font (lplogfont, lpxstr, len, specific_charset)
 LOGFONT * lplogfont;
 char * lpxstr;
 int len;
 char * specific_charset;
 lpxstr[len - 1] = 0;		/* just to be sure */
 return (TRUE);
 }
-BOOL
+static BOOL
 x_to_w32_font (lpxstr, lplogfont)
 char * lpxstr;
 LOGFONT * lplogfont;
 {
 struct coding_system coding;
 /* Strip the pixel height and point height from the given xlfd, and
 return the pixel height. If no pixel height is specified, calculate
 one from the point height, or if that isn't defined either, return
 0 (which usually signifies a scalable font).
 */
-int xlfd_strip_height (char *fontname)
+static int
-{
+xlfd_strip_height (char *fontname)
-int pixel_height, point_height, dpi, field_number;
+{
+int pixel_height, field_number;
 char *read_from, *write_to;
 xassert (fontname);
 pixel_height = field_number = 0;
 return pixel_height;
 }
 /* Assume parameter 1 is fully qualified, no wildcards. */
-BOOL
+static BOOL
 w32_font_match (fontname, pattern)
 char * fontname;
 char * pattern;
 {
 char *regex = alloca (strlen (pattern) * 2);
 XFontStruct *size_ref;
 Lisp_Object *pattern;
 Lisp_Object *tail;
 } enumfont_t;
-int CALLBACK
+static int CALLBACK
 enum_font_cb2 (lplf, lptm, FontType, lpef)
 ENUMLOGFONT * lplf;
 NEWTEXTMETRIC * lptm;
 int FontType;
 enumfont_t * lpef;
 }
 return (1);
 }
-int CALLBACK
+static int CALLBACK
 enum_font_cb1 (lplf, lptm, FontType, lpef)
 ENUMLOGFONT * lplf;
 NEWTEXTMETRIC * lptm;
 int FontType;
 enumfont_t * lpef;
 			   (FONTENUMPROC) enum_font_cb2,
 			   (LPARAM) lpef);
 }
-int CALLBACK
+static int CALLBACK
 enum_fontex_cb2 (lplf, lptm, font_type, lpef)
 ENUMLOGFONTEX * lplf;
 NEWTEXTMETRICEX * lptm;
 int font_type;
 enumfont_t * lpef;
 enumerated seperately.  */
 return enum_font_cb2 ((ENUMLOGFONT *) lplf, (NEWTEXTMETRIC *) lptm,
 font_type, lpef);
 }
-int CALLBACK
+static int CALLBACK
 enum_fontex_cb1 (lplf, lptm, font_type, lpef)
 ENUMLOGFONTEX * lplf;
 NEWTEXTMETRICEX * lptm;
 int font_type;
 enumfont_t * lpef;
 }
 /* Interface to fontset handler. (adapted from mw32font.c in Meadow
 and xterm.c in Emacs 20.3) */
-Lisp_Object w32_list_bdf_fonts (Lisp_Object pattern, int max_names)
+static Lisp_Object w32_list_bdf_fonts (Lisp_Object pattern, int max_names)
 {
 char *fontname, *ptnstr;
 Lisp_Object list, tem, newlist = Qnil;
 int n_fonts = 0;
 }
 return newlist;
 }
-Lisp_Object w32_list_synthesized_fonts (FRAME_PTR f, Lisp_Object pattern,
+static Lisp_Object w32_list_synthesized_fonts (FRAME_PTR f,
-int size, int max_names);
+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
 newlist = w32_list_synthesized_fonts (f, pattern, size, maxnames);
 return newlist;
 }
-Lisp_Object
+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, match, tem, synthed_matches = Qnil;
+Lisp_Object matches, tem, synthed_matches = Qnil;
 full_pattn = XSTRING (pattern)->data;
 pattn_part2 = alloca (XSTRING (pattern)->size);
 /* Allow some space for wildcard expansion.  */
 	fontp->font_encoder = ccl;
 }
 }
+/* Find BDF files in a specified directory.  (use GCPRO when calling,
+as this calls lisp to get a directory listing).  */
+static Lisp_Object
+w32_find_bdf_fonts_in_dir (Lisp_Object directory)
+{
+Lisp_Object filelist, list = Qnil;
+char fontname[100];
+if (!STRINGP(directory))
+return Qnil;
+filelist = Fdirectory_files (directory, Qt,
+build_string (".*\\.[bB][dD][fF]"), Qt);
+for ( ; CONSP(filelist); filelist = XCDR (filelist))
+{
+Lisp_Object filename = XCAR (filelist);
+if (w32_BDF_to_x_font (XSTRING (filename)->data, 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.")
 pair[1] = Qnil;
 GCPRO2 (directory, list);
 pair[1] = w32_find_bdf_fonts_in_dir( XCAR (directory) );
 list = Fnconc( 2, pair );
 UNGCPRO;
-}
-return list;
-}
-/* Find BDF files in a specified directory.  (use GCPRO when calling,
-as this calls lisp to get a directory listing).  */
-Lisp_Object w32_find_bdf_fonts_in_dir( Lisp_Object directory )
-{
-Lisp_Object filelist, list = Qnil;
-char fontname[100];
-if (!STRINGP(directory))
-return Qnil;
-filelist = Fdirectory_files (directory, Qt,
-build_string (".*\\.[bB][dD][fF]"), Qt);
-for ( ; CONSP(filelist); filelist = XCDR (filelist))
-{
-Lisp_Object filename = XCAR (filelist);
-if (w32_BDF_to_x_font (XSTRING (filename)->data, fontname, 100))
-store_in_alist (&list, build_string (fontname), filename);
 }
 return list;
 }
 {
 IMAGE_DONT_CHECK_VALUE_TYPE,
 IMAGE_STRING_VALUE,
 IMAGE_SYMBOL_VALUE,
 IMAGE_POSITIVE_INTEGER_VALUE,
+IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR,
 IMAGE_NON_NEGATIVE_INTEGER_VALUE,
 IMAGE_ASCENT_VALUE,
 IMAGE_INTEGER_VALUE,
 IMAGE_FUNCTION_VALUE,
 IMAGE_NUMBER_VALUE,
 	case IMAGE_POSITIVE_INTEGER_VALUE:
 	  if (!INTEGERP (value) || XINT (value) <= 0)
 	    return 0;
 	  break;
+	case IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR:
+	  if (INTEGERP (value) && XINT (value) >= 0)
+	    break;
+	  if (CONSP (value)
+	      && INTEGERP (XCAR (value)) && INTEGERP (XCDR (value))
+	      && XINT (XCAR (value)) >= 0 && XINT (XCDR (value)) >= 0)
+	    break;
+	  return 0;
 case IMAGE_ASCENT_VALUE:
 	  if (SYMBOLP (value) && EQ (value, Qcenter))
 	    break;
 	  else if (INTEGERP (value)
 int
 image_ascent (img, face)
 struct image *img;
 struct face *face;
 {
-int height = img->height + img->margin;
+int height = img->height + img->vmargin;
 int ascent;
 if (img->ascent == CENTERED_IMAGE_ASCENT)
 {
 if (face->font)
 break;
 /* If not found, create a new image and cache it.  */
 if (img == NULL)
 {
+BLOCK_INPUT;
 img = make_image (spec, hash);
 cache_image (f, img);
 img->load_failed_p = img->type->load (f, img) == 0;
-xassert (!interrupt_input_blocked);
 /* If we can't load the image, and we don't have a width and
 	 height, use some arbitrary width and height so that we can
 	 draw a rectangle for it.  */
 if (img->load_failed_p)
 	}
 else
 	{
 	  /* Handle image type independent image attributes
 	     `:ascent PERCENT', `:margin MARGIN', `:relief RELIEF'.  */
-	  Lisp_Object ascent, margin, relief, algorithm, heuristic_mask;
+	  Lisp_Object ascent, margin, relief;
-	  Lisp_Object file;
 	  ascent = image_spec_value (spec, QCascent, NULL);
 	  if (INTEGERP (ascent))
 	    img->ascent = XFASTINT (ascent);
 	  else if (EQ (ascent, Qcenter))
 img->ascent = CENTERED_IMAGE_ASCENT;
 	  margin = image_spec_value (spec, QCmargin, NULL);
 	  if (INTEGERP (margin) && XINT (margin) >= 0)
-	    img->margin = XFASTINT (margin);
+	    img->vmargin = img->hmargin = XFASTINT (margin);
+	  else if (CONSP (margin) && INTEGERP (XCAR (margin))
+		   && INTEGERP (XCDR (margin)))
+	    {
+	      if (XINT (XCAR (margin)) > 0)
+		img->hmargin = XFASTINT (XCAR (margin));
+	      if (XINT (XCDR (margin)) > 0)
+		img->vmargin = XFASTINT (XCDR (margin));
+	    }
 	  relief = image_spec_value (spec, QCrelief, NULL);
 	  if (INTEGERP (relief))
 	    {
 	      img->relief = XINT (relief);
-	      img->margin += abs (img->relief);
+	      img->hmargin += abs (img->relief);
+	      img->vmargin += abs (img->relief);
 	    }
-	  /* Should we apply a Laplace edge-detection algorithm?  */
+#if 0 /* TODO: image mask and algorithm.  */
-	  algorithm = image_spec_value (spec, QCalgorithm, NULL);
+	  /* Manipulation of the image's mask.  */
-	  if (img->pixmap && EQ (algorithm, Qlaplace))
+	  if (img->pixmap)
-	    x_laplace (f, img);
+	    {
+	      /* `:heuristic-mask t'
-	  /* Should we built a mask heuristically?  */
+		 `:mask heuristic'
-	  heuristic_mask = image_spec_value (spec, QCheuristic_mask, NULL);
+			means build a mask heuristically.
-	  if (img->pixmap && !img->mask && !NILP (heuristic_mask))
+		 `:heuristic-mask (R G B)'
-	      x_build_heuristic_mask (f, img, heuristic_mask);
+		 `: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)
+	    {
+	      Lisp_Object algorithm;
+	      algorithm = image_spec_value (spec, QCalgorithm, NULL);
+	      if (EQ (algorithm, Qdisabled))
+		x_disable_image (f, img);
+	      else if (EQ (algorithm, Qlaplace))
+		x_laplace (f, img);
+	      else if (EQ (algorithm, Qemboss))
+		x_emboss (f, img);
+	      else if (CONSP (algorithm)
+		       && EQ (XCAR (algorithm), Qedge_detection))
+		{
+		  Lisp_Object tem;
+		  tem = XCDR (algorithm);
+		  if (CONSP (tem))
+		    x_edge_detection (f, img,
+				      Fplist_get (tem, QCmatrix),
+				      Fplist_get (tem, QCcolor_adjustment));
+		}
+	    }
+#endif /* TODO.  */
 	}
+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);
 {":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},
-{":margin",		IMAGE_POSITIVE_INTEGER_VALUE,		0},
+{":margin",		IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR,	0},
 {":relief",		IMAGE_INTEGER_VALUE,			0},
 {":algorithm",	IMAGE_DONT_CHECK_VALUE_TYPE,		0},
 {":heuristic-mask",	IMAGE_DONT_CHECK_VALUE_TYPE,		0}
 };
 {
 {":type",		IMAGE_SYMBOL_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},
+{":margin",		IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR,	0},
 {":relief",		IMAGE_INTEGER_VALUE,			0},
 {":algorithm",	IMAGE_DONT_CHECK_VALUE_TYPE,		0},
 {":heuristic-mask",	IMAGE_DONT_CHECK_VALUE_TYPE,		0},
 {":color-symbols",	IMAGE_DONT_CHECK_VALUE_TYPE,		0}
 };
 {
 {":type",		IMAGE_SYMBOL_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},
+{":margin",		IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR,	0},
 {":relief",		IMAGE_INTEGER_VALUE,			0},
 {":algorithm",	IMAGE_DONT_CHECK_VALUE_TYPE,		0},
 {":heuristic-mask",	IMAGE_DONT_CHECK_VALUE_TYPE,		0}
 };
 {
 {":type",		IMAGE_SYMBOL_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},
+{":margin",		IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR,	0},
 {":relief",		IMAGE_INTEGER_VALUE,			0},
 {":algorithm",	IMAGE_DONT_CHECK_VALUE_TYPE,		0},
 {":heuristic-mask",	IMAGE_DONT_CHECK_VALUE_TYPE,		0}
 };
 {
 {":type",		IMAGE_SYMBOL_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},
+{":margin",		IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR,	0},
 {":relief",		IMAGE_INTEGER_VALUE,			0},
 {":algorithm",	IMAGE_DONT_CHECK_VALUE_TYPE,		0},
 {":heuristic-mask",	IMAGE_DONT_CHECK_VALUE_TYPE,		0}
 };
 {
 {":type",		IMAGE_SYMBOL_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},
+{":margin",		IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR,	0},
 {":relief",		IMAGE_INTEGER_VALUE,			0},
 {":algorithm",	IMAGE_DONT_CHECK_VALUE_TYPE,		0},
 {":heuristic-mask",	IMAGE_DONT_CHECK_VALUE_TYPE,		0}
 };
 {
 {":type",		IMAGE_SYMBOL_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},
+{":margin",		IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR,	0},
 {":relief",		IMAGE_INTEGER_VALUE,			0},
 {":algorithm",	IMAGE_DONT_CHECK_VALUE_TYPE,		0},
 {":heuristic-mask",	IMAGE_DONT_CHECK_VALUE_TYPE,		0},
 {":image",		IMAGE_NON_NEGATIVE_INTEGER_VALUE,	0}
 };
 {":pt-height",	IMAGE_POSITIVE_INTEGER_VALUE,		1},
 {":file",		IMAGE_STRING_VALUE,			1},
 {":loader",		IMAGE_FUNCTION_VALUE,			0},
 {":bounding-box",	IMAGE_DONT_CHECK_VALUE_TYPE,		1},
 {":ascent",		IMAGE_NON_NEGATIVE_INTEGER_VALUE,	0},
-{":margin",		IMAGE_POSITIVE_INTEGER_VALUE,		0},
+{":margin",		IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR,	0},
 {":relief",		IMAGE_INTEGER_VALUE,			0},
 {":algorithm",	IMAGE_DONT_CHECK_VALUE_TYPE,		0},
 {":heuristic-mask",	IMAGE_DONT_CHECK_VALUE_TYPE,		0}
 };
 filename[0] = '\0';
 if (use_dialog_p)
 {
 OPENFILENAME file_details;
-char *filename_file;
 /* Prevent redisplay.  */
 specbind (Qinhibit_redisplay, Qt);
 BLOCK_INPUT;
 \n\
 If optional parameter FRAME is not specified, use selected frame.")
 (command, frame)
 Lisp_Object command, frame;
 {
-WPARAM code;
 FRAME_PTR f = check_x_frame (frame);
 CHECK_NUMBER (command, 0);
 PostMessage (FRAME_W32_WINDOW (f), WM_SYSCOMMAND, XINT (command), 0);
 is set to off if the low bit of NEW-STATE is zero, otherwise on.")
 (key, new_state)
 Lisp_Object key, new_state;
 {
 int vk_code;
-int cur_state;
 if (EQ (key, intern ("capslock")))
 vk_code = VK_CAPITAL;
 else if (EQ (key, intern ("kp-numlock")))
 vk_code = VK_NUMLOCK;

Mercurial > emacs

comparison src/w32fns.c @ 35288:912ea0b8e09b