static int libExpunge(LIBBASETYPEPTR nh)
{
KPRINTF(10, ("libExpunge nh: 0x%08lx\n", nh));
CloseLibrary((struct Library *) UtilityBase);
return(TRUE);
}
/*************************************
*
* Engine for the CloseAllTVWindows()
* function.
*
* Receives the each library's info.
*
* Attempts to close window,
* close library, and free associated
* menu items for window.
*
**************************************/
BOOL __far __pascal CloseAllLibsWindows( FPTVLIBINFO fpTVLibInfo, LPARAM lParam )
{
BOOL __far * bAllWndClosed;
FPTVWNDINFO fpWndInfo;
HTVWNDINFO hWndInfo;
HWND hChildWnd;
HWND hChildsPopupWnd;
TVLIBCLOSEWINDOWPROC fpfnTVLibCloseWnd;
/* Get LPARAM data. */
bAllWndClosed = (BOOL __far *) lParam;
/* Get library's handle to first window info. */
hWndInfo = GetLibWndInfo( fpTVLibInfo );
while( hWndInfo != 0 )
{
/* Lock it. */
fpWndInfo = (FPTVWNDINFO) GlobalLock( hWndInfo ) ;
/* Get the handle of the window we are closing. */
hChildWnd = fpWndInfo->hWnd;
/* Unlock it. */
GlobalUnlock( hWndInfo ) ;
/*
** If we are already in the window's
** Wndproc() and awaiting it return,
** activate the last popup window.
*/
if( GetTVEntryCount( hChildWnd ) != 0 )
{
/* Change focus to window. */
MessageBeep( MB_ICONEXCLAMATION );
hChildsPopupWnd = GetLastActivePopup( hChildWnd );
SetActiveWindow( hChildsPopupWnd );
/* Not all windows closed. */
*bAllWndClosed = FALSE;
/* Stop enumerating. */
return FALSE;
}
/*
** Tell window to close by sending calling
** the TVLibWindowClose() function.
*/
/* Retrieve the address of the control's LibInfo() function. */
(FARPROC) fpfnTVLibCloseWnd = GetProcAddress( fpTVLibInfo->hInstance, MAKEINTRESOURCE(TVLIB_CLOSEWINDOW_ORD) );
/* Verify the GetProcAddress() function returned data. */
if ( fpfnTVLibCloseWnd == NULL)
{
/* Not all windows closed. */
*bAllWndClosed = FALSE;
/* Error message. */
MessageBox( NULL, (LPSTR)"GetProcAddress() failed!", (LPSTR)"Library Functions", MB_ICONHAND | MB_OK );
/* Stop enumerating. */
return FALSE;
}
/*
** Restore the window's WndProc() to its original
** WndProc() so we aren't trapping for the
** WM_NCDESTROY message and won't therefore call
** PostCloseLibrary().
*/
// RemoveChildWindowFilter( hChildWnd );
/* Tell the library to close the window. */
(*fpfnTVLibCloseWnd)(hChildWnd);
/*
** Window is still around.
*/
if( IsWindow( hChildWnd ) )
{
/*
** Set the window's WndProc() to our special
** WndProc() so we can keep trapping for the
** WM_NCDESTROY message to call
** PostCloseLibrary().
*/
// SetChildWindowFilter( hChildWnd );
/* Not all windows closed. */
*bAllWndClosed = FALSE;
/* Stop enumerating. */
return FALSE;
}
/*
** Window is not still around.
*/
/* Remove menu alias' associated with the window. */
DeleteMenuInfoForWnd( hChildWnd );
/* Find and delete the window info. */
DeleteWndInfo( &(fpTVLibInfo)->hTVWndInfo, hChildWnd );
/* Close the library. */
CloseLibrary( fpTVLibInfo );
/* Get library's handle to first window info. */
hWndInfo = GetLibWndInfo( fpTVLibInfo );
}
/* Keep enumerating - next library. */
return TRUE;
}
// Reads a coding table
BOOL ReadUnicodeTable(struct Globals *glob, STRPTR name)
{
BPTR fh;
struct Library *DOSBase;
if (!(DOSBase = OpenLibrary("dos.library", 0)))
return FALSE;
fh = Open(name, MODE_OLDFILE);
if (fh)
{
int i, n;
char buf[512];
while (readLine(DOSBase, fh, buf, 512 * sizeof(char)))
{
if (!isdigit(*buf))
continue;
else
{
char *p = buf;
int fmt2 = 0;
if ((*p == '=') || (fmt2 = ((*p == '0')
|| (*(p + 1) == 'x'))))
{
p++;
p += fmt2;
i = strtol((const char *)p, (char **)&p, 16);
if (i >= 0 && i < 256)
{
while (isspace(*p))
p++;
if (!strnicmp(p, "U+", 2))
{
p += 2;
n = strtol((const char *)p, (char **)&p, 16);
}
else
{
if (*p != '#')
n = strtol((const char *)p, (char **)&p, 0);
else
n = -1;
}
if (n >= 0 && n < 65536)
{
glob->from_unicode[n] = i;
glob->to_unicode[i] = n;
}
}
}
}
}
Close(fh);
}
CloseLibrary(DOSBase);
return fh ? TRUE : FALSE;
}
/* Add a bootnode using expansion.library */
BOOL ata_RegisterVolume(ULONG StartCyl, ULONG EndCyl, struct ata_Unit *unit)
{
struct ExpansionBase *ExpansionBase;
struct DeviceNode *devnode;
TEXT dosdevname[4] = "HD0";
const ULONG IdDOS = AROS_MAKE_ID('D','O','S','\001');
const ULONG IdCDVD = AROS_MAKE_ID('C','D','V','D');
ExpansionBase = (struct ExpansionBase *)OpenLibrary("expansion.library",
40L);
if (ExpansionBase)
{
IPTR pp[24];
/* This should be dealt with using some sort of volume manager or such. */
switch (unit->au_DevType)
{
case DG_DIRECT_ACCESS:
break;
case DG_CDROM:
dosdevname[0] = 'C';
break;
default:
D(bug("[ATA>>]:-ata_RegisterVolume called on unknown devicetype\n"));
}
if (unit->au_UnitNum < 10)
dosdevname[2] += unit->au_UnitNum % 10;
else
dosdevname[2] = 'A' - 10 + unit->au_UnitNum;
pp[0] = (IPTR)dosdevname;
pp[1] = (IPTR)MOD_NAME_STRING;
pp[2] = unit->au_UnitNum;
pp[DE_TABLESIZE + 4] = DE_BOOTBLOCKS;
pp[DE_SIZEBLOCK + 4] = 1 << (unit->au_SectorShift - 2);
pp[DE_NUMHEADS + 4] = unit->au_Heads;
pp[DE_SECSPERBLOCK + 4] = 1;
pp[DE_BLKSPERTRACK + 4] = unit->au_Sectors;
pp[DE_RESERVEDBLKS + 4] = 2;
pp[DE_LOWCYL + 4] = StartCyl;
pp[DE_HIGHCYL + 4] = EndCyl;
pp[DE_NUMBUFFERS + 4] = 10;
pp[DE_BUFMEMTYPE + 4] = MEMF_PUBLIC | MEMF_31BIT;
pp[DE_MAXTRANSFER + 4] = 0x00200000;
pp[DE_MASK + 4] = 0x7FFFFFFE;
pp[DE_BOOTPRI + 4] = ((unit->au_DevType == DG_DIRECT_ACCESS) ? 0 : 10);
pp[DE_DOSTYPE + 4] = ((unit->au_DevType == DG_DIRECT_ACCESS) ? IdDOS : IdCDVD);
pp[DE_CONTROL + 4] = 0;
pp[DE_BOOTBLOCKS + 4] = 2;
devnode = MakeDosNode(pp);
if (devnode)
{
D(bug("[ATA>>]:-ata_RegisterVolume: '%b', type=0x%08lx with StartCyl=%d, EndCyl=%d .. ",
devnode->dn_Name, pp[DE_DOSTYPE + 4], StartCyl, EndCyl));
AddBootNode(pp[DE_BOOTPRI + 4], ADNF_STARTPROC, devnode, NULL);
D(bug("done\n"));
return TRUE;
}
CloseLibrary((struct Library *)ExpansionBase);
}
return FALSE;
}
static BOOL ClassInit(UNUSED struct Library *base)
{
ENTER();
if((DataTypesBase = OpenLibrary("datatypes.library",37)) &&
GETINTERFACE(IDataTypes,struct DataTypesIFace *,DataTypesBase) &&
(IFFParseBase = OpenLibrary("iffparse.library",37)) &&
GETINTERFACE(IIFFParse,struct IFFParseIFace *,IFFParseBase) &&
(LocaleBase = (APTR)OpenLibrary("locale.library",36)) &&
GETINTERFACE(ILocale,struct LocaleIFace *,LocaleBase))
{
BOOL success = TRUE;
// check for MUI 3.9+
if(LIB_VERSION_IS_AT_LEAST(MUIMasterBase, 20, 0))
{
lib_flags |= BASEFLG_MUI20;
// check for MUI 4.0+
if(LIB_VERSION_IS_AT_LEAST(MUIMasterBase, 20, 5500))
lib_flags |= BASEFLG_MUI4;
}
// on MUI 3.1 system's we do have to
// initialize our subclasses as well
#if defined(__amigaos3__)
if(!(lib_flags & BASEFLG_MUI20))
{
if(!initColoradjust() ||
!initPenadjust() ||
!initBackgroundadjust() ||
!initPoppen() ||
!initPopbackground())
{
success = FALSE;
}
}
#endif
if(success == TRUE)
{
// open the TheBar_mcp catalog
OpenCat();
LocalizeArray(regs,regIDs);
LocalizeArray(frames,frameIDs);
LocalizeArray(precisions,precisionIDs);
LocalizeArray(dismodes,dismodeIDs);
LocalizeArray(spacersSizes,spacersSizeIDs);
LocalizeArray(viewModes,viewModeIDs);
LocalizeArray(labelPoss,labelPosIDs);
// we open the cybgraphics.library but without failing if
// it doesn't exist
#if !defined(__amigaos4__)
CyberGfxBase = OpenLibrary("cybergraphics.library", 41);
/*
if(!GETINTERFACE(ICyberGfx, struct CyberGfxIFace *, CyberGfxBase))
{
CloseLibrary(CyberGfxBase);
CyberGfxBase = NULL;
}
*/
#endif
#if !defined(__MORPHOS__)
{
struct Library *nbitmapMcc;
nbitmapCanHandleRawData = FALSE;
// we need at least NBitmap.mcc V15.8 to be able to let it handle raw image data
if((nbitmapMcc = OpenLibrary("mui/NBitmap.mcc", 0)) != NULL)
{
SHOWVALUE(DBF_ALWAYS, nbitmapMcc->lib_Version);
SHOWVALUE(DBF_ALWAYS, nbitmapMcc->lib_Revision);
if(nbitmapMcc->lib_Version > 15 || (nbitmapMcc->lib_Version == 15 && nbitmapMcc->lib_Revision >= 8))
nbitmapCanHandleRawData = TRUE;
CloseLibrary(nbitmapMcc);
}
SHOWVALUE(DBF_ALWAYS, nbitmapCanHandleRawData);
}
#endif
lib_flags |= BASEFLG_Init;
RETURN(TRUE);
return TRUE;
}
}
ClassExpunge(base);
RETURN(FALSE);
return FALSE;
}
// Open the button editor (called from a sub-process)
void buttons_edit(
IPCData *my_ipc,
buttons_edit_packet *packet)
{
ButtonsStartup startup;
struct Library *ConfigOpusBase;
IPCData *ipc;
long ret,command;
Buttons *buttons=0;
Cfg_Button *send_button=0;
struct AppMessage *send_msg=0;
short button_col=-1,button_row=-1;
short can_start=1;
// Get packet data
if (packet)
{
buttons=packet->buttons;
send_button=packet->edit;
button_col=packet->col;
button_row=packet->row;
can_start=packet->can_start;
send_msg=packet->appmsg;
}
// Lock process list
lock_listlock(&GUI->process_list,FALSE);
// Get edit command
command=(button_col==-2)?BUTTONEDIT_RE_EDIT_ME:BUTTONEDIT_EDIT_ME;
// See if button editor is running
if (ipc=IPC_FindProc(&GUI->process_list,NAME_BUTTON_EDITOR_RUN,FALSE,0))
{
BOOL front=1;
// Button bank supplied?
if (buttons)
{
// Does the bank not already have the editor?
if (!buttons->editor)
{
// Tell editor to edit the toolbar bank
IPC_Command(
ipc,
command,
(ULONG)buttons->bank,
buttons->ipc,
0,
0);
// Set flag for pending edit request
buttons->flags|=BUTTONF_EDIT_REQUEST;
front=0;
}
// Button to send?
if (send_button)
{
Point *pos;
// Allocate position
if (pos=AllocVec(sizeof(Point),MEMF_CLEAR))
{
// Convert coordinates to window relative
pos->x=button_col-buttons->window->LeftEdge;
pos->y=button_row-buttons->window->TopEdge;
// Send command
IPC_Command(
ipc,
BUTTONEDIT_BUTTON_TO_BANK,
0,
send_button,
pos,
0);
send_button=0;
}
front=0;
}
// Message to send?
if (send_msg)
{
// Send it on
IPC_Command(
ipc,
CFG_APPMESSAGE_PASS,
(ULONG)buttons->bank,
send_msg,
0,
0);
send_msg=0;
}
// Button to edit?
if (button_col>-1)
{
// Send edit command
IPC_Command(
ipc,
BUTTONEDIT_EDIT_BUTTON,
button_col,
(APTR)button_row,
0,
0);
front=0;
}
}
// Bring editor to front
if (front) IPC_Command(ipc,IPC_ACTIVATE,0,0,0,0);
}
// Unlock the process list
unlock_listlock(&GUI->process_list);
// Free button if we have one
if (send_button) FreeButton(send_button);
// Free message if we have one
if (send_msg) ReplyAppMessage((DOpusAppMessage *)send_msg);
// If editor was already running, or we can't start it if not, return
if (ipc || !can_start) return;
// Change our name
my_ipc->proc->pr_Task.tc_Node.ln_Name=NAME_BUTTON_EDITOR_RUN;
// Set flag
GUI->flags|=GUIF_BUTTON_EDITOR;
// Open configuration library
if (!(ConfigOpusBase=OpenModule(config_name)))
return;
// Bank supplied?
if (buttons)
{
// Fill out startup packet
startup.bank=buttons->bank;
startup.ipc=buttons->ipc;
// Button supplied?
if (button_col>-1)
{
// Set flag
startup.flag=1;
// Pass button
startup.button=(button_col<<16)|button_row;
}
else startup.flag=0;
// Set pending edit request
buttons->flags|=BUTTONF_EDIT_REQUEST;
}
else startup.bank=0;
// Configure buttons
ret=Config_Buttons(
&startup,
my_ipc,
&main_ipc,
GUI->screen_pointer,
(ULONG)&GUI->command_list.list);
// Change our name back
my_ipc->proc->pr_Task.tc_Node.ln_Name=NAME_BUTTON_EDITOR;
// Clear flag
GUI->flags&=~GUIF_BUTTON_EDITOR;
// Permit now we've cleaned up
Permit();
// Close library
CloseLibrary(ConfigOpusBase);
// Lock buttons list
lock_listlock(&GUI->buttons_list,FALSE);
// Go through button banks
for (ipc=(IPCData *)GUI->buttons_list.list.lh_Head;
ipc->node.mln_Succ;
ipc=(IPCData *)ipc->node.mln_Succ)
{
// Get buttons pointer
Buttons *buttons=IPCDATA(ipc);
// Toolbar buttons?
if (buttons->flags&BUTTONF_TOOLBAR)
{
// Hide bank
IPC_Command(ipc,IPC_HIDE,0,0,0,REPLY_NO_PORT);
// Need to save?
if (ret&CONFIG_SAVE)
IPC_Command(ipc,BUTTONS_SAVE,0,0,0,REPLY_NO_PORT);
// Use?
if (ret)
{
// Send change
send_main_reset_cmd(CONFIG_CHANGE_LIST_TOOLBAR,0,buttons->bank);
// Steal bank pointer
IPC_Command(ipc,BUTTONEDIT_NEW_BANK,1,0,0,REPLY_NO_PORT);
}
// Close bank
IPC_Command(ipc,IPC_QUIT,0,0,0,0);
}
// Ok?
else
if (ret)
{
// Save?
if (ret&CONFIG_SAVE)
{
// Buttons been changed?
if (buttons->flags&BUTTONF_CHANGED)
{
// Tell bank to save itself
IPC_Command(ipc,BUTTONS_SAVE,0,0,0,REPLY_NO_PORT);
}
}
// Clear 'new' flag
buttons->flags&=~BUTTONF_NEW_BANK;
}
}
// Unlock buttons list
unlock_listlock(&GUI->buttons_list);
}
int main(void)
{
if((IntuitionBase = (APTR)OpenLibrary("intuition.library", 38)) &&
GETINTERFACE(IIntuition, IntuitionBase))
if((KeymapBase = OpenLibrary("keymap.library", 37)) &&
GETINTERFACE(IKeymap, KeymapBase))
if((UtilityBase = (APTR)OpenLibrary("utility.library", 38)) &&
GETINTERFACE(IUtility, UtilityBase))
if((MUIMasterBase = OpenLibrary("muimaster.library", MUIMASTER_VMIN)) &&
GETINTERFACE(IMUIMaster, MUIMasterBase))
{
struct MUI_CustomClass *mcc;
Object *app, *window, *bstring, *button;
const char *classes[] = {"BetterString.mcc", NULL};
mcc = MUI_CreateCustomClass(NULL, "BetterString.mcc", NULL, sizeof(struct InstData), ENTRY(_Dispatcher));
app = ApplicationObject,
MUIA_Application_Author, "Allan Odgaard",
MUIA_Application_Base, "HotkeyString-Demo",
MUIA_Application_Copyright, "®1997 Allan Odgaard",
MUIA_Application_Description, "HotkeyString.mcc demonstration program",
MUIA_Application_Title, "HotkeyString-Demo",
MUIA_Application_Version, "$VER: HotkeyString-Demo V1.0 (3-Sep-97)",
MUIA_Application_UsedClasses, classes,
MUIA_Application_Window, window = WindowObject,
MUIA_Window_Title, "HotkeyString-Demo",
MUIA_Window_ID, MAKE_ID('M','A','I','N'),
MUIA_Window_RootObject, VGroup,
Child, TextObject,
MUIA_Font, MUIV_Font_Tiny,
MUIA_Text_Contents, "\33cHotkeyString.mcc",
End,
Child, HGroup,
Child, bstring = ((Object *)NewObject(mcc->mcc_Class, NULL,
StringFrame,
MUIA_CycleChain, TRUE,
MUIA_String_AdvanceOnCR, TRUE,
MUIA_HotkeyString_Snoop, FALSE,
End),
Child, button = TextObject, ButtonFrame,
MUIA_CycleChain, TRUE,
MUIA_Background, MUII_ButtonBack,
MUIA_Text_Contents, "Sample",
MUIA_Text_SetMax, TRUE,
MUIA_InputMode, MUIV_InputMode_Toggle,
End,
End,
Child, TextObject,
MUIA_Font, MUIV_Font_Tiny,
MUIA_Text_Contents, "\33cConstant snoop",
End,
Child, NewObject(mcc->mcc_Class, NULL,
StringFrame,
MUIA_CycleChain, TRUE,
End,
End,
End,
End;
if(app)
{
ULONG sigs;
DoMethod(window, MUIM_Notify, MUIA_Window_CloseRequest, TRUE, MUIV_Notify_Application, 3, MUIM_Application_ReturnID, MUIV_Application_ReturnID_Quit);
DoMethod(button, MUIM_Notify, MUIA_Selected, TRUE, MUIV_Notify_Window, 3, MUIM_Set, MUIA_Window_ActiveObject, bstring);
DoMethod(button, MUIM_Notify, MUIA_Selected, MUIV_EveryTime, bstring, 3, MUIM_Set, MUIA_HotkeyString_Snoop, MUIV_TriggerValue);
DoMethod(bstring, MUIM_Notify, MUIA_String_Contents, MUIV_EveryTime, button, 3, MUIM_Set, MUIA_Selected, FALSE);
set(window, MUIA_Window_ActiveObject, bstring);
set(window, MUIA_Window_Open, TRUE);
while((LONG)DoMethod(app, MUIM_Application_NewInput, &sigs) != (LONG)MUIV_Application_ReturnID_Quit)
{
if(sigs)
{
sigs = Wait(sigs | SIGBREAKF_CTRL_C);
if(sigs & SIGBREAKF_CTRL_C)
break;
}
}
MUI_DisposeObject(app);
if(mcc)
MUI_DeleteCustomClass(mcc);
}
DROPINTERFACE(IMUIMaster);
CloseLibrary(MUIMasterBase);
}
if(UtilityBase)
{
DROPINTERFACE(IUtility);
CloseLibrary((struct Library *)UtilityBase);
}
if(KeymapBase)
{
DROPINTERFACE(IKeymap);
CloseLibrary(KeymapBase);
}
if(IntuitionBase)
{
DROPINTERFACE(IIntuition);
CloseLibrary((struct Library *)IntuitionBase);
}
return 0;
}
static void getSystemCodeset(struct LibraryHeader *lib)
{
struct codeset *foundCodeset = NULL;
ENTER();
// before we go any query the system via locale.library (which
// might not be so accurate) we try different other means of
// finding the codeset/charset of the system
#if defined(__amigaos4__)
if(foundCodeset == NULL)
{
LONG default_charset = GetDiskFontCtrl(DFCTRL_CHARSET);
char *charset = (char *)ObtainCharsetInfo(DFCS_NUMBER, default_charset, DFCS_MIMENAME);
foundCodeset = codesetsFind(&lib->codesets, charset);
D(DBF_STARTUP, "%s system default codeset: '%s' (diskfont)", foundCodeset ? "found" : "not found", charset);
}
#endif
if(foundCodeset == NULL)
{
char codepage[40];
codepage[0] = '\0';
if(GetVar("CODEPAGE", codepage, sizeof(codepage), 0) > 0)
{
D(DBF_STARTUP, "trying ENV:CODEPAGE '%s'", codepage);
foundCodeset = codesetsFind(&lib->codesets, codepage);
}
D(DBF_STARTUP, "%s system default codeset: '%s' (ENV:CODEPAGE)", foundCodeset ? "found" : "did not find",
foundCodeset ? foundCodeset->name : "?");
}
#if defined(__MORPHOS__)
if(foundCodeset == NULL)
{
/* If CODEPAGE did not work (maybe user deleted it or something) we try a keymap instead. This only works
* in MorphOS 2 and only if an old Amiga keymap is not used.
*/
if(foundCodeset == NULL)
{
struct Library *KeymapBase;
if((KeymapBase = OpenLibrary("keymap.library", 51)) != NULL)
{
/* Since we requested V51 it is either V51 or newer */
if(KeymapBase->lib_Version > 51 || KeymapBase->lib_Revision >= 4)
{
CONST_STRPTR codepage;
#ifndef GetKeyMapCodepage
#define GetKeyMapCodepage(__p0) LP1(78, CONST_STRPTR , GetKeyMapCodepage, CONST struct KeyMap *, __p0, a0, , KEYMAP_BASE_NAME, 0, 0, 0, 0, 0, 0)
#endif
if((codepage = GetKeyMapCodepage(NULL)) != NULL)
{
foundCodeset = codesetsFind(&lib->codesets, codepage);
D(DBF_STARTUP, "%s system default codeset: '%s' (keymap)", foundCodeset ? "found" : "did not find",
foundCodeset ? foundCodeset->name : "?");
}
}
CloseLibrary(KeymapBase);
}
}
}
#endif
// if we still do not have our default charset we try to load
// it from and environment variable ENVARC:CHARSET
if(foundCodeset == NULL)
{
char charset[80];
charset[0] = '\0';
if(GetVar("CHARSET", charset, sizeof(charset), 0) > 0)
{
D(DBF_STARTUP, "trying ENV:CHARSET '%s'", charset);
foundCodeset = codesetsFind(&lib->codesets, charset);
}
D(DBF_STARTUP, "%s system default codeset: '%s' (ENV:CHARSET)", foundCodeset ? "found" : "did not find",
foundCodeset ? foundCodeset->name : "?");
}
// try the country code next
if(foundCodeset == NULL)
{
struct Locale *defaultLocale;
if((defaultLocale = OpenLocale(NULL)) != NULL)
{
int i;
const struct loc *curLoc = NULL;
BOOL found = FALSE;
for(i=0;;i++)
{
curLoc = &locs[i];
if(curLoc == NULL || curLoc->name == NULL)
break;
if(defaultLocale->loc_CountryCode == curLoc->carPlateCode || defaultLocale->loc_CountryCode == curLoc->iso3166Code)
{
D(DBF_STARTUP, "found country code for '%s'", curLoc->name);
found = TRUE;
break;
}
}
if(found == TRUE)
foundCodeset = codesetsFind(&lib->codesets, curLoc->codesetName);
CloseLocale(defaultLocale);
}
D(DBF_STARTUP, "%s system default codeset: '%s' (locale/country)", foundCodeset ? "found" : "did not find",
foundCodeset ? foundCodeset->name : "?");
}
// and if even the CHARSET environment variable didn't work
// out we check the LANGUAGE env variable against our own
// internal fallback list
if(foundCodeset == NULL)
{
char language[80];
language[0] = '\0';
if(GetVar("LANGUAGE", language, sizeof(language), 0) > 0)
{
int i;
const struct loc *curLoc = NULL;
BOOL found = FALSE;
for(i=0;;i++)
{
curLoc = &locs[i];
if(curLoc == NULL || curLoc->name == NULL)
break;
if(Strnicmp(language, curLoc->name, curLoc->len) == 0)
{
D(DBF_STARTUP, "found language name for '%s'", curLoc->name);
found = TRUE;
break;
}
}
if(found == TRUE)
foundCodeset = codesetsFind(&lib->codesets, curLoc->codesetName);
}
D(DBF_STARTUP, "%s system default codeset: '%s' (ENV:LANGUAGE)", foundCodeset ? "found" : "did not find",
foundCodeset ? foundCodeset->name : "?");
}
// and the very last check we do to find out the system's charset is
// to use locale.library.
if(foundCodeset == NULL)
{
struct Locale *locale;
if((locale = OpenLocale(NULL)) != NULL)
{
int i;
char *language = locale->loc_LanguageName;
const struct loc *curLoc = NULL;
BOOL found = FALSE;
for(i=0;;i++)
{
curLoc = &locs[i];
if(curLoc == NULL || curLoc->name == NULL)
break;
if(Strnicmp(language, curLoc->name, curLoc->len) == 0)
{
found = TRUE;
break;
}
}
CloseLocale(locale);
if(found == TRUE)
foundCodeset = codesetsFind(&lib->codesets, curLoc->codesetName);
}
D(DBF_STARTUP, "%s system default codeset: '%s' (locale/language)", foundCodeset ? "found" : "did not find",
foundCodeset ? foundCodeset->name : "?");
}
// and if even that very last test didn't work out we
// can just take the ISO-8859-1 charset as the fallback default
if(foundCodeset == NULL)
lib->systemCodeset = codesetsFind(&lib->codesets, "ISO-8859-1");
else
lib->systemCodeset = foundCodeset;
D(DBF_STARTUP, "final system default codeset: '%s'", lib->systemCodeset ? lib->systemCodeset->name : "?");
LEAVE();
}
LONG
main(VOID)
{
struct DosLibrary *DOSBase;
struct RDArgs *readargs;
LONG rargs[5], vargs[5];
UBYTE *source, *target;
ULONG buffersize = 0;
UBYTE *sourcedir, *targetdir;
UBYTE *textbuffer, *tmp, *tmp1, *tmp2;
struct AnchorPath *anchorpath;
struct FileInfoBlock *fib, *targetfib;
struct Process *process;
APTR wptr;
BPTR dirlock, filelock;
BOOL checkdatestamp, all;
LONG date, error, rc = 0;
/* Fail silently if < 37 */
if (DOSBase = (struct DosLibrary *) OpenLibrary("dos.library", 37))
{
rargs[0] = 0L;
rargs[1] = 0L;
rargs[2] = 0L;
rargs[3] = 0L;
rargs[4] = 0L;
if (readargs = ReadArgs("SOURCE/A,TARGET/A,DATE/S,ALL/S,BUFFER/K/N", rargs, NULL))
{
source = (UBYTE *) rargs[0];
target = (UBYTE *) rargs[1];
checkdatestamp = (BOOL) rargs[2];
all = (BOOL) rargs[3];
if (!(sourcedir = AllocMem(StrLen(source) + 129, MEMF_CLEAR)))
error = ERROR_NO_FREE_STORE;
else
{
/* 128 bytes to print informative text */
textbuffer = sourcedir + StrLen(source) + 1;
/* use user specified buffersize if indicated */
if (rargs[4])
buffersize = *((LONG *) rargs[4]);
if (buffersize < BUFFERSIZE || buffersize > 4096)
buffersize = BUFFERSIZE;
if (!(targetdir = AllocMem(buffersize, MEMF_CLEAR)))
error = ERROR_NO_FREE_STORE;
else
{
if (!(targetfib = AllocDosObject(DOS_FIB, NULL)))
error = ERROR_NO_FREE_STORE;
else
{
/*
* Check if source and target are valid.
*
* Separate source path from pattern (if any). Use the source path figure
* out what to append to the target.
*/
/* No requesters */
process = (struct Process *) FindTask(NULL);
wptr = process->pr_WindowPtr;
process->pr_WindowPtr = (APTR) - 1L;
if ((error = GetPath(source, sourcedir, StrLen(source) + 1) == 0))
{
if (!(dirlock = Lock(sourcedir, SHARED_LOCK)))
error = IoErr();
else
{
UnLock(dirlock);
if (!(dirlock = Lock(target, SHARED_LOCK)))
error = IoErr();
else
{
UnLock(dirlock);
if (anchorpath = AllocMem(sizeof(struct AnchorPath) + buffersize,
MEMF_CLEAR))
{
anchorpath->ap_Strlen = buffersize;
/* Allow to break on CTRL-C */
anchorpath->ap_BreakBits = SIGBREAKF_CTRL_C;
if ((error = MatchFirst(source, anchorpath)) == 0)
{
do
{
fib = &(anchorpath->ap_Info);
/*
* APF_DIDDIR indicates that we used returned from a
* directory. In that case we clear both APF_DIDDIR and
* APF_DODIR, so we can start afresh with the next one.
*/
if (anchorpath->ap_Flags & APF_DIDDIR)
anchorpath->ap_Flags &= ~(APF_DODIR | APF_DIDDIR);
else
{
/*
* Make a filename for the target directory. First copy
* targetname into buffer.
*/
targetdir[0] = '\0';
tmp = targetdir;
tmp1 = target;
while (*tmp++ = *tmp1++);
/* Skip sourcename in ap_Buf */
tmp1 = sourcedir;
tmp2 = anchorpath->ap_Buf;
while (*tmp1++ == *tmp2++);
/* Skip back 1 if not after a separator */
if (*(tmp2 - 1) != '/')
tmp2--;
/*
* We hit the source itself, don't compare it, but enter
* it.
*/
if (*tmp2 == 0)
{
anchorpath->ap_Flags |= APF_DODIR;
continue;
}
/* Build it */
if (AddPart(targetdir, tmp2, buffersize - 1))
vargs[0] = (LONG) targetdir;
else
{
PrintFault(ERROR_NO_FREE_STORE, NULL);
break;
}
/* Lock it and check it out */
if (filelock = Lock(targetdir, SHARED_LOCK))
{
if ((Examine(filelock, targetfib)) == DOSTRUE)
{
textbuffer[0] = '\0';
/*
* To get nice output without work I use AddPart() to
* add differences to the textbuffer.
*/
if (targetfib->fib_DirEntryType
!= fib->fib_DirEntryType)
AddPart(textbuffer, "of different type", 128);
else
{
if (targetfib->fib_Size < fib->fib_Size)
AddPart(textbuffer, "smaller", 128);
else if (targetfib->fib_Size > fib->fib_Size)
AddPart(textbuffer, "larger", 128);
if (checkdatestamp)
{
date = CompareDates((struct DateStamp *)
& (fib->fib_Date),
(struct DateStamp *) & (targetfib->fib_Date));
if (date < 0)
AddPart(textbuffer, "older", 128);
else if (date > 0)
AddPart(textbuffer, "newer", 128);
}
}
if (*textbuffer != NULL)
{
vargs[1] = (LONG) textbuffer;
VFPrintf(Output(), "%s: object %s\n", vargs);
}
}
else
PrintFault(IoErr(), targetdir);
UnLock(filelock);
}
else
{
PrintFault(IoErr(), targetdir);
/*
* If and error occured on a directory name, don't enter
* it.
*/
if (fib->fib_DirEntryType > 0)
continue;
}
/*
* If the ALL keyword has been used and this is a directory
* enter it by setting the APF_DODIR flag.
*/
if (fib->fib_DirEntryType > 0 && all != FALSE)
anchorpath->ap_Flags |= APF_DODIR;
}
} while ((error = MatchNext(anchorpath)) == 0);
}
MatchEnd(anchorpath);
if (error == ERROR_NO_MORE_ENTRIES)
error = 0;
FreeMem(anchorpath, sizeof(struct AnchorPath) + buffersize);
}
}
}
/* Reset windowpointer */
process->pr_WindowPtr = wptr;
}
else
PrintFault(error, NULL);
FreeDosObject(DOS_FIB, targetfib);
}
FreeMem(targetdir, buffersize);
}
FreeMem(sourcedir, StrLen(sourcedir) + 129);
}
FreeArgs(readargs);
}
else
error = IoErr();
SetIoErr(error);
if (error)
{
PrintFault(error, NULL);
if (error = ERROR_BREAK)
rc = RETURN_WARN;
else
error = RETURN_FAIL;
}
CloseLibrary((struct Library *) DOSBase);
}
return (rc);
}
LONG
GetPath(UBYTE * path, UBYTE * buffer, LONG buffersize)
{
UBYTE *pathpart, *filepart;
UBYTE *tmp1, *tmp2;
BPTR lock;
struct FileInfoBlock *fib;
LONG error = 0;
/* Open own copy of dos.library if pragmas are used so it's standalone */
#ifdef PRAGMAS
struct Library *DOSBase;
if (!(DOSBase = OpenLibrary("dos.library", 36)))
return (1);
#endif
/*
* If there seems to be no path, the pathpart will point to the filepart too, so we
* need to check for that.
*/
filepart = FilePart(path);
pathpart = PathPart(path);
/*
* This also handles cases where there is only a volume/device name, only a
* directory name or a combo of those.
*/
if (pathpart == path)
{
/*
* There seems to be only one component. Copy it if it is not wild. Caller will
* have to check whether if it exists and if it is a file or directory.
*/
if (!(ItsWild(pathpart)))
pathpart = NULL;
}
if (pathpart != path)
{
/*
* If pathpart equals filepart (pointer wise) then there is only one component
* (possible preceeded by a volume name).
*/
if (pathpart == filepart)
{
if (!(ItsWild(pathpart)))
pathpart = NULL;
}
else
{
/* Try to lock it to determine if the last component is a directory. */
if (lock = Lock(path, SHARED_LOCK))
{
if (fib = AllocMem(sizeof(struct FileInfoBlock), MEMF_CLEAR))
{
if ((Examine(lock, fib)) == DOSTRUE)
{
/* Hey it's a directory after all */
if (fib->fib_DirEntryType > 0)
pathpart = NULL;
}
FreeMem(fib, sizeof(struct FileInfoBlock));
}
UnLock(lock);
} /* else treat it as a filename */
}
/* Copy the pathpart in the buffer */
tmp1 = buffer;
tmp2 = path;
while ((*tmp1++ = *tmp2++) && (tmp2 != pathpart))
{
if (tmp1 == (buffer + buffersize))
{
error = ERROR_NO_FREE_STORE;
break;
}
}
*tmp1 = '\0'; /* NULL terminate. */
}
#ifdef PRAGMAS
CloseLibrary(DOSBase);
#endif
return (error);
}
BOOL BuildGUI(char *screenname)
{
Object *MUISave, *MUIUse, *MUICancel;
Object *page1,*page2;
Object *MUITFreq,*MUITChannels,*MUITOutvol,*MUITMonvol,*MUITGain,*MUITInput,*MUITOutput,*MUITDebug,*MUITEcho,*MUITSurround,*MUITClipvol,*MUITCpu,*MUITACTime,*MUITScalemode;
UpdateStrings();
MUIMasterBase = (void *)OpenLibrary("muimaster.library", MUIMASTER_VLATEST);
if(MUIMasterBase == NULL)
{
Printf((char *) msgTextNoOpen, (ULONG) "muimaster.library", MUIMASTER_VLATEST);
Printf("\n");
return FALSE;
}
#ifdef __AMIGAOS4__
IMUIMaster = (struct MUIMasterIFace *) GetInterface(MUIMasterBase, "main", 1, NULL);
if(IMUIMaster == NULL)
{
Printf((char *) msgTextNoOpen, (ULONG) "MUIMaster main interface", 1);
Printf("\n");
CloseLibrary((struct Library*) MUIMasterBase);
return FALSE;
}
#endif
page1 = HGroup,
Child, VGroup,
Child, MUIUnit = CycleObject,
MUIA_CycleChain, 1,
MUIA_Cycle_Entries, Units,
MUIA_Cycle_Active, state.UnitSelected,
End,
Child, ListviewObject,
MUIA_CycleChain, 1,
MUIA_Listview_List, MUIList = ListObject,
InputListFrame,
MUIA_List_AutoVisible, TRUE,
End,
End,
Child, HGroup,
ReadListFrame,
MUIA_Background, MUII_TextBack,
Child, TextObject,
MUIA_Text_Contents, msgProperties,
MUIA_Text_SetMax, TRUE,
End,
Child, MUIInfos = TextObject,
MUIA_Text_Contents, "\n\n\n\n\n\n",
MUIA_Text_SetMin, FALSE,
End,
End,
End,
Child, BalanceObject,
End,
Child, VGroup,
Child, HVSpace,
Child, ColGroup(3),
GroupFrameT(msgOptions),
Child, MUITFreq = SpecialButton((STRPTR)msgOptFrequency),
Child, MUIFreq = SpecialSlider(0,max(state.Frequencies-1,0),state.FreqSelected),
Child, MUILFreq = SpecialLabel(getFreq()),
Child, MUITChannels = SpecialButton((STRPTR)msgOptChannels),
Child, MUIChannels = SpecialSlider(1,state.Channels,state.ChannelsSelected),
Child, MUILChannels = SpecialLabel(getChannels()),
Child, MUITOutvol = SpecialButton((STRPTR)msgOptVolume),
Child, MUIOutvol = SpecialSlider(0,max(state.OutVols-1,0),state.OutVolSelected),
Child, MUILOutvol = SpecialLabel(getOutVol()),
Child, MUITMonvol = SpecialButton((STRPTR)msgOptMonitor),
Child, MUIMonvol = SpecialSlider(0,max(state.MonVols-1,1),state.MonVolSelected),
Child, MUILMonvol = SpecialLabel(getMonVol()),
Child, MUITGain = SpecialButton((STRPTR)msgOptGain),
Child, MUIGain = SpecialSlider(0,max(state.Gains-1,0),state.GainSelected),
Child, MUILGain = SpecialLabel(getGain()),
Child, MUITInput = SpecialButton((STRPTR)msgOptInput),
Child, MUIInput = SpecialSlider(0,max(state.Inputs-1,0),state.InputSelected),
Child, MUILInput = SpecialLabel(getInput()),
Child, MUITOutput = SpecialButton((STRPTR)msgOptOutput),
Child, MUIOutput = SpecialSlider(0,max(state.Outputs-1,0),state.OutputSelected),
Child, MUILOutput = SpecialLabel(getOutput()),
End,
Child, MUIPlay = SimpleButton(msgButtonPlay),
Child, HVSpace,
End,
End;
page2 = VGroup,
Child, HVSpace,
Child, HGroup,
Child, HVSpace,
Child, ColGroup(2),
GroupFrameT(msgGlobalOptions),
Child, MUITDebug = SpecialButton((STRPTR)msgGlobOptDebugLevel),
Child, MUIDebug = CycleObject,
MUIA_CycleChain, 1,
MUIA_Cycle_Entries, DebugLabels,
MUIA_Cycle_Active, globalprefs.ahigp_DebugLevel,
End,
Child, MUITEcho = SpecialButton((STRPTR)msgGlobOptEcho),
Child, MUIEcho = CycleObject,
MUIA_CycleChain, 1,
MUIA_Cycle_Entries, EchoLabels,
MUIA_Cycle_Active, (globalprefs.ahigp_DisableEcho ? 2 : 0) | (globalprefs.ahigp_FastEcho ? 1 : 0),
MUIA_Disabled, AHIBase->lib_Version >= 5,
End,
Child, MUITSurround = SpecialButton((STRPTR)msgGlobOptSurround),
Child, MUISurround = CycleObject,
MUIA_CycleChain, 1,
MUIA_Cycle_Entries, SurroundLabels,
MUIA_Cycle_Active, globalprefs.ahigp_DisableSurround,
MUIA_Disabled, AHIBase->lib_Version >= 5,
End,
Child, MUITClipvol = SpecialButton((STRPTR)msgGlobOptMasterVol),
Child, MUIClipvol = CycleObject,
MUIA_CycleChain, 1,
MUIA_Cycle_Entries, ClipMVLabels,
MUIA_Cycle_Active, globalprefs.ahigp_ClipMasterVolume,
MUIA_Disabled, AHIBase->lib_Version >= 5,
End,
Child, MUITCpu = SpecialButton((STRPTR)msgGlobOptCPULimit),
Child, MUICpu = SliderObject,
MUIA_CycleChain, 1,
MUIA_Slider_Horiz, TRUE,
MUIA_Numeric_Min, 0,
MUIA_Numeric_Max, 100,
MUIA_Numeric_Value,(globalprefs.ahigp_MaxCPU * 100 + 32768) / 65536,
MUIA_Numeric_Format,msgPercentFmt,
End,
Child, MUITACTime = SpecialButton((STRPTR)msgGlobOptACTime),
Child, MUIACTime = SliderObject,
MUIA_CycleChain, 1,
MUIA_Slider_Horiz, TRUE,
MUIA_Numeric_Min, 0,
MUIA_Numeric_Max, 100,
MUIA_Numeric_Value,(globalprefs.ahigp_AntiClickTime * 1000 + 32768) >> 16,
MUIA_Numeric_Format,msgACTimeFmt,
MUIA_Disabled, AHIBase->lib_Version <= 4,
End,
Child, MUITScalemode = SpecialButton((STRPTR)msgOptScalemode),
Child, MUIScalemode = CycleObject,
MUIA_CycleChain, 1,
MUIA_Cycle_Entries, ScaleLabels,
MUIA_Cycle_Active, globalprefs.ahigp_ScaleMode,
MUIA_Disabled, AHIBase->lib_Version <= 4,
End,
End,
Child, HVSpace,
End,
Child, HVSpace,
End;
MUIApp = ApplicationObject,
MUIA_Application_Title, (char *) msgTextProgramName,
MUIA_Application_Version, Version,
MUIA_Application_Copyright, "©1996-2005 Martin Blom",
MUIA_Application_Author, "Stéphane Barbaray/Martin Blom",
MUIA_Application_Base, "AHI",
MUIA_Application_HelpFile, HELPFILE,
MUIA_Application_Menustrip, MUIMenu = MUI_MakeObject(MUIO_MenustripNM,Menus,0),
MUIA_Application_SingleTask, TRUE,
SubWindow, MUIWindow = WindowObject,
MUIA_Window_Title, (char *) msgTextProgramName,
MUIA_Window_ID , MAKE_ID('M','A','I','N'),
MUIA_HelpNode, "AHI",
WindowContents, VGroup,
Child, RegisterGroup(PageNames),
MUIA_CycleChain, 1,
Child, page1,
Child, page2,
End,
Child, HGroup,
Child, MUISave = SimpleButton(msgButtonSave),
Child, MUIUse = SimpleButton(msgButtonUse),
Child, MUICancel = SimpleButton(msgButtonCancel),
End,
End,
End,
End;
if( MUIApp != NULL )
{
APTR item = (APTR)DoMethod(MUIMenu,MUIM_FindUData,ACTID_ICONS);
if(item)
{
set(item, MUIA_Menuitem_Checked, SaveIcons);
}
DoMethod(MUIWindow, MUIM_MultiSet, MUIA_Text_PreParse,"\033l",MUILFreq,MUILChannels,MUILOutvol,MUILMonvol,MUILGain,MUILInput,MUILOutput,NULL);
DoMethod(MUIWindow, MUIM_MultiSet, MUIA_CycleChain, 1, MUISave,MUIUse,MUICancel,NULL);
DoMethod(MUITFreq, MUIM_Notify, MUIA_Pressed, TRUE, MUIWindow, 3, MUIM_Set, MUIA_Window_ActiveObject, MUIFreq);
DoMethod(MUITChannels, MUIM_Notify, MUIA_Pressed, TRUE, MUIWindow, 3, MUIM_Set, MUIA_Window_ActiveObject, MUIChannels);
DoMethod(MUITOutvol, MUIM_Notify, MUIA_Pressed, TRUE, MUIWindow, 3, MUIM_Set, MUIA_Window_ActiveObject, MUIOutvol);
DoMethod(MUITMonvol, MUIM_Notify, MUIA_Pressed, TRUE, MUIWindow, 3, MUIM_Set, MUIA_Window_ActiveObject, MUIMonvol);
DoMethod(MUITGain, MUIM_Notify, MUIA_Pressed, TRUE, MUIWindow, 3, MUIM_Set, MUIA_Window_ActiveObject, MUIGain);
DoMethod(MUITInput, MUIM_Notify, MUIA_Pressed, TRUE, MUIWindow, 3, MUIM_Set, MUIA_Window_ActiveObject, MUIInput);
DoMethod(MUITOutput, MUIM_Notify, MUIA_Pressed, TRUE, MUIWindow, 3, MUIM_Set, MUIA_Window_ActiveObject, MUIOutput);
DoMethod(MUIPlay, MUIM_Notify, MUIA_Pressed, FALSE, MUIApp, 2, MUIM_Application_ReturnID, ACTID_PLAY);
DoMethod(MUITDebug, MUIM_Notify, MUIA_Pressed, TRUE, MUIWindow, 3, MUIM_Set, MUIA_Window_ActiveObject, MUIDebug);
DoMethod(MUITEcho, MUIM_Notify, MUIA_Pressed, TRUE, MUIWindow, 3, MUIM_Set, MUIA_Window_ActiveObject, MUIEcho);
DoMethod(MUITSurround, MUIM_Notify, MUIA_Pressed, TRUE, MUIWindow, 3, MUIM_Set, MUIA_Window_ActiveObject, MUISurround);
DoMethod(MUITClipvol, MUIM_Notify, MUIA_Pressed, TRUE, MUIWindow, 3, MUIM_Set, MUIA_Window_ActiveObject, MUIClipvol);
DoMethod(MUITCpu, MUIM_Notify, MUIA_Pressed, TRUE, MUIWindow, 3, MUIM_Set, MUIA_Window_ActiveObject, MUICpu);
DoMethod(MUITACTime, MUIM_Notify, MUIA_Pressed, TRUE, MUIWindow, 3, MUIM_Set, MUIA_Window_ActiveObject, MUIACTime);
DoMethod(MUITScalemode, MUIM_Notify, MUIA_Pressed, TRUE, MUIWindow, 3, MUIM_Set, MUIA_Window_ActiveObject, MUIScalemode);
DoMethod(MUIWindow, MUIM_Notify, MUIA_Window_CloseRequest, TRUE, MUIApp, 2, MUIM_Application_ReturnID, MUIV_Application_ReturnID_Quit);
DoMethod(MUISave, MUIM_Notify, MUIA_Pressed, FALSE, MUIApp, 2, MUIM_Application_ReturnID, ACTID_SAVE);
DoMethod(MUIUse, MUIM_Notify, MUIA_Pressed, FALSE, MUIApp, 2, MUIM_Application_ReturnID, ACTID_USE);
DoMethod(MUICancel, MUIM_Notify, MUIA_Pressed, FALSE, MUIApp, 2, MUIM_Application_ReturnID, MUIV_Application_ReturnID_Quit);
DoMethod(MUIUnit, MUIM_Notify, MUIA_Cycle_Active, MUIV_EveryTime, MUIApp, 2, MUIM_Application_ReturnID, ACTID_UNIT);
DoMethod(MUIList, MUIM_Notify, MUIA_List_Active, MUIV_EveryTime, MUIApp, 2, MUIM_Application_ReturnID, ACTID_MODE);
DoMethod(MUIDebug, MUIM_Notify, MUIA_Cycle_Active, MUIV_EveryTime, MUIApp, 2, MUIM_Application_ReturnID, ACTID_DEBUG);
DoMethod(MUISurround, MUIM_Notify, MUIA_Cycle_Active, MUIV_EveryTime, MUIApp, 2, MUIM_Application_ReturnID, ACTID_SURROUND);
DoMethod(MUIEcho, MUIM_Notify, MUIA_Cycle_Active, MUIV_EveryTime, MUIApp, 2, MUIM_Application_ReturnID, ACTID_ECHO);
DoMethod(MUICpu, MUIM_Notify, MUIA_Numeric_Value, MUIV_EveryTime, MUIApp, 2, MUIM_Application_ReturnID, ACTID_CPULIMIT);
DoMethod(MUIClipvol, MUIM_Notify, MUIA_Cycle_Active, MUIV_EveryTime, MUIApp, 2, MUIM_Application_ReturnID, ACTID_CLIPMV);
DoMethod(MUIACTime, MUIM_Notify, MUIA_Numeric_Value, MUIV_EveryTime, MUIApp, 2, MUIM_Application_ReturnID, ACTID_ACTIME);
DoMethod(MUIScalemode, MUIM_Notify, MUIA_Cycle_Active, MUIV_EveryTime, MUIApp, 2, MUIM_Application_ReturnID, ACTID_SCALEMODE);
DoMethod(MUIFreq, MUIM_Notify, MUIA_Numeric_Value, MUIV_EveryTime, MUIV_Notify_Self, 3, MUIM_CallHook, &hookSlider, MUIV_TriggerValue);
DoMethod(MUIChannels, MUIM_Notify, MUIA_Numeric_Value, MUIV_EveryTime, MUIV_Notify_Self, 3, MUIM_CallHook, &hookSlider, MUIV_TriggerValue);
DoMethod(MUIOutvol, MUIM_Notify, MUIA_Numeric_Value, MUIV_EveryTime, MUIV_Notify_Self, 3, MUIM_CallHook, &hookSlider, MUIV_TriggerValue);
DoMethod(MUIMonvol, MUIM_Notify, MUIA_Numeric_Value, MUIV_EveryTime, MUIV_Notify_Self, 3, MUIM_CallHook, &hookSlider, MUIV_TriggerValue);
DoMethod(MUIGain, MUIM_Notify, MUIA_Numeric_Value, MUIV_EveryTime, MUIV_Notify_Self, 3, MUIM_CallHook, &hookSlider, MUIV_TriggerValue);
DoMethod(MUIInput, MUIM_Notify, MUIA_Numeric_Value, MUIV_EveryTime, MUIV_Notify_Self, 3, MUIM_CallHook, &hookSlider, MUIV_TriggerValue);
DoMethod(MUIOutput, MUIM_Notify, MUIA_Numeric_Value, MUIV_EveryTime, MUIV_Notify_Self, 3, MUIM_CallHook, &hookSlider, MUIV_TriggerValue);
set(MUIWindow, MUIA_Window_Open, TRUE);
GUINewUnit();
return TRUE;
}
return FALSE;
}
int search_zorro(char option, BOOL testExpected, char *testValue) {
BOOL returnCode = FALSE;
struct ConfigDev *myCD = NULL;
UWORD m,t;
UBYTE p;
char manufacturer[8] = "0";
char product[8] = "0";
char type[20] = "Unknown";
if((ExpansionBase = OpenLibrary("expansion.library", 0L)) == NULL)
return FALSE;
while((myCD = FindConfigDev(myCD, -1L, -1L))) { /* search for all ConfigDevs */
m = myCD->cd_Rom.er_Manufacturer;
p = myCD->cd_Rom.er_Product;
t = myCD->cd_Rom.er_Type;
snprintf(manufacturer, 8, "%ld", m);
snprintf(product, 8, "%ld", p);
snprintf(type, 8, "%ld", t);
if (testExpected) {
switch ((unsigned int)option) {
case 'v':
if (stringTest(manufacturer, testValue)) returnCode = TRUE;
break;
case 'p':
if (stringTest(product, testValue)) returnCode = TRUE;
break;
case 't':
if (stringTest(type, testValue)) returnCode = TRUE;
break;
case '1':
case '2':
case '3':
break;
default:
error("Invalid option");
exit(EXIT_ERROR);
break;
}
} else {
switch ((unsigned int)option) {
case 'v':
printf("%s\n", manufacturer);
break;
case 'p':
printf("%s\n", product);
break;
case 't':
printf("%s\n", type);
break;
case '1':
printf("\n");
break;
case '2':
printf("\n");
break;
case '3':
printf("\n");
break;
default:
printf("ZORRO:%s:%s:%s:::\n", manufacturer, product, type);
break;
}
}
}
CloseLibrary(ExpansionBase);
return returnCode;
}
