// 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; }