xref: /dports/astro/tkgeomap/tkgeomap-2.11.6/tk/tkgeomapPlace.c

/*
 * tkgeomapPlace.c --
 *
 * 	This file defines functions that display geoplaces as canvas items.
 *
 * Copyright (c) 2004 Gordon D. Carrie. All rights reserved.
 *
 * Licensed under the Open Software License version 2.1
 *
 * Please address questions and feedback to user0@tkgeomap.org
 *
 * @(#) $Id: tkgeomapPlace.c,v 1.19 2007/06/26 21:58:34 tkgeomap Exp $
 *
 **********************************************************************
 *
 */

#include "tkgeomap.h"
#include "tkgeomapInt.h"

/*
 * The structure below declares the record for each geoplace item.
 */

typedef struct {
    Tk_Item header;		/* Generic stuff that's the same for all
				 * types.  MUST BE FIRST IN STRUCTURE. */
    Tcl_Interp *interp;		/* Interpreter in which item was created */
    Tk_Canvas canvas;		/* Canvas in which item is displayed */
    double xRef, yRef;		/* Canvas coordinates of reference point.
				 * This is NOT necessarily where the place is */
    GeoPt refPt;		/* Geographic coordinates of reference point.
				 * This is NOT necessarily where the place is */
    MapPt mRefPt;		/* Map coordinates of reference point. */
    Tclgeomap_Place tclGeoPlace;/* Geoplace the item displays */
    MapPt mapPt;		/* Map coordinates of the place. */
    double xPlc, yPlc;		/* Canvas coordinates of the place */
    Tclgeomap_Proj proj;	/* Cartographic projection */
    double scale;		/* Cartographic scale (pure number ratio) */
    int	updateMap;		/* If true, recompute place map coordinates */
    int updateCvs;		/* If true, recompute place canvas coord's */
    XColor *dotColor;		/* Dot color */
    int dotSize;		/* Dot size */
    GC dotGC;			/* Graphics context for drawing dot */
    Pixmap bitmap;		/* Bitmap to draw at place */
    XColor *bmColor;		/* Bitmap foreground color */
    GC bmGC;			/* Graphics context for drawing bitmap */
    char *text;			/* Text string to print at place */
    XColor *textColor;		/* Text color */
    Tk_Font font;		/* Text font */
    Tk_Anchor textAnchor;	/* Relative location of text. */
    GC txtGC;			/* Graphics context for drawing text */
    Tk_TextLayout layout;	/* Text layout */
    int xTxt;			/* Offset from place to left edge of text box */
    int yTxt;			/* Offset from place to top of text box */
    int txtWidth;		/* Width of text box */
    int txtHeight;		/* Height of text box */
    Angle arrow_az;		/* Arrow azimuth relative to true north */
    double arrow_len;		/* Arrow length, pixels */
    double arrow_tip_sz;	/* Length of edges of arrow tip, fraction of
				 * arrow length */
    short arrow_base_x;		/* Offset from place to arrow base, in */
    short arrow_base_y;		/* drawable coordinates */
    short arrow_head_x;		/* Offset from place to arrow head, in */
    short arrow_head_y;		/* drawable coordinates */
    short arrow_ltip_x;		/* Offset from arrow head to left side of */
    short arrow_ltip_y;		/* arrow tip, drawable coordinates */
    short arrow_rtip_x;		/* Offset from arrow head right side of */
    short arrow_rtip_y;		/* arrow tip, drawable coordinates */
    XColor *arrowColor;
    GC arrowGC;			/* Graphics context for drawing arrow */
} PlaceItem;

/*
 * Prototypes for procedures defined in this file:
 */

static int		createProc _ANSI_ARGS_((Tcl_Interp *interp,
				Tk_Canvas canvas, struct Tk_Item *itemPtr,
				int objc, Tcl_Obj *CONST objv[]));
static int		configProc _ANSI_ARGS_((Tcl_Interp *interp,
				Tk_Canvas canvas, Tk_Item *itemPtr, int objc,
				Tcl_Obj *CONST objv[], int flags));
static int		coordProc _ANSI_ARGS_((Tcl_Interp *interp,
				Tk_Canvas canvas, Tk_Item *itemPtr, int objc,
				Tcl_Obj *CONST objv[]));
static void		deleteProc _ANSI_ARGS_((Tk_Canvas canvas,
				Tk_Item *itemPtr, Display *display));
static void		forgetPlace _ANSI_ARGS_((ClientData clientData));
static void		forgetProj _ANSI_ARGS_((ClientData clientData));
static void		hide _ANSI_ARGS_((PlaceItem *plcItemPtr));
static void		displayProc _ANSI_ARGS_((Tk_Canvas canvas,
				Tk_Item *itemPtr, Display *display,
				Drawable dst, int x, int y, int width,
				int height));
static double		pointProc _ANSI_ARGS_((Tk_Canvas canvas,
				Tk_Item *itemPtr, double *coordPtr));
static int		areaProc _ANSI_ARGS_((Tk_Canvas canvas,
				Tk_Item *itemPtr, double *rectPtr));
static int		postscriptProc _ANSI_ARGS_((Tcl_Interp *interp,
				Tk_Canvas canvas, Tk_Item *itemPtr,
				int prepass));
static void		scaleProc _ANSI_ARGS_((Tk_Canvas canvas,
				Tk_Item *itemPtr, double originX,
				double originY, double scaleX, double scaleY));
static void		translateProc _ANSI_ARGS_((Tk_Canvas canvas,
				Tk_Item *itemPtr, double deltaX,
				double deltaY));
static int		parseGeoPlaceOption _ANSI_ARGS_((ClientData clientData,
				Tcl_Interp *interp, Tk_Window tkwin,
				char *value, char *widgRec, int offset));
static char *		printGeoPlaceOption _ANSI_ARGS_((ClientData clientData,
				Tk_Window tkwin, char *widgRec, int offset,
				Tcl_FreeProc **freeProcPtr));
static void		geoPlaceUpdate _ANSI_ARGS_((ClientData clientData));
static int		parseRefPtOption _ANSI_ARGS_((ClientData clientData,
				Tcl_Interp *interp, Tk_Window tkwin,
				char *value, char *widgRec, int offset));
static char *		printRefPtOption _ANSI_ARGS_((ClientData clientData,
				Tk_Window tkwin, char *widgRec, int offset,
				Tcl_FreeProc **freeProcPtr));
static int		parseProjOption _ANSI_ARGS_((ClientData clientData,
				Tcl_Interp *interp, Tk_Window tkwin,
				char *value, char *widgRec, int offset));
static char *		printProjOption _ANSI_ARGS_((ClientData clientData,
				Tk_Window tkwin, char *widgRec, int offset,
				Tcl_FreeProc **freeProcPtr));
static int		parseArrowOption _ANSI_ARGS_((ClientData clientData,
				Tcl_Interp *interp, Tk_Window tkwin,
				char *value, char *widgRec, int offset));
static char *		printArrowOption _ANSI_ARGS_((ClientData clientData,
				Tk_Window tkwin, char *widgRec, int offset,
				Tcl_FreeProc **freeProcPtr));
static void		computeTextLayout _ANSI_ARGS_((
				PlaceItem *plcItemPtr));
static void		updateMap _ANSI_ARGS_((ClientData clientData));
static void		updateCvs _ANSI_ARGS_((PlaceItem *plcItemPtr));

/*
 * Custom configuration options
 */

static Tk_CustomOption geoPlaceOption = {
    parseGeoPlaceOption,
    printGeoPlaceOption,
    NULL
};

static Tk_CustomOption refPtOption = {
    parseRefPtOption,
    printRefPtOption,
    NULL
};

static Tk_CustomOption projOption = {
    parseProjOption,
    printProjOption,
    NULL
};

static Tk_CustomOption arrowOption = {
    parseArrowOption,
    printArrowOption,
    NULL
};

/*
 * The members of tagsOption will be set in TkgeomapPlaceInit
 */

static Tk_CustomOption tagsOption = {
    NULL, NULL, NULL
};

/*
 * Configuration options for the geoplace item
 */

static Tk_ConfigSpec configSpecs[] = {
    {TK_CONFIG_CUSTOM, "-place", NULL, NULL, "", 0,
	TK_CONFIG_NULL_OK, &geoPlaceOption},
    {TK_CONFIG_CUSTOM, "-refpoint", NULL, NULL, "0.0 0.0", 0, 0,
	&refPtOption},
    {TK_CONFIG_CUSTOM, "-projection", NULL, NULL, "", 0, 0,
	&projOption},
    {TK_CONFIG_DOUBLE, "-scale", NULL, NULL, "1.0e-7",
	Tk_Offset(PlaceItem, scale), 0, NULL},
    {TK_CONFIG_COLOR, "-dotcolor", NULL, NULL, "Black",
	Tk_Offset(PlaceItem, dotColor), TK_CONFIG_NULL_OK, NULL},
    {TK_CONFIG_PIXELS, "-dotsize", NULL, NULL, "1",
	Tk_Offset(PlaceItem, dotSize), 0, NULL},
    {TK_CONFIG_BITMAP, "-bitmap", NULL, NULL, "",
	Tk_Offset(PlaceItem, bitmap), TK_CONFIG_NULL_OK, NULL},
    {TK_CONFIG_COLOR, "-bitmapcolor", NULL, NULL, "Black",
	Tk_Offset(PlaceItem, bmColor), TK_CONFIG_NULL_OK, NULL},
    {TK_CONFIG_STRING, "-text", NULL, NULL, "", Tk_Offset(PlaceItem, text),
	0, NULL},
    {TK_CONFIG_COLOR, "-textcolor", NULL, NULL, "Black",
	Tk_Offset(PlaceItem, textColor), TK_CONFIG_NULL_OK, NULL},
    {TK_CONFIG_FONT, "-font", NULL, NULL, "fixed",
	Tk_Offset(PlaceItem, font), TK_CONFIG_NULL_OK, NULL},
    {TK_CONFIG_ANCHOR, "-anchor", NULL, NULL, "center",
	Tk_Offset(PlaceItem, textAnchor), 0, NULL},
    {TK_CONFIG_CUSTOM, "-arrow", NULL, NULL, "0.0 0 0.0", 0, 0,
	&arrowOption},
    {TK_CONFIG_COLOR, "-arrowcolor", NULL, NULL, "Black",
	Tk_Offset(PlaceItem, arrowColor), TK_CONFIG_NULL_OK, NULL},
    {TK_CONFIG_CUSTOM, "-tags", NULL, NULL, NULL, 0, TK_CONFIG_NULL_OK,
	&tagsOption},
    {TK_CONFIG_END,  NULL,  NULL,  NULL, NULL, 0, 0, NULL}
};

/*
 * The structures below defines the geoplace item type in terms of
 * procedures that can be invoked by generic item code.
 */

static Tk_ItemType geoPlaceType = {
    "geomap_place",
    sizeof(PlaceItem),
    createProc,
    configSpecs,
    configProc,
    coordProc,
    deleteProc,
    displayProc,
    TK_CONFIG_OBJS,
    pointProc,
    areaProc,
    postscriptProc,
    scaleProc,
    translateProc,
    (Tk_ItemIndexProc *) NULL,
    (Tk_ItemCursorProc *) NULL,
    (Tk_ItemSelectionProc *) NULL,
    (Tk_ItemInsertProc *) NULL,
    (Tk_ItemDCharsProc *) NULL,
    (Tk_ItemType *) NULL,
};

/*
 *------------------------------------------------------------------------
 *
 * TkgeomapPlaceInit --
 *
 *	This procedure adds the geoplace item type to the canvas widget.
 *	See the user documentation for a description of the its effect
 *	on Tcl.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 * 	Prerequisite packages are initialized, and the "geoplace" item is
 * 	added to the Tk canvas interface.
 *
 *------------------------------------------------------------------------
 */

int
TkgeomapPlaceInit(interp)
    Tcl_Interp *interp;			/* Current interpreter */
{
    static int loaded;			/* If true, package is loaded */

    if (loaded) {
	return TCL_OK;
    }
#ifdef USE_TCL_STUBS
    if (Tcl_InitStubs(interp, TCL_VERSION, 0) == NULL) {
	return TCL_ERROR;
    }
#endif
#ifdef USE_TK_STUBS
    if (Tk_InitStubs(interp, TK_VERSION, 0) == NULL) {
	return TCL_ERROR;
    }
#endif

    /*
     * Set tagsOption.  This must be done at run time because the stubs
     * library set the functions to non-static values, so they cannot be
     * used in an initializer.
     */

    tagsOption.parseProc = Tk_CanvasTagsParseProc;
    tagsOption.printProc = Tk_CanvasTagsPrintProc;

    Tk_CreateItemType(&geoPlaceType);
    loaded = 1;
    return TCL_OK;
}

/*
 *--------------------------------------------------------------
 *
 * createProc --
 *
 *	This procedure is invoked to create a new geoplace
 *	item in a canvas.
 *
 * Results:
 *	A standard Tcl return value.  If an error occurred in
 *	creating the item, then an error message is left in
 *	the interp's result;  in this case itemPtr is left uninitialized,
 *	so it can be safely freed by the caller.
 *
 * Side effects:
 *	A new geoplace item is created.
 *
 *--------------------------------------------------------------
 */

static int
createProc(interp, canvas, itemPtr, objc, objv)
    Tcl_Interp *interp;			/* Interpreter for error reporting. */
    Tk_Canvas canvas;			/* Canvas to hold new item. */
    Tk_Item *itemPtr;			/* Record to hold new item;  header
					 * has been initialized by caller. */
    int objc;				/* Number of arguments in objv. */
    Tcl_Obj *CONST objv[];		/* Arguments describing rectangle. */
{
    PlaceItem *plcItemPtr = (PlaceItem *)itemPtr;
    double x, y;


    /*
     * Set location of reference point from coordinates given on command line.
     */

    if ((Tk_CanvasGetCoordFromObj(interp, canvas, objv[0], &x) != TCL_OK)
	    || (Tk_CanvasGetCoordFromObj(interp, canvas, objv[1], &y)
		!= TCL_OK)) {
	return TCL_ERROR;
    }
    plcItemPtr->xRef = x;
    plcItemPtr->yRef = y;

    /*
     * Initialize values.  Bogus initializers will be set properly
     * when the item is configured.
     */

    plcItemPtr->interp = interp;
    plcItemPtr->canvas = canvas;
    plcItemPtr->refPt = GeoPtFmDeg(0.0, 0.0);
    plcItemPtr->proj = NULL;
    plcItemPtr->scale = 0.0;
    plcItemPtr->tclGeoPlace = NULL;
    plcItemPtr->mapPt = MapPtNowhere();
    plcItemPtr->updateMap = 1;
    plcItemPtr->updateCvs = 1;
    plcItemPtr->dotColor = None;
    plcItemPtr->dotSize = 0;
    plcItemPtr->dotGC = None;
    plcItemPtr->bitmap = None;
    plcItemPtr->bmColor = None;
    plcItemPtr->bmGC = None;
    plcItemPtr->text = CKALLOC(1);
    strcpy(plcItemPtr->text, "");
    plcItemPtr->textColor = None;
    plcItemPtr->font = NULL;
    plcItemPtr->textAnchor = TK_ANCHOR_CENTER;
    plcItemPtr->txtGC = None;
    plcItemPtr->layout = NULL;
    plcItemPtr->arrowColor = None;
    plcItemPtr->arrowGC = None;

    /*
     * Configure the new geoplace item.
     */

    if (configProc(interp, canvas, itemPtr, objc - 2, objv + 2, 0)
	    != TCL_OK) {
	deleteProc(canvas, itemPtr, Tk_Display(Tk_CanvasTkwin(canvas)));
	return TCL_ERROR;
    }

    return TCL_OK;
}

/*
 *--------------------------------------------------------------
 *
 * configProc --
 *
 *	This procedure is invoked to configure various aspects
 *	of a geoplace item, such as its anchor position.
 *
 * Results:
 *	A standard Tcl result code.  If an error occurs, then
 *	an error message is left in the interp's result.
 *
 * Side effects:
 *	Configuration information may be set for itemPtr.
 *
 *--------------------------------------------------------------
 */

static int
configProc(interp, canvas, itemPtr, objc, objv, flags)
    Tcl_Interp *interp;		/* Used for error reporting. */
    Tk_Canvas canvas;		/* Canvas containing itemPtr. */
    Tk_Item *itemPtr;		/* Geoplace item to reconfigure. */
    int objc;			/* Number of elements in objv.  */
    Tcl_Obj *CONST objv[];	/* Arguments describing things to configure. */
    int flags;			/* Flags to pass to Tk_ConfigureWidget. */
{
    PlaceItem *plcItemPtr = (PlaceItem *)itemPtr;
    Tk_Window tkwin = Tk_CanvasTkwin(canvas);
    double oldScale;
    Tk_Anchor oldAnchor;
    XGCValues gcVals;
    GC gc;

    oldScale = plcItemPtr->scale;
    oldAnchor = plcItemPtr->textAnchor;
    if (Tk_ConfigureWidget(interp, Tk_CanvasTkwin(canvas),
		geoPlaceType.configSpecs, objc, (char **)objv,
		(char *)plcItemPtr, flags|TK_CONFIG_OBJS) != TCL_OK) {
	return TCL_ERROR;
    }

    /*
     * Update graphics contexts.
     */

    if (plcItemPtr->dotSize > 0 && plcItemPtr->dotColor != None) {
	gcVals.foreground = plcItemPtr->dotColor->pixel;
	gc = Tk_GetGC(tkwin, GCForeground, &gcVals);
	if (plcItemPtr->dotGC != None) {
	    Tk_FreeGC(Tk_Display(tkwin), plcItemPtr->dotGC);
	}
	plcItemPtr->dotGC = gc;
    }
    if (plcItemPtr->bitmap != None && plcItemPtr->bmColor != None) {
	gcVals.foreground = plcItemPtr->bmColor->pixel;
	gcVals.clip_mask = plcItemPtr->bitmap;
	gc = Tk_GetGC(tkwin, GCForeground|GCClipMask, &gcVals);
	if (plcItemPtr->bmGC != None) {
	    Tk_FreeGC(Tk_Display(tkwin), plcItemPtr->bmGC);
	}
	plcItemPtr->bmGC = gc;
    }
    if ( (plcItemPtr->textColor != None) && plcItemPtr->font) {
	gcVals.foreground = plcItemPtr->textColor->pixel;
	gcVals.font = Tk_FontId(plcItemPtr->font);
	gc = Tk_GetGC(tkwin, GCForeground|GCFont, &gcVals);
	if (plcItemPtr->txtGC != None) {
	    Tk_FreeGC(Tk_Display(tkwin), plcItemPtr->txtGC);
	}
	plcItemPtr->txtGC = gc;
    }
    if (plcItemPtr->arrow_len >= 1.0 && plcItemPtr->arrowColor != None) {
	gcVals.foreground = plcItemPtr->arrowColor->pixel;
	gc = Tk_GetGC(tkwin, GCForeground, &gcVals);
	if (plcItemPtr->arrowGC != None) {
	    Tk_FreeGC(Tk_Display(tkwin), plcItemPtr->arrowGC);
	}
	plcItemPtr->arrowGC = gc;
    }

    /*
     * If text has changed, compute new text layout.
     */

    if (strlen(plcItemPtr->text) > 0) {
	computeTextLayout(plcItemPtr);
    }
    updateCvs(plcItemPtr);
    return TCL_OK;
}

/*
 *--------------------------------------------------------------
 *
 * coordProc --
 *
 *	This procedure is invoked to process the "coords" widget
 *	command on geoplace items.  See the user documentation for
 *	details on what it does.
 *
 * Results:
 *	Returns TCL_OK or TCL_ERROR, and sets the interp's result.
 *
 * Side effects:
 *	The coordinates for the given item may be changed.
 *
 *--------------------------------------------------------------
 */

static int
coordProc(interp, canvas, itemPtr, objc, objv)
    Tcl_Interp *interp;			/* Used for error reporting. */
    Tk_Canvas canvas;			/* Canvas containing item. */
    Tk_Item *itemPtr;			/* Item whose coordinates are to be
					 * read or modified. */
    int objc;				/* Number of coordinates supplied in
					 * objv. */
    Tcl_Obj *CONST objv[];		/* Array of coordinates: x1, y1,
					 * x2, y2, ... */
{
    PlaceItem *plcItemPtr = (PlaceItem *)itemPtr;
    double xRef, yRef;

    if (objc == 0) {
	/*
	 * Set result to item coordinates
	 */

	Tcl_Obj *obj = Tcl_NewObj();
	Tcl_Obj *subobj = Tcl_NewDoubleObj(plcItemPtr->xRef);
	Tcl_ListObjAppendElement(interp, obj, subobj);
	subobj = Tcl_NewDoubleObj(plcItemPtr->yRef);
	Tcl_ListObjAppendElement(interp, obj, subobj);
	Tcl_SetObjResult(interp, obj);
    } else if (objc == 1) {
	Tcl_Obj *rslt;		/* Result */

	if (strcmp(Tcl_GetString(objv[0]), "dump") == 0) {
	    /*
	     * User wants dump of canvas coordinates for the linearray.
	     */

	    updateCvs(plcItemPtr);
	    rslt = Tcl_NewObj();
	    Tcl_ListObjAppendElement(interp, rslt,
		    Tcl_NewDoubleObj(plcItemPtr->xPlc));
	    Tcl_ListObjAppendElement(interp, rslt,
		    Tcl_NewDoubleObj(plcItemPtr->yPlc));
	    Tcl_SetObjResult(interp, rslt);
	    return TCL_OK;
	} else {
	    /*
	     * New coordinates given on command line in form
	     * "pathName coords {x y}"
	     */

	    Tcl_Obj **coordsPtr;
	    int n;

	    if (Tcl_ListObjGetElements(interp, objv[0], &n, &coordsPtr)
		    != TCL_OK || n != 2) {
		Tcl_AppendResult(interp, "Could not split coords list\n", NULL);
		return TCL_ERROR;
	    }
	    if ((Tk_CanvasGetCoordFromObj(interp, canvas, coordsPtr[0],
			    &xRef) != TCL_OK)
		    || (Tk_CanvasGetCoordFromObj(interp, canvas, coordsPtr[1],
			    &yRef) != TCL_OK)) {
		return TCL_ERROR;
	    }
	    plcItemPtr->xRef = xRef;
	    plcItemPtr->yRef = yRef;
	    plcItemPtr->updateCvs = 1;
	    updateCvs(plcItemPtr);
	}
    } else if (objc == 2) {
	/*
	 * New coordinates given on command line
	 */

	if ((Tk_CanvasGetCoordFromObj(interp, canvas, objv[0],
			&xRef) != TCL_OK)
		|| (Tk_CanvasGetCoordFromObj(interp, canvas, objv[1],
			&yRef) != TCL_OK)) {
	    return TCL_ERROR;
	}
	plcItemPtr->xRef = xRef;
	plcItemPtr->yRef = yRef;
	plcItemPtr->updateCvs = 1;
	updateCvs(plcItemPtr);
    } else {
	Tcl_AppendResult(interp,
		"Coordinates must be specified as \"x y\" or \"{x y}\"", NULL);
	return TCL_ERROR;
    }
    return TCL_OK;
}

/*
 *--------------------------------------------------------------
 *
 * deleteProc --
 *
 *	This procedure is called to clean up the data structure
 *	associated with a geoplace item.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Resources associated with itemPtr are released.
 *
 *--------------------------------------------------------------
 */

static void
deleteProc(canvas, itemPtr, display)
    Tk_Canvas canvas;			/* Info about overall canvas widget. */
    Tk_Item *itemPtr;			/* Item that is being deleted. */
    Display *display;			/* Display containing window for
					 * canvas. */
{
    PlaceItem *plcItemPtr = (PlaceItem *)itemPtr;

    Tclgeomap_CnxProjUpdateTask(plcItemPtr->proj, plcItemPtr);
    Tclgeomap_CnxProjDeleteTask(plcItemPtr->proj, plcItemPtr);
    Tclgeomap_CnxPlaceUpdateTask(plcItemPtr->tclGeoPlace, plcItemPtr);
    Tclgeomap_CnxPlaceDeleteTask(plcItemPtr->tclGeoPlace, plcItemPtr);
    if (plcItemPtr->dotGC != None) {
	Tk_FreeGC(display, plcItemPtr->dotGC);
    }
    if (plcItemPtr->bmGC != None) {
	Tk_FreeGC(display, plcItemPtr->bmGC);
    }
    if (plcItemPtr->txtGC != None) {
	Tk_FreeGC(display, plcItemPtr->txtGC);
    }
    if (plcItemPtr->arrowGC != None) {
	Tk_FreeGC(display, plcItemPtr->arrowGC);
    }
    Tk_FreeOptions(geoPlaceType.configSpecs, (char *)plcItemPtr,
	    display, 0);
}

/*
 *--------------------------------------------------------------
 *
 * forgetPlace --
 *
 * 	This procedure adjusts a place item if the place it is displaying
 * 	is deleted.
 *
 * Results:
 * 	None.
 *
 * Side effects:
 * 	The item is removed from the display, although it continues to exist.
 *
 *--------------------------------------------------------------
 */

static void
forgetPlace(clientData)
    ClientData clientData;	/* Geoplace item */
{
    PlaceItem *plcItemPtr = (PlaceItem *)clientData;
    Tk_Canvas canvas = plcItemPtr->canvas;
    Tk_Window tkwin = Tk_CanvasTkwin(canvas);
    Display *display = Tk_Display(tkwin);

    plcItemPtr->tclGeoPlace = NULL;
    plcItemPtr->mapPt = MapPtNowhere();
    plcItemPtr->updateMap = 0;
    if (plcItemPtr->dotGC != None) {
	Tk_FreeGC(display, plcItemPtr->dotGC);
    }
    plcItemPtr->dotGC = None;
    if (plcItemPtr->bmGC != None) {
	Tk_FreeGC(display, plcItemPtr->bmGC);
    }
    plcItemPtr->bmGC = None;
    if (plcItemPtr->txtGC != None) {
	Tk_FreeGC(display, plcItemPtr->txtGC);
    }
    plcItemPtr->txtGC = None;
    if (plcItemPtr->arrowGC != None) {
	Tk_FreeGC(display, plcItemPtr->arrowGC);
    }
    plcItemPtr->arrowGC = None;
    hide(plcItemPtr);
}

/*
 *--------------------------------------------------------------
 *
 * forgetProj --
 *
 * 	This procedure adjusts a place item if the projection it is using
 * 	is deleted.
 *
 * Results:
 * 	None.
 *
 * Side effects:
 * 	The item is removed from the display, although it continues to exist.
 *
 *--------------------------------------------------------------
 */

static void
forgetProj(clientData)
    ClientData clientData;	/* Geoplace item */
{
    PlaceItem *plcItemPtr = (PlaceItem *)clientData;

    plcItemPtr->proj = NULL;
    plcItemPtr->mapPt = MapPtNowhere();
    plcItemPtr->updateMap = 0;
    hide(plcItemPtr);
}

/*
 *--------------------------------------------------------------
 *
 * hide --
 *
 * 	This procedure removes a geoplace from a display, although the geoplace
 * 	item continues to exist.
 *
 * Results:
 * 	None.
 *
 * Side effects:
 * 	None.
 *
 *--------------------------------------------------------------
 */

static void
hide(plcItemPtr)
    PlaceItem *plcItemPtr;	/* Place to remove from the display */
{
    Tk_CanvasEventuallyRedraw(plcItemPtr->canvas,
	    plcItemPtr->header.x1, plcItemPtr->header.y1,
	    plcItemPtr->header.x2, plcItemPtr->header.y2);
    plcItemPtr->header.x1 = plcItemPtr->header.y1 = INT_MIN;
    plcItemPtr->header.x2 = plcItemPtr->header.y2 = INT_MIN + 1;
    plcItemPtr->updateCvs = 0;
}

/*
 *--------------------------------------------------------------
 *
 * displayProc --
 *
 *	This procedure is invoked to draw a geoplace item in a given
 *	drawable.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	ItemPtr is drawn in drawable using the transformation
 *	information in canvas.
 *
 *--------------------------------------------------------------
 */

static void
displayProc(canvas, itemPtr, display, drawable, x, y, width, height)
    Tk_Canvas canvas;			/* Canvas that contains item. */
    Tk_Item *itemPtr;			/* Item to be displayed. */
    Display *display;			/* Display on which to draw item. */
    Drawable drawable;			/* Pixmap or window in which to draw
					 * item. */
    int x, y, width, height;		/* Describes region of canvas that
					 * must be redisplayed (not used). */
{
    PlaceItem *plcItemPtr = (PlaceItem *)itemPtr;
    Tk_Window tkwin = Tk_CanvasTkwin(canvas);
    int dotSize;
    short dwX, dwY;			/* Drawable (X) coordinates */
    int spShift;			/* Amount to shift to center large
					 * dot or bitmap */

    if (!tkwin || !Tk_IsMapped(tkwin) || !plcItemPtr->tclGeoPlace) {
	return;
    }
    if (plcItemPtr->updateMap) {
	updateMap(plcItemPtr);
    }
    if (MapPtIsNowhere(plcItemPtr->mapPt)) {
	return;
    }
    if (plcItemPtr->updateCvs) {
	updateCvs(plcItemPtr);
    }
    Tk_CanvasDrawableCoords(canvas, plcItemPtr->xPlc, plcItemPtr->yPlc,
	    &dwX, &dwY);

    /*
     * Draw dot.
     */

    if (plcItemPtr->dotSize > 0 && plcItemPtr->dotColor != None) {
	dotSize = plcItemPtr->dotSize;
	if (dotSize == 1) {
	    XDrawPoint(display, drawable, plcItemPtr->dotGC, dwX, dwY);
	} else {
	    spShift = dotSize / 2;
	    XFillArc(display, drawable, plcItemPtr->dotGC,
		    dwX - spShift, dwY - spShift,
		    (unsigned)dotSize, (unsigned)dotSize, 0, 23040);
	}
    }

    /*
     * Draw bitmap.
     */

    if (plcItemPtr->bitmap != None && plcItemPtr->bmColor != None) {
	Pixmap bitmap = plcItemPtr->bitmap;
	int bmWidth, bmHeight;

	Tk_SizeOfBitmap(display, bitmap, &bmWidth, &bmHeight);
	XSetClipOrigin(display, plcItemPtr->bmGC,
		dwX - bmWidth / 2, dwY - bmHeight / 2);
	XCopyPlane(display, bitmap, drawable, plcItemPtr->bmGC, 0, 0,
		(unsigned)bmWidth, (unsigned)bmHeight,
		dwX -bmWidth / 2, dwY -bmHeight / 2, 0x01);
	XSetClipOrigin(display, plcItemPtr->bmGC, 0, 0);
    }

    /*
     * Draw text.
     */

    if ( (strlen(plcItemPtr->text) > 0)
	    && (plcItemPtr->textColor != None)
	    && plcItemPtr->font
	    && plcItemPtr->layout ) {
	Tk_DrawTextLayout(display, drawable, plcItemPtr->txtGC,
		plcItemPtr->layout,
		dwX + plcItemPtr->xTxt, dwY + plcItemPtr->yTxt, 0, -1);
    }

    /*
     * Draw arrow.
     */

    if (plcItemPtr->arrow_len >= 1.0 && plcItemPtr->arrowColor != None) {
	XPoint xPtsPtr[2];

	/*
	 * Coordinates of the arrow head
	 */

	xPtsPtr[0].x = dwX + plcItemPtr->arrow_head_x;
	xPtsPtr[0].y = dwY + plcItemPtr->arrow_head_y;

	/*
	 * Draw the shaft
	 */

	xPtsPtr[1].x = dwX + plcItemPtr->arrow_base_x;
	xPtsPtr[1].y = dwY + plcItemPtr->arrow_base_y;
	XDrawLines(display, drawable, plcItemPtr->arrowGC, xPtsPtr, 2,
		CoordModeOrigin);

	/*
	 * Draw the left side of the arrow head
	 */

	xPtsPtr[1].x = xPtsPtr[0].x + plcItemPtr->arrow_ltip_x;
	xPtsPtr[1].y = xPtsPtr[0].y + plcItemPtr->arrow_ltip_y;
	XDrawLines(display, drawable, plcItemPtr->arrowGC, xPtsPtr, 2,
		CoordModeOrigin);

	/*
	 * Draw the right side of the arrow head
	 */

	xPtsPtr[1].x = xPtsPtr[0].x + plcItemPtr->arrow_rtip_x;
	xPtsPtr[1].y = xPtsPtr[0].y + plcItemPtr->arrow_rtip_y;
	XDrawLines(display, drawable, plcItemPtr->arrowGC, xPtsPtr, 2,
		CoordModeOrigin);
    }
}

/*
 *--------------------------------------------------------------
 *
 * pointProc --
 *
 *	Computes the distance from a given point to a given
 *	geoplace item, in canvas units.
 *
 * Results:
 *	The return value is 0.0 if the point whose x and y coordinates
 *	are coordPtr[0] and coordPtr[1] is inside the geoplace item.  If the
 *	point isn't inside the geoplace item then the return value is the
 *	distance from the point to the geoplace.
 *
 * Side effects:
 *	None.
 *
 *--------------------------------------------------------------
 */

static double
pointProc(canvas, itemPtr, pointPtr)
    Tk_Canvas canvas;			/* Canvas containing item. */
    Tk_Item *itemPtr;			/* Item to check against point. */
    double *pointPtr;			/* Pointer to x and y coordinates. */
{
    PlaceItem *plcItemPtr = (PlaceItem *)itemPtr;
    double x = pointPtr[0], y = pointPtr[1];

    if (plcItemPtr->updateCvs) {
	updateCvs(plcItemPtr);
    }
    return hypot(plcItemPtr->xPlc - x, plcItemPtr->yPlc - y);
}

/*
 *--------------------------------------------------------------
 *
 * areaProc --
 *
 *	This procedure is called to determine whether an item
 *	lies entirely inside, entirely outside, or overlapping
 *	a given rectangle.
 *
 * Results:
 *	-1 is returned if the item is entirely outside the area
 *	given by rectPtr, 0 if it overlaps, and 1 if it is entirely
 *	inside the given area.
 *
 * Side effects:
 *	None.
 *
 *--------------------------------------------------------------
 */

static int
areaProc(canvas, itemPtr, rectPtr)
    Tk_Canvas canvas;		/* Canvas containing item. */
    Tk_Item *itemPtr;		/* Item to check against rectangle. */
    double *rectPtr;		/* Pointer to array of four coordinates
				 * (x1, y1, x2, y2) describing rectangular
				 * area.  */
{
    PlaceItem *plcItemPtr = (PlaceItem *)itemPtr;
    double x1i, y1i, x2i, y2i;	/* Limits of item */
    double x1r, y1r, x2r, y2r;	/* Limits of rectPtr rectangle */

    if (plcItemPtr->updateCvs) {
	updateCvs(plcItemPtr);
    }
    x1i = itemPtr->x1;
    y1i = itemPtr->y1;
    x2i = itemPtr->x2;
    y2i = itemPtr->y2;
    x1r = rectPtr[0];
    y1r = rectPtr[1];
    x2r = rectPtr[2];
    y2r = rectPtr[3];
    if (x1i > x2r || x2i < x1r || y1i > y2r || y2i < y1r) {
	return -1;
    } else if (x1i > x1r && x2i < x2r && y1i > y1r && y2i < y2r) {
	return 1;
    } else {
	return 0;
    }
}

/*
 *--------------------------------------------------------------
 *
 * postscriptProc --
 *
 *	This procedure is called to generate Postscript for
 *	geoplace items.
 *
 * Results:
 *	The return value is a standard Tcl result.  If an error
 *	occurs in generating Postscript then an error message is
 *	left in interp->result, replacing whatever used to be there.
 *	If no error occurs, then Postscript for the item is appended
 *	to the result.
 *
 * Side effects:
 *	None.
 *
 *--------------------------------------------------------------
 */

static int
postscriptProc(interp, canvas, itemPtr, prepass)
    Tcl_Interp *interp;			/* Leave Postscript or error message
					 * here. */
    Tk_Canvas canvas;			/* Information about overall canvas. */
    Tk_Item *itemPtr;			/* Item for which Postscript is
					 * wanted. */
    int prepass;			/* 1 means this is a prepass to
					 * collect font information;  0 means
					 * final Postscript is being created. */
{
    PlaceItem *plcItemPtr;		/* Current geoplace item */
    Tk_Window tkwin = Tk_CanvasTkwin(canvas);
    char bytes[200];			/* Printing space */
    double psX, psY;			/* Postscript coordinates */
    double cnr[8];			/* 4 corner points in canvas coord's */

    plcItemPtr = (PlaceItem *)itemPtr;
    if ( !plcItemPtr->tclGeoPlace ) {
	return TCL_OK;
    } else {
	Tcl_AppendResult(interp, "% Drawing place ",
		Tclgeomap_PlaceName(plcItemPtr->tclGeoPlace), "\n", NULL);
    }
    if (plcItemPtr->updateMap) {
	updateMap(plcItemPtr);
    }
    if (MapPtIsNowhere(plcItemPtr->mapPt)) {
	return TCL_OK;
    }
    if (plcItemPtr->updateCvs) {
	updateCvs(plcItemPtr);
    }
    psX = plcItemPtr->xPlc;
    psY = Tk_CanvasPsY(canvas, plcItemPtr->yPlc);

    /*
     * Create clipping region for item
     */

    Tcl_AppendResult(interp, "%% Create clipping region for item\n", NULL);
    cnr[0] = 0;
    cnr[1] = 0;
    cnr[2] = Tk_Width(tkwin);
    cnr[3] = 0;
    cnr[4] = Tk_Width(tkwin);
    cnr[5] = Tk_Height(tkwin);
    cnr[6] = 0;
    cnr[7] = Tk_Height(tkwin);
    Tk_CanvasPsPath(interp, canvas, cnr, 4);
    Tcl_AppendResult(interp, "closepath clip\n", NULL);

    /*
     * Draw dot.
     */

    if (plcItemPtr->dotSize > 0 && plcItemPtr->dotColor != None) {
	Tk_CanvasPsColor(interp, canvas, plcItemPtr->dotColor);
	sprintf(bytes, "newpath %f %f %f", psX, psY, 0.5 * plcItemPtr->dotSize);
	Tcl_AppendResult(interp, bytes, " 0 360 arc fill\n", NULL);
    }

    /*
     * Draw bitmap.
     */

    if (plcItemPtr->bitmap != None && plcItemPtr->bmColor != None) {
	int bmWidth, bmHeight;

	Tcl_AppendResult(interp, "gsave\n", NULL);
	Tk_CanvasPsColor(interp, canvas, plcItemPtr->bmColor);
	Tk_SizeOfBitmap(Tk_Display(Tk_CanvasTkwin(canvas)),
		plcItemPtr->bitmap, &bmWidth, &bmHeight);
	sprintf(bytes, "%f %f translate\n",
		psX - 0.5 * bmWidth, psY - 0.5 * bmHeight);
	Tcl_AppendResult(interp, bytes, NULL);
	sprintf(bytes, "%d %d scale\n", bmWidth, bmHeight);
	Tcl_AppendResult(interp, bytes, NULL);
	sprintf(bytes, "%d %d true [%d 0 0 %d 0 0]\n",
		bmWidth, bmHeight, bmWidth, bmHeight);
	Tcl_AppendResult(interp, bytes, NULL);
	Tk_CanvasPsBitmap(interp, canvas, plcItemPtr->bitmap,
		0, 0, bmWidth, bmHeight);
	Tcl_AppendResult(interp, " imagemask\ngrestore\n\n", NULL);
    }

    /*
     * Draw text.
     */

    if (plcItemPtr->text && strcmp(plcItemPtr->text, "") != 0
	    && (plcItemPtr->textColor != None) && plcItemPtr->font
	    && plcItemPtr->layout) {
	int xOffset = 0, yOffset = 0;
	Tk_FontMetrics fm;
	double justify = 0.0;

	Tcl_AppendResult(interp, "gsave\n", NULL);
	if (Tk_CanvasPsColor(interp, canvas, plcItemPtr->textColor) != TCL_OK
		|| Tk_CanvasPsFont(interp, canvas, plcItemPtr->font)
		!= TCL_OK) {
	    return TCL_ERROR;
	}
	switch (plcItemPtr->textAnchor) {
	    case TK_ANCHOR_NW    : xOffset = 0;
				   yOffset = 0;
				   justify = 0.0;
				   break;
	    case TK_ANCHOR_N     : xOffset = 1;
				   yOffset = 0;
				   justify = 0.5;
				   break;
	    case TK_ANCHOR_NE    : xOffset = 2;
				   yOffset = 0;
				   justify = 1.0;
				   break;
	    case TK_ANCHOR_E     : xOffset = 2;
				   yOffset = 1;
				   justify = 1.0;
				   break;
	    case TK_ANCHOR_SE    : xOffset = 2;
				   yOffset = 2;
				   justify = 1.0;
				   break;
	    case TK_ANCHOR_S     : xOffset = 1;
				   yOffset = 2;
				   justify = 0.5;
				   break;
	    case TK_ANCHOR_SW    : xOffset = 0;
				   yOffset = 2;
				   justify = 0.0;
				   break;
	    case TK_ANCHOR_W	 : xOffset = 0;
				   yOffset = 1;
				   justify = 0.0;
				   break;
	    case TK_ANCHOR_CENTER: xOffset = 1;
				   yOffset = 1;
				   justify = 0.5;
				   break;
	}
	sprintf(bytes, "%.15g %.15g [\n", psX, psY);
	Tcl_AppendResult(interp, bytes, NULL);
	Tk_TextLayoutToPostscript(interp, plcItemPtr->layout);
	Tk_GetFontMetrics(plcItemPtr->font, &fm);
	sprintf(bytes, "] %d %g %g %g false DrawText\ngrestore\n",
		fm.linespace, xOffset / -2.0, yOffset / 2.0, justify);
	Tcl_AppendResult(interp, bytes, NULL);
    }

    return TCL_OK;
}

/*
 *--------------------------------------------------------------
 *
 * scaleProc --
 *
 *	This function rescales a geoplace item.  It should not be confused
 *	with the "-scale" configuration option, which sets the cartographic
 *	scale of the map containing the item.
 *
 * Results:
 *	None.
 *
 * Side effects:
 * 	The reference point for a geoplace item is moved according to the
 * 	transformation:
 *		xRef' = originX + scaleX*(xRef-originX)
 *		yRef' = originY + scaleY*(yRef-originY)
 *	The geoplace may or may not move.
 *
 *--------------------------------------------------------------
 */

static void
scaleProc(canvas, itemPtr, originX, originY, scaleX, scaleY)
    Tk_Canvas canvas;			/* Canvas containing rectangle. */
    Tk_Item *itemPtr;			/* Rectangle to be scaled. */
    double originX, originY;		/* Origin about which to scale rect. */
    double scaleX;			/* Amount to scale in X direction. */
    double scaleY;			/* Amount to scale in Y direction. */
{
    PlaceItem *plcItemPtr = (PlaceItem *) itemPtr;

    plcItemPtr->xRef = originX + scaleX * (plcItemPtr->xRef - originX);
    plcItemPtr->yRef = originY + scaleY * (plcItemPtr->yRef - originY);
    updateCvs(plcItemPtr);
    return;
}

/*
 *--------------------------------------------------------------
 *
 * translateProc --
 *
 *	This procedure is called to move an item by a given amount.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	The position of the item is offset by (xDelta, yDelta), and
 *	the bounding box is updated in the generic part of the item
 *	structure.
 *
 *--------------------------------------------------------------
 */

static void
translateProc(canvas, itemPtr, deltaX, deltaY)
    Tk_Canvas canvas;			/* Canvas containing item. */
    Tk_Item *itemPtr;			/* Item that is being moved. */
    double deltaX, deltaY;		/* Amount by which item is to be
					 * moved. */
{
    PlaceItem *plcItemPtr = (PlaceItem *) itemPtr;

    plcItemPtr->xRef += deltaX;
    plcItemPtr->yRef += deltaY;
    updateCvs(plcItemPtr);
}

/*
 *------------------------------------------------------------------------
 *
 * parseGeoPlaceOption --
 *
 *	This procedure is invoked during option processing to handle
 *	the "-geoplace" option.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	The state for a given item gets replaced by the state
 *	indicated in the value argument.
 *
 *------------------------------------------------------------------------
 */

static int
parseGeoPlaceOption(clientData, interp, tkwin, value, widgRec, offset)
    ClientData clientData;	/* Not used */
    Tcl_Interp *interp;		/* Current interpreter */
    Tk_Window tkwin;		/* Window containing the geomap item */
    char *value;		/* Value of the option */
    char *widgRec;		/* Pointer to item record */
    int offset;			/* Offset into widgRec */
{
    PlaceItem *plcItemPtr = (PlaceItem *)(widgRec + offset);
    char *plcNm = value;
    Tclgeomap_Place tclGeoPlace;

    if ( strlen(value) > 0 ) {
	/*
	 * User has requested that a geoplace be displayed in the item.
	 */

	tclGeoPlace = Tclgeomap_GetPlace(interp, plcNm);
	if ( !tclGeoPlace ) {
	    Tcl_AppendResult(interp, "No geoplace named ", value, NULL);
	    return TCL_ERROR;
	}
	if ( tclGeoPlace == plcItemPtr->tclGeoPlace ) {
	    return TCL_OK;
	}
	Tclgeomap_CnxPlaceDeleteTask(plcItemPtr->tclGeoPlace, plcItemPtr);
	plcItemPtr->mapPt = MapPtNowhere();
	plcItemPtr->updateMap = 1;
	Tclgeomap_AddPlaceUpdateTask(tclGeoPlace, geoPlaceUpdate, plcItemPtr);
	Tclgeomap_AddPlaceDeleteTask(tclGeoPlace, forgetPlace, plcItemPtr);
	plcItemPtr->tclGeoPlace = tclGeoPlace;
    } else {
	/*
	 * User has requested that NO geoplace be displayed in the item.
	 */

	if ( plcItemPtr->tclGeoPlace ) {
	    Tclgeomap_CnxPlaceUpdateTask(plcItemPtr->tclGeoPlace, plcItemPtr);
	    Tclgeomap_CnxPlaceDeleteTask(plcItemPtr->tclGeoPlace, plcItemPtr);
	    plcItemPtr->mapPt = MapPtNowhere();
	    plcItemPtr->updateMap = 0;
	}
	plcItemPtr->tclGeoPlace = NULL;
    }
    return TCL_OK;
}

/*
 *------------------------------------------------------------------------
 *
 * printGeoPlaceOption --
 *
 *	This procedure is invoked by the Tk configuration code
 *	to produce a printable string for the "-refpoint" configuration
 *	option.
 *
 * Results:
 *	The return value is a string describing the state for
 *	the item referred to by "widgRec".  In addition, *freeProcPtr
 *	is filled in with the address of a procedure to call to free
 *	the result string when it's no longer needed.
 *
 * Side effects:
 * 	None.
 *
 *------------------------------------------------------------------------
 */

static char *
printGeoPlaceOption(clientData, tkwin, widgRec, offset, freeProc)
    ClientData clientData;	/* Not used */
    Tk_Window tkwin;		/* Window containing the geomap item */
    char *widgRec;		/* Pointer to item record */
    int offset;			/* Offset into widgRec */
    Tcl_FreeProc **freeProc;	/* Pointer to variable to fill in with
				 * information about how to reclaim
				 * storage for return string. */
{
    PlaceItem *plcItemPtr = (PlaceItem *)(widgRec + offset);
    CONST char *plcNm;
    char *rtn;

    plcNm = plcItemPtr->tclGeoPlace
	?  Tclgeomap_PlaceName(plcItemPtr->tclGeoPlace)
	: "";
    rtn = Tcl_Alloc(strlen(plcNm) + 1);
    strcpy(rtn, plcNm);
    *freeProc = Tcl_Free;
    return rtn;
}

/*
 *------------------------------------------------------------------------
 *
 * geoplaceUpdate --
 *
 * 	This function redraws a place.  It should be called when a place moves.
 *
 * Results:
 * 	None.
 *
 * Side effects:
 * 	Part of a canvas may be redrawn.
 *
 *------------------------------------------------------------------------
 */

static void
geoPlaceUpdate(clientData)
    ClientData clientData;	/* Item displaying the place */
{
    PlaceItem *plcItemPtr = (PlaceItem *)clientData;
    updateMap(plcItemPtr);
    updateCvs(plcItemPtr);
}

/*
 *------------------------------------------------------------------------
 *
 * parseRefPtOption --
 *
 *	This procedure is invoked during option processing to handle
 *	the "-refpoint" option.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	The state for a given item gets replaced by the state
 *	indicated in the value argument.
 *
 *------------------------------------------------------------------------
 */

static int
parseRefPtOption(clientData, interp, tkwin, value, widgRec, offset)
    ClientData clientData;	/* Not used */
    Tcl_Interp *interp;		/* Current interpreter */
    Tk_Window tkwin;		/* Window containing the geomap item */
    char *value;		/* Value of the option */
    char *widgRec;		/* Pointer to item record */
    int offset;			/* Offset into widgRec */
{

    PlaceItem *plcItemPtr = (PlaceItem *)(widgRec + offset);
    double lat, lon;

    if (sscanf(value, "%lf %lf", &lat, &lon) == 2) {
	plcItemPtr->refPt = GwchLonPt(GeoPtFmDeg(lat, lon));
	plcItemPtr->updateMap = plcItemPtr->updateCvs = 1;
	return TCL_OK;
    } else {
	Tcl_AppendResult(interp, "Expected {lat lon}, got ", value, NULL);
	return TCL_ERROR;
    }
}

/*
 *------------------------------------------------------------------------
 *
 * printRefPtOption --
 *
 *	This procedure is invoked by the Tk configuration code
 *	to produce a printable string for the "-refpoint" configuration
 *	option.
 *
 * Results:
 *	The return value is a string describing the state for
 *	the item referred to by "widgRec".  In addition, *freeProcPtr
 *	is filled in with the address of a procedure to call to free
 *	the result string when it's no longer needed.
 *
 * Side effects:
 * 	None.
 *
 *------------------------------------------------------------------------
 */

static char *
printRefPtOption(clientData, tkwin, widgRec, offset, freeProc)
    ClientData clientData;	/* Not used */
    Tk_Window tkwin;		/* Window containing the geomap item */
    char *widgRec;		/* Pointer to item record */
    int offset;			/* Offset into widgRec */
    Tcl_FreeProc **freeProc;	/* Pointer to variable to fill in with
				 * information about how to reclaim
				 * storage for return string. */
{
    PlaceItem *plcItemPtr = (PlaceItem *)(widgRec + offset);
    char lat[TCL_DOUBLE_SPACE], lon[TCL_DOUBLE_SPACE];
    char *coordPtr[2];
    double dLat, dLon;

    coordPtr[0] = lat;
    coordPtr[1] = lon;
    *freeProc = Tcl_Free;
    GeoPtGetDeg(plcItemPtr->refPt, &dLat, &dLon);
    Tcl_PrintDouble(NULL, dLat, lat);
    Tcl_PrintDouble(NULL, dLon, lon);
    return Tcl_Merge(2, coordPtr);
}

/*
 *------------------------------------------------------------------------
 *
 * parseProjOption --
 *
 *	This procedure is invoked during option processing to handle
 *	the "-projection" option.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	The state for a given item gets replaced by the state
 *	indicated in the value argument.
 *
 *------------------------------------------------------------------------
 */

static int
parseProjOption(clientData, interp, tkwin, value, widgRec, offset)
    ClientData clientData;	/* Not used */
    Tcl_Interp *interp;		/* Current interpreter */
    Tk_Window tkwin;		/* Window containing the geomap item */
    char *value;		/* Value of the option */
    char *widgRec;		/* Pointer to item record */
    int offset;			/* Offset into widgRec */
{
    PlaceItem *plcItemPtr = (PlaceItem *)(widgRec + offset);
    Tclgeomap_Proj proj;

    if ( !value || (strcmp(value, "") == 0) ) {
	if (plcItemPtr->proj) {
	    Tclgeomap_CnxProjUpdateTask(plcItemPtr->proj, plcItemPtr);
	    Tclgeomap_CnxProjDeleteTask(plcItemPtr->proj, plcItemPtr);
	}
	plcItemPtr->proj = NULL;
	return TCL_OK;
    }
    if ( !(proj = Tclgeomap_GetProj(interp, value)) ) {
	Tcl_AppendResult(interp, "No projection named ", value, NULL);
	return TCL_ERROR;
    }
    if (plcItemPtr->proj) {
	Tclgeomap_CnxProjUpdateTask(plcItemPtr->proj, plcItemPtr);
	Tclgeomap_CnxProjDeleteTask(plcItemPtr->proj, plcItemPtr);
    }
    plcItemPtr->proj = proj;
    Tclgeomap_AddProjUpdateTask(plcItemPtr->proj, geoPlaceUpdate, plcItemPtr);
    Tclgeomap_AddProjDeleteTask(plcItemPtr->proj, forgetProj, plcItemPtr);
    plcItemPtr->updateMap = 1;
    return TCL_OK;
}

/*
 *------------------------------------------------------------------------
 *
 * printProjOption --
 *
 *	This procedure is invoked by the Tk configuration code
 *	to produce a printable string for the "-projection" configuration
 *	option.
 *
 * Results:
 *	The return value is a string describing the state for
 *	the item referred to by "widgRec".  In addition, *freeProcPtr
 *	is filled in with the address of a procedure to call to free
 *	the result string when it's no longer needed.
 *
 * Side effects:
 * 	None.
 *
 *------------------------------------------------------------------------
 */

static char *
printProjOption(clientData, tkwin, widgRec, offset, freeProc)
    ClientData clientData;	/* Not used */
    Tk_Window tkwin;		/* Window containing the geomap item */
    char *widgRec;		/* Pointer to item record */
    int offset;			/* Offset into widgRec */
    Tcl_FreeProc **freeProc;	/* Pointer to variable to fill in with
				 * information about how to reclaim
				 * storage for return string. */
{
    PlaceItem *plcItemPtr = (PlaceItem *)(widgRec + offset);
    CONST char *projNm;
    char *rtn;

    projNm = plcItemPtr->proj ? Tclgeomap_ProjName(plcItemPtr->proj) : "";
    rtn = Tcl_Alloc(strlen(projNm) + 1);
    strcpy(rtn, projNm);
    *freeProc = Tcl_Free;
    return rtn;
}

/*
 *--------------------------------------------------------------
 *
 * computeTextLayout --
 *
 * 	This procedure computes the text layout for a geoplace item.
 *
 * Results:
 * 	The text related fields in a geoplace item pointer are updated.
 * Side effects:
 * 	None.
 *
 *--------------------------------------------------------------
 */

static void
computeTextLayout(plcItemPtr)
    PlaceItem *plcItemPtr;		/* Geoplace item */
{
    int txtWidth, txtHeight;
    Tk_TextLayout layout = NULL;

    if ( !plcItemPtr ) {
	return;
    }
    if (plcItemPtr->layout) {
	Tk_FreeTextLayout(plcItemPtr->layout);
    }
    if ( !plcItemPtr->text || !plcItemPtr->font ) {
	plcItemPtr->layout = NULL;
	return;
    }
    switch (plcItemPtr->textAnchor) {
	case TK_ANCHOR_N:
	    layout = Tk_ComputeTextLayout(plcItemPtr->font, plcItemPtr->text,
		    -1, -1, TK_JUSTIFY_CENTER, 0, &txtWidth, &txtHeight);
	    plcItemPtr->xTxt = -txtWidth / 2;
	    plcItemPtr->yTxt = 0;
	    break;
	case TK_ANCHOR_NE:
	    layout = Tk_ComputeTextLayout(plcItemPtr->font, plcItemPtr->text,
		    -1, -1, TK_JUSTIFY_RIGHT, 0, &txtWidth, &txtHeight);
	    plcItemPtr->xTxt = -txtWidth;
	    plcItemPtr->yTxt = 0;
	    break;
	case TK_ANCHOR_E:
	    layout = Tk_ComputeTextLayout(plcItemPtr->font, plcItemPtr->text,
		    -1, -1, TK_JUSTIFY_RIGHT, 0, &txtWidth, &txtHeight);
	    plcItemPtr->xTxt = -txtWidth;
	    plcItemPtr->yTxt = -txtHeight / 2;
	    break;
	case TK_ANCHOR_SE:
	    layout = Tk_ComputeTextLayout(plcItemPtr->font, plcItemPtr->text,
		    -1, -1, TK_JUSTIFY_RIGHT, 0, &txtWidth, &txtHeight);
	    plcItemPtr->xTxt = -txtWidth;
	    plcItemPtr->yTxt = -txtHeight;
	    break;
	case TK_ANCHOR_S:
	    layout = Tk_ComputeTextLayout(plcItemPtr->font, plcItemPtr->text,
		    -1, -1, TK_JUSTIFY_CENTER, 0, &txtWidth, &txtHeight);
	    plcItemPtr->xTxt = -txtWidth / 2;
	    plcItemPtr->yTxt = -txtHeight;
	    break;
	case TK_ANCHOR_SW:
	    layout = Tk_ComputeTextLayout(plcItemPtr->font, plcItemPtr->text,
		    -1, -1, TK_JUSTIFY_LEFT, 0, &txtWidth, &txtHeight);
	    plcItemPtr->xTxt = 0;
	    plcItemPtr->yTxt = -txtHeight;
	    break;
	case TK_ANCHOR_W:
	    layout = Tk_ComputeTextLayout(plcItemPtr->font, plcItemPtr->text,
		    -1, -1, TK_JUSTIFY_LEFT, 0, &txtWidth, &txtHeight);
	    plcItemPtr->xTxt = 0;
	    plcItemPtr->yTxt = -txtHeight / 2;
	    break;
	case TK_ANCHOR_NW:
	    layout = Tk_ComputeTextLayout(plcItemPtr->font, plcItemPtr->text,
		    -1, -1, TK_JUSTIFY_LEFT, 0, &txtWidth, &txtHeight);
	    plcItemPtr->xTxt = 0;
	    plcItemPtr->yTxt = 0;
	    break;
	case TK_ANCHOR_CENTER:
	    layout = Tk_ComputeTextLayout(plcItemPtr->font, plcItemPtr->text,
		    -1, -1, TK_JUSTIFY_CENTER, 0, &txtWidth, &txtHeight);
	    plcItemPtr->xTxt = -txtWidth / 2;
	    plcItemPtr->yTxt = -txtHeight / 2;
	    break;
    }
    plcItemPtr->layout = layout;
    plcItemPtr->txtWidth = txtWidth;
    plcItemPtr->txtHeight = txtHeight;
}

/*
 *------------------------------------------------------------------------
 *
 * parseArrowOption --
 *
 *	This procedure is invoked during option processing to handle
 *	the "-arrow" option.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	The state for a given item gets replaced by the state
 *	indicated in the value argument.
 *
 *------------------------------------------------------------------------
 */

static int
parseArrowOption(clientData, interp, tkwin, value, widgRec, offset)
    ClientData clientData;	/* Not used */
    Tcl_Interp *interp;		/* Current interpreter */
    Tk_Window tkwin;		/* Window containing the geomap item */
    char *value;		/* Value of the option */
    char *widgRec;		/* Pointer to item record */
    int offset;			/* Offset into widgRec */
{
    PlaceItem *plcItemPtr = (PlaceItem *)(widgRec + offset);
    double az, len, tip_sz;

    if (sscanf(value, "%lf %lf %lf", &az, &len, &tip_sz) == 3) {
	plcItemPtr->arrow_az = AngleFmDeg(az);
	plcItemPtr->arrow_len = len;
	plcItemPtr->arrow_tip_sz = tip_sz;
	plcItemPtr->updateMap = 1;
	return TCL_OK;
    } else {
	Tcl_AppendResult(interp, "Arrow should be specified as "
		"{azimuth length tip_size}", NULL);
	return TCL_ERROR;
    }
}

/*
 *------------------------------------------------------------------------
 *
 * printArrowOption --
 *
 *	This procedure is invoked by the Tk configuration code
 *	to produce a printable string for the "-arrow" configuration
 *	option.
 *
 * Results:
 *	The return value is a string describing the state for
 *	the item referred to by "widgRec".  In addition, *freeProcPtr
 *	is filled in with the address of a procedure to call to free
 *	the result string when it's no longer needed.
 *
 * Side effects:
 * 	None.
 *
 *------------------------------------------------------------------------
 */

static char *
printArrowOption(clientData, tkwin, widgRec, offset, freeProc)
    ClientData clientData;	/* Not used */
    Tk_Window tkwin;		/* Window containing the geomap item */
    char *widgRec;		/* Pointer to item record */
    int offset;			/* Offset into widgRec */
    Tcl_FreeProc **freeProc;	/* Pointer to variable to fill in with
				 * information about how to reclaim
				 * storage for return string. */
{
    PlaceItem *plcItemPtr = (PlaceItem *)(widgRec + offset);
    char az[TCL_DOUBLE_SPACE], len[TCL_INTEGER_SPACE], tip_sz[TCL_DOUBLE_SPACE];
    char *coordPtr[3];

    coordPtr[0] = az;
    coordPtr[1] = len;
    coordPtr[2] = tip_sz;
    *freeProc = Tcl_Free;
    Tcl_PrintDouble(NULL, AngleToDeg(plcItemPtr->arrow_az), az);
    sprintf(len, "%lf", plcItemPtr->arrow_len);
    Tcl_PrintDouble(NULL, plcItemPtr->arrow_tip_sz, tip_sz);
    return Tcl_Merge(3, coordPtr);
}

/*
 *------------------------------------------------------------------------
 *
 * updateMap --
 *
 * 	This procedure updates the mapPt member of a PlaceItem.
 *
 * Results:
 *	None.
 * Side effects:
 * 	Members in item record that depend on projection are updated.
 *
 *------------------------------------------------------------------------
 */

static void
updateMap(clientData)
    ClientData clientData;	/* Geoplace item in need of update */
{
    PlaceItem *plcItemPtr = (PlaceItem *)clientData;
    Tclgeomap_Place geoPlace = plcItemPtr->tclGeoPlace;
    GeoProj proj = (GeoProj)plcItemPtr->proj;
    GeoPt geoPt;
    MapPt mapPt, step2;

    if ( !geoPlace || !proj ) {
	plcItemPtr->mapPt = MapPtNowhere();
	plcItemPtr->updateMap = 0;
	hide(plcItemPtr);
	return;
    }

    /*
     * Compute the new map coordinates of the place.
     */

    plcItemPtr->mRefPt = LatLonToProj(plcItemPtr->refPt, proj);
    geoPt = Tclgeomap_PlaceLoc(geoPlace);
    mapPt = plcItemPtr->mapPt = LatLonToProj(geoPt, proj);

    /*
     * If necessary, figure out which way the arrow should be pointing on
     * the map.
     */

    if (plcItemPtr->arrow_len != 0 && plcItemPtr->arrowColor != None) {
	double arrow_len = plcItemPtr->arrow_len;
	double d_abs, d_ord, hypot;
	double sin_theta, cos_theta;
	double sin_alpha = sin(TKGEOMAP_PLACE_TIP_ANG * M_PI / 180.0);
	double cos_alpha = cos(TKGEOMAP_PLACE_TIP_ANG * M_PI / 180.0);
	double t = plcItemPtr->arrow_len * plcItemPtr->arrow_tip_sz;
	double cos_cos, cos_sin, sin_cos, sin_sin;

	step2 = LatLonToProj(GeoStep(geoPt, plcItemPtr->arrow_az,
		    AngleFmDeg(0.25)), proj);
	d_abs = step2.abs - mapPt.abs;
	d_ord = step2.ord - mapPt.ord;
	hypot = sqrt(d_abs * d_abs + d_ord * d_ord);
	cos_theta = d_abs / hypot;
	sin_theta = d_ord / hypot;
	cos_cos = cos_theta * cos_alpha;
	sin_sin = sin_theta * sin_alpha;
	sin_cos = sin_theta * cos_alpha;
	cos_sin = cos_theta * sin_alpha;
	plcItemPtr->arrow_base_x = -ceil(0.5 * arrow_len * cos_theta);
	plcItemPtr->arrow_base_y = ceil(0.5 * arrow_len * sin_theta);
	plcItemPtr->arrow_head_x = ceil(0.5 * arrow_len * cos_theta);
	plcItemPtr->arrow_head_y = -ceil(0.5 * arrow_len * sin_theta);
	plcItemPtr->arrow_ltip_x = - ceil(t * (cos_cos + sin_sin));
	plcItemPtr->arrow_ltip_y = ceil(t * (sin_cos - cos_sin));
	plcItemPtr->arrow_rtip_x = - ceil(t * (cos_cos - sin_sin));
	plcItemPtr->arrow_rtip_y = ceil(t * (sin_cos + cos_sin));
    }

    plcItemPtr->updateMap = 0;
    plcItemPtr->updateCvs = 1;
}

/*
 *------------------------------------------------------------------------
 *
 * updateCvs --
 *
 * 	This procedure updates the mapLnArr member of a geoplace item.
 *
 * Results:
 *	None.
 *
 * Side effects:
 * 	The coords member and bounding box of the geoplace item are updated.
 *
 *------------------------------------------------------------------------
 */

static void
updateCvs(plcItemPtr)
    PlaceItem *plcItemPtr;	/* Geoplace item to update */
{
    Tk_Canvas canvas;		/* Canvas in which to render the item */
    Tk_Window tkwin;		/* Window with canvas */
    double cvsPerM;		/* Points per meter on canvas */
    double cvsPerMapM;		/* Points per meter on projection plane */
    int x1_, x2_, y1_, y2_;	/* Boundary limits for parts of the item */
    int x1, x2, y1, y2;

    canvas = plcItemPtr->canvas;
    tkwin = Tk_CanvasTkwin(canvas);
    Tk_CanvasEventuallyRedraw(plcItemPtr->canvas,
	    plcItemPtr->header.x1, plcItemPtr->header.y1,
	    plcItemPtr->header.x2, plcItemPtr->header.y2);
    if ( !plcItemPtr->tclGeoPlace || !plcItemPtr->proj ) {
	plcItemPtr->mapPt = MapPtNowhere();
	plcItemPtr->updateMap = 0;
	hide(plcItemPtr);
	return;
    }
    if (       ( !plcItemPtr->dotColor || plcItemPtr->dotSize <= 0)
	    && ( !plcItemPtr->bmColor || !plcItemPtr->bitmap)
	    && ( !plcItemPtr->textColor || !plcItemPtr->text) ) {
	hide(plcItemPtr);
	return;
    }
    if (plcItemPtr->updateMap) {
	updateMap(plcItemPtr);
    }
    if (MapPtIsNowhere(plcItemPtr->mapPt)) {
	hide(plcItemPtr);
	return;
    }
    Tk_CanvasGetCoord(NULL, canvas, "100.0c", &cvsPerM);
    cvsPerMapM = cvsPerM * plcItemPtr->scale;
    plcItemPtr->xPlc = plcItemPtr->xRef
	+ (plcItemPtr->mapPt.abs - plcItemPtr->mRefPt.abs) * cvsPerMapM;
    plcItemPtr->yPlc = plcItemPtr->yRef
	- (plcItemPtr->mapPt.ord - plcItemPtr->mRefPt.ord) * cvsPerMapM;

    /*
     * Recompute bounding box
     */

    x1 = plcItemPtr->xPlc - (plcItemPtr->dotSize + 1) / 2 - 1;
    x2 = plcItemPtr->xPlc + (plcItemPtr->dotSize + 1) / 2 + 1;
    y1 = plcItemPtr->yPlc - (plcItemPtr->dotSize + 1) / 2 - 1;
    y2 = plcItemPtr->yPlc + (plcItemPtr->dotSize + 1) / 2 + 1;
    if ( (plcItemPtr->bitmap != None) && (plcItemPtr->bmColor != None) ) {
	int w, h;

	Tk_SizeOfBitmap(Tk_Display(tkwin), plcItemPtr->bitmap, &w, &h);
	x1_ = floor(plcItemPtr->xPlc - w / 2) - 1;
	x2_ = ceil(plcItemPtr->xPlc + w / 2) + 1;
	y1_ = floor(plcItemPtr->yPlc - h / 2) - 1;
	y2_ = ceil(plcItemPtr->yPlc + h / 2) + 1;

	x1 = (x1 < x1_) ? x1 : x1_;
	x2 = (x2 > x2_) ? x2 : x2_;
	y1 = (y1 < y1_) ? y1 : y1_;
	y2 = (y2 > y2_) ? y2 : y2_;
    }
    if (plcItemPtr->text && (plcItemPtr->textColor != None)
	    && plcItemPtr->layout ) {

	x1_ = plcItemPtr->xPlc + plcItemPtr->xTxt;
	x2_ = x1_ + plcItemPtr->txtWidth;
	y1_ = plcItemPtr->yPlc + plcItemPtr->yTxt;
	y2_ = y1_ + plcItemPtr->txtHeight;

	x1 = (x1 < x1_) ? x1 : x1_;
	x2 = (x2 > x2_) ? x2 : x2_;
	y1 = (y1 < y1_) ? y1 : y1_;
	y2 = (y2 > y2_) ? y2 : y2_;
    }
    if (plcItemPtr->arrow_len != 0) {
	int t = ceil(plcItemPtr->arrow_len * plcItemPtr->arrow_tip_sz);
	int arrow_len = plcItemPtr->arrow_len;
	x1_ = plcItemPtr->xPlc - (arrow_len + 1) / 2 - t - 1;
	x2_ = plcItemPtr->xPlc + (arrow_len + 1) / 2 + t + 1;
	y1_ = plcItemPtr->yPlc - (arrow_len + 1) / 2 - t - 1;
	y2_ = plcItemPtr->yPlc + (arrow_len + 1) / 2 + t + 1;

	x1 = (x1 < x1_) ? x1 : x1_;
	x2 = (x2 > x2_) ? x2 : x2_;
	y1 = (y1 < y1_) ? y1 : y1_;
	y2 = (y2 > y2_) ? y2 : y2_;
    }
    if ( x1 >= x2 || y1 >= y2 ) {
	hide(plcItemPtr);
	return;
    }
    plcItemPtr->header.x1 = x1;
    plcItemPtr->header.x2 = x2;
    plcItemPtr->header.y1 = y1;
    plcItemPtr->header.y2 = y2;
    Tk_CanvasEventuallyRedraw(plcItemPtr->canvas,
	    plcItemPtr->header.x1, plcItemPtr->header.y1,
	    plcItemPtr->header.x2, plcItemPtr->header.y2);

    plcItemPtr->updateCvs = 0;
}