*** empty log message ***
authorSam Lantinga <slouken@libsdl.org>
Mon, 11 Mar 2002 17:38:56 +0000
changeset 309 2de77f7b7a28
parent 308 ee32ed29a507
child 310 c97c1d3b3b5c
*** empty log message ***
README.QNX
src/video/photon/SDL_ph_modes.c
src/video/photon/SDL_ph_video.c
src/video/photon/SDL_ph_video.h
--- a/README.QNX	Sun Mar 10 03:55:45 2002 +0000
+++ b/README.QNX	Mon Mar 11 17:38:56 2002 +0000
@@ -1,16 +1,19 @@
 README by Mike Gorchak <mike@malva.ua>
 
-    OpenGL support was experimentally added in window mode (in
-fullscreen mode not yet). If you have QNX RtP v6.1.0 w/ or w/o
-Patch A you must download new Photon3D runtime from http://de-
-velopers.qnx.com. The versions of OS before 6.1.0 are not sup-
-ported.
+    OpenGL in window mode  works well  and  stable, in fullscreen
+mode too, but fullscreen mode has not been heavily tested.
+    If you have QNX RtP 6.1.0 w/ or w/o Patch A you must download
+new Photon3D runtime from http://developers.qnx.com. The versions
+of OS before 6.1.0 are not supported.
 
 Problems:
-1. Fullscreen mode (in OpenGL mode) has not been  written yet.
-2. Photon has some errors in detecting  how much bits  per pi-
-   xel videomode has.
-3. No  shared  libraries  yet. We  need  manually  set flag to
+1. While creating OpenGL context artificially  selected  software
+   renderer mode (QSSL made acceleration only for  Voodoo  boards
+   in fullscreen mode, sorry but I don't have this board, if  you
+   want acceleration - you may remove some line in source).
+2. Photon has some errors in detecting  how  much bits  per pixel
+   videomode has.
+3. No  shared  libraries  yet.  We  need  manually  set  flag  to
    'configure' --disable-shared.
 
 Some building issues:
--- a/src/video/photon/SDL_ph_modes.c	Sun Mar 10 03:55:45 2002 +0000
+++ b/src/video/photon/SDL_ph_modes.c	Mon Mar 11 17:38:56 2002 +0000
@@ -155,54 +155,52 @@
 
 SDL_Rect **ph_ListModes(_THIS, SDL_PixelFormat *format, Uint32 flags)
 {
-	int i = 0;
-	int j = 0;
-	SDL_Rect Amodelist[PH_MAX_VIDEOMODES];
+    int i = 0;
+    int j = 0;
+    SDL_Rect Amodelist[PH_MAX_VIDEOMODES];
 
-        for (i=0; i<PH_MAX_VIDEOMODES; i++)
-        {
-           SDL_modearray[i]=&SDL_modelist[i];
-        }
+    for (i=0; i<PH_MAX_VIDEOMODES; i++)
+    {
+        SDL_modearray[i]=&SDL_modelist[i];
+    }
 
-	if (PgGetVideoModeList( &mode_list ) < 0)
-	{
-	   fprintf(stderr,"error: PgGetVideoModeList failed\n");
-	   return NULL;
-	}
+    if (PgGetVideoModeList( &mode_list ) < 0)
+    {
+       fprintf(stderr,"error: PgGetVideoModeList failed\n");
+       return NULL;
+    }
 
-	mode_info.bits_per_pixel = 0;
+    mode_info.bits_per_pixel = 0;
 
-	for (i=0; i < mode_list.num_modes; i++) 
-	{
-            if (PgGetVideoModeInfo(mode_list.modes[i], &mode_info) < 0)
-            {
-                fprintf(stderr,"error: PgGetVideoModeInfo failed on mode: 0x%x\n",
-                        mode_list.modes[i]);
-                return NULL;
-            }
+    for (i=0; i < mode_list.num_modes; i++) 
+    {
+        if (PgGetVideoModeInfo(mode_list.modes[i], &mode_info) < 0)
+        {
+            fprintf(stderr,"error: PgGetVideoModeInfo failed on mode: 0x%x\n", mode_list.modes[i]);
+            return NULL;
+        }
+        if(mode_info.bits_per_pixel == format->BitsPerPixel)
+        {
+            Amodelist[j].w = mode_info.width;
+            Amodelist[j].h = mode_info.height;
+            Amodelist[j].x = 0;
+            Amodelist[j].y = 0;
+            j++;	
+        }
+    }
+	
+    /* reorder biggest for smallest, assume width dominates */
 
-            if(mode_info.bits_per_pixel == format->BitsPerPixel)
-            {
-		Amodelist[j].w = mode_info.width;
-		Amodelist[j].h = mode_info.height;
-		Amodelist[j].x = 0;
-		Amodelist[j].y = 0;
-		j++;	
-            }
-	}
+    for(i=0; i<j; i++)
+    {
+        SDL_modelist[i].w = Amodelist[j - i -1].w;
+        SDL_modelist[i].h = Amodelist[j - i -1].h;
+        SDL_modelist[i].x = Amodelist[j - i -1].x;
+        SDL_modelist[i].y = Amodelist[j - i -1].y;
+    }
+    SDL_modearray[j]=NULL;
 	
-	//reorder biggest for smallest, assume width dominates
-
-	for(i=0; i< j ; i++)
-	{
-	    SDL_modelist[i].w = Amodelist[j - i -1].w;
-	    SDL_modelist[i].h = Amodelist[j - i -1].h;
-	    SDL_modelist[i].x = Amodelist[j - i -1].x;
-	    SDL_modelist[i].y = Amodelist[j - i -1].y;
-	}
-        SDL_modearray[j]=NULL;
-	
-	return SDL_modearray;
+    return SDL_modearray;
 }
 
 void ph_FreeVideoModes(_THIS)
@@ -281,82 +279,53 @@
     }
 }
 
-/*
-static void get_real_resolution(_THIS, int* w, int* h)
-{
-
-    if ( use_vidmode ) {
-        //PgDisplaySettings_t settings;
-	    PgVideoModeInfo_t		current_mode_info;
-	    	PgHWCaps_t my_hwcaps;
-//        int unused;
-		
-//        if (PgGetVideoMode( &settings ) >= 0) {
-//			*w = settings.xres;
-//			*h = settings.yres;
-//            return;
-//        }
-            if (PgGetGraphicsHWCaps(&my_hwcaps) >= 0)
-         	{
-                 if (PgGetVideoModeInfo(my_hwcaps.current_video_mode, &current_mode_info) < 0)
-           		 {
-                fprintf(stderr,"get_real_resolution:  PgGetVideoModeInfo failed\n");
-            		 }
-				*w = current_mode_info.width;
-				*h = current_mode_info.height;            
-            }
-    }
-//    *w = DisplayWidth(SDL_Display, SDL_Screen);
-//    *h = DisplayHeight(SDL_Display, SDL_Screen);
-}
-*/
-
 int ph_ResizeFullScreen(_THIS)
 {
-
-    if ( currently_fullscreen ) {
+    if (currently_fullscreen) {
         set_best_resolution(this, current_w, current_h);
     }
-    return(1);
+    return (1);
 }
 
+/* return the mode associated with width, height and bpp */
+/* if there is no mode then zero is returned             */
 int get_mode(int width, int height, int bpp)
-/* return the mode associated with width, height and bpp */
-/* if there is no mode then zero is returned */
 {
-	int i;
-
+    int i;
 
-if(width <640)
-   width = 640;
-if(height < 480)
-  height = 480;
-
-
-	if (PgGetVideoModeList( &mode_list ) < 0)
-	{
-	    fprintf(stderr,"error: PgGetVideoModeList failed\n");
-    	return -1;
-	}
+    if(width<640)
+    {
+        width=640;
+    }
+    if(height<480)
+    {
+        height=480;
+    }
 
-	// search list for exact match
-	for (i=0;i<mode_list.num_modes;i++)
-	{
-		if (PgGetVideoModeInfo(mode_list.modes[i], &mode_info) < 0)
-		{
-			fprintf(stderr,"error: PgGetVideoModeInfo failed\n");
-			return 0;
-		}
-		
-		
-		if ((mode_info.width == width) && 
-			(mode_info.height == height) && 
-			(mode_info.bits_per_pixel == bpp))
-			{
-			return mode_list.modes[i];
-			}
-	}
-	return (i == mode_list.num_modes) ? 0 : mode_list.modes[i];
+    if (PgGetVideoModeList(&mode_list) < 0)
+    {
+        fprintf(stderr,"error: PgGetVideoModeList failed\n");
+        return -1;
+    }
+
+    /* search list for exact match */
+    for (i=0;i<mode_list.num_modes;i++)
+    {
+        if (PgGetVideoModeInfo(mode_list.modes[i], &mode_info) < 0)
+        {
+            fprintf(stderr,"error: PgGetVideoModeInfo failed\n");
+            return 0;
+        }
+
+        if ((mode_info.width == width) && 
+            (mode_info.height == height) && 
+            (mode_info.bits_per_pixel == bpp))
+        {
+            return mode_list.modes[i];
+        }
+    }
+
+    return (i == mode_list.num_modes) ? 0 : mode_list.modes[i];
 }
 
 int get_mode_any_format(int width, int height, int bpp)
@@ -421,7 +390,7 @@
 		return mode_list.modes[ closest ];
 	}
 	else
-		return 0;
+    return 0;
 }
 
 void ph_WaitMapped(_THIS);
@@ -430,78 +399,88 @@
 
 int ph_ToggleFullScreen(_THIS, int on)
 {
-
-   if(currently_fullscreen)
-        ph_LeaveFullScreen(this);
-   else
-        ph_EnterFullScreen(this);
+    if (currently_fullscreen)
+    {
+        return ph_LeaveFullScreen(this);
+    }
+    else
+    {
+        return ph_EnterFullScreen(this);
+    }
       
-   return 0;     
-
+    return 0;     
 }
 
 int ph_EnterFullScreen(_THIS)
 {
-	if ( ! currently_fullscreen ) 
-	{
-
-		if (old_video_mode==-1)
-		{
-			PgGetGraphicsHWCaps(&graphics_card_caps);
-			old_video_mode=graphics_card_caps.current_video_mode;
-			old_refresh_rate=graphics_card_caps.current_rrate;
-		}
-
+    if (!currently_fullscreen)
+    {
+        if ((this->screen->flags & SDL_OPENGL)==SDL_OPENGL)
+        {
+#ifdef HAVE_OPENGL
+#endif /* HAVE_OPENGL */
+           return 0;
+        }
+        else
+        {
+            if (old_video_mode==-1)
+            {
+                PgGetGraphicsHWCaps(&graphics_card_caps);
+                old_video_mode=graphics_card_caps.current_video_mode;
+                old_refresh_rate=graphics_card_caps.current_rrate;
+            }
 
-		if(OCImage.direct_context == NULL)
-       	 OCImage.direct_context=(PdDirectContext_t*)PdCreateDirectContext();
-        if( !OCImage.direct_context )
-             fprintf(stderr, "error: Can't create direct context\n" );
-             
-       
-		/* Remove the cursor if in full screen mode */		
-/*
-		region_info.cursor_type = Ph_CURSOR_NONE;
-		region_info.rid=PtWidgetRid(window);
-		PhRegionChange(Ph_REGION_CURSOR,0,&region_info,NULL,NULL);
-*/
+            if(OCImage.direct_context == NULL)
+            {
+                OCImage.direct_context=(PdDirectContext_t*)PdCreateDirectContext();
+            }
+            if(!OCImage.direct_context)
+            {
+                fprintf(stderr, "error: Can't create direct context\n" );
+            }
 
-	 	PdDirectStart( OCImage.direct_context );
+            PdDirectStart(OCImage.direct_context);
 
-		currently_fullscreen = 1;
-		}
+            currently_fullscreen = 1;
+        }
+    }
 
-
-		
-	return 1;
+    return 1;
 }
 
 int ph_LeaveFullScreen(_THIS )
 {
-   PgDisplaySettings_t mymode_settings;
+    PgDisplaySettings_t mymode_settings;
        
-	if ( currently_fullscreen )
-	{
-		PdDirectStop(OCImage.direct_context);
-		PdReleaseDirectContext(OCImage.direct_context);
+    if (currently_fullscreen)
+    {
+        if ((this->screen->flags & SDL_OPENGL)==SDL_OPENGL)
+        {
+#ifdef HAVE_OPENGL
+#endif /* HAVE_OPENGL */
+           return 0;
+        }
+        else
+        {
+            PdDirectStop(OCImage.direct_context);
+            PdReleaseDirectContext(OCImage.direct_context);
 
-		//Restore old video mode	
-		if (old_video_mode != -1)
-		{
-			mymode_settings.mode= (unsigned short) old_video_mode;
-			mymode_settings.refresh= (unsigned short) old_refresh_rate;
-			mymode_settings.flags = 0;
-			if(PgSetVideoMode(&mymode_settings) < 0)
-                        {
-                           fprintf(stderr,"error: PgSetVideoMode failed\n");
-        	        }
-		}
-	
-		old_video_mode=-1;
-		old_refresh_rate=-1;	
-	
-		// Restore cursor	
-	
-	}
-	return 1;
+            /* Restore old video mode */
+            if (old_video_mode != -1)
+            {
+                mymode_settings.mode= (unsigned short) old_video_mode;
+                mymode_settings.refresh= (unsigned short) old_refresh_rate;
+                mymode_settings.flags = 0;
+                if (PgSetVideoMode(&mymode_settings) < 0)
+                {
+                    fprintf(stderr,"error: PgSetVideoMode failed\n");
+                }
+            }
+
+            old_video_mode=-1;
+            old_refresh_rate=-1;	
+        }
+
+    }
+    return 1;
 }
--- a/src/video/photon/SDL_ph_video.c	Sun Mar 10 03:55:45 2002 +0000
+++ b/src/video/photon/SDL_ph_video.c	Mon Mar 11 17:38:56 2002 +0000
@@ -58,17 +58,24 @@
 static void ph_DeleteDevice(SDL_VideoDevice *device);
 
 #ifdef HAVE_OPENGL
+int ph_SetupOpenGLContext(_THIS, int width, int height, int bpp, Uint32 flags);
 static void ph_GL_SwapBuffers(_THIS);
 static int ph_GL_GetAttribute(_THIS, SDL_GLattr attrib, int* value);
 #endif /* HAVE_OPENGL */
 
-#ifdef HAVE_OPENGL
-PdOpenGLContext_t* OGLContext=NULL;
-#endif /* HAVE_OPENGL */
-
 static int ph_Available(void)
 {
-    return 1;
+    int phstat=-1;
+
+    phstat=PtInit(0);
+    if (phstat==0)
+    {
+       return 1;
+    }
+    else
+    {
+       return 0;
+    }
 }
 
 static SDL_VideoDevice *ph_CreateDevice(int devindex)
@@ -77,7 +84,7 @@
 
     /* Initialize all variables that we clean on shutdown */
     device = (SDL_VideoDevice *)malloc(sizeof(SDL_VideoDevice));
-    if ( device ) {
+    if (device) {
         memset(device, 0, (sizeof *device));
         device->hidden = (struct SDL_PrivateVideoData *)
                 malloc((sizeof *device->hidden));
@@ -98,10 +105,10 @@
     device->VideoInit = ph_VideoInit;
     device->ListModes = ph_ListModes;
     device->SetVideoMode = ph_SetVideoMode;
-    device->ToggleFullScreen =  ph_ToggleFullScreen;
+    device->ToggleFullScreen = ph_ToggleFullScreen;
     device->UpdateMouse = NULL;	
     device->SetColors = ph_SetColors;
-    device->UpdateRects = NULL; /* ph_ResizeImage; */
+    device->UpdateRects = NULL;         /* ph_ResizeImage */
     device->VideoQuit = ph_VideoQuit;
     device->AllocHWSurface = ph_AllocHWSurface;
     device->CheckHWBlit = NULL;
@@ -149,13 +156,15 @@
 
 static void ph_DeleteDevice(SDL_VideoDevice *device)
 {
-
-    if ( device ) {
-        if ( device->hidden ) {
+    if (device)
+    {
+        if (device->hidden)
+        {
             free(device->hidden);
             device->hidden = NULL;
         }
-        if ( device->gl_data ) {
+        if (device->gl_data)
+        {
             free(device->gl_data);
             device->gl_data = NULL;
         }
@@ -166,104 +175,68 @@
 
 static int ph_VideoInit(_THIS, SDL_PixelFormat *vformat)
 {
-	PtArg_t arg[1];
-	PhDim_t dim;
-	PgColor_t ph_palette[_Pg_MAX_PALETTE];
-	int i;
-	unsigned long *tempptr;
-	int rtnval;
-//	PgDisplaySettings_t mysettings;
-	PgVideoModeInfo_t my_mode_info;
-	PgHWCaps_t my_hwcaps;
-	
-	if( NULL == ( event = malloc( EVENT_SIZE ) ) )
-	   exit( EXIT_FAILURE );
+    PgColor_t ph_palette[_Pg_MAX_PALETTE];
+    int i;
+    unsigned long *tempptr;
+    int rtnval;
+    PgVideoModeInfo_t my_mode_info;
+    PgHWCaps_t my_hwcaps;
 
-	/* Create a widget 'window' to capture events */
-    dim.w=0; //JB test320;
-    dim.h=0; //JB test240;
-    //We need to return BytesPerPixel as it in used by CreateRGBsurface
+    window=NULL;
+    oglctx=NULL;
 	
-    PtSetArg(&arg[0], Pt_ARG_DIM, &dim,0);
-    
-/*    
-    PtSetArg(&arg[1], Pt_ARG_RESIZE_FLAGS, Pt_TRUE, Pt_RESIZE_XY_AS_REQUIRED);
-    PtSetArg(&arg[2], Pt_ARG_WINDOW_STATE, Pt_TRUE, Ph_WM_STATE_ISFRONT |
-                        Ph_WM_STATE_ISMAX |
-                        Ph_WM_STATE_ISFOCUS);
+    if (NULL == (event = malloc(EVENT_SIZE)))
+    {
+        exit(EXIT_FAILURE);
+    }
+
+    /* Create the blank cursor */
+    SDL_BlankCursor = this->CreateWMCursor(this, blank_cdata, blank_cmask,
+                                          (int)BLANK_CWIDTH, (int)BLANK_CHEIGHT,
+                                          (int)BLANK_CHOTX, (int)BLANK_CHOTY);
 
-    PtSetArg(&arg[3], Pt_ARG_WINDOW_RENDER_FLAGS,Pt_FALSE,~0);
-    PtSetArg(&arg[4], Pt_ARG_WINDOW_MANAGED_FLAGS,Pt_TRUE,
-                        Ph_WM_FFRONT |
-                        Ph_WM_CLOSE |
-                        Ph_WM_TOFRONT |
-                        Ph_WM_CONSWITCH);
-*/    
-    
-    
-	window=PtAppInit(NULL, NULL, NULL, 1, arg);
+    if (SDL_BlankCursor == NULL)
+    {
+        printf("ph_VideoInit: could not create blank cursor\n");
+    }
 
-  	if(window == NULL)
-  	{
-  		printf("Photon application init failed, probably Photon is not running.\n");
-        	exit( EXIT_FAILURE );
-  	}
-
-	//PgSetDrawBufferSize(16 *1024);
-	PgSetRegion(PtWidgetRid(window));
-	PgSetClipping(0,NULL);
-	PtRealizeWidget(window);
-
+    if (PgGetGraphicsHWCaps(&my_hwcaps) < 0)
+    {
+        fprintf(stderr,"ph_VideoInit: GetGraphicsHWCaps failed!! \n");
+    }
 
-    /* Get the available video modes */
-//    if(ph_GetVideoModes(this) < 0)
-//        return -1;
-
-	/* Create the blank cursor */
-	SDL_BlankCursor = this->CreateWMCursor(this, blank_cdata, blank_cmask,
-                (int)BLANK_CWIDTH, (int)BLANK_CHEIGHT,
-                   (int)BLANK_CHOTX, (int)BLANK_CHOTY);
-
-	if(SDL_BlankCursor == NULL)
-	  printf("could not create blank cursor\n");
+    if (PgGetVideoModeInfo(my_hwcaps.current_video_mode, &my_mode_info) < 0)
+    {
+        fprintf(stderr,"ph_VideoInit:  PgGetVideoModeInfo failed\n");
+    }
 
-         if (PgGetGraphicsHWCaps(&my_hwcaps) < 0)
-         {
-                fprintf(stderr,"ph_VideoInit:  GetGraphicsHWCaps failed!! \n");
-         }
-         if (PgGetVideoModeInfo(my_hwcaps.current_video_mode, &my_mode_info) < 0)
-         {
-                fprintf(stderr,"ph_VideoInit:  PgGetVideoModeInfo failed\n");
-         }
-
-         //We need to return BytesPerPixel as it in used by CreateRGBsurface
-         vformat->BitsPerPixel = my_mode_info.bits_per_pixel;
-         vformat->BytesPerPixel = my_mode_info.bytes_per_scanline/my_mode_info.width;
+    /* We need to return BytesPerPixel as it in used by CreateRGBsurface */
+    vformat->BitsPerPixel = my_mode_info.bits_per_pixel;
+    vformat->BytesPerPixel = my_mode_info.bytes_per_scanline/my_mode_info.width;
          
-         //return a palette if we are in 256 color mode           
-		if(vformat->BitsPerPixel == 8)
-		{
-			vformat->palette = malloc(sizeof(SDL_Palette));
-			memset(vformat->palette, 0, sizeof(SDL_Palette));
-			vformat->palette->ncolors = 256;
-			vformat->palette->colors = (SDL_Color *)malloc(256 *sizeof(SDL_Color));
-			
-			//fill the palette
-			rtnval = PgGetPalette(ph_palette);
-			if(rtnval < 0)
-			   printf("ph_VideoInit:  PgGetPalette failed\n");
-			   
-                        tempptr = (unsigned long *)vformat->palette->colors;
+    /* return a palette if we are in 256 color mode */
+    if (vformat->BitsPerPixel == 8)
+    {
+        vformat->palette = malloc(sizeof(SDL_Palette));
+        memset(vformat->palette, 0, sizeof(SDL_Palette));
+        vformat->palette->ncolors = 256;
+        vformat->palette->colors = (SDL_Color *)malloc(256 *sizeof(SDL_Color));
 
-			for(i=0;i<256; i++)
-			{
-  				*tempptr = (((unsigned long)ph_palette[i]) << 8);
-  				tempptr++;
+        /* fill the palette */
+        rtnval = PgGetPalette(ph_palette);
+        if (rtnval < 0)
+        {
+	    fprintf(stderr, "ph_VideoInit: PgGetPalette failed\n");
+        }
 
-			}		
-		
-		}
+        tempptr = (unsigned long *)vformat->palette->colors;
 
+        for(i=0;i<256; i++)
+        {
+            *tempptr = (((unsigned long)ph_palette[i]) << 8);
+            tempptr++;
+        }		
+    }
 
     currently_fullscreen = 0;
     
@@ -276,21 +249,14 @@
                 int width, int height, int bpp, Uint32 flags)
 {
     PgDisplaySettings_t settings;
-    int mode, actual_width, actual_height;
-    PtArg_t arg[5];
-    PhDim_t dim;	
+    int mode;
+    PtArg_t arg[32];
+    PhDim_t dim;
     int rtnval;
     PgColor_t ph_palette[_Pg_MAX_PALETTE];
     int i;
     unsigned long *tempptr;
-
-#ifdef HAVE_OPENGL
-    uint64_t OGLAttrib[PH_OGL_MAX_ATTRIBS];
-    int OGLargc;
-#endif /* HAVE_OPENGL */
-
-    actual_width = width;
-    actual_height = height;
+    int pargc;
 
     dim.w=width;
     dim.h=height;
@@ -298,136 +264,131 @@
     /* Lock the event thread, in multi-threading environments */
     SDL_Lock_EventThread();
 
-     /* Initialize the window */
-    if (flags & SDL_FULLSCREEN) /* Direct Context , assume SDL_HWSURFACE also set */
+    /* create window if no OpenGL support selected */
+    if ((flags & SDL_OPENGL)!=SDL_OPENGL)
     {
-        /* Get the video mode and set it */
-        if (flags & SDL_ANYFORMAT)
+        pargc=0;
+
+        PtSetArg(&arg[pargc++], Pt_ARG_DIM, &dim, 0);
+        PtSetArg(&arg[pargc++], Pt_ARG_RESIZE_FLAGS, Pt_FALSE, Pt_RESIZE_XY_AS_REQUIRED);
+
+        if (window!=NULL)
         {
-            if ((mode = get_mode_any_format(width, height, bpp)) == 0)
-            {
-                fprintf(stderr,"error: get_mode_any_format failed\n");
-                exit(1);
-            }
+            PtUnrealizeWidget(window);
+            PtDestroyWidget(window);
+            window=NULL;
+        }
+
+        window=PtCreateWidget(PtWindow, NULL, pargc-1, arg);
+        PtRealizeWidget(window);
+
+        PtFlush();
+    }
+
+#ifdef HAVE_OPENGL
+    if (flags & SDL_OPENGL)
+    {
+        /* ph_SetupOpenGLContext creates also window as need */
+        if (ph_SetupOpenGLContext(this, width, height, bpp, flags)==0)
+        {
+            current->flags=flags;
+            /* setup OGL update function ... ugly method */
+            ph_ResizeImage(this, current, flags); 
         }
         else
         {
-            if ((mode = get_mode(width, height, bpp)) == 0)
-            {
-                fprintf(stderr,"error: get_mode failed\n");
-                exit(1);
-            }
+            /* if context creation fail, report no OpenGL to high level */
+            current->flags=(flags & (~SDL_OPENGL));
         }
-        settings.mode = mode;
-        settings.refresh = 0;
-        settings.flags  = 0;       
-
-        if (PgSetVideoMode( &settings ) < 0)
-        {
-            fprintf(stderr,"error: PgSetVideoMode failed\n");
-        }
-
-        /* Get the true height and width */
-
-        current->flags = (flags & (~SDL_RESIZABLE)); /* no resize for Direct Context */
-
-        /* Begin direct mode */
-
-        ph_EnterFullScreen(this);
-
-    } /* end fullscreen flag */
+#else
+    if (flags & SDL_OPENGL) /* if no built-in OpenGL support */
+    {
+        fprintf(stderr, "error: no OpenGL support, try to recompile library.\n");
+        current->flags=(flags & (~SDL_OPENGL));
+        return NULL;
+#endif /* HAVE_OPENGL */
+    }
     else
     {
-       if (flags & SDL_HWSURFACE)  /* Use offscreen memory iff SDL_HWSURFACE flag is set */
-       {
-         /* Hardware surface is Offsceen Context.  ph_ResizeImage handles the switch */
-         current->flags = (flags & (~SDL_RESIZABLE)); /* no stretch blit in offscreen context */
-       }
-       else /* must be SDL_SWSURFACE */
-       {
-          current->flags = (flags | SDL_RESIZABLE); /* yes we can resize as this is a software surface */
-       }
+        /* Initialize the window */
+        if (flags & SDL_FULLSCREEN) /* Direct Context , assume SDL_HWSURFACE also set */
+        {
+            /* Get the video mode and set it */
+            if (flags & SDL_ANYFORMAT)
+            {
+                if ((mode = get_mode_any_format(width, height, bpp)) == 0)
+                {
+                    fprintf(stderr,"error: get_mode_any_format failed\n");
+                    exit(1);
+                }
+            }
+            else
+            {
+                if ((mode = get_mode(width, height, bpp)) == 0)
+                {
+                    fprintf(stderr,"error: get_mode failed\n");
+                    exit(1);
+                }
+            }
+            settings.mode = mode;
+            settings.refresh = 0;
+            settings.flags  = 0;       
+
+            if (PgSetVideoMode( &settings ) < 0)
+            {
+                fprintf(stderr,"error: PgSetVideoMode failed\n");
+            }
+
+            /* Get the true height and width */
+
+            current->flags = (flags & (~SDL_RESIZABLE)); /* no resize for Direct Context */
+
+            /* Begin direct mode */
 
-#ifdef HAVE_OPENGL       
-       if (flags & SDL_OPENGL) /* for now support OpenGL in window mode only */
-       {
-          OGLargc=0;
-          if (this->gl_config.depth_size)
-          {
-             OGLAttrib[OGLargc++]=PHOGL_ATTRIB_DEPTH_BITS;
-             OGLAttrib[OGLargc++]=this->gl_config.depth_size;
-          }
-          if (this->gl_config.stencil_size)
-          {
-             OGLAttrib[OGLargc++]=PHOGL_ATTRIB_STENCIL_BITS;
-             OGLAttrib[OGLargc++]=this->gl_config.stencil_size;
-          }
-          OGLAttrib[OGLargc++]=PHOGL_ATTRIB_NONE;
-          if (this->gl_config.double_buffer)
-          {
-             OGLContext=PdCreateOpenGLContext(2, &dim, 0, OGLAttrib);
-          }
-          else
-          {
-             OGLContext=PdCreateOpenGLContext(1, &dim, 0, OGLAttrib);
-          }
-          if (OGLContext==NULL)
-          {
-             fprintf(stderr,"error: cannot create OpenGL context.\n");
-             exit(1);
-          }
-          PhDCSetCurrent(OGLContext);
-       }
-#else
-       if (flags & SDL_OPENGL) /* if no OpenGL support */
-       {
-          fprintf(stderr, "error: no OpenGL support, try to recompile library.\n");
-          exit(1);
-       }
+            ph_EnterFullScreen(this);
+
+        } /* end fullscreen flag */
+        else
+        {
+            if (flags & SDL_HWSURFACE)  /* Use offscreen memory iff SDL_HWSURFACE flag is set */
+            {
+                /* Hardware surface is Offsceen Context.  ph_ResizeImage handles the switch */
+                current->flags = (flags & (~SDL_RESIZABLE)); /* no stretch blit in offscreen context */
+            }
+            else /* must be SDL_SWSURFACE */
+            {
+                current->flags = (flags | SDL_RESIZABLE); /* yes we can resize as this is a software surface */
+            }
+        }
 
-#endif /* HAVE_OPENGL */
-       
+	/* If we are setting video to use the palette make sure we have allocated memory for it */
+	if (bpp==8)
+	{
+            current->format->palette = malloc(sizeof(SDL_Palette));
+            memset(current->format->palette, 0, sizeof(SDL_Palette));
+            current->format->palette->ncolors = 256;
+            current->format->palette->colors = (SDL_Color *)malloc(256 *sizeof(SDL_Color));
+            /* fill the palette */
+            rtnval = PgGetPalette(ph_palette);
+
+            tempptr = (unsigned long *)current->format->palette->colors;
+
+            for(i=0; i<256; i++)
+            {
+                *tempptr = (((unsigned long)ph_palette[i]) << 8);
+                tempptr++;
+            }
+        }
+
     }
 
-	/* If we are setting video to use the palette make sure we have allocated memory for it */
-	if(bpp == 8)
-	{
-		current->format->palette = malloc(sizeof(SDL_Palette));
-		memset(current->format->palette, 0, sizeof(SDL_Palette));
-		current->format->palette->ncolors = 256;
-		current->format->palette->colors = (SDL_Color *)malloc(256 *sizeof(SDL_Color));
-		/* fill the palette */
-		rtnval = PgGetPalette(ph_palette);
-
-                tempptr = (unsigned long *)current->format->palette->colors;
-
-		for(i=0;i<256; i++)
-		{
-  			*tempptr = (((unsigned long)ph_palette[i]) << 8);
-  			tempptr++;
-
-		}
-	}
-
-
-	/* Current window dimensions */
-	PtGetResource( window, Pt_ARG_DIM, &dim, 0 );
-
-	/* If we need to resize the window */
-	if((dim.w != width)||(dim.h != height))
-	{
-	    dim.w=width;
-	    dim.h=height; 
-	    PtSetArg(&arg[0], Pt_ARG_DIM, &dim,0);
-	    PtSetResources( window, 1, arg ); 	
-            current->w = width;
-            current->h = height;
-            current->format->BitsPerPixel = bpp;
-            current->format->BytesPerPixel = (bpp+7)/8;
-            current->pitch = SDL_CalculatePitch(current);
-            /* Must call at least once it setup image planes */
-            ph_ResizeImage(this, current, flags);
-        }
+    current->w = width;
+    current->h = height;
+    current->format->BitsPerPixel = bpp;
+    current->format->BytesPerPixel = (bpp+7)/8;
+    current->pitch = SDL_CalculatePitch(current);
+    /* Must call at least once it setup image planes */
+    ph_ResizeImage(this, current, flags);
 
     SDL_Unlock_EventThread();
 
@@ -437,18 +398,47 @@
 
 static void ph_VideoQuit(_THIS)
 {
+    PhRegion_t region_info;
+
     ph_DestroyImage(this, SDL_VideoSurface); 
 
     if (currently_fullscreen)
     {
-        PdDirectStop( directContext );
-        PdReleaseDirectContext( directContext );
+        PdDirectStop(directContext);
+        PdReleaseDirectContext(directContext);
         directContext=0;	
-        currently_fullscreen = 0;
+        currently_fullscreen=0;
+    }
+
+#ifdef HAVE_OPENGL
+    if (((this->screen->flags & SDL_FULLSCREEN)==SDL_FULLSCREEN) &&
+        ((this->screen->flags & SDL_OPENGL)==SDL_OPENGL))
+    {
+        region_info.cursor_type=Ph_CURSOR_POINTER;
+        region_info.rid=PtWidgetRid(window);
+        PhRegionChange(Ph_REGION_CURSOR, 0, &region_info, NULL, NULL);
     }
+
+    PtFlush();
+#endif /* HAVE_OPENGL */
+    
+    if (window)
+    {
+        PtUnrealizeWidget(window);
+        PtDestroyWidget(window);
+        window=NULL;
+    }
+
+#ifdef HAVE_OPENGL
+    if (oglctx)
+    {
+        PhDCSetCurrent(NULL);
+        PhDCRelease(oglctx);
+        oglctx=NULL;
+    }
+#endif /* HAVE_OPENGL */
 }
 
-
 static int ph_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color *colors)
 {
 	PgColor_t *in, *out;
@@ -508,10 +498,110 @@
 }
 
 #ifdef HAVE_OPENGL
+
+int ph_SetupOpenGLContext(_THIS, int width, int height, int bpp, Uint32 flags)
+{
+    PtArg_t args[8];
+    PhDim_t dim;
+    uint64_t OGLAttrib[PH_OGL_MAX_ATTRIBS];
+    int OGLargc;
+    int pargc;
+
+    dim.w=width;
+    dim.h=height;
+    
+    if (oglctx!=NULL)
+    {
+       PhDCSetCurrent(NULL);
+       PhDCRelease(oglctx);
+       oglctx=NULL;
+    }
+
+    OGLargc=0;
+    if (this->gl_config.depth_size)
+    {
+        OGLAttrib[OGLargc++]=PHOGL_ATTRIB_DEPTH_BITS;
+        OGLAttrib[OGLargc++]=this->gl_config.depth_size;
+    }
+    if (this->gl_config.stencil_size)
+    {
+        OGLAttrib[OGLargc++]=PHOGL_ATTRIB_STENCIL_BITS;
+        OGLAttrib[OGLargc++]=this->gl_config.stencil_size;
+    }
+    OGLAttrib[OGLargc++]=PHOGL_ATTRIB_FORCE_SW;
+    if (flags & SDL_FULLSCREEN)
+    {
+        OGLAttrib[OGLargc++]=PHOGL_ATTRIB_FULLSCREEN;
+        OGLAttrib[OGLargc++]=PHOGL_ATTRIB_DIRECT;
+        OGLAttrib[OGLargc++]=PHOGL_ATTRIB_FULLSCREEN_BEST;
+        OGLAttrib[OGLargc++]=PHOGL_ATTRIB_FULLSCREEN_CENTER;
+    }
+    OGLAttrib[OGLargc++]=PHOGL_ATTRIB_NONE;
+
+    if (this->gl_config.double_buffer)
+    {
+        oglctx=PdCreateOpenGLContext(2, &dim, 0, OGLAttrib);
+    }
+    else
+    {
+        oglctx=PdCreateOpenGLContext(1, &dim, 0, OGLAttrib);
+    }
+    if (oglctx==NULL)
+    {
+        fprintf(stderr,"error: cannot create OpenGL context.\n");
+        return (-1);
+    }
+
+    PhDCSetCurrent(oglctx);
+
+    pargc=0;
+
+    PtSetArg(&args[pargc++], Pt_ARG_DIM, &dim, 0);
+    PtSetArg(&args[pargc++], Pt_ARG_RESIZE_FLAGS, Pt_FALSE, Pt_RESIZE_XY_AS_REQUIRED);
+    PtSetArg(&args[pargc++], Pt_ARG_FILL_COLOR, Pg_BLACK, 0);
+
+    if (flags & SDL_FULLSCREEN)
+    {
+        PhPoint_t pos;
+
+        pos.x=0;
+        pos.y=0;
+
+        PtSetArg(&args[pargc++], Pt_ARG_WINDOW_RENDER_FLAGS, Pt_FALSE, ~0);
+        PtSetArg(&args[pargc++], Pt_ARG_WINDOW_MANAGED_FLAGS,Pt_TRUE, Ph_WM_FFRONT | Ph_WM_CLOSE | Ph_WM_TOFRONT | Ph_WM_CONSWITCH);
+        PtSetArg(&args[pargc++], Pt_ARG_WINDOW_STATE, Pt_TRUE, Ph_WM_STATE_ISFRONT | Ph_WM_STATE_ISFOCUS);
+        PtSetArg(&args[pargc++], Pt_ARG_POS, &pos, 0);
+    }
+
+    if (window!=NULL)
+    {
+        PtUnrealizeWidget(window);
+        PtDestroyWidget(window);
+        window=NULL;
+    }
+
+    window=PtCreateWidget(PtWindow, NULL, pargc-1, args);
+    PtRealizeWidget(window);
+
+    /* disable mouse for fullscreen */
+    if (flags & SDL_FULLSCREEN)
+    {
+        PhRegion_t region_info;
+
+        region_info.cursor_type=Ph_CURSOR_NONE;
+        region_info.rid=PtWidgetRid(window);
+        PhRegionChange(Ph_REGION_CURSOR, 0, &region_info, NULL, NULL);
+    }
+
+    PtFlush();
+
+    return 0;
+}
+
 void ph_GL_SwapBuffers(_THIS)
 {
     PgSetRegion(PtWidgetRid(window));
-    PdOpenGLContextSwapBuffers(OGLContext);
+    PdOpenGLContextSwapBuffers(oglctx);
 }
 
 int ph_GL_GetAttribute(_THIS, SDL_GLattr attrib, int* value)
--- a/src/video/photon/SDL_ph_video.h	Sun Mar 10 03:55:45 2002 +0000
+++ b/src/video/photon/SDL_ph_video.h	Mon Mar 11 17:38:56 2002 +0000
@@ -19,26 +19,6 @@
     Sam Lantinga
     slouken@libsdl.org
 */
-/*
-static PhEvent_t *event;
-static PtAppContext_t app;
-static PtWidget_t *window;
-static PgVideoModes_t modelist;
-static PdOffscreenContext_t *Buff[2];
-static PdDirectContext_t *directContext;
-static PhRect_t screenRect,windowRect;
-static PgColor_t currRGB;
-static PhPoint_t zeroPoint;
-static char keyque[ QUE_SIZE ],keyMatrix[256];
-static int queput,queget;
-static int modeSet;
-static PgHWCaps_t hwCaps;
-static PgDisplaySettings_t mode_settings;
-static int rshift1,rshift2,gshift1,gshift2,bshift1,bshift2;
-static int backPitch;
-static unsigned RBitMask,GBitMask,BBitMask;
-static unsigned TranslatedFillColor;
-*/
 
 #ifndef _SDL_ph_video_h
 #define _SDL_ph_video_h
@@ -50,7 +30,9 @@
 #include "Pt.h"
 #include <photon/Pg.h>
 #include <photon/PdDirect.h>
+#ifdef HAVE_OPENGL
 #include <photon/PdGL.h>
+#endif /* HAVE_OPENGL */
 
 /* Hidden "this" pointer for the video functions */
 #define _THIS	SDL_VideoDevice *this
@@ -76,31 +58,32 @@
     int local_ph;		/* Flag: true if local display */
     PtAppContext_t app;
     PgDisplaySettings_t mode_settings;	
-    PtWidget_t *window;    /* used to handle input events */
-	PhImage_t *image;	 /* used to display image */
+    PtWidget_t *Window;    /* used to handle input events */
+    PhImage_t *image;	   /* used to display image */
+#ifdef HAVE_OPENGL
+    PdOpenGLContext_t* OGLContext;
+#endif /* HAVE_OPENGL */
 
- 	struct {
-       PdDirectContext_t *direct_context;
-		PdOffscreenContext_t *offscreen_context;
-		VidPtr_t    dc_ptr;
-		FRAMEDATA *CurrentFrameData;
-		FRAMEDATA *FrameData0;
-		FRAMEDATA *FrameData1;
-		int current;
-		long Stride;
-		long flags;
-	} ocimage;
+    struct {
+        PdDirectContext_t *direct_context;
+        PdOffscreenContext_t *offscreen_context;
+        VidPtr_t dc_ptr;
+        FRAMEDATA *CurrentFrameData;
+        FRAMEDATA *FrameData0;
+        FRAMEDATA *FrameData1;
+        int current;
+        long Stride;
+        long flags;
+    } ocimage;
 
     PhDrawContext_t *ScreenDC; //=NULL;
-	signed short old_video_mode; //=-1;
-	signed short old_refresh_rate; //=-1;
-	PgHWCaps_t graphics_card_caps;
+    signed short old_video_mode; //=-1;
+    signed short old_refresh_rate; //=-1;
+    PgHWCaps_t graphics_card_caps;
 	
-	PdDirectContext_t *directContext;
-	PdOffscreenContext_t *Buff[2];
-	struct _Ph_ctrl* ctrl_channel;
-	
-	PhGC_t *Pt_GC, *Pg_GC; /* Graphic contexts to switch between Pt and Pg APIs */
+    PdDirectContext_t *directContext;
+    PdOffscreenContext_t *Buff[2];
+    struct _Ph_ctrl* ctrl_channel;
 
     /* The variables used for displaying graphics */
 
@@ -113,15 +96,15 @@
         int x;
         int y;
     } mouse_last;
+
     struct {
         int numerator;
         int denominator;
         int threshold;
     } mouse_accel;
+
     int mouse_relative;
-	WMcursor* BlankCursor;
-
-  
+    WMcursor* BlankCursor;
 
     int depth;			/* current visual depth (not bpp) */
 
@@ -136,40 +119,39 @@
     int blit_queued;
 
     short *iconcolors;		/* List of colors used by the icon */
-	PhEvent_t* event;
+    PhEvent_t* event;
 };
 
-#define local_ph 		(this->hidden->local_ph)
-#define app				(this->hidden->app)
-#define mode_settings	(this->hidden->mode_settings)
-#define window			(this->hidden->window)
-#define directContext	(this->hidden->directContext)
-#define Buff			(this->hidden->Buff)
-#define ctrl_channel 	(this->hidden->ctrl_channel)
-#define SDL_Image		(this->hidden->image)
-#define OCImage		(this->hidden->ocimage)
-#define old_video_mode		(this->hidden->old_video_mode)
-#define old_refresh_rate		(this->hidden->old_refresh_rate)
-#define graphics_card_caps		(this->hidden->graphics_card_caps)
-#define Pt_GC			(this->hidden->Pt_GC)
-#define Pg_GC			(this->hidden->Pg_GC)
+#define local_ph             (this->hidden->local_ph)
+#define app                  (this->hidden->app)
+#define mode_settings        (this->hidden->mode_settings)
+#define window	             (this->hidden->Window)
+#define oglctx               (this->hidden->OGLContext)
+#define directContext	     (this->hidden->directContext)
+#define Buff                 (this->hidden->Buff)
+#define ctrl_channel         (this->hidden->ctrl_channel)
+#define SDL_Image            (this->hidden->image)
+#define OCImage              (this->hidden->ocimage)
+#define old_video_mode       (this->hidden->old_video_mode)
+#define old_refresh_rate     (this->hidden->old_refresh_rate)
+#define graphics_card_caps   (this->hidden->graphics_card_caps)
 
 /* Old variable names */
-#define swap_pixels		(this->hidden->swap_pixels)
-#define current_w		(this->hidden->current_w)
-#define current_h		(this->hidden->current_h)
-#define mouse_last		(this->hidden->mouse_last)
-#define mouse_accel		(this->hidden->mouse_accel)
-#define mouse_relative		(this->hidden->mouse_relative)
-#define saved_mode		(this->hidden->saved_mode)
-#define saved_view		(this->hidden->saved_view)
-#define use_vidmode		(this->hidden->use_vidmode)
-#define currently_fullscreen	(this->hidden->currently_fullscreen)
-#define switch_waiting		(this->hidden->switch_waiting)
-#define switch_time		(this->hidden->switch_time)
-#define blit_queued		(this->hidden->blit_queued)
-#define SDL_iconcolorIs		(this->hidden->iconcolors)
-#define event				(this->hidden->event)
-#define SDL_BlankCursor     (this->hidden->BlankCursor)
+#define swap_pixels          (this->hidden->swap_pixels)
+#define current_w            (this->hidden->current_w)
+#define current_h            (this->hidden->current_h)
+#define mouse_last           (this->hidden->mouse_last)
+#define mouse_accel          (this->hidden->mouse_accel)
+#define mouse_relative       (this->hidden->mouse_relative)
+#define saved_mode           (this->hidden->saved_mode)
+#define saved_view           (this->hidden->saved_view)
+#define use_vidmode          (this->hidden->use_vidmode)
+#define currently_fullscreen (this->hidden->currently_fullscreen)
+#define switch_waiting       (this->hidden->switch_waiting)
+#define switch_time          (this->hidden->switch_time)
+#define blit_queued          (this->hidden->blit_queued)
+#define SDL_iconcolorIs      (this->hidden->iconcolors)
+#define event                (this->hidden->event)
+#define SDL_BlankCursor      (this->hidden->BlankCursor)
 
 #endif /* _SDL_x11video_h */