URL https://opencores.org/ocsvn/or1k/or1k/trunk
Subversion Repositories or1k

[/] [or1k/] [trunk/] [insight/] [tix/] [generic/] [tixHList.c] - Blame information for rev 1781

Go to most recent revision | Details | Compare with Previous | View Log

/*
 * tixHList.c --
 *
 *      This module implements "HList" 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>
 
/*
 * Information used for argv parsing.
 */
 
static Tk_ConfigSpec configSpecs[] = {
    {TK_CONFIG_COLOR, "-background", "background", "Background",
       DEF_HLIST_BG_COLOR, Tk_Offset(WidgetRecord, normalBg),
       TK_CONFIG_COLOR_ONLY},
 
    {TK_CONFIG_COLOR, "-background", "background", "Background",
       DEF_HLIST_BG_MONO, Tk_Offset(WidgetRecord, normalBg),
       TK_CONFIG_MONO_ONLY},
 
    {TK_CONFIG_SYNONYM, "-bd", "borderWidth", (char *) NULL,
       (char *) NULL, 0, 0},
 
    {TK_CONFIG_SYNONYM, "-bg", "background", (char *) NULL,
       (char *) NULL, 0, 0},
 
    {TK_CONFIG_PIXELS, "-borderwidth", "borderWidth", "BorderWidth",
       DEF_HLIST_BORDER_WIDTH, Tk_Offset(WidgetRecord, borderWidth), 0},
 
    {TK_CONFIG_STRING, "-browsecmd", "browseCmd", "BrowseCmd",
        DEF_HLIST_BROWSE_COMMAND, Tk_Offset(WidgetRecord, browseCmd),
        TK_CONFIG_NULL_OK},
 
    {TK_CONFIG_INT, "-columns", "columns", "Columns",
       DEF_HLIST_COLUMNS, Tk_Offset(WidgetRecord, numColumns),
       TK_CONFIG_NULL_OK},
 
    {TK_CONFIG_STRING, "-command", "command", "Command",
       DEF_HLIST_COMMAND, Tk_Offset(WidgetRecord, command),
       TK_CONFIG_NULL_OK},
 
    {TK_CONFIG_ACTIVE_CURSOR, "-cursor", "cursor", "Cursor",
       DEF_HLIST_CURSOR, Tk_Offset(WidgetRecord, cursor),
       TK_CONFIG_NULL_OK},
 
    {TK_CONFIG_STRING, "-dragcmd", "dragCmd", "DragCmd",
        DEF_HLIST_DRAG_COMMAND, Tk_Offset(WidgetRecord, dragCmd),
        TK_CONFIG_NULL_OK},
 
    {TK_CONFIG_BOOLEAN, "-drawbranch", "drawBranch", "DrawBranch",
       DEF_HLIST_DRAW_BRANCH, Tk_Offset(WidgetRecord, drawBranch), 0},
 
    {TK_CONFIG_STRING, "-dropcmd", "dropCmd", "DropCmd",
        DEF_HLIST_DROP_COMMAND, Tk_Offset(WidgetRecord, dropCmd),
        TK_CONFIG_NULL_OK},
 
    {TK_CONFIG_SYNONYM, "-fg", "foreground", (char *) NULL,
       (char *) NULL, 0, 0},
 
    {TK_CONFIG_FONT, "-font", "font", "Font",
       DEF_HLIST_FONT, Tk_Offset(WidgetRecord, font), 0},
 
    {TK_CONFIG_COLOR, "-foreground", "foreground", "Foreground",
       DEF_HLIST_FG_COLOR, Tk_Offset(WidgetRecord, normalFg),
       TK_CONFIG_COLOR_ONLY},
 
    {TK_CONFIG_COLOR, "-foreground", "foreground", "Foreground",
       DEF_HLIST_FG_MONO, Tk_Offset(WidgetRecord, normalFg),
       TK_CONFIG_MONO_ONLY},
 
    {TK_CONFIG_PIXELS, "-gap", "gap", "Gap",
       DEF_HLIST_GAP, Tk_Offset(WidgetRecord, gap), 0},
 
    {TK_CONFIG_BOOLEAN, "-header", "header", "Header",
       DEF_HLIST_HEADER, Tk_Offset(WidgetRecord, useHeader), 0},
 
    {TK_CONFIG_INT, "-height", "height", "Height",
       DEF_HLIST_HEIGHT, Tk_Offset(WidgetRecord, height), 0},
 
    {TK_CONFIG_BORDER, "-highlightbackground", "highlightBackground",
       "HighlightBackground",
       DEF_HLIST_BG_COLOR, Tk_Offset(WidgetRecord, border),
       TK_CONFIG_COLOR_ONLY},
 
    {TK_CONFIG_BORDER, "-highlightbackground", "highlightBackground",
       "HighlightBackground",
       DEF_HLIST_BG_MONO, Tk_Offset(WidgetRecord, border),
       TK_CONFIG_MONO_ONLY},
 
    {TK_CONFIG_COLOR, "-highlightcolor", "highlightColor", "HighlightColor",
       DEF_HLIST_HIGHLIGHT_COLOR, Tk_Offset(WidgetRecord, highlightColorPtr),
       TK_CONFIG_COLOR_ONLY},
 
    {TK_CONFIG_COLOR, "-highlightcolor", "highlightColor", "HighlightColor",
       DEF_HLIST_HIGHLIGHT_MONO, Tk_Offset(WidgetRecord, highlightColorPtr),
       TK_CONFIG_MONO_ONLY},
 
    {TK_CONFIG_PIXELS, "-highlightthickness", "highlightThickness",
        "HighlightThickness",
        DEF_HLIST_HIGHLIGHT_WIDTH, Tk_Offset(WidgetRecord, highlightWidth), 0},
 
    {TK_CONFIG_PIXELS, "-indent", "indent", "Indent",
       DEF_HLIST_INDENT, Tk_Offset(WidgetRecord, indent), 0},
 
    {TK_CONFIG_BOOLEAN, "-indicator", "indicator", "Indicator",
       DEF_HLIST_INDICATOR, Tk_Offset(WidgetRecord, useIndicator), 0},
 
    {TK_CONFIG_STRING, "-indicatorcmd", "indicatorCmd", "IndicatorCmd",
        DEF_HLIST_INDICATOR_CMD, Tk_Offset(WidgetRecord, indicatorCmd),
        TK_CONFIG_NULL_OK},
 
    {TK_CONFIG_CUSTOM, "-itemtype", "itemType", "ItemType",
       DEF_HLIST_ITEM_TYPE, Tk_Offset(WidgetRecord, diTypePtr),
       0, &tixConfigItemType},
 
     {TK_CONFIG_PIXELS, "-padx", "padX", "Pad",
        DEF_HLIST_PADX, Tk_Offset(WidgetRecord, padX), 0},
 
    {TK_CONFIG_PIXELS, "-pady", "padY", "Pad",
        DEF_HLIST_PADY, Tk_Offset(WidgetRecord, padY), 0},
 
    {TK_CONFIG_RELIEF, "-relief", "relief", "Relief",
       DEF_HLIST_RELIEF, Tk_Offset(WidgetRecord, relief), 0},
 
    {TK_CONFIG_BORDER, "-selectbackground", "selectBackground", "Foreground",
        DEF_HLIST_SELECT_BG_COLOR, Tk_Offset(WidgetRecord, selectBorder),
        TK_CONFIG_COLOR_ONLY},
 
    {TK_CONFIG_BORDER, "-selectbackground", "selectBackground", "Foreground",
        DEF_HLIST_SELECT_BG_MONO, Tk_Offset(WidgetRecord, selectBorder),
        TK_CONFIG_MONO_ONLY},
 
    {TK_CONFIG_PIXELS, "-selectborderwidth", "selectBorderWidth","BorderWidth",
       DEF_HLIST_SELECT_BORDERWIDTH,Tk_Offset(WidgetRecord, selBorderWidth),0},
 
    {TK_CONFIG_COLOR, "-selectforeground", "selectForeground", "Background",
       DEF_HLIST_SELECT_FG_COLOR, Tk_Offset(WidgetRecord, selectFg),
       TK_CONFIG_COLOR_ONLY},
 
    {TK_CONFIG_COLOR, "-selectforeground", "selectForeground", "Background",
       DEF_HLIST_SELECT_FG_MONO, Tk_Offset(WidgetRecord, selectFg),
       TK_CONFIG_MONO_ONLY},
 
    {TK_CONFIG_UID, "-selectmode", "selectMode", "SelectMode",
        DEF_HLIST_SELECT_MODE, Tk_Offset(WidgetRecord, selectMode), 0},
 
    {TK_CONFIG_STRING, "-separator", "separator", "Separator",
       DEF_HLIST_SEPARATOR, Tk_Offset(WidgetRecord, separator), 0},
 
    {TK_CONFIG_STRING, "-sizecmd", "sizeCmd", "SizeCmd",
       DEF_HLIST_SIZE_COMMAND, Tk_Offset(WidgetRecord, sizeCmd),
       TK_CONFIG_NULL_OK},
 
    {TK_CONFIG_STRING, "-takefocus", "takeFocus", "TakeFocus",
        DEF_HLIST_TAKE_FOCUS, Tk_Offset(WidgetRecord, takeFocus),
        TK_CONFIG_NULL_OK},
 
    {TK_CONFIG_BOOLEAN, "-wideselection", "wideSelection", "WideSelection",
       DEF_HLIST_WIDE_SELECT, Tk_Offset(WidgetRecord, wideSelect), 0},
 
    {TK_CONFIG_INT, "-width", "width", "Width",
        DEF_HLIST_WIDTH, Tk_Offset(WidgetRecord, width), 0},
 
    {TK_CONFIG_STRING, "-xscrollcommand", "xScrollCommand", "ScrollCommand",
        DEF_HLIST_X_SCROLL_COMMAND, Tk_Offset(WidgetRecord, xScrollCmd),
        TK_CONFIG_NULL_OK},
 
    {TK_CONFIG_STRING, "-yscrollcommand", "yScrollCommand", "ScrollCommand",
        DEF_HLIST_Y_SCROLL_COMMAND, Tk_Offset(WidgetRecord, yScrollCmd),
        TK_CONFIG_NULL_OK},
 
    {TK_CONFIG_END, (char *) NULL, (char *) NULL, (char *) NULL,
        (char *) NULL, 0, 0}
};
 
static Tk_ConfigSpec entryConfigSpecs[] = {
    {TK_CONFIG_STRING, "-data", (char *) NULL, (char *) NULL,
       DEF_HLISTENTRY_DATA, Tk_Offset(HListElement, data), TK_CONFIG_NULL_OK},
 
    {TK_CONFIG_UID, "-state", (char*)NULL, (char*)NULL,
       DEF_HLISTENTRY_STATE, Tk_Offset(HListElement, state), 0},
 
    {TK_CONFIG_END, (char *) NULL, (char *) NULL, (char *) NULL,
       (char *) NULL, 0, 0}
};
 
/*
 * Forward declarations for procedures defined later in this file:
 */
        /* These are standard procedures for TK widgets
         * implemeted in C
         */
 
static void             WidgetCmdDeletedProc _ANSI_ARGS_((
                            ClientData clientData));
static int              WidgetConfigure _ANSI_ARGS_((Tcl_Interp *interp,
                            WidgetPtr wPtr, int argc, char **argv,
                            int flags));
static void             WidgetDestroy _ANSI_ARGS_((ClientData clientData));
static void             WidgetEventProc _ANSI_ARGS_((ClientData clientData,
                            XEvent *eventPtr));
static int              WidgetCommand _ANSI_ARGS_((ClientData clientData,
                            Tcl_Interp *, int argc, char **argv));
static void             WidgetDisplay _ANSI_ARGS_((ClientData clientData));
 
        /* Extra procedures for this widget
         */
static HListElement *   AllocElement _ANSI_ARGS_((WidgetPtr wPtr,
                            HListElement * parent, char * pathName,
                            char * name, char * ditemType));
static void             AppendList _ANSI_ARGS_((WidgetPtr wPtr,
                            HListElement *parent, HListElement *chPtr, int at,
                            HListElement *afterPtr,
                            HListElement *beforePtr));
static void             CancelRedrawWhenIdle _ANSI_ARGS_((
                            WidgetPtr wPtr));
static void             CheckScrollBar _ANSI_ARGS_((WidgetPtr wPtr,
                            int which));
static void             ComputeBranchPosition _ANSI_ARGS_((
                            WidgetPtr wPtr, HListElement *chPtr));
static void             ComputeElementGeometry _ANSI_ARGS_((WidgetPtr wPtr,
                            HListElement *chPtr, int indent));
static void             ComputeOneElementGeometry _ANSI_ARGS_((WidgetPtr wPtr,
                            HListElement *chPtr, int indent));
static int              ConfigElement _ANSI_ARGS_((WidgetPtr wPtr,
                            HListElement *chPtr, int argc, char ** argv,
                            int flags, int forced));
static int              CurSelection _ANSI_ARGS_((Tcl_Interp * interp,
                            WidgetPtr wPtr, HListElement * chPtr));
static void             DeleteNode _ANSI_ARGS_((WidgetPtr wPtr,
                            HListElement * chPtr));
static void             DeleteOffsprings _ANSI_ARGS_((WidgetPtr wPtr,
                            HListElement * chPtr));
static void             DeleteSiblings _ANSI_ARGS_((WidgetPtr wPtr,
                            HListElement * chPtr));
static void             DrawElements _ANSI_ARGS_((WidgetPtr wPtr,
                            Pixmap pixmap, GC gc, HListElement * chPtr,
                            int x, int y, int xOffset));
static void             DrawOneElement _ANSI_ARGS_((WidgetPtr wPtr,
                            Pixmap pixmap, GC gc, HListElement * chPtr,
                            int x, int y, int xOffset));
static HListElement *   FindElementAtPosition _ANSI_ARGS_((WidgetPtr wPtr,
                            int y));
static HListElement *   FindNextEntry  _ANSI_ARGS_((WidgetPtr wPtr,
                            HListElement * chPtr));
static HListElement *   FindPrevEntry  _ANSI_ARGS_((WidgetPtr wPtr,
                            HListElement * chPtr));
static void             FreeElement _ANSI_ARGS_((WidgetPtr wPtr,
                            HListElement * chPtr));
static HListElement *   NewElement _ANSI_ARGS_((Tcl_Interp *interp,
                            WidgetPtr wPtr, int argc, char ** argv,
                            char * pathName, char * defParentName,
                            int * newArgc));
static void             RedrawWhenIdle _ANSI_ARGS_((WidgetPtr wPtr));
static int              XScrollByPages _ANSI_ARGS_((WidgetPtr wPtr,
                            int count));
static int              XScrollByUnits _ANSI_ARGS_((WidgetPtr wPtr,
                            int count));
static int              YScrollByPages _ANSI_ARGS_((WidgetPtr wPtr,
                            int count));
static int              YScrollByUnits _ANSI_ARGS_((WidgetPtr wPtr,
                            int count));
static int              SelectionModifyRange _ANSI_ARGS_((WidgetPtr wPtr,
                            HListElement * from, HListElement * to,
                            int select));
static void             SelectionAdd _ANSI_ARGS_((WidgetPtr wPtr,
                            HListElement * chPtr));
static void             HL_SelectionClear _ANSI_ARGS_((WidgetPtr wPtr,
                            HListElement * chPtr));
static void             HL_SelectionClearAll _ANSI_ARGS_((WidgetPtr wPtr,
                            HListElement * chPtr, int *changed_ret));
static void             HL_SelectionClearNotifyAncestors _ANSI_ARGS_((
                            WidgetPtr wPtr, HListElement * chPtr));
static void             SelectionNotifyAncestors _ANSI_ARGS_((
                            WidgetPtr wPtr, HListElement * chPtr));
static void             UpdateOneScrollBar _ANSI_ARGS_((WidgetPtr wPtr,
                            char * command, int total, int window, int first));
static void             UpdateScrollBars _ANSI_ARGS_((WidgetPtr wPtr,
                            int sizeChanged));
static void             DItemSizeChangedProc _ANSI_ARGS_((
                            Tix_DItem *iPtr));
static void             SubWindowEventProc _ANSI_ARGS_((ClientData clientData,
                            XEvent *eventPtr));
static void             GetScrollFractions _ANSI_ARGS_((int total,
                            int window, int first, double * first_ret,
                            double * last_ret));
static int              Tix_HLSeeElement _ANSI_ARGS_((
                            WidgetPtr wPtr, HListElement * chPtr,
                            int callRedraw));
static int              Tix_HLBBox _ANSI_ARGS_((Tcl_Interp * interp,
                            WidgetPtr wPtr, HListElement * chPtr));
 
static TIX_DECLARE_SUBCMD(Tix_HLAdd);
static TIX_DECLARE_SUBCMD(Tix_HLAddChild);
static TIX_DECLARE_SUBCMD(Tix_HLCGet);
static TIX_DECLARE_SUBCMD(Tix_HLConfig);
static TIX_DECLARE_SUBCMD(Tix_HLDelete);
static TIX_DECLARE_SUBCMD(Tix_HLEntryCget);
static TIX_DECLARE_SUBCMD(Tix_HLEntryConfig);
static TIX_DECLARE_SUBCMD(Tix_HLGeometryInfo);
static TIX_DECLARE_SUBCMD(Tix_HLHide);
static TIX_DECLARE_SUBCMD(Tix_HLInfo);
static TIX_DECLARE_SUBCMD(Tix_HLNearest);
static TIX_DECLARE_SUBCMD(Tix_HLSee);
static TIX_DECLARE_SUBCMD(Tix_HLSelection);
static TIX_DECLARE_SUBCMD(Tix_HLSetSite);
static TIX_DECLARE_SUBCMD(Tix_HLShow);
static TIX_DECLARE_SUBCMD(Tix_HLXView);
static TIX_DECLARE_SUBCMD(Tix_HLYView);
 
 
 
/*
 *--------------------------------------------------------------
 *
 * Tix_HListCmd --
 *
 *      This procedure is invoked to process the "HList" Tcl
 *      command.  It creates a new "HList" widget.
 *
 * Results:
 *      A standard Tcl result.
 *
 * Side effects:
 *      A new widget is created and configured.
 *
 *--------------------------------------------------------------
 */
int
Tix_HListCmd(clientData, interp, argc, argv)
    ClientData clientData;
    Tcl_Interp *interp;         /* Current interpreter. */
    int argc;                   /* Number of arguments. */
    char **argv;                /* Argument strings. */
{
    Tk_Window main = (Tk_Window) clientData;
    WidgetPtr wPtr;
    Tk_Window tkwin, subwin;
 
    if (argc < 2) {
        Tcl_AppendResult(interp, "wrong # args:  should be \"",
                argv[0], " pathName ?options?\"", (char *) NULL);
        return TCL_ERROR;
    }
 
    /*
     * Allocate the main window for this window. Then allocate a subwindow
     * to act as the header. The subwidget will always be raised to the top
     * so that it won't be obscured by any window items
     */
    tkwin = Tk_CreateWindowFromPath(interp, main, argv[1], (char *) NULL);
    if (tkwin == NULL) {
        return TCL_ERROR;
    }
    subwin = Tix_CreateSubWindow(interp, tkwin, "header");
    if (subwin == NULL) {
        Tk_DestroyWindow(tkwin);
        return TCL_ERROR;
    }
 
    Tk_SetClass(tkwin, "TixHList");
    Tk_SetClass(subwin, "TixHListHeader");
 
    /*
     * Allocate and initialize the widget record.
     */
    wPtr = (WidgetPtr) ckalloc(sizeof(WidgetRecord));
 
    /* Init the hash table first (needed before calling AllocElement) */
    Tcl_InitHashTable(&wPtr->childTable, TCL_STRING_KEYS);
 
    wPtr->dispData.tkwin        = tkwin;
    wPtr->dispData.display      = Tk_Display(tkwin);
    wPtr->dispData.interp       = interp;
    wPtr->dispData.sizeChangedProc = DItemSizeChangedProc;
    wPtr->font                  = NULL;
    wPtr->normalBg              = NULL;
    wPtr->normalFg              = NULL;
    wPtr->border                = NULL;
    wPtr->borderWidth           = 0;
    wPtr->selectBorder          = NULL;
    wPtr->selBorderWidth        = 0;
    wPtr->selectFg              = NULL;
    wPtr->backgroundGC          = None;
    wPtr->normalGC              = None;
    wPtr->selectGC              = None;
    wPtr->anchorGC              = None;
    wPtr->dropSiteGC            = None;
    wPtr->highlightWidth        = 0;
    wPtr->highlightColorPtr     = NULL;
    wPtr->highlightGC           = None;
    wPtr->relief                = TK_RELIEF_FLAT;
    wPtr->cursor                = None;
    wPtr->indent                = 0;
    wPtr->resizing              = 0;
    wPtr->redrawing             = 0;
    wPtr->hasFocus              = 0;
    wPtr->topPixel              = 0;
    wPtr->leftPixel             = 0;
    wPtr->separator             = NULL;
    wPtr->selectMode            = NULL;
    wPtr->anchor                = NULL;
    wPtr->dragSite              = NULL;
    wPtr->dropSite              = NULL;
    wPtr->command               = NULL;
    wPtr->browseCmd             = NULL;
    wPtr->sizeCmd               = NULL;
    wPtr->dragCmd               = NULL;
    wPtr->dropCmd               = NULL;
    wPtr->takeFocus             = NULL;
    wPtr->xScrollCmd            = NULL;
    wPtr->yScrollCmd            = NULL;
    wPtr->scrollUnit[0]          = 1;
    wPtr->scrollUnit[1]         = 1;
    wPtr->serial                = 0;
    wPtr->numColumns            = 1;
    wPtr->initialized           = 0;
    wPtr->allDirty              = 0;
    wPtr->headerDirty           = 0;
    wPtr->needToRaise           = 0;
    wPtr->drawBranch            = 1;
    wPtr->wideSelect            = 0;
    wPtr->diTypePtr             = NULL;
    wPtr->reqSize               = NULL;
    wPtr->actualSize            = NULL;
    wPtr->root                  = NULL;
    wPtr->totalSize[0]           = 1;
    wPtr->totalSize[1]          = 1;
    wPtr->useIndicator          = 0;
    wPtr->indicatorCmd          = NULL;
    wPtr->headers               = NULL;
    wPtr->useHeader             = 0;
    wPtr->headerHeight          = 0;
    wPtr->headerWin             = subwin;
    wPtr->elmToSee              = 0;
 
    Tix_LinkListInit(&wPtr->mappedWindows);
 
    Tk_CreateEventHandler(wPtr->dispData.tkwin,
        ExposureMask|StructureNotifyMask|FocusChangeMask,
        WidgetEventProc, (ClientData) wPtr);
    Tk_CreateEventHandler(wPtr->headerWin,
        ExposureMask|StructureNotifyMask,
        SubWindowEventProc, (ClientData) wPtr);
 
    wPtr->widgetCmd = Tcl_CreateCommand(interp,
        Tk_PathName(wPtr->dispData.tkwin), WidgetCommand, (ClientData) wPtr,
        WidgetCmdDeletedProc);
    if (WidgetConfigure(interp, wPtr, argc-2, argv+2, 0) != TCL_OK) {
        Tk_DestroyWindow(wPtr->dispData.tkwin);
        return TCL_ERROR;
    }
    if (Tix_HLCreateHeaders(interp, wPtr) != TCL_OK) {
        Tk_DestroyWindow(wPtr->dispData.tkwin);
        return TCL_ERROR;
    }
 
    /* Must call this **after** wPtr->numColumns is set */
    wPtr->reqSize    = Tix_HLAllocColumn(wPtr, NULL);
    wPtr->actualSize = Tix_HLAllocColumn(wPtr, NULL);
    wPtr->root       = AllocElement(wPtr, 0, 0, 0, 0);
 
    wPtr->initialized = 1;
 
    interp->result = Tk_PathName(wPtr->dispData.tkwin);
    return TCL_OK;
}
 
/*
 *--------------------------------------------------------------
 *
 * WidgetCommand --
 *
 *      This procedure is invoked to process the Tcl command
 *      that corresponds to a widget managed by this module.
 *      See the user documentation for details on what it does.
 *
 * Results:
 *      A standard Tcl result.
 *
 * Side effects:
 *      See the user documentation.
 *
 *--------------------------------------------------------------
 */
 
static int
WidgetCommand(clientData, interp, argc, argv)
    ClientData clientData;              /* Information about the widget. */
    Tcl_Interp *interp;                 /* Current interpreter. */
    int argc;                           /* Number of arguments. */
    char **argv;                        /* Argument strings. */
{
    int code;
 
    static Tix_SubCmdInfo subCmdInfo[] = {
        {TIX_DEFAULT_LEN, "add", 1, TIX_VAR_ARGS, Tix_HLAdd,
           "entryPath"},
        {TIX_DEFAULT_LEN, "addchild", 1, TIX_VAR_ARGS, Tix_HLAddChild,
           "parentEntryPath"},
        {TIX_DEFAULT_LEN, "anchor", 1, 2, Tix_HLSetSite,
           "option ?entryPath?"},
        {TIX_DEFAULT_LEN, "cget", 1, 1, Tix_HLCGet,
           "option"},
        {TIX_DEFAULT_LEN, "column", 0, TIX_VAR_ARGS, Tix_HLColumn,
           "?option? ?args ...?"},
        {TIX_DEFAULT_LEN, "configure", 0, TIX_VAR_ARGS, Tix_HLConfig,
           "?option? ?value? ?option value ... ?"},
        {TIX_DEFAULT_LEN, "delete", 1, 2, Tix_HLDelete,
           "option ?entryPath?"},
        {TIX_DEFAULT_LEN, "dragsite", 1, 2, Tix_HLSetSite,
           "option ?entryPath?"},
        {TIX_DEFAULT_LEN, "dropsite", 1, 2, Tix_HLSetSite,
           "option ?entryPath?"},
        {TIX_DEFAULT_LEN, "entrycget", 2, 2, Tix_HLEntryCget,
           "entryPath option"},
        {TIX_DEFAULT_LEN, "entryconfigure", 1, TIX_VAR_ARGS, Tix_HLEntryConfig,
           "entryPath ?option? ?value? ?option value ... ?"},
        {TIX_DEFAULT_LEN, "geometryinfo", 0, 2, Tix_HLGeometryInfo,
           "?width height?"},
        {TIX_DEFAULT_LEN, "header", 1, TIX_VAR_ARGS, Tix_HLHeader,
           "option ?args ...?"},
        {TIX_DEFAULT_LEN, "hide", 2, 2, Tix_HLHide,
           "option entryPath"},
        {TIX_DEFAULT_LEN, "item", 0, TIX_VAR_ARGS, Tix_HLItem,
           "?option? ?args ...?"},
        {TIX_DEFAULT_LEN, "indicator", 1, TIX_VAR_ARGS, Tix_HLIndicator,
           "option ?args ...?"},
        {TIX_DEFAULT_LEN, "info", 1, TIX_VAR_ARGS, Tix_HLInfo,
           "option ?args ...?"},
        {TIX_DEFAULT_LEN, "nearest", 1, 1, Tix_HLNearest,
           "y"},
        {TIX_DEFAULT_LEN, "see", 1, 1, Tix_HLSee,
           "entryPath"},
        {TIX_DEFAULT_LEN, "selection", 1, 3, Tix_HLSelection,
           "option arg ?arg ...?"},
        {TIX_DEFAULT_LEN, "show", 2, 2, Tix_HLShow,
           "option entryPath"},
        {TIX_DEFAULT_LEN, "xview", 0, 3, Tix_HLXView,
           "args"},
        {TIX_DEFAULT_LEN, "yview", 0, 3, Tix_HLYView,
           "args"},
    };
 
    static Tix_CmdInfo cmdInfo = {
        Tix_ArraySize(subCmdInfo), 1, TIX_VAR_ARGS, "?option? arg ?arg ...?",
    };
 
    Tk_Preserve(clientData);
    code = Tix_HandleSubCmds(&cmdInfo, subCmdInfo, clientData,
        interp, argc, argv);
    Tk_Release(clientData);
 
    return code;
}
 
/*----------------------------------------------------------------------
 * "add" sub command --
 *
 *      Add a new item into the list
 *----------------------------------------------------------------------
 */
static int
Tix_HLAdd(clientData, interp, argc, argv)
    ClientData clientData;
    Tcl_Interp *interp;         /* Current interpreter. */
    int argc;                   /* Number of arguments. */
    char **argv;                /* Argument strings. */
{
    WidgetPtr wPtr = (WidgetPtr) clientData;
    HListElement * chPtr;
    char * pathName = argv[0];
 
    argc --;
    argv ++;
 
    if ((chPtr = NewElement(interp, wPtr, argc, argv, pathName,
         NULL, &argc)) == NULL) {
        return TCL_ERROR;
    }
 
    if (argc > 0) {
        if (ConfigElement(wPtr, chPtr, argc, argv, 0, 1) != TCL_OK) {
            DeleteNode(wPtr, chPtr);
            return TCL_ERROR;
        }
    } else {
        if (Tix_DItemConfigure(chPtr->col[0].iPtr, 0, 0, 0) != TCL_OK) {
            DeleteNode(wPtr, chPtr);
            return TCL_ERROR;
        }
    }
 
    Tcl_AppendResult(interp, chPtr->pathName, NULL);
    return TCL_OK;
}
 
/*----------------------------------------------------------------------
 * "addchild" sub command --
 *
 *      Replacement for "add" sub command: it is more flexible and
 *      you can have default names for entries.
 *
 *      Add a new item into the list
 *----------------------------------------------------------------------
 */
static int
Tix_HLAddChild(clientData, interp, argc, argv)
    ClientData clientData;
    Tcl_Interp *interp;         /* Current interpreter. */
    int argc;                   /* Number of arguments. */
    char **argv;                /* Argument strings. */
{
    WidgetPtr wPtr = (WidgetPtr) clientData;
    HListElement * chPtr;
    char * parentName;
 
    parentName = argv[0];
    if (argv[0] && strcmp(argv[0], "") == 0) {
        parentName = NULL;
    }
 
    argc --;
    argv ++;
    if ((chPtr = NewElement(interp, wPtr, argc, argv, NULL,
         parentName, &argc)) == NULL) {
        return TCL_ERROR;
    }
 
    if (argc > 0) {
        if (ConfigElement(wPtr, chPtr, argc, argv, 0, 1) != TCL_OK) {
            DeleteNode(wPtr, chPtr);
            return TCL_ERROR;
        }
    } else {
        if (Tix_DItemConfigure(chPtr->col[0].iPtr, 0, 0, 0) != TCL_OK) {
            DeleteNode(wPtr, chPtr);
            return TCL_ERROR;
        }
    }
 
    Tcl_AppendResult(interp, chPtr->pathName, NULL);
    return TCL_OK;
}
 
/*----------------------------------------------------------------------
 * "anchor", "dragsite" and "dropsire" sub commands --
 *
 *      Set/remove the anchor element
 *----------------------------------------------------------------------
 */
static int
Tix_HLSetSite(clientData, interp, argc, argv)
    ClientData clientData;
    Tcl_Interp *interp;         /* Current interpreter. */
    int argc;                   /* Number of arguments. */
    char **argv;                /* Argument strings. */
{
    int changed = 0;
    WidgetPtr wPtr = (WidgetPtr) clientData;
    HListElement * chPtr;
    HListElement ** changePtr;
    size_t len ;
 
    /*
     * Determine which site should be changed.
     */
    len = strlen(argv[-1]);
    if (strncmp(argv[-1], "anchor", len)==0) {
        changePtr = &wPtr->anchor;
    }
    else if (strncmp(argv[-1], "dragsite", len)==0) {
        changePtr = &wPtr->dragSite;
    }
    else {
        changePtr = &wPtr->dropSite;
    }
 
    len = strlen(argv[0]);
    if (strncmp(argv[0], "set", len)==0) {
        if (argc == 2) {
            if ((chPtr = Tix_HLFindElement(interp, wPtr, argv[1])) == NULL) {
                return TCL_ERROR;
            }
            if (*changePtr != chPtr) {
                *changePtr = chPtr;
                changed = 1;
            }
        } else {
            Tcl_AppendResult(interp, "wrong # of arguments, must be: ",
                Tk_PathName(wPtr->dispData.tkwin), " ", argv[-1],
                " set entryPath", NULL);
            return TCL_ERROR;
        }
    }
    else if (strncmp(argv[0], "clear", len)==0) {
        if (*changePtr != NULL) {
            *changePtr = NULL;
            changed = 1;
        }
    }
    else {
        Tcl_AppendResult(interp, "wrong option \"", argv[0], "\", ",
            "must be clear or set", NULL);
        return TCL_ERROR;
    }
 
    if (changed) {
        RedrawWhenIdle(wPtr);
    }
 
    return TCL_OK;
}
 
/*----------------------------------------------------------------------
 * "cget" sub command --
 *----------------------------------------------------------------------
 */
static int
Tix_HLCGet(clientData, interp, argc, argv)
    ClientData clientData;
    Tcl_Interp *interp;         /* Current interpreter. */
    int argc;                   /* Number of arguments. */
    char **argv;                /* Argument strings. */
{
    WidgetPtr wPtr = (WidgetPtr) clientData;
 
    return Tk_ConfigureValue(interp, wPtr->dispData.tkwin, configSpecs,
                (char *)wPtr, argv[0], 0);
}
 
/*----------------------------------------------------------------------
 * "configure" sub command
 *----------------------------------------------------------------------
 */
static int
Tix_HLConfig(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 (argc == 0) {
        return Tk_ConfigureInfo(interp, wPtr->dispData.tkwin, configSpecs,
            (char *) wPtr, (char *) NULL, 0);
    } else if (argc == 1) {
        return Tk_ConfigureInfo(interp, wPtr->dispData.tkwin, configSpecs,
            (char *) wPtr, argv[0], 0);
    } else {
        return WidgetConfigure(interp, wPtr, argc, argv,
            TK_CONFIG_ARGV_ONLY);
    }
}
 
/*----------------------------------------------------------------------
 * "delete" sub command
 *----------------------------------------------------------------------
 */
static int
Tix_HLDelete(clientData, interp, argc, argv)
    ClientData clientData;
    Tcl_Interp *interp;         /* Current interpreter. */
    int argc;                   /* Number of arguments. */
    char **argv;                /* Argument strings. */
{
    WidgetPtr wPtr = (WidgetPtr) clientData;
    HListElement * chPtr;
    size_t len;
 
    if (strcmp(argv[0], "all") == 0) {
        Tix_HLMarkElementDirty(wPtr, wPtr->root);
        DeleteOffsprings(wPtr, wPtr->root);
 
        Tix_HLResizeWhenIdle(wPtr);
        return TCL_OK;
    }
    len = strlen(argv[0]);
 
    if (argc != 2) {
        if ((strncmp(argv[0], "entry", len) == 0) ||
            (strncmp(argv[0], "offsprings", len) == 0) ||
            (strncmp(argv[0], "siblings", len) == 0)) {
 
            goto wrong_arg;
        }
        else {
            goto wrong_option;
        }
    }
 
    if ((chPtr = Tix_HLFindElement(interp, wPtr, argv[1])) == NULL) {
        return TCL_ERROR;
    }
 
    if (strncmp(argv[0], "entry", len) == 0) {
        Tix_HLMarkElementDirty(wPtr, chPtr->parent);
        DeleteNode(wPtr, chPtr);
    }
    else if (strncmp(argv[0], "offsprings", len) == 0) {
        Tix_HLMarkElementDirty(wPtr, chPtr);
        DeleteOffsprings(wPtr, chPtr);
    }
    else if (strncmp(argv[0], "siblings", len) == 0) {
        Tix_HLMarkElementDirty(wPtr, chPtr);
        DeleteSiblings(wPtr, chPtr);
    }
    else {
        goto wrong_arg;
    }
 
    Tix_HLResizeWhenIdle(wPtr);
    return TCL_OK;
 
wrong_arg:
 
    Tcl_AppendResult(interp,
        "wrong # of arguments, should be pathName delete ", argv[0],
        " entryPath", NULL);
    return TCL_ERROR;
 
wrong_option:
 
    Tcl_AppendResult(interp, "unknown option \"", argv[0],
        "\" must be all, entry, offsprings or siblings", NULL);
    return TCL_ERROR;
 
}
 
/*----------------------------------------------------------------------
 * "entrycget" sub command
 *----------------------------------------------------------------------
 */
static int
Tix_HLEntryCget(clientData, interp, argc, argv)
    ClientData clientData;
    Tcl_Interp *interp;         /* Current interpreter. */
    int argc;                   /* Number of arguments. */
    char **argv;                /* Argument strings. */
{
    WidgetPtr wPtr = (WidgetPtr) clientData;
    HListElement * chPtr;
 
    if ((chPtr = Tix_HLFindElement(interp, wPtr, argv[0])) == NULL) {
        return TCL_ERROR;
    }
    if (chPtr->col[0].iPtr == NULL) {
        Tcl_AppendResult(interp, "Item \"", argv[0],
            "\" does not exist", (char*)NULL);
        return TCL_ERROR;
    }
    return Tix_ConfigureValue2(interp, wPtr->dispData.tkwin, (char *)chPtr,
        entryConfigSpecs, chPtr->col[0].iPtr, argv[1], 0);
}
 
/*----------------------------------------------------------------------
 * "entryconfigure" sub command
 *----------------------------------------------------------------------
 */
static int
Tix_HLEntryConfig(clientData, interp, argc, argv)
    ClientData clientData;
    Tcl_Interp *interp;         /* Current interpreter. */
    int argc;                   /* Number of arguments. */
    char **argv;                /* Argument strings. */
{
    WidgetPtr wPtr = (WidgetPtr) clientData;
    HListElement * chPtr;
 
    if ((chPtr = Tix_HLFindElement(interp, wPtr, argv[0])) == NULL) {
        return TCL_ERROR;
    }
 
    if (argc == 1) {
        return Tix_ConfigureInfo2(interp, wPtr->dispData.tkwin,
            (char*)chPtr, entryConfigSpecs, chPtr->col[0].iPtr,
            (char *) NULL, 0);
    } else if (argc == 2) {
        return Tix_ConfigureInfo2(interp, wPtr->dispData.tkwin,
            (char*)chPtr, entryConfigSpecs, chPtr->col[0].iPtr,
            (char *) argv[1], 0);
    } else {
        return ConfigElement(wPtr, chPtr, argc-1, argv+1,
            TK_CONFIG_ARGV_ONLY, 0);
    }
}
 
/*----------------------------------------------------------------------
 * "geometryinfo" sub command
 *----------------------------------------------------------------------
 */
static int
Tix_HLGeometryInfo(clientData, interp, argc, argv)
    ClientData clientData;
    Tcl_Interp *interp;         /* Current interpreter. */
    int argc;                   /* Number of arguments. */
    char **argv;                /* Argument strings. */
{
    WidgetPtr wPtr = (WidgetPtr) clientData;
    int qSize[2];
    double first[2], last[2];
    char string[80];
 
    if (argc == 2) {
        if (Tcl_GetInt(interp, argv[0], &qSize[0]) != TCL_OK) {
            return TCL_ERROR;
        }
        if (Tcl_GetInt(interp, argv[1], &qSize[1]) != TCL_OK) {
            return TCL_ERROR;
        }
    } else {
        qSize[0] = Tk_Width (wPtr->dispData.tkwin);
        qSize[1] = Tk_Height(wPtr->dispData.tkwin);
    }
    qSize[0] -= 2*wPtr->borderWidth + 2*wPtr->highlightWidth;
    qSize[1] -= 2*wPtr->borderWidth + 2*wPtr->highlightWidth;
 
    if (wPtr->useHeader) {
        qSize[1] -= wPtr->headerHeight;
    }
 
    GetScrollFractions(wPtr->totalSize[0], qSize[0], wPtr->leftPixel,
        &first[0], &last[0]);
    GetScrollFractions(wPtr->totalSize[1], qSize[1], wPtr->topPixel,
        &first[1], &last[1]);
 
    sprintf(string, "{%f %f} {%f %f}", first[0], last[0], first[1], last[1]);
    Tcl_AppendResult(interp, string, NULL);
 
    return TCL_OK;
}
 
/*----------------------------------------------------------------------
 * "hide" sub command
 *----------------------------------------------------------------------
 */
 
/* %% ToDo: implement the siblings ... etc options, to match those of "delete"
 */
static int
Tix_HLHide(clientData, interp, argc, argv)
    ClientData clientData;
    Tcl_Interp *interp;         /* Current interpreter. */
    int argc;                   /* Number of arguments. */
    char **argv;                /* Argument strings. */
{
    WidgetPtr wPtr = (WidgetPtr) clientData;
    HListElement * chPtr;
 
    if ((chPtr = Tix_HLFindElement(interp, wPtr, argv[1])) == NULL) {
        return TCL_ERROR;
    }
 
    Tix_HLMarkElementDirty(wPtr, chPtr->parent);
    chPtr->hidden = 1;
 
    Tix_HLResizeWhenIdle(wPtr);
    return TCL_OK;
}
 
/*----------------------------------------------------------------------
 * "show" sub command
 *----------------------------------------------------------------------
 */
static int
Tix_HLShow(clientData, interp, argc, argv)
    ClientData clientData;
    Tcl_Interp *interp;         /* Current interpreter. */
    int argc;                   /* Number of arguments. */
    char **argv;                /* Argument strings. */
{
    WidgetPtr wPtr = (WidgetPtr) clientData;
    HListElement * chPtr;
 
    if ((chPtr = Tix_HLFindElement(interp, wPtr, argv[1])) == NULL) {
        return TCL_ERROR;
    }
 
    Tix_HLMarkElementDirty(wPtr, chPtr->parent);
    chPtr->hidden = 0;
 
    Tix_HLResizeWhenIdle(wPtr);
    return TCL_OK;
}
 
/*----------------------------------------------------------------------
 * "info" sub command
 *----------------------------------------------------------------------
 */
static int
Tix_HLInfo(clientData, interp, argc, argv)
    ClientData clientData;
    Tcl_Interp *interp;         /* Current interpreter. */
    int argc;                   /* Number of arguments. */
    char **argv;                /* Argument strings. */
{
    WidgetPtr wPtr = (WidgetPtr) clientData;
    HListElement * chPtr;
    size_t len = strlen(argv[0]);
 
    if (strncmp(argv[0], "anchor", len)==0) {
        if (wPtr->anchor) {
            Tcl_AppendResult(interp, wPtr->anchor->pathName, NULL);
        }
        return TCL_OK;
    }
    else if (strncmp(argv[0], "bbox", len)==0) {
        HListElement * chPtr;
 
        if (argc != 2) {
            return Tix_ArgcError(interp, argc+2, argv-2, 3, "entryPath");
        }
        if ((chPtr = Tix_HLFindElement(interp, wPtr, argv[1])) == NULL) {
            return TCL_ERROR;
        }
 
        return Tix_HLBBox(interp, wPtr, chPtr);
    }
    else if (strncmp(argv[0], "children", len)==0) {
        HListElement * ptr;
 
        if (argc != 1 && argc != 2) {
            return Tix_ArgcError(interp, argc+2, argv-2, 3, "?entryPath?");
        }
        if (argc == 1 || (argc == 2 && *argv[1]==0)) {
            chPtr = wPtr->root;
        } else {
            if ((chPtr = Tix_HLFindElement(interp, wPtr, argv[1])) == NULL) {
                return TCL_ERROR;
            }
        }
 
        for (ptr=chPtr->childHead; ptr; ptr=ptr->next) {
            Tcl_AppendElement(interp, ptr->pathName);
        }
        return TCL_OK;
    }
    else if (strncmp(argv[0], "data", len)==0) {
        if (argc != 2) {
            return Tix_ArgcError(interp, argc+2, argv-2, 3, "entryPath");
        }
        if ((chPtr = Tix_HLFindElement(interp, wPtr, argv[1])) == NULL) {
            return TCL_ERROR;
        }
 
        Tcl_AppendResult(interp, chPtr->data, NULL);
        return TCL_OK;
    }
    else if (strncmp(argv[0], "dragsite", len)==0) {
        if (wPtr->dragSite) {
            Tcl_AppendResult(interp, wPtr->dragSite->pathName, NULL);
        }
        return TCL_OK;
    }
    else if (strncmp(argv[0], "dropsite", len)==0) {
        if (wPtr->dropSite) {
            Tcl_AppendResult(interp, wPtr->dropSite->pathName, NULL);
        }
        return TCL_OK;
    }
    else if (strncmp(argv[0], "exists", len)==0) {
        if (argc != 2) {
            return Tix_ArgcError(interp, argc+2, argv-2, 3, "entryPath");
        }
        chPtr = Tix_HLFindElement(interp, wPtr, argv[1]);
 
        if (chPtr) {
            Tcl_AppendResult(interp, "1", NULL);
        } else {
            Tcl_ResetResult(interp);
            Tcl_AppendResult(interp, "0", NULL);
        }
        return TCL_OK;
    }
    else if (strncmp(argv[0], "hidden", len)==0) {
        if (argc != 2) {
            return Tix_ArgcError(interp, argc+2, argv-2, 3, "entryPath");
        }
        if ((chPtr = Tix_HLFindElement(interp, wPtr, argv[1])) == NULL) {
            return TCL_ERROR;
        }
        if (chPtr->hidden) {
            Tcl_AppendElement(interp, "1");
        } else {
            Tcl_AppendElement(interp, "0");
        }
 
        return TCL_OK;
    }
    else if (strncmp(argv[0], "item", len)==0) {
        return Tix_HLItemInfo(interp, wPtr, argc-1, argv+1);
    }
    else if (strncmp(argv[0], "next", len)==0) {
        HListElement * nextPtr;
 
        if (argc != 2) {
            return Tix_ArgcError(interp, argc+2, argv-2, 3, "entryPath");
        }
 
        if ((chPtr = Tix_HLFindElement(interp, wPtr, argv[1])) == NULL) {
            return TCL_ERROR;
        }
 
        nextPtr=FindNextEntry(wPtr, chPtr);
 
        if (nextPtr) {
            Tcl_AppendResult(interp, nextPtr->pathName, NULL);
        }
 
        return TCL_OK;
    }
    else if (strncmp(argv[0], "parent", len)==0) {
        if (argc != 2) {
            return Tix_ArgcError(interp, argc+2, argv-2, 3, "entryPath");
        }
        if ((chPtr = Tix_HLFindElement(interp, wPtr, argv[1])) == NULL) {
            return TCL_ERROR;
        }
 
        Tcl_AppendResult(interp, chPtr->parent->pathName, NULL);
        return TCL_OK;
    }
    else if (strncmp(argv[0], "prev", len)==0) {
        HListElement * prevPtr;
 
        if (argc != 2) {
            return Tix_ArgcError(interp, argc+2, argv-2, 3, "entryPath");
        }
        if ((chPtr = Tix_HLFindElement(interp, wPtr, argv[1])) == NULL) {
            return TCL_ERROR;
        }
        prevPtr = FindPrevEntry(wPtr, chPtr);
        if (prevPtr) {
            Tcl_AppendResult(interp, prevPtr->pathName, NULL);
        }
 
        return TCL_OK;
    }
    else if (strncmp(argv[0], "selection", len)==0) {
        return CurSelection(interp, wPtr, wPtr->root);
    }
    else {
        Tcl_AppendResult(interp, "unknown option \"", argv[0],
            "\": must be anchor, bbox, children, data, dragsite, dropsite, ",
            "exists, hidden, item, next, parent, prev or selection",
            NULL);
        return TCL_ERROR;
    }
}
 
/*----------------------------------------------------------------------
 * "info item" sub-sub command
 * argv[0] = x
 * argv[1] = y
 *
 *      returns {entryPath (indicator|column#) type component}
 *----------------------------------------------------------------------
 */
int
Tix_HLItemInfo(interp, wPtr, argc, argv)
    Tcl_Interp *interp;         /* Current interpreter. */
    WidgetPtr wPtr;             /* HList widget */
    int argc;                   /* Number of arguments. */
    char **argv;                /* Argument strings. */
{
    HListElement * chPtr;
    int itemX, itemY;
    int listX, listY;
    int widX,  widY;
    int i, m, n;
    char column[20];
 
    if (argc != 2) {
        return Tix_ArgcError(interp, argc+3, argv-3, 3, "x y");
    }
    if (Tcl_GetInt(interp, argv[0], &widX) != TCL_OK) {
        return TCL_ERROR;
    }
    if (Tcl_GetInt(interp, argv[1], &widY) != TCL_OK) {
        return TCL_ERROR;
    }
    if (wPtr->root->dirty || wPtr->allDirty) {
        /*
         * We must update the geometry NOW otherwise we will get a wrong entry
         */
        Tix_HLCancelResizeWhenIdle(wPtr);
        Tix_HLComputeGeometry((ClientData)wPtr);
    }
    if ((chPtr = FindElementAtPosition(wPtr, widY)) == NULL) {
        goto none;
    }
 
    listX = widX - wPtr->borderWidth - wPtr->highlightWidth + wPtr->leftPixel;
    listY = widY - wPtr->borderWidth - wPtr->highlightWidth + wPtr->topPixel;
 
    if (wPtr->useHeader) {
        listY -= wPtr->headerHeight;
    }
 
    itemX = listX - Tix_HLElementLeftOffset(wPtr, chPtr);
    itemY = listY - Tix_HLElementTopOffset (wPtr, chPtr);
 
    if (itemY < 0 || itemY >= chPtr->height) {
        goto none;
    }
    if (itemX < 0) {
        goto none;
    }
 
    if (wPtr->useIndicator && itemX < wPtr->indent) {
        if (chPtr->indicator) {
            int indCenterX;
            int indOffX, indOffY;
            int indX, indY;
 
            /* This "if" is a BIG HACK */
            if (chPtr->parent == wPtr->root) {
                indCenterX = wPtr->indent/2;
            }
            else if (chPtr->parent->parent == wPtr->root) {
                indCenterX = chPtr->parent->branchX - wPtr->indent;
            } else {
                indCenterX = chPtr->parent->branchX;
            }
 
            indOffX = indCenterX   - Tix_DItemWidth (chPtr->indicator)/2;
            indOffY = chPtr->iconY - Tix_DItemHeight(chPtr->indicator)/2;
 
            indX = itemX - indOffX;
            indY = itemY - indOffY;
 
            /* Is it outside of the indicator? */
            if (indX < 0 || indX >= Tix_DItemWidth (chPtr->indicator)) {
                goto none;
            }
            if (indY < 0 || indY >= Tix_DItemHeight(chPtr->indicator)) {
                goto none;
            }
            Tcl_AppendElement(interp, chPtr->pathName);
            Tcl_AppendElement(interp, "indicator");
            Tcl_AppendElement(interp, Tix_DItemTypeName(chPtr->indicator));
            Tcl_AppendElement(interp,
                Tix_DItemComponent(chPtr->indicator, indX, indY));
            return TCL_OK;
        } else {
            goto none;
        }
    }
 
    /* skip the indent part */
 
    if (!wPtr->useIndicator && chPtr->parent == wPtr->root) {
        /* indent not used only in this case */
    } else {
        itemX -= wPtr->indent;
    }
 
    for (m=n=0,i=0; i<wPtr->numColumns; i++) {
        n += wPtr->actualSize[i].width;
        if (listX < n) {
            if (n > 1) {
                itemX = listX - m;
            }
            goto _column;
        }
        m += wPtr->actualSize[i].width;
    }
    goto none;
 
_column:
    sprintf(column, "%d", i);
    Tcl_AppendElement(interp, chPtr->pathName);
    Tcl_AppendElement(interp, column);
 
    if (chPtr->col[i].iPtr != NULL) {
        Tcl_AppendElement(interp, Tix_DItemTypeName(chPtr->col[i].iPtr));
        Tcl_AppendElement(interp,
            Tix_DItemComponent(chPtr->col[i].iPtr, itemX, itemY));
    }
    return TCL_OK;
 
none:
    Tcl_ResetResult(interp);
    return TCL_OK;
}
 
/*----------------------------------------------------------------------
 * "nearest" sub command
 *----------------------------------------------------------------------
 */
static int
Tix_HLNearest(clientData, interp, argc, argv)
    ClientData clientData;
    Tcl_Interp *interp;         /* Current interpreter. */
    int argc;                   /* Number of arguments. */
    char **argv;                /* Argument strings. */
{
    WidgetPtr wPtr = (WidgetPtr) clientData;
    HListElement * chPtr;
    int y;
 
    if (Tcl_GetInt(interp, argv[0], &y) != TCL_OK) {
        return TCL_ERROR;
    }
    if (wPtr->root->dirty || wPtr->allDirty) {
        /*
         * We must update the geometry NOW otherwise we will get a
         * wrong entry.
         */
        Tix_HLCancelResizeWhenIdle(wPtr);
        Tix_HLComputeGeometry((ClientData)wPtr);
    }
 
    if ((chPtr = FindElementAtPosition(wPtr, y)) != NULL) {
        Tcl_AppendResult(interp, chPtr->pathName, NULL);
    }
    return TCL_OK;
}
 
/*----------------------------------------------------------------------
 * "see" sub command
 *----------------------------------------------------------------------
 */
static int
Tix_HLSee(clientData, interp, argc, argv)
    ClientData clientData;
    Tcl_Interp *interp;         /* Current interpreter. */
    int argc;                   /* Number of arguments. */
    char **argv;                /* Argument strings. */
{
    WidgetPtr wPtr = (WidgetPtr) clientData;
    HListElement * chPtr;
 
    if ((chPtr = Tix_HLFindElement(interp, wPtr, argv[0])) == NULL) {
        return TCL_ERROR;
    }
    if (wPtr->resizing || wPtr->redrawing) {
        if (wPtr->elmToSee) {
            ckfree(wPtr->elmToSee);
        }
        wPtr->elmToSee = tixStrDup(argv[0]);
        return TCL_OK;
    } else {
        Tix_HLSeeElement(wPtr, chPtr, 1);
 
        return TCL_OK;
    }
}
 
/*----------------------------------------------------------------------
 * Tix_HLBBox --
 *
 *      Returns the visible bounding box of an HList element (x1, y1, x2, y2).
 *      Currently only y1 and y2 matters. x1 and x2 are always the left
 *      and right edges of the window.
 *
 * Return value:
 *      See user documenetation.
 *
 * Side effects:
 *      None.
 *----------------------------------------------------------------------
 */
 
static int Tix_HLBBox(interp, wPtr, chPtr)
    Tcl_Interp * interp;        /* Interpreter to report the bbox. */
    WidgetPtr wPtr;             /* HList widget. */
    HListElement * chPtr;       /* Get the BBox for this element.*/
{
    int y, height;
    int wXSize, wYSize;         /* size of the listbox window area */
    int pad;
 
    if (!Tk_IsMapped(wPtr->dispData.tkwin)) {
        return TCL_OK;
    }
 
    if (wPtr->root->dirty || wPtr->allDirty) {
        /*
         * We must update the geometry NOW otherwise we will wrong geometry
         * info
         */
        Tix_HLCancelResizeWhenIdle(wPtr);
        Tix_HLComputeGeometry((ClientData)wPtr);
    }
 
    y = Tix_HLElementTopOffset(wPtr, chPtr) - wPtr->topPixel;
    pad = wPtr->borderWidth + wPtr->highlightWidth;
    wXSize = Tk_Width(wPtr->dispData.tkwin ) - 2*pad;
    wYSize = Tk_Height(wPtr->dispData.tkwin) - 2*pad;
 
    if (wXSize <= 0) {
        wXSize = 1;
    }
    if (wYSize <= 0) {
        wYSize = 1;
    }
 
    height = chPtr->height;
    if (height <= 0) {
        height = 1;
    }
 
    if (y >= wYSize || (y+height) <= 0) {
        /*
         * The element is not visible
         */
        return TCL_OK;
    } else {
        int x1;
        int y1, y2;
        char buff[100];
 
        /*
         * The bounding box is clipped with the visible area of the widget.
         */
 
        x1 = pad;
        y1 = y + wPtr->borderWidth + wPtr->highlightWidth;
        y2 = y1 + height-1;
 
        if (y1 < pad) {
            y1 = pad;
        }
        if (y2 >= pad+wYSize) {
            y2 = pad+wYSize -1;
        }
 
        if (y2 >= y1) {
            sprintf(buff, "%d %d %d %d", x1, y1, x1+wXSize-1, y2);
            Tcl_SetResult(interp, buff, TCL_VOLATILE);
        }
        return TCL_OK;
    }
}
 
static int Tix_HLSeeElement(wPtr, chPtr, callRedraw)
    WidgetPtr wPtr;
    HListElement * chPtr;
    int callRedraw;
{
    int x, y;
    int cXSize, cYSize;         /* element size */
    int wXSize, wYSize;         /* size of the listbox window area */
    int top, left;              /* new top and left offset of the HLIst */
    int oldTop, oldLeft;
 
    oldLeft = wPtr->leftPixel;
    oldTop  = wPtr->topPixel;
 
    x = Tix_HLElementLeftOffset(wPtr, chPtr);
    y = Tix_HLElementTopOffset(wPtr, chPtr);
    if (chPtr->col[0].iPtr) {
        cXSize = Tix_DItemWidth(chPtr->col[0].iPtr);
    } else {
        cXSize = chPtr->col[0].width;
    }
    cYSize = chPtr->height;
    wXSize = Tk_Width(wPtr->dispData.tkwin) -
      (2*wPtr->borderWidth + 2*wPtr->highlightWidth);
    wYSize = Tk_Height(wPtr->dispData.tkwin) -
      (2*wPtr->borderWidth + 2*wPtr->highlightWidth);
 
    if (wPtr->useHeader) {
        wYSize -= wPtr->headerHeight;
    }
 
    if (wXSize < 0 || wYSize < 0) {
        /* The window is probably not visible */
        return TCL_OK;
    }
 
    if (cXSize < wXSize && wPtr->numColumns == 1) {
        /* Align on the X direction */
        left = wPtr->leftPixel;
        if ((x < wPtr->leftPixel) || (x+cXSize > wPtr->leftPixel+wXSize)) {
            if (wXSize > cXSize) {
                left = x - (wXSize-cXSize)/2;
            } else {
                left = x;
            }
        }
    } else {
        left = wPtr->leftPixel;
    }
 
    /* Align on the Y direction */
    top = wPtr->topPixel;
 
    if (cYSize < wYSize) {
        if ((wPtr->topPixel-y)>wYSize || (y-wPtr->topPixel-wYSize) > wYSize) {
            /* far away, make it middle */
            top = y - (wYSize-cYSize)/2;
        }
        else if (y < wPtr->topPixel) {
            top = y;
        }
        else if (y+cYSize > wPtr->topPixel+wYSize){
            top = y+cYSize - wYSize ;
        }
    }
 
    if (oldLeft != left || oldTop != top) {
        wPtr->leftPixel = left;
        wPtr->topPixel  = top;
 
        if (callRedraw) {
            UpdateScrollBars(wPtr, 0);
            RedrawWhenIdle(wPtr);
        }
        return 1;
    } else {
        return 0;
    }
}
 
/*----------------------------------------------------------------------
 * "selection" sub command
 *      Modify the selection in this HList box
 *----------------------------------------------------------------------
 */
static int
Tix_HLSelection(clientData, interp, argc, argv)
    ClientData clientData;
    Tcl_Interp *interp;         /* Current interpreter. */
    int argc;                   /* Number of arguments. */
    char **argv;                /* Argument strings. */
{
    WidgetPtr wPtr = (WidgetPtr) clientData;
    HListElement * chPtr;
    size_t len = strlen(argv[0]);
    int code = TCL_OK;
    int changed = 0;
 
    if (strncmp(argv[0], "clear", len)==0) {
        if (argc == 1) {
            HL_SelectionClearAll(wPtr, wPtr->root, &changed);
        }
        else {
            HListElement * from, * to;
 
            from = Tix_HLFindElement(interp, wPtr, argv[1]);
            if (from == NULL) {
                code = TCL_ERROR;
                goto done;
            }
 
            if (argc == 3) {
                to = Tix_HLFindElement(interp, wPtr, argv[2]);
                if (to == NULL) {
                    code = TCL_ERROR;
                    goto done;
                }
                changed = SelectionModifyRange(wPtr, from, to, 0);
            }
            else {
                if (from->selected == 1) {
                    HL_SelectionClear(wPtr, from);
                    changed = 1;
                }
            }
        }
    }
    else if (strncmp(argv[0], "includes", len)==0) {
        if ((chPtr = Tix_HLFindElement(interp, wPtr, argv[1])) == NULL) {
            code = TCL_ERROR;
            goto done;
        }
        if (chPtr->selected) {
            Tcl_AppendResult(interp, "1", NULL);
        } else {
            Tcl_AppendResult(interp, "0", NULL);
        }
    }
    else if (strncmp(argv[0], "get", len)==0) {
        if (argc != 1) {
            Tix_ArgcError(interp, argc+2, argv-2, 3, "");
            code = TCL_ERROR;
        } else {
            code = CurSelection(interp, wPtr, wPtr->root);
        }
    }
    else if (strncmp(argv[0], "set", len)==0) {
        HListElement * from, * to;
 
        if (argc < 2 || argc > 3) {
            Tix_ArgcError(interp, argc+2, argv-2, 3, "from ?to?");
            code = TCL_ERROR;
            goto done;
        }
 
        from = Tix_HLFindElement(interp, wPtr, argv[1]);
        if (from == NULL) {
            code = TCL_ERROR;
            goto done;
        }
 
        if (argc == 3) {
            to = Tix_HLFindElement(interp, wPtr, argv[2]);
            if (to == NULL) {
                code = TCL_ERROR;
                goto done;
            }
            changed = SelectionModifyRange(wPtr, from, to, 1);
        } else {
            if (!from->selected && !from->hidden) {
                SelectionAdd(wPtr, from);
                changed = 1;
            }
        }
    }
    else {
        Tcl_AppendResult(interp, "unknown option \"", argv[0],
            "\": must be anchor, clear, get, includes or set", NULL);
        code = TCL_ERROR;
    }
 
  done:
    if (changed) {
        RedrawWhenIdle(wPtr);
    }
 
    return code;
}
 
/*----------------------------------------------------------------------
 * "xview" sub command
 *----------------------------------------------------------------------
 */
static int
Tix_HLXView(clientData, interp, argc, argv)
    ClientData clientData;
    Tcl_Interp *interp;         /* Current interpreter. */
    int argc;                   /* Number of arguments. */
    char **argv;                /* Argument strings. */
{
    WidgetPtr wPtr = (WidgetPtr) clientData;
    HListElement * chPtr;
    int leftPixel;
    int oldLeft = wPtr->leftPixel;
    if (argc == 0) {
        char string[20];
 
        sprintf(string, "%d", wPtr->leftPixel);
        Tcl_AppendResult(interp, string, NULL);
        return TCL_OK;
    }
    else if ((chPtr = Tix_HLFindElement(interp, wPtr, argv[0])) != NULL) {
        leftPixel = Tix_HLElementLeftOffset(wPtr, chPtr);
    }
    else if (Tcl_GetInt(interp, argv[0], &leftPixel) == TCL_OK) {
        /* %% todo backward-compatible mode */
 
    }
    else {
        int type, count;
        double fraction;
 
        Tcl_ResetResult(interp);
 
        /* Tk_GetScrollInfo () wants strange argc,argv combinations .. */
        type = Tk_GetScrollInfo(interp, argc+2, argv-2, &fraction, &count);
        switch (type) {
          case TK_SCROLL_ERROR:
            return TCL_ERROR;
 
          case TK_SCROLL_MOVETO:
            leftPixel = (int)(fraction * (double)wPtr->totalSize[0]);
            break;
 
          case TK_SCROLL_PAGES:
            leftPixel = XScrollByPages(wPtr, count);
            break;
 
          case TK_SCROLL_UNITS:
            leftPixel = XScrollByUnits(wPtr, count);
            break;
        }
    }
 
    if (oldLeft != leftPixel) {
        wPtr->leftPixel = leftPixel;
        UpdateScrollBars(wPtr, 0);
 
        RedrawWhenIdle(wPtr);
    }
 
    Tcl_ResetResult(interp);
    return TCL_OK;
}
 
/*----------------------------------------------------------------------
 * "yview" sub command
 *----------------------------------------------------------------------
 */
static int
Tix_HLYView(clientData, interp, argc, argv)
    ClientData clientData;
    Tcl_Interp *interp;         /* Current interpreter. */
    int argc;                   /* Number of arguments. */
    char **argv;                /* Argument strings. */
{
    WidgetPtr wPtr = (WidgetPtr) clientData;
    HListElement * chPtr;
    int topPixel;
    int oldTop = wPtr->topPixel;
 
    if (argc == 0) {
        char string[20];
 
        sprintf(string, "%d", wPtr->topPixel);
        Tcl_AppendResult(interp, string, NULL);
        return TCL_OK;
    }
    else if ((chPtr = Tix_HLFindElement(interp, wPtr, argv[0])) != NULL) {
        topPixel = Tix_HLElementTopOffset(wPtr, chPtr);
    }
    else if (Tcl_GetInt(interp, argv[0], &topPixel) == TCL_OK) {
        /* %% todo backward-compatible mode */
    }
    else {
        int type, count;
        double fraction;
 
        Tcl_ResetResult(interp);
 
        /* Tk_GetScrollInfo () wants strange argc,argv combinations .. */
        type = Tk_GetScrollInfo(interp, argc+2, argv-2, &fraction, &count);
        switch (type) {
          case TK_SCROLL_ERROR:
            return TCL_ERROR;
 
          case TK_SCROLL_MOVETO:
            topPixel = (int)(fraction * (double)wPtr->totalSize[1]);
            break;
 
          case TK_SCROLL_PAGES:
            topPixel = YScrollByPages(wPtr, count);
            break;
 
          case TK_SCROLL_UNITS:
            topPixel = YScrollByUnits(wPtr, count);
            break;
        }
    }
 
    if (oldTop != topPixel) {
        wPtr->topPixel = topPixel;
        UpdateScrollBars(wPtr, 0);
 
        RedrawWhenIdle(wPtr);
    }
 
    Tcl_ResetResult(interp);
    return TCL_OK;
}
 
/*
 *----------------------------------------------------------------------
 *
 * WidgetConfigure --
 *
 *      This procedure is called to process an argv/argc list in
 *      conjunction with the Tk option database to configure (or
 *      reconfigure) a HList widget.
 *
 * Results:
 *      The return value is a standard Tcl result.  If TCL_ERROR is
 *      returned, then interp->result contains an error message.
 *
 * Side effects:
 *      Configuration information, such as colors, border width,
 *      etc. get set for wPtr;  old resources get freed,
 *      if there were any.
 *
 *----------------------------------------------------------------------
 */
static int
WidgetConfigure(interp, wPtr, argc, argv, flags)
    Tcl_Interp *interp;                 /* Used for error reporting. */
    WidgetPtr wPtr;                     /* Information about widget. */
    int argc;                           /* Number of valid entries in argv. */
    char **argv;                        /* Arguments. */
    int flags;                          /* Flags to pass to
                                         * Tk_ConfigureWidget. */
{
    XGCValues gcValues;
    GC newGC;
    TixFont oldfont;
    int oldColumns;
    Tix_StyleTemplate stTmpl;
 
    oldfont = wPtr->font;
    oldColumns = wPtr->numColumns;
    if (Tk_ConfigureWidget(interp, wPtr->dispData.tkwin, configSpecs,
            argc, argv, (char *) wPtr, flags) != TCL_OK) {
        return TCL_ERROR;
    }
 
    if (wPtr->initialized && oldColumns != wPtr->numColumns) {
        Tcl_AppendResult(interp, "Cannot change the number of columns ",
            (char *) NULL);
        wPtr->numColumns = oldColumns;
        return TCL_ERROR;
    }
    if (wPtr->numColumns < 1) {
        wPtr->numColumns = 1;
    }
 
    if (wPtr->separator == 0 || wPtr->separator[0] == 0) {
        if (wPtr->separator != 0) {
            ckfree(wPtr->separator);
        }
        wPtr->separator = (char*)tixStrDup(".");
    }
 
    if (oldfont != wPtr->font) {
        /*
         * Font has been changed (initialized)
         */
        TixComputeTextGeometry(wPtr->font, "0", 1,
            0, &wPtr->scrollUnit[0], &wPtr->scrollUnit[1]);
    }
 
    /*
     * A few options need special processing, such as setting the
     * background from a 3-D border, or filling in complicated
     * defaults that couldn't be specified to Tk_ConfigureWidget.
     */
 
    Tk_SetBackgroundFromBorder(wPtr->dispData.tkwin, wPtr->border);
 
    /*
     * Note: GraphicsExpose events are disabled in normalGC because it's
     * used to copy stuff from an off-screen pixmap onto the screen (we know
     * that there's no problem with obscured areas).
     */
 
    /* The background GC */
    gcValues.foreground         = wPtr->normalBg->pixel;
    gcValues.graphics_exposures = False;
 
    newGC = Tk_GetGC(wPtr->dispData.tkwin,
        GCForeground|GCGraphicsExposures, &gcValues);
    if (wPtr->backgroundGC != None) {
        Tk_FreeGC(wPtr->dispData.display, wPtr->backgroundGC);
    }
    wPtr->backgroundGC = newGC;
 
    /* The normal text GC */
    gcValues.font               = TixFontId(wPtr->font);
    gcValues.foreground         = wPtr->normalFg->pixel;
    gcValues.background         = wPtr->normalBg->pixel;
    gcValues.graphics_exposures = False;
 
    newGC = Tk_GetGC(wPtr->dispData.tkwin,
        GCForeground|GCBackground|GCFont|GCGraphicsExposures, &gcValues);
    if (wPtr->normalGC != None) {
        Tk_FreeGC(wPtr->dispData.display, wPtr->normalGC);
    }
    wPtr->normalGC = newGC;
 
    /* The selected text GC */
    gcValues.font               = TixFontId(wPtr->font);
    gcValues.foreground         = wPtr->selectFg->pixel;
    gcValues.background         = Tk_3DBorderColor(wPtr->selectBorder)->pixel;
    gcValues.graphics_exposures = False;
 
    newGC = Tk_GetGC(wPtr->dispData.tkwin,
        GCForeground|GCBackground|GCFont|GCGraphicsExposures, &gcValues);
    if (wPtr->selectGC != None) {
        Tk_FreeGC(wPtr->dispData.display, wPtr->selectGC);
    }
    wPtr->selectGC = newGC;
 
    /* The dotted anchor lines */
    gcValues.foreground         = wPtr->normalFg->pixel;
    gcValues.background         = wPtr->normalBg->pixel;
    gcValues.graphics_exposures = False;
    gcValues.line_style         = LineDoubleDash;
    gcValues.dashes             = 2;
    gcValues.subwindow_mode     = IncludeInferiors;
 
    newGC = Tk_GetGC(wPtr->dispData.tkwin,
        GCForeground|GCBackground|GCGraphicsExposures|GCLineStyle|GCDashList|
            GCSubwindowMode, &gcValues);
    if (wPtr->anchorGC != None) {
        Tk_FreeGC(wPtr->dispData.display, wPtr->anchorGC);
    }
    wPtr->anchorGC = newGC;
 
    /* The sloid dropsite lines */
    gcValues.foreground         = wPtr->normalFg->pixel;
    gcValues.background         = wPtr->normalBg->pixel;
    gcValues.graphics_exposures = False;
    gcValues.subwindow_mode     = IncludeInferiors;
 
    newGC = Tk_GetGC(wPtr->dispData.tkwin,
        GCForeground|GCBackground|GCGraphicsExposures|GCSubwindowMode,
            &gcValues);
    if (wPtr->dropSiteGC != None) {
        Tk_FreeGC(wPtr->dispData.display, wPtr->dropSiteGC);
    }
    wPtr->dropSiteGC = newGC;
 
    /* The highlight border */
    gcValues.background         = wPtr->selectFg->pixel;
    gcValues.foreground         = wPtr->highlightColorPtr->pixel;
    gcValues.subwindow_mode     = IncludeInferiors;
 
    newGC = Tk_GetGC(wPtr->dispData.tkwin,
        GCForeground|GCBackground|GCGraphicsExposures, &gcValues);
    if (wPtr->highlightGC != None) {
        Tk_FreeGC(wPtr->dispData.display, wPtr->highlightGC);
    }
    wPtr->highlightGC = newGC;
 
    /* We must set the options of the default styles so that
     * -- the default styles will change according to what is in
     *    stTmpl
     */
 
    stTmpl.font                         = wPtr->font;
    stTmpl.pad[0]                        = wPtr->padX;
    stTmpl.pad[1]                       = wPtr->padY;
    stTmpl.colors[TIX_DITEM_NORMAL].fg  = wPtr->normalFg;
    stTmpl.colors[TIX_DITEM_NORMAL].bg  = wPtr->normalBg;
    stTmpl.colors[TIX_DITEM_SELECTED].fg= wPtr->selectFg;
    stTmpl.colors[TIX_DITEM_SELECTED].bg= Tk_3DBorderColor(wPtr->selectBorder);
    stTmpl.flags = TIX_DITEM_FONT|TIX_DITEM_NORMAL_BG|
        TIX_DITEM_SELECTED_BG|TIX_DITEM_NORMAL_FG|TIX_DITEM_SELECTED_FG |
        TIX_DITEM_PADX|TIX_DITEM_PADY;
    Tix_SetDefaultStyleTemplate(wPtr->dispData.tkwin, &stTmpl);
 
    /* Probably the size of the elements in this has changed */
    Tix_HLResizeWhenIdle(wPtr);
 
    return TCL_OK;
}
 
/*
 *--------------------------------------------------------------
 *
 * WidgetEventProc --
 *
 *      This procedure is invoked by the Tk dispatcher for various
 *      events on HLists.
 *
 * Results:
 *      None.
 *
 * Side effects:
 *      When the window gets deleted, internal structures get
 *      cleaned up.  When it gets exposed, it is redisplayed.
 *
 *--------------------------------------------------------------
 */
static void
WidgetEventProc(clientData, eventPtr)
    ClientData clientData;      /* Information about window. */
    XEvent *eventPtr;           /* Information about event. */
{
    WidgetPtr wPtr = (WidgetPtr) clientData;
 
    switch (eventPtr->type) {
      case DestroyNotify:
        if (wPtr->dispData.tkwin != NULL) {
            wPtr->dispData.tkwin = NULL;
            Tcl_DeleteCommand(wPtr->dispData.interp,
                Tcl_GetCommandName(wPtr->dispData.interp, wPtr->widgetCmd));
        }
        Tix_HLCancelResizeWhenIdle(wPtr);
        CancelRedrawWhenIdle(wPtr);
        Tk_EventuallyFree((ClientData)wPtr, (Tix_FreeProc*)WidgetDestroy);
        break;
 
      case ConfigureNotify:
        RedrawWhenIdle(wPtr);
        UpdateScrollBars(wPtr, 1);
        break;
 
      case Expose:
        RedrawWhenIdle(wPtr);
        break;
 
      case FocusIn:
        wPtr->hasFocus = 1;
        RedrawWhenIdle(wPtr);
        break;
 
      case FocusOut:
        wPtr->hasFocus = 0;
        RedrawWhenIdle(wPtr);
        break;
    }
}
 
/*
 *--------------------------------------------------------------
 *
 * SubWindowEventProc --
 *
 *      This procedure is invoked by the Tk dispatcher for various
 *      events on the header subwindow.
 *--------------------------------------------------------------
 */
static void
SubWindowEventProc(clientData, eventPtr)
    ClientData clientData;      /* Information about window. */
    XEvent *eventPtr;           /* Information about event. */
{
    WidgetPtr wPtr = (WidgetPtr) clientData;
    Tk_FakeWin * fw;
 
    switch (eventPtr->type) {
      case DestroyNotify:
 
#ifdef TK_PARENT_DESTROYED
        /*
         * The TK_PARENT_DESTROYED symbol is no longer defined in Tk 8.0
         */
        fw = (Tk_FakeWin *) (wPtr->headerWin);
        if (fw->flags & TK_PARENT_DESTROYED) {
            break;
        }
        if (wPtr->headerWin != NULL) {
            panic("HList: header subwindow deleted illegally\n");
        }
#endif
        break;
 
      case Expose:
        if (wPtr->headerWin != NULL) {
            RedrawWhenIdle(wPtr);
        }
        break;
    }
}
 
/*
 *----------------------------------------------------------------------
 *
 * WidgetDestroy --
 *
 *      This procedure is invoked by Tk_EventuallyFree or Tk_Release
 *      to clean up the internal structure of a HList at a safe time
 *      (when no-one is using it anymore).
 *
 * Results:
 *      None.
 *
 * Side effects:
 *      Everything associated with the HList is freed up.
 *
 *----------------------------------------------------------------------
 */
static void
WidgetDestroy(clientData)
    ClientData clientData;      /* Info about my widget. */
{
    WidgetPtr wPtr = (WidgetPtr) clientData;
 
    if (wPtr->root != NULL) {
        DeleteOffsprings(wPtr, wPtr->root);
        FreeElement(wPtr, wPtr->root);
    }
 
    if (wPtr->backgroundGC != None) {
        Tk_FreeGC(wPtr->dispData.display, wPtr->backgroundGC);
    }
    if (wPtr->normalGC != None) {
        Tk_FreeGC(wPtr->dispData.display, wPtr->normalGC);
    }
    if (wPtr->selectGC != None) {
        Tk_FreeGC(wPtr->dispData.display, wPtr->selectGC);
    }
    if (wPtr->anchorGC != None) {
        Tk_FreeGC(wPtr->dispData.display, wPtr->anchorGC);
    }
    if (wPtr->dropSiteGC != None) {
        Tk_FreeGC(wPtr->dispData.display, wPtr->dropSiteGC);
    }
    if (wPtr->highlightGC != None) {
        Tk_FreeGC(wPtr->dispData.display, wPtr->highlightGC);
    }
 
    /* the following two members will be NULL if the widget was destroyed
     * during its creation (e.g., wrong arguments during creation
     */
    if (wPtr->reqSize != NULL) {
        ckfree((char*)wPtr->reqSize);
    }
    if (wPtr->actualSize != NULL) {
        ckfree((char*)wPtr->actualSize);
    }
    if (wPtr->elmToSee != NULL) {
        ckfree(wPtr->elmToSee);
        wPtr->elmToSee = NULL;
    }
 
    Tix_HLFreeHeaders(wPtr->dispData.interp, wPtr);
 
    if (!Tix_IsLinkListEmpty(wPtr->mappedWindows)) {
        /*
         * All mapped windows should have been unmapped when the
         * the entries were deleted
         */
        panic("tixHList: mappedWindows not NULL");
    }
    if (wPtr->headerWin) {
        wPtr->headerWin = NULL;
    }
    Tcl_DeleteHashTable(&wPtr->childTable);
 
    Tk_FreeOptions(configSpecs, (char *) wPtr, wPtr->dispData.display, 0);
    ckfree((char *) wPtr);
}
 
/*
 *----------------------------------------------------------------------
 *
 * WidgetCmdDeletedProc --
 *
 *      This procedure is invoked when a widget command is deleted.  If
 *      the widget isn't already in the process of being destroyed,
 *      this command destroys it.
 *
 * Results:
 *      None.
 *
 * Side effects:
 *      The widget is destroyed.
 *
 *----------------------------------------------------------------------
 */
static void
WidgetCmdDeletedProc(clientData)
    ClientData clientData;      /* Pointer to widget record for widget. */
{
    WidgetPtr wPtr = (WidgetPtr) clientData;
 
    /*
     * This procedure could be invoked either because the window was
     * destroyed and the command was then deleted (in which case tkwin
     * is NULL) or because the command was deleted, and then this procedure
     * destroys the widget.
     */
    if (wPtr->dispData.tkwin != NULL) {
        Tk_Window tkwin = wPtr->dispData.tkwin;
        wPtr->dispData.tkwin = NULL;
        Tk_DestroyWindow(tkwin);
    }
}
 
/*
 *--------------------------------------------------------------
 *
 * Tix_HLComputeGeometry --
 *
 *      This procedure is invoked to process the Tcl command
 *      that corresponds to a widget managed by this module.
 *      See the user documentation for details on what it does.
 *
 * Results:
 *      A standard Tcl result.
 *
 * Side effects:
 *      none
 *
 *--------------------------------------------------------------
 */
void
Tix_HLComputeGeometry(clientData)
    ClientData clientData;
{
    WidgetPtr wPtr = (WidgetPtr)clientData;
    int i, reqW, reqH;
    int sizeChanged = 0;
    int width;
    wPtr->resizing = 0;
 
    /* Update geometry request */
    if (wPtr->useHeader && wPtr->headerDirty) {
        Tix_HLComputeHeaderGeometry(wPtr);
    }
 
    if (wPtr->root->dirty || wPtr->allDirty) {
        if (wPtr->useIndicator) {
            /*
             * If we use indicator, then the toplevel elements are indented
             * by wPtr->indent. Otherwise they are indented by 0 pixels
             */
            ComputeElementGeometry(wPtr, wPtr->root, wPtr->indent);
        } else {
            ComputeElementGeometry(wPtr, wPtr->root, 0);
        }
    }
    width = 0;
    for (i=0; i<wPtr->numColumns; i++) {
        if (wPtr->reqSize[i].width != UNINITIALIZED) {
            wPtr->actualSize[i].width = wPtr->reqSize[i].width;
        }
        else {
            /* This is the req size of the entry columns */
            int entReq = wPtr->root->col[i].width;
 
            /* This is the req size of the header columns */
            int hdrReq = wPtr->headers[i]->width;
 
            if (wPtr->useHeader && hdrReq > entReq) {
                wPtr->actualSize[i].width = hdrReq;
            } else {
                wPtr->actualSize[i].width = entReq;
            }
        }
        width += wPtr->actualSize[i].width;
    }
    sizeChanged = 1;
    wPtr->allDirty = 0;
 
    wPtr->totalSize[0] = width;
    wPtr->totalSize[1] = wPtr->root->allHeight;
 
    if (wPtr->width > 0) {
        reqW = wPtr->width * wPtr->scrollUnit[0];
    } else {
        reqW = width;
    }
    if (wPtr->height > 0) {
        reqH = wPtr->height * wPtr->scrollUnit[1];
    } else {
        reqH = wPtr->root->allHeight;
    }
 
    wPtr->totalSize[0] += 2*wPtr->borderWidth + 2*wPtr->highlightWidth;
    wPtr->totalSize[1] += 2*wPtr->borderWidth + 2*wPtr->highlightWidth;
    reqW               += 2*wPtr->borderWidth + 2*wPtr->highlightWidth;
    reqH               += 2*wPtr->borderWidth + 2*wPtr->highlightWidth;
 
    if (wPtr->useHeader) {
        reqH           += wPtr->headerHeight;
    }
 
    /* Now we need to handle the multiple columns mode */
 
    Tk_GeometryRequest(wPtr->dispData.tkwin, reqW, reqH);
 
    /* Update scrollbars */
    UpdateScrollBars(wPtr, sizeChanged);
 
    RedrawWhenIdle(wPtr);
}
 
/*
 *----------------------------------------------------------------------
 * Tix_HLResizeWhenIdle --
 *----------------------------------------------------------------------
 */
void
Tix_HLResizeWhenIdle(wPtr)
    WidgetPtr wPtr;
{
    if (!wPtr->resizing) {
        wPtr->resizing = 1;
        Tk_DoWhenIdle(Tix_HLComputeGeometry, (ClientData)wPtr);
    }
    if (wPtr->redrawing) {
        CancelRedrawWhenIdle(wPtr);
    }
}
 
/*
 *----------------------------------------------------------------------
 * Tix_HLResizeNow --
 *----------------------------------------------------------------------
 */
void
Tix_HLResizeNow(wPtr)
    WidgetPtr wPtr;
{
    if (wPtr->resizing) {
        wPtr->resizing = 0;
        Tk_CancelIdleCall(Tix_HLComputeGeometry, (ClientData)wPtr);
        Tix_HLComputeGeometry((ClientData)wPtr);
    }
}
 
/*
 *----------------------------------------------------------------------
 * Tix_HLCancelResizeWhenIdle --
 *----------------------------------------------------------------------
 */
void
Tix_HLCancelResizeWhenIdle(wPtr)
    WidgetPtr wPtr;
{
    if (wPtr->resizing) {
        wPtr->resizing = 0;
        Tk_CancelIdleCall(Tix_HLComputeGeometry, (ClientData)wPtr);
    }
}
 
/*
 *----------------------------------------------------------------------
 * RedrawWhenIdle --
 *----------------------------------------------------------------------
 */
static void
RedrawWhenIdle(wPtr)
    WidgetPtr wPtr;
{
    if (!wPtr->redrawing && Tk_IsMapped(wPtr->dispData.tkwin)) {
        wPtr->redrawing = 1;
        Tk_DoWhenIdle(WidgetDisplay, (ClientData)wPtr);
    }
}
 
/*
 *----------------------------------------------------------------------
 * CancelRedrawWhenIdle --
 *----------------------------------------------------------------------
 */
static void
CancelRedrawWhenIdle(wPtr)
    WidgetPtr wPtr;
{
    if (wPtr->redrawing) {
        wPtr->redrawing = 0;
        Tk_CancelIdleCall(WidgetDisplay, (ClientData)wPtr);
    }
}
 
/*----------------------------------------------------------------------
 * DItemSizeChangedProc --
 *
 *      This is called whenever the size of one of the HList's items
 *      changes its size.
 *----------------------------------------------------------------------
 */
static void DItemSizeChangedProc(iPtr)
    Tix_DItem *iPtr;
{
    HLItemTypeInfo * info = (HLItemTypeInfo *)iPtr->base.clientData;
    HListColumn * colPtr;
    HListElement * chPtr;
    HListHeader * hPtr;
    WidgetPtr wPtr;
 
    if (info == NULL) {
        /* Perhaps we haven't set the clientData yet! */
        return;
    }
 
    switch (info->type) {
      case HLTYPE_COLUMN:
        colPtr = (HListColumn*) info;
        chPtr = colPtr->chPtr;
 
        if (chPtr) {    /* Sanity check */
            Tix_HLMarkElementDirty(chPtr->wPtr, chPtr);
            Tix_HLResizeWhenIdle(chPtr->wPtr);
        }
        break;
      case HLTYPE_HEADER:
        hPtr = (HListHeader*)info;
        wPtr = hPtr->wPtr;
        wPtr->headerDirty = 1;
        if (wPtr->useHeader) {
            Tix_HLResizeWhenIdle(wPtr);
        }
        break;
      case HLTYPE_ENTRY:
        chPtr = (HListElement*)info;
 
        if (chPtr) {    /* Sanity check */
            Tix_HLMarkElementDirty(chPtr->wPtr, chPtr);
            Tix_HLResizeWhenIdle(chPtr->wPtr);
        }
        break;
    }
}
 
/*
 *--------------------------------------------------------------
 *
 * AllocElement --
 *
 *      Allocates a new structure for the new element and record it
 *      in the hash table
 *
 * Results:
 *      a pointer to the new element's structure
 *
 * Side effects:
 *      Has table is changed
 *--------------------------------------------------------------
 */
static HListElement *
AllocElement(wPtr, parent, pathName, name, ditemType)
    WidgetPtr wPtr;
    HListElement * parent;
    char * pathName;
    char * name;
    char * ditemType;
{
    HListElement      * chPtr;
    Tcl_HashEntry     * hashPtr;
    int                 dummy;
    Tix_DItem         * iPtr;
 
    if (ditemType == NULL) {
        iPtr = NULL;
    } else {
        if ((iPtr = Tix_DItemCreate(&wPtr->dispData, ditemType)) == NULL) {
            return NULL;
        }
    }
 
    chPtr = (HListElement*)ckalloc(sizeof(HListElement));
 
    if (pathName) {
        /* pathName == 0 is the root element */
        hashPtr = Tcl_CreateHashEntry(&wPtr->childTable, pathName, &dummy);
        Tcl_SetHashValue(hashPtr, (char*)chPtr);
    }
 
    if (parent) {
        ++ parent->numCreatedChild;
    }
 
    if (wPtr->numColumns > 1) {
        chPtr->col              = Tix_HLAllocColumn(wPtr, chPtr);
    } else {
        chPtr->col              = &chPtr->_oneCol;
        chPtr->_oneCol.type     = HLTYPE_COLUMN;
        chPtr->_oneCol.self     = (char*) &chPtr->_oneCol;
        chPtr->_oneCol.chPtr    = chPtr;
        chPtr->_oneCol.iPtr     = NULL;
        chPtr->_oneCol.width    = 0;
    }
    if (pathName) {
        chPtr->pathName         = (char*)tixStrDup(pathName);
    } else {
        chPtr->pathName         = NULL;
    }
 
    if (name) {
        chPtr->name             = (char*)tixStrDup(name);
    } else {
        chPtr->name             = NULL;
    }
 
    chPtr->type = HLTYPE_ENTRY;
    chPtr->self = (char*)chPtr;
    chPtr->wPtr                 = wPtr;
    chPtr->parent               = parent;
    chPtr->prev                 = NULL;
    chPtr->next                 = NULL;
    chPtr->childHead            = NULL;
    chPtr->childTail            = NULL;
    chPtr->numSelectedChild     = 0;
    chPtr->numCreatedChild      = 0;
    chPtr->col[0].iPtr           = iPtr;
    chPtr->indicator            = NULL;
 
    chPtr->height               = 0;
    chPtr->allHeight            = 0;
    chPtr->selected             = 0;
    chPtr->dirty                = 0;
    chPtr->hidden               = 0;
    chPtr->state                = tixNormalUid;
    chPtr->data                 = NULL;
    chPtr->branchX              = 0;
    chPtr->branchY              = 0;
 
    if (iPtr) {
        /* The clientdata is usedful for the DItemSizeChangedProc() */
        iPtr->base.clientData = (ClientData)&chPtr->col[0];
    }
 
    return chPtr;
}
 
static void
FreeElement(wPtr, chPtr)
    WidgetPtr wPtr;
    HListElement * chPtr;
{
    Tcl_HashEntry * hashPtr;
    int i;
 
    if (chPtr->selected) {
        HL_SelectionClear(wPtr, chPtr);
    }
    if (wPtr->anchor == chPtr) {
        wPtr->anchor = NULL;
    }
    if (wPtr->dragSite == chPtr) {
        wPtr->dragSite = NULL;
    }
    if (wPtr->dropSite == chPtr) {
        wPtr->dropSite = NULL;
    }
 
    /*
     * Free all the display items
     */
    for (i=0; i<wPtr->numColumns; i++) {
        if (chPtr->col[i].iPtr) {
            if (Tix_DItemType(chPtr->col[i].iPtr) == TIX_DITEM_WINDOW) {
                Tix_WindowItemListRemove(&wPtr->mappedWindows,
                    chPtr->col[i].iPtr);
            }
            Tix_DItemFree(chPtr->col[i].iPtr);
        }
    }
    if (chPtr->indicator != NULL) {
        if (Tix_DItemType(chPtr->indicator) == TIX_DITEM_WINDOW) {
            Tix_WindowItemListRemove(&wPtr->mappedWindows,
                chPtr->indicator);
        }
        Tix_DItemFree(chPtr->indicator);
    }
 
    if (chPtr->col != &chPtr->_oneCol) {
        /*
         * This space was allocated dynamically
         */
        ckfree((char*)chPtr->col);
    }
 
    if (chPtr->pathName) {
        /*
         * Root does not have an entry in the hash table
         */
        if ((hashPtr = Tcl_FindHashEntry(&wPtr->childTable, chPtr->pathName))){
            Tcl_DeleteHashEntry(hashPtr);
        }
    }
    if (chPtr->name != NULL) {
        ckfree(chPtr->name);
    }
    if (chPtr->pathName != NULL) {
        ckfree(chPtr->pathName);
    }
    if (chPtr->data != NULL) {
        ckfree(chPtr->data);
    }
 
    ckfree((char*)chPtr);
}
 
static void
AppendList(wPtr, parent, chPtr, at, afterPtr, beforePtr)
    WidgetPtr wPtr;
    HListElement *parent;
    HListElement *chPtr;
    int at;                     /* At what position should this entry be added
                                 * default is "-1": add at the end */
    HListElement *afterPtr;     /* after which entry should this entry be
                                 * added. Default is NULL : ignore */
    HListElement *beforePtr;    /* before which entry should this entry be
                                 * added. Default is NULL : ignore */
{
    if (parent->childHead == NULL) {
        parent->childHead = chPtr;
        parent->childTail = chPtr;
        chPtr->prev = NULL;
        chPtr->next = NULL;
    }
    else {
        if (at >= 0) {
            /*
             * Find the current element at the "at" position
             */
            HListElement *ptr;
            for (ptr=parent->childHead;
                 ptr!=NULL && at > 0;
                 ptr=ptr->next, --at) {
                ; /* do nothing, just keep counting */
            }
            if (ptr != NULL) {
                /*
                 * We need to insert the new element *before* ptr.E.g,
                 * if at == 0, then the new element should be the first
                 * of the list
                 */
                beforePtr = ptr;
            } else {
                /* Seems like we walked past the end of the list. Well, do
                 * nothing here. By default, the new element will be
                 * append to the end of the list
                 */
            }
        }
        if (afterPtr != NULL) {
            if (afterPtr == parent->childTail) {
                parent->childTail = chPtr;
            } else {
                afterPtr->next->prev = chPtr;
            }
            chPtr->prev = afterPtr;
            chPtr->next = afterPtr->next;
            afterPtr->next = chPtr;
            return;
        }
        if (beforePtr !=NULL) {
            if (beforePtr == parent->childHead) {
                parent->childHead = chPtr;
            } else {
                beforePtr->prev->next = chPtr;
            }
            chPtr->prev = beforePtr->prev;
            chPtr->next = beforePtr;
            beforePtr->prev = chPtr;
            return;
        }
 
        /*
         * By default, append it at the end of the list
         */
        parent->childTail->next = chPtr;
        chPtr->prev = parent->childTail;
        chPtr->next = NULL;
        parent->childTail = chPtr;
    }
}
 
/*
 *--------------------------------------------------------------
 *
 * NewElement --
 *
 *      This procedure is creates a new element and record it both
 *      the hash table and in the tree.
 *
 * Results:
 *      pointer to new element
 *
 * Side effects:
 *      Hash table and tree changed if successful
 *--------------------------------------------------------------
 */
static HListElement *
NewElement(interp, wPtr, argc, argv, pathName, defParentName, newArgc)
    Tcl_Interp *interp;
    WidgetPtr wPtr;
    int argc;
    char ** argv;
    char * pathName;            /* Default pathname, if -pathname is not
                                 * specified in the options */
    char * defParentName;       /* Default parent name (will NULL if pathName
                                 * is not NULL */
    int * newArgc;
{
#define FIXED_SPACE 20
    char fixedSpace[FIXED_SPACE+1];
    char *p, *parentName = NULL;
    char *name;                         /* Last part of the name */
    int i, n, numChars;
    HListElement *parent;
    HListElement *chPtr;
    char sep = wPtr->separator[0];
    int allocated = 0;
    char * ditemType = NULL;
    HListElement *afterPtr  = NULL;
    HListElement *beforePtr = NULL;
    int at = -1;
    int numSwitches = 0;         /* counter on how many of the
                                         * -after, -before and -at switches
                                         * have been used. No more than one
                                         * of then can be used */
 
    /*
     * (1) We need to determine the options:
     *     -itemtype, -after, -before and/or -at.
     *
     */
    if (argc > 0) {
        size_t len;
        if (argc %2 != 0) {
            Tcl_AppendResult(interp, "value for \"", argv[argc-1],
                "\" missing", NULL);
            chPtr = NULL;
            goto done;
        }
        for (n=i=0; i<argc; i+=2) {
            len = strlen(argv[i]);
            if (strncmp(argv[i], "-itemtype", len) == 0) {
                ditemType = argv[i+1];
                goto copy;
            }
            else if (strncmp(argv[i], "-after", len) == 0) {
                afterPtr = Tix_HLFindElement(interp, wPtr, argv[i+1]);
                if (afterPtr == NULL) {
                    chPtr = NULL;
                    goto done;
                }
                ++ numSwitches;
                continue;
            }
            else if (strncmp(argv[i], "-before", len) == 0) {
                beforePtr = Tix_HLFindElement(interp, wPtr, argv[i+1]);
                if (beforePtr == NULL) {
                    chPtr = NULL;
                    goto done;
                }
                ++ numSwitches;
                continue;
            }
            else if (strncmp(argv[i], "-at", len) == 0) {
                if (Tcl_GetInt(interp, argv[i+1], &at) != TCL_OK) {
                    chPtr = NULL;
                    goto done;
                }
                ++ numSwitches;
                continue;
            }
 
          copy:
            if (n!=i) {
                argv[n] = argv[i];
                argv[n+1] = argv[i+1];
            }
            n+=2;
        }
        * newArgc = n;
    } else {
        * newArgc = 0;
    }
    if (numSwitches > 1) {
        Tcl_AppendResult(interp, "No more than one of the -after, -before ",
            "and -at options can be used", NULL);
        chPtr = NULL;
        goto done;
    }
    if (ditemType == NULL) {
        ditemType = wPtr->diTypePtr->name;
    }
    if (Tix_GetDItemType(interp, ditemType) == NULL) {
        chPtr = NULL;
        goto done;
    }
 
    /*------------------------------------------------------------
     * (2) Create the new entry. The method depends on whether
     *     the "add" or "addchild" command has been called
     *------------------------------------------------------------
     */
    if (pathName == NULL) {
        /* (2.a) Called by the "addchild" command. We need to generate
         *     a default name for the child
         *
         */
        char buff[40];
 
        parentName = defParentName;
        if (parentName == NULL) {
            parent = wPtr->root;
        } else {
            if ((parent=Tix_HLFindElement(interp, wPtr, parentName))== NULL) {
                Tcl_ResetResult(interp);
                Tcl_AppendResult(interp, "parent element \"", parentName,
                    "\" does not exist", (char *) NULL);
                chPtr = NULL;
                goto done;
            }
        }
 
        /* Generate a default name for this entry */
        sprintf(buff, "%d", parent->numCreatedChild);
        name = buff;
 
        if (parentName == NULL) {
            pathName = (char*)tixStrDup(name);
            allocated = 1;
        }
        else {
            pathName = ckalloc(strlen(parentName)+1+ strlen(name)+1);
            allocated = 1;
            sprintf(pathName, "%s%c%s", parentName, sep, name);
        }
    }
    else {
        /* (2.b) Called by the "add" command.
         *
         * Strip the parent's name out of pathName (it's everything up
         * to the last dot).  There are two tricky parts: (a) must
         * copy the parent's name somewhere else to avoid modifying
         * the pathName string (for large names, space for the copy
         * will have to be malloc'ed);  (b) must special-case the
         * situation where the parent is ".".
         */
 
        if ((p = strrchr(pathName, (int)sep)) == NULL) {
            /* This is a toplevel element  (no "." in it) */
            name = pathName;
            parentName = NULL;
        }
        else {
            name = p+1;
            numChars = p-pathName;
            if (numChars > FIXED_SPACE) {
                parentName = (char *) ckalloc((unsigned)(numChars+1));
            } else {
                parentName = fixedSpace;
            }
            if (numChars == 0) {
                if ((pathName[0] == sep) && (pathName[1] == '\0')) {
                    /*
                     * The separator by itself is also a toplevel entry
                     */
                    parentName = 0;
                } else {
                    parentName[0] = sep;
                    parentName[1] = '\0';
                }
            }
            else {
                strncpy(parentName, pathName, (size_t) numChars);
                parentName[numChars] = '\0';
            }
        }
 
        if (parentName == NULL) {
            parent = wPtr->root;
        } else {
            if ((parent = Tix_HLFindElement(interp, wPtr, parentName))==NULL) {
                Tcl_ResetResult(interp);
                Tcl_AppendResult(interp, "parent element \"", parentName,
                "\" does not exist", (char *) NULL);
                chPtr = NULL;
                goto done;
            }
        }
 
    }
    if (Tix_HLFindElement(interp, wPtr, pathName) != NULL) {
        Tcl_AppendResult(interp, "element \"", pathName,
            "\" already exists", (char *) NULL);
        chPtr = NULL;
        goto done;
    }
    else {
        if (afterPtr != NULL && afterPtr->parent != parent) {
            Tcl_AppendResult(interp, "cannot add entry after \"",
                afterPtr->pathName, "\"", NULL);
            chPtr = NULL;
            goto done;
        }
        if (beforePtr != NULL && beforePtr->parent != parent) {
            Tcl_AppendResult(interp, "cannot add entry before \"",
                beforePtr->pathName, "\"", NULL);
            chPtr = NULL;
            goto done;
        }
 
        Tcl_ResetResult(interp);
        if ((chPtr = AllocElement(wPtr, parent, pathName, name, ditemType))
             == NULL) {
            /* Some error, now chPtr == NULL */
            goto done;
        }
        AppendList(wPtr, parent, chPtr, at, afterPtr, beforePtr);
        Tix_HLMarkElementDirty(wPtr, chPtr);
        Tix_HLResizeWhenIdle(wPtr);
        goto done;              /* success */
    }
 
  done:
    if (allocated) {
        ckfree((char*)pathName);
    }
    if (parentName && parentName != fixedSpace && parentName !=defParentName) {
        ckfree((char*)parentName);
    }
    return chPtr;
}
 
/*--------------------------------------------------------------
 * ConfigElement --
 *
 *      This procedure configures the element according to the
 *      options.
 *
 * Results:
 *      A standard Tcl result.
 *
 * Side effects:
 *      Hash table and tree changed if successful
 *--------------------------------------------------------------
 */
 
static int
ConfigElement(wPtr, chPtr, argc, argv, flags, forced)
    WidgetPtr wPtr;
    HListElement *chPtr;
    int argc;
    char ** argv;
    int flags;
    int forced;                 /* We need a "forced" configure to ensure that
                                 * the DItem is initialized properly */
{
    int sizeChanged;
 
    if (Tix_WidgetConfigure2(wPtr->dispData.interp, wPtr->dispData.tkwin,
        (char*)chPtr, entryConfigSpecs, chPtr->col[0].iPtr, argc, argv, flags,
        forced, &sizeChanged) != TCL_OK) {
        return TCL_ERROR;
    }
 
    if (sizeChanged) {
        Tix_HLMarkElementDirty(wPtr, chPtr);
        Tix_HLResizeWhenIdle(wPtr);
    } else {
        RedrawWhenIdle(wPtr);
    }
 
    return TCL_OK;
}
 
/*
 *--------------------------------------------------------------
 *
 * FindElementAtPosition --
 *
 *      Finds a visible element nearest to a Y position
 *
 * Results:
 *      Pointer to the element.
 *
 * Side effects:
 *      None
 *--------------------------------------------------------------
 */
static HListElement * FindElementAtPosition(wPtr, y)
    WidgetPtr wPtr;
    int y;
{
    HListElement * chPtr = wPtr->root;
    int top = 0;
 
    y -= wPtr->borderWidth + wPtr->highlightWidth;
    y += wPtr->topPixel;
 
    if (wPtr->useHeader) {
        y -= wPtr->headerHeight;
    }
 
    if (y < 0) {
        /*
         * Position is above the top of the list, return the first element in
         * the list of toplevel entries.
         */
        if (wPtr->root != NULL) {
            for (chPtr=wPtr->root->childHead; chPtr!=NULL; chPtr=chPtr->next) {
                if (!chPtr->hidden) {
                    return chPtr;
                }
            }
        }
        return NULL;
    }
    if (y >= chPtr->allHeight) {
        /*
         * Position is past the end of the list, return the last element.
         */
        HListElement * vis;
 
        chPtr=wPtr->root;
        while (1) {
            if (chPtr->childTail == NULL) {
                break;
            }
            for (vis = chPtr->childTail; vis && vis->hidden; vis=vis->prev) {
                ;
            }
            if (vis == NULL) {
                break;
            } else {
                chPtr = vis;
                continue;
            }
        }
        if (chPtr == wPtr->root) {
            /*
             * There is either no element, or all elements are not visible
             */
            return NULL;
        } else {
            return chPtr;
        }
    }
 
    /*
     * The following is a tail-recursive function flatten out in a while
     * loop.
     */
 
    while (1) {
    again:
        for (chPtr=chPtr->childHead; chPtr!=NULL; chPtr=chPtr->next) {
            if (!chPtr->hidden) {
                if (top <= y && y < top + chPtr->allHeight) {
                    if (y < top + chPtr->height) {
                        return chPtr;
                    } else {
                        top += chPtr->height;
                        goto again;
                    }
                } else {
                    top += chPtr->allHeight;
                }
            }
        }
    }
}
 
/*
 *--------------------------------------------------------------
 *
 * Tix_HLFindElement --
 *
 *      Finds an element according to its pathname.
 *
 * Results:
 *      Pointer to the element if found. Otherwise NULL.
 *
 * Side effects:
 *      None
 *--------------------------------------------------------------
 */
HListElement * Tix_HLFindElement(interp, wPtr, pathName)
    Tcl_Interp * interp;
    WidgetPtr wPtr;
    char * pathName;
{
    Tcl_HashEntry     * hashPtr;
 
    if (pathName) {
        hashPtr = Tcl_FindHashEntry(&wPtr->childTable, pathName);
 
        if (hashPtr) {
            return (HListElement*) Tcl_GetHashValue(hashPtr);
        } else {
            Tcl_AppendResult(interp, "Entry \"", pathName,
                "\" not found", NULL);
            return NULL;
        }
    }
    else {
        /* pathName == 0 is the root element */
        return wPtr->root;
    }
}
 
/*
 *--------------------------------------------------------------
 *
 * SelectionModifyRange --
 *
 *      Select or de-select all the elements between from and to
 *      (inclusive), according to the "select" argument.
 *
 *      select == 1 : select
 *      select == 0 : de-select
 *
 * Return value:
 *      Whether the selection was actually changed
 *--------------------------------------------------------------
 */
static int SelectionModifyRange(wPtr, from, to, select)
    WidgetPtr wPtr;
    HListElement * from;
    HListElement * to;
    int select;
{
    int changed = 0;
 
    if (Tix_HLElementTopOffset(wPtr, from) > Tix_HLElementTopOffset(wPtr, to)){
        HListElement * tmp;
        tmp  = to;
        to   = from;
        from = tmp;
    }
 
    while (1) {
        if (!from->hidden && (int)from->selected != select) {
            if (select) {
                SelectionAdd(wPtr, from);
            } else {
                HL_SelectionClear(wPtr, from);
                changed = 1;
            }
        }
 
        if (from == to) {
            /*
             * Iterated to the end of the region
             */
            break;
        }
 
        /*
         * Go to the next list entry
         */
        if (from->childHead) {
            from = from->childHead;
        }
        else if (from->next) {
            from = from->next;
        }
        else {
            /*
             * go to a different branch
             */
            while (from->parent->next == NULL && from != wPtr->root) {
                from = from->parent;
            }
            if (from == wPtr->root) {
                /*
                 * Iterated over all list entries
                 */
                break;
            } else {
                from = from->parent->next;
            }
        }
    }
 
    return changed;
}
 
/*
 *--------------------------------------------------------------
 *
 * Tix_HLElementTopOffset --
 *
 *--------------------------------------------------------------
 */
int Tix_HLElementTopOffset(wPtr, chPtr)
    WidgetPtr wPtr;
    HListElement * chPtr;
{
    int top;
    HListElement * ptr;
 
    if (chPtr == wPtr->root) {
        return 0;
    }
    top = Tix_HLElementTopOffset(wPtr, chPtr->parent);
    top += chPtr->parent->height;
 
    for (ptr=chPtr->parent->childHead; ptr!=NULL; ptr=ptr->next) {
        if (ptr == chPtr) {
            break;
        }
        if (ptr->hidden) {
            continue;
        }
        top += ptr->allHeight;
    }
    return top;
}
 
/*
 *--------------------------------------------------------------
 *
 * Tix_HLElementLeftOffset --
 *
 *--------------------------------------------------------------
 */
int Tix_HLElementLeftOffset(wPtr, chPtr)
    WidgetPtr wPtr;
    HListElement * chPtr;
{
    int left;
 
    if (chPtr == wPtr->root || chPtr->parent == wPtr->root) {
        return 0;
    }
 
    left = Tix_HLElementLeftOffset(wPtr, chPtr->parent);
    left += wPtr->indent;
 
    return left;
}
 
/*
 *--------------------------------------------------------------
 *
 * CurSelection --
 *
 *      returns the current selection in the result of interp;
 *
 *--------------------------------------------------------------
 */
static int CurSelection(interp, wPtr, chPtr)
    Tcl_Interp * interp;
    WidgetPtr wPtr;
    HListElement * chPtr;
{
    HListElement * ptr;
 
    /* Since this recursion starts with wPtr->root, we determine
     * whether a node is selected when its *parent* is called. This
     * will save one level of recursion (otherwise all leave nodes will
     * be recursed once and will be slow ...
     */
    for (ptr=chPtr->childHead; ptr; ptr=ptr->next) {
        if (ptr->selected && !(ptr->hidden)) {
            Tcl_AppendElement(interp, ptr->pathName);
        }
        if (ptr->childHead) {
            CurSelection(interp, wPtr, ptr);
        }
    }
    return TCL_OK;
}
 
/*
 *--------------------------------------------------------------
 *
 * Tix_HLMarkElementDirty --
 *
 *      Marks a element "dirty", i.e., its geometry needs to be
 *      recalculated.
 *
 * Results:
 *      None.
 *
 * Side effects:
 *      The element and all its ancestores are marked dirty
 *--------------------------------------------------------------
 */
void Tix_HLMarkElementDirty(wPtr, chPtr)
    WidgetPtr wPtr;
    HListElement *chPtr;
{
    HListElement *ptr;
 
    for (ptr=chPtr; ptr!= NULL && ptr->dirty == 0; ptr=ptr->parent) {
        ptr->dirty = 1;
    }
}
 
/*
 *--------------------------------------------------------------
 *
 * ComputeElementGeometry --
 *
 *      Compute the geometry of this element (if its dirty) and the
 *      geometry of all its dirty child elements
 *
 * Results:
 *      None.
 *
 * Side effects:
 *      The element and all its decendants are marked non-dirty
 *--------------------------------------------------------------
 */
 
static void ComputeElementGeometry(wPtr, chPtr, indent)
    WidgetPtr wPtr;
    HListElement *chPtr;
    int indent;
{
    HListElement *ptr;
    int i;
 
    if (!chPtr->dirty && !wPtr->allDirty) {
        return;
    } else {
        chPtr->dirty = 0;
    }
 
    if (chPtr == wPtr->root) {
        int i;
        chPtr->height = 0;
        chPtr->indent = 0;
        for (i=0; i<wPtr->numColumns; i++) {
            chPtr->col[i].width = 0;
        }
    } else {
        ComputeOneElementGeometry(wPtr, chPtr, indent);
        indent += wPtr->indent;
    }
 
    chPtr->allHeight = chPtr->height;
 
    for (ptr=chPtr->childHead; ptr!=NULL; ptr=ptr->next) {
        if (ptr->hidden) {
            continue;
        }
        if (ptr->dirty || wPtr->allDirty) {
            ComputeElementGeometry(wPtr, ptr, indent);
        }
 
        /* Propagate the child's size to the parent
         *
         */
        for (i=0; i<wPtr->numColumns; i++) {
            if (chPtr->col[i].width < ptr->col[i].width) {
                chPtr->col[i].width = ptr->col[i].width;
            }
        }
        chPtr->allHeight += ptr->allHeight;
    }
}
 
/*
 *--------------------------------------------------------------
 *
 * ComputeOneElementGeometry --
 *
 *      Compute the geometry of the element itself, not including
 *      its children, according to its current display type.
 *
 * Results:
 *      None.
 *
 * Side effects:
 *      The chPtr->height fields are updated.
 *--------------------------------------------------------------
 */
static void ComputeOneElementGeometry(wPtr, chPtr, indent)
    WidgetPtr wPtr;
    HListElement *chPtr;
    int indent;
{
    int i;
 
    chPtr->indent = indent;
    chPtr->height = 0;
 
    ComputeBranchPosition(wPtr, chPtr);
 
    for (i=0; i<wPtr->numColumns; i++) {
        Tix_DItem * iPtr = chPtr->col[i].iPtr;
        int width  = 2*wPtr->selBorderWidth;
        int height = 2*wPtr->selBorderWidth;
 
        if (iPtr != NULL) {
            Tix_DItemCalculateSize(iPtr);
            /* Tix_DItemWidth() and Tix_DItemHeight() already include padding
             */
            width  += Tix_DItemWidth (iPtr);
            height += Tix_DItemHeight(iPtr);
        }
        if (chPtr->height < height) {
            chPtr->height = height;
        }
        chPtr->col[i].width = width;
    }
    chPtr->col[0].width += indent;
}
 
/*
 *--------------------------------------------------------------
 *
 * ComputeBranchPosition --
 *
 *      Compute the position of the branches
 *
 * Results:
 *      None.
 *
 * Side effects:
 *      The chPtr->branchX and chPtr->branchY fields are updated.
 *--------------------------------------------------------------
 */
static void ComputeBranchPosition(wPtr, chPtr)
    WidgetPtr wPtr;
    HListElement *chPtr;
{
    Tix_DItem * iPtr = chPtr->col[0].iPtr;
    int branchX, branchY;
    int iconX;
    int iconY;
    int diff;
 
    if (iPtr) {
        if (Tix_DItemType(iPtr) == TIX_DITEM_IMAGETEXT) {
            /*
             * Calculate the bottom-middle position of the bitmap/image branch
             */
            if (iPtr->imagetext.image != NULL) {
                branchX = iPtr->imagetext.imageW / 2;
                branchY = iPtr->imagetext.imageH;
                if (Tix_DItemHeight(iPtr) > iPtr->imagetext.imageH) {
                    branchY +=  (Tix_DItemHeight(iPtr) -
                        iPtr->imagetext.imageH) /2;
                }
            }
            else if (iPtr->imagetext.bitmap != None) {
                branchX = iPtr->imagetext.bitmapW / 2;
                branchY = iPtr->imagetext.bitmapH;
                if (Tix_DItemHeight(iPtr) >iPtr->imagetext.bitmapH) {
                    branchY += (Tix_DItemHeight(iPtr) -
                        iPtr->imagetext.bitmapH) /2;
                }
            }
            else {
                branchX = wPtr->indent/2;
                branchY = Tix_DItemHeight(iPtr);
            }
        } else {
            branchX = wPtr->indent/2;
            branchY = Tix_DItemHeight(iPtr);
        }
 
 
        /* X adjustment
         */
        iconX = Tix_DItemPadX(iPtr);
        branchX += Tix_DItemPadX(iPtr);
 
        /* Y adjustment
         */
        iconY = Tix_DItemHeight(iPtr) / 2;
        diff = chPtr->height - Tix_DItemHeight(iPtr);
        if (diff > 0) {
            switch (iPtr->base.stylePtr->anchor) {
              case TK_ANCHOR_NW: case TK_ANCHOR_N: case TK_ANCHOR_NE:
                diff = 0;
                break;
              case TK_ANCHOR_W: case TK_ANCHOR_CENTER: case TK_ANCHOR_E:
                diff /= 2;
                break;
              default:
                /* Do nothing */
                ;
            }
            branchY += diff;
            iconY   += diff;
        }
    }
    else {
        branchX = wPtr->indent/2;
        branchY = chPtr->height;
        iconX   = 0;
        iconY   = chPtr->height/2;
    }
 
    if (wPtr->useIndicator && chPtr->parent == wPtr->root) {
        branchX += wPtr->indent;
    }
 
    chPtr->branchX = branchX - 1;
    chPtr->branchY = branchY - 1;
    chPtr->iconX   = iconX   - 1;
    chPtr->iconY   = iconY   - 1;
 
    if (chPtr->branchX < 0) {
        chPtr->branchX = 0;
    }
    if (chPtr->branchY < 0) {
        chPtr->branchY = 0;
    }
    if (chPtr->iconX < 0) {
        chPtr->iconX = 0;
    }
    if (chPtr->iconY < 0) {
        chPtr->iconY = 0;
    }
 
    chPtr->branchX += wPtr->selBorderWidth;
    chPtr->branchY += wPtr->selBorderWidth;
    chPtr->iconX   += wPtr->selBorderWidth;
    chPtr->iconY   += wPtr->selBorderWidth;
}
/*
 *----------------------------------------------------------------------
 *
 * WidgetDisplay --
 *
 *      Draw the widget to the screen.
 *
 * Results:
 *      None.
 *
 * Side effects:
 *
 *----------------------------------------------------------------------
 */
static void
WidgetDisplay(clientData)
    ClientData clientData;      /* Info about my widget. */
{
    WidgetPtr wPtr = (WidgetPtr) clientData;
    Drawable buffer;
    Tk_Window tkwin = wPtr->dispData.tkwin;
    int elmX, elmY;
    Tcl_Interp *interp = wPtr->dispData.interp;
 
    wPtr->redrawing = 0;         /* clear the redraw flag */
    wPtr->serial ++;
 
    if (wPtr->elmToSee != NULL) {
        HListElement *chPtr;
 
        if ((chPtr = Tix_HLFindElement(interp, wPtr,
                wPtr->elmToSee)) == NULL) {
            Tcl_ResetResult(interp);
        } else {
            Tix_HLSeeElement(wPtr, chPtr, 0);
        }
 
        ckfree(wPtr->elmToSee);
        wPtr->elmToSee = NULL;
    }
 
 
    /*
     *  STEP (1)
     *          Calculate the drawing parameters
     */
    if (wPtr->wideSelect) {
        wPtr->selectWidth = Tk_Width(wPtr->dispData.tkwin) -
          (2*wPtr->borderWidth + 2*wPtr->highlightWidth);
        if (wPtr->selectWidth < wPtr->totalSize[0]) {
            wPtr->selectWidth = wPtr->totalSize[0];
        }
    }
 
    /* Used to clip off elements that are too low to see */
    wPtr->bottomPixel = Tk_Height(wPtr->dispData.tkwin) - 2*wPtr->borderWidth
      - 2*wPtr->highlightWidth;
 
    elmX = wPtr->borderWidth + wPtr->highlightWidth - wPtr->leftPixel;
    elmY = wPtr->borderWidth + wPtr->highlightWidth - wPtr->topPixel;
 
    if (wPtr->useHeader) {
        elmY += wPtr->headerHeight;
    }
 
    /*
     *  STEP (2)
     *          Draw the list body
     */
    buffer = Tix_GetRenderBuffer(wPtr->dispData.display, Tk_WindowId(tkwin),
        Tk_Width(tkwin), Tk_Height(tkwin), Tk_Depth(tkwin));
 
    /* Fill the background */
    XFillRectangle(wPtr->dispData.display, buffer, wPtr->backgroundGC,
        0, 0, Tk_Width(tkwin), Tk_Height(tkwin));
 
    DrawElements(wPtr, buffer, wPtr->normalGC, wPtr->root,
        elmX, elmY,
        wPtr->borderWidth + wPtr->highlightWidth - wPtr->leftPixel);
 
    if (wPtr->borderWidth > 0) {
        /* Draw the border */
        Tk_Draw3DRectangle(wPtr->dispData.tkwin, buffer, wPtr->border,
            wPtr->highlightWidth, wPtr->highlightWidth,
            Tk_Width(tkwin)  - 2*wPtr->highlightWidth,
            Tk_Height(tkwin) - 2*wPtr->highlightWidth, wPtr->borderWidth,
            wPtr->relief);
    }
 
    if (wPtr->highlightWidth > 0) {
        /* Draw the highlight */
        GC gc;
 
        if (wPtr->hasFocus) {
            gc = wPtr->highlightGC;
        } else {
            gc = Tk_3DBorderGC(wPtr->dispData.tkwin, wPtr->border,
                TK_3D_FLAT_GC);
        }
        Tk_DrawFocusHighlight(tkwin, gc, wPtr->highlightWidth, buffer);
    }
 
    if (buffer != Tk_WindowId(tkwin)) {
        /*
         * Copy the information from the off-screen pixmap onto the screen,
         * then delete the pixmap.
         */
 
        XCopyArea(wPtr->dispData.display, buffer, Tk_WindowId(tkwin),
            wPtr->normalGC, 0, 0, Tk_Width(tkwin), Tk_Height(tkwin), 0, 0);
        Tk_FreePixmap(wPtr->dispData.display, buffer);
    }
 
    /*
     *  STEP (3)
     *          Draw the header
     */
    if (wPtr->useHeader) {
        /* We need to draw the header after the elements, because some
         * half-scrolled elements may overwrite the space for the header
         */
        int hdrX, hdrY, hdrW, hdrH, pad, xOffset;
        Drawable buffer;
 
        pad  = wPtr->borderWidth + wPtr->highlightWidth;
        hdrX = pad;
        hdrY = pad;
        hdrW = Tk_Width(tkwin) - 2*pad;
        hdrH = wPtr->headerHeight;
        xOffset = wPtr->leftPixel;
 
        Tk_MoveResizeWindow(wPtr->headerWin, hdrX, hdrY, hdrW, hdrH);
        Tk_MapWindow(wPtr->headerWin);
 
        buffer = Tix_GetRenderBuffer(wPtr->dispData.display,
            Tk_WindowId(wPtr->headerWin), hdrW, hdrH,
            Tk_Depth(wPtr->headerWin));
 
        XFillRectangle(wPtr->dispData.display, buffer,
            wPtr->backgroundGC, 0, 0, hdrW, hdrH);
 
        Tix_HLDrawHeader(wPtr, buffer, wPtr->normalGC,
            0, 0, hdrW, hdrH, xOffset);
 
        if (buffer != Tk_WindowId(wPtr->headerWin)) {
            XCopyArea(wPtr->dispData.display, buffer,
                Tk_WindowId(wPtr->headerWin), wPtr->normalGC,
                0, 0, hdrW, hdrH, 0, 0);
 
            Tk_FreePixmap(wPtr->dispData.display, buffer);
        }
 
        /* If we map the header window, that may change the size requirement
         * of the HList
         * %% Call only when geometry is *really* changed
         */
        if (wPtr->sizeCmd) {
            if (Tcl_GlobalEval(wPtr->dispData.interp, wPtr->sizeCmd)
                 != TCL_OK) {
                Tcl_AddErrorInfo(wPtr->dispData.interp,
                    "\n    (size command executed by tixHList)");
                Tk_BackgroundError(wPtr->dispData.interp);
            }
        }
    } else {
        Tk_UnmapWindow(wPtr->headerWin);
    }
 
    /* unmap those windows we mapped the last time */
    Tix_UnmapInvisibleWindowItems(&wPtr->mappedWindows, wPtr->serial);
}
 
/*
 *----------------------------------------------------------------------
 *
 * DrawElements --
 *--------------------------------------------------------------
 */
static void DrawElements(wPtr, pixmap, gc, chPtr, x, y, xOffset)
    WidgetPtr wPtr;
    Pixmap pixmap;
    GC gc;
    HListElement * chPtr;
    int x;
    int y;
    int xOffset;
{
    HListElement * ptr, * lastVisible;
    int myIconX = 0, myIconY = 0;         /* center of my icon */
    int childIconX, childIconY;         /* center of child's icon */
    int childY, childX;
    int oldY;
    int topBorder;
 
    if (wPtr->useHeader) {
        topBorder = wPtr->headerHeight;
    } else {
        topBorder = 0;
    }
 
    if (chPtr != wPtr->root) {
        if (wPtr->bottomPixel > y  && (y + chPtr->height) >= topBorder) {
            /* Otherwise element is not see at all */
            DrawOneElement(wPtr, pixmap, gc, chPtr, x, y, xOffset);
        }
        myIconX = x + chPtr->branchX;
        myIconY = y + chPtr->branchY;
 
        if (wPtr->useIndicator && chPtr->parent == wPtr->root) {
            childX = x + 2 * wPtr->indent;
        } else {
            childX = x +  wPtr->indent;
        }
        childY = y + chPtr->height;
 
        if (myIconX > childX) {
            /* Can't shift the vertical branch too much to the right */
            myIconX = childX;
        }
    } else {
        childX = x;
        childY = y;
    }
 
    oldY = childY;              /* saved for 2nd iteration */
 
    /* find the last non-hidden element,
     * to determine when to draw the vertical line
     */
    lastVisible = NULL;
    for (ptr = chPtr->childTail; ptr!=NULL; ptr=ptr->prev) {
        if (! ptr->hidden) {
            lastVisible = ptr;
            break;
        }
    }
 
    if (lastVisible == NULL) {
        /* No child is visible */
        return;
    }
 
    /* First iteration : draw the entries and branches */
    for (ptr = chPtr->childHead; ptr!=NULL; ptr=ptr->next) {
        if (ptr->hidden) {
            continue;
        }
 
        childIconX = childX + ptr->iconX;
        childIconY = childY + ptr->iconY;
 
        if (wPtr->bottomPixel > childY  &&
            (childY + ptr->allHeight) >= topBorder) {
 
            /* Otherwise all descendants of ptr are not seen at all
             */
            DrawElements(wPtr, pixmap, gc, ptr, childX, childY, xOffset);
 
            if (wPtr->drawBranch && chPtr != wPtr->root) {
                /* Draw a horizontal branch to the child's image/bitmap */
                XDrawLine(wPtr->dispData.display, pixmap, gc, myIconX,
                    childIconY, childIconX, childIconY);
            }
        }
 
        if (wPtr->drawBranch && chPtr != wPtr->root) {
            /*
             * NB: no branches for toplevel elements
             */
            if (ptr == lastVisible) {
                /* Last element. Must draw a vertical branch, even if element
                 * is not seen
                 */
                int y0, y1;     /* used to clip the vertical lines. Otherwise
                                 * will wrap-around 65536 (max coordinate for
                                 * X
                                 */
                y0 = myIconY;
                y1 = childIconY;
 
                if (y0 < 0) {
                    y0 = 0;
                }
                if (y1 > Tk_Height(wPtr->dispData.tkwin)) {
                    y1 = Tk_Height(wPtr->dispData.tkwin);
                }
                XDrawLine(wPtr->dispData.display, pixmap, gc, myIconX, y0,
                    myIconX, y1);
            }
        }
        childY += ptr->allHeight;
    }
 
    if (!wPtr->useIndicator) {
        return;
    } else {
        childY = oldY;
    }
 
    /* Second iteration : draw the indicators */
    for (ptr = chPtr->childHead; ptr!=NULL; ptr=ptr->next) {
        int justMapped;
 
        if (ptr->hidden) {
            continue;
        }
 
        childIconY = childY + ptr->iconY;
 
        if (wPtr->bottomPixel > childY  &&
            (childY + ptr->allHeight) >= topBorder) {
            /* Otherwise all descendants of ptr are not seen at all
             */
            if (ptr->indicator != NULL) {
                int indW = Tix_DItemWidth (ptr->indicator);
                int indH = Tix_DItemHeight(ptr->indicator);
                int indX;
                int indY = childIconY;
 
                if (chPtr == wPtr->root) {
                    indX = wPtr->indent / 2 + wPtr->borderWidth
                        + wPtr->highlightWidth - wPtr->leftPixel;
                } else {
                    indX = myIconX;
                }
 
                indX -= indW/2;
                indY -= indH/2;
 
                justMapped = 0;
                if (Tix_DItemType(ptr->indicator) == TIX_DITEM_WINDOW) {
                    Tix_SetWindowItemSerial(&wPtr->mappedWindows,
                        ptr->indicator, wPtr->serial);
                    if (!Tk_IsMapped(ptr->indicator->window.tkwin)) {
                        justMapped = 1;
                    }
                }
 
                /* Put down the indicator */
                Tix_DItemDisplay(pixmap, gc, ptr->indicator,
                    indX, indY, indW, indH,
                    TIX_DITEM_NORMAL_FG|TIX_DITEM_NORMAL_BG);
 
                if (justMapped) {
                    XLowerWindow(Tk_Display(ptr->indicator->window.tkwin),
                        Tk_WindowId(ptr->indicator->window.tkwin));
                }
            }
        }
        childY += ptr->allHeight;
    }
}
 
/*
 *----------------------------------------------------------------------
 *
 * DrawOneElement --
 *--------------------------------------------------------------
 */
static void DrawOneElement(wPtr, pixmap, gc, chPtr, x, y, xOffset)
    WidgetPtr wPtr;
    Pixmap pixmap;
    GC gc;
    HListElement * chPtr;
    int x;
    int y;
    int xOffset;
{
    int i;
    int flags = TIX_DITEM_NORMAL_FG, bgFlags = 0;
    int selectWidth, selectX;
 
    x = xOffset + chPtr->indent;
 
    if (wPtr->wideSelect) {
        selectWidth = wPtr->selectWidth;
        selectX = xOffset;
    } else {
        selectWidth = Tix_DItemWidth(chPtr->col[0].iPtr)
          + 2*wPtr->selBorderWidth;
        selectX = x;
    }
 
    if (chPtr->selected) {
        /*
         * When the ditem is selected, we have already drawn the
         * selection background ourself, so we don't want
         * DitemDisplay() to draw any background for us. So in this
         * case both TIX_DITEM_NORMAL_BG and TIX_DITEM_SELECTED_BG are
         * *not* set
         */
        Tk_Fill3DRectangle(wPtr->dispData.tkwin, pixmap, wPtr->selectBorder,
            selectX, y, selectWidth, chPtr->height, wPtr->selBorderWidth,
            TK_RELIEF_RAISED);
        gc = wPtr->selectGC;
        flags |= TIX_DITEM_SELECTED_FG;
    } else {
        /*
         * Set the TIX_DITEM_NORMAL_BG. This will be used unless
         * ACTIVE_BG and/or DISABLE_BG are set
         */
        bgFlags |= TIX_DITEM_NORMAL_BG;
    }
 
    if (chPtr == wPtr->anchor) {
        flags |= TIX_DITEM_ACTIVE_FG;
 
        if (!chPtr->selected) {
            /* don't set any background when the item is selected (otherwise
             * it looks messed up when wideSelect is false
             */
            bgFlags |= TIX_DITEM_ACTIVE_BG;
        }
    }
    if (chPtr == wPtr->dropSite) {
        XDrawRectangle(Tk_Display(wPtr->dispData.tkwin), pixmap,
            wPtr->dropSiteGC, selectX, y, selectWidth-1, chPtr->height-1);
    }
 
    /*
     * Now Draw the display items in each column
     *
     * %% ToDo: clip off the non-visible items
     */
    x = xOffset;
    for (i=0; i<wPtr->numColumns; i++) {
        int drawX = x;
        Tix_DItem * iPtr = chPtr->col[i].iPtr;
        int itemWidth;
 
        itemWidth = wPtr->actualSize[i].width - 2*wPtr->selBorderWidth;
 
        /*
         * Draw the background: this is tricky because we have idented the
         * first column. If we call Tix_DItemDisplay() with the background
         * flags set, the first column will look ugly
         */
        if (iPtr != NULL) {
            Tix_DItemDrawBackground(pixmap, gc, iPtr,
                drawX + wPtr->selBorderWidth, y + wPtr->selBorderWidth,
                itemWidth,
                chPtr->height - 2*wPtr->selBorderWidth, bgFlags);
        }
 
        if (i == 0) {
            drawX += chPtr->indent;
            itemWidth -= chPtr->indent;
        }
 
        if (iPtr != NULL) {
            int justMapped = 0;
 
            if (Tix_DItemType(iPtr) == TIX_DITEM_WINDOW) {
                Tix_SetWindowItemSerial(&wPtr->mappedWindows,iPtr,
                    wPtr->serial);
                if (!Tk_IsMapped(iPtr->window.tkwin)) {
                    justMapped = 1;
                }
            }
 
            Tix_DItemDisplay(pixmap, gc, iPtr,
                drawX + wPtr->selBorderWidth, y + wPtr->selBorderWidth,
                itemWidth,
                chPtr->height - 2*wPtr->selBorderWidth, flags);
 
            if (justMapped) {
                /*
                 * We need to lower it so that it doesn't
                 * overlap the header subwindow
                 */
                XLowerWindow(Tk_Display(iPtr->window.tkwin),
                    Tk_WindowId(iPtr->window.tkwin));
            }
        }
 
        x += wPtr->actualSize[i].width;
    }
 
    if (chPtr == wPtr->anchor) {
        int ancW, ancH;
        ancW = selectWidth-1;
        ancH = chPtr->height-1;
 
        Tix_DrawAnchorLines(Tk_Display(wPtr->dispData.tkwin), pixmap,
            wPtr->anchorGC, selectX, y, ancW, ancH);
    }
}
 
/*
 *----------------------------------------------------------------------
 * SelectionAdd --
 *--------------------------------------------------------------
 */
static void SelectionAdd(wPtr, chPtr)
    WidgetPtr wPtr;
    HListElement * chPtr;
{
    if (chPtr->selected) {              /* sanity check */
        return;
    }
 
    chPtr->selected = 1;
    SelectionNotifyAncestors(wPtr, chPtr->parent);
}
 
/*
 *----------------------------------------------------------------------
 * HL_SelectionClear --
 *--------------------------------------------------------------
 */
static void HL_SelectionClear(wPtr, chPtr)
    WidgetPtr wPtr;
    HListElement * chPtr;
{
    if (! chPtr->selected) {            /* sanity check */
        return;
    }
 
    chPtr->selected = 0;
    HL_SelectionClearNotifyAncestors(wPtr, chPtr->parent);
}
 
/*
 *----------------------------------------------------------------------
 * HL_SelectionClearAll --
 *--------------------------------------------------------------
 */
static void HL_SelectionClearAll(wPtr, chPtr, changed_ret)
    WidgetPtr wPtr;
    HListElement * chPtr;
    int * changed_ret;
{
    HListElement * ptr;
 
    if (chPtr->selected) {
        *changed_ret = 1;
        chPtr->selected = 0;
    }
 
    if (chPtr->numSelectedChild == 0) {
        return;
    } else {
        chPtr->numSelectedChild = 0;
 
        for (ptr=chPtr->childHead; ptr; ptr=ptr->next) {
            HL_SelectionClearAll(wPtr, ptr, changed_ret);
        }
    }
}
 
/*
 *----------------------------------------------------------------------
 * SelectionNotifyAncestors --
 *
 *      !!This has nothing to do with SelectionNotify in X!!
 *
 *      HList keeps a counter in every entry on how many of its
 *      child entries has been selected. This will make the
 *      "selection clear" very efficient. To keep this counter
 *      up-to-date, we must call SelectionNotifyAncestors() or
 *      HL_SelectionClearNotifyAncestors every time the selection
 *      has changed.
 *--------------------------------------------------------------
 */
static void SelectionNotifyAncestors(wPtr, chPtr)
    WidgetPtr wPtr;
    HListElement * chPtr;
{
    chPtr->numSelectedChild ++;
 
    if (chPtr->selected || (chPtr->numSelectedChild > 1)) {
        /* My ancestors already know that I have selections */
        return;
    } else {
        if (chPtr != wPtr->root) {
            SelectionNotifyAncestors(wPtr, chPtr->parent);
        }
    }
}
 
static void HL_SelectionClearNotifyAncestors(wPtr, chPtr)
    WidgetPtr wPtr;
    HListElement * chPtr;
{
    chPtr->numSelectedChild --;
 
    if (chPtr->selected || (chPtr->numSelectedChild > 0)) {
        /* I still have selections, don't need to notify parent */
        return;
    } else {
        if (chPtr != wPtr->root) {
            SelectionNotifyAncestors(wPtr, chPtr->parent);
        }
    }
}
/*
 *--------------------------------------------------------------
 * DeleteOffsprings --
 *--------------------------------------------------------------
 */
static void DeleteOffsprings(wPtr, chPtr)
    WidgetPtr wPtr;
    HListElement * chPtr;
{
    HListElement * ptr;
    HListElement * toFree;
 
    ptr=chPtr->childHead;
    while (ptr) {
        DeleteOffsprings(wPtr, ptr);
        toFree = ptr;
        ptr=ptr->next;
        FreeElement(wPtr, toFree);
    }
 
    chPtr->childHead = 0;
    chPtr->childTail = 0;
}
 
/*
 *--------------------------------------------------------------
 * DeleteSiblings --
 *--------------------------------------------------------------
 */
static void DeleteSiblings(wPtr, chPtr)
    WidgetPtr wPtr;
    HListElement * chPtr;
{
    HListElement * ptr;
 
    for (ptr=chPtr->parent->childHead; ptr; ptr=ptr->next) {
        if (ptr != chPtr) {
            DeleteNode(wPtr, ptr);
        }
    }
}
 
/*
 *----------------------------------------------------------------------
 * DeleteNode --
 *--------------------------------------------------------------
 */
static void DeleteNode(wPtr, chPtr)
    WidgetPtr wPtr;
    HListElement * chPtr;
{
    if (chPtr->parent == NULL) {
        /*
         * This is root node : can't delete
         */
        return;
    }
 
    DeleteOffsprings(wPtr, chPtr);
 
    /*
     * Check for deleting parent's first child
     */
    if (chPtr == chPtr->parent->childHead) {
        chPtr->parent->childHead = chPtr->next;
    }
    else {
        chPtr->prev->next = chPtr->next;
    }
 
    /*
     * Check for 'last' child (could be both first AND last)
     */
    if (chPtr == chPtr->parent->childTail) {
        chPtr->parent->childTail = chPtr->prev;
    }
    else {
        chPtr->next->prev = chPtr->prev;
    }
 
    FreeElement(wPtr, chPtr);
}
 
/*
 *----------------------------------------------------------------------
 * UpdateOneScrollBar --
 *--------------------------------------------------------------
 */
static void UpdateOneScrollBar(wPtr, command, total, window, first)
    WidgetPtr wPtr;
    char * command;
    int total;
    int window;
    int first;
{
    char string[100];
    double d_first, d_last;
 
    GetScrollFractions(total, window, first, &d_first, &d_last);
 
    sprintf(string, " %g %g", d_first, d_last);
    if (Tix_GlobalVarEval(wPtr->dispData.interp, command, string,
            (char *) NULL) != TCL_OK) {
        Tcl_AddErrorInfo(wPtr->dispData.interp,
                "\n    (scrolling command executed by tixHList)");
        Tk_BackgroundError(wPtr->dispData.interp);
    }
}
 
/*----------------------------------------------------------------------
 *  UpdateScrollBars
 *----------------------------------------------------------------------
 */
static void UpdateScrollBars(wPtr, sizeChanged)
    WidgetPtr wPtr;
    int sizeChanged;
{
    int total, window, first;
 
    CheckScrollBar(wPtr, TIX_X);
    CheckScrollBar(wPtr, TIX_Y);
 
    if (wPtr->xScrollCmd) {
        total  = wPtr->totalSize[0];
        window = Tk_Width(wPtr->dispData.tkwin)
          - 2*wPtr->borderWidth - 2*wPtr->highlightWidth;
        first  = wPtr->leftPixel;
 
        UpdateOneScrollBar(wPtr, wPtr->xScrollCmd, total, window, first);
    }
 
    if (wPtr->yScrollCmd) {
        total  = wPtr->totalSize[1];
        window = Tk_Height(wPtr->dispData.tkwin)
          - 2*wPtr->borderWidth - 2*wPtr->highlightWidth;
        first  = wPtr->topPixel;
 
        if (wPtr->useHeader) {
            window -= wPtr->headerHeight;
        }
 
        UpdateOneScrollBar(wPtr, wPtr->yScrollCmd, total, window, first);
    }
 
    if (wPtr->sizeCmd && sizeChanged) {
        if (Tcl_GlobalEval(wPtr->dispData.interp, wPtr->sizeCmd) != TCL_OK) {
            Tcl_AddErrorInfo(wPtr->dispData.interp,
                "\n    (size command executed by tixHList)");
            Tk_BackgroundError(wPtr->dispData.interp);
        }
    }
}
 
/*----------------------------------------------------------------------
 * XScrollByUnits
 *----------------------------------------------------------------------
 */
static int XScrollByUnits(wPtr, count)
    WidgetPtr wPtr;
    int count;
{
    return wPtr->leftPixel + count*wPtr->scrollUnit[0];
}
 
/*----------------------------------------------------------------------
 * XScrollByPages
 *----------------------------------------------------------------------
 */
static int XScrollByPages(wPtr, count)
    WidgetPtr wPtr;
    int count;
{
    return wPtr->leftPixel + count*Tk_Width(wPtr->dispData.tkwin);
}
 
/*----------------------------------------------------------------------
 * YScrollByUnits
 *----------------------------------------------------------------------
 */
static int YScrollByUnits(wPtr, count)
    WidgetPtr wPtr;
    int count;
{
    HListElement * chPtr;
    int height;
 
    if ((chPtr = FindElementAtPosition(wPtr, 0))) {
        height = chPtr->height;
    } else if (wPtr->root->childHead) {
        height = wPtr->root->childHead->height;
    } else {
        height = 0;
    }
 
    return wPtr->topPixel + count*height;
}
 
/*----------------------------------------------------------------------
 * YScrollByPages
 *----------------------------------------------------------------------
 */
static int YScrollByPages(wPtr, count)
    WidgetPtr wPtr;
    int count;
{
    int window = Tk_Height(wPtr->dispData.tkwin)
      - 2*wPtr->borderWidth - 2*wPtr->highlightWidth;
 
    if (wPtr->useHeader) {
        window -= wPtr->headerHeight;
    }
 
    return wPtr->topPixel + count*window;
}
 
/*----------------------------------------------------------------------
 * CheckScrollBar
 *
 *      Make sures that the seeting of the scrollbars are correct: i.e.
 *      the bottom element will never be scrolled up by too much.
 *----------------------------------------------------------------------
 */
static void CheckScrollBar(wPtr, which)
    WidgetPtr wPtr;
    int which;
{
    int window;
    int total;
    int first;
 
    if (which == TIX_Y) {
        window = Tk_Height(wPtr->dispData.tkwin)
          - 2*wPtr->borderWidth - 2*wPtr->highlightWidth;
        if (wPtr->useHeader) {
            window -= wPtr->headerHeight;
        }
        total  = wPtr->totalSize[1];
        first  = wPtr->topPixel;
    } else {
        window = Tk_Width(wPtr->dispData.tkwin)
          - 2*wPtr->borderWidth - 2*wPtr->highlightWidth;
        total  = wPtr->totalSize[0];
        first  = wPtr->leftPixel;
    }
 
    /* Check whether the topPixel is out of bound */
    if (first < 0) {
        first = 0;
    } else {
        if (window > total) {
            first = 0;
        } else if ((first + window) > total) {
            first = total - window;
        }
    }
 
    if (which == TIX_Y) {
        wPtr->topPixel = first;
    } else {
        wPtr->leftPixel = first;
    }
}
 
/*----------------------------------------------------------------------
 * GetScrollFractions --
 *
 * Compute the fractions of a scroll-able widget.
 *
 */
static void GetScrollFractions(total, window, first, first_ret, last_ret)
    int total;
    int window;
    int first;
    double * first_ret;
    double * last_ret;
{
    if (total == 0 || total < window) {
        *first_ret = 0.0;
        *last_ret  = 1.0;
    } else {
        *first_ret = (double)(first) / (double)(total);
        *last_ret  = (double)(first+window) / (double)(total);
    }
}
 
/*----------------------------------------------------------------------
 * Find the element that's immediately below this element.
 *
 *----------------------------------------------------------------------
 */
static HListElement *
FindNextEntry(wPtr, chPtr)
    WidgetPtr wPtr;
    HListElement * chPtr;
{
    if (chPtr->childHead != NULL) {
        return chPtr->childHead;
    }
    if (chPtr->next) {
        return chPtr->next;
    }
 
    /* go to a different branch */
    while (1) {
        if (chPtr == wPtr->root) {
            return (HListElement *)NULL;
        }
        chPtr = chPtr->parent;
        if (chPtr->next) {
            return chPtr->next;
        }
    }
}
 
/*----------------------------------------------------------------------
 * Find the element that's immediately above this element.
 *
 *----------------------------------------------------------------------
 */
static HListElement *
FindPrevEntry(wPtr, chPtr)
    WidgetPtr wPtr;
    HListElement * chPtr;
{
    if (chPtr->prev) {
        /* Find the bottom of this sub-tree
         */
        for (chPtr=chPtr->prev; chPtr->childTail; chPtr = chPtr->childTail)
          ;
 
        return chPtr;
    } else {
        if (chPtr->parent == wPtr->root) {
            return 0;
        } else {
            return chPtr->parent;
        }
    }
}
 
Line No.	Rev	Author	Line
1	578	markom	`/*`
2			`* tixHList.c --`
3			`*`
4			`* This module implements "HList" widgets.`
5			`*`
6			`* Copyright (c) 1996, Expert Interface Technologies`
7			`*`
8			`* See the file "license.terms" for information on usage and redistribution`
9			`* of this file, and for a DISCLAIMER OF ALL WARRANTIES.`
10			`*`
11			`*/`
12
13			`#include <tixPort.h>`
14			`#include <tixInt.h>`
15			`#include <tixHList.h>`
16			`#include <tixDef.h>`
17
18			`/*`
19			`* Information used for argv parsing.`
20			`*/`
21
22			`static Tk_ConfigSpec configSpecs[] = {`
23			`{TK_CONFIG_COLOR, "-background", "background", "Background",`
24			`DEF_HLIST_BG_COLOR, Tk_Offset(WidgetRecord, normalBg),`
25			`TK_CONFIG_COLOR_ONLY},`
26
27			`{TK_CONFIG_COLOR, "-background", "background", "Background",`
28			`DEF_HLIST_BG_MONO, Tk_Offset(WidgetRecord, normalBg),`
29			`TK_CONFIG_MONO_ONLY},`
30
31			`{TK_CONFIG_SYNONYM, "-bd", "borderWidth", (char *) NULL,`
32			`(char *) NULL, 0, 0},`
33
34			`{TK_CONFIG_SYNONYM, "-bg", "background", (char *) NULL,`
35			`(char *) NULL, 0, 0},`
36
37			`{TK_CONFIG_PIXELS, "-borderwidth", "borderWidth", "BorderWidth",`
38			`DEF_HLIST_BORDER_WIDTH, Tk_Offset(WidgetRecord, borderWidth), 0},`
39
40			`{TK_CONFIG_STRING, "-browsecmd", "browseCmd", "BrowseCmd",`
Browse

Tools

Subversion Repositories or1k

[/] [or1k/] [trunk/] [insight/] [tix/] [generic/] [tixHList.c] - Blame information for rev 1781
