From 3d5d0656695c572b7f9a20e1718656abc9de4511 Mon Sep 17 00:00:00 2001 From: treectrl Date: Wed, 21 Sep 2005 00:04:36 +0000 Subject: Add Tcl block comments above each function. Comment function arguments. --- generic/tkTreeDisplay.c | 1772 +++++++++++++++++++++++++++++++++++++++++++---- 1 file changed, 1630 insertions(+), 142 deletions(-) diff --git a/generic/tkTreeDisplay.c b/generic/tkTreeDisplay.c index 8804012..9f77e99 100644 --- a/generic/tkTreeDisplay.c +++ b/generic/tkTreeDisplay.c @@ -5,7 +5,7 @@ * * Copyright (c) 2002-2005 Tim Baker * - * RCS: @(#) $Id: tkTreeDisplay.c,v 1.33 2005/07/23 00:40:53 treectrl Exp $ + * RCS: @(#) $Id: tkTreeDisplay.c,v 1.34 2005/09/21 00:04:36 treectrl Exp $ */ #include "tkTreeCtrl.h" @@ -15,54 +15,55 @@ typedef struct Range Range; typedef struct DItem DItem; typedef struct DInfo DInfo; -void Range_RedoIfNeeded(TreeCtrl *tree); -int Range_TotalWidth(TreeCtrl *tree, Range *range_); -int Range_TotalHeight(TreeCtrl *tree, Range *range_); -void Range_Redo(TreeCtrl *tree); -Range *Range_UnderPoint(TreeCtrl *tree, int *x_, int *y_, int nearest); -RItem *Range_ItemUnderPoint(TreeCtrl *tree, Range *range, int *x_, int *y_); +static void Range_RedoIfNeeded(TreeCtrl *tree); +static int Range_TotalWidth(TreeCtrl *tree, Range *range_); +static int Range_TotalHeight(TreeCtrl *tree, Range *range_); +static void Range_Redo(TreeCtrl *tree); +static Range *Range_UnderPoint(TreeCtrl *tree, int *x_, int *y_, int nearest); +static RItem *Range_ItemUnderPoint(TreeCtrl *tree, Range *range, int *x_, int *y_); -/* One of these per TreeItem */ +/* One of these per TreeItem. */ struct RItem { - TreeItem item; /* The item */ - Range *range; /* Range the item is in */ - int size; /* height or width consumed in Range */ - int offset; /* vertical or horizontal offset in Range */ - int index; /* 0-based index in Range */ + TreeItem item; /* The item. */ + Range *range; /* Range the item is in. */ + int size; /* Height or width consumed in Range. */ + int offset; /* Vertical or horizontal offset in Range. */ + int index; /* 0-based index in Range. */ }; -/* A collection of visible TreeItems */ +/* A collection of visible TreeItems. */ struct Range { RItem *first; RItem *last; int totalWidth; int totalHeight; - int index; /* 0-based index in list of Ranges */ - int offset; /* vertical/horizontal offset from canvas top/left */ + int index; /* 0-based index in list of Ranges. */ + int offset; /* vertical/horizontal offset from canvas + * top/left. */ Range *prev; Range *next; }; -/* Display information for a TreeItem */ +/* Display information for a TreeItem. */ struct DItem { - char magic[4]; /* debug */ + char magic[4]; /* debug */ TreeItem item; - int x, y; /* Where it should be drawn, window coords */ - int oldX, oldY; /* Where it was last drawn, window coords */ - int width, height; /* Current width and height */ - int dirty[4]; /* Dirty area in item coords */ - Range *range; /* Range the TreeItem is in */ - int index; /* Used for alternating background colors */ + int x, y; /* Where it should be drawn, window coords. */ + int oldX, oldY; /* Where it was last drawn, window coords. */ + int width, height; /* Current width and height. */ + int dirty[4]; /* Dirty area in item coords. */ + Range *range; /* Range the TreeItem is in. */ + int index; /* Used for alternating background colors. */ #define DITEM_DIRTY 0x0001 #define DITEM_ALL_DIRTY 0x0002 int flags; DItem *next; }; -/* Display information for a TreeCtrl */ +/* Display information for a TreeCtrl. */ struct DInfo { GC scrollGC; @@ -73,7 +74,7 @@ struct DInfo int *columnWidth; /* Last seen column widths */ int columnWidthSize; /* Num elements in columnWidth */ int headerHeight; /* Last seen TreeCtrl.headerHeight */ - DItem *dItem; /* Head of list for each visible item */ + DItem *dItem; /* Head of list for each displayed item */ DItem *dItemLast; /* Temp for UpdateDInfo() */ Range *rangeFirst; /* Head of Ranges */ Range *rangeLast; /* Tail of Ranges */ @@ -90,13 +91,13 @@ struct DInfo int yScrollIncrement; /* Last seen TreeCtr.yScrollIncrement */ int *xScrollIncrements; /* When tree->xScrollIncrement is zero */ int *yScrollIncrements; /* When tree->yScrollIncrement is zero */ - int xScrollIncrementCount; - int yScrollIncrementCount; + int xScrollIncrementCount; /* Size of xScrollIncrements. */ + int yScrollIncrementCount; /* Size of yScrollIncrements. */ int incrementTop; /* yScrollIncrement[] index of item at top */ int incrementLeft; /* xScrollIncrement[] index of item at left */ - TkRegion wsRgn; /* region containing whitespace */ - Tcl_HashTable itemVisHash; /* table of visible items */ - DItem *dItemFree; /* list of unused DItems */ + TkRegion wsRgn; /* Region containing whitespace */ + Tcl_HashTable itemVisHash; /* Table of visible items */ + DItem *dItemFree; /* List of unused DItems */ }; /*========*/ @@ -116,11 +117,27 @@ Range_Free(TreeCtrl *tree, Range *range) } /* - * This routine puts all ReallyVisible() TreeItems into a list of Ranges. - * If tree->wrapMode is TREE_WRAP_NONE there will only be a single Range. + *---------------------------------------------------------------------- + * + * Range_Redo -- + * + * This procedure puts all ReallyVisible() TreeItems into a list of + * Ranges. If tree->wrapMode is TREE_WRAP_NONE there will only be a + * single Range. + * + * Results: + * None. + * + * Side effects: + * Memory may be allocated. + * + *---------------------------------------------------------------------- */ -void -Range_Redo(TreeCtrl *tree) + +static void +Range_Redo( + TreeCtrl *tree /* Widget info. */ + ) { DInfo *dInfo = (DInfo *) tree->dInfo; Range *rangeList = dInfo->rangeFirst; @@ -314,8 +331,28 @@ Range_Redo(TreeCtrl *tree) rangeList = Range_Free(tree, rangeList); } -int -Range_TotalWidth(TreeCtrl *tree, Range *range) +/* + *---------------------------------------------------------------------- + * + * Range_TotalWidth -- + * + * Return the width of a Range. The width is only calculated if + * it hasn't been done yet by Range_Redo(). + * + * Results: + * Pixel width of the Range. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +static int +Range_TotalWidth( + TreeCtrl *tree, /* Widget info. */ + Range *range /* Range to return the width of. */ + ) { TreeItem item; TreeItemColumn itemColumn; @@ -465,8 +502,28 @@ Range_TotalWidth(TreeCtrl *tree, Range *range) } } -int -Range_TotalHeight(TreeCtrl *tree, Range *range) +/* + *---------------------------------------------------------------------- + * + * Range_TotalHeight -- + * + * Return the height of a Range. The height is only calculated if + * it hasn't been done yet by Range_Redo(). + * + * Results: + * Pixel height of the Range. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +static int +Range_TotalHeight( + TreeCtrl *tree, /* Widget info. */ + Range *range /* Range to return the height of. */ + ) { TreeItem item; RItem *rItem; @@ -496,11 +553,30 @@ Range_TotalHeight(TreeCtrl *tree, Range *range) return range->totalHeight; } +/* + *---------------------------------------------------------------------- + * + * Tree_TotalWidth -- + * + * Return the width needed by all the Ranges. The width is only + * recalculated if it was marked out-of-date. + * + * Results: + * Pixel width of the "canvas". + * + * Side effects: + * The list of Ranges will be recalculated if needed. + * + *---------------------------------------------------------------------- + */ + int -Tree_TotalWidth(TreeCtrl *tree) +Tree_TotalWidth( + TreeCtrl *tree /* Widget info. */ + ) { DInfo *dInfo = (DInfo *) tree->dInfo; - Range *range = dInfo->rangeFirst; + Range *range; int rangeWidth; Range_RedoIfNeeded(tree); @@ -509,6 +585,7 @@ Tree_TotalWidth(TreeCtrl *tree) return tree->totalWidth; tree->totalWidth = 0; + range = dInfo->rangeFirst; while (range != NULL) { rangeWidth = Range_TotalWidth(tree, range); if (tree->vertical) { @@ -524,11 +601,30 @@ Tree_TotalWidth(TreeCtrl *tree) return tree->totalWidth; } +/* + *---------------------------------------------------------------------- + * + * Tree_TotalHeight -- + * + * Return the height needed by all the Ranges. The height is only + * recalculated if it was marked out-of-date. + * + * Results: + * Pixel height of the "canvas". + * + * Side effects: + * The list of Ranges will be recalculated if needed. + * + *---------------------------------------------------------------------- + */ + int -Tree_TotalHeight(TreeCtrl *tree) +Tree_TotalHeight( + TreeCtrl *tree /* Widget info. */ + ) { DInfo *dInfo = (DInfo *) tree->dInfo; - Range *range = dInfo->rangeFirst; + Range *range; int rangeHeight; Range_RedoIfNeeded(tree); @@ -537,6 +633,7 @@ Tree_TotalHeight(TreeCtrl *tree) return tree->totalHeight; tree->totalHeight = 0; + range = dInfo->rangeFirst; while (range != NULL) { rangeHeight = Range_TotalHeight(tree, range); if (tree->vertical) { @@ -552,8 +649,35 @@ Tree_TotalHeight(TreeCtrl *tree) return tree->totalHeight; } -Range * -Range_UnderPoint(TreeCtrl *tree, int *x_, int *y_, int nearest) +/* + *---------------------------------------------------------------------- + * + * Range_UnderPoint -- + * + * Return the Range containing the given coordinates. + * + * Results: + * Range containing the coordinates or NULL if the point is + * outside any Range. + * + * Side effects: + * The list of Ranges will be recalculated if needed. + * + *---------------------------------------------------------------------- + */ + +static Range * +Range_UnderPoint( + TreeCtrl *tree, /* Widget info. */ + int *x_, /* In: window x coordinate. + * Out: x coordinate relative to the top-left + * of the Range. */ + int *y_, /* In: window y coordinate. + * Out: y coordinate relative to the top-left + * of the Range. */ + int nearest /* TRUE if the Range nearest the coordinates + * should be returned. */ + ) { DInfo *dInfo = (DInfo *) tree->dInfo; Range *range; @@ -640,8 +764,37 @@ Range_UnderPoint(TreeCtrl *tree, int *x_, int *y_, int nearest) } } -RItem * -Range_ItemUnderPoint(TreeCtrl *tree, Range *range, int *x_, int *y_) +/* + *---------------------------------------------------------------------- + * + * Range_ItemUnderPoint -- + * + * Return the RItem containing the given x and/or y coordinates. + * + * Results: + * RItem containing the coordinates. Panics() if no RItem is found. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +static RItem * +Range_ItemUnderPoint( + TreeCtrl *tree, /* Widget info. */ + Range *range, /* Range to search. */ + int *x_, /* In: x coordinate relative to top-left of + * the Range. + * Out: x coordinate relative to top-left of + * the returned RItem. + * May be NULL if y_ is not NULL. */ + int *y_ /* In: y coordinate relative to top-left of + * the Range. + * Out: y coordinate relative to top-left of + * the returned RItem. + * May be NULL if x_ is not NULL. */ + ) { RItem *rItem; int x = -666, y = -666; @@ -703,8 +856,29 @@ Range_ItemUnderPoint(TreeCtrl *tree, Range *range, int *x_, int *y_) return NULL; } +/* + *---------------------------------------------------------------------- + * + * Increment_AddX -- + * + * Appends one or more values to the list of horizontal scroll + * increments. + * + * Results: + * New size of DInfo.xScrollIncrements. + * + * Side effects: + * Memory may be allocated. + * + *---------------------------------------------------------------------- + */ + static int -Increment_AddX(TreeCtrl *tree, int offset, int size) +Increment_AddX( + TreeCtrl *tree, /* Widget info. */ + int offset, /* Offset to add. */ + int size /* Current size of DInfo.xScrollIncrements. */ + ) { DInfo *dInfo = (DInfo *) tree->dInfo; int visWidth = Tk_Width(tree->tkwin) - tree->inset * 2; @@ -725,8 +899,29 @@ Increment_AddX(TreeCtrl *tree, int offset, int size) return size; } +/* + *---------------------------------------------------------------------- + * + * Increment_AddY -- + * + * Appends one or more values to the list of vertical scroll + * increments. + * + * Results: + * New size of DInfo.yScrollIncrements. + * + * Side effects: + * Memory may be allocated. + * + *---------------------------------------------------------------------- + */ + static int -Increment_AddY(TreeCtrl *tree, int offset, int size) +Increment_AddY( + TreeCtrl *tree, /* Widget info. */ + int offset, /* Offset to add. */ + int size /* Current size of DInfo.yScrollIncrements. */ + ) { DInfo *dInfo = (DInfo *) tree->dInfo; int topInset = tree->inset + Tree_HeaderHeight(tree); @@ -748,8 +943,28 @@ Increment_AddY(TreeCtrl *tree, int offset, int size) return size; } +/* + *---------------------------------------------------------------------- + * + * RItemsToIncrementsX -- + * + * Recalculate the list of horizontal scroll increments. This gets + * called when the TreeCtrl -orient option is "horizontal" and + * -xscrollincrement option is "". + * + * Results: + * DInfo.xScrollIncrements is updated if the canvas width is > 0. + * + * Side effects: + * Memory may be allocated. + * + *---------------------------------------------------------------------- + */ + static void -Increment_RedoX(TreeCtrl *tree) +RItemsToIncrementsX( + TreeCtrl *tree /* Widget info. */ + ) { DInfo *dInfo = (DInfo *) tree->dInfo; Range *range; @@ -795,8 +1010,28 @@ Increment_RedoX(TreeCtrl *tree) } } +/* + *---------------------------------------------------------------------- + * + * RItemsToIncrementsY -- + * + * Recalculate the list of vertical scroll increments. This gets + * called when the TreeCtrl -orient option is "vertical" and + * -yscrollincrement option is "". + * + * Results: + * DInfo.yScrollIncrements is updated if the canvas height is > 0. + * + * Side effects: + * Memory may be allocated. + * + *---------------------------------------------------------------------- + */ + static void -Increment_RedoY(TreeCtrl *tree) +RItemsToIncrementsY( + TreeCtrl *tree /* Widget info. */ + ) { DInfo *dInfo = (DInfo *) tree->dInfo; Range *range; @@ -843,8 +1078,28 @@ Increment_RedoY(TreeCtrl *tree) } } +/* + *---------------------------------------------------------------------- + * + * RangesToIncrementsX -- + * + * Recalculate the list of horizontal scroll increments. This gets + * called when the TreeCtrl -orient option is "vertical" and + * -xscrollincrement option is "". + * + * Results: + * DInfo.xScrollIncrements is updated if there are any Ranges. + * + * Side effects: + * Memory may be allocated. + * + *---------------------------------------------------------------------- + */ + static void -RangesToIncrementsX(TreeCtrl *tree) +RangesToIncrementsX( + TreeCtrl *tree /* Widget info. */ + ) { DInfo *dInfo = (DInfo *) tree->dInfo; Range *range = dInfo->rangeFirst; @@ -873,8 +1128,28 @@ RangesToIncrementsX(TreeCtrl *tree) } } +/* + *---------------------------------------------------------------------- + * + * RangesToIncrementsY -- + * + * Recalculate the list of vertical scroll increments. This gets + * called when the TreeCtrl -orient option is "horizontal" and + * -yscrollincrement option is "". + * + * Results: + * DInfo.yScrollIncrements is updated if there are any Ranges. + * + * Side effects: + * Memory may be allocated. + * + *---------------------------------------------------------------------- + */ + static void -RangesToIncrementsY(TreeCtrl *tree) +RangesToIncrementsY( + TreeCtrl *tree /* Widget info. */ + ) { DInfo *dInfo = (DInfo *) tree->dInfo; Range *range = dInfo->rangeFirst; @@ -904,8 +1179,27 @@ RangesToIncrementsY(TreeCtrl *tree) } } +/* + *---------------------------------------------------------------------- + * + * Increment_Redo -- + * + * Recalculate the lists of scroll increments. + * + * Results: + * DInfo.xScrollIncrements and DInfo.xScrollIncrements are updated. + * Either may be set to NULL. The old values are freed, if any. + * + * Side effects: + * Memory may be allocated. + * + *---------------------------------------------------------------------- + */ + static void -Increment_Redo(TreeCtrl *tree) +Increment_Redo( + TreeCtrl *tree /* Widget info. */ + ) { DInfo *dInfo = (DInfo *) tree->dInfo; @@ -928,12 +1222,12 @@ Increment_Redo(TreeCtrl *tree) /* No yScrollIncrement is given. Snap to top edge of a TreeItem */ if (tree->yScrollIncrement <= 0) - Increment_RedoY(tree); + RItemsToIncrementsY(tree); } else { /* No xScrollIncrement is given. Snap to left edge of a TreeItem */ if (tree->xScrollIncrement <= 0) - Increment_RedoX(tree); + RItemsToIncrementsX(tree); /* No yScrollIncrement is given. Snap to top edge of a Range */ if (tree->yScrollIncrement <= 0) @@ -941,8 +1235,28 @@ Increment_Redo(TreeCtrl *tree) } } +/* + *---------------------------------------------------------------------- + * + * Increment_RedoIfNeeded -- + * + * Recalculate the lists of scroll increments if needed. + * + * Results: + * DInfo.xScrollIncrements and DInfo.xScrollIncrements may be + * updated. + * + * Side effects: + * Memory may be allocated. The list of Ranges will be recalculated + * if needed. + * + *---------------------------------------------------------------------- + */ + static void -Increment_RedoIfNeeded(TreeCtrl *tree) +Increment_RedoIfNeeded( + TreeCtrl *tree /* Widget info. */ + ) { DInfo *dInfo = (DInfo *) tree->dInfo; @@ -961,8 +1275,30 @@ Increment_RedoIfNeeded(TreeCtrl *tree) } } +/* + *---------------------------------------------------------------------- + * + * B_IncrementFind -- + * + * Search a list of increments and return one nearest to the + * given offset. + * + * Results: + * Index of the nearest increment <= the given offset. + * Panic() if no appropriate offset if found. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + static int -B_IncrementFind(int *increments, int count, int offset) +B_IncrementFind( + int *increments, /* DInfo.x|yScrollIncrements. */ + int count, /* Length of increments[]. */ + int offset /* Offset to search with. */ + ) { int i, l, u, v; @@ -986,8 +1322,29 @@ B_IncrementFind(int *increments, int count, int offset) return -1; } +/* + *---------------------------------------------------------------------- + * + * B_IncrementFindX -- + * + * Search DInfo.xScrollIncrements and return one nearest to the + * given offset. + * + * Results: + * Index of the nearest increment <= the given offset. + * Panic() if no appropriate offset if found. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + int -B_IncrementFindX(TreeCtrl *tree, int offset) +B_IncrementFindX( + TreeCtrl *tree, /* Widget info. */ + int offset /* Offset to search with. */ + ) { DInfo *dInfo = (DInfo *) tree->dInfo; @@ -997,8 +1354,29 @@ B_IncrementFindX(TreeCtrl *tree, int offset) offset); } +/* + *---------------------------------------------------------------------- + * + * B_IncrementFindY -- + * + * Search DInfo.yScrollIncrements and return one nearest to the + * given offset. + * + * Results: + * Index of the nearest increment <= the given offset. + * Panic() if no appropriate offset if found. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + int -B_IncrementFindY(TreeCtrl *tree, int offset) +B_IncrementFindY( + TreeCtrl *tree, /* Widget info. */ + int offset /* Offset to search with. */ + ) { DInfo *dInfo = (DInfo *) tree->dInfo; @@ -1008,8 +1386,33 @@ B_IncrementFindY(TreeCtrl *tree, int offset) offset); } +/* + *-------------------------------------------------------------- + * + * B_XviewCmd -- + * + * This procedure is invoked to process the "xview" option for + * the widget command for a TreeCtrl. See the user documentation + * for details on what it does. + * + * NOTE: This procedure is called when the -xscrollincrement option + * is unspecified. + * + * Results: + * A standard Tcl result. + * + * Side effects: + * See the user documentation. + * + *-------------------------------------------------------------- + */ + int -B_XviewCmd(TreeCtrl *tree, int objc, Tcl_Obj *CONST objv[]) +B_XviewCmd( + TreeCtrl *tree, /* Widget info. */ + int objc, /* Number of arguments. */ + Tcl_Obj *CONST objv[] /* Argument values. */ + ) { Tcl_Interp *interp = tree->interp; DInfo *dInfo = (DInfo *) tree->dInfo; @@ -1090,8 +1493,33 @@ B_XviewCmd(TreeCtrl *tree, int objc, Tcl_Obj *CONST objv[]) return TCL_OK; } +/* + *-------------------------------------------------------------- + * + * B_YviewCmd -- + * + * This procedure is invoked to process the "yview" option for + * the widget command for a TreeCtrl. See the user documentation + * for details on what it does. + * + * NOTE: This procedure is called when the -yscrollincrement option + * is unspecified. + * + * Results: + * A standard Tcl result. + * + * Side effects: + * See the user documentation. + * + *-------------------------------------------------------------- + */ + int -B_YviewCmd(TreeCtrl *tree, int objc, Tcl_Obj *CONST objv[]) +B_YviewCmd( + TreeCtrl *tree, /* Widget info. */ + int objc, /* Number of arguments. */ + Tcl_Obj *CONST objv[] /* Argument values. */ + ) { Tcl_Interp *interp = tree->interp; DInfo *dInfo = (DInfo *) tree->dInfo; @@ -1173,8 +1601,31 @@ B_YviewCmd(TreeCtrl *tree, int objc, Tcl_Obj *CONST objv[]) return TCL_OK; } +/* + *-------------------------------------------------------------- + * + * Tree_ItemUnderPoint -- + * + * Return a TreeItem containing the given coordinates. + * + * Results: + * TreeItem token or NULL if no item contains the point. + * + * Side effects: + * The list of Ranges will be recalculated if needed. + * + *-------------------------------------------------------------- + */ + TreeItem -Tree_ItemUnderPoint(TreeCtrl *tree, int *x_, int *y_, int nearest) +Tree_ItemUnderPoint( + TreeCtrl *tree, /* Widget info. */ + int *x_, int *y_, /* In: window coordinates. + * Out: coordinates relative to top-left + * corner of the returned item. */ + int nearest /* TRUE if the item nearest the coordinates + * should be returned. */ + ) { Range *range; RItem *rItem; @@ -1188,8 +1639,32 @@ Tree_ItemUnderPoint(TreeCtrl *tree, int *x_, int *y_, int nearest) return NULL; } +/* + *-------------------------------------------------------------- + * + * Tree_ItemBbox -- + * + * Return the bounding box for an item. + * + * Results: + * Return value is -1 if the item is not ReallyVisible() + * or if there are no visible columns. The coordinates + * are relative to the top-left corner of the canvas. + * + * Side effects: + * Column layout will be updated if needed. + * The list of Ranges will be recalculated if needed. + * + *-------------------------------------------------------------- + */ + int -Tree_ItemBbox(TreeCtrl *tree, TreeItem item, int *x, int *y, int *w, int *h) +Tree_ItemBbox( + TreeCtrl *tree, /* Widget info. */ + TreeItem item, /* Item whose bbox is needed. */ + int *x, int *y, /* Returned left and top. */ + int *w, int *h /* Returned width and height. */ + ) { Range *range; RItem *rItem; @@ -1217,8 +1692,32 @@ Tree_ItemBbox(TreeCtrl *tree, TreeItem item, int *x, int *y, int *w, int *h) return 0; } +/* + *-------------------------------------------------------------- + * + * Tree_ItemLARB -- + * + * Return an adjacent item above, below, to the left or to the + * right of the given item. + * + * Results: + * An adjacent item or NULL if there is no such item. + * + * Side effects: + * The list of Ranges will be recalculated if needed. + * + *-------------------------------------------------------------- + */ + TreeItem -Tree_ItemLARB(TreeCtrl *tree, TreeItem item, int vertical, int prev) +Tree_ItemLARB( + TreeCtrl *tree, /* Widget info. */ + TreeItem item, /* Item to use as a reference. */ + int vertical, /* TRUE if items are arranged + * from top-to-bottom in each Range. */ + int prev /* TRUE for above/left, + * FALSE for below/right. */ + ) { RItem *rItem, *rItem2; Range *range; @@ -1289,8 +1788,32 @@ Tree_ItemBelow(TreeCtrl *tree, TreeItem item) return Tree_ItemLARB(tree, item, tree->vertical, FALSE); } +/* + *-------------------------------------------------------------- + * + * Tree_ItemFL -- + * + * Return the first or last item in the same row or column + * as the given item. + * + * Results: + * First/last item or NULL if there is no such item. + * + * Side effects: + * The list of Ranges will be recalculated if needed. + * + *-------------------------------------------------------------- + */ + TreeItem -Tree_ItemFL(TreeCtrl *tree, TreeItem item, int vertical, int first) +Tree_ItemFL( + TreeCtrl *tree, /* Widget info. */ + TreeItem item, /* Item to use as a reference. */ + int vertical, /* TRUE if items are arranged + * from top-to-bottom in each Range. */ + int first /* TRUE for top/left, + * FALSE for bottom/right. */ + ) { DInfo *dInfo = (DInfo *) tree->dInfo; RItem *rItem, *rItem2; @@ -1358,8 +1881,28 @@ Tree_ItemRightMost(TreeCtrl *tree, TreeItem item) return Tree_ItemFL(tree, item, !tree->vertical, FALSE); } +/* + *-------------------------------------------------------------- + * + * Tree_ItemToRNC -- + * + * Return the row and column for the given item. + * + * Results: + * A standard Tcl result. + * + * Side effects: + * The list of Ranges will be recalculated if needed. + * + *-------------------------------------------------------------- + */ + int -Tree_ItemToRNC(TreeCtrl *tree, TreeItem item, int *row, int *col) +Tree_ItemToRNC( + TreeCtrl *tree, /* Widget info. */ + TreeItem item, /* Item to get row n' column of. */ + int *row, int *col /* Returned row and column. */ + ) { RItem *rItem; @@ -1378,8 +1921,29 @@ Tree_ItemToRNC(TreeCtrl *tree, TreeItem item, int *row, int *col) return TCL_OK; } +/* + *-------------------------------------------------------------- + * + * Tree_RNCToItem -- + * + * Return the item at a given row and column. + * + * Results: + * Token for the item. Never returns NULL unless there are no + * Ranges. + * + * Side effects: + * The list of Ranges will be recalculated if needed. + * + *-------------------------------------------------------------- + */ + TreeItem -Tree_RNCToItem(TreeCtrl *tree, int row, int col) +Tree_RNCToItem( + TreeCtrl *tree, /* Widget info. */ + int row, int col /* Row and column. These values are + * clipped to valid values. */ + ) { DInfo *dInfo = (DInfo *) tree->dInfo; Range *range; @@ -1456,8 +2020,29 @@ DisplayDelay(TreeCtrl *tree) } } +/* + *-------------------------------------------------------------- + * + * DItem_Alloc -- + * + * Allocate and initialize a new DItem, and store a pointer to it + * in the given item. + * + * Results: + * Pointer to the DItem which may come from an existing pool of + * unused DItems. + * + * Side effects: + * Memory may be allocated. + * + *-------------------------------------------------------------- + */ + static DItem * -DItem_Alloc(TreeCtrl *tree, RItem *rItem) +DItem_Alloc( + TreeCtrl *tree, /* Widget info. */ + RItem *rItem /* Range info for the item. */ + ) { DInfo *dInfo = (DInfo *) tree->dInfo; DItem *dItem; @@ -1483,8 +2068,27 @@ DItem_Alloc(TreeCtrl *tree, RItem *rItem) return dItem; } +/* + *-------------------------------------------------------------- + * + * DItem_Unlink -- + * + * Remove a DItem from a linked list of DItems. + * + * Results: + * Pointer to the given list of DItems. + * + * Side effects: + * None. + * + *-------------------------------------------------------------- + */ + static DItem * -DItem_Unlink(DItem *head, DItem *dItem) +DItem_Unlink( + DItem *head, /* First in linked list. */ + DItem *dItem /* DItem to remove from list. */ + ) { DItem *prev; @@ -1502,8 +2106,29 @@ DItem_Unlink(DItem *head, DItem *dItem) return head; } +/* + *-------------------------------------------------------------- + * + * DItem_Free -- + * + * Add a DItem to the pool of unused DItems. If the DItem belongs + * to a TreeItem the pointer to the DItem is set to NULL in that + * TreeItem. + * + * Results: + * Pointer to the next DItem. + * + * Side effects: + * None. + * + *-------------------------------------------------------------- + */ + static DItem * -DItem_Free(TreeCtrl *tree, DItem *dItem) +DItem_Free( + TreeCtrl *tree, /* Widget info. */ + DItem *dItem /* DItem to free. */ + ) { DInfo *dInfo = (DInfo *) tree->dInfo; DItem *next = dItem->next; @@ -1517,8 +2142,31 @@ DItem_Free(TreeCtrl *tree, DItem *dItem) return next; } +/* + *-------------------------------------------------------------- + * + * FreeDItems -- + * + * Add a list of DItems to the pool of unused DItems, + * optionally removing the DItems from the DInfo.dItem list. + * + * Results: + * None. + * + * Side effects: + * None. + * + *-------------------------------------------------------------- + */ + static void -FreeDItems(TreeCtrl *tree, DItem *first, DItem *last, int unlink) +FreeDItems( + TreeCtrl *tree, /* Widget info. */ + DItem *first, /* First DItem to free. */ + DItem *last, /* DItem after the last one to free. */ + int unlink /* TRUE if the DItems should be removed + * from the DInfo.dItem list. */ + ) { DInfo *dInfo = (DInfo *) tree->dInfo; DItem *prev; @@ -1539,8 +2187,32 @@ FreeDItems(TreeCtrl *tree, DItem *first, DItem *last, int unlink) first = DItem_Free(tree, first); } +/* + *-------------------------------------------------------------- + * + * Tree_ItemsInArea -- + * + * Return a list of items overlapping the given area. + * + * Results: + * Pointer to an allocated array of TreeItems which the caller + * must free. NULL is returned if no items overlap. + * + * Side effects: + * The list of Ranges will be recalculated if needed. Memory may + * be allocated. + * + *-------------------------------------------------------------- + */ + TreeItem * -Tree_ItemsInArea(TreeCtrl *tree, int minX, int minY, int maxX, int maxY) +Tree_ItemsInArea( + TreeCtrl *tree, /* Widget info. */ + int minX, int minY, /* Left, top in canvas coordinates. */ + int maxX, int maxY /* Right, bottom in canvas coordinates. + * Points on the right/bottom edge are not + * included in the area. */ + ) { DInfo *dInfo = (DInfo *) tree->dInfo; int x, y, rx = 0, ry = 0, ix, iy, dx, dy; @@ -1646,9 +2318,33 @@ Tree_ItemsInArea(TreeCtrl *tree, int minX, int minY, int maxX, int maxY) return items; } +/* + *-------------------------------------------------------------- + * + * UpdateDInfoForRange -- + * + * Allocates or updates a DItem for every on-screen item in a Range. + * If an item already has a DItem (because the item was previously + * displayed), then the DItem may be marked dirty if there were + * changes to the item's on-screen size or position. + * + * Results: + * The return value is the possibly-updated dItemHead. + * + * Side effects: + * Memory may be allocated. + * + *-------------------------------------------------------------- + */ + static DItem * -UpdateDInfoForRange(TreeCtrl *tree, DItem *dItemHead, - Range *range, RItem *rItem, int x, int y) +UpdateDInfoForRange( + TreeCtrl *tree, /* Widget info. */ + DItem *dItemHead, /* Linked list of used DItems. */ + Range *range, /* Range to update DItems for. */ + RItem *rItem, /* First item in the Range we care about. */ + int x, int y /* Left & top window coordinates of rItem. */ + ) { DInfo *dInfo = (DInfo *) tree->dInfo; DItem *dItem; @@ -1874,8 +2570,28 @@ UpdateDInfoForRange(TreeCtrl *tree, DItem *dItemHead, return dItemHead; } +/* + *-------------------------------------------------------------- + * + * Tree_UpdateDInfo -- + * + * At the finish of this procedure every on-screen item will have + * a DItem associated with it and no off-screen item will have + * a DItem. + * + * Results: + * None. + * + * Side effects: + * Memory may be allocated. + * + *-------------------------------------------------------------- + */ + void -Tree_UpdateDInfo(TreeCtrl *tree) +Tree_UpdateDInfo( + TreeCtrl *tree /* Widget info. */ + ) { DInfo *dInfo = (DInfo *) tree->dInfo; DItem *dItemHead = dInfo->dItem; @@ -1977,30 +2693,74 @@ Tree_UpdateDInfo(TreeCtrl *tree) dInfo->flags &= ~DINFO_INVALIDATE; } +/* + *-------------------------------------------------------------- + * + * InvalidateDItemX -- + * + * Mark a horizontal span of a DItem as dirty (needing to be + * redrawn). The caller must set the DITEM_DIRTY flag afterwards. + * + * Results: + * None. + * + * Side effects: + * None. + * + *-------------------------------------------------------------- + */ + static void -InvalidateDItemX(DItem *dItem, int itemX, int dirtyX, int dirtyWidth) +InvalidateDItemX( + DItem *dItem, /* Item to mark dirty. */ + int itemX, /* x-coordinate of item. */ + int dirtyX, /* Left edge of area to mark as dirty. */ + int dirtyWidth /* Width of area to mark as dirty. */ + ) { int x1, x2; if (dirtyX <= itemX) dItem->dirty[LEFT] = 0; else { - x1 = dirtyX - itemX; - if (!(dItem->flags & DITEM_DIRTY) || (x1 < dItem->dirty[LEFT])) - dItem->dirty[LEFT] = x1; - } + x1 = dirtyX - itemX; + if (!(dItem->flags & DITEM_DIRTY) || (x1 < dItem->dirty[LEFT])) + dItem->dirty[LEFT] = x1; + } if (dirtyX + dirtyWidth >= itemX + dItem->width) dItem->dirty[RIGHT] = dItem->width; else { - x2 = dirtyX + dirtyWidth - itemX; - if (!(dItem->flags & DITEM_DIRTY) || (x2 > dItem->dirty[RIGHT])) - dItem->dirty[RIGHT] = x2; - } + x2 = dirtyX + dirtyWidth - itemX; + if (!(dItem->flags & DITEM_DIRTY) || (x2 > dItem->dirty[RIGHT])) + dItem->dirty[RIGHT] = x2; + } } +/* + *-------------------------------------------------------------- + * + * InvalidateDItemY -- + * + * Mark a vertical span of a DItem as dirty (needing to be + * redrawn). The caller must set the DITEM_DIRTY flag afterwards. + * + * Results: + * None. + * + * Side effects: + * None. + * + *-------------------------------------------------------------- + */ + static void -InvalidateDItemY(DItem *dItem, int itemY, int dirtyY, int dirtyHeight) +InvalidateDItemY( + DItem *dItem, /* Item to mark dirty. */ + int itemY, /* y-coordinate of item. */ + int dirtyY, /* Top edge of area to mark as dirty. */ + int dirtyHeight /* Height of area to mark as dirty. */ + ) { int y1, y2; @@ -2021,8 +2781,28 @@ InvalidateDItemY(DItem *dItem, int itemY, int dirtyY, int dirtyHeight) } } -void -Range_RedoIfNeeded(TreeCtrl *tree) +/* + *-------------------------------------------------------------- + * + * Range_RedoIfNeeded -- + * + * Recalculate the list of Ranges if they are marked out-of-date. + * Also calculate the height and width of the canvas based on the + * list of Ranges. + * + * Results: + * None. + * + * Side effects: + * Memory may be allocated. + * + *-------------------------------------------------------------- + */ + +static void +Range_RedoIfNeeded( + TreeCtrl *tree /* Widget info. */ + ) { DInfo *dInfo = (DInfo *) tree->dInfo; @@ -2040,8 +2820,29 @@ Range_RedoIfNeeded(TreeCtrl *tree) } } +/* + *-------------------------------------------------------------- + * + * ScrollVerticalComplex -- + * + * Perform scrolling by copying the pixels of items from the + * previous display position to the current position. Any areas + * of items copied over by the moved items are marked dirty. + * + * Results: + * The number of items whose pixels were copied. + * + * Side effects: + * Pixels are copied in the TreeCtrl window or in the + * offscreen pixmap (if double-buffering is used). + * + *-------------------------------------------------------------- + */ + static int -ScrollVerticalComplex(TreeCtrl *tree) +ScrollVerticalComplex( + TreeCtrl *tree /* Widget info. */ + ) { DInfo *dInfo = (DInfo *) tree->dInfo; DItem *dItem, *dItem2; @@ -2182,8 +2983,28 @@ ScrollVerticalComplex(TreeCtrl *tree) return numCopy; } +/* + *-------------------------------------------------------------- + * + * ScrollHorizontalSimple -- + * + * Perform scrolling by shifting the pixels in the content area of + * the list to the left or right. + * + * Results: + * None. + * + * Side effects: + * Stuff is copied/scrolled in the TreeCtrl window or in the + * offscreen pixmap (if double-buffering is used). + * + *-------------------------------------------------------------- + */ + static void -ScrollHorizontalSimple(TreeCtrl *tree) +ScrollHorizontalSimple( + TreeCtrl *tree /* Widget info. */ + ) { DInfo *dInfo = (DInfo *) tree->dInfo; DItem *dItem; @@ -2274,8 +3095,28 @@ ScrollHorizontalSimple(TreeCtrl *tree) } } +/* + *-------------------------------------------------------------- + * + * ScrollVerticalSimple -- + * + * Perform scrolling by shifting the pixels in the content area of + * the list up or down. + * + * Results: + * None. + * + * Side effects: + * Stuff is copied/scrolled in the TreeCtrl window or in the + * offscreen pixmap (if double-buffering is used). + * + *-------------------------------------------------------------- + */ + static void -ScrollVerticalSimple(TreeCtrl *tree) +ScrollVerticalSimple( + TreeCtrl *tree /* Widget info. */ + ) { DInfo *dInfo = (DInfo *) tree->dInfo; DItem *dItem; @@ -2366,8 +3207,29 @@ ScrollVerticalSimple(TreeCtrl *tree) } } +/* + *-------------------------------------------------------------- + * + * ScrollHorizontalComplex -- + * + * Perform scrolling by copying the pixels of items from the + * previous display position to the current position. Any areas + * of items copied over by the moved items are marked dirty. + * + * Results: + * The number of items whose pixels were copied. + * + * Side effects: + * Pixels are copied in the TreeCtrl window or in the + * offscreen pixmap (if double-buffering is used). + * + *-------------------------------------------------------------- + */ + static int -ScrollHorizontalComplex(TreeCtrl *tree) +ScrollHorizontalComplex( + TreeCtrl *tree /* Widget info. */ + ) { DInfo *dInfo = (DInfo *) tree->dInfo; DItem *dItem, *dItem2; @@ -2508,8 +3370,28 @@ ScrollHorizontalComplex(TreeCtrl *tree) return numCopy; } +/* + *-------------------------------------------------------------- + * + * TreeColumnProxy_Draw -- + * + * Draw (or erase) the visual indicator used when the user is + * resizing a column (and -columnresizemode is "proxy"). + * + * Results: + * None. + * + * Side effects: + * Stuff is drawn in the TreeCtrl window (or erased, since this + * is XOR drawing). + * + *-------------------------------------------------------------- + */ + void -TreeColumnProxy_Draw(TreeCtrl *tree) +TreeColumnProxy_Draw( + TreeCtrl *tree /* Widget info. */ + ) { #if defined(MAC_OSX_TK) DrawXORLine(tree->display, Tk_WindowId(tree->tkwin), @@ -2550,8 +3432,27 @@ TreeColumnProxy_Draw(TreeCtrl *tree) #endif } +/* + *-------------------------------------------------------------- + * + * TreeColumnProxy_Undisplay -- + * + * Hide the visual indicator used when the user is + * resizing a column (if it is displayed). + * + * Results: + * None. + * + * Side effects: + * Stuff is erased in the TreeCtrl window. + * + *-------------------------------------------------------------- + */ + void -TreeColumnProxy_Undisplay(TreeCtrl *tree) +TreeColumnProxy_Undisplay( + TreeCtrl *tree /* Widget info. */ + ) { if (tree->columnProxy.onScreen) { TreeColumnProxy_Draw(tree); @@ -2559,8 +3460,28 @@ TreeColumnProxy_Undisplay(TreeCtrl *tree) } } +/* + *-------------------------------------------------------------- + * + * TreeColumnProxy_Display -- + * + * Display the visual indicator used when the user is + * resizing a column (if it isn't displayed and should be + * displayed). + * + * Results: + * None. + * + * Side effects: + * Stuff is drawn in the TreeCtrl window. + * + *-------------------------------------------------------------- + */ + void -TreeColumnProxy_Display(TreeCtrl *tree) +TreeColumnProxy_Display( + TreeCtrl *tree /* Widget info. */ + ) { if (!tree->columnProxy.onScreen && (tree->columnProxy.xObj != NULL)) { tree->columnProxy.sx = tree->columnProxy.x; @@ -2569,8 +3490,28 @@ TreeColumnProxy_Display(TreeCtrl *tree) } } +/* + *-------------------------------------------------------------- + * + * CalcWhiteSpaceRegion -- + * + * Create a new region containing all the whitespace of the list + * The whitespace is the area inside the borders/header where items + * are not displayed. + * + * Results: + * The new whitespace region, which may be empty. + * + * Side effects: + * A new region is allocated. + * + *-------------------------------------------------------------- + */ + static TkRegion -CalcWhiteSpaceRegion(TreeCtrl *tree) +CalcWhiteSpaceRegion( + TreeCtrl *tree /* Widget info. */ + ) { DInfo *dInfo = (DInfo *) tree->dInfo; int x, y, minX, minY, maxX, maxY; @@ -2654,20 +3595,28 @@ CalcWhiteSpaceRegion(TreeCtrl *tree) * * Tree_DrawTiledImage -- * - * This procedure draws a tiled image in the indicated box. + * This procedure draws a tiled image in the indicated box. * * Results: - * None. + * None. * * Side effects: - * None. + * Stuff is drawn. * *---------------------------------------------------------------------- */ void -Tree_DrawTiledImage(TreeCtrl *tree, Drawable drawable, Tk_Image image, - int x1, int y1, int x2, int y2, int xOffset, int yOffset) +Tree_DrawTiledImage( + TreeCtrl *tree, /* Widget info. */ + Drawable drawable, /* Where to draw. */ + Tk_Image image, /* The image to draw. */ + int x1, int y1, /* Left & top of area to fill with the image. */ + int x2, int y2, /* Right & bottom, of area to fill with the + * image. */ + int xOffset, int yOffset /* Used to keep the image aligned with an + * origin. */ + ) { int imgWidth, imgHeight; int srcX, srcY; @@ -2703,8 +3652,28 @@ Tree_DrawTiledImage(TreeCtrl *tree, Drawable drawable, Tk_Image image, }; } +/* + *-------------------------------------------------------------- + * + * Tree_Display -- + * + * This procedure is called at idle time when something has happened + * that might require the list to be redisplayed. An effort is made + * to only redraw what is needed. + * + * Results: + * None. + * + * Side effects: + * Stuff is drawn in the TreeCtrl window. + * + *-------------------------------------------------------------- + */ + void -Tree_Display(ClientData clientData) +Tree_Display( + ClientData clientData /* Widget info. */ + ) { TreeCtrl *tree = (TreeCtrl *) clientData; DInfo *dInfo = (DInfo *) tree->dInfo; @@ -3235,8 +4204,28 @@ Tree_Display(ClientData clientData) } } +/* + *-------------------------------------------------------------- + * + * A_IncrementFindX -- + * + * Return a horizontal scroll position nearest to the given + * offset. + * + * Results: + * Index of the nearest increment <= the given offset. + * + * Side effects: + * None. + * + *-------------------------------------------------------------- + */ + static int -A_IncrementFindX(TreeCtrl *tree, int offset) +A_IncrementFindX( + TreeCtrl *tree, /* Widget info. */ + int offset /* Canvas x-coordinate. */ + ) { int totWidth = Tree_TotalWidth(tree); int xIncr = tree->xScrollIncrement; @@ -3253,8 +4242,28 @@ A_IncrementFindX(TreeCtrl *tree, int offset) return index; } +/* + *-------------------------------------------------------------- + * + * A_IncrementFindY -- + * + * Return a vertical scroll position nearest to the given + * offset. + * + * Results: + * Index of the nearest increment <= the given offset. + * + * Side effects: + * None. + * + *-------------------------------------------------------------- + */ + static int -A_IncrementFindY(TreeCtrl *tree, int offset) +A_IncrementFindY( + TreeCtrl *tree, /* Widget info. */ + int offset /* Canvas y-coordinate. */ + ) { int totHeight = Tree_TotalHeight(tree); int yIncr = tree->yScrollIncrement; @@ -3271,8 +4280,28 @@ A_IncrementFindY(TreeCtrl *tree, int offset) return index; } +/* + *-------------------------------------------------------------- + * + * Increment_FindX -- + * + * Return a horizontal scroll position nearest to the given + * offset. + * + * Results: + * Index of the nearest increment <= the given offset. + * + * Side effects: + * None. + * + *-------------------------------------------------------------- + */ + int -Increment_FindX(TreeCtrl *tree, int offset) +Increment_FindX( + TreeCtrl *tree, /* Widget info. */ + int offset /* Canvas x-coordinate. */ + ) { if (tree->xScrollIncrement <= 0) { Increment_RedoIfNeeded(tree); @@ -3281,8 +4310,28 @@ Increment_FindX(TreeCtrl *tree, int offset) return A_IncrementFindX(tree, offset); } +/* + *-------------------------------------------------------------- + * + * Increment_FindY -- + * + * Return a vertical scroll position nearest to the given + * offset. + * + * Results: + * Index of the nearest increment <= the given offset. + * + * Side effects: + * None. + * + *-------------------------------------------------------------- + */ + int -Increment_FindY(TreeCtrl *tree, int offset) +Increment_FindY( + TreeCtrl *tree, /* Widget info. */ + int offset /* Canvas y-coordinate. */ + ) { if (tree->yScrollIncrement <= 0) { Increment_RedoIfNeeded(tree); @@ -3291,8 +4340,27 @@ Increment_FindY(TreeCtrl *tree, int offset) return A_IncrementFindY(tree, offset); } +/* + *-------------------------------------------------------------- + * + * Increment_ToOffsetX -- + * + * Return the canvas coordinate for a scroll position. + * + * Results: + * Pixel distance. + * + * Side effects: + * None. + * + *-------------------------------------------------------------- + */ + int -Increment_ToOffsetX(TreeCtrl *tree, int index) +Increment_ToOffsetX( + TreeCtrl *tree, /* Widget info. */ + int index /* Index of the increment. */ + ) { DInfo *dInfo = (DInfo *) tree->dInfo; @@ -3305,8 +4373,27 @@ Increment_ToOffsetX(TreeCtrl *tree, int index) return index * tree->xScrollIncrement; } +/* + *-------------------------------------------------------------- + * + * Increment_ToOffsetY -- + * + * Return the canvas coordinate for a scroll position. + * + * Results: + * Pixel distance. + * + * Side effects: + * None. + * + *-------------------------------------------------------------- + */ + int -Increment_ToOffsetY(TreeCtrl *tree, int index) +Increment_ToOffsetY( + TreeCtrl *tree, /* Widget info. */ + int index /* Index of the increment. */ + ) { DInfo *dInfo = (DInfo *) tree->dInfo; @@ -3321,9 +4408,32 @@ Increment_ToOffsetY(TreeCtrl *tree, int index) return index * tree->yScrollIncrement; } +/* + *-------------------------------------------------------------- + * + * GetScrollFractions -- + * + * Return the fractions that may be passed to a scrollbar "set" + * command. + * + * Results: + * Two fractions from 0.0 to 1.0. + * + * Side effects: + * None. + * + *-------------------------------------------------------------- + */ + static void -GetScrollFractions(int screen1, int screen2, int object1, - int object2, double fractions[2]) +GetScrollFractions( + int screen1, int screen2, /* Min/max coordinates that are visible in + * the window. */ + int object1, int object2, /* Min/max coordinates of the scrollable + * content (usually 0 to N where N is the + * total width or height of the canvas). */ + double fractions[2] /* Returned values. */ + ) { double range, f1, f2; @@ -3347,8 +4457,28 @@ GetScrollFractions(int screen1, int screen2, int object1, fractions[1] = f2; } +/* + *-------------------------------------------------------------- + * + * Tree_GetScrollFractionsX -- + * + * Return the fractions that may be passed to a scrollbar "set" + * command for a horizontal scrollbar. + * + * Results: + * Two fractions from 0 to 1.0. + * + * Side effects: + * None. + * + *-------------------------------------------------------------- + */ + void -Tree_GetScrollFractionsX(TreeCtrl *tree, double fractions[2]) +Tree_GetScrollFractionsX( + TreeCtrl *tree, /* Widget info. */ + double fractions[2] /* Returned values. */ + ) { int left = tree->xOrigin + tree->inset; int visWidth = Tk_Width(tree->tkwin) - tree->inset * 2; @@ -3384,8 +4514,28 @@ Tree_GetScrollFractionsX(TreeCtrl *tree, double fractions[2]) GetScrollFractions(left, left + visWidth, 0, totWidth, fractions); } +/* + *-------------------------------------------------------------- + * + * Tree_GetScrollFractionsY -- + * + * Return the fractions that may be passed to a scrollbar "set" + * command for a vertical scrollbar. + * + * Results: + * Two fractions from 0 to 1.0. + * + * Side effects: + * None. + * + *-------------------------------------------------------------- + */ + void -Tree_GetScrollFractionsY(TreeCtrl *tree, double fractions[2]) +Tree_GetScrollFractionsY( + TreeCtrl *tree, /* Widget info. */ + double fractions[2] /* Returned values. */ + ) { int topInset = tree->inset + Tree_HeaderHeight(tree); int top = topInset + tree->yOrigin; /* canvas coords */ @@ -3422,8 +4572,31 @@ Tree_GetScrollFractionsY(TreeCtrl *tree, double fractions[2]) GetScrollFractions(top, top + visHeight, 0, totHeight, fractions); } +/* + *-------------------------------------------------------------- + * + * Tree_SetOriginX -- + * + * Change the horizontal scroll position. + * + * Results: + * None. + * + * Side effects: + * If the horizontal scroll position changes, then the widget is + * redisplayed at idle time. + * + *-------------------------------------------------------------- + */ + void -Tree_SetOriginX(TreeCtrl *tree, int xOrigin) +Tree_SetOriginX( + TreeCtrl *tree, /* Widget info. */ + int xOrigin /* The desired offset from the left edge + * of the window to the left edge of the + * canvas. The actual value will be clipped + * to the nearest scroll increment. */ + ) { DInfo *dInfo = (DInfo *) tree->dInfo; int totWidth = Tree_TotalWidth(tree); @@ -3482,8 +4655,31 @@ Tree_SetOriginX(TreeCtrl *tree, int xOrigin) Tree_EventuallyRedraw(tree); } +/* + *-------------------------------------------------------------- + * + * Tree_SetOriginY -- + * + * Change the vertical scroll position. + * + * Results: + * None. + * + * Side effects: + * If the vertical scroll position changes, then the widget is + * redisplayed at idle time. + * + *-------------------------------------------------------------- + */ + void -Tree_SetOriginY(TreeCtrl *tree, int yOrigin) +Tree_SetOriginY( + TreeCtrl *tree, /* Widget info. */ + int yOrigin /* The desired offset from the top edge + * of the window to the top edge of the + * canvas. The actual value will be clipped + * to the nearest scroll increment. */ + ) { DInfo *dInfo = (DInfo *) tree->dInfo; int topInset = tree->inset + Tree_HeaderHeight(tree); @@ -3542,8 +4738,28 @@ Tree_SetOriginY(TreeCtrl *tree, int yOrigin) Tree_EventuallyRedraw(tree); } +/* + *-------------------------------------------------------------- + * + * Tree_EventuallyRedraw -- + * + * Schedule an idle task to redisplay the widget, if one is not + * already scheduled and the widget is mapped and the widget + * hasn't been deleted. + * + * Results: + * None. + * + * Side effects: + * The widget may be redisplayed at idle time. + * + *-------------------------------------------------------------- + */ + void -Tree_EventuallyRedraw(TreeCtrl *tree) +Tree_EventuallyRedraw( + TreeCtrl *tree /* Widget info. */ + ) { DInfo *dInfo = (DInfo *) tree->dInfo; @@ -3556,8 +4772,28 @@ Tree_EventuallyRedraw(TreeCtrl *tree) Tcl_DoWhenIdle(Tree_Display, (ClientData) tree); } +/* + *-------------------------------------------------------------- + * + * Tree_RelayoutWindow -- + * + * Invalidate all the layout info for the widget and schedule a + * redisplay at idle time. This gets called when certain config + * options change and when the size of the widget changes. + * + * Results: + * None. + * + * Side effects: + * The widget will be redisplayed at idle time. + * + *-------------------------------------------------------------- + */ + void -Tree_RelayoutWindow(TreeCtrl *tree) +Tree_RelayoutWindow( + TreeCtrl *tree /* Widget info. */ + ) { DInfo *dInfo = (DInfo *) tree->dInfo; @@ -3608,8 +4844,32 @@ Tree_RelayoutWindow(TreeCtrl *tree) Tree_EventuallyRedraw(tree); } +/* + *-------------------------------------------------------------- + * + * Tree_FocusChanged -- + * + * This procedure handles the widget gaining or losing the input + * focus. The state of every item has STATE_FOCUS toggled on or + * off. + * + * Results: + * None. + * + * Side effects: + * The widget may be redisplayed at idle time if -highlightthickness + * is > 0, or if any Elements change appearance because of the + * state change. + * + *-------------------------------------------------------------- + */ + void -Tree_FocusChanged(TreeCtrl *tree, int gotFocus) +Tree_FocusChanged( + TreeCtrl *tree, /* Widget info. */ + int gotFocus /* TRUE if the widget has the focus, + * otherwise FALSE. */ + ) { DInfo *dInfo = (DInfo *) tree->dInfo; int redraw = FALSE; @@ -3641,8 +4901,31 @@ Tree_FocusChanged(TreeCtrl *tree, int gotFocus) Tree_EventuallyRedraw(tree); } +/* + *-------------------------------------------------------------- + * + * Tree_Activate -- + * + * This procedure handles the widget's toplevel being the "active" + * foreground window (on Macintosh and Windows). Currently it just + * redraws the header if -usetheme is TRUE and the header is + * visible. + * + * Results: + * None. + * + * Side effects: + * The widget may be redisplayed at idle time. + * + *-------------------------------------------------------------- + */ + void -Tree_Activate(TreeCtrl *tree, int isActive) +Tree_Activate( + TreeCtrl *tree, /* Widget info. */ + int isActive /* TRUE if the widget's toplevel is the + * active window, otherwise FALSE. */ + ) { DInfo *dInfo = (DInfo *) tree->dInfo; @@ -3660,8 +4943,30 @@ Tree_Activate(TreeCtrl *tree, int isActive) } } +/* + *-------------------------------------------------------------- + * + * Tree_FreeItemDInfo -- + * + * Free any DItem associated with each item in a range of items. + * This is called when the size of an item changed or an item is + * deleted. + * + * Results: + * None. + * + * Side effects: + * The widget will be redisplayed at idle time. + * + *-------------------------------------------------------------- + */ + void -Tree_FreeItemDInfo(TreeCtrl *tree, TreeItem item1, TreeItem item2) +Tree_FreeItemDInfo( + TreeCtrl *tree, /* Widget info. */ + TreeItem item1, /* First item in the range. */ + TreeItem item2 /* Last item in the range, or NULL. */ + ) { DInfo *dInfo = (DInfo *) tree->dInfo; DItem *dItem; @@ -3687,8 +4992,31 @@ Tree_FreeItemDInfo(TreeCtrl *tree, TreeItem item1, TreeItem item2) } } +/* + *-------------------------------------------------------------- + * + * Tree_InvalidateItemDInfo -- + * + * Mark as dirty any DItem associated with each item in a range + * of items. This is called when the appearance of an item changed + * (but not its size). + * + * Results: + * None. + * + * Side effects: + * The widget will be redisplayed at idle time if any of the items + * had a DItem. + * + *-------------------------------------------------------------- + */ + void -Tree_InvalidateItemDInfo(TreeCtrl *tree, TreeItem item1, TreeItem item2) +Tree_InvalidateItemDInfo( + TreeCtrl *tree, /* Widget info. */ + TreeItem item1, /* First item in the range. */ + TreeItem item2 /* Last item in the range, or NULL. */ + ) { /* DInfo *dInfo = (DInfo *) tree->dInfo; */ DItem *dItem; @@ -3711,8 +5039,27 @@ Tree_InvalidateItemDInfo(TreeCtrl *tree, TreeItem item1, TreeItem item2) } } +/* + *-------------------------------------------------------------- + * + * TreeDisplay_ItemDeleted -- + * + * Removes an item from the hash table of on-screen items. + * + * Results: + * None. + * + * Side effects: + * None. + * + *-------------------------------------------------------------- + */ + void -TreeDisplay_ItemDeleted(TreeCtrl *tree, TreeItem item) +TreeDisplay_ItemDeleted( + TreeCtrl *tree, /* Widget info. */ + TreeItem item /* Item to remove. */ + ) { DInfo *dInfo = (DInfo *) tree->dInfo; Tcl_HashEntry *hPtr; @@ -3723,8 +5070,27 @@ TreeDisplay_ItemDeleted(TreeCtrl *tree, TreeItem item) Tcl_DeleteHashEntry(hPtr); } +/* + *-------------------------------------------------------------- + * + * Tree_DInfoChanged -- + * + * Set some DINFO_xxx flags and schedule a redisplay. + * + * Results: + * None. + * + * Side effects: + * The widget will be redisplayed at idle time. + * + *-------------------------------------------------------------- + */ + void -Tree_DInfoChanged(TreeCtrl *tree, int flags) +Tree_DInfoChanged( + TreeCtrl *tree, /* Widget info. */ + int flags /* DINFO_xxx flags. */ + ) { DInfo *dInfo = (DInfo *) tree->dInfo; @@ -3732,8 +5098,32 @@ Tree_DInfoChanged(TreeCtrl *tree, int flags) Tree_EventuallyRedraw(tree); } +/* + *-------------------------------------------------------------- + * + * Tree_InvalidateArea -- + * + * Mark as dirty parts of any DItems in the given area. If the given + * area overlaps the borders they are marked as needing to be + * redrawn. + * + * Results: + * None. + * + * Side effects: + * None. + * + *-------------------------------------------------------------- + */ + void -Tree_InvalidateArea(TreeCtrl *tree, int x1, int y1, int x2, int y2) +Tree_InvalidateArea( + TreeCtrl *tree, /* Widget info. */ + int x1, int y1, /* Left & top of dirty area in window + * coordinates. */ + int x2, int y2 /* Right & bottom of dirty area in window + * coordinates. */ + ) { DInfo *dInfo = (DInfo *) tree->dInfo; DItem *dItem; @@ -3776,18 +5166,67 @@ Tree_InvalidateArea(TreeCtrl *tree, int x1, int y1, int x2, int y2) } } +/* + *-------------------------------------------------------------- + * + * Tree_InvalidateRegion -- + * + * Mark as dirty parts of any DItems in the given area. If the given + * area overlaps the borders they are marked as needing to be + * redrawn. + * + * Results: + * None. + * + * Side effects: + * None. + * + *-------------------------------------------------------------- + */ + void -Tree_InvalidateRegion(TreeCtrl *tree, TkRegion region) +Tree_InvalidateRegion( + TreeCtrl *tree, /* Widget info. */ + TkRegion region /* Region to mark as dirty, in window + * coordinates. */ + ) { XRectangle rect; + /* FIXME: It would be more efficient in some cases to only mark as dirty + * those items that overlap the given region, in case the region + * contains multiple disjoint rectangles. */ TkClipBox(region, &rect); Tree_InvalidateArea(tree, rect.x, rect.y, rect.x + rect.width, rect.y + rect.height); } +/* + *-------------------------------------------------------------- + * + * Tree_InvalidateItemArea -- + * + * Mark as dirty parts of any DItems in the given area. This is + * like Tree_InvalidateArea() but the given area is clipped inside + * the borders/header. + * + * Results: + * None. + * + * Side effects: + * None. + * + *-------------------------------------------------------------- + */ + void -Tree_InvalidateItemArea(TreeCtrl *tree, int x1, int y1, int x2, int y2) +Tree_InvalidateItemArea( + TreeCtrl *tree, /* Widget info. */ + int x1, int y1, /* Left & top of dirty area in window + * coordinates. */ + int x2, int y2 /* Right & bottom of dirty area in window + * coordinates. */ + ) { if (x1 < tree->inset) x1 = tree->inset; @@ -3800,16 +5239,33 @@ Tree_InvalidateItemArea(TreeCtrl *tree, int x1, int y1, int x2, int y2) Tree_InvalidateArea(tree, x1, y1, x2, y2); } -void -Tree_InvalidateWindow(TreeCtrl *tree) -{ - Tree_InvalidateArea(tree, 0, 0, - Tk_Width(tree->tkwin), - Tk_Height(tree->tkwin)); -} +/* + *-------------------------------------------------------------- + * + * Tree_RedrawArea -- + * + * Mark as dirty parts of any DItems in the given area. If the given + * area overlaps the borders they are marked as needing to be + * redrawn. The given area is subtracted from the whitespace region + * so that that part of the whitespace region will be redrawn. + * + * Results: + * None. + * + * Side effects: + * The widget will be redisplayed at idle time. + * + *-------------------------------------------------------------- + */ void -Tree_RedrawArea(TreeCtrl *tree, int x1, int y1, int x2, int y2) +Tree_RedrawArea( + TreeCtrl *tree, /* Widget info. */ + int x1, int y1, /* Left & top of dirty area in window + * coordinates. */ + int x2, int y2 /* Right & bottom of dirty area in window + * coordinates. */ + ) { DInfo *dInfo = (DInfo *) tree->dInfo; @@ -3830,15 +5286,27 @@ Tree_RedrawArea(TreeCtrl *tree, int x1, int y1, int x2, int y2) Tree_EventuallyRedraw(tree); } -void -Tree_RedrawItemArea(TreeCtrl *tree, int x1, int y1, int x2, int y2) -{ - Tree_InvalidateItemArea(tree, x1, y1, x2, y2); - Tree_EventuallyRedraw(tree); -} +/* + *-------------------------------------------------------------- + * + * TreeDInfo_Init -- + * + * Perform display-related initialization when a new TreeCtrl is + * created. + * + * Results: + * None. + * + * Side effects: + * Memory is allocated. + * + *-------------------------------------------------------------- + */ void -TreeDInfo_Init(TreeCtrl *tree) +TreeDInfo_Init( + TreeCtrl *tree /* Widget info. */ + ) { DInfo *dInfo; XGCValues gcValues; @@ -3855,8 +5323,26 @@ TreeDInfo_Init(TreeCtrl *tree) tree->dInfo = (TreeDInfo) dInfo; } +/* + *-------------------------------------------------------------- + * + * TreeDInfo_Free -- + * + * Free display-related resources for a deleted TreeCtrl. + * + * Results: + * None. + * + * Side effects: + * Memory is allocated. + * + *-------------------------------------------------------------- + */ + void -TreeDInfo_Free(TreeCtrl *tree) +TreeDInfo_Free( + TreeCtrl *tree /* Widget info. */ + ) { DInfo *dInfo = (DInfo *) tree->dInfo; Range *range = dInfo->rangeFirst; @@ -3890,7 +5376,9 @@ TreeDInfo_Free(TreeCtrl *tree) } void -DumpDInfo(TreeCtrl *tree) +DumpDInfo( + TreeCtrl *tree /* Widget info. */ + ) { DInfo *dInfo = (DInfo *) tree->dInfo; DItem *dItem; -- cgit v0.12