Layout.c File Reference

#include <X11/IntrinsicP.h>
#include <X11/StringDefs.h>
#include <X11/Xmu/Misc.h>
#include <X11/Xmu/Converters.h>
#include <X11/Xaw3d/LayoutP.h>
#include <ctype.h>
#include <stdio.h>

Include dependency graph for Layout.c:

Go to the source code of this file.

Defines
#define	DBUG_ENTER(s)
#define	DBUG_VOID_RETURN   return
#define	DBUG_PRINT(f, s)
#define	DBUG_RETURN(f, v)   return(v)
#define	offset(field)   XtOffsetOf(LayoutRec, layout.field)
#define	SuperClass   ((ConstraintWidgetClass)&constraintClassRec)
#define	ForAllChildren(pw, childP)
#define	CheckGlue(l, box, glue, n)
#define	DoStretch(l, box, dir)   CheckGlue (l, box, box->params.stretch[dir], (double) box->natural[dir]);
#define	DoShrink(l, box, dir)   CheckGlue (l, box, box->params.shrink[dir], (double) box->natural[dir])
#define	GluePart(a, b, dist)
Functions
static void	ClassInitialize ()
static void	Initialize ()
static void	Resize ()
static Boolean	SetValues ()
static XtGeometryResult	GeometryManager ()
static void	ChangeManaged ()
static void	InsertChild ()
static XtGeometryResult	QueryGeometry ()
static void	GetDesiredSize ()
static void	LayoutLayout ()
static void	LayoutGetNaturalSize ()
static void	LayoutFreeLayout ()
void	LayYYsetsource ()
void	LayYYsetdest ()
int	LayYYparse ()
static Boolean	CvtStringToLayout (Display *dpy, XrmValue *args, Cardinal *num_args, XrmValue *from, XrmValue *to, XtPointer *converter_data)
static void	DisposeLayout (XtAppContext app, XrmValue *to, XtPointer data, XrmValuePtr args, Cardinal *num_args)
static XtGeometryResult	GeometryManager (Widget child, XtWidgetGeometry *request, XtWidgetGeometry *reply)
static void	Initialize (Widget request, Widget new, ArgList args, Cardinal *num_args)
static void	ChangeManaged (Widget gw)
static void	GetDesiredSize (Widget child)
static void	InsertChild (Widget child)
static void	Resize (Widget gw)
static Boolean	SetValues (Widget gold, Widget greq, Widget gnew, ArgList args, Cardinal *num_args)
static XtGeometryResult	QueryGeometry (Widget gw, XtWidgetGeometry *request, XtWidgetGeometry *prefered_return)
static void	PrintGlue (GlueRec g)
static void	PrintDirection (LayoutDirection dir)
static void	TabTo (int level)
static void	PrintBox (BoxPtr box, int level)
static ExprPtr	LookupVariable (BoxPtr child, XrmQuark quark)
static double	Evaluate (LayoutWidget l, BoxPtr box, ExprPtr expr, double natural)
static void	DisposeExpr (ExprPtr expr)
static void	ComputeNaturalSizes (LayoutWidget l, BoxPtr box, LayoutDirection dir)
static Bool	ComputeSizes (BoxPtr box)
static void	SetSizes (BoxPtr box, Position x, Position y)
static void	LayoutFreeLayout (BoxPtr box)
static void	LayoutGetNaturalSize (LayoutWidget l, Dimension *widthp, Dimension *heightp)
static void	LayoutLayout (LayoutWidget l, Bool attemptResize)
Variables
static XtResource	resources []
LayoutClassRec	layoutClassRec
WidgetClass	layoutWidgetClass = (WidgetClass) &layoutClassRec

---

Define Documentation

#define CheckGlue	(	l,
		box,
		glue,
		n		)

Value:

{ \
    if (glue.expr) \
        glue.value = Evaluate (l, box, glue.expr, n); \
    if (glue.order == 0 && glue.value == 0) \
        glue.order = -1; \
    else if (glue.order == -1 && glue.value != 0) \
        glue.order = 0; \
}

Definition at line 634 of file Layout.c.

#define DBUG_ENTER

(

s

)

Definition at line 63 of file Layout.c.

Referenced by ChangeManaged(), ComputeNaturalSizes(), LayoutGetNaturalSize(), LayoutLayout(), and LookupVariable().

#define DBUG_PRINT	(	f,
		s		)

Definition at line 65 of file Layout.c.

Referenced by ComputeNaturalSizes(), Evaluate(), and LookupVariable().

#define DBUG_RETURN	(	f,
		v		)	return(v)

Definition at line 66 of file Layout.c.

Referenced by LookupVariable().

#define DBUG_VOID_RETURN   return

Definition at line 64 of file Layout.c.

Referenced by ChangeManaged(), ComputeNaturalSizes(), LayoutGetNaturalSize(), and LayoutLayout().

#define DoShrink	(	l,
		box,
		dir		)	CheckGlue (l, box, box->params.shrink[dir], (double) box->natural[dir])

Definition at line 646 of file Layout.c.

Referenced by ComputeNaturalSizes().

#define DoStretch	(	l,
		box,
		dir		)	CheckGlue (l, box, box->params.stretch[dir], (double) box->natural[dir]);

Definition at line 643 of file Layout.c.

Referenced by ComputeNaturalSizes().

#define ForAllChildren	(	pw,
		childP		)

Value:

for ( (childP) = (pw)->composite.children ; \
        (childP) < (pw)->composite.children + (pw)->composite.num_children ; \
        (childP)++ ) if (!XtIsManaged(*childP)) ; else

Definition at line 190 of file Layout.c.

Referenced by ChangeManaged(), GetEventEntry(), GetMenuHeight(), GetMenuWidth(), Layout(), ManageAndUnmanageGrips(), Redisplay(), Resize(), and ResortChildren().

#define GluePart	(	a,
		b,
		dist		)

Value:

((a) ? ((int) (((a) * (dist)) / (b) + \
                                        ((dist >= 0) ? 0.5 : -0.5))) : 0)

Definition at line 780 of file Layout.c.

Referenced by ComputeSizes().

#define offset

(

field

)

XtOffsetOf(LayoutRec, layout.field)

Definition at line 75 of file Layout.c.

#define SuperClass   ((ConstraintWidgetClass)&constraintClassRec)

Definition at line 108 of file Layout.c.

---

Function Documentation

static void ChangeManaged

(

Widget

gw

)

[static]

Definition at line 310 of file Layout.c.

References DBUG_ENTER, DBUG_VOID_RETURN, ForAllChildren, GetDesiredSize(), LayoutLayout(), TRUE, and w.

{
    LayoutWidget        w = (LayoutWidget) gw;
    Widget              *children;

    DBUG_ENTER("changeManaged");

    ForAllChildren (w, children)
        GetDesiredSize (*children);
    LayoutLayout ((LayoutWidget) w, TRUE);
#ifdef MOTIF
    _XmNavigChangeManaged ( gw );        
#endif
    DBUG_VOID_RETURN;
}

Here is the call graph for this function:

static void ChangeManaged

(

)

[static]

static void ClassInitialize

(

)

[static]

Definition at line 238 of file Layout.c.

References CvtStringToLayout(), DisposeLayout(), and XtRLayout.

{
    XtSetTypeConverter ( XtRString, XtRLayout, CvtStringToLayout,
                    (XtConvertArgList)NULL, (Cardinal)0, XtCacheNone, 
                    DisposeLayout );
}

Here is the call graph for this function:

static void ComputeNaturalSizes	(	LayoutWidget	l,
		BoxPtr	box,
		LayoutDirection	dir
	)			[static]

Definition at line 651 of file Layout.c.

References AddGlue, _Box::box, BoxBox, DBUG_ENTER, DBUG_PRINT, DBUG_VOID_RETURN, DoShrink, DoStretch, Evaluate(), _Box::glue, GlueBox, info, LayoutHorizontal, LayoutVertical, MinGlue, _Box::natural, _Box::nextSibling, _Glue::order, _Box::params, QuarkToWidget, _BoxParams::shrink, _BoxParams::stretch, SubInfo, _Box::type, _Box::u, _Glue::value, VariableBox, w, _Box::widget, WidgetBox, and ZeroGlue.

Referenced by LayoutGetNaturalSize().

{
    BoxPtr      child;
    Widget      w;
    SubInfoPtr  info;
    int         minStretchOrder, minShrinkOrder;
    LayoutDirection thisDir;

    DBUG_ENTER("ComputeNaturalSizes");
    DBUG_PRINT("box->type=%d",box->type);
    switch (box->type) {
    case WidgetBox:
        w = box->u.widget.widget = QuarkToWidget (l, box->u.widget.quark);
        if (!w)
        {
            box->natural[LayoutHorizontal] = 0;
            box->natural[LayoutVertical] = 0;
        }
        else 
        {
            info = SubInfo (w);
            box->natural[LayoutHorizontal] = info->naturalSize[LayoutHorizontal];
            box->natural[LayoutVertical] = info->naturalSize[LayoutVertical];
        }
        DoStretch (l, box, dir);
        DoShrink (l, box, dir);
        DoStretch (l, box, !dir);
        DoShrink (l, box, !dir);
        break;
    case GlueBox:
        box->natural[dir] = Evaluate (l, box, box->u.glue.expr, 0.0);
        box->natural[!dir] = 0;
        DoStretch (l, box, dir);
        DoShrink (l, box, dir);
        break;
    case BoxBox:
        thisDir = box->u.box.dir;
        box->natural[0] = 0;
        box->natural[1] = 0;
        minStretchOrder = 100000;
        minShrinkOrder = 100000;
        ZeroGlue (box->params.shrink[thisDir]);
        ZeroGlue (box->params.stretch[thisDir]);
        box->params.shrink[!thisDir].order = 100000;
        box->params.stretch[!thisDir].order = 100000;
        for (child = box->u.box.firstChild; child; child = child->nextSibling) 
        {
            ComputeNaturalSizes (l, child, thisDir);
            /*
             * along box axis:
             *  normal size += child normal size
             *  shrink += child shrink
             *  stretch += child stretch
             */
            box->natural[thisDir] += child->natural[thisDir];
            AddGlue (box->params.shrink[thisDir],
                     box->params.shrink[thisDir],
                     child->params.shrink[thisDir]);
            AddGlue (box->params.stretch[thisDir],
                     box->params.stretch[thisDir],
                     child->params.stretch[thisDir]);
            /*
             * normal to box axis:
             *  normal size = maximum child normal size of minimum shrink order
             *  shrink = difference between normal size and minimum shrink
             *  stretch = minimum child stretch
             */
            if (box->natural[!thisDir] >= child->natural[!thisDir])
            {
                if (child->params.stretch[!thisDir].order < minShrinkOrder)
                {
                    box->natural[!thisDir] = child->natural[!thisDir];
                    minStretchOrder = child->params.stretch[!thisDir].order;
                    if (child->params.shrink[!thisDir].order < minShrinkOrder)
                        minShrinkOrder = child->params.shrink[!thisDir].order;
                }
            }
            else
            {
                if (child->params.shrink[!thisDir].order <= minStretchOrder)
                {
                    box->natural[!thisDir] = child->natural[!thisDir];
                    minShrinkOrder = child->params.shrink[!thisDir].order;
                    if (child->params.stretch[!thisDir].order < minStretchOrder)
                        minStretchOrder = child->params.stretch[!thisDir].order;
                }
            }
            MinGlue (box->params.stretch[!thisDir],
                     box->params.stretch[!thisDir],
                     child->params.stretch[!thisDir]);
            MinGlue (box->params.shrink[!thisDir],
                     box->params.shrink[!thisDir],
                     child->params.shrink[!thisDir]);
        }
        if (box->params.shrink[!thisDir].order <= 0)
        {
            int     minSize;
            int     largestMinSize;
            
            largestMinSize = 0;
            for (child = box->u.box.firstChild; child; child = child->nextSibling) 
            {
                if (child->params.shrink[!thisDir].order <= 0)
                {
                    minSize = child->natural[!thisDir] -
                              child->params.shrink[!thisDir].value;
                    if (minSize > largestMinSize)
                        largestMinSize = minSize;
                }
            }
            box->params.shrink[!thisDir].value = box->natural[!thisDir] -
                                                 largestMinSize;
            if (box->params.shrink[!thisDir].value == 0)
                box->params.shrink[!thisDir].order = -1;
            else
                box->params.shrink[!thisDir].order = 0;
        }
        break;
    case VariableBox:
        break;
    }
    DBUG_VOID_RETURN;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static Bool ComputeSizes

(

BoxPtr

box

)

[static]

Definition at line 784 of file Layout.c.

References _Box::box, BoxBox, dir, GluePart, i, _Box::natural, _Box::nextSibling, _Glue::order, _Box::params, _BoxParams::shrink, _Box::size, size, _BoxParams::stretch, _Box::type, _Box::u, value, _Glue::value, and VariableBox.

Referenced by LayoutLayout().

{
    LayoutDirection dir;
    BoxPtr          child;
    GlueRec         stretch;
    GlueRec         shrink;
    GlueRec         totalGlue[2];
    double          remainingGlue;
    GluePtr         glue;
    int             size;
    int             totalSizes;
    int             totalChange[2];
    int             change;
    int             remainingChange;
    Bool            shrinking;
    Bool            happy;
    int             i;
    int             maxGlue;

    dir = box->u.box.dir;
    size = box->size[dir];
    
    stretch = box->params.stretch[dir];
    shrink = box->params.shrink[dir];
    
    /* pick the correct adjustment parameters based on the change direction */

    totalChange[0] = size - box->natural[dir];

    shrinking = totalChange[0] < 0;
    
    totalChange[1] = 0;
    totalGlue[1].order = 100000;
    totalGlue[1].value = 0;
    maxGlue = 1;
    if (shrinking) 
    {
        totalGlue[0] = shrink;
        /* for first-order infinites, shrink it to zero and then
         * shrink the zero-orders
         */
        if (shrink.order == 1) {
            totalSizes = 0;
            remainingGlue = 0;
            for (child = box->u.box.firstChild; 
                 child; 
                 child = child->nextSibling) 
            {
                switch (child->params.shrink[dir].order) {
                case 0:
                    remainingGlue += child->params.shrink[dir].value;
                    break;
                case 1:
                    totalSizes += child->natural[dir];
                    break;
                }
            }
            if (totalSizes < -totalChange[0])
            {
                totalGlue[1] = shrink;
                totalGlue[0].order = 0;
                totalGlue[0].value = remainingGlue;
                totalChange[1] = -totalSizes;
                totalChange[0] = totalChange[0] - totalChange[1];
                maxGlue = 2;
            }
        }
        if (totalGlue[0].order <= 0 && 
            totalChange[0] > totalGlue[0].value)
        {
            totalChange[0] = totalGlue[0].value;
        }
    }
    else
        totalGlue[0] = stretch;

    /* adjust each box */
    totalSizes = 0;
    remainingGlue = totalGlue[0].value + totalGlue[1].value;
    remainingChange = totalChange[0] + totalChange[1];
    happy = True;
    for (child = box->u.box.firstChild; child; child = child->nextSibling) 
    {
        /* never add glue or stretch to a VariableBox! */
        if (child->type == VariableBox) continue;

        if (shrinking)
            glue = &child->params.shrink[dir];
        else
            glue = &child->params.stretch[dir];
    
        child->size[dir] = child->natural[dir];
        for (i = 0; i < maxGlue; i++)
        {
            if (glue->order == totalGlue[i].order)
            {
                remainingGlue -= glue->value;
                if (remainingGlue <= 0)
                    change = remainingChange;
                else
                    change = GluePart (glue->value, 
                                       totalGlue[i].value, 
                                       totalChange[i]);
                child->size[dir] += change;
                remainingChange -= change;
            }
        }
        child->size[!dir] = box->size[!dir];
        totalSizes += child->size[dir];
        if (child->type == BoxBox)
            if (!ComputeSizes (child))
                happy = False;
    }
    return totalSizes == box->size[dir] && happy;
}

Here is the caller graph for this function:

static Boolean CvtStringToLayout	(	Display *	dpy,
		XrmValue *	args,
		Cardinal *	num_args,
		XrmValue *	from,
		XrmValue *	to,
		XtPointer *	converter_data
	)			[static]

Definition at line 209 of file Layout.c.

References FALSE, LayYYparse(), LayYYsetdest(), LayYYsetsource(), and TRUE.

Referenced by ClassInitialize().

{
    static BoxPtr tmp;
    
    LayYYsetsource ((char *) from->addr);
    if (!to->addr) to->addr = (XtPointer)&tmp;
    LayYYsetdest ((BoxPtr *) to->addr);
    to->size = sizeof (BoxPtr *);
    return  LayYYparse() ? FALSE : TRUE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void DisposeExpr

(

ExprPtr

expr

)

[static]

Definition at line 611 of file Layout.c.

References Binary, Dispose, Height, Unary, Variable, and Width.

Referenced by LayoutFreeLayout().

{
    if (!expr)
        return;
    switch (expr->type) {
    case Constant:
        break;
    case Binary:
        DisposeExpr (expr->u.binary.left);
        DisposeExpr (expr->u.binary.right);
        break;
    case Unary:
        DisposeExpr (expr->u.unary.down);
        break;
    case Width:
    case Height:
    case Variable:
        break;
    }
    Dispose (expr);
}

Here is the caller graph for this function:

static void DisposeLayout	(	XtAppContext	app,
		XrmValue *	to,
		XtPointer	data,
		XrmValuePtr	args,
		Cardinal *	num_args
	)			[static]

Definition at line 227 of file Layout.c.

References LayoutFreeLayout().

Referenced by ClassInitialize().

{
    LayoutFreeLayout (* (LayoutPtr *) to->addr);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static double Evaluate	(	LayoutWidget	l,
		BoxPtr	box,
		ExprPtr	expr,
		double	natural
	)			[static]

Definition at line 534 of file Layout.c.

References Binary, buf, DBUG_PRINT, Divide, expr(), Height, info, LayoutHorizontal, LayoutVertical, left, LookupVariable(), Minus, Percent, Plus, QuarkToWidget, right, SubInfo, Times, Unary, Variable, void(), and Width.

Referenced by ComputeNaturalSizes().

{
    double      left, right, down;
    Widget      widget;
    SubInfoPtr  info;

    DBUG_PRINT("Evaluate %d", expr->type);
    switch (expr->type) {
    case Constant:
        return expr->u.constant;
    case Binary:
        left = Evaluate (l, box, expr->u.binary.left, natural);
        right = Evaluate (l, box, expr->u.binary.right, natural);
        switch (expr->u.binary.op) {
        case Plus:
            return left + right;
        case Minus:
            return left - right;
        case Times:
            return left * right;
        case Divide:
            return left / right;
        case Percent:
            return right * left / 100.0;
        }
    case Unary:
        down = Evaluate (l, box, expr->u.unary.down, natural);
        switch (expr->u.unary.op) {
        case Percent:
            return natural * down / 100.0;
        case Minus:
            return -down;
        case Plus:
        case Times:
        case Divide:
            break;
        }
    case Width:
        widget = QuarkToWidget (l, expr->u.width);
        if (!widget)
            return 0;
        info = SubInfo (widget);
        return info->naturalSize[LayoutHorizontal];
    case Height:
        widget = QuarkToWidget (l, expr->u.height);
        if (!widget)
            return 0;
        info = SubInfo (widget);
        return info->naturalSize[LayoutVertical];
    case Variable: 
        {
        /* in the original code there was no nexpr, 
           expr was overwritten by LookupVariable and 
           the expression "expr->u.variable" to obtain the
           variable name for the errormessage cause a segmentation
           violation */
        ExprPtr    nexpr;
        nexpr = LookupVariable (box, expr->u.variable);
        if (!nexpr)
            {
            char    buf[256];
            (void) sprintf (buf, "Layout: undefined variable %s\n",
                            XrmQuarkToString (expr->u.variable));
            XtError (buf);
            return 0.0;
            }
        return Evaluate (l, box, nexpr, natural);
        }
    }
    return 0.0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static XtGeometryResult GeometryManager	(	Widget	child,
		XtWidgetGeometry *	request,
		XtWidgetGeometry *	reply
	)			[static]

Definition at line 264 of file Layout.c.

References FALSE, LayoutHorizontal, LayoutLayout(), LayoutVertical, p, SubInfo, TRUE, and w.

{
    LayoutWidget    w = (LayoutWidget) XtParent(child);
    SubInfoPtr      p = SubInfo(child);
    int             bw;
    Bool            changed, bwChanged;

    bw = p->naturalBw;
    changed = FALSE;
    bwChanged = FALSE;
    if (request->request_mode & CWBorderWidth &&
        request->border_width != child->core.border_width) 
    {
        p->naturalBw = bw;
        bw = request->border_width;
        changed = TRUE;
        bwChanged = TRUE;
    }
    if (bwChanged || ((request->request_mode & CWWidth) &&
        request->width != child->core.width))
    {
        p->naturalSize[LayoutHorizontal] = request->width + bw * 2;
        changed = TRUE;
    }
    if (bwChanged || ((request->request_mode & CWHeight) &&
        request->height != child->core.height))
    {
        p->naturalSize[LayoutVertical] = request->height + bw * 2;
        changed = TRUE;
    }
    if (changed)
        LayoutLayout (w, TRUE);
    return XtGeometryDone;
}

Here is the call graph for this function:

static XtGeometryResult GeometryManager

(

)

[static]

static void GetDesiredSize

(

Widget

child

)

[static]

Definition at line 328 of file Layout.c.

References LayoutHorizontal, LayoutVertical, p, and SubInfo.

{
    XtWidgetGeometry    desired;
    SubInfoPtr          p;
    
    XtQueryGeometry (child, (XtWidgetGeometry *) NULL, &desired);
    p = SubInfo (child);
    p->naturalBw = desired.border_width;
    p->naturalSize[LayoutHorizontal] = desired.width + desired.border_width * 2;
    p->naturalSize[LayoutVertical] = desired.height + desired.border_width * 2;
}

static void GetDesiredSize

(

)

[static]

Referenced by ChangeManaged(), and InsertChild().

Here is the caller graph for this function:

static void Initialize	(	Widget	request,
		Widget	new,
		ArgList	args,
		Cardinal *	num_args
	)			[static]

Definition at line 302 of file Layout.c.

{
/*    LayoutWidget w = (LayoutWidget)new; */
}

static void Initialize

(

)

Definition at line 26 of file javasci_globals.c.

{
  static char env[1024];
  static char initstr[]="exec(\"SCI/etc/scilab.start\",-1);quit;";
  static int iflag=-1, stacksize = 1000000, ierr=0;

  #ifdef _MSC_VER
    static char JavaSciInterf[]="javasci";
    static char nw[]="-nw";
    static char nb[]="-nb";
  #endif

  
  char *p1 = (char*)getenv ("SCI");
  
  
  #ifdef _MSC_VER
  /* Supprime le mode windows et la baniere */
    add_sci_argv(JavaSciInterf);
    add_sci_argv(nb);
  #endif
  
  #ifdef _MSC_VER 
    if ( p1== NULL )
    {
                /* Detection Scilab path */
                char modname[MAX_PATH+1];
                if (!GetModuleFileName (GetModuleHandle("javasci.dll"), modname, MAX_PATH))
                {
                        MessageBox(NULL,"javasci.dll not found","Warning",MB_ICONWARNING);
                }
                else
                {
                        char *p;
                        if ((p = strrchr (modname, '\\')) == NULL) exit(1); /* remove \javasci.dll from modname */
                        else
                        {
                                *p='\0';
                                if ((p = strrchr (modname, '\\')) == NULL) exit(1); /* remove \bin from modname */
                                else
                                {
                                        *p='\0';
                                        set_sci_env(modname);
                                }
                        }
                }
    }
    else 
        {
                char *pathSCI=(char*)MALLOC((strlen(p1)+1)*sizeof(char));
                sprintf(pathSCI,"%s",p1);
                set_sci_env(pathSCI);
                if (pathSCI) {FREE(pathSCI);pathSCI=NULL;}
        }
  #else
   if (p1==NULL)
   {
        fprintf(stderr,"Please define SCI environment variable\n");
        sprintf (env, "%s=%s", "SCI",SCI);
        setSCIpath(SCI);
        putenv (env);
   }
  #endif
  /* set TMPDIR */
  C2F(settmpdir)();
  /* Scilab Initialization */
  C2F(inisci)(&iflag,&stacksize,&ierr);
  if ( ierr > 0 ) 
    {
      fprintf(stderr,"Scilab initialization failed !\n");
      exit(1);
    }


  /* Initialisation fenetre graphique */
  #ifdef _MSC_VER
    InitWindowGraphDll();
  #endif

  /* pour initialisation de la primitive scilab : fromjava() */
  SetFromJavaToON();

  /* Chargement de Scilab.start */
  C2F(scirun)(initstr,(int)strlen(initstr));
 
}

static void InsertChild

(

Widget

child

)

[static]

Definition at line 341 of file Layout.c.

References GetDesiredSize(), and SuperClass.

{
    (*SuperClass->composite_class.insert_child) (child);
    GetDesiredSize (child);
}

Here is the call graph for this function:

static void InsertChild

(

)

[static]

static void LayoutFreeLayout

(

BoxPtr

box

)

[static]

Definition at line 955 of file Layout.c.

References _Box::box, BoxBox, Dispose, DisposeExpr(), GlueBox, LayoutFreeLayout(), LayoutHorizontal, LayoutVertical, _Box::nextSibling, _Box::u, VariableBox, and WidgetBox.

{
    BoxPtr  child, next;
    
    switch (box->type) {
    case BoxBox:
        for (child = box->u.box.firstChild; child; child = next)
        {
            next = child->nextSibling;
            LayoutFreeLayout (child);
        }
        break;
    case GlueBox:
        DisposeExpr (box->u.glue.expr);
        break;
    case WidgetBox:
    case VariableBox:
    default: 
        break;
    }
    DisposeExpr (box->params.stretch[LayoutHorizontal].expr);
    DisposeExpr (box->params.shrink[LayoutHorizontal].expr);
    DisposeExpr (box->params.stretch[LayoutVertical].expr);
    DisposeExpr (box->params.shrink[LayoutVertical].expr);
    Dispose (box);
}

Here is the call graph for this function:

static void LayoutFreeLayout

(

)

[static]

Referenced by DisposeLayout(), and LayoutFreeLayout().

Here is the caller graph for this function:

static void LayoutGetNaturalSize	(	LayoutWidget	l,
		Dimension *	widthp,
		Dimension *	heightp
	)			[static]

Definition at line 985 of file Layout.c.

References ComputeNaturalSizes(), DBUG_ENTER, DBUG_VOID_RETURN, LayoutHorizontal, LayoutVertical, and _Box::natural.

{
    BoxPtr              box;

    DBUG_ENTER("LayoutGetNaturalSize");
    box = l->layout.layout;
    if (box) 
    {
        ComputeNaturalSizes (l, box, LayoutHorizontal);
        *widthp = box->natural[LayoutHorizontal];
        *heightp = box->natural[LayoutVertical];
    }
    else
    {
        *widthp = 0;
        *heightp = 0;
    }
    DBUG_VOID_RETURN;
}

Here is the call graph for this function:

static void LayoutGetNaturalSize

(

)

[static]

Referenced by LayoutLayout(), and QueryGeometry().

Here is the caller graph for this function:

static void LayoutLayout	(	LayoutWidget	l,
		Bool	attemptResize
	)			[static]

Definition at line 1008 of file Layout.c.

References ComputeSizes(), DBUG_ENTER, DBUG_VOID_RETURN, height, LayoutGetNaturalSize(), LayoutHorizontal, LayoutVertical, PrintBox(), SetSizes(), _Box::size, and width.

{
    BoxPtr              box;
    Dimension           width, height;
    Dimension           prefered_width, prefered_height;

    DBUG_ENTER("LayoutLayout");
    box = l->layout.layout;
    if (!box)
        return;
    LayoutGetNaturalSize (l, &prefered_width, &prefered_height);
    if (l->core.width == 0 || l->core.height == 0)
    {
        l->core.width = prefered_width;
        l->core.height = prefered_height;
    }
    box->size[LayoutHorizontal] = l->core.width;
    box->size[LayoutVertical] = l->core.height;
    if (!ComputeSizes (box) && attemptResize)
    {
        XtMakeResizeRequest ((Widget) l,
                            prefered_width, prefered_height,
                            &width, &height);
        if (width != box->size[LayoutHorizontal] ||
            height != box->size[LayoutVertical])
        {
            box->size[LayoutHorizontal] = width;
            box->size[LayoutVertical] = height;
            ComputeSizes (box);
        }
    }
    if (l->layout.debug)
    {
        PrintBox (box, 0);
        fflush (stdout);
    }
    SetSizes (box, 0, 0);
    DBUG_VOID_RETURN;
}

Here is the call graph for this function:

static void LayoutLayout

(

)

[static]

Referenced by ChangeManaged(), GeometryManager(), Resize(), and SetValues().

Here is the caller graph for this function:

int LayYYparse

(

)

Referenced by CvtStringToLayout().

Here is the caller graph for this function:

void LayYYsetdest

(

)

Referenced by CvtStringToLayout().

Here is the caller graph for this function:

void LayYYsetsource

(

)

Referenced by CvtStringToLayout().

Here is the caller graph for this function:

static ExprPtr LookupVariable	(	BoxPtr	child,
		XrmQuark	quark
	)			[static]

Definition at line 510 of file Layout.c.

References _Box::box, DBUG_ENTER, DBUG_PRINT, DBUG_RETURN, _Box::nextSibling, _Box::parent, _Box::type, _Box::u, _Box::variable, and VariableBox.

Referenced by Evaluate().

{
    BoxPtr      parent, box;

    DBUG_ENTER("LookupVariable");
    DBUG_PRINT("name = <%s>",XrmQuarkToString(quark));
    DBUG_PRINT("child = %p",child);
    while ((parent = child->parent))
    {
        for (box = parent->u.box.firstChild; 
             box != child; 
             box = box->nextSibling)
        {
            if (box->type == VariableBox && box->u.variable.quark == quark)
                DBUG_RETURN("%p", box->u.variable.expr);
        }
        child = parent;
    }
    DBUG_RETURN("failure -> %d",0);
}

Here is the caller graph for this function:

static void PrintBox	(	BoxPtr	box,
		int	level
	)			[static]

Definition at line 470 of file Layout.c.

References _Box::box, BoxBox, GlueBox, LayoutHorizontal, LayoutVertical, _Box::nextSibling, PrintDirection(), PrintGlue(), TabTo(), _Box::u, VariableBox, void(), and WidgetBox.

Referenced by LayoutLayout().

{
    BoxPtr      child;
    
    TabTo (level);
    (void) printf ("%s", "< ");
    (void) printf ("%s", " + "); 
    PrintGlue (box->params.stretch[LayoutHorizontal]);
    (void) printf ("%s", " - "); 
    PrintGlue (box->params.shrink[LayoutHorizontal]);
    (void) printf ("%s", " * ");
    (void) printf ("%s", " + "); 
    PrintGlue (box->params.stretch[LayoutVertical]);
    (void) printf ("%s", " - "); 
    PrintGlue (box->params.shrink[LayoutVertical]);
    (void) printf ("%s", " >");
    (void) printf (" size: %d x %d", box->size[0], box->size[1]);
    (void) printf (" natural: %d x %d ", box->natural[0], box->natural[1]);
    switch (box->type) {
    case BoxBox:
        PrintDirection (box->u.box.dir);
        (void) printf ("%s\n", "");
        for (child = box->u.box.firstChild; child; child = child->nextSibling)
            PrintBox (child, level+1);
        break;
    case WidgetBox:
        (void) printf (" %s\n", XrmQuarkToString (box->u.widget.quark));
        break;
    case GlueBox:
        (void) printf ("%s\n", " glue");
        break;
    case VariableBox:
        (void) printf (" variable %s\n", XrmQuarkToString (box->u.variable.quark));
        break;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void PrintDirection

(

LayoutDirection

dir

)

[static]

Definition at line 444 of file Layout.c.

References LayoutHorizontal, LayoutVertical, and void().

Referenced by PrintBox().

{
    switch (dir) {
    case LayoutHorizontal:
        (void) printf ("%s", "horizontal");
        break;
    case LayoutVertical:
        (void) printf ("%s", "vertical");
        break;
    default:
        (void) printf ("Unknown layout direction %d\n", dir);
        break;
  
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void PrintGlue

(

GlueRec

g

)

[static]

Definition at line 430 of file Layout.c.

References void().

Referenced by PrintBox().

{
    if (g.order == 0 || g.value != 1.0)
        (void) printf ("%g", g.value);
    if (g.order > 0)
    {
        (void) printf ("%s", " inf");
        if (g.order > 1)
            (void) printf (" %d", g.order);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static XtGeometryResult QueryGeometry	(	Widget	gw,
		XtWidgetGeometry *	request,
		XtWidgetGeometry *	prefered_return
	)			[static]

Definition at line 371 of file Layout.c.

References LayoutGetNaturalSize(), result, and w.

{
    LayoutWidget        w = (LayoutWidget) gw;
    XtGeometryResult    result;
    XtWidgetGeometry    prefered_size;

    if (request && !(request->request_mode & (CWWidth|CWHeight)))
        return XtGeometryYes;
    LayoutGetNaturalSize (w, &prefered_size.width, &prefered_size.height);
    prefered_return->request_mode = 0;
    result = XtGeometryYes;
    if (!request) {
        prefered_return->width = prefered_size.width;
        prefered_return->height= prefered_size.height;
        if (prefered_size.width != w->core.width) {
            prefered_return->request_mode |= CWWidth;
            result = XtGeometryAlmost;
        }
        if (prefered_size.height != w->core.height) {
            prefered_return->request_mode |= CWHeight;
            result = XtGeometryAlmost;
        }
    } else {
        if (request->request_mode & CWWidth) {
            if (prefered_size.width > request->width)
            {
                if (prefered_size.width == w->core.width)
                    result = XtGeometryNo;
                else if (result != XtGeometryNo) {
                    result = XtGeometryAlmost;
                    prefered_return->request_mode |= CWWidth;
                    prefered_return->width = prefered_size.width;
                }
            }
        }
        if (request->request_mode & CWHeight) {
            if (prefered_size.height > request->height)
            {
                if (prefered_size.height == w->core.height)
                    result = XtGeometryNo;
                else if (result != XtGeometryNo) {
                    result = XtGeometryAlmost;
                    prefered_return->request_mode |= CWHeight;
                    prefered_return->height = prefered_size.height;
                }
            }
        }
    }
    return result;
}

Here is the call graph for this function:

static XtGeometryResult QueryGeometry

(

)

[static]

static void Resize

(

Widget

gw

)

[static]

Definition at line 349 of file Layout.c.

References FALSE, and LayoutLayout().

{
    LayoutLayout ((LayoutWidget) gw, FALSE);
}

Here is the call graph for this function:

static void Resize

(

)

[static]

static void SetSizes	(	BoxPtr	box,
		Position	x,
		Position	y
	)			[static]

Definition at line 902 of file Layout.c.

References _Box::box, BoxBox, GlueBox, height, info, LayoutHorizontal, LayoutVertical, _Box::nextSibling, _Box::size, SubInfo, _Box::u, VariableBox, w, WidgetBox, and width.

Referenced by LayoutLayout().

{
    BoxPtr      child;
    int         width, height;
    int         bw;
    Widget      w;
    SubInfoPtr  info;
    
    switch (box->type) {
    case WidgetBox:
        w = box->u.widget.widget;
        if (w)
        {
            info = SubInfo(w);
            /* info = (SubInfoPtr) w->core.constraints; */
            width = box->size[LayoutHorizontal];
            height = box->size[LayoutVertical];
            bw = info->naturalBw;
            width -= bw * 2;
            height -= bw * 2;
            /* Widgets which grow too small are placed off screen */
            if (width <= 0 || height <= 0) 
            {
                width = 1;
                height = 1;
                bw = 0;
                x = -1;
                y = -1;
            }
            XtConfigureWidget (w, x, y, 
                              (Dimension)width, (Dimension)height, 
                              (Dimension)bw);
        }
        break;
    case BoxBox:
        for (child = box->u.box.firstChild; child; child = child->nextSibling) 
        {
            SetSizes (child, x, y);
            if (box->u.box.dir == LayoutHorizontal)
                x += child->size[LayoutHorizontal];
            else
                y += child->size[LayoutVertical];
        }
        break;
    case GlueBox:
    case VariableBox:
        break;
    }
}

Here is the caller graph for this function:

static Boolean SetValues	(	Widget	gold,
		Widget	greq,
		Widget	gnew,
		ArgList	args,
		Cardinal *	num_args
	)			[static]

Definition at line 357 of file Layout.c.

References FALSE, LayoutPart::layout, _LayoutRec::layout, LayoutLayout(), and TRUE.

{
    LayoutWidget    old = (LayoutWidget) gold,
                    new = (LayoutWidget) gnew;

    if (old->layout.layout != new->layout.layout)
        LayoutLayout (new, TRUE);
    return FALSE;
} /* SetValues */

Here is the call graph for this function:

static Boolean SetValues

(

)

[static]

static void TabTo

(

int

level

)

[static]

Definition at line 462 of file Layout.c.

References void().

Referenced by PrintBox().

{
    while (level--)
        (void) printf ("%s", "  ");
}

Here is the call graph for this function:

Here is the caller graph for this function:

---

Variable Documentation

LayoutClassRec layoutClassRec

Definition at line 111 of file Layout.c.

WidgetClass layoutWidgetClass = (WidgetClass) &layoutClassRec

Definition at line 188 of file Layout.c.

XtResource resources[] [static]

Initial value:

 {
    {XtNlayout, XtCLayout, XtRLayout, sizeof (BoxPtr),
        offset(layout), XtRLayout, NULL },
    {XtNdebug, XtCBoolean, XtRBoolean, sizeof(Boolean),
         offset(debug), XtRImmediate, (XtPointer) FALSE},
}

Definition at line 77 of file Layout.c.

---