xemacs-beta: src/glyphs-widget.c comparison

comparison src/glyphs-widget.c @ 863:42375619fa45

[xemacs-hg @ 2002-06-04 06:03:59 by andyp] merge 21.4 windows changes, minimally tested

author	andyp
date	Tue, 04 Jun 2002 06:05:53 +0000
parents	2b6fa2618f76
children	613552a02607

comparison

equal deleted inserted replaced

-:278c743f1578
+:42375619fa45
 /* Widget-specific glyph objects.
-Copyright (C) 1998, 1999, 2000 Andy Piper.
+Copyright (C) 1998, 1999, 2000, 2002 Andy Piper.
 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
 DEFINE_IMAGE_INSTANTIATOR_FORMAT (native_layout);
 Lisp_Object Qnative_layout;
 Lisp_Object Qetched_in, Qetched_out, Qbevel_in, Qbevel_out;
 Lisp_Object Qmake_glyph;
+Lisp_Object Vwidget_border_width;
+static int widget_border_width (Lisp_Object domain);
+static int widget_spacing (Lisp_Object domain);
+static void widget_query_string_geometry (Lisp_Object string, Lisp_Object face,
+					  int *width, int *height, Lisp_Object domain);
 #ifdef DEBUG_WIDGETS
 int debug_widget_instances;
 #endif
 }
 static void
 check_valid_justification (Lisp_Object data)
 {
-if (!EQ (data, Qleft) && !EQ (data, Qright) && !EQ (data, Qcenter))
+if (!EQ (data, Qleft)
+&&
+!EQ (data, Qright)
+&&
+!EQ (data, Qtop)
+&&
+!EQ (data, Qbottom)
+&&
+!EQ (data, Qcenter))
 invalid_constant ("unknown justification for layout", data);
 }
 static void
 check_valid_border (Lisp_Object data)
 	{
 	  XVECTOR_DATA (inst)[i+1] = val;
 	  break;
 	}
 }
+}
+/* Determine the border with of the widget. */
+static int
+widget_border_width (Lisp_Object domain)
+{
+/* #### FIXME -- need to use specifiers (Vwidget_border_width) for
+some portion of this. */
+if (HAS_DEVMETH_P (DOMAIN_XDEVICE (domain),
+		     widget_border_width))
+return DEVMETH (DOMAIN_XDEVICE (domain), widget_border_width, ());
+else
+return DEFAULT_WIDGET_BORDER_WIDTH;
+}
+static int
+widget_instance_border_width (Lisp_Image_Instance* ii)
+{
+return widget_border_width (IMAGE_INSTANCE_DOMAIN (ii));
+}
+/* #### Its not clear to me what the value of logical_unit_height should
+be, or whether it should even depend on the current
+image_instance. It really should probably only depend on the
+default widget face and the domain, however you can envisage users
+wanting different logical units for nested layouts - so using the
+properties of the current lahyout is probably not so dumb. */
+static int
+logical_unit_height (Lisp_Object text, Lisp_Object face, Lisp_Object domain)
+{
+int charheight = 0;
+widget_query_string_geometry (text, face,
+				0, &charheight, domain);
+/* For the returned value to be useful it needs to be big enough to
+accomodate the largest single-height widget. This is currently
+the edit-field. */
+return charheight + 2 * widget_spacing (domain)
++ 4 * widget_border_width (domain);
+}
+static int
+widget_logical_unit_height (Lisp_Image_Instance* ii)
+{
+return logical_unit_height (NILP (IMAGE_INSTANCE_WIDGET_TEXT (ii)) ?
+			      IMAGE_INSTANCE_NAME (ii)
+			      : IMAGE_INSTANCE_WIDGET_TEXT (ii),
+			      IMAGE_INSTANCE_WIDGET_FACE (ii),
+			      IMAGE_INSTANCE_DOMAIN (ii));
 }
 /* Wire widget property invocations to specific widgets. The problem
 we are solving here is that when instantiators get converted to
 instances they lose some type information (they just become
 update the widget's size as it may have been changed by the the
 layout routines. We also do this here so that explicit resizing
 from lisp does not result in synchronous updates. Do this last so
 that format-specific methods have an opportunity to prevent
 wholesale changes - e.g. rebuilding tabs. */
-MAYBE_DEVMETH (DOMAIN_XDEVICE (ii->domain), redisplay_widget, (ii));
+MAYBE_DEVMETH (DOMAIN_XDEVICE (IMAGE_INSTANCE_DOMAIN (ii)),
+		 redisplay_widget, (ii));
 /* Pick up the items we recorded earlier. */
 if (IMAGE_INSTANCE_WIDGET_ITEMS_CHANGED (ii))
 {
 IMAGE_INSTANCE_WIDGET_ITEMS (ii) =
 DEVMETH (d, widget_query_string_geometry,
 	     (string, face, width, height, domain));
 else
 query_string_geometry (string, face, width, height, 0, domain);
+}
+/* Determine the spacing of the widget. */
+static int
+widget_spacing (Lisp_Object domain)
+{
+if (HAS_DEVMETH_P (DOMAIN_XDEVICE (domain), widget_spacing))
+return DEVMETH (DOMAIN_XDEVICE (domain),
+		    widget_spacing, (0));
+else
+return DEFAULT_WIDGET_SPACING;
 }
 /* Query for a widgets desired geometry. If no type specific method is
 provided then use the widget text to calculate sizes. */
 static void
 	      widget_query_string_geometry (IMAGE_INSTANCE_WIDGET_TEXT (ii),
 					    IMAGE_INSTANCE_WIDGET_FACE (ii),
 					    &w, &h, domain);
 	      /* Adjust the size for borders. */
 	      if (IMAGE_INSTANCE_SUBWINDOW_H_RESIZEP (ii))
-		*width = w + 2 * WIDGET_BORDER_WIDTH;
+		*width = w + 2 * widget_instance_border_width (ii);
 	      if (IMAGE_INSTANCE_SUBWINDOW_V_RESIZEP (ii))
-		*height = h +  2 * WIDGET_BORDER_HEIGHT;
+		*height = h +  2 * widget_instance_border_width (ii);
 	    }
 	}
 /* Finish off with dynamic sizing. */
 if (!NILP (IMAGE_INSTANCE_WIDGET_WIDTH_SUBR (ii)))
 	{
 IMAGE_INSTANCE_WIDGET_WIDTH_SUBR (ii) = Qnil;
 IMAGE_INSTANCE_WIDGET_HEIGHT_SUBR (ii) = Qnil;
 IMAGE_INSTANCE_SUBWINDOW_H_RESIZEP (ii) = 1;
 IMAGE_INSTANCE_SUBWINDOW_V_RESIZEP (ii) = 1;
 IMAGE_INSTANCE_SUBWINDOW_ORIENT (ii) = LAYOUT_HORIZONTAL;
-IMAGE_INSTANCE_SUBWINDOW_JUSTIFY (ii) = 0;
+IMAGE_INSTANCE_SUBWINDOW_H_JUSTIFY (ii) = 0;
+IMAGE_INSTANCE_SUBWINDOW_V_JUSTIFY (ii) = 0;
 }
 /* Instantiate a button widget. Unfortunately instantiated widgets are
 particular to a frame since they need to have a parent. It's not
 like images where you just select the image into the context you
 /* Taking the default face information when the user has specified
 size in characters is probably as good as any since the widget
 face is more likely to be proportional and thus give inadequate
 results. Using character sizes can only ever be approximate
-anyway. */
+anyway. :height is measured in logical characters which take into
-if (tw || th)
+account the borders and spacing on widgets. */
-{
+if (tw)
-int charwidth, charheight;
+{
-default_face_font_info (domain, 0, 0, &charheight, &charwidth, 0);
+int charwidth;
-if (tw)
+default_face_font_info (domain, 0, 0, 0, &charwidth, 0);
-	pw = charwidth * tw;
+pw = ROUND_UP (charwidth * tw + 4 * widget_instance_border_width (ii), charwidth);
-if (th)
+}
-	ph = charheight * th;
+/* For heights the widget face is more appropriate. */
+if (th == 1)
+{
+int charheight;
+if (!NILP (IMAGE_INSTANCE_WIDGET_TEXT (ii)))
+	{
+	  widget_query_string_geometry (IMAGE_INSTANCE_WIDGET_TEXT (ii),
+					IMAGE_INSTANCE_WIDGET_FACE (ii),
+					0, &charheight, domain);
+	}
+else
+	{
+	  default_face_font_info (domain, 0, 0, &charheight, 0, 0);
+	}
+ph = (charheight + 2 * widget_instance_border_width (ii)) * th;
+}
+/* For heights > 1 use logical units. */
+else if (th > 1)
+{
+ph = widget_logical_unit_height (ii) * th;
 }
 /* for a widget with an image pick up the dimensions from that */
 if (!NILP (glyph))
 {
 if (!pw)
-	pw = glyph_width (glyph, image_instance) + 2 * WIDGET_BORDER_WIDTH;
+	pw = glyph_width (glyph, image_instance) + 2 * widget_instance_border_width (ii);
 if (!ph)
-	ph = glyph_height (glyph, image_instance) + 2 * WIDGET_BORDER_HEIGHT;
+	ph = glyph_height (glyph, image_instance) + 2 * widget_instance_border_width (ii);
 IMAGE_INSTANCE_SUBWINDOW_V_RESIZEP (ii) = 0;
 IMAGE_INSTANCE_SUBWINDOW_H_RESIZEP (ii) = 0;
 }
 /* Pick up the margin width. */
 				IMAGE_INSTANCE_WIDGET_FACE (ii),
 				&w, &h, domain);
 /* Adjust the size for borders. */
 if (IMAGE_INSTANCE_SUBWINDOW_H_RESIZEP (ii))
 {
-*width = w + 2 * WIDGET_BORDER_WIDTH;
+*width = w + 3 * widget_instance_border_width (ii);
 if (EQ (XGUI_ITEM (IMAGE_INSTANCE_WIDGET_ITEM (ii))->style, Qradio)
 	  ||
 	  EQ (XGUI_ITEM (IMAGE_INSTANCE_WIDGET_ITEM (ii))->style, Qtoggle))
 	/* This is an approximation to the size of the actual button bit. */
 	*width += 12;
 }
 if (IMAGE_INSTANCE_SUBWINDOW_V_RESIZEP (ii))
-*height = h +  2 * WIDGET_BORDER_HEIGHT;
+*height = h +  3 * widget_instance_border_width (ii);
+}
+/* Get the geometry of an edit field. */
+static void
+edit_field_query_geometry (Lisp_Object image_instance,
+		       int* width, int* height,
+		       enum image_instance_geometry disp, Lisp_Object domain)
+{
+Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance);
+int w, h;
+widget_query_string_geometry (IMAGE_INSTANCE_WIDGET_TEXT (ii),
+				IMAGE_INSTANCE_WIDGET_FACE (ii),
+				&w, &h, domain);
+/* Adjust the size for borders. */
+if (IMAGE_INSTANCE_SUBWINDOW_H_RESIZEP (ii))
+*width = w + 4 * widget_instance_border_width (ii);
+if (IMAGE_INSTANCE_SUBWINDOW_V_RESIZEP (ii))
+*height = h + 4 * widget_instance_border_width (ii);
 }
 /* tree-view geometry - get the height right */
 static void
 tree_view_query_geometry (Lisp_Object image_instance,
 				    width, 0, domain);
 }
 if (*height)
 {
 int len, h;
+/* #### widget face would be better here. */
 default_face_font_info (domain, 0, 0, &h, 0, 0);
 GET_LIST_LENGTH (items, len);
 *height = len * h;
 }
 }
 LIST_LOOP (rest, items)
 {
 int h, w;
 widget_query_string_geometry (XGUI_ITEM (XCAR (rest))->name,
-				    IMAGE_INSTANCE_WIDGET_FACE (ii),
+			     IMAGE_INSTANCE_WIDGET_FACE (ii),
-				    &w, &h, domain);
+			     &w, &h, domain);
-tw += 5 * WIDGET_BORDER_WIDTH; /* some bias */
+tw += 5 * widget_instance_border_width (ii); /* some bias */
 tw += w;
-th = max (th, h + 2 * WIDGET_BORDER_HEIGHT);
+th = max (th, h + 2 * widget_instance_border_width (ii));
 }
 /* Fixup returned values depending on orientation. */
 if (IMAGE_INSTANCE_SUBWINDOW_ORIENT (ii))
 {
 layout_update (Lisp_Object image_instance, Lisp_Object instantiator)
 {
 Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance);
 Lisp_Object items = find_keyword_in_vector (instantiator, Q_items);
 Lisp_Object border_inst = find_keyword_in_vector (instantiator, Q_border);
+Lisp_Object justify = find_keyword_in_vector (instantiator, Q_justify);
+Lisp_Object hjustify = find_keyword_in_vector (instantiator, Q_horizontally_justify);
+Lisp_Object vjustify = find_keyword_in_vector (instantiator, Q_vertically_justify);
 Lisp_Object border = Qnil;
 Lisp_Object children = IMAGE_INSTANCE_LAYOUT_CHILDREN (ii);
 int structure_changed = 0;
 struct gcpro gcpro1;
+/* Pick up horizontal justification, left is the default.*/
+if (!NILP (hjustify))
+{
+if (EQ (hjustify, Qright) || EQ (hjustify, Qbottom))
+	IMAGE_INSTANCE_SUBWINDOW_H_JUSTIFY (ii) = LAYOUT_JUSTIFY_RIGHT;
+else if (EQ (hjustify, Qcenter))
+	IMAGE_INSTANCE_SUBWINDOW_H_JUSTIFY (ii) = LAYOUT_JUSTIFY_CENTER;
+}
+/* If not set use general justification. */
+else if (!NILP (justify))
+{
+if (EQ (justify, Qright) || EQ (justify, Qbottom))
+	IMAGE_INSTANCE_SUBWINDOW_H_JUSTIFY (ii) = LAYOUT_JUSTIFY_RIGHT;
+else if (EQ (justify, Qcenter))
+	IMAGE_INSTANCE_SUBWINDOW_H_JUSTIFY (ii) = LAYOUT_JUSTIFY_CENTER;
+}
+/* Pick up vertical justification, top is the default. */
+if (!NILP (vjustify))
+{
+if (EQ (vjustify, Qright) || EQ (vjustify, Qbottom))
+	IMAGE_INSTANCE_SUBWINDOW_V_JUSTIFY (ii) = LAYOUT_JUSTIFY_BOTTOM;
+else if (EQ (vjustify, Qcenter))
+	IMAGE_INSTANCE_SUBWINDOW_V_JUSTIFY (ii) = LAYOUT_JUSTIFY_CENTER;
+}
+/* If not set use general justification. */
+else if (!NILP (justify))
+{
+if (EQ (justify, Qright) || EQ (justify, Qbottom))
+	IMAGE_INSTANCE_SUBWINDOW_V_JUSTIFY (ii) = LAYOUT_JUSTIFY_BOTTOM;
+else if (EQ (justify, Qcenter))
+	IMAGE_INSTANCE_SUBWINDOW_V_JUSTIFY (ii) = LAYOUT_JUSTIFY_CENTER;
+}
 /* We want to avoid consing if we can. This is quite awkward because
 we have to deal with the border as well as the items. */
 GCPRO1 (border);
 if (INTP (IMAGE_INSTANCE_LAYOUT_BORDER (ii)))
 {
 border = XCAR (children);
 a glyph-face or image-instance face. All other glyphs are
 essentially fixed in appearance. Perhaps the problem is that text
 glyphs are cached on a device basis like most other glyphs. Instead
 they should be cached per-window and then the instance would be
 fixed and we wouldn't have to mess around with font metrics and the
-rest. */
+rest.
+Another sizing problem is alignment. We provide layout widgets that
+allow users to stack widgets vertically or horizontally. These
+layouts also allow the widgets to be centered (space evenly
+distributed), left or right justified (fixed spacing widgets
+stacked against the left, righ, top or bottom edge). Unfortunately
+this doesn't allow widgets in different layouts to be aligned. For
+instance how should the search dialog be organized for alignment?
+The obvious choice of two vertical columns does not work since the
+size of individual widgets will affect where they get placed. The
+same is true for several rows of widgets. To solve this problem we
+introduce the notion of `logical_unit_height'. This is a size
+quantity that is designed to be big enough to accomodate the
+largest `single height unit'. The function
+widget_logical_unit_height() determines the value of this in
+pixels. It is dependent on the widget face and some combination of
+spacing and border-width. Thus if users specify left or right
+justification in a vertical layout they get something in logical
+units. To simplify this the functions
+`widget-logical-to-character-height' and
+`widget-logical-to-character-width' allow conversion between
+characters and logical units so that frames can be sized
+appropriately. */
 /* Query the geometry of a layout widget. We assume that we can only
 get here if the size is not already fixed. */
 static void
 layout_query_geometry (Lisp_Object image_instance, int* width,
 		       Lisp_Object domain)
 {
 Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance);
 Lisp_Object items = IMAGE_INSTANCE_LAYOUT_CHILDREN (ii), rest;
 int maxph = 0, maxpw = 0, nitems = 0, ph_adjust = 0;
-int gheight, gwidth;
+int gheight, gwidth, luh;
 /* If we are not initialized then we won't have any children. */
 if (!IMAGE_INSTANCE_INITIALIZED (ii))
 return;
 if (!IMAGE_INSTANCE_SUBWINDOW_V_RESIZEP (ii)
 &&
 !IMAGE_INSTANCE_SUBWINDOW_H_RESIZEP (ii))
 return;
+luh = widget_logical_unit_height (ii);
 /* Pick up the border text if we have one. */
 if (INTP (IMAGE_INSTANCE_LAYOUT_BORDER (ii)))
 {
 glyph_query_geometry (XCAR (items), &gwidth, &gheight, disp,
 			    image_instance);
-ph_adjust = gheight / 2;
+ph_adjust = gheight;
 items = XCDR (items);
 }
 /* Flip through the items to work out how much stuff we have to display */
 LIST_LOOP (rest, items)
 {
 Lisp_Object glyph = XCAR (rest);
 glyph_query_geometry (glyph, &gwidth, &gheight, disp, image_instance);
 nitems ++;
-if (IMAGE_INSTANCE_SUBWINDOW_ORIENT (ii)
+if (IMAGE_INSTANCE_SUBWINDOW_ORIENT (ii) == LAYOUT_HORIZONTAL)
-	  == LAYOUT_HORIZONTAL)
 	{
 	  maxph = max (maxph, gheight);
 	  maxpw += gwidth;
 	}
 else
 Lisp_Object dynamic_width =
 	eval_within_redisplay (IMAGE_INSTANCE_WIDGET_WIDTH_SUBR (ii));
 if (INTP (dynamic_width))
 	*width = XINT (dynamic_width);
 }
-else if (IMAGE_INSTANCE_SUBWINDOW_ORIENT (ii)
+else if (IMAGE_INSTANCE_SUBWINDOW_ORIENT (ii) == LAYOUT_HORIZONTAL)
-	   == LAYOUT_HORIZONTAL)
+{
-*width = maxpw + ((nitems + 1) * WIDGET_BORDER_WIDTH +
+*width = maxpw + ((nitems + 1) * widget_instance_border_width (ii) +
-		      IMAGE_INSTANCE_MARGIN_WIDTH (ii)) * 2;
+			IMAGE_INSTANCE_MARGIN_WIDTH (ii)) * 2;
+}
 else
-*width = maxpw + 2 * (WIDGET_BORDER_WIDTH * 2 +
+{
-			  IMAGE_INSTANCE_MARGIN_WIDTH (ii));
+*width = maxpw + 2 * (widget_instance_border_width (ii) * 2 +
+			    IMAGE_INSTANCE_MARGIN_WIDTH (ii));
+}
 /* Work out vertical spacings. */
 if (!NILP (IMAGE_INSTANCE_WIDGET_HEIGHT_SUBR (ii)))
 {
 Lisp_Object dynamic_height =
 	eval_within_redisplay (IMAGE_INSTANCE_WIDGET_HEIGHT_SUBR (ii));
 if (INTP (dynamic_height))
 	*height = XINT (dynamic_height);
 }
-else if (IMAGE_INSTANCE_SUBWINDOW_ORIENT (ii)
+else if (IMAGE_INSTANCE_SUBWINDOW_LOGICAL_LAYOUT (ii))
-	   == LAYOUT_VERTICAL)
+{
-*height = maxph + ((nitems + 1) * WIDGET_BORDER_HEIGHT +
+*height = nitems * luh + ph_adjust;
-		       IMAGE_INSTANCE_MARGIN_WIDTH (ii)) * 2 + ph_adjust;
+}
+else if (IMAGE_INSTANCE_SUBWINDOW_ORIENT (ii) == LAYOUT_VERTICAL)
+{
+*height = maxph + ((nitems + 1) * widget_instance_border_width (ii) +
+			 IMAGE_INSTANCE_MARGIN_WIDTH (ii)) * 2 + ph_adjust;
+}
 else
-*height = maxph + (2 * WIDGET_BORDER_HEIGHT +
+{
-		       IMAGE_INSTANCE_MARGIN_WIDTH (ii)) * 2 + ph_adjust;
+*height = maxph + (2 * widget_instance_border_width (ii) +
+			 IMAGE_INSTANCE_MARGIN_WIDTH (ii)) * 2 + ph_adjust;
+}
+#ifdef DEBUG_WIDGET_OUTPUT
+stderr_out ("layout wants %dx%d\n", *width, *height);
+#endif
 }
 int
 layout_layout (Lisp_Object image_instance,
 	       int width, int height, int xoffset, int yoffset,
 Lisp_Object rest;
 Lisp_Object items = IMAGE_INSTANCE_LAYOUT_CHILDREN (ii);
 int x, y, maxph = 0, maxpw = 0, nitems = 0,
 horiz_spacing, vert_spacing, ph_adjust = 0;
 int gheight, gwidth;
+/* See comments in widget_logical_unit_height(). */
+int luh = widget_logical_unit_height (ii);
 /* If we are not initialized then we won't have any children. */
 if (!IMAGE_INSTANCE_INITIALIZED (ii))
 return 0;
-/* Pick up the border text if we have one. */
+#ifdef DEBUG_WIDGET_OUTPUT
+stderr_out ("layout output %dx%d\n", width, height);
+#endif
+/* Pick up the border text if we have one. A border can have the
+values Qetched_in, Qetched_out, Qbevel_in, Qbevel_out or an
+integer. The first four just affect the display properties of the
+border that is drawn. The last is an offset and implies that the
+first item in the list of subcontrols is a text control that
+should be displayed on the border. */
 if (INTP (IMAGE_INSTANCE_LAYOUT_BORDER (ii)))
 {
 Lisp_Object border = XCAR (items);
 items = XCDR (items);
 glyph_query_geometry (border, &gwidth, &gheight,
 			    IMAGE_DESIRED_GEOMETRY, image_instance);
-ph_adjust = gheight / 2;
+/* The vertical offset for subsequent items is the full height
-IMAGE_INSTANCE_LAYOUT_BORDER (ii) = make_int (ph_adjust);
+	 of the border glyph. */
+ph_adjust = gheight;
+/* The offset for the border is half the glyph height. */
+IMAGE_INSTANCE_LAYOUT_BORDER (ii) = make_int (gheight / 2);
 /* #### Really, what should this be? */
 glyph_do_layout (border, gwidth, gheight, 10, 0,
 		       image_instance);
 }
 /* work out spacing between items and bounds of the layout */
 if (width < maxpw)
 /* The user wants a smaller space than the largest item, so we
 just provide default spacing and will let the output routines
-clip.. */
+clip. */
-horiz_spacing = WIDGET_BORDER_WIDTH * 2;
+horiz_spacing = widget_spacing (IMAGE_INSTANCE_DOMAIN (ii));
 else if (IMAGE_INSTANCE_SUBWINDOW_ORIENT (ii)
 	   == LAYOUT_HORIZONTAL)
 /* We have a larger area to display in so distribute the space
 evenly. */
 horiz_spacing = (width - (maxpw +
 			      IMAGE_INSTANCE_MARGIN_WIDTH (ii) * 2))
 / (nitems + 1);
 else
 horiz_spacing = (width - maxpw) / 2
 - IMAGE_INSTANCE_MARGIN_WIDTH (ii);
+/* We are trying here to get widgets to line up when they are left
+or right justified vertically. This means that we must position
+widgets on logical unit boundaries, even though their height may
+be greater or less than a logical unit. In order to avoid
+clipping we need to determine how big the widget wants to be and
+then allocate as many logical units as necessary in order to
+accommodate it. */
 if (height < maxph)
-vert_spacing = WIDGET_BORDER_HEIGHT * 2;
+vert_spacing = widget_spacing (IMAGE_INSTANCE_DOMAIN (ii)) * 2;
 else if (IMAGE_INSTANCE_SUBWINDOW_ORIENT (ii)
 	   == LAYOUT_VERTICAL)
-vert_spacing = (height - (maxph + ph_adjust +
+{
-			      IMAGE_INSTANCE_MARGIN_WIDTH (ii) * 2))
+if (!IMAGE_INSTANCE_SUBWINDOW_V_CENTERED (ii))
-/ (nitems + 1);
+	vert_spacing = widget_spacing (IMAGE_INSTANCE_DOMAIN (ii)) * 2;
+else
+	vert_spacing = (height - (maxph + ph_adjust +
+				  IMAGE_INSTANCE_MARGIN_WIDTH (ii) * 2))
+	  / (nitems + 1);
+}
 else
 vert_spacing = (height - (maxph + ph_adjust)) / 2
 - IMAGE_INSTANCE_MARGIN_WIDTH (ii);
-y = vert_spacing + ph_adjust + IMAGE_INSTANCE_MARGIN_WIDTH (ii);
+y = yoffset = vert_spacing + ph_adjust + IMAGE_INSTANCE_MARGIN_WIDTH (ii);
 x = horiz_spacing + IMAGE_INSTANCE_MARGIN_WIDTH (ii);
 /* Now flip through putting items where we want them, paying
 attention to justification. Make sure we don't mess with the
 border glyph. */
 Lisp_Object glyph = XCAR (rest);
 glyph_query_geometry (glyph, &gwidth, &gheight,
 			    IMAGE_DESIRED_GEOMETRY, image_instance);
-if (IMAGE_INSTANCE_SUBWINDOW_ORIENT (ii)
+if (IMAGE_INSTANCE_SUBWINDOW_ORIENT (ii) == LAYOUT_HORIZONTAL)
-	  == LAYOUT_HORIZONTAL)
+	{
-	{
+	  if (IMAGE_INSTANCE_SUBWINDOW_BOTTOM_JUSTIFIED (ii))
-	  if (IMAGE_INSTANCE_SUBWINDOW_JUSTIFY (ii)
-	      == LAYOUT_JUSTIFY_RIGHT)
 	    y = height - (gheight + vert_spacing);
-	  if (IMAGE_INSTANCE_SUBWINDOW_JUSTIFY (ii)
+	  else if (IMAGE_INSTANCE_SUBWINDOW_V_CENTERED (ii))
-	      == LAYOUT_JUSTIFY_CENTER)
 	    y = (height - gheight) / 2;
 	}
 else
 	{
-	  if (IMAGE_INSTANCE_SUBWINDOW_JUSTIFY (ii)
+	  if (IMAGE_INSTANCE_SUBWINDOW_RIGHT_JUSTIFIED (ii))
-	      == LAYOUT_JUSTIFY_RIGHT)
 	    x = width - (gwidth + horiz_spacing);
-	  if (IMAGE_INSTANCE_SUBWINDOW_JUSTIFY (ii)
+	  else if (IMAGE_INSTANCE_SUBWINDOW_H_CENTERED (ii))
-	      == LAYOUT_JUSTIFY_CENTER)
 	    x = (width - gwidth) / 2;
 	}
 /* Now layout subwidgets if they require it. */
 glyph_do_layout (glyph, gwidth, gheight, x, y, image_instance);
-if (IMAGE_INSTANCE_SUBWINDOW_ORIENT (ii)
+if (IMAGE_INSTANCE_SUBWINDOW_ORIENT (ii) == LAYOUT_HORIZONTAL)
-	  == LAYOUT_HORIZONTAL)
 	{
 	  x += (gwidth + horiz_spacing);
 	}
 else
 	{
 	  y += (gheight + vert_spacing);
+	  if (!IMAGE_INSTANCE_SUBWINDOW_V_CENTERED (ii))
+	    {
+	      /* justified, vertical layout, try and align on logical unit
+		 boundaries. */
+	      y = ROUND_UP (y - yoffset, luh) + yoffset;
+	    }
 	}
 }
 return 1;
 }
 		     IMAGE_INSTANCE_YOFFSET (ii), &dga);
 }
 return 1;
 }
+DEFUN ("widget-logical-to-character-width", Fwidget_logical_to_character_width, 1, 3, 0, /*
+Convert the width in logical widget units to characters.
+Logical widget units do not take into account adjusments made for
+layout borders, so this adjusment is approximated.
+*/
+(width, face, domain))
+{
+int w, neww, charwidth;
+int border_width = DEFAULT_WIDGET_BORDER_WIDTH;
+if (NILP (domain))
+domain = Fselected_frame (Qnil);
+CHECK_INT (width);
+w = XINT (width);
+if (HAS_DEVMETH_P (DOMAIN_XDEVICE (domain), widget_border_width))
+border_width = DEVMETH (DOMAIN_XDEVICE (domain), widget_border_width, ());
+default_face_font_info (domain, 0, 0, 0, &charwidth, 0);
+neww = ROUND_UP (charwidth * w + 4 * border_width + 2 * widget_spacing (domain),
+		charwidth) / charwidth;
+return make_int (neww);
+}
+DEFUN ("widget-logical-to-character-height", Fwidget_logical_to_character_height, 1, 3, 0, /*
+Convert the height in logical widget units to characters.
+Logical widget units do not take into account adjusments made for
+layout borders, so this adjustment is approximated.
+If the components of a widget layout are justified to the top or the
+bottom then they are aligned in terms of `logical units'. This is a
+size quantity that is designed to be big enough to accomodate the
+largest `single height' widget. It is dependent on the widget face and
+some combination of spacing and border-width. Thus if you specify top
+or bottom justification in a vertical layout the subcontrols are laid
+out one per logical unit. This allows adjoining layouts to have
+identical alignment for their subcontrols.
+Since frame sizes are measured in characters, this function allows you
+to do appropriate conversion between logical units and characters.
+*/
+(height, face, domain))
+{
+int h, newh, charheight;
+CHECK_INT (height);
+if (NILP (domain))
+domain = Fselected_frame (Qnil);
+h = XINT (height);
+default_face_font_info (domain, 0, 0, &charheight, 0, 0);
+newh = ROUND_UP (logical_unit_height (Fsymbol_name (Qwidget),
+					Vwidget_face, domain) * h, charheight)
+/ charheight;
+return make_int (newh);
+}
 /************************************************************************/
 /*                            initialization                            */
 /************************************************************************/
 DEFSYMBOL (Qetched_in);
 DEFSYMBOL (Qetched_out);
 DEFSYMBOL (Qbevel_in);
 DEFSYMBOL (Qbevel_out);
 DEFSYMBOL (Qmake_glyph);
+DEFSUBR (Fwidget_logical_to_character_height);
+DEFSUBR (Fwidget_logical_to_character_width);
 }
 #define VALID_GUI_KEYWORDS(type) do {					      \
 IIFORMAT_VALID_NONCOPY_KEYWORD (type, Q_active, check_valid_anything);      \
 IIFORMAT_VALID_KEYWORD (type, Q_suffix, check_valid_anything);	      \
 IIFORMAT_HAS_SHARED_METHOD (edit_field, validate, widget);
 IIFORMAT_HAS_SHARED_METHOD (edit_field, possible_dest_types, widget);
 IIFORMAT_HAS_SHARED_METHOD (edit_field, instantiate, widget);
 IIFORMAT_HAS_SHARED_METHOD (edit_field, post_instantiate, widget);
 IIFORMAT_HAS_SHARED_METHOD (edit_field, governing_domain, subwindow);
+IIFORMAT_HAS_METHOD (edit_field, query_geometry);
 VALID_WIDGET_KEYWORDS (edit_field);
 VALID_GUI_KEYWORDS (edit_field);
 }
 static void image_instantiator_combo_box (void)
 #define VALID_LAYOUT_KEYWORDS(layout)					   \
 VALID_WIDGET_KEYWORDS (layout);					   \
 IIFORMAT_VALID_KEYWORD (layout, Q_orientation, check_valid_orientation); \
 IIFORMAT_VALID_KEYWORD (layout, Q_justify, check_valid_justification);   \
+IIFORMAT_VALID_KEYWORD (layout, Q_vertically_justify, check_valid_justification);   \
+IIFORMAT_VALID_KEYWORD (layout, Q_horizontally_justify, check_valid_justification);   \
 IIFORMAT_VALID_KEYWORD (layout, Q_border, check_valid_border);	   \
 IIFORMAT_VALID_KEYWORD (layout, Q_margin_width, check_valid_int);	   \
 IIFORMAT_VALID_KEYWORD (layout, Q_items,				   \
 			  check_valid_instantiator_list)
 void
 vars_of_glyphs_widget (void)
 {
 reinit_vars_of_glyphs_widget ();
 }
+void
+specifier_vars_of_glyphs_widget (void)
+{
+DEFVAR_SPECIFIER ("widget-border-width",
+		    &Vwidget_border_width /*
+*Border width of widgets.
+This is a specifier; use `set-specifier' to change it.
+*/ );
+Vwidget_border_width = Fmake_specifier (Qnatnum);
+}

Mercurial > hg > xemacs-beta

comparison src/glyphs-widget.c @ 863:42375619fa45