Hyperion Entertainment Message Boards

xenic wrote:

LyleHaze wrote: Is running as an endless loop. Somewhere after 300 times through it will wander into memory it should not be playing in, and things go badly from there.

Code: Select all

	while (lines[i] != NULL) 
	{
		node = AllocListBrowserNode(1, // crash
		       LBNCA_CopyText, TRUE,
		       LBNCA_Text, lines[i],
		       TAG_END);
		if (node == NULL)
		{
			FreeListBrowserList(list);
			FreeSysObject(ASOT_LIST, list);
			return NULL;
		}

		AddTail(list, node);
		++i;
	}

Due to lack of indentation in the pasted code, I think you missed the "++i" line below the section you quoted. Unless I'm missing something, I don't think it's an endless loop. However, there is a "return NULL" in a void function, which is wrong.

!= NULL)" always evaluates as true, which is does when run here.

Well, it continues to evaluate as TRUE only until the program crashes on DSI, so technically, it's NOT an
endless loop, but I don't think the original intent was "continue to increment until exception".

LyleHaze wrote:Well, it continues to evaluate as TRUE only until the program crashes on DSI, so technically, it's NOT an endless loop, but I don't think the original intent was "continue to increment until exception".

xenic wrote:

LyleHaze wrote:Well, it continues to evaluate as TRUE only until the program crashes on DSI, so technically, it's NOT an endless loop, but I don't think the original intent was "continue to increment until exception".

I misinterpreted your analysis because of the incomplete clip. Good catch on the loop control always evaluating to TRUE. I haven't tried to run the program but "lines" is declared as a 2 dimensional character array; which I think means that the first dimension will always contain a pointer to the second dimension text and lines will never be NULL unless it is set to NULL by the program.

/* Programmname ReqList */
#define __USE_INLINE__
#define __NOLIBBASE__
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/

/*----------------------------------------------------------------------------*/
/* Usage */
/* ReqList TITLE "City" BODY "Please select:" CHOICES "Berlin" "London" "Madrid" "Paris" "Rome" PERSIST NOTEMPTY*/
/* ReqList TITLE "City" BODY "Please select:" I_FILE clips:0 PERSIST NOTEMPTY O_FILE T:selected */

/*----------------------------------------------------------------------------*/
/* Compile
/* gcc Req_List.c -lraauto -lauto -gstabs -N -o reqlist */
/*----------------------------------------------------------------------------*/

/*----------------------------------------------------------------------------*/
/* System Includes */
/*----------------------------------------------------------------------------*/

#include <proto/exec.h>
#include <proto/dos.h>
#include <proto/intuition.h>
#include <proto/utility.h>
#include <proto/textclip.h>

#define ALL_REACTION_CLASSES
#include <reaction/reaction.h>
#include <reaction/reaction_macros.h>

#include <clib/alib_protos.h>

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
///#include "CBIO_.c" /// not used yet ; use other clipunits


/*----------------------------------------------------------------------------*/
/* Konstanten & Makros */
/*----------------------------------------------------------------------------*/

char badChar[] = {'\n', '\t',0};
enum
{
GID_LIST,
GID_OK,
GID_CANCEL,
GID_INVERSE,
GID_ALL,
GID_NONE,
GID_RESTORE, ///to original content sequence (after having sorted)
//GID_SORT_DSC, /// taken over with toggle
GID_NUM
};

enum
{
COL_DEFAULT_SORT,
///COL_CUSTOM_SORT,
///COL_LBM_SORT,
NUM_COLS
};

#define TOTAL_LINES 300
#define MAX_LINE 1280
#define MAX_CLIP 25600

char lines[TOTAL_LINES][MAX_LINE];
int totallines = 0;


#ifdef __amigaos4__
/// http://www.os4coding.net/blog/trixie/re ... rogramming
#define BASEDEF(base) struct Library *base##Base = NULL; struct base##IFace *I##base = NULL
#define OPENLIB(base,name) if (!((base##Base) = OpenLibrary ((name),0)) || !((I##base) = (void *)GetInterface ((base##Base),"main",1,NULL))) ok = FALSE
#define OPENLIBMIN(base,name,min) if (!((base##Base) = OpenLibrary ((name),min)) || !((I##base) = (void *)GetInterface ((base##Base),"main",1,NULL))) ok = FALSE
#define CLOSELIB(base) if (I##base) DropInterface ((struct Interface *)(I##base)); if (base##Base) CloseLibrary (base##Base)
#else
#define BASEDEF(base) struct Library *base##Base = NULL
#define OPENLIB(base,name) if (!((base##Base) = OpenLibrary ((name),0))) ok = FALSE
#define OPENLIBMIN(base,name) if (!((base##Base) = OpenLibrary ((name),min))) ok = FALSE
#define CLOSELIB(base) if (base##Base) CloseLibrary (base##Base)
#endif

/*----------------------------------------------------------------------------*/
/* Typdefinitionen */
/*----------------------------------------------------------------------------*/

/*----------------------------------------------------------------------------*/
/* Globale Variablen */
/*----------------------------------------------------------------------------*/

BASEDEF(Window);
BASEDEF(Layout);
BASEDEF(Button);
BASEDEF(ListBrowser);
BASEDEF(Requester);


/*----------------------------------------------------------------------------*/
/* ReAction-Klassen Öffnen */
/*----------------------------------------------------------------------------*/

BOOL open_classes (void)
{
BOOL ok = TRUE;

OPENLIBMIN(Window,"window.class",52);
OPENLIBMIN(Layout,"gadgets/layout.gadget",52);
OPENLIBMIN(Button,"gadgets/button.gadget",52);
OPENLIBMIN(ListBrowser,"gadgets/listbrowser.gadget",52);
OPENLIBMIN(Requester,"requester.class",52);
return (ok);
}

/*----------------------------------------------------------------------------*/
/* ReAction-Klassen schließen */
/*----------------------------------------------------------------------------*/

void close_classes (void)
{
CLOSELIB(Window);
CLOSELIB(Layout);
CLOSELIB(Button);
CLOSELIB(ListBrowser);
CLOSELIB(Requester);
}

/*----------------------------------------------------------------------------*/
/* free_listbrowser_list */
/*----------------------------------------------------------------------------*/

void free_listbrowser_list (struct List *list)
{
FreeListBrowserList (list);
FreeVec (list);
}



// *******************************************************************
// Make strict UPPERCASE
// return same we got (for use in functions)
// *******************************************************************

UBYTE * makeupper(UBYTE *str)
{
UBYTE *p;
for (p = str; *p!='\0'; p++) *p = toupper((char)*p); /// crash ???
return (str);
}

/*----------------------------------------------------------------------------*/
/* */
/*----------------------------------------------------------------------------*/
char *my_strtok_r(char *s, const char *sep, char **state) {
char *tok;
char c;
if (s == NULL && (s = *state) == NULL)
return NULL;
tok = s;
while ((c = *s) != '\0' && strchr(sep, c) == NULL) s++;

if (c != '\0')
*s++ = '\0';
else
s = NULL;

*state = s;

return tok;
}


/*----------------------------------------------------------------------------*/
/* Print the list */
/*----------------------------------------------------------------------------*/
void PrintListBrowser(Object *wnd, Object *lb)
{
struct Window *window;
struct List *list;
struct Node *node;
uint32 selected;
// get list
GetAttr(LISTBROWSER_Labels, lb, (uint32 *)&list);
for (node = list->lh_Head; node->ln_Succ; node = node->ln_Succ)
{
selected = FALSE;
GetListBrowserNodeAttrs(node,
LBNA_Selected, &selected,
TAG_END);
SetListBrowserNodeAttrs(node,
LBNA_Selected, !selected,
TAG_END);
}


}

/*----------------------------------------------------------------------------*/
/* Restore the original loaded sequence //maintain the selection status */
/*----------------------------------------------------------------------------*/

BOOL RestoreListBrowser(Object *wnd, Object *lb) /// listbrowser object //gadget
{
struct Window *window=NULL;
struct List *list=NULL;
struct Node *node=NULL;
int i = 0;
Printf("restore totallines %ld\n",(LONG)totallines);
GetAttr(LISTBROWSER_Labels, lb, (uint32 *)&list);
SetAttrs(lb, LISTBROWSER_Labels, ~0, TAG_END); ///remove list
list = AllocSysObject(ASOT_LIST, NULL);
if (list == NULL)
{
return (FALSE);
}
while (i < totallines)
{
node = AllocListBrowserNode(1,
LBNCA_CopyText, TRUE,
LBNCA_Text, lines,
TAG_END);
if (node == NULL)
{
FreeListBrowserList(list);
FreeSysObject(ASOT_LIST, list);
return (FALSE);
}
AddTail(list, node);
Printf("restore i %ld %s\n",(LONG)i,lines); ///seen
++i;
}

// get intuition window pointer
window = NULL;
GetAttr(WINDOW_Window, wnd, (uint32 *)&window); /// (uint32 )&window)passing argument 4 of 'IIntuition->GetAttr' makes pointer from integer without a cast
///GetAttr(WINDOW_Window, wnd, (uint32 *)window); ///passing argument 4 of 'IIntuition->GetAttr' from incompatible pointer type

Printf("GotAttr\n"); /// seen
// read list and refresh
SetGadgetAttrs((struct Gadget *)lb, window, NULL,
LISTBROWSER_Labels, list,
TAG_END);
Printf("SetAttr\n"); /// seen
return (TRUE);
}


/*----------------------------------------------------------------------------*/
/* Inverse the chosen Selection */
/*----------------------------------------------------------------------------*/

void InvertListBrowser(Object *wnd, Object *lb)
{
struct Window *window=NULL;
struct List *list=NULL;
struct Node *node=NULL;
uint32 selected;

// get list
GetAttr(LISTBROWSER_Labels, lb, (uint32 *)&list);

// remove list
SetAttrs(lb, LISTBROWSER_Labels, ~0, TAG_END);

// make changes
for (node = list->lh_Head; node->ln_Succ; node = node->ln_Succ)
{
selected = FALSE;
GetListBrowserNodeAttrs(node,
LBNA_Selected, &selected,
TAG_END);
SetListBrowserNodeAttrs(node,
LBNA_Selected, !selected,
TAG_END);
}

// get intuition window pointer
window = NULL;
GetAttr(WINDOW_Window, wnd, (uint32 *)&window); //

// read list and refresh
SetGadgetAttrs((struct Gadget *)lb, window, NULL,
LISTBROWSER_Labels, list,
TAG_END);
}
/*----------------------------------------------------------------------------*/
/* Select All */
/*----------------------------------------------------------------------------*/

void SelectAllBrowser(Object *wnd, Object *lb)
{
struct Window *window=NULL;
struct List *list=NULL;
struct Node *node=NULL;
uint32 selected;

// get list
GetAttr(LISTBROWSER_Labels, lb, (uint32 *)&list);

// remove list /// detach
SetAttrs(lb, LISTBROWSER_Labels, ~0, TAG_END);

// make changes
ListBrowserSelectAll(list);

// get intuition window pointer
window = NULL;
GetAttr(WINDOW_Window, wnd, (uint32 *)&window);

// read list and refresh
SetGadgetAttrs((struct Gadget *)lb, window, NULL,
LISTBROWSER_Labels, list,
TAG_END);
}

/*----------------------------------------------------------------------------*/
/* Select None */
/*----------------------------------------------------------------------------*/

void SelectNoneBrowser(Object *wnd, Object *lb)
{
struct Window *window=NULL;
struct List *list=NULL;
struct Node *node=NULL;
uint32 selected;

// get list
GetAttr(LISTBROWSER_Labels, lb, (uint32 *)&list);

// remove list /// detach
SetAttrs(lb, LISTBROWSER_Labels, ~0, TAG_END);

// make changeq
ListBrowserClearAll(list);

// get intuition window pointer
window = NULL;
GetAttr(WINDOW_Window, wnd, (uint32 *)&window); /// crash

// read list and refresh
SetGadgetAttrs((struct Gadget *)lb, window, NULL,
LISTBROWSER_Labels, list,
TAG_END);
}



char msg[MAX_LINE];

/*----------------------------------------------------------------------------*/
/* concatenate 3 strings */
/*----------------------------------------------------------------------------*/


STRPTR concat3strings( STRPTR string1 , STRPTR string2, STRPTR string3)
{
snprintf(msg, sizeof msg, "%s%s", &msg[0], string1);
snprintf(msg, sizeof msg, "%s\n%s", &msg[0], string2);
snprintf(msg, sizeof msg, "%s\n%s", &msg[0], string3);
return (&msg[0]);
}


/*----------------------------------------------------------------------------*/
/* display message box */
/*----------------------------------------------------------------------------*/

void log_displayBox (const char *title, int isError, const char *msg, struct Screen * scr )
{
Object *requester;
///requester = NewObject(RequesterClass, NULL, ///IIIntuition=> problems with opening libs
requester = NewObject(REQUESTER_GetClass(), NULL, ///IIIntuition=> ///IRequester->REQUESTER_GetClass()
REQ_TitleText, title,
REQ_BodyText, msg,
REQ_GadgetText, "_Ok",
REQ_Image, isError ? REQIMAGE_ERROR : REQIMAGE_INFO,
TAG_END);
if (requester != NULL) {
//IIntuition->IDoMethod(requester, RM_OPENREQ, NULL, NULL, NULL);
IDoMethod(requester, RM_OPENREQ, NULL, NULL, scr); ///IIIntuition=>
DisposeObject(requester); ///IIIntuition=>
}
}


/*----------------------------------------------------------------------------*/
/* make_listbrowser_clip */
/*----------------------------------------------------------------------------*/

struct List *make_listbrowser_clip (void) {
STRPTR clipstring;
uint32 clipsize;
struct List *list;
STRPTR line, state;
struct Node *node;
int i=0;
if (!ReadClipVector(&clipstring, &clipsize))
return NULL;
list = AllocSysObject(ASOT_LIST, NULL);
if (list == NULL) {
DisposeClipVector(clipstring);
return NULL;
}
line = my_strtok_r(clipstring, "\n", &state);
while (line != NULL)
{
Strlcpy((STRPTR)&lines,(CONST_STRPTR)line,MAX_LINE); ///IUtility-> ///passing argument 2 of 'IUtility->Strlcpy' from incompatible pointer type

node = AllocListBrowserNode(1,
LBNCA_CopyText, TRUE,
LBNCA_Text, line,
TAG_END);
if (node == NULL) {
DisposeClipVector(clipstring);
FreeListBrowserList(list);
FreeSysObject(ASOT_LIST, list);
return NULL;
}

AddTail(list, node);

line = my_strtok_r(NULL, "\n", &state);
++i;
}
totallines = i;
Printf("_clip totallines %ld\n",(LONG)totallines);
DisposeClipVector(clipstring);

if (IsListEmpty(list)) {
FreeSysObject(ASOT_LIST, list);
return NULL;
}

return list;
}

/*----------------------------------------------------------------------------*/
/* make_listbrowser_choices */
/*----------------------------------------------------------------------------*/

struct List *make_listbrowser_choices (char **args) /// called with (args.choices)
{
struct List *list=NULL;
if ((list = AllocVecTags (sizeof(struct List), AVT_ClearWithValue, 0, TAG_END)))
{
NewList (list);
while (*args) //crash
{
struct Node *node;
if (node = AllocListBrowserNode (1,LBNCA_Text,*args,TAG_END))
AddTail (list,node);
else
{
free_listbrowser_list (list);
return (NULL);
}
args++;
}
if (!(list->lh_Head->ln_Succ))
{
free_listbrowser_list (list);
return (NULL);
}
}
return (list);
}

/*----------------------------------------------------------------------------*/
/* make_listbrowser_file */
/*----------------------------------------------------------------------------*/

struct List *make_listbrowser_file (char *filepath) /// called with (input_file)
{
BPTR input_file = FOpen(filepath, MODE_OLDFILE,0); ///IDOS-> /// buffersize 0 ??
if(0 == input_file)
{
log_displayBox("ReqList", 0, concat3strings("Could not open file ",filepath ,"for reading"),NULL );
//Printf("Could not open file %s for reading\n", filepath); ///IDOS->
/// If the file cannot be opened for any reason, the value returned will be zero, and a secondary error code will be available by calling the routine IoErr().

PrintFault (IoErr(), "Error opening file");
return(NULL);
}

struct List *list = AllocSysObjectTags(ASOT_LIST, TAG_END); ///IExec->
if(NULL == list)
{
Printf("Could not allocate browser list\n"); ///IDOS->
FClose(input_file); ///IDOS->
return(NULL);
}

struct FReadLineData *frld = AllocDosObject(DOS_FREADLINEDATA, TAG_END); ///IDOS->
if(NULL == frld)
{
Printf("Could not alloc FReadLineData struct\n"); ///IDOS->
FreeSysObject(ASOT_LIST, list); ///IExec->
FClose(input_file); ///IDOS->
return(NULL);
}

int32 len, count = 0;
struct Node *node;

len = FReadLine(input_file, frld); ///IDOS->
while(len > 0)
{
// replace badChars with spaces
char *next;
while((next = strpbrk(frld->frld_Line, &badChar[0])))
{
*next = ' ';
}

if ((node = AllocListBrowserNode ( ///IListBrowser->
1,
// CopyText, TRUE is required because the buffer
// contents will be changing.. so we ask the
// listbrowser to make a copy of each entry.
LBNCA_CopyText, TRUE,
LBNCA_Text, frld->frld_Line,
TAG_END )))
{
AddTail (list,node); ///IExec->
count++;
}
else
{
Printf("LBNode allocation failure\n"); ///IDOS->
SetIoErr(ERROR_NO_FREE_STORE); ///IDOS->
len = -1;
}
len = FReadLine(input_file, frld); ///IDOS->
}

if(len < 0)
{
PrintFault(IoErr(), NULL); ///IDOS->
FreeListBrowserList(list); ///IListBrowser->
FreeSysObject(ASOT_LIST, list); ///IExec->
list = NULL;
}

FreeDosObject(DOS_FREADLINEDATA, frld); ///IDOS->
FClose(input_file); ///IDOS->

return(list);
}


/*----------------------------------------------------------------------------*/
/* Request selected info & take action according to hit button */
/* returns as "result" the list of selected lines
//reponds to each action on LV, as well select as unselect
/*----------------------------------------------------------------------------*/

char *request_list (struct Screen *scr,const char *title,const char *body,struct List *list,BOOL multi,BOOL persist,BOOL notempty)

{
char *result = NULL; /// text of the line
int32 *line_nr;
Object *winobj;
struct Gadget *lbo;
struct Gadget *bdo;

///===============
struct ColumnInfo *ci = AllocLBColumnInfo(NUM_COLS, ///IListBrowser->
LBCIA_Column,COL_DEFAULT_SORT,
LBCIA_Title, "Click to toggle sort",
LBCIA_AutoSort, TRUE,
LBCIA_SortArrow, TRUE,
TAG_DONE);

///================

/// bdo = body ? ButtonObject,
bdo = body ? (struct Gadget *)ButtonObject,
///bdo = body ? (struct Gadget *)NewObject(NULL, "button.gadget",
GA_Text,body,
GA_ReadOnly,TRUE,
BUTTON_BevelStyle,BVS_NONE,
BUTTON_Transparent,TRUE,
EndObject : NULL; ///warning: assignment from incompatible pointer type


winobj = WindowObject,
WA_Title,title ? title : "Request",
WA_Flags,WFLG_CLOSEGADGET | WFLG_DRAGBAR | WFLG_DEPTHGADGET | WFLG_SIZEGADGET | WFLG_SIZEBBOTTOM | WFLG_ACTIVATE,
WA_PubScreen,scr,
WA_Width,scr->Width * 4 / 10,
WA_Height,scr->Height * 6 / 10,
WINDOW_Position,WPOS_CENTERSCREEN,
WINDOW_Layout,VGroupObject, /// no parent group ??
LAYOUT_SpaceOuter,TRUE,
bdo ? LAYOUT_AddChild : TAG_IGNORE,bdo,
CHILD_WeightMinimum,TRUE,
LAYOUT_AddChild,lbo = (struct Gadget *) ListBrowserObject,
GA_ID,GID_LIST,
GA_RelVerify,TRUE,
LISTBROWSER_ColumnInfo, ci, /// added
LISTBROWSER_ColumnTitles, TRUE, /// added
LISTBROWSER_TitleClickable, TRUE, /// added
LISTBROWSER_SortColumn, 0, /// added
LISTBROWSER_Labels,list, /// >>>>>>> attached here
LISTBROWSER_ShowSelected,TRUE,
LISTBROWSER_MultiSelect,multi,
LISTBROWSER_PersistSelect,persist,
EndObject, ///warning: assignment from incompatible pointer type
StartHGroup,
LAYOUT_EvenSize,TRUE, ///
LAYOUT_FixedVert,FALSE,
LAYOUT_AddChild,
Button("Ok",GID_OK), /// continue = FALSE
LAYOUT_AddChild,
Button("All",GID_ALL),
LAYOUT_AddChild,
Button("None",GID_NONE),
LAYOUT_AddChild,
Button("Inverse",GID_INVERSE),
LAYOUT_AddChild,
Button("Restore",GID_RESTORE),
LAYOUT_AddChild,
Button("Cancel",GID_CANCEL),
EndHGroup,
EndVGroup,
EndWindow;

if (winobj)
{
struct Window *win;
if (win = RA_OpenWindow (winobj)) //// >>macro >>>>>>>>>>>>>>>>>>>
{
BOOL cont = TRUE;
ULONG winsig;
struct Node *node = NULL;
GetAttr (WINDOW_SigMask,winobj,&winsig);
do /// while cont
{ /// loop
ULONG sigs = Wait (winsig | SIGBREAKF_CTRL_C); /// wait for a signal
if (sigs & SIGBREAKF_CTRL_C)
cont = FALSE;
if (sigs & winsig)
{
ULONG code;
while ((code = RA_HandleInput(winobj,NULL)) != WMHI_LASTMSG) ///
{
switch (code & WMHI_CLASSMASK)
{
case WMHI_GADGETUP:
switch (code & WMHI_GADGETMASK)
{
case GID_LIST:
GetAttr (LISTBROWSER_SelectedNode,(Object *)lbo,(uint32 *)&node); ///(ULONG *)&node); ///(uint32 *)
if (node)
{
ULONG sel = 0;
GetListBrowserNodeAttrs (node,LBNA_Selected,&sel,LBNCA_Text,&result,TAG_END);
if (multi && !sel)
result = NULL;
else if (!multi && !persist)
cont = FALSE; ///>>>>>
}
break;
case GID_OK:
if (result) /// at least 1 line selected
cont = FALSE; ///>>>>>
else if (notempty)
DisplayBeep (scr);
else
{
result = "";
cont = FALSE; ///>>>
}
break;
case GID_INVERSE:
InvertListBrowser(winobj,(Object *) lbo); /// warning: passing argument 2 of 'InvertListBrowser' from incompatible pointer type
break;
case GID_NONE:
SelectNoneBrowser(winobj,(Object *) lbo);
break;
case GID_ALL:
SelectAllBrowser(winobj,(Object *) lbo);
break;
case GID_RESTORE:
RestoreListBrowser(winobj,(Object *) lbo);
break;
case GID_CANCEL:
cont = FALSE;
break;
}
break;
case WMHI_CLOSEWINDOW:
cont = FALSE;
break;
}
}
} //CLASSMASK
} ///while
while (cont);
} /// do
else
Printf ("cannot open window\n");

DisposeObject (winobj);
}
else
Printf ("cannot create objects\n");
return (result);
}



/*----------------------------------------------------------------------------*/
/* Hauptprogramm

If I_FILE is used choices will be disregarded, unless
- no file is given ??
- or the given file does not exist, ??
- is not a text file or ??
- is too large ??

If choices not used, & I_FILE switch not set, a secundary file requester will ask for the input file ??

I_FILE can be clips:0, then content of clipboard is used
If only text: if not => ??
// IF CLIP is set, the output will be directed tot the clipboard
If O_File is given the outputt will be directed to the given output file
Output file can be clips:0 (Textclip.library only sufficiênt for single line output (not multi)

>if (!(args.choices))
if (!(args.i_file))
ReqFile
LoadFile
else
LoadFile
endif
makelist_fromfile
else // choices
makelist_fromchoices
endif >>>> */

/*----------------------------------------------------------------------------*/

int main (void)
{
int rc = RETURN_FAIL;
struct RDArgs *rdargs;
struct
{
char *title;
char *body;
char *i_file;
char **choices;
long multi;
long persist;
long notempty;
long clip;
char *o_file;
char *pubscreen;
} args = {0};
struct List *list;
BPTR output_file=ZERO;///NULL; ///FILE *output_file=NULL; FILE ANSI
//FILE *input_file=NULL;
char *Selected[TOTAL_LINES]; /// not used
char buf[MAX_LINE];
char *str[TOTAL_LINES];
char clip[MAX_CLIP]= {""}; ///crash
int i =0;
if (!open_classes())
{
Printf ("cannot load required classes\n");
close_classes();
return (RETURN_FAIL);
}
rdargs = ReadArgs ("TITLE/K,BODY/K,I_FILE/K,CHOICES/A/M,MULTI/S,PERSIST/S,NOTEMPTY/S,PUBSCREEN/K,O_FILE/K",(LONG *)&args,NULL);

if (!rdargs)
{
PrintFault (IoErr(),NULL);
close_classes();
return (RETURN_ERROR);
}


if (args.o_file)
{ //> check ifexists warn, & delete if ok to overwrite
Printf("main args.o_file %s\n", args.o_file);
if (strcmp(makeupper(args.o_file),"CLIPS:0")== 0)
{ //No output file to open startup writing to clips ///No

}
else
{
output_file = Open((CONST_STRPTR)args.o_file, MODE_NEWFILE ); ///warning: assignment makes pointer from integer without a cast

if (!output_file)
{
log_displayBox("ReqList", 0, concat3strings("File ", args.o_file ,"cannot be opened"),NULL ); // screen not declared
//ReqFile
}
}
}
if(!args.i_file) ///
{
list = make_listbrowser_choices (args.choices); //>>>>>>>>>>>>>>>>>>>>1st internal call
}
else
{
if (strcmp(makeupper(args.i_file),"CLIPS:0")== 0)
{
list = make_listbrowser_clip();
/// list = make_listbrowser_file (args.i_file);
}
else
{
list = make_listbrowser_file (args.i_file);
}
} // args.i
if (list)
{
struct Screen *scr;
if (scr = LockPubScreen (args.pubscreen))
{
char *result;
if (result = request_list (scr,args.title,args.body,list,args.multi,args.persist,args.notempty)) /// internal call 2
{
if (args.multi) //selection of a nr of lines
{
struct Node *node,*next;
for (node = list->lh_Head; next = node->ln_Succ; node = next) /// loop
{
char *text = NULL;
ULONG sel = 0;
BOOL inverse = FALSE;
GetListBrowserNodeAttrs (node, /// verifcation if line is selected
LBNA_Selected,&sel,
LBNCA_Text,&text,
TAG_END);
if (sel && text) /// if line is selected
{
if (args.o_file)
{
if (strcmp(makeupper(args.o_file),"CLIPS:0")== 0) /// crash there is no args.o_file
{ ++i;
////add2clipboard(text,strlen(text) ;
if (i > 1)
snprintf(clip, sizeof clip, "%s\n%s", &clip[0], text);
else
snprintf(clip, sizeof clip, "%s%s", &clip[0], text);
}
else if (output_file)
FPrintf(output_file,"%s\n", text);
else ///if (!output_file) /// not opened if output is clips:0
Printf("%s\n",text); /// seen 1 for each selected line
}
else
Printf("%s\n",text);

}
} //node
WriteClipVector(&clip[0], strlen(&clip[0])); ///->ITextClip a global write of all the lines
} //args.multi
else /// only one line selected
{
if (args.o_file)
{
if (strcmp(makeupper(args.o_file),"CLIPS:0")== 0) /// crash there is no args.o_file
WriteClipVector(result, strlen(result)); ///->ITextClip
else if (output_file)
FPrintf(output_file,"%s\n", result);
else ///if (!output_file) /// not opened if output is clips:0
Printf("%s\n",result); /// seen 1 for each selected line
}
else
Printf("%s\n",result);
}
rc = RETURN_OK;
} //result
else
rc = RETURN_WARN;
UnlockPubScreen (NULL,scr);
} //scr
free_listbrowser_list (list);
} //list
else
{
}
// if (output_file) fclose (output_file);
FreeArgs (rdargs);
close_classes();
return (rc);
}//main

/*----------------------------------------------------------------------------*/
/* Ende des Quelltextes */
/*----------------------------------------------------------------------------*/

If each node had LBNA_UserData set to something like.. a number that is incremented with each new entry..
then restoring the list to original order would be as easy as sorting on that field.

JosDuchIt wrote:@LyleHaze

If each node had LBNA_UserData set to something like.. a number that is incremented with each new entry..
then restoring the list to original order would be as easy as sorting on that field.

I did only read this suggestion now. Quite simple indeed
Would this additional number show up in the listview ? i guess, if so , can it be hidden?
Can sorting on some column be initiated elsewhere than from column title?