diff -r da7c1a80df0d -r d2d6724aef32 holdingarea/libGLESv1/src/glesGet.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/holdingarea/libGLESv1/src/glesGet.cpp	Thu Sep 16 09:43:14 2010 +0100
@@ -0,0 +1,492 @@
+/* Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and /or associated documentation files
+ * (the "Materials "), to deal in the Materials without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Materials,
+ * and to permit persons to whom the Materials are furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Materials.
+ *
+ * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE MATERIALS OR
+ * THE USE OR OTHER DEALINGS IN THE MATERIALS.
+ *
+ * Initial Contributors:
+ * Nokia Corporation - initial contribution.
+ *
+ * Contributors:
+ *
+ * Description:
+ *
+ */
+
+#include "glesGet.h"
+#include <GLES/glext.h>
+#include "GLESContext.h"
+#include "GLESDesktopGL.h"
+
+// UINT_MAX
+#include <limits.h>
+
+bool glesGetParameter(const GLESContext& context, const GLESDesktopGL &dgl, GLenum pname, GLESGetType dstType, void* params)
+{
+    GLESGetType srcType;
+    GLboolean b[4];
+    GLint i[16];
+    GLdouble d[16];
+    int n = 1;
+
+    switch(pname)
+    {
+    case GL_MAX_TEXTURE_UNITS:
+        i[0] = context.MaxTextureUnits();
+        srcType = GLES_TYPE_INTEGER;
+        break;
+
+    case GL_MAX_CLIP_PLANES:
+        i[0] = context.MaxClipPlanes();
+        srcType = GLES_TYPE_INTEGER;
+        break;
+
+    case GL_MAX_LIGHTS:
+        i[0] = context.MaxLights();
+        srcType = GLES_TYPE_INTEGER;
+        break;
+
+    case GL_CLIENT_ACTIVE_TEXTURE:
+        i[0] = GL_TEXTURE0 + context.ClientActiveTexture();
+        srcType = GLES_TYPE_ENUM;
+        break;
+
+    case GL_VERTEX_ARRAY:
+        i[0] = context.IsArrayEnabled(GLES_VERTEX_ARRAY);
+        srcType = GLES_TYPE_BOOLEAN;
+        break;
+
+    case GL_VERTEX_ARRAY_SIZE:
+        i[0] = context.VertexArray().Size();
+        srcType = GLES_TYPE_INTEGER;
+        break;
+
+    case GL_VERTEX_ARRAY_TYPE:
+        i[0] = context.VertexArray().Type();
+        srcType = GLES_TYPE_ENUM;
+        break;
+
+    case GL_VERTEX_ARRAY_STRIDE:
+        i[0] = context.VertexArray().Stride();
+        srcType = GLES_TYPE_INTEGER;
+        break;
+
+    case GL_NORMAL_ARRAY:
+        i[0] = context.IsArrayEnabled(GLES_NORMAL_ARRAY);
+        srcType = GLES_TYPE_BOOLEAN;
+        break;
+
+    case GL_NORMAL_ARRAY_TYPE:
+        i[0] = context.NormalArray().Type();
+        srcType = GLES_TYPE_ENUM;
+        break;
+
+    case GL_NORMAL_ARRAY_STRIDE:
+        i[0] = context.NormalArray().Stride();
+        srcType = GLES_TYPE_INTEGER;
+        break;
+
+    case GL_COLOR_ARRAY:
+        i[0] = context.IsArrayEnabled(GLES_COLOR_ARRAY);
+        srcType = GLES_TYPE_BOOLEAN;
+        break;
+
+    case GL_COLOR_ARRAY_SIZE:
+        i[0] = context.ColorArray().Size();
+        srcType = GLES_TYPE_INTEGER;
+        break;
+
+    case GL_COLOR_ARRAY_TYPE:
+        i[0] = context.ColorArray().Type();
+        srcType = GLES_TYPE_ENUM;
+        break;
+
+    case GL_COLOR_ARRAY_STRIDE:
+        i[0] = context.ColorArray().Stride();
+        srcType = GLES_TYPE_INTEGER;
+        break;
+
+    case GL_POINT_SIZE_ARRAY_OES:
+        i[0] = context.IsArrayEnabled(GLES_POINT_SIZE_ARRAY);
+        srcType = GLES_TYPE_BOOLEAN;
+        break;
+
+    case GL_POINT_SIZE_ARRAY_TYPE_OES:
+        i[0] = context.PointSizeArray().Type();
+        srcType = GLES_TYPE_ENUM;
+        break;
+
+    case GL_POINT_SIZE_ARRAY_STRIDE_OES:
+        i[0] = context.PointSizeArray().Stride();
+        srcType = GLES_TYPE_INTEGER;
+        break;
+
+    case GL_POINT_SIZE_ARRAY_BUFFER_BINDING_OES:
+        i[0] = context.PointSizeArray().BufferName();
+        srcType = GLES_TYPE_INTEGER;
+        break;
+
+    case GL_TEXTURE_COORD_ARRAY:
+        i[0] = context.IsArrayEnabled(static_cast<GLESArrayFlag>(GLES_TEXTURE_COORD_ARRAY << context.ClientActiveTexture()));
+        srcType = GLES_TYPE_BOOLEAN;
+        break;
+
+    case GL_TEXTURE_COORD_ARRAY_SIZE:
+        i[0] = context.TexCoordArray().Size();
+        srcType = GLES_TYPE_INTEGER;
+        break;
+
+    case GL_TEXTURE_COORD_ARRAY_TYPE:
+        i[0] = context.TexCoordArray().Type();
+        srcType = GLES_TYPE_ENUM;
+        break;
+
+    case GL_TEXTURE_COORD_ARRAY_STRIDE:
+        i[0] = context.TexCoordArray().Stride();
+        srcType = GLES_TYPE_INTEGER;
+        break;
+
+    case GL_VERTEX_ARRAY_BUFFER_BINDING:
+        i[0] = context.VertexArray().BufferName();
+        srcType = GLES_TYPE_INTEGER;
+        break;
+
+    case GL_NORMAL_ARRAY_BUFFER_BINDING:
+        i[0] = context.NormalArray().BufferName();
+        srcType = GLES_TYPE_INTEGER;
+        break;
+
+    case GL_COLOR_ARRAY_BUFFER_BINDING:
+        i[0] = context.ColorArray().BufferName();
+        srcType = GLES_TYPE_INTEGER;
+        break;
+
+    case GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING:
+        i[0] = context.TexCoordArray().BufferName();
+        srcType = GLES_TYPE_INTEGER;
+        break;
+
+    case GL_ARRAY_BUFFER_BINDING:
+        i[0] = context.ArrayBufferBinding();
+        srcType = GLES_TYPE_INTEGER;
+        break;
+
+    case GL_ELEMENT_ARRAY_BUFFER_BINDING:
+        i[0] = context.ElementArrayBufferBinding();
+        srcType = GLES_TYPE_INTEGER;
+        break;
+
+    case GL_MODELVIEW_MATRIX_FLOAT_AS_INT_BITS_OES:
+        if(dstType != GLES_TYPE_INTEGER)
+        {
+            return false;
+        }
+        dgl.glGetDoublev(GL_MODELVIEW_MATRIX, d);
+        n = 16;
+        for(int j = 0; j < n; j++)
+        {
+            static_cast<GLint*>(params)[j] = *reinterpret_cast<GLint*>(&d[j]);
+        }
+        break;
+
+    case GL_PROJECTION_MATRIX_FLOAT_AS_INT_BITS_OES:
+        if(dstType != GLES_TYPE_INTEGER)
+        {
+            return false;
+        }
+        dgl.glGetDoublev(GL_PROJECTION_MATRIX, d);
+        n = 16;
+        for(int j = 0; j < n; j++)
+        {
+            static_cast<GLint*>(params)[j] = *reinterpret_cast<GLint*>(&d[j]);
+        }
+        break;
+
+    case GL_TEXTURE_MATRIX_FLOAT_AS_INT_BITS_OES:
+        if(dstType != GLES_TYPE_INTEGER)
+        {
+            return false;
+        }
+        dgl.glGetDoublev(GL_TEXTURE_MATRIX, d);
+        n = 16;
+        for(int j = 0; j < n; j++)
+        {
+            static_cast<GLint*>(params)[j] = *reinterpret_cast<GLint*>(&d[j]);
+        }
+        break;
+
+    case GL_POINT_SPRITE_OES:
+        b[0] = dgl.glIsEnabled(GL_POINT_SPRITE);
+        srcType = GLES_TYPE_BOOLEAN;
+        break;
+
+    case GL_NUM_COMPRESSED_TEXTURE_FORMATS:
+        i[0] = 10;
+        srcType = GLES_TYPE_INTEGER;
+        break;
+
+    case GL_COMPRESSED_TEXTURE_FORMATS:
+        i[0] = GL_PALETTE4_RGB8_OES;
+        i[1] = GL_PALETTE4_RGBA8_OES;
+        i[2] = GL_PALETTE4_R5_G6_B5_OES;
+        i[3] = GL_PALETTE4_RGBA4_OES;
+        i[4] = GL_PALETTE4_RGB5_A1_OES;
+        i[5] = GL_PALETTE8_RGB8_OES;
+        i[6] = GL_PALETTE8_RGBA8_OES;
+        i[7] = GL_PALETTE8_R5_G6_B5_OES;
+        i[8] = GL_PALETTE8_RGBA4_OES;
+        i[9] = GL_PALETTE8_RGB5_A1_OES;
+        srcType = GLES_TYPE_ENUM;
+        n = 10;
+        break;
+
+    case GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES:
+        i[0] = GL_RGBA;
+        srcType = GLES_TYPE_ENUM;
+        break;
+
+    case GL_IMPLEMENTATION_COLOR_READ_TYPE_OES:
+        i[0] = GL_UNSIGNED_BYTE;
+        srcType = GLES_TYPE_ENUM;
+        break;
+
+    case GL_ALIASED_POINT_SIZE_RANGE:
+    case GL_ALIASED_LINE_WIDTH_RANGE:
+    case GL_DEPTH_RANGE:
+    case GL_SMOOTH_LINE_WIDTH_RANGE:
+    case GL_SMOOTH_POINT_SIZE_RANGE:
+        dgl.glGetDoublev(pname, d);
+        srcType = GLES_TYPE_DOUBLE;
+        n = 2;
+        break;
+    case GL_ALPHA_TEST_FUNC:
+    case GL_STENCIL_FAIL:
+    case GL_STENCIL_FUNC:
+    case GL_STENCIL_PASS_DEPTH_FAIL:
+    case GL_STENCIL_PASS_DEPTH_PASS:
+    case GL_BLEND_DST:
+    case GL_BLEND_SRC:
+    case GL_LOGIC_OP_MODE:
+    case GL_CULL_FACE:
+    case GL_DEPTH_FUNC:
+    case GL_FOG_HINT:
+    case GL_FOG_MODE:
+    case GL_FRONT_FACE:
+    case GL_LINE_SMOOTH_HINT:
+    case GL_MATRIX_MODE:
+    case GL_PERSPECTIVE_CORRECTION_HINT:
+    case GL_POINT_SMOOTH_HINT:
+    case GL_SHADE_MODEL:
+    case GL_GENERATE_MIPMAP_HINT:
+    case GL_CULL_FACE_MODE:
+    case GL_ACTIVE_TEXTURE:
+        dgl.glGetIntegerv(pname, i);
+        srcType = GLES_TYPE_ENUM;
+        break;
+    case GL_ALPHA_BITS:
+    case GL_RED_BITS:
+    case GL_GREEN_BITS:
+    case GL_BLUE_BITS:
+    case GL_DEPTH_BITS:
+    case GL_STENCIL_BITS:
+    case GL_STENCIL_VALUE_MASK:
+    case GL_STENCIL_WRITEMASK:
+    case GL_MODELVIEW_STACK_DEPTH:
+    case GL_PROJECTION_STACK_DEPTH:
+    case GL_TEXTURE_STACK_DEPTH:
+    case GL_PACK_ALIGNMENT:
+    case GL_UNPACK_ALIGNMENT:
+    case GL_TEXTURE_BINDING_2D:
+    case GL_SUBPIXEL_BITS:
+    case GL_SAMPLE_BUFFERS:
+    case GL_SAMPLES:
+    case GL_BUFFER_SIZE:
+    case GL_STENCIL_CLEAR_VALUE:
+    case GL_MAX_MODELVIEW_STACK_DEPTH:
+    case GL_MAX_PROJECTION_STACK_DEPTH:
+    case GL_MAX_TEXTURE_STACK_DEPTH:
+    case GL_MAX_TEXTURE_SIZE:
+        dgl.glGetIntegerv(pname, i);
+        srcType = GLES_TYPE_INTEGER;
+        break;
+    case GL_ALPHA_TEST_REF:
+    case GL_STENCIL_REF:
+    case GL_DEPTH_CLEAR_VALUE:
+    case GL_FOG_DENSITY:
+    case GL_FOG_START:
+    case GL_FOG_END:
+    case GL_LINE_WIDTH:
+    case GL_POINT_SIZE:
+    case GL_POINT_SIZE_MIN:
+    case GL_POINT_SIZE_MAX:
+    case GL_POLYGON_OFFSET_FACTOR:
+    case GL_POLYGON_OFFSET_UNITS:
+    case GL_POINT_FADE_THRESHOLD_SIZE:
+        dgl.glGetDoublev(pname, d);
+        srcType = GLES_TYPE_DOUBLE;
+        break;
+    case GL_CURRENT_NORMAL:
+    case GL_POINT_DISTANCE_ATTENUATION:
+        dgl.glGetDoublev(pname, d);
+        srcType = GLES_TYPE_DOUBLE;
+        n = 3;
+        break;
+    case GL_COLOR_CLEAR_VALUE:
+    case GL_CURRENT_TEXTURE_COORDS:
+    case GL_CURRENT_COLOR:
+    case GL_FOG_COLOR:
+    case GL_LIGHT_MODEL_AMBIENT:
+    case GL_AMBIENT:
+    case GL_DIFFUSE:
+    case GL_SPECULAR:
+    case GL_EMISSION:
+        dgl.glGetDoublev(pname, d);
+        srcType = GLES_TYPE_DOUBLE;
+        n = 4;
+        break;
+    case GL_COLOR_WRITEMASK:
+        dgl.glGetBooleanv(pname, b);
+        srcType = GLES_TYPE_BOOLEAN;
+        n = 4;
+        break;
+    case GL_DEPTH_WRITEMASK:
+    case GL_LIGHT_MODEL_TWO_SIDE:
+        dgl.glGetBooleanv(pname, b);
+        srcType = GLES_TYPE_BOOLEAN;
+        break;
+    case GL_PROJECTION_MATRIX:
+    case GL_MODELVIEW_MATRIX:
+    case GL_TEXTURE_MATRIX:
+        dgl.glGetDoublev(pname, d);
+        srcType = GLES_TYPE_DOUBLE;
+        n = 16;
+        break;
+    case GL_VIEWPORT:
+    case GL_SCISSOR_BOX:
+        dgl.glGetIntegerv(pname, i);
+        srcType = GLES_TYPE_INTEGER;
+        n = 4;
+        break;
+    case GL_MAX_VIEWPORT_DIMS:
+        dgl.glGetIntegerv(pname, i);
+        srcType = GLES_TYPE_INTEGER;
+        n = 2;
+        break;
+
+    default:
+        return false;
+    }
+
+    // Type conversions
+
+    // Special cases
+    if(dstType == GLES_TYPE_INTEGER &&
+       (pname == GL_CURRENT_COLOR || pname == GL_ALPHA_TEST_REF || pname == GL_DEPTH_CLEAR_VALUE))
+    {
+        for(int j = 0; j < n; j++)
+        {
+            static_cast<GLint*>(params)[j] = static_cast<GLint>((UINT_MAX * d[j] - 1) / 2);
+        }
+        return true;
+    }
+
+    for(int j = 0; j < n; j++)
+    {
+        switch(dstType)
+        {
+        case GLES_TYPE_BOOLEAN:
+            switch(srcType)
+            {
+            case GLES_TYPE_BOOLEAN:
+                static_cast<GLboolean*>(params)[j] = b[j];
+                break;
+            case GLES_TYPE_INTEGER:
+            case GLES_TYPE_ENUM:
+                static_cast<GLboolean*>(params)[j] = i[j] ? GL_TRUE : GL_FALSE;
+                break;
+            case GLES_TYPE_DOUBLE:
+                static_cast<GLboolean*>(params)[j] = d[j] ? GL_TRUE : GL_FALSE;
+                break;
+            default:
+                GLES_ASSERT(false);
+            }
+            break;
+
+        case GLES_TYPE_INTEGER:
+            switch(srcType)
+            {
+            case GLES_TYPE_BOOLEAN:
+                static_cast<GLint*>(params)[j] = b[j];
+                break;
+            case GLES_TYPE_INTEGER:
+            case GLES_TYPE_ENUM:
+                static_cast<GLint*>(params)[j] = i[j];
+                break;
+            case GLES_TYPE_DOUBLE:
+                static_cast<GLint*>(params)[j] = static_cast<GLint>(d[j]);
+                break;
+            default:
+                GLES_ASSERT(false);
+            }
+            break;
+
+        case GLES_TYPE_FLOAT:
+            switch(srcType)
+            {
+            case GLES_TYPE_BOOLEAN:
+                static_cast<GLfloat*>(params)[j] = b[j];
+                break;
+            case GLES_TYPE_INTEGER:
+            case GLES_TYPE_ENUM:
+                static_cast<GLfloat*>(params)[j] = static_cast<GLfloat>(i[j]);
+                break;
+            case GLES_TYPE_DOUBLE:
+                static_cast<GLfloat*>(params)[j] = static_cast<GLfloat>(d[j]);
+                break;
+            default:
+                GLES_ASSERT(false);
+            }
+            break;
+
+        case GLES_TYPE_FIXED:
+            switch(srcType)
+            {
+            case GLES_TYPE_BOOLEAN:
+                static_cast<GLfixed*>(params)[j] = F_TO_X(b[j] ? 1.f : 0.f);
+                break;
+            case GLES_TYPE_INTEGER:
+                static_cast<GLfixed*>(params)[j] = I_TO_X(i[j]);
+                break;
+            case GLES_TYPE_ENUM:
+                static_cast<GLfixed*>(params)[j] = i[j];
+                break;
+            case GLES_TYPE_DOUBLE:
+                static_cast<GLfixed*>(params)[j] = D_TO_X(d[j]);
+                break;
+            default:
+                GLES_ASSERT(false);
+            }
+            break;
+
+        default:
+            GLES_ASSERT(false);
+        }
+    }
+
+    return true;
+}