static Tcl_ObjCmdProc Gles2_BiDrawTextureRectangleCmd;
static Tcl_ObjCmdProc Gles2_BiSetupRenderBufferCmd;
static Tcl_ObjCmdProc Gles2_BiSetupFrameBufferCmd;
static Tcl_ObjCmdProc Gles2_BiCompileShadersCmd;
static Tcl_ObjCmdProc Gles2_BiGetFontInfoCmd;
static Tcl_ObjCmdProc Gles2_BiMakeTextTextureCmd;
static Tcl_ObjCmdProc Gles2_BiPixel2CoordCmd;
static Tcl_ObjCmdProc Gles2_BiValue2PixelCmd;
static Tcl_ObjCmdProc Gles2_BiColorValue2RGBACmd;
static Tcl_ObjCmdProc Gles2_BiGetElementPositionsCmd;
static Tcl_ObjCmdProc Gles2_BiGetDiamondPositionsCmd;
static Tcl_ObjCmdProc Gles2_BiGetShadowsCmd;
static Tcl_ObjCmdProc Gles2_BiSwapShadersCmd;

/*
 *  Standard list of built-in methods for all objects.
 */
typedef struct BiMethod {

	0
    },
    { "pixel2coord",
        "",
        "@gles2-builtin-pixel2coord",
        Gles2_BiPixel2CoordCmd,
	0
    },
    { "value2pixel",
        "",
        "@gles2-builtin-value2pixel",
        Gles2_BiValue2PixelCmd,
	0
    },
    { "colorvalue2rgba",
        "",
        "@gles2-builtin-colorvalue2rgba",
        Gles2_BiColorValue2RGBACmd,
	0
    },
    { "getelementpositions",
        "",
        "@gles2-builtin-getelementpositions",
        Gles2_BiGetElementPositionsCmd,
	0
    },
    { "getdiamondpositions",
        "",
        "@gles2-builtin-getdiamondpositions",
        Gles2_BiGetDiamondPositionsCmd,
	0
    },
    { "getshadows",
        "",
        "@gles2-builtin-getshadows",
        Gles2_BiGetShadowsCmd,
	0
    },

	    }
            cmd_obj = Tcl_NewStringObj("::gles2::builtin::fillrectangle", -1);
	    cmd_objv[0] = cmd_obj;
	    if (Tcl_ListObjReplace(interp, obj, 0, 0, 1, cmd_objv) != TCL_OK) {
fprintf(stderr, "VerticalBevel: cannot insert command in front of vertex info\n");
                exit(1);
	    }

            if (Tcl_EvalObjEx(interp, obj, 0) != TCL_OK) {
fprintf(stderr, "VerticalBevel: error in executing fillrectangle command:%s\n", Tcl_GetStringResult(interp));
                exit(1);
	    }
        } else {
#ifdef NOTDEF
            if (strcmp(relief, "ridge") == =) {

	    }
            cmd_obj = Tcl_NewStringObj("::gles2::builtin::fillrectangle", -1);
	    cmd_objv[0] = cmd_obj;
	    if (Tcl_ListObjReplace(interp, obj, 0, 0, 1, cmd_objv) != TCL_OK) {
fprintf(stderr, "VerticalBevel: cannot insert command in front of vertex info\n");
                 exit(1);
	    }

            if (Tcl_EvalObjEx(interp, obj, 0) != TCL_OK) {
fprintf(stderr, "VerticalBevel: error in executing fillrectangle command:%s\n", Tcl_GetStringResult(interp));
                exit(1);
	     }
         }
         x1 += x1Delta;
         x2 += x2Delta;

    int i;

    /*
     *  "::itcl::builtin" commands.
     *  These commands are imported into each class
     *  just before the class definition is parsed.
     */
//fprintf(stderr, "Gles2_BiInit\n");
    Tcl_DStringInit(&buffer);
    for (i=0; i < BiMethodListLen; i++) {
	Tcl_DStringSetLength(&buffer, 0);
	Tcl_DStringAppend(&buffer, "::gles2::builtin::", -1);
	Tcl_DStringAppend(&buffer, BiMethodList[i].name, -1);

        Tcl_CreateObjCommand(interp, Tcl_DStringValue(&buffer),
	        BiMethodList[i].proc, NULL,
		(Tcl_CmdDeleteProc*)NULL);
    }
    Tcl_DStringFree(&buffer);

    gles2BiNs = Tcl_FindNamespace(interp, "::gles2::builtin",

fprintf(stderr, "bad value for useWidth!%s!\n", Tcl_GetString(objv[2]));
        return TCL_ERROR;
    }
    glValue = Pixel2Coord(interp, value, useWidth);
    Tcl_SetObjResult(interp, Tcl_ObjPrintf("%.3f", glValue));
    return result;
}

/*
 * ------------------------------------------------------------------------
 *  Gles2_BiValue2PixelCmd()
 *
 *  Invoked to handle the "value2pixel" command
 *  Handles the
 *  following syntax:
 *
 *    value2pixel value
 *
 * ------------------------------------------------------------------------
 */
int Gles2_BiValue2PixelCmd(
    ClientData dummy,        /* not used */
    Tcl_Interp *interp,      /* current interpreter */
    int objc,                /* number of arguments */
    Tcl_Obj *const objv[])   /* argument objects */
{
    int result = TCL_OK;
    GLfloat glValue;

    Gles2ShowArgs(0, "Gles_BiValue2PixelCmd", objc, objv);
    if (objc != 2) {
        Tcl_WrongNumArgs(interp, 1, objv, "value");
        return TCL_ERROR;
    }
    return Value2Pixel(interp, objv[1]);
}

/*
 * ------------------------------------------------------------------------
 *  Gles2_BiColorValue2RGBACmd()
 *
 *  Invoked to handle the "colorvalue2rgba" command
 *  Handles the

        Tcl_WrongNumArgs(interp, 1, objv, "box");
        return TCL_ERROR;
    }
    obj = GetElementPositions(interp, objv[1]);
fprintf(stderr, "OBJ!%s!\n", Tcl_GetString(obj));
    if (obj == NULL) {
        return TCL_ERROR;
    }
    Tcl_SetObjResult(interp, obj);
    return result;
}

/*
 * ------------------------------------------------------------------------
 *  Gles2_BiGetDiamondPositionsCmd()
 *
 *  Invoked to handle the "getdiamondpositions" command
 *  Handles the
 *  following syntax:
 *
 *    getdiamondpositions value diameter
 *
 * ------------------------------------------------------------------------
 */
int Gles2_BiGetDiamondPositionsCmd(
    ClientData dummy,        /* not used */
    Tcl_Interp *interp,      /* current interpreter */
    int objc,                /* number of arguments */
    Tcl_Obj *const objv[])   /* argument objects */
{
    int result = TCL_OK;
    Tcl_Obj *obj;
    int diameter;

    Gles2ShowArgs(0, "Gles_BiGetDiamondPositionsCmd", objc, objv);
    if (objc != 3) {
        Tcl_WrongNumArgs(interp, 1, objv, "box diameter");
        return TCL_ERROR;
    }
    if (Tcl_GetIntFromObj(interp, objv[2], &diameter) != TCL_OK) {
fprintf(stderr, "bad value for diameter!%s!\n", Tcl_GetString(objv[2]));
        return TCL_ERROR;
    }
    obj = GetDiamondPositions(interp, objv[1], diameter);
fprintf(stderr, "OBJ!%s!\n", Tcl_GetString(obj));
    if (obj == NULL) {
        return TCL_ERROR;
    }
    Tcl_SetObjResult(interp, obj);
    return result;
}

/*
 * ------------------------------------------------------------------------

/*
 * gles2Helpers.c --
 *
 * Copyright (c) 2013 by Arnulf P. Wiedemann
 *
 * See the file "license.terms" for information on usage and redistribution of
 * this file, and for a DISCLAIMER OF ALL WARRANTIES.
 */

#ifdef HAVE_SYS_TYPES_H
#    include <sys/types.h>
#endif
#ifdef HAVE_SYS_PARAM_H
#    include <sys/param.h>
#endif
#include <tcl.h>
#include <string.h>
#include <stdlib.h>
#include <ctype.h>
#include "gles2Int.h"

#define UCHAR(c) ((unsigned char) (c))

#ifdef GLES2_DEBUG
int _gles2_debug_level = 0;

/*
 * ------------------------------------------------------------------------
 *  Gles2ShowArgs()

    rgba->Color[3] = (GLubyte)(dbl * 255);
fprintf(stderr, "r:%d!g:%d!b:%d!@:%d!\n", rgba->Color[0], rgba->Color[1], rgba->Color[2], rgba->Color[3]);
    return TCL_OK;
}

/*
 * ------------------------------------------------------------------------
 *  Pixel2Coord()
 *
 *  the width or height depending on the ui size is delivered
 * ------------------------------------------------------------------------
 */

GLfloat
Pixel2Coord(
    Tcl_Interp *interp,      /* current interpreter */
    int pixels,              /* width or height in pixels */
    int useWidth)            /* whether to use width or height */
{
    if (useWidth) {
        return pixels * 4.0 / uiWidth;
    } else {
        return pixels * 4.0 / uiHeight;
    }
}

/*
 * ------------------------------------------------------------------------
 *  Value2Pixel()
 *
 *  the width or height depending on the ui size is delivered
 * ------------------------------------------------------------------------
 */

int
Value2Pixel(
    Tcl_Interp *interp,      /* current interpreter */
    Tcl_Obj *obj)            /* value */
{
    const char *string;
    char *rest;
    double d;
    int i;
    int units;
    GLfloat value = 0.0;
    static const double bias[] = {
        10.0,   25.4,   1.0,    0.35278 /*25.4 / 72.0*/
    };



    string = Tcl_GetString(obj);

    d = strtod(string, &rest);
    if (rest == string) {
        goto error;
    }
    while ((*rest != '\0') && isspace(UCHAR(*rest))) {
        rest++;
    }

    switch (*rest) {
    case '\0':
        units = -1;
        break;
    case 'm':
        units = 0;
        break;
    case 'c':
        units = 1;
        break;
    case 'i':
        units = 2;
        break;
    case 'p':
        units = 3;
        break;
    default:
        goto error;
    }
    i = (int) d;
    if ((units < 0) && (i == d)) {
        value = d;
    } else {
        value /= bias[units];
    }
    Tcl_SetObjResult(interp, Tcl_NewDoubleObj(value));
    return TCL_OK;

  error:
    if (interp != NULL) {
        Tcl_SetObjResult(interp, Tcl_ObjPrintf(
            "bad screen distance \"%.50s\"", string));
        Tcl_SetErrorCode(interp, "TK", "VALUE", "PIXELS", NULL);
    }
    return TCL_ERROR;
}

/*
 * ------------------------------------------------------------------------
 *  ColorValue2RGBA()
 *
 *  convert a color value like #d9d9d9 to a rgba list of values
 * ------------------------------------------------------------------------

fprintf(stderr, "GetElementPositions could not append z value: %s\n", Tcl_GetString(obj));
        return NULL;
    }
    if (Tcl_ListObjAppendElement(interp, listObj, list1Obj) != TCL_OK) {
fprintf(stderr, "GetElementPositions could not append  pos4 value: %s\n", Tcl_GetString(list1Obj));
        return NULL;
    }

    return listObj;
}

/*
 *
 * ------------------------------------------------------------------------
 *  GetDiamondPositions()
 *
 *  convert a parcel coordinates to graphics context positions
 * ------------------------------------------------------------------------
 */

Tcl_Obj *
GetDiamondPositions(
    Tcl_Interp *interp,      /* current interpreter */
    Tcl_Obj *obj,            /* value to convert */
    int diameter)            /* diameter of diamond */
{
    int pos_objc;
    Tcl_Obj **pos_objv;
    Tcl_Obj *listObj;
    Tcl_Obj *list1Obj;
    int x;
    int y;
    int width;
    int height;
    GLfloat f_x;
    GLfloat f_y;
    GLfloat f_z;
    GLfloat f_width;
    GLfloat f_height;
    GLfloat radius;
    GLfloat w_radius;
    GLfloat h_radius;

    radius = diameter / 2.0;
    w_radius = Pixel2Coord(interp, radius, 1);
    h_radius = Pixel2Coord(interp, radius, 0);
    if (Tcl_ListObjGetElements(interp, obj, &pos_objc, &pos_objv) != TCL_OK) {
fprintf(stderr, "GetDiamondPositions: bad input format: %s\n", Tcl_GetString(obj));
        return NULL;
    }
    f_z = 1.0;
    /* x */
    if (Tcl_GetIntFromObj(interp, pos_objv[0], &x) != TCL_OK) {
fprintf(stderr, "bad value for x!%s!\n", Tcl_GetString(pos_objv[0]));
        return NULL;
    }
    f_x = Pixel2Coord(interp, x, 1);
    /* y */
    if (Tcl_GetIntFromObj(interp, pos_objv[1], &y) != TCL_OK) {
fprintf(stderr, "bad value for y!%s!\n", Tcl_GetString(pos_objv[1]));
        return NULL;
    }
    f_y = Pixel2Coord(interp, y, 0);
    /* width */
    if (Tcl_GetIntFromObj(interp, pos_objv[2], &width) != TCL_OK) {
fprintf(stderr, "bad value for width!%s!\n", Tcl_GetString(pos_objv[2]));
        return NULL;
    }
    f_width = Pixel2Coord(interp, width, 1);
fprintf(stderr, "RADIUS!%f!%f!%f!\n", w_radius, h_radius, f_width);
    /* height */
    if (Tcl_GetIntFromObj(interp, pos_objv[3], &height) != TCL_OK) {
fprintf(stderr, "bad value for height!%s!\n", Tcl_GetString(pos_objv[3]));
        return NULL;
    }
    f_height = Pixel2Coord(interp, height, 0);
    listObj = Tcl_NewListObj(0, NULL); /* the return obj */

    /* pos1 */
    list1Obj = Tcl_NewListObj(0, NULL); /* the position obj */
    if (Tcl_ListObjAppendElement(interp, list1Obj, Tcl_NewDoubleObj(-1.0 + f_x)) != TCL_OK) {
fprintf(stderr, "GetDiamondPositions could not append x value: %s\n", Tcl_GetString(obj));
        return NULL;
    }
    if (Tcl_ListObjAppendElement(interp, list1Obj, Tcl_NewDoubleObj(-1.0 + f_y + h_radius)) != TCL_OK) {
fprintf(stderr, "GetDiamondPositions could not append y value: %s\n", Tcl_GetString(obj));
        return NULL;
    }
    if (Tcl_ListObjAppendElement(interp, list1Obj, Tcl_NewDoubleObj(-1.0 + f_z)) != TCL_OK) {
fprintf(stderr, "GetDiamondPositions could not append z value: %s\n", Tcl_GetString(obj));
        return NULL;
    }
    if (Tcl_ListObjAppendElement(interp, listObj, list1Obj) != TCL_OK) {
fprintf(stderr, "GetDiamondPositions could not append  pos1 value: %s\n", Tcl_GetString(list1Obj));
        return NULL;
    }

    /* pos2 */
    list1Obj = Tcl_NewListObj(0, NULL); /* the position obj */
    if (Tcl_ListObjAppendElement(interp, list1Obj, Tcl_NewDoubleObj(-1.0 + f_x + w_radius)) != TCL_OK) {
fprintf(stderr, "GetDiamondPositions could not append x value: %s\n", Tcl_GetString(obj));
        return NULL;
    }
    if (Tcl_ListObjAppendElement(interp, list1Obj, Tcl_NewDoubleObj(-1.0 + f_y + 2*h_radius)) != TCL_OK) {
fprintf(stderr, "GetDiamondPositions could not append y value: %s\n", Tcl_GetString(obj));
        return NULL;
    }
    if (Tcl_ListObjAppendElement(interp, list1Obj, Tcl_NewDoubleObj(-1.0 + f_z)) != TCL_OK) {
fprintf(stderr, "GetDiamondPositions could not append z value: %s\n", Tcl_GetString(obj));
        return NULL;
    }
    if (Tcl_ListObjAppendElement(interp, listObj, list1Obj) != TCL_OK) {
fprintf(stderr, "GetDiamondPositions could not append  pos2 value: %s\n", Tcl_GetString(list1Obj));
        return NULL;
    }

    /* pos3 */
    list1Obj = Tcl_NewListObj(0, NULL); /* the position obj */
    if (Tcl_ListObjAppendElement(interp, list1Obj, Tcl_NewDoubleObj(-1.0 + f_x + 2*w_radius)) != TCL_OK) {
fprintf(stderr, "GetDiamondPositions could not append x value: %s\n", Tcl_GetString(obj));
        return NULL;
    }
    if (Tcl_ListObjAppendElement(interp, list1Obj, Tcl_NewDoubleObj(-1.0 + f_y + h_radius)) != TCL_OK) {
fprintf(stderr, "GetDiamondPositions could not append y value: %s\n", Tcl_GetString(obj));
        return NULL;
    }
    if (Tcl_ListObjAppendElement(interp, list1Obj, Tcl_NewDoubleObj(-1.0 + f_z)) != TCL_OK) {
fprintf(stderr, "GetDiamondPositions could not append z value: %s\n", Tcl_GetString(obj));
        return NULL;
    }
    if (Tcl_ListObjAppendElement(interp, listObj, list1Obj) != TCL_OK) {
fprintf(stderr, "GetDiamondPositions could not append  pos3 value: %s\n", Tcl_GetString(list1Obj));
        return NULL;
    }

    /* pos4 */
    list1Obj = Tcl_NewListObj(0, NULL); /* the position obj */
    if (Tcl_ListObjAppendElement(interp, list1Obj, Tcl_NewDoubleObj(-1.0 + f_x + w_radius)) != TCL_OK) {
fprintf(stderr, "GetDiamondPositions could not append x value: %s\n", Tcl_GetString(obj));
        return NULL;
    }
    if (Tcl_ListObjAppendElement(interp, list1Obj, Tcl_NewDoubleObj(-1.0 + f_y)) != TCL_OK) {
fprintf(stderr, "GetDiamondPositions could not append y value: %s\n", Tcl_GetString(obj));
        return NULL;
    }
    if (Tcl_ListObjAppendElement(interp, list1Obj, Tcl_NewDoubleObj(-1.0 + f_z)) != TCL_OK) {
fprintf(stderr, "GetDiamondPositions could not append z value: %s\n", Tcl_GetString(obj));
        return NULL;
    }
    if (Tcl_ListObjAppendElement(interp, listObj, list1Obj) != TCL_OK) {
fprintf(stderr, "GetDiamondPositions could not append  pos4 value: %s\n", Tcl_GetString(list1Obj));
        return NULL;
    }

    return listObj;
}

/*
 *
 * ------------------------------------------------------------------------

MODULE_SCOPE int Gles2_GetFreeTypeInfo(Tcl_Interp *interp,
        Gles2WidgetImageInfo *infoPtr, const char *fontName, int fontSize,
        RgbaInfo *rgbaPtr, Tcl_Obj *textPtr, Gles2WidgetImage *wgtPtr,
        int measureOnly);
MODULE_SCOPE int Gles2_GetFreeTypeOffsetMap(Tcl_Interp *interp,
        Gles2WidgetImage *wgtPtr, Tcl_Obj *listPtr);
MODULE_SCOPE GLfloat Pixel2Coord(Tcl_Interp *interp, int pixels, int useWidth);
MODULE_SCOPE int Value2Pixel(Tcl_Interp *interp, Tcl_Obj *obj);
MODULE_SCOPE Tcl_Obj * ColorValue2RGBA(Tcl_Interp *interp, Tcl_Obj *obj);
MODULE_SCOPE Tcl_Obj * GetElementPositions(Tcl_Interp *interp, Tcl_Obj *obj);
MODULE_SCOPE Tcl_Obj * GetDiamondPositions(Tcl_Interp *interp, Tcl_Obj *obj, int diameter);
MODULE_SCOPE Tcl_Obj * GetShadows(Tcl_Interp *interp, Tcl_Obj *backgroundColorObj);

	return sWindow;
}

/*
 * process_window(): This function handles Windows callbacks.
 */
LRESULT CALLBACK process_window(HWND hWnd, UINT uiMsg, WPARAM wParam, LPARAM lParam) {
    switch(uiMsg) {
    case WM_CLOSE:
        PostQuitMessage(0);
        return 0;

    case WM_ACTIVATE:
    case WM_KEYDOWN:
    case WM_KEYUP:
    case WM_SIZE:
        return 0;
    }

    return DefWindowProc(hWnd, uiMsg, wParam, lParam);
}

#else

/* Waits for map notification */
Bool wait_for_map(Display *d, XEvent *e, char *win_ptr) {
fprintf(stderr, "§§§§§§       wait_for_map!0x%08x!\n", e->type);
    return (e->type == MapNotify && e->xmap.window == (*((Window*)win_ptr)));
}

/* Creates an X window */
Window create_window(const char *title, int width, int height, Display* display, 
	EGLDisplay sEGLDisplay, EGLConfig FBConfig, Colormap *pColormap, 
	XVisualInfo **ppVisual) 
{

    Window window;

    screen = DefaultScreen(display);
    eglGetConfigAttrib(sEGLDisplay, FBConfig, EGL_NATIVE_VISUAL_ID, &vID);
    template.visualid = vID;
    visual = XGetVisualInfo(display, VisualIDMask, &template, &n);

    if (!visual) {
        printf("Couldn't get X visual info\n");
        exit(-1);
    }

    colormap = XCreateColormap(display, RootWindow(display, screen), visual->visual, AllocNone);

    wa.colormap = colormap;
    wa.background_pixel = 0xFFFFFFFF;
    wa.border_pixel = 0;

    wa.event_mask = StructureNotifyMask | ExposureMask;
    wa.event_mask |= KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask;
    wa.event_mask |= EnterWindowMask | LeaveWindowMask;
    wa.event_mask |= PointerMotionMask | PointerMotionHintMask;
    wa.event_mask |= Button1MotionMask | Button2MotionMask | Button3MotionMask;
    wa.event_mask |= Button4MotionMask | Button5MotionMask | ButtonMotionMask;
    wa.event_mask |= KeymapStateMask | ExposureMask | VisibilityChangeMask;
    wa.event_mask |= StructureNotifyMask | ResizeRedirectMask;

fprintf(stderr, "event_mask!0x%08x!\n", wa.event_mask);
    mask = CWBackPixel | CWBorderPixel | CWEventMask | CWColormap;

    window = XCreateWindow(display, RootWindow(display, screen), 0, 0, width, height, 
		0, visual->depth, InputOutput, visual->visual, mask, &wa);

    sh.flags = USPosition;
    sh.x = 10;