// Load a command file
Cfg_Function *function_load_function(char *name)
{
APTR iff;
Cfg_Function *func=0;
// Open as IFF
if (!(iff=IFFOpen(name,IFF_READ,ID_OPUS)))
return 0;
// Find function chunk
if (IFFNextChunk(iff,ID_FUNC)==ID_FUNC)
{
// Read function
func=ReadFunction(iff,global_memory_pool,0,0);
}
// Close IFF file
IFFClose(iff);
return func;
}
void FunctionEditor(void)
{
struct IntuiMessage *gmsg,msg;
int break_flag=0;
UWORD gadgetid=0;
ULONG waitbits;
FuncEdData *data;
IPCData *ipc;
NewConfigWindow newwin;
FunctionStartup *startup=0;
IPCMessage *submsg;
int success=0;
BOOL open_window=1;
BPTR lock;
ConfigWindow windims;
// Do startup
if (!(ipc=Local_IPC_ProcStartup((ULONG *)&startup, (APTR)&funced_init)))
{
funced_cleanup(startup->data);
return;
}
// Get data pointer
data=startup->data;
// Lock RAM: and CD to it
if ((lock=Lock("ram:",ACCESS_READ)))
lock=CurrentDir(lock);
// Copy dimensions
if (startup->flags&FUNCEDF_CENTER)
windims=_function_editor_window_center;
else
if (startup->flags&FUNCEDF_LABEL)
windims=_function_editor_label_window;
else
windims=_function_editor_window;
// Fill in new window
newwin.parent=startup->window;
newwin.dims=&windims;
newwin.title=(startup->title[0])?startup->title:(char *)GetString(startup->locale,MSG_FUNCED_TITLE);
newwin.locale=startup->locale;
newwin.port=0;
newwin.flags=WINDOW_VISITOR|WINDOW_AUTO_KEYS|WINDOW_REQ_FILL;//|WINDOW_SIZE_BOTTOM;
newwin.font=0;
// Build flag list
funced_build_flaglist(data);
waitbits=1<<ipc->command_port->mp_SigBit|1<<data->drag.timer->port->mp_SigBit;
// Event loop
FOREVER
{
// Check drag
if (config_drag_check(&data->drag))
{
// End drag
functioned_end_drag(data,0);
}
// Task message?
while ((submsg=(IPCMessage *)GetMsg(ipc->command_port)))
{
// Close message?
if (submsg->command==IPC_QUIT)
{
// Keep changes?
success=submsg->flags;
// Set break flag
break_flag=1;
}
// Activate
else
if (submsg->command==IPC_ACTIVATE && data->window)
{
WindowToFront(data->window);
ActivateWindow(data->window);
}
// Hide
else
if (submsg->command==IPC_HIDE && data->window)
{
// Store changes in function
funced_store_edits(data);
// End any drag in progress
functioned_end_drag(data,0);
// Remove AppWindow
RemoveAppWindow(data->appwindow);
data->appwindow=0;
// Close window
CloseConfigWindow(data->window);
// Zero stuff
data->window=0;
data->objlist=0;
waitbits=1<<ipc->command_port->mp_SigBit;
}
// Show
else
if (submsg->command==IPC_SHOW && !data->window)
{
// Set flag to open window
open_window=1;
newwin.parent=(struct Window *)submsg->data;
}
// Passed-along app message
else
if (submsg->command==CFG_APPMESSAGE_PASS)
{
funced_appmsg(data,submsg->data);
ReplyMsg((struct Message *)submsg->data);
}
// Update our identity
else
if (submsg->command==CFG_NEW_ID)
{
data->function->function.func_type=submsg->flags;
startup->object_flags=(ULONG)submsg->data;
}
// Copy a function
else
if (submsg->command==FUNCTIONEDIT_COPY_LINE)
{
FunctionEntry *entry,*next;
// Copy function
functioned_copy_line(
data,
(FunctionEntry *)submsg->data,
0,
(Point *)submsg->data_free);
// Free function
entry=(FunctionEntry *)submsg->data;
while (entry)
{
// Get next
next=(FunctionEntry *)entry->node;
// Free entry
FreeVec(entry);
entry=next;
}
}
// Clip button
else
if (submsg->command==BUTTONEDIT_CLIP_BUTTON)
{
Cfg_ButtonFunction *func;
// Show busy pointer
SetWindowBusy(data->window);
// Stop editing
funced_end_edit(data,data->edit_node,0,0);
data->edit_node=0;
// Get first function
if ((func=(Cfg_ButtonFunction *)
FindFunctionType(
(struct List *)&((Cfg_Button *)submsg->data)->function_list,
FTYPE_LEFT_BUTTON)))
{
FunctionEntry dummy;
Cfg_Instruction *ins;
// Go through instructions
for (ins=(Cfg_Instruction *)func->instructions.mlh_Head;
ins->node.mln_Succ;
ins=(Cfg_Instruction *)ins->node.mln_Succ)
{
// Fill out dummy entry
dummy.type=ins->type;
if (ins->string) strcpy(dummy.buffer,ins->string);
else dummy.buffer[0]=0;
// Copy function line
data->edit_node=funced_new_entry(data,0,&dummy);
}
// Start editing last line
funced_start_edit(data);
// Get flags
data->function->function.flags=func->function.flags;
data->function->function.code=func->function.code;
data->function->function.qual=func->function.qual;
data->function->function.qual_mask=func->function.qual_mask;
data->function->function.qual_same=func->function.qual_same;
// Update flag list
funced_update_flaglist(data);
// Update key
funced_show_key(data);
}
// Free button
FreeButton((Cfg_Button *)submsg->data);
// Clear busy pointer
ClearWindowBusy(data->window);
}
// Reply the message
IPC_Reply(submsg);
}
// Open window?
if (open_window)
{
// Open window
if (!(data->window=OpenConfigWindow(&newwin)) ||
!(data->p_objlist=AddObjectList(
data->window,
(startup->flags&FUNCEDF_IMAGE)?_function_editor_image_objects:
((startup->flags&FUNCEDF_LABEL)?_function_editor_label_objects:
_function_editor_normal_objects))) ||
!(data->objlist=AddObjectList(data->window,_function_editor_objects)))
break;
// Add use or save button
AddObjectList(data->window,(startup->flags&FUNCEDF_SAVE)?_function_editor_objects_save:_function_editor_objects_use);
// Store window for drag
data->drag.window=data->window;
// Set window ID
SetWindowID(data->window,0,WINDOW_FUNCTION_EDITOR,(struct MsgPort *)ipc);
// Add menus
AddWindowMenus(data->window,_funced_menus);
// Make this an AppWindow
data->appwindow=AddAppWindowA(0,0,data->window,data->appport,0);
// Get waitbits
waitbits|=1<<data->window->UserPort->mp_SigBit;
if (data->appwindow) waitbits|=1<<data->appport->mp_SigBit;
// Disable key?
if (startup->flags&FUNCEDF_NO_KEY)
{
DisableObject(data->objlist,GAD_FUNCED_KEY,TRUE);
}
// Initialise gadgets with function data.
funced_init_gads(data);
open_window=0;
}
// Intuimessage
if (data->window)
{
while ((gmsg=GetWindowMsg(data->window->UserPort)))
{
Att_Node *node;
// Copy message and reply (unless IDCMPUPDATE)
msg=*gmsg;
if (gmsg->Class!=IDCMP_IDCMPUPDATE)
{
ReplyWindowMsg(gmsg);
gmsg=0;
}
// Get GadgetID
if (msg.Class==IDCMP_GADGETDOWN ||
msg.Class==IDCMP_GADGETUP)
gadgetid=((struct Gadget *)msg.IAddress)->GadgetID;
// Look at message
switch (msg.Class)
{
// Key press
case IDCMP_VANILLAKEY:
// If editing something, activate string gadget
if (data->edit_node)
ActivateStrGad(GADGET(GetObject(data->objlist,GAD_FUNCED_EDIT)),data->window);
break;
// Close window
case IDCMP_CLOSEWINDOW:
// Set break flag
break_flag=1;
break;
// Mouse move
case IDCMP_MOUSEMOVE:
// Handle drag move
config_drag_move(&data->drag);
break;
// Inactive window does menu down
case IDCMP_INACTIVEWINDOW:
msg.Code=MENUDOWN;
// Mouse buttons
case IDCMP_MOUSEBUTTONS:
// Valid drag info?
if (data->drag.drag)
{
short ok=-1;
// Dropped ok?
if (msg.Code==SELECTUP)
{
// Is shift down?
if (msg.Qualifier&(IEQUALIFIER_LSHIFT|IEQUALIFIER_RSHIFT))
data->drag_shift=1;
else data->drag_shift=0;
// Remember last position
data->drag.drag_x=data->window->WScreen->MouseX;
data->drag.drag_y=data->window->WScreen->MouseY;
ok=1;
}
// Aborted
else
if (msg.Code==MENUDOWN)
{
// Set abort
ok=0;
}
// End drag?
if (ok!=-1) functioned_end_drag(data,ok);
}
break;
// Menu
case IDCMP_MENUPICK:
{
struct MenuItem *item;
// Get item
if (!(item=ItemAddress(data->window->MenuStrip,msg.Code)))
break;
// Treat as gadget
gadgetid=MENUID(item);
}
// Gadget
case IDCMP_GADGETUP:
case IDCMP_GADGETDOWN:
// Look at gadget ID
switch (gadgetid)
{
// Hotkey
case GAD_FUNCED_KEY:
{
IX ix;
char *ptr;
// Get key, see if it's invalid
if ((ptr=(char *)GetGadgetValue(data->objlist,GAD_FUNCED_KEY)) && *ptr)
{
// Try to parse
if (ParseIX(ptr,&ix))
{
// Flash screen
DisplayBeep(data->window->WScreen);
// Activate key field again
ActivateStrGad(GADGET(GetObject(data->objlist,GAD_FUNCED_KEY)),data->window);
}
else
{
data->function->function.code=ix.ix_Code;
data->function->function.qual=QualValid(ix.ix_Qualifier);
data->function->function.qual_mask=ix.ix_QualMask;
data->function->function.qual_same=ix.ix_QualSame;
}
}
}
break;
// Flag selected
case GAD_FUNCED_FLAGS:
// Get selected node
node=Att_FindNode(data->flag_list,msg.Code);
// Set flag
data->function->function.flags^=node->data;
// Check change
funced_check_flag(&data->function->function.flags,node->data);
// Update flag list
funced_update_flaglist(data);
break;
// Edit a line
case GAD_FUNCED_LISTER:
// Get selected node
node=Att_FindNode(data->func_display_list,msg.Code);
// Is this the node we're already editing?
if (node==data->edit_node) break;
// If we're editing another one, store its contents
if (data->edit_node)
funced_end_edit(data,data->edit_node,0,0);
// Start editing this entry
data->edit_node=node;
funced_start_edit(data);
break;
// Return pressed in edit line
case GAD_FUNCED_EDIT:
// See if we were editing something
if (data->edit_node)
{
// Stop editing
funced_end_edit(data,data->edit_node,END_DISABLE,msg.Qualifier);
data->edit_node=0;
}
break;
// New entry
case GAD_FUNCED_NEW_ENTRY:
case GAD_FUNCED_INSERT_ENTRY:
// Create new entry
functioned_copy_line(data,0,gadgetid,0);
break;
// Delete entry
case GAD_FUNCED_DELETE_ENTRY:
// Check we were editing something
if (!data->edit_node) break;
// Stop editing (signal delete)
funced_end_edit(data,data->edit_node,END_DISABLE|END_DELETE,0);
data->edit_node=0;
break;
// Function type
case GAD_FUNCED_FUNCTION_TYPE:
// Check we were editing something
if (!data->edit_node) break;
// Store type
((FunctionEntry *)data->edit_node->data)->type=msg.Code;
// Disable popup button if no functions
DisableObject(
data->objlist,
GAD_FUNCED_EDIT_GLASS,
(msg.Code==INST_COMMAND && !data->startup->func_list));
break;
// Glass gadget
case GAD_FUNCED_EDIT_GLASS:
// Check we were editing something
if (data->edit_node)
{
char buffer[256];
// Put up requester
if (!(funced_command_req(
data,
buffer,
((FunctionEntry *)data->edit_node->data)->type)))
break;
// Insert string in edit line
funced_edit_insertstring(
data->objlist,
GAD_FUNCED_EDIT,
buffer,
DOpusBase,(struct Library *)IntuitionBase);
}
break;
// Argument list
case GAD_FUNCED_EDIT_ARGUMENT:
// Check we were editing something
if (data->edit_node)
{
char buffer[80];
// Put up requester
if (!(funced_command_req(
data,
buffer,
-1))) break;
// Insert string in edit line
funced_edit_insertstring(
data->objlist,
GAD_FUNCED_EDIT,
buffer,
DOpusBase,(struct Library *)IntuitionBase);
}
break;
// Export
case MENU_FUNCED_EXPORT_ASCII:
case MENU_FUNCED_EXPORT_CMD:
// Got file requester?
if (WINREQUESTER(data->window))
{
struct TagItem tags[6];
struct FileRequester *req=WINREQUESTER(data->window);
// Show busy pointer
SetWindowBusy(data->window);
// File requester tags
tags[0].ti_Tag=ASLFR_Window;
tags[0].ti_Data=(ULONG)data->window;
tags[1].ti_Tag=ASLFR_TitleText;
tags[1].ti_Data=(ULONG)GetString(startup->locale,MSG_FUNCED_SELECT_FILE);
tags[2].ti_Tag=ASLFR_Flags1;
tags[2].ti_Data=FRF_DOSAVEMODE|FRF_PRIVATEIDCMP;
tags[3].ti_Tag=ASLFR_Flags2;
tags[3].ti_Data=FRF_REJECTICONS;
tags[4].ti_Tag=(gadgetid==MENU_FUNCED_EXPORT_CMD)?ASLFR_InitialDrawer:TAG_DONE;
tags[4].ti_Data=(ULONG)"DOpus5:Commands";
tags[5].ti_Tag=TAG_DONE;
// Show filerequester
if (AslRequest(req,tags))
{
// Build filename
strcpy(data->buffer,req->fr_Drawer);
AddPart(data->buffer,req->fr_File,256);
// Store changes in function
funced_store_edits(data);
// Do export
if (gadgetid==MENU_FUNCED_EXPORT_CMD)
function_export_cmd(data->buffer,0,data->function);
else
L_FunctionExportASCII(data->buffer,0,data->function,startup->a4);
}
// Remove busy pointer
ClearWindowBusy(data->window);
}
break;
// Cut/Copy
case MENU_FUNCED_CUT:
case MENU_FUNCED_COPY:
{
APTR iff;
// Set busy pointer
SetWindowBusy(data->window);
// Open clipboard
if ((iff=IFFOpen((char *)0,IFF_CLIP_WRITE,ID_OPUS)))
{
// Stop editing
funced_end_edit(data,data->edit_node,END_DISABLE,0);
data->edit_node=0;
// Store changes in function
funced_store_edits(data);
// Save function
SaveFunction(iff,data->function);
// Close clipboard
IFFClose(iff);
}
// Just copy, not cut?
if (gadgetid==MENU_FUNCED_COPY)
{
// Clear busy pointer
ClearWindowBusy(data->window);
break;
}
// Fall through, paste null function
}
// Paste
case MENU_FUNCED_PASTE:
{
Cfg_Function *func=0;
// Set busy pointer
SetWindowBusy(data->window);
// End any edit
funced_end_edit(data,data->edit_node,END_DISABLE,0);
data->edit_node=0;
// Paste?
if (gadgetid==MENU_FUNCED_PASTE)
{
APTR iff;
// Open clipboard
if ((iff=IFFOpen((char *)0,IFF_CLIP_READ,ID_OPUS)))
{
// Find function
if (IFFNextChunk(iff,ID_FUNC))
{
// Read function
func=ReadFunction(iff,0,0,0);
}
// Close clipboard
IFFClose(iff);
}
// No valid function?
if (!func)
{
// Flash error
DisplayBeep(data->window->WScreen);
ClearWindowBusy(data->window);
break;
}
}
// Detach existing list
SetGadgetChoices(data->objlist,GAD_FUNCED_FLAGS,(APTR)~0);
// Clear function list
Att_RemList(data->function_list,REMLIST_SAVELIST|REMLIST_FREEDATA);
// Free existing instructions
FreeInstructionList(data->function);
// Rebuild display list
funced_build_display(data);
// Clear flags
data->function->function.flags=0;
funced_update_flaglist(data);
// Clear key
data->function->function.code=0xffff;
SetGadgetValue(data->objlist,GAD_FUNCED_KEY,0);
// Clear label
if (startup->flags&FUNCEDF_LABEL)
{
data->label[0]=0;
SetGadgetValue(data->p_objlist,GAD_FUNCED_LABEL,0);
}
// Paste function in?
if (func)
{
short type;
// Save type
type=data->function->function.func_type;
// Copy function in
CopyFunction(func,0,data->function);
data->function->function.func_type=type;
// Free copied function
FreeFunction(func);
// Initialise gadgets
funced_init_gads(data);
}
// Clear busy pointer
ClearWindowBusy(data->window);
}
break;
// Use
case GAD_FUNCED_USE:
success=1;
// Cancel
case GAD_FUNCED_CANCEL:
break_flag=1;
break;
}
break;
// Key press
case IDCMP_RAWKEY:
// Help?
if (msg.Code==0x5f &&
!(msg.Qualifier&VALID_QUALIFIERS))
{
// Set busy pointer
SetWindowBusy(data->window);
// Send help command
IPC_Command(startup->main_owner,IPC_HELP,(1<<31),"Function Editor",0,REPLY_NO_PORT);
// Clear busy pointer
ClearWindowBusy(data->window);
}
break;
// BOOPSI message
case IDCMP_IDCMPUPDATE:
{
struct TagItem *tags=(struct TagItem *)msg.IAddress;
short item;
// Check ID
if (GetTagData(GA_ID,0,tags)!=GAD_FUNCED_LISTER)
break;
// Get item
if ((item=GetTagData(DLV_DragNotify,-1,tags))!=-1)
{
// Start the drag
config_drag_start(&data->drag,data->func_display_list,item,tags,TRUE);
}
}
break;
// Ticks
case IDCMP_INTUITICKS:
++data->drag.tick_count;
break;
}
// Reply to any outstanding message
if (gmsg) ReplyWindowMsg(gmsg);
}
}
// AppMessage
if (data->appwindow)
{
struct AppMessage *msg;
while ((msg=(struct AppMessage *)GetMsg(data->appport)))
{
// Make sure window is active
ActivateWindow(data->window);
// Handle message
funced_appmsg(data,msg);
ReplyMsg((struct Message *)msg);
}
}
// Check break flag
if (break_flag) break;
// Wait for message
Wait(waitbits);
}
// Restore CD
if (lock) UnLock(CurrentDir(lock));
// Edit successful?
if (success)
{
FunctionReturn ret;
// Store changes in function
funced_store_edits(data);
// Fill out return data
ret.object=startup->object;
ret.object_flags=startup->object_flags;
ret.function=data->function;
// Send new function back
IPC_Command(startup->owner_ipc,FUNCTIONEDIT_RETURN,0,&ret,0,REPLY_NO_PORT);
}
// End any drag in progress
functioned_end_drag(data,0);
// Free edit function
FreeFunction(data->function);
// Close window
RemoveAppWindow(data->appwindow);
CloseConfigWindow(data->window);
// Close application port
if (data->appport)
{
struct Message *msg;
while ((msg=GetMsg(data->appport)))
ReplyMsg(msg);
DeleteMsgPort(data->appport);
}
// Say goodbye
IPC_Goodbye(ipc,startup->owner_ipc,startup->object_flags);
// Delete IPC data
Forbid();
IPC_Free(ipc);
// Free data
funced_cleanup(data);
FreeVec(startup);
}
static Att_List *do_read_sites_iff(struct opusftp_globals *og,char *filename,LONG *diskerr)
{
APTR iff;
BOOL err=FALSE;
Att_List *list;
D(bug("read sites\n"));
if (!(list=Att_NewList(LISTF_POOL)))
return(NULL);
// Open IFF file
if ((iff=IFFOpen(filename,IFF_READ,ID_OPUS)))
{
struct site_entry *e;
ULONG chunk;
while (!err && (chunk=IFFNextChunk(iff,0)))
{
if ((e=AllocVec(sizeof(struct site_entry),MEMF_CLEAR)))
{
int size;
int chunksize = 0;
if (chunk==ID_FTPSITE_SHORT)
size=SMALL_SIZE;
else if (chunk==ID_FTPSITE_LONG)
size=LARGE_SIZE;
else
{
*diskerr=212;
err=TRUE;
FreeVec(e);
break;
}
// Adjustment for changed ListFormat size
chunksize = (int)IFFChunkSize(iff);
if ((chunksize < size) && (size - chunksize == 84))
{
if (!(err=(chunksize!=IFFReadChunkBytes(iff,(char *)e,chunksize))));
{
char patterns[82] = {'\0'};
int i = 0;
CopyMem(e->se_listformat.show_pattern_p, patterns, 80);
memset(e->se_listformat.show_pattern_p, 0, 160);
for (i = 0; i < 40; i++)
{
e->se_listformat.show_pattern_p[i] = patterns[i];
e->se_listformat.hide_pattern_p[i] = patterns[i+40];
}
}
}
else
err=(size!=IFFReadChunkBytes(iff,(char *)e,size));
if (!err)
{
#ifdef __AROS__
e->se_anon = AROS_BE2WORD(e->se_anon);
e->se_port = AROS_BE2LONG(e->se_port);
e->se_has_custom_env = AROS_BE2WORD(e->se_has_custom_env);
if (size == LARGE_SIZE)
{
e->se_env_private.e_retry_count = AROS_BE2LONG(e->se_env_private.e_retry_count);
e->se_env_private.e_retry_delay = AROS_BE2LONG(e->se_env_private.e_retry_delay);
e->se_env_private.e_list_update = AROS_BE2LONG(e->se_env_private.e_list_update);
e->se_env_private.e_timeout = AROS_BE2LONG(e->se_env_private.e_timeout);
e->se_env_private.e_script_time = AROS_BE2LONG(e->se_env_private.e_script_time);
e->se_env_private.e_indexsize = AROS_BE2LONG(e->se_env_private.e_indexsize);
e->se_env_private.bitfield1 = AROS_BE2LONG(e->se_env_private.bitfield1);
e->se_env_private.bitfield2 = AROS_BE2LONG(e->se_env_private.bitfield2);
}
#endif
// adjust ptrs for environment
// if custom env then set ptr to internal private copy
// else set it to point to global ftp default
if (e->se_has_custom_env)
e->se_env=&e->se_env_private;
else
e->se_env=&og->og_oc.oc_env;
Att_NewNode(list, e->se_name ,(ULONG)e ,0 );
}
else
FreeVec(e);
}
else
err=TRUE;
}
// Close file
IFFClose(iff);
if (!err)
return(list);
}
Att_RemList(list,REMLIST_FREEDATA);
if (!*diskerr)
*diskerr=IoErr();
return(NULL);
}
static BOOL do_save_sites_iff(struct display_globals *dg,char *filename,LONG *diskerr)
{
APTR iff;
BOOL ok=FALSE;
struct Node *node,*next;
struct site_entry *e;
#ifdef __AROS__
struct site_entry *entry_be;
if (!(entry_be=AllocVec(sizeof(struct site_entry),MEMF_CLEAR)))
{
//*diskerr = ERROR_NO_FREE_STORE;
*diskerr=IoErr();
return 0;
}
#endif
// Open IFF file
if ((iff=IFFOpen(filename,IFF_WRITE|IFF_SAFE,ID_OPUS)))
{
LONG type;
int size;
ok=TRUE; // mark in case no entries in list
node = dg->dg_og->og_SiteList->list.lh_Head;
while ((next = node->ln_Succ))
{
e=(struct site_entry*)((Att_Node *)node)->data;
if (e->se_has_custom_env)
{
type=ID_FTPSITE_LONG;
// full site so include ftp_environment
size=LARGE_SIZE;
}
else
{
type=ID_FTPSITE_SHORT;
// short site so exclude ftp_environment
size=SMALL_SIZE;
}
// Write site_entry
if (!(ok=IFFPushChunk(iff,type)))
break;
#ifdef __AROS__
CopyMem(e,entry_be,size);
entry_be->se_anon = AROS_WORD2BE(entry_be->se_anon);
entry_be->se_port = AROS_LONG2BE(entry_be->se_port);
entry_be->se_has_custom_env = AROS_WORD2BE(entry_be->se_has_custom_env);
if (size == LARGE_SIZE)
{
entry_be->se_env_private.e_retry_count = AROS_LONG2BE(entry_be->se_env_private.e_retry_count);
entry_be->se_env_private.e_retry_delay = AROS_LONG2BE(entry_be->se_env_private.e_retry_delay);
entry_be->se_env_private.e_list_update = AROS_LONG2BE(entry_be->se_env_private.e_list_update);
entry_be->se_env_private.e_timeout = AROS_LONG2BE(entry_be->se_env_private.e_timeout);
entry_be->se_env_private.e_script_time = AROS_LONG2BE(entry_be->se_env_private.e_script_time);
entry_be->se_env_private.e_indexsize = AROS_LONG2BE(entry_be->se_env_private.e_indexsize);
entry_be->se_env_private.bitfield1 = AROS_LONG2BE(entry_be->se_env_private.bitfield1);
entry_be->se_env_private.bitfield2 = AROS_LONG2BE(entry_be->se_env_private.bitfield2);
}
if (!(ok=IFFWriteChunkBytes(iff,(char *)entry_be,size)))
#else
if (!(ok=IFFWriteChunkBytes(iff,(char *)e,size)))
#endif
break;
if (!(ok=IFFPopChunk(iff)))
break;
node = next;
}
// Close file
IFFClose(iff);
}
#ifdef __AROS__
FreeVec(entry_be);
#endif
if (ok)
return(TRUE);
*diskerr=IoErr();
return(FALSE);
}
static BOOL do_save_options_iff(struct window_params *wp,char *filename,int type,LONG *diskerr)
{
struct display_globals *dg;
APTR iff;
void * data;
int size;
BOOL ok=FALSE;
#ifdef __AROS__
struct ftp_environment *env_be;
#endif
#ifdef __AROS__
// struct ftp_config has a struct ftp_environment at the end, so this buffer is large enough to hold both
if (!(data=AllocVec(sizeof(struct ftp_config),MEMF_CLEAR)))
{
*diskerr=IoErr();
return(FALSE);
}
#endif
dg=wp->wp_dg;
// Open IFF file
if ((iff=IFFOpen(filename,IFF_WRITE|IFF_SAFE,ID_OPUS)))
{
if (type==ID_OPTIONS)
{
size=sizeof(struct ftp_config);
#ifdef __AROS__
CopyMem(&dg->dg_oc,data,size);
{
struct ftp_config *conf_be = (struct ftp_config *)data;
conf_be->bitfield1 = AROS_LONG2BE(conf_be->bitfield1);
env_be = &conf_be->oc_env;
}
#else
data=&dg->dg_oc;
#endif
}
else
{
size=sizeof(struct ftp_environment);
#ifdef __AROS__
CopyMem(wp->wp_se_copy->se_env,data,size);
env_be = (struct ftp_environment *)data;
#else
data=wp->wp_se_copy->se_env;
#endif
// sould be ? data=&wp->wp_se_copy.se_env_private;;
}
#ifdef __AROS__
env_be->e_retry_count = AROS_LONG2BE(env_be->e_retry_count);
env_be->e_retry_delay = AROS_LONG2BE(env_be->e_retry_delay);
env_be->e_list_update = AROS_LONG2BE(env_be->e_list_update);
env_be->e_timeout = AROS_LONG2BE(env_be->e_timeout);
env_be->e_script_time = AROS_LONG2BE(env_be->e_script_time);
env_be->e_indexsize = AROS_LONG2BE(env_be->e_indexsize);
env_be->bitfield1 = AROS_LONG2BE(env_be->bitfield1);
env_be->bitfield2 = AROS_LONG2BE(env_be->bitfield2);
#endif
ok=IFFWriteChunk(iff,data,type,size);
// Close file
IFFClose(iff);
}
#ifdef __AROS__
FreeVec(data);
#endif
if (ok)
return(TRUE);
*diskerr=IoErr();
return(FALSE);
}
static struct ftp_config *do_read_options_iff(char *filename,int opt_type,LONG *diskerr)
{
APTR iff;
BOOL ok=FALSE;
struct ftp_config *conf;
LONG chunk;
D(bug("read options\n"));
if ((conf=AllocVec(sizeof(struct ftp_config),MEMF_CLEAR)))
{
// Open IFF file
if ((iff=IFFOpen(filename,IFF_READ,ID_OPUS)))
{
chunk=IFFNextChunk(iff,0);
if (opt_type==WT_OPT && chunk!=ID_ENV)
*diskerr=212;
else
{
// Adjustment for changed ListFormat size
int chunksize = (int)IFFChunkSize(iff);
int size = sizeof(struct ftp_config);
if (chunk==ID_OPTIONS)
{
if ((chunksize < size) && (size - chunksize == 84))
{
if ((ok = (chunksize==IFFReadChunkBytes(iff,(char *)conf,chunksize))));
{
char patterns[82] = {'\0'};
int i = 0;
CopyMem(conf->oc_env.e_listformat.show_pattern_p, patterns, 80);
memset(conf->oc_env.e_listformat.show_pattern_p, 0, 160);
for (i = 0; i < 40; i++)
{
conf->oc_env.e_listformat.show_pattern_p[i] = patterns[i];
conf->oc_env.e_listformat.hide_pattern_p[i] = patterns[i+40];
}
}
}
else
ok = ((sizeof(struct ftp_config))==IFFReadChunkBytes(iff,(char *)conf,sizeof(struct ftp_config)));
}
else if (chunk==ID_ENV)
{
ok=((sizeof(struct ftp_environment))==IFFReadChunkBytes(iff,(char *)&conf->oc_env,sizeof(struct ftp_environment)));
}
else
*diskerr=212;
}
// Close file
IFFClose(iff);
if (ok)
{
#ifdef __AROS__
conf->bitfield1 = AROS_LONG2BE(conf->bitfield1);
conf->oc_env.e_retry_count = AROS_BE2LONG(conf->oc_env.e_retry_count);
conf->oc_env.e_retry_delay = AROS_BE2LONG(conf->oc_env.e_retry_delay);
conf->oc_env.e_list_update = AROS_BE2LONG(conf->oc_env.e_list_update);
conf->oc_env.e_timeout = AROS_BE2LONG(conf->oc_env.e_timeout);
conf->oc_env.e_script_time = AROS_BE2LONG(conf->oc_env.e_script_time);
conf->oc_env.e_indexsize = AROS_BE2LONG(conf->oc_env.e_indexsize);
conf->oc_env.bitfield1 = AROS_BE2LONG(conf->oc_env.bitfield1);
conf->oc_env.bitfield2 = AROS_BE2LONG(conf->oc_env.bitfield2);
#endif
return(conf);
}
}
FreeVec(conf);
}
if (!*diskerr)
*diskerr=IoErr();
return(NULL);
}
// Get backdrop pattern
short display_get_pattern(BOOL use_custom)
{
APTR iff;
BPTR file;
struct WBPatternPrefs pattern[NUM_PATTERNS];
short a;
char *data[NUM_PATTERNS],*filename;
short change=0;
ULONG flags=0;
// Copy from system fields to custom fields (if custom field is empty, or custom flag is not set)
for (a=0;a<4;a++)
{
if (!GUI->env_BackgroundPic[a][0] || !use_custom)
{
strcpy(GUI->env_BackgroundPic[a],environment->env->env_BackgroundPic[a]);
GUI->env_BackgroundFlags[a]=environment->env->env_BackgroundFlags[a];
GUI->env_BackgroundBorderColour[a]=environment->env->env_BackgroundBorderColour[a];
}
}
// Pattern disabled?
if (environment->env->display_options&DISPOPTF_NO_BACKDROP)
{
// Check both patterns are invalid
for (a=0;a<NUM_PATTERNS;a++)
{
// Is pattern valid?
if (GUI->pattern[a].valid)
{
// Clear existing pattern
display_update_pattern(a,0);
// Free pattern data
FreeVec(GUI->pattern[a].data);
GUI->pattern[a].data=0;
// Free pattern
FreePattern(&GUI->pattern[a]);
}
}
return 0;
}
// Use pattern prefs?
if (environment->env->display_options&DISPOPTF_USE_WBPATTERN)
{
// End pattern notification
stop_file_notify(GUI->pattern_notify);
// Get filename
filename=(IntuitionBase->LibNode.lib_Version<39)?"env:sys/wb.pat":"env:sys/wbpattern.prefs";
// User-specified file?
if (environment->env->backdrop_prefs[0])
{
BPTR lock;
// Does file exist?
if (lock=Lock(environment->env->backdrop_prefs,ACCESS_READ))
{
// Yep
UnLock(lock);
filename=environment->env->backdrop_prefs;
}
}
// Initialise pattern and data pointers
for (a=0;a<NUM_PATTERNS;a++)
{
pattern[a]=GUI->pattern[a].prefs;
data[a]=0;
}
// Try to open wbpattern prefs file
if (IntuitionBase->LibNode.lib_Version>=39 &&
(iff=IFFOpen(filename,IFF_READ,ID_PREF)))
{
ULONG id;
// Scan for chunks we know and love
while (id=IFFNextChunk(iff,0))
{
// FastIPrefs FIP0 chunk?
if (id==ID_FIP0)
{
// Get flags
IFFReadChunkBytes(iff,&flags,sizeof(flags));
}
// PTRN chunk?
else
if (id==ID_PTRN)
{
struct WBPatternPrefs *prefs;
// Allocate space for chunk
if (prefs=AllocVec(IFFChunkSize(iff),MEMF_CLEAR))
{
// Read chunk
IFFReadChunkBytes(iff,prefs,-1);
// Pattern we can handle?
if (prefs->wbp_Which==WBP_ROOT ||
prefs->wbp_Which==WBP_DRAWER)
{
// Copy data
CopyMem(
(char *)prefs,
(char *)&pattern[prefs->wbp_Which],
sizeof(struct WBPatternPrefs));
// Allocate pattern data
if (prefs->wbp_DataLength>0 &&
(data[prefs->wbp_Which]=AllocVec(prefs->wbp_DataLength+1,MEMF_CLEAR)))
{
// Copy pattern data
CopyMem((char *)(prefs+1),data[prefs->wbp_Which],prefs->wbp_DataLength);
}
}
// Free chunk
FreeVec(prefs);
}
}
}
// Close iff file
IFFClose(iff);
}
// Couldn't find it, try for wb.pat
else
if (IntuitionBase->LibNode.lib_Version<39 &&
(file=Open(filename,MODE_OLDFILE)))
{
// Allocate pattern data
if (data[PATTERN_MAIN]=AllocVec(96,MEMF_CLEAR))
{
// Skip forwards
Seek(file,20,OFFSET_CURRENT);
// Read pattern
if ((Read(file,data[PATTERN_MAIN],96))<96)
{
FreeVec(data[PATTERN_MAIN]);
data[PATTERN_MAIN]=0;
}
// Fill out WBPatternPrefs
else
{
pattern[PATTERN_MAIN].wbp_Flags=WBPF_PATTERN;
pattern[PATTERN_MAIN].wbp_Depth=GUI->screen_pointer->BitMap.Depth;
if (pattern[PATTERN_MAIN].wbp_Depth>MAXDEPTH)
pattern[PATTERN_MAIN].wbp_Depth=MAXDEPTH;
}
}
// Close file
Close(file);
}
// Start notification of wbpattern prefs
GUI->pattern_notify=start_file_notify(filename,NOTIFY_PATTERN_CHANGED,GUI->appmsg_port);
}
// Otherwise, under 39 user-defined pictures
else
if (GfxBase->LibNode.lib_Version>=39)
{
short pat;
// Do both patterns
for (pat=0;pat<NUM_PATTERNS;pat++)
{
// Got valid picture?
if (GUI->env_BackgroundPic[pat][0])
{
// Fill out WBPatternPrefs
pattern[pat].wbp_Flags=0;
pattern[pat].wbp_Which=pat;
pattern[pat].wbp_DataLength=strlen(GUI->env_BackgroundPic[pat]);
if (data[pat]=AllocVec(pattern[pat].wbp_DataLength+1,0))
strcpy(data[pat],GUI->env_BackgroundPic[pat]);
}
// Set to no pattern
else
{
// Fill out WBPatternPrefs
pattern[pat].wbp_Flags=WBPF_PATTERN;
pattern[pat].wbp_DataLength=0;
data[pat]=0;
}
}
}
// Otherwise, default to no pattern
else
{
short pat;
// Do both patterns
for (pat=0;pat<NUM_PATTERNS;pat++)
{
// Fill out WBPatternPrefs
pattern[pat].wbp_Flags=WBPF_PATTERN;
pattern[pat].wbp_DataLength=0;
data[pat]=0;
}
}
// Go through both patterns
for (a=0;a<NUM_PATTERNS;a++)
{
BOOL diff=0;
short precision=0;
// Using Opus settings?
if (!(environment->env->display_options&DISPOPTF_USE_WBPATTERN))
{
// Get precision
if (GUI->env_BackgroundFlags[a]&ENVBF_PRECISION_NONE)
precision=-1;
else
if (GUI->env_BackgroundFlags[a]&ENVBF_PRECISION_GUI)
precision=2;
else
if (GUI->env_BackgroundFlags[a]&ENVBF_PRECISION_ICON)
precision=1;
else
if (GUI->env_BackgroundFlags[a]&ENVBF_PRECISION_EXACT)
precision=3;
}
// Maybe set in prefs
else
{
// Get precision
precision=(a==0)?PATF_WB_MODE(flags):PATF_LISTER_MODE(flags);
}
// Valid data?
if (data[a])
{
// No last pattern?
if (!GUI->pattern[a].data)
{
diff=1;
}
// Changed from pattern to picture or vice versa?
else
if ((pattern[a].wbp_Flags&WBPF_PATTERN && !(GUI->pattern[a].prefs.wbp_Flags&WBPF_PATTERN)) ||
(!(pattern[a].wbp_Flags&WBPF_PATTERN) && GUI->pattern[a].prefs.wbp_Flags&WBPF_PATTERN))
{
diff=1;
}
// Pattern pattern?
else
if (pattern[a].wbp_Flags&WBPF_PATTERN)
{
// Different depth?
if (pattern[a].wbp_Depth!=GUI->pattern[a].prefs.wbp_Depth) diff=1;
// Has data changed from the last one?
else
{
short num,d;
// Get amount of data
num=PAT_HEIGHT*pattern[a].wbp_Depth;
// Compare data
for (d=0;d<num;d++)
{
if (((USHORT *)data[a])[d]!=((USHORT *)GUI->pattern[a].data)[d])
{
diff=1;
break;
}
}
}
}
// Picture?
else
{
// Different name for picture, or it's random?
if (strcmp(data[a],GUI->pattern[a].data)!=0 || GUI->pattern[a].random)
{
diff=1;
}
// Precision changed?
else
if (precision!=GUI->pattern[a].precision)
{
diff=1;
}
// Stretching changed?
else
if (a==0 &&
((GUI->env_BackgroundFlags[a]&ENVBF_STRETCH_PIC && !(GUI->pattern[a].flags&PATF_STRETCH)) ||
!(GUI->env_BackgroundFlags[a]&ENVBF_STRETCH_PIC) && (GUI->pattern[a].flags&PATF_STRETCH)))
{
diff=1;
}
// Centering changed?
else
if ((GUI->env_BackgroundFlags[a]&ENVBF_CENTER_PIC && !(GUI->pattern[a].flags&PATF_CENTER)) ||
!(GUI->env_BackgroundFlags[a]&ENVBF_CENTER_PIC) && (GUI->pattern[a].flags&PATF_CENTER))
{
diff=2;
}
}
}
// Had last data?
else
if (GUI->pattern[a].data) diff=1;
if (diff!=1)
{
// Border pen changed?
if ((GUI->env_BackgroundFlags[a]&ENVBF_USE_COLOUR && GUI->pattern[a].border_pen==0) ||
(!(GUI->env_BackgroundFlags[a]&ENVBF_USE_COLOUR) && GUI->pattern[a].border_pen!=0))
{
diff=3;
}
else
if (GUI->pattern[a].border_pen!=0 && GUI->env_BackgroundFlags[a]&ENVBF_USE_COLOUR)
{
ULONG col[3];
GetPalette32(
&GUI->screen_pointer->ViewPort,
col,
1,
(GUI->pattern[a].border_pen==-1)?0:GUI->pattern[a].border_pen);
if (ENVBF_COL_R_GET(col[0])!=ENVBF_COL_R_GET(GUI->env_BackgroundBorderColour[a]) ||
ENVBF_COL_R_GET(col[1])!=ENVBF_COL_G_GET(GUI->env_BackgroundBorderColour[a]) ||
ENVBF_COL_R_GET(col[2])!=ENVBF_COL_B_GET(GUI->env_BackgroundBorderColour[a]))
{
diff=3;
}
}
}
// Has it changed?
if (diff)
{
// Existing pattern valid?
if (GUI->pattern[a].valid)
{
// Clear existing patterns
display_update_pattern(a,0);
}
// Change more than centering?
if (diff==1)
{
// Free existing pattern
FreePattern(&GUI->pattern[a]);
FreeVec(GUI->pattern[a].data);
// Copy pattern and data pointer
GUI->pattern[a].prefs=pattern[a];
GUI->pattern[a].data=data[a];
// Stretch?
if (a==0 && GUI->env_BackgroundFlags[a]&ENVBF_STRETCH_PIC)
{
flags|=PATF_STRETCH;
flags&=~PATF_CENTER;
}
else
{
flags&=~PATF_STRETCH;
if (!(environment->env->display_options&DISPOPTF_USE_WBPATTERN) &&
GUI->env_BackgroundFlags[a]&ENVBF_CENTER_PIC)
flags|=PATF_CENTER;
else
flags&=~PATF_CENTER;
}
// Set flags and precision
GUI->pattern[a].flags=flags;
GUI->pattern[a].precision=precision;
// Initialise pattern
GetPattern(
&GUI->pattern[a],
GUI->screen_pointer,
GUI->env_BackgroundBorderColour[a]|(GUI->env_BackgroundFlags[a]&ENVBF_USE_COLOUR));
}
// Change colour
else
if (diff==3)
{
// Initialise pattern colour
GetPatternBorder(
&GUI->pattern[a],
GUI->screen_pointer,
GUI->env_BackgroundBorderColour[a]|(GUI->env_BackgroundFlags[a]&ENVBF_USE_COLOUR));
}
// Centering changed
else
{
// Environment flags set for centering?
if (!(environment->env->display_options&DISPOPTF_USE_WBPATTERN) &&
GUI->env_BackgroundFlags[a]&ENVBF_CENTER_PIC)
GUI->pattern[a].flags|=PATF_CENTER;
else
GUI->pattern[a].flags&=~PATF_CENTER;
}
// Install new pattern
display_update_pattern(a,1);
}
// If not, free data
else FreeVec(data[a]);
}
return change;
}
// Save an environment
int environment_save(Cfg_Environment *env,char *name,short snapshot,CFG_ENVR *data)
{
APTR iff;
long success=0;
struct OpenEnvironmentData *opendata=0;
#ifdef __AROS__
CFG_ENVR *env_be;
#endif
// Invalid name?
if (!name || !*name) return 0;
// Get data pointer if not supplied
if (!data) data=env->env;
#ifdef __AROS__
if (!(env_be=AllocVec(sizeof(CFG_ENVR),MEMF_CLEAR)))
return 0;
#endif
// Update main window position
if (snapshot&ENVSAVE_WINDOW)
{
GetSemaphore(&GUI->backdrop->window_lock,SEMF_SHARED,0);
display_store_pos();
FreeSemaphore(&GUI->backdrop->window_lock);
}
// Not snapshotting listers?
if (!(snapshot&ENVSAVE_LAYOUT))
{
if ((opendata=AllocMemH(env->volatile_memory,sizeof(struct OpenEnvironmentData))))
{
opendata->memory=env->desktop_memory;
opendata->volatile_memory=env->volatile_memory;
opendata->flags=OEDF_BANK|OEDF_LSTR;
OpenEnvironment(name,opendata);
}
}
// Try to open file to write
while ((iff=IFFOpen(name,MODE_NEWFILE,ID_EPUS)))
{
IPCData *ipc;
Lister *lister;
Buttons *buttons;
Cfg_Desktop *desk;
struct MinNode *node;
Cfg_SoundEntry *sound;
// Write environment settings
#ifdef __AROS__
CopyMem(data,env_be,sizeof(CFG_ENVR));
{
int i;
env_be->screen_mode = AROS_LONG2BE(env_be->screen_mode);
env_be->screen_flags = AROS_WORD2BE(env_be->screen_flags);
env_be->screen_depth = AROS_WORD2BE(env_be->screen_depth);
env_be->screen_width = AROS_WORD2BE(env_be->screen_width);
env_be->screen_height = AROS_WORD2BE(env_be->screen_height);
for (i=0; i<50; i++)
env_be->palette[i] = AROS_LONG2BE(env_be->palette[i]);
env_be->window_pos.Left = AROS_WORD2BE(env_be->window_pos.Left);
env_be->window_pos.Top = AROS_WORD2BE(env_be->window_pos.Top);
env_be->window_pos.Width = AROS_WORD2BE(env_be->window_pos.Width);
env_be->window_pos.Height = AROS_WORD2BE(env_be->window_pos.Height);
env_be->general_screen_flags = AROS_LONG2BE(env_be->general_screen_flags);
env_be->palette_count = AROS_WORD2BE(env_be->palette_count);
for (i=0; i<CUST_PENS; i++)
{
env_be->env_Colours[i][0][0] = AROS_LONG2BE(env_be->env_Colours[i][0][0]);
env_be->env_Colours[i][0][1] = AROS_LONG2BE(env_be->env_Colours[i][0][1]);
env_be->env_Colours[i][0][2] = AROS_LONG2BE(env_be->env_Colours[i][0][2]);
env_be->env_Colours[i][1][0] = AROS_LONG2BE(env_be->env_Colours[i][1][0]);
env_be->env_Colours[i][1][1] = AROS_LONG2BE(env_be->env_Colours[i][1][1]);
env_be->env_Colours[i][1][2] = AROS_LONG2BE(env_be->env_Colours[i][1][2]);
}
env_be->env_ColourFlag = AROS_LONG2BE(env_be->env_ColourFlag);
env_be->env_NewIconsFlags = AROS_LONG2BE(env_be->env_NewIconsFlags);
env_be->display_options = AROS_WORD2BE(env_be->display_options);
env_be->main_window_type = AROS_WORD2BE(env_be->main_window_type);
env_be->hotkey_flags = AROS_WORD2BE(env_be->hotkey_flags);
env_be->hotkey_code = AROS_WORD2BE(env_be->hotkey_code);
env_be->hotkey_qual = AROS_WORD2BE(env_be->hotkey_qual);
env_be->default_stack = AROS_LONG2BE(env_be->default_stack);
env_be->lister_options = AROS_WORD2BE(env_be->lister_options);
env_be->flags = AROS_LONG2BE(env_be->flags);
env_be->lister_popup_code = AROS_WORD2BE(env_be->lister_popup_code);
env_be->lister_popup_qual = AROS_WORD2BE(env_be->lister_popup_qual);
env_be->env_flags = AROS_LONG2BE(env_be->env_flags);
env_be->clock_left = AROS_WORD2BE(env_be->clock_left);
env_be->clock_top = AROS_WORD2BE(env_be->clock_top);
env_be->lister_width = AROS_WORD2BE(env_be->lister_width);
env_be->lister_height = AROS_WORD2BE(env_be->lister_height);
env_be->version = AROS_WORD2BE(env_be->version);
env_be->desktop_flags = AROS_LONG2BE(env_be->desktop_flags);
for (i=0; i<4; i++)
env_be->env_BackgroundFlags[i] = AROS_WORD2BE(env_be->env_BackgroundFlags[i]);
env_be->settings.copy_flags = AROS_LONG2BE(env_be->settings.copy_flags);
env_be->settings.delete_flags = AROS_LONG2BE(env_be->settings.delete_flags);
env_be->settings.error_flags = AROS_LONG2BE(env_be->settings.error_flags);
env_be->settings.general_flags = AROS_LONG2BE(env_be->settings.general_flags);
env_be->settings.icon_flags = AROS_LONG2BE(env_be->settings.icon_flags);
env_be->settings.replace_method = AROS_WORD2BE(env_be->settings.replace_method);
env_be->settings.replace_flags = AROS_WORD2BE(env_be->settings.replace_flags);
env_be->settings.update_flags = AROS_LONG2BE(env_be->settings.update_flags);
env_be->settings.dir_flags = AROS_LONG2BE(env_be->settings.dir_flags);
env_be->settings.view_flags = AROS_LONG2BE(env_be->settings.view_flags);
env_be->settings.max_buffer_count = AROS_WORD2BE(env_be->settings.max_buffer_count);
env_be->settings.date_format = AROS_WORD2BE(env_be->settings.date_format);
env_be->settings.date_flags = AROS_WORD2BE(env_be->settings.date_flags);
env_be->settings.pop_code = AROS_WORD2BE(env_be->settings.pop_code);
env_be->settings.pop_qual = AROS_WORD2BE(env_be->settings.pop_qual);
env_be->settings.pop_qual_mask = AROS_WORD2BE(env_be->settings.pop_qual_mask);
env_be->settings.pop_qual_same = AROS_WORD2BE(env_be->settings.pop_qual_same);
env_be->settings.popup_delay = AROS_WORD2BE(env_be->settings.popup_delay);
env_be->settings.max_openwith = AROS_WORD2BE(env_be->settings.max_openwith);
env_be->settings.command_line_length = AROS_WORD2BE(env_be->settings.command_line_length);
env_be->settings.max_filename = AROS_WORD2BE(env_be->settings.max_filename);
env_be->settings.flags = AROS_LONG2BE(env_be->settings.flags);
for (i=0; i<4; i++)
env_be->env_BackgroundBorderColour[i] = AROS_LONG2BE(env_be->env_BackgroundBorderColour[i]);
}
if (!(IFFWriteChunk(iff,env_be,ID_ENVR,sizeof(CFG_ENVR))))
#else
if (!(IFFWriteChunk(iff,data,ID_ENVR,sizeof(CFG_ENVR))))
#endif
{
success=IoErr();
break;
}
// Write some path names
if ((success=write_env_string(iff,env->toolbar_path,ID_TBAR)) ||
(success=write_env_string(iff,env->menu_path,ID_LMEN)) ||
(success=write_env_string(iff,env->user_menu_path,ID_UMEN)) ||
(success=write_env_string(iff,env->scripts_path,ID_SCRP)) ||
(success=write_env_string(iff,env->hotkeys_path,ID_HKEY)))
break;
// Not snapshotting?
if (!(snapshot&ENVSAVE_LAYOUT) && opendata)
{
ButtonBankNode *button;
OpenListerNode *lister;
// Go through existing listers
for (lister=(OpenListerNode *)opendata->listers.mlh_Head;
lister->node.ln_Succ;)
{
OpenListerNode *next=(OpenListerNode *)lister->node.ln_Succ;
// Write lister data
if (!(SaveListerDef(iff,(Cfg_Lister *)lister->lister))) break;
// Remove this node, get next
Remove((struct Node *)lister);
lister=next;
}
// Go through buttons to open
for (button=(ButtonBankNode *)opendata->buttons.mlh_Head;
button->node.ln_Succ;)
{
ButtonBankNode *next=(ButtonBankNode *)button->node.ln_Succ;
ULONG pad[5];
#ifdef __AROS__
struct IBox pos_be;
#endif
// Write bank header
if (!(IFFPushChunk(iff,ID_BANK))) break;
// Fill out padding
pad[0]=0;
pad[1]=0;
pad[2]=button->icon_pos_x;
pad[3]=button->icon_pos_y;
pad[4]=button->flags&BUTTONF_ICONIFIED;
#ifdef __AROS__
CopyMem(&button->pos,&pos_be,sizeof(struct IBox));
pos_be.Left = AROS_WORD2BE(pos_be.Left);
pos_be.Top = AROS_WORD2BE(pos_be.Top);
pos_be.Width = AROS_WORD2BE(pos_be.Width);
pos_be.Height = AROS_WORD2BE(pos_be.Height);
pad[2] = AROS_LONG2BE(pad[2]);
pad[3] = AROS_LONG2BE(pad[3]);
pad[4] = AROS_LONG2BE(pad[4]);
if (!(IFFWriteChunkBytes(iff,pad,sizeof(pad))) ||
!(IFFWriteChunkBytes(iff,&pos_be,sizeof(struct IBox))) ||
!(IFFWriteChunkBytes(iff,button->node.ln_Name,strlen(button->node.ln_Name)+1)) ||
!(IFFPopChunk(iff))) break;
#else
// Write padding and position and path
if (!(IFFWriteChunkBytes(iff,pad,sizeof(pad))) ||
!(IFFWriteChunkBytes(iff,&button->pos,sizeof(struct IBox))) ||
!(IFFWriteChunkBytes(iff,button->node.ln_Name,strlen(button->node.ln_Name)+1)) ||
!(IFFPopChunk(iff))) break;
#endif
// Remove this node, get next
Remove((struct Node *)button);
button=next;
}
// Go through StartMenus to open
for (button=(ButtonBankNode *)opendata->startmenus.mlh_Head;
button->node.ln_Succ;)
{
ButtonBankNode *next=(ButtonBankNode *)button->node.ln_Succ;
ULONG pad[5];
#ifdef __AROS__
struct IBox pos_be;
#endif
// Write bank header
if (!(IFFPushChunk(iff,ID_STRT))) break;
// Fill out padding
pad[0]=0;
pad[1]=0;
pad[2]=button->icon_pos_x;
pad[3]=button->icon_pos_y;
pad[4]=button->flags;
#ifdef __AROS__
CopyMem(&button->pos,&pos_be,sizeof(struct IBox));
pos_be.Left = AROS_WORD2BE(pos_be.Left);
pos_be.Top = AROS_WORD2BE(pos_be.Top);
pos_be.Width = AROS_WORD2BE(pos_be.Width);
pos_be.Height = AROS_WORD2BE(pos_be.Height);
pad[2] = AROS_LONG2BE(pad[2]);
pad[3] = AROS_LONG2BE(pad[3]);
pad[4] = AROS_LONG2BE(pad[4]);
if (!(IFFWriteChunkBytes(iff,pad,sizeof(pad))) ||
!(IFFWriteChunkBytes(iff,&pos_be,sizeof(struct IBox))) ||
!(IFFWriteChunkBytes(iff,button->node.ln_Name,strlen(button->node.ln_Name)+1)) ||
!(IFFPopChunk(iff))) break;
#else
// Write padding and position and path
if (!(IFFWriteChunkBytes(iff,pad,sizeof(pad))) ||
!(IFFWriteChunkBytes(iff,&button->pos,sizeof(struct IBox))) ||
!(IFFWriteChunkBytes(iff,button->node.ln_Name,strlen(button->node.ln_Name)+1)) ||
!(IFFPopChunk(iff))) break;
#endif
// Remove this node, get next
Remove((struct Node *)button);
button=next;
}
}
// Otherwise, snapshotting current layout
else
{
// Lock lister list
lock_listlock(&GUI->lister_list,FALSE);
// Write lister definitions
for (ipc=(IPCData *)GUI->lister_list.list.lh_Head;
ipc->node.mln_Succ;
ipc=(IPCData *)ipc->node.mln_Succ)
{
// Get lister
lister=IPCDATA(ipc);
// Valid lister definition?
if (lister->lister)
{
// Update lister
lister_update(lister);
// Write lister data
if (!(SaveListerDef(iff,lister->lister))) break;
}
}
// Unlock lister list
unlock_listlock(&GUI->lister_list);
// Fail?
if (ipc->node.mln_Succ)
{
success=IoErr();
break;
}
// Lock buttons list
lock_listlock(&GUI->buttons_list,FALSE);
// Write button file paths
for (ipc=(IPCData *)GUI->buttons_list.list.lh_Head;
ipc->node.mln_Succ;
ipc=(IPCData *)ipc->node.mln_Succ)
{
// Get buttons pointer
buttons=IPCDATA(ipc);
// Valid button configuration?
if (buttons->bank && buttons->bank->path[0])
{
ULONG pad[5];
#ifdef __AROS__
struct IBox pos_be;
#endif
// Update buttons
buttons_update(buttons);
// Write bank header
if (!(IFFPushChunk(iff,ID_BANK))) break;
// Fill out padding
pad[0]=0;
pad[1]=0;
pad[2]=buttons->icon_pos_x;
pad[3]=buttons->icon_pos_y;
pad[4]=buttons->flags&BUTTONF_ICONIFIED;
#ifdef __AROS__
CopyMem(&buttons->pos,&pos_be,sizeof(struct IBox));
pos_be.Left = AROS_WORD2BE(pos_be.Left);
pos_be.Top = AROS_WORD2BE(pos_be.Top);
pos_be.Width = AROS_WORD2BE(pos_be.Width);
pos_be.Height = AROS_WORD2BE(pos_be.Height);
pad[2] = AROS_LONG2BE(pad[2]);
pad[3] = AROS_LONG2BE(pad[3]);
pad[4] = AROS_LONG2BE(pad[4]);
if (!(IFFWriteChunkBytes(iff,pad,sizeof(pad))) ||
!(IFFWriteChunkBytes(iff,&pos_be,sizeof(struct IBox))) ||
!(IFFWriteChunkBytes(iff,buttons->bank->path,strlen(buttons->bank->path)+1)) ||
!(IFFPopChunk(iff))) break;
#else
// Write padding and position and path
if (!(IFFWriteChunkBytes(iff,pad,sizeof(pad))) ||
!(IFFWriteChunkBytes(iff,&buttons->pos,sizeof(struct IBox))) ||
!(IFFWriteChunkBytes(iff,buttons->bank->path,strlen(buttons->bank->path)+1)) ||
!(IFFPopChunk(iff))) break;
#endif
}
}
// Unlock buttons list
unlock_listlock(&GUI->buttons_list);
// Fail?
if (ipc->node.mln_Succ)
{
success=IoErr();
break;
}
// Lock StartMenu list
lock_listlock(&GUI->startmenu_list,FALSE);
// Write StartMenu paths
for (ipc=(IPCData *)GUI->startmenu_list.list.lh_Head;
ipc->node.mln_Succ;
ipc=(IPCData *)ipc->node.mln_Succ)
{
StartMenu *menu;
// Get menu pointer
menu=(StartMenu *)IPCDATA(ipc);
// Lock the bank
GetSemaphore(&menu->lock,SEMF_SHARED,0);
// Valid configuration?
if (menu->bank && menu->bank->path[0])
{
ULONG pad[5];
struct IBox pos;
// Get position
pos.Left=menu->bank->window.pos.Left;
pos.Top=menu->bank->window.pos.Top;
#ifdef __AROS__
pos.Left = AROS_WORD2BE(pos.Left);
pos.Top = AROS_WORD2BE(pos.Top);
#endif
// Write menu header
if (!(IFFPushChunk(iff,ID_STRT))) break;
// Fill out padding
pad[0]=0;
pad[1]=0;
pad[2]=0;
pad[3]=0;
pad[4]=0;
// Write padding and position and path
if (!(IFFWriteChunkBytes(iff,pad,sizeof(pad))) ||
!(IFFWriteChunkBytes(iff,&pos,sizeof(struct IBox))) ||
!(IFFWriteChunkBytes(iff,menu->bank->path,strlen(menu->bank->path)+1)) ||
!(IFFPopChunk(iff))) break;
}
// Unlock bank
FreeSemaphore(&menu->lock);
}
// Unlock startmenu list
unlock_listlock(&GUI->startmenu_list);
// Fail?
if (ipc->node.mln_Succ) success=IoErr();
}
// Failed?
if (success) break;
// Go through desktop list
for (desk=(Cfg_Desktop *)env->desktop.mlh_Head;
desk->node.mln_Succ;
desk=(Cfg_Desktop *)desk->node.mln_Succ)
{
#ifdef __AROS__
char buffer[64]; // 12 bytes CFG_DESK + 34 bytes device name + 18 bytes extra
CFG_DESK *desk_be = (CFG_DESK *)buffer;
CopyMem(&desk->data,desk_be,desk->data.dt_Size);
desk_be->dt_Type = AROS_WORD2BE(desk_be->dt_Type);
desk_be->dt_Size = AROS_WORD2BE(desk_be->dt_Size);
desk_be->dt_Flags = AROS_LONG2BE(desk_be->dt_Flags);
if (desk->data.dt_Type != DESKTOP_HIDE_BAD && desk->data.dt_Type != DESKTOP_HIDE)
desk_be->dt_Data = AROS_LONG2BE(desk_be->dt_Data);
if (!(IFFWriteChunk(iff,desk_be,ID_DESK,desk->data.dt_Size)))
#else
// Write chunk
if (!(IFFWriteChunk(iff,&desk->data,ID_DESK,desk->data.dt_Size)))
#endif
{
success=IoErr();
break;
}
}
// Go through pathlist
for (node=env->path_list.mlh_Head;node->mln_Succ;node=node->mln_Succ)
{
// Write chunk
if (!(IFFWriteChunk(iff,(char *)(node+1),ID_PATH,strlen((char *)(node+1)))))
{
success=IoErr();
break;
}
}
// Go through sound list
for (sound=(Cfg_SoundEntry *)env->sound_list.mlh_Head;sound->dse_Node.ln_Succ;sound=(Cfg_SoundEntry *)sound->dse_Node.ln_Succ)
{
#ifdef __AROS__
Cfg_SoundEntry sound_be;
CopyMem(&sound,&sound_be,sizeof(Cfg_SoundEntry));
sound_be.dse_Volume = AROS_WORD2BE(sound_be.dse_Volume);
sound_be.dse_Flags = AROS_WORD2BE(sound_be.dse_Flags);
if (!(IFFWriteChunk(iff,sound_be.dse_Name,ID_SNDX,32+2+2+strlen(sound->dse_Sound)+1)))
#else
// Write chunk
if (!(IFFWriteChunk(iff,sound->dse_Name,ID_SNDX,32+2+2+strlen(sound->dse_Sound)+1)))
#endif
{
success=IoErr();
break;
}
}
break;
}
// Close file
if (!iff) success=IoErr();
else IFFClose(iff);
#ifdef __AROS__
FreeVec(env_be);
#endif
// Write icon if successful (and enabled)
if ((!success) && (GUI->flags&GUIF_SAVE_ICONS))
{
WriteFileIcon("dopus5:icons/Environment",name);
}
// Free stuff
FreeMemH(opendata);
ClearMemHandle(env->volatile_memory);
return success;
}
