int lib_intuition_f_ItemAddress_2(emumsg_syscall_t *msg)
{
/* Make real syscall */
msg->arg[0]._aptr = ItemAddress((struct Menu *)msg->arg[0]._aptr, msg->arg[1]._uword);
return HOOK_DONE;
}
static void ami_menu_item_browser_enablejs(struct Hook *hook, APTR window, struct IntuiMessage *msg)
{
struct Menu *menustrip;
bool checked = false;
GetAttr(WINDOW_MenuStrip, (Object *)window, (ULONG *)&menustrip);
if(ItemAddress(menustrip, msg->Code)->Flags & CHECKED) checked = true;
nsoption_set_bool(enable_javascript, checked);
ami_menu_check_toggled = true;
}
HOOKF(void, ami_menu_item_browser_backimg, APTR, window, struct IntuiMessage *)
{
struct Menu *menustrip;
bool checked = false;
GetAttr(WINDOW_MenuStrip, (Object *)window, (ULONG *)&menustrip);
if(ItemAddress(menustrip, msg->Code)->Flags & CHECKED) checked = true;
nsoption_set_bool(background_images, checked);
ami_menu_set_check_toggled();
}
void menu_events( struct IntuiMessage *IntuiMsg)
{
ULONG menucode = IntuiMsg->Code;
if (menucode != MENUNULL)
{
while (menucode != MENUNULL)
{
struct MenuItem *item = ItemAddress(menu,menucode);
select_menu[ MENUNUM(menucode) ] ( menucode );
/* Handle multiple selection */
menucode = item->NextSelect;
}
}
}
static void vsid_event_handling(void)
{
int done = 1;
unsigned long imCode, imClass;
struct IntuiMessage *imsg;
/* Check for IDCMP messages */
while ((imsg = (struct IntuiMessage *)GetMsg(vsid_window->UserPort))) {
imClass = imsg->Class;
imCode = imsg->Code;
switch (imClass) {
case IDCMP_MENUPICK:
pointer_to_default();
while (imCode != MENUNULL) {
struct MenuItem *n = ItemAddress(vsid_menu, imCode);
vsid_menu_handle((int)GTMENUITEM_USERDATA(n));
imCode = n->NextSelect;
}
vsid_menu_update();
done = 1;
break;
default:
break;
}
ReplyMsg((struct Message *)imsg);
switch (imClass) {
case IDCMP_CLOSEWINDOW:
do_quit_vice = 1;
break;
default:
break;
}
}
if (do_quit_vice) {
exit(0); // I think it's safe to quit here
}
}
void ami_menu_update_checked(struct gui_window_2 *gwin)
{
struct Menu *menustrip;
GetAttr(WINDOW_MenuStrip, gwin->objects[OID_MAIN], (ULONG *)&menustrip);
if(!menustrip) return;
#if defined(WITH_JS) || defined(WITH_MOZJS)
if(nsoption_bool(enable_javascript) == true) {
if((ItemAddress(menustrip, AMI_MENU_JS)->Flags & CHECKED) == 0)
ItemAddress(menustrip, AMI_MENU_JS)->Flags ^= CHECKED;
} else {
if(ItemAddress(menustrip, AMI_MENU_JS)->Flags & CHECKED)
ItemAddress(menustrip, AMI_MENU_JS)->Flags ^= CHECKED;
}
#endif
if(nsoption_bool(foreground_images) == true) {
if((ItemAddress(menustrip, AMI_MENU_FOREIMG)->Flags & CHECKED) == 0)
ItemAddress(menustrip, AMI_MENU_FOREIMG)->Flags ^= CHECKED;
} else {
if(ItemAddress(menustrip, AMI_MENU_FOREIMG)->Flags & CHECKED)
ItemAddress(menustrip, AMI_MENU_FOREIMG)->Flags ^= CHECKED;
}
if(nsoption_bool(background_images) == true) {
if((ItemAddress(menustrip, AMI_MENU_BACKIMG)->Flags & CHECKED) == 0)
ItemAddress(menustrip, AMI_MENU_BACKIMG)->Flags ^= CHECKED;
} else {
if(ItemAddress(menustrip, AMI_MENU_BACKIMG)->Flags & CHECKED)
ItemAddress(menustrip, AMI_MENU_BACKIMG)->Flags ^= CHECKED;
}
ResetMenuStrip(gwin->win, menustrip);
}
static BOOL HandleReq( struct AHIAudioModeRequesterExt *req )
// Returns FALSE if requester was cancelled
{
BOOL done=FALSE,rc=TRUE;
ULONG class,sec,oldsec=0,micro,oldmicro=0,oldid=AHI_INVALID_ID;
UWORD code;
UWORD qual;
struct Gadget *pgsel;
struct IntuiMessage *imsg;
struct IDnode *idnode;
LONG sliderlevels,sliderlevel,i,selected;
struct MenuItem *item;
while(!done)
{
Wait(1L << req->Window->UserPort->mp_SigBit);
while ((imsg=GT_GetIMsg(req->Window->UserPort)) != NULL )
{
if(imsg->IDCMPWindow == req->InfoWindow)
{
class = imsg->Class;
GT_ReplyIMsg(imsg);
switch(class)
{
case IDCMP_CLOSEWINDOW:
CloseInfoWindow(req);
break;
case IDCMP_REFRESHWINDOW :
GT_BeginRefresh(req->InfoWindow);
GT_EndRefresh(req->InfoWindow,TRUE);
break;
}
continue; // Get next IntuiMessage
}
else if(imsg->IDCMPWindow != req->Window) // Not my window!
{
if(req->IntuiMsgFunc)
CallHookPkt(req->IntuiMsgFunc,req,imsg);
// else what to do??? Reply and forget? FIXIT!
continue;
}
sec=imsg->Seconds;
micro=imsg->Micros;
qual=imsg->Qualifier;
class=imsg->Class;
code=imsg->Code;
pgsel=(struct Gadget *)imsg->IAddress; // pgsel illegal if not gadget
GT_ReplyIMsg(imsg);
switch ( class )
{
case IDCMP_RAWKEY:
switch (code)
{
case 0x4c: // Cursor Up
selected=GetSelected(req);
if(selected == ~0)
selected=0;
if(selected > 0)
selected--;
idnode=(struct IDnode *)req->list->mlh_Head;
for(i=0;i<selected;i++)
idnode=(struct IDnode *)idnode->node.ln_Succ;
req->tempAudioID=idnode->ID;
SetSelected(req,TRUE);
break;
case 0x4d: // Cursor Down
selected=GetSelected(req);
selected++; // ~0 => 0
idnode=(struct IDnode *)req->list->mlh_Head;
for(i=0;i<selected;i++)
if(idnode->node.ln_Succ->ln_Succ)
idnode=(struct IDnode *)idnode->node.ln_Succ;
req->tempAudioID=idnode->ID;
SetSelected(req,TRUE);
break;
case 0x4e: // Cursor Right
GetSliderAttrs(req,&sliderlevels,&sliderlevel);
sliderlevel += (qual & (IEQUALIFIER_LSHIFT|IEQUALIFIER_RSHIFT) ? 10 :1);
if(sliderlevel >= sliderlevels)
sliderlevel=sliderlevels-1;
AHI_GetAudioAttrs(req->tempAudioID, NULL,
AHIDB_FrequencyArg,sliderlevel,
AHIDB_Frequency, (ULONG) &req->tempFrequency,
TAG_DONE);
SetSelected(req,FALSE);
break;
case 0x4f: // Cursor Left
GetSliderAttrs(req,&sliderlevels,&sliderlevel);
sliderlevel -= (qual & (IEQUALIFIER_LSHIFT|IEQUALIFIER_RSHIFT) ? 10 :1);
if(sliderlevel < 0)
sliderlevel=0;
AHI_GetAudioAttrs(req->tempAudioID, NULL,
AHIDB_FrequencyArg,sliderlevel,
AHIDB_Frequency, (ULONG) &req->tempFrequency,
TAG_DONE);
SetSelected(req,FALSE);
break;
}
break;
case IDCMP_GADGETUP :
switch ( pgsel->GadgetID )
{
case OKBUTTON:
done=TRUE;
break;
case CANCELBUTTON:
done=TRUE;
rc=FALSE;
break;
case FREQSLIDER:
AHI_GetAudioAttrs(req->tempAudioID, NULL,
AHIDB_FrequencyArg,code,
AHIDB_Frequency, (ULONG) &req->tempFrequency,
TAG_DONE);
break;
case LISTVIEW:
idnode=(struct IDnode *)req->list->mlh_Head;
for(i=0;i<code;i++)
idnode=(struct IDnode *)idnode->node.ln_Succ;
req->tempAudioID=idnode->ID;
SetSelected(req,FALSE);
// Test doubleclick and save timestamp
if( (oldid == req->tempAudioID) && DoubleClick(oldsec,oldmicro,sec,micro))
done=TRUE;
oldsec=sec;
oldmicro=micro;
oldid=req->tempAudioID;
break;
}
break;
case IDCMP_NEWSIZE:
if(!(LayOutReq(req,req->TextAttr)))
if(!(LayOutReq(req,&Topaz80)))
{
// ERROR! Quit.
done=TRUE;
break;
}
break;
case IDCMP_CLOSEWINDOW:
done=TRUE;
rc=FALSE;
break;
case IDCMP_REFRESHWINDOW :
GT_BeginRefresh(req->Window);
GT_EndRefresh(req->Window,TRUE);
break;
case IDCMP_SIZEVERIFY:
break;
case IDCMP_MENUPICK:
while((code != MENUNULL) && !done)
{
item=ItemAddress(req->Menu, code);
switch((ULONG)GTMENUITEM_USERDATA(item))
{
case LASTMODEITEM:
selected=GetSelected(req);
if(selected == ~0)
selected=0;
if(selected > 0)
selected--;
idnode=(struct IDnode *)req->list->mlh_Head;
for(i=0;i<selected;i++)
idnode=(struct IDnode *)idnode->node.ln_Succ;
req->tempAudioID=idnode->ID;
SetSelected(req,TRUE);
break;
case NEXTMODEITEM:
selected=GetSelected(req);
selected++; // ~0 => 0
idnode=(struct IDnode *)req->list->mlh_Head;
for(i=0;i<selected;i++)
if(idnode->node.ln_Succ->ln_Succ)
idnode=(struct IDnode *)idnode->node.ln_Succ;
req->tempAudioID=idnode->ID;
SetSelected(req,TRUE);
break;
case PROPERTYITEM:
OpenInfoWindow(req);
break;
case RESTOREITEM:
req->tempAudioID=req->Req.ahiam_AudioID;
req->tempFrequency=req->Req.ahiam_MixFreq;
SetSelected(req,TRUE);
break;
case OKITEM:
done=TRUE;
break;
case CANCELITEM:
done=TRUE;
rc=FALSE;
break;
}
code = item->NextSelect;
}
break;
}
}
}
void EventLoop(void) {
ULONG signal = NULL, rc;
WORD code;
BOOL running = TRUE;
GetAttr( WINDOW_SigMask, WO_Window, &signal );
if(signal) {
do {
if(Wait(signal | SIGBREAKF_CTRL_C) & SIGBREAKF_CTRL_C ) {
running=FALSE;
}
while (( rc = CA_HandleInput( WO_Window, &code)) != WMHI_LASTMSG) {
switch(rc & WMHI_CLASSMASK) {
case WMHI_CLOSEWINDOW:
running=FALSE;
break;
case WMHI_GADGETUP:
case WMHI_MENUPICK:
{
if((rc & WMHI_CLASSMASK) == WMHI_MENUPICK) {
struct MenuItem *mi;
mi = ItemAddress(Menu, rc & WMHI_MENUMASK);
if(mi) {
rc = (ULONG) GTMENUITEM_USERDATA(mi);
}
}
switch( rc & WMHI_GADGETMASK) {
#if 0
case ACTID_OPEN:
{
if(DoMethod( openreq, FRM_DOREQUEST ) == FRQ_OK) {
char *file = NULL;
GetAttr( FRQ_Path, openreq, (ULONG *) &file);
NewSettings(file);
GUINewSettings();
}
break;
}
case ACTID_SAVEAS:
{
FillUnit();
if(DoMethod( savereq, FRM_DOREQUEST ) == FRQ_OK) {
char *file = NULL;
GetAttr( FRQ_Path, savereq, (ULONG *) &file);
SaveSettings(file, UnitList);
if(SaveIcons) {
WriteIcon(file);
}
}
break;
}
#endif
case ACTID_ABOUT:
Req( (char *) msgButtonOK,
(char *) msgTextCopyright,
"",(char *) msgTextProgramName,
"1996-2003 Martin Blom" );
break;
case ACTID_SAVE:
FillUnit();
SaveSettings(ENVFILE, UnitList);
SaveSettings(ENVARCFILE, UnitList);
running=FALSE;
break;
case ACTID_USE:
FillUnit();
SaveSettings(ENVFILE, UnitList);
running=FALSE;
break;
case ACTID_QUIT:
running=FALSE;
break;
case ACTID_DEFAULT:
SetAttrs( WO_Window, WA_BusyPointer, TRUE, TAG_DONE);
NewSettings(NULL); // This is VERY slow!!
SetAttrs( WO_Window, WA_BusyPointer, FALSE, TAG_DONE);
GUINewSettings();
break;
case ACTID_LASTSAVED:
NewSettings(ENVARCFILE);
GUINewSettings();
break;
case ACTID_RESTORE:
NewSettings(args.from);
GUINewSettings();
break;
case ACTID_ICONS:
{
struct MenuItem *item;
item = FindMenuItem(ACTID_ICONS);
if(item) {
if(item->Flags & CHECKED)
SaveIcons = TRUE;
else
SaveIcons = FALSE;
}
break;
}
#if 0
case ACTID_HELP: {
APTR lock = BGUI_LockWindow(Window);
if(!BGUI_Help( Window, HELPFILE, "AHI", NULL)) {
Req( (char *) msgButtonOK, (char *) msgTextNoFind, HELPFILE);
}
BGUI_UnlockWindow(lock);
break;
}
case ACTID_GUIDE: {
APTR lock = BGUI_LockWindow(Window);
if(!BGUI_Help( Window, HELPFILE, NULL, NULL)) {
Req( (char *) msgButtonOK, (char *) msgTextNoFind, HELPFILE);
}
BGUI_UnlockWindow(lock);
break;
}
case ACTID_HELPINDEX: {
APTR lock = BGUI_LockWindow(Window);
if(!BGUI_Help( Window, HELPFILE, "Concept Index", 0)) {
Req( (char *) msgButtonOK, (char *) msgTextNoFind, HELPFILE);
}
BGUI_UnlockWindow(lock);
break;
}
#endif
case ACTID_UNIT: {
FillUnit();
NewUnit(code);
GUINewUnit();
break;
}
case ACTID_MODE: {
FillUnit();
NewMode(code);
GUINewMode();
break;
}
case ACTID_DEBUG:
case ACTID_SURROUND:
case ACTID_ECHO:
case ACTID_CPULIMIT:
case ACTID_CLIPMV:
{
ULONG debug = AHI_DEBUG_NONE, surround = FALSE, echo = 0, cpu = 90;
ULONG clip = FALSE;
GetAttr( CHOOSER_Active, Window_Objs[ACTID_DEBUG], &debug);
GetAttr( CHOOSER_Active, Window_Objs[ACTID_SURROUND], &surround);
GetAttr( CHOOSER_Active, Window_Objs[ACTID_ECHO], &echo);
GetAttr( CHOOSER_Active, Window_Objs[ACTID_CLIPMV], &clip);
GetAttr( INTEGER_Number, Window_Objs[ACTID_CPULIMIT], &cpu);
globalprefs.ahigp_DebugLevel = debug;
globalprefs.ahigp_DisableSurround = surround;
globalprefs.ahigp_DisableEcho = (echo == 2);
globalprefs.ahigp_FastEcho = (echo == 1);
globalprefs.ahigp_MaxCPU = (cpu << 16) / 100;
globalprefs.ahigp_ClipMasterVolume= clip;
break;
}
} /* switch(GADGETMASK) */
}
} /* switch(CLASSMASK) */
} /* HandleInput */
} while(running);
}
}
int main(int argc,char **argv)
{
font_data *data;
// Need dopus library
if (!(DOpusBase=OpenLibrary("dopus5.library",LIB_VERSION)))
if (!(DOpusBase=OpenLibrary("dopus5:libs/dopus5.library",55)))
return(10);
#ifdef __amigaos4__
if (!(IDOpus = (struct DOpusIFace *)GetInterface(DOpusBase, "main", 1, NULL)))
{
CloseLibrary(DOpusBase);
return(10);
}
#endif
// Allocate data
if (!(data=AllocVec(sizeof(font_data),MEMF_CLEAR)))
{
font_free(0);
return(5);
}
// Parse arguments
data->args=
ReadArgs(
"FONT,SIZE/N,B=BOLD/S,I=ITALIC/S,U=ULINE/S,PUBSCREEN/K",
(APTR)data->arg_array,
NULL);
// Default to topaz 8
#ifdef __AROS__
strcpy(data->font_name,"ttcourier.font");
#else
strcpy(data->font_name,"topaz.font");
#endif
data->font_size=8;
// Got font name?
if (data->arg_array[ARG_FONT])
font_get_name(data,(char *)data->arg_array[ARG_FONT]);
// Got a font size?
if (data->arg_array[ARG_SIZE] && *((long *)data->arg_array[ARG_SIZE]))
{
data->font_size=*((long *)data->arg_array[ARG_SIZE]);
data->first=TRUE;
}
// Initialise locale
init_locale_data(&data->locale);
// Got locale library?
if (LocaleBase)
{
BPTR lock;
// Change PROGDIR: to dopus5:
if ((lock=Lock("dopus5:",ACCESS_READ)))
#ifdef __AROS__
// the lock returned here is the initial PROGDIR: which belongs to the system,
// so it's not a very good idea to just UnLock it
SetProgramDir(lock);
#else
UnLock(SetProgramDir(lock));
#endif
// Initialise
data->locale.li_LocaleBase=LocaleBase;
data->locale.li_Catalog=OpenCatalogA(0,"viewfont.catalog",0);
data->locale.li_Locale=OpenLocale(0);
}
// Create message port
data->appport=CreateMsgPort();
// Open window
if (!(font_open(data)))
{
font_free(data);
return(5);
}
// Initial gadget settings
if (data->arg_array[ARG_BOLD]) SetGadgetValue(data->list,GAD_FONT_BOLD,1);
if (data->arg_array[ARG_ITALIC]) SetGadgetValue(data->list,GAD_FONT_ITALIC,1);
if (data->arg_array[ARG_ULINE]) SetGadgetValue(data->list,GAD_FONT_ULINE,1);
// Show font
font_show_font(data,FALSE);
// Initialise refresh hook
data->refresh_hook.h_Entry=(ULONG (*)())font_refresh;
data->refresh_hook.h_Data=data;
// Event loop
FOREVER
{
struct IntuiMessage *msg;
BOOL quit_flag=FALSE;
// AppWindow?
if (data->appwindow)
{
struct AppMessage *amsg;
// Get messages
while ((amsg=(struct AppMessage *)GetMsg(data->appport)))
{
// Got file?
if (amsg->am_NumArgs>0)
{
char buf[256];
// Get name
DevNameFromLockDopus(amsg->am_ArgList[0].wa_Lock,buf,256);
if (amsg->am_ArgList[0].wa_Name && *amsg->am_ArgList[0].wa_Name)
AddPart(buf,amsg->am_ArgList[0].wa_Name,256);
// Get font name
font_get_name(data,buf);
// Get new font
font_get_font(data);
font_show_font(data,FALSE);
}
// Reply to message
ReplyMsg((struct Message *)amsg);
}
}
// Requester?
if (data->about)
{
// Handle requester
if (SysReqHandler(data->about,0,0)>=0)
{
// Close requester
FreeSysRequest(data->about);
data->about=NULL;
}
}
// Intuition messages
if (data->window)
{
while ((msg=GetWindowMsg(data->window->UserPort)))
{
struct IntuiMessage msg_copy;
UWORD id=0;
// Copy message and reply
msg_copy=*msg;
ReplyWindowMsg(msg);
// Get gadget ID
if (msg_copy.Class==IDCMP_GADGETUP)
id=((struct Gadget *)msg_copy.IAddress)->GadgetID;
// Look at message
switch (msg_copy.Class)
{
// Close window
case IDCMP_CLOSEWINDOW:
quit_flag=TRUE;
break;
// New size
case IDCMP_NEWSIZE:
// Redraw font
font_show_font(data,FALSE);
// Set flag to say we resized
data->resized=TRUE;
break;
// Menu
case IDCMP_MENUPICK:
{
struct MenuItem *item;
// Get item
if (!(item=ItemAddress(data->window->MenuStrip,msg_copy.Code)))
break;
// Get ID
id=GTMENUITEM_USERDATA(item);
// Fall through
}
// Gadget
case IDCMP_GADGETUP:
switch (id)
{
// Show requester
case GAD_FONT_FONT_POPUP:
case MENU_OPEN_FONT:
// Ask for name
font_ask_name(data);
break;
// Font name typed
case GAD_FONT_FONT:
// Get name
font_get_name(data,(char *)GetGadgetValue(data->list,GAD_FONT_FONT));
// Get new font
font_get_font(data);
font_show_font(data,FALSE);
break;
// Font size up/down
case GAD_FONT_UP:
case GAD_FONT_DOWN:
{
short size;
// Get next size
size=font_get_size(data,(id==GAD_FONT_UP)?1:-1);
// No change?
if (size==data->font_size) break;
// Use this size
data->font_size=size;
SetGadgetValue(data->list,GAD_FONT_SIZE,size);
}
// Font size given
case GAD_FONT_CYCLE:
// Check id
if (id==GAD_FONT_CYCLE)
{
short size;
// Get size
if (!(size=atoi(data->size_labels[msg_copy.Code])))
break;
// Refresh gadget
data->font_size=size;
SetGadgetValue(data->list,GAD_FONT_SIZE,data->font_size);
}
// Font size
case GAD_FONT_SIZE:
// Entered size
if (id==GAD_FONT_SIZE)
{
// Bounds check gadget
data->font_size=
BoundsCheckGadget(
data->list,
GAD_FONT_SIZE,
4,
255);
}
// Get new font
font_get_font(data);
font_show_font(data,FALSE);
break;
// Styles changed
case GAD_FONT_BOLD:
case GAD_FONT_ITALIC:
case GAD_FONT_ULINE:
// Redraw font
font_show_font(data,FALSE);
break;
// Save settings
case MENU_SAVE_SETTINGS:
font_save_settings(data);
break;
// Quit
case MENU_QUIT:
quit_flag=TRUE;
break;
// About
case MENU_ABOUT:
font_show_about(data);
break;
}
break;
// Rawkey
case IDCMP_RAWKEY:
// Help?
if (msg_copy.Code==0x5f)
font_show_about(data);
// Key
case IDCMP_VANILLAKEY:
// Escape does quit
if (msg_copy.Code==0x1b) quit_flag=TRUE;
break;
// Refresh
case IDCMP_REFRESHWINDOW:
// Have we just resized?
if (data->resized)
{
// Don't need to refresh
BeginRefresh(data->window);
EndRefresh(data->window,TRUE);
data->resized=FALSE;
break;
}
// Refresh font display
font_show_font(data,TRUE);
break;
}
// Check window is still valid
if (!data->window) break;
}
}
if (quit_flag) break;
// Wait for signal (ctrl-c breaks)
if ((Wait(SIGBREAKF_CTRL_C|
((data->window)?(1<<data->window->UserPort->mp_SigBit):0)|
((data->about)?(1<<data->about->UserPort->mp_SigBit):0)|
((data->appwindow)?(1<<data->appport->mp_SigBit):0)))&SIGBREAKF_CTRL_C) break;
}
// Free stuff
font_free(data);
return(0);
}
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);
}
/*** Handle events coming from main window: ***/
void dispatch_events()
{
extern ULONG sigmainwnd, swinsig;
extern UBYTE record;
BYTE scrolldisp=0, state=0, cnt=0, mark=0, quit = 0;
while( quit == 0 )
{
/* Active collect, when pressing arrow gadgets */
sigrcvd = (state==0 ? Wait(sigbits) : sigmainwnd);
/* if(sigrcvd & SIGBREAKF_CTRL_C) break;
else */ if(sigrcvd & sigport) { handle_port(); continue; }
else if(sigrcvd & swinsig) { handle_search(); continue; }
/* Collect messages posted to the window port */
while( ( msg = (struct IntuiMessage *) GetMsg(Wnd->UserPort) ) )
{
/* Copy the entire message into the buffer */
CopyMemQuick(msg, &msgbuf, sizeof(msgbuf));
ReplyMsg( (struct Message *) msg );
switch( msgbuf.Class )
{
case IDCMP_CLOSEWINDOW: handle_menu(112); break;
case IDCMP_RAWKEY:
handle_kbd(edit);
if(record) {
if(record == 1) reg_act_com(MAC_ACT_SHORTCUT, msgbuf.Code, msgbuf.Qualifier);
else record &= 0x7f;
}
break;
case IDCMP_INTUITICKS:
/* An error message which needs to be removed? */
if(err_time == 0) err_time = msgbuf.Seconds;
if(err_time && msgbuf.Seconds-err_time>4) StopError(Wnd);
break;
case IDCMP_MOUSEBUTTONS:
/* Click somewhere in the text */
switch( msgbuf.Code )
{
case SELECTDOWN:
/* Click over the project bar ? */
if(msgbuf.MouseY < gui.top)
{
edit = select_panel(edit, msgbuf.MouseX);
break;
}
click(edit, msgbuf.MouseX, msgbuf.MouseY, FALSE);
/* Shift-click to use columnar selection */
if( ( move_selection = SwitchSelect(edit, msgbuf.Qualifier & SHIFTKEYS ? 1:0, 1) ) )
mark=TRUE;
break;
case SELECTUP:
if(mark) unclick(edit);
mark=FALSE; scrolldisp=0; break;
}
break;
case IDCMP_NEWSIZE:
new_size(EDIT_ALL);
break;
case IDCMP_GADGETDOWN: /* Left scroll bar */
if(msgbuf.IAddress == (APTR) &Prop->down) state=1;
if(msgbuf.IAddress == (APTR) &Prop->up) state=2;
break;
case IDCMP_GADGETUP: /* Arrows or prop gadget */
state=0;
if(msgbuf.IAddress == (APTR) Prop)
scroll_disp(edit, FALSE), scrolldisp=0;
break;
case IDCMP_MOUSEMOVE:
if(mark) scrolldisp=2;
else
if(Prop->scroller.Flags & GFLG_SELECTED) scrolldisp=1;
break;
case IDCMP_MENUPICK:
{ struct MenuItem * Item;
ULONG MenuId;
/* Multi-selection of menu entries */
while(msgbuf.Code != MENUNULL)
if( (Item = ItemAddress( Menu, msgbuf.Code )) )
{
/* stegerg: get NextSelect here in case menu action causes screen
to be closed/reopened in which case item becomes invalid.
Also assuming here that user in such case will not use
multiselection, ie. that nextselect will be MENUNULL.
If that's not the case it would mean more trouble and to protect
against that one would need to check if during handle_menu() the
screen has been closed/reopened and in that case break out of
the menu multiselection loop here. */
UWORD nextselect = Item->NextSelect;
MenuId = (ULONG)GTMENUITEM_USERDATA( Item );
handle_menu( MenuId );
if(record) reg_act_com(MAC_ACT_COM_MENU, MenuId, msgbuf.Qualifier);
else record &= 0x7f;
msgbuf.Code = nextselect;
}
}
}
}
/* Reduces the number of IDCMP mousemove messages to process */
if(scrolldisp==1) scroll_disp(edit, FALSE), scrolldisp=0;
if(scrolldisp==2) { scrolldisp=0; goto moveit; }
/* User may want to auto-scroll the display using arrow gadgets */
if(state && (mark || (((struct Gadget *)Prop)[state].Flags & GFLG_SELECTED))) {
/* Slow down animation: */
WaitTOF(); cnt++;
if(cnt>1) {
cnt=0;
if(autoscroll(edit,state==1 ? 1:-1)==0) state=0;
else if(mark) {
LONG x , y; moveit:
/* Adjust mouse position */
x = (msgbuf.MouseX-gui.left) / XSIZE;
y = (msgbuf.MouseY-gui.top) / YSIZE;
if(x < 0) x = 0; if(x >= gui.nbcol) x = gui.nbcol-1;
if(y < 0) y = -1; if(y > gui.nbline) y = gui.nbline;
edit->nbrwc = (x += edit->left_pos);
y += (LONG)edit->top_line;
if( x != edit->ccp.xc || y != edit->ccp.yc )
/* Move the selected stream */
if( !(state = move_selection(edit,x,y)) )
set_cursor_line(edit, y, edit->top_line),
inv_curs(edit,TRUE);
}
}
} /* endif: arrow gadget pressed or autoscroll */
}
}
STATIC ULONG FOHandleEvents(struct LayoutData *ld, struct AslBase_intern *AslBase)
{
struct IntuiMessage *imsg = ld->ld_Event;
struct FOUserData *udata = (struct FOUserData *)ld->ld_UserData;
struct IntFontReq *iforeq = (struct IntFontReq *)ld->ld_IntReq;
WORD gadid;
ULONG retval = GHRET_OK;
EnterFunc(bug("FOHandleEvents: Class: %d\n", imsg->Class));
switch (imsg->Class)
{
case IDCMP_CLOSEWINDOW:
retval = FALSE;
break;
case IDCMP_RAWKEY:
switch (imsg->Code)
{
case CURSORUP:
FOChangeActiveFont(ld, -1, imsg->Qualifier, FALSE, AslBase);
break;
case RAWKEY_PAGEUP:
FOChangeActiveFont(ld, -1, IEQUALIFIER_LSHIFT, FALSE, AslBase);
break;
case RAWKEY_HOME:
FOChangeActiveFont(ld, -1, IEQUALIFIER_LALT, FALSE, AslBase);
break;
case RAWKEY_NM_WHEEL_UP:
FOChangeActiveFont(ld, -3, imsg->Qualifier, FALSE, AslBase);
break;
case CURSORDOWN:
FOChangeActiveFont(ld, 1, imsg->Qualifier, FALSE, AslBase);
break;
case RAWKEY_PAGEDOWN:
FOChangeActiveFont(ld, 1, IEQUALIFIER_LSHIFT, FALSE, AslBase);
break;
case RAWKEY_END:
FOChangeActiveFont(ld, 1, IEQUALIFIER_LALT, FALSE, AslBase);
break;
case RAWKEY_NM_WHEEL_DOWN:
FOChangeActiveFont(ld, 3, imsg->Qualifier, FALSE, AslBase);
break;
}
break;
case IDCMP_VANILLAKEY:
switch(imsg->Code)
{
case 27:
retval = FALSE;
break;
}
break;
case IDCMP_GADGETUP:
gadid = ((struct Gadget *)imsg->IAddress)->GadgetID;
D(bug("GADGETUP! gadgetid=%d code=%d\n", gadid, imsg->Code));
switch (gadid)
{
case ID_BUTCANCEL:
retval = FALSE;
break;
case ID_BUTOK:
retval = FOGetSelectedFont(ld, AslBase);
break;
case ID_NAMELISTVIEW:
{
struct ASLLVFontReqNode *fontnode;
IPTR active;
IPTR size;
GetAttr(ASLLV_Active, udata->NameListview, &active);
GetAttr(STRINGA_LongVal, udata->SizeString, &size);
if ((fontnode = (struct ASLLVFontReqNode *)FindListNode(&udata->NameListviewList, (WORD)active)))
{
FOActivateFont(ld, active, (LONG)size, AslBase);
if (imsg->Code) /* TRUE if double clicked */
{
retval = FOGetSelectedFont(ld, AslBase);
}
}
ActivateGadget((struct Gadget *)udata->NameString, ld->ld_Window, NULL);
}
break;
case ID_SIZELISTVIEW:
if (udata->ActiveFont)
{
struct Node *node;
IPTR active;
GetAttr(ASLLV_Active, udata->SizeListview, &active);
if ((node = FindListNode(&udata->ActiveFont->SizeList, (WORD)active)))
{
FOSetSizeString((LONG)node->ln_Name, ld, AslBase);
FOUpdatePreview(ld, AslBase);
if (imsg->Code) /* TRUE if double clicked */
{
retval = FOGetSelectedFont(ld, AslBase);
}
}
ActivateGadget((struct Gadget *)udata->SizeString, ld->ld_Window, NULL);
}
break;
case ID_NAMESTRING:
if (imsg->Code == STRINGCODE_CURSORUP)
{
FOChangeActiveFont(ld, -1, imsg->Qualifier, TRUE, AslBase);
ActivateGadget((struct Gadget *)udata->NameString, ld->ld_Window, NULL);
break;
}
else if (imsg->Code == STRINGCODE_CURSORDOWN)
{
FOChangeActiveFont(ld, 1, imsg->Qualifier, TRUE, AslBase);
ActivateGadget((struct Gadget *)udata->NameString, ld->ld_Window, NULL);
break;
}
else if ((imsg->Code == 0) || (imsg->Code == 9))
{
FOUpdatePreview(ld, AslBase);
break;
}
break;
case ID_SIZESTRING:
if (imsg->Code == STRINGCODE_CURSORUP)
{
FOChangeActiveSize(ld, -1, imsg->Qualifier, AslBase);
ActivateGadget((struct Gadget *)udata->SizeString, ld->ld_Window, NULL);
break;
}
else if (imsg->Code == STRINGCODE_CURSORDOWN)
{
FOChangeActiveSize(ld, 1, imsg->Qualifier, AslBase);
ActivateGadget((struct Gadget *)udata->SizeString, ld->ld_Window, NULL);
break;
}
else if ((imsg->Code == 0) || (imsg->Code == 9))
{
IPTR val;
LONG size;
GetAttr(STRINGA_LongVal, udata->SizeString, (IPTR *)&val);
size = (LONG)val;
if ((size < iforeq->ifo_MinHeight) || (size > iforeq->ifo_MaxHeight))
{
if (size < iforeq->ifo_MinHeight) size = iforeq->ifo_MinHeight;
if (size > iforeq->ifo_MaxHeight) size = iforeq->ifo_MaxHeight;
FOSetSizeString(size, ld, AslBase);
}
FOActivateSize(ld, -size, AslBase);
break;
}
break;
case ID_STYLE:
case ID_FRONTPEN:
case ID_BACKPEN:
FOUpdatePreview(ld, AslBase);
break;
} /* switch (gadget ID) */
break; /* case IDCMP_GADGETUP: */
case IDCMP_MENUPICK:
if (ld->ld_Menu)
{
UWORD men = imsg->Code;
while(men != MENUNULL)
{
struct MenuItem *item;
if ((item = ItemAddress(ld->ld_Menu, men)))
{
switch((IPTR)GTMENUITEM_USERDATA(item))
{
/* Control menu */
case FOMEN_LASTFONT:
FOChangeActiveFont(ld, -1, 0, FALSE, AslBase);
break;
case FOMEN_NEXTFONT:
FOChangeActiveFont(ld, 1, 0, FALSE, AslBase);
break;
case FOMEN_RESTORE:
FORestore(ld, iforeq->ifo_TextAttr.ta_Name, iforeq->ifo_TextAttr.ta_YSize, AslBase);
break;
case FOMEN_RESCAN:
FOGetFonts(ld, AslBase);
break;
case FOMEN_OK:
retval = FOGetSelectedFont(ld, AslBase);
break;
case FOMEN_CANCEL:
retval = FALSE;
break;
} /* switch id */
men = item->NextSelect;
} /* if ((item = ItemAddress(ld->ld_Menu, men))) */
else
{
men = MENUNULL;
}
} /* while(men != MENUNULL) */
} /* if (ld->ld_Menu) */
break; /* case IDCMP_MENUPICK: */
} /* switch (imsg->Class) */
ReturnInt ("FOHandleEvents", ULONG, retval);
}
// 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 __stdargs
__main( char *argstring )
{
static struct Args args;
LONG rev;
/* Get arguments if started from CLI */
if( !_WBenchMsg )
{
if( !( RDArgs = ReadArgs( TEMPLATE, ( IPTR * ) &args, NULL ) ) )
{
PrintFault( IoErr(), GetString( MSG_ERROR_ARGS ) );
__exit( 0 );
}
}
IntuiHook.h_Entry = ( HOOKFUNC ) IntuiMsgFunc;
// DefaultPrefs.Flags = 0;
DefaultPrefs.ReqDefaults[ RTPREF_OTHERREQ ].ReqPos = REQPOS_POINTER;
DefaultPrefs.ReqDefaults[ RTPREF_FILEREQ ].Size = 75;
DefaultPrefs.ReqDefaults[ RTPREF_FONTREQ ].Size =
DefaultPrefs.ReqDefaults[ RTPREF_SCREENMODEREQ ].Size =
DefaultPrefs.ReqDefaults[ RTPREF_VOLUMEREQ ].Size = 65;
DefaultPrefs.ReqDefaults[ RTPREF_FILEREQ ].ReqPos =
DefaultPrefs.ReqDefaults[ RTPREF_FONTREQ ].ReqPos =
DefaultPrefs.ReqDefaults[ RTPREF_SCREENMODEREQ ].ReqPos =
DefaultPrefs.ReqDefaults[ RTPREF_VOLUMEREQ ].ReqPos =
DefaultPrefs.ReqDefaults[ RTPREF_PALETTEREQ ].ReqPos = REQPOS_TOPLEFTSCR;
DefaultPrefs.ReqDefaults[ RTPREF_FILEREQ ].LeftOffset =
DefaultPrefs.ReqDefaults[ RTPREF_FONTREQ ].LeftOffset =
DefaultPrefs.ReqDefaults[ RTPREF_SCREENMODEREQ ].LeftOffset =
DefaultPrefs.ReqDefaults[ RTPREF_VOLUMEREQ ].LeftOffset =
DefaultPrefs.ReqDefaults[ RTPREF_PALETTEREQ ].LeftOffset =
DefaultPrefs.ReqDefaults[ RTPREF_OTHERREQ ].LeftOffset = 25;
DefaultPrefs.ReqDefaults[ RTPREF_FILEREQ ].TopOffset =
DefaultPrefs.ReqDefaults[ RTPREF_FONTREQ ].TopOffset =
DefaultPrefs.ReqDefaults[ RTPREF_SCREENMODEREQ ].TopOffset =
DefaultPrefs.ReqDefaults[ RTPREF_VOLUMEREQ ].TopOffset =
DefaultPrefs.ReqDefaults[ RTPREF_PALETTEREQ ].TopOffset =
DefaultPrefs.ReqDefaults[ RTPREF_OTHERREQ ].TopOffset = 18;
DefaultPrefs.ReqDefaults[ RTPREF_FILEREQ ].MinEntries = 10;
DefaultPrefs.ReqDefaults[ RTPREF_FONTREQ ].MinEntries =
DefaultPrefs.ReqDefaults[ RTPREF_SCREENMODEREQ ].MinEntries =
DefaultPrefs.ReqDefaults[ RTPREF_VOLUMEREQ ].MinEntries = 6;
DefaultPrefs.ReqDefaults[ RTPREF_FILEREQ ].MaxEntries = 50;
DefaultPrefs.ReqDefaults[ RTPREF_FONTREQ ].MaxEntries =
DefaultPrefs.ReqDefaults[ RTPREF_SCREENMODEREQ ].MaxEntries =
DefaultPrefs.ReqDefaults[ RTPREF_VOLUMEREQ ].MaxEntries = 10;
if( !( IntuitionBase = ( struct IntuitionBase * ) OpenLibrary( "intuition.library", 37 ) ) )
{
BPTR con;
if( ( con = Open( "CON:40/20/320/40/ReqTools 2.8", MODE_NEWFILE ) ) )
{
Write( con, "\nNeed OS 2.04 or better!\n", 25 );
Delay( 120L );
Close( con );
}
FreeExit( 0 );
}
InitLocale();
GfxBase = OpenLib( "graphics.library", 37 );
UtilityBase = OpenLib( "utility.library", 36 );
IconBase = OpenLib( "icon.library", 0 );
GadToolsBase = OpenLib( "gadtools.library", 37 );
ReqToolsBase = OpenLib( "reqtools.library", 38 );
rev = ReqToolsBase->LibNode.lib_Revision;
if( ( rev >= 693 && rev <= 811 ) || ( rev >= 347 && rev <= 363 ) )
{
LocEZReq( MSG_WRONG_REQTOOLS_VERSION, MSG_ABORT );
FreeExit( RETURN_FAIL );
}
if( rtLockPrefs()->PrefsSize != PREFSLEN )
{
LocEZReq( MSG_ALL_PREFS_NOT_SUPPORTED, MSG_OK );
}
rtUnlockPrefs();
if( _WBenchMsg )
{
struct WBArg *wbarg;
BPTR oldcd;
CreateIcons = TRUE;
wbarg = &_WBenchMsg->sm_ArgList[ 0 ];
oldcd = CurrentDir( wbarg->wa_Lock );
if( ( DiskObject = GetDiskObject( wbarg->wa_Name ) ) )
{
STRPTR str;
if( ( str = FindToolType( (UBYTE **)DiskObject->do_ToolTypes, "CREATEICONS" ) ) )
{
CreateIcons = Stricmp( str, "NO" );
}
if( ( str = FindToolType( (UBYTE **)DiskObject->do_ToolTypes, "SCREENFONT" ) ) )
{
UseScreenFont = Stricmp( str, "NO" );
}
if( ( str = FindToolType( (UBYTE **)DiskObject->do_ToolTypes, "PUBSCREEN" ) ) )
{
args.PubScreen = str;
}
}
CurrentDir( oldcd );
}
else
{
if( args.ScreenFont )
{
UseScreenFont = Stricmp( args.ScreenFont, "NO" );
}
}
if( !( FileReq = rtAllocRequestA( RT_FILEREQ, NULL ) ) )
{
FreeExit( RETURN_FAIL );
}
{
struct TagItem tags[] =
{
{RTFI_Dir , (IPTR)"Presets" },
{TAG_DONE }
};
rtChangeReqAttrA( FileReq, tags );
}
/* Get current prefs from ReqTools */
CopyMem( rtLockPrefs(), &RTPrefs, sizeof( struct ReqToolsPrefs ) );
rtUnlockPrefs();
/* If FROM was used load prefs from disk */
if( args.From )
{
if( !LoadConfig( args.From ) )
{
FreeExit( RETURN_ERROR );
}
}
WheelType = GetWheelType( RTPrefs.Flags );
if( !( Screen = LockPubScreen( args.PubScreen ) ) )
{
LocEZReq( MSG_COULDNT_LOCK_PUBSCREEN, MSG_ABORT );
FreeExit( RETURN_ERROR );
}
if( !( DrawInfo = GetScreenDrawInfo( Screen ) ) )
{
LocEZReq( MSG_ERROR_GETSCREENDRAWINFO, MSG_ABORT );
FreeExit( RETURN_ERROR );
}
if( !( VisualInfo = GetVisualInfoA( Screen, NULL ) ) )
{
LocEZReq( MSG_ERROR_GETVISUALINFO, MSG_ABORT );
FreeExit( RETURN_FAIL );
}
if( IntuitionBase->LibNode.lib_Version >= 39 )
{
Zoom[ 0 ] = Zoom[ 1 ] = 65535;
}
else
{
Zoom[ 1 ] = Screen->BarHeight + 1;
}
Zoom[ 2 ] = 250;
Zoom[ 3 ] = Screen->WBorTop + Screen->Font->ta_YSize + 1;
LocalizeMenus( NewMenu );
if( !( Menus = CreateMenusA( NewMenu, NULL ) ) )
{
LocEZReq( MSG_ERROR_MENUS, MSG_ABORT );
FreeExit( RETURN_FAIL );
}
LayoutMenus( Menus, VisualInfo,
GTMN_NewLookMenus, TRUE,
TAG_END );
if( !OpenGUI() )
{
LocEZReq( MSG_COULDNT_OPEN_WINDOW, MSG_ABORT );
FreeExit( RETURN_FAIL );
}
{
struct MenuItem *iconItem;
iconItem = ItemAddress( Menus, FULLMENUNUM( OPTIONS_MENU, SAVEICONS_ITEM, NOSUB ) );
if( !CreateIcons )
{
iconItem->Flags &= ~CHECKED;
}
}
CurrentReq = RTPREF_FILEREQ;
ReqDefs = &RTPrefs.ReqDefaults[ CurrentReq ];
LoopGUI();
FreeExit( 0 );
}
