--- /dev/null
+/*
+ * bltTable.h --
+ *
+ * This module implements a table-based geometry manager
+ * for the BLT toolkit.
+ *
+ * Copyright 1993-1998 Lucent Technologies, Inc.
+ *
+ * Permission to use, copy, modify, and distribute this software and
+ * its documentation for any purpose and without fee is hereby
+ * granted, provided that the above copyright notice appear in all
+ * copies and that both that the copyright notice and warranty
+ * disclaimer appear in supporting documentation, and that the names
+ * of Lucent Technologies any of their entities not be used in
+ * advertising or publicity pertaining to distribution of the software
+ * without specific, written prior permission.
+ *
+ * Lucent Technologies disclaims all warranties with regard to this
+ * software, including all implied warranties of merchantability and
+ * fitness. In no event shall Lucent Technologies be liable for any
+ * special, indirect or consequential damages or any damages
+ * whatsoever resulting from loss of use, data or profits, whether in
+ * an action of contract, negligence or other tortuous action, arising
+ * out of or in connection with the use or performance of this
+ * software.
+ *
+ * The table geometry manager was created by George Howlett.
+ */
+
+#ifndef _BLT_TABLE_H
+#define _BLT_TABLE_H
+
+#include "bltChain.h"
+#include "bltHash.h"
+#include "bltList.h"
+
+typedef struct {
+ Blt_HashTable tableTable; /* Hash table of table structures keyed by
+ * the address of the reference Tk window */
+} TableInterpData;
+
+
+typedef struct EditorStruct Editor;
+typedef void (EditorDrawProc) _ANSI_ARGS_((Editor *editor));
+typedef void (EditorDestroyProc) _ANSI_ARGS_((DestroyData destroyData));
+
+struct EditorStruct {
+ int gridLineWidth;
+ int buttonHeight;
+ int entryPad;
+ int minSize; /* Minimum size to allow any partition */
+
+ EditorDrawProc *drawProc;
+ EditorDestroyProc *destroyProc;
+};
+
+#define nRows rowInfo.chainPtr->nLinks
+#define nColumns columnInfo.chainPtr->nLinks
+
+/*
+ * Limits --
+ *
+ * Defines the bounding of a size (width or height) in the table.
+ * It may be related to the partition, entry, or table size. The
+ * widget pointers are used to associate sizes with the requested
+ * size of other widgets.
+ */
+
+typedef struct {
+ int flags; /* Flags indicate whether using default
+ * values for limits or not. See flags
+ * below. */
+ int max, min; /* Values for respective limits. */
+ int nom; /* Nominal starting value. */
+ Tk_Window wMax, wMin; /* If non-NULL, represents widgets whose
+ * requested sizes will be set as limits. */
+ Tk_Window wNom; /* If non-NULL represents widget whose
+ * requested size will be the nominal
+ * size. */
+} Limits;
+
+#define LIMITS_SET_BIT 1
+#define LIMITS_SET_MIN (LIMITS_SET_BIT<<0)
+#define LIMITS_SET_MAX (LIMITS_SET_BIT<<1)
+#define LIMITS_SET_NOM (LIMITS_SET_BIT<<2)
+
+#define LIMITS_MIN 0 /* Default minimum limit */
+#define LIMITS_MAX SHRT_MAX/* Default maximum limit */
+#define LIMITS_NOM -1000 /* Default nomimal value. Indicates if a
+ * partition has received any space yet */
+
+typedef int (LimitsProc) _ANSI_ARGS_((int value, Limits *limitsPtr));
+
+/*
+ * Resize --
+ *
+ * These flags indicate in what ways each partition in a table
+ * can be resized from its default dimensions. The normal size of
+ * a row/column is the minimum amount of space needed to hold the
+ * widgets that span it. The table may then be stretched or
+ * shrunk depending if the container is larger or smaller than
+ * the table. This can occur if 1) the user resizes the toplevel
+ * widget, or 2) the container is in turn packed into a larger
+ * widget and the "fill" option is set.
+ *
+ * RESIZE_NONE - No resizing from normal size.
+ * RESIZE_EXPAND - Do not allow the size to decrease.
+ * The size may increase however.
+ * RESIZE_SHRINK - Do not allow the size to increase.
+ * The size may decrease however.
+ * RESIZE_BOTH - Allow the size to increase or
+ * decrease from the normal size.
+ * RESIZE_VIRGIN - Special case of the resize flag. Used to
+ * indicate the initial state of the flag.
+ * Empty rows/columns are treated differently
+ * if this row/column is set.
+ */
+
+#define RESIZE_NONE 0
+#define RESIZE_EXPAND (1<<0)
+#define RESIZE_SHRINK (1<<1)
+#define RESIZE_BOTH (RESIZE_EXPAND | RESIZE_SHRINK)
+#define RESIZE_VIRGIN (1<<2)
+
+/*
+ * Control --
+ */
+#define CONTROL_NORMAL 1.0 /* Consider the widget when
+ * calculating the row heights and
+ * column widths. */
+#define CONTROL_NONE 0.0 /* Ignore the widget. The height and
+ * width of the rows/columns spanned
+ * by this widget will not affected by
+ * the size of the widget.
+ */
+#define CONTROL_FULL -1.0 /* Consider only this widget when
+ * determining the column widths
+ * and row heights of the partitions
+ * it spans. */
+#define EXCL_PAD 0
+#define INCL_PAD 1
+
+typedef struct TableStruct Table;
+typedef struct RowColumnStruct RowColumn;
+
+/*
+ * Entry --
+ *
+ * An entry holds a widget and describes how the widget should
+ * appear in a range of cells.
+ * 1. padding.
+ * 2. how many rows/columns the entry spans.
+ * 3. size bounds for the widget.
+ *
+ * Several entries may start at the same cell in
+ * the table, but a entry can hold only one widget.
+ */
+
+typedef struct {
+ Tk_Window tkwin; /* Widget to be managed. */
+
+ Table *tablePtr; /* Table managing this widget */
+
+ int borderWidth; /* The external border width of
+ * the widget. This is needed to check if
+ * Tk_Changes(tkwin)->border_width changes.
+ */
+
+ int manageWhenNeeded; /* If non-zero, allow joint custody of
+ * the widget. This is for cases
+ * where the same widget may be shared
+ * between two different tables
+ * (e.g. same graph on two different
+ * notebook pages). Claim the widget
+ * only when the table is
+ * mapped. Don't destroy the entry if
+ * the table loses custody of the
+ * widget. */
+
+ Limits reqWidth, reqHeight; /* Bounds for width and height requests
+ * made by the widget. */
+ struct PositionInfo {
+ RowColumn *rcPtr; /* Row or column where this entry starts. */
+
+ int span; /* Number of rows or columns spanned. */
+ double control; /* Weight of widget in the row or column. */
+
+ Blt_ChainLink *linkPtr; /* Link to widget in the chain of spans */
+
+ Blt_Chain *chainPtr; /* Pointer to the chain of spans. */
+ } row, column;
+
+ Tk_Anchor anchor; /* Anchor type: indicates how the
+ * widget is positioned if extra space
+ * is available in the entry */
+
+ Blt_Pad padX; /* Extra padding placed left and right of the
+ * widget. */
+ Blt_Pad padY; /* Extra padding placed above and below the
+ * widget */
+
+ int ipadX, ipadY; /* Extra padding added to the interior of
+ * the widget (i.e. adds to the requested
+ * size of the widget) */
+
+ int fill; /* Indicates how the widget should
+ * fill the span of cells it occupies. */
+
+ int x, y; /* Origin of widget wrt container. */
+
+ Blt_ChainLink *linkPtr; /* Pointer into list of entries. */
+
+ Blt_HashEntry *hashPtr; /* Pointer into table of entries. */
+
+} Entry;
+
+/*
+ * RowColumn --
+ *
+ * Creates a definable space (row or column) in the table. It may
+ * have both requested minimum or maximum values which constrain
+ * the size of it.
+ */
+
+struct RowColumnStruct {
+ int index; /* Index of row or column */
+
+ int size; /* Current size of the partition. This size
+ * is bounded by minSize and maxSize. */
+
+ /*
+ * nomSize and size perform similar duties. I need to keep track
+ * of the amount of space allocated to the partition (using size).
+ * But at the same time, I need to indicate that space can be
+ * parcelled out to this partition. If a nominal size was set for
+ * this partition, I don't want to add space.
+ */
+
+ int nomSize; /* The nominal size (neither expanded
+ * nor shrunk) of the partition based
+ * upon the requested sizes of the
+ * widgets spanning this partition. */
+
+ int minSize, maxSize; /* Size constraints on the partition */
+
+ int offset; /* Offset of the partition (in pixels)
+ * from the origin of the container. */
+
+ int minSpan; /* Minimum spanning widget in
+ * partition. Used for bookkeeping
+ * when growing a span of partitions
+ * */
+
+ double weight; /* Weight of row or column */
+
+ Entry *control; /* Pointer to the entry that is
+ * determining the size of this
+ * partition. This is used to know
+ * when a partition is occupied. */
+
+ int resize; /* Indicates if the partition should
+ * shrink or expand from its nominal
+ * size. */
+
+ Blt_Pad pad; /* Pads the partition beyond its nominal
+ * size */
+
+ Limits reqSize; /* Requested bounds for the size of
+ * the partition. The partition will
+ * not expand or shrink beyond these
+ * limits, regardless of how it was
+ * specified (max widget size). This
+ * includes any extra padding which
+ * may be specified. */
+
+ int maxSpan; /* Maximum spanning widget to consider
+ * when growing a span of partitions.
+ * A value of zero indicates that all
+ * spans should be considered. */
+
+ int count;
+
+ Blt_ChainLink *linkPtr;
+
+};
+
+#define DEF_TBL_RESIZE "both"
+#define DEF_TBL_PAD "0"
+#define DEF_TBL_MAXSPAN "0"
+
+
+/*
+ * This is the default number of elements in the statically
+ * pre-allocated column and row arrays. This number should reflect a
+ * useful number of row and columns, which fit most applications.
+ */
+#define DEF_ARRAY_SIZE 32
+
+typedef Entry *(EntrySearchProc) _ANSI_ARGS_((Table *tablePtr,
+ Tk_Window tkwin));
+
+/*
+ * PartitionInfo --
+ *
+ * Manages the rows or columns of the table. Contains
+ * a chain of partitions (representing the individiual
+ * rows or columns).
+ *
+ */
+typedef struct PartitionInfo {
+ char *type; /* String identifying the type of
+ * partition: "row" or "column". */
+ Blt_Chain *chainPtr;
+ Blt_List list; /* Linked list of bins of widgets
+ * keyed by increasing span. */
+ Tk_ConfigSpec *configSpecs;
+ int reqLength;
+ int ePad; /* Extra padding for row/column
+ * needed to display editor marks */
+} PartitionInfo;
+
+/*
+ * Table structure
+ */
+struct TableStruct {
+ int flags; /* See the flags definitions below. */
+ Tk_Window tkwin; /* The container widget into which
+ * other widgets are arranged. */
+ Tcl_Interp *interp; /* Interpreter associated with all
+ * widgets */
+
+ Blt_Chain *chainPtr; /* Chain of entries in the table. */
+
+ Blt_HashTable entryTable; /* Table of entries. Serves as a
+ * directory to look up entries from
+ * widget their names. */
+ Blt_Pad padX, padY;
+
+ int propagate; /* If non-zero, the table will make a
+ * geometry request on behalf of the
+ * container widget. */
+
+ int eTablePad, eEntryPad;
+
+ PartitionInfo columnInfo;
+ PartitionInfo rowInfo; /* Manages row and column partitions */
+
+ Dim2D container; /* Last known dimenion of the container. */
+ Dim2D normal; /* Normal dimensions of the table */
+ Limits reqWidth, reqHeight; /* Constraints on the table's normal
+ * width and height */
+ Editor *editPtr; /* If non-NULL, indicates that the
+ * table is currently being edited */
+ Tcl_IdleProc *arrangeProc;
+ EntrySearchProc *findEntryProc;
+ Blt_HashEntry *hashPtr; /* Used to delete the table from its
+ * hashtable. */
+ Blt_HashTable *tablePtr;
+};
+
+/*
+ * Table flags definitions
+ */
+#define ARRANGE_PENDING (1<<0) /* A call to ArrangeTable is
+ * pending. This flag allows multiple
+ * layout changes to be requested
+ * before the table is actually
+ * reconfigured. */
+#define REQUEST_LAYOUT (1<<1) /* Get the requested sizes of the
+ * widgets before expanding/shrinking
+ * the size of the container. It's
+ * necessary to recompute the layout
+ * every time a partition or entry is
+ * added, reconfigured, or deleted,
+ * but not when the container is
+ * resized. */
+#define NON_PARENT (1<<2) /* The table is managing widgets that
+ * arern't children of the container.
+ * This requires that they are
+ * manually moved when the container
+ * is moved (a definite performance
+ * hit). */
+/*
+ * Forward declarations
+ */
+
+extern int Blt_GetTable _ANSI_ARGS_((TableInterpData *dataPtr,
+ Tcl_Interp *interp, char *pathName, Table **tablePtrPtr));
+
+#endif /* _BLT_TABLE_H */
OSDN Git Service
