// Update checkmarks in action list
void filetypeed_update_actions(filetype_ed_data *data)
{
Att_Node *node;
// Detach list from listview
SetGadgetChoices(data->objlist,GAD_FILETYPEED_ACTION_LIST,(APTR)~0);
// Go through action list
for (node=(Att_Node *)data->action_list->list.lh_Head;
node->node.ln_Succ;
node=(Att_Node *)node->node.ln_Succ)
{
Cfg_Function *func;
// Initially not selected
node->node.lve_Flags&=~LVEF_SELECTED;
// Go through function list
for (func=(Cfg_Function *)data->type->function_list.lh_Head;
func->node.ln_Succ;
func=(Cfg_Function *)func->node.ln_Succ)
{
// Right type?
if (func->function.func_type==node->data &&
!(func->function.flags2&FUNCF2_LABEL_FUNC))
{
node->node.lve_Flags|=LVEF_SELECTED;
break;
}
}
}
// Reattach list
SetGadgetChoices(data->objlist,GAD_FILETYPEED_ACTION_LIST,data->action_list);
}
void config_env_store_sound(config_env_data *data)
{
short num;
Cfg_SoundEntry *sound;
// Get selection
if ((num=GetGadgetValue(data->option_list,GAD_SETTINGS_SOUNDLIST))>-1 &&
(sound=(Cfg_SoundEntry *)Att_FindNode((Att_List *)&data->sound_list,num)))
{
short flags,old_volume;
char old_sound[256];
strcpy(old_sound,sound->dse_Sound);
old_volume=sound->dse_Volume;
strcpy(sound->dse_Sound,(char *)GetGadgetValue(data->option_list,GAD_SETTINGS_SOUNDLIST_PATH));
UpdateGadgetValue(data->option_list,0,GAD_SETTINGS_VOLUME);
if ((sound->dse_Volume=GetGadgetValue(data->option_list,GAD_SETTINGS_VOLUME))<0)
sound->dse_Volume=0;
else
if (sound->dse_Volume>64)
sound->dse_Volume=64;
SetGadgetValue(data->option_list,GAD_SETTINGS_VOLUME,sound->dse_Volume);
SetGadgetValue(data->option_list,GAD_SETTINGS_VOLUME_SLIDER,sound->dse_Volume);
// Did sound change?
if (strcmp(old_sound,sound->dse_Sound)!=0)
{
// Fix pen usage
flags=sound->dse_Node.lve_Flags;
if (sound->dse_Sound[0])
sound->dse_Node.lve_Flags|=LVEF_USE_PEN;
else
sound->dse_Node.lve_Flags&=~LVEF_USE_PEN;
if (flags!=sound->dse_Node.lve_Flags)
{
SetGadgetChoices(data->objlist,GAD_SETTINGS_SOUNDLIST,(APTR)~0);
SetGadgetChoices(data->objlist,GAD_SETTINGS_SOUNDLIST,&data->sound_list);
}
sound->dse_Node.lve_Flags|=LVEF_TEMP;
}
// Or volume?
else
if (old_volume!=sound->dse_Volume)
sound->dse_Node.lve_Flags|=LVEF_TEMP;
}
}
// Open window
BOOL config_paths_open(config_path_data *data,struct Screen *screen)
{
// Already open?
if (data->window) return 1;
// Fill out and open window
data->newwin.parent=screen;
data->newwin.dims=&pathformat_window;
data->newwin.title=GetString(locale,MSG_PATHFORMAT_TITLE);
data->newwin.locale=locale;
data->newwin.flags=WINDOW_VISITOR|WINDOW_AUTO_KEYS|WINDOW_REQ_FILL|WINDOW_SCREEN_PARENT;
if (!(data->window=OpenConfigWindow(&data->newwin)) ||
!(data->objlist=AddObjectList(data->window,pathformat_objects)))
{
config_paths_cleanup(data);
return 0;
}
// Add AppWindow
if (data->appport)
data->appwindow=AddAppWindowA(0,0,data->window,data->appport,0);
// Attach path list
SetGadgetChoices(data->objlist,GAD_PATHFORMAT_PATHS,data->path_list);
// Initially disable everything
config_paths_disable(data,TRUE);
return 1;
}
// Receive an edited filetype
BOOL filetype_receive_edit(
config_filetypes_data *data,
Cfg_Filetype *type,
FiletypeNode *node)
{
BOOL success=0;
Cfg_Filetype *type_copy;
Att_Node *display_node;
// Try to copy the new filetype
if ((type_copy=CopyFiletype(type,data->memory)))
{
// Get list pointer from existing filetype
type_copy->list=node->type->list;
type_copy->list->flags|=FTLISTF_CHANGED;
// Free existing filetype
FreeFiletype(node->type);
// Add new filetype to list
AddTail(&type_copy->list->filetype_list,&type_copy->node);
// Remove existing display list
SetGadgetChoices(data->objlist,GAD_FILETYPES_LIST,(APTR)~0);
// Free display node
if ((display_node=Att_FindNodeData(data->filetype_list,(ULONG)node)))
Att_RemNode(display_node);
FreeVec(node);
// Add new filetype entry
filetype_add_entry(data,type_copy);
// Reattach list to gadget
SetGadgetChoices(data->objlist,GAD_FILETYPES_LIST,data->filetype_list);
// Set success flag
success=1;
}
return success;
}
// Update flag selections
void funced_update_flaglist(FuncEdData *data)
{
Att_Node *node;
// Detach existing list
SetGadgetChoices(data->objlist,GAD_FUNCED_FLAGS,(APTR)~0);
// Go through flag list
for (node=(Att_Node *)data->flag_list->list.lh_Head;
node->node.ln_Succ;
node=(Att_Node *)node->node.ln_Succ)
{
// Is flag set?
if (data->function->function.flags&node->data) node->node.lve_Flags|=LVEF_SELECTED;
else node->node.lve_Flags&=~LVEF_SELECTED;
}
// Attach list to gadget
SetGadgetChoices(data->objlist,GAD_FUNCED_FLAGS,data->flag_list);
}
// Build list of available filetypes
void filetype_build_list(config_filetypes_data *data)
{
Cfg_FiletypeList *list;
Cfg_Filetype *type;
// Remove existing list
SetGadgetChoices(data->objlist,GAD_FILETYPES_LIST,(APTR)~0);
// Free list
Att_RemList(data->filetype_list,REMLIST_FREEDATA);
// Create new list
if ((data->filetype_list=Att_NewList(0)))
{
// Go through filetype lists
for (list=(Cfg_FiletypeList *)data->list_list.lh_Head;
list->node.ln_Succ;
list=(Cfg_FiletypeList *)list->node.ln_Succ)
{
// Go through filetypes in this list
for (type=(Cfg_Filetype *)list->filetype_list.lh_Head;
type->node.ln_Succ;
type=(Cfg_Filetype *)type->node.ln_Succ)
{
// Add an entry for this filetype
filetype_add_entry(data,type);
}
}
}
// Add list to gadget
SetGadgetChoices(data->objlist,GAD_FILETYPES_LIST,data->filetype_list);
// Clear current selection
SetGadgetValue(data->objlist,GAD_FILETYPES_LIST,(ULONG)-1);
data->sel_filetype=0;
// Disable buttons
filetype_able_buttons(data,TRUE);
}
// Build display list from function list
void funced_build_display(FuncEdData *data)
{
Att_Node *node;
// Detach existing list
SetGadgetChoices(data->objlist,GAD_FUNCED_LISTER,(APTR)~0);
// Clear list
Att_RemList(data->func_display_list,REMLIST_SAVELIST);
// Go through function list
for (node=(Att_Node *)data->function_list->list.lh_Head;
node->node.ln_Succ;
node=(Att_Node *)node->node.ln_Succ)
{
// Build display string for this node
funced_build_entrydisplay(data,0,(FunctionEntry *)node->data);
}
// Attach list to gadget
SetGadgetChoices(data->objlist,GAD_FUNCED_LISTER,data->func_display_list);
}
// Add an entry
void config_paths_add(config_path_data *data,BOOL activate)
{
position_rec *pos;
Att_Node *node;
// Create a new entry
if ((pos=(position_rec *)AllocMemH(data->memory,sizeof(position_rec)+256)))
{
// Initialise entry
pos->node.ln_Type=PTYPE_POSITION;
pos->node.ln_Name=pos->name;
pos->flags|=POSITIONF_USER|POSITIONF_NEW;
if (data->def_format)
CopyMem((char *)data->def_format,(char *)&pos->format,sizeof(ListFormatStorage));
// Initialise key
pos->code=0xffff;
// Add to list path list
AddTail(data->paths,(struct Node *)pos);
// Remove list from gadget
SetGadgetChoices(data->objlist,GAD_PATHFORMAT_PATHS,(APTR)~0);
// Add to lister
node=Att_NewNode(data->path_list,0,(ULONG)pos,ADDNODE_SORT);
// Attach list to gadget
SetGadgetChoices(data->objlist,GAD_PATHFORMAT_PATHS,data->path_list);
// Select the new node
config_paths_select(data,node,TRUE);
// Activate path field
if (activate) ActivateStrGad(GADGET(GetObject(data->objlist,GAD_PATHFORMAT_PATH)),data->window);
}
}
// Handle new nodes
void filetype_new_node(config_filetypes_data *data,Att_Node *node)
{
// Reattach list
SetGadgetChoices(data->objlist,GAD_FILETYPES_LIST,data->filetype_list);
// Select the new entry
data->sel_filetype=node;
SetGadgetValue(data->objlist,GAD_FILETYPES_LIST,Att_FindNodeNumber(data->filetype_list,node));
// Enable buttons
filetype_able_buttons(data,FALSE);
// Launch editor for this filetype
if (node)
{
filetype_edit(data,(FiletypeNode *)node->data,1);
data->change=1;
}
}
// Build size labels
void font_build_labels(font_data *data,struct FontContentsHeader *fch)
{
char **labels,*ptr;
short num=0,a,smallest=0;
struct FontContents *fc=NULL;
BOOL topaz=FALSE;
// Get number
if (fch) num=fch->fch_NumEntries;
if (num<1)
{
num=1;
fch=NULL;
}
// Kludge for topaz
if (fch)
{
// Get first contents pointer
fc=(struct FontContents *)(fch+1);
// Topaz?
if (strnicmp(fc->fc_FileName,"topaz/",6)==0)
{
// Add 8 and 9
num+=2;
topaz=TRUE;
}
}
// Allocate array and buffer
if (!(ptr=AllocVec((sizeof(char *)+8)*(num+1),MEMF_CLEAR)))
return;
// Get label array, bump pointer
labels=(char **)ptr;
ptr+=sizeof(char *)*(num+1);
// No font contents?
if (!fc)
{
// Null label
labels[0]=ptr;
labels[1]=0;
}
// Get label pointers, build labels
else
for (a=0;a<num;a++,ptr+=8)
{
// Get pointer
labels[a]=ptr;
// Topaz kludge?
if (topaz && a<2)
{
short val=8+a;
// Add 8 or 9
labels[a][0]='0'+val;
labels[a][1]=0;
// Is this the smallest?
if (!smallest || val<smallest)
smallest=val;
}
// Normal font
else
{
// Add size
lsprintf(labels[a],"%ld",fc->fc_YSize);
// Is this the smallest?
if (!smallest || fc->fc_YSize<smallest)
smallest=fc->fc_YSize;
// Bump contents pointer
fc++;
}
}
// Use smallest as first size to show
if (!data->first && smallest) data->font_size=smallest;
// Use new labels
SetGadgetChoices(data->list,GAD_FONT_CYCLE,labels);
// Disable if no labels
DisableObject(data->list,GAD_FONT_CYCLE,(BOOL)!labels[1]);
// Free old labels, store pointer
FreeVec(data->size_labels);
data->size_labels=labels;
}
Att_List *build_text_display(struct Window *window,ObjectList *objlist,char *text)
{
Att_List *list;
struct TextExtent extent;
short want_len,max_len,textlen=0,width;
char *textpos=0;
struct Rectangle rect;
char old;
// Allocate a new list
list=Att_NewList(0);
// Get list object size
GetObjectRect(objlist,GAD_TEXT_DISPLAY,&rect);
width=RECTWIDTH(&rect)-28;
// Go through text
FOREVER
{
// No current line?
if (!textpos) textpos=text;
// Move on from current line
else
{
// Were we on a newline?
if (textlen==0) ++textpos;
// No
else
{
// Bump pointer
textpos+=textlen;
// If this leaves us on a newline or space, skip over it
if (*textpos=='\n' || *textpos=='\t') ++textpos;
}
}
// End of text?
if (!*textpos) break;
// If we're on a space, skip over it
if (*textpos==' ') ++textpos;
// Calculate desired length of the line
for (want_len=0;textpos[want_len] && textpos[want_len]!='\n';++want_len);
// Blank line?
if (want_len==0)
{
textlen=0;
}
// Not blank
else
{
// Get maximum length that will actually fit
max_len=TextFit(
window->RPort,
textpos,
want_len,
&extent,
0,1,
width,window->RPort->TxHeight);
// Go from here to end of current word
want_len=max_len;
while ( textpos[want_len] &&
textpos[want_len]!='\n' &&
textpos[want_len]!=' ') ++want_len;
// Loop until successful
do
{
// Get text size
TextExtent(window->RPort,textpos,want_len,&extent);
// Will it fit?
if (extent.te_Width<=width)
{
// Save size
textlen=want_len;
break;
}
// Come backwards to word break
for (--want_len;want_len>0 && textpos[want_len]!=' ';--want_len);
// Didn't find one?
if (want_len<1)
{
// Get maximum length
want_len=max_len;
}
} while(1);
}
// Null out break temporarily
old=textpos[textlen];
textpos[textlen]=0;
// Add node
Att_NewNode(list,textpos,0,0);
// Restore character
textpos[textlen]=old;
}
// Add list to display
SetGadgetChoices(objlist,GAD_TEXT_DISPLAY,list);
return list;
}
// Change entry's path
void config_paths_change(config_path_data *data)
{
char *str;
BPTR lock;
char path[256];
position_rec *pos;
Att_Node *node;
struct List *search;
// No path selected?
if (!data->path_sel) return;
// Get path string
str=(char *)GetGadgetValue(data->objlist,GAD_PATHFORMAT_PATH);
// Invalid?
if (!str || !*str)
{
// Remove this path
config_paths_remove(data,TRUE);
return;
}
// Try to lock
if ((lock=Lock(str,ACCESS_READ)))
{
// Get full pathname
NameFromLock(lock,path,256);
UnLock(lock);
}
// Otherwise, use entered path
else strcpy(path,str);
// Fix path with trailing /
AddPart(path,"",256);
// See if path is already in edit list
if ((node=(Att_Node *)FindNameI((struct List *)data->path_list,path)))
{
// Not the currently selected node?
if (node!=data->path_sel)
{
// Error
DisplayBeep(data->window->WScreen);
ActivateStrGad(GADGET(GetObject(data->objlist,GAD_PATHFORMAT_PATH)),data->window);
return;
}
}
// Is path already in snapshot list?
search=data->paths;
while ((pos=(position_rec *)FindNameI(search,path)))
{
// Position entry?
if (pos->node.ln_Type==PTYPE_POSITION) break;
search=(struct List *)pos;
}
// Found it?
if (pos)
{
// Different entry?
if (pos!=(position_rec *)data->path_sel->data)
{
// Remove current entry from list
Remove((struct Node *)data->path_sel->data);
// Free current data
FreeMemH((void *)data->path_sel->data);
data->path_sel->data=(ULONG)pos;
}
// If path exists, clear "new" flag
if (lock) pos->flags&=~POSITIONF_NEW;
}
// It is now
else pos=(position_rec *)data->path_sel->data;
// Set its user flag
pos->flags|=POSITIONF_USER;
// Store new name
strcpy(pos->name,path);
// Remove list from gadget
SetGadgetChoices(data->objlist,GAD_PATHFORMAT_PATHS,(APTR)~0);
// Remove existing node and add new one
Att_RemNode(data->path_sel);
// Add to list
data->path_sel=Att_NewNode(data->path_list,pos->node.ln_Name,(ULONG)pos,ADDNODE_SORT);
// Attach list to gadget
SetGadgetChoices(data->objlist,GAD_PATHFORMAT_PATHS,data->path_list);
// Select the new node
config_paths_select(data,data->path_sel,TRUE);
}
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);
}
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;
}
void _config_env_screenmode_fix_gadgets(config_env_data *data)
{
BOOL state=FALSE;
// If screen mode is WORKBENCH_CLONE, select both default checks and disable them
if (data->config->screen_mode==MODE_WORKBENCHCLONE)
{
// Set default size flags
SetGadgetValue(data->option_list,GAD_ENVIRONMENT_SCREENMODE_DEFWIDTH,1);
SetGadgetValue(data->option_list,GAD_ENVIRONMENT_SCREENMODE_DEFHEIGHT,1);
state=TRUE;
}
// Or if mode is a USE mode, disable them
else
if (data->config->screen_mode==MODE_WORKBENCHUSE ||
data->config->screen_mode==MODE_PUBLICSCREEN)
state=TRUE;
// Set enable/disable state of default checks
DisableObject(data->option_list,GAD_ENVIRONMENT_SCREENMODE_DEFWIDTH,state);
DisableObject(data->option_list,GAD_ENVIRONMENT_SCREENMODE_DEFHEIGHT,state);
// If default width is checked, fill out width field with default width
// and disable it
if (GetGadgetValue(data->option_list,GAD_ENVIRONMENT_SCREENMODE_DEFWIDTH))
{
SetGadgetValue(data->option_list,GAD_ENVIRONMENT_SCREENMODE_WIDTH,data->mode_size_default.MaxX);
state=TRUE;
}
// Or if mode is a USE mode, disable it
else
if (data->config->screen_mode==MODE_WORKBENCHUSE ||
data->config->screen_mode==MODE_PUBLICSCREEN)
state=TRUE;
// Otherwise, make sure field is enabled
else state=FALSE;
// Set enable state
DisableObject(data->option_list,GAD_ENVIRONMENT_SCREENMODE_WIDTH,state);
// If default height is checked, fill out height field with default height
// and disable it
if (GetGadgetValue(data->option_list,GAD_ENVIRONMENT_SCREENMODE_DEFHEIGHT))
{
SetGadgetValue(data->option_list,GAD_ENVIRONMENT_SCREENMODE_HEIGHT,data->mode_size_default.MaxY);
state=TRUE;
}
// Or if mode is a USE mode, disable it
else
if (data->config->screen_mode==MODE_WORKBENCHUSE ||
data->config->screen_mode==MODE_PUBLICSCREEN)
state=TRUE;
// Otherwise, make sure field is enabled
else state=FALSE;
// Set enable state
DisableObject(data->option_list,GAD_ENVIRONMENT_SCREENMODE_HEIGHT,state);
// Fix depth slider limits
SetGadgetChoices(
data->option_list,
GAD_ENVIRONMENT_SCREENMODE_COLORS,
(APTR)(((ULONG)data->mode_max_colours<<16)|2));
SetGadgetValue(
data->option_list,
GAD_ENVIRONMENT_SCREENMODE_COLORS,
data->config->screen_depth);
// Is mode is a USE mode, disable colours selector and font gadgets
state=(data->config->screen_mode==MODE_WORKBENCHUSE || data->config->screen_mode==MODE_PUBLICSCREEN);
DisableObject(data->option_list,GAD_ENVIRONMENT_SCREENMODE_COLORS,state);
DisableObject(data->option_list,GAD_ENVIRONMENT_SCREENMODE_FONT,state);
DisableObject(data->option_list,GAD_ENVIRONMENT_SCREENMODE_FONTNAME,state);
DisableObject(data->option_list,GAD_ENVIRONMENT_SCREENMODE_FONTSIZE,state);
// Check maximum/minimum values
_config_env_screenmode_check_values(data);
}
// Edit a specific filetype
void filetype_edit_name(config_filetypes_data *data,char *name)
{
Att_Node *node;
char *path;
// Store path pointer
path=name;
// Full path specified?
if (strchr(name,':') || strchr(name,'/'))
{
// Get pointer to filename only
name=FilePart(name);
}
// Find node
if ((node=(Att_Node *)FindNameI((struct List *)data->filetype_list,name)))
{
// Select the new entry
data->sel_filetype=node;
SetGadgetValue(data->objlist,GAD_FILETYPES_LIST,Att_FindNodeNumber(data->filetype_list,node));
// Launch editor
filetype_edit(data,(FiletypeNode *)node->data,0);
}
// Load from disk?
else
{
Cfg_FiletypeList *list;
// Try to load filetype from disk
if ((list=ReadFiletypes(path,data->memory)))
{
Cfg_Filetype *type;
Att_Node *node=0;
// Add filetype list to main list
AddTail(&data->list_list,&list->node);
// Fix list path and flags
strcpy(list->path,"dopus5:filetypes/");
strcat(list->path,name);
list->flags=FTLISTF_CHANGED;
// Remove list from gadget
SetGadgetChoices(data->objlist,GAD_FILETYPES_LIST,(APTR)~0);
// Go through filetypes in list
for (type=(Cfg_Filetype *)list->filetype_list.lh_Head;
type->node.ln_Succ;
type=(Cfg_Filetype *)type->node.ln_Succ)
{
// Add entry for this filetype
node=filetype_add_entry(data,type);
}
// Handle new node
filetype_new_node(data,node);
}
}
// Free name
FreeVec(path);
}
// Remove a filetype
short filetype_remove(
config_filetypes_data *data,
Att_Node *node,
short store)
{
FiletypeNode *ftnode;
struct DOpusSimpleRequest simple;
char buf[100],*gadgets[3];
int ret_vals[2];
short change=0;
// Get filetype node
ftnode=(FiletypeNode *)node->data;
// Fill out requester structure
simple.title=GetString(locale,MSG_FILETYPE_EDITOR_TITLE);
simple.message=buf;
simple.gadgets=gadgets;
simple.return_values=ret_vals;
simple.string_buffer=0;
simple.flags=SRF_IPC;
simple.font=0;
simple.ipc=data->ipc;
// Build message
lsprintf(buf,GetString(locale,MSG_FILETYPE_REMOVE_REQ),ftnode->type->type.name);
// Fill in gadgets
gadgets[0]=GetString(locale,MSG_FILETYPES_REMOVE);
gadgets[1]=GetString(locale,MSG_CANCEL);
gadgets[2]=0;
ret_vals[0]=1;
ret_vals[1]=0;
// Make window busy
SetWindowBusy(data->window);
// Display requester
if (store || (change=DoSimpleRequest(data->window,&simple))==1)
{
// Is the editor open for this filetype?
if (ftnode->editor)
{
// Tell it to quit
IPC_Quit(ftnode->editor,-1,0);
}
// Remove filetype list from lister
SetGadgetChoices(data->objlist,GAD_FILETYPES_LIST,(APTR)~0);
// Mark this list as changed
ftnode->type->list->flags|=FTLISTF_CHANGED;
// Stored?
if (store)
{
ftnode->type->list->flags|=FTLISTF_STORE;
change=1;
}
// Removed
else
{
// Free filetype
FreeFiletype(ftnode->type);
}
// Free node data and node
FreeVec(ftnode);
Att_RemNode(node);
// Reattach list with no selection
SetGadgetValue(data->objlist,GAD_FILETYPES_LIST,(ULONG)-1);
SetGadgetChoices(data->objlist,GAD_FILETYPES_LIST,data->filetype_list);
// Disable buttons
filetype_able_buttons(data,TRUE);
}
// Make window unbusy
ClearWindowBusy(data->window);
return change;
}