This is MiscTableTypes.h in view mode; [Download] [Up]
#ifndef __MiscTableTypes_h
#define __MiscTableTypes_h
//=============================================================================
//
// Copyright (C) 1995-1997 by Paul S. McCarthy and Eric Sunshine.
// Written by Paul S. McCarthy and Eric Sunshine.
// All Rights Reserved.
//
// This notice may not be removed from this source code.
//
// This object is included in the MiscKit by permission from the authors
// and its use is governed by the MiscKit license, found in the file
// "License.rtf" in the MiscKit distribution. Please refer to that file
// for a list of all applicable permissions and restrictions.
//
//=============================================================================
//-----------------------------------------------------------------------------
// <MiscTableTypes.h>
//
// Common types used for the MiscTableScroll object.
//
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// $Id: MiscTableTypes.h,v 1.11 97/06/18 10:03:06 sunshine Exp $
// $Log: MiscTableTypes.h,v $
// Revision 1.11 97/06/18 10:03:06 sunshine
// v125.9: MISC_TABLE_CELL_ICON --> MISC_TABLE_CELL_IMAGE.
//
// Revision 1.10 97/04/01 07:58:18 sunshine
// v0.125.5: Fixed bug: MiscDefaultCompareSlotFunc was being declared as a
// pointer to a function rather than a function.
//
// Revision 1.9 97/03/10 10:43:44 sunshine
// v113.1: For better OpenStep conformance, many 'func' methods renamed to
// 'function'.
//-----------------------------------------------------------------------------
#ifdef __cplusplus
# define MISC_TS_EXTERN_BEGIN(X) extern X {
# define MISC_TS_EXTERN_END }
# define MISC_TS_CLASS_DEF(X) class X
#else
# define MISC_TS_EXTERN_BEGIN(X)
# define MISC_TS_EXTERN_END
# define MISC_TS_CLASS_DEF(X) typedef struct X X
#endif
MISC_TS_EXTERN_BEGIN( "Objective-C" )
#import <objc/zone.h>
#import <AppKit/NSGraphics.h>
MISC_TS_EXTERN_END
typedef int MiscPixels;
typedef int MiscCoord_V; // Visual coordinate.
typedef int MiscCoord_P; // Physical coordinate.
#define MISC_MIN_PIXELS_SIZE ((MiscPixels) 10)
#define MISC_MAX_PIXELS_SIZE ((MiscPixels) 0x7FFF0000)
typedef enum
{
MISC_COL_BORDER,
MISC_ROW_BORDER
} MiscBorderType;
#define MISC_MAX_BORDER MISC_ROW_BORDER
#define MISC_OTHER_BORDER(B) \
(B == MISC_ROW_BORDER ? MISC_COL_BORDER : MISC_ROW_BORDER)
typedef struct
{
NSSize page_size; // [NSPrintInfo paperSize]
NSRect print_rect; // MiscTableView rect.
MiscCoord_V first_print_row;// one's comp if started on prev page.
MiscCoord_V last_print_row; // one's comp if ends on later page.
MiscCoord_V first_print_col;// one's comp if started on prev page.
MiscCoord_V last_print_col; // one's comp if ends on later page.
int print_page; // 1 <= print_page <= num_print_pages
int print_row; // 1 <= print_row <= num_print_rows
int print_col; // 1 <= print_col <= num_print_cols
int num_print_pages;
int num_print_rows;
int num_print_cols;
double scale_factor;
BOOL is_scaled;
} MiscTablePrintInfo;
typedef enum
{
MISC_NO_TITLE, // No titles on row/col cells.
MISC_NUMBER_TITLE, // Titles are sequential numbers.
MISC_ALPHA_TITLE, // Titles are sequential alphabetics...
MISC_CUSTOM_TITLE, // Titles are user-supplied strings...
MISC_DELEGATE_TITLE // Ask the delegate for titles.
} MiscTableTitleMode;
#define MISC_MAX_TITLE MISC_DELEGATE_TITLE
typedef enum
{
MISC_LIST_MODE,
MISC_RADIO_MODE,
MISC_HIGHLIGHT_MODE
} MiscSelectionMode;
#define MISC_MAX_MODE MISC_HIGHLIGHT_MODE
typedef enum
{
MISC_TABLE_CELL_TEXT,
MISC_TABLE_CELL_IMAGE,
MISC_TABLE_CELL_BUTTON,
MISC_TABLE_CELL_CALLBACK
} MiscTableCellStyle;
#define MISC_TABLE_CELL_MAX MISC_TABLE_CELL_CALLBACK
#define MISC_SIZING_SPRINGY_BIT (1 << 0) // Adjusts for global limits.
#define MISC_SIZING_DATA_BIT (1 << 1) // Expands to size of data.
#define MISC_SIZING_USER_BIT (1 << 2) // User can resize.
typedef enum
{
MISC_NUSER_NDATA_NSPRINGY_SIZING,
MISC_NUSER_NDATA_SPRINGY_SIZING,
MISC_NUSER_DATA_NSPRINGY_SIZING,
MISC_NUSER_DATA_SPRINGY_SIZING,
MISC_USER_NDATA_NSPRINGY_SIZING,
MISC_USER_NDATA_SPRINGY_SIZING,
MISC_USER_DATA_NSPRINGY_SIZING,
MISC_USER_DATA_SPRINGY_SIZING,
} MiscTableSizing;
#define MISC_MAX_SIZING MISC_USER_DATA_SPRINGY_SIZING
typedef enum
{
MISC_SORT_ASCENDING,
MISC_SORT_DESCENDING
} MiscSortDirection;
#define MISC_SORT_DIR_MAX MISC_SORT_DESCENDING
#define MISC_OTHER_DIRECTION(D)\
((D) == MISC_SORT_DESCENDING ? \
MISC_SORT_ASCENDING : MISC_SORT_DESCENDING)
typedef enum // Selector used to get data:
{
MISC_SORT_STRING_CASE_INSENSITIVE, // 0 -stringValue
MISC_SORT_STRING_CASE_SENSITIVE, // 1 -stringValue
MISC_SORT_INT, // 2 -intValue
MISC_SORT_UNSIGNED_INT, // 3 -intValue
MISC_SORT_TAG, // 4 -tag
MISC_SORT_UNSIGNED_TAG, // 5 -tag
MISC_SORT_FLOAT, // 6 -floatValue
MISC_SORT_DOUBLE, // 7 -doubleValue
MISC_SORT_SKIP, // 8 Don't compare cells in this slot.
MISC_SORT_TITLE_CASE_INSENSITIVE, // 9 -title
MISC_SORT_TITLE_CASE_SENSITIVE, // 10 -title
MISC_SORT_STATE, // 11 -state
MISC_SORT_UNSIGNED_STATE, // 12 -state
} MiscSortType;
#define MISC_SORT_TYPE_MAX MISC_SORT_UNSIGNED_STATE
#define MISC_SORT_CUSTOM ((MiscSortType)(int(MISC_SORT_TYPE_MAX) + 1))
@class MiscTableScroll;
typedef struct MiscEntrySortInfo MiscEntrySortInfo;
typedef struct MiscSlotSortInfo MiscSlotSortInfo;
//-----------------------------------------------------------------------------
// MiscCompareEntryFunc
//
// Compare two cells, given the coordinates of the cells, and a pointer
// to the sorting information structure. This is the prototype for
// custom sort functions that you write, and install with
// -border:setSlot:sortFunction:, -setColumn:sortFunction:,
// or -setRow:sortFunction:.
//
// Returns:
// < 0 if (table[r1][c1] < table[r2][c2])
// = 0 if (table[r1][c1] = table[r2][c2])
// > 0 if (table[r1][c1] > table[r2][c2])
//
// When sorting rows:
// info->border_type == MISC_COL_BORDER, col1 == col2
//
// When sorting columns:
// info->border_type == MISC_ROW_BORDER, row1 == row2
//
// Always return the result of an "ascending" comparison. The
// caller is responsible for choosing the sort direction.
//
// WARNING:
// If info->need_copy is YES, you must copy the information from
// the first cell *BEFORE* accessing the second cell. (This happens
// with lazy tables that provide only a single buffer.) Failure to
// do so will result in catastrophic worst-case performance and will
// not sort the table.
//-----------------------------------------------------------------------------
typedef int (*MiscCompareEntryFunc)
( int r1, int c1, int r2, int c2,
MiscEntrySortInfo const* entry_info,
MiscSlotSortInfo* sort_info );
//-----------------------------------------------------------------------------
// MiscCompareSlotFunc
//
// Compare two entire slots (usually rows) from the table.
//
// Returns:
// < 0 if (table.b[slot1] < table.b[slot2])
// = 0 if (table.b[slot1] = table.b[slot2])
// > 0 if (table.b[slot1] > table.b[slot2])
//
// The default version, MiscDefaultComareSlotFunc(), compares the
// slots, one entry at a time, using the sorting information
// structure.
//
// You can install a customized replacement via -setCompareSlotFunction:
//
// This routine is responsible for honoring the slot-sort-vector (order
// in which columns/rows are visited), applying the sort-direction
// (ascending/descending), and calling user-installed custom
// slot-sort-funcs.
//-----------------------------------------------------------------------------
typedef int (*MiscCompareSlotFunc)
( int slot1, int slot2, MiscSlotSortInfo* );
extern int MiscDefaultCompareSlotFunc( int, int, MiscSlotSortInfo* );
//-----------------------------------------------------------------------------
// MiscSlotSortInfo
//
// This structure provides the sorting information used by the
// MiscDefaultCompareSlotFunc() function. This structure is properly
// intialized by the -sortInfoInit:border: method, and storage is
// reclaimed by the -sortInfoDone: method. The initialization and
// cleanup is handled automatically by the sorting and comparison
// methods that do NOT accept an "info" argument. You are responsible
// for calling -sortInfoInit:border: and -sortInfoDone: when you call
// any of the methods that DO accept an 'info' argument.
//
// Order in which entries are visited:
// If you have installed a slot-sort-vector for the "other" border, that
// will determine the order in which entries are compared. If you have
// not installed a slot-sort-vector, the current visual order is used.
// This information is stored in num_entries and entry_info[].slot
//
// Sort direction:
// Each entry (slot from the "other" border) has a sort direction which
// is either ascending or descending. This is the basis for determining
// the sort direction of an entry. In addition, if you have installed
// a slot-sort-vector, and any of the elements of that slot-sort-vector
// are negative, they will reverse the sort direction of that entry.
// (If the sort-direction for the entry is ascending, a negative index
// will cause that entry to be sorted in descending order. If the
// sort-direction for the entry is descending, a negative index will
// cause that entry to be sorted in ascending order.) This information
// is stored in entry_info[].ascending.
//
// Comparison function:
// If you have installed a custom comparison function for the entry
// (slot from the "other" border), your custom comparison function will
// be used. Otherwise, an internal comparison function will be selected
// based on the "sort-type" for the entry. The address of the function
// is stored in entry_info[].compare_func.
//
// struct MiscSlotSortInfo
//
// table_scroll The MiscTableScroll being used.
//
// zone This is [table_scroll zone]. The zone that
// is used for allocation of the entry_info[]
// buff[] arrays.
//
// border_type The "other" border. When rows are being
// compared, this is MISC_COL_BORDER. When
// comparing columns, this is MISC_ROW_BORDER.
//
// num_entries The number of entries that will be compared.
// Normally, this is the number of slots in
// the "border_type" border (usually, the number
// of columns). This can be different if you
// have installed a slot-sort-vector.
//
// entry_info An array of sorting information for each
// entry in a slot. This information is
// precomputed in -sortInfoInit:border: for
// use by MiscDefaultCompareSlotFunc().
//
// need_copy Flag indicating whether information from the
// the first entry (cell) must be copied before
// accessing the second entry (cell). This is
// YES when table_scroll is lazy and supplies
// only a single buffer.
//
// struct MiscEntrySortInfo
//
// slot The original (physical) index of the slot that
// this entry corresponds to.
//
// ascending Sort direction: 1=ascending, 0=descending.
//
// value_func The address of the function that will be
// value_target called to get the values for the comparison.
// value_sel The function must match the argument pattern
// of the -tableScroll:intValueAtRow:column:
// method, but the data-type of the return value
// depends on the sort-type of the slot. The
// -sortInfoInit:border: method determines which
// object will supply the values for the slot
// (value_target), and which message should be
// used to retrieve the value (value_sel). Then
// it calls [value_target methodFor:value_sel] to
// get the address of the function (value_func).
// The value_func is called directly during
// sorting, rather than going through the normal
// Objective-C dispatch.
//
// value_obj The object that will be passed as the
// 'tableScroll:' argument to the 'value_func'
// function. This is usually the table scroll
// itself.
//
// cell_at_func Address of the tableScroll:cellAtRow:column:
// function.
// cell_class Last cell class seen in this slot.
// cell_sel Selector to extract value (intValue,etc.)
// cell_func Address of the cell's cell_sel function.
//
// sort_type The sort-type for this slot.
//
// compare_func Comparison function to use for this slot.
//
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// MISC_TS_TYPE_AT
// This macro generates a function prototype typedef that describes the
// methods used to retrieve the values for comparison during sorting.
// The macro is used to generate function prototypes for each data-type
// that can be compared. These prototypes describe the arguments passed
// to a function that has the same format as the following standard
// delegate message:
// - (int) tableScroll:(MiscTableScroll*)tableScroll
// intValueAtRow:(int)row column:(int)col
// The data-type for the return value is different for each of the
// data-types.
//-----------------------------------------------------------------------------
#define MISC_TS_TYPE_AT( TYPE, NAME ) \
typedef TYPE (*MISC_TS_##NAME##_AT)(id,SEL,id,int r,int c, ...);
MISC_TS_TYPE_AT( int, INT ) // MISC_TS_INT_AT
MISC_TS_TYPE_AT( float, FLOAT ) // MISC_TS_FLOAT_AT
MISC_TS_TYPE_AT( double, DOUBLE ) // MISC_TS_DOUBLE_AT
MISC_TS_TYPE_AT( NSString*, STRING ) // MISC_TS_STRING_AT
typedef union
{
MISC_TS_INT_AT i;
MISC_TS_FLOAT_AT f;
MISC_TS_DOUBLE_AT d;
MISC_TS_STRING_AT s;
} MISC_TS_VAL_AT_FUNC;
//-----------------------------------------------------------------------------
// MISC_TS_TYPE_VAL
// This macro generates a function prototype typedef that describes
// the value-access methods for a cell. They match the following
// pattern:
// - (int) intValue
// The data-type for the return value is different for each.
//-----------------------------------------------------------------------------
#define MISC_TS_TYPE_VAL( TYPE, NAME ) \
typedef TYPE (*MISC_TS_##NAME##_VAL)(id,SEL);
MISC_TS_TYPE_VAL( int, INT ) // MISC_TS_INT_VAL
MISC_TS_TYPE_VAL( float, FLOAT ) // MISC_TS_FLOAT_VAL
MISC_TS_TYPE_VAL( double, DOUBLE ) // MISC_TS_DOUBLE_VAL
MISC_TS_TYPE_VAL( NSString*, STRING ) // MISC_TS_STRING_VAL
typedef union
{
MISC_TS_INT_VAL i;
MISC_TS_FLOAT_VAL f;
MISC_TS_DOUBLE_VAL d;
MISC_TS_STRING_VAL s;
} MISC_TS_VAL_FUNC;
// *** WARNING ***
// The sizes of these structures are likely to change between versions.
// *** WARNING ***
struct MiscEntrySortInfo
{
int slot;
int ascending;
MISC_TS_VAL_AT_FUNC value_func;
id value_target;
SEL value_sel;
id value_obj;
IMP cell_at_func;
id cell_class;
SEL cell_sel;
MISC_TS_VAL_FUNC cell_func;
MiscSortType sort_type;
MiscCompareEntryFunc compare_func;
};
struct MiscSlotSortInfo
{
MiscTableScroll* table_scroll;
NSZone* zone;
MiscBorderType border_type;
int num_entries;
MiscEntrySortInfo const* entry_info;
BOOL need_copy;
};
#endif // __MiscTableTypes_h
These are the contents of the former NiCE NeXT User Group NeXTSTEP/OpenStep software archive, currently hosted by Netfuture.ch.