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

[/] [or1k/] [trunk/] [insight/] [tix/] [generic/] [tixTList.c] - Blame information for rev 1778

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

/*
 * tixTList.c --
 *
 *      This module implements "TList" 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 <tixDef.h>
#include <tixTList.h>
 
#define TIX_UP          1
#define TIX_DOWN        2
#define TIX_LEFT        3
#define TIX_RIGHT       4
 
/*
 * Information used for argv parsing.
 */
static Tk_ConfigSpec configSpecs[] = {
    {TK_CONFIG_COLOR, "-background", "background", "Background",
       DEF_TLIST_BG_COLOR, Tk_Offset(WidgetRecord, normalBg),
       TK_CONFIG_COLOR_ONLY},
 
    {TK_CONFIG_COLOR, "-background", "background", "Background",
       DEF_TLIST_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_BORDER, "-highlightbackground", "highlightBackground",
       "HighlightBackground",
       DEF_TLIST_BG_COLOR, Tk_Offset(WidgetRecord, border),
       TK_CONFIG_COLOR_ONLY},
 
    {TK_CONFIG_BORDER, "-highlightbackground", "highlightBackground",
       "HighlightBackground",
       DEF_TLIST_BG_MONO, Tk_Offset(WidgetRecord, border),
       TK_CONFIG_MONO_ONLY},
 
    {TK_CONFIG_PIXELS, "-borderwidth", "borderWidth", "BorderWidth",
       DEF_TLIST_BORDER_WIDTH, Tk_Offset(WidgetRecord, borderWidth), 0},
 
    {TK_CONFIG_STRING, "-browsecmd", "browseCmd", "BrowseCmd",
        DEF_TLIST_BROWSE_COMMAND, Tk_Offset(WidgetRecord, browseCmd),
        TK_CONFIG_NULL_OK},
 
    {TK_CONFIG_STRING, "-command", "command", "Command",
       DEF_TLIST_COMMAND, Tk_Offset(WidgetRecord, command),
       TK_CONFIG_NULL_OK},
 
    {TK_CONFIG_ACTIVE_CURSOR, "-cursor", "cursor", "Cursor",
       DEF_TLIST_CURSOR, Tk_Offset(WidgetRecord, cursor),
       TK_CONFIG_NULL_OK},
 
    {TK_CONFIG_SYNONYM, "-fg", "foreground", (char *) NULL,
       (char *) NULL, 0, 0},
 
    {TK_CONFIG_FONT, "-font", "font", "Font",
       DEF_TLIST_FONT, Tk_Offset(WidgetRecord, font), 0},
 
    {TK_CONFIG_COLOR, "-foreground", "foreground", "Foreground",
       DEF_TLIST_FG_COLOR, Tk_Offset(WidgetRecord, normalFg),
       TK_CONFIG_COLOR_ONLY},
 
    {TK_CONFIG_COLOR, "-foreground", "foreground", "Foreground",
       DEF_TLIST_FG_MONO, Tk_Offset(WidgetRecord, normalFg),
       TK_CONFIG_MONO_ONLY},
 
    {TK_CONFIG_INT, "-height", "height", "Height",
       DEF_TLIST_HEIGHT, Tk_Offset(WidgetRecord, height), 0},
 
    {TK_CONFIG_COLOR, "-highlightcolor", "highlightColor", "HighlightColor",
       DEF_TLIST_HIGHLIGHT_COLOR, Tk_Offset(WidgetRecord, highlightColorPtr),
       TK_CONFIG_COLOR_ONLY},
 
    {TK_CONFIG_COLOR, "-highlightcolor", "highlightColor", "HighlightColor",
       DEF_TLIST_HIGHLIGHT_MONO, Tk_Offset(WidgetRecord, highlightColorPtr),
       TK_CONFIG_MONO_ONLY},
 
    {TK_CONFIG_PIXELS, "-highlightthickness", "highlightThickness",
       "HighlightThickness",
       DEF_TLIST_HIGHLIGHT_WIDTH, Tk_Offset(WidgetRecord, highlightWidth), 0},
 
    {TK_CONFIG_CUSTOM, "-itemtype", "itemType", "ItemType",
       DEF_TLIST_ITEM_TYPE, Tk_Offset(WidgetRecord, diTypePtr),
       0, &tixConfigItemType},
 
    {TK_CONFIG_UID, "-orient", "orient", "Orient",
        DEF_TLIST_ORIENT, Tk_Offset(WidgetRecord, orientUid), 0},
 
    {TK_CONFIG_PIXELS, "-padx", "padX", "Pad",
        DEF_TLIST_PADX, Tk_Offset(WidgetRecord, padX), 0},
 
    {TK_CONFIG_PIXELS, "-pady", "padY", "Pad",
        DEF_TLIST_PADY, Tk_Offset(WidgetRecord, padY), 0},
 
    {TK_CONFIG_RELIEF, "-relief", "relief", "Relief",
       DEF_TLIST_RELIEF, Tk_Offset(WidgetRecord, relief), 0},
 
    {TK_CONFIG_BORDER, "-selectbackground", "selectBackground", "Foreground",
        DEF_TLIST_SELECT_BG_COLOR, Tk_Offset(WidgetRecord, selectBorder),
        TK_CONFIG_COLOR_ONLY},
 
    {TK_CONFIG_BORDER, "-selectbackground", "selectBackground", "Foreground",
        DEF_TLIST_SELECT_BG_MONO, Tk_Offset(WidgetRecord, selectBorder),
        TK_CONFIG_MONO_ONLY},
 
    {TK_CONFIG_PIXELS, "-selectborderwidth", "selectBorderWidth","BorderWidth",
       DEF_TLIST_SELECT_BORDERWIDTH,Tk_Offset(WidgetRecord, selBorderWidth),0},
 
    {TK_CONFIG_COLOR, "-selectforeground", "selectForeground", "Background",
       DEF_TLIST_SELECT_FG_COLOR, Tk_Offset(WidgetRecord, selectFg),
       TK_CONFIG_COLOR_ONLY},
 
    {TK_CONFIG_COLOR, "-selectforeground", "selectForeground", "Background",
       DEF_TLIST_SELECT_FG_MONO, Tk_Offset(WidgetRecord, selectFg),
       TK_CONFIG_MONO_ONLY},
 
    {TK_CONFIG_UID, "-selectmode", "selectMode", "SelectMode",
        DEF_TLIST_SELECT_MODE, Tk_Offset(WidgetRecord, selectMode), 0},
 
    {TK_CONFIG_UID, "-state", (char*)NULL, (char*)NULL,
       DEF_TLIST_STATE, Tk_Offset(WidgetRecord, state), 0},
 
    {TK_CONFIG_STRING, "-sizecmd", "sizeCmd", "SizeCmd",
       DEF_TLIST_SIZE_COMMAND, Tk_Offset(WidgetRecord, sizeCmd),
       TK_CONFIG_NULL_OK},
 
    {TK_CONFIG_STRING, "-takefocus", "takeFocus", "TakeFocus",
        DEF_TLIST_TAKE_FOCUS, Tk_Offset(WidgetRecord, takeFocus),
        TK_CONFIG_NULL_OK},
 
    {TK_CONFIG_INT, "-width", "width", "Width",
        DEF_TLIST_WIDTH, Tk_Offset(WidgetRecord, width), 0},
 
    {TK_CONFIG_STRING, "-xscrollcommand", "xScrollCommand", "ScrollCommand",
       DEF_TLIST_X_SCROLL_COMMAND,
       Tk_Offset(WidgetRecord, scrollInfo[0].command),
       TK_CONFIG_NULL_OK},
 
    {TK_CONFIG_STRING, "-yscrollcommand", "yScrollCommand", "ScrollCommand",
       DEF_TLIST_Y_SCROLL_COMMAND,
       Tk_Offset(WidgetRecord, scrollInfo[1].command),
       TK_CONFIG_NULL_OK},
 
    {TK_CONFIG_END, (char *) NULL, (char *) NULL, (char *) NULL,
       (char *) NULL, 0, 0}
};
 
#define DEF_TLISTENTRY_STATE     "normal"
 
static Tk_ConfigSpec entryConfigSpecs[] = {
 
    {TK_CONFIG_UID, "-state", (char*)NULL, (char*)NULL,
       DEF_TLISTENTRY_STATE, Tk_Offset(ListEntry, state), 0},
 
    {TK_CONFIG_END, (char *) NULL, (char *) NULL, (char *) NULL,
       (char *) NULL, 0, 0}
};
 
static Tix_ListInfo entListInfo = {
    Tk_Offset(ListEntry, next),
    TIX_UNDEFINED,
};
 
 
/*
 * 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));
static void             WidgetComputeGeometry _ANSI_ARGS_((
                            ClientData clientData));
 
        /* Extra procedures for this widget
         */
static void             CancelRedrawWhenIdle _ANSI_ARGS_((WidgetPtr wPtr));
static void             CancelResizeWhenIdle _ANSI_ARGS_((WidgetPtr wPtr));
static int              ConfigElement _ANSI_ARGS_((WidgetPtr wPtr,
                            ListEntry *chPtr, int argc, char ** argv,
                            int flags, int forced));
static void             RedrawRows _ANSI_ARGS_((
                            WidgetPtr wPtr, Drawable pixmap));
static void             RedrawWhenIdle _ANSI_ARGS_((WidgetPtr wPtr));
static void             ResizeRows _ANSI_ARGS_((
                            WidgetPtr wPtr, int winW, int winH));
static void             ResizeWhenIdle _ANSI_ARGS_((WidgetPtr wPtr));
static void             ResizeNow _ANSI_ARGS_((WidgetPtr wPtr));
static void             UpdateScrollBars _ANSI_ARGS_((WidgetPtr wPtr,
                            int sizeChanged));
static int              Tix_TLGetFromTo _ANSI_ARGS_((
                            Tcl_Interp *interp, WidgetPtr wPtr,
                            int argc, char **argv,
                            ListEntry ** fromPtr_ret, ListEntry ** toPtr_ret));
static void             Tix_TLDItemSizeChanged _ANSI_ARGS_((
                            Tix_DItem *iPtr));
static void             MakeGeomRequest _ANSI_ARGS_((
                            WidgetPtr wPtr));
static int              Tix_TLGetNearest _ANSI_ARGS_((
                            WidgetPtr wPtr, int posn[2]));
static int              Tix_TLGetAt _ANSI_ARGS_((WidgetPtr wPtr,
                            Tcl_Interp *interp, char * spec, int *at));
static int              Tix_TLGetNeighbor _ANSI_ARGS_((
                            WidgetPtr wPtr, Tcl_Interp *interp,
                            int type, int argc, char **argv));
static int              Tix_TranslateIndex _ANSI_ARGS_((
                            WidgetPtr wPtr, Tcl_Interp *interp, char * string,
                            int * index, int isInsert));
static int              Tix_TLDeleteRange _ANSI_ARGS_((
                            WidgetPtr wPtr, ListEntry * fromPtr,
                            ListEntry *toPtr));
static ListEntry *      AllocEntry _ANSI_ARGS_((WidgetPtr wPtr));
static int              AddElement _ANSI_ARGS_((WidgetPtr wPtr,
                            ListEntry * chPtr, int at));
static void             FreeEntry _ANSI_ARGS_((WidgetPtr wPtr,
                            ListEntry * chPtr));
static int              Tix_TLSpecialEntryInfo _ANSI_ARGS_((
                            WidgetPtr wPtr, Tcl_Interp *interp,
                            ListEntry * chPtr));
static void             Realloc _ANSI_ARGS_((WidgetPtr wPtr,int new_size));
 
static TIX_DECLARE_SUBCMD(Tix_TLInsert);
static TIX_DECLARE_SUBCMD(Tix_TLCGet);
static TIX_DECLARE_SUBCMD(Tix_TLConfig);
static TIX_DECLARE_SUBCMD(Tix_TLDelete);
static TIX_DECLARE_SUBCMD(Tix_TLEntryCget);
static TIX_DECLARE_SUBCMD(Tix_TLEntryConfig);
static TIX_DECLARE_SUBCMD(Tix_TLGeometryInfo);
static TIX_DECLARE_SUBCMD(Tix_TLIndex);
static TIX_DECLARE_SUBCMD(Tix_TLInfo);
static TIX_DECLARE_SUBCMD(Tix_TLNearest);
static TIX_DECLARE_SUBCMD(Tix_TLSee);
static TIX_DECLARE_SUBCMD(Tix_TLSelection);
static TIX_DECLARE_SUBCMD(Tix_TLSetSite);
static TIX_DECLARE_SUBCMD(Tix_TLView);
 
/*
 *--------------------------------------------------------------
 *
 * Tix_TListCmd --
 *
 *      This procedure is invoked to process the "tixTList" Tcl
 *      command.  It creates a new "TixTList" widget.
 *
 * Results:
 *      A standard Tcl result.
 *
 * Side effects:
 *      A new widget is created and configured.
 *
 *--------------------------------------------------------------
 */
int
Tix_TListCmd(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;
 
    if (argc < 2) {
        Tcl_AppendResult(interp, "wrong # args:  should be \"",
                argv[0], " pathName ?options?\"", (char *) NULL);
        return TCL_ERROR;
    }
 
    tkwin = Tk_CreateWindowFromPath(interp, main, argv[1], (char *) NULL);
    if (tkwin == NULL) {
        return TCL_ERROR;
    }
 
    Tk_SetClass(tkwin, "TixTList");
 
    /*
     * Allocate and initialize the widget record.
     */
    wPtr = (WidgetPtr) ckalloc(sizeof(WidgetRecord));
 
    wPtr->dispData.tkwin        = tkwin;
    wPtr->dispData.display      = Tk_Display(tkwin);
    wPtr->dispData.interp       = interp;
    wPtr->dispData.sizeChangedProc = Tix_TLDItemSizeChanged;
    wPtr->font          = NULL;
    wPtr->normalBg              = NULL;
    wPtr->normalFg              = NULL;
    wPtr->command               = NULL;
    wPtr->border                = NULL;
    wPtr->borderWidth           = 0;
    wPtr->selectBorder          = NULL;
    wPtr->selBorderWidth        = 0;
    wPtr->selectFg              = NULL;
    wPtr->backgroundGC          = None;
    wPtr->selectGC              = None;
    wPtr->anchorGC              = None;
    wPtr->highlightWidth        = 0;
    wPtr->highlightColorPtr     = NULL;
    wPtr->highlightGC           = None;
    wPtr->relief                = TK_RELIEF_FLAT;
    wPtr->cursor                = None;
    wPtr->redrawing             = 0;
    wPtr->resizing              = 0;
    wPtr->hasFocus              = 0;
    wPtr->selectMode            = NULL;
    wPtr->seeElemPtr            = NULL;
    wPtr->anchor                = NULL;
    wPtr->active                = NULL;
    wPtr->dropSite              = NULL;
    wPtr->dragSite              = NULL;
    wPtr->sizeCmd               = NULL;
    wPtr->browseCmd             = NULL;
    wPtr->takeFocus             = NULL;
    wPtr->orientUid             = NULL;
    wPtr->serial                = 0;
    wPtr->state                 = tixNormalUid;
    wPtr->rows                  = (ListRow*)ckalloc(sizeof(ListRow) *1);
    wPtr->numRow                = 1;
    wPtr->numRowAllocd          = 1;
    wPtr->width                 = 0;
    wPtr->height                = 0;
 
    Tix_LinkListInit(&wPtr->entList);
    Tix_InitScrollInfo((Tix_ScrollInfo*)&wPtr->scrollInfo[0], TIX_SCROLL_INT);
    Tix_InitScrollInfo((Tix_ScrollInfo*)&wPtr->scrollInfo[1], TIX_SCROLL_INT);
 
    Tk_CreateEventHandler(wPtr->dispData.tkwin,
        ExposureMask|StructureNotifyMask|FocusChangeMask,
        WidgetEventProc, (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;
    }
 
    interp->result = Tk_PathName(wPtr->dispData.tkwin);
    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 List 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;
    size_t length;
    Tix_StyleTemplate stTmpl;
 
    oldfont = wPtr->font;
 
    if (Tk_ConfigureWidget(interp, wPtr->dispData.tkwin, configSpecs,
            argc, argv, (char *) wPtr, flags) != TCL_OK) {
        return TCL_ERROR;
    }
 
    length = strlen(wPtr->orientUid);
    if (strncmp(wPtr->orientUid, "vertical", length) == 0) {
        wPtr->isVertical = 1;
    } else if (strncmp(wPtr->orientUid, "horizontal", length) == 0) {
        wPtr->isVertical = 0;
    } else {
        Tcl_AppendResult(interp, "bad orientation \"", wPtr->orientUid,
            "\": must be vertical or horizontal", (char *) NULL);
        wPtr->orientUid = Tk_GetUid("vertical");
        wPtr->isVertical = 1;
        return TCL_ERROR;
    }
 
    if ((wPtr->state != tixNormalUid) && (wPtr->state != tixDisabledUid)) {
        Tcl_AppendResult(interp, "bad state value \"", wPtr->state,
            "\":  must be normal or disabled", (char *) NULL);
        wPtr->state = tixNormalUid;
        return TCL_ERROR;
    }
 
 
    if (oldfont != wPtr->font) {
        /* Font has been changed (initialized) */
        TixComputeTextGeometry(wPtr->font, "0", 1,
            0, &wPtr->scrollInfo[0].unit, &wPtr->scrollInfo[1].unit);
    }
 
    /*
     * 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 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 highlight border */
    gcValues.background         = wPtr->selectFg->pixel;
    gcValues.foreground         = wPtr->highlightColorPtr->pixel;
    gcValues.graphics_exposures = False;
 
    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 -font or -width or -height options have changed. Let's
     * make geometry request
     */
    MakeGeomRequest(wPtr);
 
    ResizeWhenIdle(wPtr);
 
    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, "active", 1, 2, Tix_TLSetSite,
           "option ?index?"},
        {TIX_DEFAULT_LEN, "anchor", 1, 2, Tix_TLSetSite,
           "option ?index?"},
        {TIX_DEFAULT_LEN, "cget", 1, 1, Tix_TLCGet,
           "option"},
        {TIX_DEFAULT_LEN, "configure", 0, TIX_VAR_ARGS, Tix_TLConfig,
           "?option? ?value? ?option value ... ?"},
        {TIX_DEFAULT_LEN, "delete", 1, 2, Tix_TLDelete,
           "from ?to?"},
        {TIX_DEFAULT_LEN, "dragsite", 1, 2, Tix_TLSetSite,
           "option ?entryPath?"},
        {TIX_DEFAULT_LEN, "dropsite", 1, 2, Tix_TLSetSite,
           "option ?entryPath?"},
        {TIX_DEFAULT_LEN, "entrycget", 2, 2, Tix_TLEntryCget,
           "entryPath option"},
        {TIX_DEFAULT_LEN, "entryconfigure", 1, TIX_VAR_ARGS, Tix_TLEntryConfig,
           "index ?option? ?value? ?option value ... ?"},
        {TIX_DEFAULT_LEN, "geometryinfo", 0, 2, Tix_TLGeometryInfo,
           "?width height?"},
        {TIX_DEFAULT_LEN, "index", 1, 1, Tix_TLIndex,
           "index"},
        {TIX_DEFAULT_LEN, "info", 1, TIX_VAR_ARGS, Tix_TLInfo,
           "option ?args ...?"},
        {TIX_DEFAULT_LEN, "insert", 1, TIX_VAR_ARGS, Tix_TLInsert,
           "where ?option value ..."},
        {TIX_DEFAULT_LEN, "nearest", 2, 2, Tix_TLNearest,
           "x y"},
        {TIX_DEFAULT_LEN, "see", 1, 1, Tix_TLSee,
           "entryPath"},
        {TIX_DEFAULT_LEN, "selection", 1, 3, Tix_TLSelection,
           "option arg ?arg ...?"},
        {TIX_DEFAULT_LEN, "xview", 0, 3, Tix_TLView,
           "args"},
        {TIX_DEFAULT_LEN, "yview", 0, 3, Tix_TLView,
           "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;
}
 
/*
 *--------------------------------------------------------------
 *
 * WidgetEventProc --
 *
 *      This procedure is invoked by the Tk dispatcher for various
 *      events on Lists.
 *
 * 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));
        }
        CancelResizeWhenIdle(wPtr);
        CancelRedrawWhenIdle(wPtr);
        Tk_EventuallyFree((ClientData) wPtr, (Tix_FreeProc*)WidgetDestroy);
        break;
 
      case ConfigureNotify:
        ResizeWhenIdle(wPtr);
        break;
 
      case Expose:
        RedrawWhenIdle(wPtr);
        break;
 
      case FocusIn:
        wPtr->hasFocus = 1;
        RedrawWhenIdle(wPtr);
        break;
 
      case FocusOut:
        wPtr->hasFocus = 0;
        RedrawWhenIdle(wPtr);
        break;
    }
}
 
/*
 *----------------------------------------------------------------------
 *
 * WidgetDestroy --
 *
 *      This procedure is invoked by Tk_EventuallyFree or Tk_Release
 *      to clean up the internal structure of a List at a safe time
 *      (when no-one is using it anymore).
 *
 * Results:
 *      None.
 *
 * Side effects:
 *      Everything associated with the List is freed up.
 *
 *----------------------------------------------------------------------
 */
 
static void
WidgetDestroy(clientData)
    ClientData clientData;      /* Info about my widget. */
{
    WidgetPtr wPtr = (WidgetPtr) clientData;
 
 
    if (wPtr->backgroundGC != None) {
        Tk_FreeGC(wPtr->dispData.display, wPtr->backgroundGC);
    }
    if (wPtr->selectGC != None) {
        Tk_FreeGC(wPtr->dispData.display, wPtr->selectGC);
    }
    if (wPtr->anchorGC != None) {
        Tk_FreeGC(wPtr->dispData.display, wPtr->anchorGC);
    }
    if (wPtr->highlightGC != None) {
        Tk_FreeGC(wPtr->dispData.display, wPtr->highlightGC);
    }
 
    if (wPtr->entList.numItems > 0) {
        ListEntry * fromPtr=NULL, *toPtr=NULL;
        char * argv[2];
        argv[0] = "0";
        argv[1] = "end";
 
        Tix_TLGetFromTo(wPtr->dispData.interp, wPtr, 2, argv, &fromPtr,&toPtr);
        Tcl_ResetResult(wPtr->dispData.interp);
 
        if (fromPtr && toPtr) {
            Tix_TLDeleteRange(wPtr, fromPtr, toPtr);
        }
    }
 
    if (wPtr->rows) {
        ckfree((char*)wPtr->rows);
    }
 
    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);
    }
}
 
/*
 *--------------------------------------------------------------
 *
 * WidgetComputeGeometry --
 *
 *      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
 *
 *--------------------------------------------------------------
 */
static void
WidgetComputeGeometry(clientData)
    ClientData clientData;
{
    WidgetPtr wPtr = (WidgetPtr)clientData;
    int winW, winH;
    Tk_Window tkwin = wPtr->dispData.tkwin;
 
    wPtr->resizing = 0;
 
    winW = Tk_Width(tkwin)  - 2*wPtr->highlightWidth - 2*wPtr->borderWidth;
    winH = Tk_Height(tkwin) - 2*wPtr->highlightWidth - 2*wPtr->borderWidth;
 
    ResizeRows(wPtr, winW, winH);
    /* Update scrollbars */
    UpdateScrollBars(wPtr, 1);
 
    RedrawWhenIdle(wPtr);
}
 
static void
MakeGeomRequest(wPtr)
    WidgetPtr wPtr;
{
    int reqW, reqH;
 
    reqW = wPtr->width  * wPtr->scrollInfo[0].unit;
    reqH = wPtr->height * wPtr->scrollInfo[1].unit;
 
    Tk_GeometryRequest(wPtr->dispData.tkwin, reqW, reqH);
}
 
 
 
/*----------------------------------------------------------------------
 * DItemSizeChanged --
 *
 *      This is called whenever the size of one of the HList's items
 *      changes its size.
 *----------------------------------------------------------------------
 */
static void
Tix_TLDItemSizeChanged(iPtr)
    Tix_DItem *iPtr;
{
    WidgetPtr wPtr = (WidgetPtr)iPtr->base.clientData;
 
    if (wPtr) {
        /* double-check: perhaps we haven't set the clientData yet! */
        ResizeWhenIdle(wPtr);
    }
}
 
/*
 *----------------------------------------------------------------------
 * ResizeWhenIdle --
 *----------------------------------------------------------------------
 */
static void
ResizeWhenIdle(wPtr)
    WidgetPtr wPtr;
{
    if (wPtr->redrawing) {
        CancelRedrawWhenIdle(wPtr);
    }
    if (!wPtr->resizing) {
        wPtr->resizing = 1;
        Tk_DoWhenIdle(WidgetComputeGeometry, (ClientData)wPtr);
    }
}
 
/*
 *----------------------------------------------------------------------
 * ResizeWhenIdle --
 *----------------------------------------------------------------------
 */
static void
ResizeNow(wPtr)
    WidgetPtr wPtr;
{
    if (wPtr->resizing) {
        Tk_CancelIdleCall(WidgetComputeGeometry, (ClientData)wPtr);
 
        WidgetComputeGeometry((ClientData)wPtr);
        wPtr->resizing = 0;
    }
}
 
/*
 *----------------------------------------------------------------------
 * CancelResizeWhenIdle --
 *----------------------------------------------------------------------
 */
static void
CancelResizeWhenIdle(wPtr)
    WidgetPtr wPtr;
{
    if (wPtr->resizing) {
        wPtr->resizing = 0;
        Tk_CancelIdleCall(WidgetComputeGeometry, (ClientData)wPtr);
    }
}
 
/*
 *----------------------------------------------------------------------
 * RedrawWhenIdle --
 *----------------------------------------------------------------------
 */
static void
RedrawWhenIdle(wPtr)
    WidgetPtr wPtr;
{
    if (wPtr->resizing) {
        /*
         * Resize will eventually call redraw.
         */
        return;
    }
    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);
    }
}
 
/*
 *----------------------------------------------------------------------
 *
 * 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;
    Pixmap pixmap;
    Tk_Window tkwin = wPtr->dispData.tkwin;
    int winH, winW;
 
    wPtr->redrawing = 0;         /* clear the redraw flag */
    wPtr->serial ++;
 
    pixmap = Tk_GetPixmap(wPtr->dispData.display, Tk_WindowId(tkwin),
        Tk_Width(tkwin), Tk_Height(tkwin), Tk_Depth(tkwin));
 
    /* Fill the background */
    XFillRectangle(wPtr->dispData.display, pixmap, wPtr->backgroundGC,
        0, 0, Tk_Width(tkwin), Tk_Height(tkwin));
 
    winW = Tk_Width(tkwin)  - 2*wPtr->highlightWidth - 2*wPtr->borderWidth;
    winH = Tk_Height(tkwin) - 2*wPtr->highlightWidth - 2*wPtr->borderWidth;
 
    if (winW > 0 && winH > 0) {
        RedrawRows(wPtr, pixmap);
    }
 
    /* Draw the border */
    Tk_Draw3DRectangle(wPtr->dispData.tkwin, pixmap, wPtr->border,
        wPtr->highlightWidth, wPtr->highlightWidth,
        Tk_Width(tkwin)  - 2*wPtr->highlightWidth,
        Tk_Height(tkwin) - 2*wPtr->highlightWidth, wPtr->borderWidth,
        wPtr->relief);
 
    /* Draw the highlight */
    if (wPtr->highlightWidth > 0) {
        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, pixmap);
    }
 
    /*
     * Copy the information from the off-screen pixmap onto the screen,
     * then delete the pixmap.
     */
    XCopyArea(wPtr->dispData.display, pixmap, Tk_WindowId(tkwin),
        wPtr->backgroundGC, 0, 0, Tk_Width(tkwin), Tk_Height(tkwin), 0, 0);
    Tk_FreePixmap(wPtr->dispData.display, pixmap);
 
}
 
/*----------------------------------------------------------------------
 *  AddElement  --
 *
 *      Add the element at the position indicated by "at".
 *----------------------------------------------------------------------
 */
static int
AddElement(wPtr, chPtr, at)
    WidgetPtr wPtr;
    ListEntry * chPtr;
    int at;
{
    if (at >= wPtr->entList.numItems) {
        /* The "end" position */
        Tix_LinkListAppend(&entListInfo, &wPtr->entList, (char*)chPtr, 0);
    }
    else {
        Tix_ListIterator li;
        Tix_LinkListIteratorInit(&li);
 
        for (Tix_LinkListStart(&entListInfo, &wPtr->entList, &li);
             !Tix_LinkListDone(&li);
             Tix_LinkListNext (&entListInfo, &wPtr->entList, &li)) {
 
            if (at == 0) {
                Tix_LinkListInsert(&entListInfo, &wPtr->entList,
                    (char*)chPtr, &li);
                break;
            } else {
                -- at;
            }
        }
    }
 
    return TCL_OK;
}
 
/*----------------------------------------------------------------------
 *  AllocEntry  --
 *
 *      Allocates memory for a new entry and initializes it to a
 *      proper state.
 *----------------------------------------------------------------------
 */
static ListEntry *
AllocEntry(wPtr)
    WidgetPtr wPtr;
{
    ListEntry * chPtr;
 
    chPtr = (ListEntry *)ckalloc(sizeof(ListEntry));
    chPtr->state        = NULL;
    chPtr->selected     = 0;
    chPtr->iPtr         = NULL;
 
    return chPtr;
}
 
/*----------------------------------------------------------------------
 *  FreeEntry  --
 *
 *      Free the entry and all resources allocated to this entry.
 *      This entry must already be deleted from the list.
 *----------------------------------------------------------------------
 */
static void
FreeEntry(wPtr, chPtr)
    WidgetPtr wPtr;
    ListEntry * chPtr;
{
 
    if (wPtr->seeElemPtr == chPtr) {
        /*
         * This is the element that should be visible the next time
         * we draw the window. Adjust the "to see element" to an element
         * that is close to it.
         */
        if (chPtr->next != NULL) {
            wPtr->seeElemPtr = chPtr->next;
        } else {
            ListEntry *p;
 
            wPtr->seeElemPtr = NULL;
            for (p=(ListEntry*)wPtr->entList.head; p; p=p->next) {
                if (p->next == chPtr) {
                    wPtr->seeElemPtr = p;
                    break;
                }
            }
        }
    }
 
    if (wPtr->anchor == chPtr) {
        wPtr->anchor = NULL;
    }
    if (wPtr->active == chPtr) {
        wPtr->active = NULL;
    }
    if (wPtr->dragSite == chPtr) {
        wPtr->dragSite = NULL;
    }
    if (wPtr->dropSite == chPtr) {
        wPtr->dropSite = NULL;
    }
 
    if (chPtr->iPtr != NULL) {
        if (Tix_DItemType(chPtr->iPtr) == TIX_DITEM_WINDOW) {
#if 0
            Tix_WindowItemListRemove(&wPtr->mappedWindows,
                chPtr->iPtr);
#endif
        }
        Tix_DItemFree(chPtr->iPtr);
    }
 
    Tk_FreeOptions(entryConfigSpecs, (char *)chPtr,wPtr->dispData.display, 0);
    ckfree((char*)chPtr);
}
 
/*----------------------------------------------------------------------
 * "insert" sub command --
 *
 *      Insert a new item into the list
 *----------------------------------------------------------------------
 */
static int
Tix_TLInsert(clientData, interp, argc, argv)
    ClientData clientData;
    Tcl_Interp *interp;         /* Current interpreter. */
    int argc;                   /* Number of arguments. */
    char **argv;                /* Argument strings. */
{
    WidgetPtr wPtr = (WidgetPtr) clientData;
    ListEntry * chPtr = NULL;
    char buff[40];
    char * ditemType;
    int at;
    int added = 0;
    int code = TCL_OK;
 
    /*------------------------------------------------------------
     * (1) We need to determine the options:
     *     -itemtype and -at.
     *------------------------------------------------------------
     */
 
    /* (1.1) Find out where */
    if (Tix_TranslateIndex(wPtr, interp, argv[0], &at, 1) != TCL_OK) {
        code = TCL_ERROR; goto done;
    }
 
    /* (1.2) Find out the -itemtype, if specified */
    ditemType = wPtr->diTypePtr->name;                   /* default value */
    if (argc > 1) {
        size_t len;
        int i;
        if (argc %2 != 1) {
            Tcl_AppendResult(interp, "value for \"", argv[argc-1],
                "\" missing", NULL);
            code = TCL_ERROR; goto done;
        }
        for (i=1; i<argc; i+=2) {
            len = strlen(argv[i]);
            if (strncmp(argv[i], "-itemtype", len) == 0) {
                ditemType = argv[i+1];
            }
        }
    }
 
    if (Tix_GetDItemType(interp, ditemType) == NULL) {
        code = TCL_ERROR; goto done;
    }
 
    /*
     * (2) Allocate a new entry
     */
    chPtr = AllocEntry(wPtr);
 
    /* (2.1) The Display item data */
    if ((chPtr->iPtr = Tix_DItemCreate(&wPtr->dispData, ditemType)) == NULL) {
        code = TCL_ERROR; goto done;
    }
    chPtr->iPtr->base.clientData = (ClientData)wPtr;
    chPtr->size[0] = chPtr->iPtr->base.size[0];
    chPtr->size[1] = chPtr->iPtr->base.size[1];
 
    /*
     * (3) Add the entry into the list
     */
    if (AddElement(wPtr, chPtr, at) != TCL_OK) {
        code = TCL_ERROR; goto done;
    } else {
        added = 1;
    }
 
    if (ConfigElement(wPtr, chPtr, argc-1, argv+1, 0, 1) != TCL_OK) {
        code = TCL_ERROR; goto done;
    }
 
    ResizeWhenIdle(wPtr);
 
  done:
    if (code == TCL_ERROR) {
        if (chPtr != NULL) {
            if (added) {
                Tix_LinkListFindAndDelete(&entListInfo, &wPtr->entList,
                    (char*)chPtr, NULL);
            }
            FreeEntry(wPtr, chPtr);
        }
    } else {
        sprintf(buff, "%d", at);
        Tcl_AppendResult(interp, buff, NULL);
    }
 
    return code;
}
 
static int
Tix_TLSpecialEntryInfo(wPtr, interp, chPtr)
    WidgetPtr wPtr;
    Tcl_Interp *interp;
    ListEntry * chPtr;
{
    char buff[100];
 
    if (chPtr) {
        int i;
        Tix_ListIterator li;
 
        Tix_LinkListIteratorInit(&li);
 
        for (i=0,Tix_LinkListStart(&entListInfo, &wPtr->entList, &li);
             !Tix_LinkListDone(&li);
             Tix_LinkListNext(&entListInfo, &wPtr->entList, &li),i++) {
            if (li.curr == (char*)chPtr) {
                break;
            }
        }
        if (li.curr != NULL) {
            sprintf(buff, "%d", i);
            Tcl_AppendResult(interp, buff, NULL);
        } else {
            panic("TList list entry is invalid");
        }
    } else {
        Tcl_ResetResult(interp);
    }
    return TCL_OK;
}
 
/*----------------------------------------------------------------------
 * "index" sub command
 *----------------------------------------------------------------------
 */
static int
Tix_TLIndex(clientData, interp, argc, argv)
    ClientData clientData;      /* TList widget record. */
    Tcl_Interp *interp;         /* Current interpreter. */
    int argc;                   /* Number of arguments. */
    char **argv;                /* Argument strings. */
{
    WidgetPtr wPtr = (WidgetPtr) clientData;
    int index;
    char buff[100];
 
    if (Tix_TranslateIndex(wPtr, interp, argv[0], &index, 0) != TCL_OK) {
        return TCL_ERROR;
    }
 
    sprintf(buff, "%d", index);
    Tcl_AppendResult(interp, buff, NULL);
    return TCL_OK;
}
 
/*----------------------------------------------------------------------
 * "info" sub command
 *----------------------------------------------------------------------
 */
static int
Tix_TLInfo(clientData, interp, argc, argv)
    ClientData clientData;
    Tcl_Interp *interp;         /* Current interpreter. */
    int argc;                   /* Number of arguments. */
    char **argv;                /* Argument strings. */
{
    WidgetPtr wPtr = (WidgetPtr) clientData;
    size_t len = strlen(argv[0]);
 
    if (strncmp(argv[0], "anchor", len)==0) {
        return Tix_TLSpecialEntryInfo(wPtr, interp, wPtr->anchor);
    }
    else if (strncmp(argv[0], "active", len)==0) {
        return Tix_TLSpecialEntryInfo(wPtr, interp, wPtr->active);
    }
    else if (strncmp(argv[0], "down", len)==0) {
        return Tix_TLGetNeighbor(wPtr, interp, TIX_DOWN,  argc-1, argv+1);
    }
    else if (strncmp(argv[0], "left", len)==0) {
        return Tix_TLGetNeighbor(wPtr, interp, TIX_LEFT,  argc-1, argv+1);
    }
    else if (strncmp(argv[0], "right", len)==0) {
        return Tix_TLGetNeighbor(wPtr, interp, TIX_RIGHT, argc-1, argv+1);
    }
    else if (strncmp(argv[0], "selection", len)==0) {
        ListEntry *chPtr;
        int i;
        char buffer[32];
 
        for (chPtr=(ListEntry*)wPtr->entList.head, i=0;
             chPtr;
             chPtr=chPtr->next, i++) {
 
            if (chPtr->selected) {
                if (i) {
                    Tcl_AppendResult(interp, " ", (char *) NULL);
                }
                sprintf(buffer, "%d", i);
                Tcl_AppendResult(interp, buffer, (char *) NULL);
            }
        }
        return TCL_OK;
    }
    else if (strncmp(argv[0], "size", len)==0) {
        char buff[100];
 
        sprintf(buff, "%d", wPtr->entList.numItems);
        Tcl_AppendResult(interp, buff, NULL);
 
        return TCL_OK;
    }
    else if (strncmp(argv[0], "up", len)==0) {
        return Tix_TLGetNeighbor(wPtr, interp, TIX_UP,    argc-1, argv+1);
    }
    else {
        Tcl_AppendResult(interp, "unknown option \"", argv[0],
            "\": must be anchor or selection",
            NULL);
        return TCL_ERROR;
    }
}
 
static int
Tix_TranslateIndex(wPtr, interp, string, index, isInsert)
    WidgetPtr wPtr;             /* TList widget record. */
    Tcl_Interp *interp;         /* Current interpreter. */
    char * string;              /* String representation of the index. */
    int * index;                /* Returns the index value(0 = 1st element).*/
    int isInsert;               /* Is this function called by an "insert"
                                 * operation? */
{
    if (strcmp(string, "end") == 0) {
        *index = wPtr->entList.numItems;
    }
    else if (Tix_TLGetAt(wPtr, interp, string, index) != TCL_OK) {
        if (Tcl_GetInt(interp, string, index) != TCL_OK) {
            return TCL_ERROR;
        }
        else if (*index < 0) {
            Tcl_AppendResult(interp,"expected non-negative integer but got \"",
                string, "\"", NULL);
            return TCL_ERROR;
        }
    }
 
 
    /*
     * The meaning of "end" means:
     *     isInsert:wPtr->entList.numItems
     *    !isInsert:wPtr->entList.numItems-1;
     */
 
    if (isInsert) {
        if (*index > wPtr->entList.numItems) {
            /*
             * By default add it to the end, just to follow what TK
             * does for the Listbox widget
             */
            *index = wPtr->entList.numItems;
        }
    } else {
        if (*index >= wPtr->entList.numItems) {
            /*
             * By default add it to the end, just to follow what TK
             * does for the Listbox widget
             */
            *index = wPtr->entList.numItems - 1;
        }
    }
 
    if (*index < 0) {
        *index = 0;
    }
 
    return TCL_OK;
}
 
static int Tix_TLGetNeighbor(wPtr, interp, type, argc, argv)
    WidgetPtr wPtr;
    Tcl_Interp *interp;         /* Current interpreter. */
    int type;
    int argc;                   /* Number of arguments. */
    char **argv;                /* Argument strings. */
{
    int index;
    int dst;
    int xStep, yStep;
    int numPerRow;
    char buff[100];
 
    if (argc != 1) {
        Tix_ArgcError(interp, argc+3, argv-3, 3, "index");
    }
 
    if (Tix_TranslateIndex(wPtr, interp, argv[0], &index, 0) != TCL_OK) {
        return TCL_ERROR;
    }
 
    if (wPtr->entList.numItems == 0) {
        Tcl_ResetResult(interp);
        return TCL_OK;
    }
 
    numPerRow = wPtr->rows[0].numEnt;
 
    if (wPtr->isVertical) {
        xStep = numPerRow;
        yStep = 1;
    } else {
        xStep = 1;
        yStep = numPerRow;
    }
 
    switch (type) {
      case TIX_UP:
        dst = index - yStep;
        break;
      case TIX_DOWN:
        dst = index + yStep;
        break;
      case TIX_LEFT:
        dst = index - xStep;
        break;
      case TIX_RIGHT:
        dst = index + xStep;
        break;
    }
 
    if (dst < 0) {
        dst = index;
    } else if (dst >= wPtr->entList.numItems) {
        dst = index;
    }
 
    sprintf(buff, "%d", dst);
    Tcl_AppendResult(interp, buff, NULL);
 
    return TCL_OK;
}
 
 
 
/*----------------------------------------------------------------------
 * "cget" sub command --
 *----------------------------------------------------------------------
 */
static int
Tix_TLCGet(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_TLConfig(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);
    }
}
 
/*----------------------------------------------------------------------
 * "geometryinfo" sub command
 *----------------------------------------------------------------------
 */
static int
Tix_TLGeometryInfo(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[40];
    int i;
 
    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;
 
    for (i=0; i<2; i++) {
        qSize[i] -= 2*wPtr->borderWidth + 2*wPtr->highlightWidth;
        Tix_GetScrollFractions((Tix_ScrollInfo*)&wPtr->scrollInfo[i],
            &first[i], &last[i]);
    }
 
    sprintf(string, "{%f %f} {%f %f}", first[0], last[0], first[1], last[1]);
    Tcl_AppendResult(interp, string, NULL);
 
    return TCL_OK;
}
 
/*----------------------------------------------------------------------
 * "delete" sub command
 *----------------------------------------------------------------------
 */
static int
Tix_TLDelete(clientData, interp, argc, argv)
    ClientData clientData;
    Tcl_Interp *interp;         /* Current interpreter. */
    int argc;                   /* Number of arguments. */
    char **argv;                /* Argument strings. */
{
    WidgetPtr wPtr = (WidgetPtr) clientData;
    ListEntry * fromPtr, *toPtr;
    int code = TCL_OK;
 
    if (argc < 1 || argc > 2) {
        Tix_ArgcError(interp, argc+2, argv-2, 2, "from ?to?");
        code = TCL_ERROR;
        goto done;
    }
 
    if (Tix_TLGetFromTo(interp, wPtr, argc, argv, &fromPtr, &toPtr)!= TCL_OK) {
        code = TCL_ERROR;
        goto done;
    }
    if (fromPtr == NULL) {
        goto done;
    }
 
    if (Tix_TLDeleteRange(wPtr, fromPtr, toPtr)) {
        ResizeWhenIdle(wPtr);
    }
 
  done:
    return code;
}
 
/* returns true if some element has been deleted */
static int Tix_TLDeleteRange(wPtr, fromPtr, toPtr)
    WidgetPtr wPtr;
    ListEntry * fromPtr;
    ListEntry *toPtr;
{
    int started;
    Tix_ListIterator li;
 
    Tix_LinkListIteratorInit(&li);
    started = 0;
    for (Tix_LinkListStart(&entListInfo, &wPtr->entList, &li);
         !Tix_LinkListDone(&li);
         Tix_LinkListNext (&entListInfo, &wPtr->entList, &li)) {
 
        ListEntry * curr = (ListEntry *)li.curr;
        if (curr == fromPtr) {
            started = 1;
        }
        if (started) {
            Tix_LinkListDelete(&entListInfo, &wPtr->entList, &li);
            FreeEntry(wPtr, curr);
        }
        if (curr == toPtr) {
            break;
        }
    }
 
    return started;
}
 
 
/*----------------------------------------------------------------------
 * "entrycget" sub command
 *----------------------------------------------------------------------
 */
static int
Tix_TLEntryCget(clientData, interp, argc, argv)
    ClientData clientData;
    Tcl_Interp *interp;         /* Current interpreter. */
    int argc;                   /* Number of arguments. */
    char **argv;                /* Argument strings. */
{
    WidgetPtr wPtr = (WidgetPtr) clientData;
    ListEntry * chPtr, * dummy;
 
    if (Tix_TLGetFromTo(interp, wPtr, 1, argv, &chPtr, &dummy)
        != TCL_OK) {
        return TCL_ERROR;
    }
 
    if (chPtr == NULL) {
        Tcl_AppendResult(interp, "list entry \"", argv[0],
            "\" does not exist", NULL);
        return TCL_ERROR;
    }
 
    return Tix_ConfigureValue2(interp, wPtr->dispData.tkwin, (char *)chPtr,
        entryConfigSpecs, chPtr->iPtr, argv[1], 0);
}
 
/*----------------------------------------------------------------------
 * "entryconfigure" sub command
 *----------------------------------------------------------------------
 */
static int
Tix_TLEntryConfig(clientData, interp, argc, argv)
    ClientData clientData;
    Tcl_Interp *interp;         /* Current interpreter. */
    int argc;                   /* Number of arguments. */
    char **argv;                /* Argument strings. */
{
    WidgetPtr wPtr = (WidgetPtr) clientData;
    ListEntry * chPtr, * dummy;
 
    if (Tix_TLGetFromTo(interp, wPtr, 1, argv, &chPtr, &dummy)
        != TCL_OK) {
        return TCL_ERROR;
    }
 
    if (chPtr == NULL) {
        Tcl_AppendResult(interp, "list entry \"", argv[0],
            "\" does not exist", NULL);
        return TCL_ERROR;
    }
 
    if (argc == 1) {
        return Tix_ConfigureInfo2(interp, wPtr->dispData.tkwin,
            (char*)chPtr, entryConfigSpecs, chPtr->iPtr, (char *) NULL, 0);
    } else if (argc == 2) {
        return Tix_ConfigureInfo2(interp, wPtr->dispData.tkwin,
            (char*)chPtr, entryConfigSpecs, chPtr->iPtr, (char *) argv[1], 0);
    } else {
        return ConfigElement(wPtr, chPtr, argc-1, argv+1,
            TK_CONFIG_ARGV_ONLY, 0);
    }
}
 
/*----------------------------------------------------------------------
 * "nearest" sub command
 *----------------------------------------------------------------------
 */
static int
Tix_TLNearest(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 posn[2];
    int index;
    char buff[100];
 
    if (Tcl_GetInt(interp, argv[0], &posn[0]) != TCL_OK) {
        return TCL_ERROR;
    }
    if (Tcl_GetInt(interp, argv[1], &posn[1]) != TCL_OK) {
        return TCL_ERROR;
    }
 
    index = Tix_TLGetNearest(wPtr, posn);
    Tcl_ResetResult(interp);
 
    if (index != -1) {
        sprintf(buff, "%d", index);
        Tcl_AppendResult(interp, buff, NULL);
    }
    return TCL_OK;
}
 
static int Tix_TLGetAt(wPtr, interp, spec, at)
    WidgetPtr wPtr;
    Tcl_Interp *interp;
    char * spec;
    int *at;
{
    int posn[2];
    char *p, *end;
 
    if (spec[0] != '@') {
        return TCL_ERROR;
    }
 
    p = spec+1;
    posn[0] = strtol(p, &end, 0);
    if ((end == p) || (*end != ',')) {
        return TCL_ERROR;
    }
    p = end+1;
    posn[1] = strtol(p, &end, 0);
    if ((end == p) || (*end != 0)) {
        return TCL_ERROR;
    }
 
    *at = Tix_TLGetNearest(wPtr, posn);
    return TCL_OK;
}
 
static int Tix_TLGetNearest(wPtr, posn)
    WidgetPtr wPtr;
    int posn[2];
{
    int i, j, index;
    int maxX, maxY;
    int r, c;
 
    if (wPtr->resizing) {
        ResizeNow(wPtr);
    }
 
    if (wPtr->entList.numItems == 0) {
        return -1;
    }
 
    /* clip off the position with the border of the window */
 
    posn[0] -= wPtr->borderWidth + wPtr->highlightWidth;
    posn[1] -= wPtr->borderWidth + wPtr->highlightWidth;
 
    maxX = Tk_Width (wPtr->dispData.tkwin);
    maxY = Tk_Height(wPtr->dispData.tkwin);
 
    maxX -= 2*(wPtr->borderWidth + wPtr->highlightWidth);
    maxY -= 2*(wPtr->borderWidth + wPtr->highlightWidth);
 
    if (posn[0] >= maxX) {
        posn[0] =  maxX -1;
    }
    if (posn[1] >= maxY) {
        posn[1] =  maxY -1;
    }
    if (posn[0] < 0) {
        posn[0] = 0;
    }
    if (posn[1] < 0) {
        posn[1] = 0;
    }
 
    i = (wPtr->isVertical == 0);
    j = (wPtr->isVertical == 1);
 
    posn[0] += wPtr->scrollInfo[0].offset;
    posn[1] += wPtr->scrollInfo[1].offset;
 
    r = posn[i] / wPtr->maxSize[i];
    c = posn[j] / wPtr->maxSize[j];
 
    index = (r * wPtr->rows[0].numEnt) + c;
 
    if (index >= wPtr->entList.numItems) {
        index = wPtr->entList.numItems - 1;
    }
 
    return index;
}
 
/*----------------------------------------------------------------------
 * "selection" sub command
 *      Modify the selection in this HList box
 *----------------------------------------------------------------------
 */
static int
Tix_TLGetFromTo(interp, wPtr, argc, argv, fromPtr_ret, toPtr_ret)
    Tcl_Interp *interp;
    WidgetPtr wPtr;
    int argc;
    char **argv;
    ListEntry ** fromPtr_ret;
    ListEntry ** toPtr_ret;
{
    /*
     * ToDo: make it more efficient by saving the previous from and to
     * pointers and make the list of childrens a doubly-linked list
     */
    ListEntry * fromPtr;
    ListEntry * toPtr;
    int from, to, tmp;
 
    if (Tix_TranslateIndex(wPtr, interp, argv[0], &from, 0) != TCL_OK) {
        return TCL_ERROR;
    }
    if (argc == 2) {
        if (Tix_TranslateIndex(wPtr, interp, argv[1], &to, 0) != TCL_OK) {
            return TCL_ERROR;
        }
    } else {
        to = from;
    }
 
    if (from > to) {
        /* swap from and to */
        tmp = to; to = from; from = tmp;
    }
 
    fromPtr = NULL;
    toPtr   = NULL;
 
    if (from >= wPtr->entList.numItems) {
        fromPtr = (ListEntry *)wPtr->entList.tail;
        toPtr   = (ListEntry *)wPtr->entList.tail;
    }
    if (to >= wPtr->entList.numItems) {
        toPtr   = (ListEntry *)wPtr->entList.tail;
    }
 
    if (fromPtr == NULL) {
        for (fromPtr = (ListEntry*)wPtr->entList.head;
             from > 0;
             fromPtr=fromPtr->next) {
 
            -- from;
            -- to;
        }
    }
    if (toPtr == NULL) {
        for (toPtr = fromPtr; to > 0; toPtr=toPtr->next) {
            -- to;
        }
    }
 
    * fromPtr_ret = fromPtr;
    if (toPtr_ret) {
        * toPtr_ret = toPtr;
    }
    return TCL_OK;
}
 
static int
Tix_TLSelection(clientData, interp, argc, argv)
    ClientData clientData;
    Tcl_Interp *interp;         /* Current interpreter. */
    int argc;                   /* Number of arguments. */
    char **argv;                /* Argument strings. */
{
    WidgetPtr wPtr = (WidgetPtr) clientData;
    size_t len = strlen(argv[0]);
    int code = TCL_OK;
    int changed = 0;
    ListEntry * chPtr, * fromPtr, * toPtr;
 
    if (strncmp(argv[0], "clear", len)==0) {
        if (argc == 1) {
            /*
             * Clear all entries
             */
            for (chPtr=(ListEntry*)wPtr->entList.head;
                 chPtr;
                 chPtr=chPtr->next) {
 
                chPtr->selected = 0;
            }
            changed = 1;
        }
        else {
            if (Tix_TLGetFromTo(interp, wPtr, argc-1, argv+1, &fromPtr, &toPtr)
                    != TCL_OK) {
                code = TCL_ERROR;
                goto done;
            }
            if (fromPtr == NULL) {
                goto done;
            }
            else {
                while (1) {
                    fromPtr->selected = 0;
                    if (fromPtr == toPtr) {
                        break;
                    } else {
                        fromPtr=fromPtr->next;
                    }
                }
                changed = 1;
                goto done;
            }
        }
    }
    else if (strncmp(argv[0], "includes", len)==0) {
        if (argc != 2) {
            Tix_ArgcError(interp, argc+2, argv-2, 3, "index");
            code = TCL_ERROR;
            goto done;
        }
        if (Tix_TLGetFromTo(interp, wPtr, argc-1, argv+1, &fromPtr, &toPtr)
                != TCL_OK) {
            code = TCL_ERROR;
            goto done;
        }
        if (fromPtr->selected) {
            Tcl_AppendResult(interp, "1", NULL);
        } else {
            Tcl_AppendResult(interp, "0", NULL);
        }
    }
    else if (strncmp(argv[0], "set", len)==0) {
        if (argc < 2 || argc > 3) {
            Tix_ArgcError(interp, argc+2, argv-2, 3, "from ?to?");
            code = TCL_ERROR;
            goto done;
        }
 
        if (Tix_TLGetFromTo(interp, wPtr, argc-1, argv+1, &fromPtr, &toPtr)
                != TCL_OK) {
            code = TCL_ERROR;
            goto done;
        }
        if (fromPtr == NULL) {
            goto done;
        }
        else {
            while (1) {
                fromPtr->selected = 1;
                if (fromPtr == toPtr) {
                    break;
                } else {
                    fromPtr=fromPtr->next;
                }
            }
            changed = 1;
            goto done;
        }
    }
    else {
        Tcl_AppendResult(interp, "unknown option \"", argv[0],
            "\": must be anchor, clear, includes or set", NULL);
        code = TCL_ERROR;
    }
 
  done:
    if (changed) {
        RedrawWhenIdle(wPtr);
    }
 
    return code;
}
 
/*----------------------------------------------------------------------
 * "see" command
 *----------------------------------------------------------------------
 */
static int
Tix_TLSee(clientData, interp, argc, argv)
    ClientData clientData;
    Tcl_Interp *interp;         /* Current interpreter. */
    int argc;                   /* Number of arguments. */
    char **argv;                /* Argument strings. */
{
    WidgetPtr wPtr = (WidgetPtr) clientData;
    ListEntry * chPtr, * dummy;
 
    if (argc == 1) {
        if (Tix_TLGetFromTo(interp, wPtr, 1, argv, &chPtr, &dummy) != TCL_OK) {
            return TCL_ERROR;
        }
        if (chPtr != NULL) {
            wPtr->seeElemPtr = chPtr;
            RedrawWhenIdle(wPtr);
        }
    } else {
        Tcl_AppendResult(interp, "wrong # of arguments, must be: ",
                Tk_PathName(wPtr->dispData.tkwin), " ", argv[-1],
                " index", NULL);
    }
 
    return TCL_OK;
}
 
/*----------------------------------------------------------------------
 * "anchor", "dragsite" and "dropsite" sub commands --
 *
 *      Set/remove the anchor element
 *----------------------------------------------------------------------
 */
static int
Tix_TLSetSite(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;
    ListEntry * fromPtr;
    ListEntry * toPtr;                  /* unused */
    ListEntry ** changePtr;
    size_t len;
 
    /* Determine which site should be changed (the last else clause
     * doesn't need to check the string because HandleSubCommand
     * already ensures that only the valid options can be specified.
     **/
    len = strlen(argv[-1]);
    if (strncmp(argv[-1], "anchor", len)==0) {
        changePtr = &wPtr->anchor;
    }
    else if (strncmp(argv[-1], "active", len)==0) {
        changePtr = &wPtr->active;
    }
    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 (Tix_TLGetFromTo(interp,wPtr, argc-1, argv+1, &fromPtr, &toPtr)
                    != TCL_OK) {
                return TCL_ERROR;
            }
            if (*changePtr != fromPtr) {
                *changePtr = fromPtr;
                changed = 1;
            }
        } else {
            Tcl_AppendResult(interp, "wrong # of arguments, must be: ",
                Tk_PathName(wPtr->dispData.tkwin), " ", argv[-1],
                " set index", 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;
}
 
/*----------------------------------------------------------------------
 * "xview" and "yview" sub command
 *----------------------------------------------------------------------
 */
static int
Tix_TLView(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 axis;
 
    if (argv[-1][0] == 'x') {
        axis = 0;
    } else {
        axis = 1;
    }
 
    if (argc == 0) {
        char string[80];
        double first, last;
 
        Tix_GetScrollFractions((Tix_ScrollInfo*)&wPtr->scrollInfo[axis],
            &first, &last);
 
        sprintf(string, "{%f %f}", first, last);
        Tcl_AppendResult(interp, string, NULL);
        return TCL_OK;
    }
    else if (Tix_SetScrollBarView(interp,
        (Tix_ScrollInfo*)&wPtr->scrollInfo[axis], argc, argv, 0) != TCL_OK) {
 
        return TCL_ERROR;
    }
 
    UpdateScrollBars(wPtr, 0);
    RedrawWhenIdle(wPtr);
    return TCL_OK;
}
/*----------------------------------------------------------------------
 *
 *
 *                      Memory Management Section
 *
 *
 *----------------------------------------------------------------------
 */
static int
ConfigElement(wPtr, chPtr, argc, argv, flags, forced)
    WidgetPtr wPtr;
    ListEntry *chPtr;
    int argc;
    char ** argv;
    int flags;
    int forced;
{
    int sizeChanged;
 
    if (Tix_WidgetConfigure2(wPtr->dispData.interp, wPtr->dispData.tkwin,
        (char*)chPtr, entryConfigSpecs, chPtr->iPtr, argc, argv, flags,
        forced, &sizeChanged) != TCL_OK) {
        return TCL_ERROR;
    }
 
    if (sizeChanged) {
        chPtr->size[0] = chPtr->iPtr->base.size[0];
        chPtr->size[1] = chPtr->iPtr->base.size[1];
        ResizeWhenIdle(wPtr);
    } else {
        RedrawWhenIdle(wPtr);
    }
    return TCL_OK;
}
 
static void
Realloc(wPtr, new_size)
    WidgetPtr wPtr;
    int new_size;
{
    if (new_size < 1) {
        new_size = 1;
    }
    if (new_size == wPtr->numRowAllocd) {
        return;
    }
    wPtr->rows = (ListRow*)ckrealloc(wPtr->rows, sizeof(ListRow)*new_size);
    wPtr->numRowAllocd = new_size;
}
 
static void ResizeRows(wPtr, winW, winH)
    WidgetPtr wPtr;
    int winW;                   /* -1 == current width */
    int winH;                   /* -1 == current height */
{
    ListEntry * chPtr;
    ListEntry * rowHead;
    int n, c, r;
    int maxI;                   /* max of width in the current column */
    int maxJ;                   /* max of height among all elements */
    int curRow;
    int i, j;
    int sizeJ;
    int winSize[2];
 
    if (wPtr->isVertical) {
        i = 0;           /* Column major, 0,0 -> 0,1 -> 0,2 ... -> 1,0 */
        j = 1;
    } else {
        i = 1;          /* Row major, 0,0 -> 1,0 -> 2,0 ... -> 0,1 */
        j = 0;
    }
 
    if (winW == -1) {
        winW = Tk_Width (wPtr->dispData.tkwin);
    }
    if (winH == -1) {
        winH = Tk_Height(wPtr->dispData.tkwin);
    }
 
    winSize[0] = winW;
    winSize[1] = winH;
 
    if (wPtr->entList.numItems == 0) {
        wPtr->rows[0].chPtr = NULL;
        wPtr->rows[0].size[0] = 1;
        wPtr->rows[0].size[1] = 1;
        wPtr->rows[0].numEnt = 0;
 
        wPtr->numRow = 1;
        goto done;
    }
 
    /*      --  The following verbal description follows the "Column Major"
     *          model. Row major are similar, just the i,j incides are swapped
     *
     * (1) (a) Search for the tallest element, use it as the height of all
     *         the elements;
     *     (b) Search for the widest element, use it as the width of all
     *         the elements;
     */
    for (maxJ=1, maxI=1, chPtr = (ListEntry*)wPtr->entList.head;
         chPtr;
         chPtr=chPtr->next) {
 
        if (maxJ < chPtr->iPtr->base.size[j]) {
            maxJ = chPtr->iPtr->base.size[j];
        }
        if (maxI < chPtr->iPtr->base.size[i]) {
            maxI = chPtr->iPtr->base.size[i];
        }
    }
    wPtr->maxSize[i] = maxI;
    wPtr->maxSize[j] = maxJ;
 
    /* (2) Calculate how many elements can be in each column
     *
     */
    n = winSize[j] / maxJ;
    if (n <=0) {
        n = 1;
    }
 
    wPtr->numRow = 0;
    curRow = 0;
    c = 0;
    sizeJ = 0;
    rowHead = (ListEntry*)wPtr->entList.head;
    for(chPtr = (ListEntry*)wPtr->entList.head; chPtr; chPtr=chPtr->next) {
        sizeJ += chPtr->iPtr->base.size[j];
        ++ c;
        if (c == n || chPtr->next == NULL) {
            if (curRow >= wPtr->numRowAllocd) {
                Realloc(wPtr, curRow*2);
            }
            wPtr->rows[curRow].chPtr   = rowHead;
            wPtr->rows[curRow].size[i] = maxI;
            wPtr->rows[curRow].size[j] = sizeJ;
            wPtr->rows[curRow].numEnt  = c;
            ++ curRow;
            ++ wPtr->numRow;
            c = 0;
            rowHead = chPtr->next;
            sizeJ = 0;
        }
    }
 
  done:
    /* calculate the size of the total and visible area */
    wPtr->scrollInfo[i].total = 0;
    wPtr->scrollInfo[j].total = 0;
 
    for (r=0; r<wPtr->numRow; r++) {
        wPtr->scrollInfo[i].total += wPtr->rows[r].size[i];
        if (wPtr->scrollInfo[j].total < wPtr->rows[r].size[j]) {
            wPtr->scrollInfo[j].total = wPtr->rows[r].size[j];
        }
    }
 
    wPtr->scrollInfo[i].window = winSize[i];
    wPtr->scrollInfo[j].window = winSize[j];
 
    if (wPtr->scrollInfo[i].total < 1) {
        wPtr->scrollInfo[i].total = 1;
    }
    if (wPtr->scrollInfo[j].total < 1) {
        wPtr->scrollInfo[j].total = 1;
    }
    if (wPtr->scrollInfo[i].window < 1) {
        wPtr->scrollInfo[i].window = 1;
    }
    if (wPtr->scrollInfo[j].window < 1) {
        wPtr->scrollInfo[j].window = 1;
    }
 
    /* If we have much fewer rows now, adjust the size of the rows list */
    if (wPtr->numRowAllocd > (2*wPtr->numRow)) {
        Realloc(wPtr, 2*wPtr->numRow);
    }
 
    /* Update the scrollbars */
 
    UpdateScrollBars(wPtr, 1);
}
/*----------------------------------------------------------------------
 * RedrawRows --
 *
 *      Redraw the rows, according to the "offset: in both directions
 *----------------------------------------------------------------------
 */
 
static void
RedrawRows(wPtr, pixmap)
    WidgetPtr wPtr;
    Drawable pixmap;
{
    int r, n;
    int p[2];
    ListEntry * chPtr;
    int i, j;
    int total;
    int windowSize;
 
    if (wPtr->entList.numItems == 0) {
        return;
    }
 
    if (wPtr->isVertical) {
        i = 0;           /* Column major, 0,0 -> 0,1 -> 0,2 ... -> 1,0 */
        j = 1;
        windowSize = Tk_Width(wPtr->dispData.tkwin);
    } else {
        i = 1;          /* Row major, 0,0 -> 1,0 -> 2,0 ... -> 0,1 */
        j = 0;
        windowSize = Tk_Height(wPtr->dispData.tkwin);
    }
 
    p[i] = wPtr->highlightWidth + wPtr->borderWidth;
    windowSize -= 2*p[i];
 
    if (windowSize < 1) {
        windowSize = 1;
    }
 
    if (wPtr->seeElemPtr != NULL) {
        /*
         * Adjust the scrolling so that the given entry is visible.
         */
        int start = 0;           /* x1 position of the element to see. */
        int size = 0;            /* width of the element to see. */
        int old = wPtr->scrollInfo[i].offset;
 
        for (r=0, n=0, chPtr=(ListEntry*)wPtr->entList.head; chPtr;
                chPtr=chPtr->next, n++) {
            if (chPtr == wPtr->seeElemPtr) {
                size = wPtr->rows[r].size[i];
                break;
            }
            if (n == wPtr->rows[r].numEnt) {
                n=0;
                r++;
                start += wPtr->rows[r].size[i];
            }
        }
 
        if (wPtr->scrollInfo[i].offset + windowSize > start + size) {
            wPtr->scrollInfo[i].offset = start + size - windowSize;
        }
        if (wPtr->scrollInfo[i].offset < start) {
            wPtr->scrollInfo[i].offset = start;
        }
        if (wPtr->scrollInfo[i].offset != old) {
            UpdateScrollBars(wPtr, 0);
        }
        wPtr->seeElemPtr = NULL;
    }
 
    /* Search for a row that is (possibly partially) visible*/
    total=0; r=0;
    if (wPtr->scrollInfo[i].offset != 0) {
        for (; r<wPtr->numRow; r++) {
            total += wPtr->rows[r].size[i];
 
            if (total > wPtr->scrollInfo[i].offset) {
                p[i] -= wPtr->scrollInfo[i].offset -
                        (total - wPtr->rows[r].size[i]);
                break;
            }
            if (total == wPtr->scrollInfo[i].offset) {
                r++;
                break;
            }
        }
    }
 
    /* Redraw all the visible rows */
    for (; r<wPtr->numRow; r++) {
 
        p[j] = wPtr->highlightWidth + wPtr->borderWidth;
 
        total=0; n=0; chPtr=wPtr->rows[r].chPtr;
        if (wPtr->scrollInfo[j].offset > 0)  {
            /* Search for a column that is (possibly partially) visible*/
            for (;
                 n<wPtr->rows[r].numEnt;
                 n++, chPtr = chPtr->next) {
 
                total += chPtr->iPtr->base.size[j];
                if (total > wPtr->scrollInfo[j].offset) {
                    /* Adjust for the shift due to partially visible elements*/
                    p[j] -= wPtr->scrollInfo[j].offset -
                      (total - chPtr->iPtr->base.size[j]);
                    break;
                }
                if (total == wPtr->scrollInfo[j].offset) {
                    n++; chPtr = chPtr->next;
                    break;
                }
            }
        }
 
        /* Redraw all the visible columns in this row */
        for (; n<wPtr->rows[r].numEnt; n++, chPtr = chPtr->next) {
            int flags = TIX_DITEM_NORMAL_FG;
            int W, H;
 
            if (chPtr->selected) {
                flags |= TIX_DITEM_SELECTED_FG;
                flags |= TIX_DITEM_SELECTED_BG;
            }
 
            if (wPtr->isVertical) {
                W = wPtr->rows[r].size[0];
                H = chPtr->iPtr->base.size[1];
            } else {
                H = wPtr->rows[r].size[1];
                W = chPtr->iPtr->base.size[0];
            }
 
            Tix_DItemDisplay(pixmap, None, chPtr->iPtr, p[0], p[1], W, H,
                flags);
 
            if (chPtr == wPtr->anchor) {
                Tix_DrawAnchorLines(Tk_Display(wPtr->dispData.tkwin), pixmap,
                    wPtr->anchorGC, p[0], p[1], W-1, H-1);
            }
            p[j] += wPtr->maxSize[j];
        }
 
        /* advance to the next row */
        p[i]+= wPtr->rows[r].size[i];
    }
}
 
/*----------------------------------------------------------------------
 *  UpdateScrollBars
 *----------------------------------------------------------------------
 */
static void UpdateScrollBars(wPtr, sizeChanged)
    WidgetPtr wPtr;
    int sizeChanged;
{
    Tix_UpdateScrollBar(wPtr->dispData.interp,
        (Tix_ScrollInfo*)&wPtr->scrollInfo[0]);
    Tix_UpdateScrollBar(wPtr->dispData.interp,
        (Tix_ScrollInfo*)&wPtr->scrollInfo[1]);
 
    if (wPtr->sizeCmd && sizeChanged) {
        if (Tcl_Eval(wPtr->dispData.interp, wPtr->sizeCmd) != TCL_OK) {
            Tcl_AddErrorInfo(wPtr->dispData.interp,
                "\n    (size command executed by tixTList)");
            Tk_BackgroundError(wPtr->dispData.interp);
        }
    }
}
Line No.	Rev	Author	Line
1	578	markom	`/*`
2			`* tixTList.c --`
3			`*`
4			`* This module implements "TList" widgets.`
5			`*`
6			`*`
7			`* Copyright (c) 1996, Expert Interface Technologies`
8			`*`
9			`* See the file "license.terms" for information on usage and redistribution`
10			`* of this file, and for a DISCLAIMER OF ALL WARRANTIES.`
11			`*/`
12
13			`#include <tixPort.h>`
14			`#include <tixInt.h>`
15			`#include <tixDef.h>`
16			`#include <tixTList.h>`
17
18			`#define TIX_UP 1`
19			`#define TIX_DOWN 2`
20			`#define TIX_LEFT 3`
21			`#define TIX_RIGHT 4`
22
23			`/*`
24			`* Information used for argv parsing.`
25			`*/`
26			`static Tk_ConfigSpec configSpecs[] = {`
27			`{TK_CONFIG_COLOR, "-background", "background", "Background",`
28			`DEF_TLIST_BG_COLOR, Tk_Offset(WidgetRecord, normalBg),`
29			`TK_CONFIG_COLOR_ONLY},`
30
31			`{TK_CONFIG_COLOR, "-background", "background", "Background",`
32			`DEF_TLIST_BG_MONO, Tk_Offset(WidgetRecord, normalBg),`
33			`TK_CONFIG_MONO_ONLY},`
34
35			`{TK_CONFIG_SYNONYM, "-bd", "borderWidth", (char *) NULL,`
36			`(char *) NULL, 0, 0},`
37
38			`{TK_CONFIG_SYNONYM, "-bg", "background", (char *) NULL,`
39			`(char *) NULL, 0, 0},`
40
Browse

Tools

Subversion Repositories or1k

[/] [or1k/] [trunk/] [insight/] [tix/] [generic/] [tixTList.c] - Blame information for rev 1778
