/*	$Id: tixHLHdr.c,v 1.1.1.1 2000/05/17 11:08:42 idiscovery Exp $	*/

/*
 *  tixHLHdr.c ---
 *
 *
 *	Implements headers for tixHList widgets
 *
 * Copyright (c) 1996, Expert Interface Technologies
 *
 * See the file "license.terms" for information on usage and redistribution
 * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
 *
 */

#include "tixPort.h"
#include "tixInt.h"
#include "tixHList.h"
#include "tixDef.h"

static TIX_DECLARE_SUBCMD(Tix_HLHdrCreate);
static TIX_DECLARE_SUBCMD(Tix_HLHdrConfig);
static TIX_DECLARE_SUBCMD(Tix_HLHdrCGet);
static TIX_DECLARE_SUBCMD(Tix_HLHdrDelete);
static TIX_DECLARE_SUBCMD(Tix_HLHdrExist);
static TIX_DECLARE_SUBCMD(Tix_HLHdrSize);
static TIX_DECLARE_SUBCMD(Tix_HLHdrHeight);

static void		FreeWindowItem _ANSI_ARGS_((Tcl_Interp  *interp,
			    WidgetPtr wPtr, HListHeader *hPtr));
static void		FreeHeader _ANSI_ARGS_((Tcl_Interp  *interp,
			    WidgetPtr wPtr, HListHeader *hPtr));
static HListHeader*	AllocHeader _ANSI_ARGS_((Tcl_Interp *interp,
			    WidgetPtr wPtr));
static HListHeader*	Tix_HLGetHeader _ANSI_ARGS_((Tcl_Interp * interp,
			    WidgetPtr wPtr, Tcl_Obj * string,
			    int requireIPtr));

static Tk_ConfigSpec headerConfigSpecs[] = {
    {TK_CONFIG_SYNONYM, "-bd", "borderWidth", (char *) NULL,
       (char *) NULL, 0, 0},

    {TK_CONFIG_PIXELS, "-borderwidth", "headerBorderWidth", "BorderWidth",
       DEF_HLISTHEADER_BORDER_WIDTH, Tk_Offset(HListHeader, borderWidth), 0},

    {TK_CONFIG_BORDER, "-headerbackground", "headerBackground", "Background",
       DEF_HLISTHEADER_BG_COLOR, Tk_Offset(HListHeader, background),
       TK_CONFIG_COLOR_ONLY},

    {TK_CONFIG_BORDER, "-headerbackground", "headerBackground", "Background",
       DEF_HLISTHEADER_BG_MONO, Tk_Offset(HListHeader, background),
       TK_CONFIG_MONO_ONLY},

    {TK_CONFIG_RELIEF, "-relief", "headerRelief", "Relief",
       DEF_HLISTHEADER_RELIEF, Tk_Offset(HListHeader, relief), 0},

    {TK_CONFIG_END, (char *) NULL, (char *) NULL, (char *) NULL,
       (char *) NULL, 0, 0}
};

/*----------------------------------------------------------------------
 *
 * 		Local functions
 *
 *----------------------------------------------------------------------
 */

static HListHeader*
AllocHeader(interp, wPtr)
    Tcl_Interp *interp;
    WidgetPtr wPtr;
{
    HListHeader * hPtr = (HListHeader*)ckalloc(sizeof(HListHeader));
    hPtr->type 		= HLTYPE_HEADER;
    hPtr->self 		= (char*)hPtr;
    hPtr->wPtr 		= wPtr;
    hPtr->iPtr 		= NULL;
    hPtr->width 	= 0;
    hPtr->background	= NULL;
    hPtr->relief	= TK_RELIEF_RAISED;
    hPtr->borderWidth	= 2;

    if (Tk_ConfigureWidget(interp, wPtr->headerWin, headerConfigSpecs,
	    0, 0, (char *)hPtr, 0) != TCL_OK) {
	/* some unrecoverable errors */
	return NULL;
    }
    Tk_SetBackgroundFromBorder(wPtr->headerWin, hPtr->background);

    return hPtr;
}

static void
FreeWindowItem(interp, wPtr, hPtr)
    Tcl_Interp  *interp;
    WidgetPtr    wPtr;
    HListHeader *hPtr;
{
    Tix_WindowItemListRemove(&wPtr->mappedWindows,
	hPtr->iPtr);
}

static void
FreeHeader(interp, wPtr, hPtr)
    Tcl_Interp  *interp;
    WidgetPtr    wPtr;
    HListHeader *hPtr;
{
    if (hPtr->iPtr) {
	if (Tix_DItemType(hPtr->iPtr) == TIX_DITEM_WINDOW) {
	    FreeWindowItem(interp, wPtr, hPtr);
	}
	Tix_DItemFree(hPtr->iPtr);
    }

    Tk_FreeOptions(headerConfigSpecs, (char *)hPtr, wPtr->dispData.display, 0);
    ckfree((char*) hPtr);
}

static HListHeader*
Tix_HLGetHeader(interp, wPtr, string, requireIPtr)
    Tcl_Interp * interp;
    WidgetPtr wPtr;
    Tcl_Obj * string;
    int requireIPtr;
{
    int column;

    if (Tcl_GetIntFromObj(interp, string, &column) != TCL_OK) {
	return NULL;
    }
    if (column >= wPtr->numColumns || column < 0) {
	Tcl_AppendResult(interp, "Column \"", Tcl_GetString(string),
	    "\" does not exist", (char*)NULL);
	return NULL;
    }
    if (requireIPtr && wPtr->headers[column]->iPtr == NULL) {
	Tcl_AppendResult(interp, "Column \"", Tcl_GetString(string),
	    "\" does not have a header", (char*)NULL);
	return NULL;
    }

    return wPtr->headers[column];
}

int
Tix_HLCreateHeaders(interp, wPtr)
    Tcl_Interp *interp;
    WidgetPtr wPtr;
{
    int i;

    wPtr->headers = (HListHeader**)
      ckalloc(sizeof(HListHeader*) * wPtr->numColumns);

    for (i=0; i<wPtr->numColumns; i++) {
	wPtr->headers[i] = NULL;
    }

    for (i=0; i<wPtr->numColumns; i++) {
	if ((wPtr->headers[i] = AllocHeader(interp, wPtr)) == NULL) {
	    return TCL_ERROR;
	}
    }

    wPtr->headerDirty = 1;
    return TCL_OK;
}

void Tix_HLFreeHeaders(interp, wPtr)
    Tcl_Interp *interp;
    WidgetPtr wPtr;
{
    int i;

    if (wPtr->headers == NULL) {
	return;
    }

    for (i=0; i<wPtr->numColumns; i++) {
	if (wPtr->headers[i] != NULL) {
	    FreeHeader(interp, wPtr, wPtr->headers[i]);
	}
    }

    ckfree((char*)wPtr->headers);
}

void
Tix_HLDrawHeader(wPtr, pixmap, gc, hdrX, hdrY, hdrW, hdrH, xOffset)
    WidgetPtr wPtr;
    Pixmap pixmap;
    GC gc;
    int hdrX;
    int hdrY;
    int hdrW;
    int hdrH;
    int xOffset;
{
    int i, x, y;
    int drawnWidth;		/* how much of the header have I drawn? */
    int width;			/* width of the current header item */
    int winItemExtra;		/* window items need a bit extra offset
				 * because they must be places relative to
				 * the main window, not the header subwindow
				 */
    x = hdrX - xOffset;
    y = hdrY;
    drawnWidth = 0;

    winItemExtra = wPtr->borderWidth + wPtr->highlightWidth;

    if (wPtr->needToRaise) {
	/* the needToRaise flag is set every time a new window item is
	 * created inside the header of the HList.
	 *
	 * We need to make sure that the windows items in the list
	 * body are clipped by the header subwindow. However, the window
	 * items inside the header should be over the header subwindow.
	 *
	 * The two XRaiseWindow calls in this function make sure that
	 * the stacking relationship as described above always hold
	 */
	XRaiseWindow(Tk_Display(wPtr->headerWin),
	    Tk_WindowId(wPtr->headerWin));
    }

    for (i=0; i<wPtr->numColumns; i++) {
	HListHeader * hPtr = wPtr->headers[i];
	width = wPtr->actualSize[i].width;

	if (i == wPtr->numColumns-1) {
	    /* If the widget is wider than required,
	     * We need to extend the last item to the end of the list,
	     * or otherwise we'll see a curtailed header
	     */
	    if (drawnWidth + width <hdrW) {
		width = hdrW - drawnWidth;
	    }
	}

        Tk_Fill3DRectangle(wPtr->dispData.tkwin, pixmap, hPtr->background,
	    x, y, width, wPtr->headerHeight, hPtr->borderWidth,
	    hPtr->relief);

	/* Note when we draw the item, we use the
	 * wPtr->actualSize[i].width instead of the (possibly extended) width
	 * so that the header is well-aligned with the element columns.
	 */
	if (hPtr->iPtr) {
	    int itemX, itemY;
	    itemX = x+hPtr->borderWidth;
	    itemY = y+hPtr->borderWidth;

	    if (Tix_DItemType(hPtr->iPtr) == TIX_DITEM_WINDOW) {
		itemX += winItemExtra;
		itemY += winItemExtra;
	    }

	    Tix_DItemDisplay(pixmap, gc, hPtr->iPtr,
	        itemX, itemY,
		wPtr->actualSize[i].width - 2*hPtr->borderWidth,
		wPtr->headerHeight        - 2*hPtr->borderWidth,
		TIX_DITEM_NORMAL_FG);

	    if (wPtr->needToRaise &&
		Tix_DItemType(hPtr->iPtr) == TIX_DITEM_WINDOW) {
		TixWindowItem * wiPtr;

		wiPtr = (TixWindowItem *)hPtr->iPtr;
		if (Tk_WindowId(wiPtr->tkwin) == None) {
		    Tk_MakeWindowExist(wiPtr->tkwin);
		}

		XRaiseWindow(Tk_Display(wiPtr->tkwin),
		    Tk_WindowId(wiPtr->tkwin));
	    }
	}

	x += width;
	drawnWidth += width;

#if 0
	/* %% funny, doesn't work */
	if (drawnWidth >= hdrW) {
	    /* The rest is invisible. Don't bother to draw */
	    break;
	}
#endif
    }

    wPtr->needToRaise = 0;
}

void Tix_HLComputeHeaderGeometry(wPtr)
    WidgetPtr wPtr;
{
    int i;

    wPtr->headerHeight = 0;

    for (i=0; i<wPtr->numColumns; i++) {
	int height;
	int width;

	if (wPtr->headers[i]->iPtr) {
	    width  = Tix_DItemWidth (wPtr->headers[i]->iPtr);
	    height = Tix_DItemHeight(wPtr->headers[i]->iPtr);
	} else {
	    width  = 0;
	    height = 0;
	}

	width  += wPtr->headers[i]->borderWidth * 2;
	height += wPtr->headers[i]->borderWidth * 2;

	wPtr->headers[i]->width = width;

	if (height > wPtr->headerHeight) {
	    wPtr->headerHeight = height;
	}
    }

    wPtr->headerDirty = 0;
}

/*----------------------------------------------------------------------
 * "header" sub command
 *----------------------------------------------------------------------
 */
int
Tix_HLHeader(clientData, interp, argc, argv)
    ClientData clientData;
    Tcl_Interp *interp;		/* Current interpreter. */
    int argc;			/* Number of arguments. */
    char **argv;		/* Argument strings. */
{
    static Tix_SubCmdInfo subCmdInfo[] = {
	{TIX_DEFAULT_LEN, "cget", 2, 2, Tix_HLHdrCGet,
	   "column option"},
	{TIX_DEFAULT_LEN, "configure", 1, TIX_VAR_ARGS, Tix_HLHdrConfig,
	   "column ?option? ?value ...?"},
	{TIX_DEFAULT_LEN, "create", 1, TIX_VAR_ARGS, Tix_HLHdrCreate,
	   "column ?option value ...?"},
	{TIX_DEFAULT_LEN, "delete", 1, 1, Tix_HLHdrDelete,
	   "column"},
	{TIX_DEFAULT_LEN, "exists", 1, 1, Tix_HLHdrExist,
	   "column"},
	{TIX_DEFAULT_LEN, "size", 1, 1, Tix_HLHdrSize,
	   "column"},
	{TIX_DEFAULT_LEN, "height", 0, 0, Tix_HLHdrHeight,
	   ""},
    };
    static Tix_CmdInfo cmdInfo = {
	Tix_ArraySize(subCmdInfo), 1, TIX_VAR_ARGS, "?option? ?arg ...?",
    };

    return Tix_HandleSubCmds(&cmdInfo, subCmdInfo, clientData,
	interp, argc+1, argv-1);
}

/*----------------------------------------------------------------------
 * "header cget" sub command
 *----------------------------------------------------------------------
 */
static int
Tix_HLHdrCGet(clientData, interp, argc, argv)
    ClientData clientData;
    Tcl_Interp *interp;		/* Current interpreter. */
    int argc;			/* Number of arguments. */
    char **argv;		/* Argument strings. */
{
    WidgetPtr wPtr = (WidgetPtr) clientData;
    HListHeader * hPtr;

    if ((hPtr=Tix_HLGetHeader(interp, wPtr, objv[0], 1)) == NULL) {
	return TCL_ERROR;
    }

    return Tix_ConfigureValue2(interp, wPtr->dispData.tkwin,
	(char*)hPtr, headerConfigSpecs, hPtr->iPtr, argv[1], 0);
}

/*----------------------------------------------------------------------
 * "header configure" sub command
 *----------------------------------------------------------------------
 */
static int
Tix_HLHdrConfig(clientData, interp, argc, argv)
    ClientData clientData;
    Tcl_Interp *interp;		/* Current interpreter. */
    int argc;			/* Number of arguments. */
    char **argv;		/* Argument strings. */
{
    WidgetPtr wPtr = (WidgetPtr) clientData;
    HListHeader * hPtr;

    if ((hPtr=Tix_HLGetHeader(interp, wPtr, objv[0], 1)) == NULL) {
	return TCL_ERROR;
    }

    if (argc == 1) {
	return Tix_ConfigureInfo2(interp, wPtr->dispData.tkwin,
	    (char*)hPtr, headerConfigSpecs, hPtr->iPtr,
	    (char *) NULL, 0);
    } else if (argc == 2) {
	return Tix_ConfigureInfo2(interp, wPtr->dispData.tkwin,
	    (char*)hPtr, headerConfigSpecs, hPtr->iPtr,
	    (char *) argv[1], 0);
    } else {
	int sizeChanged = 0;

	if (Tix_WidgetConfigure2(interp, wPtr->dispData.tkwin,
	    (char*)hPtr, headerConfigSpecs, hPtr->iPtr,
	    argc-1, argv+1, TK_CONFIG_ARGV_ONLY, 0, &sizeChanged) != TCL_OK) {
	    return TCL_ERROR;
	}
	if (sizeChanged) {
	    wPtr->headerDirty = 1;
	    Tix_HLResizeWhenIdle(wPtr);
	}
	return TCL_OK;
    }
}


/*----------------------------------------------------------------------
 * "header create" sub command
 *----------------------------------------------------------------------
 */
static int
Tix_HLHdrCreate(clientData, interp, argc, argv)
    ClientData clientData;
    Tcl_Interp *interp;		/* Current interpreter. */
    int argc;			/* Number of arguments. */
    char **argv;		/* Argument strings. */
{
    WidgetPtr wPtr = (WidgetPtr) clientData;
    HListHeader * hPtr;
    int i;
    Tix_DItem * iPtr;
    char * ditemType = NULL;

    if ((hPtr=Tix_HLGetHeader(interp, wPtr, objv[0], 0)) == NULL) {
	return TCL_ERROR;
    }

    if ((argc %2) == 0) {
	Tcl_AppendResult(interp, "value for \"", argv[argc-1],
	    "\" missing", NULL);
	return TCL_ERROR;
    }
    for (i=1; i<argc; i+=2) {
	if (strncmp(argv[i], "-itemtype", strlen(argv[i])) == 0) {
	    ditemType = argv[i+1];
	}
    }
    if (ditemType == NULL) {
	ditemType = wPtr->diTypePtr->name;
    }

    iPtr = Tix_DItemCreate(&wPtr->dispData, ditemType);
    if (iPtr == NULL) {
	return TCL_ERROR;
    }
    if (Tix_DItemType(iPtr) == TIX_DITEM_WINDOW) {
	wPtr->needToRaise = 1;
    }

    /*
     * mark clientData to NULL. This will tell DItemSizeChanged()
     * that ths item belongs to the header
     */
    iPtr->base.clientData = (ClientData)hPtr;

    if (hPtr->iPtr != NULL) {
	if (Tix_DItemType(hPtr->iPtr) == TIX_DITEM_WINDOW) {
	    FreeWindowItem(interp, wPtr, hPtr);
	}
	Tix_DItemFree(hPtr->iPtr);
    }
    hPtr->iPtr = iPtr;

    if (Tix_WidgetConfigure2(wPtr->dispData.interp, wPtr->dispData.tkwin,
	(char*)hPtr, headerConfigSpecs, hPtr->iPtr, argc-1, argv+1, 0,
	1, NULL) != TCL_OK) {
	return TCL_ERROR;
    }


    wPtr->headerDirty = 1;
    Tix_HLResizeWhenIdle(wPtr);

    return TCL_OK;
}
/*----------------------------------------------------------------------
 * "header delete" sub command
 *----------------------------------------------------------------------
 */
static int
Tix_HLHdrDelete(clientData, interp, argc, argv)
    ClientData clientData;
    Tcl_Interp *interp;		/* Current interpreter. */
    int argc;			/* Number of arguments. */
    char **argv;		/* Argument strings. */
{
    WidgetPtr wPtr = (WidgetPtr) clientData;
    HListHeader * hPtr;

    if ((hPtr=Tix_HLGetHeader(interp, wPtr, objv[0], 1)) == NULL) {
	return TCL_ERROR;
    }

    if (Tix_DItemType(hPtr->iPtr) == TIX_DITEM_WINDOW) {
	FreeWindowItem(interp, wPtr, hPtr);
    }

    /* Free the item and leave a blank! */
    Tix_DItemFree(hPtr->iPtr);
    hPtr->iPtr = NULL;

    wPtr->headerDirty = 1;
    Tix_HLResizeWhenIdle(wPtr);

    return TCL_OK;
}
/*----------------------------------------------------------------------
 * "header exist" sub command
 *----------------------------------------------------------------------
 */
static int
Tix_HLHdrExist(clientData, interp, argc, argv)
    ClientData clientData;
    Tcl_Interp *interp;		/* Current interpreter. */
    int argc;			/* Number of arguments. */
    char **argv;		/* Argument strings. */
{
    WidgetPtr wPtr = (WidgetPtr) clientData;
    HListHeader * hPtr;

    if ((hPtr=Tix_HLGetHeader(interp, wPtr, objv[0], 0)) == NULL) {
	return TCL_ERROR;
    }

    if (hPtr->iPtr == NULL) {
	Tcl_AppendResult(interp, "0", NULL);
    } else {
	Tcl_AppendResult(interp, "1", NULL);
    }

    return TCL_OK;
}

/*----------------------------------------------------------------------
 * "header size" sub command
 *----------------------------------------------------------------------
 */
static int
Tix_HLHdrSize(clientData, interp, argc, argv)
    ClientData clientData;
    Tcl_Interp *interp;		/* Current interpreter. */
    int argc;			/* Number of arguments. */
    char **argv;		/* Argument strings. */
{
    WidgetPtr wPtr = (WidgetPtr) clientData;
    HListHeader * hPtr;

    if ((hPtr=Tix_HLGetHeader(interp, wPtr, objv[0], 1)) == NULL) {
	return TCL_ERROR;
    }

    if (hPtr->iPtr == NULL) {
	Tcl_AppendResult(interp, "entry \"", argv[0],
	    "\" does not have a header", (char*)NULL);
	return TCL_ERROR;
    }
    Tcl_IntResults(interp,2, 0,
		   Tix_DItemWidth(hPtr->iPtr),
		   Tix_DItemHeight(hPtr->iPtr));
    return TCL_OK;
}

/*----------------------------------------------------------------------
 * "header height" sub command
 *----------------------------------------------------------------------
 */
static int
Tix_HLHdrHeight(clientData, interp, argc, argv)
    ClientData clientData;
    Tcl_Interp *interp;		/* Current interpreter. */
    int argc;			/* Number of arguments. */
    char **argv;		/* Argument strings. */
{
    WidgetPtr wPtr = (WidgetPtr) clientData;

    if (wPtr->headerDirty) {
	Tix_HLComputeHeaderGeometry(wPtr);
    }

    Tcl_SetObjResult(interp,Tcl_NewIntObj(wPtr->headerHeight));
    return TCL_OK;
}