blob.c

安装DDD之前

	if (wc->primitive_class.border_highlight)
	    (*wc->primitive_class.border_highlight) (w);
    }
    else {
        if (wc->primitive_class.border_unhighlight)
            (*wc->primitive_class.border_unhighlight) (w);
    }
}



/************************************************************************
 *
 *  SetValues
 *
 ************************************************************************/
static Boolean SetValues (old_w, request_w, new_w, args, num_args)
    Widget old_w;
    Widget request_w;
    Widget new_w;
    ArgList args;
    Cardinal *num_args;
{
    XmpBlobWidgetClass wc = (XmpBlobWidgetClass)XtClass(new_w);
    XmpBlobWidget cw = (XmpBlobWidget)old_w;
    XmpBlobWidget rw = (XmpBlobWidget)request_w;
    XmpBlobWidget nw = (XmpBlobWidget)new_w;
    Boolean redisplayFlag = False;

    /* Validate XmNblobShape */

    if (nw->blob.blob_shape != cw->blob.blob_shape) {
	if (!XmRepTypeValidValue (blobShapeId, nw->blob.blob_shape, (Widget)nw))
            nw->blob.blob_shape = cw->blob.blob_shape;
	else
	    redisplayFlag = True;
    }

    /* Redisplay on change in sensitivity */

    if (XtIsSensitive((Widget)nw) != XtIsSensitive((Widget)cw)) {
	redisplayFlag = True;
    }

    /* Update GC's on color change */

    if (nw->primitive.foreground != cw->primitive.foreground) {
	if (wc->blob_class.destroy_gc)
	    (*(wc->blob_class.destroy_gc))((Widget)cw);
	if (wc->blob_class.create_gc)
	    (*(wc->blob_class.create_gc))((Widget)nw);
        redisplayFlag = True;
    }

    /* Check for application geometry settings. '0' means 'ideal size' */

    if (rw->core.width == 0) {
	nw->core.width = 0;
	nw->blob.compute_width = True;
    }
    else if (rw->core.width != cw->core.width) {
	nw->core.width = rw->core.width;
	nw->blob.pref_width = rw->core.width;
	nw->blob.compute_width = False;
    }
    if (rw->core.height == 0) {
	nw->core.height = 0;
	nw->blob.compute_height = True;
    }
    else if (rw->core.height != cw->core.height) {
	nw->core.height = rw->core.height;
	nw->blob.pref_height = rw->core.height;
	nw->blob.compute_height = False;
    }

    nw->blob.reconfigure = False;
    if (nw->core.width != cw->core.width ||
        nw->core.height != cw->core.height ||
        nw->blob.margin_width != cw->blob.margin_width ||
        nw->blob.margin_height != cw->blob.margin_height ||
        nw->primitive.shadow_thickness != cw->primitive.shadow_thickness ||
        nw->primitive.highlight_thickness !=
                cw->primitive.highlight_thickness) {

	/* If we are a Blob calculate ideal size. If we are a subclass let */
	/* the subclass SetValues do it - the subclass CalcWidgetSize      */
	/* method may need information derived in its SetValues method.    */

	if ((WidgetClass)wc == xmpBlobWidgetClass) {
	    if (wc->blob_class.calc_widget_size)
		(*(wc->blob_class.calc_widget_size))((Widget)nw);

	    nw->blob.pref_width = nw->core.width;
	    nw->blob.pref_height = nw->core.height;

	    if (nw->core.width == cw->core.width &&
		nw->core.height == cw->core.height) {
		if (wc->core_class.resize)
		    (*(wc->core_class.resize))((Widget)nw);
	    }
	}
	else {
	    nw->blob.reconfigure = True;
	}
 	redisplayFlag = True;
    }

    return (redisplayFlag);
}



/************************************************************************
 *
 *  QueryGeometry
 *
 ************************************************************************/
static XtGeometryResult QueryGeometry (w, request, reply)
    Widget w;
    XtWidgetGeometry *request;
    XtWidgetGeometry *reply;
{
    XmpBlobWidget bw = (XmpBlobWidget)w;

    /* Return our preferred size */

    if ((request->request_mode & CWWidth) &&
	request->width == bw->blob.pref_width &&
	(request->request_mode & CWHeight) &&
	request->height == bw->blob.pref_height) {

	return (XtGeometryYes);
    }

    if (bw->core.width == bw->blob.pref_width &&
	bw->core.height == bw->blob.pref_height) {

	return (XtGeometryNo);
    }

    reply->request_mode = (CWWidth | CWHeight);
    reply->width = bw->blob.pref_width;
    reply->height = bw->blob.pref_height;

    return (XtGeometryAlmost);
}



/************************************************************************
 *
 *  DrawVisual
 *
 ************************************************************************/
static void DrawVisual (w)
    Widget w;
{
    XmpBlobWidgetClass wc = (XmpBlobWidgetClass)XtClass(w);
    XmpBlobWidget bw = (XmpBlobWidget)w;

    /* Draw XmNblobShape */

    if (bw->blob.visual_width > 0 && bw->blob.visual_height > 0) {
	switch (bw->blob.blob_shape) {
	    case(XmBLOB_OVAL):
	    default:
		XFillArc (XtDisplay(w), XtWindow(w),
			wc->blob_class.select_gc(w),
			bw->blob.visual_x, bw->blob.visual_y,
			bw->blob.visual_width, bw->blob.visual_height,
			0, 360 * 64);
		break;
	    case(XmBLOB_RECTANGLE):
		XFillRectangle (XtDisplay(w), XtWindow(w),
                        wc->blob_class.select_gc(w),
                        bw->blob.visual_x, bw->blob.visual_y,
                        bw->blob.visual_width, bw->blob.visual_height);
		break;
	}
    }
}



/************************************************************************
 *
 *  DrawShadow
 *
 ************************************************************************/
static void DrawShadow (w)
    Widget w;
{
    XmpBlobWidget bw = (XmpBlobWidget)w;

    /* Draw rectangular 3D shadow */

    if (bw->core.width > 2 * bw->primitive.highlight_thickness &&
	bw->core.height > 2 * bw->primitive.highlight_thickness &&
	bw->primitive.shadow_thickness > 0) {
	_XmDrawShadows (XtDisplay (bw), XtWindow (bw),
		bw->primitive.top_shadow_GC,
		bw->primitive.bottom_shadow_GC,
		bw->primitive.highlight_thickness,
		bw->primitive.highlight_thickness,
		bw->core.width - 2 * bw->primitive.highlight_thickness,
		bw->core.height - 2 * bw->primitive.highlight_thickness,
		bw->primitive.shadow_thickness, XmSHADOW_ETCHED_OUT);
    }
}



/************************************************************************
 *
 *  CreateGC
 *
 ************************************************************************/
static void CreateGC (w )
    Widget w;
{
    XmpBlobWidget bw = (XmpBlobWidget)w;
    XGCValues values;
    XtGCMask valueMask;

    /* Create normal GC */

    valueMask = GCForeground | GCBackground | GCGraphicsExposures;

    values.foreground = bw->primitive.foreground;
    values.background = bw->core.background_pixel;
    values.graphics_exposures = False;

    bw->blob.normal_gc = XtGetGC ((Widget)bw, valueMask, &values);

    /* Create grayed-out GC */

    valueMask |= GCFillStyle | GCStipple;
    values.fill_style = FillStippled;
    values.stipple = XmGetPixmapByDepth (XtScreen((Widget)(bw)),
				"50_foreground", 1, 0, 1);

    bw->blob.insensitive_gc = XtGetGC((Widget)bw, valueMask, &values);
}



/************************************************************************
 *
 *  DestroyGC
 *
 ************************************************************************/
static void DestroyGC (w)
    Widget w;
{
    XmpBlobWidget bw = (XmpBlobWidget)w;

    /* Destroy GC's */

    XtReleaseGC ((Widget)bw, bw->blob.normal_gc);
    XtReleaseGC ((Widget)bw, bw->blob.insensitive_gc);
}



/************************************************************************
 *
 *  SelectGC
 *
 ************************************************************************/
static GC SelectGC (w)
    Widget w;
{
    XmpBlobWidget bw = (XmpBlobWidget)w;
    GC drawGC;

    /* Select drawing GC */

    drawGC = XtIsSensitive((Widget)bw) ? bw->blob.normal_gc : bw->blob.insensitive_gc;

    return (drawGC);
}



/************************************************************************
 *
 *  CalcWidgetSize 
 *
 ************************************************************************/
static void CalcWidgetSize (w)
    Widget w;
{
    XmpBlobWidgetClass wc = (XmpBlobWidgetClass)XtClass(w);
    XmpBlobWidget bw = (XmpBlobWidget)w;

    /* Calculate ideal size. If application set geometry, use that. */

    if (wc->blob_class.calc_visual_size)
                (*(wc->blob_class.calc_visual_size))((Widget)bw);

    if (bw->blob.compute_width)
	bw->core.width = bw->blob.visual_width + 2 * (
		bw->blob.margin_width +
		bw->primitive.shadow_thickness +
		bw->primitive.highlight_thickness);
    else
	bw->core.width = bw->blob.pref_width;

    if (bw->blob.compute_height)
	bw->core.height = bw->blob.visual_height + 2 * (
		bw->blob.margin_height +
		bw->primitive.shadow_thickness +
		bw->primitive.highlight_thickness);
    else
	bw->core.height = bw->blob.pref_height;

}



/************************************************************************
 *
 *  CalcVisualSize 
 *
 ************************************************************************/
static void CalcVisualSize (w)
    Widget w;
{
    XmpBlobWidget bw = (XmpBlobWidget)w;

    /* Calculate ideal size of class's visual */
    bw->blob.visual_width = BLOB_SIZE;
    bw->blob.visual_height = BLOB_SIZE;
}



/************************************************************************
 *
 *  BlobActivate
 *
 ************************************************************************/
static void BlobActivate (w, event, params, num_params)
    Widget w;
    XEvent *event;
    String *params;
    Cardinal *num_params;
{

    /* Take focus */

    XmProcessTraversal (w, XmTRAVERSE_CURRENT);

    /* Activate noisily! */

    XBell (XtDisplay(w), 0);
}



/************************************************************************
 *
 *  XmpCreateBlob
 *
 ************************************************************************/
Widget XmpCreateBlob (parent, name, arglist, argCount)
    Widget parent;
    char *name;
    Arg *arglist;
    Cardinal argCount;
{
    return (XtCreateWidget (name, xmpBlobWidgetClass,
				parent, arglist, argCount));
}