// Open window BOOL config_paths_open(config_path_data *data,struct Screen *screen) { // Already open? if (data->window) return 1; // Fill out and open window data->newwin.parent=screen; data->newwin.dims=&pathformat_window; data->newwin.title=GetString(locale,MSG_PATHFORMAT_TITLE); data->newwin.locale=locale; data->newwin.flags=WINDOW_VISITOR|WINDOW_AUTO_KEYS|WINDOW_REQ_FILL|WINDOW_SCREEN_PARENT; if (!(data->window=OpenConfigWindow(&data->newwin)) || !(data->objlist=AddObjectList(data->window,pathformat_objects))) { config_paths_cleanup(data); return 0; } // Add AppWindow if (data->appport) data->appwindow=AddAppWindowA(0,0,data->window,data->appport,0); // Attach path list SetGadgetChoices(data->objlist,GAD_PATHFORMAT_PATHS,data->path_list); // Initially disable everything config_paths_disable(data,TRUE); return 1; }
IPC_StartupCode(_filetypeed_init, filetype_ed_data *, data) #endif { short a; // Store IPC pointer data->ipc=ipc; // Fill in new window data->new_win.title=data->type->type.name; data->new_win.flags=WINDOW_VISITOR|WINDOW_REQ_FILL|WINDOW_AUTO_KEYS; // Create timer if (!(data->drag.timer=AllocTimer(UNIT_VBLANK,0))) return 0; // Open window, create action list if (!(data->window=OpenConfigWindow(&data->new_win)) || !(data->objlist=AddObjectList(data->window,data->obj_def)) || !(data->action_list=Att_NewList(0))) { CloseConfigWindow(data->window); FreeTimer(data->drag.timer); return 0; } // Store window for drag data->drag.window=data->window; // Set window ID SetWindowID(data->window,0,WINDOW_BUTTON_CONFIG,(struct MsgPort *)data->ipc); // Build action list for (a=0;data->action_lookup[a];a+=2) { Att_NewNode( data->action_list, GetString(Locale,data->action_lookup[a]), data->action_lookup[a+1], 0); } // Disable edit and delete buttons DisableObject(data->objlist,GAD_FILETYPES_EDIT_ACTION,TRUE); // Update action and icon list filetypeed_update_actions(data); filetypeed_update_iconmenu(data); // Initialise process list InitListLock(&data->proc_list,0); return 1; }
// Open font window BOOL font_open(font_data *data) { struct Screen *screen=NULL; // Screen supplied? if (data->arg_array[ARG_SCREEN]) screen=LockPubScreen((char *)data->arg_array[ARG_SCREEN]); // Fill out new window data->new_win.parent=screen; data->new_win.dims=&data->win_dims; data->new_win.title=GetString(&data->locale,MSG_FONT_TITLE); data->new_win.locale=&data->locale; data->new_win.flags=WINDOW_SCREEN_PARENT|WINDOW_VISITOR|WINDOW_AUTO_KEYS|WINDOW_SIZE_BOTTOM|WINDOW_SIMPLE; // Default dimensions data->win_dims=font_window; // Read settings font_read_settings(data); // Open window if ((data->window=OpenConfigWindow(&data->new_win))) data->list=AddObjectList(data->window,font_objects); // Unlock screen UnlockPubScreen(0,screen); // Failed to open? if (!data->list) return FALSE; // Fix sizing limits WindowLimits(data->window, (font_window.char_dim.Width*data->window->RPort->TxWidth)+font_window.fine_dim.Width, (font_window.char_dim.Height*data->window->RPort->TxHeight)+font_window.fine_dim.Height, ~0,~0); // Add menus AddWindowMenus(data->window,font_menus); // Add AppWindow if (data->appport) data->appwindow=AddAppWindowA(0,0,data->window,data->appport,0); // Get the font font_get_font(data); return TRUE; }
int __asm __saveds L_Module_Entry( register __a0 struct List *files, register __a1 struct Screen *callback1, register __a2 IPCData *callback2, register __a3 IPCData *main_ipc, register __d0 ULONG mod_id, register __d1 ULONG mod_data) { NewConfigWindow newwin; struct Window *window; ObjectList *objlist; Att_List *list; TimerHandle *timer; short count=0; struct Task *task; rego_data test={0}; // Call back to main program ((void __asm (*) (register __a0 struct List *, register __a1 rego_data *, register __a2 rego_data *, register __a3 void **, register __d0 ULONG))callback2)(files,&test,®o,&newwin.parent,global_checksum); // Won't work with DOpus library > 55 if (DOpusBase->lib_Version>55) return 0; // Fix IPC main_ipc->proc=(struct Process *)FindTask(0); main_ipc->proc->pr_Task.tc_UserData=main_ipc; main_ipc->list=0; if (!main_ipc->command_port) main_ipc->command_port=CreateMsgPort(); // Fill out new window newwin.parent=0; newwin.dims=&serial_window; newwin.title=GetString(locale,MSG_TITLE); newwin.locale=locale; newwin.port=0; newwin.flags=WINDOW_VISITOR|WINDOW_NO_CLOSE|WINDOW_REQ_FILL|WINDOW_AUTO_KEYS; newwin.font=0; // Initialise timer if (!(timer=AllocTimer(UNIT_VBLANK,0))) return 0; // Open window if (!(window=OpenConfigWindow(&newwin)) || !(objlist=AddObjectList(window,serial_objects))) { CloseConfigWindow(window); FreeTimer(timer); return 0; } // Set ok flag *((ULONG *)mod_data)|=(1<<28); // Display text list=build_text_display(window,objlist,message0); // Start timer StartTimer(timer,DELAY,0); // Event loop FOREVER { struct IntuiMessage *msg; BOOL break_flag=0; // Timer returned? if (CheckTimer(timer)) { // Exit break_flag=1; } // Any Intuition messages? while (msg=GetWindowMsg(window->UserPort)) { struct IntuiMessage copy_msg; // Copy message and reply copy_msg=*msg; ReplyWindowMsg(msg); // Gadget? if (copy_msg.Class==IDCMP_GADGETUP) { struct Gadget *gadget; // Get gadget gadget=(struct Gadget *)copy_msg.IAddress; // Look at gadget ID switch (gadget->GadgetID) { // Ok case GAD_SERIAL_OKAY: break_flag=1; break; } } } if (break_flag) break; Wait(1<<window->UserPort->mp_SigBit|1<<timer->port->mp_SigBit); } // Close window CloseConfigWindow(window); // Free list and timer Att_RemList(list,0); FreeTimer(timer); // Success return 1; }
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); }
// Get search data static int search_get_data( FunctionHandle *handle, SearchData *data) { NewConfigWindow new_win; struct Window *window; ObjectList *objlist; Lister *lister; short cancel=1; // Fill out new window if ((lister=function_lister_current(&handle->source_paths))) { new_win.parent=lister->window; new_win.flags=0; } else { new_win.parent=GUI->screen_pointer; new_win.flags=WINDOW_SCREEN_PARENT; } new_win.dims=&search_window; new_win.title=GetString(&locale,MSG_ENTER_SEARCH_STRING); new_win.locale=&locale; new_win.port=0; new_win.flags|=WINDOW_NO_CLOSE|WINDOW_VISITOR|WINDOW_AUTO_KEYS|WINDOW_REQ_FILL; new_win.font=0; // Open window if (!(window=OpenConfigWindow(&new_win)) || !(objlist=AddObjectList(window,search_objects))) { CloseConfigWindow(window); return 0; } // Initial settings SetGadgetValue(objlist,GAD_SEARCH_TEXT,(ULONG)data->search_text); SetGadgetValue(objlist,GAD_SEARCH_CASE,data->search_flags&SEARCH_NOCASE); SetGadgetValue(objlist,GAD_SEARCH_WILD,data->search_flags&SEARCH_WILDCARD); SetGadgetValue(objlist,GAD_SEARCH_ONLYWORD,data->search_flags&SEARCH_ONLYWORDS); SetGadgetValue(objlist,GAD_SEARCH_RESULT,data->search_result); // Activate text field ActivateStrGad(GADGET(GetObject(objlist,GAD_SEARCH_TEXT)),window); // Event loop FOREVER { struct IntuiMessage *msg; BOOL break_flag=0; // Check for abort if (function_check_abort(handle)) break; // Activate? if (handle->flags2&FUNCF_ACTIVATE_ME) { ActivateWindow(window); WindowToFront(window); handle->flags2&=~FUNCF_ACTIVATE_ME; } // Any Intuition messages? while ((msg=GetWindowMsg(window->UserPort))) { struct IntuiMessage copy_msg; // Copy message and reply copy_msg=*msg; ReplyWindowMsg(msg); // Gadget? if (copy_msg.Class==IDCMP_GADGETUP) { UWORD gadgetid; // Get gadget id gadgetid=((struct Gadget *)copy_msg.IAddress)->GadgetID; // Look at gadget ID switch (gadgetid) { // Okay case GAD_SEARCH_TEXT: case GAD_SEARCH_OKAY: // Store flags data->search_flags=0; if (GetGadgetValue(objlist,GAD_SEARCH_CASE)) data->search_flags|=SEARCH_NOCASE; if (GetGadgetValue(objlist,GAD_SEARCH_WILD)) data->search_flags|=SEARCH_WILDCARD; if (GetGadgetValue(objlist,GAD_SEARCH_ONLYWORD)) data->search_flags|=SEARCH_ONLYWORDS; data->search_result=GetGadgetValue(objlist,GAD_SEARCH_RESULT); // Get search text strcpy(data->search_text,(char *)GetGadgetValue(objlist,GAD_SEARCH_TEXT)); cancel=0; // Cancel case GAD_SEARCH_CANCEL: break_flag=1; break; } } } // Check break flag if (break_flag) break; // Wait for an event Wait(1<<window->UserPort->mp_SigBit|1<<handle->ipc->command_port->mp_SigBit); } // Close window CloseConfigWindow(window); // Return return !cancel; }
short LIBFUNC L_Config_Filetypes( REG(a0, struct Screen *screen), REG(a1, IPCData *ipc), REG(a2, IPCData *owner_ipc), REG(d0, ULONG command_list), REG(a3, char *name)) { config_filetypes_data *data; IPCMessage *quit_msg=0; short undo_flag=0,pending_quit=0; short ret=0,fontsize; struct IBox pos; ConfigWindow dims; // Allocate data and memory handle if (!(data=AllocVec(sizeof(config_filetypes_data),MEMF_CLEAR)) || !(data->memory=NewMemHandle(4096,256,MEMF_CLEAR))) return 0; // Save pointers data->ipc=ipc; data->owner_ipc=owner_ipc; data->command_list=command_list; // Initialise data NewList(&data->list_list); InitListLock(&data->proc_list,0); // Fill in new window data->newwin.parent=screen; data->newwin.dims=&dims; data->newwin.title=GetString(locale,MSG_FILETYPES_TITLE); data->newwin.locale=locale; data->newwin.flags=WINDOW_SCREEN_PARENT|WINDOW_VISITOR|WINDOW_REQ_FILL|WINDOW_AUTO_KEYS|WINDOW_SIZE_BOTTOM; // Get default size dims=_config_filetypes_window; // Get saved position if (LoadPos("dopus/windows/filetypes",&pos,&fontsize)) { dims.char_dim.Width=0; dims.char_dim.Height=0; dims.fine_dim.Width=pos.Width; dims.fine_dim.Height=pos.Height; } // Open window and add objects if (!(data->window=OpenConfigWindow(&data->newwin)) || !(data->objlist=AddObjectList(data->window,_config_filetypes_objects))) { CloseConfigWindow(data->window); FreeMemHandle(data->memory); FreeVec(data); return 0; } // Set minimum size SetConfigWindowLimits(data->window,&_config_filetypes_window,0); // Read filetype list SetWindowBusy(data->window); filetype_read_list(data->memory,&data->list_list); // Build display list filetype_build_list(data); ClearWindowBusy(data->window); // Name to edit? if (name) filetype_edit_name(data,name); // Event loop FOREVER { struct IntuiMessage *msg; IPCMessage *imsg; int quit_flag=0; // Any IPC messages? while ((imsg=(IPCMessage *)GetMsg(ipc->command_port))) { // Look at command switch (imsg->command) { // Quit case IPC_QUIT: quit_flag=1; quit_msg=imsg; imsg=0; data->change=0; break; // Activate case IPC_ACTIVATE: if (data->window) { // Bring window to front WindowToFront(data->window); ActivateWindow(data->window); // Edit name supplied? if (imsg->data) filetype_edit_name(data,(char *)imsg->data); } break; // Process saying goodbye case IPC_GOODBYE: { FiletypeNode *node; // Handle goodbye if ((node=(FiletypeNode *)IPC_GetGoodbye(imsg))) { // Node no longer has an editor node->editor=0; } // All process gone and pending quit? if (pending_quit && (IsListEmpty(&data->proc_list.list))) { quit_flag=1; pending_quit=2; } } break; // Got a filetype back from the editor case FILETYPEEDIT_RETURN: if (filetype_receive_edit( data, (Cfg_Filetype *)imsg->flags, (FiletypeNode *)imsg->data)) { data->change=1; imsg->command=1; } else imsg->command=0; break; } // Reply message IPC_Reply(imsg); // Check quit flag if (quit_flag) break; } // Intuimessages if (data->window) { while ((msg=GetWindowMsg(data->window->UserPort))) { struct IntuiMessage msg_copy; UWORD id; // Copy message and reply msg_copy=*msg; ReplyWindowMsg(msg); if (pending_quit) continue; // Look at message switch (msg_copy.Class) { // Close window case IDCMP_CLOSEWINDOW: quit_flag=1; undo_flag=1; break; // Gadget case IDCMP_GADGETUP: id=((struct Gadget *)msg_copy.IAddress)->GadgetID; switch (id) { // Cancel case GAD_FILETYPES_CANCEL: undo_flag=1; // Use case GAD_FILETYPES_USE: quit_flag=1; break; // Filetype selected case GAD_FILETYPES_LIST: { Att_Node *node; // Enable buttons filetype_able_buttons(data,FALSE); // Get selection if (!(node=Att_FindNode(data->filetype_list,msg_copy.Code))) break; // Double-click? if (node==data->sel_filetype && DoubleClick( data->seconds,data->micros, msg_copy.Seconds,msg_copy.Micros)) { // Launch editor for this filetype filetype_edit(data,(FiletypeNode *)data->sel_filetype->data,0); } // New selection else { data->sel_filetype=node; data->seconds=msg_copy.Seconds; data->micros=msg_copy.Micros; } } break; // Add a new filetype case GAD_FILETYPES_DUPLICATE: if (!data->sel_filetype) break; case GAD_FILETYPES_ADD: { Cfg_FiletypeList *list; Cfg_Filetype *type=0; // Allocate a new filetype list if ((list=AllocMemH(data->memory,sizeof(Cfg_FiletypeList)))) { // Initialise list NewList(&list->filetype_list); // Copy existing filetype? if ((((struct Gadget *)msg_copy.IAddress)->GadgetID== GAD_FILETYPES_DUPLICATE)) { // Copy filetype type=CopyFiletype( ((FiletypeNode *)data->sel_filetype->data)->type, data->memory); } // Allocate a new filetype else if ((type=NewFiletype(data->memory))) { // Initialise name strcpy(type->type.name,GetString(locale,MSG_UNTITLED)); } // Get a filetype? if (type) { // Add filetype list to main list AddTail(&data->list_list,&list->node); // Add filetype to list AddTail(&list->filetype_list,&type->node); // Set list pointer type->list=list; list->flags=FTLISTF_CHANGED; } // Failed else FreeMemH(list); } // Got new filetype? if (type) { Att_Node *node; // Remove existing list SetGadgetChoices( data->objlist, GAD_FILETYPES_LIST, (APTR)~0); // Add entry for this filetype node=filetype_add_entry(data,type); // Handle new nodes filetype_new_node(data,node); } } break; // Edit filetype case GAD_FILETYPES_EDIT: // Valid selection? if (data->sel_filetype) { // Launch editor for this filetype filetype_edit(data,(FiletypeNode *)data->sel_filetype->data,0); } break; // Remove/Store case GAD_FILETYPES_REMOVE: case GAD_FILETYPES_STORE: // Valid selection? if (data->sel_filetype) { short ret; // Remove filetype if ((ret= filetype_remove( data, data->sel_filetype, (id==GAD_FILETYPES_STORE)))==1) { data->change=1; data->sel_filetype=0; } // Quit? else if (ret==-1) { quit_flag=1; } } break; } break; // Key press case IDCMP_RAWKEY: // Help? if (msg_copy.Code==0x5f && !(msg_copy.Qualifier&VALID_QUALIFIERS)) { // Set busy pointer SetWindowBusy(data->window); // Send help command IPC_Command(data->owner_ipc,IPC_HELP,(1<<31),"File Types",0,REPLY_NO_PORT); // Clear busy pointer ClearWindowBusy(data->window); } break; } // Check quit flag if (quit_flag) break; } } // Check quit flag if (quit_flag) { if (!pending_quit) { SetWindowBusy(data->window); if (!(IPC_ListQuit(&data->proc_list,0,!undo_flag,FALSE))) pending_quit=2; else pending_quit=1; } } // Set to break? if (pending_quit==2) { // Save filetypes? if (data->change && !undo_flag) { if (!(ret=filetype_save(data))) { // Abort save/quit ClearWindowBusy(data->window); pending_quit=0; continue; } } break; } // Wait for an event Wait(1<<ipc->command_port->mp_SigBit| ((data->window)?1<<data->window->UserPort->mp_SigBit:0)); } // Save window position if (data->window) { struct IBox pos; pos.Left=data->window->LeftEdge; pos.Top=data->window->TopEdge; pos.Width=data->window->Width-data->window->BorderLeft-data->window->BorderRight; pos.Height=data->window->Height-data->window->BorderTop-data->window->BorderBottom; SavePos("dopus/windows/filetypes",(struct IBox *)&pos,data->window->RPort->TxHeight); } // Close up CloseConfigWindow(data->window); // Free data Att_RemList(data->filetype_list,REMLIST_FREEDATA); FreeMemHandle(data->memory); FreeVec(data); // Reply quit message IPC_Reply(quit_msg); return ret; }