xemacs-beta: lwlib/xlwtabs.c comparison

comparison lwlib/xlwtabs.c @ 434:9d177e8d4150 r21-2-25

Import from CVS: tag r21-2-25

author	cvs
date	Mon, 13 Aug 2007 11:30:53 +0200
parents	3a7e78e1142d
children	080151679be2

comparison

equal deleted inserted replaced

-:892ca416f0fb
+:9d177e8d4150
 You should have received a copy of the GNU General Public License
 along with XEmacs; see the file COPYING.  If not, write to
 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 Boston, MA 02111-1307, USA.  */
-/* Synched up with: Tabs.c 1.25 */
+/* Synched up with: Tabs.c 1.27 */
 /*
 * Tabs.c - Index Tabs composite widget
 *
 * Author: Edward A. Falk
 * The tabs overlap the frame and each other vertically by the shadow
 * width, so that when the topmost tab is drawn, it obliterates part of
 * the frame.
 */
-/* TODO: min child height = tab height
+/*
-*
+* TODO: min child height = tab height
 */
 #include	<config.h>
 #include	<stdio.h>
 static	void	TabsResize();
 static	void	TabsExpose();
 static	void	TabsDestroy();
 static	void	TabsRealize();
 static	Boolean	TabsSetValues();
+static	Boolean	TabsAcceptFocus();
 static	XtGeometryResult	TabsQueryGeometry();
 static	XtGeometryResult	TabsGeometryManager();
 static	void	TabsChangeManaged();
 static	void	TabsConstraintInitialize() ;
 static	Boolean	TabsConstraintSetValues() ;
 static	void	TabsRealize(Widget, Mask *, XSetWindowAttributes *) ;
 static	void	TabsDestroy( Widget w) ;
 static	void	TabsResize( Widget w) ;
 static	void	TabsExpose( Widget w, XEvent *event, Region region) ;
 static	Boolean	TabsSetValues(Widget, Widget, Widget, ArgList, Cardinal *) ;
+static	Boolean	TabsAcceptFocus(Widget, Time *);
 static	Boolean	TabsConstraintSetValues(Widget, Widget, Widget,
 			ArgList, Cardinal *) ;
 static	XtGeometryResult TabsQueryGeometry(Widget,
 				XtWidgetGeometry *, XtWidgetGeometry *) ;
 static	XtGeometryResult TabsGeometryManager(Widget,
 static	void	TabWidth( Widget w) ;
 static	int	TabLayout( TabsWidget, int wid, int hgt, Dimension *r_hgt,
 			Bool query_only) ;
 static	void	GetPreferredSizes(TabsWidget) ;
-static	void	MaxChild(TabsWidget) ;
+static	void	MaxChild(TabsWidget, Widget except, Dimension, Dimension) ;
 static	void	TabsShuffleRows( TabsWidget tw) ;
 static	int	PreferredSize( TabsWidget,
 			Dimension *reply_width, Dimension *reply_height,
 			Dimension *reply_cw, Dimension *reply_ch) ;
 static	int	PreferredSize2( TabsWidget, int cw, int ch,
 /* num_actions	  */	XtNumber(actionsList),
 /* resources          */    resources,
 /* num_resources      */    XtNumber(resources),
 /* xrm_class          */    NULLQUARK,
 /* compress_motion	  */	TRUE,
-/* compress_exposure  */	TRUE,
+#if XtSpecificationRelease < 6
+/* compress_exposure  */	XtExposeCompressMaximal,
+#else
+/* compress_exposure  */	XtExposeCompressMaximal|XtExposeNoRegion,
+#endif
 /* compress_enterleave*/	TRUE,
-/* visible_interest   */    FALSE,
+/* visible_interest   */    TRUE,
 /* destroy            */    TabsDestroy,
 /* resize             */    TabsResize,
 /* expose             */    TabsExpose,
 /* set_values         */    TabsSetValues,
 /* set_values_hook    */	NULL,
 /* set_values_almost  */    XtInheritSetValuesAlmost,
 /* get_values_hook    */	NULL,
-/* accept_focus       */    NULL,
+/* accept_focus       */    TabsAcceptFocus,
 /* version            */	XtVersion,
 /* callback_private   */    NULL,
 /* tm_table           */    defaultTranslations,
 /* query_geometry     */	TabsQueryGeometry,
 /* display_accelerator*/	XtInheritDisplayAccelerator,
 newTw->tabs.botGC = None ;
 newTw->tabs.grey50 = None ;
 newTw->tabs.needs_layout = False ;
 newTw->tabs.hilight = NULL ;
 #ifdef	NEED_MOTIF
 newTw->manager.navigation_type = XmTAB_GROUP ;
 newTw->manager.traversal_on = True ;
 TabsConstraintInitialize(Widget request, Widget new,
 	ArgList args, Cardinal *num_args)
 {
 	TabsConstraints tab = (TabsConstraints) new->core.constraints ;
 	tab->tabs.greyAlloc = False ;	/* defer allocation of pixel */
-	tab->tabs.queried = False ;	/* defer size query */
 	getBitmapInfo((TabsWidget)XtParent(new), tab) ;
 	TabWidth(new) ;
 }
 	 * Once the tabs are laid out, if there is more than one
 	 * row, we may need to shuffle the rows to bring the top tab
 	 * to the bottom row.
 	 */
+	tw->tabs.needs_layout = False ;
 	if( num_children > 0 && tw->composite.children != NULL )
 	{
 	  /* Loop through the tabs and assign rows & x positions */
 	  (void) TabLayout(tw, tw->core.width, tw->core.height, NULL, False) ;
 	  num_children = tw->tabs.displayChildren;
 	   * same: just inside the frame.  Sizes are also all the same.
 	   */
 	  tw->tabs.child_width = cw = tw->core.width - 2 * SHADWID ;
 	  tw->tabs.child_height = ch =
-	  		tw->core.height - tw->tabs.tab_total - 2 * SHADWID ;
+			tw->core.height - tw->tabs.tab_total - 2 * SHADWID ;
 	  for(i=0, childP=tw->composite.children;
-	  	i < num_children;
+		i < num_children;
 		++i, ++childP)
 	    if( XtIsManaged(*childP) )
 	    {
 	      tab = (TabsConstraints) (*childP)->core.constraints ;
-	      bw = tab->tabs.bwid ;
+	      bw = (*childP)->core.border_width ;
 	      XtConfigureWidget(*childP, SHADWID,tw->tabs.tab_total+SHADWID,
 			  cw-bw*2,ch-bw*2, bw) ;
 	    }
-	  if( XtIsRealized(w) )
+	  if( XtIsRealized(w) ) {
-	    {
+	    XClearWindow(XtDisplay((Widget)tw), XtWindow((Widget)tw)) ;
-	      XClearWindow(XtDisplay((Widget)tw), XtWindow((Widget)tw)) ;
+	    /* should not be necessary to explicitly repaint after a
-	      tw->tabs.needs_layout = False ;
+	     * resize, but XEmacs folks tell me it is.
-	      XtClass(tw)->core_class.expose((Widget)tw,NULL,None) ;
+	     */
-	    }
+	    XtClass(tw)->core_class.expose((Widget)tw,NULL,None) ;
-	}
+	  }
+	}
-	tw->tabs.needs_layout = False ;
 } /* Resize */
 	/* Redraw entire Tabs widget */
 	return False ;
 }
+static	Boolean
+TabsAcceptFocus(Widget w, Time *t)
+{
+	if( !w->core.being_destroyed && XtIsRealized(w) &&
+	    XtIsSensitive(w) && XtIsManaged(w) && w->core.visible )
+	{
+	  Widget p ;
+	  for(p = XtParent(w); !XtIsShell(p); p = XtParent(p)) ;
+	  XtSetKeyboardFocus(p,w) ;
+	  return True ;
+	}
+	else
+	  return False ;
+}
 /*
 * Return preferred size.  Happily accept anything >= our preferred size.
 * (TODO: is that the right thing to do?  Should we always return "almost"
 * if offerred more than we need?)
 if( (!(mode & CWWidth) || intended->width == w->core.width)  &&
 (!(mode & CWHeight) || intended->height == w->core.height) )
 return XtGeometryNo ;
-#ifdef	COMMENT
 if( (!(mode & CWWidth) || intended->width >= preferred->width)  &&
 	(!(mode & CWHeight) || intended->height >= preferred->height) )
 return XtGeometryYes;
-#endif	/* COMMENT */
 return XtGeometryAlmost;
 }
 {
 	TabsWidget		tw = (TabsWidget) XtParent(w);
 	Dimension		s = SHADWID ;
 	TabsConstraints		tab = (TabsConstraints)w->core.constraints;
 	XtGeometryResult	result ;
+	Dimension		rw, rh ;
 	/* Position request always denied */
 	if( ((req->request_mode & CWX) && req->x != w->core.x) ||
 	    ((req->request_mode & CWY) && req->y != w->core.y) ||
 	if( req->width == w->core.width &&
 	    req->height == w->core.height &&
 	    req->border_width == w->core.border_width )
 	  return XtGeometryNo ;
-	/* updated cached preferred size of the child */
+	rw = req->width + 2 * req->border_width ;
-	tab->tabs.bwid = req->border_width ;
+	rh = req->height + 2 * req->border_width ;
-	tab->tabs.wid = req->width + req->border_width * 2 ;
-	tab->tabs.hgt = req->height + req->border_width * 2 ;
+	/* find out how big the children want to be now */
-	MaxChild(tw) ;
+	MaxChild(tw, w, rw, rh) ;
 	/* Size changes must see if the new size can be accommodated.
 	 * The Tabs widget keeps all of its children the same
 	 * size.  A request to shrink will be accepted only if the
 	 * new size is still big enough for all other children.  A
 	 * request to shrink that is not big enough for all children
-	 * returns an "almost" response with the new proposed size.
+	 * returns an "almost" response with the new proposed size
+	 * or a "no" response if unable to shrink at all.
+	 *
 	 * A request to grow will be accepted only if the Tabs parent can
 	 * grow to accommodate.
 	 *
 	 * TODO:
 	 * We could get fancy here and re-arrange the tabs if it is
 	 * for another day.
 	 */
 	if (req->request_mode & (CWWidth | CWHeight | CWBorderWidth))
 	{
-	  Dimension	rw,rh ;		/* child's requested width, height */
 	  Dimension	cw,ch ;		/* children's preferred size */
 	  Dimension	aw,ah ;		/* available size we can give child */
 	  Dimension	th ;		/* space used by tabs */
 	  Dimension	wid,hgt ;	/* Tabs widget size */
-	  rw = cw = tab->tabs.wid ;
+	  cw = tw->tabs.max_cw ;
-	  rh = ch = tab->tabs.hgt ;
+	  ch = tw->tabs.max_ch ;
-	  /* find out what the resulting preferred size would be */
+	  /* find out what *my* resulting preferred size would be */
-#ifdef	COMMENT
+	  PreferredSize2(tw, cw, ch, &wid, &hgt) ;
-	  MaxChild(tw, &cw, &ch) ;
-#endif	/* COMMENT */
+	  /* Would my size change?  If so, ask to be resized. */
-	  PreferredSize2(tw,
-	  	cw=tw->tabs.max_cw, ch=tw->tabs.max_ch, &wid, &hgt) ;
-	  /* Ask to be resized to accommodate. */
 	  if( wid != tw->core.width || hgt != tw->core.height )
 	  {
 	    Dimension	oldWid = tw->core.width, oldHgt = tw->core.height ;
 	    XtWidgetGeometry	myrequest, myreply ;
 	    if( (req->request_mode & XtCWQueryOnly)  || rw < cw || rh < ch )
 	      myrequest.request_mode |= XtCWQueryOnly ;
 	    result = XtMakeGeometryRequest((Widget)tw, &myrequest, &myreply) ;
-	    /* !$@# Box widget changes the core size even if QueryOnly
+	    /* !$@# Athena Box widget changes the core size even if QueryOnly
 	     * is set.  I'm convinced this is a bug.  At any rate, to work
 	     * around the bug, we need to restore the core size after every
 	     * query geometry request.  This is only partly effective,
 	     * as there may be other boxes further up the tree.
 	     */
 	     */
 	    switch( result ) {
 	      case XtGeometryYes:
 	      case XtGeometryDone:
+		tw->tabs.needs_layout = True ;
 		break ;
 	      case XtGeometryNo:
 		wid = tw->core.width ;
 		hgt = tw->core.height ;
 		break ;
 	      case XtGeometryAlmost:
 		wid = myreply.width ;
 		hgt = myreply.height ;
+		tw->tabs.needs_layout = True ;
+		break ;
 	    }
 	  }
 	  /* Within the constraints imposed by the parent, what is
 	   * the max size we can give the child?
 }
 if( tw->tabs.topWidget != NULL )
 XtVaSetValues(tw->tabs.topWidget, XmNtraversalOn, True, 0) ;
 #endif
 }
 	TabsConstraints tab ;
 	Widget		oldtop = tw->tabs.topWidget ;
 	if( !XtIsSubclass(w->core.parent, tabsWidgetClass) )
 	{
-	  char line[1024] ;
+	  char line[256] ;
-	  sprintf(line, "XawTabsSetTop: widget \"%s\" is not the child of a tabs widget.", XtName(w)) ;
+	  sprintf(line, "XawTabsSetTop: widget \"%.64s\" is not the child of a tabs widget.", XtName(w)) ;
 	  XtAppWarning(XtWidgetToApplicationContext(w), line) ;
 	  return ;
 	}
 	if( callCallbacks )
 	  XtCallCallbackList(w, tw->tabs.popdownCallbacks,
-	  	(XtPointer)tw->tabs.topWidget) ;
+		(XtPointer)tw->tabs.topWidget) ;
 	if( !XtIsRealized(w) ) {
 	  tw->tabs.topWidget = w ;
 	  tw->tabs.needs_layout = True ;
 	  return ;
 	  if( tab->tabs.left_bitmap != None && tab->tabs.lbm_width > 0 )
 	  {
 	    if( tab->tabs.lbm_depth == 1 )
 	      XCopyPlane(dpy, tab->tabs.left_bitmap, win,gc,
-	      	0,0, tab->tabs.lbm_width, tab->tabs.lbm_height,
+		0,0, tab->tabs.lbm_width, tab->tabs.lbm_height,
 		x+tab->tabs.lbm_x, y+tab->tabs.lbm_y, 1L) ;
 	    else
 	      XCopyArea(dpy, tab->tabs.left_bitmap, win,gc,
-	      	0,0, tab->tabs.lbm_width, tab->tabs.lbm_height,
+		0,0, tab->tabs.lbm_width, tab->tabs.lbm_height,
 		x+tab->tabs.lbm_x, y+tab->tabs.lbm_y) ;
 	  }
 	  if( lbl != NULL && tw->tabs.font != NULL )
 	    XDrawString(dpy,win,gc,
 	/* GEOMETRY UTILITIES */
+	/* Overview:
-	/* Compute the size of one child's tab.  Positions will be computed
+	 *
+	 *  MaxChild(): ask all children (except possibly one) their
+	 *  preferred sizes, set max_cw, max_ch accordingly.
+	 *
+	 *  GetPreferredSizes(): ask all children their preferred sizes,
+	 *  set max_cw, max_ch accordingly.
+	 *
+	 *  PreferredSize(): given max_cw, max_ch, return tabs widget
+	 *  preferred size.  Iterate with other widths in order to get
+	 *  a reasonable aspect ratio.
+	 *
+	 *  PreferredSize2(): Given child dimensions, return Tabs
+	 *  widget dimensions.
+	 *
+	 *  PreferredSize3(): Same, except given child dimensions plus
+	 *  shadow.
+	 */
+	/* Compute the width of one child's tab.  Positions will be computed
 	 * elsewhere.
 	 *
 	 *	height: font height + vertical_space*2 + shadowWid*2
 	 *	width:	string width + horizontal_space*2 + shadowWid*2
 	 *
 	if( lbl != NULL && font != NULL )
 	{
 	  tab->tabs.width += XTextWidth( font, lbl, (int)strlen(lbl) ) + iw ;
 	  tab->tabs.l_y = (tw->tabs.tab_height +
-	 	 tw->tabs.font->max_bounds.ascent -
+		 tw->tabs.font->max_bounds.ascent -
 		 tw->tabs.font->max_bounds.descent)/2 ;
 	}
 }
 }
 	/* Find max preferred child size.  Returned sizes include child
-	 * border widths.  We only ever ask a child its preferred
+	 * border widths.
-	 * size once.  After that, the preferred size is updated only
-	 * if the child makes a geometry request.
 	 */
 static	void
 GetPreferredSizes(TabsWidget tw)
+{
+	MaxChild(tw, NULL, 0,0) ;
+}
+	/* Find max preferred child size.  Returned sizes include child
+	 * border widths.  If except is non-null, don't ask that one.
+	 */
+static	void
+MaxChild(TabsWidget tw, Widget except, Dimension cw, Dimension ch)
 {
 	int			i ;
 	Widget			*childP = tw->composite.children ;
 	XtWidgetGeometry	preferred ;
-	TabsConstraints		tab ;
-	Dimension		cw = 0, ch = 0 ;
+	for(i=tw->composite.num_children; --i >=0; ++childP)
+	  if( XtIsManaged(*childP)  &&  *childP != except )
-	for(i=tw->tabs.displayChildren; --i >= 0; ++childP)
-	  if( XtIsManaged(*childP) )
 	  {
-	    tab = (TabsConstraints) (*childP)->core.constraints ;
+	    (void) XtQueryGeometry(*childP, NULL, &preferred) ;
-	    if( !tab->tabs.queried ) {
+	    cw = Max(cw, preferred.width + preferred.border_width * 2 ) ;
-	      (void) XtQueryGeometry(*childP, NULL, &preferred) ;
+	    ch = Max(ch, preferred.height + preferred.border_width * 2 ) ;
-	      tab->tabs.bwid = preferred.border_width ;
-	      tab->tabs.wid = preferred.width + preferred.border_width * 2 ;
-	      tab->tabs.hgt = preferred.height + preferred.border_width * 2 ;
-	      tab->tabs.queried = True ;
-	    }
-	    cw = Max(cw, tab->tabs.wid ) ;
-	    ch = Max(ch, tab->tabs.hgt ) ;
-	  }
-	tw->tabs.max_cw = cw ;
-	tw->tabs.max_ch = ch ;
-}
-	/* Find max preferred child size.  Returned sizes include child
-	 * border widths. */
-static	void
-MaxChild(TabsWidget tw)
-{
-	Dimension	cw,ch ;	/* child width, height */
-	int		i ;
-	Widget		*childP = tw->composite.children ;
-	TabsConstraints	tab ;
-	cw = ch = 0 ;
-	for(i=tw->composite.num_children; --i >=0; ++childP)
-	  if( XtIsManaged(*childP) )
-	  {
-	    tab = (TabsConstraints) (*childP)->core.constraints ;
-	    cw = Max(cw, tab->tabs.wid ) ;
-	    ch = Max(ch, tab->tabs.hgt ) ;
 	  }
 	tw->tabs.max_cw = cw ;
 	tw->tabs.max_ch = ch ;
 }
 	  }
 	}
 }
-	/* find preferred size.  Ask children, find size of largest,
+	/* Find preferred size.  Ask children, find size of largest,
 	 * add room for tabs & return.  This can get a little involved,
 	 * as we don't want to have too many rows of tabs; we may widen
 	 * the widget to reduce # of rows.
+	 *
+	 * This function requires that max_cw, max_ch already be set.
 	 */
 static	int
 PreferredSize(
 	TabsWidget	tw,
 	Dimension	cw,ch ;		/* child width, height */
 	Dimension	wid,hgt ;
 	Dimension	rwid,rhgt ;
 	int		nrow ;
-	/* find max desired child height */
-#ifdef	COMMENT
-	MaxChild(tw, &cw, &ch) ;
-#endif	/* COMMENT */
 	wid = cw = tw->tabs.max_cw ;
 	hgt = ch = tw->tabs.max_ch ;
 	nrow = PreferredSize2(tw, wid,hgt, &rwid, &rhgt) ;
 	 */
 	if( nrow > 2 && rhgt > rwid )
 	{
 	  Dimension w0, w1 ;
+	  int maxloop = 20 ;
 	  /* step 1: start doubling size until it's too big */
 	  do {
 	    w0 = wid ;
 	    wid = Max(wid*2, wid+20) ;
 	  w1 = wid ;
 	  /* step 2: use Newton's method to find ideal size.  Stop within
 	   * 8 pixels.
 	   */
-	  while( w1 > w0 + 8 )
+	  while( --maxloop > 0 && w1 > w0 + 8 )
 	  {
 	    wid = (w0+w1)/2 ;
 	    nrow = PreferredSize2(tw, wid,hgt, &rwid,&rhgt) ;
 	    if( nrow > 2 && rhgt > rwid )
 	      w0 = wid ;
 	int	x,y ;
 	unsigned int bw ;
 	if( tab->tabs.left_bitmap == None  ||
 	    !XGetGeometry(XtDisplay(tw), tab->tabs.left_bitmap, &root, &x, &y,
-	    	&tab->tabs.lbm_width, &tab->tabs.lbm_height,
+		&tab->tabs.lbm_width, &tab->tabs.lbm_height,
 		&bw, &tab->tabs.lbm_depth) )
 	  tab->tabs.lbm_width = tab->tabs.lbm_height = 0 ;
 }

Mercurial > hg > xemacs-beta

comparison lwlib/xlwtabs.c @ 434:9d177e8d4150 r21-2-25