예제 #1
1
파일: amiga.c 프로젝트: DavidKinder/Level9
void amiga_init (char *dir)
{
  if ((DefaultPubScreen = LockPubScreen (0)) == 0)
    exit (1);
  screen_ratio (DefaultPubScreen);

  char prog_name[256];
  static char font_name[MAXFONTPATH];
  char *font_desc, *name_ptr;
  static WORD pens[] =
  {-1};
  static struct TextAttr font =
  {NULL, 0, FS_NORMAL, 0};
  int window = 0;

  if (Icon == NULL)
  {
    if (GetProgramName (prog_name, 256))
      Icon = GetDiskObject (prog_name);
  }

  if (Icon)
  {
    if (FindToolType (Icon->do_ToolTypes, "WINDOW"))
      window = 1;
    if (font_desc = FindToolType (Icon->do_ToolTypes, "FONT"))
    {
      strcpy (font_name, font_desc);
      if (name_ptr = strrchr (font_name, '/'))
      {
	font.ta_Name = font_name;
	font.ta_YSize = atoi (name_ptr + 1);
	strcpy (name_ptr, ".font");
      }
    }
    if (font.ta_Name)
      Font = OpenDiskFont (&font);
  }
  if (Font == NULL)
  {
    font.ta_Name = "topaz.font";
    font.ta_YSize = 8;
    Font = OpenFont (&font);
  }

  if (window == 0)
  {
    if ((Screen = OpenScreenTags (0,
				  SA_Pens, pens,
				  SA_DisplayID, GetVPModeID (&DefaultPubScreen->ViewPort),
				  SA_Overscan, OSCAN_TEXT,
				  SA_Depth, 2,
				  SA_Type, CUSTOMSCREEN | AUTOSCROLL,
				  SA_Font, &font,
				  SA_Title, TitleBar, TAG_DONE)) == 0)
      exit (1);
  }

  if ((Window = OpenWindowTags (0,
				WA_Left, 0,
				WA_Top, Screen ? 2 : DefaultPubScreen->BarHeight + 1,
				WA_Width, Screen ? Screen->Width : ScreenWidth,
				WA_Height, Screen ? Screen->Height - 2 : ScreenHeight - DefaultPubScreen->BarHeight - 1,
				WA_SmartRefresh, 1,
				WA_NewLookMenus, 1,
				WA_AutoAdjust, 1,
				WA_Borderless, Screen ? 1 : 0,
				WA_Backdrop, Screen ? 1 : 0,
				WA_Activate, 1,
				WA_CloseGadget, Screen ? 0 : 1,
				WA_DragBar, Screen ? 0 : 1,
				WA_DepthGadget, Screen ? 0 : 1,
				WA_SizeGadget, Screen ? 0 : 1,
				WA_SizeBBottom, Screen ? 0 : 1,
				WA_Title, TitleBar,
				WA_ScreenTitle, TitleBar,
				WA_IDCMP, IDCMP_RAWKEY | IDCMP_VANILLAKEY | IDCMP_MENUPICK | IDCMP_CLOSEWINDOW | IDCMP_CHANGEWINDOW,
				Screen ? WA_CustomScreen : WA_PubScreen, Screen ? Screen : DefaultPubScreen,
				TAG_DONE)) == 0)
    exit (1);

  ThisProcess = (struct Process *)FindTask(0);
  OldWindowPtr = ThisProcess->pr_WindowPtr;
  ThisProcess->pr_WindowPtr = Window;

  if ((Visual = GetVisualInfo (Window->WScreen, TAG_DONE)) == 0)
    exit (1);
  if ((Menus = CreateMenus (NewMenus, GTMN_NewLookMenus, TRUE, TAG_DONE)) == 0)
    exit (1);
  LayoutMenus (Menus, Visual, GTMN_NewLookMenus, TRUE, TAG_DONE);
  SetMenuStrip (Window, Menus);

  if ((GameReq = alloc_freq (dir)) == 0)
    exit (1);
  if ((SaveReq = alloc_freq (dir)) == 0)
    exit (1);
  if ((ScriptReq = alloc_freq (dir)) == 0)
    exit (1);

  RastPort = Window->RPort;
  SetDrMd (RastPort, JAM2);
  SetAPen (RastPort, 1);
  SetBPen (RastPort, 0);
  SetFont (RastPort, Font);
  DisplayHeight = ((Window->Height - Window->BorderTop - Window->BorderBottom) / RastPort->TxHeight) - 1;
  PreviousHeight = DisplayHeight;

  reset_cursor ();
}
예제 #2
0
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;
}
예제 #3
0
// Find (and lock) a public screen
struct PubScreenNode *LIBFUNC L_FindPubScreen(
	REG(a0, struct Screen *screen),
	REG(d0, BOOL lock))
{
	struct List *pubscreenlist;
	struct PubScreenNode *node;
	char *name=0;

	// Lock the public screen list
	pubscreenlist=LockPubScreenList();

	// Scan it
	for (node=(struct PubScreenNode *)pubscreenlist->lh_Head;
		node->psn_Node.ln_Succ;
		node=(struct PubScreenNode *)node->psn_Node.ln_Succ)
	{
		// See if this node is what we're looking for
		if (node->psn_Screen==screen)
		{
			// Get name pointer
			name=node->psn_Node.ln_Name;

			// Lock screen?
			if (lock && !(LockPubScreen(name)))
				name=0;
			break;
		}
	}

	// Unlock list
	UnlockPubScreenList();

	// Return node pointer
	return (name)?node:0;
}
예제 #4
0
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);
    }
}
예제 #5
0
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
	}
}
예제 #6
0
static void getvisual(void)
{
    if (!(scr = LockPubScreen(NULL)))
    {
        cleanup("Can't lock pub screen!");
    }    
}
예제 #7
0
static void getvisual(void)
{
    if (!(scr = LockPubScreen(0)))
    {
        cleanup("Can't lock pub screen!");
    }

    if (!(dri = GetScreenDrawInfo(scr)))
    {
        cleanup("Can't get screen drawinfo!");
    }

    vp = &scr->ViewPort;
    cm = vp->ColorMap;

    pen1 = ObtainPen(cm, -1, 0, 0, 0, PENF_EXCLUSIVE);
    pen2 = ObtainPen(cm, -1, 0, 0, 0, PENF_EXCLUSIVE);

    pens[0] = pen1;
    pens[1] = pen2;

    if ((pen1 == -1) || (pen2 == -1)) cleanup("Can't obtain 2 pens!");

    if (GetBitMapAttr(scr->RastPort.BitMap, BMA_DEPTH) >= 15) truecolor = TRUE;
}
예제 #8
0
파일: Startup.c 프로젝트: punktniklas/NiKom
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.");
  }
}
예제 #9
0
int SetupScreen( void )
{
	if ( ! ( Scr = LockPubScreen( PubScreenName )))
		return( 1L );

	ComputeFont( 0, 0 );

	if ( ! ( VisualInfo = GetVisualInfo( Scr, TAG_DONE )))
		return( 2L );

	return( 0L );
}
예제 #10
0
파일: main.c 프로젝트: michalsc/AROS
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;
}
예제 #11
0
static void getvisual(void)
{
    if (!(scr = LockPubScreen(NULL)))
    {
        cleanup("Can't lock pub screen!");
    }
    
    if (GetBitMapAttr(scr->RastPort.BitMap, BMA_DEPTH) <= 8)
    {
        cleanup("Need hi or true color screen!");
    }
}
예제 #12
0
파일: vsidui.c 프로젝트: bobsummerwill/VICE
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;
}
예제 #13
0
// 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;
}
예제 #14
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;
}
예제 #15
0
static void getvisual(void)
{
    if (!(scr = LockPubScreen(NULL)))
    {
        cleanup("Can't lock pub screen!");
    }
    
    if (1)
    {
    	LONG val;
	
	val = GetCyberMapAttr(scr->RastPort.BitMap,CYBRMATTR_PIXFMT);
	
	printf("cgfx attribute = %ld\n", val); 
    }

    if (GetBitMapAttr(scr->RastPort.BitMap, BMA_DEPTH) <= 8)
    {
        cleanup("Need hi or true color screen!");
    }

}
예제 #16
0
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 );
}
예제 #17
0
/**************************************************************************************
** 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);
}
예제 #18
0
void shutdownwnd_open(void)
{
	if ((scr = LockPubScreen(NULL)))
	{
		char *filename;

		/* get a white pen for the color of our text */
		pen = ObtainBestPenA(scr->ViewPort.ColorMap,0xffffffff,0xffffffff,0xffffffff,NULL);

		if ((filename = mycombinepath(gui_get_images_directory(),"shutdown")))
		{
			if ((obj = LoadAndMapPicture("PROGDIR:Images/shutdown",scr)))
			{
				struct BitMapHeader *bmhd = NULL;
				struct BitMap *bitmap = NULL;

				GetDTAttrs(obj,PDTA_BitMapHeader,&bmhd,TAG_DONE);
				GetDTAttrs(obj,PDTA_DestBitMap,&bitmap,TAG_DONE);
				if (!bitmap) GetDTAttrs(obj,PDTA_BitMap,&bitmap,TAG_DONE);

				if (bmhd && bitmap)
				{
					int width = bmhd->bmh_Width;
					int height = bmhd->bmh_Height;

					int wndleft,wndtop;

					wndleft = (scr->Width - width)/2;
					wndtop = (scr->Height - height)/2;

					if ((shutdown_wnd = OpenWindowTags(NULL,
						WA_SmartRefresh, TRUE,
						WA_NoCareRefresh, TRUE,
						WA_Borderless, TRUE,
						WA_Width, width,
						WA_Height, height,
						WA_PubScreen, scr,
						WA_Left, wndleft,
						WA_Top, wndtop,
						WA_BackFill, LAYERS_NOBACKFILL,
						TAG_DONE)))
					{
						BltBitMapRastPort(bitmap,0,0,
										  shutdown_wnd->RPort, 0, 0, width, height,
										  0xc0);

						if (!user.config.dont_show_shutdown_text)
						{
							struct TextExtent te;
							const char *txt = _("Shutting down...");

							SetDrMd(shutdown_wnd->RPort,JAM1);
							SetAPen(shutdown_wnd->RPort,pen);
							TextExtent(shutdown_wnd->RPort,txt,strlen(txt),&te);
							if ((te.te_Width < width) && (te.te_Height < height))
							{
								/* only draw the text if there is enought space for it */
								Move(shutdown_wnd->RPort,(width - te.te_Width)/2, height - te.te_Height - 4 + shutdown_wnd->RPort->TxBaseline);
								Text(shutdown_wnd->RPort,txt,strlen(txt));
							}
						}
					}
				}
			}
			free(filename);
		}
	}
}
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);
}
예제 #20
0
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;
}
예제 #21
0
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;
}
예제 #22
0
/*
** 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;
}
예제 #23
0
파일: hidds.c 프로젝트: michalsc/AROS
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
    }
}
예제 #24
0
파일: loaddesktop.c 프로젝트: michalsc/AROS
int main(void)
{
    Object *app, *win, *iconCon, *vert, *horiz;
    Object *strip;
    struct MUI_CustomClass *iconContainerClass;
    BOOL running=TRUE;
    ULONG signals=0;
    struct Screen *screen;
    struct NewMenu *menuDat;
    struct TagItem icTags[6];
    ULONG inputResult;

    MUIMasterBase=OpenLibrary("muimaster.library", 0);
    if(!MUIMasterBase)
        printf("could not open muimaster.library\n");
    DesktopBase=OpenLibrary("desktop.library", 0);
    if(!DesktopBase)
        printf("could not open desktop.library\n");

    menuDat=BuildDesktopMenus();
    if(!menuDat)
        kprintf("EEK! EEKK! Menu ERROR!!!\n");

    screen=LockPubScreen(NULL);

    horiz=PropObject,
        MUIA_Prop_Horiz, TRUE,
        MUIA_Prop_Entries, 0,
        MUIA_Prop_UseWinBorder, MUIV_Prop_UseWinBorder_Bottom,
        End;
    vert=PropObject,
        MUIA_Prop_Horiz, FALSE,
        MUIA_Prop_UseWinBorder, MUIV_Prop_UseWinBorder_Right,
        End;

    icTags[0].ti_Tag=MUIA_InnerLeft;
    icTags[0].ti_Data=0;
    icTags[1].ti_Tag=MUIA_InnerTop;
    icTags[1].ti_Data=0;
    icTags[2].ti_Tag=MUIA_InnerBottom;
    icTags[2].ti_Data=0;
    icTags[3].ti_Tag=MUIA_InnerRight;
    icTags[3].ti_Data=0;
    icTags[4].ti_Tag=MUIA_FillArea;
    icTags[4].ti_Data=FALSE;
//  icTags[1].ti_Tag=ICOA_Directory;
//  icTags[1].ti_Data="C:";
//  icTags[2].ti_Tag=ICA_VertScroller;
//  icTags[2].ti_Data=vert;
//  icTags[3].ti_Tag=ICA_HorizScroller;
//  icTags[3].ti_Data=horiz;
    icTags[5].ti_Tag=TAG_END;
    icTags[5].ti_Data=0;

	kprintf("here1\n");

    app=ApplicationObject,
        SubWindow, win=WindowObject,
            MUIA_Window_Backdrop, TRUE,
            MUIA_Window_Borderless, TRUE,
            MUIA_Window_CloseGadget, FALSE,
            MUIA_Window_DepthGadget, FALSE,
            MUIA_Window_SizeGadget, FALSE,
            MUIA_Window_DragBar, FALSE,
            MUIA_Window_LeftEdge, 0,
            MUIA_Window_TopEdge, screen->BarHeight+1,
            MUIA_Window_Width, screen->Width,
            MUIA_Window_Height, screen->Height-screen->BarHeight-1,
            MUIA_Window_Menustrip, strip=MUI_MakeObject(MUIO_MenustripNM, menuDat, 0),
//          MUIA_Window_UseBottomBorderScroller, TRUE,
//          MUIA_Window_UseRightBorderScroller, TRUE,
            MUIA_Window_EraseArea, FALSE,
            WindowContents, iconCon=CreateDesktopObjectA(CDO_Desktop, icTags),
        End,
    End;


    if(app)
    {
        DoMethod(win, MUIM_Notify, MUIA_Window_CloseRequest, TRUE, app, 2, MUIM_Application_ReturnID, MUIV_Application_ReturnID_Quit);

        // these are here temporarily..
        DoMethod(vert, MUIM_Notify, MUIA_Prop_First, MUIV_EveryTime, iconCon, 3, MUIM_Set, ICA_ScrollToVert, MUIV_TriggerValue);
        DoMethod(horiz, MUIM_Notify, MUIA_Prop_First, MUIV_EveryTime, iconCon, 3, MUIM_Set, ICA_ScrollToHoriz, MUIV_TriggerValue);

        SetAttrs(win, MUIA_Window_Open, TRUE, TAG_DONE);

        while(running)
        {
            inputResult=DoMethod(app, MUIM_Application_Input, &signals);
            switch(inputResult)
            {
                case MUIV_Application_ReturnID_Quit:
                    running=FALSE;
                    break;
                case 2:
                    running=FALSE;
                    break;
                default:
                {
                    // a menuitem was selected...
                    struct MinList *subjects=NULL;
                    Object *member, *ostate;
                    Tag activeSubjectsTag;
                    struct TagItem args[2];

                    if(inputResult & DOC_DESKTOPOP)
                    {
                        args[0].ti_Tag=DDO_Target;
                        args[0].ti_Data=iconCon;
                        args[1].ti_Tag=TAG_END;
                        args[1].ti_Data=0;

                        DoDesktopOperation(inputResult, args);
                    }
                    else if(inputResult & DOC_ICONOP)
                    {
                        GetAttr(AICA_SelectedIcons, iconCon, &subjects);

                        ostate=subjects->mlh_Head;
                        while((member=NextObject(&ostate)))
                        {
                            args[0].ti_Tag=DDO_Target;
                            args[0].ti_Data=member;
                            args[1].ti_Tag=TAG_END;
                            args[1].ti_Data=0;

                            DoDesktopOperation(inputResult, args);
                        }
                    }
                    else if(inputResult & DOC_WINDOWOP)
                    {
                        GetAttr(DA_ActiveWindow, iconCon, &subjects);

                        args[0].ti_Tag=DDO_Target;
                        args[0].ti_Data=subjects;
                        args[1].ti_Tag=TAG_END;
                        args[1].ti_Data=0;

                        DoDesktopOperation(inputResult, args);
                    }
                }
            }

            if(running && signals)
                Wait(signals);
        }

        SetAttrs(win, MUIA_Window_Open, FALSE, TAG_DONE);

        DisposeObject(app);
    }
    else
        kprintf("could not create app\n");


    CloseLibrary(DesktopBase);
    CloseLibrary(MUIMasterBase);

    return 0;
}
예제 #25
0
VOID __stdargs
__main( char *argstring )
{
    static struct Args     args;
    LONG    rev;

    /* Get arguments if started from CLI */
    if( !_WBenchMsg )
    {
        if( !( RDArgs = ReadArgs( TEMPLATE, ( IPTR * ) &args, NULL ) ) )
        {
            PrintFault( IoErr(), GetString( MSG_ERROR_ARGS ) );
            __exit( 0 );
        }
    }

    IntuiHook.h_Entry = ( HOOKFUNC ) IntuiMsgFunc;

//    DefaultPrefs.Flags = 0;
    DefaultPrefs.ReqDefaults[ RTPREF_OTHERREQ      ].ReqPos = REQPOS_POINTER;
    DefaultPrefs.ReqDefaults[ RTPREF_FILEREQ       ].Size = 75;
    DefaultPrefs.ReqDefaults[ RTPREF_FONTREQ       ].Size =
    DefaultPrefs.ReqDefaults[ RTPREF_SCREENMODEREQ ].Size =
    DefaultPrefs.ReqDefaults[ RTPREF_VOLUMEREQ     ].Size = 65;
    DefaultPrefs.ReqDefaults[ RTPREF_FILEREQ       ].ReqPos =
    DefaultPrefs.ReqDefaults[ RTPREF_FONTREQ       ].ReqPos =
    DefaultPrefs.ReqDefaults[ RTPREF_SCREENMODEREQ ].ReqPos =
    DefaultPrefs.ReqDefaults[ RTPREF_VOLUMEREQ     ].ReqPos =
    DefaultPrefs.ReqDefaults[ RTPREF_PALETTEREQ    ].ReqPos = REQPOS_TOPLEFTSCR;
    DefaultPrefs.ReqDefaults[ RTPREF_FILEREQ       ].LeftOffset =
    DefaultPrefs.ReqDefaults[ RTPREF_FONTREQ       ].LeftOffset =
    DefaultPrefs.ReqDefaults[ RTPREF_SCREENMODEREQ ].LeftOffset =
    DefaultPrefs.ReqDefaults[ RTPREF_VOLUMEREQ     ].LeftOffset =
    DefaultPrefs.ReqDefaults[ RTPREF_PALETTEREQ    ].LeftOffset =
    DefaultPrefs.ReqDefaults[ RTPREF_OTHERREQ      ].LeftOffset = 25;
    DefaultPrefs.ReqDefaults[ RTPREF_FILEREQ       ].TopOffset =
    DefaultPrefs.ReqDefaults[ RTPREF_FONTREQ       ].TopOffset =
    DefaultPrefs.ReqDefaults[ RTPREF_SCREENMODEREQ ].TopOffset =
    DefaultPrefs.ReqDefaults[ RTPREF_VOLUMEREQ     ].TopOffset =
    DefaultPrefs.ReqDefaults[ RTPREF_PALETTEREQ    ].TopOffset =
    DefaultPrefs.ReqDefaults[ RTPREF_OTHERREQ      ].TopOffset = 18;
    DefaultPrefs.ReqDefaults[ RTPREF_FILEREQ       ].MinEntries = 10;
    DefaultPrefs.ReqDefaults[ RTPREF_FONTREQ       ].MinEntries =
    DefaultPrefs.ReqDefaults[ RTPREF_SCREENMODEREQ ].MinEntries =
    DefaultPrefs.ReqDefaults[ RTPREF_VOLUMEREQ     ].MinEntries = 6;
    DefaultPrefs.ReqDefaults[ RTPREF_FILEREQ       ].MaxEntries = 50;
    DefaultPrefs.ReqDefaults[ RTPREF_FONTREQ       ].MaxEntries =
    DefaultPrefs.ReqDefaults[ RTPREF_SCREENMODEREQ ].MaxEntries =
    DefaultPrefs.ReqDefaults[ RTPREF_VOLUMEREQ     ].MaxEntries = 10;

    if( !( IntuitionBase = ( struct IntuitionBase * ) OpenLibrary( "intuition.library", 37 ) ) )
    {
        BPTR    con;

        if( ( con = Open( "CON:40/20/320/40/ReqTools 2.8", MODE_NEWFILE ) ) )
        {
            Write( con, "\nNeed OS 2.04 or better!\n", 25 );
            Delay( 120L );
            Close( con );
        }

        FreeExit( 0 );
    }

    InitLocale();
    GfxBase      = OpenLib( "graphics.library", 37 );
    UtilityBase  = OpenLib( "utility.library", 36 );
    IconBase     = OpenLib( "icon.library", 0 );
    GadToolsBase = OpenLib( "gadtools.library", 37 );
    ReqToolsBase = OpenLib( "reqtools.library", 38 );

    rev = ReqToolsBase->LibNode.lib_Revision;

    if( ( rev >= 693 && rev <= 811 ) || ( rev >= 347 && rev <= 363 ) )
    {
        LocEZReq( MSG_WRONG_REQTOOLS_VERSION, MSG_ABORT );
        FreeExit( RETURN_FAIL );
    }

    if( rtLockPrefs()->PrefsSize != PREFSLEN )
    {
        LocEZReq( MSG_ALL_PREFS_NOT_SUPPORTED, MSG_OK );
    }

    rtUnlockPrefs();

    if( _WBenchMsg )
    {
        struct WBArg    *wbarg;
        BPTR    oldcd;

        CreateIcons = TRUE;
        wbarg = &_WBenchMsg->sm_ArgList[ 0 ];
        oldcd = CurrentDir( wbarg->wa_Lock );

        if( ( DiskObject = GetDiskObject( wbarg->wa_Name ) ) )
        {
            STRPTR    str;

            if( ( str = FindToolType( (UBYTE **)DiskObject->do_ToolTypes, "CREATEICONS" ) ) )
            {
                CreateIcons = Stricmp( str, "NO" );
            }

            if( ( str = FindToolType( (UBYTE **)DiskObject->do_ToolTypes, "SCREENFONT" ) ) )
            {
                UseScreenFont = Stricmp( str, "NO" );
            }

            if( ( str = FindToolType( (UBYTE **)DiskObject->do_ToolTypes, "PUBSCREEN" ) ) )
            {
                args.PubScreen = str;
            }
        }

        CurrentDir( oldcd );
    }
    else
    {
        if( args.ScreenFont )
        {
            UseScreenFont = Stricmp( args.ScreenFont, "NO" );
        }
    }

    if( !( FileReq = rtAllocRequestA( RT_FILEREQ, NULL ) ) )
    {
        FreeExit( RETURN_FAIL );
    }

        {
        struct TagItem tags[] =
        {
            {RTFI_Dir    , (IPTR)"Presets"    },
            {TAG_DONE                }
        };
        
        rtChangeReqAttrA( FileReq, tags );
    }
    
    /* Get current prefs from ReqTools */
    CopyMem( rtLockPrefs(), &RTPrefs, sizeof( struct ReqToolsPrefs ) );
    rtUnlockPrefs();

    /* If FROM was used load prefs from disk */
    if( args.From )
    {
        if( !LoadConfig( args.From ) )
        {
            FreeExit( RETURN_ERROR );
        }
    }

    WheelType = GetWheelType( RTPrefs.Flags );

    if( !( Screen = LockPubScreen( args.PubScreen ) ) )
    {
        LocEZReq( MSG_COULDNT_LOCK_PUBSCREEN, MSG_ABORT );
        FreeExit( RETURN_ERROR );
    }

    if( !( DrawInfo = GetScreenDrawInfo( Screen ) ) )
    {
        LocEZReq( MSG_ERROR_GETSCREENDRAWINFO, MSG_ABORT );
        FreeExit( RETURN_ERROR );
    }

    if( !( VisualInfo = GetVisualInfoA( Screen, NULL ) ) )
    {
        LocEZReq( MSG_ERROR_GETVISUALINFO, MSG_ABORT );
        FreeExit( RETURN_FAIL );
    }

    if( IntuitionBase->LibNode.lib_Version >= 39 )
    {
        Zoom[ 0 ] = Zoom[ 1 ] = 65535;
    }
    else
    {
        Zoom[ 1 ] = Screen->BarHeight + 1;
    }

    Zoom[ 2 ] = 250;
    Zoom[ 3 ] = Screen->WBorTop + Screen->Font->ta_YSize + 1;
    LocalizeMenus( NewMenu );

    if( !( Menus = CreateMenusA( NewMenu, NULL ) ) )
    {
        LocEZReq( MSG_ERROR_MENUS, MSG_ABORT );
        FreeExit( RETURN_FAIL );
    }

    LayoutMenus( Menus, VisualInfo,
        GTMN_NewLookMenus,    TRUE,
    TAG_END );

    if( !OpenGUI() )
    {
        LocEZReq( MSG_COULDNT_OPEN_WINDOW, MSG_ABORT );
        FreeExit( RETURN_FAIL );
    }


    {
        struct MenuItem    *iconItem;

        iconItem = ItemAddress( Menus, FULLMENUNUM( OPTIONS_MENU, SAVEICONS_ITEM, NOSUB ) );

        if( !CreateIcons )
        {
            iconItem->Flags &= ~CHECKED;
        }
    }

    CurrentReq = RTPREF_FILEREQ;
    ReqDefs = &RTPrefs.ReqDefaults[ CurrentReq ];
    LoopGUI();
    FreeExit( 0 );
}
예제 #26
0
/*****************************************
* Opens up the window & sets the gadgets *
*****************************************/
int setup_window(void)
{
    struct Gadget *g;
    struct NewGadget ng;
    UWORD offy;
    ULONG drawtags[20];
    static const char *keyb_langs[] =
    {
	"US",
	"DE",
	"SE",
	"FR",
	"IT",
	NULL
    };
    scr = LockPubScreen(NULL);
    if (!scr)
	return (0);
    VisInfo = GetVisualInfo(scr, TAG_DONE);
    if (!VisInfo)
	return (0);
    offy = scr->WBorTop + scr->RastPort.TxHeight + 1;

    /* Create buttons */
    g = CreateContext(&glist);
    if (!g)
	return (0);

    ng.ng_TextAttr = &topaz8;
    ng.ng_VisualInfo = VisInfo;
    ng.ng_Flags = PLACETEXT_IN;
    ng.ng_LeftEdge = 284;
    ng.ng_TopEdge = offy + 86;
    ng.ng_Width = 96;
    ng.ng_Height = 15;
    ng.ng_GadgetText = (UBYTE *) "Hard Reset";
    ng.ng_GadgetID = GAD_RESET;
    g = CreateGadget(BUTTON_KIND, g, &ng, TAG_DONE);

    ng.ng_TopEdge = offy + 105;
    ng.ng_GadgetText = (UBYTE *) "Debug";
    ng.ng_GadgetID = GAD_DEBUG;
    g = CreateGadget(BUTTON_KIND, g, &ng, TAG_DONE);

    ng.ng_TopEdge = offy + 135;
    ng.ng_GadgetText = (UBYTE *) "Quit UAE";
    ng.ng_GadgetID = GAD_EXITEMU;
    g = CreateGadget(BUTTON_KIND, g, &ng, TAG_DONE);

    /* Eject buttons */
    ng.ng_LeftEdge = 262;
    ng.ng_TopEdge = offy + 11;
    ng.ng_Width = 70;
    ng.ng_GadgetID = GAD_EJECT_DF0;
    ng.ng_GadgetText = (UBYTE *) "Eject";
    g = CreateGadget(BUTTON_KIND, g, &ng, TAG_DONE);

    ng.ng_TopEdge = offy + 28;
    ng.ng_GadgetID = GAD_EJECT_DF1;
    g = CreateGadget(BUTTON_KIND, g, &ng, TAG_DONE);

    ng.ng_TopEdge = offy + 45;
    ng.ng_GadgetID = GAD_EJECT_DF2;
    g = CreateGadget(BUTTON_KIND, g, &ng, TAG_DONE);

    ng.ng_TopEdge = offy + 62;
    ng.ng_GadgetID = GAD_EJECT_DF3;
    g = CreateGadget(BUTTON_KIND, g, &ng, TAG_DONE);

    /* Insert buttons */
    ng.ng_LeftEdge = 332;
    ng.ng_TopEdge = offy + 11;
    ng.ng_GadgetID = GAD_INSERT_DF0;
    ng.ng_GadgetText = (UBYTE *) "Insert";
    g = CreateGadget(BUTTON_KIND, g, &ng, TAG_DONE);

    ng.ng_TopEdge = offy + 28;
    ng.ng_GadgetID = GAD_INSERT_DF1;
    g = CreateGadget(BUTTON_KIND, g, &ng, TAG_DONE);

    ng.ng_TopEdge = offy + 45;
    ng.ng_GadgetID = GAD_INSERT_DF2;
    g = CreateGadget(BUTTON_KIND, g, &ng, TAG_DONE);

    ng.ng_TopEdge = offy + 62;
    ng.ng_GadgetID = GAD_INSERT_DF3;
    g = CreateGadget(BUTTON_KIND, g, &ng, TAG_DONE);

    /* Sound & Joystick buttons */
    ng.ng_LeftEdge = 133;
    ng.ng_TopEdge = 97;
    ng.ng_GadgetID = GAD_SOUND;
    ng.ng_GadgetText = (UBYTE *) "Sound:";
    ng.ng_Flags = PLACETEXT_LEFT;
    g = CreateGadget(CHECKBOX_KIND, g, &ng, GTCB_Checked, config.do_output_sound ? 1 : 0, TAG_DONE);

    ng.ng_TopEdge = 114;
    ng.ng_GadgetID = GAD_JOYSTICK;
    ng.ng_GadgetText = (UBYTE *) "Fake Joystick:";
    g = CreateGadget(CHECKBOX_KIND, g, &ng, GTCB_Checked, config.do_fake_joystick ? 1 : 0, TAG_DONE);

    ng.ng_TopEdge = 129;
    ng.ng_GadgetID = GAD_LANGUAGE;
    ng.ng_GadgetText = (UBYTE *) "Language:";
    g = CreateGadget(CYCLE_KIND, g, &ng,
		     GTCY_Labels, (ULONG) keyb_langs,
		     GTCY_Active, config.keyboard,
		     TAG_DONE);

    ng.ng_TopEdge = 146;
    ng.ng_GadgetID = GAD_FRAMERATE;
    ng.ng_GadgetText = (UBYTE *) "Framerate:";
    g = CreateGadget(INTEGER_KIND, g, &ng, GTIN_Number, config.framerate, TAG_DONE);

    newwindow.Title = "UAE-Control";
    newwindow.Width = 419;
    newwindow.Height = 171;
    newwindow.LeftEdge = 20;
    newwindow.TopEdge = 20;
    newwindow.FirstGadget = glist;
    newwindow.Screen = scr;	/* Store screen ptr */
    window = OpenWindow(&newwindow);
    if (!window)
	return (0);

    /* Draw texts etc... */
    SetAPen(window->RPort, 1);
    SetDrMd(window->RPort, JAM2);
    Move(window->RPort, 19, offy + 11 + 10);
    Text(window->RPort, (UBYTE *) "DF0:", 4);
    Move(window->RPort, 19, offy + 28 + 10);
    Text(window->RPort, (UBYTE *) "DF1:", 4);
    Move(window->RPort, 19, offy + 45 + 10);
    Text(window->RPort, (UBYTE *) "DF2:", 4);
    Move(window->RPort, 19, offy + 62 + 10);
    Text(window->RPort, (UBYTE *) "DF3:", 4);

    drawtags[0] = GT_VisualInfo;
    drawtags[1] = (ULONG) VisInfo;
    drawtags[2] = GTBB_Recessed;
    drawtags[3] = 1;
    drawtags[4] = TAG_DONE;
    DrawBevelBoxA(window->RPort, 14, offy + 10, 390, 17, (struct TagItem *) &drawtags);
    DrawBevelBoxA(window->RPort, 14, offy + 27, 390, 17, (struct TagItem *) &drawtags);
    DrawBevelBoxA(window->RPort, 14, offy + 44, 390, 17, (struct TagItem *) &drawtags);
    DrawBevelBoxA(window->RPort, 14, offy + 61, 390, 17, (struct TagItem *) &drawtags);

    print_drive_status();

    return (1);
}
예제 #27
0
// Open progress window
void progress_open(ProgressWindow *prog)
{
	struct IBox win;
	struct TextFont *font;
	struct Screen *wbscreen=0,*screen;
	struct LibData *libdata;
	short a,last=-1;

	// Already open?
	if (prog->pw_Window)
	{
		// If we have an owner window, move in front of it
		if (prog->pw_OwnerWindow)
			MoveWindowInFrontOf(prog->pw_Window,prog->pw_OwnerWindow);
		return;
	}

	// Get library data pointer
	libdata=(struct LibData *)prog->pw_Lib->ml_UserData;

	// Got a screen to open on?
	if (!(screen=prog->pw_Screen) &&
		!(prog->pw_OwnerWindow && (screen=prog->pw_OwnerWindow->WScreen)))
	{
		// Lock public screen
		if (!(wbscreen=LockPubScreen(0))) return;

		// Use this screen
		screen=wbscreen;
	}

	// Get font pointer
	font=screen->RastPort.Font;

	// Initial size
	win.Width=0;
	win.Height=0;

	// Clear coordinates
	for (a=0;a<PROG_LAST;a++)
	{
		prog->pw_Coords[a].Left=0;
		prog->pw_Coords[a].Top=0;
		prog->pw_Coords[a].Width=0;
		prog->pw_Coords[a].Height=0;
	}

	// Want filename display?
	if (prog->pw_Flags&PWF_FILENAME)
	{
		// Get position
		prog->pw_Coords[PROG_NAME].Width=font->tf_XSize*24;
		prog->pw_Coords[PROG_NAME].Height=font->tf_YSize;

		// Want size display?
		if (prog->pw_Flags&PWF_FILESIZE)
		{
			char *ptr;
			short len;

			// Get appropriate string
			ptr=GetString(&libdata->locale,(prog->pw_Flags&PWF_SWAP)?MSG_FILE_FIT:MSG_SIZE_FIT);

			// Get length of byte string
			len=TextLength(&screen->RastPort,ptr,strlen(ptr));

			// Get position
			prog->pw_Coords[PROG_SIZE].Left=
				prog->pw_Coords[PROG_NAME].Left+
				prog->pw_Coords[PROG_NAME].Width+32;
			prog->pw_Coords[PROG_SIZE].Width=len;
			prog->pw_Coords[PROG_SIZE].Height=font->tf_YSize;

			// Cache size string
			prog->pw_SizeString=GetString(&libdata->locale,(prog->pw_Flags&PWF_SWAP)?MSG_FILE:MSG_SIZE);
			last=PROG_SIZE;
		}

		// Set last id	
		else last=PROG_NAME;
	}

	// Want information display?
	if (prog->pw_Flags&PWF_INFO)
	{
		// Get position
		prog->pw_Coords[PROG_INFO].Top=(prog->pw_Flags&PWF_FILENAME)?font->tf_YSize+2:0;
		prog->pw_Coords[PROG_INFO].Width=40*font->tf_XSize;
		prog->pw_Coords[PROG_INFO].Height=font->tf_YSize;
		last=PROG_INFO;
	}

	// Want information display?
	if (prog->pw_Flags&PWF_INFO2)
	{
		// Get position
		prog->pw_Coords[PROG_INFO2].Top=prog->pw_Coords[last].Top+prog->pw_Coords[last].Height+2;
		prog->pw_Coords[PROG_INFO2].Width=40*font->tf_XSize;
		prog->pw_Coords[PROG_INFO2].Height=font->tf_YSize;
		last=PROG_INFO2;
	}

	// Want information display?
	if (prog->pw_Flags&PWF_INFO3)
	{
		// Get position
		prog->pw_Coords[PROG_INFO3].Top=prog->pw_Coords[last].Top+prog->pw_Coords[last].Height+2;
		prog->pw_Coords[PROG_INFO3].Width=40*font->tf_XSize;
		prog->pw_Coords[PROG_INFO3].Height=font->tf_YSize;
		last=PROG_INFO3;
	}

	// Want bar graph?
	if (prog->pw_Flags&PWF_GRAPH)
	{
		// Get position
		if (last>-1)
			prog->pw_Coords[PROG_GRAPH].Top=prog->pw_Coords[last].Top+prog->pw_Coords[last].Height+3;
		prog->pw_Coords[PROG_GRAPH].Width=40*font->tf_XSize;
		prog->pw_Coords[PROG_GRAPH].Height=font->tf_YSize+6;
		last=PROG_GRAPH;
	}

	// Get window size
	for (a=0;a<=last;a++)
	{
		short x,y;

		// Get bottom-left coordinates of this item
		x=prog->pw_Coords[a].Left+prog->pw_Coords[a].Width-1;
		y=prog->pw_Coords[a].Top+prog->pw_Coords[a].Height-1;

		// Check against current window size
		if (win.Width<x) win.Width=x;
		if (win.Height<y) win.Height=y;
	}

	// Info can grow to fill window
	if (prog->pw_Flags&PWF_INFO)
	{
		// Check against width
		if (prog->pw_Coords[PROG_INFO].Width<win.Width)
			prog->pw_Coords[PROG_INFO].Width=win.Width;
	}

	// Info can grow to fill window
	if (prog->pw_Flags&PWF_INFO2)
	{
		// Check against width
		if (prog->pw_Coords[PROG_INFO2].Width<win.Width)
			prog->pw_Coords[PROG_INFO2].Width=win.Width;
	}

	// Info can grow to fill window
	if (prog->pw_Flags&PWF_INFO3)
	{
		// Check against width
		if (prog->pw_Coords[PROG_INFO3].Width<win.Width)
			prog->pw_Coords[PROG_INFO3].Width=win.Width;
	}

	// As can the graph
	if (prog->pw_Flags&PWF_GRAPH)
	{
		// Check against width
		if (prog->pw_Coords[PROG_GRAPH].Width<win.Width)
			prog->pw_Coords[PROG_GRAPH].Width=win.Width;
	}

	// Filename can too if there's no filesize
	if ((prog->pw_Flags&(PWF_FILENAME|PWF_FILESIZE))==PWF_FILENAME)
	{
		// Check against width
		if (prog->pw_Coords[PROG_NAME].Width<win.Width)
			prog->pw_Coords[PROG_NAME].Width=win.Width;
	}

	// If there's a filesize, it should be right-justified
	if (prog->pw_Flags&PWF_FILESIZE)
	{
		// Right-justify
		prog->pw_Coords[PROG_SIZE].Left=win.Width-prog->pw_Coords[PROG_SIZE].Width;
	}

	// Want abort gadget?
	if ((prog->pw_SigTask || prog->pw_Flags&PWF_ABORT) && !(prog->pw_Flags&PWF_NOABORT))
	{
		char *ptr=GetString(&libdata->locale,MSG_ABORT);
		short len;

		// Get length of abort string
		len=TextLength(&screen->RastPort,ptr,strlen(ptr));

		// Get gadget size
		prog->pw_Coords[PROG_LAST].Width=len+16;
		prog->pw_Coords[PROG_LAST].Height=font->tf_YSize+6;

		// Got a graph?
		if (prog->pw_Flags&PWF_GRAPH)
		{
			// Shrink graph to fit progress gadget
			prog->pw_Coords[PROG_GRAPH].Width-=prog->pw_Coords[PROG_LAST].Width+8;
		}

		// Otherwise, grow window by height of gadget
		else
		{
			win.Height+=prog->pw_Coords[PROG_LAST].Height;
			if (win.Width<prog->pw_Coords[PROG_LAST].Width)
				win.Width=prog->pw_Coords[PROG_LAST].Width;
		}

		// Position gadget
		prog->pw_Coords[PROG_LAST].Left=win.Width-prog->pw_Coords[PROG_LAST].Width;
		prog->pw_Coords[PROG_LAST].Top=win.Height-prog->pw_Coords[PROG_LAST].Height+1;
	}

	// Get border sizes
	prog->pw_Offset.x=6;
	prog->pw_Offset.y=6;

	// Add additional space to window
	win.Width+=prog->pw_Offset.x<<1;
	win.Height+=prog->pw_Offset.y<<1;

	// Add system border sizes
	win.Width+=screen->WBorLeft+screen->WBorRight;
	win.Height+=screen->WBorTop+screen->WBorBottom+font->tf_YSize+1;

	// Is window position valid?
	if (prog->pw_PosValid)
	{
		// Get saved position
		win.Left=prog->pw_WindowPos.x;
		win.Top=prog->pw_WindowPos.y;
	}

	// Calculate window position
	else
	if (prog->pw_OwnerWindow)
	{
		// Center in owner window
		win.Left=prog->pw_OwnerWindow->LeftEdge+((prog->pw_OwnerWindow->Width-win.Width)>>1);
		win.Top=prog->pw_OwnerWindow->TopEdge+((prog->pw_OwnerWindow->Height-win.Height)>>1);
	}
예제 #28
0
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);
}
예제 #29
0
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;
}
예제 #30
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;
	}