/*
    Copyright 2005-2008 Intel Corporation.  All Rights Reserved.

    This file is part of Threading Building Blocks.

    Threading Building Blocks is free software; you can redistribute it
    and/or modify it under the terms of the GNU General Public License
    version 2 as published by the Free Software Foundation.

    Threading Building Blocks is distributed in the hope that it will be
    useful, but WITHOUT ANY WARRANTY; without even the implied warranty
    of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with Threading Building Blocks; if not, write to the Free Software
    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

    As a special exception, you may use this file as part of a free software
    library without restriction.  Specifically, if other files instantiate
    templates or use macros or inline functions from this file, or you compile
    this file and link it with other files to produce an executable, this
    file does not by itself cause the resulting executable to be covered by
    the GNU General Public License.  This exception does not however
    invalidate any other reasons why the executable file might be covered by
    the GNU General Public License.
*/

/*
 *  Based on "OpenGL Image" example from http://developer.apple.com/samplecode/OpenGL_Image/
 */

#include "video.h"
#include <sched.h>
#include <sys/time.h>
#include <stdio.h>
#include <string.h>
#include <pthread.h>

#include <AvailabilityMacros.h>
#undef DEPRECATED_ATTRIBUTE
#define DEPRECATED_ATTRIBUTE
#include <Carbon/Carbon.h>
#include <AGL/agl.h>
#include <OpenGL/gl.h>    // for OpenGL API
#include <OpenGL/glext.h> // for OpenGL extension support 

unsigned int *      g_pImg = 0;
int                 g_sizex, g_sizey;
WindowRef           g_window = 0;
static video *      g_video = 0;
static int          g_fps = 0;
struct timeval      g_time;
static pthread_mutex_t  g_mutex = PTHREAD_MUTEX_INITIALIZER;


static OSStatus     AppEventHandler( EventHandlerCallRef inCaller, EventRef inEvent, void* inRefcon );
WindowRef           HandleNew();
static OSStatus     WindowEventHandler( EventHandlerCallRef inCaller, EventRef inEvent, void* inRefcon );

static IBNibRef     sNibRef;

//-------------------------------------------------------------------------------------------- 

// structure for creating a fullscreen context
struct structGLInfo // storage for setup info
{
    SInt16 width;               // input: width of drawable (screen width in full screen mode), return: actual width allocated
    SInt16 height;              // input: height of drawable (screen height in full screen mode), return: actual height allocated
    UInt32 pixelDepth;          // input: requested pixel depth
    Boolean fDepthMust;         // input: pixel depth must be set (if false then current depth will be used if able)
    Boolean fAcceleratedMust;   // input: must renderer be accelerated?
    GLint aglAttributes[64];    // input: pixel format attributes always required (reset to what was actually allocated)
    SInt32 VRAM;                // input: minimum VRAM; output: actual (if successful otherwise input)
    SInt32 textureRAM;          // input: amount of texture RAM required on card; output: same (used in allcoation to ensure enough texture
    AGLPixelFormat    fmt;      // input: none; output pixel format...
};
typedef struct structGLInfo structGLInfo;
typedef struct structGLInfo * pstructGLInfo;

// structure for creating a context from a window
struct structGLWindowInfo // storage for setup info
{
    Boolean fAcceleratedMust;   // input: must renderer be accelerated?
    GLint aglAttributes[64];    // input: pixel format attributes always required (reset to what was actually allocated)
    SInt32 VRAM;                // input: minimum VRAM; output: actual (if successful otherwise input)
    SInt32 textureRAM;          // input: amount of texture RAM required on card; output: same (used in allcoation to ensure enough texture
    AGLPixelFormat    fmt;      // input: none; output pixel format...
    Boolean fDraggable;         // input: is window going to be dragable, 
                                //        if so renderer check (accel, VRAM, textureRAM) will look at all renderers vice just the current one
                                //        if window is not dragable renderer check will either check the single device or short 
                                //            circuit to software if window spans multiple devices 
                                //        software renderer is consider to have unlimited VRAM, unlimited textureRAM and to not be accelerated
};
typedef struct structGLWindowInfo structGLWindowInfo;
typedef struct structGLWindowInfo * pstructGLWindowInfo;

//-------------------------------------------------------------------------------------------- 

struct recGLCap // structure to store minimum OpenGL capabilites across all displays and GPUs
{
    Boolean f_ext_texture_rectangle; // is texture rectangle extension supported
    Boolean f_ext_client_storage; // is client storage extension supported
    Boolean f_ext_packed_pixel; // is packed pixel extension supported
    Boolean f_ext_texture_edge_clamp; // is SGI texture edge clamp extension supported
    Boolean f_gl_texture_edge_clamp; // is OpenGL texture edge clamp support (1.2+)
    unsigned long edgeClampParam; // the param that is passed to the texturing parmeteres
    long maxTextureSize; // the minimum max texture size across all GPUs
    long maxNOPTDTextureSize; // the minimum max texture size across all GPUs that support non-power of two texture dimensions
};
typedef struct recGLCap recGLCap;
typedef recGLCap * pRecGLCap;

struct recImage // OpenGL and image information associated with each window
{
    // genric OpenGL stuff
    structGLWindowInfo glInfo;  // gl info used with SetupGL to build context
    AGLContext aglContext;      // the OpenGL context (read: state)
    GLuint fontList;            // the display list storing the bitmap font created for the context to display info
    
    Boolean fAGPTexturing;      // 10.1+ only: texture from AGP memory without loading to GPU
    
    // texture display stuff
    Boolean fNPOTTextures; // are we using Non-Power Of Two (NPOT) textures?
    Boolean fTileTextures; // are multiple tiled textures used to display image?
    Boolean fOverlapTextures; // do tiled textures overlapped to create correct filtering between tiles? (only applies if using tiled textures)
    Boolean fClientTextures; // 10.1+ only: texture from client memory
        
    unsigned char * pImageBuffer; // image buffer that contains data for image (disposed after loading into texture if not using client textures)
    long imageWidth; // height of orginal image
    long imageHeight; // width of orginal image
    float imageAspect; // width / height or aspect ratio of orginal image
    long imageDepth; // depth of image (after loading into gworld, will be either 32 or 16 bits)
    long textureX; // number of horizontal textures
    long textureY; // number of vertical textures
    long maxTextureSize; // max texture size for image
    GLuint * pTextureName; // array for texture names (# = textureX * textureY)
    long textureWidth; // total width of texels with cover image (including any border on image, but not internal texture overlaps)
    long textureHeight; // total height of texels with cover image (including any border on image, but not internal texture overlaps)
    float zoomX; // zoom from on texel = one pixel is 1.0
    float zoomY; // zoom from on texel = one pixel is 1.0
 };
typedef struct recImage recImage; // typedef for easy declaration
typedef recImage * pRecImage; // pointer type

// ==================================

// public function declarations -------------------------------------

// Destroys drawable and context
// Ouputs: *paglDraw, *paglContext should be 0 on exit
// destorys a context that was associated with an existing window, window is left intacted
OSStatus DestroyGLFromWindow (AGLContext* paglContext, pstructGLWindowInfo pcontextInfo);

short FindGDHandleFromWindow (WindowPtr pWindow, GDHandle * phgdOnThisDevice);

// disposes OpenGL context, and associated texture list
OSStatus DisposeGLForWindow (WindowRef window);

// builds the GL context and associated state for the window
// loads image into a texture or textures
// disposes of GWorld and image buffer when finished loading textures
OSStatus BuildGLForWindow (WindowRef window);

// Handle updating context for window moves and resizing
OSStatus ResizeMoveGLWindow (WindowRef window);

// main GL drawing routine, should be valid window passed in (will setupGL if require).  Draw image
void DrawGL (WindowRef window);

pRecGLCap gpOpenGLCaps; 

// prototypes (internal/private) --------------------------------------------

static Boolean CheckRenderer (GDHandle hGD, long *VRAM, long *textureRAM, GLint*  , Boolean fAccelMust);
static Boolean CheckAllDeviceRenderers (long* pVRAM, long* pTextureRAM, GLint* pDepthSizeSupport, Boolean fAccelMust);
static void DumpCurrent (AGLDrawable* paglDraw, AGLContext* paglContext, pstructGLInfo pcontextInfo);
static OSStatus BuildGLonWindow (WindowPtr pWindow, AGLContext* paglContext, pstructGLWindowInfo pcontextInfo, AGLContext aglShareContext);

static long GetNextTextureSize (long textureDimension, long maxTextureSize, Boolean textureRectangle);
static long GetTextureNumFromTextureDim (long textureDimension, long maxTextureSize, Boolean texturesOverlap, Boolean textureRectangle);

// ----------------------------------------------------------------------------------------

// functions (internal/private) ---------------------------------------------

#pragma mark -
// --------------------------------------------------------------------------

// central error reporting

void ReportErrorNum (char * strError, long numError)
{
    char errMsgPStr [257];
    
    errMsgPStr[0] = (char)snprintf (errMsgPStr+1, 255, "%s %ld (0x%lx)\n", strError, numError, numError); 

    // ensure we are faded in
    DebugStr ( (ConstStr255Param) errMsgPStr );
}

// --------------------------------------------------------------------------

void ReportError (char * strError)
{
    char errMsgPStr [257];
    
    errMsgPStr[0] = (char)snprintf (errMsgPStr+1, 255, "%s\n", strError); 

    // ensure we are faded in
    DebugStr ( (ConstStr255Param) errMsgPStr );
}

//-----------------------------------------------------------------------------------------------------------------------

// if error dump agl errors to debugger string, return error

OSStatus aglReportError (void)
{
    GLenum err = aglGetError();
    if (AGL_NO_ERROR != err)
        ReportError ((char *)aglErrorString(err));
    // ensure we are returning an OSStatus noErr if no error condition
    if (err == AGL_NO_ERROR)
        return noErr;
    else
        return (OSStatus) err;
}

//-----------------------------------------------------------------------------------------------------------------------

// if error dump gl errors to debugger string, return error

OSStatus glReportError (void)
{
    GLenum err = glGetError();
    switch (err)
    {
        case GL_NO_ERROR:
            break;
        case GL_INVALID_ENUM:
            ReportError ("GL Error: Invalid enumeration");
            break;
        case GL_INVALID_VALUE:
            ReportError ("GL Error: Invalid value");
            break;
        case GL_INVALID_OPERATION:
            ReportError ("GL Error: Invalid operation");
            break;
        case GL_STACK_OVERFLOW:
            ReportError ("GL Error: Stack overflow");
            break;
        case GL_STACK_UNDERFLOW:
            ReportError ("GL Error: Stack underflow");
            break;
        case GL_OUT_OF_MEMORY:
            ReportError ("GL Error: Out of memory");
            break;
    }
    // ensure we are returning an OSStatus noErr if no error condition
    if (err == GL_NO_ERROR)
        return noErr;
    else
        return (OSStatus) err;
}

//--------------------------------------------------------------------------------------------

// functions (internal/private) ---------------------------------------------

// CheckRenderer

// looks at renderer attributes it has at least the VRAM is accelerated

// Inputs:     hGD: GDHandle to device to look at
//            pVRAM: pointer to VRAM in bytes required; out is actual VRAM if a renderer was found, otherwise it is the input parameter
//            pTextureRAM:  pointer to texture RAM in bytes required; out is same (implementation assume VRAM returned by card is total so we add texture and VRAM)
//            fAccelMust: do we check for acceleration

// Returns: true if renderer for the requested device complies, false otherwise

static Boolean CheckRenderer (GDHandle hGD, long* pVRAM, long* pTextureRAM, GLint* pDepthSizeSupport, Boolean fAccelMust)
{
    AGLRendererInfo info, head_info;
    GLint inum;
    GLint dAccel = 0;
    GLint dVRAM = 0, dMaxVRAM = 0;
    Boolean canAccel = false, found = false;
    head_info = aglQueryRendererInfo(&hGD, 1);
    aglReportError ();
    if(!head_info)
    {
        ReportError ("aglQueryRendererInfo error");
        return false;
    }
    else
    {
        info = head_info;
        inum = 0;
        // see if we have an accelerated renderer, if so ignore non-accelerated ones
        // this prevents returning info on software renderer when actually we'll get the hardware one
        while (info)
        {    
            aglDescribeRenderer(info, AGL_ACCELERATED, &dAccel);
            aglReportError ();
            if (dAccel)
                canAccel = true;
            info = aglNextRendererInfo(info);
            aglReportError ();
            inum++;
        }
            
        info = head_info;
        inum = 0;
        while (info)
        {
            aglDescribeRenderer (info, AGL_ACCELERATED, &dAccel);
            aglReportError ();
            // if we can accel then we will choose the accelerated renderer 
            // how about compliant renderers???
            if ((canAccel && dAccel) || (!canAccel && (!fAccelMust || dAccel)))
            {
                aglDescribeRenderer (info, AGL_VIDEO_MEMORY, &dVRAM);    // we assume that VRAM returned is total thus add texture and VRAM required
                aglReportError ();
                if (dVRAM >= (*pVRAM + *pTextureRAM))
                {
                    if (dVRAM >= dMaxVRAM) // find card with max VRAM
                    {
                        aglDescribeRenderer (info, AGL_DEPTH_MODES, pDepthSizeSupport);    // which depth buffer modes are supported
                        aglReportError ();
                        dMaxVRAM = dVRAM; // store max
                        found = true;
                    }
                }
            }
            info = aglNextRendererInfo(info);
            aglReportError ();
            inum++;
        }
    }
    aglDestroyRendererInfo(head_info);
    if (found) // if we found a card that has enough VRAM and meets the accel criteria
    {
        *pVRAM = dMaxVRAM; // return VRAM
        return true;
    }
    // VRAM will remain to same as it did when sent in
    return false;
}

//-----------------------------------------------------------------------------------------------------------------------

// CheckAllDeviceRenderers 

// looks at renderer attributes and each device must have at least one renderer that fits the profile

// Inputs:     pVRAM: pointer to VRAM in bytes required; out is actual min VRAM of all renderers found, otherwise it is the input parameter
//            pTextureRAM:  pointer to texture RAM in bytes required; out is same (implementation assume VRAM returned by card is total so we add texture and VRAM)
//            fAccelMust: do we check fro acceleration

// Returns: true if any renderer for on each device complies (not necessarily the same renderer), false otherwise

static Boolean CheckAllDeviceRenderers (long* pVRAM, long* pTextureRAM, GLint* pDepthSizeSupport, Boolean fAccelMust)
{
    AGLRendererInfo info, head_info;
    GLint inum;
    GLint dAccel = 0;
    GLint dVRAM = 0, dMaxVRAM = 0;
    Boolean canAccel = false, found = false, goodCheck = true; // can the renderer accelerate, did we find a valid renderer for the device, are we still successfully on all the devices looked at
    long MinVRAM = 0x8FFFFFFF; // max long
    GDHandle hGD = GetDeviceList (); // get the first screen
    while (hGD && goodCheck)
    {
        head_info = aglQueryRendererInfo(&hGD, 1);
        aglReportError ();
        if(!head_info)
        {
            ReportError ("aglQueryRendererInfo error");
            return false;
        }
        else
        {
            info = head_info;
            inum = 0;
            // see if we have an accelerated renderer, if so ignore non-accelerated ones
            // this prevents returning info on software renderer when actually we'll get the hardware one
            while (info)
            {
                aglDescribeRenderer(info, AGL_ACCELERATED, &dAccel);
                aglReportError ();
                if (dAccel)
                    canAccel = true;
                info = aglNextRendererInfo(info);
                aglReportError ();
                inum++;
            }
                
            info = head_info;
            inum = 0;
            while (info)
            {    
                aglDescribeRenderer(info, AGL_ACCELERATED, &dAccel);
                aglReportError ();
                // if we can accel then we will choose the accelerated renderer 
                // how about compliant renderers???
                if ((canAccel && dAccel) || (!canAccel && (!fAccelMust || dAccel)))
                {
                    aglDescribeRenderer(info, AGL_VIDEO_MEMORY, &dVRAM);    // we assume that VRAM returned is total thus add texture and VRAM required
                    aglReportError ();
                    if (dVRAM >= (*pVRAM + *pTextureRAM))
                    {
                        if (dVRAM >= dMaxVRAM) // find card with max VRAM
                        {
                            aglDescribeRenderer(info, AGL_DEPTH_MODES, pDepthSizeSupport);    // which depth buffer modes are supported
                            aglReportError ();
                            dMaxVRAM = dVRAM; // store max
                            found = true;
                        }
                    }
                }
                info = aglNextRendererInfo(info);
                aglReportError ();
                inum++;
            }
        }
        aglDestroyRendererInfo(head_info);
        if (found) // if we found a card that has enough VRAM and meets the accel criteria
        {
            if (MinVRAM > dMaxVRAM)
                MinVRAM = dMaxVRAM; // return VRAM
            
        }
        else
            goodCheck = false; // one device failed thus entire requirement fails
        hGD = GetNextDevice (hGD); // get next device
    } // while
    if (goodCheck) // we check all devices and each was good
    {
        *pVRAM = MinVRAM; // return VRAM
        return true;
    }
    return false; //at least one device failed to have mins
}

//-----------------------------------------------------------------------------------------------------------------------

// DumpCurrent

// Kills currently allocated context
// does not care about being pretty (assumes display is likely faded)

// Inputs:     paglDraw, paglContext: things to be destroyed

void DumpCurrent (AGLDrawable* paglDraw, AGLContext* paglContext, pstructGLInfo pcontextInfo)
{
    if (*paglContext)
    {
        aglSetCurrentContext (NULL);
        aglReportError ();
        aglSetDrawable (*paglContext, NULL);
        aglReportError ();
        aglDestroyContext (*paglContext);
        aglReportError ();
        *paglContext = NULL;
    }
    
    if (pcontextInfo->fmt)
    {
        aglDestroyPixelFormat (pcontextInfo->fmt); // pixel format is no longer needed
        aglReportError ();
    }
    pcontextInfo->fmt = 0;

    if (*paglDraw) // do not destory a window on DSp since there is no window built in X
        DisposeWindow (GetWindowFromPort (*paglDraw));
    *paglDraw = NULL;
}

#pragma mark -
// --------------------------------------------------------------------------

// BuildGLonWindow

static OSStatus BuildGLonWindow (WindowPtr pWindow, AGLContext* paglContext, pstructGLWindowInfo pcontextInfo, AGLContext aglShareContext)
{
    GDHandle hGD = NULL;
    GrafPtr cgrafSave = NULL;
    short numDevices;
    GLint depthSizeSupport;
    OSStatus err = noErr;
    
    if (!pWindow || !pcontextInfo)
    {
        ReportError ("NULL parameter passed to BuildGLonWindow.");
        return paramErr;
    }
    
    GetPort (&cgrafSave);
    SetPortWindowPort(pWindow);

    // check renderere VRAM and acceleration
    numDevices = FindGDHandleFromWindow (pWindow, &hGD);
    if (!pcontextInfo->fDraggable)     // if numDevices > 1 then we will only be using the software renderer otherwise check only window device
    {
        if ((numDevices > 1) || (numDevices == 0)) // this window spans mulitple devices thus will be software only
        {
            // software renderer
            // infinite VRAM, infinite textureRAM, not accelerated
            if (pcontextInfo->fAcceleratedMust)
            {
                ReportError ("Unable to accelerate window that spans multiple devices");
                return err;
            }
        }
        else // not draggable on single device
        {
            if (!CheckRenderer (hGD, &(pcontextInfo->VRAM), &(pcontextInfo->textureRAM), &depthSizeSupport, pcontextInfo->fAcceleratedMust))
            {
                ReportError ("Renderer check failed");
                return err;
            }
        }
    }
    // else draggable so must check all for support (each device should have at least one renderer that meets the requirements)
    else if (!CheckAllDeviceRenderers (&(pcontextInfo->VRAM), &(pcontextInfo->textureRAM), &depthSizeSupport, pcontextInfo->fAcceleratedMust))
    {
        ReportError ("Renderer check failed");
        return err;
    }
    
    // do agl
    if ((Ptr) kUnresolvedCFragSymbolAddress == (Ptr) aglChoosePixelFormat) // check for existance of OpenGL
    {
        ReportError ("OpenGL not installed");
        return noErr;
    }    
    // we successfully passed the renderer check

    if ((!pcontextInfo->fDraggable && (numDevices == 1)))  // not draggable on a single device
        pcontextInfo->fmt = aglChoosePixelFormat (&hGD, 1, pcontextInfo->aglAttributes); // get an appropriate pixel format
    else
        pcontextInfo->fmt = aglChoosePixelFormat (NULL, 0, pcontextInfo->aglAttributes); // get an appropriate pixel format
    aglReportError ();
    if (NULL == pcontextInfo->fmt) 
    {
        ReportError("Could not find valid pixel format");
        return noErr;
    }

    *paglContext = aglCreateContext (pcontextInfo->fmt, aglShareContext); // Create an AGL context
    if (AGL_BAD_MATCH == aglGetError())
        *paglContext = aglCreateContext (pcontextInfo->fmt, 0); // unable to sahre context, create without sharing
    aglReportError ();
    if (NULL == *paglContext) 
    {
        ReportError ("Could not create context");
        return noErr;
    }
    
    if (!aglSetDrawable (*paglContext, GetWindowPort (pWindow))) // attach the CGrafPtr to the context
        return aglReportError ();
    
    if(!aglSetCurrentContext (*paglContext)) // make the context the current context
        return aglReportError ();

    SetPort (cgrafSave);

    return err;
}

#pragma mark -

// functions (public) -------------------------------------------------------

// DestroyGLFromWindow

// Destroys context that waas allocated with BuildGLonWindow
// Ouputs: *paglContext should be NULL on exit

OSStatus DestroyGLFromWindow (AGLContext* paglContext, pstructGLWindowInfo pcontextInfo)
{
    OSStatus err;
    
    if ((!paglContext) || (!*paglContext))
        return paramErr; // not a valid context
    glFinish ();
    aglSetCurrentContext (NULL);
    err = aglReportError ();
    aglSetDrawable (*paglContext, NULL);
    err = aglReportError ();
    aglDestroyContext (*paglContext);
    err = aglReportError ();
    *paglContext = NULL;

    if (pcontextInfo->fmt)
    {
        aglDestroyPixelFormat (pcontextInfo->fmt); // pixel format is no longer valid
        err = aglReportError ();
    }
    pcontextInfo->fmt = 0;
    
    return err;
}

//-----------------------------------------------------------------------------------------------------------------------

// GetWindowDevice

// Inputs:    a valid WindowPtr

// Outputs:    the GDHandle that that window is mostly on

// returns the number of devices that the windows content touches

short FindGDHandleFromWindow (WindowPtr pWindow, GDHandle * phgdOnThisDevice)
{
    GrafPtr pgpSave;
    Rect rectWind, rectSect;
    long greatestArea, sectArea;
    short numDevices = 0;
    GDHandle hgdNthDevice;
    
    if (!pWindow || !phgdOnThisDevice)
        return 0;
        
    *phgdOnThisDevice = NULL;
    
    GetPort (&pgpSave);
    SetPortWindowPort (pWindow);
    

    GetWindowPortBounds (pWindow, &rectWind);
    LocalToGlobal ((Point*)& rectWind.top);    // convert to global coordinates
    LocalToGlobal ((Point*)& rectWind.bottom);
    hgdNthDevice = GetDeviceList ();
    greatestArea = 0;
    // check window against all gdRects in gDevice list and remember 
    //  which gdRect contains largest area of window}
    while (hgdNthDevice)
    {
        if (TestDeviceAttribute (hgdNthDevice, screenDevice))
            if (TestDeviceAttribute (hgdNthDevice, screenActive))
            {
                // The SectRect routine calculates the intersection 
                //  of the window rectangle and this gDevice 
                //  rectangle and returns TRUE if the rectangles intersect, 
                //  FALSE if they don't.
                SectRect (&rectWind, &(**hgdNthDevice).gdRect, &rectSect);
                // determine which screen holds greatest window area
                //  first, calculate area of rectangle on current device
                sectArea = (long) (rectSect.right - rectSect.left) * (rectSect.bottom - rectSect.top);
                if (sectArea > 0)
                    numDevices++;
                if (sectArea > greatestArea)
                {
                    greatestArea = sectArea; // set greatest area so far
                    *phgdOnThisDevice = hgdNthDevice; // set zoom device
                }
                hgdNthDevice = GetNextDevice(hgdNthDevice);
            }
    }
    
    SetPort (pgpSave);
    return numDevices;
}

//--------------------------------------------------------------------------------------------
// private

// returns the largest power of 2 texture <= textureDimension
// or in the case of texture rectangle returns the next texture size (can be non-power of two)

static long GetNextTextureSize (long textureDimension, long maxTextureSize, Boolean textureRectangle)
{
    long targetTextureSize = maxTextureSize; // start at max texture size
    if (textureRectangle)
    {
        if (textureDimension >= targetTextureSize) // the texture dimension is greater than the target texture size (i.e., it fits)
            return targetTextureSize; // return corresponding texture size
        else
            return textureDimension; // jusr return the dimension
    }
    else
    {
        do // while we have txture sizes check for texture value being equal or greater
        {  
            if (textureDimension >= targetTextureSize) // the texture dimension is greater than the target texture size (i.e., it fits)
                return targetTextureSize; // return corresponding texture size
        }
        while (targetTextureSize >>= 1); // step down to next texture size smaller
    }
    return 0; // no textures fit so return zero
}

// ---------------------------------

// returns the nuber of textures need to represent a size of textureDimension given
// requirement for power of 2 textures as the maximum texture size
// for the overlap case each texture effectively covers two less pixels so must iterate through using whole statement

static long GetTextureNumFromTextureDim (long textureDimension, long maxTextureSize, Boolean texturesOverlap, Boolean textureRectangle) 
{
    // start at max texture size 
    // loop through each texture size, removing textures in turn which are less than the remaining texture dimension
    // each texture has 2 pixels of overlap (one on each side) thus effective texture removed is 2 less than texture size
    
    long i = 0; // initially no textures
    long bitValue = maxTextureSize; // start at max texture size
    long texOverlapx2 = texturesOverlap ? 2 : 0;
    textureDimension -= texOverlapx2; // ignore texture border since we are using effective texure size (by subtracting 2 from the initial size)
    if (textureRectangle)
    {
        // count number of full textures
        while (textureDimension > (bitValue - texOverlapx2)) // while our texture dimension is greater than effective texture size (i.e., minus the border)
        {
            i++; // count a texture
            textureDimension -= bitValue - texOverlapx2; // remove effective texture size
        }
        // add one partial texture
        i++; 
    }
    else
    {
        do
        {
            while (textureDimension >= (bitValue - texOverlapx2)) // while our texture dimension is greater than effective texture size (i.e., minus the border)
            {
                i++; // count a texture
                textureDimension -= bitValue - texOverlapx2; // remove effective texture size
            }
        }
        while ((bitValue >>= 1) > texOverlapx2); // step down to next texture while we are greater than two (less than 4 can't be used due to 2 pixel overlap)
    if (textureDimension > 0x0) // if any textureDimension is left there is an error, because we can't texture these small segments and in anycase should not have image pixels left
        ReportErrorNum ("GetTextureNumFromTextureDim error: Texture to small to draw, should not ever get here, texture size remaining:", textureDimension);
    }
    return i; // return textures counted
} 

#pragma mark -
// ==================================
// public

// disposes OpenGL context, and associated texture list

OSStatus DisposeGLForWindow (WindowRef window)
{
    if (window)
    {
        pRecImage pWindowInfo = (pRecImage) GetWRefCon (window); // get gl data stored in refcon
        SetWRefCon (window, 0); // ensure the refcon is not used again
        if (NULL == pWindowInfo) // if this is non-existant
            return paramErr; // then drop out
        if (NULL != pWindowInfo->aglContext)
        {
            aglSetCurrentContext (pWindowInfo->aglContext); // ensaure the context we are working with is set to current
            aglUpdateContext (pWindowInfo->aglContext); // ensaure the context we are working with is set to current
            glFinish (); // ensure all gl commands are complete
            glDeleteTextures (pWindowInfo->textureX * pWindowInfo->textureY, pWindowInfo->pTextureName); // delete the complete set of textures used for the window
            DestroyGLFromWindow (&pWindowInfo->aglContext, &pWindowInfo->glInfo); // preoperly destroy GL context and any associated structures
            pWindowInfo->aglContext = NULL; // ensure we don't use invlad context
        }
        if (NULL != pWindowInfo->pTextureName)
        {
            DisposePtr ((Ptr) pWindowInfo->pTextureName); // dispose of the allocate4d texture name storage
            pWindowInfo->pTextureName = NULL; // ensure we do not use it again
        }
        if (pWindowInfo->pImageBuffer) // MUST preserve the buffer if texturing from client memory
        {
            //DisposePtr ((Ptr) pWindowInfo->pImageBuffer); // or image buffer
            pWindowInfo->pImageBuffer = NULL;
        }
        DisposePtr ((Ptr) pWindowInfo);
        return noErr; // we are good to go
    }
    else
        return paramErr; // NULL window ref passed in
}

// ---------------------------------

// builds the GL context and associated state for the window
// loads image into a texture or textures
// disposes of GWorld and image buffer when finished loading textures

OSStatus BuildGLForWindow (WindowRef window)
{
    GrafPtr portSave = NULL; // port which is set on entrance to this routine
    pRecImage pWindowInfo = (pRecImage) GetWRefCon (window); // the info structure for the window stored in the refcon
    short i; // iterator
    GLenum textureTarget = GL_TEXTURE_2D;
   
    if (!pWindowInfo->aglContext) // if we get here and do not have a context built, build one
    {
        GetPort (&portSave);    // save current port
        SetPort ((GrafPtr) GetWindowPort (window)); // set port to the current window
        // set parameters for Carbon SetupGL
        pWindowInfo->glInfo.fAcceleratedMust = false; // must renderer be accelerated?
        pWindowInfo->glInfo.VRAM = 0 * 1048576; // minimum VRAM (if not zero this is always required)
        pWindowInfo->glInfo.textureRAM = 0 * 1048576; // minimum texture RAM (if not zero this is always required)
           pWindowInfo->glInfo.fDraggable = true; // is this a draggable window
        pWindowInfo->glInfo.fmt = 0; // output pixel format
        
        i = 0; // first attribute in array
        pWindowInfo->glInfo.aglAttributes [i++] = AGL_RGBA; // RGB + Alpha pixels
        pWindowInfo->glInfo.aglAttributes [i++] = AGL_DOUBLEBUFFER; // doble buffered context
        pWindowInfo->glInfo.aglAttributes [i++] = AGL_ACCELERATED; // require hardware acceleration
        pWindowInfo->glInfo.aglAttributes [i++] = AGL_NO_RECOVERY; // 10.0.4 has problems with the GL (disregards UNPACK_ROW_LENGTH) resulting from using no recovery
                                                                   // normally we would use no recovery to ensure the minimum pixel size textures are stored by GL.
        pWindowInfo->glInfo.aglAttributes [i++] = AGL_NONE; // end parameter list
        BuildGLonWindow (window, &(pWindowInfo->aglContext), &(pWindowInfo->glInfo), NULL); // build opengl context for our window
        if (!pWindowInfo->aglContext) // if could not create context
            DestroyGLFromWindow (&pWindowInfo->aglContext, &pWindowInfo->glInfo); // ensure context is destroyed correctly
        else // we have a valid context
        {
            GLint swap = 0; // swap interval (i.e., VBL sync) setting 1 = sync, 0 = no sync
            Rect rectPort; // window port rectangle
            long width = pWindowInfo->imageWidth, height = pWindowInfo->imageHeight; // image width and height
            GDHandle device; // GDevice to find the constrain the window to
            Rect deviceRect, availRect, rect; // rect of device which window is on (mostly, area wise at least). avialable area for window (minus dock and menu if req), working rect

            GetWindowGreatestAreaDevice (window, kWindowContentRgn, &device, &deviceRect); // find device the window is mostly on
            GetAvailableWindowPositioningBounds (device, &availRect); //  get the geretest available area for te windoew (mminus doc and menu if applicable)
            if (width > (availRect.right - availRect.left)) // adjust window width if it is greater than available area (orginally set to image width, see above)
                width = (availRect.right - availRect.left);
            if (height > (availRect.bottom - availRect.top)) // adjust window height if it is greater than available area (orginally set to image width, see above)
                height = (availRect.bottom - availRect.top);
            SizeWindow (window, (short) width, (short) height, true); // size the window to new width and height
            ConstrainWindowToScreen(window, kWindowStructureRgn, kWindowConstrainMayResize, NULL, &rect); // ensure window structure region is on the screen
            GetWindowPortBounds (window, &rectPort); // get port rect for viewport reset

            aglSetCurrentContext (pWindowInfo->aglContext); // set our GL context to this one
            aglUpdateContext (pWindowInfo->aglContext); // update the context to account for the resize
            InvalWindowRect (window, &rectPort); // inval the entire window to ensure we get a redraw
            glViewport (0, 0, rectPort.right - rectPort.left, rectPort.bottom - rectPort.top); // reset viewport to entier window area

            aglSetInteger (pWindowInfo->aglContext, AGL_SWAP_INTERVAL, &swap); // set swap interval to account for vbl syncing or not
            
            // set correct texture target // if building on 10.0 or 9 this will be undefined
        #ifdef GL_TEXTURE_RECTANGLE_EXT
            if (pWindowInfo->fNPOTTextures)
                textureTarget = GL_TEXTURE_RECTANGLE_EXT;
        #endif
            
            // Set texture mapping parameters
            glEnable (textureTarget); // enable texturing
                
            glClearColor(0.0f, 0.0f, 0.0f, 1.0f); // set clear color buffer to dark gray
            glClear (GL_COLOR_BUFFER_BIT); // clear just to color buffer
            aglSwapBuffers (pWindowInfo->aglContext); // swap the cleared buffer to front
    
            //GetFNum ("\pMonaco", &fNum); // get font number for named font
            //pWindowInfo->fontList = BuildFontGL (pWindowInfo->aglContext, fNum, normal, 9); // build display list for fonts for this context (see aglString for more info)
            
            // if we can use texture rectangle // if building on 10.0 or 9 this will be undefined
        #ifdef GL_TEXTURE_RECTANGLE_EXT
            if (pWindowInfo->fNPOTTextures)
                glEnable(GL_TEXTURE_RECTANGLE_EXT);
        #endif
            if (pWindowInfo->fAGPTexturing)
                glTextureRangeAPPLE(textureTarget, pWindowInfo->textureHeight * pWindowInfo->textureWidth * (pWindowInfo->imageDepth >> 3), pWindowInfo->pImageBuffer);
            glPixelStorei (GL_UNPACK_ROW_LENGTH, pWindowInfo->textureWidth); // set image width in groups (pixels), accounts for border this ensures proper image alignment row to row
            // get number of textures x and y
                // extract the number of horiz. textures needed to tile image
            pWindowInfo->textureX = GetTextureNumFromTextureDim (pWindowInfo->textureWidth, pWindowInfo->maxTextureSize, pWindowInfo->fOverlapTextures, pWindowInfo->fNPOTTextures); 
                // extract the number of horiz. textures needed to tile image
            pWindowInfo->textureY = GetTextureNumFromTextureDim (pWindowInfo->textureHeight, pWindowInfo->maxTextureSize, pWindowInfo->fOverlapTextures, pWindowInfo->fNPOTTextures); 
            pWindowInfo->pTextureName = (GLuint *) NewPtrClear ((long) sizeof (GLuint) * pWindowInfo->textureX * pWindowInfo->textureY); // allocate storage for texture name lists
            glGenTextures (pWindowInfo->textureX * pWindowInfo->textureY, pWindowInfo->pTextureName); // generate textures names need to support tiling
            {
                long x, y, k = 0, offsetY, offsetX = 0, currWidth, currHeight; // texture iterators, texture name iterator, image offsets for tiling, current texture width and height
                for (x = 0; x < pWindowInfo->textureX; x++) // for all horizontal textures
                {
                    currWidth = GetNextTextureSize (pWindowInfo->textureWidth - offsetX, pWindowInfo->maxTextureSize, pWindowInfo->fNPOTTextures); // use remaining to determine next texture size 
                                                                                                                    // (basically greatest power of 2 which fits into remaining space)
                    offsetY = 0; // reset vertical offest for every column
                    for (y = 0; y < pWindowInfo->textureY; y++) // for all vertical textures
                    {
                        // buffer pointer is at base + rows * row size + columns
                        unsigned char * pBuffer = pWindowInfo->pImageBuffer + 
                                                   offsetY * pWindowInfo->textureWidth * (pWindowInfo->imageDepth >> 3) + 
                                                   offsetX * (pWindowInfo->imageDepth >> 3);
                        currHeight = GetNextTextureSize (pWindowInfo->textureHeight - offsetY, pWindowInfo->maxTextureSize, pWindowInfo->fNPOTTextures); // use remaining to determine next texture size
                        glBindTexture (textureTarget, pWindowInfo->pTextureName[k++]);
                        if (pWindowInfo->fAGPTexturing) {
                            glTexParameterf (textureTarget, GL_TEXTURE_PRIORITY, 0.0f); // AGP texturing
                            glTexParameteri (textureTarget, GL_TEXTURE_STORAGE_HINT_APPLE, GL_STORAGE_SHARED_APPLE);
                        }
                        else
                            glTexParameterf (textureTarget, GL_TEXTURE_PRIORITY, 1.0f);
                            
                    #ifdef GL_UNPACK_CLIENT_STORAGE_APPLE
                        if (pWindowInfo->fClientTextures)
                            glPixelStorei (GL_UNPACK_CLIENT_STORAGE_APPLE, 1);
                        else
                            glPixelStorei (GL_UNPACK_CLIENT_STORAGE_APPLE, 0);
                    #endif

                        glTexParameteri (textureTarget, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
                        glTexParameteri (textureTarget, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
                        glTexParameteri (textureTarget, GL_TEXTURE_WRAP_S, gpOpenGLCaps->edgeClampParam);
                        glTexParameteri (textureTarget, GL_TEXTURE_WRAP_T, gpOpenGLCaps->edgeClampParam);
                        glReportError (); // report any errors so far
                        glTexImage2D (textureTarget, 0, GL_RGBA, currWidth, currHeight, 0, 
                                      GL_BGRA_EXT, pWindowInfo->imageDepth == 32 ? GL_UNSIGNED_INT_8_8_8_8_REV : GL_UNSIGNED_SHORT_1_5_5_5_REV, 
                                      pBuffer); // texture with current width and height at pBuffer location in image buffer with image size as GL_UNPACK_ROW_LENGTH
                        glReportError (); // report any errors
                        offsetY += currHeight - 2 * pWindowInfo->fOverlapTextures; // offset in for the amount of texture used, 
                                                                                       //  since we are overlapping the effective texture used is 2 texels less than texture width
                    }
                    offsetX += currWidth - 2 * pWindowInfo->fOverlapTextures; // offset in for the amount of texture used, 
                                                                              //  since we are overlapping the effective texture used is 2 texels less than texture width
                }
            }
            if (false == pWindowInfo->fClientTextures) // MUST preserve the buffer if texturing from client memory
            {
                DisposePtr ((Ptr) pWindowInfo->pImageBuffer); // or image buffer
                pWindowInfo->pImageBuffer = NULL;
            }
        }
        SetPort (portSave); //reset port
    }
    return noErr; // we done
}

// ---------------------------------

// Handle updating context for window moves and resizing

OSStatus ResizeMoveGLWindow (WindowRef window)
{
    OSStatus err = noErr; // no errors to start
    Rect rectPort; // new port rect
    pRecImage pWindowInfo = (pRecImage) GetWRefCon (window); // get GL info;
    if (window && pWindowInfo) // if we have a window
    {
        GetWindowPortBounds (window, &rectPort);
        pWindowInfo->zoomX = (float) (rectPort.right - rectPort.left) / (float) pWindowInfo->imageWidth;
        pWindowInfo->zoomY = (float) (rectPort.bottom - rectPort.top) / (float) pWindowInfo->imageHeight;

        if (!aglUpdateContext (pWindowInfo->aglContext)) // update the context to ensure gl knows about the move or resize
               aglReportError (); // report any error with update context
        if (noErr != err)
            ReportErrorNum ("ResizeMoveGLWindow error with InvalWindowRect on window: ", err);  // should not get erro here, but who knows
        err = InvalWindowRect (window, &rectPort);
    }
    else
        err = paramErr; // bad window
    return err; // return any error 
}

// ---------------------------------

// main GL drawing routine, should be valid window passed in (will setupGL if require).  Draw image

void DrawGL (WindowRef window)
{
    Rect rectPort; // rectangle for port
    pRecImage pWindowInfo; // the gl info for the target window 
    long width, height; // width and height or the port and the row of the raster position
    long effectiveTextureMod = 0; // texture size modification (inset) to account for borders
    long x, y, k = 0, offsetY, offsetX = 0, currTextureWidth, currTextureHeight;
    GLenum textureTarget = GL_TEXTURE_2D;
    
    if (NULL == window) // if we do not have a window
        return; // drop out
    pWindowInfo = (pRecImage) GetWRefCon (window); // get the gl info for the window
    if (NULL == pWindowInfo) // if this is non-existant
        return; // then drop out
    if (NULL == pWindowInfo->aglContext) // try to buld the context if we don't have one (safety check)
        BuildGLForWindow (window);
    if (NULL == pWindowInfo->aglContext) // if we still don't have one then drop out
        return;
        
    if (pWindowInfo->fOverlapTextures)
        effectiveTextureMod = 2; // if we overlap then we need to inset the textures passed to the drawing code
    // set texture target
#ifdef GL_TEXTURE_RECTANGLE_EXT
    if (pWindowInfo->fNPOTTextures)
        textureTarget = GL_TEXTURE_RECTANGLE_EXT;
#endif

    aglSetCurrentContext (pWindowInfo->aglContext); // ensaure the context we are working with is set to current
    aglUpdateContext (pWindowInfo->aglContext); // ensaure the context we are working with is set to current

    GetWindowPortBounds (window, &rectPort); // get the current port (window) bounds
    width = rectPort.right - rectPort.left; // find width
    height = rectPort.bottom - rectPort.top; // and height
    glViewport (0, 0, width, height); // set the viewport to cover entire window
    
    glMatrixMode (GL_PROJECTION); // set projection matrix
    glLoadIdentity (); // to indetity
    glMatrixMode (GL_MODELVIEW); // set modelview matrix
    glLoadIdentity (); // to identity
    glReportError (); // report any GL errors so far
    
    // set the model view matrix for an orthographic view scaled to one screen pixel equal image pixel (independent of image zoom)
    glScalef (2.0f / width, -2.0f /  height, 1.0f); // scale to port per pixel scale
    //glTranslatef (pWindowInfo->centerX, pWindowInfo->centerY, 0.0f); // translate for image movement
    //glRotatef (0.0f, 0.0f, 0.0f, 1.0f); // ratate matrix for image rotation
    glReportError (); // report any GL errors
    
    glClear (GL_COLOR_BUFFER_BIT); // clear the color buffer before drawing

    // draw image
    glEnable (textureTarget); // enable texturing
    glColor3f (1.0f, 1.0f, 1.0f); // white polygons
    // offset x and y are used to draw the polygon and need to represent the texture effective edges (without borders)
    // so walk the texture size images adjusting for each border
    for (x = 0; x < pWindowInfo->textureX; x++) // for all horizontal textures
    {
        // use remaining to determine next texture size
        currTextureWidth = GetNextTextureSize (pWindowInfo->textureWidth - offsetX, pWindowInfo->maxTextureSize, pWindowInfo->fNPOTTextures) - effectiveTextureMod; // current effective texture width for drawing
        offsetY = 0; // start at top
        for (y = 0; y < pWindowInfo->textureY; y++) // for a complete column
        {
            // use remaining to determine next texture size
            currTextureHeight = GetNextTextureSize (pWindowInfo->textureHeight - offsetY, pWindowInfo->maxTextureSize, pWindowInfo->fNPOTTextures) - effectiveTextureMod; // effective texture height for drawing
            glBindTexture(textureTarget, pWindowInfo->pTextureName[k++]); // work through textures in same order as stored, setting each texture name as current in turn
            if (!pWindowInfo->fAGPTexturing)
                glTexSubImage2D(textureTarget, 0, 0, 0, currTextureWidth, currTextureHeight, GL_BGRA, pWindowInfo->imageDepth == 32 ? GL_UNSIGNED_INT_8_8_8_8_REV : GL_UNSIGNED_SHORT_1_5_5_5_REV, pWindowInfo->pImageBuffer);
            glReportError (); // report any errors
            {
                float endX = pWindowInfo->fTileTextures ? currTextureWidth + offsetX : pWindowInfo->imageWidth;
                float endY = pWindowInfo->fTileTextures ? currTextureHeight + offsetY : pWindowInfo->imageHeight;
                float startXDraw = (offsetX - pWindowInfo->imageWidth * 0.5f) * pWindowInfo->zoomX; // left edge of poly: offset is in image local coordinates convert to world coordinates
                float endXDraw = (endX - pWindowInfo->imageWidth * 0.5f) * pWindowInfo->zoomX; // right edge of poly: offset is in image local coordinates convert to world coordinates
                float startYDraw = (offsetY - pWindowInfo->imageHeight * 0.5f) * pWindowInfo->zoomY; // top edge of poly: offset is in image local coordinates convert to world coordinates
                float endYDraw = (endY - pWindowInfo->imageHeight * 0.5f) * pWindowInfo->zoomY; // bottom edge of poly: offset is in image local coordinates convert to world coordinates
                float texOverlap =  pWindowInfo->fOverlapTextures ? 1.0f : 0.0f; // size of texture overlap, switch based on whether we are using overlap or not
                float startXTexCoord = texOverlap / (currTextureWidth + 2.0f * texOverlap); // texture right edge coordinate (stepped in one pixel for border if required)
                float endXTexCoord = 1.0f - startXTexCoord; // texture left edge coordinate (stepped in one pixel for border if required)
                float startYTexCoord = texOverlap / (currTextureHeight + 2.0f * texOverlap); // texture top edge coordinate (stepped in one pixel for border if required)
                float endYTexCoord = 1.0f - startYTexCoord; // texture bottom edge coordinate (stepped in one pixel for border if required)
                if (pWindowInfo->fNPOTTextures)
                {
                    startXTexCoord = texOverlap; // texture right edge coordinate (stepped in one pixel for border if required)
                    endXTexCoord = currTextureWidth + texOverlap; // texture left edge coordinate (stepped in one pixel for border if required)
                    startYTexCoord = texOverlap; // texture top edge coordinate (stepped in one pixel for border if required)
                    endYTexCoord = currTextureHeight + texOverlap; // texture bottom edge coordinate (stepped in one pixel for border if required)
                }
                if (endX > (pWindowInfo->imageWidth + 0.5)) // handle odd image sizes, (+0.5 is to ensure there is no fp resolution problem in comparing two fp numbers)
                {
                    endXDraw = (pWindowInfo->imageWidth * 0.5f) * pWindowInfo->zoomX; // end should never be past end of image, so set it there
                    if (pWindowInfo->fNPOTTextures)
                        endXTexCoord -= 1.0f;
                    else
                        endXTexCoord = 1.0f -  2.0f * startXTexCoord; // for the last texture in odd size images there are two texels of padding so step in 2
                }
                if (endY > (pWindowInfo->imageHeight + 0.5f)) // handle odd image sizes, (+0.5 is to ensure there is no fp resolution problem in comparing two fp numbers)
                {
                    endYDraw = (pWindowInfo->imageHeight * 0.5f) * pWindowInfo->zoomY; // end should never be past end of image, so set it there
                    if (pWindowInfo->fNPOTTextures)
                        endYTexCoord -= 1.0f;
                    else
                        endYTexCoord = 1.0f -  2.0f * startYTexCoord; // for the last texture in odd size images there are two texels of padding so step in 2
                }
                
                glBegin (GL_TRIANGLE_STRIP); // draw either tri strips of line strips
                    glTexCoord2f (startXTexCoord, startYTexCoord); // draw upper left in world coordinates
                    glVertex3d (startXDraw, startYDraw, 0.0);

                    glTexCoord2f (endXTexCoord, startYTexCoord); // draw lower left in world coordinates
                    glVertex3d (endXDraw, startYDraw, 0.0);

                    glTexCoord2f (startXTexCoord, endYTexCoord); // draw upper right in world coordinates
                    glVertex3d (startXDraw, endYDraw, 0.0);

                    glTexCoord2f (endXTexCoord, endYTexCoord); // draw lower right in world coordinates
                    glVertex3d (endXDraw, endYDraw, 0.0);
                glEnd();
                
            }

            //////////////////////

            glReportError (); // report any errors
            offsetY += currTextureHeight; // offset drawing position for next texture vertically
        }
        offsetX += currTextureWidth; // offset drawing position for next texture horizontally
    }
    glReportError (); // report any errors

    glDisable (textureTarget); // done with texturing
        
    aglSwapBuffers (pWindowInfo->aglContext);
}

// finds the minimum OpenGL capabilites across all displays and GPUs attached to machine.

static void FindMinimumOpenGLCapabilities (pRecGLCap pOpenGLCaps)
{
    WindowPtr pWin = NULL; 
    Rect rectWin = {0, 0, 10, 10};
    GLint attrib[] = { AGL_RGBA, AGL_NONE };
    AGLPixelFormat fmt = NULL;
    AGLContext ctx = NULL;
    GLint deviceMaxTextureSize = 0, NPOTDMaxTextureSize = 0;
    
    if (NULL != gpOpenGLCaps)
    {
        // init desired caps to max values
        pOpenGLCaps->f_ext_texture_rectangle = true;
        pOpenGLCaps->f_ext_client_storage = true;
        pOpenGLCaps->f_ext_packed_pixel = true;
        pOpenGLCaps->f_ext_texture_edge_clamp = true;
        pOpenGLCaps->f_gl_texture_edge_clamp = true;
        pOpenGLCaps->maxTextureSize = 0x7FFFFFFF;
        pOpenGLCaps->maxNOPTDTextureSize = 0x7FFFFFFF;

        // build window
        pWin = NewCWindow (0L, &rectWin, NULL, false,
                plainDBox, (WindowPtr) -1L, true, 0L);
                
        // build context
        fmt = aglChoosePixelFormat(NULL, 0, attrib);
        if (fmt)
            ctx = aglCreateContext(fmt, NULL);
        if (ctx)
        {
            GDHandle hgdNthDevice;
            
            aglSetDrawable(ctx, GetWindowPort (pWin));
            aglSetCurrentContext(ctx);
            
            // for each display
            hgdNthDevice = GetDeviceList ();
            while (hgdNthDevice)
            {
                if (TestDeviceAttribute (hgdNthDevice, screenDevice))
                    if (TestDeviceAttribute (hgdNthDevice, screenActive))
                    {
                        // move window to display
                        MoveWindow (pWin, (**hgdNthDevice).gdRect.left + 5, (**hgdNthDevice).gdRect.top + 5, false);
                        aglUpdateContext(ctx);
                        
                        // for each cap (this can obviously be expanded)
                        // if this driver/GPU/display is less capable
                            // save this minimum capability
                        {
                            // get strings
                            enum { kShortVersionLength = 32 };
                            const GLubyte * strVersion = glGetString (GL_VERSION); // get version string
                            const GLubyte * strExtension = glGetString (GL_EXTENSIONS);    // get extension string
                            
                            // get just the non-vendor specific part of version string
                            GLubyte strShortVersion [kShortVersionLength];
                            short i = 0;
                            while ((((strVersion[i] <= '9') && (strVersion[i] >= '0')) || (strVersion[i] == '.')) && (i < kShortVersionLength)) // get only basic version info (until first space)
                                strShortVersion [i] = strVersion[i++];
                            strShortVersion [i] = 0; //truncate string
                            
                            // compare capabilities based on extension string and GL version
                            pOpenGLCaps->f_ext_texture_rectangle = 
                                pOpenGLCaps->f_ext_texture_rectangle && (NULL != strstr ((const char *) strExtension, "GL_EXT_texture_rectangle"));
                            pOpenGLCaps->f_ext_client_storage = 
                                pOpenGLCaps->f_ext_client_storage && (NULL != strstr ((const char *) strExtension, "GL_APPLE_client_storage"));
                            pOpenGLCaps->f_ext_packed_pixel = 
                                pOpenGLCaps->f_ext_packed_pixel && (NULL != strstr ((const char *) strExtension, "GL_APPLE_packed_pixel"));
                            pOpenGLCaps->f_ext_texture_edge_clamp = 
                                pOpenGLCaps->f_ext_texture_edge_clamp && (NULL != strstr ((const char *) strExtension, "GL_SGIS_texture_edge_clamp"));
                            pOpenGLCaps->f_gl_texture_edge_clamp = 
                                pOpenGLCaps->f_gl_texture_edge_clamp && (!strstr ((const char *) strShortVersion, "1.0") && !strstr ((const char *) strShortVersion, "1.1")); // if not 1.0 and not 1.1 must be 1.2 or greater
                            
                            // get device max texture size
                            glGetIntegerv (GL_MAX_TEXTURE_SIZE, &deviceMaxTextureSize);
                            if (deviceMaxTextureSize < pOpenGLCaps->maxTextureSize)
                                pOpenGLCaps->maxTextureSize = deviceMaxTextureSize;
                            // get max size of non-power of two texture on devices which support
                            if (NULL != strstr ((const char *) strExtension, "GL_EXT_texture_rectangle"))
                            {
                            #ifdef GL_MAX_RECTANGLE_TEXTURE_SIZE_EXT
                                glGetIntegerv (GL_MAX_RECTANGLE_TEXTURE_SIZE_EXT, &NPOTDMaxTextureSize);
                                if (NPOTDMaxTextureSize < pOpenGLCaps->maxNOPTDTextureSize)
                                    pOpenGLCaps->maxNOPTDTextureSize = NPOTDMaxTextureSize;
                            #endif
                            }
                        }
                        // next display
                        hgdNthDevice = GetNextDevice(hgdNthDevice);
                    }
            }
            aglDestroyContext( ctx );
        }
        else
        { // could not build context set caps to min
            pOpenGLCaps->f_ext_texture_rectangle = false;
            pOpenGLCaps->f_ext_client_storage = false;
            pOpenGLCaps->f_ext_packed_pixel = false;
            pOpenGLCaps->f_ext_texture_edge_clamp = false;
            pOpenGLCaps->f_gl_texture_edge_clamp = false;
            pOpenGLCaps->maxTextureSize = 0;
        }
        
        // set clamp param based on retrieved capabilities
        if (pOpenGLCaps->f_gl_texture_edge_clamp) // if OpenGL 1.2 or later and texture edge clamp is supported natively
                    pOpenGLCaps->edgeClampParam = GL_CLAMP_TO_EDGE;  // use 1.2+ constant to clamp texture coords so as to not sample the border color
        else if (pOpenGLCaps->f_ext_texture_edge_clamp) // if GL_SGIS_texture_edge_clamp extension supported
            pOpenGLCaps->edgeClampParam = GL_CLAMP_TO_EDGE_SGIS; // use extension to clamp texture coords so as to not sample the border color
        else
            pOpenGLCaps->edgeClampParam = GL_CLAMP; // clamp texture coords to [0, 1]

        aglDestroyPixelFormat( fmt );
        DisposeWindow( pWin );
    }
}

//--------------------------------------------------------------------------------------------

static OSStatus
WindowEventHandler( EventHandlerCallRef inCaller, EventRef inEvent, void* inRefcon )
{
    OSStatus    err = eventNotHandledErr;
    WindowRef    window = (WindowRef) inRefcon;

    if( GetEventClass(inEvent) == kEventClassMouse )
    {
        Point mousePoint; // UInt32 modifiers;
        verify_noerr( GetEventParameter(inEvent, kEventParamMouseLocation, typeQDPoint, NULL, sizeof(Point), NULL, &mousePoint) );
        pRecImage pWindowInfo = (pRecImage) GetWRefCon (window); // get the gl info for the window
        if(pWindowInfo) {
            SetPortWindowPort(window);
            GlobalToLocal (&mousePoint); //convert mouse coordinates to local coordintes prior to recording
            mousePoint.h /= pWindowInfo->zoomX; mousePoint.v /= pWindowInfo->zoomY;
            if(mousePoint.h >= 0 && mousePoint.h < pWindowInfo->imageWidth && mousePoint.v >= 0 && mousePoint.v < pWindowInfo->imageHeight)
                g_video->on_mouse(mousePoint.h, mousePoint.v, GetEventKind(inEvent) == kEventMouseUp?-1:1), err = noErr;
        }
    }
    else if( GetEventClass(inEvent) == kEventClassKeyboard )
    {
        char ch;
        verify_noerr( GetEventParameter( inEvent, kEventParamKeyMacCharCodes, typeChar, NULL, sizeof( ch ), NULL, &ch ) );
        if(g_video)
            g_video->on_key(ch);
    }
    else //if( GetEventClass(inEvent) == kEventClassWindow )
    {
        if (GetEventKind(inEvent) == kEventWindowDrawContent)
        {
            //DrawGL(window);
            err = noErr;
        }
        else if (GetEventKind(inEvent) == kEventWindowClose)
        {
            if (window)
            {
                g_video->running = false;
            }
            err = noErr;
        }
        else if (GetEventKind(inEvent) == kEventWindowShowing)
        {
            err = BuildGLForWindow (window);
        }
        else if ((GetEventKind(inEvent) == kEventWindowResizeCompleted) || (GetEventKind(inEvent) == kEventWindowDragCompleted))
        {
            err = ResizeMoveGLWindow (window);
        }
        else if (GetEventKind(inEvent) == kEventWindowZoomed)
        {
            err = ResizeMoveGLWindow (window);
        }
    }
    
    return err;
}
//--------------------------------------------------------------------------------------------
DEFINE_ONE_SHOT_HANDLER_GETTER( WindowEventHandler )

//--------------------------------------------------------------------------------------------
WindowRef HandleNew()
{
    OSStatus  err;
    WindowRef window;
    pRecImage pWindowInfo = NULL;
    static const EventTypeSpec    kWindowEvents[] =
    {
       { kEventClassMouse, kEventMouseUp },
       { kEventClassMouse, kEventMouseDown },
       { kEventClassKeyboard, kEventRawKeyDown },
//       { kEventClassCommand, kEventCommandProcess },
       { kEventClassWindow, kEventWindowShowing },
       { kEventClassWindow, kEventWindowClose },
       { kEventClassWindow, kEventWindowDrawContent },
       { kEventClassWindow, kEventWindowResizeCompleted },
       { kEventClassWindow, kEventWindowDragCompleted },
       { kEventClassWindow, kEventWindowZoomed}
    };
    if (!gpOpenGLCaps)
    {
        gpOpenGLCaps = (pRecGLCap) NewPtrClear (sizeof (recGLCap));
        FindMinimumOpenGLCapabilities (gpOpenGLCaps);
    }

    // Create a window. "MainWindow" is the name of the window object. This name is set in 
    // InterfaceBuilder when the nib is created.
    err = CreateWindowFromNib( sNibRef, CFSTR("MainWindow"), &window );
    require_noerr( err, CantCreateWindow );
    // We don't need the nib reference anymore.
    DisposeNibReference(sNibRef);
    
    pWindowInfo = (recImage *) NewPtrClear (sizeof (recImage));
    pWindowInfo->textureWidth = pWindowInfo->imageWidth = g_sizex;
    pWindowInfo->textureHeight = pWindowInfo->imageHeight = g_sizey;
    pWindowInfo->imageDepth = 32;
    pWindowInfo->fTileTextures = true;
    pWindowInfo->fOverlapTextures = false; // TODO: ???
    pWindowInfo->maxTextureSize = gpOpenGLCaps->maxTextureSize;
    pWindowInfo->fNPOTTextures = gpOpenGLCaps->f_ext_texture_rectangle;
    pWindowInfo->fClientTextures = gpOpenGLCaps->f_ext_client_storage; // texture from client memory if available
    pWindowInfo->fAGPTexturing = true; // if AGP texturing selected
    pWindowInfo->pImageBuffer = (unsigned char*) g_pImg;
    // set default parameters for this image
    pWindowInfo->zoomX = 1.0f; // pixel 1 to 1 size
    pWindowInfo->zoomY = 1.0f; // pixel 1 to 1 size
    SetWRefCon (window, (long) pWindowInfo);
    char buffer[256]; buffer[0] = snprintf(buffer+1, 255, "%s", g_video->title);
    SetWTitle (window, (ConstStr255Param)buffer);
    // Install a command handler on the window. We don't use this handler yet, but nearly all
    // Carbon apps will need to handle commands, so this saves everyone a little typing.
    InstallStandardEventHandler(GetWindowEventTarget(window));
    InstallWindowEventHandler( window, GetWindowEventHandlerUPP(),
                               GetEventTypeCount( kWindowEvents ), kWindowEvents, window, NULL );
    if (noErr != BuildGLForWindow (window))
    {
        DisposeGLForWindow (window);
        DisposeWindow (window);
        return 0;
    }

    // Position new windows in a staggered arrangement on the main screen
    RepositionWindow( window, NULL, kWindowCascadeOnMainScreen );
    
    // The window was created hidden, so show it
    ShowWindow( window );
    return window;
  
CantCreateWindow:
    return 0;
}


//--------------------------------------------------------------------------------------------
static OSStatus
AppEventHandler( EventHandlerCallRef inCaller, EventRef inEvent, void* inRefcon )
{
    OSStatus    result = eventNotHandledErr;

    return result;
}

//=======================================================================================================

video::video()
    : red_mask(0xff0000), red_shift(16), green_mask(0xff00),
      green_shift(8), blue_mask(0xff), blue_shift(0), depth(24)
{
    assert(g_video == 0);
    g_video = this; title = "Video"; updating = true; calc_fps = false;
}

bool video::init_window(int x, int y)
{
    g_sizex = x; g_sizey = y; g_window = 0;
    g_pImg = new unsigned int[x*y];

    // Check for graphics availability
    if( CGGetOnlineDisplayList(0, NULL, NULL) ) {
        running = true; // console mode
        return false;
    }

    OSStatus                    err;
    static const EventTypeSpec    kAppEvents[] =
    {
        { kEventClassCommand, kEventCommandProcess }
    };

    // Create a Nib reference, passing the name of the nib file (without the .nib extension).
    // CreateNibReference only searches into the application bundle.
    err = CreateNibReference( CFSTR("main"), &sNibRef );
    require_noerr( err, ReturnLabel );

    // Install our handler for common commands on the application target
    // Register for standard event handlers
    InstallStandardEventHandler(GetApplicationEventTarget()); // Doesn't work?
    verify_noerr( InstallApplicationEventHandler( NewEventHandlerUPP( AppEventHandler ),
                                    GetEventTypeCount( kAppEvents ), kAppEvents, 0, NULL ) );
    
    // Once the nib reference is created, set the menu bar. "MainMenu" is the name of the menu bar
    // object. This name is set in InterfaceBuilder when the nib is created.
    //err = SetMenuBarFromNib( sNibRef, CFSTR("MenuBar") );
    //require_noerr( err, ReturnLabel );
    InstallStandardEventHandler(GetMenuEventTarget(AcquireRootMenu()));

    // Create a new window. A full-fledged application would do this from an AppleEvent handler for kAEOpenApplication.
    g_window = HandleNew();

ReturnLabel:
    return running = g_window != 0;
}

bool video::init_console()
{
    running = true;
    return true;
}

void video::terminate()
{
    g_video = 0; running = false;
    if(g_pImg) { delete[] g_pImg; g_pImg = 0; }
    if(g_window) {
        DisposeGLForWindow (g_window);
        DisposeWindow (g_window);
        g_window = 0;
    }
}

video::~video()
{
    if(g_video) terminate();
}

//! Count and display FPS count in titlebar
bool video::next_frame()
{
	if(!running) return false;
	if(!g_window) return running;
    //! try acquire mutex if threaded code, returns on failure
    if(threaded && pthread_mutex_trylock(&g_mutex))
        return running;
    g_fps++;
    struct timezone tz; struct timeval now_time; gettimeofday(&now_time, &tz);
    double sec = (now_time.tv_sec+1.0*now_time.tv_usec/1000000.0) - (g_time.tv_sec+1.0*g_time.tv_usec/1000000.0);
    if(sec > 1) {
        memcpy(&g_time, &now_time, sizeof(g_time));
        if(calc_fps) {
            double fps = g_fps; g_fps = 0;
            char buffer[256]; buffer[0] = snprintf(buffer+1, 255, "%s%s: %d fps", title, updating?"":" (no updating)", int(fps/sec));
            SetWTitle (g_window, (ConstStr255Param) buffer );
        }
      }

    EventRef theEvent;
    EventTargetRef theTarget;
    OSStatus                    err;
    // Run the event loop

    theTarget = GetEventDispatcherTarget();
    while( (err = ReceiveNextEvent(0, NULL, kEventDurationNoWait, true, &theEvent)) == noErr)
    {
        SendEventToEventTarget(theEvent, theTarget);
        ReleaseEvent(theEvent);
    }
    if(err != eventLoopTimedOutErr) running = false;
    if(updating) {
        pRecImage pWindowInfo = (pRecImage) GetWRefCon (g_window); // get the gl info for the window
        if(pWindowInfo) DrawGL(g_window);
    }
  	if(threaded) pthread_mutex_unlock(&g_mutex);
    return true;
}

//! Do standart loop
void video::main_loop()
{
    struct timezone tz; gettimeofday(&g_time, &tz);
    //RunApplicationEventLoop(); -- using another application loop model
    on_process();
}

//! Change window title
void video::show_title()
{
    char buffer[256]; buffer[0] = snprintf(buffer+1, 255, "%s", title);
    SetWTitle (g_window, (ConstStr255Param) buffer );
}

///////////////////////////////////////////// public methods of video class ///////////////////////

drawing_area::drawing_area(int x, int y, int sizex, int sizey)
    : start_x(x), start_y(y), size_x(sizex), size_y(sizey), pixel_depth(24),
    base_index(y*g_sizex + x), max_index(g_sizex*g_sizey), index_stride(g_sizex), ptr32(g_pImg)
{
    assert(x < g_sizex); assert(y < g_sizey);
    assert(x+sizex <= g_sizex); assert(y+sizey <= g_sizey);

    index = base_index; // current index
}

drawing_area::~drawing_area() {}