![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to tklist.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Micropolis - Activity] / micropolis / src / tk|
Return to tklist.c CVS log | Up to [Micropolis - Activity] / micropolis / src / tk |
1.1 root 1: /*
2: * tkListbox.c --
3: *
4: * This module implements listbox widgets for the Tk
5: * toolkit. A listbox displays a collection of strings,
6: * one per line, and provides scrolling and selection.
7: *
8: * Copyright 1990-1992 Regents of the University of California.
9: * Permission to use, copy, modify, and distribute this
10: * software and its documentation for any purpose and without
11: * fee is hereby granted, provided that the above copyright
12: * notice appear in all copies. The University of California
13: * makes no representations about the suitability of this
14: * software for any purpose. It is provided "as is" without
15: * express or implied warranty.
16: */
17:
18: #ifndef lint
19: static char rcsid[] = "$Header: /user6/ouster/wish/RCS/tkListbox.c,v 1.56 92/05/13 09:05:20 ouster Exp $ SPRITE (Berkeley)";
20: #endif
21:
22: #include "tkconfig.h"
23: #include "default.h"
24: #include "tkint.h"
25:
26: /*
27: * One record of the following type is kept for each element
28: * associated with a listbox widget:
29: */
30:
31: typedef struct Element {
32: int textLength; /* # non-NULL characters in text. */
33: int lBearing; /* Distance from first character's
34: * origin to left edge of character. */
35: int pixelWidth; /* Total width of element in pixels (including
36: * left bearing and right bearing). */
37: struct Element *nextPtr; /* Next in list of all elements of this
38: * listbox, or NULL for last element. */
39: char text[4]; /* Characters of this element, NULL-
40: * terminated. The actual space allocated
41: * here will be as large as needed (> 4,
42: * most likely). Must be the last field
43: * of the record. */
44: } Element;
45:
46: #define ElementSize(stringLength) \
47: ((unsigned) (sizeof(Element) - 3 + stringLength))
48:
49: /*
50: * A data structure of the following type is kept for each listbox
51: * widget managed by this file:
52: */
53:
54: typedef struct {
55: Tk_Window tkwin; /* Window that embodies the listbox. NULL
56: * means that the window has been destroyed
57: * but the data structures haven't yet been
58: * cleaned up.*/
59: Tcl_Interp *interp; /* Interpreter associated with listbox. */
60: int numElements; /* Total number of elements in this listbox. */
61: Element *elementPtr; /* First in list of elements (NULL if no
62: * elements. */
63:
64: /*
65: * Information used when displaying widget:
66: */
67:
68: Tk_3DBorder normalBorder; /* Used for drawing border around whole
69: * window, plus used for background. */
70: int borderWidth; /* Width of 3-D border around window. */
71: int relief; /* 3-D effect: TK_RELIEF_RAISED, etc. */
72: XFontStruct *fontPtr; /* Information about text font, or NULL. */
73: XColor *fgColorPtr; /* Text color in normal mode. */
74: GC textGC; /* For drawing normal text. */
75: Tk_3DBorder selBorder; /* Borders and backgrounds for selected
76: * elements. */
77: int selBorderWidth; /* Width of border around selection. */
78: XColor *selFgColorPtr; /* Foreground color for selected elements. */
79: GC selTextGC; /* For drawing selected text. */
80: char *geometry; /* Desired geometry for window. Malloc'ed. */
81: int lineHeight; /* Number of pixels allocated for each line
82: * in display. */
83: int topIndex; /* Index of top-most element visible in
84: * window. */
85: int numLines; /* Number of lines (elements) that fit
86: * in window at one time. */
87:
88: /*
89: * Information to support horizontal scrolling:
90: */
91:
92: int maxWidth; /* Width (in pixels) of widest string in
93: * listbox. */
94: int xScrollUnit; /* Number of pixels in one "unit" for
95: * horizontal scrolling (window scrolls
96: * horizontally in increments of this size).
97: * This is an average character size. */
98: int xOffset; /* The left edge of each string in the
99: * listbox is offset to the left by this
100: * many pixels (0 means no offset, positive
101: * means there is an offset). */
102:
103: /*
104: * Information about what's selected, if any.
105: */
106:
107: int selectFirst; /* Index of first selected element (-1 means
108: * nothing selected. */
109: int selectLast; /* Index of last selected element. */
110: int selectAnchor; /* Fixed end of selection (i.e. element
111: * at which selection was started.) */
112: int exportSelection; /* Non-zero means tie internal listbox
113: * to X selection. */
114:
115: /*
116: * Information for scanning:
117: */
118:
119: int scanMarkX; /* X-position at which scan started (e.g.
120: * button was pressed here). */
121: int scanMarkY; /* Y-position at which scan started (e.g.
122: * button was pressed here). */
123: int scanMarkXOffset; /* Value of "xOffset" field when scan
124: * started. */
125: int scanMarkYIndex; /* Index of line that was at top of window
126: * when scan started. */
127:
128: /*
129: * Miscellaneous information:
130: */
131:
132: Cursor cursor; /* Current cursor for window, or None. */
133: char *yScrollCmd; /* Command prefix for communicating with
134: * vertical scrollbar. NULL means no command
135: * to issue. Malloc'ed. */
136: char *xScrollCmd; /* Command prefix for communicating with
137: * horizontal scrollbar. NULL means no command
138: * to issue. Malloc'ed. */
139: int flags; /* Various flag bits: see below for
140: * definitions. */
141: } Listbox;
142:
143: /*
144: * Flag bits for buttons:
145: *
146: * REDRAW_PENDING: Non-zero means a DoWhenIdle handler
147: * has already been queued to redraw
148: * this window.
149: * UPDATE_V_SCROLLBAR: Non-zero means vertical scrollbar needs
150: * to be updated.
151: * UPDATE_H_SCROLLBAR: Non-zero means horizontal scrollbar needs
152: * to be updated.
153: */
154:
155: #define REDRAW_PENDING 1
156: #define UPDATE_V_SCROLLBAR 2
157: #define UPDATE_H_SCROLLBAR 4
158:
159: /*
160: * Information used for argv parsing:
161: */
162:
163: static Tk_ConfigSpec configSpecs[] = {
164: {TK_CONFIG_BORDER, "-background", "background", "Background",
165: DEF_LISTBOX_BG_COLOR, Tk_Offset(Listbox, normalBorder),
166: TK_CONFIG_COLOR_ONLY},
167: {TK_CONFIG_BORDER, "-background", "background", "Background",
168: DEF_LISTBOX_BG_MONO, Tk_Offset(Listbox, normalBorder),
169: TK_CONFIG_MONO_ONLY},
170: {TK_CONFIG_SYNONYM, "-bd", "borderWidth", (char *) NULL,
171: (char *) NULL, 0, 0},
172: {TK_CONFIG_SYNONYM, "-bg", "background", (char *) NULL,
173: (char *) NULL, 0, 0},
174: {TK_CONFIG_PIXELS, "-borderwidth", "borderWidth", "BorderWidth",
175: DEF_LISTBOX_BORDER_WIDTH, Tk_Offset(Listbox, borderWidth), 0},
176: {TK_CONFIG_ACTIVE_CURSOR, "-cursor", "cursor", "Cursor",
177: DEF_LISTBOX_CURSOR, Tk_Offset(Listbox, cursor), TK_CONFIG_NULL_OK},
178: {TK_CONFIG_BOOLEAN, "-exportselection", "exportSelection",
179: "ExportSelection", DEF_LISTBOX_EXPORT_SELECTION,
180: Tk_Offset(Listbox, exportSelection), 0},
181: {TK_CONFIG_SYNONYM, "-fg", "foreground", (char *) NULL,
182: (char *) NULL, 0, 0},
183: {TK_CONFIG_FONT, "-font", "font", "Font",
184: DEF_LISTBOX_FONT, Tk_Offset(Listbox, fontPtr), 0},
185: {TK_CONFIG_COLOR, "-foreground", "foreground", "Foreground",
186: DEF_LISTBOX_FG, Tk_Offset(Listbox, fgColorPtr), 0},
187: {TK_CONFIG_STRING, "-geometry", "geometry", "Geometry",
188: DEF_LISTBOX_GEOMETRY, Tk_Offset(Listbox, geometry), 0},
189: {TK_CONFIG_RELIEF, "-relief", "relief", "Relief",
190: DEF_LISTBOX_RELIEF, Tk_Offset(Listbox, relief), 0},
191: {TK_CONFIG_BORDER, "-selectbackground", "selectBackground", "Foreground",
192: DEF_LISTBOX_SELECT_COLOR, Tk_Offset(Listbox, selBorder),
193: TK_CONFIG_COLOR_ONLY},
194: {TK_CONFIG_BORDER, "-selectbackground", "selectBackground", "Foreground",
195: DEF_LISTBOX_SELECT_MONO, Tk_Offset(Listbox, selBorder),
196: TK_CONFIG_MONO_ONLY},
197: {TK_CONFIG_PIXELS, "-selectborderwidth", "selectBorderWidth", "BorderWidth",
198: DEF_LISTBOX_SELECT_BD, Tk_Offset(Listbox, selBorderWidth), 0},
199: {TK_CONFIG_COLOR, "-selectforeground", "selectForeground", "Background",
200: DEF_LISTBOX_SELECT_FG_COLOR, Tk_Offset(Listbox, selFgColorPtr),
201: TK_CONFIG_COLOR_ONLY},
202: {TK_CONFIG_COLOR, "-selectforeground", "selectForeground", "Background",
203: DEF_LISTBOX_SELECT_FG_MONO, Tk_Offset(Listbox, selFgColorPtr),
204: TK_CONFIG_MONO_ONLY},
205: {TK_CONFIG_STRING, "-xscrollcommand", "xScrollCommand", "ScrollCommand",
206: DEF_LISTBOX_SCROLL_COMMAND, Tk_Offset(Listbox, xScrollCmd), 0},
207: {TK_CONFIG_STRING, "-yscrollcommand", "yScrollCommand", "ScrollCommand",
208: DEF_LISTBOX_SCROLL_COMMAND, Tk_Offset(Listbox, yScrollCmd), 0},
209: {TK_CONFIG_END, (char *) NULL, (char *) NULL, (char *) NULL,
210: (char *) NULL, 0, 0}
211: };
212:
213: /*
214: * Forward declarations for procedures defined later in this file:
215: */
216:
217: static void ChangeListboxOffset _ANSI_ARGS_((Listbox *listPtr,
218: int offset));
219: static void ChangeListboxView _ANSI_ARGS_((Listbox *listPtr,
220: int index));
221: static int ConfigureListbox _ANSI_ARGS_((Tcl_Interp *interp,
222: Listbox *listPtr, int argc, char **argv,
223: int flags));
224: static void DeleteEls _ANSI_ARGS_((Listbox *listPtr, int first,
225: int last));
226: static void DestroyListbox _ANSI_ARGS_((ClientData clientData));
227: static void DisplayListbox _ANSI_ARGS_((ClientData clientData));
228: static int GetListboxIndex _ANSI_ARGS_((Tcl_Interp *interp,
229: Listbox *listPtr, char *string, int *indexPtr));
230: static void InsertEls _ANSI_ARGS_((Listbox *listPtr, int index,
231: int argc, char **argv));
232: static void ListboxComputeWidths _ANSI_ARGS_((Listbox *listPtr,
233: int fontChanged));
234: static void ListboxEventProc _ANSI_ARGS_((ClientData clientData,
235: XEvent *eventPtr));
236: static int ListboxFetchSelection _ANSI_ARGS_((
237: ClientData clientData, int offset, char *buffer,
238: int maxBytes));
239: static void ListboxLostSelection _ANSI_ARGS_((
240: ClientData clientData));
241: static void ListboxRedrawRange _ANSI_ARGS_((Listbox *listPtr,
242: int first, int last));
243: static void ListboxScanTo _ANSI_ARGS_((Listbox *listPtr,
244: int x, int y));
245: static void ListboxSelectFrom _ANSI_ARGS_((Listbox *listPtr,
246: int index));
247: static void ListboxSelectTo _ANSI_ARGS_((Listbox *listPtr,
248: int index));
249: static void ListboxUpdateHScrollbar _ANSI_ARGS_((Listbox *listPtr));
250: static void ListboxUpdateVScrollbar _ANSI_ARGS_((Listbox *listPtr));
251: static int ListboxWidgetCmd _ANSI_ARGS_((ClientData clientData,
252: Tcl_Interp *interp, int argc, char **argv));
253: static int NearestListboxElement _ANSI_ARGS_((Listbox *listPtr,
254: int y));
255:
256: /*
257: *--------------------------------------------------------------
258: *
259: * Tk_ListboxCmd --
260: *
261: * This procedure is invoked to process the "listbox" Tcl
262: * command. See the user documentation for details on what
263: * it does.
264: *
265: * Results:
266: * A standard Tcl result.
267: *
268: * Side effects:
269: * See the user documentation.
270: *
271: *--------------------------------------------------------------
272: */
273:
274: int
275: Tk_ListboxCmd(clientData, interp, argc, argv)
276: ClientData clientData; /* Main window associated with
277: * interpreter. */
278: Tcl_Interp *interp; /* Current interpreter. */
279: int argc; /* Number of arguments. */
280: char **argv; /* Argument strings. */
281: {
282: register Listbox *listPtr;
283: Tk_Window new;
284: Tk_Window tkwin = (Tk_Window) clientData;
285:
286: if (argc < 2) {
287: Tcl_AppendResult(interp, "wrong # args: should be \"",
288: argv[0], " pathName ?options?\"", (char *) NULL);
289: return TCL_ERROR;
290: }
291:
292: new = Tk_CreateWindowFromPath(interp, tkwin, argv[1], (char *) NULL);
293: if (new == NULL) {
294: return TCL_ERROR;
295: }
296:
297: /*
298: * Initialize the fields of the structure that won't be initialized
299: * by ConfigureListbox, or that ConfigureListbox requires to be
300: * initialized already (e.g. resource pointers).
301: */
302:
303: listPtr = (Listbox *) ckalloc(sizeof(Listbox));
304: listPtr->tkwin = new;
305: listPtr->interp = interp;
306: listPtr->numElements = 0;
307: listPtr->elementPtr = NULL;
308: listPtr->normalBorder = NULL;
309: listPtr->fontPtr = NULL;
310: listPtr->fgColorPtr = NULL;
311: listPtr->textGC = None;
312: listPtr->selBorder = NULL;
313: listPtr->selFgColorPtr = NULL;
314: listPtr->selTextGC = NULL;
315: listPtr->geometry = NULL;
316: listPtr->topIndex = 0;
317: listPtr->xOffset = 0;
318: listPtr->selectFirst = -1;
319: listPtr->selectLast = -1;
320: listPtr->exportSelection = 1;
321: listPtr->cursor = None;
322: listPtr->yScrollCmd = NULL;
323: listPtr->xScrollCmd = NULL;
324: listPtr->flags = 0;
325:
326: Tk_SetClass(listPtr->tkwin, "Listbox");
327: Tk_CreateEventHandler(listPtr->tkwin, ExposureMask|StructureNotifyMask,
328: ListboxEventProc, (ClientData) listPtr);
329: Tk_CreateSelHandler(listPtr->tkwin, XA_STRING, ListboxFetchSelection,
330: (ClientData) listPtr, XA_STRING);
331: Tcl_CreateCommand(interp, Tk_PathName(listPtr->tkwin), ListboxWidgetCmd,
332: (ClientData) listPtr, (void (*)()) NULL);
333: if (ConfigureListbox(interp, listPtr, argc-2, argv+2, 0) != TCL_OK) {
334: goto error;
335: }
336:
337: interp->result = Tk_PathName(listPtr->tkwin);
338: return TCL_OK;
339:
340: error:
341: Tk_DestroyWindow(listPtr->tkwin);
342: return TCL_ERROR;
343: }
344:
345: /*
346: *--------------------------------------------------------------
347: *
348: * ListboxWidgetCmd --
349: *
350: * This procedure is invoked to process the Tcl command
351: * that corresponds to a widget managed by this module.
352: * See the user documentation for details on what it does.
353: *
354: * Results:
355: * A standard Tcl result.
356: *
357: * Side effects:
358: * See the user documentation.
359: *
360: *--------------------------------------------------------------
361: */
362:
363: static int
364: ListboxWidgetCmd(clientData, interp, argc, argv)
365: ClientData clientData; /* Information about listbox widget. */
366: Tcl_Interp *interp; /* Current interpreter. */
367: int argc; /* Number of arguments. */
368: char **argv; /* Argument strings. */
369: {
370: register Listbox *listPtr = (Listbox *) clientData;
371: int result = TCL_OK;
372: int length;
373: char c;
374:
375: if (argc < 2) {
376: Tcl_AppendResult(interp, "wrong # args: should be \"",
377: argv[0], " option ?arg arg ...?\"", (char *) NULL);
378: return TCL_ERROR;
379: }
380: Tk_Preserve((ClientData) listPtr);
381: c = argv[1][0];
382: length = strlen(argv[1]);
383: if ((c == 'c') && (strncmp(argv[1], "configure", length) == 0)
384: && (length >= 2)) {
385: if (argc == 2) {
386: result = Tk_ConfigureInfo(interp, listPtr->tkwin, configSpecs,
387: (char *) listPtr, (char *) NULL, 0);
388: } else if (argc == 3) {
389: result = Tk_ConfigureInfo(interp, listPtr->tkwin, configSpecs,
390: (char *) listPtr, argv[2], 0);
391: } else {
392: result = ConfigureListbox(interp, listPtr, argc-2, argv+2,
393: TK_CONFIG_ARGV_ONLY);
394: }
395: } else if ((c == 'c') && (strncmp(argv[1], "curselection", length) == 0)
396: && (length >= 2)) {
397: int i;
398: char index[20];
399:
400: if (argc != 2) {
401: Tcl_AppendResult(interp, "wrong # args: should be \"",
402: argv[0], " curselection\"",
403: (char *) NULL);
404: goto error;
405: }
406: if (listPtr->selectFirst != -1) {
407: for (i = listPtr->selectFirst; i <= listPtr->selectLast; i++) {
408: sprintf(index, "%d", i);
409: Tcl_AppendElement(interp, index, 0);
410: }
411: }
412: } else if ((c == 'd') && (strncmp(argv[1], "delete", length) == 0)) {
413: int first, last;
414:
415: if ((argc < 3) || (argc > 4)) {
416: Tcl_AppendResult(interp, "wrong # args: should be \"",
417: argv[0], " delete firstIndex ?lastIndex?\"",
418: (char *) NULL);
419: goto error;
420: }
421: if (GetListboxIndex(interp, listPtr, argv[2], &first) != TCL_OK) {
422: goto error;
423: }
424: if (argc == 3) {
425: last = first;
426: } else {
427: if (GetListboxIndex(interp, listPtr, argv[3], &last) != TCL_OK) {
428: goto error;
429: }
430: }
431: DeleteEls(listPtr, first, last);
432: } else if ((c == 'g') && (strncmp(argv[1], "get", length) == 0)) {
433: int index;
434: register Element *elPtr;
435:
436: if (argc != 3) {
437: Tcl_AppendResult(interp, "wrong # args: should be \"",
438: argv[0], " get index\"", (char *) NULL);
439: goto error;
440: }
441: if (GetListboxIndex(interp, listPtr, argv[2], &index) != TCL_OK) {
442: goto error;
443: }
444: if (index < 0) {
445: index = 0;
446: }
447: if (index >= listPtr->numElements) {
448: index = listPtr->numElements-1;
449: }
450: for (elPtr = listPtr->elementPtr; index > 0;
451: index--, elPtr = elPtr->nextPtr) {
452: /* Empty loop body. */
453: }
454: if (elPtr != NULL) {
455: interp->result = elPtr->text;
456: }
457: } else if ((c == 'i') && (strncmp(argv[1], "insert", length) == 0)) {
458: int index;
459:
460: if (argc < 3) {
461: Tcl_AppendResult(interp, "wrong # args: should be \"",
462: argv[0], " insert index ?element? ?element ...?\"",
463: (char *) NULL);
464: goto error;
465: }
466: if (argc > 3) {
467: if (GetListboxIndex(interp, listPtr, argv[2], &index) != TCL_OK) {
468: goto error;
469: }
470: InsertEls(listPtr, index, argc-3, argv+3);
471: }
472: } else if ((c == 'n') && (strncmp(argv[1], "nearest", length) == 0)) {
473: int index, y;
474:
475: if (argc != 3) {
476: Tcl_AppendResult(interp, "wrong # args: should be \"",
477: argv[0], " nearest y\"", (char *) NULL);
478: goto error;
479: }
480: if (Tcl_GetInt(interp, argv[2], &y) != TCL_OK) {
481: goto error;
482: }
483: index = NearestListboxElement(listPtr, y);
484: sprintf(interp->result, "%d", index);
485: } else if ((c == 's') && (length >= 2)
486: && (strncmp(argv[1], "scan", length) == 0)) {
487: int x, y;
488:
489: if (argc != 5) {
490: Tcl_AppendResult(interp, "wrong # args: should be \"",
491: argv[0], " scan mark|dragto x y\"", (char *) NULL);
492: goto error;
493: }
494: if ((Tcl_GetInt(interp, argv[3], &x) != TCL_OK)
495: || (Tcl_GetInt(interp, argv[4], &y) != TCL_OK)) {
496: goto error;
497: }
498: if ((argv[2][0] == 'm')
499: && (strncmp(argv[2], "mark", strlen(argv[2])) == 0)) {
500: listPtr->scanMarkX = x;
501: listPtr->scanMarkY = y;
502: listPtr->scanMarkXOffset = listPtr->xOffset;
503: listPtr->scanMarkYIndex = listPtr->topIndex;
504: } else if ((argv[2][0] == 'd')
505: && (strncmp(argv[2], "dragto", strlen(argv[2])) == 0)) {
506: ListboxScanTo(listPtr, x, y);
507: } else {
508: Tcl_AppendResult(interp, "bad scan option \"", argv[2],
509: "\": must be mark or dragto", (char *) NULL);
510: goto error;
511: }
512: } else if ((c == 's') && (length >= 2)
513: && (strncmp(argv[1], "select", length) == 0)) {
514: int index;
515:
516: if (argc < 3) {
517: Tcl_AppendResult(interp, "too few args: should be \"",
518: argv[0], " select option ?index?\"", (char *) NULL);
519: goto error;
520: }
521: length = strlen(argv[2]);
522: c = argv[2][0];
523: if ((c == 'c') && (argv[2] != NULL)
524: && (strncmp(argv[2], "clear", length) == 0)) {
525: if (argc != 3) {
526: Tcl_AppendResult(interp, "wrong # args: should be \"",
527: argv[0], " select clear\"", (char *) NULL);
528: goto error;
529: }
530: if (listPtr->selectFirst != -1) {
531: ListboxRedrawRange(listPtr, listPtr->selectFirst,
532: listPtr->selectLast);
533: listPtr->selectFirst = -1;
534: }
535: goto done;
536: }
537: if (argc != 4) {
538: Tcl_AppendResult(interp, "wrong # args: should be \"",
539: argv[0], " select option index\"", (char *) NULL);
540: goto error;
541: }
542: if (GetListboxIndex(interp, listPtr, argv[3], &index) != TCL_OK) {
543: goto error;
544: }
545: if ((c == 'a') && (strncmp(argv[2], "adjust", length) == 0)) {
546: if (index < (listPtr->selectFirst + listPtr->selectLast)/2) {
547: listPtr->selectAnchor = listPtr->selectLast;
548: } else {
549: listPtr->selectAnchor = listPtr->selectFirst;
550: }
551: ListboxSelectTo(listPtr, index);
552: } else if ((c == 'f') && (strncmp(argv[2], "from", length) == 0)) {
553: ListboxSelectFrom(listPtr, index);
554: } else if ((c == 't') && (strncmp(argv[2], "to", length) == 0)) {
555: ListboxSelectTo(listPtr, index);
556: } else {
557: Tcl_AppendResult(interp, "bad select option \"", argv[2],
558: "\": must be adjust, clear, from, or to", (char *) NULL);
559: goto error;
560: }
561: } else if ((c == 's') && (length >= 2)
562: && (strncmp(argv[1], "size", length) == 0)) {
563: sprintf(interp->result, "%d", listPtr->numElements);
564: } else if ((c == 'x') && (strncmp(argv[1], "xview", length) == 0)) {
565: int index;
566:
567: if (argc != 3) {
568: Tcl_AppendResult(interp, "wrong # args: should be \"",
569: argv[0], " xview index\"", (char *) NULL);
570: goto error;
571: }
572: if (Tcl_GetInt(interp, argv[2], &index) != TCL_OK) {
573: goto error;
574: }
575: ChangeListboxOffset(listPtr, index*listPtr->xScrollUnit);
576: } else if ((c == 'y') && (strncmp(argv[1], "yview", length) == 0)) {
577: int index;
578:
579: if (argc != 3) {
580: Tcl_AppendResult(interp, "wrong # args: should be \"",
581: argv[0], " yview index\"", (char *) NULL);
582: goto error;
583: }
584: if (GetListboxIndex(interp, listPtr, argv[2], &index) != TCL_OK) {
585: goto error;
586: }
587: ChangeListboxView(listPtr, index);
588: } else {
589: Tcl_AppendResult(interp, "bad option \"", argv[1],
590: "\": must be configure, curselection, delete, get, ",
591: "insert, nearest, scan, select, size, ",
592: "xview, or yview", (char *) NULL);
593: goto error;
594: }
595: done:
596: Tk_Release((ClientData) listPtr);
597: return result;
598:
599: error:
600: Tk_Release((ClientData) listPtr);
601: return TCL_ERROR;
602: }
603:
604: /*
605: *----------------------------------------------------------------------
606: *
607: * DestroyListbox --
608: *
609: * This procedure is invoked by Tk_EventuallyFree or Tk_Release
610: * to clean up the internal structure of a listbox at a safe time
611: * (when no-one is using it anymore).
612: *
613: * Results:
614: * None.
615: *
616: * Side effects:
617: * Everything associated with the listbox is freed up.
618: *
619: *----------------------------------------------------------------------
620: */
621:
622: static void
623: DestroyListbox(clientData)
624: ClientData clientData; /* Info about listbox widget. */
625: {
626: register Listbox *listPtr = (Listbox *) clientData;
627: register Element *elPtr, *nextPtr;
628:
629: for (elPtr = listPtr->elementPtr; elPtr != NULL; ) {
630: nextPtr = elPtr->nextPtr;
631: ckfree((char *) elPtr);
632: elPtr = nextPtr;
633: }
634: if (listPtr->normalBorder != NULL) {
635: Tk_Free3DBorder(listPtr->normalBorder);
636: }
637: if (listPtr->fontPtr != NULL) {
638: Tk_FreeFontStruct(listPtr->fontPtr);
639: }
640: if (listPtr->fgColorPtr != NULL) {
641: Tk_FreeColor(listPtr->fgColorPtr);
642: }
643: if (listPtr->textGC != None) {
644: Tk_FreeGC(listPtr->textGC);
645: }
646: if (listPtr->selBorder != NULL) {
647: Tk_Free3DBorder(listPtr->selBorder);
648: }
649: if (listPtr->selFgColorPtr != NULL) {
650: Tk_FreeColor(listPtr->selFgColorPtr);
651: }
652: if (listPtr->selTextGC != None) {
653: Tk_FreeGC(listPtr->selTextGC);
654: }
655: if (listPtr->geometry != NULL) {
656: ckfree(listPtr->geometry);
657: }
658: if (listPtr->cursor != None) {
659: Tk_FreeCursor(listPtr->cursor);
660: }
661: if (listPtr->yScrollCmd != NULL) {
662: ckfree(listPtr->yScrollCmd);
663: }
664: if (listPtr->xScrollCmd != NULL) {
665: ckfree(listPtr->xScrollCmd);
666: }
667: ckfree((char *) listPtr);
668: }
669:
670: /*
671: *----------------------------------------------------------------------
672: *
673: * ConfigureListbox --
674: *
675: * This procedure is called to process an argv/argc list, plus
676: * the Tk option database, in order to configure (or reconfigure)
677: * a listbox widget.
678: *
679: * Results:
680: * The return value is a standard Tcl result. If TCL_ERROR is
681: * returned, then interp->result contains an error message.
682: *
683: * Side effects:
684: * Configuration information, such as colors, border width,
685: * etc. get set for listPtr; old resources get freed,
686: * if there were any.
687: *
688: *----------------------------------------------------------------------
689: */
690:
691: static int
692: ConfigureListbox(interp, listPtr, argc, argv, flags)
693: Tcl_Interp *interp; /* Used for error reporting. */
694: register Listbox *listPtr; /* Information about widget; may or may
695: * not already have values for some fields. */
696: int argc; /* Number of valid entries in argv. */
697: char **argv; /* Arguments. */
698: int flags; /* Flags to pass to Tk_ConfigureWidget. */
699: {
700: XGCValues gcValues;
701: GC new;
702: int width, height, fontHeight, oldExport;
703:
704: oldExport = listPtr->exportSelection;
705: if (Tk_ConfigureWidget(interp, listPtr->tkwin, configSpecs,
706: argc, argv, (char *) listPtr, flags) != TCL_OK) {
707: return TCL_ERROR;
708: }
709:
710: /*
711: * A few options need special processing, such as parsing the
712: * geometry and setting the background from a 3-D border.
713: */
714:
715: Tk_SetBackgroundFromBorder(listPtr->tkwin, listPtr->normalBorder);
716:
717: gcValues.foreground = listPtr->fgColorPtr->pixel;
718: gcValues.font = listPtr->fontPtr->fid;
719: gcValues.graphics_exposures = False;
720: new = Tk_GetGC(listPtr->tkwin, GCForeground|GCFont|GCGraphicsExposures,
721: &gcValues);
722: if (listPtr->textGC != None) {
723: Tk_FreeGC(listPtr->textGC);
724: }
725: listPtr->textGC = new;
726:
727: gcValues.foreground = listPtr->selFgColorPtr->pixel;
728: gcValues.font = listPtr->fontPtr->fid;
729: new = Tk_GetGC(listPtr->tkwin, GCForeground|GCFont, &gcValues);
730: if (listPtr->selTextGC != None) {
731: Tk_FreeGC(listPtr->selTextGC);
732: }
733: listPtr->selTextGC = new;
734:
735: /*
736: * Claim the selection if we've suddenly started exporting it.
737: */
738:
739: if (listPtr->exportSelection && (!oldExport)
740: && (listPtr->selectFirst !=-1)) {
741: Tk_OwnSelection(listPtr->tkwin, ListboxLostSelection,
742: (ClientData) listPtr);
743: }
744:
745: /*
746: * Register the desired geometry for the window, and arrange for
747: * the window to be redisplayed.
748: */
749:
750: if ((sscanf(listPtr->geometry, "%dx%d", &width, &height) != 2)
751: || (width <= 0) || (height <= 0)) {
752: Tcl_AppendResult(interp, "bad geometry \"",
753: listPtr->geometry, "\"", (char *) NULL);
754: return TCL_ERROR;
755: }
756: fontHeight = listPtr->fontPtr->ascent + listPtr->fontPtr->descent;
757: listPtr->lineHeight = fontHeight + 1 + 2*listPtr->selBorderWidth;
758: listPtr->numLines = (Tk_Height(listPtr->tkwin) - 2*listPtr->borderWidth)
759: / listPtr->lineHeight;
760: if (listPtr->numLines < 0) {
761: listPtr->numLines = 0;
762: }
763: ListboxComputeWidths(listPtr, 1);
764: width = (width+1)*listPtr->xScrollUnit + 2*listPtr->borderWidth
765: + 2*listPtr->selBorderWidth;
766: height = height*listPtr->lineHeight + 2*listPtr->borderWidth;
767: Tk_GeometryRequest(listPtr->tkwin, width, height);
768: Tk_SetInternalBorder(listPtr->tkwin, listPtr->borderWidth);
769: listPtr->flags |= UPDATE_V_SCROLLBAR|UPDATE_H_SCROLLBAR;
770: ListboxRedrawRange(listPtr, 0, listPtr->numElements-1);
771: return TCL_OK;
772: }
773:
774: /*
775: *--------------------------------------------------------------
776: *
777: * DisplayListbox --
778: *
779: * This procedure redraws the contents of a listbox window.
780: *
781: * Results:
782: * None.
783: *
784: * Side effects:
785: * Information appears on the screen.
786: *
787: *--------------------------------------------------------------
788: */
789:
790: static void
791: DisplayListbox(clientData)
792: ClientData clientData; /* Information about window. */
793: {
794: register Listbox *listPtr = (Listbox *) clientData;
795: register Tk_Window tkwin = listPtr->tkwin;
796: register Element *elPtr;
797: GC gc;
798: int i, limit, x, y, margin;
799: Pixmap pixmap;
800:
801: listPtr->flags &= ~REDRAW_PENDING;
802: if (listPtr->flags & UPDATE_V_SCROLLBAR) {
803: ListboxUpdateVScrollbar(listPtr);
804: }
805: if (listPtr->flags & UPDATE_H_SCROLLBAR) {
806: ListboxUpdateHScrollbar(listPtr);
807: }
808: listPtr->flags &= ~(REDRAW_PENDING|UPDATE_V_SCROLLBAR|UPDATE_H_SCROLLBAR);
809: if ((listPtr->tkwin == NULL) || !Tk_IsMapped(tkwin)) {
810: return;
811: }
812:
813: /*
814: * Redrawing is done in a temporary pixmap that is allocated
815: * here and freed at the end of the procedure. All drawing is
816: * done to the pixmap, and the pixmap is copied to the screen
817: * at the end of the procedure. This provides the smoothest
818: * possible visual effects (no flashing on the screen).
819: */
820:
821: pixmap = XCreatePixmap(Tk_Display(tkwin), Tk_WindowId(tkwin),
822: Tk_Width(tkwin), Tk_Height(tkwin),
823: Tk_DefaultDepth(Tk_Screen(tkwin)));
824: Tk_Fill3DRectangle(Tk_Display(tkwin), pixmap, listPtr->normalBorder,
825: 0, 0, Tk_Width(tkwin), Tk_Height(tkwin), listPtr->borderWidth,
826: listPtr->relief);
827:
828: /*
829: * Iterate through all of the elements of the listbox, displaying each
830: * in turn. Selected elements use a different GC and have a raised
831: * background.
832: */
833:
834: limit = listPtr->topIndex + listPtr->numLines - 1;
835: if (limit >= listPtr->numElements) {
836: limit = listPtr->numElements-1;
837: }
838: margin = listPtr->selBorderWidth + listPtr->xScrollUnit/2;
839: for (elPtr = listPtr->elementPtr, i = 0; (elPtr != NULL) && (i <= limit);
840: elPtr = elPtr->nextPtr, i++) {
841: if (i < listPtr->topIndex) {
842: continue;
843: }
844: x = listPtr->borderWidth;
845: y = ((i - listPtr->topIndex) * listPtr->lineHeight)
846: + listPtr->borderWidth;
847: gc = listPtr->textGC;
848: if ((listPtr->selectFirst >= 0) && (i >= listPtr->selectFirst)
849: && (i <= listPtr->selectLast)) {
850: gc = listPtr->selTextGC;
851: Tk_Fill3DRectangle(Tk_Display(tkwin), pixmap,
852: listPtr->selBorder, x, y,
853: Tk_Width(tkwin) - 2*listPtr->borderWidth,
854: listPtr->lineHeight, listPtr->selBorderWidth,
855: TK_RELIEF_RAISED);
856: }
857: y += listPtr->fontPtr->ascent + listPtr->selBorderWidth;
858: x += margin - elPtr->lBearing - listPtr->xOffset;
859: XDrawString(Tk_Display(tkwin), pixmap, gc, x, y,
860: elPtr->text, elPtr->textLength);
861: }
862:
863: /*
864: * Redraw the border for the listbox to make sure that it's on top
865: * of any of the text of the listbox entries.
866: */
867:
868: Tk_Draw3DRectangle(Tk_Display(tkwin), pixmap,
869: listPtr->normalBorder, 0, 0, Tk_Width(tkwin),
870: Tk_Height(tkwin), listPtr->borderWidth,
871: listPtr->relief);
872: XCopyArea(Tk_Display(tkwin), pixmap, Tk_WindowId(tkwin),
873: listPtr->textGC, 0, 0, Tk_Width(tkwin), Tk_Height(tkwin),
874: 0, 0);
875: XFreePixmap(Tk_Display(tkwin), pixmap);
876: }
877:
878: /*
879: *----------------------------------------------------------------------
880: *
881: * InsertEls --
882: *
883: * Add new elements to a listbox widget.
884: *
885: * Results:
886: * None.
887: *
888: * Side effects:
889: * New information gets added to listPtr; it will be redisplayed
890: * soon, but not immediately.
891: *
892: *----------------------------------------------------------------------
893: */
894:
895: static void
896: InsertEls(listPtr, index, argc, argv)
897: register Listbox *listPtr; /* Listbox that is to get the new
898: * elements. */
899: int index; /* Add the new elements before this
900: * element. */
901: int argc; /* Number of new elements to add. */
902: char **argv; /* New elements (one per entry). */
903: {
904: register Element *prevPtr, *newPtr;
905: int length, dummy, i, oldMaxWidth;
906: XCharStruct bbox;
907:
908: /*
909: * Find the element before which the new ones will be inserted.
910: */
911:
912: if (index <= 0) {
913: index = 0;
914: }
915: if (index > listPtr->numElements) {
916: index = listPtr->numElements;
917: }
918: if (index == 0) {
919: prevPtr = NULL;
920: } else {
921: for (prevPtr = listPtr->elementPtr, i = index - 1; i > 0; i--) {
922: prevPtr = prevPtr->nextPtr;
923: }
924: }
925:
926: /*
927: * For each new element, create a record, initialize it, and link
928: * it into the list of elements.
929: */
930:
931: oldMaxWidth = listPtr->maxWidth;
932: for (i = argc ; i > 0; i--, argv++, prevPtr = newPtr) {
933: length = strlen(*argv);
934: newPtr = (Element *) ckalloc(ElementSize(length));
935: newPtr->textLength = length;
936: strcpy(newPtr->text, *argv);
937: XTextExtents(listPtr->fontPtr, newPtr->text, newPtr->textLength,
938: &dummy, &dummy, &dummy, &bbox);
939: newPtr->lBearing = bbox.lbearing;
940: newPtr->pixelWidth = bbox.lbearing + bbox.rbearing;
941: if (newPtr->pixelWidth > listPtr->maxWidth) {
942: listPtr->maxWidth = newPtr->pixelWidth;
943: }
944: if (prevPtr == NULL) {
945: newPtr->nextPtr = listPtr->elementPtr;
946: listPtr->elementPtr = newPtr;
947: } else {
948: newPtr->nextPtr = prevPtr->nextPtr;
949: prevPtr->nextPtr = newPtr;
950: }
951: }
952: listPtr->numElements += argc;
953:
954: /*
955: * Update the selection to account for the renumbering that has just
956: * occurred. Then arrange for the new information to be displayed.
957: */
958:
959: if (index <= listPtr->selectFirst) {
960: listPtr->selectFirst += argc;
961: }
962: if (index <= listPtr->selectLast) {
963: listPtr->selectLast += argc;
964: }
965: listPtr->flags |= UPDATE_V_SCROLLBAR;
966: if (listPtr->maxWidth != oldMaxWidth) {
967: listPtr->flags |= UPDATE_H_SCROLLBAR;
968: }
969: ListboxRedrawRange(listPtr, index, listPtr->numElements-1);
970: }
971:
972: /*
973: *----------------------------------------------------------------------
974: *
975: * DeleteEls --
976: *
977: * Remove one or more elements from a listbox widget.
978: *
979: * Results:
980: * None.
981: *
982: * Side effects:
983: * Memory gets freed, the listbox gets modified and (eventually)
984: * redisplayed.
985: *
986: *----------------------------------------------------------------------
987: */
988:
989: static void
990: DeleteEls(listPtr, first, last)
991: register Listbox *listPtr; /* Listbox widget to modify. */
992: int first; /* Index of first element to delete. */
993: int last; /* Index of last element to delete. */
994: {
995: register Element *prevPtr, *elPtr;
996: int count, i, widthChanged;
997:
998: /*
999: * Adjust the range to fit within the existing elements of the
1000: * listbox, and make sure there's something to delete.
1001: */
1002:
1003: if (first < 0) {
1004: first = 0;
1005: }
1006: if (last >= listPtr->numElements) {
1007: last = listPtr->numElements-1;
1008: }
1009: count = last + 1 - first;
1010: if (count <= 0) {
1011: return;
1012: }
1013:
1014: /*
1015: * Find the element just before the ones to delete.
1016: */
1017:
1018: if (first == 0) {
1019: prevPtr = NULL;
1020: } else {
1021: for (i = first-1, prevPtr = listPtr->elementPtr; i > 0; i--) {
1022: prevPtr = prevPtr->nextPtr;
1023: }
1024: }
1025:
1026: /*
1027: * Delete the requested number of elements.
1028: */
1029:
1030: widthChanged = 0;
1031: for (i = count; i > 0; i--) {
1032: if (prevPtr == NULL) {
1033: elPtr = listPtr->elementPtr;
1034: listPtr->elementPtr = elPtr->nextPtr;
1035: } else {
1036: elPtr = prevPtr->nextPtr;
1037: prevPtr->nextPtr = elPtr->nextPtr;
1038: }
1039: if (elPtr->pixelWidth == listPtr->maxWidth) {
1040: widthChanged = 1;
1041: }
1042: ckfree((char *) elPtr);
1043: }
1044: listPtr->numElements -= count;
1045:
1046: /*
1047: * Update the selection and viewing information to reflect the change
1048: * in the element numbering, and redisplay to slide information up over
1049: * the elements that were deleted.
1050: */
1051:
1052: if (first <= listPtr->selectFirst) {
1053: listPtr->selectFirst -= count;
1054: if (listPtr->selectFirst < first) {
1055: listPtr->selectFirst = first;
1056: }
1057: }
1058: if (first <= listPtr->selectLast) {
1059: listPtr->selectLast -= count;
1060: if (listPtr->selectLast < first) {
1061: listPtr->selectLast = first-1;
1062: }
1063: }
1064: if (listPtr->selectLast < listPtr->selectFirst) {
1065: listPtr->selectFirst = -1;
1066: }
1067: if (first <= listPtr->topIndex) {
1068: listPtr->topIndex -= count;
1069: if (listPtr->topIndex < first) {
1070: listPtr->topIndex = first;
1071: }
1072: }
1073: listPtr->flags |= UPDATE_V_SCROLLBAR;
1074: if (widthChanged) {
1075: ListboxComputeWidths(listPtr, 0);
1076: listPtr->flags |= UPDATE_H_SCROLLBAR;
1077: }
1078: ListboxRedrawRange(listPtr, first, listPtr->numElements-1);
1079: }
1080:
1081: /*
1082: *--------------------------------------------------------------
1083: *
1084: * ListboxEventProc --
1085: *
1086: * This procedure is invoked by the Tk dispatcher for various
1087: * events on listboxes.
1088: *
1089: * Results:
1090: * None.
1091: *
1092: * Side effects:
1093: * When the window gets deleted, internal structures get
1094: * cleaned up. When it gets exposed, it is redisplayed.
1095: *
1096: *--------------------------------------------------------------
1097: */
1098:
1099: static void
1100: ListboxEventProc(clientData, eventPtr)
1101: ClientData clientData; /* Information about window. */
1102: XEvent *eventPtr; /* Information about event. */
1103: {
1104: Listbox *listPtr = (Listbox *) clientData;
1105:
1106: if (eventPtr->type == Expose) {
1107: ListboxRedrawRange(listPtr,
1108: NearestListboxElement(listPtr, eventPtr->xexpose.y),
1109: NearestListboxElement(listPtr, eventPtr->xexpose.y
1110: + eventPtr->xexpose.height));
1111: } else if (eventPtr->type == DestroyNotify) {
1112: Tcl_DeleteCommand(listPtr->interp, Tk_PathName(listPtr->tkwin));
1113: listPtr->tkwin = NULL;
1114: if (listPtr->flags & REDRAW_PENDING) {
1115: Tk_CancelIdleCall(DisplayListbox, (ClientData) listPtr);
1116: }
1117: Tk_EventuallyFree((ClientData) listPtr, DestroyListbox);
1118: } else if (eventPtr->type == ConfigureNotify) {
1119: Tk_Preserve((ClientData) listPtr);
1120: listPtr->numLines = (Tk_Height(listPtr->tkwin)
1121: - 2*listPtr->borderWidth) / listPtr->lineHeight;
1122: listPtr->flags |= UPDATE_V_SCROLLBAR|UPDATE_H_SCROLLBAR;
1123: ListboxRedrawRange(listPtr, 0, listPtr->numElements-1);
1124: Tk_Release((ClientData) listPtr);
1125: }
1126: }
1127:
1128: /*
1129: *--------------------------------------------------------------
1130: *
1131: * GetListboxIndex --
1132: *
1133: * Parse an index into a listbox and return either its value
1134: * or an error.
1135: *
1136: * Results:
1137: * A standard Tcl result. If all went well, then *indexPtr is
1138: * filled in with the index (into listPtr) corresponding to
1139: * string. Otherwise an error message is left in interp->result.
1140: *
1141: * Side effects:
1142: * None.
1143: *
1144: *--------------------------------------------------------------
1145: */
1146:
1147: static int
1148: GetListboxIndex(interp, listPtr, string, indexPtr)
1149: Tcl_Interp *interp; /* For error messages. */
1150: Listbox *listPtr; /* Listbox for which the index is being
1151: * specified. */
1152: char *string; /* Numerical index into listPtr's element
1153: * list, or "end" to refer to last element. */
1154: int *indexPtr; /* Where to store converted index. */
1155: {
1156: if (string[0] == 'e') {
1157: if (strncmp(string, "end", strlen(string)) != 0) {
1158: badIndex:
1159: Tcl_AppendResult(interp, "bad listbox index \"", string,
1160: "\"", (char *) NULL);
1161: return TCL_ERROR;
1162: }
1163: *indexPtr = listPtr->numElements;
1164: if (listPtr->numElements <= 0) {
1165: *indexPtr = 0;
1166: }
1167: } else {
1168: if (Tcl_GetInt(interp, string, indexPtr) != TCL_OK) {
1169: Tcl_ResetResult(interp);
1170: goto badIndex;
1171: }
1172: }
1173: return TCL_OK;
1174: }
1175:
1176: /*
1177: *----------------------------------------------------------------------
1178: *
1179: * ChangeListboxView --
1180: *
1181: * Change the view on a listbox widget.
1182: *
1183: * Results:
1184: * None.
1185: *
1186: * Side effects:
1187: * What's displayed on the screen is changed. If there is a
1188: * scrollbar associated with this widget, then the scrollbar
1189: * is instructed to change its display too.
1190: *
1191: *----------------------------------------------------------------------
1192: */
1193:
1194: static void
1195: ChangeListboxView(listPtr, index)
1196: register Listbox *listPtr; /* Information about widget. */
1197: int index; /* Index of element in listPtr. */
1198: {
1199: if (listPtr->tkwin == NULL) {
1200: return;
1201: }
1202:
1203: if (index >= listPtr->numElements) {
1204: index = listPtr->numElements-1;
1205: }
1206: if (index < 0) {
1207: index = 0;
1208: }
1209: if (listPtr->topIndex != index) {
1210: if (!(listPtr->flags & REDRAW_PENDING)) {
1211: Tk_DoWhenIdle(DisplayListbox, (ClientData) listPtr);
1212: listPtr->flags |= REDRAW_PENDING;
1213: }
1214: listPtr->topIndex = index;
1215: ListboxUpdateVScrollbar(listPtr);
1216: }
1217: }
1218:
1219: /*
1220: *----------------------------------------------------------------------
1221: *
1222: * ChangListboxOffset --
1223: *
1224: * Change the horizontal offset for a listbox.
1225: *
1226: * Results:
1227: * None.
1228: *
1229: * Side effects:
1230: * The listbox may be redrawn to reflect its new horizontal
1231: * offset.
1232: *
1233: *----------------------------------------------------------------------
1234: */
1235:
1236: static void
1237: ChangeListboxOffset(listPtr, offset)
1238: register Listbox *listPtr; /* Information about widget. */
1239: int offset; /* Desired new "xOffset" for
1240: * listbox. */
1241: {
1242: int maxOffset;
1243:
1244: if (listPtr->tkwin == NULL) {
1245: return;
1246: }
1247:
1248: /*
1249: * Make sure that the new offset is within the allowable range, and
1250: * round it off to an even multiple of xScrollUnit.
1251: */
1252:
1253: maxOffset = listPtr->maxWidth + (listPtr->xScrollUnit-1)
1254: - (Tk_Width(listPtr->tkwin) - 2*listPtr->borderWidth
1255: - 2*listPtr->selBorderWidth - listPtr->xScrollUnit);
1256: if (offset > maxOffset) {
1257: offset = maxOffset;
1258: }
1259: if (offset < 0) {
1260: offset = 0;
1261: }
1262: offset -= offset%listPtr->xScrollUnit;
1263: if (offset != listPtr->xOffset) {
1264: listPtr->xOffset = offset;
1265: listPtr->flags |= UPDATE_H_SCROLLBAR;
1266: ListboxRedrawRange(listPtr, 0, listPtr->numElements);
1267: }
1268: }
1269:
1270: /*
1271: *----------------------------------------------------------------------
1272: *
1273: * ListboxScanTo --
1274: *
1275: * Given a point (presumably of the curent mouse location)
1276: * drag the view in the window to implement the scan operation.
1277: *
1278: * Results:
1279: * None.
1280: *
1281: * Side effects:
1282: * The view in the window may change.
1283: *
1284: *----------------------------------------------------------------------
1285: */
1286:
1287: static void
1288: ListboxScanTo(listPtr, x, y)
1289: register Listbox *listPtr; /* Information about widget. */
1290: int x; /* X-coordinate to use for scan
1291: * operation. */
1292: int y; /* Y-coordinate to use for scan
1293: * operation. */
1294: {
1295: int newTopIndex, newOffset;
1296:
1297: /*
1298: * Compute new top line for screen by amplifying the difference
1299: * between the current position and the place where the scan
1300: * started (the "mark" position). If we run off the top or bottom
1301: * of the list, then reset the mark point so that the current
1302: * position continues to correspond to the edge of the window.
1303: * This means that the picture will start dragging as soon as the
1304: * mouse reverses direction (without this reset, might have to slide
1305: * mouse a long ways back before the picture starts moving again).
1306: */
1307:
1308: newTopIndex = listPtr->scanMarkYIndex
1309: - (10*(y - listPtr->scanMarkY))/listPtr->lineHeight;
1310: if (newTopIndex >= listPtr->numElements) {
1311: newTopIndex = listPtr->scanMarkYIndex = listPtr->numElements-1;
1312: listPtr->scanMarkY = y;
1313: } else if (newTopIndex < 0) {
1314: newTopIndex = listPtr->scanMarkYIndex = 0;
1315: listPtr->scanMarkY = y;
1316: }
1317: ChangeListboxView(listPtr, newTopIndex);
1318:
1319: /*
1320: * Compute new left edge for display in a similar fashion by amplifying
1321: * the difference between the current position and the place where the
1322: * scan started.
1323: */
1324:
1325: newOffset = listPtr->scanMarkXOffset - (10*(x - listPtr->scanMarkX));
1326: if (newOffset >= listPtr->maxWidth) {
1327: newOffset = listPtr->scanMarkXOffset = listPtr->maxWidth;
1328: listPtr->scanMarkX = x;
1329: } else if (newOffset < 0) {
1330: newOffset = listPtr->scanMarkXOffset = 0;
1331: listPtr->scanMarkX = x;
1332: }
1333: ChangeListboxOffset(listPtr, newOffset);
1334: }
1335:
1336: /*
1337: *----------------------------------------------------------------------
1338: *
1339: * NearestListboxElement --
1340: *
1341: * Given a y-coordinate inside a listbox, compute the index of
1342: * the element under that y-coordinate (or closest to that
1343: * y-coordinate).
1344: *
1345: * Results:
1346: * The return value is an index of an element of listPtr. If
1347: * listPtr has no elements, then 0 is always returned.
1348: *
1349: * Side effects:
1350: * None.
1351: *
1352: *----------------------------------------------------------------------
1353: */
1354:
1355: static int
1356: NearestListboxElement(listPtr, y)
1357: register Listbox *listPtr; /* Information about widget. */
1358: int y; /* Y-coordinate in listPtr's window. */
1359: {
1360: int index;
1361:
1362: index = (y - listPtr->borderWidth)/listPtr->lineHeight;
1363: if (index >= listPtr->numLines) {
1364: index = listPtr->numLines-1;
1365: }
1366: if (index < 0) {
1367: index = 0;
1368: }
1369: index += listPtr->topIndex;
1370: if (index >= listPtr->numElements) {
1371: index = listPtr->numElements-1;
1372: }
1373: return index;
1374: }
1375:
1376: /*
1377: *----------------------------------------------------------------------
1378: *
1379: * ListboxSelectFrom --
1380: *
1381: * Start a new selection in a listbox.
1382: *
1383: * Results:
1384: * None.
1385: *
1386: * Side effects:
1387: * ListPtr claims the selection, and the selection becomes the
1388: * single element given by index.
1389: *
1390: *----------------------------------------------------------------------
1391: */
1392:
1393: static void
1394: ListboxSelectFrom(listPtr, index)
1395: register Listbox *listPtr; /* Information about widget. */
1396: int index; /* Index of element that is to
1397: * become the new selection. */
1398: {
1399: /*
1400: * Make sure the index is within the proper range for the listbox.
1401: */
1402:
1403: if (index <= 0) {
1404: index = 0;
1405: }
1406: if (index >= listPtr->numElements) {
1407: index = listPtr->numElements-1;
1408: }
1409:
1410: if (listPtr->selectFirst != -1) {
1411: ListboxRedrawRange(listPtr, listPtr->selectFirst, listPtr->selectLast);
1412: } else if (listPtr->exportSelection) {
1413: Tk_OwnSelection(listPtr->tkwin, ListboxLostSelection,
1414: (ClientData) listPtr);
1415: }
1416:
1417: listPtr->selectFirst = listPtr->selectLast = index;
1418: listPtr->selectAnchor = index;
1419: ListboxRedrawRange(listPtr, index, index);
1420: }
1421:
1422: /*
1423: *----------------------------------------------------------------------
1424: *
1425: * ListboxSelectTo --
1426: *
1427: * Modify the selection by moving its un-anchored end. This could
1428: * make the selection either larger or smaller.
1429: *
1430: * Results:
1431: * None.
1432: *
1433: * Side effects:
1434: * The selection changes.
1435: *
1436: *----------------------------------------------------------------------
1437: */
1438:
1439: static void
1440: ListboxSelectTo(listPtr, index)
1441: register Listbox *listPtr; /* Information about widget. */
1442: int index; /* Index of element that is to
1443: * become the "other" end of the
1444: * selection. */
1445: {
1446: int newFirst, newLast;
1447:
1448: /*
1449: * Make sure the index is within the proper range for the listbox.
1450: */
1451:
1452: if (index <= 0) {
1453: index = 0;
1454: }
1455: if (index >= listPtr->numElements) {
1456: index = listPtr->numElements-1;
1457: }
1458:
1459: /*
1460: * We should already own the selection, but grab it if we don't.
1461: */
1462:
1463: if (listPtr->selectFirst == -1) {
1464: ListboxSelectFrom(listPtr, index);
1465: }
1466:
1467: if (listPtr->selectAnchor < index) {
1468: newFirst = listPtr->selectAnchor;
1469: newLast = index;
1470: } else {
1471: newFirst = index;
1472: newLast = listPtr->selectAnchor;
1473: }
1474: if ((listPtr->selectFirst == newFirst)
1475: && (listPtr->selectLast == newLast)) {
1476: return;
1477: }
1478: if (listPtr->selectFirst != newFirst) {
1479: if (listPtr->selectFirst < newFirst) {
1480: ListboxRedrawRange(listPtr, listPtr->selectFirst, newFirst-1);
1481: } else {
1482: ListboxRedrawRange(listPtr, newFirst, listPtr->selectFirst-1);
1483: }
1484: listPtr->selectFirst = newFirst;
1485: }
1486: if (listPtr->selectLast != newLast) {
1487: if (listPtr->selectLast < newLast) {
1488: ListboxRedrawRange(listPtr, listPtr->selectLast+1, newLast);
1489: } else {
1490: ListboxRedrawRange(listPtr, newLast+1, listPtr->selectLast);
1491: }
1492: listPtr->selectLast = newLast;
1493: }
1494: }
1495:
1496: /*
1497: *----------------------------------------------------------------------
1498: *
1499: * ListboxFetchSelection --
1500: *
1501: * This procedure is called back by Tk when the selection is
1502: * requested by someone. It returns part or all of the selection
1503: * in a buffer provided by the caller.
1504: *
1505: * Results:
1506: * The return value is the number of non-NULL bytes stored
1507: * at buffer. Buffer is filled (or partially filled) with a
1508: * NULL-terminated string containing part or all of the selection,
1509: * as given by offset and maxBytes. The selection is returned
1510: * as a Tcl list with one list element for each element in the
1511: * listbox.
1512: *
1513: * Side effects:
1514: * None.
1515: *
1516: *----------------------------------------------------------------------
1517: */
1518:
1519: static int
1520: ListboxFetchSelection(clientData, offset, buffer, maxBytes)
1521: ClientData clientData; /* Information about listbox widget. */
1522: int offset; /* Offset within selection of first
1523: * byte to be returned. */
1524: char *buffer; /* Location in which to place
1525: * selection. */
1526: int maxBytes; /* Maximum number of bytes to place
1527: * at buffer, not including terminating
1528: * NULL character. */
1529: {
1530: register Listbox *listPtr = (Listbox *) clientData;
1531: register Element *elPtr;
1532: char **argv, *selection;
1533: int src, dst, length, count, argc;
1534:
1535: if ((listPtr->selectFirst == -1) || !listPtr->exportSelection) {
1536: return -1;
1537: }
1538:
1539: /*
1540: * Use Tcl_Merge to format the listbox elements into a suitable
1541: * Tcl list.
1542: */
1543:
1544: argc = listPtr->selectLast - listPtr->selectFirst + 1;
1545: argv = (char **) ckalloc((unsigned) (argc*sizeof(char *)));
1546: for (src = 0, dst = 0, elPtr = listPtr->elementPtr; ;
1547: src++, elPtr = elPtr->nextPtr) {
1548: if (src < listPtr->selectFirst) {
1549: continue;
1550: }
1551: if (src > listPtr->selectLast) {
1552: break;
1553: }
1554: argv[dst] = elPtr->text;
1555: dst++;
1556: }
1557: selection = Tcl_Merge(argc, argv);
1558:
1559: /*
1560: * Copy the requested portion of the selection to the buffer.
1561: */
1562:
1563: length = strlen(selection);
1564: count = length - offset;
1565: if (count <= 0) {
1566: count = 0;
1567: goto done;
1568: }
1569: if (count > maxBytes) {
1570: count = maxBytes;
1571: }
1572: memcpy((VOID *) buffer, (VOID *) (selection + offset), count);
1573:
1574: done:
1575: buffer[count] = '\0';
1576: ckfree(selection);
1577: ckfree((char *) argv);
1578: return count;
1579: }
1580:
1581: /*
1582: *----------------------------------------------------------------------
1583: *
1584: * ListboxLostSelection --
1585: *
1586: * This procedure is called back by Tk when the selection is
1587: * grabbed away from a listbox widget.
1588: *
1589: * Results:
1590: * None.
1591: *
1592: * Side effects:
1593: * The existing selection is unhighlighted, and the window is
1594: * marked as not containing a selection.
1595: *
1596: *----------------------------------------------------------------------
1597: */
1598:
1599: static void
1600: ListboxLostSelection(clientData)
1601: ClientData clientData; /* Information about listbox widget. */
1602: {
1603: register Listbox *listPtr = (Listbox *) clientData;
1604:
1605: if ((listPtr->selectFirst >= 0) && listPtr->exportSelection) {
1606: ListboxRedrawRange(listPtr, listPtr->selectFirst, listPtr->selectLast);
1607: listPtr->selectFirst = -1;
1608: }
1609: }
1610:
1611: /*
1612: *----------------------------------------------------------------------
1613: *
1614: * ListboxRedrawRange --
1615: *
1616: * Ensure that a given range of elements is eventually redrawn on
1617: * the display (if those elements in fact appear on the display).
1618: *
1619: * Results:
1620: * None.
1621: *
1622: * Side effects:
1623: * Information gets redisplayed.
1624: *
1625: *----------------------------------------------------------------------
1626: */
1627:
1628: /* ARGSUSED */
1629: static void
1630: ListboxRedrawRange(listPtr, first, last)
1631: register Listbox *listPtr; /* Information about widget. */
1632: int first; /* Index of first element in list
1633: * that needs to be redrawn. */
1634: int last; /* Index of last element in list
1635: * that needs to be redrawn. May
1636: * be less than first;
1637: * these just bracket a range. */
1638: {
1639: if ((listPtr->tkwin == NULL) || !Tk_IsMapped(listPtr->tkwin)
1640: || (listPtr->flags & REDRAW_PENDING)) {
1641: return;
1642: }
1643: Tk_DoWhenIdle(DisplayListbox, (ClientData) listPtr);
1644: listPtr->flags |= REDRAW_PENDING;
1645: }
1646:
1647: /*
1648: *----------------------------------------------------------------------
1649: *
1650: * ListboxUpdateVScrollbar --
1651: *
1652: * This procedure is invoked whenever information has changed in
1653: * a listbox in a way that would invalidate a vertical scrollbar
1654: * display. If there is an associated scrollbar, then this command
1655: * updates it by invoking a Tcl command.
1656: *
1657: * Results:
1658: * None.
1659: *
1660: * Side effects:
1661: * A Tcl command is invoked, and an additional command may be
1662: * invoked to process errors in the command.
1663: *
1664: *----------------------------------------------------------------------
1665: */
1666:
1667: static void
1668: ListboxUpdateVScrollbar(listPtr)
1669: register Listbox *listPtr; /* Information about widget. */
1670: {
1671: char string[60];
1672: int result, last;
1673:
1674: if (listPtr->yScrollCmd == NULL) {
1675: return;
1676: }
1677: last = listPtr->topIndex + listPtr->numLines - 1;
1678: if (last >= listPtr->numElements) {
1679: last = listPtr->numElements-1;
1680: }
1681: if (last < listPtr->topIndex) {
1682: last = listPtr->topIndex;
1683: }
1684: sprintf(string, " %d %d %d %d", listPtr->numElements, listPtr->numLines,
1685: listPtr->topIndex, last);
1686: result = Tcl_VarEval(listPtr->interp, listPtr->yScrollCmd, string,
1687: (char *) NULL);
1688: if (result != TCL_OK) {
1689: TkBindError(listPtr->interp);
1690: }
1691: }
1692:
1693: /*
1694: *----------------------------------------------------------------------
1695: *
1696: * ListboxUpdateHScrollbar --
1697: *
1698: * This procedure is invoked whenever information has changed in
1699: * a listbox in a way that would invalidate a horizontal scrollbar
1700: * display. If there is an associated horizontal scrollbar, then
1701: * this command updates it by invoking a Tcl command.
1702: *
1703: * Results:
1704: * None.
1705: *
1706: * Side effects:
1707: * A Tcl command is invoked, and an additional command may be
1708: * invoked to process errors in the command.
1709: *
1710: *----------------------------------------------------------------------
1711: */
1712:
1713: static void
1714: ListboxUpdateHScrollbar(listPtr)
1715: register Listbox *listPtr; /* Information about widget. */
1716: {
1717: char string[60];
1718: int result, totalUnits, windowUnits, first, last;
1719:
1720: if (listPtr->xScrollCmd == NULL) {
1721: return;
1722: }
1723: totalUnits = 1 + (listPtr->maxWidth-1)/listPtr->xScrollUnit;
1724: windowUnits = 1 + (Tk_Width(listPtr->tkwin)
1725: - 2*(listPtr->borderWidth + listPtr->selBorderWidth)-1)
1726: /listPtr->xScrollUnit;
1727: first = listPtr->xOffset/listPtr->xScrollUnit;
1728: last = first + windowUnits - 1;
1729: if (last < first) {
1730: last = first;
1731: }
1732: sprintf(string, " %d %d %d %d", totalUnits, windowUnits, first, last);
1733: result = Tcl_VarEval(listPtr->interp, listPtr->xScrollCmd, string,
1734: (char *) NULL);
1735: if (result != TCL_OK) {
1736: TkBindError(listPtr->interp);
1737: }
1738: }
1739:
1740: /*
1741: *----------------------------------------------------------------------
1742: *
1743: * ListboxComputeWidths --
1744: *
1745: * This procedure is invoked to completely recompute width
1746: * information used for displaying listboxes and for horizontal
1747: * scrolling.
1748: *
1749: * Results:
1750: * None.
1751: *
1752: * Side effects:
1753: * If "fontChanged" is non-zero then the widths of the individual
1754: * elements are all recomputed. In addition, listPtr->maxWidth is
1755: * recomputed.
1756: *
1757: *----------------------------------------------------------------------
1758: */
1759:
1760: static void
1761: ListboxComputeWidths(listPtr, fontChanged)
1762: Listbox *listPtr; /* Listbox whose geometry is to be
1763: * recomputed. */
1764: int fontChanged; /* Non-zero means the font may have changed
1765: * so per-element width information also
1766: * has to be computed. */
1767: {
1768: register Element *elPtr;
1769: int dummy;
1770: XCharStruct bbox;
1771:
1772: listPtr->xScrollUnit = XTextWidth(listPtr->fontPtr, "0", 1);
1773: listPtr->maxWidth = 0;
1774: for (elPtr = listPtr->elementPtr; elPtr != NULL; elPtr = elPtr->nextPtr) {
1775: if (fontChanged) {
1776: XTextExtents(listPtr->fontPtr, elPtr->text, elPtr->textLength,
1777: &dummy, &dummy, &dummy, &bbox);
1778: elPtr->lBearing = bbox.lbearing;
1779: elPtr->pixelWidth = bbox.lbearing + bbox.rbearing;
1780: }
1781: if (elPtr->pixelWidth > listPtr->maxWidth) {
1782: listPtr->maxWidth = elPtr->pixelWidth;
1783: }
1784: }
1785: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.