Example #1
1
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 ();
}
Example #2
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 Window *win;
    struct Image myImage;

    IntuitionBase = (struct IntuitionBase *)OpenLibrary("intuition.library",37);
    if (IntuitionBase != NULL)
    {
#ifdef __AROS__
        if (NULL != (win = OpenWindowTags(NULL,
                                          WA_Width,	200,
                                          WA_Height,	100,
                                          WA_RMBTrap,	TRUE,
                                          WA_IDCMP,	IDCMP_RAWKEY,
                                          TAG_END)))
#else
        if (NULL != (win = OpenWindowTags(NULL,
                                          WA_Width,	200,
                                          WA_Height,	100,
                                          WA_RMBTrap,	TRUE,
                                          TAG_END)))
#endif
        {
            myImage.LeftEdge    = MYIMAGE_LEFT;
            myImage.TopEdge     = MYIMAGE_TOP;
            myImage.Width	    = MYIMAGE_WIDTH;
            myImage.Height	    = MYIMAGE_HEIGHT;
            myImage.Depth	    = MYIMAGE_DEPTH;
            myImage.ImageData   = myImageData;
            myImage.PlanePick   = 0x1;		/* use first bit-plane	   */
            myImage.PlaneOnOff  = 0x0;		/* clear all unused planes */
            myImage.NextImage   = NULL;

            /* Draw the 1 bit-plane image into the first bit-plane (color 1) */
            DrawImage(win->RPort,&myImage,10,10);

            /* Draw the same image at a new location */
            DrawImage(win->RPort,&myImage,100,10);

#ifdef __AROS__
            /* Wait for a 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);
        }
        CloseLibrary((struct Library *)IntuitionBase);
    }
    return 0;
}
Example #3
0
static void makewin(void)
{
    shapehook.h_Entry = HookEntry;
    shapehook.h_SubEntry = (HOOKFUNC)shapefunc;
    
    
    win = OpenWindowTags(NULL, WA_CustomScreen	, (IPTR)scr,
    			       WA_InnerWidth	, WINWIDTH,
    			       WA_InnerHeight	, WINHEIGHT,
			       WA_Title		, (IPTR)"Round Edged Window",
			       WA_DragBar	, TRUE,
			       //WA_DepthGadget	, TRUE,
			       //WA_CloseGadget	, TRUE,
			       WA_Activate	, TRUE,
			       WA_MinWidth  	, 160,
			       WA_MinHeight 	, 160,
			       WA_MaxWidth  	, 2000,
			       WA_MaxHeight 	, 2000,
			       WA_SizeGadget	, TRUE,
			       WA_SizeBBottom	, TRUE,
			       WA_NoCareRefresh , TRUE,
			       WA_ShapeHook 	, (IPTR)&shapehook,
			       WA_IDCMP		, IDCMP_CLOSEWINDOW |
			       			  IDCMP_RAWKEY |
						  IDCMP_NEWSIZE,
			       TAG_DONE);

   if (!win) cleanup("Can't open window");

   rp = win->RPort;

}
Example #4
0
struct Window *openwindow(LONG x, LONG y, LONG w, LONG h)
{

  struct Window *window;
  struct Rectangle R;
  R.MinX = 10;
  R.MinY = 10;
  R.MaxX = 100;
  R.MaxY = 100;
  
  window = OpenWindowTags(NULL,
			  WA_IDCMP, IDCMP_RAWKEY|IDCMP_CLOSEWINDOW,
			  WA_Left,	x,
			  WA_Top,	y,
                          WA_Height, 	w,
                          WA_Width, 	h,
			  WA_Activate,		TRUE,
			  WA_DepthGadget, 	TRUE,
			  WA_Zoom,		(IPTR)&R,
			  WA_CloseGadget,	TRUE,
			  WA_Title,		(IPTR)"Windowing demo",
                          TAG_END);

  printf("Window opened\n");
  
  return window;
}
Example #5
0
/*
** Open a simple window using OpenWindowTagList()
*/
int main(int argc, char **argv)
{

    win = OpenWindowTags(0,
                WA_Title, (IPTR)"glAGetProcAddress",
                WA_CloseGadget, TRUE,
                WA_DragBar, TRUE,
                WA_DepthGadget, TRUE,
                WA_Left, 10,
                WA_Top, 10,
                WA_InnerWidth, 300,
                WA_InnerHeight, 300,
                WA_Activate, TRUE,
                WA_RMBTrap, TRUE,
                WA_SimpleRefresh, TRUE,
                WA_NoCareRefresh, TRUE,
                WA_IDCMP, IDCMP_CLOSEWINDOW,
                TAG_DONE);

    initgl();

    testextensions();

    deinitgl();

    CloseWindow(win);

    return 0;
}
Example #6
0
struct Window *openwindow(struct Screen *screen, const char *title, LONG x, LONG y, LONG w, LONG h)
{

  struct Window *window;
  printf("Opening window, screen=0x%p\n", screen);
  
  window = OpenWindowTags(NULL,
			  WA_IDCMP, IDCMP_CLOSEWINDOW | IDCMP_INTUITICKS,
			  WA_Left,	x,
			  WA_Top,	y,
                          WA_InnerWidth, 	w,
                          WA_InnerHeight, 	h,
			  WA_CustomScreen, screen,
			  WA_Activate,		TRUE,
			  WA_DepthGadget, 	TRUE,
			  WA_DragBar,		TRUE,
			  WA_CloseGadget,	TRUE,
			  WA_NoCareRefresh,	TRUE,
			  WA_NotifyDepth,	TRUE,
			  WA_Title,		title,

                          TAG_END);

  printf("Window opened\n");
  
  return window;
}
Example #7
0
static void makewin(void)
{
    win = OpenWindowTags(0, WA_PubScreen	, (IPTR)scr,
                         WA_Left		, 10,
                         WA_Top		, 20,
                         WA_Width		, 200,
                         WA_Height		, 190,
                         WA_MinWidth		, 50,
                         WA_MinHeight	, 50,
                         WA_MaxWidth		, 4000,
                         WA_MaxHeight	, 4000,
                         WA_AutoAdjust	, TRUE,
                         WA_Title		, (IPTR)"ColorWheel",
                         WA_CloseGadget	, TRUE,
                         WA_DragBar		, TRUE,
                         WA_DepthGadget	, TRUE,
                         WA_SizeGadget	, TRUE,
                         WA_SizeBBottom	, TRUE,
                         WA_Activate		, TRUE,
                         WA_ReportMouse	, TRUE,
                         WA_IDCMP		, IDCMP_CLOSEWINDOW | IDCMP_IDCMPUPDATE,
                         WA_Gadgets		, (IPTR)gradgad,
                         TAG_DONE);

    if (!win) cleanup("Can't open window!");

}
Example #8
0
void openWindow(void) {
  int windowHeight;
  struct Screen *lockscreen;

  strcpy(NiKomReleaseStr, NIKRELEASE " (" __DATE__ " " __TIME__ ")");
  sprintf(windowTitle, "NiKom %s,  0 noder aktiva", NiKomReleaseStr);
  if(!(lockscreen = LockPubScreen(pubscreen[0] == '-' ? NULL : pubscreen))) {
    cleanup(EXIT_ERROR,"Kunde inte låsa angiven Public Screen\n");
  }
  windowHeight = lockscreen->WBorTop + lockscreen->Font->ta_YSize + 1;
  NiKWindow = (struct Window *)OpenWindowTags(NULL,
                                              WA_Left, xpos,
                                              WA_Top, ypos,
                                              WA_Width, 500,
                                              WA_Height, windowHeight,
                                              WA_IDCMP, IDCMP_CLOSEWINDOW,
                                              WA_Title, windowTitle,
                                              WA_SizeGadget, FALSE,
                                              WA_DragBar, TRUE,
                                              WA_DepthGadget, TRUE,
                                              WA_CloseGadget, TRUE,
                                              WA_NoCareRefresh, TRUE,
                                              WA_ScreenTitle, "NiKom Server",
                                              WA_AutoAdjust, TRUE,
                                              WA_PubScreen, lockscreen);
  UnlockPubScreen(NULL, lockscreen);
  if(NiKWindow == NULL) {
    cleanup(EXIT_ERROR, "Could not open window.");
  }
}
Example #9
0
struct Window *openwindow(struct Screen *screen, const char *title, LONG x, LONG y, LONG w, LONG h)
{

  struct Window *window;
  printf("Opening window, screen=%p\n", screen);
  
  window = OpenWindowTags(NULL,
			  WA_IDCMP, IDCMP_RAWKEY | IDCMP_CLOSEWINDOW | IDCMP_CHANGEWINDOW,
			  WA_Left,	x,
			  WA_Top,	y,
                          WA_Width, 	w,
                          WA_Height, 	h,
			  WA_CustomScreen, screen,
			  WA_Activate,		TRUE,
			  WA_DepthGadget, 	TRUE,
			  WA_CloseGadget,	TRUE,
			  WA_SmartRefresh,	TRUE,
			  WA_NotifyDepth,	TRUE,
			  WA_Title,		title,

                          TAG_END);

  printf("Window opened\n");
  
  return window;
}
Example #10
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);
    }
}
int OpenBlankerWindow( void )
{
	struct NewGadget	ng;
	struct Gadget	*g;
	UWORD		lc, tc;
	UWORD		wleft = BlankerLeft, wtop = BlankerTop, ww, wh;

	ComputeFont( BlankerWidth, BlankerHeight );

	ww = ComputeX( BlankerWidth );
	wh = ComputeY( BlankerHeight );

	if (( wleft + ww + OffX + Scr->WBorRight ) > Scr->Width ) wleft = Scr->Width - ww;
	if (( wtop + wh + OffY + Scr->WBorBottom ) > Scr->Height ) wtop = Scr->Height - wh;

	if ( ! ( BlankerFont = OpenDiskFont( Font )))
		return( 5L );

	if ( ! ( g = CreateContext( &BlankerGList )))
		return( 1L );

	for( lc = 0, tc = 0; lc < Blanker_CNT; lc++ ) {

		CopyMem((char * )&BlankerNGad[ lc ], (char * )&ng, (long)sizeof( struct NewGadget ));

		ng.ng_VisualInfo = VisualInfo;
		ng.ng_TextAttr   = Font;
		ng.ng_LeftEdge   = OffX + ComputeX( ng.ng_LeftEdge );
		ng.ng_TopEdge    = OffY + ComputeY( ng.ng_TopEdge );
		ng.ng_Width      = ComputeX( ng.ng_Width );
		ng.ng_Height     = ComputeY( ng.ng_Height);

		BlankerGadgets[ lc ] = g = CreateGadgetA((ULONG)BlankerGTypes[ lc ], g, &ng, ( struct TagItem * )&BlankerGTags[ tc ] );

		while( BlankerGTags[ tc ] ) tc += 2;
		tc++;

		if ( NOT g )
			return( 2L );
	}

	if ( ! ( BlankerWnd = OpenWindowTags( NULL,
				WA_Left,	wleft,
				WA_Top,		wtop,
				WA_Width,	ww + OffX + Scr->WBorRight,
				WA_Height,	wh + OffY + Scr->WBorBottom,
				WA_IDCMP,	BUTTONIDCMP|LISTVIEWIDCMP|IDCMP_MENUPICK|IDCMP_CLOSEWINDOW|IDCMP_VANILLAKEY|IDCMP_REFRESHWINDOW,
				WA_Flags,	WFLG_DRAGBAR|WFLG_DEPTHGADGET|WFLG_CLOSEGADGET|WFLG_SIZEBBOTTOM|WFLG_SMART_REFRESH|WFLG_ACTIVATE|WFLG_RMBTRAP,
				WA_Gadgets,	BlankerGList,
				WA_Title,	BlankerWdt,
				WA_ScreenTitle,	"Garshneblanker",
				WA_PubScreen,	Scr,
				TAG_DONE )))
	return( 4L );

	GT_RefreshWindow( BlankerWnd, NULL );

	return( 0L );
}
Example #12
0
int OpenBlockSelectWindow( void )
{
	struct NewGadget	ng;
	struct Gadget	*g;
	UWORD		lc, tc;
	UWORD		offx = Scr->WBorLeft, offy = Scr->WBorTop + Scr->RastPort.TxHeight + 1;

	if ( ! ( g = CreateContext( &BlockSelectGList ))){
		CloseBlockSelectWindow();
		return( 1L );
	}

	for( lc = 0, tc = 0; lc < BlockSelect_CNT; lc++ ) {

		CopyMem((char * )&BlockSelectNGad[ lc ], (char * )&ng, (long)sizeof( struct NewGadget ));

		ng.ng_VisualInfo = VisualInfo;
		ng.ng_TextAttr   = &topaz8;
		ng.ng_LeftEdge  += offx;
		ng.ng_TopEdge   += offy;

		BlockSelectGadgets[ lc ] = g = CreateGadgetA((ULONG)BlockSelectGTypes[ lc ], g, &ng, ( struct TagItem * )&BlockSelectGTags[ tc ] );

		while( BlockSelectGTags[ tc ] ) tc += 2;
		tc++;

		if ( NOT g ){
			CloseBlockSelectWindow();
			return( 2L );
		}
	}

	if ( ! ( BlockSelectWnd = OpenWindowTags( NULL,
				WA_Left,	BlockSelectLeft,
				WA_Top,		BlockSelectTop,
				WA_Width,	BlockSelectWidth,
				WA_Height,	BlockSelectHeight + offy,
				WA_IDCMP,	LISTVIEWIDCMP | BUTTONIDCMP | IDCMP_NEWSIZE | IDCMP_REFRESHWINDOW | IDCMP_RAWKEY,
				WA_Flags,	WFLG_SIZEGADGET|WFLG_DRAGBAR|WFLG_DEPTHGADGET|WFLG_SMART_REFRESH,
				WA_Gadgets,	BlockSelectGList,
				WA_Title,	BlockSelectWdt,
				WA_MinWidth,	160,
				WA_MinHeight,	60,
				WA_MaxWidth,	720,
				WA_MaxHeight,	467,
				WA_AutoAdjust,	TRUE,
				WA_PubScreen,Scr,
				TAG_DONE )))
	{
		CloseBlockSelectWindow();
		return( 4L );
	}

	GT_RefreshWindow( BlockSelectWnd, NULL );

	return( 0L );
}
Example #13
0
void ami_drag_icon_show(struct Window *win, const char *type)
{
    struct DiskObject *dobj = NULL;
    ULONG *icondata1;
    ULONG width, height;
    long format = 0;
    int err = 0;
    int deftype = WBPROJECT;

    drag_in_progress = TRUE;

    if(nsoption_bool(drag_save_icons) == false)
    {
        ami_update_pointer(win, AMI_GUI_POINTER_DRAG);
        return;
    }
    else
    {
        ami_update_pointer(win, GUI_POINTER_DEFAULT);
    }

    if(!strcmp(type, "drawer")) deftype = WBDRAWER;

    dobj = GetIconTags(NULL, ICONGETA_GetDefaultName, type,
                       ICONGETA_GetDefaultType, deftype,
                       TAG_DONE);

    err = IconControl(dobj,
                      ICONCTRLA_GetWidth,&width,
                      ICONCTRLA_GetHeight,&height,
                      TAG_DONE);

    drag_icon_width = width;
    drag_icon_height = height;

    drag_icon = OpenWindowTags(NULL,
                               WA_Left, scrn->MouseX - (width/2),
                               WA_Top, scrn->MouseY - (height/2),
                               WA_Width, width,
                               WA_Height, height,
                               WA_PubScreen, scrn,
                               WA_Borderless, TRUE,
                               WA_ToolBox, TRUE,
                               WA_StayTop, TRUE,
                               WA_Opaqueness, 128,
                               WA_OverrideOpaqueness, TRUE,
                               TAG_DONE);

    /* probably need layouticon and drawinfo stuff too */

    DrawIconState(drag_icon->RPort, dobj, NULL, 0, 0, IDS_NORMAL,
                  ICONDRAWA_Frameless, TRUE,
                  ICONDRAWA_Borderless, TRUE,
                  TAG_DONE);
}
Example #14
0
File: main.c Project: 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;
}
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;
}
Example #16
0
int vsid_ui_init(void)
{
    int i;

    vsid_window = (struct Window *)OpenWindowTags(NULL,
                                                  WA_Left, 20,
                                                  WA_Top, 20,
                                                  WA_Width, 400,
                                                  WA_Height, 200,
                                                  WA_Title, (ULONG)"VSID: The VICE SID player",
                                                  WA_DepthGadget, TRUE,
                                                  WA_CloseGadget, TRUE,
                                                  WA_SizeGadget, TRUE,
                                                  WA_DragBar, TRUE,
                                                  WA_IDCMP, IDCMP_CLOSEWINDOW | IDCMP_MENUPICK | IDCMP_MENUVERIFY,
                                                  TAG_END);
    if (vsid_window == NULL) {
        return -1;
    }

    ui_event_handling = vsid_event_handling;

    if (vsid_menu_create() != 0) {
        return -1;
    }

    for (i = 0; i < VSID_S_LASTLINE; i++) {
        vsidstrings[i][0] = 0;
        vsid_text[i].LeftEdge = 10;
        vsid_text[i].TopEdge = 25 + i * 10;
        vsid_text[i].IText = vsidstrings[i];
        vsid_text[i].ITextFont = &vsid_font_attr;
        vsid_text[i].DrawMode = JAM1;
        vsid_text[i].FrontPen = 1;
        vsid_text[i].NextText = NULL;
    }

    vsid_update_text();

    self = (APTR)FindTask(NULL);
    orig_windowptr = self->pr_WindowPtr;
    self->pr_WindowPtr = vsid_window;

    return mui_init();
}
Example #17
0
static void makewin(void)
{
    win = OpenWindowTags(NULL, WA_CustomScreen	, (IPTR)scr, 
    			       WA_InnerWidth	, SCREENWIDTH,
    			       WA_InnerHeight	, SCREENHEIGHT,
			       WA_Title		, (IPTR)"ReadPixelArray",
			       WA_DragBar	, TRUE,
			       WA_DepthGadget	, TRUE,
			       WA_CloseGadget	, TRUE,
			       WA_Activate	, TRUE,
			       WA_BackFill  	, (IPTR)LAYERS_NOBACKFILL,
			       WA_IDCMP		, IDCMP_CLOSEWINDOW |
			       			  IDCMP_RAWKEY,
			       TAG_DONE);
			       
   if (!win) cleanup("Can't open window");

   rp = win->RPort; 
}
Example #18
0
static void makewin(void)
{
    win = OpenWindowTags(NULL, WA_CustomScreen	, (IPTR)scr, 
    			       WA_InnerWidth	, SCREENWIDTH,
    			       WA_InnerHeight	, SCREENHEIGHT,
			       WA_Title		, (IPTR)"BltTemplateAlpha: Moving mouse is useless!",
			       WA_DragBar	, TRUE,
			       WA_DepthGadget	, TRUE,
			       WA_CloseGadget	, TRUE,
			       WA_Activate	, TRUE,
			       WA_IDCMP		, IDCMP_CLOSEWINDOW,
			       WA_BackFill  	, (IPTR) LAYERS_NOBACKFILL,
			       TAG_DONE);
			       
    if (!win) cleanup("Can't open window");

    rp = win->RPort; 

}
Example #19
0
static void MakeWin(void)
{
    win = OpenWindowTags(0,WA_Left,10,
			   WA_Top,20,
			   WA_Width,200,
			   WA_Height,200,
			   WA_Title,(IPTR)"Press key to flip color!",
			   WA_CloseGadget,TRUE,
			   WA_DepthGadget,TRUE,
			   WA_DragBar,TRUE,
			   WA_Activate,TRUE,
			   args[ARG_SIMPLE] ? WA_SimpleRefresh : TAG_IGNORE, TRUE,
			   WA_IDCMP,IDCMP_CLOSEWINDOW |
				    IDCMP_VANILLAKEY |
				    IDCMP_REFRESHWINDOW,
			   TAG_DONE);

    if (!win) Cleanup("Can't open window!");

    rp = win->RPort;
    lay = win->WLayer;
}
Example #20
0
int main (int argc, char **argv)
{
    UBYTE buffer[BUFSIZE];
    
    KeymapBase = OpenLibrary("keymap.library", 37);
    if (!KeymapBase)
        printf("Failed to open keymap.library v37\n");
    else
    {
        IntuitionBase = (struct IntuitionBase *)OpenLibrary("intuition.library", 37);
        if (!IntuitionBase)
            printf("Failed to open intuition.library v37\n");
        else
        {
            struct Window *win;
            
            win = OpenWindowTags(NULL,
                WA_Width,    200,
                WA_Height,    60,
                WA_Title,    (IPTR)"Maprawkey test (ESC to exit)",
                WA_Flags,    WFLG_ACTIVATE,
                WA_IDCMP,    IDCMP_RAWKEY,
                TAG_DONE);
                
            if (!win)
                printf("Could not open window\n");
            else
            {
                HandleEvents(win, buffer, BUFSIZE);
                
                CloseWindow(win);
            }
            CloseLibrary((struct Library *)IntuitionBase);
        }
        CloseLibrary(KeymapBase);
    }
    return (0);
}
Example #21
0
struct Window *openmywindow(char *screenname) {
    static char titel[32];
    sprintf(titel,"NiKom PreNode, nod #%d SER:",nodnr);
    return(OpenWindowTags(NULL,WA_Left,xpos,
                          WA_Top,ypos,
                          WA_Width,xsize,
                          WA_Height,ysize,
                          WA_IDCMP,IDCMP_CLOSEWINDOW,
                          WA_MinWidth,50,
                          WA_MinHeight,10,
                          WA_MaxWidth,~0,
                          WA_MaxHeight,~0,
                          WA_SizeGadget,TRUE,
                          WA_SizeBBottom, TRUE,
                          WA_DragBar,TRUE,
                          WA_DepthGadget,TRUE,
                          WA_CloseGadget,TRUE,
                          WA_SimpleRefresh,TRUE,
                          WA_Title,titel,
                          WA_ScreenTitle,"NiKom Prenode",
                          WA_AutoAdjust,TRUE,
                          WA_PubScreenName,screenname,
                          TAG_DONE));
}
Example #22
0
VOID OpenWindows (STRPTR name, ULONG count, ULONG repeat, struct Screen *scr)
{
//	struct BitMap **windows = new BitMap *[count];
	struct Window **windows = new Window *[count];
	struct TimeIt timer(name);
	for(ULONG i = 0; i < repeat; i++)
	{
		for(ULONG j = 0; j < count; j++)
//			windows[j] = MyAllocBitMap(rand() % scr->Width/2, rand() % scr->Height/2, GetBitMapAttr(scr->RastPort.BitMap, BMA_DEPTH), 0L, scr->RastPort.BitMap);
//			windows[j] = AllocBitMap(rand() % scr->Width/2, rand() % scr->Height/2, GetBitMapAttr(scr->RastPort.BitMap, BMA_DEPTH), 0L, scr->RastPort.BitMap);
//			windows[j] = (BitMap *)new UBYTE [RASSIZE(rand() % scr->Width/2, rand() % scr->Height/2) * GetBitMapAttr(scr->RastPort.BitMap, BMA_DEPTH)];
//			windows[j] = (BitMap *)AllocVec(RASSIZE(rand() % scr->Width/2, rand() % scr->Height/2) * GetBitMapAttr(scr->RastPort.BitMap, BMA_DEPTH), MEMF_ANY);
			windows[j] = OpenWindowTags(NULL, WA_PubScreen, scr, WA_SimpleRefresh, TRUE, WA_Left, rand() % scr->Width/2, WA_Top, rand() % scr->Height/2, WA_InnerWidth, rand() % scr->Width/2, WA_InnerHeight, rand() % scr->Height/2, TAG_DONE);

//		for(j = 0; j < count; j++)
		while(j--)
//			MyFreeBitMap(windows[j]);
//			FreeBitMap(windows[j]);
//			delete windows[j];
//			FreeVec(windows[j]);
			CloseWindow(windows[j]);
	}
	delete windows;
}
Example #23
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);
		}
	}
}
Example #24
0
  grArosSurface*  init_surface( grArosSurface*  surface,
                             grBitmap*    bitmap )
  {
    printf("init_surface: width = %d  height = %d\n",
    		bitmap->width,
		bitmap->rows);
    
    bitmap->width = (bitmap->width + 15) & ~15;
    surface->bpr = bitmap->width / 8;
    
    if (grNewBitmap(bitmap->mode,
    		    bitmap->grays,
		    bitmap->width,
		    bitmap->rows,
		    bitmap)) return 0;
		
    surface->win = OpenWindowTags(0, WA_Left, 20,
    				     WA_Top, 20,
				     WA_InnerWidth, bitmap->width,
				     WA_InnerHeight, bitmap->rows,
				     WA_AutoAdjust, TRUE,
				     WA_Title, "Freetype demo",
				     WA_CloseGadget, TRUE,
				     WA_DepthGadget, TRUE,
				     WA_Activate, TRUE,
				     WA_IDCMP, IDCMP_VANILLAKEY | IDCMP_RAWKEY,
				     TAG_DONE);

    if (!surface->win)
    {
      puts("Could not open window!");
      grDoneBitmap(bitmap);
      return 0;
    }					    

    puts("Window opened.");

    surface->grays = ( bitmap->mode == gr_pixel_mode_gray &&
                       bitmap->grays >= 2 );

    if (surface->grays)
    {
      WORD i;
      
      if (GetBitMapAttr(surface->win->RPort->BitMap, BMA_DEPTH <= 8))
      {
        puts("Need hi/true color screen!");
	CloseWindow(surface->win);
	grDoneBitmap(bitmap);
	return 0;
      }
      
      for(i = 0; i < bitmap->grays; i++)
      {
        LONG red, green, blue;
	
	red = green = blue = (bitmap->grays - i) * 255 / bitmap->grays;
	
        surface->cgfxcoltab[i] = (red << 16) | (green << 8) | blue;
      }
    }	          
    surface->root.bitmap       = *bitmap;
    surface->root.done         = (grDoneSurfaceFunc) done_surface;
    surface->root.refresh_rect = (grRefreshRectFunc) refresh_rectangle;
    surface->root.set_title    = (grSetTitleFunc)    set_title;
    surface->root.listen_event = (grListenEventFunc) listen_event;
    
    return surface;
  }
Example #25
0
static BOOL MakePopupWin(Object *obj, struct Numericbutton_DATA *data)
{
    const struct ZuneFrameGfx 	*zframe;
    struct RastPort 	    	*rp, *saverp;
    LONG    	    	    	 winx, winy, winw, winh;
    LONG    	    	    	 framew, frameh;
    LONG    	    	    	 min, max;

    zframe = zune_zframe_get_with_state(obj, &muiGlobalInfo(obj)->mgi_Prefs->frames[MUIV_Frame_Slider],
                                        muiGlobalInfo(obj)->mgi_Prefs->frames[MUIV_Frame_Slider].state);

    data->pop_innerx = zframe->ileft;
    data->pop_innery = zframe->itop;

    data->knob_width = data->max_text_width + 4;
    data->knob_height = data->text_height + 2;

    framew = data->pop_innerx + zframe->iright;
    frameh = data->pop_innery + zframe->ibottom;

    longget(obj, MUIA_Numeric_Min, &min);
    longget(obj, MUIA_Numeric_Max, &max);

    winw = max - min + data->knob_width + framew;
    winh = data->knob_height + frameh;

    if (winw > _screen(obj)->Width)
    {
        winw = _screen(obj)->Width;
    }

    if ((winw < data->knob_width + framew) || (winh > _screen(obj)->Height))
    {
        return FALSE;
    }

    data->pop_innerw = winw - framew;
    data->pop_innerh = winh - frameh;

    data->knob_left = DoMethod(obj, MUIM_Numeric_ValueToScale, 0, data->pop_innerw - data->knob_width);

    winx = _window(obj)->LeftEdge + _mleft(obj) -
           data->pop_innerx - 2 -
           data->knob_left;
    winy = _window(obj)->TopEdge + _mtop(obj) - 1-
           data->pop_innery;

    data->popwin = OpenWindowTags(NULL, WA_CustomScreen, (IPTR)_screen(obj),
                                  WA_Left, winx,
                                  WA_Top, winy,
                                  WA_Width, winw,
                                  WA_Height, winh,
                                  WA_AutoAdjust, TRUE,
                                  WA_Borderless, TRUE,
                                  WA_Activate, FALSE,
                                  WA_BackFill, (IPTR)LAYERS_NOBACKFILL,
                                  TAG_DONE);

    if (!data->popwin)
    {
        return FALSE;
    }

    rp = data->popwin->RPort;

    saverp = _rp(obj);
    _rp(obj) = rp;
    zframe->draw(zframe->customframe, muiRenderInfo(obj), 0, 0, winw, winh, 0, 0, winw, winh);

    DrawKnob(obj, data, TRUE);


    _rp(obj) = saverp;

    return TRUE;

}
Example #26
0
LONG Blank( PrefObject *Prefs )
{
	LONG delay_rate, i, j, counter = 0, RetVal = OK;
	struct RastPort *Rast;
	struct Screen *FTScr;
	struct Window *FTWin;
	struct Window *Wnd;
	
	NumToasters = Prefs[OBJECTS].po_Level;
	delay_rate = 11 - Prefs[SPEED].po_Level;
	
	Toasters = AllocVec( sizeof( Toaster ) * NumToasters, MEMF_CLEAR );
	FTScr = OpenScreenTags( NULL, SA_DisplayID, Prefs[MODE].po_ModeID,
						   SA_Depth, 4, SA_Overscan, OSCAN_STANDARD,
						   SA_Type, CUSTOMSCREEN, SA_Quiet, TRUE,
						   SA_Behind, TRUE, TAG_DONE );
	if( Toasters && FTScr )
	{
		for( i = 0; i < 48; i += 3 )
			if( GfxBase->lib_Version < 39 )
				SetRGB4(&( FTScr->ViewPort ), i/3, ( cmap[i] * 16 ) / 256,
						( cmap[i+1] * 16 ) / 256, ( cmap[i+2] * 16 ) / 256 );
			else
				SetRGB32(&( FTScr->ViewPort ), i/3, cmap[i]<<24, cmap[i+1]<<24,
						 cmap[i+2]<<24 );
		FTWin = OpenWindowTags( 0L, WA_Width, FTScr->Width, WA_Height,
							   FTScr->Height, WA_IDCMP, 0L, WA_Flags,
							   WFLG_SIMPLE_REFRESH|WFLG_BORDERLESS,
							   WA_CustomScreen, FTScr, TAG_DONE );
		if( FTWin )
		{
			Rast = FTWin->RPort;
			SetAPen( Rast, 0 );
			
			for( i = 0; i < NumToasters; i++ )
				if( !FindLaunchPos( i, ( LONG )FTWin->Width,
								   ( LONG )FTWin->Height ))
					Toasters[i].delay = 30;
			
			Wnd = BlankMousePointer( FTScr );
			ScreenToFront( FTScr );
			
			while( RetVal == OK )
			{
				WaitTOF();
				
				if(!( ++counter % 60 ))
					ScreenToFront( FTScr );
				
				if(!( counter % delay_rate ))
				{
					for( i = 0; i < NumToasters; i++ )
					{
						if( !Toasters[i].delay )
						{
							Toasters[i].old_x = Toasters[i].x;
							Toasters[i].old_y = Toasters[i].y;
							Toasters[i].x -= Toasters[i].xspeed;
							Toasters[i].y += Toasters[i].yspeed;
							Toasters[i].xcol = -1;
							Toasters[i].ycol = -1;
						}
					}

					for( i = 0; i < NumToasters; i++ )
					{
						if( !Toasters[i].delay )
						{
							j = -1;
							while(( j = TestExtent( j+1, i, Toasters[i].x,
												   Toasters[i].y )) >= 0 )
							{
								if( abs( Toasters[j].old_x -
										Toasters[i].old_x ) < IM_WIDBUF )
								{
									if( Toasters[i].y < Toasters[j].y )
										Toasters[i].ycol = j;
									if( Toasters[i].xspeed ==
									   Toasters[j].xspeed )
										Toasters[i].xspeed++;
								}
								else
								{
									if( Toasters[i].x > Toasters[j].x )
										Toasters[i].xcol = j;
									if( Toasters[i].yspeed ==
									   Toasters[j].yspeed )
										Toasters[i].yspeed++;
								}
								if( abs( Toasters[j].old_y -
										Toasters[i].old_y ) < IM_HEIBUF )
								{
									if( Toasters[i].x > Toasters[j].x )
										Toasters[i].xcol = j;
									if( Toasters[i].yspeed ==
									   Toasters[j].yspeed )
										Toasters[i].yspeed++;
								}
							}
						}
					}

					for( i = 0; i < NumToasters; i++ )
					{
						if( !Toasters[i].delay )
						{
							Toasters[i].x = Toasters[i].old_x - ActXSpeed( i );
							Toasters[i].y = Toasters[i].old_y + ActYSpeed( i );
						}
					}
					
					for( i = 0; i < NumToasters; i++ )
					{
						if( !Toasters[i].delay )
						{
							j = -1;
							while(( j = TestExtent( j+1, i, Toasters[i].x,
												   Toasters[i].y )) >= 0 )
							{
								if( abs( Toasters[j].old_x -
										Toasters[i].old_x ) < IM_WIDBUF )
									if( Toasters[i].x > Toasters[j].x )
										Toasters[i].x = Toasters[i].old_x;
								else
									if( Toasters[i].y < Toasters[j].y )
										Toasters[i].y = Toasters[i].old_y;
								if( abs( Toasters[j].old_y -
										Toasters[i].old_y ) < IM_HEIBUF )
									if( Toasters[i].y < Toasters[j].y )
										Toasters[i].y = Toasters[i].old_y;
							}
						}
					}

					for( i = 0; i < NumToasters; i++ )
					{
						if( !Toasters[i].delay )
						{
							Toasters[i].phase =
								( Toasters[i].phase + 1 ) % IMAGEMAX;
							EraseRect( Rast, Toasters[i].x + IM_WIDTH,
									  Toasters[i].old_y, Toasters[i].x +
									  IM_WIDTH + Toasters[i].xspeed,
									  Toasters[i].old_y + IM_HEIGHT );
							EraseRect( Rast, Toasters[i].old_x,
									  Toasters[i].old_y,
									  Toasters[i].old_x + IM_WIDTH,
									  Toasters[i].old_y + Toasters[i].yspeed );
							DrawImage( Rast, img[Toasters[i].phase],
									  Toasters[i].x, Toasters[i].y );
							if(( Toasters[i].x < -IM_WIDTH-1 )||
							   ( Toasters[i].y > FTWin->Height ))
								Toasters[i].delay = RangeRand( 50 );
						}
						else
							if(!( --Toasters[i].delay ))
								Toasters[i].delay =
									FindLaunchPos( i, ( LONG )FTWin->Width,
												  ( LONG )FTWin->Height )
										? 0 : 30;
					}
				}
				RetVal = ContinueBlanking();
			}

			SetSignal( 0L, SIGBREAKF_CTRL_C );
			UnblankMousePointer( Wnd );
			CloseWindow( FTWin );
		}
		else
			RetVal = FAILED;
		CloseScreen( FTScr );
	}
	else
		RetVal = FAILED;
	
	FreeVec( Toasters );

	return RetVal;
}
Example #27
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);
}
Example #28
0
int main(int argc, char **argv)
{
	ULONG DisplayID,Depth;
	struct Screen *CyberScreen;
	struct Window *WriteWindow;
	LONG done;
	struct IntuiMessage *IntMsg;
	IMAGE image;
	LONG src_x,src_y, old_src_x,old_src_y;
	ULONG argarray[2];
	struct RDArgs *rdargs;
	char *file;

	rdargs = ReadArgs((STRPTR)arg_template, (LONG*)argarray, NULL);
	if(!rdargs)
		return 20;

	file = (char*)argarray[0];

	IntuitionBase = (struct IntuitionBase *)OpenLibrary("intuition.library",39L);
	if(!IntuitionBase)
		return 20;

	CyberGfxBase = OpenLibrary(CYBERGFXNAME,CYBERGFXVERSION);
	if(!CyberGfxBase)
	{
		ErrorF ("Can't open \"%s\" version %ld or newer.",
			CYBERGFXNAME,CYBERGFXVERSION);
		CloseLibrary (&IntuitionBase->LibNode);
		return 10;
	}

	if(!Load(file, &image))
	{
		ErrorF ("Can't load image.");
		FreeArgs(rdargs);
		CloseLibrary (CyberGfxBase);
		CloseLibrary (&IntuitionBase->LibNode);
		return 10;
	}

	/* Let CyberGraphX search a display mode for us! */

	if(argarray[1])
		Depth = 16;
	else
		Depth = 24;

	FreeArgs(rdargs);

	while (Depth)
	{
		DisplayID = BestCModeIDTags(CYBRBIDTG_NominalWidth, image.width,
			CYBRBIDTG_NominalHeight, image.height,
			CYBRBIDTG_Depth, Depth,
			TAG_DONE);
		if(DisplayID != INVALID_ID)
		{
			/* Because older version of the "cybergraphics.library" don't handle */
			/* CYBRBIDTG_Depth properly we query the real depth of the mode.     */
			Depth = GetCyberIDAttr(CYBRIDATTR_DEPTH,DisplayID);
			break;
		}
		/* retry with less bits per pixel */
		Depth = NextDepth(Depth);
	}

	if (Depth < SCREEN_MIN_DEPTH)
	{
		ErrorF ("Can't find suitable display mode for %ldx%ldx.",
			image.width, image.height);
		CloseLibrary (CyberGfxBase);
		CloseLibrary (&IntuitionBase->LibNode);
		Cleanup(&image);
		return 5;
	}

	/* open screen, but let Intuition choose the actual dimensions */

	CyberScreen = OpenScreenTags(
		NULL,
		SA_Title,"RayStorm Image Viewer (C) 1998 Andreas Heumann",
		SA_DisplayID,DisplayID,
		SA_Depth,Depth,
		TAG_DONE);
	if(!CyberScreen)
	{
		ErrorF ("Can't open screen.");
		CloseLibrary (CyberGfxBase);
		CloseLibrary (&IntuitionBase->LibNode);
		Cleanup(&image);
		return 5;
	}

	/* create Write window */

	WriteWindow = OpenWindowTags(
		NULL,
		WA_Title,"Viewer",
		WA_Flags,
			WFLG_ACTIVATE|WFLG_SIMPLE_REFRESH|WFLG_RMBTRAP,
		WA_IDCMP,
			IDCMP_REFRESHWINDOW|IDCMP_VANILLAKEY|IDCMP_RAWKEY|IDCMP_MOUSEBUTTONS,
		WA_Borderless, TRUE,
		WA_Left, 0,
		WA_Top, 0,
		WA_Width, image.width,
		WA_Height, image.height,
		WA_CustomScreen,CyberScreen,
		TAG_DONE);
	if(!WriteWindow)
	{
		ErrorF ("Can't open write window.");
		CloseScreen (CyberScreen);
		CloseLibrary (CyberGfxBase);
		CloseLibrary (&IntuitionBase->LibNode);
		Cleanup(&image);
		return 5;
	}

	src_x = 0;
	src_y = 0;
	WritePixelArray(
		image.colormap,
		src_x, src_y,
		image.width*sizeof(SMALL_COLOR),
		WriteWindow->RPort,
		0, 0,
		image.width,
		image.height,
		RECTFMT_RGBA);

	/* event loop */

	done = FALSE;
	while (!done)
	{
		(void)Wait(SIGMASK(WriteWindow));

		while (IntMsg=GETIMSG(WriteWindow))
		{
			switch (IntMsg->Class)
			{
				case IDCMP_REFRESHWINDOW:
					BeginRefresh(WriteWindow);
					WritePixelArray(
						image.colormap,
						src_x, src_y,
						image.width*sizeof(SMALL_COLOR),
						WriteWindow->RPort,
						0, 0,
						image.width,
						image.height,
						RECTFMT_RGBA);
					EndRefresh(WriteWindow,TRUE);
					break;
				case IDCMP_VANILLAKEY:
					switch(IntMsg->Qualifier & 0x7fff)
					{
						case 0:
							switch (IntMsg->Code)
							{
								case 27:
									done = TRUE;
									break;
							}
							break;
					}
					break;
				case IDCMP_RAWKEY:
					old_src_x = src_x;
					old_src_y = src_y;
					switch(IntMsg->Code)
					{
						case CURSORRIGHT:
							if(src_x + WriteWindow->Width + WriteWindow->LeftEdge < image.width)
							{
								src_x += 8;
								if(src_x + WriteWindow->Width + WriteWindow->LeftEdge > image.width)
									src_x = image.width - WriteWindow->Width - WriteWindow->LeftEdge;
							}
							break;
						case CURSORLEFT:
							if(src_x > 0)
							{
								src_x -= 8;
								if(src_x < 0)
									src_x = 0;
							}
							break;
						case CURSORDOWN:
							if(src_y + WriteWindow->Height + WriteWindow->TopEdge < image.height)
							{
								src_y += 8;
								if(src_y + WriteWindow->Height + WriteWindow->TopEdge > image.height)
									src_y = image.height - WriteWindow->Height - WriteWindow->TopEdge;
							}
							break;
						case CURSORUP:
							if(src_y > 0)
							{
								src_y -= 8;
								if(src_y < 0)
									src_y = 0;
							}
							break;
					}
					if((old_src_x != src_x) || (old_src_y != src_y))
					{
						if(old_src_x < src_x)
						{
							ClipBlit(
								WriteWindow->RPort,
								src_x - old_src_x,
								0,
								WriteWindow->RPort,
								0,
								0,
								WriteWindow->Width + WriteWindow->LeftEdge - (src_x - old_src_x),
								WriteWindow->Height + WriteWindow->TopEdge,
								0xc0);
							WritePixelArray(
								image.colormap,
								old_src_x + WriteWindow->Width + WriteWindow->LeftEdge,
								src_y,
								image.width*sizeof(SMALL_COLOR),
								WriteWindow->RPort,
								WriteWindow->Width + WriteWindow->LeftEdge - (src_x - old_src_x),
								0,
								src_x - old_src_x,
								WriteWindow->Height + WriteWindow->TopEdge,
								RECTFMT_RGBA);
						}
						else if(old_src_x > src_x)
						{
							ClipBlit(
								WriteWindow->RPort,
								0,
								0,
								WriteWindow->RPort,
								old_src_x - src_x,
								0,
								WriteWindow->Width + WriteWindow->LeftEdge - (old_src_x - src_x),
								WriteWindow->Height + WriteWindow->TopEdge,
								0xc0);
							WritePixelArray(
								image.colormap,
								src_x,
								src_y,
								image.width*sizeof(SMALL_COLOR),
								WriteWindow->RPort,
								0,
								0,
								old_src_x - src_x,
								WriteWindow->Height + WriteWindow->TopEdge,
								RECTFMT_RGBA);
						}
						else if(old_src_y < src_y)
						{
							ClipBlit(
								WriteWindow->RPort,
								0,
								src_y - old_src_y,
								WriteWindow->RPort,
								0,
								0,
								WriteWindow->Width + WriteWindow->LeftEdge,
								WriteWindow->Height + WriteWindow->TopEdge - (src_y - old_src_y),
								0xc0);
							WritePixelArray(
								image.colormap,
								src_x,
								old_src_y + WriteWindow->Height + WriteWindow->TopEdge,
								image.width*sizeof(SMALL_COLOR),
								WriteWindow->RPort,
								0,
								WriteWindow->Height + WriteWindow->TopEdge - (src_y - old_src_y),
								WriteWindow->Width + WriteWindow->LeftEdge,
								src_y - old_src_y,
								RECTFMT_RGBA);
						}
						else if(old_src_y > src_y)
						{
							ClipBlit(
								WriteWindow->RPort,
								0,
								0,
								WriteWindow->RPort,
								0,
								old_src_y - src_y,
								WriteWindow->Width + WriteWindow->LeftEdge,
								WriteWindow->Height + WriteWindow->TopEdge - (old_src_y - src_y),
								0xc0);
							WritePixelArray(
								image.colormap,
								src_x,
								src_y,
								image.width*sizeof(SMALL_COLOR),
								WriteWindow->RPort,
								0,
								0,
								WriteWindow->Width + WriteWindow->LeftEdge,
								old_src_y - src_y,
								RECTFMT_RGBA);
						}
					}
					break;
				case IDCMP_MOUSEBUTTONS:
					done = TRUE;
					break;
			}

			ReplyMsg (&IntMsg->ExecMessage);
		}
	}

	/* cleanup */

	CloseWindow(WriteWindow);
	CloseScreen(CyberScreen);
	CloseLibrary(CyberGfxBase);
	CloseLibrary(&IntuitionBase->LibNode);
	Cleanup(&image);

	return 0;
}
void *Sys_Video_Open(const char *mode, unsigned int width, unsigned int height, int fullscreen, unsigned char *palette)
{
	struct display *d;
	struct modeinfo modeinfo;
	char monitorname[128];
	int r;
	int i;

	d = AllocVec(sizeof(*d), MEMF_CLEAR);
	if (d)
	{
		MesaBase = OpenLibrary("mesa.library", 0);
		if (MesaBase)
		{
			if (fullscreen)
			{
				if (*mode && modeline_to_modeinfo(mode, &modeinfo))
				{
					snprintf(monitorname, sizeof(monitorname), "%s.monitor", modeinfo.monitorname);
					d->screen = OpenScreenTags(0,
						SA_Width, modeinfo.width,
						SA_Height, modeinfo.height,
						SA_Depth, modeinfo.depth,
#if 0
						SA_MonitorName, monitorname,
#endif
						SA_Quiet, TRUE,
						TAG_DONE);
				}
				else
				{
					d->screen = OpenScreenTags(0,
						SA_Quiet, TRUE,
						TAG_DONE);
				}

				if (d->screen)
				{
					width = d->screen->Width;
					height = d->screen->Height;

					snprintf(d->used_mode, sizeof(d->used_mode), "Dunno,%d,%d,42", width, height);
				}
				else
					fullscreen = 0;
			}

			if (d->screen || !fullscreen)
			{
				d->window = OpenWindowTags(0,
					d->screen?WA_Width:WA_InnerWidth, width,
					d->screen?WA_Height:WA_InnerHeight, height,
					WA_Title, "Fodquake",
					WA_DragBar, d->screen?FALSE:TRUE,
					WA_DepthGadget, d->screen?FALSE:TRUE,
					WA_Borderless, d->screen?TRUE:FALSE,
					WA_RMBTrap, TRUE,
					d->screen?WA_CustomScreen:TAG_IGNORE, (IPTR)d->screen,
					WA_Activate, TRUE,
					TAG_DONE);

				if (d->window)
				{
					d->mesacontext = AROSMesaCreateContextTags(
						AMA_Window, d->window,
						AMA_Left, d->screen?0:d->window->BorderLeft,
						AMA_Top, d->screen?0:d->window->BorderTop,
						AMA_Width, width,
						AMA_Height, height,
						AMA_NoStencil, TRUE,
						AMA_NoAccum, TRUE,
						TAG_DONE);

					if (d->mesacontext)
					{
						AROSMesaMakeCurrent(d->mesacontext);
						
						d->pointermem = AllocVec(256, MEMF_ANY|MEMF_CLEAR);
						if (d->pointermem)
						{
							SetPointer(d->window, d->pointermem, 16, 16, 0, 0);

							d->width = width;
							d->height = height;
							d->fullscreen = fullscreen;

							d->inputdata = Sys_Input_Init(d->screen, d->window);
							if (d->inputdata)
							{
								return d;
							}

							FreeVec(d->pointermem);
						}

						AROSMesaMakeCurrent(0);
						AROSMesaDestroyContext(d->mesacontext);
					}

					CloseWindow(d->window);
				}

				if (d->screen)
					CloseScreen(d->screen);
			}

			CloseLibrary(MesaBase);
		}

		FreeVec(d);
	}

	return 0;
}
Example #30
0
struct Window *initWindow(void)
{
  struct Window *win;

  gad[0] = CreateContext(&glist);

  ng.ng_LeftEdge = 8;
  ng.ng_TopEdge = fontheight+7;
  ng.ng_Width = 192;
  ng.ng_Height = 11*fontheight+4;
  ng.ng_VisualInfo = vi;
  ng.ng_TextAttr = scr->Font;
  ng.ng_GadgetText = NULL;
  ng.ng_UserData = NULL;
  ng.ng_GadgetID = 1;
  lvgad[0] = CreateGadget(LISTVIEW_KIND,gad[0],&ng,GTLV_Labels,&list[0],TAG_END);

  ng.ng_LeftEdge = 206;
  ng.ng_Width = 186;
  ng.ng_GadgetText = NULL;
  ng.ng_GadgetID++;
  lvgad[1] = CreateGadget(LISTVIEW_KIND,lvgad[0],&ng,GTLV_Labels,&list[1],TAG_END);

  ng.ng_TopEdge += ng.ng_Height+3;
  ng.ng_LeftEdge = 8;
  ng.ng_Height = fontheight+4;
  ng.ng_Width = TLn("New")+16;
  ng.ng_Flags = PLACETEXT_IN;
  ng.ng_GadgetText = "New";
  ng.ng_GadgetID++;
  gad[0] = CreateGadget(BUTTON_KIND,lvgad[1],&ng,GA_Immediate,TRUE,TAG_END);

  ng.ng_LeftEdge += ng.ng_Width+6;
  ng.ng_Width = TLn("Copy")+16;
  ng.ng_GadgetText = "Copy";
  ng.ng_GadgetID++;
  gad[1] = CreateGadget(BUTTON_KIND,gad[0],&ng,TAG_END);

  ng.ng_LeftEdge += ng.ng_Width+6;
  ng.ng_Width = TLn("Delete")+16;
  ng.ng_GadgetText = "Delete";
  ng.ng_GadgetID++;
  gad[2] = CreateGadget(BUTTON_KIND,gad[1],&ng,TAG_END);

  if ((win = OpenWindowTags(NULL,WA_Title,   "gtdrag - Test",
                                WA_Flags,   WFLG_CLOSEGADGET | WFLG_DRAGBAR | WFLG_DEPTHGADGET | WFLG_ACTIVATE,
                                WA_IDCMP,   IDCMP_CLOSEWINDOW | DRAGIDCMP,
                                WA_Width,   400,
                                WA_Height,  fontheight*13+23,
                                WA_Gadgets, glist,
                                TAG_END)) != 0)
  {
    GT_RefreshWindow(win,NULL);
    GTD_AddGadget(LISTVIEW_KIND,lvgad[0],win,GTDA_InternalType, 1,
                                             GTDA_NoPosition,   TRUE,
                                             GTDA_Type,         ODT_NODE,
                                             TAG_END);
    GTD_AddGadget(LISTVIEW_KIND,lvgad[1],win,GTDA_InternalType,1,
                                             GTDA_Same,        TRUE,
                                             GTDA_Type,        ODT_NODE,
                                             TAG_END);
    GTD_AddGadget(BUTTON_KIND,gad[0],win,GTDA_Object,      &in,
                                         GTDA_Image,       in.in_Image,
                                         GTDA_InternalType,2,
                                         GTDA_AcceptTypes, 0,
                                         GTDA_Width,       newImg.Width,
                                         GTDA_Height,      newImg.Height,
                                         TAG_END);
    GTD_AddGadget(BUTTON_KIND,gad[1],win,GTDA_AcceptTypes,1,TAG_END);
    GTD_AddGadget(BUTTON_KIND,gad[2],win,GTDA_AcceptTypes,1,TAG_END);
    GTD_AddWindow(win,TAG_END);
    return(win);
  }
  return(NULL);
}