// Show list of status bar options
void _config_env_status_list(ObjectList *objlist,ULONG id,long first,long last)
{
Att_List *list;
short a,b;
char name[80];
// Build list
if (!(list=Att_NewList(0))) return;
for (a=first;a<=((last)?last:32767);a++)
{
stccpy(name,GetString(locale,a),sizeof(name));
if (name[0]=='-' && name[1]==0)
break;
for (b=0;name[b] && name[b]!='\t';b++)
if (name[b]=='*') name[b]='%';
Att_NewNode(list,name,0,0);
}
// Make window busy
SetWindowBusy(objlist->window);
// Display selection list
a=SelectionList(list,objlist->window,0,
GetString(locale,MSG_ENVIRONMENT_LISTER_SELECT_STATUS),
-1,
0,
0,
GetString(locale,MSG_OKAY),
GetString(locale,MSG_CANCEL),0,0);
// Clear busy
ClearWindowBusy(objlist->window);
// Selection?
if (a!=-1)
{
Att_Node *node;
// Get node
if ((node=Att_FindNode(list,a)))
{
char *ptr,buf[10];
// Get string pointer
ptr=strchr(node->node.ln_Name,'\t');
if (ptr) stccpy(buf,node->node.ln_Name,(ptr-node->node.ln_Name)+1);
else stccpy(buf,node->node.ln_Name,sizeof(buf));
// Insert into gadget
funced_edit_insertstring(objlist,id,buf,DOpusBase,(struct Library *)IntuitionBase);
}
}
// Free list
Att_RemList(list,0);
}
void config_env_store_sound(config_env_data *data)
{
short num;
Cfg_SoundEntry *sound;
// Get selection
if ((num=GetGadgetValue(data->option_list,GAD_SETTINGS_SOUNDLIST))>-1 &&
(sound=(Cfg_SoundEntry *)Att_FindNode((Att_List *)&data->sound_list,num)))
{
short flags,old_volume;
char old_sound[256];
strcpy(old_sound,sound->dse_Sound);
old_volume=sound->dse_Volume;
strcpy(sound->dse_Sound,(char *)GetGadgetValue(data->option_list,GAD_SETTINGS_SOUNDLIST_PATH));
UpdateGadgetValue(data->option_list,0,GAD_SETTINGS_VOLUME);
if ((sound->dse_Volume=GetGadgetValue(data->option_list,GAD_SETTINGS_VOLUME))<0)
sound->dse_Volume=0;
else
if (sound->dse_Volume>64)
sound->dse_Volume=64;
SetGadgetValue(data->option_list,GAD_SETTINGS_VOLUME,sound->dse_Volume);
SetGadgetValue(data->option_list,GAD_SETTINGS_VOLUME_SLIDER,sound->dse_Volume);
// Did sound change?
if (strcmp(old_sound,sound->dse_Sound)!=0)
{
// Fix pen usage
flags=sound->dse_Node.lve_Flags;
if (sound->dse_Sound[0])
sound->dse_Node.lve_Flags|=LVEF_USE_PEN;
else
sound->dse_Node.lve_Flags&=~LVEF_USE_PEN;
if (flags!=sound->dse_Node.lve_Flags)
{
SetGadgetChoices(data->objlist,GAD_SETTINGS_SOUNDLIST,(APTR)~0);
SetGadgetChoices(data->objlist,GAD_SETTINGS_SOUNDLIST,&data->sound_list);
}
sound->dse_Node.lve_Flags|=LVEF_TEMP;
}
// Or volume?
else
if (old_volume!=sound->dse_Volume)
sound->dse_Node.lve_Flags|=LVEF_TEMP;
}
}
void config_env_test_sound(config_env_data *data)
{
struct Library *ModuleBase;
BOOL ok=0;
// Busy the window
SetWindowBusy(data->window);
// Open play.module
if (ModuleBase=OpenLibrary("dopus5:modules/play.module",0))
{
short num;
Cfg_SoundEntry *sound;
// Get selection
if ((num=GetGadgetValue(data->option_list,GAD_SETTINGS_SOUNDLIST))>-1 &&
(sound=(Cfg_SoundEntry *)Att_FindNode((Att_List *)&data->sound_list,num)) &&
sound->dse_Sound[0])
{
struct Node node;
struct List list;
// Build file list
NewList(&list);
node.ln_Name=sound->dse_Sound;
AddTail(&list,&node);
// Play the sound
Module_Entry(
&list,
data->window->WScreen,
data->ipc,
data->main_ipc,
(ULONG)data->window,
sound->dse_Volume<<8);
ok=1;
}
// Close module
CloseLibrary(ModuleBase);
}
// Unbusy the window
ClearWindowBusy(data->window);
if (!ok) DisplayBeep(data->window->WScreen);
}
void config_env_show_sound(config_env_data *data)
{
short num;
Cfg_SoundEntry *sound;
// Get selection
if ((num=GetGadgetValue(data->option_list,GAD_SETTINGS_SOUNDLIST))>-1 &&
(sound=(Cfg_SoundEntry *)Att_FindNode((Att_List *)&data->sound_list,num)) && sound->dse_Sound[0])
{
SetGadgetValue(data->option_list,GAD_SETTINGS_SOUNDLIST_PATH,(ULONG)sound->dse_Sound);
SetGadgetValue(data->option_list,GAD_SETTINGS_VOLUME,sound->dse_Volume);
SetGadgetValue(data->option_list,GAD_SETTINGS_VOLUME_SLIDER,sound->dse_Volume);
}
else
{
SetGadgetValue(data->option_list,GAD_SETTINGS_SOUNDLIST_PATH,0);
SetGadgetValue(data->option_list,GAD_SETTINGS_VOLUME,64);
SetGadgetValue(data->option_list,GAD_SETTINGS_VOLUME_SLIDER,64);
}
}
int LIBFUNC L_Module_Entry(
REG(a0, struct List *files),
REG(a1, struct Screen *screen),
REG(a2, IPCData *ipc),
REG(a3, IPCData *main_ipc),
REG(d0, ULONG mod_id),
REG(d1, ULONG mod_data))
{
config_path_data *data;
short success=1;
// Allocate data
if (!(data=AllocVec(sizeof(config_path_data),MEMF_CLEAR)) ||
!(data->path_list=Att_NewList(0)))
{
FreeVec(data);
return 0;
}
// Store data pointers
data->paths=files;
data->ipc=ipc;
data->main_ipc=main_ipc;
data->memory=(APTR)mod_id;
data->def_format=(ListFormat *)mod_data;
// AppPort
data->appport=CreateMsgPort();
// Open commodities library
/*data->cxbase=OpenLibrary("commodities.library",0);
#ifdef __amigaos4__
ICommodities=(struct CommoditiesIFace *)GetInterface(data->cxbase,"main",1,NULL);
#endif */
// Build path list
config_paths_build_list(data);
// Open window
if (!(config_paths_open(data,screen)))
return 0;
// Event loop
FOREVER
{
IPCMessage *imsg;
struct IntuiMessage *msg;
int quit_flag=0;
// IPC messages?
while ((imsg=(IPCMessage *)GetMsg(ipc->command_port)))
{
// Quit?
if (imsg->command==IPC_QUIT)
{
quit_flag=1;
success=0;
}
// Hide?
else if (imsg->command==IPC_HIDE)
{
RemoveAppWindow(data->appwindow);
data->appwindow=0;
CloseConfigWindow(data->window);
data->window=0;
}
// Show?
else if (imsg->command==IPC_SHOW)
{
if (!(config_paths_open(data,imsg->data)))
{
quit_flag=1;
success=0;
}
}
// Activate
else if (imsg->command==IPC_ACTIVATE)
{
if (data->window)
{
WindowToFront(data->window);
ActivateWindow(data->window);
}
}
// Reply
IPC_Reply(imsg);
}
// Any messages to the window?
if (data->window)
{
while ((msg=GetWindowMsg(data->window->UserPort)))
{
struct IntuiMessage msg_copy;
UWORD gadgetid;
// Copy message and reply
msg_copy=*msg;
ReplyWindowMsg(msg);
// Look at message
switch (msg_copy.Class)
{
// Close window
case IDCMP_CLOSEWINDOW:
quit_flag=1;
success=0;
break;
// Gadget
case IDCMP_GADGETUP:
case IDCMP_GADGETDOWN:
// Get GadgetID
gadgetid=((struct Gadget *)msg_copy.IAddress)->GadgetID;
// Look at gadget
switch (gadgetid)
{
// Cancel
case GAD_PATHFORMAT_CANCEL:
success=0;
// Use
case GAD_PATHFORMAT_SAVE:
quit_flag=1;
break;
// Add an entry
case GAD_PATHFORMAT_ADD:
config_paths_add(data,TRUE);
break;
// Change path name
case GAD_PATHFORMAT_PATH:
config_paths_change(data);
break;
// Select an entry
case GAD_PATHFORMAT_PATHS:
{
Att_Node *node;
// Find selected entry
node=Att_FindNode(data->path_list,msg_copy.Code);
// Double-click?
if (DoubleClick(data->seconds,data->micros,msg_copy.Seconds,msg_copy.Micros) &&
node==data->path_sel)
{
// Edit it
config_paths_edit(data);
break;
}
// Store double-click time
data->seconds=msg_copy.Seconds;
data->micros=msg_copy.Micros;
// Not already selected?
if (node!=data->path_sel)
{
// Select it
config_paths_select(data,node,FALSE);
}
}
break;
// Key
case GAD_PATHFORMAT_KEY:
config_paths_get_key(data);
break;
// Open new lister
case GAD_PATHFORMAT_NEW_LISTER:
// Valid selection?
if (data->path_sel)
{
position_rec *pos=(position_rec *)data->path_sel->data;
// Open new lister?
if (msg_copy.Code)
{
// Set flag
pos->flags|=POSITIONF_OPEN_NEW;
// Clear type flags
pos->flags&=~(POSITIONF_ICON|POSITIONF_ICON_ACTION);
// Icon action?
if (msg_copy.Code==MODE_ACTION)
pos->flags|=POSITIONF_ICON|POSITIONF_ICON_ACTION;
// Icon?
else
if (msg_copy.Code==MODE_ICON)
pos->flags|=POSITIONF_ICON;
}
// No lister
else pos->flags&=~POSITIONF_OPEN_NEW;
}
break;
// Remove
case GAD_PATHFORMAT_REMOVE:
config_paths_remove(data,TRUE);
break;
// Edit
case GAD_PATHFORMAT_EDIT:
config_paths_edit(data);
break;
}
break;
// Key press
case IDCMP_RAWKEY:
// Help?
if (msg_copy.Code==0x5f &&
!(msg_copy.Qualifier&VALID_QUALIFIERS))
{
// Valid main IPC?
if (main_ipc)
{
// Set busy pointer
SetWindowBusy(data->window);
// Send help request
IPC_Command(main_ipc,IPC_HELP,(1<<31),"Paths",0,(struct MsgPort *)-1);
// Clear busy pointer
ClearWindowBusy(data->window);
}
}
break;
}
// Check quit flag
if (quit_flag) break;
}
}
// Check quit flag
if (quit_flag) break;
// App messages?
if (data->appport)
{
struct AppMessage *msg;
// Get messages
while ((msg=(struct AppMessage *)GetMsg(data->appport)))
{
// Get first argument
if (msg->am_NumArgs>0)
{
// Is it a directory?
if (!msg->am_ArgList[0].wa_Name || !*msg->am_ArgList[0].wa_Name)
{
char buf[256];
// Expand path name
if (NameFromLock(msg->am_ArgList[0].wa_Lock,buf,256))
{
Att_Node *node;
// Fix trailing /
AddPart(buf,"",256);
// Check it's not already in the list
if (!(node=(Att_Node *)FindNameI((struct List *)data->path_list,buf)))
{
// Add a new entry
config_paths_add(data,FALSE);
// Copy path to path field
SetGadgetValue(data->objlist,GAD_PATHFORMAT_PATH,(ULONG)buf);
// Accept the new path
config_paths_change(data);
}
// It is, select this entry
else config_paths_select(data,node,FALSE);
}
}
}
// Reply message
ReplyMsg((struct Message *)msg);
}
}
// Wait for input
Wait(
((data->window)?(1<<data->window->UserPort->mp_SigBit):0)|
((data->appport)?(1<<data->appport->mp_SigBit):0)|
1<<ipc->command_port->mp_SigBit);
}
// Free stuff
config_paths_cleanup(data);
return success;
}
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);
}
void FiletypeEditor(void)
{
filetype_ed_data *data=0;
IPCData *ipc;
short success=0,pending_quit=0;
BOOL change_flag=0;
// Do startup
if (!(ipc=Local_IPC_ProcStartup((ULONG *)&data, (APTR)&_filetypeed_init)))
return;
// Create App stuff
if ((data->app_port=CreateMsgPort()))
{
data->app_window=AddAppWindowA(0,0,data->window,data->app_port,0);
}
// Get icon image
if (data->type->icon_path)
{
#ifdef USE_DRAWICONSTATE
{
char *path_copy;
data->icon_image=NULL;
if ((path_copy=AllocMemH(0,strlen(data->type->icon_path)+1)))
{
// icon_path is guaranteed to have a .info at the end
stccpy(path_copy,data->type->icon_path,strlen(data->type->icon_path)-4);
data->icon_image=GetCachedDiskObject(path_copy,0);
FreeMemH(path_copy);
}
}
#else
data->icon_image=OpenImage(data->type->icon_path,0);
#endif
// Show icon image
filetypeed_show_icon(data);
}
// Launch class editor immediately?
if (data->edit_flag) filetypeed_edit_definition(data);
// Message loop
FOREVER
{
IPCMessage *msg;
struct IntuiMessage *imsg;
short break_flag=0;
// Check drag
if (config_drag_check(&data->drag))
{
// End drag
filetypeed_end_drag(data,0);
}
// Task message?
while ((msg=(IPCMessage *)GetMsg(ipc->command_port)))
{
switch (msg->command)
{
// Close message?
case IPC_QUIT:
if (!pending_quit)
{
success=msg->flags;
break_flag=1;
}
break;
// Activate
case IPC_ACTIVATE:
if (data->window)
{
WindowToFront(data->window);
ActivateWindow(data->window);
}
break;
// Editor saying goodbye
case IPC_GOODBYE:
{
ULONG which;
// What's just gone?
which=IPC_GetGoodbye(msg);
// Class editor?
if (which==(ULONG)-1) data->class_editor=0;
// Icon menu editor?
else
if (which>15)
{
Att_Node *node;
// Go through icon list
for (node=(Att_Node *)data->icon_list->list.lh_Head;
node->node.ln_Succ;
node=(Att_Node *)node->node.ln_Succ)
{
// Match function
if (((func_node *)node->data)->func==(Cfg_Function *)which)
{
// Clear editor pointer
((func_node *)node->data)->editor=0;
// Check for invalid function
if (filetypeed_check_iconmenu(data,node,FALSE))
change_flag=1;
break;
}
}
}
// Normal filetype editor
else data->editor[which]=0;
}
break;
// Editor returning a function
case FUNCTIONEDIT_RETURN:
{
short ret;
if ((ret=filetypeed_receive_edit(
data,
(FunctionReturn *)msg->data)))
{
change_flag=1;
filetypeed_update_actions(data);
if (ret==2) filetypeed_update_iconmenu(data);
}
}
break;
// Class editor returning
case CLASSEDIT_RETURN:
filetypeed_receive_class(data,(Cfg_Filetype *)msg->data);
change_flag=1;
break;
// Get a copy of a button
case BUTTONEDIT_CLIP_BUTTON:
// Handle this button
if (filetypeed_get_button(data,(Cfg_Button *)msg->data,(Point *)msg->data_free))
change_flag=1;
break;
}
// Reply the message
IPC_Reply(msg);
}
// Intuimessage
if (data->window)
{
while ((imsg=GetWindowMsg(data->window->UserPort)))
{
struct IntuiMessage msg_copy;
struct Gadget *gadget;
struct TagItem *tags;
// Copy message
msg_copy=*imsg;
// Don't reply to IDCMPUPDATE messages just yet
if (imsg->Class!=IDCMP_IDCMPUPDATE)
{
ReplyWindowMsg(imsg);
imsg=0;
}
// Get gadget and tag pointers
gadget=(struct Gadget *)msg_copy.IAddress;
tags=(struct TagItem *)gadget;
// Look at message
switch (msg_copy.Class)
{
// Close window
case IDCMP_CLOSEWINDOW:
if (!pending_quit) break_flag=1;
break;
// Gadget
case IDCMP_GADGETUP:
switch (gadget->GadgetID)
{
// Use
case GAD_FILETYPEED_USE:
success=1;
// Cancel
case GAD_FILETYPEED_CANCEL:
if (!pending_quit) break_flag=1;
break;
// Select a function
case GAD_FILETYPEED_ACTION_LIST:
{
Att_Node *node;
// Get selected node
if (!(node=Att_FindNode(data->action_list,msg_copy.Code)))
break;
// Enable edit action button
DisableObject(data->objlist,GAD_FILETYPES_EDIT_ACTION,FALSE);
// Double-click?
if (!(DoubleClick(data->last_sec,data->last_mic,msg_copy.Seconds,msg_copy.Micros)) ||
node!=data->last_sel)
{
data->last_sec=msg_copy.Seconds;
data->last_mic=msg_copy.Micros;
data->last_sel=node;
data->last_icon=0;
break;
}
}
// Fall through
case GAD_FILETYPES_EDIT_ACTION:
// No current selection?
if (!data->last_sel) break;
// Is editor already up for this action?
if (data->editor[data->last_sel->data])
IPC_Command(data->editor[data->last_sel->data],IPC_ACTIVATE,0,0,0,0);
// Need to launch editor
else filetypeed_edit_action(data,data->last_sel->data,data->last_sel->node.ln_Name);
break;
// Delete action
case GAD_FILETYPES_DEL_ACTION:
// No current selection?
if (!data->last_sel) break;
// Is editor up for this action?
if (data->editor[data->last_sel->data])
IPC_Command(data->editor[data->last_sel->data],IPC_QUIT,0,0,0,0);
// Delete it
if (filetypeed_del_action(data,data->last_sel->data))
change_flag=1;
break;
// Edit filetype definition
case GAD_FILETYPEED_EDIT_CLASS:
// Is class editor already up for this action?
if (data->class_editor)
IPC_Command(data->class_editor,IPC_ACTIVATE,0,0,0,0);
// Need to launch editor
else filetypeed_edit_definition(data);
break;
// Select icon
case GAD_FILETYPEED_SELECT_ICON:
if (filetypeed_pick_icon(data))
change_flag=1;
break;
// Add to icon menu
case GAD_FILETYPES_ADD_ICON_MENU:
filetypeed_add_iconmenu(data);
break;
// Select an icon menu
case GAD_FILETYPES_ICON_MENU:
{
Att_Node *last=data->last_icon;
// Handle selection
if (!(filetypeed_sel_icon(data,msg_copy.Code))) break;
// Double-click?
if (data->last_icon!=last ||
!(DoubleClick(
data->last_sec,
data->last_mic,
msg_copy.Seconds,
msg_copy.Micros)))
{
data->last_sec=msg_copy.Seconds;
data->last_mic=msg_copy.Micros;
data->last_sel=0;
break;
}
}
// Fall through
case GAD_FILETYPES_EDIT_ICON_MENU:
// No current selection?
if (!data->last_icon) break;
// Edit it
filetypeed_edit_iconmenu(data,data->last_icon);
break;
// Delete from icon menu
case GAD_FILETYPES_DEL_ICON_MENU:
// No current selection?
if (!data->last_icon) break;
// Delete function
if (filetypeed_check_iconmenu(data,data->last_icon,TRUE))
change_flag=1;
break;
}
break;
// BOOPSI message
case IDCMP_IDCMPUPDATE:
{
short item;
// Icon list?
if (GetTagData(GA_ID,0,tags)!=GAD_FILETYPES_ICON_MENU) break;
// Get item
if ((item=GetTagData(DLV_DragNotify,-1,tags))!=-1)
{
// Handle selection
filetypeed_sel_icon(data,item);
// Start the drag
config_drag_start(&data->drag,data->icon_list,item,tags,TRUE);
}
}
break;
// Ticks
case IDCMP_INTUITICKS:
++data->drag.tick_count;
break;
// Mouse move
case IDCMP_MOUSEMOVE:
// Handle drag move
config_drag_move(&data->drag);
break;
// Mouse buttons
case IDCMP_MOUSEBUTTONS:
// Valid drag info?
if (data->drag.drag)
{
short ok=-1;
// Dropped ok?
if (msg_copy.Code==SELECTUP)
{
// 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_copy.Code==MENUDOWN) ok=0;
// End drag?
if (ok!=-1 && filetypeed_end_drag(data,ok)) change_flag=1;
}
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->func_startup.main_owner,IPC_HELP,(1<<31),"File Type Editor",0,REPLY_NO_PORT);
// Clear busy pointer
ClearWindowBusy(data->window);
}
break;
}
// Reply to outstanding messages
if (imsg) ReplyWindowMsg(imsg);
}
// Check break flag
if (break_flag || pending_quit)
{
// See if all the editors are gone
if (IsListEmpty(&data->proc_list.list))
break;
// Send quit?
if (break_flag)
{
IPC_ListQuit(&data->proc_list,0,success,FALSE);
SetWindowBusy(data->window);
}
pending_quit=1;
}
}
// AppMessage
if (data->app_window)
{
struct AppMessage *msg;
while ((msg=(struct AppMessage *)GetMsg(data->app_port)))
{
// Got an argument?
if (msg->am_NumArgs>0)
{
char name[256];
short len;
APTR image;
// Get full name
NameFromLock(msg->am_ArgList[0].wa_Lock,name,256);
if (msg->am_ArgList[0].wa_Name &&
*msg->am_ArgList[0].wa_Name)
AddPart(name,msg->am_ArgList[0].wa_Name,256);
// Add .info
if ((len=strlen(name))<6 ||
stricmp(name+len-5,".info")!=0) strcat(name,".info");
// Try to get image
#ifdef USE_DRAWICONSTATE
{
char *path_copy;
image=NULL;
if ((path_copy=AllocMemH(0,strlen(name)+1)))
{
// icon_path is guaranteed to have a .info at the end
stccpy(path_copy,name,strlen(name)-4);
image=GetCachedDiskObject(path_copy,0);
FreeMemH(path_copy);
}
}
#else
image=OpenImage(name,0);
#endif
if (image)
{
// Store path
FreeMemH(data->type->icon_path);
if ((data->type->icon_path=AllocMemH(0,strlen(name)+1)))
strcpy(data->type->icon_path,name);
// Free existing image
#ifdef USE_DRAWICONSTATE
FreeCachedDiskObject(data->icon_image);
#else
CloseImage(data->icon_image);
#endif
data->icon_image=image;
// Show new image
filetypeed_show_icon(data);
change_flag=1;
}
}
// Reply message
ReplyMsg((struct Message *)msg);
}
}
Wait(1<<ipc->command_port->mp_SigBit|
1<<data->drag.timer->port->mp_SigBit|
((data->window)?(1<<data->window->UserPort->mp_SigBit):0)|
((data->app_window)?(1<<data->app_port->mp_SigBit):0));
}
// End any drag in progress
filetypeed_end_drag(data,0);
// Need to send button back?
if (success==1 && change_flag)
{
if (IPC_Command(
data->owner_ipc,
FILETYPEEDIT_RETURN,
(ULONG)data->type,
data->node,
0,
REPLY_NO_PORT))
{
data->node=0;
}
}
// Free edit filetype
FreeFiletype(data->type);
// Remove AppWindow
RemoveAppWindow(data->app_window);
// Close window
CloseConfigWindow(data->window);
// Close app port
if (data->app_port)
{
struct Message *msg;
while ((msg=GetMsg(data->app_port)))
ReplyMsg(msg);
DeleteMsgPort(data->app_port);
}
// Say goodbye
IPC_Goodbye(ipc,data->owner_ipc,(success==-1)?0:(ULONG)data->node);
// Free icon image
#ifdef USE_DRAWICONSTATE
FreeCachedDiskObject(data->icon_image);
#else
CloseImage(data->icon_image);
#endif
// Close timer
FreeTimer(data->drag.timer);
// Free data
IPC_Free(ipc);
Att_RemList(data->action_list,0);
Att_RemList(data->icon_list,REMLIST_FREEDATA);
FreeVec(data);
}
int LIBFUNC L_Module_Entry(
REG(a0, char *argstring),
REG(a1, struct Screen *screen),
REG(a2, IPCData *ipc),
REG(a3, IPCData *main_ipc),
REG(d0, ULONG mod_id),
REG(d1, EXT_FUNC(func_callback)))
{
DOpusCallbackInfo info, *infoptr = &info;
char filename[300];
FuncArgs *args;
// Get callbacks
info.dc_Count=DOPUS_HOOK_COUNT;
info.dc_RexxCommand=0;
info.dc_FileRequest=0;
info.dc_GetThemes=0;
info.dc_UnlockSource=0;
IPC_Command(main_ipc,HOOKCMD_GET_CALLBACKS,0,&info,0,REPLY_NO_PORT);
// Must be able to send rexx commands and show file requester
if (!info.dc_RexxCommand || !info.dc_FileRequest) return 0;
// See if filename is supplied
filename[0]=0;
if ((args=ParseArgs(func_templates[mod_id],argstring)) && args->FA_Arguments[0])
{
strcpy(filename,(char *)args->FA_Arguments[0]);
if (!strchr(filename,'/') && !strchr(filename,':'))
{
lsprintf(filename,"D5THEMES:%s",(IPTR)args->FA_Arguments[0]);
}
if (mod_id!=CONVERTTHEME && (strlen(filename)<7 || stricmp(filename+strlen(filename)-6,".theme")!=0))
strcat(filename,".theme");
}
// No filename?
if (!*filename && (mod_id==LOADTHEME || mod_id==CONVERTTHEME))
{
FunctionEntry *entry;
// Get first entries
if ((entry=(FunctionEntry *)func_callback(EXTCMD_GET_ENTRY,IPCDATA(ipc),0)))
{
struct endentry_packet packet;
// Build filename
func_callback(EXTCMD_GET_SOURCE,IPCDATA(ipc),filename);
AddPart(filename,entry->name,256);
// Fill out packet to end entry
packet.entry=entry;
packet.deselect=1;
func_callback(EXTCMD_END_ENTRY,IPCDATA(ipc),&packet);
}
}
// Unlock source lister
if (info.dc_UnlockSource)
DC_CALL1(infoptr, dc_UnlockSource, DC_REGA0, IPCDATA(ipc));
//DC_UnlockSource(infoptr, IPCDATA(ipc));
//info.dc_UnlockSource(IPCDATA(ipc));
// Save theme?
if (mod_id==SAVETHEME || mod_id==BUILDTHEME)
{
char buf[256];
// Get themes path
if (info.dc_GetThemes)
DC_CALL1(infoptr, dc_GetThemes, DC_REGA0, buf);
//DC_GetThemes(infoptr,buf);
//info.dc_GetThemes(buf);
else
strcpy(buf,"D5THEMES:");
// Get filename
if (filename[0] ||
DC_CALL6(infoptr, dc_FileRequest,
DC_REGA0, (struct Window *)screen,
DC_REGA1, GetString(locale,(mod_id==SAVETHEME)?MSG_SAVE_THEME_MSG:MSG_BUILD_THEME_MSG),
DC_REGA2, buf,
DC_REGA3, filename,
DC_REGD0, (1<<30)|(1<<31)|FRF_DOSAVEMODE,
DC_REGD1, 0))
//DC_FileRequest(infoptr,
//info.dc_FileRequest(
/* (struct Window *)screen,
GetString(locale,(mod_id==SAVETHEME)?MSG_SAVE_THEME_MSG:MSG_BUILD_THEME_MSG),
buf,
filename,
(1<<30)|(1<<31)|FRF_DOSAVEMODE,0))*/
{
long res;
char *ptr;
// Check .theme suffix
if (strlen(filename)<7 || stricmp(filename+strlen(filename)-6,".theme")!=0)
strcat(filename,".theme");
// Remove spaces
for (ptr=FilePart(filename);*ptr;ptr++)
if (*ptr==' ') *ptr='_';
// Save theme
if ((res=save_theme(screen,&info,filename,(mod_id==BUILDTHEME)?TRUE:FALSE)))
{
// Build error
lsprintf(filename,GetString(locale,MSG_SAVE_ERROR),res);
// Show error
AsyncRequestTags(
ipc,
REQTYPE_SIMPLE,
0,
0,
0,
AR_Screen,(IPTR)screen,
AR_Message,(IPTR)filename,
AR_Button,(IPTR)GetString(locale,MSG_OK),
TAG_END);
}
}
}
// Load theme
else
if (mod_id==LOADTHEME)
{
ULONG apply_flags=0;
// Flags supplied?
if (args)
{
short num;
for (num=0;num<4;num++)
{
if (args->FA_Arguments[num+1])
apply_flags|=1<<num;
}
}
// No name supplied?
if (!filename[0])
{
BPTR lock;
Att_List *list;
Att_Node *node;
char *apply_switches[5];
char temp[20];
char path[256];
long err;
// Get old apply flags
if (!apply_flags && (GetVar("dopus/taf",temp,16,GVF_GLOBAL_ONLY))>0)
apply_flags=atoi(temp);
// Initial theme path
strcpy(path,"D5THEMES:");
if ((lock=Lock(path,ACCESS_READ)))
{
NameFromLock(lock,path,256);
UnLock(lock);
}
// Get list of themes
while ((list=theme_build_list(path)))
{
// Switches for what to apply
apply_switches[0]=GetString(locale,MSG_THEME_APPLY_PALETTE);
apply_switches[1]=GetString(locale,MSG_THEME_APPLY_FONTS);
apply_switches[2]=GetString(locale,MSG_THEME_APPLY_PICTURES);
apply_switches[3]=GetString(locale,MSG_THEME_APPLY_SOUNDS);
apply_switches[4]=0;
// Show selection list
strcpy(filename,path);
if ((err=SelectionList(
list,
0,
screen,
GetString(locale,MSG_LOAD_THEME_MSG),
-1,
SLF_DIR_FIELD|SLF_USE_INITIAL|SLF_SWITCHES|SLF_RETURN_PATH,
filename,
GetString(locale,MSG_OK),
GetString(locale,MSG_CANCEL),
apply_switches,
&apply_flags))>-1)
{
// Name selected?
if ((node=Att_FindNode(list,err)))
{
char *ptr;
for (ptr=node->node.ln_Name;*ptr;ptr++)
if (*ptr==' ') *ptr='_';
lsprintf(filename,"D5THEMES:%s.theme",(IPTR)node->node.ln_Name);
}
else
filename[0]=0;
// Save apply flags
lsprintf(temp,"%ld",apply_flags);
SetEnv("dopus/taf",temp,TRUE);
}
else
if (err!=-1 && filename[0]!=0 && filename[strlen(filename)-1]=='/') filename[0]=0;
// Free list
Att_RemList(list,0);
// Break out?
if (err!=-1) break;
// Empty path returns to default
if (!filename[0])
{
// Get themes path
if (info.dc_GetThemes)
DC_CALL1(infoptr, dc_GetThemes, DC_REGA0, filename);
//DC_GetThemes(infoptr,filename);
//info.dc_GetThemes(filename);
else
strcpy(filename,"DOpus5:Themes/");
}
// Re-open with new path
strcpy(path,filename);
// Assign D5THEMES to the new directory
if ((lock=Lock(filename,ACCESS_READ)) &&
!(AssignLock("D5THEMES",lock)))
UnLock(lock);
}
}
// File to load?
if (filename[0])
{
short num;
char apply[20],*ptr,command[400],port[40];
// Build apply flags
for (num=0,ptr=apply;num<APPLY_LAST;num++)
{
if (apply_flags&(1<<num))
*(ptr++)=apply_lookup[num];
}
*ptr=0;
// Get ARexx port name
DC_CALL1(infoptr, dc_GetPort, DC_REGA0, port);
//DC_GetPort(infoptr,port);
//info.dc_GetPort(port);
// Build ARexx command to send to DOpus
lsprintf(command,"%s %s %s",(IPTR)filename,(IPTR)port,(IPTR)apply);
DC_CALL4(infoptr, dc_SendCommand,
DC_REGA0, 0,
DC_REGA1, command,
DC_REGA2, 0,
DC_REGD0, COMMANDF_RUN_SCRIPT);
//DC_SendCommand(infoptr,0,command,0,COMMANDF_RUN_SCRIPT);
//info.dc_SendCommand(0,command,0,COMMANDF_RUN_SCRIPT);
}
}
// Convert theme
else
if (mod_id==CONVERTTHEME)
{
// Get filename
if (filename[0] ||
DC_CALL6(infoptr, dc_FileRequest,
DC_REGA0, (struct Window *)screen,
DC_REGA1, GetString(locale,MSG_CONVERT_THEME_MSG),
DC_REGA2, 0,
DC_REGA3, filename,
DC_REGD0, (1<<30)|(1<<31)|(1<<29)|FRF_DOPATTERNS,
DC_REGD1, "#?.theme"))
//DC_FileRequest(infoptr,
//info.dc_FileRequest(
/*(struct Window *)screen,
GetString(locale,MSG_CONVERT_THEME_MSG),
0,
filename,
(1<<30)|(1<<31)|(1<<29)|FRF_DOPATTERNS,
"#?.theme"))*/
{
char dest[256],buf[256],*ptr;
dest[0]=0;
if ((args=ParseArgs(func_templates[mod_id],argstring)) && args->FA_Arguments[1])
{
strcpy(dest,(char *)args->FA_Arguments[1]);
if (!strchr(dest,'/') && !strchr(dest,':'))
{
lsprintf(dest,"D5THEMES:%s",(IPTR)args->FA_Arguments[0]);
}
}
// Ask for path?
if (!dest[0])
{
// Get themes path
if (info.dc_GetThemes)
DC_CALL1(infoptr, dc_GetThemes, DC_REGA0, buf);
//DC_GetThemes(infoptr,buf);
//info.dc_GetThemes(buf);
else
strcpy(buf,"D5THEMES:");
}
// Get save filename
if (dest[0] ||
DC_CALL6(infoptr, dc_FileRequest,
DC_REGA0, (struct Window *)screen,
DC_REGA1, GetString(locale,MSG_SAVE_THEME_MSG),
DC_REGA2, buf,
DC_REGA3, dest,
DC_REGD0, (1<<30)|(1<<31)|FRF_DOSAVEMODE,
DC_REGD1, 0))
//(DC_FileRequest(infoptr,
//(info.dc_FileRequest(
/* (struct Window *)screen,
GetString(locale,MSG_SAVE_THEME_MSG),
buf,
dest,
(1<<30)|(1<<31)|FRF_DOSAVEMODE,0)))*/
{
short res;
// Check .theme suffix
if (strlen(dest)<7 || stricmp(dest+strlen(dest)-6,".theme")!=0)
strcat(dest,".theme");
// Remove spaces
for (ptr=FilePart(dest);*ptr;ptr++)
if (*ptr==' ') *ptr='_';
// Convert the file
if ((res=convert_theme(&info,filename,dest)))
{
// Build error
lsprintf(filename,GetString(locale,MSG_SAVE_ERROR),res);
// Show error
AsyncRequestTags(
ipc,
REQTYPE_SIMPLE,
0,
0,
0,
AR_Screen,(IPTR)screen,
AR_Message,(IPTR)filename,
AR_Button,(IPTR)GetString(locale,MSG_OK),
TAG_END);
}
}
}
}
DisposeArgs(args);
return 1;
}
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;
}
