static void set_best_resolution(_THIS, int width, int height)
{
Uint32 idok;
int depth=8;
if(SDL_Display)
depth=GetCyberMapAttr(SDL_Display->RastPort.BitMap,CYBRMATTR_DEPTH);
idok=BestCModeIDTags(CYBRBIDTG_NominalWidth,width,
CYBRBIDTG_NominalHeight,height,
CYBRBIDTG_Depth,depth,
TAG_DONE);
if(idok!=INVALID_ID)
{
if(SDL_Display)
{
if(currently_fullscreen)
CloseScreen(SDL_Display);
else
UnlockPubScreen(NULL,SDL_Display);
}
SDL_Display=GFX_Display=OpenScreenTags(NULL,SA_Width,width,SA_Height,height,
SA_Depth,depth,SA_DisplayID,idok,
SA_ShowTitle,FALSE,
TAG_DONE);
}
}
void main()
{
if ((scr = LockPubScreen("Workbench")))
{
wnd = OpenWindowTags(NULL,
WA_Title, "Textview",
WA_CloseGadget, TRUE,
WA_DragBar, TRUE,
WA_DepthGadget, TRUE,
WA_Activate, TRUE,
WA_InnerHeight, 400,
WA_IDCMP, IDCMP_CLOSEWINDOW | IDCMP_RAWKEY | IDCMP_MOUSEMOVE | IDCMP_MOUSEBUTTONS | IDCMP_VANILLAKEY,
WA_SizeGadget, TRUE,
WA_MinWidth, 100,
WA_MinHeight, 100,
WA_MaxWidth, -1,
WA_MaxHeight, -1,
WA_ReportMouse, TRUE,
TAG_DONE);
if (wnd)
{
if ((text = Text_Create()))
{
Text_SetFrameBox(text, scr, wnd->RPort, (LONG) wnd->BorderLeft, (LONG) wnd->BorderTop, wnd->Width - wnd->BorderLeft - wnd->BorderRight - 1, wnd->Height - wnd->BorderTop - wnd->BorderBottom - 1);
Text_Load(text, "DH0:");
Text_Redraw(text);
loop();
Text_Free(text);
}
CloseWindow(wnd);
}
UnlockPubScreen(NULL, scr);
}
}
static void cleanup(char *msg)
{
if (msg) printf("colorwheel: %s\n", msg);
if (win)
{
if (wheelgad) RemoveGadget(win, wheelgad);
if (gradgad) RemoveGadget(win, gradgad);
CloseWindow(win);
}
if (wheelgad) DisposeObject((Object *)wheelgad);
if (gradgad) DisposeObject((Object *)gradgad);
if (pen1 != -1) ReleasePen(cm, pen1);
if (pen2 != -1) ReleasePen(cm, pen2);
if (dri) FreeScreenDrawInfo(scr, dri);
if (scr) UnlockPubScreen(0, scr);
if (ColorWheelBase) CloseLibrary(ColorWheelBase);
if (GradientSliderBase) CloseLibrary(GradientSliderBase);
if (UtilityBase) CloseLibrary((struct Library *)UtilityBase);
if (GfxBase) CloseLibrary((struct Library *)GfxBase);
if (IntuitionBase) CloseLibrary((struct Library *)IntuitionBase);
exit(0);
}
void openWindow(void) {
int windowHeight;
struct Screen *lockscreen;
strcpy(NiKomReleaseStr, NIKRELEASE " (" __DATE__ " " __TIME__ ")");
sprintf(windowTitle, "NiKom %s, 0 noder aktiva", NiKomReleaseStr);
if(!(lockscreen = LockPubScreen(pubscreen[0] == '-' ? NULL : pubscreen))) {
cleanup(EXIT_ERROR,"Kunde inte låsa angiven Public Screen\n");
}
windowHeight = lockscreen->WBorTop + lockscreen->Font->ta_YSize + 1;
NiKWindow = (struct Window *)OpenWindowTags(NULL,
WA_Left, xpos,
WA_Top, ypos,
WA_Width, 500,
WA_Height, windowHeight,
WA_IDCMP, IDCMP_CLOSEWINDOW,
WA_Title, windowTitle,
WA_SizeGadget, FALSE,
WA_DragBar, TRUE,
WA_DepthGadget, TRUE,
WA_CloseGadget, TRUE,
WA_NoCareRefresh, TRUE,
WA_ScreenTitle, "NiKom Server",
WA_AutoAdjust, TRUE,
WA_PubScreen, lockscreen);
UnlockPubScreen(NULL, lockscreen);
if(NiKWindow == NULL) {
cleanup(EXIT_ERROR, "Could not open window.");
}
}
__autoexit void amiga_exit (void)
{
int i;
for (i = 0; i < HISTORY_LINES; i++)
{
if (*(History + i))
FreeVec (*(History + i));
*(History + i) = 0;
}
if (GameReq)
FreeAslRequest (GameReq);
if (SaveReq)
FreeAslRequest (SaveReq);
if (ScriptReq)
FreeAslRequest (ScriptReq);
if (Menus)
FreeMenus (Menus);
if (Visual)
FreeVisualInfo (Visual);
if (ThisProcess)
ThisProcess->pr_WindowPtr = OldWindowPtr;
if (Window)
CloseWindow (Window);
if (Screen)
CloseScreen (Screen);
if (Font)
CloseFont (Font);
if (DefaultPubScreen)
UnlockPubScreen (0, DefaultPubScreen);
if (Icon)
FreeDiskObject (Icon);
}
void getAROSScreenSize(int *user_width, int *user_height) {
// see http://wiki.amigaos.net/index.php/Intuition_Screens
// setup a default in case we can't access the Workbench Screen for some reason
*user_width = 640;
*user_height = 480;
struct Screen *my_wbscreen_ptr = LockPubScreen("Workbench");
if( my_wbscreen_ptr == NULL ) {
LOG("getAROSScreenSize: failed to lock Workbench screen\n");
}
else {
*user_width = my_wbscreen_ptr->Width;
*user_height = my_wbscreen_ptr->Height;
LOG("getAROSScreenSize: Workbench screen size is %d x %d\n", *user_width, *user_height);
UnlockPubScreen(NULL, my_wbscreen_ptr);
#ifdef __amigaos4__
/* Performance on AmigaOS 4 is reported to be slow when run at 1280x960, so we set a max of 640x480.
*/
const int max_width_c = 640, max_height_c = 480;
if( *user_width > max_width_c )
*user_width = max_width_c;
if( *user_height > max_height_c )
*user_height = max_height_c;
LOG("size restricted to %d x %d\n", *user_width, *user_height);
#endif
}
}
int main(int argc, char **argv)
{
if ((GTDragBase = OpenLibrary("gtdrag.library",3)) != 0)
{
if (GTD_AddApp("dragtest",GTDA_NewStyle,TRUE,TAG_END))
{
if ((scr = LockPubScreen(NULL)) != 0)
{
vi = GetVisualInfo(scr,TAG_END);
fontheight = scr->Font->ta_YSize;
init();
if ((win = initWindow()) != 0)
{
processMsg();
CloseWindow(win);
}
FreeGadgets(glist);
cleanup();
FreeVisualInfo(vi);
UnlockPubScreen(NULL,scr);
}
GTD_RemoveApp();
}
CloseLibrary(GTDragBase);
}
return 0;
}
void CloseDownScreen( void )
{
if ( VisualInfo ) {
FreeVisualInfo( VisualInfo );
VisualInfo = NULL;
}
if ( Scr ) {
UnlockPubScreen( NULL, Scr );
Scr = NULL;
}
}
struct Window * createMainWindow(int req_width, int req_height)
{
struct Screen *pubScreen;
struct Window *displayWin = NULL;
int width, height;
pubScreen = LockPubScreen(0);
if (pubScreen)
{
width = ((pubScreen->Width * 4) / 5) & ~0x1f;
height = (width * 3 / 4) & ~0x1f;
if (req_width && req_width < width)
width = req_width & ~0x1f;
if (req_height && req_height < height)
height = req_height & ~0x1f;
if (height >= (pubScreen->Height * 4) / 5)
{
height = ((pubScreen->Height * 4) / 5) & ~0x1f;
width = (height * 4 / 3) & ~0x1f;
}
}
else
{
width = 320;
height = 240;
}
if ((displayWin = OpenWindowTags(0,
WA_PubScreen, (IPTR)pubScreen,
WA_Left, 0,
WA_Top, (pubScreen) ? pubScreen->BarHeight : 10,
WA_InnerWidth, width,
WA_InnerHeight, height,
WA_Title, (IPTR) "SMP-Smallpt renderer",
WA_SimpleRefresh, TRUE,
WA_CloseGadget, TRUE,
WA_DepthGadget, TRUE,
WA_DragBar, TRUE,
WA_SizeGadget, FALSE,
WA_SizeBBottom, FALSE,
WA_SizeBRight, FALSE,
WA_IDCMP, IDCMP_CLOSEWINDOW | IDCMP_REFRESHWINDOW,
TAG_DONE)) != NULL)
{
if (pubScreen)
UnlockPubScreen(0, pubScreen);
}
return displayWin;
}
static int vsid_menu_create(void)
{
struct Screen* pubscreen = NULL;
int i, j;
pubscreen = LockPubScreen(NULL);
if (pubscreen == NULL) {
return -1;
}
if (!(VisualInfo = GetVisualInfo(pubscreen, TAG_DONE))) {
return -1;
}
for (i = 0, j = 0; vsid_ui_translation_menu[i].nm_Type != NM_END; i++) {
vsid_ui_menu[j].nm_Type = vsid_ui_translation_menu[i].nm_Type;
vsid_ui_menu[j].nm_CommKey = vsid_ui_translation_menu[i].nm_CommKey;
vsid_ui_menu[j].nm_Flags = vsid_ui_translation_menu[i].nm_Flags;
vsid_ui_menu[j].nm_MutualExclude = vsid_ui_translation_menu[i].nm_MutualExclude;
vsid_ui_menu[j].nm_UserData = vsid_ui_translation_menu[i].nm_UserData;
switch (vsid_ui_translation_menu[i].nm_Label) {
case 0:
vsid_ui_menu[j++].nm_Label = (STRPTR)NM_BARLABEL;
break;
default:
vsid_ui_menu[j++].nm_Label = translate_text(vsid_ui_translation_menu[i].nm_Label);
break;
}
}
vsid_ui_menu[i].nm_Type = NM_END;
vsid_ui_menu[i].nm_CommKey = NULL;
vsid_ui_menu[i].nm_Flags = 0;
vsid_ui_menu[i].nm_MutualExclude = 0L;
vsid_ui_menu[i].nm_UserData = NULL;
vsid_ui_menu[i].nm_Label = NULL;
if (!(vsid_menu = CreateMenus(vsid_ui_menu, GTMN_FrontPen, 0L, TAG_DONE))) {
return -1;
}
LayoutMenus(vsid_menu, VisualInfo, GTMN_NewLookMenus, TRUE, TAG_DONE);
SetMenuStrip(vsid_window, vsid_menu);
vsid_menu_update();
UnlockPubScreen(NULL, pubscreen);
return 0;
}
/*****************************************
* Quits the program *
*****************************************/
void quit_program(int error, char *text)
{
if (error > 0) {
printf(VERSION_SHELL);
printf(" ERROR: %s\n", text);
}
if (scr)
UnlockPubScreen(NULL, scr);
if (window)
CloseWindow(window);
if (VisInfo)
FreeVisualInfo(VisInfo);
if (glist)
FreeGadgets(glist);
}
VOID
FreeExit( LONG rc )
{
if( Menus )
{
if( WindowPtr )
{
ClearMenuStrip( WindowPtr );
}
FreeMenus( Menus );
}
CloseGUI();
if( Screen )
{
FreeScreenDrawInfo( Screen, DrawInfo );
UnlockPubScreen (NULL, Screen );
}
if( GadToolsBase )
{
FreeVisualInfo( VisualInfo );
}
if( FileReq )
{
rtFreeRequest( FileReq );
}
if( DiskObject )
{
FreeDiskObject( DiskObject );
}
FreeArgs( RDArgs );
FreeLocale();
CloseLib( GadToolsBase );
CloseLib( IconBase );
CloseLib( IntuitionBase );
CloseLib( ReqToolsBase );
CloseLib( UtilityBase );
CloseLibrary( ( struct Library * ) GfxBase );
__exit( rc );
}
// Open font window
BOOL font_open(font_data *data)
{
struct Screen *screen=NULL;
// Screen supplied?
if (data->arg_array[ARG_SCREEN])
screen=LockPubScreen((char *)data->arg_array[ARG_SCREEN]);
// Fill out new window
data->new_win.parent=screen;
data->new_win.dims=&data->win_dims;
data->new_win.title=GetString(&data->locale,MSG_FONT_TITLE);
data->new_win.locale=&data->locale;
data->new_win.flags=WINDOW_SCREEN_PARENT|WINDOW_VISITOR|WINDOW_AUTO_KEYS|WINDOW_SIZE_BOTTOM|WINDOW_SIMPLE;
// Default dimensions
data->win_dims=font_window;
// Read settings
font_read_settings(data);
// Open window
if ((data->window=OpenConfigWindow(&data->new_win)))
data->list=AddObjectList(data->window,font_objects);
// Unlock screen
UnlockPubScreen(0,screen);
// Failed to open?
if (!data->list) return FALSE;
// Fix sizing limits
WindowLimits(data->window,
(font_window.char_dim.Width*data->window->RPort->TxWidth)+font_window.fine_dim.Width,
(font_window.char_dim.Height*data->window->RPort->TxHeight)+font_window.fine_dim.Height,
~0,~0);
// Add menus
AddWindowMenus(data->window,font_menus);
// Add AppWindow
if (data->appport)
data->appwindow=AddAppWindowA(0,0,data->window,data->appport,0);
// Get the font
font_get_font(data);
return TRUE;
}
static void cleanup(char *msg)
{
if (msg)
{
printf("roundshape: %s\n",msg);
}
if (win) CloseWindow(win);
if (shape) DisposeRegion(shape);
if (scr) UnlockPubScreen(0, scr);
if (GfxBase) CloseLibrary((struct Library *)GfxBase);
if (IntuitionBase) CloseLibrary((struct Library *)IntuitionBase);
exit(0);
}
void
nsSplashScreenAmigaOS::Open()
{
if (mIsOpen)
return;
struct Screen *scr = mIIntuition->LockPubScreen(NULL);
uint32 scrWidth, scrHeight;
mIIntuition->GetScreenAttrs(scr,
SA_Width, &scrWidth,
SA_Height, &scrHeight,
TAG_DONE);
mIIntuition->UnlockPubScreen(NULL, scr);
uint32 winX = (scrWidth - splash_img.width) / 2;
uint32 winY = (scrHeight - splash_img.height) / 2;
mWindow = mIIntuition->OpenWindowTags(NULL,
WA_Flags, WFLG_BORDERLESS,
WA_IDCMP, 0,
WA_Left, winX,
WA_Top, winY,
WA_InnerWidth, splash_img.width,
WA_InnerHeight, splash_img.height,
WA_WindowName, "Timberwolf Splash",
WA_Hidden, FALSE,
TAG_DONE);
mIGraphics->BltBitMapTags(
BLITA_SrcX, 0,
BLITA_SrcY, 0,
BLITA_Width, splash_img.width,
BLITA_Height, splash_img.height,
BLITA_SrcType, BLITT_RGB24,
BLITA_Source, splash_img.pixel_data,
BLITA_SrcBytesPerRow,splash_img.bytes_per_pixel * splash_img.width,
BLITA_DestX, 0,
BLITA_DestY, 0,
BLITA_DestType, BLITT_RASTPORT,
BLITA_Dest, mWindow->RPort,
TAG_DONE);
mIsOpen = PR_TRUE;
}
static void cleanup(char *msg)
{
if (msg)
{
printf("BltTemplateAlpha: %s\n",msg);
}
if (win) CloseWindow(win);
if (scr) UnlockPubScreen(0, scr);
if (CyberGfxBase) CloseLibrary(CyberGfxBase);
if (GfxBase) CloseLibrary((struct Library *)GfxBase);
if (IntuitionBase) CloseLibrary((struct Library *)IntuitionBase);
exit(0);
}
VOID ImageDecoderThread ()
{
LONG args[6];
struct RDArgs *readargs;
if(readargs = ReadArgs("/A/N,/A/N,/A/N,/A/N,/A/N,/A/F", args, NULL))
{
ULONG pageID = *((ULONG *)args[0]);
struct ImageList *images = *((struct ImageList **)args[1]);
Object *ipc = *((Object **)args[2]);
ULONG handle = *((ULONG *)args[3]);
struct Screen *scr = *((struct Screen **)args[4]);
STRPTR url = (STRPTR)args[5];
Object *dt = NULL;
if(dt = NewDTObject(url,
DTA_GroupID, GID_PICTURE,
PDTA_DestMode, MODE_V43,
PDTA_Remap, TRUE,
PDTA_FreeSourceBitMap, TRUE,
PDTA_Screen, scr,
PDTA_UseFriendBitMap, TRUE,
TAG_DONE))
{
DoMethod(dt, DTM_PROCLAYOUT);
}
struct IPCMsg ipcmsg(handle, IPCFlg_Unlock);
ipcmsg.MethodID = MUIM_IPC_DoMessage;
ipcmsg.PageID = pageID;
ipcmsg.Images = images;
ipcmsg.DTObject = dt;
ipcmsg.ImageDecoderThread = FindTask(NULL);
if(!DoMethodA(ipc, (Msg)&ipcmsg))
DisposeDTObject(dt);
UnlockPubScreen(NULL, scr);
}
}
void shutdownwnd_close(void)
{
if (shutdown_wnd)
{
CloseWindow(shutdown_wnd);
shutdown_wnd = NULL;
}
if (obj)
{
DisposeObject(obj);
obj = NULL;
}
if (scr)
{
ReleasePen(scr->ViewPort.ColorMap,pen);
UnlockPubScreen(NULL,scr);
scr = NULL;
}
}
void _glfwPlatformGetDesktopMode( GLFWvidmode *mode )
{
struct Screen *pubscreen;
ULONG modeID;
// Get default public screen screen handle
pubscreen = LockPubScreen( NULL );
// Get screen width and height (use actual screen size rather than
// ModeID nominal size)
mode->Width = (int) pubscreen->Width;
mode->Height = (int) pubscreen->Height;
// Get ModeID for public screen
modeID = GetVPModeID( &pubscreen->ViewPort );
// Release workbench screen
UnlockPubScreen( NULL, pubscreen );
// Get color bits information
_glfwGetModeIDInfo( modeID, NULL, NULL, &mode->RedBits,
&mode->GreenBits, &mode->BlueBits, NULL );
}
/**************************************************************************************
** Main
***************************************************************************************
*/
VOID main()
{
struct Screen *pubscreen;
struct ViewPort *vp;
if ( !(GfxBase = OpenLibrary("graphics.library",0)) )
return(NULL);
if ( !(IntuitionBase = OpenLibrary("intuition.library",0)) )
{
CloseLibrary(GfxBase);
return(NULL);
}
pubscreen = LockPubScreen(NULL);
vp = &pubscreen->ViewPort;
SetRGB32 (vp, 4, 123<<24, 123<<24, 123<<24 );
SetRGB32 (vp, 5, 175<<24, 175<<24, 175<<24 );
SetRGB32 (vp, 6, 170<<24, 144<<24, 124<<24 );
SetRGB32 (vp, 7, 255<<24, 169<<24, 151<<24 );
SetRGB32 (vp, 8, 0, 0, 255<<24 );
SetRGB32 (vp, 9, 50<<24, 50<<24, 50<<24 );
SetRGB32 (vp, 10, 96<<24, 128<<24, 96<<24 );
SetRGB32 (vp, 11, 226<<24, 209<<24, 119<<24 );
SetRGB32 (vp, 12, 255<<24, 212<<24, 203<<24 );
SetRGB32 (vp, 13, 122<<24, 96<<24, 72<<24 );
SetRGB32 (vp, 14, 210<<24, 210<<24, 210<<24 );
SetRGB32 (vp, 15, 229<<24, 93<<24, 93<<24 );
UnlockPubScreen(NULL,pubscreen);
CloseLibrary(IntuitionBase);
CloseLibrary(GfxBase);
return(NULL);
}
void hidd_demo(struct ExecBase * SysBase)
{
D(bug("graphics.hidd = %08.8lx\n",OpenLibrary("graphics.hidd",0)));
D(bug("display.hidd = %08.8lx\n",OpenLibrary("display.hidd",0)));
OpenLibrary("hidd.gfx.display",0);
{
struct GfxBase *GfxBase;
BOOL success = FALSE;
D(bug("init_gfx(hiddbase=%s)\n", "hidd.gfx.display"));
GfxBase = (struct GfxBase *)OpenLibrary("graphics.library", 37);
if (GfxBase)
{
/* Call private gfx.library call to init the HIDD.
Gfx library is responsable for closing the HIDD
library (although it will probably not be neccesary).
*/
D(bug("calling private gfx LateGfxInit()\n"));
if (LateGfxInit("hidd.gfx.display"))
{
struct IntuitionBase *IntuitionBase;
D(bug("lategfxinit okay\n"));
/* Now that gfx. is guaranteed to be up & working, let intuition open WB screen */
IntuitionBase = (struct IntuitionBase *)OpenLibrary("intuition.library", 37);
D(bug("ibase = %lx\n", IntuitionBase));
if (IntuitionBase)
{
if (LateIntuiInit(NULL))
{
success = TRUE;
}
CloseLibrary((struct Library *)IntuitionBase);
}
}
D(bug("Closing gfx\n"));
CloseLibrary((struct Library *)GfxBase);
if (success == FALSE)
{
D(bug("There is something wrong with hidd subsystem..."));
while(1) {};
}
}
}
#if 0
{
struct IORequest *io;
struct MsgPort *mp;
mp=CreateMsgPort();
io=CreateIORequest(mp,sizeof(struct IOStdReq));
D(bug("Result of opening device %d\n",
OpenDevice("gameport.device",0,io,0)));
D(bug("Doing CMD_HIDDINIT...\n"));
{
UBYTE *data;
data = AllocMem(100, MEMF_PUBLIC);
strcpy(data, "hidd.bus.mouse");
ioStd(io)->io_Command=32000;
ioStd(io)->io_Data=data;
ioStd(io)->io_Length=strlen(data);
DoIO(io);
D(bug("Got io_ERROR=%d",io->io_Error));
}
}
#endif
{
struct IntuitionBase *IntuitionBase;
struct GfxBase *GfxBase;
struct Window * win = NULL;
#define XSTART 50
#define YSTART 50
int x = XSTART;
int y = YSTART;
IntuitionBase = (struct IntuitionBase *)OpenLibrary("intuition.library", 37);
GfxBase = (struct GfxBase *)OpenLibrary("graphics.library", 37);
if (IntuitionBase)
{
struct TagItem tags[] = {
{WA_Width, 100},
{WA_Height, 100},
{WA_Left, x},
{WA_Top, y},
{WA_MinWidth, 100},
{WA_MinHeight, 100},
{WA_MaxWidth, 120},
{WA_MaxHeight, 120},
{WA_Title, (ULONG)"AROS Dream :-)"},
{WA_Activate, 1},
{WA_SizeGadget, TRUE},
{WA_DepthGadget, TRUE},
{TAG_DONE, 0}};
win = OpenWindowTagList(0, tags);
}
DrawEllipse(win->RPort,160/2-35,120/2-4,80/2,80/2);
DrawEllipse(win->RPort,185/2-35,90/2-4,15/2,15/2);
DrawEllipse(win->RPort,135/2-35,90/2-4,15/2,15/2);
Move(win->RPort,125/2-35,140/2-4);
Draw(win->RPort,140/2-35,150/2-4);
Draw(win->RPort,180/2-35,150/2-4);
Draw(win->RPort,195/2-35,140/2-4);
#if 0
if (win)
{
while (x < 100)
{
MoveWindow(win,1,0);
x++;
}
while (y < 100)
{
MoveWindow(win,0,1);
y++;
}
while (x > XSTART)
{
MoveWindow(win,-1,0);
x--;
}
while (y > YSTART)
{
MoveWindow(win,0,-1);
y--;
}
}
#endif
#if 0
if (IntuitionBase)
{
struct Screen *screen;
struct Window *win2;
struct IntuiMessage *msg;
char ScreenInfo[40];
if ((screen = LockPubScreen(NULL)))
{
struct TagItem tags[] = {
{WA_Width, 640},
{WA_Height, 100},
{WA_Left, 0},
{WA_Top, 79},
{WA_MinWidth, 200},
{WA_MinHeight, 100},
{WA_MaxWidth, 640},
{WA_MaxHeight, 480},
{WA_Title, (ULONG)"AROS !ext" },
{WA_Activate, 1},
{WA_CloseGadget, TRUE},
{WA_SizeGadget, TRUE},
{WA_DepthGadget, TRUE},
{WA_IDCMP, IDCMP_CLOSEWINDOW | IDCMP_MOUSEMOVE | IDCMP_RAWKEY},
{WA_ReportMouse, TRUE},
{TAG_DONE, 0}};
win2 = OpenWindowTagList(0, tags);
sprintf(ScreenInfo,"ScreenWidth: %d, ScreenHeight: %d", screen->Width, screen->Height);
if (win2)
{
BlackPrint(win2->RPort, ScreenInfo, 40, GfxBase);
for(;;)
{
BOOL quitme = FALSE;
WaitPort(win2->UserPort);
while((msg = ((struct IntuiMessage *)GetMsg(win2->UserPort))))
{
switch(msg->Class)
{
case IDCMP_RAWKEY:
{
static char hex[] = "0123456789ABCDEF";
char s[9];
s[0] = 'K';
s[1] = 'e';
s[2] = 'y';
s[3] = ' ';
s[4] = hex[(msg->Code >> 12) & 0xF];
s[5] = hex[(msg->Code >> 8) & 0xF];
s[6] = hex[(msg->Code >> 4) & 0xF];
s[7] = hex[(msg->Code >> 0) & 0xF];
s[8] = '\0';
BlackPrint(win2->RPort, s, 60, GfxBase);
if (msg->Code == 0x45) quitme = TRUE;
}
break;
case IDCMP_MOUSEMOVE:
{
WORD mx = win2->WScreen->MouseX;
WORD my = win2->WScreen->MouseY;
char s[20];
sprintf(s, "Mouse: %4d, %4d", mx, my);
WhitePrint(win2->RPort, s, 80, GfxBase);
#if 0
mx &= 511;
my &= 255;
SetAPen(&win2->WScreen->RastPort, 1);
SetDrMd(&win2->WScreen->RastPort, JAM2);
WritePixel(&win2->WScreen->RastPort, mx, my);
#endif
}
break;
case IDCMP_CLOSEWINDOW:
{
quitme = TRUE;
}
break;
}
ReplyMsg((struct Message *)msg);
}
if (quitme) break;
}
CloseWindow(win2);
}
UnlockPubScreen(NULL,screen);
}
}
#endif
}
}
BOOL BuildGUI(char *screenname) {
Object **ar = Window_Objs;
struct Screen *screen;
BOOL OptionFrame = FALSE;
LONG indicatorwidth = 100;
UpdateStrings();
// Kludge for Piccaso 96/BGUI.
if(FindTask("Picasso96"))
{
PopUpMenus = FALSE;
}
BGUIBase = (void *)OpenLibrary("bgui.library", 41);
if(BGUIBase == NULL) {
Printf((char *) msgTextNoOpen, (ULONG) "bgui.library", 41);
Printf("\n");
return FALSE;
}
screen = LockPubScreen(screenname);
indicatorwidth = max(indicatorwidth, 16 * screen->RastPort.Font->tf_XSize);
if(screen->Height > 240) {
OptionFrame = TRUE;
}
WO_Window = WindowObject,
WINDOW_PubScreen, screen,
WINDOW_Title, (char *) msgTextProgramName,
WINDOW_CloseGadget, FALSE,
WINDOW_MenuStrip, Menus,
WINDOW_AutoAspect, TRUE,
WINDOW_AutoKeyLabel, TRUE,
WINDOW_ScaleWidth, 60,
WINDOW_ScaleHeight, 20,
WINDOW_HelpFile, HELPFILE,
WINDOW_HelpNode, "AHI",
WINDOW_IDCMPHook, &IDCMPhook,
WINDOW_IDCMPHookBits, IDCMP_RAWKEY,
WINDOW_MasterGroup, VGroupObject, NormalOffset,
/* TABS */
StartMember, ar[ACTID_TABS] = MxObject,
MX_Labels, PageNames,
MX_TabsObject, TRUE,
GA_ID, ACTID_TABS,
EndObject, FixMinHeight, EndMember,
StartMember, ar[ACTID_PAGE] = PageObject, NormalSpacing,
PAGE_NoBufferRP, TRUE,
/* PAGE 1 */
PageMember, HGroupObject, NormalOffset, NormalSpacing, TabAboveFrame,
StartMember, vgroup = VGroupObject, NormalSpacing,
StartMember, ar[ACTID_UNIT] = CycleObject,
CYC_Labels, Units,
CYC_Active, state.UnitSelected,
CYC_PopActive, PopUpMenus,
CYC_Popup, PopUpMenus,
GA_ID, ACTID_UNIT,
EndObject, FixMinHeight, EndMember,
StartMember, ar[ACTID_MODE] = ListviewObject,
// LISTV_EntryArray, Modes,
// LISTV_Select, state.ModeSelected,
PGA_NewLook, TRUE,
GA_ID, ACTID_MODE,
EndObject, EndMember,
StartMember, HGroupObject,
ButtonFrame, FRM_Flags, FRF_RECESSED,
StartMember, InfoObject,
INFO_TextFormat, (char *) msgProperties,
INFO_FixTextWidth,TRUE,
INFO_MinLines, 6,
EndObject, FixMinWidth, EndMember,
StartMember, ar[SHOWID_MODE] = InfoObject,
INFO_MinLines, 6,
EndObject, EndMember,
EndObject, FixMinHeight, EndMember,
EndObject /* vgroup */, EndMember,
StartMember, VGroupObject, NormalSpacing,
VarSpace(1),
StartMember, VGroupObject,
(OptionFrame ? GROUP_HorizOffset : TAG_IGNORE), GRSPACE_NORMAL,
(OptionFrame ? GROUP_VertOffset : TAG_IGNORE), GRSPACE_NORMAL,
(OptionFrame ? GROUP_Spacing : TAG_IGNORE), GRSPACE_NORMAL,
(OptionFrame ? FRM_Type : TAG_IGNORE), FRTYPE_RIDGE,
(OptionFrame ? FRM_Flags : TAG_IGNORE), FRF_RECESSED,
(OptionFrame ? FRM_Title : TAG_IGNORE), (char *) msgOptions,
StartMember, HGroupObject,
StartMember, ar[ACTID_FREQ] = SliderObject,
LAB_Label, (char *) msgOptFrequency,
SLIDER_Min, 0,
SLIDER_Max, state.Frequencies -1 ,
SLIDER_Level, state.FreqSelected,
PGA_NewLook, TRUE,
GA_ID, ACTID_FREQ,
EndObject, EndMember,
StartMember, ar[SHOWID_FREQ] = InfoObject,
INFO_TextFormat, getFreq(),
INFO_VertOffset, 0,
EndObject, FixWidth(indicatorwidth), EndMember,
EndObject, FixMinHeight, EndMember,
StartMember, HGroupObject,
StartMember, ar[ACTID_CHANNELS] = SliderObject,
LAB_Label, (char *) msgOptChannels,
SLIDER_Min, 1,
SLIDER_Max, state.Channels,
SLIDER_Level, state.ChannelsSelected,
PGA_NewLook, TRUE,
GA_ID, ACTID_CHANNELS,
EndObject, EndMember,
StartMember, ar[SHOWID_CHANNELS] = InfoObject,
INFO_TextFormat, getChannels(),
INFO_VertOffset, 0,
EndObject, FixWidth(indicatorwidth), EndMember,
EndObject, FixMinHeight, EndMember,
StartMember, HGroupObject,
StartMember, ar[ACTID_OUTVOL] = SliderObject,
LAB_Label, (char *) msgOptVolume,
SLIDER_Min, 0,
SLIDER_Max, state.OutVols-1 ,
SLIDER_Level, state.OutVolSelected,
PGA_NewLook, TRUE,
GA_ID, ACTID_OUTVOL,
EndObject, EndMember,
StartMember, ar[SHOWID_OUTVOL] = InfoObject,
INFO_TextFormat, getOutVol(),
INFO_VertOffset, 0,
EndObject, FixWidth(indicatorwidth), EndMember,
EndObject, FixMinHeight, EndMember,
StartMember, HGroupObject,
StartMember, ar[ACTID_MONVOL] = SliderObject,
LAB_Label, (char *) msgOptMonitor,
SLIDER_Min, 0,
SLIDER_Max, state.MonVols-1 ,
SLIDER_Level, state.MonVolSelected,
PGA_NewLook, TRUE,
GA_ID, ACTID_MONVOL,
EndObject, EndMember,
StartMember, ar[SHOWID_MONVOL] = InfoObject,
INFO_TextFormat, getMonVol(),
INFO_VertOffset, 0,
EndObject, FixWidth(indicatorwidth), EndMember,
EndObject, FixMinHeight, EndMember,
StartMember, HGroupObject,
StartMember, ar[ACTID_GAIN] = SliderObject,
LAB_Label, (char *) msgOptGain,
SLIDER_Min, 0,
SLIDER_Max, state.Gains-1 ,
SLIDER_Level, state.GainSelected,
PGA_NewLook, TRUE,
GA_ID, ACTID_GAIN,
EndObject, EndMember,
StartMember, ar[SHOWID_GAIN] = InfoObject,
INFO_TextFormat, getGain(),
INFO_VertOffset, 0,
EndObject, FixWidth(indicatorwidth), EndMember,
EndObject, FixMinHeight, EndMember,
StartMember, HGroupObject,
StartMember, ar[ACTID_INPUT] = SliderObject,
LAB_Label, (char *) msgOptInput,
SLIDER_Min, 0,
SLIDER_Max, state.Inputs-1 ,
SLIDER_Level, state.InputSelected,
PGA_NewLook, TRUE,
GA_ID, ACTID_INPUT,
EndObject, EndMember,
StartMember, ar[SHOWID_INPUT] = InfoObject,
INFO_TextFormat, getInput(),
INFO_VertOffset, 0,
EndObject, FixWidth(indicatorwidth), EndMember,
EndObject, FixMinHeight, EndMember,
StartMember, HGroupObject,
StartMember, ar[ACTID_OUTPUT] = SliderObject,
LAB_Label, (char *) msgOptOutput,
SLIDER_Min, 0,
SLIDER_Max, state.Outputs-1 ,
SLIDER_Level, state.OutputSelected,
PGA_NewLook, TRUE,
GA_ID, ACTID_OUTPUT,
EndObject, EndMember,
StartMember, ar[SHOWID_OUTPUT] = InfoObject,
INFO_TextFormat, getOutput(),
INFO_VertOffset, 0,
EndObject, FixWidth(indicatorwidth), EndMember,
EndObject, FixMinHeight, EndMember,
EndObject /* vgroup "Options" */, FixMinHeight, EndMember,
VarSpace(1),
EndObject /* vgroup */, EndMember,
EndObject, /* (EndMember) page */
/* PAGE 2 */
PageMember, HGroupObject, NormalSpacing, TabAboveFrame,
VarSpace(1),
StartMember, VGroupObject, NormalSpacing,
VarSpace(1),
StartMember, VGroupObject, NormalOffset, NormalSpacing,
RidgeFrame, FRM_Flags, FRF_RECESSED, FrameTitle((char *) msgGlobalOptions),
StartMember, HGroupObject, NormalSpacing,
StartMember, VGroupObject, NormalSpacing,
StartMember, ar[ACTID_DEBUG] = CycleObject,
LAB_Label, (char *) msgGlobOptDebugLevel,
LAB_Place, PLACE_LEFT,
CYC_Labels, DebugLabels,
CYC_Active, globalprefs.ahigp_DebugLevel,
CYC_PopActive, PopUpMenus,
CYC_Popup, PopUpMenus,
GA_ID, ACTID_DEBUG,
EndObject, FixMinHeight, EndMember,
StartMember, ar[ACTID_ECHO] = CycleObject,
LAB_Label, (char *) msgGlobOptEcho,
LAB_Place, PLACE_LEFT,
CYC_Labels, EchoLabels,
CYC_Active, (globalprefs.ahigp_DisableEcho ? 2 : 0) |
(globalprefs.ahigp_FastEcho ? 1 : 0),
CYC_PopActive, PopUpMenus,
CYC_Popup, PopUpMenus,
GA_ID, ACTID_ECHO,
EndObject, FixMinHeight, EndMember,
StartMember, ar[ACTID_SURROUND] = CycleObject,
LAB_Label, (char *) msgGlobOptSurround,
LAB_Place, PLACE_LEFT,
CYC_Labels, SurroundLabels,
CYC_Active, globalprefs.ahigp_DisableSurround,
GA_ID, ACTID_SURROUND,
EndObject, FixMinHeight, EndMember,
StartMember, ar[ACTID_CLIPMV] = CycleObject,
LAB_Label, (char *) msgGlobOptMasterVol,
LAB_Place, PLACE_LEFT,
CYC_Labels, ClipMVLabels,
CYC_Active, globalprefs.ahigp_ClipMasterVolume,
GA_ID, ACTID_CLIPMV,
EndObject, FixMinHeight, EndMember,
StartMember, ar[ACTID_CPULIMIT] = SliderObject,
LAB_Label, (char *) msgGlobOptCPULimit,
SLIDER_Min, 0,
SLIDER_Max, 100,
SLIDER_Level, (globalprefs.ahigp_MaxCPU * 100 + 32768) >> 16,
PGA_NewLook, TRUE,
GA_ID, ACTID_CPULIMIT,
EndObject, EndMember,
EndObject /* vgroup */, EndMember,
StartMember, VGroupObject, NormalSpacing,
VarSpace(1),
StartMember, ar[SHOWID_CPULIMIT] = IndicatorObject,\
INDIC_Min, 0,
INDIC_Max, 100,
INDIC_Level, (globalprefs.ahigp_MaxCPU * 100 + 32768) / 65536,
INDIC_Justification, IDJ_LEFT,
INDIC_FormatString, "%ld%%",
EndObject, FixMinWidth, FixMinHeight, EndMember,
EndObject /* vgroup */, EndMember,
EndObject /* hgroup */, EndMember,
EndObject, FixMinWidth, FixMinHeight, EndMember,
VarSpace(1),
EndObject /* vgroup */ , FixMinWidth, EndMember,
VarSpace(1),
EndObject, /* (EndMember) page */
EndObject /* page */, EndMember,
/* BUTTONS */
StartMember, HGroupObject, NormalSpacing, NormalVOffset,
StartMember, ar[ACTID_SAVE] = ButtonObject,
ButtonFrame,
LAB_Label, (char *) msgButtonSave,
GA_ID, ACTID_SAVE,
EndObject, EndMember,
StartMember, ar[ACTID_USE] = ButtonObject,
ButtonFrame,
LAB_Label, (char *) msgButtonUse,
GA_ID, ACTID_USE,
EndObject, EndMember,
StartMember, ar[ACTID_QUIT] = ButtonObject,
ButtonFrame,
LAB_Label, (char *) msgButtonCancel,
GA_ID, ACTID_QUIT,
EndObject, EndMember,
EndObject, FixMinHeight, EndMember,
EndObject,
EndObject;
if(WO_Window) {
AddMap( ar[ACTID_TABS], ar[ACTID_PAGE], pagemap );
DoMethod( ar[ACTID_FREQ], BASE_ADDHOOK, &GadgetHook );
DoMethod( ar[ACTID_CHANNELS], BASE_ADDHOOK, &GadgetHook );
DoMethod( ar[ACTID_OUTVOL], BASE_ADDHOOK, &GadgetHook );
DoMethod( ar[ACTID_MONVOL], BASE_ADDHOOK, &GadgetHook );
DoMethod( ar[ACTID_GAIN], BASE_ADDHOOK, &GadgetHook );
DoMethod( ar[ACTID_INPUT], BASE_ADDHOOK, &GadgetHook );
DoMethod( ar[ACTID_OUTPUT], BASE_ADDHOOK, &GadgetHook );
AddMap( ar[ACTID_CPULIMIT], ar[SHOWID_CPULIMIT], cpumap);
window = WindowOpen(WO_Window);
}
if(screen) {
UnlockPubScreen(NULL, screen);
}
if(window == NULL) {
Printf((char *) msgTextNoWindow);
Printf("\n");
return FALSE;
}
openreq = FileReqObject,
ASLFR_Window, window,
ASLFR_SleepWindow, TRUE,
ASLFR_RejectIcons, TRUE,
ASLFR_InitialDrawer, "SYS:Prefs/Presets",
EndObject;
savereq = FileReqObject,
ASLFR_Window, window,
ASLFR_SleepWindow, TRUE,
ASLFR_RejectIcons, TRUE,
ASLFR_InitialDrawer, "SYS:Prefs/Presets",
ASLFR_DoSaveMode, TRUE,
EndObject;
if((openreq == NULL) || (savereq == NULL)) {
Printf((char *) msgTextNoFileRequester);
Printf("\n");
return FALSE;
}
// Update the checkmark for "Create Icons?"
{
struct Menu *menu = NULL;
struct MenuItem *item;
GetAttr( WINDOW_MenuStrip, WO_Window, (ULONG *) &menu);
ClearMenuStrip(window);
item = FindMenuItem(ACTID_ICONS);
if(item) {
if(SaveIcons)
item->Flags |= CHECKED;
else
item->Flags &= ~CHECKED;
}
ResetMenuStrip(window, menu);
}
GUINewUnit();
return TRUE;
}
int detect_screen(void)
{
struct Screen *myScreen;
struct Window *myWindow;
struct RastPort myRastPort;
struct BitMap *myBitMap;
APTR bitMapHandle;
ULONG result;
int bpp = 0;
if((ULONG)IntuitionBase == 0)
{
IntuitionBase = (struct IntuitionBase *)OpenLibrary("intuition.library", 39L);
}
if((ULONG)GfxBase == 0)
{
GfxBase = (struct GfxBase *)OpenLibrary("graphics.library", 39L);
}
if((ULONG)CyberGfxBase == 0)
{
CyberGfxBase = OpenLibrary("cybergraphics.library", 0);
}
if(!CyberGfxBase) {
if( !(CyberGfxBase=OpenLibrary("cybergraphics.library",40L))) {
printf("Couldn't open cybergraphics.");
return(-1);
}
}
myScreen = LockPubScreen(NULL);
if(myScreen != NULL)
{
UnlockPubScreen(NULL, myScreen);
}
else
{
printf("Couldnt get screen data.\n");
CloseLibrary((struct Library*)IntuitionBase);
CloseLibrary(CyberGfxBase);
CloseLibrary((struct Library *)GfxBase);
return 5;
}
myBitMap = AllocBitMap(1, 1, 8, BMF_MINPLANES | BMF_DISPLAYABLE, myScreen->RastPort.BitMap);
if((ULONG)myBitMap == 0)
{
printf("Couldnt allocate bitmap.\n");
CloseLibrary(CyberGfxBase);
CloseLibrary((struct Library *)GfxBase);
CloseLibrary((struct Library *)IntuitionBase);
return 6;
}
//Creates the RastPort used for blitting
InitRastPort(&myRastPort);
myRastPort.BitMap = myBitMap;
result=GetCyberMapAttr(myBitMap, CYBRMATTR_PIXFMT);
switch(result)
{
case 0://PIXFMT_LUT8:
bpp = 8; //printf("0");
break;
case 1://PIXFMT_RGB15:
bpp = 16; //printf("1");
break;
case 2://PIXFMT_BGR15:
bpp = 16; //printf("2");
break;
case 3://PIXFMT_RGB15PC:
bpp = 16; //printf("3");
break;
case 4://PIXFMT_BGR15PC:
bpp = 16; //printf("4");
break;
case 5://PIXFMT_RGB16:
bpp = 16; //printf("5");
break;
case 6://PIXFMT_BGR16:
bpp = 16; //printf("6");
break;
case 7://PIXFMT_RGB16PC:
bpp = 16; //printf("7");
break;
case 8://PIXFMT_BGR16PC:
bpp = 16; //printf("8");
break;
case 9://PIXFMT_RGB24:
bpp = 24; //printf("9");
break;
case 10://PIXFMT_BGR24:
bpp = 24; //printf("10");
break;
case 11://PIXFMT_ARGB32:
bpp = 32; //printf("11");
break;
case 12://PIXFMT_BGRA32:
#if defined NOVA_SDL
bpp = 16; //printf("12");
#else
bpp = 32; //printf("12");
#endif
break;
case 13://PIXFMT_RGBA32:
bpp = 32; //printf("13");
break;
default:
bpp = 16; //printf("14");
}
#ifdef DEBUG
printf("Pixel format: %d \n",result);
printf("Bpp: %d ",bpp);
#endif
FreeBitMap(myBitMap);
CloseLibrary((struct Library *)IntuitionBase);
//CloseLibrary(CyberGfxBase);
//CloseLibrary((struct Library *)GfxBase);
return bpp;
}
/*
** main routine. Open required library and window and draw the images.
** This routine opens a very simple window with no IDCMP. See the
** chapters on "Windows" and "Input and Output Methods" for more info.
** Free all resources when done.
*/
int main(int argc, char **argv)
{
struct Screen *screen;
struct DrawInfo *drawinfo;
struct Window *win;
struct IntuiText myIText;
struct TextAttr myTextAttr;
ULONG myTEXTPEN;
ULONG myBACKGROUNDPEN;
IntuitionBase = (struct IntuitionBase *)OpenLibrary("intuition.library",37);
if (IntuitionBase)
{
#ifdef __AROS__
if ((screen = LockPubScreen(NULL)))
#else
if (screen = LockPubScreen(NULL))
#endif
{
#ifdef __AROS__
if ((drawinfo = GetScreenDrawInfo(screen)))
#else
if (drawinfo = GetScreenDrawInfo(screen))
#endif
{
/* Get a copy of the correct pens for the screen.
** This is very important in case the user or the
** application has the pens set in a unusual way.
*/
myTEXTPEN = drawinfo->dri_Pens[TEXTPEN];
myBACKGROUNDPEN = drawinfo->dri_Pens[BACKGROUNDPEN];
/* create a TextAttr that matches the specified font. */
myTextAttr.ta_Name = drawinfo->dri_Font->tf_Message.mn_Node.ln_Name;
myTextAttr.ta_YSize = drawinfo->dri_Font->tf_YSize;
myTextAttr.ta_Style = drawinfo->dri_Font->tf_Style;
myTextAttr.ta_Flags = drawinfo->dri_Font->tf_Flags;
/* open a simple window on the workbench screen for displaying
** a text string. An application would probably never use such a
** window, but it is useful for demonstrating graphics...
*/
#ifdef __AROS__
if ((win = OpenWindowTags(NULL,
WA_PubScreen, (IPTR)screen,
WA_RMBTrap, TRUE,
WA_IDCMP, IDCMP_RAWKEY,
TAG_END)))
#else
if (win = OpenWindowTags(NULL,
WA_PubScreen, screen,
WA_RMBTrap, TRUE,
TAG_END))
#endif
{
myIText.FrontPen = myTEXTPEN;
myIText.BackPen = myBACKGROUNDPEN;
myIText.DrawMode = JAM2;
myIText.LeftEdge = MYTEXT_LEFT;
myIText.TopEdge = MYTEXT_TOP;
myIText.ITextFont = &myTextAttr;
myIText.IText = "Hello, World. ;-)";
myIText.NextText = NULL;
/* Draw the text string at 10,10 */
PrintIText(win->RPort,&myIText,10,10);
#ifdef __AROS__
/* Wait for keypress */
Wait (1L << win->UserPort->mp_SigBit);
#else
/* Wait a bit, then quit.
** In a real application, this would be an event loop,
** like the one described in the Intuition Input and
** Output Methods chapter.
*/
Delay(200);
#endif
CloseWindow(win);
}
FreeScreenDrawInfo(screen,drawinfo);
}
UnlockPubScreen(NULL,screen);
}
CloseLibrary((struct Library *)IntuitionBase);
}
return 0;
}
// Build requester
BOOL simple_build(simplereq_data *data)
{
struct DOpusSimpleRequest *simple;
short count,object,pos;
struct TextFont *font=0;
struct RastPort rp;
struct Screen *scr,*pub=0;
short font_try;
// Get simple pointer
simple=data->simple;
// Get screen pointer
if (simple->flags&SRF_SCREEN_PARENT && data->parent) scr=data->parent;
else
if (data->parent) scr=((struct Window *)data->parent)->WScreen;
else
if ((pub=LockPubScreen(0))) scr=pub;
else
return 0;
// Initialise dummy rastport
InitRastPort(&rp);
// Try 3 fonts (screen font, default font, topaz)
for (font_try=0;font_try<3;font_try++)
{
short width,len,pos;
char *ptr;
// Get font
if (font_try==0) font=scr->RastPort.Font;
else
if (font_try==1) font=((struct GfxBase *)GfxBase)->DefaultFont;
else
font=topaz_font;
// Set font in dummy rastport
SetFont(&rp,font);
// Initialise counts
data->text_lines=0;
data->max_text_width=0;
// Get max text width and number of lines
for (pos=0,len=0,ptr=simple->message;;pos++)
{
// End of a line?
if (simple->message[pos]=='\0' || simple->message[pos]=='\n')
{
// Get text width
width=TextLength(&rp,ptr,len);
// See if this is the longest line
if (width>data->max_text_width)
data->max_text_width=width;
// Reset length, increment line count
len=0;
ptr=simple->message+pos+1;
++data->text_lines;
// End of text?
if (simple->message[pos]=='\0') break;
}
// Otherwise, increment length
else len++;
}
// Will fit in screen?
if (data->max_text_width<scr->Width-TEXT_X_SPACE) break;
}
// Add space to text
if (data->max_text_width>=scr->Width-TEXT_X_SPACE)
data->max_text_width=scr->Width;
else
data->max_text_width+=TEXT_X_SPACE;
// Save font to use
simple->font=font;
// Unlock public screen
if (pub) UnlockPubScreen(0,pub);
// Count gadgets
for (count=0;simple->gadgets[count];count++)
{
short width;
// Get width of gadget text
width=TextLength(&rp,simple->gadgets[count],strlen(simple->gadgets[count]));
// Add to total gadget width
data->max_gadget_width+=width+GAD_X_EXTRA;
}
// Save count
data->gadget_count=count;
// Are gadgets bigger than text?
if (data->max_gadget_width+((count-1)*GAD_X_SPACE)>data->max_text_width)
{
// Add spacing between gadgets
data->max_gadget_width+=((count-1)*GAD_X_SPACE);
}
// Calculate window width
data->req_dims.fine_dim.Width=10+
((data->max_text_width>data->max_gadget_width)?data->max_text_width:data->max_gadget_width);
// Height is number of text lines plus one line for gadgets
data->req_dims.char_dim.Height=data->text_lines+1;
data->req_dims.fine_dim.Height=39+((data->text_lines-1)*3);
// String gadget?
if (simple->string_buffer)
{
// Get string length
data->string_len=simple->string_len;
// Add height
data->req_dims.char_dim.Height++;
data->req_dims.fine_dim.Height+=5;
// Second string gadget?
if (data->string_len<0)
{
// Fix length
data->string_len=-data->string_len;
data->string_buffer_2=simple->string_buffer+data->string_len+1;
data->string_len_2=data->string_len;
// Adjust height
data->req_dims.char_dim.Height++;
data->req_dims.fine_dim.Height+=5;
}
else
if (simple->flags&SRF_BUFFER2)
{
data->string_buffer_2=simple->string_buffer_2;
data->string_len_2=simple->string_len_2;
// Adjust height
data->req_dims.char_dim.Height++;
data->req_dims.fine_dim.Height+=5;
}
}
// Checkmark?
if (simple->flags&SRF_CHECKMARK)
{
// Adjust height
data->req_dims.char_dim.Height++;
data->req_dims.fine_dim.Height+=9;
}
// Fill out NewConfigWindow
data->new_win.dims=&data->req_dims;
data->new_win.title=simple->title;
data->new_win.flags=WINDOW_NO_CLOSE|WINDOW_AUTO_KEYS|WINDOW_REQ_FILL;
if (simple->flags&SRF_SCREEN_PARENT) data->new_win.flags|=WINDOW_SCREEN_PARENT;
data->new_win.font=simple->font;
// Calculate number of objects we'll need; area plus text plus gadgets plus end
data->object_count=data->text_lines+data->gadget_count+2;
// If strbuf is supplied, need a string gadget
if (simple->string_buffer)
{
++data->object_count;
if (data->string_buffer_2) ++data->object_count;
if (simple->flags&SRF_FILEREQ && simple->filereq)
++data->object_count;
}
// Checkmark?
if (simple->flags&SRF_CHECKMARK) ++data->object_count;
// Allocate objects
if (!(data->objects=(ObjectDef *)L_AllocMemH(data->memory,sizeof(ObjectDef)*data->object_count)))
return 0;
// Fill out text area
data->objects[0].type=OD_AREA;
data->objects[0].char_dims.Width=SIZE_MAXIMUM;
data->objects[0].char_dims.Height=data->text_lines+((simple->flags&SRF_CHECKMARK)?1:0);
data->objects[0].fine_dims.Left=3;
data->objects[0].fine_dims.Top=3;
data->objects[0].fine_dims.Width=-3;
data->objects[0].fine_dims.Height=24+((data->text_lines-1)*3)+((simple->flags&SRF_CHECKMARK)?9:0);
data->objects[0].gadgetid=32767;
data->objects[0].flags=AREAFLAG_RECESSED|AREAFLAG_ERASE|AREAFLAG_THIN;
// Layout tags
data->rel_tags[0].ti_Tag=GTCustom_LayoutRel;
data->rel_tags[0].ti_Data=32767;
data->rel_tags[1].ti_Tag=TAG_END;
// Allocate key array
data->keys=(unsigned char *)L_AllocMemH(data->memory,data->gadget_count);
// Build objects; first text
for (pos=0,object=1,data->start_pos=0;;pos++)
{
// End of a text line?
if (simple->message[pos]=='\0' || simple->message[pos]=='\n')
{
// Fill out text object
data->objects[object].type=OD_TEXT;
data->objects[object].object_kind=TEXTPEN;
data->objects[object].char_dims.Top=object-1;
data->objects[object].char_dims.Width=SIZE_MAXIMUM;
data->objects[object].char_dims.Height=1;
data->objects[object].fine_dims.Top=10+((object-1)*3);
// Get copy of text
if ((data->objects[object].gadget_text=
(ULONG)L_AllocMemH(data->memory,(pos-data->start_pos)+1)))
{
CopyMem(
simple->message+data->start_pos,
(char *)data->objects[object].gadget_text,
pos-data->start_pos);
data->objects[object].flags=TEXTFLAG_TEXT_STRING|TEXTFLAG_NO_USCORE;
}
// Flags and id
data->objects[object].flags|=TEXTFLAG_CENTER;
data->objects[object].gadgetid=GAD_TEXT_ID;
data->objects[object].taglist=data->rel_tags;
// Save start position for next line, increment object count
data->start_pos=pos+1;
++object;
// End of text?
if (simple->message[pos]=='\0') break;
}
}
// String gadget?
if (simple->string_buffer)
{
// Second string gadget?
if (data->string_buffer_2)
{
data->objects[object].type=OD_GADGET;
data->objects[object].object_kind=(simple->flags&SRF_LONGINT)?INTEGER_KIND:STRING_KIND;
data->objects[object].char_dims.Top=POS_RIGHT_JUSTIFY-2;
data->objects[object].char_dims.Width=SIZE_MAXIMUM;
data->objects[object].char_dims.Height=1;
data->objects[object].fine_dims.Left=3;
data->objects[object].fine_dims.Top=-16;
data->objects[object].fine_dims.Width=-3;
data->objects[object].fine_dims.Height=4;
data->objects[object].gadgetid=GAD_STRING2_ID;
data->objects[object].taglist=data->tags2;
// String tags
data->tags2[0].ti_Tag=(simple->flags&SRF_LONGINT)?GTIN_Number:TAG_IGNORE;
data->tags2[0].ti_Data=(simple->flags&SRF_LONGINT)?(ULONG)atoi(data->string_buffer_2):0;
data->tags2[1].ti_Tag=(simple->flags&SRF_LONGINT)?GTIN_MaxChars:GTST_MaxChars;
data->tags2[1].ti_Data=data->string_len;
data->tags2[2].ti_Tag=STRINGA_Justification;
data->tags2[2].ti_Data=(simple->flags&SRF_CENTJUST)?
GACT_STRINGCENTER:((simple->flags&SRF_RIGHTJUST)?GACT_STRINGRIGHT:GACT_STRINGLEFT);
data->tags2[3].ti_Tag=GTCustom_PathFilter;
data->tags2[3].ti_Data=(simple->flags&SRF_PATH_FILTER)?1:0;
data->tags2[4].ti_Tag=GTCustom_Secure;
data->tags2[4].ti_Data=(simple->flags&SRF_SECURE)?1:0;
data->tags2[5].ti_Tag=GTCustom_ThinBorders;
data->tags2[5].ti_Data=TRUE;
data->tags2[6].ti_Tag=TAG_END;
// Increment object
++object;
}
// File requester?
if (simple->flags&SRF_FILEREQ && simple->filereq)
{
// Popup button
data->objects[object].type=OD_GADGET;
data->objects[object].object_kind=POPUP_BUTTON_KIND;
data->objects[object].char_dims.Top=POS_RIGHT_JUSTIFY-1;
data->objects[object].char_dims.Width=0;
data->objects[object].char_dims.Height=1;
data->objects[object].fine_dims.Left=3;
data->objects[object].fine_dims.Top=-11;
data->objects[object].fine_dims.Width=28;
data->objects[object].fine_dims.Height=4;
data->objects[object].gadgetid=GAD_POPUP_ID;
data->objects[object].taglist=0;
// Increment object
++object;
}
// String gadget
data->objects[object].type=OD_GADGET;
data->objects[object].object_kind=(simple->flags&SRF_LONGINT)?INTEGER_KIND:STRING_KIND;
data->objects[object].char_dims.Top=POS_RIGHT_JUSTIFY-1;
data->objects[object].char_dims.Width=SIZE_MAXIMUM;
data->objects[object].char_dims.Height=1;
data->objects[object].fine_dims.Left=(simple->flags&SRF_FILEREQ && simple->filereq)?31:3;
data->objects[object].fine_dims.Top=-11;
data->objects[object].fine_dims.Width=-3;
data->objects[object].fine_dims.Height=4;
data->objects[object].gadgetid=GAD_STRING_ID;
data->objects[object].taglist=data->tags;
// String tags
data->tags[0].ti_Tag=(simple->flags&SRF_LONGINT)?GTIN_Number:TAG_IGNORE;
data->tags[0].ti_Data=(simple->flags&SRF_LONGINT)?(ULONG)atoi(simple->string_buffer):0;
data->tags[1].ti_Tag=(simple->flags&SRF_LONGINT)?GTIN_MaxChars:GTST_MaxChars;
data->tags[1].ti_Data=data->string_len;
data->tags[2].ti_Tag=STRINGA_Justification;
data->tags[2].ti_Data=(simple->flags&SRF_CENTJUST)?
GACT_STRINGCENTER:((simple->flags&SRF_RIGHTJUST)?GACT_STRINGRIGHT:GACT_STRINGLEFT);
data->tags[3].ti_Tag=GTCustom_NoSelectNext;
data->tags[3].ti_Data=TRUE;
data->tags[4].ti_Tag=GTCustom_History;
data->tags[4].ti_Data=(simple->flags&SRF_HISTORY)?(ULONG)simple->history:0;
data->tags[5].ti_Tag=GTCustom_PathFilter;
data->tags[5].ti_Data=(simple->flags&SRF_PATH_FILTER)?1:0;
data->tags[6].ti_Tag=GTCustom_Secure;
data->tags[6].ti_Data=(simple->flags&SRF_SECURE)?1:0;
data->tags[7].ti_Tag=GTCustom_ThinBorders;
data->tags[7].ti_Data=TRUE;
data->tags[8].ti_Tag=TAG_END;
// Increment object
++object;
}
// Checkmark?
if (simple->flags&SRF_CHECKMARK)
{
// Fill out gadget
data->objects[object].type=OD_GADGET;
data->objects[object].object_kind=CHECKBOX_KIND;
data->objects[object].char_dims.Top=POS_RIGHT_JUSTIFY;
data->objects[object].char_dims.Left=POS_CENTER;
data->objects[object].char_dims.Height=1;
data->objects[object].fine_dims.Left=FPOS_TEXT_OFFSET+(strlen(simple->check_text)>>1);
data->objects[object].fine_dims.Top=-4;
data->objects[object].fine_dims.Width=28;
data->objects[object].fine_dims.Height=6;
data->objects[object].gadget_text=(ULONG)simple->check_text;
data->objects[object].flags=TEXTFLAG_TEXT_STRING|PLACETEXT_RIGHT;
data->objects[object].gadgetid=GAD_CHECK_ID;
data->objects[object].taglist=data->rel_tags;
// Increment object
++object;
}
void main()
{
ULONG class,code;
struct Gadget *gadget;
struct IntuiMessage *message;
struct DrawInfo *dri;
BOOL running=TRUE;
unless(Scr=LockPubScreen("Workbench")) LEAVE;
unless(dri=GetScreenDrawInfo(Scr)) LEAVE;
unless(SmartBitMapBase=OpenLibrary("images/smartbitmap.image",36L)) LEAVE;
unless(ImClass=GetSmartBitMapClass()) LEAVE;
GetRGB32(Scr->ViewPort.ColorMap,0,1,&pal[0].R);
unless(Im=NewObject(ImClass,NULL,
IA_Left,25,
IA_Top,25,
IA_Width,20,
SMBM_Border,FALSE,
SMBM_SelBorder,TRUE,
SMBM_Screen,Scr,
SMBM_BitMap,&TBCOLORWHEELBitMap,
// SMBM_BitMap,&Size45UDBitMap,
SMBM_Palette,pal,
TAG_DONE)) LEAVE;
unless(MainWnd=OpenWindowTags(NULL,
WA_Left,0,
WA_Top,0,
WA_Width,600,
WA_Height,200,
WA_IDCMP,IDCMP_CLOSEWINDOW|IDCMP_GADGETUP,
WA_Flags,WFLG_CLOSEGADGET|WFLG_DRAGBAR|WFLG_DEPTHGADGET|WFLG_ACTIVATE|WFLG_SIZEGADGET,
WA_CustomScreen,Scr,
TAG_DONE)) LEAVE;
DrawImageState(MainWnd->RPort,(struct Image *)Im,0,0,IDS_NORMAL,dri);
while(running)
{
Wait(1L<<MainWnd->UserPort->mp_SigBit);
while(message=GT_GetIMsg(MainWnd->UserPort))
{
class=message->Class;
code=message->Code;
gadget=(struct Gadget *)message->IAddress;
GT_ReplyIMsg(message);
switch(class)
{
case IDCMP_CLOSEWINDOW:
running=FALSE;
break;
}
}
}
end:
if(MainWnd)
{
CloseWindow(MainWnd);
}
if(Im) DisposeObject(Im);
if(SmartBitMapBase) CloseLibrary(SmartBitMapBase);
if(dri) FreeScreenDrawInfo(Scr,dri);
if(Scr) UnlockPubScreen(NULL,Scr);
}
BOOL BuildGUI(char *screenname) {
Object **ar = Window_Objs;
struct Screen *screen;
BOOL OptionFrame = FALSE;
LONG indicatorwidth = 100;
Object *l1, *l2, *l3, *l4, *l5, *l6, *l7;
UpdateStrings();
if (ButtonBase == NULL) { /* force it open */
Printf((char *) msgTextNoOpen, "button.gadget", __classactversion);
Printf("\n");
return FALSE;
}
/* Dynamic */
unitlist = ChooserLabelsA( (STRPTR *) Units);
modelist = BrowserNodesA( (STRPTR *) Modes);
infolist = BrowserNodes2(infotexts, infoargs);
/* Static */
pagelist = ClickTabs( (char *) msgPageMode, (char *) msgPageAdvanced, NULL);
debuglist = ChooserLabels( (char *) msgDebugNone,
(char *) msgDebugLow,
(char *) msgDebugHigh,
(char *) msgDebugFull,
NULL);
echolist = ChooserLabels( (char *) msgEchoEnabled,
(char *) msgEchoFast,
(char *) msgEchoDisabled,
NULL);
surroundlist = ChooserLabels( (char *) msgSurroundEnabled,
(char *) msgSurroundDisabled,
NULL);
clipMVlist = ChooserLabels( (char *) msgMVNoClip,
(char *) msgMVClip,
NULL);
screen = LockPubScreen(screenname);
vi = GetVisualInfoA(screen, NULL);
Menu = CreateMenusA(NewMenus, NULL);
if(vi == NULL || Menu == NULL) {
Printf((char *) msgTextNoWindow);
Printf("\n");
return FALSE;
}
if(!LayoutMenus(Menu, vi, GTMN_NewLookMenus, TRUE, TAG_DONE)) {
Printf((char *) msgTextNoWindow);
Printf("\n");
return FALSE;
}
indicatorwidth = max(indicatorwidth, 16 * screen->RastPort.Font->tf_XSize);
if(screen->Height > 240) {
OptionFrame = TRUE;
}
ar[ACTID_PAGE] = PageObject,
PAGE_Current, 0,
/* PAGE 1 */
PAGE_Add, HLayoutObject,
LAYOUT_VertAlignment, LALIGN_CENTER,
LAYOUT_AddChild, VLayoutObject,
LAYOUT_AddChild, ar[ACTID_UNIT] = PopUpObject,
CHOOSER_Labels, unitlist,
CHOOSER_Active, state.UnitSelected,
ChooserEnd,
CHILD_WeightedHeight, 0,
LAYOUT_AddChild, ar[ACTID_MODE] = ListBrowserObject,
LISTBROWSER_Labels, modelist,
LISTBROWSER_MakeVisible,state.ModeSelected,
LISTBROWSER_Selected, state.ModeSelected,
LISTBROWSER_ShowSelected,TRUE,
ListBrowserEnd,
LAYOUT_AddChild, ar[SHOWID_MODE] = ListBrowserObject,
LISTBROWSER_Labels, infolist,
LISTBROWSER_ColumnInfo, (ULONG)&ci,
LISTBROWSER_AutoFit, TRUE,
LISTBROWSER_VertSeparators, FALSE,
GA_ReadOnly, TRUE,
ListBrowserEnd,
CHILD_MaxHeight, screen->RastPort.Font->tf_YSize * 6 + 6, // UHH!!
LayoutEnd,
LAYOUT_AddChild, HLayoutObject,
(OptionFrame ? LAYOUT_SpaceOuter : TAG_IGNORE), TRUE,
(OptionFrame ? LAYOUT_RightSpacing : TAG_IGNORE), 0,
(OptionFrame ? LAYOUT_BevelStyle : TAG_IGNORE), BVS_GROUP,
(OptionFrame ? LAYOUT_Label : TAG_IGNORE), (char *) msgOptions,
LAYOUT_AddChild, VLayoutObject,
LAYOUT_AddChild, l1 = HLayoutObject,
LAYOUT_AddChild, ar[ACTID_FREQ] = SliderObject,
SLIDER_Min, 0,
SLIDER_Max, state.Frequencies,
SLIDER_Level, state.FreqSelected,
SLIDER_Orientation, SORIENT_HORIZ,
GA_UserData, &GadgetHook,
SliderEnd,
CHILD_Label, LabelObject,
LABEL_Text, (char *) msgOptFrequency,
LabelEnd,
LAYOUT_AddChild, ar[SHOWID_FREQ] = ButtonObject,
GA_Text, getFreq(),
GA_ReadOnly, TRUE,
BUTTON_BevelStyle, BVS_NONE,
BUTTON_Transparent, TRUE,
BUTTON_Justification, BCJ_LEFT,
ButtonEnd,
CHILD_MinWidth, indicatorwidth,
CHILD_MaxWidth, indicatorwidth,
LayoutEnd,
LAYOUT_AddChild, l2 = HLayoutObject,
LAYOUT_AddChild, ar[ACTID_CHANNELS] = SliderObject,
SLIDER_Min, 1,
SLIDER_Max, state.Channels,
SLIDER_Level, state.ChannelsSelected,
SLIDER_Orientation, SORIENT_HORIZ,
GA_UserData, &GadgetHook,
SliderEnd,
CHILD_Label, LabelObject,
LABEL_Text, (char *) msgOptChannels,
LabelEnd,
LAYOUT_AddChild, ar[SHOWID_CHANNELS] = ButtonObject,
GA_Text, getChannels(),
GA_ReadOnly, TRUE,
BUTTON_BevelStyle, BVS_NONE,
BUTTON_Transparent, TRUE,
BUTTON_Justification, BCJ_LEFT,
ButtonEnd,
CHILD_MinWidth, indicatorwidth,
CHILD_MaxWidth, indicatorwidth,
LayoutEnd,
LAYOUT_AddChild, l3 = HLayoutObject,
LAYOUT_AddChild, ar[ACTID_OUTVOL] = SliderObject,
SLIDER_Min, 0,
SLIDER_Max, state.OutVols,
SLIDER_Level, state.OutVolSelected,
SLIDER_Orientation, SORIENT_HORIZ,
GA_UserData, &GadgetHook,
SliderEnd,
CHILD_Label, LabelObject,
LABEL_Text, (char *) msgOptVolume,
LabelEnd,
LAYOUT_AddChild, ar[SHOWID_OUTVOL] = ButtonObject,
GA_Text, getOutVol(),
GA_ReadOnly, TRUE,
BUTTON_BevelStyle, BVS_NONE,
BUTTON_Transparent, TRUE,
BUTTON_Justification, BCJ_LEFT,
ButtonEnd,
CHILD_MinWidth, indicatorwidth,
CHILD_MaxWidth, indicatorwidth,
LayoutEnd,
LAYOUT_AddChild, l4 = HLayoutObject,
LAYOUT_AddChild, ar[ACTID_MONVOL] = SliderObject,
SLIDER_Min, 0,
SLIDER_Max, state.MonVols,
SLIDER_Level, state.MonVolSelected,
SLIDER_Orientation, SORIENT_HORIZ,
GA_UserData, &GadgetHook,
SliderEnd,
CHILD_Label, LabelObject,
LABEL_Text, (char *) msgOptMonitor,
LabelEnd,
LAYOUT_AddChild, ar[SHOWID_MONVOL] = ButtonObject,
GA_Text, getMonVol(),
GA_ReadOnly, TRUE,
BUTTON_BevelStyle, BVS_NONE,
BUTTON_Transparent, TRUE,
BUTTON_Justification, BCJ_LEFT,
ButtonEnd,
CHILD_MinWidth, indicatorwidth,
CHILD_MaxWidth, indicatorwidth,
LayoutEnd,
LAYOUT_AddChild, l5 = HLayoutObject,
LAYOUT_AddChild, ar[ACTID_GAIN] = SliderObject,
SLIDER_Min, 0,
SLIDER_Max, state.Gains,
SLIDER_Level, state.GainSelected,
SLIDER_Orientation, SORIENT_HORIZ,
GA_UserData, &GadgetHook,
SliderEnd,
CHILD_Label, LabelObject,
LABEL_Text, (char *) msgOptGain,
LabelEnd,
LAYOUT_AddChild, ar[SHOWID_GAIN] = ButtonObject,
GA_Text, getGain(),
GA_ReadOnly, TRUE,
BUTTON_BevelStyle, BVS_NONE,
BUTTON_Transparent, TRUE,
BUTTON_Justification, BCJ_LEFT,
ButtonEnd,
CHILD_MinWidth, indicatorwidth,
CHILD_MaxWidth, indicatorwidth,
LayoutEnd,
LAYOUT_AddChild, l6 = HLayoutObject,
LAYOUT_AddChild, ar[ACTID_INPUT] = SliderObject,
SLIDER_Min, 0,
SLIDER_Max, state.Inputs,
SLIDER_Level, state.InputSelected,
SLIDER_Orientation, SORIENT_HORIZ,
GA_UserData, &GadgetHook,
SliderEnd,
CHILD_Label, LabelObject,
LABEL_Text, (char *) msgOptInput,
LabelEnd,
LAYOUT_AddChild, ar[SHOWID_INPUT] = ButtonObject,
GA_Text, getInput(),
GA_ReadOnly, TRUE,
BUTTON_BevelStyle, BVS_NONE,
BUTTON_Transparent, TRUE,
BUTTON_Justification, BCJ_LEFT,
ButtonEnd,
CHILD_MinWidth, indicatorwidth,
CHILD_MaxWidth, indicatorwidth,
LayoutEnd,
LAYOUT_AddChild, l7 = HLayoutObject,
LAYOUT_AddChild, ar[ACTID_OUTPUT] = SliderObject,
SLIDER_Min, 0,
SLIDER_Max, state.Outputs,
SLIDER_Level, state.OutputSelected,
SLIDER_Orientation, SORIENT_HORIZ,
GA_UserData, &GadgetHook,
SliderEnd,
CHILD_Label, LabelObject,
LABEL_Text, (char *) msgOptOutput,
LabelEnd,
LAYOUT_AddChild, ar[SHOWID_OUTPUT] = ButtonObject,
GA_Text, getOutput(),
GA_ReadOnly, TRUE,
BUTTON_BevelStyle, BVS_NONE,
BUTTON_Transparent, TRUE,
BUTTON_Justification, BCJ_LEFT,
ButtonEnd,
CHILD_MinWidth, indicatorwidth,
CHILD_MaxWidth, indicatorwidth,
LayoutEnd,
LayoutEnd,
LayoutEnd,
CHILD_WeightedHeight, 0,
LayoutEnd,
/* PAGE 2 */
PAGE_Add, HLayoutObject,
LAYOUT_VertAlignment, LALIGN_CENTER,
LAYOUT_HorizAlignment, LALIGN_CENTER,
LAYOUT_AddChild, VLayoutObject,
LAYOUT_SpaceOuter, TRUE,
LAYOUT_BevelStyle, BVS_GROUP,
LAYOUT_Label, (char *) msgGlobalOptions,
LAYOUT_VertAlignment, LALIGN_BOTTOM,
LAYOUT_AddChild, ar[ACTID_DEBUG] = PopUpObject,
CHOOSER_Labels, debuglist,
CHOOSER_Active, globalprefs.ahigp_DebugLevel,
ChooserEnd,
CHILD_Label, LabelObject,
LABEL_Text, (char *) msgGlobOptDebugLevel,
LabelEnd,
LAYOUT_AddChild, ar[ACTID_ECHO] = PopUpObject,
CHOOSER_Labels, echolist,
CHOOSER_Active, (globalprefs.ahigp_DisableEcho ? 2 : 0) |
(globalprefs.ahigp_FastEcho ? 1 : 0),
ChooserEnd,
CHILD_Label, LabelObject,
LABEL_Text, (char *) msgGlobOptEcho,
LabelEnd,
LAYOUT_AddChild, ar[ACTID_SURROUND] = PopUpObject,
CHOOSER_Labels, surroundlist,
CHOOSER_Active, globalprefs.ahigp_DisableSurround,
ChooserEnd,
CHILD_Label, LabelObject,
LABEL_Text, (char *) msgGlobOptSurround,
LabelEnd,
LAYOUT_AddChild, ar[ACTID_CLIPMV] = PopUpObject,
CHOOSER_Labels, clipMVlist,
CHOOSER_Active, globalprefs.ahigp_ClipMasterVolume,
ChooserEnd,
CHILD_Label, LabelObject,
LABEL_Text, (char *) msgGlobOptMasterVol,
LabelEnd,
LAYOUT_AddChild, ar[ACTID_CPULIMIT] = IntegerObject,
INTEGER_MaxChars, 3,
INTEGER_MinVisible, 3,
INTEGER_Minimum, 0,
INTEGER_Maximum, 100,
INTEGER_Number, (globalprefs.ahigp_MaxCPU * 100 + 32768) >> 16,
INTEGER_Arrows, TRUE,
IntegerEnd,
CHILD_Label, LabelObject,
LABEL_Text, (char *) msgGlobOptCPULimit,
LabelEnd,
LayoutEnd,
CHILD_WeightedHeight, 0,
CHILD_WeightedWidth, 0,
LayoutEnd,
PageEnd;
if(ar[ACTID_PAGE] != NULL) {
SetAttrs( l1, LAYOUT_AlignLabels, l2, TAG_DONE);
SetAttrs( l2, LAYOUT_AlignLabels, l3, TAG_DONE);
SetAttrs( l3, LAYOUT_AlignLabels, l4, TAG_DONE);
SetAttrs( l4, LAYOUT_AlignLabels, l5, TAG_DONE);
SetAttrs( l5, LAYOUT_AlignLabels, l6, TAG_DONE);
SetAttrs( l6, LAYOUT_AlignLabels, l7, TAG_DONE);
SetAttrs( l7, LAYOUT_AlignLabels, l1, TAG_DONE);
}
WO_Window = WindowObject,
WA_PubScreen, screen,
WA_Title, (char *) msgTextProgramName,
WA_CloseGadget, TRUE,
WA_DepthGadget, TRUE,
WA_DragBar, TRUE,
WA_Activate, TRUE,
WA_SizeGadget, TRUE,
WA_SizeBBottom, TRUE,
WA_NewLookMenus, TRUE,
WA_InnerWidth, 800,
WA_InnerHeight, 400,
WINDOW_MenuStrip, Menu,
WINDOW_Position, WPOS_CENTERSCREEN,
WINDOW_GadgetUserData, WGUD_HOOK,
WINDOW_IDCMPHook, &IDCMPhook,
WINDOW_IDCMPHookBits, IDCMP_RAWKEY,
WINDOW_Layout, VLayoutObject,
LAYOUT_SpaceOuter, TRUE,
LAYOUT_DeferLayout, TRUE,
/* TABS */
LAYOUT_AddChild, ar[LAYOUT_PAGE] = VLayoutObject,
LAYOUT_AddChild, ar[ACTID_TABS] = ClickTabObject,
CLICKTAB_Labels, pagelist,
CLICKTAB_Current, 0L,
ICA_TARGET, ar[ACTID_PAGE],
ICA_MAP, MapTab2Page,
ClickTabEnd,
LAYOUT_AddChild, ar[ACTID_PAGE],
LayoutEnd,
/* BUTTONS */
LAYOUT_AddChild, HLayoutObject,
LAYOUT_EvenSize, TRUE,
LAYOUT_AddChild, ar[ACTID_SAVE] = ButtonObject,
GA_Text, (char *) msgButtonSave,
ButtonEnd,
CHILD_WeightedHeight, 0,
LAYOUT_AddChild, ar[ACTID_USE] = ButtonObject,
GA_Text, (char *) msgButtonUse,
ButtonEnd,
CHILD_WeightedHeight, 0,
LAYOUT_AddChild, ar[ACTID_QUIT] = ButtonObject,
GA_Text, (char *) msgButtonCancel,
ButtonEnd,
CHILD_WeightedHeight, 0,
LayoutEnd,
CHILD_WeightedHeight, 0,
LayoutEnd,
WindowEnd;
if(WO_Window) {
int i;
for(i = 0; i < ACTID_COUNT; i++) {
if(Window_Objs[i] != NULL) {
SetAttrs(Window_Objs[i], GA_ID, i,
GA_RelVerify, TRUE,
TAG_END);
}
}
Window = (struct Window *) CA_OpenWindow(WO_Window);
}
if(screen) {
UnlockPubScreen(NULL, screen);
}
if(Window == NULL) {
Printf((char *) msgTextNoWindow);
Printf("\n");
return FALSE;
}
openreq = GetFileObject,
GETFILE_RejectIcons, TRUE,
GETFILE_Drawer, "SYS:Prefs/Presets",
EndObject;
savereq = GetFileObject,
GETFILE_RejectIcons, TRUE,
GETFILE_Drawer, "SYS:Prefs/Presets",
GETFILE_DoSaveMode, TRUE,
EndObject;
if((openreq == NULL) || (savereq == NULL)) {
Printf((char *) msgTextNoFileRequester);
Printf("\n");
return FALSE;
}
// Update the checkmark for "Create Icons?"
{
struct Menu *menu;
struct MenuItem *item;
menu = Menu;
ClearMenuStrip(Window);
item = FindMenuItem(ACTID_ICONS);
if(item) {
if(SaveIcons)
item->Flags |= CHECKED;
else
item->Flags &= ~CHECKED;
}
ResetMenuStrip(Window, menu);
}
GUINewUnit();
return TRUE;
}
void _config_env_screenmode_init_mode(config_env_data *data,BOOL save_depth)
{
struct DimensionInfo diminfo;
char buf[128];
struct Screen *screen;
int a;
ULONG mode_id=0;
BOOL got_dims=0;
// Get current screenmode information
switch (data->config->screen_mode)
{
// Existing screen
case MODE_WORKBENCHUSE:
case MODE_WORKBENCHCLONE:
case MODE_PUBLICSCREEN:
{
// Strip Use/Clone from mode name
stccpy(buf,data->mode_name,sizeof(buf));
for (a=strlen(buf)-1;a>=0;a--)
{
if (buf[a]==':')
{
buf[a]=0;
break;
}
}
// Get screen
if (screen=LockPubScreen(buf))
{
// Get screen mode
mode_id=GetVPModeID(&screen->ViewPort);
// Get minimum size
if (data->config->screen_mode==MODE_WORKBENCHCLONE)
{
data->mode_size_limit.MinX=screen->Width;
data->mode_size_limit.MinY=screen->Height;
// Clone depth
if (!save_depth)
data->config->screen_depth=screen->RastPort.BitMap->Depth;
}
else
{
data->mode_size_limit.MinX=640;
data->mode_size_limit.MinY=200;
}
// Get maximum size
data->mode_size_limit.MaxX=screen->Width;
data->mode_size_limit.MaxY=screen->Height;
// Get default size
data->mode_size_default.MaxX=screen->Width;
data->mode_size_default.MaxY=screen->Height;
// Got dimensions
got_dims=1;
// Release screen
UnlockPubScreen(0,screen);
}
}
break;
// Real screen mode
default:
mode_id=data->config->screen_mode;
break;
}
// Get mode info (if available)
if (!(ModeNotAvailable(mode_id)) &&
(GetDisplayInfoData(0,(char *)&diminfo,sizeof(diminfo),DTAG_DIMS,mode_id)))
{
// Not already got dimensions?
if (!got_dims)
{
// Get minimum size
data->mode_size_limit.MinX=diminfo.MinRasterWidth;
data->mode_size_limit.MinY=diminfo.MinRasterHeight;
// Get maximum size
data->mode_size_limit.MaxX=diminfo.MaxRasterWidth;
data->mode_size_limit.MaxY=diminfo.MaxRasterHeight;
// Get default size
data->mode_size_default.MaxX=diminfo.TxtOScan.MaxX+1;
data->mode_size_default.MaxY=diminfo.TxtOScan.MaxY+1;
}
// Get maximum colours
data->mode_max_colours=diminfo.MaxDepth;
}
// Check settings
if (data->mode_size_limit.MinX<640)
data->mode_size_limit.MinX=640;
if (data->mode_size_limit.MinY<200)
data->mode_size_limit.MinY=200;
if (data->mode_size_limit.MaxX<data->mode_size_limit.MinX)
data->mode_size_limit.MaxX=data->mode_size_limit.MinX;
if (data->mode_size_limit.MaxY<data->mode_size_limit.MinY)
data->mode_size_limit.MaxY=data->mode_size_limit.MinY;
if (data->mode_size_default.MaxX<data->mode_size_limit.MinX)
data->mode_size_default.MaxX=data->mode_size_limit.MinX;
else
if (data->mode_size_default.MaxX>data->mode_size_limit.MaxX)
data->mode_size_default.MaxX=data->mode_size_limit.MaxX;
if (data->mode_size_default.MaxY<data->mode_size_limit.MinY)
data->mode_size_default.MaxY=data->mode_size_limit.MinY;
else
if (data->mode_size_default.MaxY>data->mode_size_limit.MaxY)
data->mode_size_default.MaxY=data->mode_size_limit.MaxY;
if (data->mode_max_colours<1) data->mode_max_colours=1;
// Fix gadgets
_config_env_screenmode_fix_gadgets(data);
}
