Document sans nom

#define INC_EXEC
#define INC_DOS
#define INC_INTUITION
#define INC_WORKBENCH
#define INC_GADTOOLS
#define INC_ASL

#include <stdio.h>
#include "h:macros.h"
#include "h:cpe.h"

CPEGRP *grp;

#define INOUT( toput ) { WriteFile( inout, toput, strlen(toput) ); WriteFile( inout, '\n', 1 );}

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

DFILE *save;
DFILE *load;

EXTERN UWORD left,top,width,height;

EXTERN WIN *wnd;
EXTERN SCR *scn;
EXTERN GAD *gad[GCOUNT];
EXTERN GAD *glist = NL;
DISK_OBJET *od = NL;

MNU_NEW mnu_new[100];
MNU *mnu = NL;
#define NUM_ITEM 15

MNU_NEW mnu_new_tmp[NUM_ITEM] = {
NM_TITLE,(STRPTR)"Project", NULL, 0, 0L, NULL,
NM_ITEM, (STRPTR)"New", "n" , 0, 0L, (APTR)prj_new_clic,
NM_ITEM, (STRPTR)NM_BARLABEL, NULL, 0, 0L, NULL,
NM_ITEM, (STRPTR)"Load", "l" , 0, 0L, (APTR)prj_lod_clic,
NM_ITEM, (STRPTR)"Save", "s" , 0, 0L, (APTR)prj_sav_clic,
NM_ITEM, (STRPTR)"Save as...", "S" , 0, 0L, (APTR)prj_sas_clic,
NM_ITEM, (STRPTR)NM_BARLABEL, NULL, 0, 0L, NULL,
NM_ITEM, (STRPTR)"About", "t" , 0, 0L, (APTR)prj_abt_clic,
NM_ITEM, (STRPTR)NM_BARLABEL, NULL, 0, 0L, NULL,
NM_ITEM, (STRPTR)"Quit", "q" , 0, 0L, (APTR)prj_qit_clic,
NM_TITLE,(STRPTR)"Source", NULL, 0, 0L, NULL,
NM_ITEM, (STRPTR)"Make *", "*", 0, 0L, (APTR)src_mke_sta_clic,
NM_ITEM, (STRPTR)"Make All", "a", 0, 0L, (APTR)src_mke_all_clic,
NM_ITEM, (STRPTR)"Scan Directory","d",0, 0L, (APTR)src_scn_all_clic,
NM_TITLE,(STRPTR)"Groups", NULL, 0, 0L, NULL };

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

#define NUM_PATH 5
#define NUM_NAME 4
#define NUM_OPTS 4
#define NUM_DIVS 4
#define NUM_CUST 5

STRPTR toolpath[NUM_PATH]={"PATH_GRP","PATH_LIB","PATH_SRC","PATH_ED","PATH_BIN"};
STRPTR toolname[NUM_NAME]={"NAME_PREPRO","NAME_COMPIL","NAME_ASSEMB","NAME_LINKER"};
STRPTR toolopts[NUM_OPTS]={"OPTS_PREPRO","OPTS_COMPIL","OPTS_ASSEMB","OPTS_LINKER"};
STRPTR tooldivs[NUM_DIVS]={"OUTPUT","START_GRP","STR_FINISH","CMDS_RES"};
STRPTR toolcust[NUM_CUST]={"CUST1","CUST2","CUST3","CUST4","CUST5"};

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

STRPTR path[NUM_PATH], cur_path[3];

#define GRP 0 /* path & cur_path */
#define LIB 1
#define SRC 2
#define EDI 3 /* only path */
#define BIN 4

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

STRPTR *name[NUM_NAME];
STRPTR *opts[NUM_OPTS];

#define PREPRO 0 /* name & opts */
#define COMPIL 1
#define ASSEMB 2
#define LINKER 3
#define CUSTOM 4

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

STRPTR *divs[NUM_DIVS];

#define OUT 0
#define STA 1
#define FIN 2
#define CMD 3

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

STRPTR *cust[NUM_CUST];

#define CUST1 0
#define CUST2 1
#define CUST3 2
#define CUST4 3
#define CUST5 4

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

#define NUM_LIST 3

LIST list[ NUM_LIST ];

#define LTOP 0
#define LEND 1
#define LSRC 2

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

LIST *filelist;

MSG_PORT *notify_port;
NOTIFY_MSG *notify_msg;

LONG cur_grp;

LONG cur_out = FALSE;

BPTR inout = NL;

/*--------------------------------------------------------------------------*/
EXTERN WORD grp_func();
EXTERN VOID con();

VOID Main()
{
REGISTER loop;
ULONG wndsig=NL, notify_sig=NL, sig = NL;
NODE *n;
INT num=NL;

grp = (CPEGRP *) New( SIZEOF( CPEGRP ), MEMF_CLEAR );

NewList( &list[ LEND ] );
NewList( &list[ LTOP ] );
NewList( &list[ LSRC ] );

IF( AddPart( o_pn.path, o_pn.name, PATH ) )
{
IF( od = ( DISK_OBJET *) GetDiskObject( o_pn.path ) )
{
FOR(loop=0;loop<NUM_PATH;loop++){path[loop]=(STRPTR)FindToolType(od->do_ToolTypes,toolpath[loop]);}
FOR(loop=0;loop<NUM_NAME;loop++){name[loop]=(STRPTR)FindToolType(od->do_ToolTypes,toolname[loop]);}
FOR(loop=0;loop<NUM_OPTS;loop++){opts[loop]=(STRPTR)FindToolType(od->do_ToolTypes,toolopts[loop]);}
FOR(loop=0;loop<NUM_DIVS;loop++){divs[loop]=(STRPTR)FindToolType(od->do_ToolTypes,tooldivs[loop]);}
FOR(loop=0;loop<NUM_CUST;loop++){cust[loop]=(STRPTR)FindToolType(od->do_ToolTypes,toolcust[loop]);}

left=(UWORD)atoi(FindToolType(od->do_ToolTypes,"WIN_LEFT"));
top =(UWORD)atoi(FindToolType(od->do_ToolTypes,"WIN_TOP"));
}
}

cur_path[GRP] = path[GRP];
cur_path[SRC] = path[SRC];
cur_path[LIB] = path[LIB];

strcpy( grp->name, divs[STA] );
strcpy( grp->path, path[GRP] );

FOR( loop=NL; loop<NUM_ITEM; loop++)
{
CopyMem( &mnu_new_tmp[loop], &mnu_new[loop], sizeof( MNU_NEW ) );
num = loop;
}

filelist = (LIST *) GetFileList( "#?.cpe", grp->path );

IF( ListNotEmpty( filelist ) )
{
n = (NODE *) GetHead( filelist );

WHILE( ISNODE(n) )
{
num++;
RemExt( n->ln_Name );
mnu_new[num].nm_Type = NM_ITEM;
mnu_new[num].nm_Label = (STRPTR)n->ln_Name;
mnu_new[num].nm_CommKey = NL;
mnu_new[num].nm_Flags = 0;
mnu_new[num].nm_MutualExclude = 0L;
mnu_new[num].nm_UserData = grp_func;
n = (NODE *) GetSucc( n );
}
}

num++;
mnu_new[num].nm_Type = NM_END;
mnu_new[num].nm_Label = NL;
mnu_new[num].nm_CommKey = NL;
mnu_new[num].nm_Flags = 0;
mnu_new[num].nm_MutualExclude = 0L;
mnu_new[num].nm_UserData = NL;

out(); /* open output */

notify_port = NewMsgPort( );

scn = (SCR *) NewScrPub( NL );
NewVI( scn );

OpenWnd(); /* gt.c */

ReadGroup( grp->path, grp->name );

IF( StrCmp( divs[CMD], "TRUE" ) )
{
FOR( loop = PREPRO; loop <= LINKER; loop++ )
{
IF(! FindRes(name[loop]) )
{
IF(! LoadRes(path[BIN],name[loop]) )
{
Request( "Ok", "Load resident failed on : %ls\nPlease change tool type : %ls",name[loop],toolname[loop] );
bye(0L);
}
}
}
path[BIN] = "";
}
ELSE
{
FOR( loop = PREPRO; loop <= LINKER; loop++ )
{
IF(!( Exist(path[BIN],name[loop])))
{
Request( "Ok", "Find command failed on : %ls\nPlease change tool type : %ls",name[loop],toolname[loop] );
bye(0L);
}
}
}

wndsig = GetSig( wnd->UserPort );
notify_sig = GetSig( notify_port );

WHILE(1)
{
sig = Wait( notify_sig | wndsig );

IF( sig & wndsig ) HandleIDCMP();
IF( sig & notify_sig )
{
CPESRC *src;
SetNoList( gad_src_lst );

WHILE( notify_msg = (NOTIFY_MSG *) GetMsg( notify_port ) )
{
src = (CPESRC *) notify_msg->nm_NReq->nr_UserData;
ReplyMsg( (MSG *) notify_msg );
}

IF( src )GetMakeSrc( src );
SetListAndRefresh( gad_src_lst, &list[ LSRC ] );
}
}
}

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

VOID bye( ULONG n )
{
IF( cur_out )
{
RemFile( inout );
cur_out = FALSE;
}

FreeGroup();
RemMnu( mnu, wnd );
RemWin( wnd );
RemGads( glist );

CloseScn();

RemFileList( filelist );
FreeDiskObject( od );

RemMsgPort( notify_port );

Rem( grp, SIZEOF( CPEGRP) );

Exit(0); /* Free all */
}

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

VOID out()
{
IF( cur_out )
{
RemFile( inout );
cur_out = FALSE;
}
ELSE
{
inout = NewFile( divs[OUT], MODE_NEWFILE );
cur_out = TRUE;
}
}

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

WORD grp_func( )
{
INT loop=NL;
NODE *n;

n = (NODE *) GetHead( filelist );

WHILE( ISNODE(n) )
{
IF( loop == cur_grp )
{
strcpy( grp->name, n->ln_Name );
ReadGroup( grp->path, grp->name );
BREAK;
}
loop++;
n = (NODE *) GetSucc( n );
}
}

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

CPESRC *last_src;
CPELIB *last_top;

WORD top_lst_clic()
{
CPELIB *top = (CPELIB *)GetSelectNode(gad_top_lst,&list[ LTOP ]);

IF( Double() )
{
IF( top == last_top )
{
IF( StrCmp( top->name, "o.o" ) )
{
sprintf( cmd,"%s %s",path[EDI],"lib:o.c");
CmdA( cmd, "NIL:", "NIL:" );
}
}
}
last_top = top;
}

WORD end_lst_clic() {}
WORD src_lst_clic()
{
CPESRC *src=(CPESRC *)GetSelectNode(gad_src_lst,&list[ LSRC ]);

IF( Double() )
{
IF( src == last_src )
{
FreeCmd(); FreeTmp();
MakePathName( tmp, src->path, src->name );
sprintf( cmd,"%s %s",path[EDI],tmp);
CmdA( cmd, "NIL:", "NIL:" );
}
}
last_src = src;
}

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

WORD top_add_clic( void )
{
CPELIB *top; NewTop( top );

strcpy( top->path, cur_path[LIB] );
strcpy( top->name, "");

IF( ReqFile( "", "Select top lib", top->path, top->name ))
{
top->node.ln_Name = top->name;
AddNodeEndList( gad_top_lst, &list[ LTOP ], top );
SetAttr(gad_top_lst,GTLV_Top,grp->num_top);
SetAttr(gad_top_lst,GTLV_Selected,grp->num_top);
}
ELSE RemTop( top );
}

WORD end_add_clic( void )
{
CPELIB *end; NewEnd( end );

strcpy( end->path, cur_path[LIB] );
strcpy( end->name, "");

IF( ReqFile( "", "Select end lib", end->path, end->name ))
{
end->node.ln_Name = end->name;
AddNodeEndList( gad_end_lst, &list[ LEND ], end );
SetAttr(gad_end_lst,GTLV_Top,grp->num_end);
SetAttr(gad_end_lst,GTLV_Selected,grp->num_end);
}
ELSE { RemEnd( end ); }
}

WORD src_add_clic( void )
{
CPESRC *src; NewSrc( src );

strcpy( src->path, cur_path[SRC] );
strcpy( src->name, "");

IF( ReqFile( "~(#?.o|#?.info)", "Select Source File", src->path, src->name ))
{
GetMakeSrc( src );
AddNodeEndList( gad_src_lst, &list[ LSRC ], src );
SetAttr(gad_src_lst,GTLV_Top,grp->num_src);
SetAttr(gad_src_lst,GTLV_Selected,grp->num_src);
src->notify = (NOTIFY_REQ *) LinkNotify( notify_port, src->path, src->name, src );
}
ELSE { RemSrc( src ); }
}

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

WORD top_rem_clic( void )
{
CPELIB *top;
IF(top=(CPELIB *)RemSelectNode(gad_top_lst,&list[ LTOP ]))
{
RemTop(top);
}
}
WORD end_rem_clic( void )
{
CPELIB *end;
IF(end=(CPELIB *)RemSelectNode(gad_end_lst,&list[ LEND ]))
{
RemEnd(end);
}
}
WORD src_rem_clic( void )
{
int res=-1;
CPESRC *src;
IF(src=(CPESRC *)GetSelectNode(gad_src_lst,&list[ LSRC ]))
{
IF( StrCmp( grp->exe_name, "dfk.lib" ) )
{
res = Request("From list|From lib|Cancel","Removing %ls", src->list );
}

SWITCH( res )
{
CASE 0: BREAK;

CASE 2:
{
WindowToBack( wnd );
FreeCmd(); FreeBuf();
MakePathNameExt( buf, src->path, src->name, ".o" );
sprintf( cmd,"bin:libr -d lib:dfk.lib %ls",buf );
INOUT( cmd );
Cmd( cmd, inout );
INOUT( divs[FIN] );
WindowToFront( wnd );
} BREAK;

CASE 1:
CASE -1:
{
src=(CPESRC *)RemSelectNode(gad_src_lst,&list[ LSRC ]);
UnLinkNotify( src->notify );
RemSrc(src);
} BREAK;
}
}
}

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

WORD top_upp_clic( void ){UpSelectNode( gad_top_lst, &list[ LTOP ] );}
WORD end_upp_clic( void ){UpSelectNode( gad_end_lst, &list[ LEND ] );}
WORD src_upp_clic( void ){UpSelectNode( gad_src_lst, &list[ LSRC ] );}

WORD top_dow_clic( void ){DownSelectNode( gad_top_lst, &list[ LTOP ] );}
WORD end_dow_clic( void ){DownSelectNode( gad_end_lst, &list[ LEND ] );}
WORD src_dow_clic( void ){DownSelectNode( gad_src_lst, &list[ LSRC ] );}

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

WORD src_mke_clic( void )
{
REGISTER loop;
CPESRC *src;

IF( src = (CPESRC *) GetSelectNode( gad_src_lst, &list[ LSRC ] ))
{
FOR( loop = PREPRO; loop <= ASSEMB; loop++ )
{
FreeCmd();
FreeTmp();
MakePathName( tmp, path[BIN], name[loop] );

SWITCH( loop )
{
CASE PREPRO :
{
FreeBuf();
MakePathName( buf, src->path, src->name );
sprintf( cmd,"%s %s -oT:t.i %s",tmp,opts[PREPRO],buf);
} BREAK;

CASE COMPIL :
{
sprintf( cmd,"%s %s -oT:t.a T:t.i",tmp, opts[COMPIL]);
} BREAK;

CASE ASSEMB :
{
FreeBuf();
MakePathNameExt( buf, src->path, src->name, ".o" );
sprintf( cmd,"%s %s -o%s T:t.a", tmp, opts[ASSEMB], buf);
} BREAK;
}
INOUT( cmd );
Cmd( cmd, inout );
}

IF( StrCmp( grp->exe_name, "dfk.lib" ) )
{
FreeCmd();
sprintf( cmd,"bin:libr -r lib:dfk.lib %s",buf );/* buf = object.o" */
INOUT( cmd );
Cmd( cmd, inout );
}

DeleteFile( "T:t.i" );
DeleteFile( "T:t.a" );

INOUT( divs[FIN] );

SetNoList( gad_src_lst );
GetMakeSrc( src );
SetListAndRefresh( gad_src_lst, &list[ LSRC ] );
}
}

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

WORD exe_mke_clic( void )
{
LONG loop = NL;
CHAR *bigcmd;
CPELIB *top;
CPELIB *end;
CPESRC *src;

bigcmd = (CHAR *) New( 1024, MEMF_CLEAR );

MakePathName( bigcmd, path[BIN], name[LINKER] );

strcat( bigcmd, " " );
strcat( bigcmd, opts[LINKER] );
INOUT( bigcmd );

top = (CPELIB *) GetHead( &list[ LTOP ] );
WHILE( ISNODE(top) )
{
FreeTmp();
MakePathName( tmp, top->path, top->name );
strcat( bigcmd, " ");
strcat( bigcmd, tmp );
INOUT( tmp );
top = (CPELIB *) GetSucc( top );
}

src = (CPESRC *) GetHead( &list[ LSRC ] );
WHILE( ISNODE(src) )
{
FreeTmp();
MakePathNameExt( tmp, src->path, src->name, ".o" );
strcat( bigcmd, " ");
strcat( bigcmd, tmp );
INOUT( tmp );
src = (CPESRC *) GetSucc( src );
}

end = (CPELIB *) GetHead( &list[ LEND ] );
WHILE( ISNODE(end) )
{
FreeTmp();
MakePathName( tmp, end->path, end->name );
strcat( bigcmd, " ");
strcat( bigcmd, tmp );
INOUT( tmp );
end = (CPELIB *) GetSucc( end );
}
strcat( bigcmd, " " );
strcat( bigcmd, "-o" );
strcat( bigcmd, grp->exe_name );

INOUT( grp->exe_name );

WindowToBack( wnd );
Cmd( bigcmd, inout );
INOUT( divs[FIN] );
Rem( bigcmd, 1024 );
WindowToFront( wnd );
}

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

WORD exe_nam_clic( void ) { strcpy(grp->exe_name,GetStr(gad[gad_exe_nam])); }
WORD prj_new_clic( void ) { FreeGroup(); }
WORD prj_abt_clic( void )
{
Request("Ok","'C' Project Editor\n 2.12 (16.5.95)\nBy Franck Dutouron\n\nCopyright dFk Prod\n 1994-1995 ",NL);
FlushIntuiMsg( wnd );
}
WORD prj_qit_clic( void ) { bye(0); }

WORD prj_lod_clic( void )
{
IF( ReqFile( "(#?.cpe)", "Select a file to load", grp->path, grp->name ))
{
ReadGroup( grp->path, grp->name );
}
}
WORD prj_sav_clic( void )
{
IF( (StrCmp( grp->name,"")) == TRUE )
{
ReqFile( "(#?.cpe)", "Select a file name to save",grp->path, grp->name );
}
WriteGroup( grp->path, grp->name );
}
WORD prj_sas_clic( void )
{
IF( ReqFile( "(#?.cpe)", "Select a file name to save",grp->path, grp->name ))
{
WriteGroup( grp->path, grp->name );
}
}

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

WORD src_mke_sta_clic( void )
{
REGISTER loop=NL;
CPESRC *src = (CPESRC *) GetHead( &list[ LSRC ] );

WHILE( ISNODE(src) )
{
IF( src->make_it == TRUE )
{
SetAttr( gad_src_lst, GTLV_Selected, loop );
SetAttr( gad_src_lst, GTLV_Top,loop);
src_mke_clic();
}
src = (CPESRC *) GetSucc( src );
loop++;
}
}

WORD src_mke_all_clic( void )
{
REGISTER loop=NL;
CPESRC *src = (CPESRC *) GetHead( &list[ LSRC ] );

WHILE( ISNODE(src) )
{
SetAttr( gad_src_lst, GTLV_Selected, loop );
SetAttr( gad_src_lst, GTLV_Top,loop);
src_mke_clic();
src = (CPESRC *) GetSucc( src );
loop++;
}
}
WORD src_scn_all_clic( void )
{
FreeBuf();
strcpy( buf, path[SRC] );

IF( ReqPath( "Select A Drawer", buf ) )
{
LIST *l= (LIST *) GetFileList( "~(#?.o|#?.info)", buf /*path*/ );

WHILE( ListNotEmpty( l ))
{
NODE *n = (NODE *) RemHead( l );
IF( n )
{
CPESRC *src; NewSrc( src );

strcpy( src->path, buf );
strcpy( src->name, n->ln_Name );

GetMakeSrc( src );
AddNodeEndList( gad_src_lst, &list[ LSRC ], src );
src->notify = (NOTIFY_REQ *) LinkNotify( notify_port, src->path, src->name, src );
Rem( n->ln_Name, strlen(n->ln_Name) );
Rem( n, sizeof( NODE ) );
}
}
Rem( l, sizeof( LIST ) );
}
}

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

VOID UpSelectNode(LONG num,LIST *l)
{
LONG sel;
NODE *top;

IF( top = (NODE *) GetSelectNode( num, l ))
{
SetNoList( num );
UpNode( (LIST *)l, (NODE *)top );
SetListAndRefresh( num, l );
GetAttr( num, GTLV_Selected, &sel );
IF( sel > 0 )SetAttr( num, GTLV_Selected, --sel );
}
}
VOID DownSelectNode(LONG num,LIST *l)
{
LONG sel;
NODE *top;

IF( top = (NODE *) GetSelectNode( num, l ))
{
SetNoList( num );
DownNode( l, (NODE *)top );
SetListAndRefresh( num, l );
GetAttr( num, GTLV_Selected, &sel );
SetAttr( num, GTLV_Selected, ++sel );
}
}

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

VOID GetMakeSrc( CPESRC *src )
{
src->make_it = CompareSrcObj( src );

IF( src->make_it ){sprintf( src->list, " * %ls", src->name );}
ELSE {sprintf( src->list, " - %ls", src->name );}

src->node.ln_Name = src->list;
}

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

VOID SetListAndRefresh( LONG num, LIST *l)
{
GT_SetGadgetAttrs(gad[num],wnd,NL,GTLV_Labels,(LIST *)l,TAG_DONE);
RefreshGList(gad[num],wnd,NL,(UWORD)1);
}
VOID SetAttrAndRefresh( LONG num, LONG tag, LONG data)
{
GT_SetGadgetAttrs( gad[num], wnd, NL,tag,data,TAG_DONE);
RefreshGList(gad[num],wnd,NL,(UWORD)1);
}
VOID SetNoList( LONG num)
{
GT_SetGadgetAttrs(gad[num],wnd,NL,GTLV_Labels,(LIST *)~0,TAG_DONE);
}
VOID Refresh(LONG num)
{
RefreshGList(gad[num],wnd,NL,(UWORD)1);
}
VOID GetAttr(LONG num,LONG tag,LONG *data)
{
GT_GetGadgetAttrs(gad[num],wnd,NL,tag,data,TAG_DONE);
}
VOID SetAttr(LONG num,LONG tag,LONG data)
{
GT_SetGadgetAttrs(gad[num],wnd,NL,tag,data,TAG_DONE);
}
NODE *GetSelectNode(LONG num,LIST *l)
{
RETURN((NODE *)GTLV_GetSelectNode(wnd,gad[num],l));
}
NODE *RemSelectNode(LONG num,LIST *l)
{
RETURN((NODE *)GTLV_RemSelectNode((WIN *)wnd,(GAD *)gad[num],(LIST *)l));
}
VOID AddNodeEndList(LONG num,LIST *l,NODE *n)
{
GTLV_AddNodeEndList(wnd,gad[num],(LIST *)l,(NODE *)n);
}

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

VOID FreeGroup()
{
SetNoList( gad_top_lst );
SetNoList( gad_end_lst );
SetNoList( gad_src_lst );

WHILE( ListNotEmpty( &list[ LTOP ] ))
{
CPELIB *top = (CPELIB *) RemHead( &list[ LTOP ] );
RemTop( top );
}

WHILE( ListNotEmpty( &list[ LEND ] ))
{
CPELIB *end = (CPELIB *) RemHead( &list[ LEND ] );
RemEnd( end );
}

WHILE( ListNotEmpty( &list[ LSRC ] ))
{
CPESRC *src = (CPESRC *) RemHead( &list[ LSRC ] );
UnLinkNotify( src->notify );
RemSrc( src );
}

SetListAndRefresh( gad_top_lst, &list[ LTOP ] );
SetListAndRefresh( gad_end_lst, &list[ LEND ] );
SetListAndRefresh( gad_src_lst, &list[ LSRC ] );

strcpy( grp->exe_name, "" );

SetAttrAndRefresh( gad_exe_nam, GTST_String, (STRPTR) grp->exe_name );
}

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

VOID WriteGroup( STRPTR path, STRPTR name )
{
LONG loop = NL;
CPELIB *top;
CPELIB *end;
CPESRC *src;

FreeTmp();
MakePathNameExt( tmp, path, name, ".cpe" );

save = fopen( tmp, "w" );

fprintf( save, "%7s\n", "CPEPREF" );

fprintf( save, "%ld\n", strlen(grp->exe_name) );
IF(strlen( grp->exe_name ))
{
fprintf( save, "%ls\n", grp->exe_name );
}

fprintf( save, "%ld\n%ld\n%ld\n",grp->num_top,grp->num_end,grp->num_src);

top = (CPELIB *) GetHead( &list[ LTOP ] );
WHILE( ISNODE(top) )
{
fprintf( save,"%ls\n%ls\n",top->path,top->name);
top = (CPELIB *) GetSucc( top );
}

end = (CPELIB *) GetHead( &list[ LEND ] );
WHILE( ISNODE(end) )
{
fprintf( save,"%ls\n%ls\n",end->path,end->name);
end = (CPELIB *) GetSucc( end );
}

src = (CPESRC *) GetHead( &list[ LSRC ] );
WHILE( ISNODE(src) )
{
fprintf( save,"%ls\n%ls\n",src->path,src->name);
src = (CPESRC *) GetSucc( src );
}
fclose( save );
}

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

VOID ReadGroup( STRPTR path, STRPTR name )
{
LONG loop = NL;
CHAR cpepref[7];
CPELIB *top;
CPELIB *end;
CPESRC *src;
FreeGroup();

FreeTmp();
MakePathNameExt( tmp, path, name, ".cpe" );

SetNoList( gad_top_lst );
SetNoList( gad_end_lst );
SetNoList( gad_src_lst );

load = fopen( tmp , "r" );

fscanf( load, "%7s\n", cpepref );

IF((StrCmp( cpepref, "CPEPREF")))
{
INT size=NL;

fscanf( load, "%ld\n", &size);
IF(size) { fscanf( load, "%ls\n", grp->exe_name); size=NL; }

fscanf( load, "%ld\n%ld\n%ld\n",&grp->num_top,&grp->num_end,&grp->num_src);

IF( grp->num_top )
{
FOR( loop = NL; loop < grp->num_top; loop++ )
{
top = (CPELIB *) New( SIZEOF( CPELIB), MEMF_CLEAR ); /* no NewTop func for inc count ! (count is already loaded from disk) */
fscanf( load,"%ls\n%ls\n",top->path,top->name);
top->node.ln_Name = top->name;
AddTail( (LIST *)&list[ LTOP ], (NODE *)top );
}
}

IF( grp->num_end )
{
FOR( loop = NL; loop < grp->num_end; loop++ )
{
end = (CPELIB *) New( SIZEOF( CPELIB), MEMF_CLEAR ); /* no NewTop func for inc count ! (count is already loaded from disk) */
fscanf( load,"%ls\n%ls\n",end->path,end->name);
end->node.ln_Name = end->name;
AddTail( (LIST *)&list[ LEND ], (NODE *)end );
}
}

IF( grp->num_src )
{
FOR( loop = NL; loop < grp->num_src; loop++ )
{
src = (CPESRC *) New( SIZEOF( CPESRC), MEMF_CLEAR ); /* no NewTop func for inc count ! (count is already loaded from disk) */
fscanf( load,"%ls\n%ls\n",src->path,src->name);

AddTail( (LIST *)&list[ LSRC ], (NODE *)src );
}
{CPESRC *src = (CPESRC *) GetHead( &list[ LSRC ] );
WHILE( ISNODE(src) )
{
GetMakeSrc( src );
src = (CPESRC *) GetSucc( src );
}}

{CPESRC *src = (CPESRC *) GetHead( &list[ LSRC ] );
WHILE( ISNODE(src) )
{
src->notify = (NOTIFY_REQ *) LinkNotify( notify_port, src->path, src->name, src );
src = (CPESRC *) GetSucc( src );
}}
}

}
fclose( load );

SetListAndRefresh( gad_top_lst, &list[ LTOP ] );
SetListAndRefresh( gad_end_lst, &list[ LEND ] );
SetListAndRefresh( gad_src_lst, &list[ LSRC ] );
SetAttrAndRefresh( gad_exe_nam, GTST_String, (STRPTR) grp->exe_name );
}

/* gt.c (GUI) */
#define INC_EXEC
#define INC_INTUITION
#define INC_GADTOOLS
#define INC_GRAPHICS
#define INC_ASL
#define INC_DOS
#define INC_ICON
#define INC_WORKBENCH

#include "h:macros.h"
#include "h:cpe.h"

UBYTE *ver = "$VER: C Project Editor 2.12 By dFk (16.5.95)";

INTUI_MSG msg;
WIN *wnd = NL;
REQ_FILE *asl = NL;
SCR *scn = NL;
GAD *gad[GCOUNT];
GAD *glist = NL;

/*TXT_ATTR topaz8 = {( STRPTR )"topaz.font", 8, 0x00, 0x01 }; */

UWORD left = 3;
UWORD top = 15;
UWORD width = 574;
UWORD height = 190;
UBYTE *wndtle = (UBYTE *)"CPE";
UBYTE *scntle = (UBYTE *)"C Project Editor" ;

#define NUM_LIST 3

#define LTOP 0
#define LEND 1
#define LSRC 2

EXTERN LIST list[ NUM_LIST ];

UBYTE *lab[] = {};

EXTERN CPEGRP grp;
EXTERN LONG cur_grp;
/*--------------------------------------------------------------------------*/

INTUI_TXT txt[] = {
1,0,JAM2, 66, 2,NL,(UBYTE *)" Executable ",&txt[1],
1,0,JAM2,368, 2,NL,(UBYTE *)" Sources ", &txt[2],
2,0,JAM1, 72, 1,NL,(UBYTE *)"Executable", &txt[3],
2,0,JAM1,374, 1,NL,(UBYTE *)"Sources", &txt[4],
1,0,JAM1,170, 29,NL,(UBYTE *)"Top", &txt[5],
1,0,JAM1,170,108,NL,(UBYTE *)"End", &txt[6],
2,0,JAM1,168, 28,NL,(UBYTE *)"Top", &txt[7],
2,0,JAM1,168,107,NL,(UBYTE *)"End", NULL
};

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

EXTERN MNU_NEW mnu_new[100];
EXTERN MNU *mnu;

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

UWORD gad_typ[] = {
LISTVIEW_KIND,
LISTVIEW_KIND,
LISTVIEW_KIND,
STRING_KIND,
BUTTON_KIND,
BUTTON_KIND,
BUTTON_KIND,
BUTTON_KIND,
BUTTON_KIND,
BUTTON_KIND,
BUTTON_KIND,
BUTTON_KIND,
BUTTON_KIND,
BUTTON_KIND,
BUTTON_KIND,
BUTTON_KIND,
BUTTON_KIND,
BUTTON_KIND
};

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

GAD_NEW gad_new[] = {
15, 26,135, 80, NULL, NULL, gad_top_lst, 0, NULL, (APTR)top_lst_clic,
15,105,135, 80, NULL, NULL, gad_end_lst, 0, NULL, (APTR)end_lst_clic,
236, 11,324,160, NULL, NULL, gad_src_lst, 0, NULL, (APTR)src_lst_clic,

60, 11,151, 13, NULL, NULL, gad_exe_nam, 0, NULL, (APTR)exe_nam_clic,
15, 11, 42, 13, (UBYTE *)"Make", NULL, gad_exe_mke, PLACETEXT_IN, NULL, (APTR)exe_mke_clic,

152, 39, 58, 15, (UBYTE *)"Add", NULL, gad_top_add, PLACETEXT_IN, NULL, (APTR)top_add_clic,
152, 87, 58, 15, (UBYTE *)"Remove", NULL, gad_top_rem, PLACETEXT_IN, NULL, (APTR)top_rem_clic,
152, 55, 58, 15, (UBYTE *)"Up", NULL, gad_top_upp, PLACETEXT_IN, NULL, (APTR)top_upp_clic,
152, 71, 58, 15, (UBYTE *)"Down", NULL, gad_top_dow, PLACETEXT_IN, NULL, (APTR)top_dow_clic,

152,118, 58, 15, (UBYTE *)"Add", NULL, gad_end_add, PLACETEXT_IN, NULL, (APTR)end_add_clic,
152,166, 58, 15, (UBYTE *)"Remove", NULL, gad_end_rem, PLACETEXT_IN, NULL, (APTR)end_rem_clic,
152,134, 58, 15, (UBYTE *)"Up", NULL, gad_end_upp, PLACETEXT_IN, NULL, (APTR)end_upp_clic,
152,150, 58, 15, (UBYTE *)"Down", NULL, gad_end_dow, PLACETEXT_IN, NULL, (APTR)end_dow_clic,

306,168, 62, 13, (UBYTE *)"Add", NULL, gad_src_add, PLACETEXT_IN, NULL, (APTR)src_add_clic,
498,168, 62, 13, (UBYTE *)"Remove", NULL, gad_src_rem, PLACETEXT_IN, NULL, (APTR)src_rem_clic,
370,168, 62, 13, (UBYTE *)"Up", NULL, gad_src_upp, PLACETEXT_IN, NULL, (APTR)src_upp_clic,
434,168, 62, 13, (UBYTE *)"Down", NULL, gad_src_dow, PLACETEXT_IN, NULL, (APTR)src_dow_clic,

236,168, 68, 13, (UBYTE *)"Make", NULL, gad_src_mke, PLACETEXT_IN, NULL, (APTR)src_mke_clic
};

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

ULONG *gad_tag[] = {
(GTLV_Labels), (ULONG)&list[ LTOP ], (GTLV_ShowSelected), NULL, (TAG_DONE),
(GTLV_Labels), (ULONG)&list[ LEND ], (GTLV_ShowSelected), NULL, (TAG_DONE),
(GTLV_Labels), (ULONG)&list[ LSRC ], (GTLV_ShowSelected), NULL, (TAG_DONE),
(GTST_MaxChars), 128, (STRINGA_Justification), (GACT_STRINGCENTER), (TAG_DONE),
(TAG_DONE),
(TAG_DONE),
(TAG_DONE),
(TAG_DONE),
(TAG_DONE),
(TAG_DONE),
(TAG_DONE),
(TAG_DONE),
(TAG_DONE),
(TAG_DONE),
(TAG_DONE),
(TAG_DONE),
(TAG_DONE),
(TAG_DONE)
};

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

WORD zoom[4];

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

VOID Render( VOID )
{
UWORD offx, offy;

offx = wnd->BorderLeft;
offy = wnd->BorderTop;

DrawBevelBox( wnd->RPort, offx + 8, offy + 6, 210, 178, GT_VisualInfo, o_vi, TAG_DONE );
/* DrawBevelBox( wnd->RPort, offx + 228, offy + 6, 340, 178, GT_VisualInfo, o_vi, TAG_DONE );*/
DrawBevelBox( wnd->RPort, offx + 6, offy + 5, 214, 180, GT_VisualInfo, o_vi, GTBB_Recessed, TRUE, TAG_DONE );
/* DrawBevelBox( wnd->RPort, offx + 226, offy + 5, 344, 180, GT_VisualInfo, o_vi, GTBB_Recessed, TRUE, TAG_DONE ); */
PrintIText( wnd->RPort, txt, offx, offy );
}

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

VOID CloseScn( VOID )
{
RemVI( );
RemScrPub( scn );
}

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

VOID OpenWnd( VOID )
{
GAD_NEW ng;
GAD *g;
UWORD lc, tc;
UWORD offx = scn->WBorLeft;
UWORD offy = scn->WBorTop + scn->RastPort.TxHeight + 1;

zoom[0] = 0;
zoom[1] = 0;
zoom[2] = 90+strlen(wndtle)*9;
zoom[3] = offy;

g = (GAD *) NewCtx( &glist );

for( lc = 0, tc = 0; lc < GCOUNT; lc++ )
{
CopyMem((char * )&gad_new[ lc ], (char * )&ng, (long)sizeof( GAD_NEW ));

ng.ng_VisualInfo=o_vi;
/* ng.ng_TextAttr=&topaz8; */
ng.ng_LeftEdge+=offx;
ng.ng_TopEdge+=offy;

gad[lc]=g=(GAD *)CreateGadgetA(gad_typ[lc],g,&ng,&gad_tag[tc]);

while( gad_tag[ tc ] ) tc += 2; tc++; if ( NOT g ) return( 2L );
}

mnu = (MNU *) NewMnu( mnu_new, wnd );

Render();
GT_RefreshWindow( wnd, NL );
}

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

VOID CloseWnd( VOID )
{
bye(0);
}

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

VOID HandleIDCMP( VOID )
{
INTUI_MSG *m;
int (*func)();

WHILE( m = (INTUI_MSG *) GT_GetIMsg( wnd->UserPort ))
{
CopyMem(( char * )m, ( char * )&msg, (long)sizeof( INTUI_MSG ));

GT_ReplyIMsg( m );

SWITCH ( msg.Class )
{
CASE IDCMP_REFRESHWINDOW:
GT_BeginRefresh( wnd );
Render();
GT_EndRefresh( wnd, TRUE );
break;

CASE IDCMP_CLOSEWINDOW:
bye(NL);
break;

CASE IDCMP_GADGETUP:
CASE IDCMP_GADGETDOWN:
RunGadFunc( &msg );
break;

CASE IDCMP_MENUPICK:
cur_grp = ITEMNUM( msg.Code );
RunMnuFunc( &msg, mnu );
break;

CASE IDCMP_NEWSIZE:
out();
break;
}
}
}