// Save from button editor
void buttons_edit_defaults(ULONG id)
{
IPCData *ipc;
// Lock buttons list
lock_listlock(&GUI->buttons_list,FALSE);
// Go through button banks
for (ipc=(IPCData *)GUI->buttons_list.list.lh_Head;
ipc->node.mln_Succ;
ipc=(IPCData *)ipc->node.mln_Succ)
{
// Get buttons pointer
Buttons *buttons=IPCDATA(ipc);
// Is this the bank being edited, and is it a toolbar?
if (buttons->editor && buttons->flags&BUTTONF_TOOLBAR)
{
// Send command to button bank
IPC_Command(buttons->ipc,id,0,0,0,0);
break;
}
}
// Unlock buttons list
unlock_listlock(&GUI->buttons_list);
}
// Save from button editor
void buttons_edit_save(ULONG id)
{
IPCData *ipc;
// Lock buttons list
lock_listlock(&GUI->buttons_list,FALSE);
// Go through button banks
for (ipc=(IPCData *)GUI->buttons_list.list.lh_Head;
ipc->node.mln_Succ;
ipc=(IPCData *)ipc->node.mln_Succ)
{
// Get buttons pointer
Buttons *buttons=IPCDATA(ipc);
// Is this the bank being edited?
if (buttons->editor)
{
// Send command to button bank
IPC_Command(
buttons->ipc,
(id==BUTTONEDIT_MENU_SAVE)?BUTTONS_SAVE:BUTTONS_SAVEAS,
0,
0,
0,
0);
break;
}
}
// Unlock buttons list
unlock_listlock(&GUI->buttons_list);
}
// Update size for a backdrop
void backdrop_update_size(BackdropInfo *info)
{
// Check new size
backdrop_check_size(info);
// Set flag to say we have a new size
info->flags|=BDIF_NEW_SIZE;
// Centered pattern?
if (info->window->WLayer->BackFill!=LAYERS_BACKFILL &&
GUI->pattern &&
GUI->pattern[(info->flags&BDIF_MAIN_DESKTOP)?WBP_ROOT:WBP_DRAWER].flags&PATF_CENTER)
{
// Signal full refresh
IPC_Command(info->ipc,LISTER_BACKFILL_CHANGE,1,0,0,0);
}
// Smart-refresh?
else
if (info->window->WLayer->Flags&LAYERSMART)
{
// Refresh objects immediately
backdrop_show_objects(info,BDSF_REFRESH_DONE|BDSF_RECALC);
info->flags&=~BDIF_NEW_SIZE;
}
}
// Handles key press in edit mode
void buttons_edit_key(Buttons *buttons,USHORT code,USHORT qual)
{
// Look at key
switch (code)
{
// Cursor to move
case CURSORLEFT:
case CURSORRIGHT:
case CURSORUP:
case CURSORDOWN:
// Is the editor running?
if (buttons->editor)
{
// Send key to the editor
IPC_Command(
buttons->editor,
BUTTONEDIT_PROCESS_KEY,
code,
(APTR)qual,
0,
0);
}
break;
// Enter edits
case 0x44:
// Is the editor running?
if (buttons->editor)
{
// Send edit command
IPC_Command(
buttons->editor,
BUTTONEDIT_EDIT_BUTTON,
buttons->editor_sel_col,
(APTR)buttons->editor_sel_row,
0,
0);
}
break;
}
}
// Someone pressed the help key
void help_get_help(short x,short y,unsigned short qual)
{
struct Window *window=0;
struct Layer *layer;
IPCData *ipc=0;
// Lock screen layer
LockLayerInfo(&GUI->screen_pointer->LayerInfo);
// Find which layer the mouse is over
if ((layer=WhichLayer(&GUI->screen_pointer->LayerInfo,x,y)))
{
// Get window pointer
window=layer->Window;
// Get window ID
if (GetWindowID(window)!=WINDOW_UNKNOWN)
{
// Forbid to get port
Forbid();
// Get port
if (!(ipc=(IPCData *)GetWindowAppPort(window)))
Permit();
}
}
// Unlock layer
UnlockLayerInfo(&GUI->screen_pointer->LayerInfo);
// Got a port?
if (ipc)
{
ULONG coords;
// Convert coordinates to window-relative
x-=window->LeftEdge;
y-=window->TopEdge;
// Pack into longword
coords=((unsigned short)x<<16)|(unsigned short)y;
// Send help command
IPC_Command(ipc,IPC_HELP,qual,(APTR)coords,0,0);
// Enable multitasking now that message has been sent
Permit();
}
// Otherwise, show generic help
else help_show_help(HELP_MAIN,0);
}
void UseIPC(void) /* ROM patch: executing IPC command */
{
if((Ptr)gPC-(Ptr)theROM-2==IPC_CMD_ADDR)
{ if(IPC_Command()) rts();
else table[code=0x40e7]();
}
else
{ exception=4;
extraFlag=true;
nInst2=nInst;
nInst=0;
}
}
// Send reset command to main process
void send_main_reset_cmd(ULONG flags1,ULONG flags2,APTR data)
{
ULONG *flags;
// Allocate flags
if ((flags=AllocVec(sizeof(ULONG)*2,0)))
{
// Fill out flags
flags[0]=flags1;
flags[1]=flags2;
// Send command
IPC_Command(&main_ipc,MAINCMD_RESET,0,data,flags,0);
}
}
// Signal with pattern update
void display_update_pattern(short which,short valid)
{
// Main pattern changed?
if (which==PATTERN_MAIN)
{
// Send refresh command
IPC_Command(&main_ipc,LISTER_BACKFILL_CHANGE,valid,0,0,REPLY_NO_PORT);
}
// Redraw listers and groups if they need it
else
if (which==PATTERN_LISTER)
{
IPC_ListCommand(&GUI->lister_list,LISTER_BACKFILL_CHANGE,valid,0,TRUE);
IPC_ListCommand(&GUI->group_list,LISTER_BACKFILL_CHANGE,valid,0,TRUE);
}
}
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;
}
Cfg_Filetype *LIBFUNC L_EditFiletype(
REG(a0, Cfg_Filetype *type),
REG(a1, struct Window *window),
REG(a2, IPCData *ipc),
REG(a3, IPCData *dopus_ipc),
REG(d0, ULONG flags))
{
filetype_ed_data *data;
IPCData *editor;
IPCMessage *imsg;
Cfg_Filetype *ret_type=0;
// Valid filetype?
if (!type) return 0;
// Allocate data for the editor, copy filetype
if (!(data=AllocVec(sizeof(filetype_ed_data),MEMF_CLEAR)) ||
!(data->type=CopyFiletype(type,0)))
{
FreeVec(data);
return 0;
}
// Fill out data
data->owner_ipc=ipc;
data->action_lookup=filetype_action_lookup;
// Supply libraries
/*data->func_startup.dopus_base=DOpusBase;
data->func_startup.dos_base=(struct Library *)DOSBase;
data->func_startup.int_base=(struct Library *)IntuitionBase;
data->func_startup.util_base=(struct Library *)UtilityBase;
data->func_startup.cx_base=CxBase;
data->func_startup.wb_base=WorkbenchBase;
data->func_startup.gfx_base=(struct Library *)GfxBase;
data->func_startup.asl_base=AslBase;
data->func_startup.layers_base=LayersBase;*/
// Supply locale
data->func_startup.locale=locale;
// Supply gui data pointers
data->new_win.parent=window;
data->new_win.dims=&_filetype_editor_window;
data->new_win.locale=locale;
data->obj_def=_filetype_editor_objects;
// Supply data pointers for function editor
data->func_startup.win_def=&_function_editor_window;
data->func_startup.obj_def=_function_editor_objects;
data->func_startup.func_labels=_function_type_labels;
data->func_startup.flag_list=_funced_flaglist;
data->func_startup.func_list=IPC_Command(dopus_ipc,MAINCMD_GET_LIST,0,0,0,REPLY_NO_PORT);
data->func_startup.flags=FUNCEDF_NO_KEY;
data->func_startup.main_owner=ipc;
// Supply data pointers for the fileclass editor
data->class_win=&_fileclass_editor_window;
data->class_obj=_fileclass_editor_objects;
data->class_lookup=fileclass_match_lookup;
data->class_strings=matchtype_labels;
// Open class editor automatically?
if (flags&EFTF_EDIT_CLASS) data->edit_flag=1;
// Launch editor
if (!(IPC_Launch(
0,
&editor,
"dopus_filetype_editor",
(ULONG)IPC_NATIVE(FiletypeEditor),
STACK_DEFAULT,
(ULONG)data,
(struct Library *)DOSBase)) || !editor)
{
// Failed; free data
FreeFiletype(data->type);
FreeVec(data);
return 0;
}
// Event loop
FOREVER
{
BOOL quit=0;
// IPC messages
while ((imsg=(IPCMessage *)GetMsg(ipc->command_port)))
{
// Filetype returned?
if (imsg->command==FILETYPEEDIT_RETURN)
{
// Copy the filetype
ret_type=CopyFiletype((Cfg_Filetype *)imsg->flags,0);
}
// Said goodbye?
else
if (imsg->command==IPC_GOODBYE && imsg->data==editor)
quit=1;
// Abort?
else
if (imsg->command==IPC_QUIT)
{
// Send abort message
IPC_Quit(editor,imsg->flags,TRUE);
}
// Activate?
else
if (imsg->command==IPC_ACTIVATE)
{
// Send message
IPC_Command(editor,IPC_ACTIVATE,imsg->flags,imsg->data,0,0);
}
// Identify?
else
if (imsg->command==IPC_IDENTIFY)
{
// Pass to DOpus
IPC_Command(dopus_ipc,IPC_IDENTIFY,imsg->flags,imsg->data,0,REPLY_NO_PORT);
}
// Reply to message
IPC_Reply(imsg);
}
// Check quit flag
if (quit) break;
// Wait for message
WaitPort(ipc->command_port);
}
// Return new filetype (if any)
return ret_type;
}
void desktop_delete(IPCData *ipc,BackdropInfo *info,BackdropObject *only_one)
{
short groupcount=0,filecount=0,assigncount=0,othercount=0,dircount=0;
BackdropObject *object=0;
Att_List *list;
Att_Node *node;
char buf[100];
// Create list
if (!(list=Att_NewList(LISTF_POOL)))
return;
// Lock backdrop list
lock_listlock(&info->objects,0);
// Go through backdrop list
while ((object=backdrop_next_object(info,object,only_one)))
{
// Group?
if (object->type==BDO_GROUP) ++groupcount;
// Assign?
else
if (object->flags&BDOF_ASSIGN) ++assigncount;
// Group object?
else
if (object->type==BDO_LEFT_OUT && info->flags&BDIF_GROUP) ++filecount;
// Desktop object?
else
if (object->type==BDO_LEFT_OUT && object->flags&BDOF_DESKTOP_FOLDER)
{
++othercount;
if (object->icon->do_Type==WBDRAWER) ++dircount;
}
// Something else
else continue;
// Add to list
Att_NewNode(list,0,(ULONG)object,0);
}
// Unlock backdrop list
unlock_listlock(&info->objects);
// Nothing to delete?
if (IsListEmpty((struct List *)list))
{
Att_RemList(list,0);
return;
}
// Build message; start with query
strcpy(info->buffer,GetString(&locale,MSG_DESKTOP_REALLY_DELETE));
// Any groups?
if (groupcount>0)
{
lsprintf(buf,GetString(&locale,MSG_DESKTOP_DELETE_GROUPS),groupcount);
strcat(info->buffer,buf);
}
// Or assigns?
else
if (assigncount>0)
{
lsprintf(buf,GetString(&locale,MSG_DESKTOP_DELETE_ASSIGNS),assigncount);
strcat(info->buffer,buf);
}
// Any group files?
else
if (filecount>0)
{
// Add file count
lsprintf(buf,GetString(&locale,MSG_DESKTOP_DELETE_GROUP_OBJECTS),filecount);
strcat(info->buffer,buf);
}
// Desktop objects?
if (othercount>0)
{
BOOL cr=0;
// Add CR?
if (groupcount>0 || assigncount>0 || filecount>0) cr=1;
// Add files
if (othercount>dircount)
{
lsprintf(buf,GetString(&locale,MSG_DESKTOP_DELETE_DESKTOP_FILES),othercount-dircount);
if (cr) strcat(info->buffer,"\n");
strcat(info->buffer,buf);
cr=1;
}
// Add dirs
if (dircount>0)
{
lsprintf(buf,GetString(&locale,MSG_DESKTOP_DELETE_DESKTOP_DIRS),dircount);
if (cr) strcat(info->buffer,"\n");
strcat(info->buffer,buf);
}
}
// Add question mark
strcat(info->buffer,"?");
// Display requester
if (!(super_request_args(
GUI->screen_pointer,
info->buffer,
SRF_IPC|SRF_SCREEN_PARENT,
ipc,
GetString(&locale,MSG_DELETE),
GetString(&locale,MSG_CANCEL),0)))
{
Att_RemList(list,0);
return;
}
// Check owner for refresh
if (info->lister)
IPC_Command(info->lister->ipc,LISTER_CHECK_REFRESH,0,0,0,REPLY_NO_PORT);
// Group objects?
if (info->flags&BDIF_GROUP)
{
// Send command to group
IPC_Command(info->ipc,GROUP_DELETE,0,only_one,0,0);
}
// Otherwise
else
{
// Go through the list
for (node=(Att_Node *)list->list.lh_Head;
node->node.ln_Succ;
node=(Att_Node *)node->node.ln_Succ)
{
// Lock backdrop list
lock_listlock(&info->objects,1);
// Get object
if ((object=find_backdrop_object(info,(BackdropObject *)node->data)))
{
// Group?
if (object->type==BDO_GROUP)
{
// Delete this group
backdrop_delete_group(info,object);
}
// Assign?
else
if (object->flags&BDOF_ASSIGN)
{
// Copy name, strip trailing colon
strcpy(info->buffer+2,object->name);
info->buffer[strlen(info->buffer+2)+1]=0;
// Delete assign
if (AssignLock(info->buffer+2,0))
{
// Erase object
backdrop_erase_icon(info,object,0);
// Remove object
backdrop_remove_object(info,object);
}
}
}
// Unlock backdrop list
unlock_listlock(&info->objects);
}
}
// Free list
Att_RemList(list,0);
// Recalc backdrop objects
backdrop_calc_virtual(info);
// Delete other things?
if (othercount>0)
{
// Run delete function
icon_function(info,0,0,def_function_delete_quiet,0);
}
}
// Show help on something
void help_show_help(char *thing,char *file)
{
IPCData *ipc;
char *copy,*ptr,helpbuf[256];
CommandList *cmd;
// Valid thing?
if (!thing || !*thing) return;
// Can't do help if we don't have the amigaguide.library
if (!AmigaGuideBase)
{
// Flash error and return
DisplayBeep(GUI->screen_pointer);
return;
}
// Is the node name a command?
ptr=thing;
if (!file && (cmd=function_find_internal(&ptr,0)))
{
// Is this an external module that has help available?
if (cmd->flags&FUNCF_EXTERNAL_FUNCTION &&
cmd->help_name)
{
// Build full path to help file
strcpy(helpbuf,"dopus5:help/");
AddPart(helpbuf,FilePart(cmd->help_name),256);
// Use this file for help
file=helpbuf;
}
}
// Lock process list
lock_listlock(&GUI->process_list,FALSE);
// Is help process running?
if (!(ipc=IPC_FindProc(&GUI->process_list,"dopus_help",0,0)))
{
// Unlock process list
unlock_listlock(&GUI->process_list);
// Launch help process
if (!(IPC_Launch(
&GUI->process_list,
&ipc,
"dopus_help",
(ULONG)&help_proc,
STACK_DEFAULT,
0,
(struct Library *)DOSBase)))
{
// Couldn't launch it
return;
}
// Lock process list
lock_listlock(&GUI->process_list,FALSE);
}
// No file given?
if (!file || !*file) file="dopus5:Help/dopus5.guide";
// Copy thing
if (ipc && (copy=AllocVec(strlen(thing)+1+strlen(file)+1,0)))
{
// Copy thing and file string
strcpy(copy,thing);
strcpy(copy+strlen(copy)+1,file);
// Send help command
IPC_Command(ipc,HELPCMD_LINK,0,0,copy,0);
}
// Unlock process list
unlock_listlock(&GUI->process_list);
}
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;
}
// Load a new bank into open buttons window
void buttons_new_bank(Buttons *buttons,short func,Cfg_ButtonBank *use_bank)
{
Cfg_ButtonBank *bank;
IPCData *ipc;
// Check for change
if (!buttons_check_change(buttons,1)) return;
// Save old bank pointer
bank=buttons->bank;
// New?
if (func==MENU_TOOLBAR_BUTTONS_NEW)
{
// Create new button bank
if (!(buttons->bank=NewButtonBank(1,1)))
{
// Restore old pointer
buttons->bank=bank;
return;
}
// Free old bank
CloseButtonBank(bank);
}
// Load?
else
if (func==MENU_OPEN_BUTTONS_LOCAL)
{
// Open button bank
if (!(buttons_load(buttons,GUI->screen_pointer,0)))
return;
}
// Defaults
else
if (func==MENU_TOOLBAR_RESET_DEFAULTS)
{
// Open button bank
if (!(buttons_load(buttons,GUI->screen_pointer,"dopus5:buttons/toolbar_default")))
return;
}
// Restore
else
if (func==MENU_TOOLBAR_RESTORE)
{
// Copy backup bank
if (!(buttons->bank=CopyButtonBank(buttons->backup)))
{
// Restore old pointer
buttons->bank=bank;
return;
}
// Free old bank
CloseButtonBank(bank);
}
// Last saved
else
if (buttons->last_saved[0])
{
// Open button bank
if (!(buttons_load(buttons,GUI->screen_pointer,buttons->last_saved)))
return;
}
// Lock process list
lock_listlock(&GUI->process_list,FALSE);
// Find editor
if ((ipc=IPC_FindProc(&GUI->process_list,NAME_BUTTON_EDITOR_RUN,0,0)))
{
// Set flag in bank
buttons->bank->window.flags|=BTNWF_TOOLBAR;
// Tell editor to change bank pointer
IPC_Command(
buttons->editor,
BUTTONEDIT_CHANGE_BANK,
(ULONG)bank,
buttons->bank,
0,
REPLY_NO_PORT);
}
// Unlock the process list
unlock_listlock(&GUI->process_list);
// Signal for re-open
IPC_Command(buttons->ipc,BUTTONEDIT_REOPEN,0,0,0,0);
// Clear change flag
buttons->flags&=~BUTTONF_CHANGED;
}
// Change volume name of a disk in buffers
void notify_disk_name_change(
BackdropInfo *info,
char *device,
char *new_volume)
{
IPCData *ipc;
Lister *lister;
DirBuffer *buffer;
char *ptr;
// Get list lock
lock_listlock(&GUI->buffer_list,FALSE);
// Go through all buffers
for (buffer=(DirBuffer *)GUI->buffer_list.list.lh_Head;
buffer->node.ln_Succ;
buffer=(DirBuffer *)buffer->node.ln_Succ)
{
// Correct disk?
if (strnicmp(device,buffer->buf_Path,strlen(device))==0)
{
// Change volume name
strcpy(buffer->buf_VolumeLabel,new_volume);
// Get new full path
strcpy(buffer->buf_ExpandedPath,new_volume);
if ((ptr=strchr(buffer->buf_Path,':')))
strcat(buffer->buf_ExpandedPath,ptr);
// Is buffer currently displayed in a lister?
if (buffer->buf_CurrentLister)
{
// Refresh path
IPC_Command(buffer->buf_CurrentLister->ipc,LISTER_REFRESH_PATH,0,0,0,0);
}
}
}
// Free list lock
unlock_listlock(&GUI->buffer_list);
// Lock lister list
lock_listlock(&GUI->lister_list,FALSE);
// Go through listers
for (ipc=(IPCData *)GUI->lister_list.list.lh_Head;
ipc->node.mln_Succ;
ipc=(IPCData *)ipc->node.mln_Succ)
{
// Get lister pointer
lister=(Lister *)IPCDATA(ipc);
// Is lister a device list?
if (lister->cur_buffer->more_flags&DWF_DEVICE_LIST)
{
// Check it's not our current backdrop
if (lister->backdrop_info!=info)
{
devname_change *change;
// Allocate data structure
if ((change=AllocVec(sizeof(devname_change),MEMF_CLEAR)))
{
// Fill it out
strcpy(change->old_name,device);
strcpy(change->new_name,new_volume);
// Signal it to update the name of the device
IPC_Command(
ipc,
LISTER_UPDATE_DEVICE,
0,
0,
change,
0);
}
}
}
}
// Unlock lister list
unlock_listlock(&GUI->lister_list);
// Have to update main window?
if (info!=GUI->backdrop)
{
devname_change change;
// Fill in change packet
strcpy(change.old_name,device);
strcpy(change.new_name,new_volume);
// Update name
backdrop_update_disk(GUI->backdrop,&change,TRUE);
}
}
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 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);
}
// Open a group
void backdrop_open_group(BackdropInfo *info,BackdropObject *object,BOOL activate)
{
GroupData *group;
IPCData *ipc=0;
// Valid object?
if (!object || !object->icon || object->icon->do_Type!=WBDRAWER) return;
// See if it's already open
lock_listlock(&GUI->group_list,0);
if (group=backdrop_find_group(object))
{
// Send activate message
if (activate) IPC_Command(group->ipc,IPC_ACTIVATE,0,0,0,0);
}
unlock_listlock(&GUI->group_list);
// If it was open, return
if (group) return;
// Allocate group packet
if (!(group=AllocVec(sizeof(GroupData),MEMF_CLEAR)))
return;
// Fill in group packet
group->screen=info->window->WScreen;
if (object->icon->do_DrawerData)
group->dimensions=*((struct IBox *)&object->icon->do_DrawerData->dd_NewWindow.LeftEdge);
else
{
group->dimensions.Left=20;
group->dimensions.Top=20;
group->dimensions.Width=200;
group->dimensions.Height=150;
}
strcpy(group->name,object->name);
group->object=object;
// Initialise popup menu
if (group->popup=PopUpNewHandle(0,0,&locale))
{
// Add items
PopUpNewItem(group->popup,MSG_ICON_SNAPSHOT_MENU,MENU_ICON_SNAPSHOT_WINDOW,0);
PopUpNewItem(group->popup,MSG_ICON_CLEANUP,MENU_ICON_CLEANUP,0);
}
// Launch process
IPC_Launch(
&GUI->group_list,
&ipc,
"dopus_group",
(ULONG)backdrop_group_handler,
STACK_DEFAULT,
(ULONG)group,(struct Library *)DOSBase);
// Failed?
if (!ipc)
{
// Free
PopUpFreeHandle(group->popup);
FreeVec(group);
}
}
// Read an environment
BOOL environment_open(Cfg_Environment *env,char *name,BOOL first,APTR prog)
{
struct OpenEnvironmentData *opendata;
BOOL success;
short progress=1;
// Free volatile memory
ClearMemHandle(env->volatile_memory);
// Initialise open structure
if (!(opendata=AllocMemH(env->volatile_memory,sizeof(struct OpenEnvironmentData))))
return 0;
opendata->memory=env->desktop_memory;
opendata->volatile_memory=env->volatile_memory;
opendata->flags=OEDF_ALL;
// Initialise progress
SetProgressWindowTags(prog,PW_FileCount,14,PW_FileNum,1,TAG_END);
// Read environment
if ((success=OpenEnvironment((name)?name:env->path,opendata)))
{
// Check stack setting and increase if too low
if (opendata->env.default_stack < STACK_DEFAULT)
opendata->env.default_stack = STACK_DEFAULT;
// Copy things back to the environment
CopyMem((char *)&opendata->env,(char *)env->env,sizeof(CFG_ENVR));
strcpy(env->toolbar_path,opendata->toolbar_path);
strcpy(env->menu_path,opendata->menu_path);
strcpy(env->user_menu_path,opendata->user_menu_path);
strcpy(env->scripts_path,opendata->scripts_path);
strcpy(env->hotkeys_path,opendata->hotkeys_path);
// Get maximum filename length
// we have to do this before the listers are opened
GUI->def_filename_length=environment->env->settings.max_filename;
if (GUI->def_filename_length<FILENAME_LEN)
GUI->def_filename_length=FILENAME_LEN;
else
if (GUI->def_filename_length>107)
GUI->def_filename_length=107;
}
// Successful?
if (success || first)
{
ButtonBankNode *button;
OpenListerNode *lister;
// Bump progress
main_bump_progress(prog,progress++,0);
// Store new environment path
if (name) strcpy(env->path,name);
// Bump progress
main_bump_progress(prog,progress++,0);
// Get new toolbar
FreeToolBar(GUI->toolbar);
GUI->toolbar=OpenToolBar(0,env->toolbar_path);
// Bump progress
main_bump_progress(prog,progress++,0);
// Free lister menu, get new one
CloseButtonBank(GUI->lister_menu);
if ((GUI->lister_menu=OpenButtonBank(env->menu_path)))
{
// Check if it needs conversion
if (!(GUI->lister_menu->window.flags&BTNWF_FIX_MENU))
{
// Convert it to new format
ConvertStartMenu(GUI->lister_menu);
GUI->lister_menu->window.flags|=BTNWF_FIX_MENU;
}
}
// Bump progress
main_bump_progress(prog,progress++,0);
// Free user menu, get new one
CloseButtonBank(GUI->user_menu);
GUI->user_menu=OpenButtonBank(env->user_menu_path);
// Bump progress
main_bump_progress(prog,progress++,0);
// Free scripts, get new set
CloseButtonBank(GUI->scripts);
GUI->scripts=OpenButtonBank(env->scripts_path);
// Bump progress
main_bump_progress(prog,progress++,0);
// Free hotkeys, get new ones
send_main_reset_cmd(CONFIG_CHANGE_HOTKEYS,0,0);
// Go through buttons to open
for (button=(ButtonBankNode *)opendata->buttons.mlh_Head;
button->node.ln_Succ;)
{
ButtonBankNode *next=(ButtonBankNode *)button->node.ln_Succ;
Buttons *but;
// Create button bank from this node
if ((but=buttons_new(button->node.ln_Name,0,&button->pos,0,button->flags|BUTTONF_FAIL)))
{
// Set icon position
but->icon_pos_x=button->icon_pos_x;
but->icon_pos_y=button->icon_pos_y;
}
// Free this node, get next
Remove((struct Node *)button);
FreeMemH(button->node.ln_Name);
FreeMemH(button);
button=next;
}
// Bump progress
main_bump_progress(prog,progress++,0);
// Go through StartMenus to open
for (button=(ButtonBankNode *)opendata->startmenus.mlh_Head;
button->node.ln_Succ;)
{
ButtonBankNode *next=(ButtonBankNode *)button->node.ln_Succ;
// Create new start menu
start_new(button->node.ln_Name,0,0,button->pos.Left,button->pos.Top);
// Free this node, get next
Remove((struct Node *)button);
FreeMemH(button->node.ln_Name);
FreeMemH(button);
button=next;
}
// Bump progress
main_bump_progress(prog,progress++,0);
// Go through listers to open
for (lister=(OpenListerNode *)opendata->listers.mlh_Head;
lister->node.ln_Succ;)
{
OpenListerNode *next=(OpenListerNode *)lister->node.ln_Succ;
// Create lister from this node
if (lister->lister)
lister_new((Cfg_Lister *)lister->lister);
// Free this node, get next
Remove((struct Node *)lister);
FreeMemH(lister);
lister=next;
}
// Bump progress
main_bump_progress(prog,progress++,0);
// Free existing desktop list
env_free_desktop(&env->desktop);
// Copy new desktop into list
if (!(IsListEmpty((struct List *)&opendata->desktop)))
{
env->desktop=opendata->desktop;
env->desktop.mlh_TailPred->mln_Succ=(struct MinNode *)&env->desktop.mlh_Tail;
env->desktop.mlh_Head->mln_Pred=(struct MinNode *)&env->desktop.mlh_Head;
}
// Free existing path list
env_free_desktop(&env->path_list);
// Copy new pathlist into list
if (!(IsListEmpty((struct List *)&opendata->pathlist)))
{
env->path_list=opendata->pathlist;
env->path_list.mlh_TailPred->mln_Succ=(struct MinNode *)&env->path_list.mlh_Tail;
env->path_list.mlh_Head->mln_Pred=(struct MinNode *)&env->path_list.mlh_Head;
}
// Free existing sound list
env_free_desktop(&env->sound_list);
// Copy new sound list into list
if (!(IsListEmpty((struct List *)&opendata->soundlist)))
{
env->sound_list=opendata->soundlist;
env->sound_list.mlh_TailPred->mln_Succ=(struct MinNode *)&env->sound_list.mlh_Tail;
env->sound_list.mlh_Head->mln_Pred=(struct MinNode *)&env->sound_list.mlh_Head;
}
// Bump progress
main_bump_progress(prog,progress++,0);
// Update priority
IPC_Command(&main_ipc,
IPC_PRIORITY,
env->env->settings.pri_main[1],
(APTR)env->env->settings.pri_main[0],
0,0);
// Fix lister priorities
lister_fix_priority(0);
// Bump progress
main_bump_progress(prog,progress++,0);
}
// Failed, free temp lists
else
{
env_free_desktop(&opendata->desktop);
env_free_desktop(&opendata->pathlist);
env_free_desktop(&opendata->soundlist);
env_free_desktop(&opendata->startmenus);
env_free_desktop(&opendata->buttons);
env_free_desktop(&opendata->listers);
}
// Free open data structure
FreeMemH(opendata);
// Bump progress
main_bump_progress(prog,progress,0);
// Build the user menu (needed even if there is none)
display_build_user_menu();
// Initialise progress
SetProgressWindowTags(prog,PW_FileCount,1,PW_FileNum,1,TAG_END);
// Set library flag for 'Move AppIcons to Tools Menu'
SetLibraryFlags((env->env->display_options&DISPOPTF_SHIFT_APPICONS)?LIBDF_REDIRECT_TOOLS:0,LIBDF_REDIRECT_TOOLS);
// Set library flag for borderless icons
SetLibraryFlags((env->env->desktop_flags&DESKTOPF_NO_BORDERS)?LIBDF_BORDERS_OFF:0,LIBDF_BORDERS_OFF);
// No icon caching?
SetLibraryFlags((env->env->desktop_flags&DESKTOPF_NO_CACHE)?LIBDF_NO_CACHING:0,LIBDF_NO_CACHING);
// Set NewIcons flags
SetNewIconsFlags(env->env->env_NewIconsFlags,env->env->env_NewIconsPrecision);
// No custom drag?
SetLibraryFlags((env->env->desktop_flags&DESKTOPF_NO_CUSTOMDRAG)?LIBDF_NO_CUSTOM_DRAG:0,LIBDF_NO_CUSTOM_DRAG);
// Thin borders?
SetLibraryFlags((env->env->display_options&DISPOPTF_THIN_BORDERS)?LIBDF_THIN_BORDERS:0,LIBDF_THIN_BORDERS);
// Update pathlist environment variable
env_update_pathlist();
// Set popup delay
SetPopUpDelay(env->env->settings.popup_delay);
// Fix MUFS library
env_fix_mufs();
// Assign themes path
env_fix_themes();
// Initialise sound events
InitSoundEvents(TRUE);
return success;
}
// Stop dragging a button
void buttons_stop_drag(Buttons *buttons,short x,short y)
{
struct Layer *layer;
struct Window *window;
ULONG id=0;
BOOL swap_local=0;
IPCData *ipc=0;
BOOL ok=0;
// Free drag info
FreeDragInfo(buttons->drag_info);
buttons->drag_info=0;
// Nothing selected now
buttons->editor_sel_col=-1;
buttons->editor_sel_row=-1;
buttons->button_sel_button=0;
IPC_Command(
buttons->editor,
BUTTONEDIT_SELECT_BUTTON,
-1,
(APTR)-1,
0,
0);
// Invalid coordinates?
if (x==-1 || y==-1) return;
// Lock layer
LockScreenLayer(buttons->window->WScreen);
// Find which layer we dropped it on
if (layer=WhichLayer(
&buttons->window->WScreen->LayerInfo,
x+buttons->window->LeftEdge,
y+buttons->window->TopEdge))
{
// Does layer have a window?
if ((window=layer->Window))
{
// Is it our own window?
if (window==buttons->window)
{
// Set flag to swap with local button
swap_local=1;
}
else
{
// Get window ID
id=GetWindowID(window);
// Forbid to get IPC
Forbid();
if (!(ipc=(IPCData *)GetWindowAppPort(window)))
Permit();
}
}
}
// Unlock layer
UnlockScreenLayer(buttons->window->WScreen);
// Got an IPC port?
if (ipc)
{
// Button editor or another button bank?
if (id==WINDOW_BUTTON_CONFIG || id==WINDOW_BUTTONS || id==WINDOW_FUNCTION_EDITOR)
{
Cfg_Button *button;
Point *pos;
// Store position (screen relative)
if (pos=AllocVec(sizeof(Point),0))
{
pos->x=x+buttons->window->LeftEdge;
pos->y=y+buttons->window->TopEdge;
}
// Copy current button
if (button=CopyButton(buttons->button_drag_button,0,-1))
{
// Send button
IPC_Command(ipc,BUTTONEDIT_CLIP_BUTTON,0,button,pos,0);
ok=1;
}
}
// Permit now we've sent the message
Permit();
}
// Swapping local buttons?
else
if (swap_local)
{
Cfg_Button *swap;
// Lock bank
GetSemaphore(&buttons->bank->lock,SEMF_SHARED,0);
// Get swap button
if (swap=button_from_point(buttons,&x,&y))
{
// Different button?
if (swap!=buttons->button_drag_button)
{
// Swap buttons
SwapListNodes(
&buttons->bank->buttons,
(struct Node *)buttons->button_drag_button,
(struct Node *)swap);
// Redraw buttons
buttons_show_button(
buttons,
swap,
buttons->drag_col,
buttons->drag_row,
swap->current,0);
buttons_show_button(
buttons,
buttons->button_drag_button,
x,
y,
buttons->button_drag_button->current,0);
buttons->flags|=BUTTONF_CHANGED;
}
}
// Unlock bank
FreeSemaphore(&buttons->bank->lock);
ok=1;
}
// Failed?
if (!ok) DisplayBeep(buttons->window->WScreen);
}
// Open the button editor (called from a sub-process)
void buttons_edit(
IPCData *my_ipc,
buttons_edit_packet *packet)
{
ButtonsStartup startup;
struct Library *ConfigOpusBase;
IPCData *ipc;
long ret,command;
Buttons *buttons=0;
Cfg_Button *send_button=0;
struct AppMessage *send_msg=0;
short button_col=-1,button_row=-1;
short can_start=1;
// Get packet data
if (packet)
{
buttons=packet->buttons;
send_button=packet->edit;
button_col=packet->col;
button_row=packet->row;
can_start=packet->can_start;
send_msg=packet->appmsg;
}
// Lock process list
lock_listlock(&GUI->process_list,FALSE);
// Get edit command
command=(button_col==-2)?BUTTONEDIT_RE_EDIT_ME:BUTTONEDIT_EDIT_ME;
// See if button editor is running
if (ipc=IPC_FindProc(&GUI->process_list,NAME_BUTTON_EDITOR_RUN,FALSE,0))
{
BOOL front=1;
// Button bank supplied?
if (buttons)
{
// Does the bank not already have the editor?
if (!buttons->editor)
{
// Tell editor to edit the toolbar bank
IPC_Command(
ipc,
command,
(ULONG)buttons->bank,
buttons->ipc,
0,
0);
// Set flag for pending edit request
buttons->flags|=BUTTONF_EDIT_REQUEST;
front=0;
}
// Button to send?
if (send_button)
{
Point *pos;
// Allocate position
if (pos=AllocVec(sizeof(Point),MEMF_CLEAR))
{
// Convert coordinates to window relative
pos->x=button_col-buttons->window->LeftEdge;
pos->y=button_row-buttons->window->TopEdge;
// Send command
IPC_Command(
ipc,
BUTTONEDIT_BUTTON_TO_BANK,
0,
send_button,
pos,
0);
send_button=0;
}
front=0;
}
// Message to send?
if (send_msg)
{
// Send it on
IPC_Command(
ipc,
CFG_APPMESSAGE_PASS,
(ULONG)buttons->bank,
send_msg,
0,
0);
send_msg=0;
}
// Button to edit?
if (button_col>-1)
{
// Send edit command
IPC_Command(
ipc,
BUTTONEDIT_EDIT_BUTTON,
button_col,
(APTR)button_row,
0,
0);
front=0;
}
}
// Bring editor to front
if (front) IPC_Command(ipc,IPC_ACTIVATE,0,0,0,0);
}
// Unlock the process list
unlock_listlock(&GUI->process_list);
// Free button if we have one
if (send_button) FreeButton(send_button);
// Free message if we have one
if (send_msg) ReplyAppMessage((DOpusAppMessage *)send_msg);
// If editor was already running, or we can't start it if not, return
if (ipc || !can_start) return;
// Change our name
my_ipc->proc->pr_Task.tc_Node.ln_Name=NAME_BUTTON_EDITOR_RUN;
// Set flag
GUI->flags|=GUIF_BUTTON_EDITOR;
// Open configuration library
if (!(ConfigOpusBase=OpenModule(config_name)))
return;
// Bank supplied?
if (buttons)
{
// Fill out startup packet
startup.bank=buttons->bank;
startup.ipc=buttons->ipc;
// Button supplied?
if (button_col>-1)
{
// Set flag
startup.flag=1;
// Pass button
startup.button=(button_col<<16)|button_row;
}
else startup.flag=0;
// Set pending edit request
buttons->flags|=BUTTONF_EDIT_REQUEST;
}
else startup.bank=0;
// Configure buttons
ret=Config_Buttons(
&startup,
my_ipc,
&main_ipc,
GUI->screen_pointer,
(ULONG)&GUI->command_list.list);
// Change our name back
my_ipc->proc->pr_Task.tc_Node.ln_Name=NAME_BUTTON_EDITOR;
// Clear flag
GUI->flags&=~GUIF_BUTTON_EDITOR;
// Permit now we've cleaned up
Permit();
// Close library
CloseLibrary(ConfigOpusBase);
// Lock buttons list
lock_listlock(&GUI->buttons_list,FALSE);
// Go through button banks
for (ipc=(IPCData *)GUI->buttons_list.list.lh_Head;
ipc->node.mln_Succ;
ipc=(IPCData *)ipc->node.mln_Succ)
{
// Get buttons pointer
Buttons *buttons=IPCDATA(ipc);
// Toolbar buttons?
if (buttons->flags&BUTTONF_TOOLBAR)
{
// Hide bank
IPC_Command(ipc,IPC_HIDE,0,0,0,REPLY_NO_PORT);
// Need to save?
if (ret&CONFIG_SAVE)
IPC_Command(ipc,BUTTONS_SAVE,0,0,0,REPLY_NO_PORT);
// Use?
if (ret)
{
// Send change
send_main_reset_cmd(CONFIG_CHANGE_LIST_TOOLBAR,0,buttons->bank);
// Steal bank pointer
IPC_Command(ipc,BUTTONEDIT_NEW_BANK,1,0,0,REPLY_NO_PORT);
}
// Close bank
IPC_Command(ipc,IPC_QUIT,0,0,0,0);
}
// Ok?
else
if (ret)
{
// Save?
if (ret&CONFIG_SAVE)
{
// Buttons been changed?
if (buttons->flags&BUTTONF_CHANGED)
{
// Tell bank to save itself
IPC_Command(ipc,BUTTONS_SAVE,0,0,0,REPLY_NO_PORT);
}
}
// Clear 'new' flag
buttons->flags&=~BUTTONF_NEW_BANK;
}
}
// Unlock buttons list
unlock_listlock(&GUI->buttons_list);
}
// Edit a filetype
void filetype_edit(
config_filetypes_data *data,
FiletypeNode *node,
short edit_flag)
{
filetype_ed_data *eddata;
// Valid node?
if (!node) return;
// Check editor is not already up for this node
if (node->editor)
{
// Send activate message
IPC_Command(node->editor,IPC_ACTIVATE,0,0,0,0);
return;
}
// Allocate data for the editor
if (!(eddata=AllocVec(sizeof(filetype_ed_data),MEMF_CLEAR)))
return;
// Try to copy filetype
if (!(eddata->type=CopyFiletype(node->type,0)))
{
FreeVec(eddata);
return;
}
// Fill out data
eddata->owner_ipc=data->ipc;
eddata->node=node;
eddata->action_lookup=filetype_action_lookup;
// Supply libraries
/*eddata->func_startup.dopus_base=DOpusBase;
eddata->func_startup.dos_base=(struct Library *)DOSBase;
eddata->func_startup.int_base=(struct Library *)IntuitionBase;
eddata->func_startup.util_base=(struct Library *)UtilityBase;
eddata->func_startup.cx_base=CxBase;
eddata->func_startup.wb_base=WorkbenchBase;
eddata->func_startup.gfx_base=(struct Library *)GfxBase;
eddata->func_startup.asl_base=AslBase;
eddata->func_startup.layers_base=LayersBase;*/
// Supply locale
eddata->func_startup.locale=locale;
// Supply gui data pointers
eddata->new_win.parent=data->window;
eddata->new_win.dims=&_filetype_editor_window;
eddata->new_win.locale=locale;
eddata->obj_def=_filetype_editor_objects;
// Supply data pointers for function editor
eddata->func_startup.win_def=&_function_editor_window;
eddata->func_startup.obj_def=_function_editor_objects;
eddata->func_startup.func_labels=_function_type_labels;
eddata->func_startup.flag_list=_funced_flaglist;
eddata->func_startup.func_list=data->command_list;
eddata->func_startup.flags=FUNCEDF_NO_KEY;
eddata->func_startup.main_owner=data->owner_ipc;
// Supply data pointers for the fileclass editor
eddata->class_win=&_fileclass_editor_window;
eddata->class_obj=_fileclass_editor_objects;
eddata->class_lookup=fileclass_match_lookup;
eddata->class_strings=matchtype_labels;
eddata->edit_flag=edit_flag;
// Launch editor
if (!(IPC_Launch(
&data->proc_list,
&node->editor,
"dopus_filetype_editor",
(ULONG)IPC_NATIVE(FiletypeEditor),
STACK_DEFAULT,
(ULONG)eddata,
(struct Library *)DOSBase)) || !node->editor)
{
// Failed; free data
FreeFiletype(eddata->type);
FreeVec(eddata);
}
}
void SAVEDS PaletteBox(void)
{
PaletteBoxData *data;
struct Window *window;
IPCData *ipc;
// Do startup
if (!(ipc=Local_IPC_ProcStartup((ULONG *)&data,0)))
{
Forbid();
return;
}
// Get pen count
data->pen_count=data->screen_data.pen_count;
// Open window
if ((window=palette_box_open(data,data->stuff.stuff1.object_def,data->pen_array,data->pen_array)))
{
// Event loop
FOREVER
{
struct IntuiMessage *msg;
IPCMessage *imsg;
short break_flag=0;
// IPC messages
while ((imsg=(IPCMessage *)GetMsg(ipc->command_port)))
{
switch (imsg->command)
{
// Quit
case IPC_QUIT:
break_flag=1;
break;
// Activate
case IPC_ACTIVATE:
if (window)
{
WindowToFront(window);
ActivateWindow(window);
}
break;
// Hide
case IPC_HIDE:
CloseConfigWindow(window);
window=0;
break;
// Show
case IPC_SHOW:
data->newwin.parent=(void *)imsg->data;
if (!(window=palette_box_open(data,data->stuff.stuff1.object_def,data->pen_array,data->pen_array)))
break_flag=1;
break;
}
IPC_Reply(imsg);
}
// Intuition messages
if (window)
{
while ((msg=GetWindowMsg(window->UserPort)))
{
struct IntuiMessage msg_copy;
msg_copy=*msg;
ReplyWindowMsg(msg);
// Close
if (msg_copy.Class==IDCMP_CLOSEWINDOW)
break_flag=1;
// Gadget
else
if (msg_copy.Class==IDCMP_GADGETUP)
{
short fg,bg;
// Get foreground and background colours
fg=GetGadgetValue(OBJLIST(window),GAD_PALETTE_FOREGROUND);
bg=GetGadgetValue(OBJLIST(window),GAD_PALETTE_BACKGROUND);
// Fix pens
if (((struct Library*)IntuitionBase)->lib_Version>=39)
{
if (fg>=4 && fg<8) fg=248+fg;
else
if (fg>7) fg-=4;
if (bg>=4 && bg<8) bg=248+bg;
else
if (bg>7) bg-=4;
}
data->fgpen=fg;
data->bgpen=bg;
// Send new colours
IPC_Command(
data->owner_ipc,
BUTTONEDIT_NEW_COLOURS,
data->fgpen,
(APTR)data->bgpen,
0,
0);
}
// Key
else
if (msg_copy.Class==IDCMP_RAWKEY)
{
// Help?
if (msg_copy.Code==0x5f &&
!(msg_copy.Qualifier&VALID_QUALIFIERS))
{
// Set busy pointer
SetWindowBusy(window);
// Send help command
IPC_Command(data->main_ipc,IPC_HELP,(1<<31),"Select Colours",0,REPLY_NO_PORT);
// Clear busy pointer
ClearWindowBusy(window);
}
}
}
}
if (break_flag) break;
Wait(1<<ipc->command_port->mp_SigBit|
((window)?1<<window->UserPort->mp_SigBit:0));
}
CloseConfigWindow(window);
}
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);
}
// Got a notify message from PutDiskObject()
BOOL backdrop_check_notify(
BackdropInfo *info,
DOpusNotify *notify,
Lister *lister)
{
char *name_buf;
BOOL disk=0,ret=0;
struct List *search;
BackdropObject *object;
if (!(name_buf=AllocVec(256,0)))
return 0;
// Disk icon?
if (notify->dn_Name[strlen(notify->dn_Name)-1]==':')
{
char *ptr;
// Get volume name
if ((ptr=strchr(notify->dn_Name,':')))
{
stccpy(name_buf,notify->dn_Name,ptr-notify->dn_Name+1);
disk=1;
}
}
// Otherwise copy name and clear it
else
{
// Get name pointer
char *name=FilePart(notify->dn_Name);
// Copy name
strcpy(name_buf,name);
*name=0;
// Strip trailing '/'
if (*(name-1)=='/') *(name-1)=0;
}
// Is this a lister?
if (lister)
{
short len;
BOOL ok=0;
// Match length
len=strlen(notify->dn_Name);
// See if strings match
if (strnicmp(lister->cur_buffer->buf_Path,notify->dn_Name,len)==0)
{
// Check termination
if (lister->cur_buffer->buf_Path[len]=='\0') ok=1;
// / can terminate too
else
if (lister->cur_buffer->buf_Path[len]=='/' &&
lister->cur_buffer->buf_Path[len+1]=='\0') ok=1;
}
// Didn't match?
if (!ok)
{
// Free message
ReplyFreeMsg(notify);
FreeVec(name_buf);
return 0;
}
}
// Lock backdrop list
lock_listlock(&info->objects,1);
// See if there's an icon of this name
search=&info->objects.list;
while ((object=(BackdropObject *)FindNameI(search,name_buf)))
{
// Disk?
if (object->type==BDO_DISK && disk)
{
// Matched
break;
}
// Valid object?
else
if (object->type!=BDO_APP_ICON &&
object->type!=BDO_BAD_DISK &&
object->path)
{
char *path=0;
BPTR lock;
// If no lister, get full path of object
if (!lister && (path=AllocVec(512,0)))
{
// Lock path
if ((lock=Lock(object->path,ACCESS_READ)))
{
// Get full path
DevNameFromLockDopus(lock,path,512);
UnLock(lock);
}
// Failed
else strcpy(path,object->path);
}
// Objects in same directory?
if (lister || stricmp(notify->dn_Name,(path)?path:object->path)==0)
{
// Free path
if (path) FreeVec(path);
// Matched
break;
}
// Free path
if (path) FreeVec(path);
}
// If this is a lister, there could only be one
if (lister)
{
object=0;
break;
}
// Keep searching from this object
search=(struct List *)object;
}
// Got object?
if (object)
{
ULONG old_image1=0,old_image2=0,new_image1,new_image2,old_flags=0,new_flags;
BOOL redraw=0;
struct DiskObject *old;
// Save old icon
old=object->icon;
object->icon=0;
// Not deleted?
if (!notify->dn_Flags)
{
// Get image checksums
old_image1=IconCheckSum(old,0);
old_image2=IconCheckSum(old,1);
old_flags=GetIconFlags(old);
// Get new icon
backdrop_get_icon(info,object,GETICON_CD|GETICON_NO_POS|GETICON_FAIL);
}
// No icon now?
if (!object->icon)
{
// Replace old icon
object->icon=old;
// Erase old object
backdrop_erase_icon(info,object,BDSF_RECALC);
// Is object a disk?
if (object->type==BDO_DISK)
{
// Signal to refresh drives
IPC_Command(info->ipc,MAINCMD_REFRESH_DRIVES,0,0,0,0);
}
// Remove object from list
backdrop_remove_object(info,object);
}
// Ok to keep going
else
{
// Get image checksums
new_image1=IconCheckSum(object->icon,0);
new_image2=IconCheckSum(object->icon,1);
new_flags=GetIconFlags(object->icon);
// Mask out uninteresting flag bits
old_flags&=ICONF_BORDER_OFF|ICONF_BORDER_ON|ICONF_NO_LABEL;
new_flags&=ICONF_BORDER_OFF|ICONF_BORDER_ON|ICONF_NO_LABEL;
// Need to redraw?
if (old_image1!=new_image1 ||
old_image2!=new_image2 ||
old_flags!=new_flags)
{
// Erase old object
backdrop_erase_icon(info,object,0);
redraw=1;
}
// Free old icon
if (old)
{
// Free icon remapping
RemapIcon(old,(info->window)?info->window->WScreen:0,1);
// Free icon
FreeCachedDiskObject(old);
}
// Fix new icon size
backdrop_get_icon(info,object,GETICON_POS_ONLY|GETICON_SAVE_POS|GETICON_KEEP);
// Need to get masks?
if (!backdrop_icon_border(object))
{
// Get masks for this icon
backdrop_get_masks(object);
}
// Show new icon
if (redraw) backdrop_render_object(info,object,BRENDERF_CLIP);
}
ret=1;
}
// Otherwise, got lister?
else
if (lister)
{
// Tell lister to get icons
IPC_Command(lister->ipc,LISTER_GET_ICONS,0,0,0,0);
ret=1;
}
// Or, on the desktop?
else
if (info->flags&BDIF_MAIN_DESKTOP)
{
BPTR lock1,lock2;
// Lock the desktop folder and the changed directory
if ((lock1=Lock(environment->env->desktop_location,ACCESS_READ)) &&
(lock2=Lock(notify->dn_Name,ACCESS_READ)))
{
// Same directory?
if (SameLock(lock1,lock2)==LOCK_SAME)
{
// Update the desktop folder
misc_startup("dopus_desktop_update",MENU_UPDATE_DESKTOP,GUI->window,0,TRUE);
}
// Unlock second lock
UnLock(lock2);
}
// Unlock first lock
UnLock(lock1);
}
// Unlock list
unlock_listlock(&info->objects);
// Free message
ReplyFreeMsg(notify);
FreeVec(name_buf);
return ret;
}
// Handle drop on an object
BOOL desktop_drop_on_object(BackdropInfo *info,DOpusAppMessage **msg,BackdropObject *drop_obj,UWORD qual)
{
char *name;
short ret=1;
// Allocate buffer
if (!(name=AllocVec(1024,0))) return 1;
// Was it an AppIcon?
if (drop_obj->type==BDO_APP_ICON)
{
// Is the icon busy?
if (drop_obj->flags&BDOF_BUSY)
{
// Flash error
DisplayBeep(info->window->WScreen);
}
// Otherwise, pass message on
else
{
struct MsgPort *port;
// Turn message into an AppIcon one
(*msg)->da_Msg.am_Type=MTYPE_APPICON;
// Get port and info
port=WB_AppWindowData(
(struct AppWindow *)drop_obj->misc_data,
&(*msg)->da_Msg.am_ID,
&(*msg)->da_Msg.am_UserData);
// Fix reply port
(*msg)->da_Msg.am_Message.mn_ReplyPort=GUI->appmsg_port;
// Send the message on
PutMsg(port,(struct Message *)*msg);
// Zero message pointer
*msg=0;
}
}
// Was it a group?
else
if (drop_obj->type==BDO_GROUP)
{
short arg;
GroupData *group;
BOOL ok=0;
// Find group if it's open
lock_listlock(&GUI->group_list,0);
if (!(group=backdrop_find_group(drop_obj)))
unlock_listlock(&GUI->group_list);
// Go through arguments
for (arg=0;arg<(*msg)->da_Msg.am_NumArgs;arg++)
{
// Valid file?
if ((*msg)->da_Msg.am_ArgList[arg].wa_Name &&
*(*msg)->da_Msg.am_ArgList[arg].wa_Name)
{
// Get filename
GetWBArgPath(&(*msg)->da_Msg.am_ArgList[arg],name,512);
// Send add message to group if it's open
if (group)
{
char *copy;
// Copy name
if ((copy=AllocVec(strlen(name)+1,0)))
{
strcpy(copy,name);
IPC_Command(group->ipc,GROUP_ADD_ICON,0,0,copy,0);
ok=1;
}
}
// Otherwise add object to group
else
{
backdrop_group_add_object(drop_obj->name,0,name,-1,-1);
ok=1;
}
}
}
// Show error if no ok
if (!ok) DisplayBeep(GUI->screen_pointer);
// Unlock process list if it's locked
if (group) unlock_listlock(&GUI->group_list);
}
// Or a project?
else
if (drop_obj->icon->do_Type==WBPROJECT)
{
// Is it an Opus command?
if (command_filetype)
{
BPTR lock,old;
// Set failure initially
ret=0;
// Get lock on directory
if ((lock=backdrop_icon_lock(drop_obj)))
{
// Go there
old=CurrentDir(lock);
// See if it's a command
if (filetype_match_type(drop_obj->name,command_filetype))
{
// Run command with args
backdrop_object_open(
info,
drop_obj,
0,
0,
(*msg)->da_Msg.am_NumArgs,
(*msg)->da_Msg.am_ArgList);
ret=1;
}
// Restore CD
CurrentDir(old);
}
}
// Beep if not a command
if (!ret) DisplayBeep(GUI->screen_pointer);
}
// Or a tool?
else
if (drop_obj->icon->do_Type==WBTOOL)
{
// Run program with args
backdrop_object_open(
info,
drop_obj,
0,
0,
(*msg)->da_Msg.am_NumArgs,
(*msg)->da_Msg.am_ArgList);
}
// Or a disk/directory?
else
if (drop_obj->icon->do_Type==WBDISK ||
drop_obj->icon->do_Type==WBDRAWER ||
drop_obj->icon->do_Type==WBGARBAGE)
{
struct ArgArray *arg_array;
// Get arg array
if ((arg_array=AppArgArray(*msg,AAF_ALLOW_DIRS)))
{
BPTR lock;
// Get pathname of first file
DevNameFromLockDopus((*msg)->da_Msg.am_ArgList[0].wa_Lock,name,512);
// Need source directory; if no name, get parent
if ((!(*msg)->da_Msg.am_ArgList[0].wa_Name ||
!*(*msg)->da_Msg.am_ArgList[0].wa_Name) &&
(lock=ParentDir((*msg)->da_Msg.am_ArgList[0].wa_Lock)))
{
// Get pathname of parent
DevNameFromLockDopus(lock,name,512);
UnLock(lock);
}
// Get destination path
if ((lock=backdrop_icon_lock(drop_obj)))
{
short action;
// Get path
DevNameFromLockDopus(lock,name+512,512);
UnLock(lock);
// Is object a left-out?
if (drop_obj->type==BDO_LEFT_OUT)
{
// Add left-out name
AddPart(name+512,drop_obj->name,512);
}
// Get filetype action
if (qual&IEQUALIFIER_CONTROL) action=FTTYPE_CTRL_DRAGDROP;
else
if (qual&(IEQUALIFIER_LALT|IEQUALIFIER_RALT)) action=FTTYPE_ALT_DRAGDROP;
else
action=FTTYPE_DRAG_DROP;
// Do filetype action on files
function_launch(
FUNCTION_FILETYPE,
0,
action,
FUNCF_DRAG_DROP|FUNCF_ICONS,
0,0,
name,name+512,
arg_array,
0,
(Buttons *)CopyAppMessage(*msg,global_memory_pool));
}
}
}
else ret=0;
FreeVec(name);
return ret;
}
// Rename some objects
void icon_rename(IPCData *ipc,BackdropInfo *info,BackdropObject *icon)
{
Att_List *list;
Att_Node *node;
BackdropObject *object;
BOOL save_pos=0;
BPTR lock=0,old=0;
// Group?
if (info->flags&BDIF_GROUP)
{
GroupData *group;
// Get group pointer
group=(GroupData *)IPCDATA(info->ipc);
// Build directory name
lsprintf(info->buffer,"dopus5:groups/%s",group->name);
// Lock directory
if (!(lock=Lock(info->buffer,ACCESS_READ)))
return;
// Change directory
old=CurrentDir(lock);
}
// Create list
if (!(list=Att_NewList(0)))
{
if (lock) UnLock(CurrentDir(old));
return;
}
// Lock backdrop list
lock_listlock(&info->objects,0);
// Go through backdrop list (backwards, just for the hell of it)
for (object=(BackdropObject *)info->objects.list.lh_TailPred;
object->node.ln_Pred;
object=(BackdropObject *)object->node.ln_Pred)
{
// Correct type?
if (object->type!=BDO_APP_ICON && object->type!=BDO_BAD_DISK && !(object->flags&BDOF_CACHE))
{
// Selected or supplied?
if ((!icon && object->state) || icon==object)
{
// Add object to list
Att_NewNode(
list,
(object->flags&BDOF_CUSTOM_LABEL)?object->device_name:object->name,
(ULONG)object,
0);
if (icon) break;
}
}
}
// Unlock backdrop list
unlock_listlock(&info->objects);
// Go through list of objects
for (node=(Att_Node *)list->list.lh_Head;
node->node.ln_Succ;
node=(Att_Node *)node->node.ln_Succ)
{
char *name,*origname;
BackdropObject *object;
short ret,copy=1;
BOOL retry,fail=0;
if (!(name=AllocVec(512,0)))
break;
origname=name+256;
// Loop on retries
do
{
// Clear retry flag
retry=0;
// Copy name
strcpy(name,node->node.ln_Name);
// Build message
lsprintf(info->buffer,GetString(&locale,MSG_RENAME_DISK),name);
// Strip trailing colon for assigns
if (name[(ret=(strlen(name)-1))]==':') name[ret]=0;
// Copy original name
strcpy(origname,name);
// Ask for new name
if (!(ret=super_request_args(
info->window,
info->buffer,
SRF_BUFFER|SRF_IPC|SRF_PATH_FILTER|SRF_MOUSE_POS,
name,255,
ipc,
GetString(&locale,MSG_OKAY),
GetString(&locale,(node->node.ln_Succ->ln_Succ)?MSG_SKIP:MSG_CANCEL),
(node->node.ln_Succ->ln_Succ)?GetString(&locale,MSG_CANCEL):0,0)))
{
// Cancel
fail=1;
break;
}
// Ok to rename?
else
if (ret!=2)
{
// Lock backdrop list
lock_listlock(&info->objects,0);
// Is object still valid?>
if ((object=find_backdrop_object(info,(BackdropObject *)node->data)))
{
// Object in a group?
if (info->flags&BDIF_GROUP)
{
// Must have custom label
if (object->flags&BDOF_CUSTOM_LABEL)
{
// Try to rename object
if (Rename(object->device_name,name))
{
// Store new name
strcpy(object->device_name,name);
ret=1;
copy=0;
}
}
}
// Assign?
else
if (object->flags&BDOF_ASSIGN)
{
BPTR lock;
// Lock the assign
if ((lock=Lock(object->name,ACCESS_READ)))
{
// Assign the new name to it
while (!(ret=AssignLock(name,lock)))
{
// Failed, display requester
if (!(error_request(
info->window,
ERF_MOUSE,
GetString(&locale,MSG_RENAMING),
-1,
object->name,
":",
0))) break;
}
// Success?
if (ret)
{
// Delete the old assignment
AssignLock(origname,0);
}
// Otherwise free the lock
else UnLock(lock);
}
}
// Disk?
else
if (object->type==BDO_DISK)
{
// Try to relabel
while (!(ret=OriginalRelabel(object->device_name,name)))
{
// Failed, display requester
if (!(error_request(
info->window,
ERF_MOUSE,
GetString(&locale,MSG_RENAMING),
-1,
object->name,
":",
0))) break;
}
// Success?
if (ret)
{
// Pass name change through to things
notify_disk_name_change(info,object->device_name,name);
}
}
// Group, desktop folder
else
if (object->type==BDO_GROUP ||
(object->type==BDO_LEFT_OUT && object->flags&BDOF_DESKTOP_FOLDER))
{
BPTR old=0,lock;
// Change directory
if ((lock=Lock(object->path,ACCESS_READ)))
old=CurrentDir(lock);
// Rename file
if (!(ret=Rename(object->name,name)))
{
// Show error requester
if (error_request(
info->window,
ERF_MOUSE,
GetString(&locale,MSG_RENAMING),
-1,
object->name,
":",
0))
{
// Set flag to retry
retry=1;
}
}
// Success?
if (ret)
{
GroupData *group;
// Add .infos on
strcpy(info->buffer,object->name);
strcat(info->buffer,".info");
strcpy(info->buffer+300,name);
strcat(info->buffer+300,".info");
// Rename icon
Rename(info->buffer,info->buffer+300);
// Group?
if (object->type==BDO_GROUP)
{
// Lock process list
lock_listlock(&GUI->group_list,0);
// See if group is open
if ((group=backdrop_find_group(object)))
{
char *name_copy;
// Get a copy of the name
if ((name_copy=AllocVec(strlen(name)+1,0)))
{
// Signal it to update its name
strcpy(name_copy,name);
IPC_Command(group->ipc,GROUP_NEW_NAME,0,0,name_copy,0);
}
}
// Unlock process list
unlock_listlock(&GUI->group_list);
}
}
// Restore directory
if (lock) UnLock(CurrentDir(old));
}
// Left-out
else
if (object->type==BDO_LEFT_OUT)
{
leftout_record *left;
// Lock position list
lock_listlock(&GUI->positions,0);
// Look for entry for icon
for (left=(leftout_record *)&GUI->positions.list.lh_Head;
left->node.ln_Succ;
left=(leftout_record *)left->node.ln_Succ)
{
// Leftout?
if (left->node.ln_Type==PTYPE_LEFTOUT)
{
// Match this icon?
if (object->misc_data==(ULONG)left)
{
// Store new label
stccpy(left->icon_label,name,sizeof(left->icon_label));
save_pos=1;
break;
}
}
}
// Unlock position list
unlock_listlock(&GUI->positions);
// Store name in icon
if (object->flags&BDOF_CUSTOM_LABEL)
{
strcpy(object->device_name,name);
ret=1;
copy=0;
}
}
// Successful?
if (ret)
{
// Erase object
backdrop_erase_icon(info,object,0);
// Store new name
if (copy)
{
strcpy(object->name,name);
if (object->flags&BDOF_ASSIGN) strcat(object->name,":");
}
// Show new object
backdrop_render_object(info,object,BRENDERF_CLIP);
}
}
// Unlock backdrop list
unlock_listlock(&info->objects);
}
} while (retry);
// Abort?
FreeVec(name);
if (fail) break;
}
// Free list
Att_RemList(list,0);
// Lock backdrop list
lock_listlock(&info->objects,0);
// Save any left-outs
if (save_pos)
{
// Lock list
lock_listlock(&GUI->positions,0);
// Save list
SavePositions(&GUI->positions.list,GUI->position_name);
// Unlock list
unlock_listlock(&GUI->positions);
}
// Unlock backdrop list
unlock_listlock(&info->objects);
// Restore CD
if (lock) UnLock(CurrentDir(old));
}
