xemacs-beta: lwlib/xlwtabs.c comparison

comparison lwlib/xlwtabs.c @ 446:1ccc32a20af4 r21-2-38

Import from CVS: tag r21-2-38

author	cvs
date	Mon, 13 Aug 2007 11:37:21 +0200
parents	abe6d1db359e
children	3078fd1074e8

comparison

equal deleted inserted replaced

-:34f3776fcf0e
+:1ccc32a20af4
 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.27 */
+/* Synched up with: Tabs.c 1.27.
+#### This file contains essential XEmacs related fixes to the original
+verison of the Tabs widget. Be VERY careful about syncing if you ever
+update to a more recent version. In general this is probably now a
+bad idea. */
 /*
 * Tabs.c - Index Tabs composite widget
 *
 * Author: Edward A. Falk
 	<Key>KP_Up:		highlight(up)	\n\
 	<Key>Down:		highlight(down)	\n\
 	<Key>KP_Down:		highlight(down)	\n\
 	<Key> :			page(select)	\n\
 	 " ;
-static	XtAccelerators	defaultAccelerators ;
+static	XtAccelerators	defaultAccelerators ; /* #### Never used */
 #define	offset(field)	XtOffsetOf(TabsRec, tabs.field)
 static XtResource resources[] = {
 {XtNselectInsensitive, XtCSelectInsensitive, XtRBoolean, sizeof(Boolean),
 #endif
 #else
 #define	assert(e)
 #endif
+#define TabsNumChildren(tw) (((TabsWidget)tw)->composite.num_children)
+#define TabVisible(tab) \
+	(XtIsManaged(tab) && \
+	 ((TabsConstraints)((tab)->core.constraints))->tabs.visible)
 /****************************************************************
 *
 * Member Procedures
 TabsInit(Widget request, Widget new, ArgList args, Cardinal *num_args)
 {
 TabsWidget newTw = (TabsWidget)new;
 newTw->tabs.numRows = 0 ;
-newTw->tabs.displayChildren = 0;
+newTw->tabs.realRows = 0;
 GetPreferredSizes(newTw) ;
 /* height is easy, it's the same for all tabs:
 *  TODO: font height + height of tallest bitmap.
 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.visible = False ;
 	getBitmapInfo((TabsWidget)XtParent(new), tab) ;
 	TabWidth(new) ;
 }
 {
 	TabsWidget	tw = (TabsWidget) w;
 	int		i ;
 	int		num_children = tw->composite.num_children ;
 	Widget		*childP ;
-	TabsConstraints tab ;
+	TabsConstraints tab ; /* #### unused */
 	Dimension	cw,ch,bw ;
 	/* Our size has now been dictated by the parent.  Lay out the
 	 * tabs, lay out the frame, lay out the children.  Remember
 	 * that the tabs overlap each other and the frame by shadowWidth.
 	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;
+	  num_children = TabsNumChildren (tw);
 	  /* assign a top widget, bring it to bottom row. */
 	  TabsShuffleRows(tw) ;
 	  /* now assign child positions & sizes.  Positions are all the
 	  for(i=0, childP=tw->composite.children;
 		i < num_children;
 		++i, ++childP)
-	    if( XtIsManaged(*childP) )
+	    if( TabVisible(*childP) )
 	    {
 	      tab = (TabsConstraints) (*childP)->core.constraints ;
 	      bw = (*childP)->core.border_width ;
 	      XtConfigureWidget(*childP, SHADWID,tw->tabs.tab_total+SHADWID,
 			  cw-bw*2,ch-bw*2, bw) ;
 	    else
 	    {
 	      Widget	*childP = tw->composite.children ;
 	      int	i,bw ;
 	      w->core.border_width = req->border_width ;
-	      for(i=tw->tabs.displayChildren; --i >= 0; ++childP)
+	      for(i=TabsNumChildren (tw); --i >= 0; ++childP)
-		if( XtIsManaged(*childP) )
+		if( TabVisible(*childP) )
 		{
 		  bw = (*childP)->core.border_width ;
 		  XtConfigureWidget(*childP, s,tw->tabs.tab_total+s,
 			    rw-2*bw, rh-2*bw, bw) ;
 		}
 /* make sure the top widget stays on top.  This requires
 * making sure that all new children are realized first.
 */
 if( tw->tabs.topWidget != NULL && XtIsRealized(tw->tabs.topWidget) )
 {
-	for(i=tw->tabs.displayChildren; --i >= 0; ++childP)
+	for(i=TabsNumChildren (tw); --i >= 0; ++childP)
 	  if( !XtIsRealized(*childP) )
 	    XtRealizeWidget(*childP) ;
 	XRaiseWindow(dpy, XtWindow(tw->tabs.topWidget)) ;
 }
 	/* TODO: determine which tab was clicked, if any.  Set that
 	 * widget to be top of stacking order with XawTabsSetTop().
 	 */
 	for(i=0, childP=tw->composite.children;
-	      i < tw->tabs.displayChildren;
+	      i < TabsNumChildren (tw);
 	      ++i, ++childP)
-	  if( XtIsManaged(*childP) )
+	  if( TabVisible(*childP) )
 	  {
 	    TabsConstraints tab = (TabsConstraints)(*childP)->core.constraints;
 	    if( x > tab->tabs.x  &&  x < tab->tabs.x + tab->tabs.width  &&
 		y > tab->tabs.y  &&  y < tab->tabs.y + h )
 	    {
 {
 	TabsWidget	tw = (TabsWidget) w ;
 	Widget		newtop = NULL;
 	Widget		*childP ;
 	int		idx ;
-	int		nc = tw->tabs.displayChildren ;
+	int		nc = TabsNumChildren (tw) ;
 	if( nc <= 0 )
 	  return ;
 	if( *num_params < 1 ) {
 {
 	TabsWidget	tw = (TabsWidget) w ;
 	Widget		newhl = NULL;
 	Widget		*childP ;
 	int		idx ;
-	int		nc = tw->tabs.displayChildren ;
+	int		nc = TabsNumChildren (tw) ;
 	if( nc <= 0 )
 	  return ;
 	if( *num_params < 1 )
 	 */
 	y = tw->tabs.numRows == 1 ? TABDELTA : 0 ;
 	for(i=0; i<tw->tabs.numRows; ++i, y += th)
 	{
-	  for( j=tw->tabs.displayChildren, childP=tw->composite.children;
+	  for( j=TabsNumChildren (tw), childP=tw->composite.children;
 	      --j >= 0; ++childP )
-	    if( XtIsManaged(*childP) )
+	    if( TabVisible(*childP) )
 	    {
 	      tab = (TabsConstraints)(*childP)->core.constraints;
 	      if( tab->tabs.row == i && *childP != tw->tabs.topWidget )
 		DrawTab(tw, *childP, labels) ;
 	    }
 	 */
 static	int
 TabLayout(TabsWidget tw, int wid, int hgt, Dimension *reply_height, Bool query_only)
 {
-	int		i, row ;
+	int		i, row, done = 0, display_rows = 0 ;
 	int		num_children = tw->composite.num_children ;
 	Widget		*childP ;
 	Dimension	w ;
 	Position	x,y ;
 	TabsConstraints	tab ;
-	if (!query_only)
-	  tw->tabs.displayChildren = 0;
 	/* Algorithm: loop through children, assign X positions.  If a tab
 	 * would extend beyond the right edge, start a new row.  After all
 	 * rows are assigned, make a second pass and assign Y positions.
 	 */
 	  for(i=num_children, childP=tw->composite.children; --i >= 0; ++childP)
 	    if( XtIsManaged(*childP) )
 	    {
 	      tab = (TabsConstraints) (*childP)->core.constraints ;
 	      w = tab->tabs.width ;
 	      if( x + w > wid ) {			/* new row */
-		if (y + tw->tabs.tab_height > hgt)
+		if (y + tw->tabs.tab_height > hgt && !done)
-		  break;
+		  {
-		++row ;
+		    display_rows = row;
+		    done = 1;
+		  }
+		++row;
 		x = INDENT ;
 		y += tw->tabs.tab_height ;
 	      }
 	      if( !query_only ) {
 		tab->tabs.x = x ;
 		tab->tabs.y = y ;
 		tab->tabs.row = row ;
 	      }
 	      x += w + SPACING ;
-	      if (!query_only)
+	      if (!query_only && !done)
-		tw->tabs.displayChildren++;
+		tab->tabs.visible = 1;
 	    }
 	  /* If there was only one row, increase the height by TABDELTA */
-	  if( ++row == 1 )
+	  if( ++display_rows == 1 )
 	  {
+	    row++;
 	    y = TABDELTA ;
 	    if( !query_only )
 	      for(i=num_children, childP=tw->composite.children;
 		    --i >= 0 ; ++childP)
 		if( XtIsManaged(*childP) )
 		}
 	  }
 	  y += tw->tabs.tab_height ;
 	}
 	else
-	  row = y = 0 ;
+	  display_rows = row = y = 0 ;
 	if( !query_only ) {
 	  tw->tabs.tab_total = y ;
-	  tw->tabs.numRows = row ;
+	  tw->tabs.numRows = display_rows ;
+	  tw->tabs.realRows = row;
 	}
 	if( reply_height != NULL )
 	  *reply_height = y ;
-	return row ;
+	return display_rows ;
 }
 	/* Find max preferred child size.  Returned sizes include child
 static	void
 TabsShuffleRows(TabsWidget tw)
 {
 	TabsConstraints	tab ;
 	int		move ;
-	int		nrows ;
+	int		real_rows, display_rows ;
 	Widget		*childP ;
 	Dimension	th = tw->tabs.tab_height ;
 	Position	bottom ;
 	int		i ;
 	/* There must be a top widget.  If not, assign one. */
 	if( tw->tabs.topWidget == NULL && tw->composite.children != NULL )
-	  for(i=tw->composite.num_children, childP=tw->composite.children;
+	  for(i=TabsNumChildren (tw), childP=tw->composite.children;
 	      --i >= 0;
 	      ++childP)
 	    if( XtIsManaged(*childP) ) {
 	      tw->tabs.topWidget = *childP ;
 	      break ;
 	    }
 	if( tw->tabs.topWidget != NULL )
 	{
-	  nrows = tw->tabs.numRows ;
+	  display_rows = tw->tabs.numRows ;
-	  assert( nrows > 0 ) ;
+	  real_rows = tw->tabs.realRows ;
+	  assert( display_rows >= real_rows ) ;
-	  if( nrows > 1 )
+	  if( real_rows > 1 )
 	  {
 	    tab = (TabsConstraints) tw->tabs.topWidget->core.constraints ;
 	    assert( tab != NULL ) ;
-	    /* how far to move top row */
+	    /* How far to move top row. The selected tab must be on
-	    move = nrows - tab->tabs.row ;
+	       the bottom row of the *visible* rows. */
+	    move = (real_rows + 1 - display_rows) - tab->tabs.row ;
+	    if (move < 0)
+	      move = real_rows - move;
 	    bottom = tw->tabs.tab_total - th ;
-	    for(i=tw->tabs.displayChildren, childP=tw->composite.children;
+	    for(i=tw->composite.num_children, childP=tw->composite.children;
 		  --i >= 0;
 		  ++childP)
 	      if( XtIsManaged(*childP) )
 	      {
 		tab = (TabsConstraints) (*childP)->core.constraints ;
-		tab->tabs.row = (tab->tabs.row + move) % nrows ;
+		tab->tabs.row = (tab->tabs.row + move) % real_rows ;
 		tab->tabs.y = bottom - tab->tabs.row * th ;
+		tab->tabs.visible = (tab->tabs.row < display_rows);
 	      }
 	  }
 	}
 }
 	 * 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	*reply_width,		/* total widget size */
 	Dimension	*reply_height,

Mercurial > hg > xemacs-beta

comparison lwlib/xlwtabs.c @ 446:1ccc32a20af4 r21-2-38