List.mui Class Reference

BOOPSI custom class List.mui (MUI 3.8 dev). Each ### sub-section below documents one of the class's attributes or methods. Sub-classes of List.mui are listed at the end under Sub-classes; the class hierarchy itself is documented in the MUI classes index.

Function index

Class definition

Attributes

Methods

List.mui

MUIA_List_Active

MUIA_List_Active -- (V4 ) [ISG], LONG — SPECIAL INPUTS — MUIV_List_Active_Off — MUIV_List_Active_Top — MUIV_List_Active_Bottom — MUIV_List_Active_Up — MUIV_List_Active_Down — MUIV_List_Active_PageUp — MUIV_List_Active_PageDown

Function

Reading this attribute will return the number of the active entry (the one with the cursor on it). The result is between 0 and MUIA_List_Entries-1 or MUIV_List_Active_Off, in which case there is currently no active entry. Setting the attribute will cause the list to move the cursor to the new position and scroll this position into the visible area.

See also

MUIA_List_Entries, MUIA_List_First, MUIA_List_Visible

MUIA_List_AdjustHeight

MUIA_List_AdjustHeight -- (V4 ) [I..], BOOL

Function

A list with MUIA_List_AdjustHeight set to true is exactly as high as all of its entries and not resizable. This is only possible when the list is filled before the window is opened.

See also

MUIA_List_AdjustWidth

MUIA_List_AdjustWidth

MUIA_List_AdjustWidth -- (V4 ) [I..], BOOL

Function

A list with MUIA_List_AdjustWidth set to true is exactly as wide as the widest entry and not resizable. This is only possible when the list is filled before the window is opened.

See also

MUIA_List_AdjustHeight

MUIA_List_AutoVisible

MUIA_List_AutoVisible -- (V11) [ISG], BOOL

Function

Set this to make your lists automatically jump to the active entry when they are displayed.

See also

MUIA_List_Active

MUIA_List_CompareHook

**MUIA_List_CompareHook -- (V4 ) [IS.], struct Hook ***

Function

If you plan to have the entries of your list sorted (either by inserting them sorted or by using the MUIM_List_Sort method) and if the entries of your list are not simple strings, you must supply a compare hook. This hook will be called with one list element in A1 and another one in A2. You should return something like <0 e1 < e2 0 e1 == e2

0� e1 > e2

Example

/* the builtin string compare function */
LONG __asm cmpfunc(_a1 char *s1,_a2 char *s2)
{
return(stricmp(s1,s2));
}

See also

MUIA_List_ConstructHook, MUIA_List_DestructHook

MUIA_List_ConstructHook

MUIA_List_ConstructHook -- (V4 ) [IS.], struct Hook * — SPECIAL INPUTS — MUIV_List_ConstructHook_String

Function

The construct hook is called whenever you add an entry to your list. MUI will not insert the given pointer directly, but instead call the construct hook and add its result code. Imagine you want to display a list of entries in a directory. You could step through it using Examine()/ExNext() and directly use the MUIM_List_Insert method on your file info block buffer. Your construct hook will be called with this file info block as parameter, makes a copy of it and returns the address of that copy. Thats what is actually added to the list. The corresponding destruct hook is called whenever an entry shall be removed. It's task would simply be to free the memory and maybe other resources concering this entry that were allocated by the construct hook. Using these two functions, you will never have to worry about freeing the memory used by your list entries. Clearing the list or disposing the list object will automatically remove all entries and thus free the associated resources. The construct hook will be called with the hook in A0, the data given to MUIM_List_Insert as message in register A1 and with pointer to a standard kick 3.x memory pool in A2. If you want, you can use the exec or amiga.lib functions for allocating memory within this pool, but this is only an option. If the construct hook returns NULL, nothing will be added to the list. There is a builtin construct hook available called MUIV_List_ConstructHook_String. This expects that you only add strings to your list and will make a local copy of this string to allow you destroying the original. Of course you must also use MUIV_List_DestructHook_String in this case. Without construct and destruct hooks, you are responsible for allocating and freeing entries yourself.

Example

/* the builtin string construct and destruct functions: */
APTR __asm consfunc(_a2 APTR pool,_a1 char *str)
{
char *new;
if (new=AllocPooled(pool,strlen(str)+1))
strcpy(new,str);
return(new);
}
VOID __asm desfunc(_a2 APTR pool,_a1 char *entry)
{
FreePooled(pool,entry,strlen(entry)+1);
}
/* for more sophisticated hooks see demo program WbMan.c */

See also

MUIA_List_DestructHook, MUIA_List_DisplayHook

MUIA_List_DestructHook

MUIA_List_DestructHook -- (V4 ) [IS.], struct Hook * — SPECIAL INPUTS — MUIV_List_DestructHook_String

Function

Set up a destruct hook for your list. For detailed explanation see MUIA_List_ConstructHook.

See also

MUIA_List_ConstructHook, MUIA_List_DisplayHook

MUIA_List_DisplayHook

**MUIA_List_DisplayHook -- (V4 ) [IS.], struct Hook ***

Function

Since MUI's lists can handle any kind of entries, you have to supply a display hook to specify what should actually be shown in the display. The hook will be called with a pointer to the entry to be displayed in A1 and a pointer to a string array containing as many entries as your list may have columns in A2. You must fill this array with the strings that you want to display. Note: You can of course use MUI's text engine facilities here to create e.g. right aligned or centered columns. Without a display hook, MUI expects a simple one columned string list. See MUIA_List_Format for details about column handling. Note: Since version 6 of MUI, the display hook also gets the position of the current entry as additional parameter. You can easily do e.g. some line numbering using this feature. The number (from 0 to NumEntries-1) is stored in the longword preceding the column array (see example below).

Example

/* list of file info blocks, two columned, name and size */
LONG __asm dispfunc(_a2 char **array,_a1 struct FileInfoBlock *fib)
{
static char buf1[20],buf2[20];
if (fib->fib_EntryType<0)
sprintf(buf2,"\33r%ld",fib->fib_Size);
else
strcpy(buf2,"\33r(dir)");
sprintf(buf1,"%ld",array[-1]);   // get the line number.
*array++ = buf1;
*array++ = fib->fib_FileName;
*array   = buf2;
return(0);
}

See also

MUIA_List_Format, MUIA_Text_Contents

MUIA_List_DragSortable

MUIA_List_DragSortable -- (V11) [ISG], BOOL

Function

If you set this attribute to TRUE, the user will be able to move around entries in the list by using drag&drop.

MUIA_List_DropMark

MUIA_List_DropMark -- (V11) [..G], LONG

Function

After a successfull drop operation, this attribute holds the position where we should insert the new entry(ies).

Example

See DragnDrop example program

MUIA_List_Entries

MUIA_List_Entries -- (V4 ) [..G], LONG

Function

Get the current number of entries in the list.

See also

MUIA_List_First, MUIA_List_Visible, MUIA_List_Active

MUIA_List_First

MUIA_List_First -- (V4 ) [..G], LONG

Function

Get the number of the entry displayed on top of the list. You have to be prepared to get a result of -1, which means that the list is not visible at all (e.g. when the window is iconifed).

See also

MUIA_List_Visible, MUIA_List_Entries, MUIA_List_Active

MUIA_List_Format

MUIA_List_Format -- (V4 ) [ISG], STRPTR — 8 FUNCTION — MUI has the ability to handle multi column lists. To define — how many columns should be displayed and how they should be — formatted, you specify a format string. — This format string must contain one entry for each column — you want to see. Entries are seperated by commas, one — entry is parsed via dos.library/ReadArgs(). — The template for a single entry looks like this: — DELTA=D/N,PREPARSE=P/K,WEIGHT=W/N, — MINWIDTH=MIW/N,MAXWIDTH=MAW/N,COL=C/N,BAR/S — DELTA — Space in pixel between this column and the next. — the last displayed column ignores this setting. — Defaults to 4. — PREPARSE — A preparse value for this column. Setting this — e.g. to "\33c" would make the column centered. — See MUIA_Text_Contents for other control codes. — WEIGHT — The weight of the column. As with MUI's group — class, columns are layouted with a minimum — size, a maximum size and weight. A column with — a weight of 200 would gain twice the space than — a column with a weight of 100. — Defaults to 100. — MINWIDTH — Minimum percentage width for the current column. — If your list is 200 pixel wide and you set this — to 25, your column will at least be 50 pixel. — The special value -1 for this parameter means that — the minimum width is as wide as the widest entry in — this column. This ensures that every entry will be — completely visible (as long as the list is wide enough). — Defaults to -1. — MAXWIDTH — Maximum percentage width for the current column. — If your list is 200 pixel wide and you set this — to 25, your column will not be wider as 50 pixel. — The special value -1 for this parameter means that — the maximum width is as wide as the widest entry in — this column. — Defaults to -1. — COL — This value adjusts the number of the current column. — This allows you to adjust the order of your columns — without having to change your display hook. See — example for details. — Defaults to current entry number (0,1,...) — BAR — Since muimaster.library V11, you can enable a — vertical bar between this and the next column by — using this switch. — If your list object gets so small there is not enough — place for the minwidth of a column, this column will — be hidden completely and the remaining space is — distributed between the remaining columns. This is not — true if the column is the first column, in this case — the entries will simply be clipped. — Note: You will have as many columns in your list as — entries in the format string (i.e. number of — commas + 1). Empty entries, e.g. with a format — string of ",,,," are perfectly ok. — The default list format is an empty string (""), this — means a one column list without special formatting.

Bugs

Currently there is a maximum of 64 columns for a list.

Example

/* Three column list without further formatting: */
MUIA_List_Format: ",,"
/* Three column list, middle column centered: */
MUIA_List_Format: ",P=\33c,"
/* Three column list, display order 2 1 0: */
MUIA_List_Format: "COL=2,COL=1,COL=0"
/* now something more complex.           */
/* the display hook defines six entries: */
dispfunc(_a2 char **array,_a1 struct Article *at)
{
*array++ = at->FromName; // col 0
*array++ = at->FromPath; // col 1
*array++ = at->ToName;   // col 2
*array++ = at->ToPath;   // col 3
*array++ = at->Date;     // col 4
*array   = at->Subject;  // col 5
}
/* but we only want to have fromname, date and subject
/* actually displayed, subject shoud be centered: */
MUIA_List_Format, "COL=0,COL=4,COL=5 P=\33c"
/* maybe this looks kind of silly, why not make our  */
/* display hook only fill in these three columns.    */
/* well, if you would e.g. make the format string    */
/* user configurable and document what your display  */
/* hook puts into the array, the user could decide   */
/* what columns he actually wants to see.            */
/* The supplied example DFView does something like   */
/* that.                                             */
/* two column list:   ! Eye    1234 !
! Foot     22 !
! Nose  22331 ! */
MUIA_List_Format, "MAW=100,P=\33r"

See also

MUIA_List_DisplayHook, MUIA_Text_Contents

MUIA_List_InsertPosition

MUIA_List_InsertPosition -- (V9 ) [..G], LONG

Function

After insertion of an element with MUIM_List_Insert, you can query the position of the new entry by getting this attribute.

MUIA_List_MinLineHeight

MUIA_List_MinLineHeight -- (V4 ) [I..], LONG

Function

Sets the minimum line height for lists in pixels. Useful e.g. if you have custom images.

MUIA_List_MultiTestHook

**MUIA_List_MultiTestHook -- (V4 ) [IS.], struct Hook ***

Function

If you plan to have a multi selecting list but not all of your entries are actually multi selectable (e.g. in a file requester), you can supply a MUIA_List_MultiTestHook. It will be called with a pointer to an entry in A1 and should return TRUE if the entry is multi selectable, FALSE otherwise.

Example

/* multi test func for a list of file info blocks */
LONG __asm mtfunc(_a1 struct FileInfoBlock *fib)
{
if (fib->fib_DirEntryType<0)
return(TRUE);
else
return(FALSE);
}

See also

MUIA_List_ConstructHook, MUIA_List_DestructHook

MUIA_List_Pool

MUIA_List_Pool -- (V13) [I..], APTR

Function

Pass something from CreatePool() here if you dont want the list to create its own memory pool but use this one instead. Note that list class does not use semaphore protection when accessing the pool, you must not use pools which are accessed from different tasks than the applications main task.

See also

MUIA_List_PoolPuddleSize, MUIA_List_PoolThreshSize

MUIA_List_PoolPuddleSize

MUIA_List_PoolPuddleSize -- (V13) [I..], ULONG

Function

Specify the puddle size for the lists memory pool. Defaults to 2008. Is ignored if you specify your own pool with MUIA_List_Pool.

See also

MUIA_List_PoolThreshSize, MUIA_List_Pool

MUIA_List_PoolThreshSize

MUIA_List_PoolThreshSize -- (V13) [I..], ULONG

Function

Specify the thresh size for the lists memory pool. Defaults to 1024. Is ignored if you specify your own pool with MUIA_List_Pool.

See also

MUIA_List_PoolPuddleSize, MUIA_List_Pool

MUIA_List_Quiet

MUIA_List_Quiet -- (V4 ) [.S.], BOOL

Function

If you add/remove lots of entries to/from a currently visible list, this will cause lots of screen action and slow down the operation. Setting MUIA_List_Quiet to true will temporarily prevent the list from being refreshed, this refresh will take place only once when you set it back to false again.

Example

set(list,MUIA_List_Quiet,TRUE);
AddThousandEntries(list);
set(list,MUIA_List_Quiet,FALSE);

See also

MUIM_List_Insert, MUIM_List_Remove

MUIA_List_ShowDropMarks

MUIA_List_ShowDropMarks -- (V11) [ISG], BOOL

Function

If a list supports Drag & Drop, it usually indicates the place where a new line would be inserted with some horizontal lines. Showing this place doesnt make much sense if you dont care about the drop position anyway, e.g. because your list is always alphabetically sorted. You should set this attribute to FALSE in these cases.

See also

MUIA_List_DropMark

MUIA_List_SourceArray

MUIA_List_SourceArray -- (V4 ) [I..], APTR

Function

The NULL terminated array given here is immediately inserted into the list after object creation time.

Example

static const char *KeyList[] =
{
"Cursor Up",
"Cursor Down",
"Cursor Left",
"Cursor Right",
NULL;
};
LV_Keys = ListviewObject,
MUIA_Listview_List, ListObject,
InputListFrame,
MUIA_List_AdjustWidth, TRUE,
MUIA_List_SourceArray, KeyList,
End,
End;

MUIA_List_Title

**MUIA_List_Title -- (V6 ) [ISG], char ***

Function

Specify a title for the current list. The title is displayed at the very first line and doesn't scroll away when the list top position moves. Usually, the title is just a string. However, if you have a multi column list with a custom display hook and you want to have seperate titles for each of your columns, you can set this attribute to TRUE. In this case, whenever MUI feels that the list title has to be drawn, it will call your display hook with a NULL entry pointer. Your hook has to check for this NULL entry and fill the given string array with your column titles. Layout of the column titles follows the same rules as layout of the lists entries.

Example

/* display function for a multi columned file list with titles */
LONG __asm DisplayFunc(_a2 char **array,_a1 struct Entry *e)
{
struct Data *data = hook->h_Data;
if (e)
{
*array++ = e->Name;
*array++ = e->Size;
*array++ = e->Date;
*array++ = e->Time;
*array++ = e->Flags;
*array   = e->Comment;
}
else
{
*array++ = "Name";
*array++ = "Size";
*array++ = "Date";
*array++ = "Time";
*array++ = "Flags";
*array   = "Comment";
}
return(0);
}

See also

MUIA_List_DisplayHook

MUIA_List_Visible

MUIA_List_Visible -- (V4 ) [..G], LONG

Function

Get the current number of visible entries in the list. You have to be prepared to get a result of -1, which means that the list is not visible at all (e.g. when the window is iconifed).

See also

MUIA_List_First, MUIA_List_Entries, MUIA_List_Active

MUIM_List_Clear

MUIM_List_Clear (V4 ) — SYNOPSIS — DoMethod(obj,MUIM_List_Clear);

Function

Clear the list, all entries are removed. If a destruct hook is set it will be called for every entry.

See also

MUIM_List_Insert, MUIA_List_DestructHook

MUIM_List_CreateImage

MUIM_List_CreateImage (V11) — SYNOPSIS — DoMethod(obj,MUIM_List_CreateImage,Object *obj, ULONG flags);

Function

If you want to have custom images in a listview (e.g. like the little monitor icons in PSI), you should create them as Bitmap objects (or Bodychunk objects) in the setup method of your list class (use a subclass!). After that, pass the newly created object pointer to MUIM_List_CreateImage and use the result in your display hook with \33O[%08lx] where %08lx must be replaced by the pointer you got from MUIM_List_CreateImage. When your list is done (i.e. in the Cleanup method), kill your image with MUIM_List_DeleteImage and dispose your object.

Result

The result you get is a black box pointer, it's not valid to assume anything about it. The only useful thing you can do is to include it in \33O[%08lx]. The result may be NULL in which case MUI was unable to create the image, but the \33O[] combination simply draws nothing when receiving a NULL so it shouldnt be considered an error.

Example

See ScreenList class in screen inspector source code psi.c

See also

MUIM_List_DeleteImage

MUIM_List_DeleteImage

MUIM_List_DeleteImage (V11) — SYNOPSIS — DoMethod(obj,MUIM_List_DeleteImage,APTR listimg);

Function

Delete the image pointer returned from MUIM_List_CreateImage.

See also

MUIM_List_DeleteImage

MUIM_List_Exchange

MUIM_List_Exchange (V4 ) — SYNOPSIS — DoMethod(obj,MUIM_List_Exchange,LONG pos1, LONG pos2);

Function

Exchange two entries in a list.

Inputs

pos1 - number of the first entry. pos2 - number of the second entry. Possible special values since muimaster.library V9: MUIV_List_Exchange_Top 0 MUIV_List_Exchange_Active -1 MUIV_List_Exchange_Bottom -2 MUIV_List_Exchange_Next -3 / only valid for second parameter / MUIV_List_Exchange_Previous -4 / only valid for second parameter /

See also

MUIM_List_Insert, MUIM_List_Remove, MUIM_List_Move

MUIM_List_GetEntry

MUIM_List_GetEntry (V4 ) — SYNOPSIS — DoMethod(obj,MUIM_List_GetEntry,LONG pos, APTR *entry);

Function

Get an entry of a list.

Inputs

pos - Number of entry, MUIV_List_GetEntry_Active can be used to get the active entry. entry - Pointer to a longword where the entry will be stored. If the entry is not available (either because you are out of bounds or because there is no active entry), you will receive a NULL.

Example

/* iterate through a list containing file info blocks */
for (i=0;;i++)
{
struct FileInfoBlock *fib;
DoMethod(list,MUIM_List_GetEntry,i,&fib);
if (!fib) break;
printf("%s\n",fib->fib_FileName);
}

See also

MUIM_List_Insert, MUIM_List_Remove

MUIM_List_Insert

MUIM_List_Insert (V4 ) — SYNOPSIS — DoMethod(obj,MUIM_List_Insert,APTR *entries, LONG count, LONG pos);

Function

Insert new entries into a list. When the list has a construct hook, the given pointers won't be inserted directly but instead passed through to the construct hook.

Inputs

entries - pointer to an array of pointers to be inserted. Warning: This is a pointer to a pointer. See example for details. count - Number of elements to be inserted. If count==-1, entries will be inserted until NULL pointer in the entries array is found. pos - New entries will be added in front of this entry. MUIV_List_Insert_Top: insert as first entry. MUIV_List_Insert_Active: insert in front of the active entry. MUIV_List_Insert_Sorted: insert sorted. MUIV_List_Insert_Bottom: insert as last entry. If pos is bigger or equal to the number of entries in the list, it's treated like MUIV_List_Insert_Bottom.

Example

/* insert a string */
char *str = "New entry";
DoMethod(list,MUIM_List_Insert,&str,1,MUIV_List_Insert_Bottom);
/* insert an array */
char *str[] =
{
"Entry 1",
"Entry 2",
"Entry 3",
"Entry 4",
NULL
};
DoMethod(list,MUIM_List_Insert,str,-1,MUIV_List_Insert_Bottom);

See also

MUIM_List_Remove, MUIA_List_ConstructHook

MUIM_List_InsertSingle

MUIM_List_InsertSingle (V7 ) — SYNOPSIS — DoMethod(obj,MUIM_List_InsertSingle,APTR entry, LONG pos);

Function

Insert one new entry into a list. Using MUIM_List_Insert has caused some confusion since it takes an array to items instead a single item. To insert single items, MUIM_List_InsertSingle is the better choice. When the list has a construct hook, the given pointer won't be inserted directly but instead passed through to the construct hook.

Inputs

entry - item to insert. pos - New entry will be added in front of this entry. MUIV_List_Insert_Top: insert as first entry. MUIV_List_Insert_Active: insert in front of the active entry. MUIV_List_Insert_Sorted: insert sorted. MUIV_List_Insert_Bottom: insert as last entry. If pos is bigger or equal to the number of entries in the list, it's treated like MUIV_List_Insert_Bottom.

Example

/* insert a string */
DoMethod(list,MUIM_List_InsertSingle,"foobar",MUIV_List_Insert_Bottom);

See also

MUIM_List_Remove, MUIA_List_ConstructHook, MUIM_List_InsertSingle

MUIM_List_Jump

MUIM_List_Jump (V4 ) — SYNOPSIS — DoMethod(obj,MUIM_List_Jump,LONG pos);

Function

Scroll any entry into the visible part of a list. Note: Jumping to an entry doesn't mean to make this entry the active one. This can be done by setting the MUIA_List_Active attribute.

Inputs

pos - Number of the entry that should be made visible. Use MUIV_List_Jump_Active to jump to the active entry.

Example

/* line 42 is interesting, so make it visible */
DoMethod(list,MUIM_List_Jump,42);

See also

MUIA_List_Active

MUIM_List_Move

MUIM_List_Move (V9 ) — SYNOPSIS — DoMethod(obj,MUIM_List_Move,LONG from, LONG to);

Function

Move an entry from one position to another.

Inputs

pos1 - number of the first entry. pos2 - number of the second entry. Possible special values since muimaster.library V9: MUIV_List_Move_Top 0 MUIV_List_Move_Active -1 MUIV_List_Move_Bottom -2 MUIV_List_Move_Next -3 / only valid for second parameter / MUIV_List_Move_Previous -4 / only valid for second parameter /

See also

MUIM_List_Insert, MUIM_List_Remove, MUIM_List_Exchange

MUIM_List_NextSelected

MUIM_List_NextSelected (V6 ) — SYNOPSIS — DoMethod(obj,MUIM_List_NextSelected,LONG *pos);

Function

Iterate through the selected entries of a list. This method steps through the contents of a (multi select) list and returns every entry that is currently selected. When no entry is selected but an entry is active, only the active entry will be returned. This behaviour will result in not returning the active entry when you have some other selected entries somewhere in your list. Since the active entry just acts as some kind of cursor mark, this seems to be the only sensible possibility to handle multi selection together with keyboard control.

Inputs

pos - a pointer to longword that will hold the number of the returned entry. Must be set to MUIV_List_NextSelected_Start at start of iteration. Is set to MUIV_List_NextSelected_End when iteration is finished.

Example

/* Iterate through a list with FileInfoBlocks */
struct FileInfoBlock *fib;
LONG id = MUIV_List_NextSelected_Start;
for (;;)
{
DoMethod(list,MUIM_List_NextSelected,&id);
if (id==MUIV_List_NextSelected_End) break;
DoMethod(list,MUIM_List_GetEntry,id,&fib);
printf("selected: %s\n",fib->fib_FileName);
}

See also

MUIM_List_Select

MUIM_List_Redraw

MUIM_List_Redraw (V4 ) — SYNOPSIS — DoMethod(obj,MUIM_List_Redraw,LONG pos);

Function

If you made some changes to an entry of your list and want these changes to be shown in the display, you will have to call this method.

Inputs

pos - Number of the line to redraw. When the line is not currently visible, nothing will happen. Specials: MUIV_List_Redraw_Active: redraw the active line (if any), MUIV_List_Redraw_All: redraw all lines.

Example

/* do a complete refresh: */
DoMethod(list,MUIM_List_Redraw,MUIV_List_Redraw_All);

MUIM_List_Remove

MUIM_List_Remove (V4 ) — SYNOPSIS — DoMethod(obj,MUIM_List_Remove,LONG pos);

Function

Remove an entry from a list.

Inputs

pos - number of the entry to be removed or one of MUIV_List_Remove_First, MUIV_List_Remove_Active, MUIV_List_Remove_Last. MUIV_List_Remove_Selected. When the active entry is removed, the following entry will become active.

Example

/* when delete is pressed, remove the active entry */
DoMethod(btdel,MUIM_Notify,MUIA_Pressed,FALSE,
list,2,MUIM_List_Remove,MUIV_List_Remove_Active);

See also

MUIM_List_Insert, MUIA_List_DestructHook

MUIM_List_Select

MUIM_List_Select (V4 ) — SYNOPSIS — DoMethod(obj,MUIM_List_Select,LONG pos, LONG seltype, LONG *state);

Function

Select/deselect a list entry or ask an entry if its selected.

Inputs

pos - Number of the entry or MUIV_List_Select_Active for the active entry. MUIV_List_Select_All for all entries. seltype - MUIV_List_Select_Off unselect entry. MUIV_List_Select_On select entry. MUIV_List_Select_Toggle toggle entry. MUIV_List_Select_Ask just ask about the state. state - Pointer to a longword. If not NULL, this will be filled with the current selection state.

Notes

Since version V9 of muimaster.library: If pos==MUIV_List_Select_All and seltype==MUIV_List_Select_Ask, state will be filled with the total number of selected entries.

Example

/* toggle selection state of active entry */
DoMethod(list,MUIM_List_Select,MUIV_List_Select_Active,
MUIV_List_Select_Toggle,NULL);
/* select all entries */
DoMethod(list,MUIM_List_Select,MUIV_List_Select_All,
MUIV_List_Select_On,NULL);

See also

MUIA_List_MultiTestHook

MUIM_List_Sort

MUIM_List_Sort (V4 ) — SYNOPSIS — DoMethod(obj,MUIM_List_Sort);

Function

Sort the list. MUI uses an iterative quicksort algorithm, no stack problems will occur.

See also

MUIA_List_CompareHook

MUIM_List_TestPos

MUIM_List_TestPos (V11) — SYNOPSIS — DoMethod(obj,MUIM_List_TestPos,LONG x, LONG y, struct MUI_List_TestPos_Result *res);

Function

Find out which line/column of a listview is currently displayed at a certain position.