// 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;
}
// 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;
}
struct AppWindow * AddAppWindow (
/* SYNOPSIS */
ULONG id,
ULONG userdata,
struct Window * window,
struct MsgPort * msgport,
Tag tag1,
...)
/* FUNCTION
This is the varargs version of workbench.library/AddAppWindowA().
For information see workbench.library/AddAppWindowA().
INPUTS
RESULT
NOTES
EXAMPLE
BUGS
SEE ALSO
workbench.library/AddAppWindowA()
INTERNALS
HISTORY
*****************************************************************************/
{
AROS_SLOWSTACKTAGS_PRE(tag1)
retval = AddAppWindowA (id, userdata, window, msgport, AROS_SLOWSTACKTAGS_ARG(tag1));
AROS_SLOWSTACKTAGS_POST
} /* AddAppWindow */
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);
}
struct Window *lister_open_window(Lister *lister,struct Screen *screen)
{
struct Gadget *gadget,*lock_gad;
struct IBox *dims;
ULONG mode;
// If lister is already open, return
if (!lister || lister->window) return lister->window;
// Is lister meant to be iconified?
if (lister->flags&LISTERF_ICONIFIED) return 0;
// Is lister iconified?
if (lister->appicon)
{
// Update icon position
lister_update_icon(lister);
// Remove AppIcon
RemoveAppIcon(lister->appicon);
lister->appicon=0;
// Free icon
if (lister->appicon_icon)
{
FreeDiskObjectCopy(lister->appicon_icon);
lister->appicon_icon=0;
}
}
// If lister was zoomed, swap dimensions around
if ((lister->dimensions.wd_Flags&(WDF_VALID|WDF_ZOOMED))==(WDF_VALID|WDF_ZOOMED))
{
struct IBox temp;
// Swap dimensions
temp=lister->dimensions.wd_Zoomed;
lister->dimensions.wd_Zoomed=lister->dimensions.wd_Normal;
lister->dimensions.wd_Normal=temp;
// Clear zoomed flag
lister->dimensions.wd_Flags&=~WDF_ZOOMED;
}
// Get dimensions pointer
dims=&lister->dimensions.wd_Normal;
// Get screen font
AskFont(&screen->RastPort,&lister->screen_font);
// Calculate minimum size
lister_calc_limits(lister,screen);
// Check lister size against minimums
if (dims->Width<lister->win_limits.Left) dims->Width=lister->win_limits.Left;
if (dims->Height<lister->win_limits.Top) dims->Height=lister->win_limits.Top;
// Initialise backfill pattern
#if defined(__MORPHOS__)
lister->pattern.hook.h_Entry = (HOOKFUNC)HookEntry;
lister->pattern.hook.h_SubEntry=(ULONG (*)())PatternBackfill;
#else
lister->pattern.hook.h_Entry=(ULONG (*)())PatternBackfill;
#endif
lister->pattern.hook.h_Data=lister->backdrop_info;
lister->pattern.pattern=&GUI->pattern[PATTERN_LISTER];
// Is pattern initially enabled?
if (lister->flags&LISTERF_VIEW_ICONS)
lister->pattern.disabled=FALSE;
else lister->pattern.disabled=TRUE;
// Get refresh mode
if (environment->env->lister_options&LISTEROPTF_SIMPLE) mode=WA_SimpleRefresh;
else mode=WA_SmartRefresh;
// Initialise boopsi list
NewList(&lister->backdrop_info->boopsi_list);
// Create iconify gadget
gadget=
create_iconify_gadget(
screen,
&lister->backdrop_info->boopsi_list,
(lister->flags&LISTERF_LOCK_POS)?TRUE:FALSE);
// Create lock gadget
if (!(GUI->flags2&GUIF2_NO_PADLOCK) &&
(lock_gad=
CreateTitleGadget(
screen,
&lister->backdrop_info->boopsi_list,
(lister->flags&LISTERF_LOCK_POS)?TRUE:FALSE,
(gadget)?-gadget->Width+TBGADGETOFFSET:0,
IM_LOCK,
GAD_LOCK)))
{
// Chain gadgets
if (gadget) gadget->NextGadget=lock_gad;
else gadget=lock_gad;
// Fix selection flags
lock_gad->Activation|=GACT_TOGGLESELECT;
if (lister->more_flags&LISTERF_LOCK_FORMAT)
lock_gad->Flags|=GFLG_SELECTED;
}
// Open lister window
if (!(lister->window=OpenWindowTags(0,
WA_Left,dims->Left,
WA_Top,dims->Top,
WA_Width,dims->Width,
WA_Height,dims->Height,
WA_MinWidth,lister->win_limits.Left,
WA_MinHeight,lister->win_limits.Top,
WA_MaxWidth,(ULONG)~0,
WA_MaxHeight,(ULONG)~0,
(lister->dimensions.wd_Flags&WDF_VALID)?WA_Zoom:TAG_IGNORE,(ULONG)&lister->dimensions.wd_Zoomed,
WA_IDCMP,
IDCMP_ACTIVEWINDOW|
IDCMP_CHANGEWINDOW|
IDCMP_CLOSEWINDOW|
IDCMP_GADGETDOWN|
IDCMP_GADGETUP|
IDCMP_INACTIVEWINDOW|
IDCMP_MENUHELP|
IDCMP_MENUPICK|
IDCMP_MENUVERIFY|
IDCMP_MOUSEBUTTONS|
IDCMP_MOUSEMOVE|
#ifdef __amigaos4__
IDCMP_EXTENDEDMOUSE|
#endif
IDCMP_NEWSIZE|
IDCMP_REFRESHWINDOW|
IDCMP_RAWKEY,
WA_AutoAdjust,TRUE,
WA_CloseGadget,!(lister->flags&LISTERF_LOCK_POS),
WA_DragBar,!(lister->flags&LISTERF_LOCK_POS),
WA_DepthGadget,TRUE,
WA_MenuHelp,TRUE,
WA_NewLookMenus,TRUE,
WA_SizeGadget,TRUE,
WA_SizeBRight,TRUE,
WA_SizeBBottom,TRUE,
WA_CustomScreen,screen,
WA_ScreenTitle,GUI->screen_title,
WA_WindowName, DOPUS_WIN_NAME,
WA_Gadgets,gadget,
mode,TRUE,
(lister->flags&LISTERF_LOCK_POS)?WA_Title:TAG_IGNORE,"",
WA_BackFill,&lister->pattern,
TAG_END))) return 0;
// Fix title gadgets
FixTitleGadgets(lister->window);
// Save left border
lister->old_border_left=lister->window->BorderLeft;
// Initialise ID
SetWindowID(lister->window,&lister->id,WINDOW_LISTER,(struct MsgPort *)lister->ipc);
// Initialise dimensions
InitWindowDims(lister->window,&lister->dimensions);
// Close existing font
if (lister->font) CloseFont(lister->font);
// Clear proportional font flag
lister->more_flags&=~LISTERF_PROP_FONT;
// Open font
if ((lister->font=OpenDiskFont(&lister->lister_font)))
{
// Proportional font?
if (lister->font->tf_Flags&FPF_PROPORTIONAL)
{
lister->more_flags|=LISTERF_PROP_FONT;
}
}
// Got a font?
if (lister->font)
{
// Set font in window and text area
SetFont(lister->window->RPort,lister->font);
SetFont(&lister->text_area.rast,lister->font);
}
// Otherwise, get info on default font
else
{
// Get font info
AskFont(lister->window->RPort,&lister->lister_font);
}
// Get DrawInfo
lister->drawinfo=GetScreenDrawInfo(lister->window->WScreen);
// Set menus
display_get_menu(lister->window);
display_fix_menu(
lister->window,
(lister->flags&LISTERF_VIEW_ICONS)?WINDOW_LISTER_ICONS:WINDOW_LISTER,
lister);
lister_fix_menus(lister,0);
// Initialise backdrop info
backdrop_init_info(lister->backdrop_info,lister->window,0);
// Turn on gauge if needed
lister_set_gauge(lister,FALSE);
// Fill out size covering gadget
if ((gadget=FindGadgetType(lister->window->FirstGadget,GTYP_SIZING)))
{
// Copy size gadget
fill_out_cover_gadget(gadget,&lister->size_cover_gadget);
// Clear image in original gadget if lister is locked
if (lister->flags&LISTERF_LOCK_POS)
{
gadget->Flags&=~GFLG_GADGIMAGE;
gadget->GadgetRender=0;
}
}
// Fill out zoom covering gadget
if ((gadget=FindGadgetType(lister->window->FirstGadget,GTYP_WZOOM)))
{
// Copy zoom gadget
fill_out_cover_gadget(gadget,&lister->zoom_cover_gadget);
// Clear image in original gadget if lister is locked
if (lister->flags&LISTERF_LOCK_POS)
{
// Clear image in original gadget
gadget->Flags&=~GFLG_GADGIMAGE;
gadget->GadgetRender=0;
}
// Otherwise, change gadget type
else
{
// Clear zoom flag, set ID
gadget->GadgetType&=~(GTYP_SYSTYPEMASK|GTYP_SYSGADGET);
gadget->GadgetID=GAD_ZOOM;
}
}
// Is lister locked?
if (lister->flags&LISTERF_LOCK_POS)
{
// Add to window
lister->size_cover_gadget.NextGadget=0;
AddGList(lister->window,&lister->size_cover_gadget,0,1,0);
RefreshWindowFrame(lister->window);
}
// Fix next pointer
else lister->size_cover_gadget.NextGadget=&lister->zoom_cover_gadget;
// Create edit hook
lister->path_edit_hook=
GetEditHookTags(
0,
OBJECTF_NO_SELECT_NEXT,
GTCustom_History,lister->path_history,
TAG_END);
// Create path field
if (!(lister->path_field=(struct Gadget *)
NewObject(0,"dopusstrgclass",
GA_ID,GAD_PATH,
GA_Left,lister->window->BorderLeft,
GA_RelBottom,-(lister->window->BorderBottom+FIELD_FONT->tf_YSize+4),
GA_RelWidth,-(lister->window->BorderLeft+lister->window->BorderRight),
GA_Height,FIELD_FONT->tf_YSize+4,
GA_RelVerify,TRUE,
GA_Immediate,TRUE,
GTCustom_ThinBorders,TRUE,
GTCustom_NoGhost,TRUE,
STRINGA_TextVal,(lister->cur_buffer)?lister->cur_buffer->buf_Path:"",
STRINGA_MaxChars,511,
STRINGA_Buffer,lister->path_buffer,
STRINGA_UndoBuffer,GUI->global_undo_buffer,
STRINGA_WorkBuffer,GUI->global_undo_buffer+512,
STRINGA_Font,FIELD_FONT,
STRINGA_EditHook,lister->path_edit_hook,
TAG_END)))
{
lister_close(lister,0);
return 0;
}
DoMethod((Object *)lister->path_field,OM_ADDTAIL,&lister->backdrop_info->boopsi_list);
// Initialise side parent button
lister->parent_button.NextGadget=lister->path_field;
lister->parent_button.TopEdge=lister->window->BorderTop;
lister->parent_button.Width=lister->window->BorderLeft;
lister->parent_button.Height=-(lister->window->BorderTop+lister->window->BorderBottom);
lister->parent_button.Flags=GFLG_GADGHCOMP|GFLG_RELHEIGHT;
lister->parent_button.Activation=GACT_RELVERIFY;
lister->parent_button.GadgetType=GTYP_BOOLGADGET;
lister->parent_button.GadgetID=GAD_PARENT;
// Try to add AppWindow
lister->appwindow=AddAppWindowA(
WINDOW_LISTER,
(ULONG)lister,
lister->window,
lister->app_port,0);
// Is lister busy?
if (lister->flags&LISTERF_BUSY || lister->old_flags&LISTERF_BUSY)
{
lister->flags&=~(LISTERF_BUSY|LISTERF_LOCK|LISTERF_LOCKED);
lister_busy(lister,0);
}
else
if (lister->flags&LISTERF_LOCKED || lister->old_flags&LISTERF_LOCKED)
{
lister->flags&=~(LISTERF_BUSY|LISTERF_LOCK|LISTERF_LOCKED);
lister_busy(lister,1);
}
// Initialise lister flags
lister->flags&=
LISTERF_LOCK_POS|LISTERF_BUSY|
LISTERF_LOCK|LISTERF_LOCKED|
LISTERF_VIEW_ICONS|LISTERF_SHOW_ALL|LISTERF_PATH_FIELD|
LISTERF_STORED_SOURCE|LISTERF_STORED_DEST|LISTERF_ICON_ACTION|
LISTERF_FIRST_TIME;
lister->more_flags&=~LISTERF_TITLEBARRED;
// Update selection count if in icon mode
if (lister->flags&LISTERF_ICON_ACTION)
backdrop_fix_count(lister->backdrop_info,0);
// Initialise cursor setting
lister->cursor_line=-1;
lister->edit_type=-1;
// Setup lister display
lister_init_display(lister);
lister_refresh(lister,LREFRESH_FULL);
lister_refresh_name(lister);
// Clear old flags
lister->old_flags=0;
// Is this our first time open?
if (lister->flags&LISTERF_FIRST_TIME)
{
char buf[16];
// Build handle string
lsprintf(buf,"%ld",lister);
// Launch script
RunScript(SCRIPT_OPEN_LISTER,buf);
}
// If busy, show progress window
if (lister->progress_window)
ShowProgressWindow(lister->progress_window,0,lister->window);
// Fix current directory
lister_fix_cd(lister);
// Initialise things
lister->title_click=-1;
// Return window pointer
return lister->window;
}
