|
Mac OS 9
|
List Manager Interfaces. More...
Go to the source code of this file.
Data Structures | |
| struct | ListRec |
| struct | StandardIconListCellDataRec |
| struct | ListDefSpec |
Macros | |
| #define | NewListSearchUPP(userRoutine) |
| #define | NewListClickLoopUPP(userRoutine) |
| #define | NewListDefUPP(userRoutine) |
| #define | DisposeListSearchUPP(userUPP) DisposeRoutineDescriptor(userUPP) |
| #define | DisposeListClickLoopUPP(userUPP) DisposeRoutineDescriptor(userUPP) |
| #define | DisposeListDefUPP(userUPP) DisposeRoutineDescriptor(userUPP) |
| #define | InvokeListSearchUPP(aPtr, bPtr, aLen, bLen, userUPP) |
| #define | InvokeListClickLoopUPP(userUPP) (Boolean) CALL_ZERO_PARAMETER_UPP((userUPP), uppListClickLoopProcInfo) |
| #define | InvokeListDefUPP(lMessage, lSelect, lRect, lCell, lDataOffset, lDataLen, lHandle, userUPP) |
| #define | NewListSearchProc(userRoutine) NewListSearchUPP(userRoutine) |
| #define | NewListClickLoopProc(userRoutine) NewListClickLoopUPP(userRoutine) |
| #define | NewListDefProc(userRoutine) NewListDefUPP(userRoutine) |
| #define | CallListSearchProc(userRoutine, aPtr, bPtr, aLen, bLen) InvokeListSearchUPP(aPtr, bPtr, aLen, bLen, userRoutine) |
| #define | CallListClickLoopProc(userRoutine) InvokeListClickLoopUPP(userRoutine) |
| #define | CallListDefProc(userRoutine, lMessage, lSelect, lRect, lCell, lDataOffset, lDataLen, lHandle) |
Typedefs | |
| typedef Point | Cell |
| typedef Rect | ListBounds |
| typedef char | DataArray[32001] |
| typedef char * | DataPtr |
| typedef DataPtr * | DataHandle |
| typedef Ptr | bPtr |
| typedef Ptr short | aLen |
| typedef Ptr short short | bLen |
| typedef long | ListNotification |
| typedef struct ListRec | ListRec |
| typedef ListRec * | ListPtr |
| typedef ListPtr * | ListHandle |
| typedef ListHandle | ListRef |
| typedef struct StandardIconListCellDataRec | StandardIconListCellDataRec |
| typedef StandardIconListCellDataRec * | StandardIconListCellDataPtr |
| typedef Boolean | lSelect |
| typedef Boolean Rect * | lRect |
| typedef Boolean Rect Cell | lCell |
| typedef Boolean Rect Cell short | lDataOffset |
| typedef Boolean Rect Cell short short | lDataLen |
| typedef Boolean Rect Cell short short ListHandle | lHandle |
| typedef UInt32 | ListDefType |
| typedef struct ListDefSpec | ListDefSpec |
| typedef ListDefSpec * | ListDefSpecPtr |
| typedef ListNotification | notification |
| typedef ListNotification long | param |
| typedef ListNotificationProcPtr | ListNotificationUPP |
Enumerations | |
| enum | { listNotifyNothing = FOUR_CHAR_CODE('nada') , listNotifyClick = FOUR_CHAR_CODE('clik') , listNotifyDoubleClick , listNotifyPreClick = FOUR_CHAR_CODE('pclk') } |
| enum | { lDrawingModeOffBit = 3 , lDoVAutoscrollBit = 1 , lDoHAutoscrollBit = 0 } |
| enum | { lDrawingModeOff = 8 , lDoVAutoscroll = 2 , lDoHAutoscroll = 1 } |
| enum | { lOnlyOneBit = 7 , lExtendDragBit = 6 , lNoDisjointBit = 5 , lNoExtendBit = 4 , lNoRectBit = 3 , lUseSenseBit = 2 , lNoNilHiliteBit = 1 } |
| enum | { lOnlyOne = -128 , lExtendDrag = 64 , lNoDisjoint = 32 , lNoExtend = 16 , lNoRect = 8 , lUseSense = 4 , lNoNilHilite = 2 } |
| enum | { lInitMsg = 0 , lDrawMsg = 1 , lHiliteMsg = 2 , lCloseMsg = 3 } |
| enum | { uppListSearchProcInfo = 0x00002BE0 } |
| enum | { uppListClickLoopProcInfo = 0x00000012 } |
| enum | { uppListDefProcInfo = 0x000EBD80 } |
| enum | { kListDefProcPtr = 0 , kListDefUserProcType = kListDefProcPtr , kListDefStandardTextType = 1 , kListDefStandardIconType = 2 } |
Functions | |
| typedef | CALLBACK_API (short, ListSearchProcPtr)(Ptr aPtr |
| typedef | CALLBACK_API_REGISTER68K (Boolean, ListClickLoopProcPtr,(void)) |
| typedef | STACK_UPP_TYPE (ListSearchProcPtr) ListSearchUPP |
| typedef | REGISTER_UPP_TYPE (ListClickLoopProcPtr) ListClickLoopUPP |
| typedef | CALLBACK_API (void, ListDefProcPtr)(short lMessage |
| typedef | STACK_UPP_TYPE (ListDefProcPtr) ListDefUPP |
| ListSearchUPP | NewListSearchUPP (ListSearchProcPtr userRoutine) |
| ListClickLoopUPP | NewListClickLoopUPP (ListClickLoopProcPtr userRoutine) |
| ListDefUPP | NewListDefUPP (ListDefProcPtr userRoutine) |
| void | DisposeListSearchUPP (ListSearchUPP userUPP) |
| void | DisposeListClickLoopUPP (ListClickLoopUPP userUPP) |
| void | DisposeListDefUPP (ListDefUPP userUPP) |
| short | InvokeListSearchUPP (Ptr aPtr, Ptr bPtr, short aLen, short bLen, ListSearchUPP userUPP) |
| Boolean | InvokeListClickLoopUPP (ListClickLoopUPP userUPP) |
| void | InvokeListDefUPP (short lMessage, Boolean lSelect, Rect *lRect, Cell lCell, short lDataOffset, short lDataLen, ListHandle lHandle, ListDefUPP userUPP) |
| OSStatus | CreateCustomList (const Rect *rView, const ListBounds *dataBounds, Point cellSize, const ListDefSpec *theSpec, WindowRef theWindow, Boolean drawIt, Boolean hasGrow, Boolean scrollHoriz, Boolean scrollVert, ListHandle *outList) |
| typedef | CALLBACK_API (void, ListNotificationProcPtr)(ListHandle theList |
| void | LSetNotificationCallback (ListNotificationProcPtr callBack, ListHandle lHandle) |
| void | GetListVisibleBounds (ListHandle theList, Rect *visibleBounds) |
| ListHandle | LNew (const Rect *rView, const ListBounds *dataBounds, Point cSize, short theProc, WindowRef theWindow, Boolean drawIt, Boolean hasGrow, Boolean scrollHoriz, Boolean scrollVert) |
| void | LDispose (ListHandle lHandle) |
| Discard a list and release all its memory. More... | |
| Boolean | LGetSelect (Boolean next, Cell *theCell, ListHandle lHandle) |
| Insert column(s) of empty cells into a list. More... | |
| Cell | LLastClick (ListHandle lHandle) |
| Query which cell was clicked last. More... | |
Variables | |
| </pre > *par | Copyright |
| Query which cell is next in a list. More... | |
| </pre > *par Boolean | vNext |
| </pre > *par Boolean Cell * | theCell |
List Manager Interfaces.
For bug reports, consult the following page on the World Wide Web:
http://developer.apple.com/bugreporter/
| #define CallListDefProc | ( | userRoutine, | |
| lMessage, | |||
| lSelect, | |||
| lRect, | |||
| lCell, | |||
| lDataOffset, | |||
| lDataLen, | |||
| lHandle | |||
| ) |
| #define InvokeListDefUPP | ( | lMessage, | |
| lSelect, | |||
| lRect, | |||
| lCell, | |||
| lDataOffset, | |||
| lDataLen, | |||
| lHandle, | |||
| userUPP | |||
| ) |
| #define InvokeListSearchUPP | ( | aPtr, | |
| bPtr, | |||
| aLen, | |||
| bLen, | |||
| userUPP | |||
| ) |
| #define NewListClickLoopUPP | ( | userRoutine | ) |
register 1_byte:D0 Func()
| #define NewListDefUPP | ( | userRoutine | ) |
pascal no_return_value Func(2_bytes, 1_byte, 4_bytes, 4_bytes, 2_bytes, 2_bytes, 4_bytes)
| #define NewListSearchProc | ( | userRoutine | ) | NewListSearchUPP(userRoutine) |
support for pre-Carbon UPP routines: New...Proc and Call...Proc
| #define NewListSearchUPP | ( | userRoutine | ) |
pascal 2_bytes Func(4_bytes, 4_bytes, 2_bytes, 2_bytes)
| typedef long ListNotification |
QuickTime 3.0
| typedef ListHandle ListRef |
ListRef is obsolete. Use ListHandle.
| anonymous enum |
| anonymous enum |
| Enumerator | |
|---|---|
| lDrawingModeOffBit | ListRec.listFlags bits |
| anonymous enum |
| Enumerator | |
|---|---|
| lDrawingModeOff | ListRec.listFlags masks |
| anonymous enum |
| Enumerator | |
|---|---|
| lOnlyOneBit | ListRec.selFlags bits |
| anonymous enum |
| Enumerator | |
|---|---|
| lOnlyOne | ListRec.selFlags masks |
| anonymous enum |
CALL_NOT_IN_CARBON
| typedef CALLBACK_API | ( | void | , |
| ListNotificationProcPtr | |||
| ) |
QuickTime 3.0
| OSStatus CreateCustomList | ( | const Rect * | rView, |
| const ListBounds * | dataBounds, | ||
| Point | cellSize, | ||
| const ListDefSpec * | theSpec, | ||
| WindowRef | theWindow, | ||
| Boolean | drawIt, | ||
| Boolean | hasGrow, | ||
| Boolean | scrollHoriz, | ||
| Boolean | scrollVert, | ||
| ListHandle * | outList | ||
| ) |
| void DisposeListClickLoopUPP | ( | ListClickLoopUPP | userUPP | ) |
| void DisposeListDefUPP | ( | ListDefUPP | userUPP | ) |
| void DisposeListSearchUPP | ( | ListSearchUPP | userUPP | ) |
| void GetListVisibleBounds | ( | ListHandle | theList, |
| Rect * | visibleBounds | ||
| ) |
| Boolean InvokeListClickLoopUPP | ( | ListClickLoopUPP | userUPP | ) |
| void InvokeListDefUPP | ( | short | lMessage, |
| Boolean | lSelect, | ||
| Rect * | lRect, | ||
| Cell | lCell, | ||
| short | lDataOffset, | ||
| short | lDataLen, | ||
| ListHandle | lHandle, | ||
| ListDefUPP | userUPP | ||
| ) |
| short InvokeListSearchUPP | ( | Ptr | aPtr, |
| Ptr | bPtr, | ||
| short | aLen, | ||
| short | bLen, | ||
| ListSearchUPP | userUPP | ||
| ) |
| void LDispose | ( | ListHandle | lHandle | ) |
Discard a list and release all its memory.
LDispose frees up all memory associated with a list. Use it only after you no longer need the list. theListis a handle leading to a variable-length ListRec structure. It is a value previously obtained via LNew.
none
LDispose frees up the list data (the handle in ListRec.cells), the memory associated with the scroll bar controls (if any) and the memory containing the ListRec itself (including the variable-length portion - the array of offsets to the data). If you have allocated additional data and stored the handle in ListRec.userHandle or ListRec.refCon, it is your responsibility to dispose of this memory before calling LDispose .
| Boolean LGetSelect | ( | Boolean | next, |
| Cell * | theCell, | ||
| ListHandle | lHandle | ||
| ) |
Insert column(s) of empty cells into a list.
| count | how many columns to insert LAddColumn inserts one or more columns of empty cells into a list. If drawing is on, the list display and the horizontal scroll bar (if any) are updated. countspecifies the number of columns to insert. clmNum specifies where to start inserting columns. Columns are inserted before this column. For instance, if clmNum=3 and count=1, columns 3... n are renumbered as columns 4... n+1. Thus, the cell that used to be called (3,0) is now called (4,0), and so forth. If clmNum > ListRec.dataBounds.right (i.e., greater than the current width), then exactly count columns are added to the rightmost side of the list. The column where they were actually added is returned. theListis a handle leading to a variable-length ListRec structure. It is a value previously obtained via LNew. |
a short; the column number of the first column inserted. When inserting within the array bounds, this simply returns clmNum. But, if you attempt to insert beyond the current bounds, the return value is the current horizontal size of the list (i.e., ListRec.dataBounds.right).
LAddColumn increases the size of the ListRec structure by ( count * ListRec.dataBounds.bottom) * 2 bytes. ListRec.dataBounds.right is increased by count. For instance, after: LAddColumn( 1,1, theList ); // insert 1 column at column 1 The list shown in the LNew example changes to look like : </ pre>
1992 Symantec Corporation
later
later
later
/
short
LAddColumn(short count, short colNum, ListHandle lHandle);
/**
Insert row(s) of empty cells into a list
| count | how many rows to insertLAddRow inserts one or more rows of empty cells into a list. If drawing is on, the list display and the vertical scroll bar (if any) are updated. countis the desired number of rows to insert. rowNum specifies where to start inserting rows. Rows are inserted before this row. For instance, if rowNum=3 and count=1, then rows 3... n are renumbered as rows 4... n+1. Thus, the cell that used to be called (0,3) is now called (0,4), and so forth. If rowNum > ListRec.dataBounds.bottom (i.e., greater than the current height), exactly count rows are added to the bottom of the list. The row where they were actually added is returned. theListis a handle leading to a variable-length ListRec structure. It is a value previously obtained via LNew. |
a short; the row number of the first new row inserted. When inserting within the array bounds, this simply returns rowNum. But, if you attempt to insert beyond the current bounds, the return value is the current vertical size of the list (i.e., ListRec.dataBounds.bottom).
LAddRow increases the size of the ListRec structure by ( count * ListRec.dataBounds.right) * 2 bytes. ListRec.dataBounds.bottom is increased by count. For instance, after: LAddRow( 3,2, theList ); // insert 3 rows at row 2 The list shown in the LNew example would look like : </ pre>
1992 Symantec Corporation
later
later
later
/
short
LAddRow(short count, short rowNum, ListHandle lHandle);
/**
Delete column(s) of cells from a list
LDelColumn deletes one or more columns of cells from a list. If drawing is
on, the list display and the horizontal scroll bar (if any) are updated.
countis the desired number of columns to delete. If count=0, all cell are
deleted and ListRec.dataBounds.right is set to dataBounds.left.
clmNum specifies where to start deleting rows. For instance, if clmNum=3
and count=1, columns 4... n are renumbered as 3... n-1. Thus, the
cell that used to be called (4,0) is now called (3,0), and so forth.
If clmNum > ListRec.dataBounds.right (i.e., beyond the list's
width), then nothing happens.
theListis a handle leading to a variable-length ListRec structure. It is a
value previously obtained via LNew.
none
LDelColumn decreases the size of the ListRec structure by ( count * ListRec.dataBounds.bottom) * 2 bytes. ListRec.dataBounds.right is decreased by count. For instance, after: LDelColumn ( 1,1, theList ); // delete column 1 the list shown in the LNew example might look like : It is a lot faster to delete multiple columns in one call than to delete one at a time.Use LDispose(or set count to 0) to delete them all.</ pre>
1992 Symantec Corporation
later
later
later / void LDelColumn(short count, short colNum, ListHandle lHandle); /** Delete rows(s) of cells from a listLDelRow deletes one or more rows of cells from a list. If drawing is on, the list display and the horizontal scroll bar (if any) are updated. countis the desired number of rows to delete. If count=0, all cells are deleted and ListRec.dataBounds.bottom is set to dataBounds.top. rowNum specifies where to start deleting rows. For instance, if rowNum=3 and count=1, columns 4... n are renumbered as columns 3... n-1. Thus, the cell that used to be called (0,4) is now called (0,3), and so forth. If rowNum > ListRec.dataBounds.bottom, then nothing happens. theListis a handle leading to a variable-length ListRec structure. It is a value previously obtained via LNew.
none
LDelRow decreases the size of the ListRec structure by ( count * ListRec.dataBounds.right) * 2 bytes. ListRec.dataBounds.bottom is decreased by count. For instance, after: LDelRow ( 4,3, theList ); // delete 4 rows, starting at row 3 The list shown in the LNew example might look like : It is a lot faster to delete multiple rows with one call than than to delete one at a time.Use LDispose(or set count to 0) to delete them all.</ pre>
1992 Symantec Corporation
later
later
later / void LDelRow(short count, short rowNum, ListHandle lHandle); /** Query if a cell is selected; get next selected cellLGetSelect performs two different operations. It can query to see if a specific cell is currently selected OR it can check cells until it finds one that is selected. advanceIt is a Boolean specifying which operation to perform. It is one of: FALSESee if theCell is currently selected and return TRUE if it is. If it is not selected, return FALSE. TRUESee if theCell is selected and return TRUE if it is; otherwise, advance to the next cell on the row and check it. Keep advancing across the row and on to subsequent rows until a selected cell is found or the end of the list is reached. If a selected cell is found, return TRUE and store its coordinates in theCell. theCellis the address of a 32-bit Cell (a.k.a. Point). On entry it specifies the first (or only) cell to check. Upon return, it receives the coordinates of the selected cell (if the return value is TRUE). theListis a handle leading to a variable-length ListRec structure. It is a value previously obtained via LNew.
a Boolean identifying whether theCell is selected (if advance=FALSE) OR whether the search for a selected cell succeeded. It is one of: FALSEtheCell is NOT currently selected OR none of the cells to the right of (or in rows below) theCell is currently selected. TRUEtheCell IS currently selected OR another selected cell was found by scanning the list (its coordinates have been stored in theCell ).
LGetSelect is designed for locating selected (highlighted) cells in a list. You might use it after LLastClick to verify that a certain cell is currently selected, but it is most often used to search for selected cells. If advanceIt is TRUE, the search starts at theCell and proceeds from left to right and if no selection is found in a row, the search continues on to subsequent rows, as described under LNextCell ( TRUE,TRUE,...). Note that in searching for all selections in a list, you will need to advance theCell after a selection is found. For example: CelltheCell;
| Cell LLastClick | ( | ListHandle | lHandle | ) |
Query which cell was clicked last.
Use LLastClick after calling LClick. It returns the list coordinates of the cell most recently clicked. theListis a handle leading to a variable-length ListRec structure. It is a value previously obtained via LNew.
either a 32-bit long integer, or a Cell, depending on your programming environment. The low word is the horizontal index and the high word is the vertical index of the most recently clicked cell.
LLastClick returns the same value as that stored in the lastClick field of the ListRec. Note that this does NOT necessarily identify the last cell selected or a cell in which a double-click occurred. It is simply the last cell in which a mouseDown occurred. However, if called directly after a call to LClick that returns TRUE, it does return the cell that was double clicked.
| ListHandle LNew | ( | const Rect * | rView, |
| const ListBounds * | dataBounds, | ||
| Point | cSize, | ||
| short | theProc, | ||
| WindowRef | theWindow, | ||
| Boolean | drawIt, | ||
| Boolean | hasGrow, | ||
| Boolean | scrollHoriz, | ||
| Boolean | scrollVert | ||
| ) |
CALL_NOT_IN_CARBON !TARGET_OS_MAC LNew()
| void LSetNotificationCallback | ( | ListNotificationProcPtr | callBack, |
| ListHandle | lHandle | ||
| ) |
| ListClickLoopUPP NewListClickLoopUPP | ( | ListClickLoopProcPtr | userRoutine | ) |
| ListDefUPP NewListDefUPP | ( | ListDefProcPtr | userRoutine | ) |
| ListSearchUPP NewListSearchUPP | ( | ListSearchProcPtr | userRoutine | ) |
| </ pre> * par Copyright |
Query which cell is next in a list.
| hNext | look horizontally (toward the right)? |
| vNext | look vertically (toward the bottom)? LNextCell advances from one cell position to the next. You can advance horizontally only (across a row), vertically only (down a column), or both (horizontally until at the end of a row and wrapping from row to row). hNextand . . . vNextAre Booleans that identify how to look for the next cell. There are three meaningful combinations: hNext=TRUE(vNext=FALSE) Advance horizontally to the right. If beyond the end of the row, return FALSE. vNext=TRUE(hNext=FALSE) Advance vertically toward the bottom. If beyond the bottom of the list, return FALSE. Both TRUEAdvance horizontally to the right. If beyond the last column, advance to first cell in the the next lower row. If beyond the bottom of the list, return FALSE. theCellis the address of a 32-bit Cell (a.k.a. Point). On entry, it specifies where to start looking. Upon return, it contains the cell coordinates of the next cell, according to the criteria set forth in hNext and vNext. If the return value is FALSE, the value of theCell is undefined upon exit. theListis a handle leading to a variable-length ListRec structure. It is a value previously obtained via LNew. |
a Boolean identifying whether a valid 'next' cell was obtained. It is one of: FALSENo more cells - either at the end of a row, column, or list. The value of theCell is now undefined. TRUEA valid 'next' cell was found, its coordinates are in theCell.
You can use LNextCell in place of a set of nested loops. For instance, you could use it to loop through and deselect all cells (a function NOT provided by the List Manager). Another example: given a mouse location in local coordinates, you could determine which cell was currently pointed to via: Cell theCell; Rect cellRect; Point mousePt; Boolean found; found = FALSE; theCell. h=theCell. v=0; /* start at top left