frame.c

NIST Net – A Linux-based Network Emulation Tool, It is a raw IP packet filter with many controllable

	    break ;
	  case Trough:
	    Draw3dBox(w, 0,sy+0, sw,sh, 2, botGC, topGC) ;
	    Draw3dBox(w, s-2, sy+s-2, sw-s*2+4, sh-s*2+4, 2, topGC, botGC) ;
	    break ;
	}
}


	/* Called when any Frame widget resources are changed. */

/* ARGSUSED */
static	Boolean
FrameSetValues(current, request, new, args, num_args)
    Widget current, request, new;
    ArgList args;
    Cardinal *num_args;
{
	FrameWidget curfw = (FrameWidget) current ;
	FrameWidget fw = (FrameWidget) new ;
	Boolean	needRedraw = False ;

	if( fw->frame.title != curfw->frame.title ||
	    fw->frame.shadowWidth != curfw->frame.shadowWidth  ||
	    fw->frame.marginWidth != curfw->frame.marginWidth ||
	    fw->frame.marginHeight != curfw->frame.marginHeight )
	{
	  needRedraw = True ;
	  fw->frame.needs_layout = True ;
	}

	/* TODO: if any color changes, need to recompute GCs and redraw */

	if( fw->core.background_pixel != curfw->core.background_pixel ||
	    fw->core.background_pixmap != curfw->core.background_pixmap ||
	    fw->frame.foreground != curfw->frame.foreground  ||
	    fw->frame.be_nice_to_cmap != curfw->frame.be_nice_to_cmap  ||
	    fw->frame.top_shadow_contrast != curfw->frame.top_shadow_contrast ||
	    fw->frame.bot_shadow_contrast != curfw->frame.bot_shadow_contrast )
	{
	  FrameFreeGCs(fw) ;
	  FrameAllocGCs(fw) ;
	  needRedraw = True ;
	}

	else if( fw->core.sensitive != curfw->core.sensitive  ||
		 fw->frame.type != curfw->frame.type  ||
		 fw->frame.justify != curfw->frame.justify )
	  needRedraw = True ;

	return needRedraw ;
}




/*
 * Return preferred size.
 */

static XtGeometryResult
FrameQueryGeometry(w, intended, preferred)
	Widget		w;
	XtWidgetGeometry *intended, *preferred;
{
register FrameWidget fw = (FrameWidget)w ;
	Dimension	cw,ch ;		/* child width, height */
	Dimension	tw,th ;		/* title width, height */
	XtWidgetGeometry c_intended, c_preferred ;
	Widget		child = FrameChild(fw) ;
	Widget		ttl = fw->frame.title ;
	Dimension	sw = fw->frame.shadowWidth ;
	Dimension	mw = fw->frame.marginWidth ;
	Dimension	mh = fw->frame.marginHeight ;


	/* Take intended size; subtract shadow width, margin, child border
	 * size and forward the offer to the child.  Take child response,
	 * add border size, margin, shadow width and return that result
	 * to parent.
	 *
	 * Somewhat more complicated if there's a title widget.
	 */

	/* First, get title size.  */

	if( ttl != NULL && XtIsManaged(ttl) ) {
	  XtQueryGeometry(ttl, NULL, &c_preferred) ;
	  tw = c_preferred.width + 2*c_preferred.border_width + 
	  	2*max(mw, TTL_MARGIN) ;
	  th = c_preferred.height + 2*c_preferred.border_width ;
	}
	else
	  tw = th = 0 ;

	/* title height will be used in place of top shadow width */
	th = max(sw,th) ;

	if( child != NULL && XtIsManaged(child) ) {
	  if( intended != NULL ) {
	    c_intended = *intended ;
	    c_intended.request_mode &= CWWidth | CWHeight ;
	    c_intended.width -= 2*sw + 2*mw + 2*child->core.border_width ;
	    c_intended.width = max(c_intended.width,1) ;
	    c_intended.height -= th+sw + 2*mh + 2*child->core.border_width ;
	    c_intended.height = max(c_intended.height,1) ;
	  }
	  else
	    c_intended.request_mode = 0 ;

	  XtQueryGeometry(child, &c_intended, &c_preferred) ;
	  cw = c_preferred.width + 2*c_preferred.border_width + 2*sw + 2*mw ;
	  ch = c_preferred.height + 2*c_preferred.border_width ;
	  /* I dunno if this is the right semantics, but I prefer it! - Mark */
	  if (!fw->frame.allowResize) { /* don't allow initial request... */
	  	if (child->core.width) {
			cw = child->core.width + 2*child->core.border_width + 2*sw + 2*mw;
		}
		if (child->core.height) {
			ch = child->core.height + 2*child->core.border_width;
		}
	  }
	}
	else
	  cw = ch = MIN_SIZE ;

	preferred->request_mode = CWWidth | CWHeight ;
	preferred->width = max(cw,tw) /* + 2*sw BUGBUG - was adding sw twice! Mark */ ;
	preferred->height = th+sw + 2*mh + ch ;

	if( intended == NULL )
	  return XtGeometryYes ;

	if( intended->width == w->core.width  &&
	    intended->height == w->core.height )
	  return XtGeometryNo ;

	if( (!(intended->request_mode & CWWidth) ||
	      intended->width >= preferred->width)  &&
	    (!(intended->request_mode & CWHeight) ||
	      intended->height >= preferred->height) )
	  return XtGeometryYes;
	else
	  return XtGeometryAlmost;
}



/*
 * Geometry Manager; called when a child wants to be resized.
 */

static XtGeometryResult
FrameGeometryManager(w, req, reply)
    Widget		w;
    XtWidgetGeometry	*req;
    XtWidgetGeometry	*reply;	/* RETURN */

{
	FrameWidget		fw = (FrameWidget) XtParent(w);
	XtGeometryResult	result ;

	/* Position request always denied */
	if( !fw->frame.allowResize  ||
	    (req->request_mode & CWX) && req->x != w->core.x ||
	    (req->request_mode & CWY) && req->y != w->core.y )
	  return XtGeometryNo ;

	/* Make all three fields in the request valid */
	if( !(req->request_mode & CWWidth) )
	    req->width = w->core.width;
	if( !(req->request_mode & CWHeight) )
	    req->height = w->core.height;
	if( !(req->request_mode & CWBorderWidth) )
	    req->border_width = w->core.border_width;

	if( req->width == w->core.width &&
	    req->height == w->core.height &&
	    req->border_width == w->core.border_width )
	  return XtGeometryNo ;

	/* Size changes must see if the new size can be accomodated.
	 * A request to resize will be accepted only if the Frame can be
	 * resized to accomodate.
	 */

	if (req->request_mode & (CWWidth | CWHeight | CWBorderWidth))
	{
	  XtWidgetGeometry	myrequest, myreply ;
	  Dimension	cw,ch ;		/* child size, including borders */
	  Dimension	tw,th ;		/* title size, including borders */
	  Dimension	wid,hgt ;	/* Frame widget size */
	  Dimension	oldWid = fw->core.width, oldHgt = fw->core.height ;
	  Widget	child = FrameChild(fw) ;
	  Widget	ttl = fw->frame.title ;
	  Dimension	sw = fw->frame.shadowWidth ;
	  Dimension	mw = fw->frame.marginWidth ;
	  Dimension	mh = fw->frame.marginHeight ;
	  Dimension	margin = sw + req->border_width ;

	  if( w == child ) {
	    cw = req->width + req->border_width*2 ;
	    ch = req->height + req->border_width*2 ;
	  }
	  else if( child != NULL ) {
	    cw = child->core.width + child->core.border_width*2 ;
	    ch = child->core.height + child->core.border_width*2 ;
	  }
	  else
	    cw = ch = 0 ;

	  if( w == ttl ) {
	    tw = req->width + req->border_width*2 ;
	    th = req->height + req->border_width*2 ;
	  }
	  else if( ttl != NULL ) {
	    tw = ttl->core.width + ttl->core.border_width*2 ;
	    th = ttl->core.height + ttl->core.border_width*2 ;
	  }
	  else
	    tw = th = 0 ;

	  PreferredSize3(fw, cw,ch, tw,th, &wid, &hgt) ;

	  /* Ask to be resized to accomodate. */

	  myrequest.width = wid ;
	  myrequest.height = hgt ;
	  myrequest.request_mode = CWWidth | CWHeight ;

	  myrequest.request_mode |= req->request_mode & XtCWQueryOnly ;

	  result = XtMakeGeometryRequest((Widget)fw, &myrequest, &myreply) ;

	  /* !$@# 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.
	   */
	  if( myrequest.request_mode & XtCWQueryOnly ) {
	    fw->core.width = oldWid ;
	    fw->core.height = oldHgt ;
	  }

	  /* If parent offers a compromise, we do the same. */
	  if( result == XtGeometryAlmost ) {
	    reply->width  = myreply.width - (margin + mw) * 2 ;
	    reply->width  = min(reply->width, req->width) ;
	    reply->height = myreply.height- (margin+mh)*2;
	    reply->height = min(reply->height, req->height) ;
	    reply->border_width = req->border_width ;
	    if( reply->width < 1 || reply->height < 1 )
	      result = XtGeometryNo ;
	  }

	  else if( result == XtGeometryYes &&
		   !(req->request_mode & XtCWQueryOnly) )
	  {
	    w->core.width = req->width ;
	    w->core.height = req->height ;
	    w->core.border_width = req->border_width ;
	  }

	  return result ;
	}

	return XtGeometryNo ;
}




	/* The number of children we manage has changed; recompute
	 * size from scratch.
	 */

static	void
FrameChangeManaged(w)
    Widget w;
{
	FrameWidget		fw = (FrameWidget)w ;
	XtWidgetGeometry	request, reply ;

	request.request_mode = CWWidth | CWHeight ;
	PreferredSize(fw, &request.width, &request.height) ;
	(void) XtMakeGeometryRequest(w, &request, &reply) ;

	/* TODO: is this needed? */
	XtClass(w)->core_class.resize(w) ;
}







/****************************************************************
 *
 * Private Procedures
 *
 * TODO:  Somehow make these shared.
 *
 ****************************************************************/


static	void
FrameAllocGCs(fw)
	FrameWidget fw ;
{
	Widget	w = (Widget)fw ;

	fw->frame.foregroundGC =
		AllocFgGC(w, fw->frame.foreground, None ) ;
	fw->frame.topGC = AllocTopShadowGC(w, fw->frame.top_shadow_contrast,
		fw->frame.be_nice_to_cmap) ;
	fw->frame.botGC = AllocBotShadowGC(w, fw->frame.bot_shadow_contrast,
		fw->frame.be_nice_to_cmap) ;
}


static	void
FrameFreeGCs(fw)
	FrameWidget	fw ;
{
	Widget w = (Widget) fw;

	XtReleaseGC(w, fw->frame.foregroundGC) ;
	XtReleaseGC(w, fw->frame.topGC) ;
	XtReleaseGC(w, fw->frame.botGC) ;
}







	/* GEOMETRY UTILITIES */


	/* find preferred size.  Ask child, add room for frame & return.  */

static	void
PreferredSize(fw, reply_width, reply_height)
	FrameWidget	fw;
	Dimension	*reply_width, *reply_height;	/* total widget size */
{
	XtWidgetGeometry preferred ;

	(void) FrameQueryGeometry((Widget)fw, NULL, &preferred) ;
	*reply_width = preferred.width ;
	*reply_height = preferred.height ;
}


	/* Find preferred size, given child and title's preferred sizes. */

static	void
PreferredSize3(fw, cw,ch, tw,th, reply_width, reply_height)
	FrameWidget	fw;
	int		cw,ch ;		/* child width, height */
	int		tw,th ;		/* title width, height */
	Dimension	*reply_width, *reply_height;	/* total widget size */
{
	Dimension	sw = fw->frame.shadowWidth ;

	cw += 2*fw->frame.marginWidth ;
	tw += 2*max(fw->frame.marginWidth, TTL_MARGIN) ;

	*reply_width = max(cw,tw) + 2*sw ;
	*reply_height = max(sw,th) + ch + 2*fw->frame.marginHeight + sw ;
}


static	Widget
FrameChild(fw)
    FrameWidget	fw ;
{
    Widget	*childP = NULL ;
    Widget	ttl = fw->frame.title ;
    int		i ;

    if( (childP = fw->composite.children) != NULL )
      for(i=fw->composite.num_children; --i >= 0; ++childP )
	if( *childP != ttl )
	  return *childP ;

    return NULL ;
}






	/* RESOURCES */



/* ARGSUSED */
static	void
_CvtStringToShadowType(args, num_args, fromVal, toVal)
    XrmValuePtr args;		/* unused */
    Cardinal    *num_args;	/* unused */
    XrmValuePtr fromVal ;
    XrmValuePtr toVal ;
{
    String	str = (String)fromVal->addr ;
    int		i ;
    static XtShadowType	type;
    static struct {char *name; XtShadowType type;} types[] = {
      {"blank", Blank}, {"none", Blank}, {"solid", Solid},
      {"raised", Raised}, {"shadow_out", Raised},
      {"lowered", Lowered}, {"shadow_in", Lowered},
      {"ridge", Ridge}, {"shadow_etched_out", Ridge},
      {"groove", Groove}, {"shadow_etched_in", Groove},
      {"plateau", Plateau}, {"trough", Trough},
    } ;

    for(i=0; i<XtNumber(types); ++i)
    if( XmuCompareISOLatin1(str, types[i].name) == 0 ) {
      type = types[i].type ;
      break ;
    }

    if( i > XtNumber(types) ) {
      XtStringConversionWarning(fromVal->addr, XtRShadowType);
      toVal->size = 0 ;
      toVal->addr = NULL ;
      return ;
    }

    toVal->size = sizeof(type) ;
    toVal->addr = (XPointer) &type;
}