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

/*
 * tkgeomapLnArr.c --
 *
 * 	This file defines functions that display geolinearrays 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: tkgeomapLnArr.c,v 1.20 2009/10/23 20:37:25 tkgeomap Exp $
 *
 **********************************************************************
 *
 */

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

/*
 * This structure stores one geomap_lnarr 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 */
    GeoPt refPt;		/* Geographic coordinates of reference point */
    Tclgeomap_Proj proj;	/* Cartographic projection */
    double scale;		/* Cartographic scale (pure number ratio) */
    Tclgeomap_LnArr tclGeoLnArr;/* Geolinearray the item displays */
    int nLines;			/* Number of lines to draw */
    int nMax;			/* Number of points in longest line */
    MapLnArr mapLnArr;		/* Array of map coordinates for the lines */
    double **coordPtrPtr;	/* Array of canvas coordinates corresponding to
				 * the points in the map.  Dimensions are
				 * [nLines][num pts in line] */
    int *nPtsPtr;		/* Number of points in each line of
				 * coordPtrPtr.  Dimension is [num lines] */
    int	updateMap;		/* If true, mapLnArr is out of date */
    int updateCvs;		/* If true, coordPtrPtr is out of date */
    int width;			/* Line width */
    XColor *lineColor;		/* Outline color */
    int lineStyle;		/* LineSolid, LineOnOffDash, or
				 * LineDoubleDash */
    int dashes;			/* Dash length */
    GC lineGC;			/* Graphics context for drawing outline */
    int smooth;			/* If true, smooth the line.  Currently
    				 * smoothing is done only with Tk's bezier
				 * function */
    int splineSteps;		/* Number of steps in each spline segment */
    XColor *fillColor;		/* Color to fill shapes */
    Pixmap stipple;		/* Stipple pattern to fill shapes */
    int shape;			/* Complex, Convex, or Nonconvex */
    GC fillGC;			/* Graphics context for filling */
    int dotSize;		/* Dot size at segment ends */
} LnArrItem;

/*
 * 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		forgetLnArr _ANSI_ARGS_((ClientData clientData));
static void		forgetProj _ANSI_ARGS_((ClientData clientData));
static void		hide _ANSI_ARGS_((LnArrItem *lnArrItemPtr));
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		parseGeoLnArrOption _ANSI_ARGS_((ClientData clientData,
				Tcl_Interp *interp, Tk_Window tkwin,
				char *value, char *widgRec, int offset));
static char *		printGeoLnArrOption _ANSI_ARGS_((ClientData clientData,
				Tk_Window tkwin, char *widgRec, int offset,
				Tcl_FreeProc **freeProcPtr));
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		parseLineStyleOption _ANSI_ARGS_((ClientData clientData,
				Tcl_Interp *interp, Tk_Window tkwin,
				char *value, char *widgRec, int offset));
static char *		printLineStyleOption _ANSI_ARGS_((ClientData clientData,
				Tk_Window tkwin, char *widgRec, int offset,
				Tcl_FreeProc **freeProcPtr));
static int		parseShapeOption _ANSI_ARGS_((ClientData clientData,
				Tcl_Interp *interp, Tk_Window tkwin,
				char *value, char *widgRec, int offset));
static char *		printShapeOption _ANSI_ARGS_((ClientData clientData,
				Tk_Window tkwin, char *widgRec, int offset,
				Tcl_FreeProc **freeProcPtr));
static void		updateMap _ANSI_ARGS_((ClientData clientData));
static void		updateCvs _ANSI_ARGS_((ClientData clientData));

/*
 * Custom configuration options
 */

static Tk_CustomOption geoLnArrOption = {
    parseGeoLnArrOption,
    printGeoLnArrOption,
    NULL
};

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

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

static Tk_CustomOption shapeOption = {
    parseShapeOption,
    printShapeOption,
    NULL
};

static Tk_CustomOption lineStyleOption = {
    parseLineStyleOption,
    printLineStyleOption,
    NULL
};

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

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

/*
 * Configuration options for the geomap_lnarr item
 */

static Tk_ConfigSpec configSpecs[] = {
    {TK_CONFIG_CUSTOM, "-lnarr", NULL, NULL, "", 0, TK_CONFIG_NULL_OK,
	&geoLnArrOption},
    {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(LnArrItem, scale), 0, NULL},
    {TK_CONFIG_COLOR, "-outline", NULL, NULL, "NavyBlue",
	Tk_Offset(LnArrItem, lineColor), TK_CONFIG_NULL_OK, NULL},
    {TK_CONFIG_PIXELS, "-width", NULL, NULL, "1",
	Tk_Offset(LnArrItem, width), 0, NULL},
    {TK_CONFIG_CUSTOM, "-linestyle", NULL, NULL, "LineSolid",
	0, 0, &lineStyleOption},
    {TK_CONFIG_INT, "-dashes", NULL, NULL, "4",
	Tk_Offset(LnArrItem, dashes), 0, NULL},
    {TK_CONFIG_BOOLEAN, "-smooth", NULL, NULL, "0",
	Tk_Offset(LnArrItem, smooth), 0, NULL},
    {TK_CONFIG_INT, "-splinesteps", NULL, NULL, "12",
	Tk_Offset(LnArrItem, splineSteps), 0, NULL},
    {TK_CONFIG_COLOR, "-fill", NULL, NULL, "",
	Tk_Offset(LnArrItem, fillColor), TK_CONFIG_NULL_OK, NULL},
    {TK_CONFIG_BITMAP, "-stipple", NULL, NULL, NULL,
	Tk_Offset(LnArrItem, stipple), TK_CONFIG_NULL_OK, NULL},
    {TK_CONFIG_CUSTOM, "-shape", "shape", "Shape", "Complex", 0, 0,
	&shapeOption},
    {TK_CONFIG_PIXELS, "-dotsize", NULL, NULL, "0",
	Tk_Offset(LnArrItem, dotSize), 0, 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 geomap_lnarr item type in terms of
 * procedures that can be invoked by generic item code.
 */

static Tk_ItemType geoLnArrType = {
    "geomap_lnarr",			/* item type name */
    sizeof(LnArrItem),			/* itemSize */
    createProc,				/* createProc */
    configSpecs,			/* configSpecs */
    configProc,				/* configureProc */
    coordProc,				/* coordProc */
    deleteProc,				/* deleteProc */
    displayProc,			/* displayProc */
    TK_CONFIG_OBJS,			/* alwaysredraw or flags (?) */
    pointProc,				/* pointProc */
    areaProc,				/* areaProc */
    postscriptProc,	                /* postscriptProc */
    scaleProc,				/* scaleProc */
    translateProc,			/* translateProc */
    (Tk_ItemIndexProc *) NULL,		/* indexProc */
    (Tk_ItemCursorProc *) NULL,		/* icursorProc */
    (Tk_ItemSelectionProc *) NULL,	/* selectionProc */
    (Tk_ItemInsertProc *) NULL,		/* insertProc */
    (Tk_ItemDCharsProc *) NULL,		/* dTextProc */
    (Tk_ItemType *) NULL,		/* nextPtr */
};

/*
 *------------------------------------------------------------------------
 *
 * TkgeomapLnArrInit --
 *
 *	This procedure adds the geomap_lnarr 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 "geomap_lnarr" item is
 * 	added to the Tk canvas interface.
 *
 *------------------------------------------------------------------------
 */

int
TkgeomapLnArrInit(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(&geoLnArrType);
    loaded = 1;
    return TCL_OK;
}

/*
 *--------------------------------------------------------------
 *
 * createProc --
 *
 *	This procedure is invoked to create a new geomap_lnarr
 *	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 geomap_lnarr 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 linearray. */
{
    LnArrItem *lnArrItemPtr = (LnArrItem *)itemPtr;
    double xRef, yRef;


    /*
     * Set location of reference point from 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;
    }
    lnArrItemPtr->xRef = xRef;
    lnArrItemPtr->yRef = yRef;

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

    lnArrItemPtr->interp = interp;
    lnArrItemPtr->canvas = canvas;
    lnArrItemPtr->refPt = GeoPtFmDeg(0.0, 0.0);
    lnArrItemPtr->proj = NULL;
    lnArrItemPtr->scale = 0.0;
    lnArrItemPtr->tclGeoLnArr = NULL;
    lnArrItemPtr->nLines = 0;
    lnArrItemPtr->mapLnArr = NULL;
    lnArrItemPtr->coordPtrPtr = NULL;
    lnArrItemPtr->nPtsPtr = NULL;
    lnArrItemPtr->updateMap = 1;
    lnArrItemPtr->updateCvs = 1;
    lnArrItemPtr->width = 0;
    lnArrItemPtr->lineColor = None;
    lnArrItemPtr->lineStyle = LineSolid;
    lnArrItemPtr->dashes = 4;
    lnArrItemPtr->lineGC = None;
    lnArrItemPtr->fillColor = None;
    lnArrItemPtr->stipple = None;
    lnArrItemPtr->shape = Nonconvex;
    lnArrItemPtr->fillGC = None;
    lnArrItemPtr->dotSize = 0;

    /*
     * Configure the new geomap_lnarr 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;
}

/*
 *------------------------------------------------------------------------
 *
 * parseGeoLnArrOption --
 *
 *	This procedure is invoked during option processing to handle
 *	the "-lnarr" 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
parseGeoLnArrOption(clientData, interp, tkwin, value, widgRec, offset)
    ClientData clientData;	/* Not used */
    Tcl_Interp *interp;		/* Current interpreter */
    Tk_Window tkwin;		/* Window containing the geomap_lnarr item */
    char *value;		/* Value of the option */
    char *widgRec;		/* Pointer to item record */
    int offset;			/* Offset into widgRec */
{
    LnArrItem *lnArrItemPtr = (LnArrItem *)(widgRec + offset);
    char *arrNm = value;
    Tclgeomap_LnArr tclGeoLnArr;
    int n;

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

	tclGeoLnArr = Tclgeomap_GetLnArr(interp, arrNm);
	if ( !tclGeoLnArr ) {
	    Tcl_AppendResult(interp, "No linearray named ", value, NULL);
	    return TCL_ERROR;
	}
	if ( tclGeoLnArr == lnArrItemPtr->tclGeoLnArr ) {
	    return TCL_OK;
	}
	if (lnArrItemPtr->tclGeoLnArr) {
	    Tclgeomap_CnxLnArrDeleteTask(lnArrItemPtr->tclGeoLnArr,
		    lnArrItemPtr);
	}
	MapLnArrDestroy(lnArrItemPtr->mapLnArr);
	lnArrItemPtr->mapLnArr = NULL;
	lnArrItemPtr->updateMap = 1;
	for (n = 0; n < lnArrItemPtr->nLines; n++) {
	    CKFREE((char *)lnArrItemPtr->coordPtrPtr[n]);
	    lnArrItemPtr->coordPtrPtr[n] = NULL;
	}
	lnArrItemPtr->tclGeoLnArr = tclGeoLnArr;
	Tclgeomap_AddLnArrDeleteTask(tclGeoLnArr, forgetLnArr, lnArrItemPtr);
	lnArrItemPtr->nLines = 0;
    } else {
	/*
	 * User has requested that NO linearray be displayed in the item.
	 */

	if (lnArrItemPtr->tclGeoLnArr) {
	    Tclgeomap_CnxLnArrDeleteTask(lnArrItemPtr->tclGeoLnArr,
		    lnArrItemPtr);
	    for (n = 0; n < lnArrItemPtr->nLines; n++) {
		CKFREE((char *)lnArrItemPtr->coordPtrPtr[n]);
		lnArrItemPtr->coordPtrPtr[n] = NULL;
	    }
	    lnArrItemPtr->tclGeoLnArr = NULL;
	    MapLnArrDestroy(lnArrItemPtr->mapLnArr);
	    lnArrItemPtr->mapLnArr = NULL;
	    lnArrItemPtr->updateMap = 0;
	    lnArrItemPtr->nLines = 0;
	}
    }
    return TCL_OK;
}

/*
 *------------------------------------------------------------------------
 *
 * printGeoLnArrOption --
 *
 *	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 *
printGeoLnArrOption(clientData, tkwin, widgRec, offset, freeProc)
    ClientData clientData;	/* Not used */
    Tk_Window tkwin;		/* Window containing the geomap_lnarr 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. */
{
    LnArrItem *lnArrItemPtr = (LnArrItem *)(widgRec + offset);
    CONST char *arrNm;
    char *rtn;

    arrNm = lnArrItemPtr->tclGeoLnArr
	?  Tclgeomap_LnArrName(lnArrItemPtr->tclGeoLnArr)
	: "";
    rtn = Tcl_Alloc(strlen(arrNm) + 1);
    strcpy(rtn, arrNm);
    *freeProc = Tcl_Free;
    return rtn;
}

/*
 *------------------------------------------------------------------------
 *
 * 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_lnarr item */
    char *value;		/* Value of the option */
    char *widgRec;		/* Pointer to item record */
    int offset;			/* Offset into widgRec */
{

    LnArrItem *lnArrItemPtr = (LnArrItem *)(widgRec + offset);
    GeoPt refPt;
    double lat, lon;

    if (sscanf(value, "%lf %lf", &lat, &lon) == 2) {
	refPt = GeoPtFmDeg(lat, lon);
	lnArrItemPtr->refPt = GwchLonPt(refPt);
	lnArrItemPtr->updateMap = lnArrItemPtr->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_lnarr 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. */
{
    LnArrItem *lnArrItemPtr = (LnArrItem *)(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(lnArrItemPtr->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 linearray item */
    char *value;		/* Value of the option */
    char *widgRec;		/* Pointer to item record */
    int offset;			/* Offset into widgRec */
{
    LnArrItem *lnArrItemPtr = (LnArrItem *)(widgRec + offset);
    Tclgeomap_Proj proj;

    if (*value == '\0') {
	if (lnArrItemPtr->proj) {
	    Tclgeomap_CnxProjUpdateTask(lnArrItemPtr->proj, lnArrItemPtr);
	    Tclgeomap_CnxProjDeleteTask(lnArrItemPtr->proj, lnArrItemPtr);
	}
	lnArrItemPtr->proj = NULL;
	return TCL_OK;
    }
    if ( !(proj = Tclgeomap_GetProj(interp, value)) ) {
	Tcl_AppendResult(interp, "No projection named ", value, NULL);
	return TCL_ERROR;
    }
    if (lnArrItemPtr->proj) {
	Tclgeomap_CnxProjUpdateTask(lnArrItemPtr->proj, lnArrItemPtr);
	Tclgeomap_CnxProjDeleteTask(lnArrItemPtr->proj, lnArrItemPtr);
    }
    lnArrItemPtr->proj = proj;
    Tclgeomap_AddProjUpdateTask(lnArrItemPtr->proj, updateMap, lnArrItemPtr);
    Tclgeomap_AddProjDeleteTask(lnArrItemPtr->proj, forgetProj, lnArrItemPtr);
    lnArrItemPtr->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. */
{
    LnArrItem *lnArrItemPtr = (LnArrItem *)(widgRec + offset);
    CONST char *projNm;
    char *rtn;

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

/*
 *------------------------------------------------------------------------
 *
 * parseShapeOption --
 *
 *	This procedure is invoked during option processing to handle
 *	the "-shape" 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
parseShapeOption(clientData, interp, tkwin, value, widgRec, offset)
    ClientData clientData;	/* Not used */
    Tcl_Interp *interp;		/* Current interpreter */
    Tk_Window tkwin;		/* Window containing the geomap_lnarr item */
    char *value;		/* Value of the option */
    char *widgRec;		/* Pointer to item record */
    int offset;			/* Offset into widgRec */
{
    LnArrItem *lnArrItemPtr = (LnArrItem *)(widgRec + offset);

    if (strcmp(value, "Convex") == 0) {
	lnArrItemPtr->shape = Convex;
    } else if (strcmp(value, "Nonconvex") == 0) {
	lnArrItemPtr->shape = Nonconvex;
    } else if (strcmp(value, "Complex") == 0) {
	lnArrItemPtr->shape = Complex;
    } else {
	Tcl_AppendResult(interp,
		"Shape must be \"Convex\", \"Nonconvex\" or \"Complex\"", NULL);
	return TCL_ERROR;
    }
    return TCL_OK;
}

/*
 *------------------------------------------------------------------------
 *
 * printShapeOption --
 *
 *	This procedure is invoked by the Tk configuration code
 *	to produce a printable string for the "-shape" 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 *
printShapeOption(clientData, tkwin, widgRec, offset, freeProc)
    ClientData clientData;	/* Not used */
    Tk_Window tkwin;		/* Window containing the geomap_lnarr item */
    char *widgRec;		/* Pointer to item record */
    int offset;			/* Offset into widgRec */
    Tcl_FreeProc **freeProc;	/* Not used */
{
    LnArrItem *lnArrItemPtr = (LnArrItem *)(widgRec + offset);
    char *rslt = "Convex";

    switch (lnArrItemPtr->shape) {
	case Convex:
	    rslt = "Convex";
	    break;
	case Nonconvex:
	    rslt = "Nonconvex";
	    break;
	case Complex:
	    rslt = "Complex";
	    break;
    }
    return rslt;
}

/*
 *------------------------------------------------------------------------
 *
 * parseLineStyleOption --
 *
 *	This procedure is invoked during option processing to handle
 *	the "-linestyle" 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
parseLineStyleOption(clientData, interp, tkwin, value, widgRec, offset)
    ClientData clientData;	/* Not used */
    Tcl_Interp *interp;		/* Current interpreter */
    Tk_Window tkwin;		/* Window containing the geomap_lnarr item */
    char *value;		/* Value of the option */
    char *widgRec;		/* Pointer to item record */
    int offset;			/* Offset into widgRec */
{
    LnArrItem *lnArrItemPtr = (LnArrItem *)(widgRec + offset);

    if (strcmp(value, "LineSolid") == 0) {
	lnArrItemPtr->lineStyle = LineSolid;
    } else if (strcmp(value, "LineOnOffDash") == 0) {
	lnArrItemPtr->lineStyle = LineOnOffDash;
    } else if (strcmp(value, "LineDoubleDash") == 0) {
	lnArrItemPtr->lineStyle = LineDoubleDash;
    } else {
	Tcl_AppendResult(interp,
		"LineStyle must be \"LineSolid\", \"LineOnOffDash\" or"
		" \"LineDoubleDash\"", NULL);
	return TCL_ERROR;
    }
    return TCL_OK;
}

/*
 *------------------------------------------------------------------------
 *
 * printLineStyleOption --
 *
 *	This procedure is invoked by the Tk configuration code
 *	to produce a printable string for the "-linestyle" 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 *
printLineStyleOption(clientData, tkwin, widgRec, offset, freeProc)
    ClientData clientData;	/* Not used */
    Tk_Window tkwin;		/* Window containing the geomap_lnarr item */
    char *widgRec;		/* Pointer to item record */
    int offset;			/* Offset into widgRec */
    Tcl_FreeProc **freeProc;	/* Not used */
{
    LnArrItem *lnArrItemPtr = (LnArrItem *)(widgRec + offset);
    char *rslt = "Convex";

    switch (lnArrItemPtr->lineStyle) {
	case LineSolid:
	    rslt = "LineSolid";
	    break;
	case LineOnOffDash:
	    rslt = "LineOnOffDash";
	    break;
	case LineDoubleDash:
	    rslt = "LineDoubleDash";
	    break;
    }
    return rslt;
}

/*
 *--------------------------------------------------------------
 *
 * configProc --
 *
 *	This procedure is invoked to configure various aspects
 *	of a geomap_lnarr 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;		/* Geolinearray 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. */
{
    LnArrItem *lnArrItemPtr = (LnArrItem *)itemPtr;
    Tk_Window tkwin = Tk_CanvasTkwin(canvas);
    unsigned long mask;
    XGCValues gcVals;
    GC gc;

    /*
     * Configure the item.
     */

    if (Tk_ConfigureWidget(interp, Tk_CanvasTkwin(canvas),
		geoLnArrType.configSpecs, objc, (char **)objv,
		(char *)lnArrItemPtr, flags|TK_CONFIG_OBJS) != TCL_OK) {
	return TCL_ERROR;
    }
    if (lnArrItemPtr->lineColor != None) {
	gcVals.foreground = lnArrItemPtr->lineColor->pixel;
	gcVals.line_width = lnArrItemPtr->width;
	gcVals.line_style = lnArrItemPtr->lineStyle;
	gcVals.dashes = lnArrItemPtr->dashes;
	mask = GCForeground|GCLineWidth|GCLineStyle|GCDashList;
	gc = Tk_GetGC(tkwin, mask, &gcVals);
	if (lnArrItemPtr->lineGC != None) {
	    Tk_FreeGC(Tk_Display(tkwin), lnArrItemPtr->lineGC);
	}
	lnArrItemPtr->lineGC = gc;
    }

    if (lnArrItemPtr->fillColor != None) {
	gcVals.foreground = lnArrItemPtr->fillColor->pixel;
	mask = GCForeground;
	if (lnArrItemPtr->stipple != None) {
	    gcVals.stipple = lnArrItemPtr->stipple;
	    gcVals.fill_style = FillStippled;
	    mask |= GCStipple|GCFillStyle;
	}
	gc = Tk_GetGC(tkwin, mask, &gcVals);
	if (lnArrItemPtr->fillGC != None) {
	    Tk_FreeGC(Tk_Display(tkwin), lnArrItemPtr->fillGC);
	}
	lnArrItemPtr->fillGC = gc;
    }
    updateCvs(lnArrItemPtr);
    return TCL_OK;
}

/*
 *--------------------------------------------------------------
 *
 * coordProc --
 *
 *	This procedure is invoked to process the "coords" widget
 *	command on geomap_lnarr 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, ... */
{
    LnArrItem *lnArrItemPtr = (LnArrItem *)itemPtr;

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

	Tcl_Obj *obj = Tcl_NewObj();
	Tcl_Obj *subobj = Tcl_NewDoubleObj(lnArrItemPtr->xRef);
	Tcl_ListObjAppendElement(interp, obj, subobj);
	subobj = Tcl_NewDoubleObj(lnArrItemPtr->yRef);
	Tcl_ListObjAppendElement(interp, obj, subobj);
	Tcl_SetObjResult(interp, obj);
    } else if (objc == 1) {
	Tcl_Obj *lineObj, *rslt;	/* Result */
	int nl, np;			/* Loop indeces */
	double *coordPtr;		/* Canvas coordinate to put in result */

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

	    updateCvs(lnArrItemPtr);
	    rslt = Tcl_NewObj();
	    if (lnArrItemPtr->nLines == 1) {
		/*
		 * Array has one line.  Set result to list of {x y x y ...}
		 * values.
		 */

		for (coordPtr = lnArrItemPtr->coordPtrPtr[0], np = 0;
			np < lnArrItemPtr->nPtsPtr[0];
			np++) {
		    Tcl_ListObjAppendElement(interp, rslt,
			    Tcl_NewDoubleObj(*coordPtr++));
		    Tcl_ListObjAppendElement(interp, rslt,
			    Tcl_NewDoubleObj(*coordPtr++));
		}
	    } else {
		/*
		 * If array has several lines, set result to a list of lists of
		 * {x y x y ...} values.
		 */

		for (nl = 0; nl < lnArrItemPtr->nLines; nl++) {
		    lineObj = Tcl_NewObj();
		    for (coordPtr = lnArrItemPtr->coordPtrPtr[nl], np = 0;
			    np < lnArrItemPtr->nPtsPtr[nl];
			    np++) {
			Tcl_ListObjAppendElement(interp, lineObj,
				Tcl_NewDoubleObj(*coordPtr++));
			Tcl_ListObjAppendElement(interp, lineObj,
				Tcl_NewDoubleObj(*coordPtr++));
		    }
		    Tcl_ListObjAppendElement(interp, rslt, lineObj);
		}
	    }
	    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],
			    &lnArrItemPtr->xRef) != TCL_OK)
		    || (Tk_CanvasGetCoordFromObj(interp, canvas, coordsPtr[1],
			    &lnArrItemPtr->yRef) != TCL_OK)) {
		return TCL_ERROR;
	    }
	    lnArrItemPtr-> updateCvs = 1;
	    updateCvs(lnArrItemPtr);
	}
    } else if (objc == 2) {
	/*
	 * New coordinates given on command line in form "pathName coords x y"
	 */

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

/*
 *--------------------------------------------------------------
 *
 * deleteProc --
 *
 *	This procedure is called to clean up the data structure
 *	associated with a geomap_lnarr 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. */
{
    LnArrItem *lnArrItemPtr = (LnArrItem *)itemPtr;
    int nl;

    Tclgeomap_CnxProjUpdateTask(lnArrItemPtr->proj, lnArrItemPtr);
    Tclgeomap_CnxProjDeleteTask(lnArrItemPtr->proj, lnArrItemPtr);
    Tclgeomap_CnxLnArrDeleteTask(lnArrItemPtr->tclGeoLnArr, lnArrItemPtr);
    for (nl = 0; nl < lnArrItemPtr->nLines; nl++) {
	CKFREE((char *)lnArrItemPtr->coordPtrPtr[nl]);
    }
    CKFREE((char *)lnArrItemPtr->nPtsPtr);
    CKFREE((char *)lnArrItemPtr->coordPtrPtr);
    if (lnArrItemPtr->lineGC != None) {
	Tk_FreeGC(display, lnArrItemPtr->lineGC);
    }
    if (lnArrItemPtr->fillGC != None) {
	Tk_FreeGC(display, lnArrItemPtr->fillGC);
    }
    Tk_FreeOptions(geoLnArrType.configSpecs, (char *)lnArrItemPtr,
	    display, 0);
}

/*
 *--------------------------------------------------------------
 *
 * forgetLnArr --
 *
 * 	This procedure modifies a LnArrItem if the linearray it is
 * 	displaying is deleted.
 *
 * Results:
 * 	None.
 *
 * Side effects:
 * 	The item is removed from the display and appropriate members are
 * 	updated.
 *
 *--------------------------------------------------------------
 */

static void
forgetLnArr(clientData)
    ClientData clientData;	/* Geolinearray item */
{
    LnArrItem *lnArrItemPtr = (LnArrItem *)clientData;
    Tk_Window tkwin = Tk_CanvasTkwin(lnArrItemPtr->canvas);

    lnArrItemPtr->tclGeoLnArr = NULL;
    MapLnArrDestroy(lnArrItemPtr->mapLnArr);
    lnArrItemPtr->mapLnArr = NULL;
    lnArrItemPtr->updateMap = 0;
    if (lnArrItemPtr->lineGC != None) {
	Tk_FreeGC(Tk_Display(tkwin), lnArrItemPtr->lineGC);
    }
    lnArrItemPtr->lineGC = None;
    if (lnArrItemPtr->fillGC != None) {
	Tk_FreeGC(Tk_Display(tkwin), lnArrItemPtr->fillGC);
    }
    lnArrItemPtr->fillGC = None;
    hide(lnArrItemPtr);
}

/*
 *--------------------------------------------------------------
 *
 * forgetProj --
 *
 * 	This procedure modifies a LnArrItem if the projection it is
 * 	using is deleted.
 *
 * Results:
 * 	None.
 *
 * Side effects:
 * 	The item is removed from the display and appropriate members are
 * 	updated.
 *
 *--------------------------------------------------------------
 */

static void
forgetProj(clientData)
    ClientData clientData;	/* Geolinearray item */
{
    LnArrItem *lnArrItemPtr = (LnArrItem *)clientData;

    lnArrItemPtr->proj = NULL;
    MapLnArrDestroy(lnArrItemPtr->mapLnArr);
    lnArrItemPtr->mapLnArr = NULL;
    lnArrItemPtr->updateMap = 0;
    hide(lnArrItemPtr);
}

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

static void
hide(lnArrItemPtr)
    LnArrItem *lnArrItemPtr;	/* Linearray to remove from display */
{
    int n;

    for (n = 0; n < lnArrItemPtr->nLines; n++) {
	CKFREE((char *)lnArrItemPtr->coordPtrPtr[n]);
	lnArrItemPtr->coordPtrPtr[n] = NULL;
    }
    lnArrItemPtr->nLines = 0;
    Tk_CanvasEventuallyRedraw(lnArrItemPtr->canvas,
	    lnArrItemPtr->header.x1, lnArrItemPtr->header.y1,
	    lnArrItemPtr->header.x2, lnArrItemPtr->header.y2);
    lnArrItemPtr->header.x1 = lnArrItemPtr->header.y1 = INT_MAX;
    lnArrItemPtr->header.x2 = lnArrItemPtr->header.y2 = INT_MIN;
    lnArrItemPtr->updateCvs = 0;
}

/*
 *--------------------------------------------------------------
 *
 * displayProc --
 *
 *	This procedure is invoked to draw a geomap_lnarr 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. */
{
    LnArrItem *lnArrItemPtr = (LnArrItem *)itemPtr;
    static XPoint *xPtsPtr;
    XPoint *pPtr, *ePtr;
    double *coordPtr, xc, yc;
    unsigned sz, nl, nMax;
    int nPts;
    Tk_Window tkwin = Tk_CanvasTkwin(canvas);

    if (!tkwin || !Tk_IsMapped(tkwin)) {
	return;
    }
    if ( lnArrItemPtr->nLines == 0 || !lnArrItemPtr->nPtsPtr
	    || !lnArrItemPtr->coordPtrPtr ) {
	return;
    }
    if (lnArrItemPtr->updateMap) {
	updateMap(lnArrItemPtr);
    }
    if ( !lnArrItemPtr->mapLnArr ) {
	return;
    }
    if (lnArrItemPtr->updateCvs) {
	updateCvs(lnArrItemPtr);
    }

    nMax = lnArrItemPtr->nMax;
    if ((lnArrItemPtr->smooth) && (nMax > 2)) {
	sz = sizeof(XPoint) * TkgeomapMakeBezierCurve(canvas, NULL,
		(int)nMax, lnArrItemPtr->splineSteps, NULL, NULL);
    } else {
	sz = sizeof(XPoint) * nMax;
    }
    if (sz == 0) {
	return;
    } else {
	xPtsPtr = (XPoint *)CKREALLOC((char *)xPtsPtr, sz);
    }

    for (nl = 0; nl < lnArrItemPtr->nLines; nl++) {

	nPts = lnArrItemPtr->nPtsPtr[nl];

	/*
	 * Put the shape into drawable (X) coordinates.
	 */

	if ((lnArrItemPtr->smooth) && (nMax > 2)) {
	    nPts = TkgeomapMakeBezierCurve(canvas,
		    lnArrItemPtr->coordPtrPtr[nl], nPts,
		    lnArrItemPtr->splineSteps, xPtsPtr, NULL);
	} else {
	    for (pPtr = xPtsPtr, ePtr = pPtr + nPts,
		    coordPtr = lnArrItemPtr->coordPtrPtr[nl];
		    pPtr < ePtr; pPtr++) {
		xc = *coordPtr++;
		yc = *coordPtr++;
		Tk_CanvasDrawableCoords(canvas, xc, yc, &pPtr->x, &pPtr->y);
	    }
	}

	/*
	 * Fill in the area.
	 */

	if (lnArrItemPtr->fillColor != None) {
	    XFillPolygon(display, drawable, lnArrItemPtr->fillGC, xPtsPtr,
		    nPts, lnArrItemPtr->shape, CoordModeOrigin);
	}


	/*
	 * Draw the line segments.
	 */

	if (lnArrItemPtr->width > 0
		&& lnArrItemPtr->lineColor != None) {
	    XDrawLines(display, drawable, lnArrItemPtr->lineGC, xPtsPtr,
		    nPts, CoordModeOrigin);
	}

	/*
	 * Draw dots at segment endpoints.
	 */

	if (lnArrItemPtr->dotSize > 0 && lnArrItemPtr->lineColor != None) {
	    for (pPtr = xPtsPtr, ePtr = pPtr + nPts,
		    coordPtr = lnArrItemPtr->coordPtrPtr[nl];
		    pPtr < ePtr; pPtr++) {
		unsigned dotSize = lnArrItemPtr->dotSize;
		int spShift = dotSize / 2;
		short x, y;

		xc = *coordPtr++;
		yc = *coordPtr++;
		Tk_CanvasDrawableCoords(canvas, xc, yc, &x, &y);
		if (dotSize == 1) {
		    XDrawPoint(display, drawable, lnArrItemPtr->lineGC, x, y);
		} else {
		    XFillArc(display, drawable, lnArrItemPtr->lineGC,
			    x - spShift, y - spShift, dotSize, dotSize,
			    0, 23040);
		}
	    }
	}
    }
}

/*
 *--------------------------------------------------------------
 *
 * pointProc --
 *
 *	Computes the distance from a given point to a given
 *	geomap_lnarr item, in canvas units.
 *
 * Results:
 *	The return value is 0.0 if the point whose x and y coordinates
 *	are pointPtr[0] and pointPtr[1] is inside the geomap_lnarr.  If the
 *	point isn't inside the geomap_lnarr then the return value is the
 *	distance from the point to the geomap_lnarr.
 *
 * 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. */
{
    LnArrItem *lnArrItemPtr = (LnArrItem *)itemPtr;
    int nl, np, nPair;
    double **coordPtrPtr;
    int *nPtsPtr;
    double x0 = pointPtr[0], y0 = pointPtr[1];
    double end1Ptr[2], end2Ptr[2];
    double *coordPtr;
    double d, dx, dy, closest;

    if (lnArrItemPtr->updateCvs) {
	updateCvs(lnArrItemPtr);
    }
    if ( !itemPtr || !lnArrItemPtr->coordPtrPtr || lnArrItemPtr->nLines == 0 ) {
	return DBL_MAX;
    }
    coordPtrPtr = lnArrItemPtr->coordPtrPtr;
    nPtsPtr = lnArrItemPtr->nPtsPtr;
    if (lnArrItemPtr->fillColor != None) {
	/*
	 * Treat all lines as closed polygons.
	 */

	closest = DBL_MAX;
	for (nl = 0; nl < lnArrItemPtr->nLines; nl++) {
	    d = TkgeomapPolygonToPoint(coordPtrPtr[nl], nPtsPtr[nl], pointPtr);
	    if (d == 0.0) {
		return 0.0;
	    } else if (d < closest) {
		closest = d;
	    }
	}
    } else if (lnArrItemPtr->width < 0) {
	/*
	 * Points are not connected.  Return distance to nearest point.
	 */

	closest = DBL_MAX;
	for (nl = 0; nl < lnArrItemPtr->nLines; nl++) {
	    coordPtr = coordPtrPtr[nl];
	    for (np = 0; np < nPtsPtr[nl]; np++) {
		dx = x0 - *coordPtr++;
		dy = y0 - *coordPtr++;
		d = dx * dx + dy * dy;
		closest = (d < closest) ? d : closest;
	    }
	}
	closest = sqrt(closest);
    } else {
	/*
	 * Lines are either closed polygons that are not filled, or they
	 * are open.
	 */

	closest = DBL_MAX;
	for (nl = 0; nl < lnArrItemPtr->nLines; nl++) {
	    coordPtr = coordPtrPtr[nl];
	    nPair = nPtsPtr[nl] - 1;
	    if (nPair == 0) {
		continue;
	    }
	    for (np = 0, coordPtr = coordPtrPtr[nl];
		    np < nPair; np++, coordPtr += 2) {
		end1Ptr[0] = coordPtr[0];
		end1Ptr[1] = coordPtr[1];
		end2Ptr[0] = coordPtr[2];
		end2Ptr[1] = coordPtr[3];
		d = TkgeomapLineToPoint(end1Ptr, end2Ptr, pointPtr);
		closest = (d < closest) ? d : closest;
	    }
	}
    }
    return closest;
}

/*
 *--------------------------------------------------------------
 *
 * 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.  */
{
    LnArrItem *lnArrItemPtr = (LnArrItem *)itemPtr;
    double x1, y1, x2, y2;	/* Limits of rectPtr */
    double x, y;
    int nl, np, nPts;
    double **coordPtrPtr = lnArrItemPtr->coordPtrPtr;
    int *nPtsPtr = lnArrItemPtr->nPtsPtr;
    double end1Ptr[2], end2Ptr[2];
    double *coordPtr;
    int currInside, prevInside;	/* Status of current and previous polygon, line,
				 * or point.  1 means inside, 0 means
				 * overlapping, and -1 means outside. */

    if (lnArrItemPtr->updateCvs) {
	updateCvs(lnArrItemPtr);
    }
    if ( !lnArrItemPtr->coordPtrPtr || lnArrItemPtr->nLines == 0 ) {
	return -1;
    }
    x1 = rectPtr[0];
    y1 = rectPtr[1];
    x2 = rectPtr[2];
    y2 = rectPtr[3];
    if (lnArrItemPtr->fillColor != None) {
	/*
	 * Treat all lines as closed polygons.
	 */

	prevInside = currInside
	    = TkgeomapPolygonToArea(coordPtrPtr[0], nPtsPtr[0], rectPtr);
	for (nl = 1; nl < lnArrItemPtr->nLines; nl++) {
	    currInside = TkgeomapPolygonToPoint(coordPtrPtr[nl], nPtsPtr[nl],
		    rectPtr);
	    if (currInside == 0 || currInside != prevInside) {
		return 0;
	    }
	    prevInside = currInside;
	}
	return currInside;
    } else if (lnArrItemPtr->width < 0) {
	/*
	 * Points are not connected.
	 */

	x = coordPtrPtr[0][0];
	y = coordPtrPtr[0][1];
	prevInside = currInside
	    = (x > x1 && x < x2 && y > y1 && y < y2) ? 1 : 0;
	for (nl = 0; nl < lnArrItemPtr->nLines; nl++) {
	    coordPtr = coordPtrPtr[nl];
	    for (np = 0; np < nPtsPtr[nl]; np++) {
		x = *coordPtr++;
		y = *coordPtr++;
		currInside = (x > x1 && x < x2 && y > y1 && y < y2) ? 1 : 0;
		if (currInside != prevInside) {
		    return 0;
		}
		prevInside = currInside;
	    }
	}
	return currInside;
    } else {
	/*
	 * Lines are either closed polygons that are not filled, or they
	 * are open lines.
	 */

	nPts = nPtsPtr[0];
	end1Ptr[0] = coordPtrPtr[0][0];
	end1Ptr[1] = coordPtrPtr[0][1];
	end2Ptr[0] = coordPtrPtr[0][2 * nPts - 2];
	end2Ptr[1] = coordPtrPtr[0][2 * nPts - 1];
	if ((end1Ptr[0] == end2Ptr[0]) && (end1Ptr[1] == end2Ptr[1])) {
	    /*
	     * First line in the linearray is closed.  Treat it as a
	     * polygon.
	     */

	    prevInside = currInside
		= TkgeomapPolygonToArea(coordPtrPtr[0], nPts, rectPtr);
	    if (lnArrItemPtr->nLines == 1) {
		return prevInside;
	    }

	} else {
	    /*
	     * First line in the linearray is open.  Compute the distances
	     * to the segments.
	     */

	    x = coordPtrPtr[0][0];
	    y = coordPtrPtr[0][1];
	    prevInside = currInside
		= (x > x1 && x < x2 && y > y1 && y < y2) ? 1 : 0;
	    coordPtr = coordPtrPtr[0];
	    for (np = 0; np < nPtsPtr[0]; np++) {
		x = *coordPtr++;
		y = *coordPtr++;
		currInside = (x > x1 && x < x2 && y > y1 && y < y2) ? 1 : 0;
		if (currInside != prevInside) {
		    return 0;
		}
		currInside = prevInside;
	    }
	}
	for (nl = 0; nl < lnArrItemPtr->nLines; nl++) {
	    coordPtr = coordPtrPtr[nl];
	    nPts = nPtsPtr[nl];
	    end1Ptr[0] = coordPtr[0];
	    end1Ptr[1] = coordPtr[1];
	    end2Ptr[0] = coordPtr[2 * nPts - 2];
	    end2Ptr[1] = coordPtr[2 * nPts - 1];
	    if ((end1Ptr[0] == end2Ptr[0]) && (end1Ptr[1] == end2Ptr[1])) {
		/*
		 * This line in the linearray is closed.  Treat it as a
		 * polygon.
		 */

		currInside = TkgeomapPolygonToArea(coordPtrPtr[0], nPts,
			rectPtr);
		if (currInside != prevInside) {
		    return 0;
		}
		currInside = prevInside;
	    } else {
		/*
		 * This line in the linearray is open.  Compute the distances
		 * to the segments.
		 */

		for (np = 0; np < nPts; np++) {
		    x = *coordPtr++;
		    y = *coordPtr++;
		    currInside = (x > x1 && x < x2 && y > y1 && y < y2) ? 1 : 0;
		    if (currInside != prevInside) {
			return 0;
		    }
		    currInside = prevInside;
		}
	    }
	}
    }
    return -1;
}

/*
 *--------------------------------------------------------------
 *
 * postscriptProc --
 *
 *	This procedure is called to generate Postscript for
 *	geomap_lnarr 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.*/
{
    LnArrItem *lnArrItemPtr;	/* Geomap in which to draw line array */
    Tk_Window tkwin = Tk_CanvasTkwin(canvas);
    static double *coord1Ptr;		/* Array of canvas coordinates for
    					 * one line.  This pointer holds
					 * the result of CKREALLOC. */
    double *coordPtr;			/* Array of canvas coordinates for
    					 * one line.  May be the same as
					 * coord1Ptr, or may point into the
					 * item's coordinates array. */
    double x, y;
    int nl, nPts, np;			/* Loop indices and limits */
    char bytes[200];			/* Printing space */
    double cnr[8];			/* 4 corner points in canvas coord's */

    lnArrItemPtr = (LnArrItem *)itemPtr;
    if ( !lnArrItemPtr->tclGeoLnArr ) {
	return TCL_OK;
    }
    if (lnArrItemPtr->updateMap) {
	updateMap(lnArrItemPtr);
    }
    if (lnArrItemPtr->updateCvs) {
	updateCvs(lnArrItemPtr);
    }
    if ( !lnArrItemPtr->mapLnArr || lnArrItemPtr->nLines == 0
	    || !lnArrItemPtr->nPtsPtr || !lnArrItemPtr->coordPtrPtr) {
	Tcl_AppendResult(interp,
		"Could not generate postscript for linearray ",
		Tclgeomap_LnArrName(lnArrItemPtr->tclGeoLnArr), NULL);
	return TCL_ERROR;
    }

    Tcl_AppendResult(interp, "%% Drawing linearray ",
		Tclgeomap_LnArrName(lnArrItemPtr->tclGeoLnArr), "\n", NULL);

    /*
     * 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);

    for (nl = 0; nl < lnArrItemPtr->nLines; nl++) {

	nPts = lnArrItemPtr->nPtsPtr[nl];
	if (nPts == 0) {
	    continue;
	}
	if ( !lnArrItemPtr->smooth || nPts < 3 ) {
	    coordPtr = lnArrItemPtr->coordPtrPtr[nl];
	} else {
	    nPts = TkgeomapMakeBezierCurve(canvas, NULL,
		    lnArrItemPtr->nPtsPtr[nl], lnArrItemPtr->splineSteps,
		    NULL, NULL);
	    coordPtr = coord1Ptr = (double *)CKREALLOC((char *)coord1Ptr,
		    nPts * 2 * sizeof(double));
	    nPts = TkgeomapMakeBezierCurve(canvas,
		    lnArrItemPtr->coordPtrPtr[nl], lnArrItemPtr->nPtsPtr[nl],
		    lnArrItemPtr->splineSteps, NULL, coordPtr);
	}

	/*
	 * Fill in the area.
	 */

	if (lnArrItemPtr->fillColor) {
	    Tk_CanvasPsColor(interp, canvas, lnArrItemPtr->fillColor);
	    Tcl_AppendResult(interp, "newpath\n", NULL);
	    Tk_CanvasPsPath(interp, canvas, coordPtr, nPts);
	    Tcl_AppendResult(interp, "closepath\n", NULL);
	    if (lnArrItemPtr->stipple != None) {
		Tcl_AppendResult(interp, "clip\n", NULL);
		Tcl_AppendResult(interp, "newpath\n", NULL);
		Tk_CanvasPsPath(interp, canvas, coordPtr, nPts);
		Tcl_AppendResult(interp, "closepath\n", NULL);
		if (Tk_CanvasPsStipple(interp, canvas, lnArrItemPtr->stipple)
			== TCL_ERROR) {
		    return TCL_ERROR;
		}
	    } else {
		Tcl_AppendResult(interp, "fill\n", NULL);
	    }
	}

	/*
	 * Draw the outline.
	 */

	if (lnArrItemPtr->width > 0
		&& lnArrItemPtr->lineColor != None) {
	    sprintf(bytes, "%d", lnArrItemPtr->width);
	    Tcl_AppendResult(interp, bytes, " setlinewidth\n", NULL);
	    if (lnArrItemPtr->lineStyle == LineSolid) {
		Tcl_AppendResult(interp, "[] 0 setdash\n", NULL);
	    } else if (lnArrItemPtr->lineStyle == LineOnOffDash) {
		sprintf(bytes, "[%d %d] 0 setdash\n",
			lnArrItemPtr->dashes, lnArrItemPtr->dashes);
		Tcl_AppendResult(interp, bytes, NULL);
	    }
	    Tk_CanvasPsColor(interp, canvas, lnArrItemPtr->lineColor);
	    Tcl_AppendResult(interp, "newpath\n", NULL);
	    Tk_CanvasPsPath(interp, canvas, coordPtr, nPts);
	    Tcl_AppendResult(interp, "stroke\n", NULL);
	}

	/*
	 * Draw dots at segment endpoints.
	 */

	if (lnArrItemPtr->dotSize != 0) {
	    Tk_CanvasPsColor(interp, canvas, lnArrItemPtr->lineColor);
	    for (np = 0; np < nPts; np++) {
		x = *coordPtr++;
		y = *coordPtr++;
		if (lnArrItemPtr->dotSize != 0) {
		    sprintf(bytes, "newpath %f %f %f",
			    x, y, 0.5 * lnArrItemPtr->dotSize);
		    Tcl_AppendResult(interp, bytes, " 0 360 arc fill\n", NULL);
		}
	    }
	}
    }

    return TCL_OK;
}

/*
 *--------------------------------------------------------------
 *
 * scaleProc --
 *
 *	This function rescales a geomap_lnarr 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 geomap_lnarr item is moved according to the
 * 	transformation:
 *		xRef' = originX + scaleX*(xRef-originX)
 *		yRef' = originY + scaleY*(yRef-originY)
 *	The geomap_lnarr's points on the canvas 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. */
{
    LnArrItem *lnArrItemPtr = (LnArrItem *) itemPtr;

    lnArrItemPtr->xRef = originX + scaleX * (lnArrItemPtr->xRef - originX);
    lnArrItemPtr->yRef = originY + scaleY * (lnArrItemPtr->yRef - originY);
    updateCvs(lnArrItemPtr);
    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. */
{
    LnArrItem *lnArrItemPtr = (LnArrItem *) itemPtr;

    lnArrItemPtr->xRef += deltaX;
    lnArrItemPtr->yRef += deltaY;
    updateCvs(lnArrItemPtr);
}
/*
 *------------------------------------------------------------------------
 *
 * updateMap --
 *
 * 	This procedure updates the map coordinates of a geomap_lnarr item.
 *
 * Results:
 *	None.
 *
 * Side effects:
 * 	The mapLnArr member of the geomap_lnarr item are updated.
 *
 *------------------------------------------------------------------------
 */

static void
updateMap(clientData)
    ClientData clientData;	/* Geolinearray item to update */
{
    LnArrItem *lnArrItemPtr = (LnArrItem *)clientData;
    Tk_Canvas canvas = lnArrItemPtr->canvas;
    Tk_Window tkwin = Tk_CanvasTkwin(canvas);
    Tclgeomap_LnArr tclGeoLnArr = lnArrItemPtr->tclGeoLnArr;
    GeoLnArr geoLnArr = (GeoLnArr)lnArrItemPtr->tclGeoLnArr;
    Tclgeomap_Proj tclGeoProj = lnArrItemPtr->proj;
    GeoProj proj = (GeoProj)tclGeoProj;
    MapLnArr mapLnArr = lnArrItemPtr->mapLnArr;

    if ( !tclGeoLnArr || !proj ) {
	MapLnArrDestroy(lnArrItemPtr->mapLnArr);
	lnArrItemPtr->mapLnArr = NULL;
	lnArrItemPtr->updateMap = 0;
	hide(lnArrItemPtr);
	return;
    }

    if (lnArrItemPtr->mapLnArr) {
	MapLnArrDestroy(lnArrItemPtr->mapLnArr);
	lnArrItemPtr->mapLnArr = NULL;
    }
    if ( !(mapLnArr = GeoLnArrToMap(geoLnArr, proj)) ) {
	lnArrItemPtr->mapLnArr = NULL;
	hide(lnArrItemPtr);
	return;
    }
    lnArrItemPtr->mapLnArr = mapLnArr;
    lnArrItemPtr->updateMap = 0;
    lnArrItemPtr->updateCvs = 1;
}

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

static void
updateCvs(clientData)
    ClientData clientData;	/* Geolinearray item to update */
{
    LnArrItem *lnArrItemPtr = (LnArrItem *)clientData;
    Tk_Canvas canvas = lnArrItemPtr->canvas;
    Tk_Window tkwin = Tk_CanvasTkwin(canvas);
    Tclgeomap_LnArr tclGeoLnArr = lnArrItemPtr->tclGeoLnArr;
    Tclgeomap_Proj tclGeoProj = lnArrItemPtr->proj;
    GeoProj proj = (GeoProj)tclGeoProj;
    MapLnArr mapLnArr = lnArrItemPtr->mapLnArr;
    static Tcl_Obj *cvsPerMObj;		/* Object storing measure for 1 meter */
    double cvsPerM;			/* Canvas units per meter on display */
    double cvsPerMapM;			/* Canvas units per meter on map
					 * (2D surface which contains projected
					 * and rotated lat-lons) */
    double xRef = lnArrItemPtr->xRef;
    double yRef = lnArrItemPtr->yRef;
    int x, y;
    int x1, y1, x2, y2;
    int width, height;
    MapPt mRefPt;			/* Reference point in map coordinates */
    double ordMax, absMax, ordMin, absMin;
    unsigned nl, nls, np;
    unsigned nlc;			/* Number of lines in canvas */
    unsigned r;				/* Dot radius */
    int noLines, noFill;		/* Booleans to indicate whether
					 * anything visible in display */

    if ( !tclGeoLnArr || !proj ) {
	hide(lnArrItemPtr);
	return;
    }
    if (lnArrItemPtr->updateMap) {
	updateMap(lnArrItemPtr);
    }
    if ( !lnArrItemPtr->mapLnArr ) {
	hide(lnArrItemPtr);
	return;
    }
    mapLnArr = lnArrItemPtr->mapLnArr;
    noLines = !lnArrItemPtr->lineColor
	|| (lnArrItemPtr->width <= 0 && lnArrItemPtr->dotSize <= 0);
    noFill = !lnArrItemPtr->fillColor;
    if (noLines && noFill) {
	hide(lnArrItemPtr);
	return;
    }
    mRefPt = LatLonToProj(lnArrItemPtr->refPt, proj);
    if ( !cvsPerMObj ) {
	cvsPerMObj = Tcl_NewStringObj("100.0c", -1);
    }
    Tk_CanvasGetCoordFromObj(NULL, canvas, cvsPerMObj, &cvsPerM);
    cvsPerMapM = cvsPerM * lnArrItemPtr->scale;
    Tk_CanvasEventuallyRedraw(canvas,
	    lnArrItemPtr->header.x1, lnArrItemPtr->header.y1,
	    lnArrItemPtr->header.x2, lnArrItemPtr->header.y2);
    if (!tkwin || !Tk_IsMapped(tkwin)) {
	/*
	 * If canvas limits are not know yet, draw everything.
	 */

	ordMax = DBL_MAX;
	absMax = DBL_MAX;
	ordMin = -DBL_MAX;
	absMin = -DBL_MAX;
    } else {
	/*
	 * If canvas limits are known, only draw lines on canvas.
	 */

	width = Tk_Width(tkwin);
	height = Tk_Height(tkwin);
	ordMax = mRefPt.ord + yRef / cvsPerMapM;
	absMax = mRefPt.abs + (width - xRef) / cvsPerMapM;
	ordMin = mRefPt.ord - (height -yRef) / cvsPerMapM;
	absMin = mRefPt.abs - xRef / cvsPerMapM;
    }
    nls = mapLnArr->nLines;
    if (nls == 0) {
	hide(lnArrItemPtr);
	return;
    }

    /*
     * Reinitialize coords arrays and array sizes in lnArrItemPtr.
     */

    for (nl = 0; nl < lnArrItemPtr->nLines; nl++) {
	CKFREE((char *)lnArrItemPtr->coordPtrPtr[nl]);
    }
    CKFREE((char *)lnArrItemPtr->coordPtrPtr);
    lnArrItemPtr->nLines = 0;
    lnArrItemPtr->coordPtrPtr = (double **)CKALLOC(nls * sizeof(double *));
    for (nl = 0, nlc = 0; nl < nls; nl++) {
	lnArrItemPtr->coordPtrPtr[nl] = NULL;
    }

    CKFREE((char *)lnArrItemPtr->nPtsPtr);
    lnArrItemPtr->nPtsPtr = (int *)CKALLOC(nls * sizeof(int));
    for (nl = 0, nlc = 0; nl < nls; nl++) {
	lnArrItemPtr->nPtsPtr[nl] = 0;
    }

    x1 = y1 = INT_MAX;
    x2 = y2 = INT_MIN;
    for (nl = 0, nlc = 0; nl < nls; nl++) {
	size_t sz;

	/*
	 * Compute canvas coordinates for one line from mapLnArr,
	 * if it has points in the window.
	 */

	MapLn mapLn = MapLnArrGetLine(mapLnArr, nl);

	/*
	 * Update bounding box of the linearray.
	 */

	if (mapLn->ordMax > ordMin && mapLn->ordMin < ordMax
		&& mapLn->absMax > absMin && mapLn->absMin < absMax) {
	    double *coordPtr;

	    lnArrItemPtr->nPtsPtr[nlc] = mapLn->nPts;
	    sz = lnArrItemPtr->nPtsPtr[nlc] * 2 * sizeof(double);
	    lnArrItemPtr->coordPtrPtr[nlc] = (double *)CKALLOC(sz);
	    for (np = 0, coordPtr = lnArrItemPtr->coordPtrPtr[nlc];
		    np < lnArrItemPtr->nPtsPtr[nlc];
		    np++) {
		MapPt mapPt = MapLnGetPt(mapLn, np);
		x = xRef + (mapPt.abs - mRefPt.abs) * cvsPerMapM;
		x1 = (x < x1) ? x : x1;
		x2 = (x > x2) ? x : x2;
		*coordPtr++ = x;
		y = yRef - (mapPt.ord - mRefPt.ord) * cvsPerMapM;
		y1 = (y < y1) ? y : y1;
		y2 = (y > y2) ? y : y2;
		*coordPtr++ = y;
	    }

	    nlc++;
	}
    }

    /*
     * Store new coords arrays and array sizes in lnArrItemPtr.
     */

    if (nlc == 0) {
	hide(lnArrItemPtr);
	return;
    }
    lnArrItemPtr->nLines = nlc;
    lnArrItemPtr->nMax = mapLnArr->nMax;
    r = (lnArrItemPtr->dotSize + 1) / 2;
    lnArrItemPtr->header.x1 = x1 - lnArrItemPtr->width - r - 1;
    lnArrItemPtr->header.x2 = x2 + lnArrItemPtr->width + r + 1;
    lnArrItemPtr->header.y1 = y1 - lnArrItemPtr->width - r - 1;
    lnArrItemPtr->header.y2 = y2 + lnArrItemPtr->width + r + 1;
    if ( lnArrItemPtr->header.x1 >= lnArrItemPtr->header.x2
	    || lnArrItemPtr->header.y1 >= lnArrItemPtr->header.y2 ) {
	hide(lnArrItemPtr);
	return;
    }
    Tk_CanvasEventuallyRedraw(lnArrItemPtr->canvas,
	    lnArrItemPtr->header.x1, lnArrItemPtr->header.y1,
	    lnArrItemPtr->header.x2, lnArrItemPtr->header.y2);
    lnArrItemPtr->updateCvs = 0;
}