source: trunk/kitgen/8.x/blt/generic/bltTable.h

Last change on this file was 175, checked in by demin, 12 years ago

initial commit
File size: 12.2 KB
Line 
1/*
2 * bltTable.h --
3 *
4 * This module implements a table-based geometry manager
5 * for the BLT toolkit.
6 *
7 * Copyright 1993-1998 Lucent Technologies, Inc.
8 *
9 * Permission to use, copy, modify, and distribute this software and
10 * its documentation for any purpose and without fee is hereby
11 * granted, provided that the above copyright notice appear in all
12 * copies and that both that the copyright notice and warranty
13 * disclaimer appear in supporting documentation, and that the names
14 * of Lucent Technologies any of their entities not be used in
15 * advertising or publicity pertaining to distribution of the software
16 * without specific, written prior permission.
17 *
18 * Lucent Technologies disclaims all warranties with regard to this
19 * software, including all implied warranties of merchantability and
20 * fitness. In no event shall Lucent Technologies be liable for any
21 * special, indirect or consequential damages or any damages
22 * whatsoever resulting from loss of use, data or profits, whether in
23 * an action of contract, negligence or other tortuous action, arising
24 * out of or in connection with the use or performance of this
25 * software.
26 *
27 * The table geometry manager was created by George Howlett.
28 */
29
30#ifndef _BLT_TABLE_H
31#define _BLT_TABLE_H
32
33#include "bltChain.h"
34#include "bltHash.h"
35#include "bltList.h"
36
37typedef struct {
38 Blt_HashTable tableTable; /* Hash table of table structures keyed by
39 * the address of the reference Tk window */
40} TableInterpData;
41
42
43typedef struct EditorStruct Editor;
44typedef void (EditorDrawProc) _ANSI_ARGS_((Editor *editor));
45typedef void (EditorDestroyProc) _ANSI_ARGS_((DestroyData destroyData));
46
47struct EditorStruct {
48 int gridLineWidth;
49 int buttonHeight;
50 int entryPad;
51 int minSize; /* Minimum size to allow any partition */
52
53 EditorDrawProc *drawProc;
54 EditorDestroyProc *destroyProc;
55};
56
57#define nRows rowInfo.chainPtr->nLinks
58#define nColumns columnInfo.chainPtr->nLinks
59
60/*
61 * Limits --
62 *
63 * Defines the bounding of a size (width or height) in the table.
64 * It may be related to the partition, entry, or table size. The
65 * widget pointers are used to associate sizes with the requested
66 * size of other widgets.
67 */
68
69typedef struct {
70 int flags; /* Flags indicate whether using default
71 * values for limits or not. See flags
72 * below. */
73 int max, min; /* Values for respective limits. */
74 int nom; /* Nominal starting value. */
75 Tk_Window wMax, wMin; /* If non-NULL, represents widgets whose
76 * requested sizes will be set as limits. */
77 Tk_Window wNom; /* If non-NULL represents widget whose
78 * requested size will be the nominal
79 * size. */
80} Limits;
81
82#define LIMITS_SET_BIT 1
83#define LIMITS_SET_MIN (LIMITS_SET_BIT<<0)
84#define LIMITS_SET_MAX (LIMITS_SET_BIT<<1)
85#define LIMITS_SET_NOM (LIMITS_SET_BIT<<2)
86
87#define LIMITS_MIN 0 /* Default minimum limit */
88#define LIMITS_MAX SHRT_MAX/* Default maximum limit */
89#define LIMITS_NOM -1000 /* Default nomimal value. Indicates if a
90 * partition has received any space yet */
91
92typedef int (LimitsProc) _ANSI_ARGS_((int value, Limits *limitsPtr));
93
94/*
95 * Resize --
96 *
97 * These flags indicate in what ways each partition in a table
98 * can be resized from its default dimensions. The normal size of
99 * a row/column is the minimum amount of space needed to hold the
100 * widgets that span it. The table may then be stretched or
101 * shrunk depending if the container is larger or smaller than
102 * the table. This can occur if 1) the user resizes the toplevel
103 * widget, or 2) the container is in turn packed into a larger
104 * widget and the "fill" option is set.
105 *
106 * RESIZE_NONE - No resizing from normal size.
107 * RESIZE_EXPAND - Do not allow the size to decrease.
108 * The size may increase however.
109 * RESIZE_SHRINK - Do not allow the size to increase.
110 * The size may decrease however.
111 * RESIZE_BOTH - Allow the size to increase or
112 * decrease from the normal size.
113 * RESIZE_VIRGIN - Special case of the resize flag. Used to
114 * indicate the initial state of the flag.
115 * Empty rows/columns are treated differently
116 * if this row/column is set.
117 */
118
119#define RESIZE_NONE 0
120#define RESIZE_EXPAND (1<<0)
121#define RESIZE_SHRINK (1<<1)
122#define RESIZE_BOTH (RESIZE_EXPAND | RESIZE_SHRINK)
123#define RESIZE_VIRGIN (1<<2)
124
125/*
126 * Control --
127 */
128#define CONTROL_NORMAL 1.0 /* Consider the widget when
129 * calculating the row heights and
130 * column widths. */
131#define CONTROL_NONE 0.0 /* Ignore the widget. The height and
132 * width of the rows/columns spanned
133 * by this widget will not affected by
134 * the size of the widget.
135 */
136#define CONTROL_FULL -1.0 /* Consider only this widget when
137 * determining the column widths
138 * and row heights of the partitions
139 * it spans. */
140#define EXCL_PAD 0
141#define INCL_PAD 1
142
143typedef struct TableStruct Table;
144typedef struct RowColumnStruct RowColumn;
145
146/*
147 * Entry --
148 *
149 * An entry holds a widget and describes how the widget should
150 * appear in a range of cells.
151 * 1. padding.
152 * 2. how many rows/columns the entry spans.
153 * 3. size bounds for the widget.
154 *
155 * Several entries may start at the same cell in
156 * the table, but a entry can hold only one widget.
157 */
158
159typedef struct {
160 Tk_Window tkwin; /* Widget to be managed. */
161
162 Table *tablePtr; /* Table managing this widget */
163
164 int borderWidth; /* The external border width of
165 * the widget. This is needed to check if
166 * Tk_Changes(tkwin)->border_width changes.
167 */
168
169 int manageWhenNeeded; /* If non-zero, allow joint custody of
170 * the widget. This is for cases
171 * where the same widget may be shared
172 * between two different tables
173 * (e.g. same graph on two different
174 * notebook pages). Claim the widget
175 * only when the table is
176 * mapped. Don't destroy the entry if
177 * the table loses custody of the
178 * widget. */
179
180 Limits reqWidth, reqHeight; /* Bounds for width and height requests
181 * made by the widget. */
182 struct PositionInfo {
183 RowColumn *rcPtr; /* Row or column where this entry starts. */
184
185 int span; /* Number of rows or columns spanned. */
186 double control; /* Weight of widget in the row or column. */
187
188 Blt_ChainLink *linkPtr; /* Link to widget in the chain of spans */
189
190 Blt_Chain *chainPtr; /* Pointer to the chain of spans. */
191 } row, column;
192
193 Tk_Anchor anchor; /* Anchor type: indicates how the
194 * widget is positioned if extra space
195 * is available in the entry */
196
197 Blt_Pad padX; /* Extra padding placed left and right of the
198 * widget. */
199 Blt_Pad padY; /* Extra padding placed above and below the
200 * widget */
201
202 int ipadX, ipadY; /* Extra padding added to the interior of
203 * the widget (i.e. adds to the requested
204 * size of the widget) */
205
206 int fill; /* Indicates how the widget should
207 * fill the span of cells it occupies. */
208
209 int x, y; /* Origin of widget wrt container. */
210
211 Blt_ChainLink *linkPtr; /* Pointer into list of entries. */
212
213 Blt_HashEntry *hashPtr; /* Pointer into table of entries. */
214
215} Entry;
216
217/*
218 * RowColumn --
219 *
220 * Creates a definable space (row or column) in the table. It may
221 * have both requested minimum or maximum values which constrain
222 * the size of it.
223 */
224
225struct RowColumnStruct {
226 int index; /* Index of row or column */
227
228 int size; /* Current size of the partition. This size
229 * is bounded by minSize and maxSize. */
230
231 /*
232 * nomSize and size perform similar duties. I need to keep track
233 * of the amount of space allocated to the partition (using size).
234 * But at the same time, I need to indicate that space can be
235 * parcelled out to this partition. If a nominal size was set for
236 * this partition, I don't want to add space.
237 */
238
239 int nomSize; /* The nominal size (neither expanded
240 * nor shrunk) of the partition based
241 * upon the requested sizes of the
242 * widgets spanning this partition. */
243
244 int minSize, maxSize; /* Size constraints on the partition */
245
246 int offset; /* Offset of the partition (in pixels)
247 * from the origin of the container. */
248
249 int minSpan; /* Minimum spanning widget in
250 * partition. Used for bookkeeping
251 * when growing a span of partitions
252 * */
253
254 double weight; /* Weight of row or column */
255
256 Entry *control; /* Pointer to the entry that is
257 * determining the size of this
258 * partition. This is used to know
259 * when a partition is occupied. */
260
261 int resize; /* Indicates if the partition should
262 * shrink or expand from its nominal
263 * size. */
264
265 Blt_Pad pad; /* Pads the partition beyond its nominal
266 * size */
267
268 Limits reqSize; /* Requested bounds for the size of
269 * the partition. The partition will
270 * not expand or shrink beyond these
271 * limits, regardless of how it was
272 * specified (max widget size). This
273 * includes any extra padding which
274 * may be specified. */
275
276 int maxSpan; /* Maximum spanning widget to consider
277 * when growing a span of partitions.
278 * A value of zero indicates that all
279 * spans should be considered. */
280
281 int count;
282
283 Blt_ChainLink *linkPtr;
284
285};
286
287#define DEF_TBL_RESIZE "both"
288#define DEF_TBL_PAD "0"
289#define DEF_TBL_MAXSPAN "0"
290
291
292/*
293 * This is the default number of elements in the statically
294 * pre-allocated column and row arrays. This number should reflect a
295 * useful number of row and columns, which fit most applications.
296 */
297#define DEF_ARRAY_SIZE 32
298
299typedef Entry *(EntrySearchProc) _ANSI_ARGS_((Table *tablePtr,
300 Tk_Window tkwin));
301
302/*
303 * PartitionInfo --
304 *
305 * Manages the rows or columns of the table. Contains
306 * a chain of partitions (representing the individiual
307 * rows or columns).
308 *
309 */
310typedef struct PartitionInfo {
311 char *type; /* String identifying the type of
312 * partition: "row" or "column". */
313 Blt_Chain *chainPtr;
314 Blt_List list; /* Linked list of bins of widgets
315 * keyed by increasing span. */
316 Tk_ConfigSpec *configSpecs;
317 int reqLength;
318 int ePad; /* Extra padding for row/column
319 * needed to display editor marks */
320} PartitionInfo;
321
322/*
323 * Table structure
324 */
325struct TableStruct {
326 int flags; /* See the flags definitions below. */
327 Tk_Window tkwin; /* The container widget into which
328 * other widgets are arranged. */
329 Tcl_Interp *interp; /* Interpreter associated with all
330 * widgets */
331
332 Blt_Chain *chainPtr; /* Chain of entries in the table. */
333
334 Blt_HashTable entryTable; /* Table of entries. Serves as a
335 * directory to look up entries from
336 * widget their names. */
337 Blt_Pad padX, padY;
338
339 int propagate; /* If non-zero, the table will make a
340 * geometry request on behalf of the
341 * container widget. */
342
343 int eTablePad, eEntryPad;
344
345 PartitionInfo columnInfo;
346 PartitionInfo rowInfo; /* Manages row and column partitions */
347
348 Dim2D container; /* Last known dimenion of the container. */
349 Dim2D normal; /* Normal dimensions of the table */
350 Limits reqWidth, reqHeight; /* Constraints on the table's normal
351 * width and height */
352 Editor *editPtr; /* If non-NULL, indicates that the
353 * table is currently being edited */
354 Tcl_IdleProc *arrangeProc;
355 EntrySearchProc *findEntryProc;
356 Blt_HashEntry *hashPtr; /* Used to delete the table from its
357 * hashtable. */
358 Blt_HashTable *tablePtr;
359};
360
361/*
362 * Table flags definitions
363 */
364#define ARRANGE_PENDING (1<<0) /* A call to ArrangeTable is
365 * pending. This flag allows multiple
366 * layout changes to be requested
367 * before the table is actually
368 * reconfigured. */
369#define REQUEST_LAYOUT (1<<1) /* Get the requested sizes of the
370 * widgets before expanding/shrinking
371 * the size of the container. It's
372 * necessary to recompute the layout
373 * every time a partition or entry is
374 * added, reconfigured, or deleted,
375 * but not when the container is
376 * resized. */
377#define NON_PARENT (1<<2) /* The table is managing widgets that
378 * arern't children of the container.
379 * This requires that they are
380 * manually moved when the container
381 * is moved (a definite performance
382 * hit). */
383/*
384 * Forward declarations
385 */
386
387extern int Blt_GetTable _ANSI_ARGS_((TableInterpData *dataPtr,
388 Tcl_Interp *interp, char *pathName, Table **tablePtrPtr));
389
390#endif /* _BLT_TABLE_H */
Note: See TracBrowser for help on using the repository browser.