--- a/src/video/photon/SDL_ph_image.c	Sun May 21 17:27:13 2006 +0000
+++ b/src/video/photon/SDL_ph_image.c	Sun May 28 13:04:16 2006 +0000
@@ -32,70 +32,78 @@
 #include "SDL_ph_modes_c.h"
 #include "SDL_ph_gl.h"
 
-int ph_SetupImage(_THIS, SDL_Surface *screen)
+int
+ph_SetupImage (_THIS, SDL_Surface * screen)
 {
-    PgColor_t* palette=NULL;
-    int type=0;
+    PgColor_t *palette = NULL;
+    int type = 0;
     int bpp;
-    
-    bpp=screen->format->BitsPerPixel;
+
+    bpp = screen->format->BitsPerPixel;
 
     /* Determine image type */
-    switch(bpp)
-    {
-        case 8:{
+    switch (bpp) {
+    case 8:
+        {
             type = Pg_IMAGE_PALETTE_BYTE;
         }
         break;
-        case 15:{
-            type = Pg_IMAGE_DIRECT_555; 
+    case 15:
+        {
+            type = Pg_IMAGE_DIRECT_555;
         }
         break;
-        case 16:{
-            type = Pg_IMAGE_DIRECT_565; 
+    case 16:
+        {
+            type = Pg_IMAGE_DIRECT_565;
         }
         break;
-        case 24:{
+    case 24:
+        {
             type = Pg_IMAGE_DIRECT_888;
         }
         break;
-        case 32:{
+    case 32:
+        {
             type = Pg_IMAGE_DIRECT_8888;
         }
         break;
-        default:{
-            SDL_SetError("ph_SetupImage(): unsupported bpp=%d !\n", bpp);
+    default:
+        {
+            SDL_SetError ("ph_SetupImage(): unsupported bpp=%d !\n", bpp);
             return -1;
         }
         break;
     }
 
     /* palette emulation code */
-    if ((bpp==8) && (desktoppal==SDLPH_PAL_EMULATE))
-    {
+    if ((bpp == 8) && (desktoppal == SDLPH_PAL_EMULATE)) {
         /* creating image palette */
-        palette=SDL_malloc(_Pg_MAX_PALETTE*sizeof(PgColor_t));
-        if (palette==NULL)
-        {
-            SDL_SetError("ph_SetupImage(): can't allocate memory for palette !\n");
+        palette = SDL_malloc (_Pg_MAX_PALETTE * sizeof (PgColor_t));
+        if (palette == NULL) {
+            SDL_SetError
+                ("ph_SetupImage(): can't allocate memory for palette !\n");
             return -1;
         }
-        PgGetPalette(palette);
+        PgGetPalette (palette);
 
         /* using shared memory for speed (set last param to 1) */
-        if ((SDL_Image = PhCreateImage(NULL, screen->w, screen->h, type, palette, _Pg_MAX_PALETTE, 1)) == NULL)
-        {
-            SDL_SetError("ph_SetupImage(): PhCreateImage() failed for bpp=8 !\n");
-            SDL_free(palette);
+        if ((SDL_Image =
+             PhCreateImage (NULL, screen->w, screen->h, type, palette,
+                            _Pg_MAX_PALETTE, 1)) == NULL) {
+            SDL_SetError
+                ("ph_SetupImage(): PhCreateImage() failed for bpp=8 !\n");
+            SDL_free (palette);
             return -1;
         }
-    }
-    else
-    {
+    } else {
         /* using shared memory for speed (set last param to 1) */
-        if ((SDL_Image = PhCreateImage(NULL, screen->w, screen->h, type, NULL, 0, 1)) == NULL)
-        {
-            SDL_SetError("ph_SetupImage(): PhCreateImage() failed for bpp=%d !\n", bpp);
+        if ((SDL_Image =
+             PhCreateImage (NULL, screen->w, screen->h, type, NULL, 0,
+                            1)) == NULL) {
+            SDL_SetError
+                ("ph_SetupImage(): PhCreateImage() failed for bpp=%d !\n",
+                 bpp);
             return -1;
         }
     }
@@ -108,62 +116,72 @@
     return 0;
 }
 
-int ph_SetupOCImage(_THIS, SDL_Surface *screen)
+int
+ph_SetupOCImage (_THIS, SDL_Surface * screen)
 {
     int type = 0;
     int bpp;
 
     OCImage.flags = screen->flags;
-    
-    bpp=screen->format->BitsPerPixel;
+
+    bpp = screen->format->BitsPerPixel;
 
     /* Determine image type */
-    switch(bpp)
-    {
-        case 8: {
-                    type = Pg_IMAGE_PALETTE_BYTE;
-                }
-                break;
-        case 15:{
-                    type = Pg_IMAGE_DIRECT_555; 
-		}
-		break;
-        case 16:{
-                    type = Pg_IMAGE_DIRECT_565; 
-                }
-                break;
-        case 24:{
-                    type = Pg_IMAGE_DIRECT_888;
-                }
-                break;
-        case 32:{
-                    type = Pg_IMAGE_DIRECT_8888;
-                }
-                break;
-        default:{
-                    SDL_SetError("ph_SetupOCImage(): unsupported bpp=%d !\n", bpp);
-                    return -1;
-                }
-                break;
+    switch (bpp) {
+    case 8:
+        {
+            type = Pg_IMAGE_PALETTE_BYTE;
+        }
+        break;
+    case 15:
+        {
+            type = Pg_IMAGE_DIRECT_555;
+        }
+        break;
+    case 16:
+        {
+            type = Pg_IMAGE_DIRECT_565;
+        }
+        break;
+    case 24:
+        {
+            type = Pg_IMAGE_DIRECT_888;
+        }
+        break;
+    case 32:
+        {
+            type = Pg_IMAGE_DIRECT_8888;
+        }
+        break;
+    default:
+        {
+            SDL_SetError ("ph_SetupOCImage(): unsupported bpp=%d !\n", bpp);
+            return -1;
+        }
+        break;
     }
 
     /* Currently offscreen contexts with the same bit depth as display bpp only can be created */
-    OCImage.offscreen_context = PdCreateOffscreenContext(0, screen->w, screen->h, Pg_OSC_MEM_PAGE_ALIGN);
+    OCImage.offscreen_context =
+        PdCreateOffscreenContext (0, screen->w, screen->h,
+                                  Pg_OSC_MEM_PAGE_ALIGN);
 
-    if (OCImage.offscreen_context == NULL)
-    {
-        SDL_SetError("ph_SetupOCImage(): PdCreateOffscreenContext() function failed !\n");
+    if (OCImage.offscreen_context == NULL) {
+        SDL_SetError
+            ("ph_SetupOCImage(): PdCreateOffscreenContext() function failed !\n");
         return -1;
     }
 
     screen->pitch = OCImage.offscreen_context->pitch;
 
-    OCImage.dc_ptr = (unsigned char *)PdGetOffscreenContextPtr(OCImage.offscreen_context);
+    OCImage.dc_ptr =
+        (unsigned char *) PdGetOffscreenContextPtr (OCImage.
+                                                    offscreen_context);
 
-    if (OCImage.dc_ptr == NULL)
-    {
-        SDL_SetError("ph_SetupOCImage(): PdGetOffscreenContextPtr function failed !\n");
-        PhDCRelease(OCImage.offscreen_context);
+    if (OCImage.dc_ptr == NULL) {
+        SDL_SetError
+            ("ph_SetupOCImage(): PdGetOffscreenContextPtr function failed !\n");
+        PhDCRelease (OCImage.offscreen_context);
         return -1;
     }
 
@@ -171,7 +189,7 @@
     OCImage.CurrentFrameData = OCImage.FrameData0;
     OCImage.current = 0;
 
-    PhDCSetCurrent(OCImage.offscreen_context);
+    PhDCSetCurrent (OCImage.offscreen_context);
 
     screen->pixels = OCImage.CurrentFrameData;
 
@@ -180,805 +198,764 @@
     return 0;
 }
 
-int ph_SetupFullScreenImage(_THIS, SDL_Surface* screen)
+int
+ph_SetupFullScreenImage (_THIS, SDL_Surface * screen)
 {
     OCImage.flags = screen->flags;
 
     /* Begin direct and fullscreen mode */
-    if (!ph_EnterFullScreen(this, screen, PH_ENTER_DIRECTMODE))
-    {
+    if (!ph_EnterFullScreen (this, screen, PH_ENTER_DIRECTMODE)) {
         return -1;
     }
 
     /* store palette for fullscreen */
-    if ((screen->format->BitsPerPixel==8) && (desktopbpp!=8))
-    {
-        PgGetPalette(savedpal);
-        PgGetPalette(syspalph);
+    if ((screen->format->BitsPerPixel == 8) && (desktopbpp != 8)) {
+        PgGetPalette (savedpal);
+        PgGetPalette (syspalph);
     }
 
-    OCImage.offscreen_context = PdCreateOffscreenContext(0, 0, 0, Pg_OSC_MAIN_DISPLAY | Pg_OSC_MEM_PAGE_ALIGN | Pg_OSC_CRTC_SAFE);
-    if (OCImage.offscreen_context == NULL)
-    {
-        SDL_SetError("ph_SetupFullScreenImage(): PdCreateOffscreenContext() function failed !\n");
+    OCImage.offscreen_context =
+        PdCreateOffscreenContext (0, 0, 0,
+                                  Pg_OSC_MAIN_DISPLAY | Pg_OSC_MEM_PAGE_ALIGN
+                                  | Pg_OSC_CRTC_SAFE);
+    if (OCImage.offscreen_context == NULL) {
+        SDL_SetError
+            ("ph_SetupFullScreenImage(): PdCreateOffscreenContext() function failed !\n");
         return -1;
     }
-    
-    if ((screen->flags & SDL_DOUBLEBUF) == SDL_DOUBLEBUF)
-    {
-        OCImage.offscreen_backcontext = PdDupOffscreenContext(OCImage.offscreen_context, Pg_OSC_MEM_PAGE_ALIGN | Pg_OSC_CRTC_SAFE);
-        if (OCImage.offscreen_backcontext == NULL)
-        {
-            SDL_SetError("ph_SetupFullScreenImage(): PdCreateOffscreenContext(back) function failed !\n");
+
+    if ((screen->flags & SDL_DOUBLEBUF) == SDL_DOUBLEBUF) {
+        OCImage.offscreen_backcontext =
+            PdDupOffscreenContext (OCImage.offscreen_context,
+                                   Pg_OSC_MEM_PAGE_ALIGN | Pg_OSC_CRTC_SAFE);
+        if (OCImage.offscreen_backcontext == NULL) {
+            SDL_SetError
+                ("ph_SetupFullScreenImage(): PdCreateOffscreenContext(back) function failed !\n");
             return -1;
         }
     }
 
-    OCImage.FrameData0 = (unsigned char *)PdGetOffscreenContextPtr(OCImage.offscreen_context);
-    if (OCImage.FrameData0 == NULL)
-    {
-        SDL_SetError("ph_SetupFullScreenImage(): PdGetOffscreenContextPtr() function failed !\n");
-        ph_DestroyImage(this, screen);
+    OCImage.FrameData0 =
+        (unsigned char *) PdGetOffscreenContextPtr (OCImage.
+                                                    offscreen_context);
+    if (OCImage.FrameData0 == NULL) {
+        SDL_SetError
+            ("ph_SetupFullScreenImage(): PdGetOffscreenContextPtr() function failed !\n");
+        ph_DestroyImage (this, screen);
         return -1;
     }
 
-    if ((screen->flags & SDL_DOUBLEBUF) == SDL_DOUBLEBUF)
-    {
-        OCImage.FrameData1 = (unsigned char *)PdGetOffscreenContextPtr(OCImage.offscreen_backcontext);
-        if (OCImage.FrameData1 == NULL)
-        {
-            SDL_SetError("ph_SetupFullScreenImage(back): PdGetOffscreenContextPtr() function failed !\n");
-            ph_DestroyImage(this, screen);
+    if ((screen->flags & SDL_DOUBLEBUF) == SDL_DOUBLEBUF) {
+        OCImage.FrameData1 =
+            (unsigned char *) PdGetOffscreenContextPtr (OCImage.
+                                                        offscreen_backcontext);
+        if (OCImage.FrameData1 == NULL) {
+            SDL_SetError
+                ("ph_SetupFullScreenImage(back): PdGetOffscreenContextPtr() function failed !\n");
+            ph_DestroyImage (this, screen);
             return -1;
         }
     }
 
     /* wait for the hardware */
-    PgFlush();
-    PgWaitHWIdle();
+    PgFlush ();
+    PgWaitHWIdle ();
 
-    if ((screen->flags & SDL_DOUBLEBUF) == SDL_DOUBLEBUF)
-    {
+    if ((screen->flags & SDL_DOUBLEBUF) == SDL_DOUBLEBUF) {
         OCImage.current = 0;
-        PhDCSetCurrent(OCImage.offscreen_context);
-        screen->pitch = OCImage.offscreen_context->pitch;
-        screen->pixels = OCImage.FrameData0;
-        
-        /* emulate 640x400 videomode */
-        if (videomode_emulatemode==1)
-        {
-           int i;
-           
-           for (i=0; i<40; i++)
-           {
-              SDL_memset(screen->pixels+screen->pitch*i, 0x00, screen->pitch);
-           }
-           for (i=440; i<480; i++)
-           {
-              SDL_memset(screen->pixels+screen->pitch*i, 0x00, screen->pitch);
-           }
-           screen->pixels+=screen->pitch*40;
-        }
-        PgSwapDisplay(OCImage.offscreen_backcontext, 0);
-    }
-    else
-    {
-        OCImage.current = 0;
-        PhDCSetCurrent(OCImage.offscreen_context);
+        PhDCSetCurrent (OCImage.offscreen_context);
         screen->pitch = OCImage.offscreen_context->pitch;
         screen->pixels = OCImage.FrameData0;
 
         /* emulate 640x400 videomode */
-        if (videomode_emulatemode==1)
-        {
-           int i;
-           
-           for (i=0; i<40; i++)
-           {
-              SDL_memset(screen->pixels+screen->pitch*i, 0x00, screen->pitch);
-           }
-           for (i=440; i<480; i++)
-           {
-              SDL_memset(screen->pixels+screen->pitch*i, 0x00, screen->pitch);
-           }
-           screen->pixels+=screen->pitch*40;
+        if (videomode_emulatemode == 1) {
+            int i;
+
+            for (i = 0; i < 40; i++) {
+                SDL_memset (screen->pixels + screen->pitch * i, 0x00,
+                            screen->pitch);
+            }
+            for (i = 440; i < 480; i++) {
+                SDL_memset (screen->pixels + screen->pitch * i, 0x00,
+                            screen->pitch);
+            }
+            screen->pixels += screen->pitch * 40;
+        }
+        PgSwapDisplay (OCImage.offscreen_backcontext, 0);
+    } else {
+        OCImage.current = 0;
+        PhDCSetCurrent (OCImage.offscreen_context);
+        screen->pitch = OCImage.offscreen_context->pitch;
+        screen->pixels = OCImage.FrameData0;
+
+        /* emulate 640x400 videomode */
+        if (videomode_emulatemode == 1) {
+            int i;
+
+            for (i = 0; i < 40; i++) {
+                SDL_memset (screen->pixels + screen->pitch * i, 0x00,
+                            screen->pitch);
+            }
+            for (i = 440; i < 480; i++) {
+                SDL_memset (screen->pixels + screen->pitch * i, 0x00,
+                            screen->pitch);
+            }
+            screen->pixels += screen->pitch * 40;
         }
     }
 
     this->UpdateRects = ph_OCDCUpdate;
 
     /* wait for the hardware */
-    PgFlush();
-    PgWaitHWIdle();
+    PgFlush ();
+    PgWaitHWIdle ();
 
     return 0;
 }
 
 #if SDL_VIDEO_OPENGL
 
-int ph_SetupOpenGLImage(_THIS, SDL_Surface* screen)
+int
+ph_SetupOpenGLImage (_THIS, SDL_Surface * screen)
 {
     this->UpdateRects = ph_OpenGLUpdate;
-    screen->pixels=NULL;
-    screen->pitch=NULL;
+    screen->pixels = NULL;
+    screen->pitch = NULL;
 
-    #if (_NTO_VERSION >= 630)
-        if ((screen->flags & SDL_FULLSCREEN) == SDL_FULLSCREEN)
-        {
-            if (!ph_EnterFullScreen(this, screen, PH_IGNORE_DIRECTMODE))
-            {
-                screen->flags &= ~SDL_FULLSCREEN;
-                return -1;
-            }
+#if (_NTO_VERSION >= 630)
+    if ((screen->flags & SDL_FULLSCREEN) == SDL_FULLSCREEN) {
+        if (!ph_EnterFullScreen (this, screen, PH_IGNORE_DIRECTMODE)) {
+            screen->flags &= ~SDL_FULLSCREEN;
+            return -1;
         }
-    #endif /* 6.3.0 */
+    }
+#endif /* 6.3.0 */
 
-    if (ph_SetupOpenGLContext(this, screen->w, screen->h, screen->format->BitsPerPixel, screen->flags)!=0)
-    {
+    if (ph_SetupOpenGLContext
+        (this, screen->w, screen->h, screen->format->BitsPerPixel,
+         screen->flags) != 0) {
         screen->flags &= ~SDL_INTERNALOPENGL;
         return -1;
     }
-   
+
     return 0;
 }
 
 #endif /* SDL_VIDEO_OPENGL */
 
-void ph_DestroyImage(_THIS, SDL_Surface* screen)
+void
+ph_DestroyImage (_THIS, SDL_Surface * screen)
 {
 
 #if SDL_VIDEO_OPENGL
-    if (screen->flags & SDL_INTERNALOPENGL)
-    {
-        if (oglctx)
-        {
-            #if (_NTO_VERSION < 630)
-                PhDCSetCurrent(NULL);
-                PhDCRelease(oglctx);
-            #else
-                qnxgl_context_destroy(oglctx);
-                qnxgl_buffers_destroy(oglbuffers);
-                qnxgl_finish();
-            #endif /* 6.3.0 */
-            oglctx=NULL;
-            oglbuffers=NULL;
-            oglflags=0;
-            oglbpp=0;
+    if (screen->flags & SDL_INTERNALOPENGL) {
+        if (oglctx) {
+#if (_NTO_VERSION < 630)
+            PhDCSetCurrent (NULL);
+            PhDCRelease (oglctx);
+#else
+            qnxgl_context_destroy (oglctx);
+            qnxgl_buffers_destroy (oglbuffers);
+            qnxgl_finish ();
+#endif /* 6.3.0 */
+            oglctx = NULL;
+            oglbuffers = NULL;
+            oglflags = 0;
+            oglbpp = 0;
         }
-
-        #if (_NTO_VERSION >= 630)
-            if (currently_fullscreen)
-            {
-                ph_LeaveFullScreen(this);
-            }
-        #endif /* 6.3.0 */
+#if (_NTO_VERSION >= 630)
+        if (currently_fullscreen) {
+            ph_LeaveFullScreen (this);
+        }
+#endif /* 6.3.0 */
 
         return;
     }
 #endif /* SDL_VIDEO_OPENGL */
 
-    if (currently_fullscreen)
-    {
+    if (currently_fullscreen) {
         /* if we right now in 8bpp fullscreen we must release palette */
-        if ((screen->format->BitsPerPixel==8) && (desktopbpp!=8))
-        {
-            PgSetPalette(syspalph, 0, -1, 0, 0, 0);
-            PgSetPalette(savedpal, 0, 0, _Pg_MAX_PALETTE, Pg_PALSET_GLOBAL | Pg_PALSET_FORCE_EXPOSE, 0);
-            PgFlush();
+        if ((screen->format->BitsPerPixel == 8) && (desktopbpp != 8)) {
+            PgSetPalette (syspalph, 0, -1, 0, 0, 0);
+            PgSetPalette (savedpal, 0, 0, _Pg_MAX_PALETTE,
+                          Pg_PALSET_GLOBAL | Pg_PALSET_FORCE_EXPOSE, 0);
+            PgFlush ();
         }
-        ph_LeaveFullScreen(this);
+        ph_LeaveFullScreen (this);
     }
 
-    if (OCImage.offscreen_context != NULL)
-    {
-        PhDCRelease(OCImage.offscreen_context);
+    if (OCImage.offscreen_context != NULL) {
+        PhDCRelease (OCImage.offscreen_context);
         OCImage.offscreen_context = NULL;
         OCImage.FrameData0 = NULL;
     }
-    if (OCImage.offscreen_backcontext != NULL)
-    {
-        PhDCRelease(OCImage.offscreen_backcontext);
+    if (OCImage.offscreen_backcontext != NULL) {
+        PhDCRelease (OCImage.offscreen_backcontext);
         OCImage.offscreen_backcontext = NULL;
         OCImage.FrameData1 = NULL;
     }
     OCImage.CurrentFrameData = NULL;
 
-    if (SDL_Image)
-    {
+    if (SDL_Image) {
         /* if palette allocated, free it */
-        if (SDL_Image->palette)
-        {
-            SDL_free(SDL_Image->palette);
+        if (SDL_Image->palette) {
+            SDL_free (SDL_Image->palette);
         }
-        PgShmemDestroy(SDL_Image->image);
-        SDL_free(SDL_Image);
+        PgShmemDestroy (SDL_Image->image);
+        SDL_free (SDL_Image);
     }
 
     /* Must be zeroed everytime */
     SDL_Image = NULL;
 
-    if (screen)
-    {
+    if (screen) {
         screen->pixels = NULL;
     }
 }
 
-int ph_UpdateHWInfo(_THIS)
+int
+ph_UpdateHWInfo (_THIS)
 {
     PgVideoModeInfo_t vmode;
     PgHWCaps_t hwcaps;
 
     /* Update video ram amount */
-    if (PgGetGraphicsHWCaps(&hwcaps) < 0)
-    {
-        SDL_SetError("ph_UpdateHWInfo(): GetGraphicsHWCaps() function failed !\n");
+    if (PgGetGraphicsHWCaps (&hwcaps) < 0) {
+        SDL_SetError
+            ("ph_UpdateHWInfo(): GetGraphicsHWCaps() function failed !\n");
         return -1;
     }
-    this->info.video_mem=hwcaps.currently_available_video_ram/1024;
+    this->info.video_mem = hwcaps.currently_available_video_ram / 1024;
 
     /* obtain current mode capabilities */
-    if (PgGetVideoModeInfo(hwcaps.current_video_mode, &vmode) < 0)
-    {
-        SDL_SetError("ph_UpdateHWInfo(): GetVideoModeInfo() function failed !\n");
+    if (PgGetVideoModeInfo (hwcaps.current_video_mode, &vmode) < 0) {
+        SDL_SetError
+            ("ph_UpdateHWInfo(): GetVideoModeInfo() function failed !\n");
         return -1;
     }
 
-    if ((vmode.mode_capabilities1 & PgVM_MODE_CAP1_OFFSCREEN) == PgVM_MODE_CAP1_OFFSCREEN)
-    {
+    if ((vmode.mode_capabilities1 & PgVM_MODE_CAP1_OFFSCREEN) ==
+        PgVM_MODE_CAP1_OFFSCREEN) {
         /* this is a special test for drivers which tries to lie about offscreen capability */
-        if (hwcaps.currently_available_video_ram!=0)
-        {
-           this->info.hw_available = 1;
+        if (hwcaps.currently_available_video_ram != 0) {
+            this->info.hw_available = 1;
+        } else {
+            this->info.hw_available = 0;
         }
-        else
-        {
-           this->info.hw_available = 0;
-        }
-    }
-    else
-    {
+    } else {
         this->info.hw_available = 0;
     }
 
-    if ((vmode.mode_capabilities2 & PgVM_MODE_CAP2_RECTANGLE) == PgVM_MODE_CAP2_RECTANGLE)
-    {
+    if ((vmode.mode_capabilities2 & PgVM_MODE_CAP2_RECTANGLE) ==
+        PgVM_MODE_CAP2_RECTANGLE) {
         this->info.blit_fill = 1;
-    }
-    else
-    {
+    } else {
         this->info.blit_fill = 0;
     }
 
-    if ((vmode.mode_capabilities2 & PgVM_MODE_CAP2_BITBLT) == PgVM_MODE_CAP2_BITBLT)
-    {
+    if ((vmode.mode_capabilities2 & PgVM_MODE_CAP2_BITBLT) ==
+        PgVM_MODE_CAP2_BITBLT) {
         this->info.blit_hw = 1;
-    }
-    else
-    {
+    } else {
         this->info.blit_hw = 0;
     }
 
-    if ((vmode.mode_capabilities2 & PgVM_MODE_CAP2_ALPHA_BLEND) == PgVM_MODE_CAP2_ALPHA_BLEND)
-    {
+    if ((vmode.mode_capabilities2 & PgVM_MODE_CAP2_ALPHA_BLEND) ==
+        PgVM_MODE_CAP2_ALPHA_BLEND) {
         this->info.blit_hw_A = 1;
-    }
-    else
-    {
+    } else {
         this->info.blit_hw_A = 0;
     }
-    
-    if ((vmode.mode_capabilities2 & PgVM_MODE_CAP2_CHROMA) == PgVM_MODE_CAP2_CHROMA)
-    {
+
+    if ((vmode.mode_capabilities2 & PgVM_MODE_CAP2_CHROMA) ==
+        PgVM_MODE_CAP2_CHROMA) {
         this->info.blit_hw_CC = 1;
-    }
-    else
-    {
+    } else {
         this->info.blit_hw_CC = 0;
     }
-    
+
     return 0;
 }
 
-int ph_SetupUpdateFunction(_THIS, SDL_Surface* screen, Uint32 flags)
+int
+ph_SetupUpdateFunction (_THIS, SDL_Surface * screen, Uint32 flags)
 {
-    int setupresult=-1;
+    int setupresult = -1;
 
-    ph_DestroyImage(this, screen);
-    
+    ph_DestroyImage (this, screen);
+
 #if SDL_VIDEO_OPENGL
-    if (flags & SDL_INTERNALOPENGL)
-    {
-        setupresult=ph_SetupOpenGLImage(this, screen);
-    }
-    else
-    {
+    if (flags & SDL_INTERNALOPENGL) {
+        setupresult = ph_SetupOpenGLImage (this, screen);
+    } else {
 #endif
-       if ((flags & SDL_FULLSCREEN)==SDL_FULLSCREEN)
-       {
-           setupresult=ph_SetupFullScreenImage(this, screen);
-       }
-       else
-       {
-          if ((flags & SDL_HWSURFACE)==SDL_HWSURFACE)
-          {
-              setupresult=ph_SetupOCImage(this, screen);
-          }
-          else
-          {
-              setupresult=ph_SetupImage(this, screen);
-          }
-       }
+        if ((flags & SDL_FULLSCREEN) == SDL_FULLSCREEN) {
+            setupresult = ph_SetupFullScreenImage (this, screen);
+        } else {
+            if ((flags & SDL_HWSURFACE) == SDL_HWSURFACE) {
+                setupresult = ph_SetupOCImage (this, screen);
+            } else {
+                setupresult = ph_SetupImage (this, screen);
+            }
+        }
 #if SDL_VIDEO_OPENGL
     }
 #endif
-    if (setupresult!=-1)
-    {
-       ph_UpdateHWInfo(this);
+    if (setupresult != -1) {
+        ph_UpdateHWInfo (this);
     }
-    
+
     return setupresult;
 }
 
-int ph_AllocHWSurface(_THIS, SDL_Surface* surface)
+int
+ph_AllocHWSurface (_THIS, SDL_Surface * surface)
 {
     PgHWCaps_t hwcaps;
 
-    if (surface->hwdata!=NULL)
-    {
-       SDL_SetError("ph_AllocHWSurface(): hwdata already exists!\n");
-       return -1;
+    if (surface->hwdata != NULL) {
+        SDL_SetError ("ph_AllocHWSurface(): hwdata already exists!\n");
+        return -1;
     }
-    surface->hwdata=SDL_malloc(sizeof(struct private_hwdata));
-    SDL_memset(surface->hwdata, 0x00, sizeof(struct private_hwdata));
-    surface->hwdata->offscreenctx=PdCreateOffscreenContext(0, surface->w, surface->h, Pg_OSC_MEM_PAGE_ALIGN);
-    if (surface->hwdata->offscreenctx == NULL)
-    {
-        SDL_SetError("ph_AllocHWSurface(): PdCreateOffscreenContext() function failed !\n");
+    surface->hwdata = SDL_malloc (sizeof (struct private_hwdata));
+    SDL_memset (surface->hwdata, 0x00, sizeof (struct private_hwdata));
+    surface->hwdata->offscreenctx =
+        PdCreateOffscreenContext (0, surface->w, surface->h,
+                                  Pg_OSC_MEM_PAGE_ALIGN);
+    if (surface->hwdata->offscreenctx == NULL) {
+        SDL_SetError
+            ("ph_AllocHWSurface(): PdCreateOffscreenContext() function failed !\n");
         return -1;
     }
-    surface->pixels=PdGetOffscreenContextPtr(surface->hwdata->offscreenctx);
-    if (surface->pixels==NULL)
-    {
-        PhDCRelease(surface->hwdata->offscreenctx);
-        SDL_SetError("ph_AllocHWSurface(): PdGetOffscreenContextPtr() function failed !\n");
+    surface->pixels =
+        PdGetOffscreenContextPtr (surface->hwdata->offscreenctx);
+    if (surface->pixels == NULL) {
+        PhDCRelease (surface->hwdata->offscreenctx);
+        SDL_SetError
+            ("ph_AllocHWSurface(): PdGetOffscreenContextPtr() function failed !\n");
         return -1;
     }
-    surface->pitch=surface->hwdata->offscreenctx->pitch;
-    surface->flags|=SDL_HWSURFACE;
-    surface->flags|=SDL_PREALLOC;
-    
-#if 0 /* FIXME */
+    surface->pitch = surface->hwdata->offscreenctx->pitch;
+    surface->flags |= SDL_HWSURFACE;
+    surface->flags |= SDL_PREALLOC;
+
+#if 0                           /* FIXME */
     /* create simple offscreen lock */
-    surface->hwdata->crlockparam.flags=0;
-    if (PdCreateOffscreenLock(surface->hwdata->offscreenctx, &surface->hwdata->crlockparam)!=EOK)
+    surface->hwdata->crlockparam.flags = 0;
+    if (PdCreateOffscreenLock
+        (surface->hwdata->offscreenctx, &surface->hwdata->crlockparam) != EOK)
     {
-        PhDCRelease(surface->hwdata->offscreenctx);
-        SDL_SetError("ph_AllocHWSurface(): Can't create offscreen lock !\n");
+        PhDCRelease (surface->hwdata->offscreenctx);
+        SDL_SetError ("ph_AllocHWSurface(): Can't create offscreen lock !\n");
         return -1;
     }
 #endif /* 0 */
 
     /* Update video ram amount */
-    if (PgGetGraphicsHWCaps(&hwcaps) < 0)
-    {
-        PdDestroyOffscreenLock(surface->hwdata->offscreenctx);
-        PhDCRelease(surface->hwdata->offscreenctx);
-        SDL_SetError("ph_AllocHWSurface(): GetGraphicsHWCaps() function failed !\n");
+    if (PgGetGraphicsHWCaps (&hwcaps) < 0) {
+        PdDestroyOffscreenLock (surface->hwdata->offscreenctx);
+        PhDCRelease (surface->hwdata->offscreenctx);
+        SDL_SetError
+            ("ph_AllocHWSurface(): GetGraphicsHWCaps() function failed !\n");
         return -1;
     }
-    this->info.video_mem=hwcaps.currently_available_video_ram/1024;
+    this->info.video_mem = hwcaps.currently_available_video_ram / 1024;
 
     return 0;
 }
 
-void ph_FreeHWSurface(_THIS, SDL_Surface* surface)
+void
+ph_FreeHWSurface (_THIS, SDL_Surface * surface)
 {
     PgHWCaps_t hwcaps;
 
-    if (surface->hwdata==NULL)
-    {
-       SDL_SetError("ph_FreeHWSurface(): no hwdata!\n");
-       return;
+    if (surface->hwdata == NULL) {
+        SDL_SetError ("ph_FreeHWSurface(): no hwdata!\n");
+        return;
     }
-    if (surface->hwdata->offscreenctx == NULL)
-    {
-       SDL_SetError("ph_FreeHWSurface(): no offscreen context to delete!\n");
-       return;
+    if (surface->hwdata->offscreenctx == NULL) {
+        SDL_SetError
+            ("ph_FreeHWSurface(): no offscreen context to delete!\n");
+        return;
+    }
+#if 0                           /* FIXME */
+    /* unlock the offscreen context if it has been locked before destroy it */
+    if (PdIsOffscreenLocked (surface->hwdata->offscreenctx) == Pg_OSC_LOCKED) {
+        PdUnlockOffscreen (surface->hwdata->offscreenctx);
     }
 
-#if 0 /* FIXME */
-    /* unlock the offscreen context if it has been locked before destroy it */
-    if (PdIsOffscreenLocked(surface->hwdata->offscreenctx)==Pg_OSC_LOCKED)
-    {
-       PdUnlockOffscreen(surface->hwdata->offscreenctx);
-    }
-
-    PdDestroyOffscreenLock(surface->hwdata->offscreenctx);
+    PdDestroyOffscreenLock (surface->hwdata->offscreenctx);
 #endif /* 0 */
 
-    PhDCRelease(surface->hwdata->offscreenctx);
-    
-    SDL_free(surface->hwdata);
-    surface->hwdata=NULL;
+    PhDCRelease (surface->hwdata->offscreenctx);
+
+    SDL_free (surface->hwdata);
+    surface->hwdata = NULL;
 
     /* Update video ram amount */
-    if (PgGetGraphicsHWCaps(&hwcaps) < 0)
-    {
-        SDL_SetError("ph_FreeHWSurface(): GetGraphicsHWCaps() function failed !\n");
+    if (PgGetGraphicsHWCaps (&hwcaps) < 0) {
+        SDL_SetError
+            ("ph_FreeHWSurface(): GetGraphicsHWCaps() function failed !\n");
         return;
     }
-    this->info.video_mem=hwcaps.currently_available_video_ram/1024;
+    this->info.video_mem = hwcaps.currently_available_video_ram / 1024;
 
     return;
 }
 
-int ph_CheckHWBlit(_THIS, SDL_Surface *src, SDL_Surface *dst)
+int
+ph_CheckHWBlit (_THIS, SDL_Surface * src, SDL_Surface * dst)
 {
-   if ((src->hwdata==NULL) && (src != this->screen))
-   {
-      SDL_SetError("ph_CheckHWBlit(): Source surface haven't hardware specific data.\n");
-      src->flags&=~SDL_HWACCEL;
-      return -1;
-   }
-   if ((src->flags & SDL_HWSURFACE) != SDL_HWSURFACE)
-   {
-      SDL_SetError("ph_CheckHWBlit(): Source surface isn't a hardware surface.\n");
-      src->flags&=~SDL_HWACCEL;
-      return -1;
-   }
+    if ((src->hwdata == NULL) && (src != this->screen)) {
+        SDL_SetError
+            ("ph_CheckHWBlit(): Source surface haven't hardware specific data.\n");
+        src->flags &= ~SDL_HWACCEL;
+        return -1;
+    }
+    if ((src->flags & SDL_HWSURFACE) != SDL_HWSURFACE) {
+        SDL_SetError
+            ("ph_CheckHWBlit(): Source surface isn't a hardware surface.\n");
+        src->flags &= ~SDL_HWACCEL;
+        return -1;
+    }
 
-   if ((src->flags & SDL_SRCCOLORKEY) == SDL_SRCCOLORKEY)
-   {
-       if (this->info.blit_hw_CC!=1)
-       {
-           src->flags&=~SDL_HWACCEL;
-           src->map->hw_blit=NULL;
-           return -1;
-       }
-   }
+    if ((src->flags & SDL_SRCCOLORKEY) == SDL_SRCCOLORKEY) {
+        if (this->info.blit_hw_CC != 1) {
+            src->flags &= ~SDL_HWACCEL;
+            src->map->hw_blit = NULL;
+            return -1;
+        }
+    }
 
-   if ((src->flags & SDL_SRCALPHA) == SDL_SRCALPHA)
-   {
-       if (this->info.blit_hw_A!=1)
-       {
-           src->flags&=~SDL_HWACCEL;
-           src->map->hw_blit=NULL;
-           return -1;
-       }
-   }
+    if ((src->flags & SDL_SRCALPHA) == SDL_SRCALPHA) {
+        if (this->info.blit_hw_A != 1) {
+            src->flags &= ~SDL_HWACCEL;
+            src->map->hw_blit = NULL;
+            return -1;
+        }
+    }
 
-   src->flags|=SDL_HWACCEL;
-   src->map->hw_blit = ph_HWAccelBlit;
+    src->flags |= SDL_HWACCEL;
+    src->map->hw_blit = ph_HWAccelBlit;
 
-   return 1;
+    return 1;
 }
 
-PgColor_t ph_ExpandColor(_THIS, SDL_Surface* surface, Uint32 color)
+PgColor_t
+ph_ExpandColor (_THIS, SDL_Surface * surface, Uint32 color)
 {
     Uint32 truecolor;
 
     /* Photon API accepts true colors only during hw filling operations */
-    switch(surface->format->BitsPerPixel)
-    {
-       case 8:
-            {
-                if ((surface->format->palette) && (color<=surface->format->palette->ncolors))
-                {
-                    truecolor=PgRGB(surface->format->palette->colors[color].r,
-                                    surface->format->palette->colors[color].g,
-                                    surface->format->palette->colors[color].b);
-                }
-                else
-                {
-                    SDL_SetError("ph_ExpandColor(): Color out of range for the 8bpp mode !\n");
-                    return 0xFFFFFFFFUL;
-                }
-            }
-            break;
-       case 15: 
-            {
-                truecolor = ((color & 0x00007C00UL) << 9) |   /* R */
-                            ((color & 0x000003E0UL) << 6) |   /* G */
-                            ((color & 0x0000001FUL) << 3) |   /* B */
-                            ((color & 0x00007000UL) << 4) |   /* R compensation */
-                            ((color & 0x00000380UL) << 1) |   /* G compensation */
-                            ((color & 0x0000001CUL) >> 2);    /* B compensation */
-            }
-            break;
-       case 16: 
-            {
-                truecolor = ((color & 0x0000F800UL) << 8) |   /* R */
-                            ((color & 0x000007E0UL) << 5) |   /* G */
-                            ((color & 0x0000001FUL) << 3) |   /* B */
-                            ((color & 0x0000E000UL) << 3) |   /* R compensation */
-                            ((color & 0x00000600UL) >> 1) |   /* G compensation */
-                            ((color & 0x0000001CUL) >> 2);    /* B compensation */
-
-            }
-            break;
-       case 24: 
-            {
-                truecolor=color & 0x00FFFFFFUL;
-            }
-            break;
-       case 32: 
-            {
-                truecolor=color;
-            }
-            break;
-       default:
-            {
-                SDL_SetError("ph_ExpandColor(): Unsupported depth for the hardware operations !\n");
+    switch (surface->format->BitsPerPixel) {
+    case 8:
+        {
+            if ((surface->format->palette)
+                && (color <= surface->format->palette->ncolors)) {
+                truecolor =
+                    PgRGB (surface->format->palette->colors[color].r,
+                           surface->format->palette->colors[color].g,
+                           surface->format->palette->colors[color].b);
+            } else {
+                SDL_SetError
+                    ("ph_ExpandColor(): Color out of range for the 8bpp mode !\n");
                 return 0xFFFFFFFFUL;
             }
+        }
+        break;
+    case 15:
+        {
+            truecolor = ((color & 0x00007C00UL) << 9) | /* R */
+                ((color & 0x000003E0UL) << 6) | /* G */
+                ((color & 0x0000001FUL) << 3) | /* B */
+                ((color & 0x00007000UL) << 4) | /* R compensation */
+                ((color & 0x00000380UL) << 1) | /* G compensation */
+                ((color & 0x0000001CUL) >> 2);  /* B compensation */
+        }
+        break;
+    case 16:
+        {
+            truecolor = ((color & 0x0000F800UL) << 8) | /* R */
+                ((color & 0x000007E0UL) << 5) | /* G */
+                ((color & 0x0000001FUL) << 3) | /* B */
+                ((color & 0x0000E000UL) << 3) | /* R compensation */
+                ((color & 0x00000600UL) >> 1) | /* G compensation */
+                ((color & 0x0000001CUL) >> 2);  /* B compensation */
+
+        }
+        break;
+    case 24:
+        {
+            truecolor = color & 0x00FFFFFFUL;
+        }
+        break;
+    case 32:
+        {
+            truecolor = color;
+        }
+        break;
+    default:
+        {
+            SDL_SetError
+                ("ph_ExpandColor(): Unsupported depth for the hardware operations !\n");
+            return 0xFFFFFFFFUL;
+        }
     }
 
     return truecolor;
 }
 
-int ph_FillHWRect(_THIS, SDL_Surface* surface, SDL_Rect* rect, Uint32 color)
+int
+ph_FillHWRect (_THIS, SDL_Surface * surface, SDL_Rect * rect, Uint32 color)
 {
     PgColor_t oldcolor;
     Uint32 truecolor;
-    int ydisp=0;
+    int ydisp = 0;
 
-    if (this->info.blit_fill!=1)
-    {
-       return -1;
+    if (this->info.blit_fill != 1) {
+        return -1;
     }
 
-    truecolor=ph_ExpandColor(this, surface, color);
-    if (truecolor==0xFFFFFFFFUL)
-    {
+    truecolor = ph_ExpandColor (this, surface, color);
+    if (truecolor == 0xFFFFFFFFUL) {
         return -1;
     }
 
-    oldcolor=PgSetFillColor(truecolor);
+    oldcolor = PgSetFillColor (truecolor);
 
     /* 640x400 videomode emulation */
-    if (videomode_emulatemode==1)
-    {
-        ydisp+=40;
+    if (videomode_emulatemode == 1) {
+        ydisp += 40;
     }
 
-    PgDrawIRect(rect->x, rect->y+ydisp, rect->w+rect->x-1, rect->h+rect->y+ydisp-1, Pg_DRAW_FILL);
-    PgSetFillColor(oldcolor);
-    PgFlush();
-    PgWaitHWIdle();
+    PgDrawIRect (rect->x, rect->y + ydisp, rect->w + rect->x - 1,
+                 rect->h + rect->y + ydisp - 1, Pg_DRAW_FILL);
+    PgSetFillColor (oldcolor);
+    PgFlush ();
+    PgWaitHWIdle ();
 
     return 0;
 }
 
-int ph_FlipHWSurface(_THIS, SDL_Surface* screen)
+int
+ph_FlipHWSurface (_THIS, SDL_Surface * screen)
 {
     PhArea_t farea;
 
-    if ((screen->flags & SDL_FULLSCREEN) == SDL_FULLSCREEN)
-    {
+    if ((screen->flags & SDL_FULLSCREEN) == SDL_FULLSCREEN) {
         /* flush all drawing ops before blitting */
-        PgFlush();
-        PgWaitHWIdle();
+        PgFlush ();
+        PgWaitHWIdle ();
 
-        farea.pos.x=0;
-        farea.pos.y=0;
-        farea.size.w=screen->w;
-        farea.size.h=screen->h;
+        farea.pos.x = 0;
+        farea.pos.y = 0;
+        farea.size.w = screen->w;
+        farea.size.h = screen->h;
 
         /* emulate 640x400 videomode */
-        if (videomode_emulatemode==1)
-        {
-            farea.pos.y+=40;
+        if (videomode_emulatemode == 1) {
+            farea.pos.y += 40;
         }
 
-        PgContextBlitArea(OCImage.offscreen_context, &farea, OCImage.offscreen_backcontext, &farea);
+        PgContextBlitArea (OCImage.offscreen_context, &farea,
+                           OCImage.offscreen_backcontext, &farea);
 
         /* flush the blitting */
-        PgFlush();
-        PgWaitHWIdle();
+        PgFlush ();
+        PgWaitHWIdle ();
     }
     return 0;
 }
 
-int ph_LockHWSurface(_THIS, SDL_Surface* surface)
+int
+ph_LockHWSurface (_THIS, SDL_Surface * surface)
 {
 
-#if 0 /* FIXME */
+#if 0                           /* FIXME */
     int lockresult;
 
-    if (surface->hwdata == NULL)
-    {
+    if (surface->hwdata == NULL) {
         return;
     }
 
-    surface->hwdata->lockparam.flags=0;
-    surface->hwdata->lockparam.time_out=NULL;
-    lockresult=PdLockOffscreen(surface->hwdata->offscreenctx, &surface->hwdata->lockparam);
+    surface->hwdata->lockparam.flags = 0;
+    surface->hwdata->lockparam.time_out = NULL;
+    lockresult =
+        PdLockOffscreen (surface->hwdata->offscreenctx,
+                         &surface->hwdata->lockparam);
 
-    switch (lockresult)
-    {
-       case EOK:
-                 break;
-       case Pg_OSC_LOCK_DEADLOCK: 
-                 SDL_SetError("ph_LockHWSurface(): Deadlock detected !\n");
-                 return -1;
-       case Pg_OSC_LOCK_INVALID:
-                 SDL_SetError("ph_LockHWSurface(): Lock invalid !\n");
-                 return -1;
-       default:
-                 SDL_SetError("ph_LockHWSurface(): Can't lock the surface !\n");
-                 return -1;
+    switch (lockresult) {
+    case EOK:
+        break;
+    case Pg_OSC_LOCK_DEADLOCK:
+        SDL_SetError ("ph_LockHWSurface(): Deadlock detected !\n");
+        return -1;
+    case Pg_OSC_LOCK_INVALID:
+        SDL_SetError ("ph_LockHWSurface(): Lock invalid !\n");
+        return -1;
+    default:
+        SDL_SetError ("ph_LockHWSurface(): Can't lock the surface !\n");
+        return -1;
     }
 #endif /* 0 */
 
     return 0;
 }
 
-void ph_UnlockHWSurface(_THIS, SDL_Surface* surface)
+void
+ph_UnlockHWSurface (_THIS, SDL_Surface * surface)
 {
 
-#if 0 /* FIXME */
+#if 0                           /* FIXME */
     int unlockresult;
 
-    if ((surface == NULL) || (surface->hwdata == NULL))
-    {
+    if ((surface == NULL) || (surface->hwdata == NULL)) {
         return;
     }
 
-    if (PdIsOffscreenLocked(surface->hwdata->offscreenctx)==Pg_OSC_LOCKED)
-    {
-        unlockresult=PdUnlockOffscreen(surface->hwdata->offscreenctx);
+    if (PdIsOffscreenLocked (surface->hwdata->offscreenctx) == Pg_OSC_LOCKED) {
+        unlockresult = PdUnlockOffscreen (surface->hwdata->offscreenctx);
     }
 #endif /* 0 */
 
     return;
 }
 
-int ph_HWAccelBlit(SDL_Surface* src, SDL_Rect* srcrect, SDL_Surface* dst, SDL_Rect* dstrect)
+int
+ph_HWAccelBlit (SDL_Surface * src, SDL_Rect * srcrect, SDL_Surface * dst,
+                SDL_Rect * dstrect)
 {
-    SDL_VideoDevice* this=current_video;
+    SDL_VideoDevice *this = current_video;
     PhArea_t srcarea;
     PhArea_t dstarea;
-    int ydisp=0;
+    int ydisp = 0;
 
     /* 640x400 videomode emulation */
-    if (videomode_emulatemode==1)
-    {
-       ydisp+=40;
+    if (videomode_emulatemode == 1) {
+        ydisp += 40;
     }
 
-    srcarea.pos.x=srcrect->x;
-    srcarea.pos.y=srcrect->y;
-    srcarea.size.w=srcrect->w;
-    srcarea.size.h=srcrect->h;
+    srcarea.pos.x = srcrect->x;
+    srcarea.pos.y = srcrect->y;
+    srcarea.size.w = srcrect->w;
+    srcarea.size.h = srcrect->h;
 
-    dstarea.pos.x=dstrect->x;
-    dstarea.pos.y=dstrect->y;
-    dstarea.size.w=dstrect->w;
-    dstarea.size.h=dstrect->h;
+    dstarea.pos.x = dstrect->x;
+    dstarea.pos.y = dstrect->y;
+    dstarea.size.w = dstrect->w;
+    dstarea.size.h = dstrect->h;
 
-    if (((src == this->screen) || (src->hwdata!=NULL)) && ((dst == this->screen) || (dst->hwdata!=NULL)))
-    {
-        if ((src->flags & SDL_SRCCOLORKEY) == SDL_SRCCOLORKEY)
-        {
-            ph_SetHWColorKey(this, src, src->format->colorkey);
-            PgChromaOn();
+    if (((src == this->screen) || (src->hwdata != NULL))
+        && ((dst == this->screen) || (dst->hwdata != NULL))) {
+        if ((src->flags & SDL_SRCCOLORKEY) == SDL_SRCCOLORKEY) {
+            ph_SetHWColorKey (this, src, src->format->colorkey);
+            PgChromaOn ();
         }
 
-        if ((src->flags & SDL_SRCALPHA) == SDL_SRCALPHA)
-        {
-            ph_SetHWAlpha(this, src, src->format->alpha);
-            PgAlphaOn();
+        if ((src->flags & SDL_SRCALPHA) == SDL_SRCALPHA) {
+            ph_SetHWAlpha (this, src, src->format->alpha);
+            PgAlphaOn ();
         }
 
-        if (dst == this->screen)
-        {
-            if (src == this->screen)
-            {
+        if (dst == this->screen) {
+            if (src == this->screen) {
                 /* blitting from main screen to main screen */
-                dstarea.pos.y+=ydisp;
-                srcarea.pos.y+=ydisp;
-                PgContextBlitArea(OCImage.offscreen_context, &srcarea, OCImage.offscreen_context, &dstarea);
-            }
-            else
-            {
+                dstarea.pos.y += ydisp;
+                srcarea.pos.y += ydisp;
+                PgContextBlitArea (OCImage.offscreen_context, &srcarea,
+                                   OCImage.offscreen_context, &dstarea);
+            } else {
                 /* blitting from offscreen to main screen */
-                dstarea.pos.y+=ydisp;
-                PgContextBlitArea(src->hwdata->offscreenctx, &srcarea, OCImage.offscreen_context, &dstarea);
+                dstarea.pos.y += ydisp;
+                PgContextBlitArea (src->hwdata->offscreenctx, &srcarea,
+                                   OCImage.offscreen_context, &dstarea);
             }
-        }
-        else
-        {
-            if (src == this->screen)
-            {
+        } else {
+            if (src == this->screen) {
                 /* blitting from main screen to offscreen */
-                srcarea.pos.y+=ydisp;
-                PgContextBlitArea(OCImage.offscreen_context, &srcarea, dst->hwdata->offscreenctx, &dstarea);
-            }
-            else
-            {
+                srcarea.pos.y += ydisp;
+                PgContextBlitArea (OCImage.offscreen_context, &srcarea,
+                                   dst->hwdata->offscreenctx, &dstarea);
+            } else {
                 /* blitting offscreen to offscreen */
-                PgContextBlitArea(src->hwdata->offscreenctx, &srcarea, dst->hwdata->offscreenctx, &dstarea);
+                PgContextBlitArea (src->hwdata->offscreenctx, &srcarea,
+                                   dst->hwdata->offscreenctx, &dstarea);
             }
         }
 
-        if ((src->flags & SDL_SRCALPHA) == SDL_SRCALPHA)
-        {
-            PgAlphaOff();
+        if ((src->flags & SDL_SRCALPHA) == SDL_SRCALPHA) {
+            PgAlphaOff ();
         }
 
-        if ((src->flags & SDL_SRCCOLORKEY) == SDL_SRCCOLORKEY)
-        {
-            PgChromaOff();
+        if ((src->flags & SDL_SRCCOLORKEY) == SDL_SRCCOLORKEY) {
+            PgChromaOff ();
         }
-    }
-    else
-    {
-        SDL_SetError("ph_HWAccelBlit(): Source or target surface is not a hardware surface !\n");
+    } else {
+        SDL_SetError
+            ("ph_HWAccelBlit(): Source or target surface is not a hardware surface !\n");
         return -1;
     }
 
-    PgFlush();
-    PgWaitHWIdle();
+    PgFlush ();
+    PgWaitHWIdle ();
 
     return 0;
 }
 
-int ph_SetHWColorKey(_THIS, SDL_Surface *surface, Uint32 key)
+int
+ph_SetHWColorKey (_THIS, SDL_Surface * surface, Uint32 key)
 {
-    if (this->info.blit_hw_CC!=1)
-    {
-       return -1;
+    if (this->info.blit_hw_CC != 1) {
+        return -1;
     }
 
-    if (surface->hwdata!=NULL)
-    {
-        surface->hwdata->colorkey=ph_ExpandColor(this, surface, key);
-        if (surface->hwdata->colorkey==0xFFFFFFFFUL)
-        {
+    if (surface->hwdata != NULL) {
+        surface->hwdata->colorkey = ph_ExpandColor (this, surface, key);
+        if (surface->hwdata->colorkey == 0xFFFFFFFFUL) {
             return -1;
         }
     }
-    PgSetChroma(surface->hwdata->colorkey, Pg_CHROMA_SRC_MATCH | Pg_CHROMA_NODRAW);
+    PgSetChroma (surface->hwdata->colorkey,
+                 Pg_CHROMA_SRC_MATCH | Pg_CHROMA_NODRAW);
 
     return 0;
 }
 
-int ph_SetHWAlpha(_THIS, SDL_Surface* surface, Uint8 alpha)
+int
+ph_SetHWAlpha (_THIS, SDL_Surface * surface, Uint8 alpha)
 {
-    if (this->info.blit_hw_A!=1)
-    {
-       return -1;
+    if (this->info.blit_hw_A != 1) {
+        return -1;
     }
 
-    PgSetAlphaBlend(NULL, alpha);
+    PgSetAlphaBlend (NULL, alpha);
 
     return 0;
 }
 
 #if SDL_VIDEO_OPENGL
-void ph_OpenGLUpdate(_THIS, int numrects, SDL_Rect* rects)
+void
+ph_OpenGLUpdate (_THIS, int numrects, SDL_Rect * rects)
 {
-   this->GL_SwapBuffers(this);
-   
-   return;
+    this->GL_SwapBuffers (this);
+
+    return;
 }
 #endif /* SDL_VIDEO_OPENGL */
 
-void ph_NormalUpdate(_THIS, int numrects, SDL_Rect *rects)
+void
+ph_NormalUpdate (_THIS, int numrects, SDL_Rect * rects)
 {
     PhPoint_t ph_pos;
     PhRect_t ph_rect;
     int i;
 
-    for (i=0; i<numrects; ++i) 
-    {
-    	if (rects[i].w==0) /* Clipped? dunno why but this occurs sometime. */
-        { 
+    for (i = 0; i < numrects; ++i) {
+        if (rects[i].w == 0) {  /* Clipped? dunno why but this occurs sometime. */
             continue;
         }
 
-    	if (rects[i].h==0) /* Clipped? dunno why but this occurs sometime. */
-        { 
+        if (rects[i].h == 0) {  /* Clipped? dunno why but this occurs sometime. */
             continue;
         }
 
@@ -989,71 +966,69 @@
         ph_rect.lr.x = rects[i].x + rects[i].w;
         ph_rect.lr.y = rects[i].y + rects[i].h;
 
-        if (PgDrawPhImageRectmx(&ph_pos, SDL_Image, &ph_rect, 0) < 0)
-        {
-            SDL_SetError("ph_NormalUpdate(): PgDrawPhImageRectmx failed!\n");
+        if (PgDrawPhImageRectmx (&ph_pos, SDL_Image, &ph_rect, 0) < 0) {
+            SDL_SetError ("ph_NormalUpdate(): PgDrawPhImageRectmx failed!\n");
             return;
         }
     }
 
-    if (PgFlush() < 0)
-    {
-    	SDL_SetError("ph_NormalUpdate(): PgFlush() function failed!\n");
+    if (PgFlush () < 0) {
+        SDL_SetError ("ph_NormalUpdate(): PgFlush() function failed!\n");
     }
 }
 
-void ph_OCUpdate(_THIS, int numrects, SDL_Rect *rects)
+void
+ph_OCUpdate (_THIS, int numrects, SDL_Rect * rects)
 {
     int i;
 
-    PhPoint_t zero = {0, 0};
+    PhPoint_t zero = { 0, 0 };
     PhArea_t src_rect;
     PhArea_t dest_rect;
 
-    PgSetTranslation(&zero, 0);
-    PgSetRegion(PtWidgetRid(window));
-    PgSetClipping(0, NULL);
+    PgSetTranslation (&zero, 0);
+    PgSetRegion (PtWidgetRid (window));
+    PgSetClipping (0, NULL);
+
+    PgFlush ();
+    PgWaitHWIdle ();
 
-    PgFlush();
-    PgWaitHWIdle();
+    for (i = 0; i < numrects; ++i) {
+        if (rects[i].w == 0) {  /* Clipped? */
+            continue;
+        }
 
-    for (i=0; i<numrects; ++i)
-    {
-        if (rects[i].w == 0)  /* Clipped? */
-        {
+        if (rects[i].h == 0) {  /* Clipped? */
             continue;
         }
 
-        if (rects[i].h == 0)  /* Clipped? */
-        {
-            continue;
-        }
-        
-        src_rect.pos.x=rects[i].x;
-        src_rect.pos.y=rects[i].y;
-        dest_rect.pos.x=rects[i].x;
-        dest_rect.pos.y=rects[i].y;
+        src_rect.pos.x = rects[i].x;
+        src_rect.pos.y = rects[i].y;
+        dest_rect.pos.x = rects[i].x;
+        dest_rect.pos.y = rects[i].y;
 
-        src_rect.size.w=rects[i].w;
-        src_rect.size.h=rects[i].h;
-        dest_rect.size.w=rects[i].w;
-        dest_rect.size.h=rects[i].h;
-        
-        PgContextBlitArea(OCImage.offscreen_context, &src_rect, NULL, &dest_rect);
+        src_rect.size.w = rects[i].w;
+        src_rect.size.h = rects[i].h;
+        dest_rect.size.w = rects[i].w;
+        dest_rect.size.h = rects[i].h;
+
+        PgContextBlitArea (OCImage.offscreen_context, &src_rect, NULL,
+                           &dest_rect);
     }
 
-    if (PgFlush() < 0)
-    {
-        SDL_SetError("ph_OCUpdate(): PgFlush failed.\n");
+    if (PgFlush () < 0) {
+        SDL_SetError ("ph_OCUpdate(): PgFlush failed.\n");
     }
 }
 
-void ph_OCDCUpdate(_THIS, int numrects, SDL_Rect *rects)
+void
+ph_OCDCUpdate (_THIS, int numrects, SDL_Rect * rects)
 {
-    PgWaitHWIdle();
+    PgWaitHWIdle ();
 
-    if (PgFlush() < 0)
-    {
-        SDL_SetError("ph_OCDCUpdate(): PgFlush failed.\n");
+    if (PgFlush () < 0) {
+        SDL_SetError ("ph_OCDCUpdate(): PgFlush failed.\n");
     }
 }
+
+/* vi: set ts=4 sw=4 expandtab: */