/*************
* DESCRIPTION: this method is called whenever the user presses return in
* the float string object
* INPUT: cl class
* obj object
* msg message
* OUTPUT:
*************/
static ULONG StringAck(struct IClass *cl,Object *obj,struct opGet *msg)
{
struct Float_Data *data = (struct Float_Data *)INST_DATA(cl,obj);
char *s;
float value;
char buffer[32];
GetAttr(MUIA_String_Contents,data->fs_gadget,(ULONG*)&s);
value = atof(s);
if(data->lowerbound && (((value < data->lower) && data->lowerinside) || ((value <= data->lower) && !data->lowerinside)))
{
value = data->value;
Float2String(value, buffer);
SetAttrs(data->fs_gadget, MUIA_String_Contents, buffer, TAG_DONE);
DisplayBeep(_screen(obj));
}
if(data->upperbound && (((value > data->upper) && data->upperinside) || ((value >= data->upper) && !data->upperinside)))
{
value = data->value;
Float2String(value, buffer);
SetAttrs(data->fs_gadget, MUIA_String_Contents, buffer, TAG_DONE);
DisplayBeep(_screen(obj));
}
data->value = value;
return 0;
}
/**************************************************************
*
* Read the addressbook ONLY not the config. Done in setup_config
*
*/
void read_build_addressbook(struct opusftp_globals *ogp,IPCData *ipc)
{
D(bug( "read_build_addressbook()\n" ));
if (ogp->og_SiteList)
{
DisplayBeep(NULL);
return;
}
// read new one ok then return
if (read_addrbook(ogp,ipc))
return;
// try to read old one
if (!(ogp->og_SiteList=do_import_sites(ogp,CONFIGFILE)))
{
// failed?
DisplayBeep(0);
// display_msg(ogp,ipc,NULL,0,GetString(locale,MSG_BADADRBOOK));
}
}
/**
* callback on drag end for history viewer
*
* \param ami_cw The Amiga core window structure.
* \param x mouse x co-ordinate
* \param y mouse y co-ordinate
* \return NSERROR_OK on success otherwise apropriate error code
*/
static nserror
ami_history_global_drag_end(struct ami_corewindow *ami_cw, int x, int y)
{
struct nsurl *url = NULL;
const char *title = NULL;
bool ok = false;
struct gui_window_2 *gwin;
struct ami_corewindow *cw;
if(global_history_has_selection()) {
ok = global_history_get_selection(&url, &title);
}
if((ok == false) || (url == NULL)) {
DisplayBeep(scrn);
} else if(url) {
if((gwin = ami_window_at_pointer(AMINS_WINDOW))) {
browser_window_navigate(gwin->gw->bw,
url,
NULL,
BW_NAVIGATE_HISTORY,
NULL,
NULL,
NULL);
} else if((cw = (struct ami_corewindow *)ami_window_at_pointer(AMINS_COREWINDOW)) &&
(ami_cw->icon_drop != NULL)) {
cw->icon_drop(cw, url, title, x, y);
}
}
return NSERROR_OK;
}
/*** Performs some checks on what user has enterred ***/
void check_tab(struct Gadget *str)
{
UBYTE *buf = GetSI(str)->Buffer, *start;
for(start=buf; *buf; buf++)
if(*buf < '0' || *buf > '9')
{
/* Wrong char, avert user */
GetSI(str)->BufferPos = buf-start;
DisplayBeep(NULL);
ActivateGadget(str, Wnd, NULL);
break;
}
}
void config_env_test_sound(config_env_data *data)
{
struct Library *ModuleBase;
BOOL ok=0;
// Busy the window
SetWindowBusy(data->window);
// Open play.module
if (ModuleBase=OpenLibrary("dopus5:modules/play.module",0))
{
short num;
Cfg_SoundEntry *sound;
// Get selection
if ((num=GetGadgetValue(data->option_list,GAD_SETTINGS_SOUNDLIST))>-1 &&
(sound=(Cfg_SoundEntry *)Att_FindNode((Att_List *)&data->sound_list,num)) &&
sound->dse_Sound[0])
{
struct Node node;
struct List list;
// Build file list
NewList(&list);
node.ln_Name=sound->dse_Sound;
AddTail(&list,&node);
// Play the sound
Module_Entry(
&list,
data->window->WScreen,
data->ipc,
data->main_ipc,
(ULONG)data->window,
sound->dse_Volume<<8);
ok=1;
}
// Close module
CloseLibrary(ModuleBase);
}
// Unbusy the window
ClearWindowBusy(data->window);
if (!ok) DisplayBeep(data->window->WScreen);
}
ULONG openWindow(Object *app, Object *win)
{
ULONG v;
if (win)
{
set(win,MUIA_Window_Open,TRUE);
v = xget(win, MUIA_Window_Open);
if (!v)
v = xget(app, MUIA_Application_Iconified);
}
else v = FALSE;
if (!v) DisplayBeep(0);
return v;
}
BOOL OverwriteA(STRPTR text, UWORD x, UWORD length, UWORD ptrn_length, struct InstData *data)
{
BOOL result = TRUE;
ENTER();
if(length < ptrn_length)
{
ULONG expand = ptrn_length-length;
if(data->MaxLength && strlen(data->Contents)+expand > (unsigned int)(data->MaxLength-1))
{
ptrn_length -= expand;
ptrn_length += (data->MaxLength-1)-strlen(data->Contents);
result = FALSE;
}
if(ExpandContentString(&data->Contents, expand) == TRUE)
memmove(data->Contents+x+ptrn_length, data->Contents+x+length, strlen(data->Contents+x+length)+1);
else
E(DBF_ALWAYS, "content expansion by %ld bytes failed", expand);
}
else
{
memmove(data->Contents+x+ptrn_length, data->Contents+x+length, strlen(data->Contents+x+length)+1);
}
CopyMem(text, data->Contents+x, ptrn_length);
if(data->BufferPos >= x)
{
data->BufferPos += ptrn_length-length;
if(data->BufferPos < x)
data->BufferPos = x;
}
if(result == FALSE)
DisplayBeep(NULL);
RETURN(result);
return result;
}
// Group handler
void __saveds backdrop_group_handler(void)
{
IPCData *ipc;
GroupData *group=0;
// Do group
if (ipc=IPC_ProcStartup((ULONG *)&group,backdrop_group_init))
{
// Read objects
SetBusyPointer(group->window);
backdrop_read_group_objects(group);
ClearPointer(group->window);
// Event loop
FOREVER
{
IPCMessage *msg;
BOOL quit_flag=0;
// Got an AppWindow?
if (group->appwindow)
{
DOpusAppMessage *amsg;
BOOL beep=0;
// AppMessages?
while (amsg=(DOpusAppMessage *)GetMsg(group->appport))
{
short arg;
char path[256];
BackdropObject *drop_obj;
// Lock backdrop list
lock_listlock(&group->info->objects,1);
// Set busy pointer
if (group->window) SetBusyPointer(group->window);
// Dropped on an object?
if (drop_obj=backdrop_get_object(group->info,amsg->da_Msg.am_MouseX,amsg->da_Msg.am_MouseY,0))
{
USHORT qual;
// Get qualifiers
qual=(InputBase)?PeekQualifier():0;
// Is shift/alt down?
if (qual&(IEQUALIFIER_LSHIFT|IEQUALIFIER_LALT)==(IEQUALIFIER_LSHIFT|IEQUALIFIER_LALT))
{
// Get path of first file
GetWBArgPath(&amsg->da_Msg.am_ArgList[0],path,256);
// Replace the image
backdrop_replace_icon_image(group->info,path,drop_obj);
}
// Run program with args
else
backdrop_object_open(
group->info,
drop_obj,
0,
0,
amsg->da_Msg.am_NumArgs,
amsg->da_Msg.am_ArgList);
}
// Otherwise, adding objects to the group
else
for (arg=0;arg<amsg->da_Msg.am_NumArgs;arg++)
{
// Valid name?
if (*amsg->da_Msg.am_ArgList[arg].wa_Name)
{
short x,y;
// Get full path name
GetWBArgPath(&amsg->da_Msg.am_ArgList[arg],path,256);
// Default to no position
x=-1;
y=-1;
// Dopus app message?
if (CheckAppMessage(amsg))
{
// Get icon position
x=amsg->da_DragOffset.x+amsg->da_Msg.am_MouseX+amsg->da_DropPos[arg].x;
y=amsg->da_DragOffset.y+amsg->da_Msg.am_MouseY+amsg->da_DropPos[arg].y;
}
// Add group object
backdrop_group_add_object(group->name,group->info,path,x,y);
}
// Otherwise, set beep flag for error
else
if (!beep)
{
beep=1;
DisplayBeep(group->window->WScreen);
}
}
// Clear busy pointer
if (group->window) ClearPointer(group->window);
// Unlock backdrop list
unlock_listlock(&group->info->objects);
// Reply to message
ReplyMsg((struct Message *)amsg);
}
}
// Icon notification
if (group->info->notify_req)
{
DOpusNotify *notify;
// Get notify message
if (notify=(DOpusNotify *)GetMsg(group->info->notify_port))
backdrop_check_notify(group->info,notify,0);
}
// IPC messages?
while (msg=(IPCMessage *)GetMsg(ipc->command_port))
{
// Look at message
switch (msg->command)
{
// Activate
case IPC_ACTIVATE:
// Bring window to front
if (group->window)
backdrop_show_group(group);
break;
// Quit
case IPC_QUIT:
quit_flag=1;
group->got_quit=1;
break;
// Hide
case IPC_HIDE:
backdrop_hide_group(group);
break;
// Show
case IPC_SHOW:
group->screen=(struct Screen *)msg->data;
backdrop_show_group(group);
break;
// Reset (menus)
case IPC_RESET:
// Gotta window?
if (group->window)
{
// Reset menus?
if (msg->flags)
{
display_free_menu(group->window);
display_get_menu(group->window);
}
// Fix menus
display_fix_menu(group->window,WINDOW_GROUP,0);
}
break;
// New font
case GROUP_NEW_FONT:
// Get new font
backdrop_get_font(group->info);
// Redraw objects
backdrop_show_objects(group->info,BDSF_CLEAR|BDSF_RESET);
break;
// New name
case GROUP_NEW_NAME:
// Copy name
strcpy(group->name,msg->data_free);
// Update window title
if (group->window) SetWindowTitles(group->window,group->name,(char *)-1);
break;
// Add a new icon
case GROUP_ADD_ICON:
// Lock backdrop list
lock_listlock(&group->info->objects,1);
// Set busy pointer
if (group->window) SetBusyPointer(group->window);
// Add object
backdrop_group_add_object(group->name,group->info,msg->data_free,-1,-1);
// Clear busy pointer
if (group->window) ClearPointer(group->window);
// Unlock backdrop list
unlock_listlock(&group->info->objects);
break;
// New backfill pattern
case LISTER_BACKFILL_CHANGE:
// Window open?
if (group->window)
{
// Install appropriate hook
InstallLayerHook(
group->window->WLayer,
(msg->flags)?&group->pattern.hook:LAYERS_BACKFILL);
// Redraw window
erase_window(group->window);
// Redraw icons
backdrop_show_objects(group->info,0);
}
break;
// Delete from group
case GROUP_DELETE:
SetBusyPointer(group->window);
backdrop_remove_group_objects(group,(BackdropObject *)msg->data);
ClearPointer(group->window);
break;
// Help
case IPC_HELP:
// Show help for group
help_show_help(HELP_PROGRAM_GROUP,0);
break;
// Do a function
case LISTER_DO_FUNCTION:
// Arrange icons?
if (msg->data>=(APTR)MENU_LISTER_ARRANGE_NAME &&
msg->data<=(APTR)MENU_LISTER_ARRANGE_SIZE)
{
// Do cleanup
backdrop_cleanup(group->info,BSORT_NAME+(((ULONG)msg->data)-MENU_LISTER_ARRANGE_NAME),0);
}
break;
}
// Reply to message
IPC_Reply(msg);
}
// Is window open?
if (group->window)
{
struct IntuiMessage *imsg;
// Check timer
if (CheckTimer(group->timer))
{
// Dragging something?
if (group->info->flags&BDIF_DRAGGING)
{
// Check for deadlocks
if (group->info->last_tick==group->info->tick_count)
{
// Stop drag
backdrop_stop_drag(group->info);
}
// Remember tick count
group->info->last_tick=group->info->tick_count;
}
// Re-start timer
StartTimer(group->timer,0,500000);
}
// Window messages
while (imsg=(struct IntuiMessage *)GetMsg(group->window->UserPort))
{
struct IntuiMessage msg_copy;
struct MenuItem *item;
// Copy message
msg_copy=*imsg;
// Menu verify?
if (imsg->Class==IDCMP_MENUVERIFY)
{
// See if we want to swallow it
if (!backdrop_test_rmb(group->info,imsg,&msg_copy,TRUE))
{
// Did event happen over the window?
if (imsg->MouseX>=0 &&
imsg->MouseY>=0 &&
imsg->MouseX<group->window->Width &&
imsg->MouseY<group->window->Height &&
imsg->Qualifier&IEQUALIFIER_RBUTTON)
{
// Cancel menu event
imsg->Code=MENUCANCEL;
// Change our copy to MOUSEBUTTONS
msg_copy.Class=IDCMP_MOUSEBUTTONS;
msg_copy.Code=MENUDOWN;
// Kludge for MagicMenu
if (msg_copy.Seconds==0)
CurrentTime(&msg_copy.Seconds,&msg_copy.Micros);
}
}
}
// Resize/refresh?
if (imsg->Class==IDCMP_NEWSIZE ||
imsg->Class==IDCMP_REFRESHWINDOW)
{
// Handle message
backdrop_idcmp(group->info,imsg,0);
// Reply to message
ReplyMsg((struct Message *)imsg);
continue;
}
// Reply to message
ReplyMsg((struct Message *)imsg);
// Is it a backdrop message?
if (backdrop_idcmp(group->info,&msg_copy,0))
continue;
// Look at message class
switch (msg_copy.Class)
{
// Window closed
case IDCMP_CLOSEWINDOW:
quit_flag=1;
break;
// Window is inactive
case IDCMP_INACTIVEWINDOW:
// Abort timer if running
StopTimer(group->timer);
break;
// Window is active
case IDCMP_ACTIVEWINDOW:
// Start timer if not running
StartTimer(group->timer,1,0);
break;
// Key press
case IDCMP_RAWKEY:
// Help?
if (msg_copy.Code==0x5f &&
!(msg_copy.Qualifier&VALID_QUALIFIERS))
{
help_get_help(
msg_copy.MouseX+group->window->LeftEdge,
msg_copy.MouseY+group->window->TopEdge,
msg_copy.Qualifier);
}
// Close?
else
if (msg_copy.Code==0x45 &&
msg_copy.Qualifier&IEQUAL_ANYSHIFT) quit_flag=1;
break;
// Button pressed
case IDCMP_MOUSEBUTTONS:
// Right button?
if (msg_copy.Code==MENUDOWN)
{
USHORT res;
// Do popup menu
if (group->popup &&
(res=DoPopUpMenu(group->window,&group->popup->ph_Menu,NULL,MENUDOWN))!=(USHORT)-1)
{
// Help?
if (res&POPUP_HELPFLAG)
{
// Get help ID
res&=~POPUP_HELPFLAG;
// Do help
help_menu_help(res,0);
break;
}
// Do the function
quit_flag=backdrop_group_do_function(group,res,0);
}
}
break;
// Menu event
case IDCMP_MENUPICK:
case IDCMP_MENUHELP:
{
struct Menu *oldstrip=group->window->MenuStrip;
USHORT nextselect;
// Get item
nextselect=msg_copy.Code;
while (item=ItemAddress(group->window->MenuStrip,nextselect))
{
// get next
nextselect=item->NextSelect;
// Help?
if (msg_copy.Class==IDCMP_MENUHELP)
{
help_menu_help((long)GTMENUITEM_USERDATA(item),0);
break;
}
// Do the function
quit_flag=backdrop_group_do_function(group,(ULONG)GTMENUITEM_USERDATA(item),item);
// Check valid next
if (!nextselect || !group->window || oldstrip!=group->window->MenuStrip)
break;
}
}
break;
}
}
}
// Check quit flag
if (quit_flag) break;
// Wait for event
Wait( 1<<ipc->command_port->mp_SigBit|
1<<group->timer->port->mp_SigBit|
((group->info->notify_req)?(1<<group->info->notify_port->mp_SigBit):0)|
((group->window)?(1<<group->window->UserPort->mp_SigBit):0)|
((group->appwindow)?(1<<group->appport->mp_SigBit):0));
}
// Close window
backdrop_free_group(group);
// Send goodbye
IPC_Goodbye(ipc,&main_ipc,0);
}
void processMsg(void)
{
struct IntuiMessage *msg;
struct DropMessage *dm;
int source,target;
while(!ende)
{
WaitPort(win->UserPort);
while((msg = GTD_GetIMsg(win->UserPort)) != 0)
{
imsg = *msg;
if (imsg.Class == IDCMP_OBJECTDROP)
{
if ((dm = imsg.IAddress) != 0)
{
if (!dm->dm_Object.od_Owner && dm->dm_Target)
{
target = dm->dm_Target->GadgetID;
switch(target)
{
case 1:
case 2:
source = dm->dm_Gadget->GadgetID;
if (source < 3)
{
source--; target--;
GT_SetGadgetAttrs(lvgad[0],win,NULL,GTLV_Labels,~0L,TAG_END);
GT_SetGadgetAttrs(lvgad[1],win,NULL,GTLV_Labels,~0L,TAG_END);
if (target)
MoveTo(dm->dm_Object.od_Object,&list[source],dm->dm_SourceEntry,&list[target],dm->dm_TargetEntry);
else
{
Remove(dm->dm_Object.od_Object);
AddTail(&list[target],dm->dm_Object.od_Object);
}
GT_SetGadgetAttrs(lvgad[0],win,NULL,GTLV_Labels,&list[0],TAG_END);
GT_SetGadgetAttrs(lvgad[1],win,NULL,GTLV_Labels,&list[1],TAG_END);
}
else
{
target--;
GT_SetGadgetAttrs(lvgad[target],win,NULL,GTLV_Labels,~0L,TAG_END);
if ((node = AllocMem(sizeof(struct Node),MEMF_CLEAR | MEMF_PUBLIC)) != 0)
{
node->ln_Name = in.in_Name;
InsertAt(&list[target],node,dm->dm_TargetEntry);
}
GT_SetGadgetAttrs(lvgad[target],win,NULL,GTLV_Labels,&list[target],TAG_END);
}
break;
case 3:
DisplayBeep(NULL);
break;
case 4:
case 5:
source = dm->dm_Gadget->GadgetID-1;
GT_SetGadgetAttrs(lvgad[source],win,NULL,GTLV_Labels,~0L,TAG_END);
if (target == 4)
{
if ((node = AllocMem(sizeof(struct Node),MEMF_CLEAR | MEMF_PUBLIC)) != 0)
{
node->ln_Name = ((struct ImageNode *)dm->dm_Object.od_Object)->in_Name;
AddTail(&list[source],node);
}
}
else
{
Remove((struct Node *)dm->dm_Object.od_Object);
FreeMem(dm->dm_Object.od_Object,sizeof(struct Node));
}
GT_SetGadgetAttrs(lvgad[source],win,NULL,GTLV_Labels,&list[source],TAG_END);
break;
}
}
else if (!dm->dm_Object.od_Owner)
{
DisplayBeep(NULL); // unsupported drag?!
}
else if (!stricmp(dm->dm_Object.od_Owner,"dragtest"))
{
char t[256];
if (GTD_GetString(&dm->dm_Object,t,256))
ErrorRequest("I do not want a node from a clone of mine.\nEspecially, I don't like \"%s\".",t);
}
else if (!strcmp(dm->dm_Object.od_Owner,"intuition"))
ErrorRequest("An object from a custom gadget?\nThat's nothing for me.",dm->dm_Object.od_Owner);
else
ErrorRequest("An object from %s?\nSounds interesting.",dm->dm_Object.od_Owner);
}
else
DisplayBeep(NULL);
}
GTD_ReplyIMsg(msg);
switch(imsg.Class)
{
case IDCMP_GADGETDOWN:
break;
case IDCMP_GADGETUP:
switch(((struct Gadget *)imsg.IAddress)->GadgetID)
{
case 3:
GT_SetGadgetAttrs(lvgad[0],win,NULL,GTLV_Labels,~0L,TAG_END);
if ((node = AllocMem(sizeof(struct Node),MEMF_CLEAR | MEMF_PUBLIC)) != 0)
{
node->ln_Name = in.in_Name;
AddTail(&list[0],node);
}
GT_SetGadgetAttrs(lvgad[0],win,NULL,GTLV_Labels,&list[0],TAG_END);
break;
}
break;
case IDCMP_CLOSEWINDOW:
ende = TRUE;
break;
}
}
}
}
// Help process
IPC_EntryCode(help_proc, static)
{
struct NewAmigaGuide guide;
AMIGAGUIDECONTEXT help=0;
IPCData *ipc;
char buf[256],filename[256];
ULONG waitbits;
BOOL help_ok=0;
struct MinList queue;
IPCMessage *msg;
// Do startup
if ((ipc=IPC_ProcStartup(0,0)))
{
// Get initial database name
strcpy(filename,"dopus5:Help/dopus5.guide");
// Get wait bits
waitbits=1<<ipc->command_port->mp_SigBit;
// Initialise queue list
NewList((struct List *)&queue);
// Event loop
FOREVER
{
struct AmigaGuideMsg *agm;
BOOL quit_flag=0;
// AmigaGuide messages?
while (help && (agm=GetAmigaGuideMsg(help)))
{
// Quit?
if (agm->agm_Type==ShutdownMsgID)
quit_flag=1;
// Ok to proceed?
else if (agm->agm_Type==ActiveToolID ||
agm->agm_Type==ToolStatusID)
{
// Ok to send link commands
help_ok=1;
// Go through queue
for (msg=(IPCMessage *)queue.mlh_Head;
msg->msg.mn_Node.ln_Succ;)
{
IPCMessage *next=(IPCMessage *)msg->msg.mn_Node.ln_Succ;
// Build command string
lsprintf(buf,"link \"%s\"",(char *)msg->data_free);
// Send command
SendAmigaGuideCmdA(help,buf,0);
// Remove from queue
Remove((struct Node *)msg);
// Reply to message
IPC_Reply(msg);
// Get next
msg=next;
}
}
// Reply
ReplyAmigaGuideMsg(agm);
}
// Get messages
while ((msg=(IPCMessage *)GetMsg(ipc->command_port)))
{
// Look at command
switch (msg->command)
{
// Show a link?
case HELPCMD_LINK:
{
char *name;
// Get guide name
name=(char *)msg->data_free;
name+=strlen(name)+1;
// New guide file, or don't have a guide at all?
if ((*name && stricmp(name,filename)!=0) || !help)
{
// Shutdown the existing database
if (help) CloseAmigaGuide(help);
// Copy new filename
if (*name) strcpy(filename,name);
// Open new database
if (!(help=help_open_database(&guide,filename,GUI->screen,GUI->rexx_port_name)))
{
// Can't get database
DisplayBeep(GUI->screen_pointer);
quit_flag=1;
}
// Got database
else
{
// Get waitbits
waitbits=AmigaGuideSignal(help);
waitbits|=1<<ipc->command_port->mp_SigBit;
}
// Can no longer take messages (need an ok from AG)
help_ok=0;
}
// Haven't got ok message yet?
if (!help_ok)
{
// Add message to queue
AddTail((struct List *)&queue,(struct Node *)msg);
// Clear pointer so it won't get replied
msg=0;
}
// Ok to send command
else
{
// Build command string
lsprintf(buf,"link \"%s\"",(char *)msg->data_free);
// Send command
SendAmigaGuideCmdA(help,buf,0);
}
}
break;
// Hide/Quit
case IPC_HIDE:
case IPC_QUIT:
quit_flag=1;
break;
}
// Reply
IPC_Reply(msg);
}
// Check quit flag
if (quit_flag) break;
// Wait for events
Wait(waitbits);
}
// Close database
if (help) CloseAmigaGuide(help);
// Anything left in the queue?
for (msg=(IPCMessage *)queue.mlh_Head;
msg->msg.mn_Node.ln_Succ;)
{
IPCMessage *next=(IPCMessage *)msg->msg.mn_Node.ln_Succ;
// Reply to message
IPC_Reply(msg);
// Get next
msg=next;
}
// Send goodbye message
IPC_Goodbye(ipc,&main_ipc,0);
}
// Drop some objects on another one
void backdrop_drop_object(BackdropInfo *info,BackdropObject *on_object)
{
BackdropObject *object;
char *buf,*dbuf;
struct InfoData __aligned data;
BPTR lock;
if (!(buf=AllocVec(512,0)))
return;
dbuf=buf+256;
// Drop on an AppIcon
if (on_object->type==BDO_APP_ICON)
{
DOpusAppMessage *msg;
struct MsgPort *port;
// Is the icon busy?
if (on_object->flags&BDOF_BUSY)
{
DisplayBeep(info->window->WScreen);
FreeVec(buf);
return;
}
// Build AppMessage
if (!(msg=backdrop_appmessage(info,1)))
{
FreeVec(buf);
return;
}
// Set message type
msg->da_Msg.am_Type=MTYPE_APPICON;
// Get AppInfo
port=WB_AppWindowData(
(struct AppWindow *)on_object->misc_data,
&msg->da_Msg.am_ID,
&msg->da_Msg.am_UserData);
// Send the message
PutMsg(port,(struct Message *)msg);
FreeVec(buf);
return;
}
// Only support dropping on disks at the moment
if ((on_object->type!=BDO_DISK && on_object->type!=BDO_BAD_DISK) ||
on_object->flags&(BDOF_ASSIGN|BDOF_CACHE))
{
DisplayBeep(info->window->WScreen);
FreeVec(buf);
return;
}
// Go through backdrop list
for (object=(BackdropObject *)info->objects.list.lh_Head;
object->node.ln_Succ;
object=(BackdropObject *)object->node.ln_Succ)
{
// Selected disk?
if (object->type==BDO_DISK && !(object->flags&(BDOF_ASSIGN|BDOF_CACHE)) && object->state)
{
BPTR lock;
// Get disk lock
if (lock=backdrop_icon_lock(object))
{
// This is the source
Info(lock,&data);
// Get device name
DeviceFromLock(lock,buf);
// Unlock lock
UnLock(lock);
}
break;
}
}
// Didn't get anything?
if (!object->node.ln_Succ)
{
DisplayBeep(info->window->WScreen);
FreeVec(buf);
return;
}
// Drop on a bad disk?
if (on_object->type==BDO_BAD_DISK)
{
// Get device name
strcpy(dbuf,on_object->name);
}
// Real disk
else
{
// Get destination disk lock
if (!(lock=backdrop_icon_lock(on_object)))
{
FreeVec(buf);
return;
}
// Destination is the one we dropped it on
Info(lock,&data);
// Get device name
DeviceFromLock(lock,dbuf);
UnLock(lock);
}
// Launch diskcopy
function_launch(
FUNCTION_RUN_FUNCTION,
def_function_diskcopy,
0,
0,
0,0,
0,0,
BuildArgArray(buf,dbuf,0),
0,0);
FreeVec(buf);
}
void
EditClipping(void)
{
int i;
long mflags;
static int sizes[] = { 8, 16, 20, 24, 28, 32, 36 };
char buf[40];
int done = 0, okay = 0;
long code, qual, class;
register struct Gadget *gd, *dgad;
register struct Window *nw;
register struct IntuiMessage *imsg;
register struct PropInfo *pip;
register struct Screen *scrn;
long aidx;
int lmxsize = mxsize, lmysize = mysize;
int lxclipbord = xclipbord, lyclipbord = yclipbord;
int msx, msy;
int drag = 0;
static int once = 0;
scrn = HackScreen;
if (!once) {
SetBorder(&ClipOkay);
SetBorder(&ClipCancel);
once = 1;
}
ClipNewWindowStructure1.Screen = scrn;
#ifdef INTUI_NEW_LOOK
if (IntuitionBase->LibNode.lib_Version >= 37) {
((struct PropInfo *) ClipXSIZE.SpecialInfo)->Flags |= PROPNEWLOOK;
((struct PropInfo *) ClipYSIZE.SpecialInfo)->Flags |= PROPNEWLOOK;
((struct PropInfo *) ClipXCLIP.SpecialInfo)->Flags |= PROPNEWLOOK;
((struct PropInfo *) ClipYCLIP.SpecialInfo)->Flags |= PROPNEWLOOK;
}
#endif
if (WINVERS_AMIV || WINVERS_AMII) {
#ifdef INTUI_NEW_LOOK
ClipNewWindowStructure1.Extension = wintags;
ClipNewWindowStructure1.Flags |= WFLG_NW_EXTENDED;
#ifdef __GNUC__
fillhook.h_Entry = (void *) &LayerFillHook;
#else
fillhook.h_Entry = (ULONG (*) ()) LayerFillHook;
#endif
fillhook.h_Data = (void *) -2;
fillhook.h_SubEntry = 0;
#endif
}
nw = OpenWindow((void *) &ClipNewWindowStructure1);
if (nw == NULL) {
DisplayBeep(NULL);
return;
}
ShowClipValues(nw);
mflags = AUTOKNOB | FREEHORIZ;
#ifdef INTUI_NEW_LOOK
if (IntuitionBase->LibNode.lib_Version >= 37) {
mflags |= PROPNEWLOOK;
}
#endif
for (i = 0; i < 7; ++i) {
if (mxsize <= sizes[i])
break;
}
NewModifyProp(&ClipXSIZE, nw, NULL, mflags, (i * MAXPOT) / 6, 0,
MAXPOT / 6, 0, 1);
for (i = 0; i < 7; ++i) {
if (mysize <= sizes[i])
break;
}
NewModifyProp(&ClipYSIZE, nw, NULL, mflags, (i * MAXPOT) / 6, 0,
MAXPOT / 6, 0, 1);
NewModifyProp(&ClipXCLIP, nw, NULL, mflags,
((xclipbord - 2) * MAXPOT) / 6, 0, MAXPOT / 6, 0, 1);
NewModifyProp(&ClipYCLIP, nw, NULL, mflags,
((yclipbord - 2) * MAXPOT) / 6, 0, MAXPOT / 6, 0, 1);
while (!done) {
WaitPort(nw->UserPort);
while (imsg = (struct IntuiMessage *) GetMsg(nw->UserPort)) {
gd = (struct Gadget *) imsg->IAddress;
code = imsg->Code;
class = imsg->Class;
qual = imsg->Qualifier;
msx = imsg->MouseX;
msy = imsg->MouseY;
ReplyMsg((struct Message *) imsg);
switch (class) {
case VANILLAKEY:
if (code == '\33')
okay = 0, done = 1;
else if (code == 'v' && qual == AMIGALEFT)
okay = done = 1;
else if (code == 'b' && qual == AMIGALEFT)
okay = 0, done = 1;
else if (code == 'o' || code == 'O')
okay = done = 1;
else if (code == 'c' || code == 'C')
okay = 0, done = 1;
break;
case CLOSEWINDOW:
done = 1;
break;
case GADGETUP:
drag = 0;
if (gd->GadgetID == XSIZE || gd->GadgetID == YSIZE
|| gd->GadgetID == XCLIP || gd->GadgetID == YCLIP) {
pip = (struct PropInfo *) gd->SpecialInfo;
aidx = pip->HorizPot / (MAXPOT / 6);
if (gd->GadgetID == XSIZE) {
mxsize = sizes[aidx];
} else if (gd->GadgetID == YSIZE) {
mysize = sizes[aidx];
} else if (gd->GadgetID == XCLIP) {
xclipbord = aidx + 2;
} else if (gd->GadgetID == YCLIP) {
yclipbord = aidx + 2;
}
ShowClipValues(nw);
#ifdef OPT_DISPMAP
dispmap_sanity();
#endif
} else if (gd->GadgetID == GADOKAY) {
done = 1;
okay = 1;
} else if (gd->GadgetID == GADCANCEL) {
done = 1;
okay = 0;
}
ReportMouse(0, nw);
reclip = 2;
doredraw();
flush_glyph_buffer(amii_wins[WIN_MAP]->win);
reclip = 0;
break;
case GADGETDOWN:
drag = 1;
dgad = gd;
ReportMouse(1, nw);
break;
case MOUSEMOVE:
if (!drag)
break;
pip = (struct PropInfo *) dgad->SpecialInfo;
aidx = pip->HorizPot / (MAXPOT / 6);
Move(nw->RPort,
dgad->LeftEdge + (nw->Width + dgad->Width) + 8,
dgad->TopEdge + nw->RPort->TxBaseline);
if (dgad->GadgetID == XSIZE) {
mxsize = sizes[aidx];
sprintf(buf, "%d ", lmxsize);
} else if (dgad->GadgetID == YSIZE) {
mysize = sizes[aidx];
sprintf(buf, "%d ", mysize);
} else if (dgad->GadgetID == XCLIP) {
xclipbord = aidx + 2;
sprintf(buf, "%d ", xclipbord);
} else if (dgad->GadgetID == YCLIP) {
yclipbord = aidx + 2;
sprintf(buf, "%d ", yclipbord);
}
SetAPen(nw->RPort, 5);
SetBPen(nw->RPort, amii_otherBPen);
SetDrMd(nw->RPort, JAM2);
Text(nw->RPort, buf, strlen(buf));
#ifdef OPT_DISPMAP
dispmap_sanity();
#endif
break;
}
}
}
CloseWindow(nw);
/* Restore oldvalues if cancelled. */
if (!okay) {
mxsize = lmxsize;
mysize = lmysize;
xclipbord = lxclipbord;
yclipbord = lyclipbord;
}
}
// 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 ami_drag_save(struct Window *win)
{
ULONG which = WBO_NONE, type;
char path[1025], dpath[1025];
ULONG source_size;
ami_drag_icon_close(NULL);
ami_autoscroll = FALSE;
if(nsoption_charp(pubscreen_name) && (strcmp(nsoption_charp(pubscreen_name),"Workbench") == 0))
{
which = WhichWorkbenchObject(NULL,scrn->MouseX,scrn->MouseY,
WBOBJA_Type,&type,
WBOBJA_FullPath,&path,
WBOBJA_FullPathSize,1024,
WBOBJA_DrawerPath,&dpath,
WBOBJA_DrawerPathSize,1024,
TAG_DONE);
}
if((which == WBO_DRAWER) || ((which == WBO_ICON) && (type > WBDRAWER)))
{
strcpy(path,dpath);
}
else if(which == WBO_NONE)
{
if(drag_save == GUI_SAVE_TEXT_SELECTION)
ami_drag_selection((struct gui_window *)drag_save_data);
else DisplayBeep(scrn);
drag_save = 0;
drag_save_data = NULL;
return;
}
if(path[0] == '\0')
{
DisplayBeep(scrn);
drag_save = 0;
drag_save_data = NULL;
return;
}
ami_update_pointer(win, GUI_POINTER_WAIT);
switch(drag_save)
{
case GUI_SAVE_OBJECT_ORIG: // object
case GUI_SAVE_SOURCE:
{
struct hlcache_handle *c = drag_save_data;
BPTR fh = 0;
AddPart(path, content_get_title(c), 1024);
ami_file_save(AMINS_SAVE_SOURCE, path, win, c, NULL, NULL);
}
break;
case GUI_SAVE_TEXT_SELECTION: // selection
AddPart(path,"netsurf_text_selection",1024);
struct gui_window *g = (struct gui_window *) drag_save_data;
ami_file_save(AMINS_SAVE_SELECTION, path, win, NULL, NULL, g->shared->bw);
break;
case GUI_SAVE_COMPLETE:
{
struct hlcache_handle *c = drag_save_data;
BPTR lock = 0;
AddPart(path, content_get_title(c), 1024);
ami_file_save(AMINS_SAVE_COMPLETE, path, win, c, drag_save_gui->favicon, NULL);
}
break;
case GUI_SAVE_OBJECT_NATIVE:
{
hlcache_handle *c = drag_save_data;
AddPart(path, content_get_title(c), 1024);
ami_file_save(AMINS_SAVE_IFF, path, win, c, NULL, NULL);
}
break;
default:
LOG(("Unsupported drag save operation %ld",drag_save));
break;
}
drag_save = 0;
drag_save_data = NULL;
ami_update_pointer(win, GUI_POINTER_DEFAULT);
}
BOOL FileNameComplete(Object *obj, BOOL backwards, struct InstData *data)
{
BOOL edited = FALSE;
ENTER();
if(data->FNCBuffer != NULL)
{
if(data->FileEntries == 1)
{
DisplayBeep(NULL);
}
else
{
if(backwards)
{
if(--data->FileNumber < 0)
data->FileNumber = data->FileEntries-1;
}
else
{
if(++data->FileNumber >= data->FileEntries)
data->FileNumber = 0;
}
}
InsertFileName(data->FileNameStart, data);
edited = TRUE;
}
else
{
LONG pos = DoMethod(obj, MUIM_BetterString_FileNameStart, data->Contents, data->BufferPos);
switch(pos)
{
case MUIR_BetterString_FileNameStart_Volume:
{
struct DosList *dl;
STRPTR volumeName = NULL;
char tmpBuffer[256];
UWORD cut;
pos = VolumeStart(data->Contents, data->BufferPos);
if((cut = data->BufferPos-pos) != 0)
{
dl = LockDosList(LDF_READ|LDF_DEVICES|LDF_VOLUMES|LDF_ASSIGNS);
while((dl = NextDosEntry(dl, LDF_READ|LDF_DEVICES|LDF_VOLUMES|LDF_ASSIGNS)) != NULL)
{
#ifdef __AROS__
strlcpy(tmpBuffer, dl->dol_Ext.dol_AROS.dol_DevName, sizeof tmpBuffer);
#else
// dol_Name is a BSTR, we have to convert it to a regular C string
char *bstr = BADDR(dl->dol_Name);
// a BSTR cannot exceed 255 characters, hence the buffer size of 256 is enough in any case
strlcpy(tmpBuffer, &bstr[1], (unsigned char)bstr[0]);
#endif
if(Strnicmp(tmpBuffer, data->Contents+pos, cut) == 0)
{
volumeName = tmpBuffer;
break;
}
}
if(volumeName != NULL)
{
if(OverwriteA(volumeName, pos, cut, strlen(volumeName)+1, data))
data->Contents[data->BufferPos-1] = ':';
edited = TRUE;
}
UnLockDosList(LDF_READ|LDF_DEVICES|LDF_VOLUMES|LDF_ASSIGNS);
}
}
break;
default:
{
struct FNCData *fncbuffer;
struct FNCData *fncframe;
struct ExAllControl *control;
BPTR dirlock;
char pattern[42];
UWORD namestart = data->BufferPos;
char oldletter = '\0';
BOOL filename = TRUE;
while(filename)
{
switch(*(data->Contents+namestart-1))
{
case '/':
case ':':
filename = FALSE;
break;
default:
namestart--;
break;
}
}
if((data->BufferPos-namestart) < 32)
{
strlcpy(pattern, data->Contents+namestart, sizeof(pattern));
strlcat(pattern, "~(#?.info)", sizeof(pattern));
oldletter = data->Contents[namestart];
data->Contents[namestart] = '\0';
if((fncbuffer = (struct FNCData *)SharedPoolAlloc(4100)) != NULL)
{
fncbuffer->next = NULL;
if((control = (struct ExAllControl *)AllocDosObject(DOS_EXALLCONTROL, NULL)))
{
char tokenized[sizeof(pattern) * 2 + 2];
if(ParsePatternNoCase(pattern, tokenized, sizeof(tokenized)) != -1)
control->eac_MatchString = tokenized;
if((dirlock = Lock(data->Contents+pos, ACCESS_READ)))
{
UWORD entries = 0;
fncframe = fncbuffer;
while(fncframe && ExAll(dirlock, &fncframe->buffer, 4096, ED_TYPE, control))
{
entries += control->eac_Entries;
if((fncframe->next = (struct FNCData *)SharedPoolAlloc(4100)))
fncframe->next->next = NULL;
fncframe = fncframe->next;
}
control->eac_Entries += entries;
data->FileNumber = backwards ? control->eac_Entries-1 : 0;
data->FileEntries = control->eac_Entries;
data->FileNameStart = namestart;
data->FNCBuffer = fncbuffer;
if(control->eac_Entries)
{
data->Contents[namestart] = oldletter;
InsertFileName(namestart, data);
edited = TRUE;
}
UnLock(dirlock);
}
else
{
SharedPoolFree(fncbuffer);
}
FreeDosObject(DOS_EXALLCONTROL, (APTR)control);
}
}
}
if(edited == FALSE)
data->Contents[namestart] = oldletter;
}
break;
}
}
RETURN(edited);
return edited;
}
int main( VOID )
{
LONG arg[5] = {0};
struct RDArgs *args = NULL;
int rc = 10;
if((G = (struct GlobalData*)AllocMem(sizeof(struct GlobalData),MEMF_PUBLIC|MEMF_CLEAR)))
{
/* Initialize 'GlobalData' */
G->WbStartup = ((_WBenchMsg != NULL) ? TRUE : FALSE);
if((IntuitionBase = OpenLibrary("intuition.library", 0)))
{
if((DOSBase = OpenLibrary("dos.library", 0)))
{
args = ReadArgs( TEMPLATE, (long*)arg, NULL);
if(!args)
{
if((rc = _7zUI ( )) != 0 )
{
/* failed creating MUI App */
if( G->WbStartup )
DisplayBeep(NULL);
PrintFault(IoErr(),0L);
}
}
else
{
int mode = 1;
BPTR WhereToExtract = 0,
OldCurrentdir = 0;
G->CliUsage = TRUE;
if( TOFOLDER )
{
MakeDir( TOFOLDER );
mode=SwitchCurrentdir(TOFOLDER,
&WhereToExtract,
&OldCurrentdir );
}
if( mode )
{
mode = LIST_ARG ? 1 : TEST_ARG ? 2:3;
rc = _7zArchive( ARCHIVE_ARG, mode );
if( TOFOLDER )
SwitchCurrentdir(NULL,
&WhereToExtract,
&OldCurrentdir);
}
FreeArgs( args );
}
CloseLibrary( DOSBase );
}
CloseLibrary( IntuitionBase );
}
FreeMem( G, sizeof(struct GlobalData));
}
return rc;
}
void ami_drag_selection(struct selection *s)
{
struct box *text_box;
int x;
int y;
char *utf8text;
struct ami_text_selection *sel;
struct IFFHandle *old_iffh = iffh;
struct gui_window_2 *gwin = ami_window_at_pointer(AMINS_WINDOW);
if(!gwin)
{
DisplayBeep(scrn);
return;
}
x = gwin->win->MouseX;
y = gwin->win->MouseY;
if(text_box = ami_text_box_at_point(gwin, (ULONG *)&x, (ULONG *)&y))
{
ami_utf8_clipboard = true;
iffh = ami_clipboard_init_internal(1);
if(gui_copy_to_clipboard(s))
{
browser_window_mouse_click(gwin->bw, BROWSER_MOUSE_PRESS_1, x, y);
browser_window_key_press(gwin->bw, KEY_PASTE);
}
ami_clipboard_free_internal(iffh);
iffh = old_iffh;
ami_utf8_clipboard = false;
}
else
{
x = gwin->win->MouseX;
y = gwin->win->MouseY;
if(ami_gadget_hit(gwin->objects[GID_URL], x, y))
{
if(sel = ami_selection_to_text(gwin))
{
utf8text = ami_utf8_easy(sel->text);
RefreshSetGadgetAttrs((struct Gadget *)gwin->objects[GID_URL],
gwin->win, NULL, STRINGA_TextVal, utf8text, TAG_DONE);
FreeVec(sel);
ami_utf8_free(utf8text);
}
}
else if(ami_gadget_hit(gwin->objects[GID_SEARCHSTRING], x, y))
{
if(sel = ami_selection_to_text(gwin))
{
utf8text = ami_utf8_easy(sel->text);
RefreshSetGadgetAttrs((struct Gadget *)gwin->objects[GID_SEARCHSTRING],
gwin->win, NULL, STRINGA_TextVal, utf8text, TAG_DONE);
FreeVec(sel);
ami_utf8_free(utf8text);
}
}
else
{
DisplayBeep(scrn);
}
}
}
void
amii_player_selection()
{
register struct Window *cwin;
register struct IntuiMessage *imsg;
register int aredone = 0;
register struct Gadget *gd;
static int once=0;
long class, code;
amii_clear_nhwindow( WIN_BASE );
if( *pl_character ){
pl_character[ 0 ] = toupper( pl_character[ 0 ] );
if( index( pl_classes, pl_character[ 0 ] ) )
return;
}
if( !once ){
if( bigscreen ){
Type_NewWindowStructure1.TopEdge =
(HackScreen->Height/2) - (Type_NewWindowStructure1.Height/2);
}
for( gd = Type_NewWindowStructure1.FirstGadget; gd;
gd = gd->NextGadget )
{
if( gd->GadgetID != 0 )
SetBorder( gd );
}
once = 1;
}
Type_NewWindowStructure1.Screen = HackScreen;
if( ( cwin = OpenShWindow( (void *)&Type_NewWindowStructure1 ) ) == NULL )
{
return;
}
WindowToFront( cwin );
while( !aredone )
{
WaitPort( cwin->UserPort );
while( ( imsg = (void *) GetMsg( cwin->UserPort ) ) != NULL )
{
class = imsg->Class;
code = imsg->Code;
gd = (struct Gadget *)imsg->IAddress;
ReplyMsg( (struct Message *)imsg );
switch( class )
{
case VANILLAKEY:
if( index( pl_classes, toupper( code ) ) )
{
pl_character[0] = toupper( code );
aredone = 1;
}
else if( code == ' ' || code == '\n' || code == '\r' )
{
#ifdef TOURIST
strcpy( pl_character, roles[ rnd( 11 ) ] );
#else
strcpy( pl_character, roles[ rnd( 10 ) ] );
#endif
aredone = 1;
amii_clear_nhwindow( WIN_BASE );
CloseShWindow( cwin );
RandomWindow( pl_character );
return;
}
else if( code == 'q' || code == 'Q' )
{
CloseShWindow( cwin );
clearlocks();
exit_nhwindows(NULL);
terminate(0);
}
else
DisplayBeep( NULL );
break;
case GADGETUP:
switch( gd->GadgetID )
{
case 1: /* Random Character */
#ifdef TOURIST
strcpy( pl_character, roles[ rnd( 11 ) ] );
#else
strcpy( pl_character, roles[ rnd( 10 ) ] );
#endif
amii_clear_nhwindow( WIN_BASE );
CloseShWindow( cwin );
RandomWindow( pl_character );
return;
default:
pl_character[0] = gd->GadgetID;
break;
}
aredone = 1;
break;
case CLOSEWINDOW:
CloseShWindow( cwin );
clearlocks();
exit_nhwindows(NULL);
terminate(0);
break;
}
}
}
amii_clear_nhwindow( WIN_BASE );
CloseShWindow( cwin );
}
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))
{
struct IOAudio audio;
struct MsgPort *reply_port;
// Flash only?
if (mod_id==FLASH)
{
DisplayBeep(screen);
return 1;
}
// Create port
if (!(reply_port=CreateMsgPort()))
return 0;
// Fill out audio request
audio.ioa_Request.io_Message.mn_ReplyPort=reply_port;
audio.ioa_Request.io_Message.mn_Node.ln_Pri=90;
audio.ioa_Data=achannels;
audio.ioa_Length=sizeof(achannels);
// Open audio device
if (!(OpenDevice("audio.device",0,(struct IORequest *)&audio,0)))
{
// Initialise write command
audio.ioa_Request.io_Command=CMD_WRITE;
audio.ioa_Request.io_Flags=ADIOF_PERVOL;
audio.ioa_Volume=64;
audio.ioa_Data=(UBYTE *)beepwave;
// It's an alarm?
if (mod_id==ALARM)
{
short a;
// Waveform size
audio.ioa_Length=8;
// Standard length
audio.ioa_Cycles=60;
// Five cycles
for (a=0;a<5;a++)
{
// High tone
audio.ioa_Period=800;
// Play sound
BeginIO((struct IORequest *)&audio);
WaitIO((struct IORequest *)&audio);
// Low tone
audio.ioa_Period=1200;
// Play sound
BeginIO((struct IORequest *)&audio);
WaitIO((struct IORequest *)&audio);
}
}
// Waveform size
else audio.ioa_Length=sizeof(beepwave);
// Set note information
audio.ioa_Period=(mod_id==BEEP)?300:800;
audio.ioa_Cycles=(mod_id==BEEP)?100:60;
// Play sound
BeginIO((struct IORequest *)&audio);
WaitIO((struct IORequest *)&audio);
// Close audio device
CloseDevice((struct IORequest *)&audio);
}
// Delete message port
DeleteMsgPort(reply_port);
return 1;
}
static Att_List *do_import_sites(struct opusftp_globals *og,char *path)
{
FuncArgs * fa;
struct site_entry *e;
int anon, acct;
BPTR cf;
char *buf;
Att_List *list=NULL;
if (!(buf=AllocVec(TMPBUFLEN,MEMF_CLEAR)))
{
DisplayBeep(NULL);
return(NULL);
}
if ((list = Att_NewList(LISTF_POOL)))
{
if ((cf = Open(path, MODE_OLDFILE )))
{
while ( FGets( cf, buf, TMPBUFLEN ))
{
if (*buf=='#' || *buf=='\n')
continue;
/* skip config entries */
if ((fa = ParseArgs( CONFIG_TEMPLATE, buf )))
{
DisposeArgs( fa );
continue;
}
/* handle addressbook stuff*/
if ((fa = ParseArgs( ADDR_TEMPLATE, buf )))
{
anon = fa->FA_Arguments[A_OPT_ANON];
acct = fa->FA_Arguments[A_OPT_ACCT];
// skip any lines starting with '---'
if (fa->FA_Arguments[A_OPT_HOST] &&
strncmp((char*)fa->FA_Arguments[A_OPT_HOST],"---",3)==0)
{
DisposeArgs( fa );
continue;
}
if (((anon == 0) != (acct == 0)) /* Can't be both or neither */
&& (anon || fa->FA_Arguments[A_OPT_USER]) /* User Account must have user name */
&& (fa->FA_Arguments[A_OPT_HOST] || fa->FA_Arguments[A_OPT_ADDR])/* Must have Hostname or Address */
)
{
if ((e = AllocVec( sizeof(struct site_entry), MEMF_CLEAR )))
{
e->se_anon = anon;
if (!anon)
{
if (fa->FA_Arguments[A_OPT_USER])
stccpy( e->se_user, (char*)fa->FA_Arguments[A_OPT_USER], USERNAMELEN );
if (fa->FA_Arguments[A_OPT_PASS])
stccpy( e->se_pass, (char*)fa->FA_Arguments[A_OPT_PASS], PASSWORDLEN );
}
/* Use Hostname or Address for the socket */
if (fa->FA_Arguments[A_OPT_HOST])
stccpy( e->se_host, (char*)fa->FA_Arguments[A_OPT_HOST], HOSTNAMELEN );
else
stccpy( e->se_host, (char*)fa->FA_Arguments[A_OPT_ADDR], HOSTNAMELEN );
// special port specified ?
if (fa->FA_Arguments[A_OPT_PORT])
e->se_port=*(int*)fa->FA_Arguments[A_OPT_PORT];
if (e->se_port<=0 || e->se_port >9999)
e->se_port=21;
/* Use Alias, Hostname, or Address in requester */
if (fa->FA_Arguments[A_OPT_ALIS])
stccpy( e->se_name, (char*)fa->FA_Arguments[A_OPT_ALIS], HOSTNAMELEN );
else if (fa->FA_Arguments[A_OPT_HOST])
stccpy( e->se_name, (char*)fa->FA_Arguments[A_OPT_HOST], HOSTNAMELEN );
else if (fa->FA_Arguments[A_OPT_ADDR])
stccpy( e->se_name, (char*)fa->FA_Arguments[A_OPT_ADDR], HOSTNAMELEN );
if (fa->FA_Arguments[A_OPT_PATH])
stccpy( e->se_path, (char*)fa->FA_Arguments[A_OPT_PATH], PATHLEN );
// set env to point to global default
e->se_env=&og->og_oc.oc_env;
e->se_has_custom_env=FALSE;
Att_NewNode(list, e->se_name ,(ULONG)e ,ADDNODE_SORT);
}
}
DisposeArgs( fa );
}
}
Close(cf);
}
}
FreeVec(buf);
return(list);
}
STATIC VOID ProgressWindow_SubTask( STRPTR message )
{
struct Library * MUIMasterBase;
ENTER();
DBG_STRING(message);
if((MUIMasterBase = OpenLibrary(MUIMASTER_NAME,MUIMASTER_VMIN)))
{
Object * app, * window;
app = ApplicationObject,
MUIA_Application_Title , "AmiNZB.WNDP",
MUIA_Application_Base , "AmiNZB.WNDP",
MUIA_Application_Version , ProgramVersionTag(),
MUIA_Application_Description, ProgramDescription(),
SubWindow, window = WindowObject,
MUIA_Window_Borderless , TRUE,
MUIA_Window_CloseGadget, FALSE,
MUIA_Window_SizeGadget , FALSE,
MUIA_Window_DepthGadget, FALSE,
MUIA_Window_DragBar , FALSE,
MUIA_Window_ScreenTitle, ProgramDescription(),
WindowContents, VGroup, GroupFrameT(NULL),
InnerSpacing(2,4),
Child, TextObject,
MUIA_Text_Contents, (ULONG)message,
MUIA_Text_PreParse, "\033b\033c",
MUIA_Font, MUIV_Font_Big,
End,
Child, BusyObject, End,
End,
End,
End;
if( app )
{
DoMethod(window,MUIM_Notify,MUIA_Window_CloseRequest,TRUE,
app,2,MUIM_Application_ReturnID,MUIV_Application_ReturnID_Quit);
set(window,MUIA_Window_Open,TRUE);
if(xget( window, MUIA_Window_Open))
{
ULONG sigs = 0;
BOOL running = TRUE;
struct Window * iWindow;
if((iWindow = (struct Window *) xget( window, MUIA_Window_Window)))
{
((struct Process *)FindTask(0))->pr_WindowPtr = iWindow;
//SetWindowTitles( iWindow, NULL, ProgramDescription());
}
do {
switch(DoMethod(app,MUIM_Application_NewInput,&sigs))
{
case MUIV_Application_ReturnID_Quit:
//running = FALSE;
DisplayBeep(NULL);
break;
default:
break;
}
if(running && sigs)
{
sigs = Wait(sigs | SIGBREAKF_CTRL_C);
if (sigs & SIGBREAKF_CTRL_C) break;
}
} while(running);
set(window,MUIA_Window_Open,FALSE);
}
MUI_DisposeObject(app);
}
CloseLibrary(MUIMasterBase);
}
LEAVE();
}
void ami_drag_selection(struct gui_window *g)
{
int x;
int y;
char *utf8text;
char *sel;
struct IFFHandle *old_iffh = iffh;
struct gui_window_2 *gwin = ami_window_at_pointer(AMINS_WINDOW);
/* NB: 'gwin' is at the drop point, 'g' is where the selection was dragged from.
* These may be different if the selection has been dragged between windows. */
if(!gwin)
{
DisplayBeep(scrn);
return;
}
x = gwin->win->MouseX;
y = gwin->win->MouseY;
if(ami_text_box_at_point(gwin, (ULONG *)&x, (ULONG *)&y))
{
iffh = ami_clipboard_init_internal(1);
browser_window_key_press(g->shared->bw, KEY_COPY_SELECTION);
browser_window_mouse_click(gwin->bw, BROWSER_MOUSE_PRESS_1, x, y);
browser_window_key_press(gwin->bw, KEY_PASTE);
ami_clipboard_free_internal(iffh);
iffh = old_iffh;
}
else
{
x = gwin->win->MouseX;
y = gwin->win->MouseY;
if(ami_gadget_hit(gwin->objects[GID_URL], x, y))
{
if(sel = browser_window_get_selection(g->shared->bw))
{
utf8text = ami_utf8_easy(sel);
RefreshSetGadgetAttrs((struct Gadget *)gwin->objects[GID_URL],
gwin->win, NULL, STRINGA_TextVal, utf8text, TAG_DONE);
free(sel);
ami_utf8_free(utf8text);
}
}
else if(ami_gadget_hit(gwin->objects[GID_SEARCHSTRING], x, y))
{
if(sel = browser_window_get_selection(g->shared->bw))
{
utf8text = ami_utf8_easy(sel);
RefreshSetGadgetAttrs((struct Gadget *)gwin->objects[GID_SEARCHSTRING],
gwin->win, NULL, STRINGA_TextVal, utf8text, TAG_DONE);
free(sel);
ami_utf8_free(utf8text);
}
}
else
{
DisplayBeep(scrn);
}
}
}
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);
}
// Snapshot objects
void backdrop_snapshot(BackdropInfo *info,BOOL unsnapshot,BOOL all,BackdropObject *icon)
{
BackdropObject *object;
Lister *lister;
IPCData *ipc;
BPTR old,lock;
short count=0,beep=0;
#ifdef DISTINCT_OK
BOOL save_env=0;
#endif
BOOL savepos=0;
// Lock backdrop list
lock_listlock(&info->objects,0);
// Lock lister list
lock_listlock(&GUI->lister_list,0);
// Lock group list
lock_listlock(&GUI->group_list,0);
// Go through backdrop list
for (object=(BackdropObject *)info->objects.list.lh_Head;
object->node.ln_Succ;
object=(BackdropObject *)object->node.ln_Succ)
{
BOOL ok=0;
// Icon supplied?
if (icon)
{
// Does it match?
if (object!=icon || !object->icon) continue;
}
// Is object selected?
else
if ((!object->state && !all) || !object->icon) continue;
beep=1;
// Appicon?
if (object->type==BDO_APP_ICON)
{
// Does icon support snapshot itself?
if (WB_AppIconFlags((struct AppIcon *)object->misc_data)&APPENTF_SNAPSHOT)
{
backdrop_appicon_message(object,(unsnapshot)?BAPPF_UNSNAPSHOT:0);
++count;
}
// Otherwise, fake snapshot
else
if (*object->name) ok=1;
}
// Otherwise, is it ok to snapshot?
else
if (object->type!=BDO_BAD_DISK) ok=1;
// Ok to snapshot?
if (ok)
{
short x,y;
// UnShapshot?
if (unsnapshot)
{
// Set "no position" position
x=-1;
y=-1;
}
// Snapshot
else
{
// Drawer?
if (object->icon->do_DrawerData)
{
// Group icon?
if (object->type==BDO_GROUP)
{
GroupData *group;
// See if group is open
if ((group=backdrop_find_group(object)))
{
// Update window position
*((struct IBox *)&object->icon->do_DrawerData->dd_NewWindow.LeftEdge)=group->dimensions;
}
}
// Otherwise go through listers
else
for (ipc=(IPCData *)GUI->lister_list.list.lh_Head;
ipc->node.mln_Succ;
ipc=(IPCData *)ipc->node.mln_Succ)
{
// Get lister
lister=IPCDATA(ipc);
// Is lister from this icon?
if (lister->backdrop==object)
{
// Update lister
PositionUpdate(lister,POSUPF_SAVE);
break;
}
}
}
// Get position
x=object->pos.Left;
y=object->pos.Top;
}
// AppIcon?
if (object->type==BDO_APP_ICON)
{
leftout_record *left;
// Lock position list
lock_listlock(&GUI->positions,TRUE);
// 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_APPICON)
{
// Match this icon?
if (strcmp(left->icon_label,object->name)==0)
break;
}
}
// Didn't find one?
if (!(left->node.ln_Succ) && !unsnapshot)
{
// Create a new entry
if ((left=AllocMemH(GUI->position_memory,sizeof(leftout_record))))
{
// Fill out entry
stccpy(left->icon_label,object->name,sizeof(left->icon_label));
left->node.ln_Name=left->name;
left->node.ln_Type=PTYPE_APPICON;
// Add to list
AddTail((struct List *)&GUI->positions,(struct Node *)left);
}
}
// Got one?
if (left->node.ln_Succ)
{
// Unsnapshot?
if (unsnapshot)
{
// Remove entry and free it
Remove((struct Node *)left);
FreeMemH(left);
}
// Update entry
else
{
ULONG iflags;
// Adjust for borders?
if (!((iflags=GetIconFlags(object->icon))&ICONF_BORDER_OFF) &&
(!(environment->env->desktop_flags&DESKTOPF_NO_BORDERS) || (iflags&ICONF_BORDER_ON)))
{
// Shift back by border size
x-=ICON_BORDER_X;
y-=ICON_BORDER_Y_TOP;
}
// Save position
left->icon_x=x;
left->icon_y=y;
left->flags&=~LEFTOUTF_NO_POSITION;
}
// Set flag to save positions
savepos=1;
}
// Can't snapshot for some reason
else
if (!unsnapshot) beep=1;
// Unlock position list
unlock_listlock(&GUI->positions);
}
// Left-out on desktop?
else
if (object->type==BDO_LEFT_OUT && !(object->flags&BDOF_DESKTOP_FOLDER) && info->flags&BDIF_MAIN_DESKTOP)
{
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) break;
}
}
// Got one?
if (left->node.ln_Succ)
{
// Save position
left->icon_x=x;
left->icon_y=y;
left->flags&=~LEFTOUTF_NO_POSITION;
// Set flag to save positions
savepos=1;
}
// Must be temporary
else beep=1;
// Unlock position list
unlock_listlock(&GUI->positions);
}
#ifdef DISTINCT_OK
// Distinct icon positions?
else
if (environment->env->desktop_flags&DESKTOPF_DISTINCT &&
info->flags&BDIF_MAIN_DESKTOP)
{
// Snapshot icon for this environment
desktop_snapshot_icon(object,x,y);
save_env=1;
}
#endif
// Group icon?
else
if (info->flags&BDIF_GROUP)
{
// Snapshot in group
group_snapshot_icon(info,object,x,y);
}
// Save to icon
else
{
// Using Workbench positions?
if (environment->env->display_options&DISPOPTF_ICON_POS)
{
// Set position
object->icon->do_CurrentX=(unsnapshot)?NO_ICON_POSITION:x-WBICONMAGIC_X;
object->icon->do_CurrentY=(unsnapshot)?NO_ICON_POSITION:y-WBICONMAGIC_Y;
// Removing Opus positions?
if (environment->env->display_options&DISPOPTF_REMOPUSPOS)
{
// Remove Opus position from icon
SetIconFlags(object->icon,GetIconFlags(object->icon)&~ICONF_POSITION_OK);
}
}
// Using Opus positions
else
{
// Set "position ok" flag
SetIconFlags(object->icon,GetIconFlags(object->icon)|ICONF_POSITION_OK);
// Update icon position
SetIconPosition(object->icon,x,y);
}
// Get icon lock
if ((lock=backdrop_icon_lock(object)))
{
// Change directory
old=CurrentDir(lock);
// Save this object out
if (!(WriteIcon((object->icon->do_Type==WBDISK)?"Disk":object->name,object->icon)))
beep=1;
// Success; is this in a lister?
else
if (info->lister)
{
char name[256];
// Get icon name
strcpy(name,(object->icon->do_Type==WBDISK)?"Disk":object->name);
strcat(name,".info");
// Reload the file
rexx_lister_reload_file(info->lister,name);
}
// Restore directory
CurrentDir(old);
UnLock(lock);
}
}
++count;
}
// Icon supplied?
if (icon) break;
}
// Failed to do anything?
if (!count && beep) DisplayBeep(info->window->WScreen);
// Unlock group list
unlock_listlock(&GUI->group_list);
// Unlock backdrop list
unlock_listlock(&info->objects);
// Unlock lister list
unlock_listlock(&GUI->lister_list);
#ifdef DISTINCT_OK
// Save environment file?
if (save_env && environment->env->flags&ENVF_CHANGED)
{
// Save environment
if (environment_save(environment,environment->path,0,0))
environment->env->flags&=~ENVF_CHANGED;
}
#endif
// Save positions?
if (savepos)
{
// Lock list
lock_listlock(&GUI->positions,0);
// Save list
SavePositions(&GUI->positions.list,GUI->position_name);
// Unlock list
unlock_listlock(&GUI->positions);
}
// If this is a lister, update its datestamp
if (info->lister) update_buffer_stamp(info->lister);
}
// 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;
}
// 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);
}
void
EditColor()
{
extern const char *configfile;
int i, done = 0, okay = 0;
long code, qual, class;
register struct Gadget *gd, *dgad;
register struct Window *nw;
register struct IntuiMessage *imsg;
register struct PropInfo *pip;
register struct Screen *scrn;
long aidx;
int msx, msy;
int curcol = 0, drag = 0;
int bxorx, bxory, bxxlen, bxylen;
static UWORD colors[AMII_MAXCOLORS];
static UWORD svcolors[AMII_MAXCOLORS];
static int once = 0;
scrn = HackScreen;
if (!once) {
if (WINVERS_AMIV) {
Col_NewWindowStructure1.Width += 300;
Col_NewWindowStructure1.Height += 20;
Col_NewWindowStructure1.LeftEdge -= 150;
Col_BluePen.Width += 300;
Col_RedPen.Width += 300;
Col_GreenPen.Width += 300;
Col_Cancel.LeftEdge += 300;
Col_Okay.LeftEdge += 150;
Col_Cancel.TopEdge += 20;
Col_Save.TopEdge += 20;
Col_Okay.TopEdge += 20;
}
SetBorder(&Col_Okay);
SetBorder(&Col_Cancel);
SetBorder(&Col_Save);
once = 1;
}
bxylen = Col_NewWindowStructure1.Height
- (Col_BluePen.TopEdge + Col_BluePen.Height + 6);
bxxlen = Col_BluePen.Width;
bxorx = Col_BluePen.LeftEdge;
bxory = Col_BluePen.TopEdge + Col_BluePen.Height + 2;
/* Save the current colors */
for (i = 0; i < amii_numcolors; ++i)
svcolors[i] = colors[i] = GetRGB4(scrn->ViewPort.ColorMap, i);
Col_NewWindowStructure1.Screen = scrn;
#ifdef INTUI_NEW_LOOK
if (IntuitionBase->LibNode.lib_Version >= 37) {
((struct PropInfo *) Col_BluePen.SpecialInfo)->Flags |= PROPNEWLOOK;
((struct PropInfo *) Col_RedPen.SpecialInfo)->Flags |= PROPNEWLOOK;
((struct PropInfo *) Col_GreenPen.SpecialInfo)->Flags |= PROPNEWLOOK;
}
#endif
if (WINVERS_AMIV || WINVERS_AMII) {
#ifdef INTUI_NEW_LOOK
Col_NewWindowStructure1.Extension = wintags;
Col_NewWindowStructure1.Flags |= WFLG_NW_EXTENDED;
#ifdef __GNUC__
fillhook.h_Entry = (void *) &LayerFillHook;
#else
fillhook.h_Entry = (ULONG (*) ()) LayerFillHook;
#endif
fillhook.h_Data = (void *) -2;
fillhook.h_SubEntry = 0;
#endif
}
nw = OpenWindow((void *) &Col_NewWindowStructure1);
if (nw == NULL) {
DisplayBeep(NULL);
return;
}
PrintIText(nw->RPort, &Col_IntuiTextList1, 0, 0);
ClearCol(nw);
DrawCol(nw, curcol, colors);
while (!done) {
WaitPort(nw->UserPort);
while (imsg = (struct IntuiMessage *) GetMsg(nw->UserPort)) {
gd = (struct Gadget *) imsg->IAddress;
code = imsg->Code;
class = imsg->Class;
qual = imsg->Qualifier;
msx = imsg->MouseX;
msy = imsg->MouseY;
ReplyMsg((struct Message *) imsg);
switch (class) {
case VANILLAKEY:
if (code == 'v' && qual == AMIGALEFT)
okay = done = 1;
else if (code == 'b' && qual == AMIGALEFT)
okay = 0, done = 1;
else if (code == 'o' || code == 'O')
okay = done = 1;
else if (code == 'c' || code == 'C')
okay = 0, done = 1;
break;
case CLOSEWINDOW:
done = 1;
break;
case GADGETUP:
drag = 0;
if (gd->GadgetID == GADREDPEN || gd->GadgetID == GADBLUEPEN
|| gd->GadgetID == GADGREENPEN) {
pip = (struct PropInfo *) gd->SpecialInfo;
aidx = pip->HorizPot / (MAXPOT / 15);
if (gd->GadgetID == GADREDPEN) {
colors[curcol] =
(colors[curcol] & ~0xf00) | (aidx << 8);
LoadRGB4(&scrn->ViewPort, colors, amii_numcolors);
} else if (gd->GadgetID == GADBLUEPEN) {
colors[curcol] = (colors[curcol] & ~0xf) | aidx;
LoadRGB4(&scrn->ViewPort, colors, amii_numcolors);
} else if (gd->GadgetID == GADGREENPEN) {
colors[curcol] =
(colors[curcol] & ~0x0f0) | (aidx << 4);
LoadRGB4(&scrn->ViewPort, colors, amii_numcolors);
}
DispCol(nw, curcol, colors);
} else if (gd->GadgetID == GADCOLOKAY) {
done = 1;
okay = 1;
} else if (gd->GadgetID == GADCOLSAVE) {
FILE *fp, *nfp;
char buf[300], nname[300], oname[300];
int once = 0;
fp = fopen(configfile, "r");
if (!fp) {
pline("can't find NetHack.cnf");
break;
}
strcpy(oname, dirname((char *) configfile));
if (oname[strlen(oname) - 1] != ':') {
sprintf(nname, "%s/New_NetHack.cnf", oname);
strcat(oname, "/");
strcat(oname, "Old_NetHack.cnf");
} else {
sprintf(nname, "%sNew_NetHack.cnf", oname);
strcat(oname, "Old_NetHack.cnf");
}
nfp = fopen(nname, "w");
if (!nfp) {
pline("can't write to New_NetHack.cnf");
fclose(fp);
break;
}
while (fgets(buf, sizeof(buf), fp)) {
if (strncmp(buf, "PENS=", 5) == 0) {
once = 1;
fputs("PENS=", nfp);
for (i = 0; i < amii_numcolors; ++i) {
fprintf(nfp, "%03x", colors[i]);
if ((i + 1) < amii_numcolors)
putc('/', nfp);
}
putc('\n', nfp);
} else {
fputs(buf, nfp);
}
}
/* If none in the file yet, now write it */
if (!once) {
fputs("PENS=", nfp);
for (i = 0; i < amii_numcolors; ++i) {
fprintf(nfp, "%03x", colors[i]);
if ((i + 1) < amii_numcolors)
putc(',', nfp);
}
putc('\n', nfp);
}
fclose(fp);
fclose(nfp);
unlink(oname);
if (filecopy((char *) configfile, oname) == 0)
if (filecopy(nname, (char *) configfile) == 0)
unlink(nname);
done = 1;
okay = 1;
} else if (gd->GadgetID == GADCOLCANCEL) {
done = 1;
okay = 0;
}
break;
case GADGETDOWN:
drag = 1;
dgad = gd;
break;
case MOUSEMOVE:
if (!drag)
break;
pip = (struct PropInfo *) dgad->SpecialInfo;
aidx = pip->HorizPot / (MAXPOT / 15);
if (dgad->GadgetID == GADREDPEN) {
colors[curcol] = (colors[curcol] & ~0xf00) | (aidx << 8);
LoadRGB4(&scrn->ViewPort, colors, amii_numcolors);
} else if (dgad->GadgetID == GADBLUEPEN) {
colors[curcol] = (colors[curcol] & ~0xf) | aidx;
LoadRGB4(&scrn->ViewPort, colors, amii_numcolors);
} else if (dgad->GadgetID == GADGREENPEN) {
colors[curcol] = (colors[curcol] & ~0x0f0) | (aidx << 4);
LoadRGB4(&scrn->ViewPort, colors, amii_numcolors);
}
DispCol(nw, curcol, colors);
break;
case MOUSEBUTTONS:
if (code == SELECTDOWN) {
if (msy > bxory && msy < bxory + bxylen - 1 && msx > bxorx
&& msx < bxorx + bxxlen - 1) {
curcol = (msx - bxorx) / (bxxlen / amii_numcolors);
if (curcol >= 0 && curcol < amii_numcolors)
DrawCol(nw, curcol, colors);
}
}
break;
}
}
}
if (okay) {
for (i = 0; i < (amii_numcolors); ++i)
sysflags.amii_curmap[i] = colors[i];
LoadRGB4(&scrn->ViewPort, sysflags.amii_curmap, amii_numcolors);
} else
LoadRGB4(&scrn->ViewPort, svcolors, amii_numcolors);
CloseWindow(nw);
}
// 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);
}
/* Get the player selection character */
#if 0 /* New function at the bottom */
void
amii_player_selection()
{
register struct Window *cwin;
register struct IntuiMessage *imsg;
register int aredone = 0;
register struct Gadget *gd;
static int once = 0;
long class, code;
amii_clear_nhwindow( WIN_BASE );
if (validrole(flags.initrole))
return;
else {
flags.initrole=randrole();
return;
}
#if 0 /* Don't query the user ... instead give random character -jhsa */
#if 0 /* OBSOLETE */
if( *pl_character ){
pl_character[ 0 ] = toupper( pl_character[ 0 ] );
if( index( pl_classes, pl_character[ 0 ] ) )
return;
}
#endif
if( !once ){
if( bigscreen ){
Type_NewWindowStructure1.TopEdge =
(HackScreen->Height/2) - (Type_NewWindowStructure1.Height/2);
}
for( gd = Type_NewWindowStructure1.FirstGadget; gd;
gd = gd->NextGadget )
{
if( gd->GadgetID != 0 )
SetBorder( gd );
}
once = 1;
}
if( WINVERS_AMIV )
{
# ifdef INTUI_NEW_LOOK
Type_NewWindowStructure1.Extension = wintags;
Type_NewWindowStructure1.Flags |= WFLG_NW_EXTENDED;
fillhook.h_Entry = (ULONG(*)())LayerFillHook;
fillhook.h_Data = (void *)-2;
fillhook.h_SubEntry = 0;
#endif
}
Type_NewWindowStructure1.Screen = HackScreen;
if( ( cwin = OpenShWindow( (void *)&Type_NewWindowStructure1 ) ) == NULL )
{
return;
}
#if 0
WindowToFront( cwin );
#endif
while( !aredone )
{
WaitPort( cwin->UserPort );
while( ( imsg = (void *) GetMsg( cwin->UserPort ) ) != NULL )
{
class = imsg->Class;
code = imsg->Code;
gd = (struct Gadget *)imsg->IAddress;
ReplyMsg( (struct Message *)imsg );
switch( class )
{
case VANILLAKEY:
if( index( pl_classes, toupper( code ) ) )
{
pl_character[0] = toupper( code );
aredone = 1;
}
else if( code == ' ' || code == '\n' || code == '\r' )
{
flags.initrole = randrole();
#if 0 /* OBSOLETE */
#ifdef TOURIST
strcpy( pl_character, roles[ rnd( 11 ) ] );
#else
strcpy( pl_character, roles[ rnd( 10 ) ] );
#endif
#endif
aredone = 1;
amii_clear_nhwindow( WIN_BASE );
CloseShWindow( cwin );
RandomWindow( pl_character );
return;
}
else if( code == 'q' || code == 'Q' )
{
CloseShWindow( cwin );
clearlocks();
exit_nhwindows(NULL);
terminate(0);
}
else
DisplayBeep( NULL );
break;
case GADGETUP:
switch( gd->GadgetID )
{
case 1: /* Random Character */
flags.initrole = randrole();
#if 0 /* OBSOLETE */
#ifdef TOURIST
strcpy( pl_character, roles[ rnd( 11 ) ] );
#else
strcpy( pl_character, roles[ rnd( 10 ) ] );
#endif
#endif
amii_clear_nhwindow( WIN_BASE );
CloseShWindow( cwin );
RandomWindow( pl_character );
return;
default:
pl_character[0] = gd->GadgetID;
break;
}
aredone = 1;
break;
case CLOSEWINDOW:
CloseShWindow( cwin );
clearlocks();
exit_nhwindows(NULL);
terminate(0);
break;
}
}
}
amii_clear_nhwindow( WIN_BASE );
CloseShWindow( cwin );
#endif /* Do not query user ... -jhsa */
}
BOOL save_options(struct window_params *wp,int opt_type,short gadgetid)
{
struct display_globals *dg;
short ok=1,loop;
char path[256];
BOOL ret=FALSE;
int type;
if (!wp)
{
DisplayBeep(0);
return(FALSE);
}
dg=wp->wp_dg;
// Make window busy
SetWindowBusy(wp->wp_win);
if (opt_type==WT_DEFOPT)
{
type=ID_OPTIONS;
// Copy default path
strcpy(path,FTP_OPTIONS_NAME);
}
else
{
type=ID_ENV;
*path=0;
}
// Loop until successful
do
{
// Clear loop flag
loop=0;
if (gadgetid==MENU_ENV_SAVEAS || !path[0])
ok=do_filereq(wp->wp_win,path,opt_type==WT_OPT?MSG_ENV_SAVE_OPTIONS:MSG_ENV_SAVE_DEFAULT_OPTIONS,FRF_DOSAVEMODE);
// Ok to save?
if (ok)
{
long err=0;
// Save options TRUE == ok
if (do_save_options_iff(wp,path,type,&err))
{
// Clear change flag
dg->dg_options_change=0;
ret=TRUE;
}
// Error?
else
{
// Show error
loop=disk_error(dg->dg_og,wp->wp_win,err,ERROR_WRITE,dg->dg_ipc);
}
}
} while (loop);
// Make window unbusy
ClearWindowBusy(wp->wp_win);
return(ret);
}
