/*
* tkListbox.c --
*
* This module implements listbox widgets for the Tk
* toolkit. A listbox displays a collection of strings,
* one per line, and provides scrolling and selection.
*
* Copyright (c) 1990-1994 The Regents of the University of California.
* Copyright (c) 1994-1995 Sun Microsystems, Inc.
*
* See the file "license.terms" for information on usage and redistribution
* of this file, and for a DISCLAIMER OF ALL WARRANTIES.
*
* SCCS: @(#) tkListbox.c 1.109 96/05/17 16:26:55
*/
#include "tkInt.h"
#include "tkDefault.h"
/*
* One record of the following type is kept for each element
* associated with a listbox widget:
*/
typedef struct Element {
* origin to left edge of character. */
* left bearing and right bearing). */
* it isn't. */
* listbox, or NULL for last element. */
* terminated. The actual space allocated
* here will be as large as needed (> 4,
* most likely). Must be the last field
* of the record. */
} Element;
/*
* A data structure of the following type is kept for each listbox
* widget managed by this file:
*/
typedef struct {
* means that the window has been destroyed
* but the data structures haven't yet been
* cleaned up.*/
* other things, so that resources can be
* freed even after tkwin has gone away. */
* elements). */
* elements). */
/*
* Information used when displaying widget:
*/
* window, plus used for background. */
* around widget when it has the focus.
* <= 0 means don't draw a highlight. */
/* Color for drawing traversal highlight
* area when highlight is off. */
* traversal highlight and 3-D border.
* Indicates how much interior stuff must
* be offset from outside edges to leave
* room for borders. */
* elements. */
* in display. */
* window. */
* visible in window. There may be one
* additional line at the bottom that is
* partially visible. */
* fullLines lines. 1 means that there is
* one additional line that is partially
* visble. */
* to window manager. */
/*
* Information to support horizontal scrolling:
*/
* listbox. */
* horizontal scrolling (window scrolls
* horizontally in increments of this size).
* This is an average character size. */
* listbox is offset to the left by this
* many pixels (0 means no offset, positive
* means there is an offset). */
/*
* Information about what's selected or active, if any.
*/
* or extended. This value isn't used in C
* code, but the Tcl bindings use it. */
* at which selection was started.) */
* to X selection. */
* has been selected by keyboard traversal).
* -1 means none. */
/*
* Information for scanning:
*/
* button was pressed here). */
* button was pressed here). */
* started. */
* when scan started. */
/*
* Miscellaneous information:
*/
* the C code, but used by keyboard traversal
* scripts. Malloc'ed, but may be NULL. */
* vertical scrollbar. NULL means no command
* to issue. Malloc'ed. */
* horizontal scrollbar. NULL means no command
* to issue. Malloc'ed. */
* definitions. */
} Listbox;
/*
* Flag bits for listboxes:
*
* REDRAW_PENDING: Non-zero means a DoWhenIdle handler
* has already been queued to redraw
* this window.
* UPDATE_V_SCROLLBAR: Non-zero means vertical scrollbar needs
* to be updated.
* UPDATE_H_SCROLLBAR: Non-zero means horizontal scrollbar needs
* to be updated.
* GOT_FOCUS: Non-zero means this widget currently
* has the input focus.
*/
/*
* Information used for argv parsing:
*/
(char *) NULL, 0, 0},
(char *) NULL, 0, 0},
"ExportSelection", DEF_LISTBOX_EXPORT_SELECTION,
(char *) NULL, 0, 0},
"HighlightBackground", DEF_LISTBOX_HIGHLIGHT_BG,
"HighlightThickness",
(char *) NULL, 0, 0}
};
/*
* Forward declarations for procedures defined later in this file:
*/
int offset));
int index));
int flags));
int last));
int *indexPtr));
static void ListboxCmdDeletedProc _ANSI_ARGS_((
static int ListboxFetchSelection _ANSI_ARGS_((
int maxBytes));
static void ListboxLostSelection _ANSI_ARGS_((
int x, int y));
int y));
/*
*--------------------------------------------------------------
*
* Tk_ListboxCmd --
*
* This procedure is invoked to process the "listbox" Tcl
* command. See the user documentation for details on what
* it does.
*
* Results:
* A standard Tcl result.
*
* Side effects:
* See the user documentation.
*
*--------------------------------------------------------------
*/
int
* interpreter. */
int argc; /* Number of arguments. */
char **argv; /* Argument strings. */
{
if (argc < 2) {
return TCL_ERROR;
}
return TCL_ERROR;
}
/*
* Initialize the fields of the structure that won't be initialized
* by ConfigureListbox, or that ConfigureListbox requires to be
* initialized already (e.g. resource pointers).
*/
listPtr->numElements = 0;
listPtr->borderWidth = 0;
listPtr->highlightWidth = 0;
listPtr->selBorderWidth = 0;
listPtr->lineHeight = 0;
listPtr->partialLine = 0;
listPtr->xScrollUnit = 0;
listPtr->numSelected = 0;
listPtr->selectAnchor = 0;
listPtr->scanMarkXOffset = 0;
listPtr->scanMarkYIndex = 0;
goto error;
}
return TCL_OK;
return TCL_ERROR;
}
/*
*--------------------------------------------------------------
*
* ListboxWidgetCmd --
*
* 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
int argc; /* Number of arguments. */
char **argv; /* Argument strings. */
{
int c;
if (argc < 2) {
return TCL_ERROR;
}
c = argv[1][0];
int index;
if (argc != 3) {
argv[0], " activate index\"",
(char *) NULL);
goto error;
}
!= TCL_OK) {
goto error;
}
int index, x, y, i;
if (argc != 3) {
goto error;
}
goto error;
}
/* Empty loop body. */
}
+ listPtr->partialLine))) {
}
&& (length >= 2)) {
if (argc != 3) {
argv[0], " cget option\"",
(char *) NULL);
goto error;
}
&& (length >= 2)) {
if (argc == 2) {
} else if (argc == 3) {
} else {
}
&& (length >= 2)) {
int i, count;
if (argc != 2) {
argv[0], " curselection\"",
(char *) NULL);
goto error;
}
count = 0;
count++;
}
}
panic("ListboxWidgetCmd: selection count incorrect");
}
argv[0], " delete firstIndex ?lastIndex?\"",
(char *) NULL);
goto error;
}
goto error;
}
if (argc == 3) {
} else {
goto error;
}
}
goto error;
}
goto error;
}
goto error;
}
/* Empty loop body. */
}
if (argc == 3) {
} else {
}
}
}
&& (length >= 3)) {
int index;
if (argc != 3) {
argv[0], " index index\"",
(char *) NULL);
goto error;
}
!= TCL_OK) {
goto error;
}
&& (length >= 3)) {
int index;
if (argc < 3) {
argv[0], " insert index ?element element ...?\"",
(char *) NULL);
goto error;
}
!= TCL_OK) {
goto error;
}
int index, y;
if (argc != 3) {
goto error;
}
goto error;
}
int x, y;
if (argc != 5) {
goto error;
}
goto error;
}
ListboxScanTo(listPtr, x, y);
} else {
"\": must be mark or dragto", (char *) NULL);
goto error;
}
&& (length >= 3)) {
if (argc != 3) {
argv[0], " see index\"",
(char *) NULL);
goto error;
}
goto error;
}
if (diff > 0) {
} else {
}
} else {
if (diff > 0) {
} else {
}
}
}
argv[0], " selection option index ?index?\"",
(char *) NULL);
goto error;
}
goto error;
}
if (argc == 5) {
goto error;
}
} else {
}
c = argv[2][0];
if (argc != 4) {
goto error;
}
int i;
if (argc != 4) {
goto error;
}
/* Empty loop body. */
}
} else {
}
} else {
"\": must be anchor, clear, includes, or set",
(char *) NULL);
goto error;
}
if (argc != 2) {
goto error;
}
if (argc == 2) {
} else {
if (fraction2 > 1.0) {
fraction2 = 1.0;
}
}
} else if (argc == 3) {
goto error;
}
} else {
switch (type) {
case TK_SCROLL_ERROR:
goto error;
case TK_SCROLL_MOVETO:
break;
case TK_SCROLL_PAGES:
if (windowUnits > 2) {
} else {
}
break;
case TK_SCROLL_UNITS:
break;
}
}
if (argc == 2) {
if (listPtr->numElements == 0) {
} else {
/((double) listPtr->numElements);
if (fraction2 > 1.0) {
fraction2 = 1.0;
}
}
} else if (argc == 3) {
!= TCL_OK) {
goto error;
}
} else {
switch (type) {
case TK_SCROLL_ERROR:
goto error;
case TK_SCROLL_MOVETO:
break;
case TK_SCROLL_PAGES:
} else {
}
break;
case TK_SCROLL_UNITS:
break;
}
}
} else {
"\": must be activate, bbox, cget, configure, ",
"curselection, delete, get, index, insert, nearest, ",
"scan, see, selection, size, ",
"xview, or yview", (char *) NULL);
goto error;
}
return result;
return TCL_ERROR;
}
/*
*----------------------------------------------------------------------
*
* DestroyListbox --
*
* This procedure is invoked by Tcl_EventuallyFree or Tcl_Release
* to clean up the internal structure of a listbox at a safe time
* (when no-one is using it anymore).
*
* Results:
* None.
*
* Side effects:
* Everything associated with the listbox is freed up.
*
*----------------------------------------------------------------------
*/
static void
char *memPtr; /* Info about listbox widget. */
{
/*
* Free up all of the list elements.
*/
}
/*
* Free up all the stuff that requires special handling, then
* let Tk_FreeOptions handle all the standard option-related
* stuff.
*/
}
}
}
/*
*----------------------------------------------------------------------
*
* ConfigureListbox --
*
* the Tk option database, in order to configure (or reconfigure)
* a listbox 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 listPtr; old resources get freed,
* if there were any.
*
*----------------------------------------------------------------------
*/
static int
* not already have values for some fields. */
int argc; /* Number of valid entries in argv. */
char **argv; /* Arguments. */
int flags; /* Flags to pass to Tk_ConfigureWidget. */
{
int oldExport;
return TCL_ERROR;
}
/*
* A few options need special processing, such as setting the
* background from a 3-D border.
*/
if (listPtr->highlightWidth < 0) {
listPtr->highlightWidth = 0;
}
&gcValues);
}
}
/*
* Claim the selection if we've suddenly started exporting it and
* there is a selection to export.
*/
&& (listPtr->numSelected != 0)) {
(ClientData) listPtr);
}
/*
* Register the desired geometry for the window and arrange for
* the window to be redisplayed.
*/
return TCL_OK;
}
/*
*--------------------------------------------------------------
*
* DisplayListbox --
*
* This procedure redraws the contents of a listbox window.
*
* Results:
* None.
*
* Side effects:
* Information appears on the screen.
*
*--------------------------------------------------------------
*/
static void
{
* that the left or right edge of
* the listbox is off-screen. */
}
}
return;
}
/*
* Redrawing is done in a temporary pixmap that is allocated
* here and freed at the end of the procedure. All drawing is
* done to the pixmap, and the pixmap is copied to the screen
* at the end of the procedure. This provides the smoothest
* possible visual effects (no flashing on the screen).
*/
/*
* Iterate through all of the elements of the listbox, displaying each
* in turn. Selected elements use a different GC and have a raised
* background.
*/
}
}
}
prevSelected = 0;
continue;
}
/*
* Draw beveled edges around the selection, if there are visible
* edges next to this element. Special considerations:
* 1. The left and right bevels may not be visible if horizontal
* scrolling is enabled (the "left" and "right" variables
* are zero to indicate that the corresponding bevel is
* visible).
* 2. Top and bottom bevels are only drawn if this is the
* first or last seleted item.
* 3. If the left or right bevel isn't visible, then the "left"
* and "right" variables, computed above, have non-zero values
* that extend the top and bottom bevels so that the mitered
* corners are off-screen.
*/
if (left == 0) {
1, TK_RELIEF_RAISED);
}
if (right == 0) {
0, TK_RELIEF_RAISED);
}
if (!prevSelected) {
}
}
}
/*
* If this is the active element, underline it.
*/
}
}
/*
* Redraw the border for the listbox to make sure that it's on top
* of any of the text of the listbox entries.
*/
if (listPtr->highlightWidth > 0) {
} else {
}
}
}
/*
*----------------------------------------------------------------------
*
* ListboxComputeGeometry --
*
* This procedure is invoked to recompute geometry information
* such as the sizes of the elements and the overall dimensions
* desired for the listbox.
*
* Results:
* None.
*
* Side effects:
* Geometry information is updated and a new requested size is
* registered for the widget. Internal border and gridding
* information is also set.
*
*----------------------------------------------------------------------
*/
static void
* recomputed. */
int fontChanged; /* Non-zero means the font may have changed
* so per-element width information also
* has to be computed. */
int maxIsStale; /* Non-zero means the "maxWidth" field may
* no longer be up-to-date and must
* be recomputed. If fontChanged is 1 then
* this must be 1. */
int updateGrid; /* Non-zero means call Tk_SetGrid or
* Tk_UnsetGrid to update gridding for
* the window. */
{
if (fontChanged || maxIsStale) {
if (fontChanged) {
}
}
}
}
if (width <= 0) {
if (width < 1) {
width = 1;
}
}
if (height < 1) {
height = 1;
}
}
if (updateGrid) {
} else {
}
}
}
/*
*----------------------------------------------------------------------
*
* InsertEls --
*
* Add new elements to a listbox widget.
*
* Results:
* None.
*
* Side effects:
* New information gets added to listPtr; it will be redisplayed
* soon, but not immediately.
*
*----------------------------------------------------------------------
*/
static void
* elements. */
int index; /* Add the new elements before this
* element. */
int argc; /* Number of new elements to add. */
char **argv; /* New elements (one per entry). */
{
/*
* Find the element before which the new ones will be inserted.
*/
if (index <= 0) {
index = 0;
}
}
if (index == 0) {
} else {
}
}
/*
* For each new element, create a record, initialize it, and link
* it into the list of elements.
*/
}
} else {
}
}
}
/*
* Update the selection and other indexes to account for the
* renumbering that has just occurred. Then arrange for the new
* information to be displayed.
*/
}
}
&& (listPtr->numElements > 0)) {
}
}
}
ListboxComputeGeometry(listPtr, 0, 0, 0);
}
/*
*----------------------------------------------------------------------
*
* DeleteEls --
*
* Remove one or more elements from a listbox widget.
*
* Results:
* None.
*
* Side effects:
* Memory gets freed, the listbox gets modified and (eventually)
* redisplayed.
*
*----------------------------------------------------------------------
*/
static void
int first; /* Index of first element to delete. */
int last; /* Index of last element to delete. */
{
/*
* Adjust the range to fit within the existing elements of the
* listbox, and make sure there's something to delete.
*/
if (first < 0) {
first = 0;
}
}
if (count <= 0) {
return;
}
/*
* Find the element just before the ones to delete.
*/
if (first == 0) {
} else {
}
}
/*
* Delete the requested number of elements.
*/
widthChanged = 0;
for (i = count; i > 0; i--) {
}
} else {
}
}
widthChanged = 1;
}
}
}
/*
* Update the selection and viewing information to reflect the change
* in the element numbering, and redisplay to slide information up over
* the elements that were deleted.
*/
}
}
}
}
}
}
&& (listPtr->numElements > 0)) {
}
}
if (widthChanged) {
}
}
/*
*--------------------------------------------------------------
*
* ListboxEventProc --
*
* This procedure is invoked by the Tk dispatcher for various
* events on listboxes.
*
* Results:
* None.
*
* Side effects:
* When the window gets deleted, internal structures get
* cleaned up. When it gets exposed, it is redisplayed.
*
*--------------------------------------------------------------
*/
static void
{
}
}
}
int vertSpace;
} else {
listPtr->partialLine = 0;
}
/*
* Redraw the whole listbox. It's hard to tell what needs
* to be redrawn (e.g. if the listbox has shrunk then we
* may only need to redraw the borders), so just redraw
* everything for safety.
*/
}
}
}
}
/*
*----------------------------------------------------------------------
*
* ListboxCmdDeletedProc --
*
* 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
{
/*
* 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.
*/
}
}
}
/*
*--------------------------------------------------------------
*
* GetListboxIndex --
*
* Parse an index into a listbox and return either its value
* or an error.
*
* Results:
* A standard Tcl result. If all went well, then *indexPtr is
* filled in with the index (into listPtr) corresponding to
* string. Otherwise an error message is left in interp->result.
*
* Side effects:
* None.
*
*--------------------------------------------------------------
*/
static int
* specified. */
char *string; /* Specifies an element in the listbox. */
int numElsOK; /* 0 means the return value must be less
* less than the number of entries in
* the listbox; 1 means it may also be
* equal to the number of entries. */
int *indexPtr; /* Where to store converted index. */
{
int c;
c = string[0];
&& (length >= 2)) {
&& (length >= 2)) {
} else if (c == '@') {
int y;
char *p, *end;
p = string+1;
goto badIndex;
}
p = end+1;
goto badIndex;
}
} else {
goto badIndex;
}
}
if (numElsOK) {
}
}
if (*indexPtr < 0) {
*indexPtr = 0;
}
return TCL_OK;
"\": must be active, anchor, end, @x,y, or a number",
(char *) NULL);
return TCL_ERROR;
}
/*
*----------------------------------------------------------------------
*
* ChangeListboxView --
*
* Change the view on a listbox widget so that a given element
* is displayed at the top.
*
* Results:
* None.
*
* Side effects:
* What's displayed on the screen is changed. If there is a
* scrollbar associated with this widget, then the scrollbar
* is instructed to change its display too.
*
*----------------------------------------------------------------------
*/
static void
int index; /* Index of element in listPtr
* that should now appear at the
* top of the listbox. */
{
}
if (index < 0) {
index = 0;
}
}
}
}
/*
*----------------------------------------------------------------------
*
* ChangListboxOffset --
*
* Change the horizontal offset for a listbox.
*
* Results:
* None.
*
* Side effects:
* The listbox may be redrawn to reflect its new horizontal
* offset.
*
*----------------------------------------------------------------------
*/
static void
int offset; /* Desired new "xOffset" for
* listbox. */
{
int maxOffset;
/*
* Make sure that the new offset is within the allowable range, and
* round it off to an even multiple of xScrollUnit.
*/
}
if (offset < 0) {
offset = 0;
}
}
}
/*
*----------------------------------------------------------------------
*
* ListboxScanTo --
*
* Given a point (presumably of the curent mouse location)
* drag the view in the window to implement the scan operation.
*
* Results:
* None.
*
* Side effects:
* The view in the window may change.
*
*----------------------------------------------------------------------
*/
static void
int x; /* X-coordinate to use for scan
* operation. */
int y; /* Y-coordinate to use for scan
* operation. */
{
/*
* Compute new top line for screen by amplifying the difference
* between the current position and the place where the scan
* started (the "mark" position). If we run off the top or bottom
* of the list, then reset the mark point so that the current
* position continues to correspond to the edge of the window.
* This means that the picture will start dragging as soon as the
* mouse reverses direction (without this reset, might have to slide
* mouse a long ways back before the picture starts moving again).
*/
if (newTopIndex > maxIndex) {
} else if (newTopIndex < 0) {
}
/*
* Compute new left edge for display in a similar fashion by amplifying
* the difference between the current position and the place where the
* scan started.
*/
} else if (newOffset < 0) {
}
}
/*
*----------------------------------------------------------------------
*
* NearestListboxElement --
*
* Given a y-coordinate inside a listbox, compute the index of
* the element under that y-coordinate (or closest to that
* y-coordinate).
*
* Results:
* The return value is an index of an element of listPtr. If
* listPtr has no elements, then 0 is always returned.
*
* Side effects:
* None.
*
*----------------------------------------------------------------------
*/
static int
int y; /* Y-coordinate in listPtr's window. */
{
int index;
}
if (index < 0) {
index = 0;
}
}
return index;
}
/*
*----------------------------------------------------------------------
*
* ListboxSelect --
*
* Select or deselect one or more elements in a listbox..
*
* Results:
* None.
*
* Side effects:
* All of the elements in the range between first and last are
* marked as either selected or deselected, depending on the
* "select" argument. Any items whose state changes are redisplayed.
* The selection is claimed from X when the number of selected
* elements changes from zero to non-zero.
*
*----------------------------------------------------------------------
*/
static void
int first; /* Index of first element to
* select or deselect. */
int last; /* Index of last element to
* select or deselect. */
int select; /* 1 means select items, 0 means
* deselect them. */
{
i = first;
last = i;
}
return;
}
firstRedisplay = -1;
/* Empty loop body. */
}
continue;
}
if (firstRedisplay < 0) {
firstRedisplay = i;
}
}
if (firstRedisplay >= 0) {
}
&& (listPtr->exportSelection)) {
(ClientData) listPtr);
}
}
/*
*----------------------------------------------------------------------
*
* ListboxFetchSelection --
*
* This procedure is called back by Tk when the selection is
* requested by someone. It returns part or all of the selection
* in a buffer provided by the caller.
*
* Results:
* The return value is the number of non-NULL bytes stored
* at buffer. Buffer is filled (or partially filled) with a
* NULL-terminated string containing part or all of the selection,
* as given by offset and maxBytes. The selection is returned
* as a Tcl list with one list element for each element in the
* listbox.
*
* Side effects:
* None.
*
*----------------------------------------------------------------------
*/
static int
int offset; /* Offset within selection of first
* byte to be returned. */
char *buffer; /* Location in which to place
* selection. */
int maxBytes; /* Maximum number of bytes to place
* at buffer, not including terminating
* NULL character. */
{
if (!listPtr->exportSelection) {
return -1;
}
/*
* Use a dynamic string to accumulate the contents of the selection.
*/
needNewline = 0;
if (needNewline) {
}
needNewline = 1;
}
}
if (length == 0) {
return -1;
}
/*
* Copy the requested portion of the selection to the buffer.
*/
if (count <= 0) {
count = 0;
} else {
}
}
return count;
}
/*
*----------------------------------------------------------------------
*
* ListboxLostSelection --
*
* This procedure is called back by Tk when the selection is
* grabbed away from a listbox widget.
*
* Results:
* None.
*
* Side effects:
* The existing selection is unhighlighted, and the window is
* marked as not containing a selection.
*
*----------------------------------------------------------------------
*/
static void
{
}
}
/*
*----------------------------------------------------------------------
*
* ListboxRedrawRange --
*
* Ensure that a given range of elements is eventually redrawn on
* the display (if those elements in fact appear on the display).
*
* Results:
* None.
*
* Side effects:
* Information gets redisplayed.
*
*----------------------------------------------------------------------
*/
/* ARGSUSED */
static void
int first; /* Index of first element in list
* that needs to be redrawn. */
int last; /* Index of last element in list
* that needs to be redrawn. May
* be less than first;
* these just bracket a range. */
{
return;
}
}
/*
*----------------------------------------------------------------------
*
* ListboxUpdateVScrollbar --
*
* This procedure is invoked whenever information has changed in
* a listbox in a way that would invalidate a vertical scrollbar
* display. If there is an associated scrollbar, then this command
* updates it by invoking a Tcl command.
*
* Results:
* None.
*
* Side effects:
* A Tcl command is invoked, and an additional command may be
* invoked to process errors in the command.
*
*----------------------------------------------------------------------
*/
static void
{
int result;
return;
}
if (listPtr->numElements == 0) {
first = 0.0;
last = 1.0;
} else {
/((double) listPtr->numElements);
if (last > 1.0) {
last = 1.0;
}
}
/*
* We must hold onto the interpreter from the listPtr because the data
* at listPtr might be freed as a result of the Tcl_VarEval.
*/
(char *) NULL);
"\n (vertical scrolling command executed by listbox)");
}
}
/*
*----------------------------------------------------------------------
*
* ListboxUpdateHScrollbar --
*
* This procedure is invoked whenever information has changed in
* a listbox in a way that would invalidate a horizontal scrollbar
* display. If there is an associated horizontal scrollbar, then
* this command updates it by invoking a Tcl command.
*
* Results:
* None.
*
* Side effects:
* A Tcl command is invoked, and an additional command may be
* invoked to process errors in the command.
*
*----------------------------------------------------------------------
*/
static void
{
return;
}
+ listPtr->selBorderWidth);
first = 0;
last = 1.0;
} else {
if (last > 1.0) {
last = 1.0;
}
}
/*
* We must hold onto the interpreter because the data referred to at
* listPtr might be freed as a result of the call to Tcl_VarEval.
*/
(char *) NULL);
"\n (horizontal scrolling command executed by listbox)");
}
}