![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to tkcanvas.h 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 tkcanvas.h CVS log | Up to [Micropolis - Activity] / micropolis / src / tk |
1.1 root 1: /*
2: * tkCanvas.h --
3: *
4: * Declarations shared among all the files that implement
5: * canvas widgets.
6: *
7: * Copyright 1991-1992 Regents of the University of California.
8: * Permission to use, copy, modify, and distribute this
9: * software and its documentation for any purpose and without
10: * fee is hereby granted, provided that the above copyright
11: * notice appear in all copies. The University of California
12: * makes no representations about the suitability of this
13: * software for any purpose. It is provided "as is" without
14: * express or implied warranty.
15: *
16: * $Header: /user6/ouster/wish/RCS/tkCanvas.h,v 1.14 92/08/19 08:34:16 ouster Exp $ SPRITE (Berkeley)
17: */
18:
19: #ifndef _TKCANVAS
20: #define _TKCANVAS
21:
22: #ifndef _TK
23: #include "tk.h"
24: #endif
25:
26: /*
27: * For each item in a canvas widget there exists one record with
28: * the following structure. Each actual item is represented by
29: * a record with the following stuff at its beginning, plus additional
30: * type-specific stuff after that.
31: */
32:
33: #define TK_TAG_SPACE 3
34:
35: typedef struct Tk_Item {
36: int id; /* Unique identifier for this item
37: * (also serves as first tag for
38: * item). */
39: struct Tk_Item *nextPtr; /* Next in display list of all
40: * items in this canvas. Later items
41: * in list are drawn on top of earlier
42: * ones. */
43: Tk_Uid staticTagSpace[TK_TAG_SPACE];/* Built-in space for limited # of
44: * tags. */
45: Tk_Uid *tagPtr; /* Pointer to array of tags. Usually
46: * points to staticTagSpace, but
47: * may point to malloc-ed space if
48: * there are lots of tags. */
49: int tagSpace; /* Total amount of tag space available
50: * at tagPtr. */
51: int numTags; /* Number of tag slots actually used
52: * at *tagPtr. */
53: struct Tk_ItemType *typePtr; /* Table of procedures that implement
54: * this type of item. */
55: int x1, y1, x2, y2; /* Bounding box for item, in integer
56: * canvas units. Set by item-specific
57: * code and guaranteed to contain every
58: * pixel drawn in item. Item area
59: * includes x1 and y1 but not x2
60: * and y2. */
61:
62: /*
63: *------------------------------------------------------------------
64: * Starting here is additional type-specific stuff; see the
65: * declarations for individual types to see what is part of
66: * each type. The actual space below is determined by the
67: * "itemInfoSize" of the type's Tk_ItemType record.
68: *------------------------------------------------------------------
69: */
70: } Tk_Item;
71:
72: /*
73: * The record below describes a canvas widget. It is made available
74: * to the item procedures so they can access certain shared fields such
75: * as the overall displacement and scale factor for the canvas.
76: */
77:
78: typedef struct {
79: Tk_Window tkwin; /* Window that embodies the canvas. NULL
80: * means that the window has been destroyed
81: * but the data structures haven't yet been
82: * cleaned up.*/
83: Tcl_Interp *interp; /* Interpreter associated with canvas. */
84: Tk_Item *firstItemPtr; /* First in list of all items in canvas,
85: * or NULL if canvas empty. */
86: Tk_Item *lastItemPtr; /* Last in list of all items in canvas,
87: * or NULL if canvas empty. */
88:
89: /*
90: * Information used when displaying widget:
91: */
92:
93: int borderWidth; /* Width of 3-D border around window. */
94: Tk_3DBorder bgBorder; /* Used for canvas background. */
95: XColor *bgColor; /* Color used for clearing to background. */
96: int relief; /* Indicates whether window as a whole is
97: * raised, sunken, or flat. */
98: GC pixmapGC; /* Used to copy bits from a pixmap to the
99: * screen and also to clear the pixmap. */
100: int width, height; /* Dimensions to request for canvas window,
101: * specified in pixels. */
102: int redrawX1, redrawY1; /* Upper left corner of area to redraw,
103: * in pixel coordinates. Border pixels
104: * are included. Only valid if
105: * REDRAW_PENDING flag is set. */
106: int redrawX2, redrawY2; /* Lower right corner of area to redraw,
107: * in pixel coordinates. Border pixels
108: * will *not* be redrawn. */
109: int confine; /* Non-zero means constrain view to keep
110: * as much of canvas visible as possible. */
111:
112: /*
113: * Information used to manage and display selection:
114: */
115:
116: Tk_3DBorder selBorder; /* Border and background for selected
117: * characters. */
118: int selBorderWidth; /* Width of border around selection. */
119: XColor *selFgColorPtr; /* Foreground color for selected text. */
120: Tk_Item *selItemPtr; /* Pointer to selected item. NULL means
121: * selection isn't in this canvas. */
122: int selectFirst; /* Index of first selected character. */
123: int selectLast; /* Index of last selected character. */
124: Tk_Item *anchorItemPtr; /* Item corresponding to "selectAnchor":
125: * not necessarily selItemPtr. */
126: int selectAnchor; /* Fixed end of selection (i.e. "select to"
127: * operation will use this as one end of the
128: * selection). */
129:
130: /*
131: * Information for display insertion cursor in text:
132: */
133:
134: Tk_3DBorder cursorBorder; /* Used to draw vertical bar for insertion
135: * cursor. */
136: int cursorWidth; /* Total width of insertion cursor. */
137: int cursorBorderWidth; /* Width of 3-D border around insert cursor. */
138: int cursorOnTime; /* Number of milliseconds cursor should spend
139: * in "on" state for each blink. */
140: int cursorOffTime; /* Number of milliseconds cursor should spend
141: * in "off" state for each blink. */
142: Tk_TimerToken cursorBlinkHandler;
143: /* Timer handler used to blink cursor on and
144: * off. */
145: Tk_Item *focusItemPtr; /* Item that currently has the input focus,
146: * or NULL if no such item. */
147:
148: /*
149: * Transformation applied to canvas as a whole: to compute screen
150: * coordinates (X,Y) from canvas coordinates (x,y), do the following:
151: *
152: * X = x - xOrigin;
153: * Y = y - yOrigin;
154: */
155:
156: int xOrigin, yOrigin; /* Canvas coordinates corresponding to
157: * upper-left corner of window, given in
158: * canvas pixel units. */
159: int drawableXOrigin, drawableYOrigin;
160: /* During redisplay, these fields give the
161: * canvas coordinates corresponding to
162: * the upper-left corner of the drawable
163: * where items are actually being drawn
164: * (typically a pixmap smaller than the
165: * whole window). */
166:
167: /*
168: * Information used for event bindings associated with items.
169: */
170:
171: Tk_BindingTable bindingTable;
172: /* Table of all bindings currently defined
173: * for this canvas. NULL means that no
174: * bindings exist, so the table hasn't been
175: * created. Each "object" used for this
176: * table is either a Tk_Uid for a tag or
177: * the address of an item named by id. */
178: Tk_Item *currentItemPtr; /* The item currently containing the mouse
179: * pointer, or NULL if none. */
180: double closeEnough; /* The mouse is assumed to be inside an
181: * item if it is this close to it. */
182: XEvent pickEvent; /* The event upon which the current choice
183: * of currentItem is based. Must be saved
184: * so that if the currentItem is deleted,
185: * can pick another. */
186:
187: /*
188: * Information used for managing scrollbars:
189: */
190:
191: char *xScrollCmd; /* Command prefix for communicating with
192: * horizontal scrollbar. NULL means no
193: * horizontal scrollbar. Malloc'ed*/
194: char *yScrollCmd; /* Command prefix for communicating with
195: * vertical scrollbar. NULL means no
196: * vertical scrollbar. Malloc'ed*/
197: int scrollX1, scrollY1, scrollX2, scrollY2;
198: /* These four coordinates define the region
199: * that is the 100% area for scrolling (i.e.
200: * these numbers determine the size and
201: * location of the sliders on scrollbars).
202: * Units are pixels in canvas coords. */
203: char *regionString; /* The option string from which scrollX1
204: * etc. are derived. Malloc'ed. */
205: int scrollIncrement; /* The number of canvas units that the
206: * picture shifts when a scrollbar up or
207: * down arrow is pressed. */
208:
209: /*
210: * Information used for scanning:
211: */
212:
213: int scanX; /* X-position at which scan started (e.g.
214: * button was pressed here). */
215: int scanXOrigin; /* Value of xOrigin field when scan started. */
216: int scanY; /* Y-position at which scan started (e.g.
217: * button was pressed here). */
218: int scanYOrigin; /* Value of yOrigin field when scan started. */
219:
220: /*
221: * Information used to speed up searches by remembering the last item
222: * created or found with an item id search.
223: */
224:
225: Tk_Item *hotPtr; /* Pointer to "hot" item (one that's been
226: * recently used. NULL means there's no
227: * hot item. */
228: Tk_Item *hotPrevPtr; /* Pointer to predecessor to hotPtr (NULL
229: * means item is first in list). This is
230: * only a hint and may not really be hotPtr's
231: * predecessor. */
232:
233: /*
234: * Miscellaneous information:
235: */
236:
237: Cursor cursor; /* Current cursor for window, or None. */
238: double pixelsPerMM; /* Scale factor between MM and pixels;
239: * used when converting coordinates. */
240: int flags; /* Various flags; see below for
241: * definitions. */
242: int nextId; /* Number to use as id for next item
243: * created in widget. */
244: Tk_TimerToken updateTimerToken; /* Added by Don to optimize rapid
245: * updates. */
246: } Tk_Canvas;
247:
248: /*
249: * Flag bits for canvases:
250: *
251: * REDRAW_PENDING - 1 means a DoWhenIdle handler has already
252: * been created to redraw some or all of the
253: * canvas.
254: * REPICK_NEEDED - 1 means DisplayCanvas should pick a new
255: * current item before redrawing the canvas.
256: * GOT_FOCUS - 1 means the focus is currently in this
257: * widget, so should draw the insertion cursor.
258: * CURSOR_ON - 1 means the insertion cursor is in the "on"
259: * phase of its blink cycle. 0 means either
260: * we don't have the focus or the cursor is in
261: * the "off" phase of its cycle.
262: * BUTTON_DOWN - 1 means that a button is currently down;
263: * this is used to implement grabs for the
264: * duration of button presses.
265: * UPDATE_SCROLLBARS - 1 means the scrollbars should get updated
266: * as part of the next display operation.
267: */
268:
269: #define REDRAW_PENDING 1
270: #define REPICK_NEEDED 2
271: #define GOT_FOCUS 4
272: #define CURSOR_ON 8
273: #define BUTTON_DOWN 0x10
274: #define UPDATE_SCROLLBARS 0x20
275:
276: /*
277: * Records of the following type are used to describe a type of
278: * item (e.g. lines, circles, etc.) that can form part of a
279: * canvas widget.
280: */
281:
282: typedef int Tk_ItemCreateProc _ANSI_ARGS_((Tk_Canvas *canvasPtr,
283: Tk_Item *itemPtr, int argc, char **argv));
284: typedef int Tk_ItemConfigureProc _ANSI_ARGS_((Tk_Canvas *canvasPtr,
285: Tk_Item *itemPtr, int argc, char **argv, int flags));
286: typedef int Tk_ItemCoordProc _ANSI_ARGS_((Tk_Canvas *canvasPtr,
287: Tk_Item *itemPtr, int argc, char **argv));
288: typedef void Tk_ItemDeleteProc _ANSI_ARGS_((Tk_Item *itemPtr));
289: typedef void Tk_ItemDisplayProc _ANSI_ARGS_((Tk_Canvas *canvasPtr,
290: Tk_Item *itemPtr, Drawable dst));
291: typedef double Tk_ItemPointProc _ANSI_ARGS_((Tk_Canvas *canvasPtr,
292: Tk_Item *itemPtr, double *pointPtr));
293: typedef int Tk_ItemAreaProc _ANSI_ARGS_((Tk_Canvas *canvasPtr,
294: Tk_Item *itemPtr, double *rectPtr));
295: typedef void Tk_ItemPostscriptProc _ANSI_ARGS_((Tk_Canvas *canvasPtr,
296: Tk_Item *itemPtr));
297: typedef void Tk_ItemScaleProc _ANSI_ARGS_((Tk_Canvas *canvasPtr,
298: Tk_Item *itemPtr, double originX, double originY,
299: double scaleX, double scaleY));
300: typedef void Tk_ItemTranslateProc _ANSI_ARGS_((Tk_Canvas *canvasPtr,
301: Tk_Item *itemPtr, double deltaX, double deltaY));
302: typedef int Tk_ItemIndexProc _ANSI_ARGS_((Tk_Canvas *canvasPtr,
303: Tk_Item *itemPtr, char *indexString,
304: int *indexPtr));
305: typedef void Tk_ItemCursorProc _ANSI_ARGS_((Tk_Canvas *canvasPtr,
306: Tk_Item *itemPtr, int index));
307: typedef int Tk_ItemSelectionProc _ANSI_ARGS_((Tk_Canvas *canvasPtr,
308: Tk_Item *itemPtr, int offset, char *buffer,
309: int maxBytes));
310: typedef int Tk_ItemInsertProc _ANSI_ARGS_((Tk_Canvas *canvasPtr,
311: Tk_Item *itemPtr, int beforeThis, char *string));
312: typedef int Tk_ItemDCharsProc _ANSI_ARGS_((Tk_Canvas *canvasPtr,
313: Tk_Item *itemPtr, int first, int last));
314:
315: typedef struct Tk_ItemType {
316: char *name; /* The name of this type of item, such
317: * as "line". */
318: int itemSize; /* Total amount of space needed for
319: * item's record. */
320: Tk_ItemCreateProc *createProc; /* Procedure to create a new item of
321: * this type. */
322: Tk_ConfigSpec *configSpecs; /* Pointer to array of configuration
323: * specs for this type. Used for
324: * returning configuration info. */
325: Tk_ItemConfigureProc *configProc; /* Procedure to call to change
326: * configuration options. */
327: Tk_ItemCoordProc *coordProc; /* Procedure to call to get and set
328: * the item's coordinates. */
329: Tk_ItemDeleteProc *deleteProc; /* Procedure to delete existing item of
330: * this type. */
331: Tk_ItemDisplayProc *displayProc; /* Procedure to display items of
332: * this type. */
333: int alwaysRedraw; /* Non-zero means displayProc should
334: * be called even when the item has
335: * been moved off-screen. */
336: Tk_ItemPointProc *pointProc; /* Computes distance from item to
337: * a given point. */
338: Tk_ItemAreaProc *areaProc; /* Computes whether item is inside,
339: * outside, or overlapping an area. */
340: Tk_ItemPostscriptProc *postscriptProc;
341: /* Procedure to write a Postscript
342: * description for items of this
343: * type. */
344: Tk_ItemScaleProc *scaleProc; /* Procedure to rescale items of
345: * this type. */
346: Tk_ItemTranslateProc *translateProc;/* Procedure to translate items of
347: * this type. */
348: Tk_ItemIndexProc *indexProc; /* Procedure to determine index of
349: * indicated character. NULL if
350: * item doesn't support indexing. */
351: Tk_ItemCursorProc *cursorProc; /* Procedure to set cursor position
352: * to just before a given position. */
353: Tk_ItemSelectionProc *selectionProc;/* Procedure to return selection (in
354: * STRING format) when it is in this
355: * item. */
356: Tk_ItemInsertProc *insertProc; /* Procedure to insert something into
357: * an item. */
358: Tk_ItemDCharsProc *dCharsProc; /* Procedure to delete characters
359: * from an item. */
360: struct Tk_ItemType *nextPtr; /* Used to link types together into
361: * a list. */
362: } Tk_ItemType;
363:
364: /*
365: * Macros to transform a point from double-precision canvas coordinates
366: * to integer pixel coordinates in the pixmap where redisplay is being
367: * done.
368: */
369:
370: #define SCREEN_X(canvasPtr, x) \
371: (((int) ((x) + 0.5)) - (canvasPtr)->drawableXOrigin)
372: #define SCREEN_Y(canvasPtr, y) \
373: (((int) ((y) + 0.5)) - (canvasPtr)->drawableYOrigin)
374:
375: /*
376: * Canvas-related variables that are shared among Tk modules but not
377: * exported to the outside world:
378: */
379:
380: extern Tk_CustomOption tkCanvasTagsOption;
381:
382: /*
383: * Canvas-related procedures that are shared among Tk modules but not
384: * exported to the outside world:
385: */
386:
387: extern void TkBezierScreenPoints _ANSI_ARGS_((Tk_Canvas *canvasPtr,
388: double control[], int numSteps,
389: XPoint *xPointPtr));
390: extern void TkFillPolygon _ANSI_ARGS_((Tk_Canvas *canvasPtr,
391: double *coordPtr, int numPoints, Drawable drawable,
392: GC gc));
393: extern int TkGetCanvasCoord _ANSI_ARGS_((Tk_Canvas *canvasPtr,
394: char *string, double *doublePtr));
395: extern void TkIncludePoint _ANSI_ARGS_((Tk_Canvas *canvasPtr,
396: Tk_Item *itemPtr, double *pointPtr));
397: extern int TkMakeBezierCurve _ANSI_ARGS_((Tk_Canvas *canvasPtr,
398: double *pointPtr, int numPoints, int numSteps,
399: XPoint xPoints[], double dblPoints[]));
400:
401: #endif /* _TKCANVAS */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.