[evas_gl] Evas GL Render Threading Patch - 2

Change-Id: I856a0ba3a2ba57c6b09a9bb5803a6e2461f82cf7

diff --git a/src/Makefile_Evas.am b/src/Makefile_Evas.am
old mode 100755 (executable)
new mode 100644 (file)
index b6187ed..5b82581
--- a/src/Makefile_Evas.am
+++ b/src/Makefile_Evas.am
@@ -778,7 +778,7 @@ else
 noinst_LTLIBRARIES += modules/evas/engines/gl_common/libevas_engine_gl_common.la
 modules_evas_engines_gl_common_libevas_engine_gl_common_la_SOURCES = $(GL_COMMON_SOURCES)
 modules_evas_engines_gl_common_libevas_engine_gl_common_la_CPPFLAGS = \
--DEVAS_GL_RENDER_THREAD_IS_GENERIC \
+-DEVAS_GL_RENDER_THREAD_COMPILE_FOR_GL_GENERIC \
 -I$(top_builddir)/src/lib/efl \
 -I$(top_srcdir)/src/lib/evas/include \
 -I$(top_srcdir)/src/lib/evas/cserve2 \
@@ -795,7 +795,7 @@ $(install_engineglgenericpkgLTLIBRARIES): install-libLTLIBRARIES
 
 modules_evas_engines_gl_generic_module_la_SOURCES = $(GL_GENERIC_SOURCES)
 modules_evas_engines_gl_generic_module_la_CFLAGS = \
--DEVAS_GL_RENDER_THREAD_IS_GENERIC \
+-DEVAS_GL_RENDER_THREAD_COMPILE_FOR_GL_GENERIC \
 -I$(top_builddir)/src/lib/efl \
 -I$(top_srcdir)/src/lib/evas/include \
 -I$(top_srcdir)/src/lib/evas/cserve2 \

diff --git a/src/lib/evas/common/evas_thread_render.c b/src/lib/evas/common/evas_thread_render.c
index f2815f5..5137454 100644 (file)
--- a/src/lib/evas/common/evas_thread_render.c
+++ b/src/lib/evas/common/evas_thread_render.c
@@ -13,8 +13,7 @@ typedef struct
    Evas_Thread_Command *queue_cache;
    unsigned int queue_cache_max;
 
-   Eina_Condition finish_condition;
-   Eina_Lock finish_lock;
+   Eina_Spinlock finish_spinlock;
    Evas_Thread_Command *waiting_cmd;
 
    volatile int exited;
@@ -64,9 +63,9 @@ evas_thread_queue_append(Evas_Thread *ev_thread, Evas_Thread_Command_Cb cb, void
 
    if (do_finish)
      {
-        eina_lock_take(&ev_thread->finish_lock);
+        eina_spinlock_take(&ev_thread->finish_spinlock);
         ev_thread->waiting_cmd = cmd;
-        eina_lock_release(&ev_thread->finish_lock);
+        eina_spinlock_release(&ev_thread->finish_spinlock);
      }
 
    if (do_flush)
@@ -193,10 +192,10 @@ evas_thread_worker_func(void *data, Eina_Thread thread EINA_UNUSED)
              eina_evlog("+thread_do", cmd->data, 0.0, NULL);
              cmd->cb(cmd->data);
              eina_evlog("-thread_do", cmd->data, 0.0, NULL);
-             eina_lock_take(&ev_thread->finish_lock);
+             eina_spinlock_take(&ev_thread->finish_spinlock);
              if (cmd == ev_thread->waiting_cmd)
                ev_thread->waiting_cmd = NULL;
-             eina_lock_release(&ev_thread->finish_lock);
+             eina_spinlock_release(&ev_thread->finish_spinlock);
 
              cmd++;
              len--;
@@ -221,11 +220,6 @@ evas_thread_init(Evas_Thread *ev_thread, char *thread_name)
    ev_thread->exited = 0;
    ev_thread->exit_thread = EINA_FALSE;
 
-   if(!eina_threads_init())
-     {
-        CRI("Could not init eina threads");
-        goto fail_on_eina_thread_init;
-     }
 
    eina_inarray_step_set(&ev_thread->queue, sizeof (Eina_Inarray), sizeof (Evas_Thread_Command), 128);
 
@@ -234,21 +228,16 @@ evas_thread_init(Evas_Thread *ev_thread, char *thread_name)
          CRI("Could not create draw thread queue lock");
          goto fail_on_lock_creation;
       }
-   if (!eina_lock_new(&ev_thread->finish_lock))
+   if (!eina_spinlock_new(&ev_thread->finish_spinlock))
       {
          CRI("Could not create draw thread finish lock");
-         goto fail_on_lock_creation;
+         goto fail_on_spin_lock_creation;
       }
    if (!eina_condition_new(&ev_thread->queue_condition, &ev_thread->queue_lock))
       {
          CRI("Could not create draw thread queue condition");
          goto fail_on_cond_creation;
       }
-   if (!eina_condition_new(&ev_thread->finish_condition, &ev_thread->finish_lock))
-      {
-         CRI("Could not create draw thread finish condition");
-         goto fail_on_cond_finish_creation;
-      }
    if (!eina_thread_create(&ev_thread->worker, EINA_THREAD_NORMAL, 0,
                            evas_thread_worker_func, ev_thread))
       {
@@ -258,12 +247,12 @@ evas_thread_init(Evas_Thread *ev_thread, char *thread_name)
    return 1;
 fail_on_thread_creation:
    ev_thread->worker = 0;
-   eina_condition_free(&ev_thread->finish_condition);
+   eina_spinlock_free(&ev_thread->finish_spinlock);
    eina_condition_free(&ev_thread->queue_condition);
-fail_on_cond_finish_creation:
-   eina_lock_free(&ev_thread->finish_lock);
 fail_on_cond_creation:
    eina_lock_free(&ev_thread->queue_lock);
+fail_on_spin_lock_creation:
+   eina_spinlock_free(&ev_thread->finish_spinlock);
 fail_on_lock_creation:
    eina_threads_shutdown();
 fail_on_eina_thread_init:
@@ -297,6 +286,7 @@ evas_thread_shutdown(Evas_Thread *ev_thread)
 
    eina_thread_join(ev_thread->worker);
 timeout_shutdown:
+   eina_spinlock_free(&ev_thread->finish_spinlock);
    eina_lock_free(&ev_thread->queue_lock);
    eina_condition_free(&ev_thread->queue_condition);
 
@@ -305,7 +295,6 @@ timeout_shutdown:
    eina_inarray_flush(&ev_thread->queue);
    free(ev_thread->queue_cache);
 
-   eina_threads_shutdown();
 }
 
 int
@@ -313,6 +302,11 @@ evas_threads_init(void)
 {
    if (evas_threads_init_count++) return evas_threads_init_count;
 
+   if(!eina_threads_init())
+     {
+        CRI("Could not init eina threads");
+        return --evas_threads_init_count;
+     }
    if (!evas_thread_init(&evas_thread_software, "Eevas-thread-wk-sw")) return --evas_threads_init_count;
    if (!evas_thread_init(&evas_thread_gl, "Eevas-thread-wk-gl"))       return --evas_threads_init_count;
    if (!evas_thread_init(&evas_thread_evgl, "Eevas-thread-wk-evgl"))   return --evas_threads_init_count;
@@ -331,5 +325,5 @@ evas_threads_shutdown(void)
    evas_thread_shutdown(&evas_thread_evgl);
    evas_thread_shutdown(&evas_thread_gl);
    evas_thread_shutdown(&evas_thread_software);
-
+   eina_threads_shutdown();
 }

diff --git a/src/modules/evas/engines/gl_common/evas_gl_context.c b/src/modules/evas/engines/gl_common/evas_gl_context.c
index 984f04d..08b58c2 100644 (file)
--- a/src/modules/evas/engines/gl_common/evas_gl_context.c
+++ b/src/modules/evas/engines/gl_common/evas_gl_context.c
@@ -3248,7 +3248,6 @@ _orig_shader_array_flush(Evas_Engine_GL_Context *gc)
    Eina_Bool setclip;
    Eina_Bool fbo = EINA_FALSE;
 
-   if (!gc->havestuff) return;
    gw = gc->w;
    gh = gc->h;
    if (!((gc->pipe[0].shader.surface == gc->def_surface) ||
@@ -3958,6 +3957,8 @@ _gl_thread_shader_array_flush(void *data)
 static void
 shader_array_flush(Evas_Engine_GL_Context *gc)
 {
+   if (!gc->havestuff) return;
+
    if (!evas_gl_thread_enabled())
      {
         _orig_shader_array_flush(gc);

diff --git a/src/modules/evas/engines/gl_common/evas_gl_texture.c b/src/modules/evas/engines/gl_common/evas_gl_texture.c
index a4431b5..144f221 100644 (file)
--- a/src/modules/evas/engines/gl_common/evas_gl_texture.c
+++ b/src/modules/evas/engines/gl_common/evas_gl_texture.c
@@ -1822,6 +1822,7 @@ evas_gl_common_texture_rgb_a_pair_update(Evas_GL_Texture *tex,
      }
 on_error:
    glBindTexture_thread_cmd(tex->gc->state.current.tex_target, tex->gc->state.current.cur_tex);
+   evas_gl_thread_finish();
 }
 
 Evas_GL_Texture *

diff --git a/src/modules/evas/engines/gl_common/evas_gl_thread.c b/src/modules/evas/engines/gl_common/evas_gl_thread.c
index 3865bc3..2f6978e 100644 (file)
--- a/src/modules/evas/engines/gl_common/evas_gl_thread.c
+++ b/src/modules/evas/engines/gl_common/evas_gl_thread.c
@@ -4,7 +4,7 @@
 /* Main Thread id */
 Eina_Thread _main_thread_id = 0;
 
-#ifdef EVAS_GL_RENDER_THREAD_IS_GENERIC
+#ifdef EVAS_GL_RENDER_THREAD_COMPILE_FOR_GL_GENERIC
 
 /* Memory Pool */
 Eina_Mempool *_mp_default = NULL;
@@ -92,7 +92,8 @@ evas_gl_thread_force_finish()
 }
 
 
-void evas_gl_thread_init()
+void
+evas_gl_thread_init()
 {
 #define BUILD_MEMPOOL(name) \
    name = eina_mempool_add("chained_mempool", #name, NULL, \
@@ -109,7 +110,8 @@ void evas_gl_thread_init()
    _main_thread_id = eina_thread_self();
 }
 
-void evas_gl_thread_terminate()
+void
+evas_gl_thread_terminate()
 {
    eina_mempool_del(_mp_default);
    eina_mempool_del(_mp_command);
@@ -173,7 +175,7 @@ evas_evgl_thread_finish()
 }
 
 
-#else /* ! EVAS_GL_RENDER_THREAD_IS_GENERIC */
+#else /* ! EVAS_GL_RENDER_THREAD_COMPILE_FOR_GL_GENERIC */
 
 
 #include <dlfcn.h>
@@ -188,7 +190,8 @@ void (*evas_evgl_thread_begin)();
 void (*evas_evgl_thread_end)();
 void (*evas_evgl_thread_finish)();
 
-void evas_gl_thread_link_init()
+void
+evas_gl_thread_link_init()
 {
 #define LINK2GENERIC(sym) \
    sym = dlsym(RTLD_DEFAULT, #sym); \
@@ -210,10 +213,9 @@ void evas_gl_thread_link_init()
    _glx_thread_link_init();
 #endif
    _gl_thread_link_init();
-   _evgl_thread_link_init();
 
    _main_thread_id = eina_thread_self();
 }
 
 
-#endif /* EVAS_GL_RENDER_THREAD_IS_GENERIC */
+#endif /* EVAS_GL_RENDER_THREAD_COMPILE_FOR_GL_GENERIC */

diff --git a/src/modules/evas/engines/gl_common/evas_gl_thread.h b/src/modules/evas/engines/gl_common/evas_gl_thread.h
index 3b0d907..5b1201a 100644 (file)
--- a/src/modules/evas/engines/gl_common/evas_gl_thread.h
+++ b/src/modules/evas/engines/gl_common/evas_gl_thread.h
@@ -1,10 +1,10 @@
 #ifndef EVAS_GL_THREAD_H
 #define EVAS_GL_THREAD_H
 
-extern Eina_Thread _main_thread_id;
-
 #include "evas_gl_common.h"
 
+extern Eina_Thread _main_thread_id;
+
 /* Memory Pool */
 extern Eina_Mempool *_mp_default;
 extern Eina_Mempool *_mp_command;
@@ -25,7 +25,7 @@ extern unsigned int _mp_delete_object_pool_size;
 extern unsigned int _mp_texture_pool_size;
 
 
-#ifdef EVAS_GL_RENDER_THREAD_IS_GENERIC
+#ifdef EVAS_GL_RENDER_THREAD_COMPILE_FOR_GL_GENERIC
 
 #ifdef EAPI
 # undef EAPI
@@ -69,7 +69,7 @@ extern void evas_gl_thread_init();
 extern void evas_gl_thread_terminate();
 
 
-#else /* ! EVAS_GL_RENDER_THREAD_IS_GENERIC */
+#else /* ! EVAS_GL_RENDER_THREAD_COMPILE_FOR_GL_GENERIC */
 
 
 extern int (*evas_gl_thread_enabled)();
@@ -85,7 +85,7 @@ extern void (*evas_evgl_thread_finish)();
 extern void evas_gl_thread_link_init();
 
 
-#endif /* EVAS_GL_RENDER_THREAD_IS_GENERIC */
+#endif /* EVAS_GL_RENDER_THREAD_COMPILE_FOR_GL_GENERIC */
 
 
 #include "evas_gl_thread_gl.h"

diff --git a/src/modules/evas/engines/gl_common/evas_gl_thread_egl.c b/src/modules/evas/engines/gl_common/evas_gl_thread_egl.c
index 07bbb4a..0227623 100644 (file)
--- a/src/modules/evas/engines/gl_common/evas_gl_thread_egl.c
+++ b/src/modules/evas/engines/gl_common/evas_gl_thread_egl.c
@@ -1,9 +1,8 @@
-#include "evas_common_private.h"
 #include "evas_gl_thread.h"
 
 #ifdef GL_GLES
 
-#ifdef EVAS_GL_RENDER_THREAD_IS_GENERIC
+#ifdef EVAS_GL_RENDER_THREAD_COMPILE_FOR_GL_GENERIC
 
 
 
@@ -15,8 +14,8 @@ typedef struct
 static void
 _gl_thread_eglGetError(void *data)
 {
-   Evas_Thread_Command_eglGetError *thread_param = data;
-   thread_param->return_value = eglGetError();
+   Evas_Thread_Command_eglGetError *thread_data = data;
+   thread_data->return_value = eglGetError();
 }
 
 EAPI EGLint
@@ -25,9 +24,14 @@ eglGetError_thread_cmd(void)
    if (!evas_gl_thread_enabled())
      return eglGetError();
 
-   Evas_Thread_Command_eglGetError thread_param;
-   evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL, _gl_thread_eglGetError, &thread_param, EVAS_GL_THREAD_MODE_FINISH);
-   return thread_param.return_value;
+   Evas_Thread_Command_eglGetError thread_data;
+
+   evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
+                              _gl_thread_eglGetError,
+                              &thread_data,
+                              EVAS_GL_THREAD_MODE_FINISH);
+
+   return thread_data.return_value;
 }
 
 
@@ -41,8 +45,9 @@ typedef struct
 static void
 _gl_thread_eglBindAPI(void *data)
 {
-   Evas_Thread_Command_eglBindAPI *thread_param = data;
-   thread_param->return_value = eglBindAPI(thread_param->api);
+   Evas_Thread_Command_eglBindAPI *thread_data = data;
+
+   thread_data->return_value = eglBindAPI(thread_data->api);
 }
 
 EAPI EGLBoolean
@@ -51,10 +56,16 @@ eglBindAPI_thread_cmd(EGLenum api)
    if (!evas_gl_thread_enabled())
      return eglBindAPI(api);
 
-   Evas_Thread_Command_eglBindAPI thread_param;
-   thread_param.api = api;
-   evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL, _gl_thread_eglBindAPI, &thread_param, EVAS_GL_THREAD_MODE_FINISH);
-   return thread_param.return_value;
+   Evas_Thread_Command_eglBindAPI thread_data;
+
+   thread_data.api = api;
+
+   evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
+                              _gl_thread_eglBindAPI,
+                              &thread_data,
+                              EVAS_GL_THREAD_MODE_FINISH);
+
+   return thread_data.return_value;
 }
 
 
@@ -67,8 +78,9 @@ typedef struct
 static void
 _gl_thread_eglQueryAPI(void *data)
 {
-   Evas_Thread_Command_eglQueryAPI *thread_param = data;
-   thread_param->return_value = eglQueryAPI();
+   Evas_Thread_Command_eglQueryAPI *thread_data = data;
+
+   thread_data->return_value = eglQueryAPI();
 }
 
 EAPI EGLenum
@@ -77,9 +89,14 @@ eglQueryAPI_thread_cmd(void)
    if (!evas_gl_thread_enabled())
      return eglQueryAPI();
 
-   Evas_Thread_Command_eglQueryAPI thread_param;
-   evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL, _gl_thread_eglQueryAPI, &thread_param, EVAS_GL_THREAD_MODE_FINISH);
-   return thread_param.return_value;
+   Evas_Thread_Command_eglQueryAPI thread_data;
+
+   evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
+                              _gl_thread_eglQueryAPI,
+                              &thread_data,
+                              EVAS_GL_THREAD_MODE_FINISH);
+
+   return thread_data.return_value;
 }
 
 
@@ -93,16 +110,30 @@ typedef struct
    EGLContext ctx;
 } Evas_Thread_Command_eglMakeCurrent;
 
-EGLContext current_thread_ctx = EGL_NO_CONTEXT;
+EGLDisplay current_thread_dpy  = EGL_NO_DISPLAY;
+EGLSurface current_thread_draw = EGL_NO_SURFACE;
+EGLSurface current_thread_read = EGL_NO_SURFACE;
+EGLContext current_thread_ctx  = EGL_NO_CONTEXT;
 
 static void
 _gl_thread_eglMakeCurrent(void *data)
 {
-   Evas_Thread_Command_eglMakeCurrent *thread_param = data;
-   ERR("THREAD >> OTHER THREAD MAKECURRENT : (%p, %p, %p, %p)\n", thread_param->dpy, thread_param->draw, thread_param->read, thread_param->ctx);
-   thread_param->return_value = eglMakeCurrent(thread_param->dpy, thread_param->draw, thread_param->read, thread_param->ctx);
-   if (thread_param->return_value == EGL_TRUE)
-     current_thread_ctx = thread_param->ctx;
+   Evas_Thread_Command_eglMakeCurrent *thread_data = data;
+   DBG("THREAD >> OTHER THREAD MAKECURRENT : (%p, %p, %p, %p)\n", thread_data->dpy,
+         thread_data->draw, thread_data->read, thread_data->ctx);
+
+   thread_data->return_value = eglMakeCurrent(thread_data->dpy,
+                                              thread_data->draw,
+                                              thread_data->read,
+                                              thread_data->ctx);
+
+   if (thread_data->return_value == EGL_TRUE)
+     {
+        current_thread_dpy = thread_data->dpy;
+        current_thread_draw = thread_data->draw;
+        current_thread_read = thread_data->read;
+        current_thread_ctx = thread_data->ctx;
+     }
 }
 
 EAPI EGLBoolean
@@ -111,13 +142,19 @@ eglMakeCurrent_thread_cmd(EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLC
    if (!evas_gl_thread_enabled())
      return eglMakeCurrent(dpy, draw, read, ctx);
 
-   Evas_Thread_Command_eglMakeCurrent thread_param;
-   thread_param.dpy = dpy;
-   thread_param.draw = draw;
-   thread_param.read = read;
-   thread_param.ctx = ctx;
-   evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL, _gl_thread_eglMakeCurrent, &thread_param, EVAS_GL_THREAD_MODE_FINISH);
-   return thread_param.return_value;
+   Evas_Thread_Command_eglMakeCurrent thread_data;
+
+   thread_data.dpy = dpy;
+   thread_data.draw = draw;
+   thread_data.read = read;
+   thread_data.ctx = ctx;
+
+   evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
+                              _gl_thread_eglMakeCurrent,
+                              &thread_data,
+                              EVAS_GL_THREAD_MODE_FINISH);
+
+   return thread_data.return_value;
 }
 
 
@@ -133,59 +170,29 @@ eglGetCurrentContext_thread_cmd(void)
 }
 
 
-
-typedef struct
-{
-   EGLDisplay return_value;
-   EGLint     readdraw;
-} Evas_Thread_Command_eglGetCurrentSurface;
-
-static void
-_gl_thread_eglGetCurrentSurface(void *data)
-{
-   Evas_Thread_Command_eglGetCurrentSurface *thread_param = data;
-   thread_param->return_value = eglGetCurrentSurface(thread_param->readdraw);
-}
-
 EAPI EGLSurface
 eglGetCurrentSurface_thread_cmd(EGLint readdraw)
 {
    if (!evas_gl_thread_enabled())
      return eglGetCurrentSurface(readdraw);
 
-   Evas_Thread_Command_eglGetCurrentSurface thread_param;
-   thread_param.readdraw = readdraw;
-   evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL, _gl_thread_eglGetCurrentSurface, &thread_param, EVAS_GL_THREAD_MODE_FINISH);
-   return thread_param.return_value;
+   if (readdraw == EGL_READ)
+      return current_thread_read;
+   if (readdraw == EGL_DRAW)
+      return current_thread_draw;
 }
 
 
-
-typedef struct
-{
-   EGLDisplay return_value;
-} Evas_Thread_Command_eglGetCurrentDisplay;
-
-static void
-_gl_thread_eglGetCurrentDisplay(void *data)
-{
-   Evas_Thread_Command_eglGetCurrentDisplay *thread_param = data;
-   thread_param->return_value = eglGetCurrentDisplay();
-}
-
 EAPI EGLDisplay
 eglGetCurrentDisplay_thread_cmd(void)
 {
    if (!evas_gl_thread_enabled())
      return eglGetCurrentDisplay();
 
-   Evas_Thread_Command_eglGetCurrentDisplay thread_param;
-   evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL, _gl_thread_eglGetCurrentDisplay, &thread_param, EVAS_GL_THREAD_MODE_FINISH);
-   return thread_param.return_value;
+   return current_thread_dpy;
 }
 
 
-
 typedef struct
 {
    EGLBoolean return_value;
@@ -194,8 +201,9 @@ typedef struct
 static void
 _gl_thread_eglReleaseThread(void *data)
 {
-   Evas_Thread_Command_eglReleaseThread *thread_param = data;
-   thread_param->return_value = eglReleaseThread();
+   Evas_Thread_Command_eglReleaseThread *thread_data = data;
+
+   thread_data->return_value = eglReleaseThread();
 }
 
 EAPI EGLBoolean
@@ -204,9 +212,14 @@ eglReleaseThread_thread_cmd(void)
    if (!evas_gl_thread_enabled())
      return eglReleaseThread();
 
-   Evas_Thread_Command_eglReleaseThread thread_param;
-   evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL, _gl_thread_eglReleaseThread, &thread_param, EVAS_GL_THREAD_MODE_FINISH);
-   return thread_param.return_value;
+   Evas_Thread_Command_eglReleaseThread thread_data;
+
+   evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
+                              _gl_thread_eglReleaseThread,
+                              &thread_data,
+                              EVAS_GL_THREAD_MODE_FINISH);
+
+   return thread_data.return_value;
 }
 
 
@@ -223,8 +236,12 @@ typedef struct
 static void
 _gl_thread_eglQuerySurface(void *data)
 {
-   Evas_Thread_Command_eglQuerySurface *thread_param = data;
-   thread_param->return_value = eglQuerySurface(thread_param->dpy, thread_param->surface, thread_param->attribute, thread_param->value);
+   Evas_Thread_Command_eglQuerySurface *thread_data = data;
+
+   thread_data->return_value = eglQuerySurface(thread_data->dpy,
+                                               thread_data->surface,
+                                               thread_data->attribute,
+                                               thread_data->value);
 }
 
 EAPI EGLBoolean
@@ -233,13 +250,19 @@ eglQuerySurface_thread_cmd(EGLDisplay dpy, EGLSurface surface, EGLint attribute,
    if (!evas_gl_thread_enabled())
      return eglQuerySurface(dpy, surface, attribute, value);
 
-   Evas_Thread_Command_eglQuerySurface thread_param;
-   thread_param.dpy = dpy;
-   thread_param.surface = surface;
-   thread_param.attribute = attribute;
-   thread_param.value = value;
-   evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL, _gl_thread_eglQuerySurface, &thread_param, EVAS_GL_THREAD_MODE_FINISH);
-   return thread_param.return_value;
+   Evas_Thread_Command_eglQuerySurface thread_data;
+
+   thread_data.dpy = dpy;
+   thread_data.surface = surface;
+   thread_data.attribute = attribute;
+   thread_data.value = value;
+
+   evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
+                              _gl_thread_eglQuerySurface,
+                              &thread_data,
+                              EVAS_GL_THREAD_MODE_FINISH);
+
+   return thread_data.return_value;
 }
 
 
@@ -254,8 +277,10 @@ typedef struct
 static void
 _gl_thread_eglSwapInterval(void *data)
 {
-   Evas_Thread_Command_eglSwapInterval *thread_param = data;
-   thread_param->return_value = eglSwapInterval(thread_param->dpy, thread_param->interval);
+   Evas_Thread_Command_eglSwapInterval *thread_data = data;
+
+   thread_data->return_value = eglSwapInterval(thread_data->dpy,
+                                               thread_data->interval);
 }
 
 EAPI EGLBoolean
@@ -264,11 +289,17 @@ eglSwapInterval_thread_cmd(EGLDisplay dpy, EGLint interval)
    if (!evas_gl_thread_enabled())
      return eglSwapInterval(dpy, interval);
 
-   Evas_Thread_Command_eglSwapInterval thread_param;
-   thread_param.dpy = dpy;
-   thread_param.interval = interval;
-   evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL, _gl_thread_eglSwapInterval, &thread_param, EVAS_GL_THREAD_MODE_FINISH);
-   return thread_param.return_value;
+   Evas_Thread_Command_eglSwapInterval thread_data;
+
+   thread_data.dpy = dpy;
+   thread_data.interval = interval;
+
+   evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
+                              _gl_thread_eglSwapInterval,
+                              &thread_data,
+                              EVAS_GL_THREAD_MODE_FINISH);
+
+   return thread_data.return_value;
 }
 
 
@@ -281,8 +312,9 @@ typedef struct
 static void
 _gl_thread_eglWaitGL(void *data)
 {
-   Evas_Thread_Command_eglWaitGL *thread_param = data;
-   thread_param->return_value = eglWaitGL();
+   Evas_Thread_Command_eglWaitGL *thread_data = data;
+
+   thread_data->return_value = eglWaitGL();
 }
 
 EAPI EGLBoolean
@@ -291,9 +323,14 @@ eglWaitGL_thread_cmd(void)
    if (!evas_gl_thread_enabled())
      return eglWaitGL();
 
-   Evas_Thread_Command_eglWaitGL thread_param;
-   evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL, _gl_thread_eglWaitGL, &thread_param, EVAS_GL_THREAD_MODE_FINISH);
-   return thread_param.return_value;
+   Evas_Thread_Command_eglWaitGL thread_data;
+
+   evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
+                              _gl_thread_eglWaitGL,
+                              &thread_data,
+                              EVAS_GL_THREAD_MODE_FINISH);
+
+   return thread_data.return_value;
 }
 
 
@@ -308,8 +345,10 @@ typedef struct
 static void
 _gl_thread_eglSwapBuffers(void *data)
 {
-   Evas_Thread_Command_eglSwapBuffers *thread_param = data;
-   thread_param->return_value = eglSwapBuffers(thread_param->dpy, thread_param->surface);
+   Evas_Thread_Command_eglSwapBuffers *thread_data = data;
+
+   thread_data->return_value = eglSwapBuffers(thread_data->dpy,
+                                              thread_data->surface);
 }
 
 EAPI EGLBoolean
@@ -318,11 +357,17 @@ eglSwapBuffers_thread_cmd(EGLDisplay dpy, EGLSurface surface)
    if (!evas_gl_thread_enabled())
      return eglSwapBuffers(dpy, surface);
 
-   Evas_Thread_Command_eglSwapBuffers thread_param;
-   thread_param.dpy = dpy;
-   thread_param.surface = surface;
-   evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL, _gl_thread_eglSwapBuffers, &thread_param, EVAS_GL_THREAD_MODE_FINISH);
-   return thread_param.return_value;
+   Evas_Thread_Command_eglSwapBuffers thread_data;
+
+   thread_data.dpy = dpy;
+   thread_data.surface = surface;
+
+   evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
+                              _gl_thread_eglSwapBuffers,
+                              &thread_data,
+                              EVAS_GL_THREAD_MODE_FINISH);
+
+   return thread_data.return_value;
 }
 
 
@@ -353,8 +398,12 @@ eglSwapBuffersWithDamage_orig_evas_get()
 static void
 _gl_thread_eglSwapBuffersWithDamage(void *data)
 {
-   Evas_Thread_Command_eglSwapBuffersWithDamage *thread_param = data;
-   thread_param->return_value = orig_evas_eglSwapBuffersWithDamage(thread_param->dpy, thread_param->surface, thread_param->rects, thread_param->n_rects);
+   Evas_Thread_Command_eglSwapBuffersWithDamage *thread_data = data;
+
+   thread_data->return_value = orig_evas_eglSwapBuffersWithDamage(thread_data->dpy,
+                                                                  thread_data->surface,
+                                                                  thread_data->rects,
+                                                                  thread_data->n_rects);
 }
 
 EAPI EGLBoolean
@@ -363,13 +412,19 @@ eglSwapBuffersWithDamage_thread_cmd(EGLDisplay dpy, EGLSurface surface, EGLint *
    if (!evas_gl_thread_enabled())
      return orig_evas_eglSwapBuffersWithDamage(dpy, surface, rects, n_rects);
 
-   Evas_Thread_Command_eglSwapBuffersWithDamage thread_param;
-   thread_param.dpy = dpy;
-   thread_param.surface = surface;
-   thread_param.rects = rects;
-   thread_param.n_rects = n_rects;
-   evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL, _gl_thread_eglSwapBuffersWithDamage, &thread_param, EVAS_GL_THREAD_MODE_FINISH);
-   return thread_param.return_value;
+   Evas_Thread_Command_eglSwapBuffersWithDamage thread_data;
+
+   thread_data.dpy = dpy;
+   thread_data.surface = surface;
+   thread_data.rects = rects;
+   thread_data.n_rects = n_rects;
+
+   evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
+                              _gl_thread_eglSwapBuffersWithDamage,
+                              &thread_data,
+                              EVAS_GL_THREAD_MODE_FINISH);
+
+   return thread_data.return_value;
 }
 
 
@@ -400,8 +455,12 @@ eglSetDamageRegion_orig_evas_get()
 static void
 _gl_thread_eglSetDamageRegion(void *data)
 {
-   Evas_Thread_Command_eglSetDamageRegion *thread_param = data;
-   thread_param->return_value = orig_evas_eglSetDamageRegion(thread_param->dpy, thread_param->surface, thread_param->rects, thread_param->n_rects);
+   Evas_Thread_Command_eglSetDamageRegion *thread_data = data;
+
+   thread_data->return_value = orig_evas_eglSetDamageRegion(thread_data->dpy,
+                                                            thread_data->surface,
+                                                            thread_data->rects,
+                                                            thread_data->n_rects);
 }
 
 EAPI EGLBoolean
@@ -410,13 +469,19 @@ eglSetDamageRegion_thread_cmd(EGLDisplay dpy, EGLSurface surface, EGLint *rects,
    if (!evas_gl_thread_enabled())
      return orig_evas_eglSetDamageRegion(dpy, surface, rects, n_rects);
 
-   Evas_Thread_Command_eglSetDamageRegion thread_param;
-   thread_param.dpy = dpy;
-   thread_param.surface = surface;
-   thread_param.rects = rects;
-   thread_param.n_rects = n_rects;
-   evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL, _gl_thread_eglSetDamageRegion, &thread_param, EVAS_GL_THREAD_MODE_FINISH);
-   return thread_param.return_value;
+   Evas_Thread_Command_eglSetDamageRegion thread_data;
+
+   thread_data.dpy = dpy;
+   thread_data.surface = surface;
+   thread_data.rects = rects;
+   thread_data.n_rects = n_rects;
+
+   evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
+                              _gl_thread_eglSetDamageRegion,
+                              &thread_data,
+                              EVAS_GL_THREAD_MODE_FINISH);
+
+   return thread_data.return_value;
 }
 
 
@@ -447,8 +512,12 @@ eglQueryWaylandBuffer_orig_evas_get()
 static void
 _gl_thread_eglQueryWaylandBuffer(void *data)
 {
-   Evas_Thread_Command_eglQueryWaylandBuffer *thread_param = data;
-   thread_param->return_value = orig_evas_eglQueryWaylandBuffer(thread_param->dpy, thread_param->buffer, thread_param->attribute, thread_param->value);
+   Evas_Thread_Command_eglQueryWaylandBuffer *thread_data = data;
+
+   thread_data->return_value = orig_evas_eglQueryWaylandBuffer(thread_data->dpy,
+                                                               thread_data->buffer,
+                                                               thread_data->attribute,
+                                                               thread_data->value);
 }
 
 EAPI EGLBoolean
@@ -457,13 +526,19 @@ eglQueryWaylandBuffer_thread_cmd(EGLDisplay dpy, void *buffer, EGLint attribute,
    if (!evas_gl_thread_enabled())
      return orig_evas_eglQueryWaylandBuffer(dpy, buffer, attribute, value);
 
-   Evas_Thread_Command_eglQueryWaylandBuffer thread_param;
-   thread_param.dpy = dpy;
-   thread_param.buffer = buffer;
-   thread_param.attribute = attribute;
-   thread_param.value = value;
-   evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL, _gl_thread_eglQueryWaylandBuffer, &thread_param, EVAS_GL_THREAD_MODE_FINISH);
-   return thread_param.return_value;
+   Evas_Thread_Command_eglQueryWaylandBuffer thread_data;
+
+   thread_data.dpy = dpy;
+   thread_data.buffer = buffer;
+   thread_data.attribute = attribute;
+   thread_data.value = value;
+
+   evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
+                              _gl_thread_eglQueryWaylandBuffer,
+                              &thread_data,
+                              EVAS_GL_THREAD_MODE_FINISH);
+
+   return thread_data.return_value;
 }
 
 
@@ -478,8 +553,9 @@ typedef struct
 static void
 _evgl_thread_eglGetError(void *data)
 {
-   Evas_GL_Thread_Command_eglGetError *thread_param = data;
-   thread_param->return_value = eglGetError();
+   Evas_GL_Thread_Command_eglGetError *thread_data = data;
+
+   thread_data->return_value = eglGetError();
 }
 
 EAPI EGLint
@@ -488,15 +564,22 @@ eglGetError_evgl_thread_cmd(void)
    if (!evas_evgl_thread_enabled())
      return eglGetError();
 
-   Evas_GL_Thread_Command_eglGetError thread_param;
-   evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL, _evgl_thread_eglGetError, &thread_param, EVAS_GL_THREAD_MODE_FINISH);
-   return thread_param.return_value;
-}
+   Evas_GL_Thread_Command_eglGetError thread_data;
+
+   evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
+                              _evgl_thread_eglGetError,
+                              &thread_data,
+                              EVAS_GL_THREAD_MODE_FINISH);
 
+   return thread_data.return_value;
+}
 
 
-EGLContext current_evgl_thread_context = EGL_NO_CONTEXT;
 
+EGLDisplay current_evgl_thread_dpy  = EGL_NO_DISPLAY;
+EGLSurface current_evgl_thread_draw = EGL_NO_SURFACE;
+EGLSurface current_evgl_thread_read = EGL_NO_SURFACE;
+EGLContext current_evgl_thread_ctx  = EGL_NO_CONTEXT;
 
 typedef struct
 {
@@ -510,11 +593,23 @@ typedef struct
 static void
 _evgl_thread_eglMakeCurrent(void *data)
 {
-   Evas_GL_Thread_Command_eglMakeCurrent *thread_param = data;
-   ERR("THREAD >> EVGL OTHER THREAD MAKECURRENT : (%p, %p, %p, %p)\n", thread_param->dpy, thread_param->draw, thread_param->read, thread_param->ctx);
-   thread_param->return_value = eglMakeCurrent(thread_param->dpy, thread_param->draw, thread_param->read, thread_param->ctx);
-   if (thread_param->return_value == EGL_TRUE)
-          current_evgl_thread_context = thread_param->ctx;
+   Evas_GL_Thread_Command_eglMakeCurrent *thread_data = data;
+
+   DBG("THREAD >> EVGL OTHER THREAD MAKECURRENT : (%p, %p, %p, %p)\n", thread_data->dpy,
+                     thread_data->draw, thread_data->read, thread_data->ctx);
+
+   thread_data->return_value = eglMakeCurrent(thread_data->dpy,
+                                              thread_data->draw,
+                                              thread_data->read,
+                                              thread_data->ctx);
+
+   if (thread_data->return_value == EGL_TRUE)
+     {
+        current_evgl_thread_dpy = thread_data->dpy;
+        current_evgl_thread_draw = thread_data->draw;
+        current_evgl_thread_read = thread_data->read;
+        current_evgl_thread_ctx = thread_data->ctx;
+     }
 }
 
 EAPI EGLBoolean
@@ -523,108 +618,68 @@ eglMakeCurrent_evgl_thread_cmd(EGLDisplay dpy, EGLSurface draw, EGLSurface read,
    if (!evas_evgl_thread_enabled())
      {
         if (eina_thread_self() == evas_gl_thread_get(EVAS_GL_THREAD_TYPE_EVGL))
-           ERR("THREAD >> EVGL OTHER THREAD MAKECURRENT(INNER) : (%p, %p, %p, %p)\n", dpy, draw, read, ctx);
+           DBG("THREAD >> EVGL OTHER THREAD MAKECURRENT(INNER) : (%p, %p, %p, %p)\n",
+                                                               dpy, draw, read, ctx);
         return eglMakeCurrent(dpy, draw, read, ctx);
      }
 
-   Evas_GL_Thread_Command_eglMakeCurrent thread_param;
-   thread_param.dpy = dpy;
-   thread_param.draw = draw;
-   thread_param.read = read;
-   thread_param.ctx = ctx;
-   evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL, _evgl_thread_eglMakeCurrent, &thread_param, EVAS_GL_THREAD_MODE_FINISH);
-   return thread_param.return_value;
-}
-
+   Evas_GL_Thread_Command_eglMakeCurrent thread_data;
 
+   thread_data.dpy = dpy;
+   thread_data.draw = draw;
+   thread_data.read = read;
+   thread_data.ctx = ctx;
 
-typedef struct
-{
-   EGLContext return_value;
-} Evas_GL_Thread_Command_eglGetCurrentContext;
+   evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
+                              _evgl_thread_eglMakeCurrent,
+                              &thread_data,
+                              EVAS_GL_THREAD_MODE_FINISH);
 
-static void
-_evgl_thread_eglGetCurrentContext(void *data)
-{
-   Evas_GL_Thread_Command_eglGetCurrentContext *thread_param = data;
-   thread_param->return_value = eglGetCurrentContext();
+   return thread_data.return_value;
 }
 
+
 EAPI EGLContext
 eglGetCurrentContext_evgl_thread_cmd(void)
 {
    if (!evas_evgl_thread_enabled())
      return eglGetCurrentContext();
 
-   return current_evgl_thread_context;
-
-   Evas_GL_Thread_Command_eglGetCurrentContext thread_param;
-   evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL, _evgl_thread_eglGetCurrentContext, &thread_param, EVAS_GL_THREAD_MODE_FINISH);
-   return thread_param.return_value;
+   return current_evgl_thread_ctx;
 }
 
 
-
-typedef struct
-{
-   EGLDisplay return_value;
-   EGLint     readdraw;
-} Evas_GL_Thread_Command_eglGetCurrentSurface;
-
-static void
-_evgl_thread_eglGetCurrentSurface(void *data)
-{
-   Evas_GL_Thread_Command_eglGetCurrentSurface *thread_param = data;
-   thread_param->return_value = eglGetCurrentSurface(thread_param->readdraw);
-}
-
 EAPI EGLSurface
 eglGetCurrentSurface_evgl_thread_cmd(EGLint readdraw)
 {
    if (!evas_evgl_thread_enabled())
      return eglGetCurrentSurface(readdraw);
 
-   Evas_GL_Thread_Command_eglGetCurrentSurface thread_param;
-   thread_param.readdraw = readdraw;
-   evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL, _evgl_thread_eglGetCurrentSurface, &thread_param, EVAS_GL_THREAD_MODE_FINISH);
-   return thread_param.return_value;
+   if (readdraw == EGL_READ)
+      return current_evgl_thread_read;
+   if (readdraw == EGL_DRAW)
+      return current_evgl_thread_draw;
 }
 
 
-
-typedef struct
-{
-   EGLDisplay return_value;
-} Evas_GL_Thread_Command_eglGetCurrentDisplay;
-
-static void
-_evgl_thread_eglGetCurrentDisplay(void *data)
-{
-   Evas_GL_Thread_Command_eglGetCurrentDisplay *thread_param = data;
-   thread_param->return_value = eglGetCurrentDisplay();
-}
-
 EAPI EGLDisplay
 eglGetCurrentDisplay_evgl_thread_cmd(void)
 {
    if (!evas_evgl_thread_enabled())
      return eglGetCurrentDisplay();
 
-   Evas_GL_Thread_Command_eglGetCurrentDisplay thread_param;
-   evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL, _evgl_thread_eglGetCurrentDisplay, &thread_param, EVAS_GL_THREAD_MODE_FINISH);
-   return thread_param.return_value;
+   return current_evgl_thread_dpy;
 }
 
 
-
-#else /* EVAS_GL_RENDER_THREAD_IS_GENERIC */
+#else /* ! EVAS_GL_RENDER_THREAD_COMPILE_FOR_GL_GENERIC */
 
 
 #include <dlfcn.h>
 
-EGLint (*eglGetError_thread_cmd)();
+EGLint     (*eglGetError_thread_cmd)();
 EGLBoolean (*eglBindAPI_thread_cmd)(EGLenum api);
-EGLenum (*eglQueryAPI_thread_cmd)();
+EGLenum    (*eglQueryAPI_thread_cmd)();
 EGLBoolean (*eglMakeCurrent_thread_cmd)(EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext ctx);
 EGLContext (*eglGetCurrentContext_thread_cmd)(void);
 EGLSurface (*eglGetCurrentSurface_thread_cmd)(EGLint readdraw);
@@ -636,22 +691,22 @@ EGLBoolean (*eglSwapInterval_thread_cmd)(EGLDisplay dpy, EGLint interval);
 EGLBoolean (*eglWaitGL_thread_cmd)(void);
 EGLBoolean (*eglSwapBuffers_thread_cmd)(EGLDisplay dpy, EGLSurface surface);
 
-void (*eglSwapBuffersWithDamage_orig_evas_set)(void *func);
-void *(*eglSwapBuffersWithDamage_orig_evas_get)();
+void       (*eglSwapBuffersWithDamage_orig_evas_set)(void *func);
+void      *(*eglSwapBuffersWithDamage_orig_evas_get)();
 EGLBoolean (*eglSwapBuffersWithDamage_thread_cmd)(EGLDisplay dpy, EGLSurface surface, EGLint *rects, EGLint n_rects);
 
-void (*eglSetDamageRegion_orig_evas_set)(void *func);
-void *(*eglSetDamageRegion_orig_evas_get)();
+void       (*eglSetDamageRegion_orig_evas_set)(void *func);
+void      *(*eglSetDamageRegion_orig_evas_get)();
 EGLBoolean (*eglSetDamageRegion_thread_cmd)(EGLDisplay dpy, EGLSurface surface, EGLint *rects, EGLint n_rects);
 
-void (*eglQueryWaylandBuffer_orig_evas_set)(void *func);
-void *(*eglQueryWaylandBuffer_orig_evas_get)();
+void       (*eglQueryWaylandBuffer_orig_evas_set)(void *func);
+void      *(*eglQueryWaylandBuffer_orig_evas_get)();
 EGLBoolean (*eglQueryWaylandBuffer_thread_cmd)(EGLDisplay dpy, void *buffer, EGLint attribute, EGLint *value);
 
 
 /***** EVAS GL *****/
 
-EGLint (*eglGetError_evgl_thread_cmd)();
+EGLint     (*eglGetError_evgl_thread_cmd)();
 EGLBoolean (*eglMakeCurrent_evgl_thread_cmd)(EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext ctx);
 EGLContext (*eglGetCurrentContext_evgl_thread_cmd)(void);
 EGLSurface (*eglGetCurrentSurface_evgl_thread_cmd)(EGLint readdraw);
@@ -700,6 +755,6 @@ void _egl_thread_link_init()
    LINK2GENERIC(eglGetCurrentDisplay_evgl_thread_cmd);
 }
 
-#endif /* EVAS_GL_RENDER_THREAD_IS_GENERIC */
+#endif /* EVAS_GL_RENDER_THREAD_COMPILE_FOR_GL_GENERIC */
 
 #endif

diff --git a/src/modules/evas/engines/gl_common/evas_gl_thread_egl.h b/src/modules/evas/engines/gl_common/evas_gl_thread_egl.h
index e90ea52..36932dd 100644 (file)
--- a/src/modules/evas/engines/gl_common/evas_gl_thread_egl.h
+++ b/src/modules/evas/engines/gl_common/evas_gl_thread_egl.h
@@ -5,7 +5,7 @@
 
 #include <EGL/egl.h>
 
-#ifdef EVAS_GL_RENDER_THREAD_IS_GENERIC
+#ifdef EVAS_GL_RENDER_THREAD_COMPILE_FOR_GL_GENERIC
 
 
 #ifdef EAPI
@@ -35,9 +35,9 @@
 #endif /* ! _WIN32 */
 
 /* EGL 1.4 Referencing to Thread Local Storage */
-EAPI EGLint eglGetError_thread_cmd();
+EAPI EGLint     eglGetError_thread_cmd();
 EAPI EGLBoolean eglBindAPI_thread_cmd(EGLenum api);
-EAPI EGLenum eglQueryAPI_thread_cmd();
+EAPI EGLenum    eglQueryAPI_thread_cmd();
 EAPI EGLBoolean eglMakeCurrent_thread_cmd(EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext ctx);
 EAPI EGLContext eglGetCurrentContext_thread_cmd(void);
 EAPI EGLSurface eglGetCurrentSurface_thread_cmd(EGLint readdraw);
@@ -51,36 +51,36 @@ EAPI EGLBoolean eglSwapInterval_thread_cmd(EGLDisplay dpy, EGLint interval);
 EAPI EGLBoolean eglWaitGL_thread_cmd(void);
 EAPI EGLBoolean eglSwapBuffers_thread_cmd(EGLDisplay dpy, EGLSurface surface);
 
-EAPI void eglSwapBuffersWithDamage_orig_evas_set(void *func);
-EAPI void *eglSwapBuffersWithDamage_orig_evas_get();
+EAPI void       eglSwapBuffersWithDamage_orig_evas_set(void *func);
+EAPI void      *eglSwapBuffersWithDamage_orig_evas_get();
 EAPI EGLBoolean eglSwapBuffersWithDamage_thread_cmd(EGLDisplay dpy, EGLSurface surface, EGLint *rects, EGLint n_rects);
 
-EAPI void eglSetDamageRegion_orig_evas_set(void *func);
-EAPI void *eglSetDamageRegion_orig_evas_get();
+EAPI void       eglSetDamageRegion_orig_evas_set(void *func);
+EAPI void      *eglSetDamageRegion_orig_evas_get();
 EAPI EGLBoolean eglSetDamageRegion_thread_cmd(EGLDisplay dpy, EGLSurface surface, EGLint *rects, EGLint n_rects);
 
-EAPI void eglQueryWaylandBuffer_orig_evas_set(void *func);
-EAPI void *eglQueryWaylandBuffer_orig_evas_get();
+EAPI void       eglQueryWaylandBuffer_orig_evas_set(void *func);
+EAPI void      *eglQueryWaylandBuffer_orig_evas_get();
 EAPI EGLBoolean eglQueryWaylandBuffer_thread_cmd(EGLDisplay dpy, void *buffer, EGLint attribute, EGLint *value);
 
 
 /***** EVAS GL *****/
 
 /* EGL 1.4 Referencing to Thread Local Storage */
-EAPI EGLint eglGetError_evgl_thread_cmd();
+EAPI EGLint     eglGetError_evgl_thread_cmd();
 EAPI EGLBoolean eglMakeCurrent_evgl_thread_cmd(EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext ctx);
 EAPI EGLContext eglGetCurrentContext_evgl_thread_cmd(void);
 EAPI EGLSurface eglGetCurrentSurface_evgl_thread_cmd(EGLint readdraw);
 EAPI EGLDisplay eglGetCurrentDisplay_evgl_thread_cmd(void);
 
 
-#else /* EVAS_GL_RENDER_THREAD_IS_GENERIC */
+#else /* ! EVAS_GL_RENDER_THREAD_COMPILE_FOR_GL_GENERIC */
 
 
 /* EGL 1.4 Referencing to Thread Local Storage */
-extern EGLint (*eglGetError_thread_cmd)();
+extern EGLint     (*eglGetError_thread_cmd)();
 extern EGLBoolean (*eglBindAPI_thread_cmd)(EGLenum api);
-extern EGLenum (*eglQueryAPI_thread_cmd)();
+extern EGLenum    (*eglQueryAPI_thread_cmd)();
 extern EGLBoolean (*eglMakeCurrent_thread_cmd)(EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext ctx);
 extern EGLContext (*eglGetCurrentContext_thread_cmd)(void);
 extern EGLSurface (*eglGetCurrentSurface_thread_cmd)(EGLint readdraw);
@@ -93,21 +93,21 @@ extern EGLBoolean (*eglQuerySurface_thread_cmd)(EGLDisplay dpy, EGLSurface surfa
 extern EGLBoolean (*eglSwapInterval_thread_cmd)(EGLDisplay dpy, EGLint interval);
 extern EGLBoolean (*eglWaitGL_thread_cmd)(void);
 extern EGLBoolean (*eglSwapBuffers_thread_cmd)(EGLDisplay dpy, EGLSurface surface);
-extern void (*eglSwapBuffersWithDamage_orig_evas_set)(void *func);
-extern void *(*eglSwapBuffersWithDamage_orig_evas_get)();
+extern void       (*eglSwapBuffersWithDamage_orig_evas_set)(void *func);
+extern void      *(*eglSwapBuffersWithDamage_orig_evas_get)();
 extern EGLBoolean (*eglSwapBuffersWithDamage_thread_cmd)(EGLDisplay dpy, EGLSurface surface, EGLint *rects, EGLint n_rects);
-extern void (*eglSetDamageRegion_orig_evas_set)(void *func);
-extern void *(*eglSetDamageRegion_orig_evas_get)();
+extern void       (*eglSetDamageRegion_orig_evas_set)(void *func);
+extern void      *(*eglSetDamageRegion_orig_evas_get)();
 extern EGLBoolean (*eglSetDamageRegion_thread_cmd)(EGLDisplay dpy, EGLSurface surface, EGLint *rects, EGLint n_rects);
-extern void (*eglQueryWaylandBuffer_orig_evas_set)(void *func);
-extern void *(*eglQueryWaylandBuffer_orig_evas_get)();
+extern void       (*eglQueryWaylandBuffer_orig_evas_set)(void *func);
+extern void      *(*eglQueryWaylandBuffer_orig_evas_get)();
 extern EGLBoolean (*eglQueryWaylandBuffer_thread_cmd)(EGLDisplay dpy, void *buffer, EGLint attribute, EGLint *value);
 
 
 /***** EVAS GL *****/
 
 /* EGL 1.4 Referencing to Thread Local Storage */
-extern EGLint (*eglGetError_evgl_thread_cmd)();
+extern EGLint     (*eglGetError_evgl_thread_cmd)();
 extern EGLBoolean (*eglMakeCurrent_evgl_thread_cmd)(EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext ctx);
 extern EGLContext (*eglGetCurrentContext_evgl_thread_cmd)(void);
 extern EGLSurface (*eglGetCurrentSurface_evgl_thread_cmd)(EGLint readdraw);
@@ -118,10 +118,8 @@ extern EGLDisplay (*eglGetCurrentDisplay_evgl_thread_cmd)(void);
 extern void _egl_thread_link_init();
 
 
-#endif /* EVAS_GL_RENDER_THREAD_IS_GENERIC */
+#endif /* EVAS_GL_RENDER_THREAD_COMPILE_FOR_GL_GENERIC */
 
 #endif /* GL_GLES */
 
-#define SCORE_EGL_MOVE_TO_OTHER_THREAD
-
 #endif

diff --git a/src/modules/evas/engines/gl_common/evas_gl_thread_evgl_api_generated.c b/src/modules/evas/engines/gl_common/evas_gl_thread_evgl_api_generated.c
index 6858144..6aa3dba 100644 (file)
--- a/src/modules/evas/engines/gl_common/evas_gl_thread_evgl_api_generated.c
+++ b/src/modules/evas/engines/gl_common/evas_gl_thread_evgl_api_generated.c
@@ -1,9 +1,13 @@
-/* DO NOT MODIFY THIS FILE AS IT IS AUTO-GENERATED */
-
+/*
+ * This is an automatically generated file using a python script.
+ * ($EFL_HOME/src/utils/evas/generate_gl_thread_api.py)
+ * Recommend that you modify data files ($EFL_HOME/src/utils/evas/gl_api_def.txt)
+ * and make use of scripts if you need to fix them.
+ */
 
 /*
-   void
-   glActiveTexture(GLenum texture);
+ * void
+ * glActiveTexture(GLenum texture);
  */
 
 typedef struct
@@ -17,10 +21,10 @@ void (*orig_evgl_api_glActiveTexture)(GLenum texture);
 static void
 _evgl_api_thread_glActiveTexture(void *data)
 {
-   EVGL_API_Thread_Command_glActiveTexture *thread_param =
+   EVGL_API_Thread_Command_glActiveTexture *thread_data =
       (EVGL_API_Thread_Command_glActiveTexture *)data;
 
-   orig_evgl_api_glActiveTexture(thread_param->texture);
+   orig_evgl_api_glActiveTexture(thread_data->texture);
 
 }
 
@@ -35,20 +39,20 @@ glActiveTexture_evgl_api_thread_cmd(GLenum texture)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glActiveTexture thread_param_local;
-   EVGL_API_Thread_Command_glActiveTexture *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glActiveTexture thread_data_local;
+   EVGL_API_Thread_Command_glActiveTexture *thread_data = &thread_data_local;
 
-   thread_param->texture = texture;
+   thread_data->texture = texture;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glActiveTexture,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glAttachShader(GLuint program, GLuint shader);
+ * void
+ * glAttachShader(GLuint program, GLuint shader);
  */
 
 typedef struct
@@ -64,14 +68,14 @@ void (*orig_evgl_api_glAttachShader)(GLuint program, GLuint shader);
 static void
 _evgl_api_thread_glAttachShader(void *data)
 {
-   EVGL_API_Thread_Command_glAttachShader *thread_param =
+   EVGL_API_Thread_Command_glAttachShader *thread_data =
       (EVGL_API_Thread_Command_glAttachShader *)data;
 
-   orig_evgl_api_glAttachShader(thread_param->program,
-                                thread_param->shader);
+   orig_evgl_api_glAttachShader(thread_data->program,
+                                thread_data->shader);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -85,37 +89,37 @@ glAttachShader_evgl_api_thread_cmd(GLuint program, GLuint shader)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glAttachShader thread_param_local;
-   EVGL_API_Thread_Command_glAttachShader *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glAttachShader thread_data_local;
+   EVGL_API_Thread_Command_glAttachShader *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_API_Thread_Command_glAttachShader *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_API_Thread_Command_glAttachShader));
-        if (thread_param_new)
+        EVGL_API_Thread_Command_glAttachShader *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_API_Thread_Command_glAttachShader));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->program = program;
-   thread_param->shader = shader;
+   thread_data->program = program;
+   thread_data->shader = shader;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glAttachShader,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glBindAttribLocation(GLuint program, GLuint index, const char* name);
+ * void
+ * glBindAttribLocation(GLuint program, GLuint index, const char* name);
  */
 
 typedef struct
@@ -131,12 +135,12 @@ void (*orig_evgl_api_glBindAttribLocation)(GLuint program, GLuint index, const c
 static void
 _evgl_api_thread_glBindAttribLocation(void *data)
 {
-   EVGL_API_Thread_Command_glBindAttribLocation *thread_param =
+   EVGL_API_Thread_Command_glBindAttribLocation *thread_data =
       (EVGL_API_Thread_Command_glBindAttribLocation *)data;
 
-   orig_evgl_api_glBindAttribLocation(thread_param->program,
-                                      thread_param->index,
-                                      thread_param->name);
+   orig_evgl_api_glBindAttribLocation(thread_data->program,
+                                      thread_data->index,
+                                      thread_data->name);
 
 }
 
@@ -151,22 +155,22 @@ glBindAttribLocation_evgl_api_thread_cmd(GLuint program, GLuint index, const cha
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glBindAttribLocation thread_param_local;
-   EVGL_API_Thread_Command_glBindAttribLocation *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glBindAttribLocation thread_data_local;
+   EVGL_API_Thread_Command_glBindAttribLocation *thread_data = &thread_data_local;
 
-   thread_param->program = program;
-   thread_param->index = index;
-   thread_param->name = name;
+   thread_data->program = program;
+   thread_data->index = index;
+   thread_data->name = name;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glBindAttribLocation,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glBindBuffer(GLenum target, GLuint buffer);
+ * void
+ * glBindBuffer(GLenum target, GLuint buffer);
  */
 
 typedef struct
@@ -182,14 +186,14 @@ void (*orig_evgl_api_glBindBuffer)(GLenum target, GLuint buffer);
 static void
 _evgl_api_thread_glBindBuffer(void *data)
 {
-   EVGL_API_Thread_Command_glBindBuffer *thread_param =
+   EVGL_API_Thread_Command_glBindBuffer *thread_data =
       (EVGL_API_Thread_Command_glBindBuffer *)data;
 
-   orig_evgl_api_glBindBuffer(thread_param->target,
-                              thread_param->buffer);
+   orig_evgl_api_glBindBuffer(thread_data->target,
+                              thread_data->buffer);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -203,37 +207,37 @@ glBindBuffer_evgl_api_thread_cmd(GLenum target, GLuint buffer)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glBindBuffer thread_param_local;
-   EVGL_API_Thread_Command_glBindBuffer *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glBindBuffer thread_data_local;
+   EVGL_API_Thread_Command_glBindBuffer *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_API_Thread_Command_glBindBuffer *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_API_Thread_Command_glBindBuffer));
-        if (thread_param_new)
+        EVGL_API_Thread_Command_glBindBuffer *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_API_Thread_Command_glBindBuffer));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->target = target;
-   thread_param->buffer = buffer;
+   thread_data->target = target;
+   thread_data->buffer = buffer;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glBindBuffer,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glBindFramebuffer(GLenum target, GLuint framebuffer);
+ * void
+ * glBindFramebuffer(GLenum target, GLuint framebuffer);
  */
 
 typedef struct
@@ -249,14 +253,14 @@ void (*orig_evgl_api_glBindFramebuffer)(GLenum target, GLuint framebuffer);
 static void
 _evgl_api_thread_glBindFramebuffer(void *data)
 {
-   EVGL_API_Thread_Command_glBindFramebuffer *thread_param =
+   EVGL_API_Thread_Command_glBindFramebuffer *thread_data =
       (EVGL_API_Thread_Command_glBindFramebuffer *)data;
 
-   orig_evgl_api_glBindFramebuffer(thread_param->target,
-                                   thread_param->framebuffer);
+   orig_evgl_api_glBindFramebuffer(thread_data->target,
+                                   thread_data->framebuffer);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -270,37 +274,37 @@ glBindFramebuffer_evgl_api_thread_cmd(GLenum target, GLuint framebuffer)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glBindFramebuffer thread_param_local;
-   EVGL_API_Thread_Command_glBindFramebuffer *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glBindFramebuffer thread_data_local;
+   EVGL_API_Thread_Command_glBindFramebuffer *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_API_Thread_Command_glBindFramebuffer *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_API_Thread_Command_glBindFramebuffer));
-        if (thread_param_new)
+        EVGL_API_Thread_Command_glBindFramebuffer *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_API_Thread_Command_glBindFramebuffer));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->target = target;
-   thread_param->framebuffer = framebuffer;
+   thread_data->target = target;
+   thread_data->framebuffer = framebuffer;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glBindFramebuffer,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glBindRenderbuffer(GLenum target, GLuint renderbuffer);
+ * void
+ * glBindRenderbuffer(GLenum target, GLuint renderbuffer);
  */
 
 typedef struct
@@ -316,14 +320,14 @@ void (*orig_evgl_api_glBindRenderbuffer)(GLenum target, GLuint renderbuffer);
 static void
 _evgl_api_thread_glBindRenderbuffer(void *data)
 {
-   EVGL_API_Thread_Command_glBindRenderbuffer *thread_param =
+   EVGL_API_Thread_Command_glBindRenderbuffer *thread_data =
       (EVGL_API_Thread_Command_glBindRenderbuffer *)data;
 
-   orig_evgl_api_glBindRenderbuffer(thread_param->target,
-                                    thread_param->renderbuffer);
+   orig_evgl_api_glBindRenderbuffer(thread_data->target,
+                                    thread_data->renderbuffer);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -337,37 +341,37 @@ glBindRenderbuffer_evgl_api_thread_cmd(GLenum target, GLuint renderbuffer)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glBindRenderbuffer thread_param_local;
-   EVGL_API_Thread_Command_glBindRenderbuffer *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glBindRenderbuffer thread_data_local;
+   EVGL_API_Thread_Command_glBindRenderbuffer *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_API_Thread_Command_glBindRenderbuffer *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_API_Thread_Command_glBindRenderbuffer));
-        if (thread_param_new)
+        EVGL_API_Thread_Command_glBindRenderbuffer *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_API_Thread_Command_glBindRenderbuffer));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->target = target;
-   thread_param->renderbuffer = renderbuffer;
+   thread_data->target = target;
+   thread_data->renderbuffer = renderbuffer;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glBindRenderbuffer,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glBindTexture(GLenum target, GLuint texture);
+ * void
+ * glBindTexture(GLenum target, GLuint texture);
  */
 
 typedef struct
@@ -383,14 +387,14 @@ void (*orig_evgl_api_glBindTexture)(GLenum target, GLuint texture);
 static void
 _evgl_api_thread_glBindTexture(void *data)
 {
-   EVGL_API_Thread_Command_glBindTexture *thread_param =
+   EVGL_API_Thread_Command_glBindTexture *thread_data =
       (EVGL_API_Thread_Command_glBindTexture *)data;
 
-   orig_evgl_api_glBindTexture(thread_param->target,
-                               thread_param->texture);
+   orig_evgl_api_glBindTexture(thread_data->target,
+                               thread_data->texture);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -404,37 +408,37 @@ glBindTexture_evgl_api_thread_cmd(GLenum target, GLuint texture)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glBindTexture thread_param_local;
-   EVGL_API_Thread_Command_glBindTexture *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glBindTexture thread_data_local;
+   EVGL_API_Thread_Command_glBindTexture *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_API_Thread_Command_glBindTexture *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_API_Thread_Command_glBindTexture));
-        if (thread_param_new)
+        EVGL_API_Thread_Command_glBindTexture *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_API_Thread_Command_glBindTexture));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->target = target;
-   thread_param->texture = texture;
+   thread_data->target = target;
+   thread_data->texture = texture;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glBindTexture,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glBlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
+ * void
+ * glBlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
  */
 
 typedef struct
@@ -452,16 +456,16 @@ void (*orig_evgl_api_glBlendColor)(GLclampf red, GLclampf green, GLclampf blue,
 static void
 _evgl_api_thread_glBlendColor(void *data)
 {
-   EVGL_API_Thread_Command_glBlendColor *thread_param =
+   EVGL_API_Thread_Command_glBlendColor *thread_data =
       (EVGL_API_Thread_Command_glBlendColor *)data;
 
-   orig_evgl_api_glBlendColor(thread_param->red,
-                              thread_param->green,
-                              thread_param->blue,
-                              thread_param->alpha);
+   orig_evgl_api_glBlendColor(thread_data->red,
+                              thread_data->green,
+                              thread_data->blue,
+                              thread_data->alpha);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -475,39 +479,39 @@ glBlendColor_evgl_api_thread_cmd(GLclampf red, GLclampf green, GLclampf blue, GL
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glBlendColor thread_param_local;
-   EVGL_API_Thread_Command_glBlendColor *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glBlendColor thread_data_local;
+   EVGL_API_Thread_Command_glBlendColor *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_API_Thread_Command_glBlendColor *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_API_Thread_Command_glBlendColor));
-        if (thread_param_new)
+        EVGL_API_Thread_Command_glBlendColor *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_API_Thread_Command_glBlendColor));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->red = red;
-   thread_param->green = green;
-   thread_param->blue = blue;
-   thread_param->alpha = alpha;
+   thread_data->red = red;
+   thread_data->green = green;
+   thread_data->blue = blue;
+   thread_data->alpha = alpha;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glBlendColor,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glBlendEquation(GLenum mode);
+ * void
+ * glBlendEquation(GLenum mode);
  */
 
 typedef struct
@@ -522,13 +526,13 @@ void (*orig_evgl_api_glBlendEquation)(GLenum mode);
 static void
 _evgl_api_thread_glBlendEquation(void *data)
 {
-   EVGL_API_Thread_Command_glBlendEquation *thread_param =
+   EVGL_API_Thread_Command_glBlendEquation *thread_data =
       (EVGL_API_Thread_Command_glBlendEquation *)data;
 
-   orig_evgl_api_glBlendEquation(thread_param->mode);
+   orig_evgl_api_glBlendEquation(thread_data->mode);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -542,36 +546,36 @@ glBlendEquation_evgl_api_thread_cmd(GLenum mode)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glBlendEquation thread_param_local;
-   EVGL_API_Thread_Command_glBlendEquation *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glBlendEquation thread_data_local;
+   EVGL_API_Thread_Command_glBlendEquation *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_API_Thread_Command_glBlendEquation *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_API_Thread_Command_glBlendEquation));
-        if (thread_param_new)
+        EVGL_API_Thread_Command_glBlendEquation *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_API_Thread_Command_glBlendEquation));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->mode = mode;
+   thread_data->mode = mode;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glBlendEquation,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha);
+ * void
+ * glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha);
  */
 
 typedef struct
@@ -587,14 +591,14 @@ void (*orig_evgl_api_glBlendEquationSeparate)(GLenum modeRGB, GLenum modeAlpha);
 static void
 _evgl_api_thread_glBlendEquationSeparate(void *data)
 {
-   EVGL_API_Thread_Command_glBlendEquationSeparate *thread_param =
+   EVGL_API_Thread_Command_glBlendEquationSeparate *thread_data =
       (EVGL_API_Thread_Command_glBlendEquationSeparate *)data;
 
-   orig_evgl_api_glBlendEquationSeparate(thread_param->modeRGB,
-                                         thread_param->modeAlpha);
+   orig_evgl_api_glBlendEquationSeparate(thread_data->modeRGB,
+                                         thread_data->modeAlpha);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -608,37 +612,37 @@ glBlendEquationSeparate_evgl_api_thread_cmd(GLenum modeRGB, GLenum modeAlpha)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glBlendEquationSeparate thread_param_local;
-   EVGL_API_Thread_Command_glBlendEquationSeparate *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glBlendEquationSeparate thread_data_local;
+   EVGL_API_Thread_Command_glBlendEquationSeparate *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_API_Thread_Command_glBlendEquationSeparate *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_API_Thread_Command_glBlendEquationSeparate));
-        if (thread_param_new)
+        EVGL_API_Thread_Command_glBlendEquationSeparate *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_API_Thread_Command_glBlendEquationSeparate));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->modeRGB = modeRGB;
-   thread_param->modeAlpha = modeAlpha;
+   thread_data->modeRGB = modeRGB;
+   thread_data->modeAlpha = modeAlpha;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glBlendEquationSeparate,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glBlendFunc(GLenum sfactor, GLenum dfactor);
+ * void
+ * glBlendFunc(GLenum sfactor, GLenum dfactor);
  */
 
 typedef struct
@@ -654,14 +658,14 @@ void (*orig_evgl_api_glBlendFunc)(GLenum sfactor, GLenum dfactor);
 static void
 _evgl_api_thread_glBlendFunc(void *data)
 {
-   EVGL_API_Thread_Command_glBlendFunc *thread_param =
+   EVGL_API_Thread_Command_glBlendFunc *thread_data =
       (EVGL_API_Thread_Command_glBlendFunc *)data;
 
-   orig_evgl_api_glBlendFunc(thread_param->sfactor,
-                             thread_param->dfactor);
+   orig_evgl_api_glBlendFunc(thread_data->sfactor,
+                             thread_data->dfactor);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -675,37 +679,37 @@ glBlendFunc_evgl_api_thread_cmd(GLenum sfactor, GLenum dfactor)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glBlendFunc thread_param_local;
-   EVGL_API_Thread_Command_glBlendFunc *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glBlendFunc thread_data_local;
+   EVGL_API_Thread_Command_glBlendFunc *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_API_Thread_Command_glBlendFunc *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_API_Thread_Command_glBlendFunc));
-        if (thread_param_new)
+        EVGL_API_Thread_Command_glBlendFunc *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_API_Thread_Command_glBlendFunc));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->sfactor = sfactor;
-   thread_param->dfactor = dfactor;
+   thread_data->sfactor = sfactor;
+   thread_data->dfactor = dfactor;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glBlendFunc,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glBlendFuncSeparate(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha);
+ * void
+ * glBlendFuncSeparate(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha);
  */
 
 typedef struct
@@ -723,16 +727,16 @@ void (*orig_evgl_api_glBlendFuncSeparate)(GLenum srcRGB, GLenum dstRGB, GLenum s
 static void
 _evgl_api_thread_glBlendFuncSeparate(void *data)
 {
-   EVGL_API_Thread_Command_glBlendFuncSeparate *thread_param =
+   EVGL_API_Thread_Command_glBlendFuncSeparate *thread_data =
       (EVGL_API_Thread_Command_glBlendFuncSeparate *)data;
 
-   orig_evgl_api_glBlendFuncSeparate(thread_param->srcRGB,
-                                     thread_param->dstRGB,
-                                     thread_param->srcAlpha,
-                                     thread_param->dstAlpha);
+   orig_evgl_api_glBlendFuncSeparate(thread_data->srcRGB,
+                                     thread_data->dstRGB,
+                                     thread_data->srcAlpha,
+                                     thread_data->dstAlpha);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -746,39 +750,39 @@ glBlendFuncSeparate_evgl_api_thread_cmd(GLenum srcRGB, GLenum dstRGB, GLenum src
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glBlendFuncSeparate thread_param_local;
-   EVGL_API_Thread_Command_glBlendFuncSeparate *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glBlendFuncSeparate thread_data_local;
+   EVGL_API_Thread_Command_glBlendFuncSeparate *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_API_Thread_Command_glBlendFuncSeparate *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_API_Thread_Command_glBlendFuncSeparate));
-        if (thread_param_new)
+        EVGL_API_Thread_Command_glBlendFuncSeparate *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_API_Thread_Command_glBlendFuncSeparate));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->srcRGB = srcRGB;
-   thread_param->dstRGB = dstRGB;
-   thread_param->srcAlpha = srcAlpha;
-   thread_param->dstAlpha = dstAlpha;
+   thread_data->srcRGB = srcRGB;
+   thread_data->dstRGB = dstRGB;
+   thread_data->srcAlpha = srcAlpha;
+   thread_data->dstAlpha = dstAlpha;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glBlendFuncSeparate,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glBufferData(GLenum target, GLsizeiptr size, const void* data, GLenum usage);
+ * void
+ * glBufferData(GLenum target, GLsizeiptr size, const void* data, GLenum usage);
  */
 
 typedef struct
@@ -795,13 +799,13 @@ void (*orig_evgl_api_glBufferData)(GLenum target, GLsizeiptr size, const void* d
 static void
 _evgl_api_thread_glBufferData(void *data)
 {
-   EVGL_API_Thread_Command_glBufferData *thread_param =
+   EVGL_API_Thread_Command_glBufferData *thread_data =
       (EVGL_API_Thread_Command_glBufferData *)data;
 
-   orig_evgl_api_glBufferData(thread_param->target,
-                              thread_param->size,
-                              thread_param->data,
-                              thread_param->usage);
+   orig_evgl_api_glBufferData(thread_data->target,
+                              thread_data->size,
+                              thread_data->data,
+                              thread_data->usage);
 
 }
 
@@ -816,23 +820,23 @@ glBufferData_evgl_api_thread_cmd(GLenum target, GLsizeiptr size, const void* dat
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glBufferData thread_param_local;
-   EVGL_API_Thread_Command_glBufferData *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glBufferData thread_data_local;
+   EVGL_API_Thread_Command_glBufferData *thread_data = &thread_data_local;
 
-   thread_param->target = target;
-   thread_param->size = size;
-   thread_param->data = data;
-   thread_param->usage = usage;
+   thread_data->target = target;
+   thread_data->size = size;
+   thread_data->data = data;
+   thread_data->usage = usage;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glBufferData,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const void* data);
+ * void
+ * glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const void* data);
  */
 
 typedef struct
@@ -849,13 +853,13 @@ void (*orig_evgl_api_glBufferSubData)(GLenum target, GLintptr offset, GLsizeiptr
 static void
 _evgl_api_thread_glBufferSubData(void *data)
 {
-   EVGL_API_Thread_Command_glBufferSubData *thread_param =
+   EVGL_API_Thread_Command_glBufferSubData *thread_data =
       (EVGL_API_Thread_Command_glBufferSubData *)data;
 
-   orig_evgl_api_glBufferSubData(thread_param->target,
-                                 thread_param->offset,
-                                 thread_param->size,
-                                 thread_param->data);
+   orig_evgl_api_glBufferSubData(thread_data->target,
+                                 thread_data->offset,
+                                 thread_data->size,
+                                 thread_data->data);
 
 }
 
@@ -870,23 +874,23 @@ glBufferSubData_evgl_api_thread_cmd(GLenum target, GLintptr offset, GLsizeiptr s
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glBufferSubData thread_param_local;
-   EVGL_API_Thread_Command_glBufferSubData *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glBufferSubData thread_data_local;
+   EVGL_API_Thread_Command_glBufferSubData *thread_data = &thread_data_local;
 
-   thread_param->target = target;
-   thread_param->offset = offset;
-   thread_param->size = size;
-   thread_param->data = data;
+   thread_data->target = target;
+   thread_data->offset = offset;
+   thread_data->size = size;
+   thread_data->data = data;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glBufferSubData,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   GLenum
-   glCheckFramebufferStatus(GLenum target);
+ * GLenum
+ * glCheckFramebufferStatus(GLenum target);
  */
 
 typedef struct
@@ -901,10 +905,10 @@ GLenum (*orig_evgl_api_glCheckFramebufferStatus)(GLenum target);
 static void
 _evgl_api_thread_glCheckFramebufferStatus(void *data)
 {
-   EVGL_API_Thread_Command_glCheckFramebufferStatus *thread_param =
+   EVGL_API_Thread_Command_glCheckFramebufferStatus *thread_data =
       (EVGL_API_Thread_Command_glCheckFramebufferStatus *)data;
 
-   thread_param->return_value = orig_evgl_api_glCheckFramebufferStatus(thread_param->target);
+   thread_data->return_value = orig_evgl_api_glCheckFramebufferStatus(thread_data->target);
 
 }
 
@@ -918,22 +922,22 @@ glCheckFramebufferStatus_evgl_api_thread_cmd(GLenum target)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glCheckFramebufferStatus thread_param_local;
-   EVGL_API_Thread_Command_glCheckFramebufferStatus *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glCheckFramebufferStatus thread_data_local;
+   EVGL_API_Thread_Command_glCheckFramebufferStatus *thread_data = &thread_data_local;
 
-   thread_param->target = target;
+   thread_data->target = target;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glCheckFramebufferStatus,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
-   void
-   glClear(GLbitfield mask);
+ * void
+ * glClear(GLbitfield mask);
  */
 
 typedef struct
@@ -947,10 +951,10 @@ void (*orig_evgl_api_glClear)(GLbitfield mask);
 static void
 _evgl_api_thread_glClear(void *data)
 {
-   EVGL_API_Thread_Command_glClear *thread_param =
+   EVGL_API_Thread_Command_glClear *thread_data =
       (EVGL_API_Thread_Command_glClear *)data;
 
-   orig_evgl_api_glClear(thread_param->mask);
+   orig_evgl_api_glClear(thread_data->mask);
 
 }
 
@@ -965,20 +969,20 @@ glClear_evgl_api_thread_cmd(GLbitfield mask)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glClear thread_param_local;
-   EVGL_API_Thread_Command_glClear *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glClear thread_data_local;
+   EVGL_API_Thread_Command_glClear *thread_data = &thread_data_local;
 
-   thread_param->mask = mask;
+   thread_data->mask = mask;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glClear,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
+ * void
+ * glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
  */
 
 typedef struct
@@ -995,13 +999,13 @@ void (*orig_evgl_api_glClearColor)(GLclampf red, GLclampf green, GLclampf blue,
 static void
 _evgl_api_thread_glClearColor(void *data)
 {
-   EVGL_API_Thread_Command_glClearColor *thread_param =
+   EVGL_API_Thread_Command_glClearColor *thread_data =
       (EVGL_API_Thread_Command_glClearColor *)data;
 
-   orig_evgl_api_glClearColor(thread_param->red,
-                              thread_param->green,
-                              thread_param->blue,
-                              thread_param->alpha);
+   orig_evgl_api_glClearColor(thread_data->red,
+                              thread_data->green,
+                              thread_data->blue,
+                              thread_data->alpha);
 
 }
 
@@ -1016,23 +1020,23 @@ glClearColor_evgl_api_thread_cmd(GLclampf red, GLclampf green, GLclampf blue, GL
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glClearColor thread_param_local;
-   EVGL_API_Thread_Command_glClearColor *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glClearColor thread_data_local;
+   EVGL_API_Thread_Command_glClearColor *thread_data = &thread_data_local;
 
-   thread_param->red = red;
-   thread_param->green = green;
-   thread_param->blue = blue;
-   thread_param->alpha = alpha;
+   thread_data->red = red;
+   thread_data->green = green;
+   thread_data->blue = blue;
+   thread_data->alpha = alpha;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glClearColor,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glClearDepthf(GLclampf depth);
+ * void
+ * glClearDepthf(GLclampf depth);
  */
 
 typedef struct
@@ -1046,10 +1050,10 @@ void (*orig_evgl_api_glClearDepthf)(GLclampf depth);
 static void
 _evgl_api_thread_glClearDepthf(void *data)
 {
-   EVGL_API_Thread_Command_glClearDepthf *thread_param =
+   EVGL_API_Thread_Command_glClearDepthf *thread_data =
       (EVGL_API_Thread_Command_glClearDepthf *)data;
 
-   orig_evgl_api_glClearDepthf(thread_param->depth);
+   orig_evgl_api_glClearDepthf(thread_data->depth);
 
 }
 
@@ -1064,20 +1068,20 @@ glClearDepthf_evgl_api_thread_cmd(GLclampf depth)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glClearDepthf thread_param_local;
-   EVGL_API_Thread_Command_glClearDepthf *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glClearDepthf thread_data_local;
+   EVGL_API_Thread_Command_glClearDepthf *thread_data = &thread_data_local;
 
-   thread_param->depth = depth;
+   thread_data->depth = depth;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glClearDepthf,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glClearStencil(GLint s);
+ * void
+ * glClearStencil(GLint s);
  */
 
 typedef struct
@@ -1091,10 +1095,10 @@ void (*orig_evgl_api_glClearStencil)(GLint s);
 static void
 _evgl_api_thread_glClearStencil(void *data)
 {
-   EVGL_API_Thread_Command_glClearStencil *thread_param =
+   EVGL_API_Thread_Command_glClearStencil *thread_data =
       (EVGL_API_Thread_Command_glClearStencil *)data;
 
-   orig_evgl_api_glClearStencil(thread_param->s);
+   orig_evgl_api_glClearStencil(thread_data->s);
 
 }
 
@@ -1109,20 +1113,20 @@ glClearStencil_evgl_api_thread_cmd(GLint s)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glClearStencil thread_param_local;
-   EVGL_API_Thread_Command_glClearStencil *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glClearStencil thread_data_local;
+   EVGL_API_Thread_Command_glClearStencil *thread_data = &thread_data_local;
 
-   thread_param->s = s;
+   thread_data->s = s;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glClearStencil,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
+ * void
+ * glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
  */
 
 typedef struct
@@ -1139,13 +1143,13 @@ void (*orig_evgl_api_glColorMask)(GLboolean red, GLboolean green, GLboolean blue
 static void
 _evgl_api_thread_glColorMask(void *data)
 {
-   EVGL_API_Thread_Command_glColorMask *thread_param =
+   EVGL_API_Thread_Command_glColorMask *thread_data =
       (EVGL_API_Thread_Command_glColorMask *)data;
 
-   orig_evgl_api_glColorMask(thread_param->red,
-                             thread_param->green,
-                             thread_param->blue,
-                             thread_param->alpha);
+   orig_evgl_api_glColorMask(thread_data->red,
+                             thread_data->green,
+                             thread_data->blue,
+                             thread_data->alpha);
 
 }
 
@@ -1160,23 +1164,23 @@ glColorMask_evgl_api_thread_cmd(GLboolean red, GLboolean green, GLboolean blue,
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glColorMask thread_param_local;
-   EVGL_API_Thread_Command_glColorMask *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glColorMask thread_data_local;
+   EVGL_API_Thread_Command_glColorMask *thread_data = &thread_data_local;
 
-   thread_param->red = red;
-   thread_param->green = green;
-   thread_param->blue = blue;
-   thread_param->alpha = alpha;
+   thread_data->red = red;
+   thread_data->green = green;
+   thread_data->blue = blue;
+   thread_data->alpha = alpha;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glColorMask,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glCompileShader(GLuint shader);
+ * void
+ * glCompileShader(GLuint shader);
  */
 
 typedef struct
@@ -1191,13 +1195,13 @@ void (*orig_evgl_api_glCompileShader)(GLuint shader);
 static void
 _evgl_api_thread_glCompileShader(void *data)
 {
-   EVGL_API_Thread_Command_glCompileShader *thread_param =
+   EVGL_API_Thread_Command_glCompileShader *thread_data =
       (EVGL_API_Thread_Command_glCompileShader *)data;
 
-   orig_evgl_api_glCompileShader(thread_param->shader);
+   orig_evgl_api_glCompileShader(thread_data->shader);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -1211,36 +1215,36 @@ glCompileShader_evgl_api_thread_cmd(GLuint shader)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glCompileShader thread_param_local;
-   EVGL_API_Thread_Command_glCompileShader *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glCompileShader thread_data_local;
+   EVGL_API_Thread_Command_glCompileShader *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_API_Thread_Command_glCompileShader *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_API_Thread_Command_glCompileShader));
-        if (thread_param_new)
+        EVGL_API_Thread_Command_glCompileShader *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_API_Thread_Command_glCompileShader));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->shader = shader;
+   thread_data->shader = shader;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glCompileShader,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void* data);
+ * void
+ * glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void* data);
  */
 
 typedef struct
@@ -1263,22 +1267,22 @@ void (*orig_evgl_api_glCompressedTexImage2D)(GLenum target, GLint level, GLenum
 static void
 _evgl_api_thread_glCompressedTexImage2D(void *data)
 {
-   EVGL_API_Thread_Command_glCompressedTexImage2D *thread_param =
+   EVGL_API_Thread_Command_glCompressedTexImage2D *thread_data =
       (EVGL_API_Thread_Command_glCompressedTexImage2D *)data;
 
-   orig_evgl_api_glCompressedTexImage2D(thread_param->target,
-                                        thread_param->level,
-                                        thread_param->internalformat,
-                                        thread_param->width,
-                                        thread_param->height,
-                                        thread_param->border,
-                                        thread_param->imageSize,
-                                        thread_param->data);
+   orig_evgl_api_glCompressedTexImage2D(thread_data->target,
+                                        thread_data->level,
+                                        thread_data->internalformat,
+                                        thread_data->width,
+                                        thread_data->height,
+                                        thread_data->border,
+                                        thread_data->imageSize,
+                                        thread_data->data);
 
    GLCOMPRESSEDTEXIMAGE2D_COPY_VARIABLE_FREE; /* TODO */
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -1292,33 +1296,33 @@ glCompressedTexImage2D_evgl_api_thread_cmd(GLenum target, GLint level, GLenum in
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glCompressedTexImage2D thread_param_local;
-   EVGL_API_Thread_Command_glCompressedTexImage2D *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glCompressedTexImage2D thread_data_local;
+   EVGL_API_Thread_Command_glCompressedTexImage2D *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_API_Thread_Command_glCompressedTexImage2D *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_API_Thread_Command_glCompressedTexImage2D));
-        if (thread_param_new)
+        EVGL_API_Thread_Command_glCompressedTexImage2D *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_API_Thread_Command_glCompressedTexImage2D));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->target = target;
-   thread_param->level = level;
-   thread_param->internalformat = internalformat;
-   thread_param->width = width;
-   thread_param->height = height;
-   thread_param->border = border;
-   thread_param->imageSize = imageSize;
-   thread_param->data = data;
+   thread_data->target = target;
+   thread_data->level = level;
+   thread_data->internalformat = internalformat;
+   thread_data->width = width;
+   thread_data->height = height;
+   thread_data->border = border;
+   thread_data->imageSize = imageSize;
+   thread_data->data = data;
 
    GLCOMPRESSEDTEXIMAGE2D_COPY_VARIABLE_INIT; /* TODO */
 
@@ -1330,13 +1334,13 @@ glCompressedTexImage2D_evgl_api_thread_cmd(GLenum target, GLint level, GLenum in
 finish:
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glCompressedTexImage2D,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void* data);
+ * void
+ * glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void* data);
  */
 
 typedef struct
@@ -1360,23 +1364,23 @@ void (*orig_evgl_api_glCompressedTexSubImage2D)(GLenum target, GLint level, GLin
 static void
 _evgl_api_thread_glCompressedTexSubImage2D(void *data)
 {
-   EVGL_API_Thread_Command_glCompressedTexSubImage2D *thread_param =
+   EVGL_API_Thread_Command_glCompressedTexSubImage2D *thread_data =
       (EVGL_API_Thread_Command_glCompressedTexSubImage2D *)data;
 
-   orig_evgl_api_glCompressedTexSubImage2D(thread_param->target,
-                                           thread_param->level,
-                                           thread_param->xoffset,
-                                           thread_param->yoffset,
-                                           thread_param->width,
-                                           thread_param->height,
-                                           thread_param->format,
-                                           thread_param->imageSize,
-                                           thread_param->data);
+   orig_evgl_api_glCompressedTexSubImage2D(thread_data->target,
+                                           thread_data->level,
+                                           thread_data->xoffset,
+                                           thread_data->yoffset,
+                                           thread_data->width,
+                                           thread_data->height,
+                                           thread_data->format,
+                                           thread_data->imageSize,
+                                           thread_data->data);
 
    GLCOMPRESSEDTEXSUBIMAGE2D_COPY_VARIABLE_FREE; /* TODO */
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -1390,34 +1394,34 @@ glCompressedTexSubImage2D_evgl_api_thread_cmd(GLenum target, GLint level, GLint
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glCompressedTexSubImage2D thread_param_local;
-   EVGL_API_Thread_Command_glCompressedTexSubImage2D *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glCompressedTexSubImage2D thread_data_local;
+   EVGL_API_Thread_Command_glCompressedTexSubImage2D *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_API_Thread_Command_glCompressedTexSubImage2D *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_API_Thread_Command_glCompressedTexSubImage2D));
-        if (thread_param_new)
+        EVGL_API_Thread_Command_glCompressedTexSubImage2D *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_API_Thread_Command_glCompressedTexSubImage2D));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->target = target;
-   thread_param->level = level;
-   thread_param->xoffset = xoffset;
-   thread_param->yoffset = yoffset;
-   thread_param->width = width;
-   thread_param->height = height;
-   thread_param->format = format;
-   thread_param->imageSize = imageSize;
-   thread_param->data = data;
+   thread_data->target = target;
+   thread_data->level = level;
+   thread_data->xoffset = xoffset;
+   thread_data->yoffset = yoffset;
+   thread_data->width = width;
+   thread_data->height = height;
+   thread_data->format = format;
+   thread_data->imageSize = imageSize;
+   thread_data->data = data;
 
    GLCOMPRESSEDTEXSUBIMAGE2D_COPY_VARIABLE_INIT; /* TODO */
 
@@ -1429,13 +1433,13 @@ glCompressedTexSubImage2D_evgl_api_thread_cmd(GLenum target, GLint level, GLint
 finish:
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glCompressedTexSubImage2D,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
+ * void
+ * glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
  */
 
 typedef struct
@@ -1456,17 +1460,17 @@ void (*orig_evgl_api_glCopyTexImage2D)(GLenum target, GLint level, GLenum intern
 static void
 _evgl_api_thread_glCopyTexImage2D(void *data)
 {
-   EVGL_API_Thread_Command_glCopyTexImage2D *thread_param =
+   EVGL_API_Thread_Command_glCopyTexImage2D *thread_data =
       (EVGL_API_Thread_Command_glCopyTexImage2D *)data;
 
-   orig_evgl_api_glCopyTexImage2D(thread_param->target,
-                                  thread_param->level,
-                                  thread_param->internalformat,
-                                  thread_param->x,
-                                  thread_param->y,
-                                  thread_param->width,
-                                  thread_param->height,
-                                  thread_param->border);
+   orig_evgl_api_glCopyTexImage2D(thread_data->target,
+                                  thread_data->level,
+                                  thread_data->internalformat,
+                                  thread_data->x,
+                                  thread_data->y,
+                                  thread_data->width,
+                                  thread_data->height,
+                                  thread_data->border);
 
 }
 
@@ -1481,27 +1485,27 @@ glCopyTexImage2D_evgl_api_thread_cmd(GLenum target, GLint level, GLenum internal
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glCopyTexImage2D thread_param_local;
-   EVGL_API_Thread_Command_glCopyTexImage2D *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glCopyTexImage2D thread_data_local;
+   EVGL_API_Thread_Command_glCopyTexImage2D *thread_data = &thread_data_local;
 
-   thread_param->target = target;
-   thread_param->level = level;
-   thread_param->internalformat = internalformat;
-   thread_param->x = x;
-   thread_param->y = y;
-   thread_param->width = width;
-   thread_param->height = height;
-   thread_param->border = border;
+   thread_data->target = target;
+   thread_data->level = level;
+   thread_data->internalformat = internalformat;
+   thread_data->x = x;
+   thread_data->y = y;
+   thread_data->width = width;
+   thread_data->height = height;
+   thread_data->border = border;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glCopyTexImage2D,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
+ * void
+ * glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
  */
 
 typedef struct
@@ -1522,17 +1526,17 @@ void (*orig_evgl_api_glCopyTexSubImage2D)(GLenum target, GLint level, GLint xoff
 static void
 _evgl_api_thread_glCopyTexSubImage2D(void *data)
 {
-   EVGL_API_Thread_Command_glCopyTexSubImage2D *thread_param =
+   EVGL_API_Thread_Command_glCopyTexSubImage2D *thread_data =
       (EVGL_API_Thread_Command_glCopyTexSubImage2D *)data;
 
-   orig_evgl_api_glCopyTexSubImage2D(thread_param->target,
-                                     thread_param->level,
-                                     thread_param->xoffset,
-                                     thread_param->yoffset,
-                                     thread_param->x,
-                                     thread_param->y,
-                                     thread_param->width,
-                                     thread_param->height);
+   orig_evgl_api_glCopyTexSubImage2D(thread_data->target,
+                                     thread_data->level,
+                                     thread_data->xoffset,
+                                     thread_data->yoffset,
+                                     thread_data->x,
+                                     thread_data->y,
+                                     thread_data->width,
+                                     thread_data->height);
 
 }
 
@@ -1547,27 +1551,27 @@ glCopyTexSubImage2D_evgl_api_thread_cmd(GLenum target, GLint level, GLint xoffse
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glCopyTexSubImage2D thread_param_local;
-   EVGL_API_Thread_Command_glCopyTexSubImage2D *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glCopyTexSubImage2D thread_data_local;
+   EVGL_API_Thread_Command_glCopyTexSubImage2D *thread_data = &thread_data_local;
 
-   thread_param->target = target;
-   thread_param->level = level;
-   thread_param->xoffset = xoffset;
-   thread_param->yoffset = yoffset;
-   thread_param->x = x;
-   thread_param->y = y;
-   thread_param->width = width;
-   thread_param->height = height;
+   thread_data->target = target;
+   thread_data->level = level;
+   thread_data->xoffset = xoffset;
+   thread_data->yoffset = yoffset;
+   thread_data->x = x;
+   thread_data->y = y;
+   thread_data->width = width;
+   thread_data->height = height;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glCopyTexSubImage2D,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   GLuint
-   glCreateProgram(void);
+ * GLuint
+ * glCreateProgram(void);
  */
 
 typedef struct
@@ -1581,10 +1585,10 @@ GLuint (*orig_evgl_api_glCreateProgram)(void);
 static void
 _evgl_api_thread_glCreateProgram(void *data)
 {
-   EVGL_API_Thread_Command_glCreateProgram *thread_param =
+   EVGL_API_Thread_Command_glCreateProgram *thread_data =
       (EVGL_API_Thread_Command_glCreateProgram *)data;
 
-   thread_param->return_value = orig_evgl_api_glCreateProgram();
+   thread_data->return_value = orig_evgl_api_glCreateProgram();
 
 }
 
@@ -1598,21 +1602,21 @@ glCreateProgram_evgl_api_thread_cmd(void)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glCreateProgram thread_param_local;
-   EVGL_API_Thread_Command_glCreateProgram *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glCreateProgram thread_data_local;
+   EVGL_API_Thread_Command_glCreateProgram *thread_data = &thread_data_local;
 
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glCreateProgram,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
-   GLuint
-   glCreateShader(GLenum type);
+ * GLuint
+ * glCreateShader(GLenum type);
  */
 
 typedef struct
@@ -1627,10 +1631,10 @@ GLuint (*orig_evgl_api_glCreateShader)(GLenum type);
 static void
 _evgl_api_thread_glCreateShader(void *data)
 {
-   EVGL_API_Thread_Command_glCreateShader *thread_param =
+   EVGL_API_Thread_Command_glCreateShader *thread_data =
       (EVGL_API_Thread_Command_glCreateShader *)data;
 
-   thread_param->return_value = orig_evgl_api_glCreateShader(thread_param->type);
+   thread_data->return_value = orig_evgl_api_glCreateShader(thread_data->type);
 
 }
 
@@ -1644,22 +1648,22 @@ glCreateShader_evgl_api_thread_cmd(GLenum type)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glCreateShader thread_param_local;
-   EVGL_API_Thread_Command_glCreateShader *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glCreateShader thread_data_local;
+   EVGL_API_Thread_Command_glCreateShader *thread_data = &thread_data_local;
 
-   thread_param->type = type;
+   thread_data->type = type;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glCreateShader,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
-   void
-   glCullFace(GLenum mode);
+ * void
+ * glCullFace(GLenum mode);
  */
 
 typedef struct
@@ -1673,10 +1677,10 @@ void (*orig_evgl_api_glCullFace)(GLenum mode);
 static void
 _evgl_api_thread_glCullFace(void *data)
 {
-   EVGL_API_Thread_Command_glCullFace *thread_param =
+   EVGL_API_Thread_Command_glCullFace *thread_data =
       (EVGL_API_Thread_Command_glCullFace *)data;
 
-   orig_evgl_api_glCullFace(thread_param->mode);
+   orig_evgl_api_glCullFace(thread_data->mode);
 
 }
 
@@ -1691,20 +1695,20 @@ glCullFace_evgl_api_thread_cmd(GLenum mode)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glCullFace thread_param_local;
-   EVGL_API_Thread_Command_glCullFace *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glCullFace thread_data_local;
+   EVGL_API_Thread_Command_glCullFace *thread_data = &thread_data_local;
 
-   thread_param->mode = mode;
+   thread_data->mode = mode;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glCullFace,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glDeleteBuffers(GLsizei n, const GLuint* buffers);
+ * void
+ * glDeleteBuffers(GLsizei n, const GLuint* buffers);
  */
 
 typedef struct
@@ -1721,18 +1725,18 @@ void (*orig_evgl_api_glDeleteBuffers)(GLsizei n, const GLuint* buffers);
 static void
 _evgl_api_thread_glDeleteBuffers(void *data)
 {
-   EVGL_API_Thread_Command_glDeleteBuffers *thread_param =
+   EVGL_API_Thread_Command_glDeleteBuffers *thread_data =
       (EVGL_API_Thread_Command_glDeleteBuffers *)data;
 
-   orig_evgl_api_glDeleteBuffers(thread_param->n,
-                                 thread_param->buffers);
+   orig_evgl_api_glDeleteBuffers(thread_data->n,
+                                 thread_data->buffers);
 
 
-   if (thread_param->buffers_copied)
-     eina_mempool_free(_mp_delete_object, thread_param->buffers_copied);
+   if (thread_data->buffers_copied)
+     eina_mempool_free(_mp_delete_object, thread_data->buffers_copied);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -1746,29 +1750,29 @@ glDeleteBuffers_evgl_api_thread_cmd(GLsizei n, const GLuint* buffers)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glDeleteBuffers thread_param_local;
-   EVGL_API_Thread_Command_glDeleteBuffers *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glDeleteBuffers thread_data_local;
+   EVGL_API_Thread_Command_glDeleteBuffers *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_API_Thread_Command_glDeleteBuffers *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_API_Thread_Command_glDeleteBuffers));
-        if (thread_param_new)
+        EVGL_API_Thread_Command_glDeleteBuffers *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_API_Thread_Command_glDeleteBuffers));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->n = n;
-   thread_param->buffers = buffers;
+   thread_data->n = n;
+   thread_data->buffers = buffers;
 
-   thread_param->buffers_copied = NULL;
+   thread_data->buffers_copied = NULL;
    if (thread_mode == EVAS_GL_THREAD_MODE_FINISH)
      goto finish;
 
@@ -1783,10 +1787,10 @@ glDeleteBuffers_evgl_api_thread_cmd(GLsizei n, const GLuint* buffers)
              goto finish;
           }
         /* 2. malloc & copy */
-        thread_param->buffers_copied = eina_mempool_malloc(_mp_delete_object, copy_size);
-        if (thread_param->buffers_copied)
+        thread_data->buffers_copied = eina_mempool_malloc(_mp_delete_object, copy_size);
+        if (thread_data->buffers_copied)
           {
-             memcpy(thread_param->buffers_copied, buffers, copy_size);
+             memcpy(thread_data->buffers_copied, buffers, copy_size);
           }
         else
           {
@@ -1794,20 +1798,20 @@ glDeleteBuffers_evgl_api_thread_cmd(GLsizei n, const GLuint* buffers)
              goto finish;
           }
         /* 3. replace */
-        thread_param->buffers = (const GLuint *)thread_param->buffers_copied;
+        thread_data->buffers = (const GLuint *)thread_data->buffers_copied;
      }
    /* end of copy variable */
 
 finish:
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glDeleteBuffers,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glDeleteFramebuffers(GLsizei n, const GLuint* framebuffers);
+ * void
+ * glDeleteFramebuffers(GLsizei n, const GLuint* framebuffers);
  */
 
 typedef struct
@@ -1824,18 +1828,18 @@ void (*orig_evgl_api_glDeleteFramebuffers)(GLsizei n, const GLuint* framebuffers
 static void
 _evgl_api_thread_glDeleteFramebuffers(void *data)
 {
-   EVGL_API_Thread_Command_glDeleteFramebuffers *thread_param =
+   EVGL_API_Thread_Command_glDeleteFramebuffers *thread_data =
       (EVGL_API_Thread_Command_glDeleteFramebuffers *)data;
 
-   orig_evgl_api_glDeleteFramebuffers(thread_param->n,
-                                      thread_param->framebuffers);
+   orig_evgl_api_glDeleteFramebuffers(thread_data->n,
+                                      thread_data->framebuffers);
 
 
-   if (thread_param->framebuffers_copied)
-     eina_mempool_free(_mp_delete_object, thread_param->framebuffers_copied);
+   if (thread_data->framebuffers_copied)
+     eina_mempool_free(_mp_delete_object, thread_data->framebuffers_copied);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -1849,29 +1853,29 @@ glDeleteFramebuffers_evgl_api_thread_cmd(GLsizei n, const GLuint* framebuffers)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glDeleteFramebuffers thread_param_local;
-   EVGL_API_Thread_Command_glDeleteFramebuffers *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glDeleteFramebuffers thread_data_local;
+   EVGL_API_Thread_Command_glDeleteFramebuffers *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_API_Thread_Command_glDeleteFramebuffers *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_API_Thread_Command_glDeleteFramebuffers));
-        if (thread_param_new)
+        EVGL_API_Thread_Command_glDeleteFramebuffers *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_API_Thread_Command_glDeleteFramebuffers));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->n = n;
-   thread_param->framebuffers = framebuffers;
+   thread_data->n = n;
+   thread_data->framebuffers = framebuffers;
 
-   thread_param->framebuffers_copied = NULL;
+   thread_data->framebuffers_copied = NULL;
    if (thread_mode == EVAS_GL_THREAD_MODE_FINISH)
      goto finish;
 
@@ -1886,10 +1890,10 @@ glDeleteFramebuffers_evgl_api_thread_cmd(GLsizei n, const GLuint* framebuffers)
              goto finish;
           }
         /* 2. malloc & copy */
-        thread_param->framebuffers_copied = eina_mempool_malloc(_mp_delete_object, copy_size);
-        if (thread_param->framebuffers_copied)
+        thread_data->framebuffers_copied = eina_mempool_malloc(_mp_delete_object, copy_size);
+        if (thread_data->framebuffers_copied)
           {
-             memcpy(thread_param->framebuffers_copied, framebuffers, copy_size);
+             memcpy(thread_data->framebuffers_copied, framebuffers, copy_size);
           }
         else
           {
@@ -1897,20 +1901,20 @@ glDeleteFramebuffers_evgl_api_thread_cmd(GLsizei n, const GLuint* framebuffers)
              goto finish;
           }
         /* 3. replace */
-        thread_param->framebuffers = (const GLuint *)thread_param->framebuffers_copied;
+        thread_data->framebuffers = (const GLuint *)thread_data->framebuffers_copied;
      }
    /* end of copy variable */
 
 finish:
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glDeleteFramebuffers,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glDeleteProgram(GLuint program);
+ * void
+ * glDeleteProgram(GLuint program);
  */
 
 typedef struct
@@ -1924,10 +1928,10 @@ void (*orig_evgl_api_glDeleteProgram)(GLuint program);
 static void
 _evgl_api_thread_glDeleteProgram(void *data)
 {
-   EVGL_API_Thread_Command_glDeleteProgram *thread_param =
+   EVGL_API_Thread_Command_glDeleteProgram *thread_data =
       (EVGL_API_Thread_Command_glDeleteProgram *)data;
 
-   orig_evgl_api_glDeleteProgram(thread_param->program);
+   orig_evgl_api_glDeleteProgram(thread_data->program);
 
 }
 
@@ -1942,20 +1946,20 @@ glDeleteProgram_evgl_api_thread_cmd(GLuint program)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glDeleteProgram thread_param_local;
-   EVGL_API_Thread_Command_glDeleteProgram *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glDeleteProgram thread_data_local;
+   EVGL_API_Thread_Command_glDeleteProgram *thread_data = &thread_data_local;
 
-   thread_param->program = program;
+   thread_data->program = program;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glDeleteProgram,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glDeleteRenderbuffers(GLsizei n, const GLuint* renderbuffers);
+ * void
+ * glDeleteRenderbuffers(GLsizei n, const GLuint* renderbuffers);
  */
 
 typedef struct
@@ -1972,18 +1976,18 @@ void (*orig_evgl_api_glDeleteRenderbuffers)(GLsizei n, const GLuint* renderbuffe
 static void
 _evgl_api_thread_glDeleteRenderbuffers(void *data)
 {
-   EVGL_API_Thread_Command_glDeleteRenderbuffers *thread_param =
+   EVGL_API_Thread_Command_glDeleteRenderbuffers *thread_data =
       (EVGL_API_Thread_Command_glDeleteRenderbuffers *)data;
 
-   orig_evgl_api_glDeleteRenderbuffers(thread_param->n,
-                                       thread_param->renderbuffers);
+   orig_evgl_api_glDeleteRenderbuffers(thread_data->n,
+                                       thread_data->renderbuffers);
 
 
-   if (thread_param->renderbuffers_copied)
-     eina_mempool_free(_mp_delete_object, thread_param->renderbuffers_copied);
+   if (thread_data->renderbuffers_copied)
+     eina_mempool_free(_mp_delete_object, thread_data->renderbuffers_copied);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -1997,29 +2001,29 @@ glDeleteRenderbuffers_evgl_api_thread_cmd(GLsizei n, const GLuint* renderbuffers
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glDeleteRenderbuffers thread_param_local;
-   EVGL_API_Thread_Command_glDeleteRenderbuffers *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glDeleteRenderbuffers thread_data_local;
+   EVGL_API_Thread_Command_glDeleteRenderbuffers *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_API_Thread_Command_glDeleteRenderbuffers *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_API_Thread_Command_glDeleteRenderbuffers));
-        if (thread_param_new)
+        EVGL_API_Thread_Command_glDeleteRenderbuffers *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_API_Thread_Command_glDeleteRenderbuffers));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->n = n;
-   thread_param->renderbuffers = renderbuffers;
+   thread_data->n = n;
+   thread_data->renderbuffers = renderbuffers;
 
-   thread_param->renderbuffers_copied = NULL;
+   thread_data->renderbuffers_copied = NULL;
    if (thread_mode == EVAS_GL_THREAD_MODE_FINISH)
      goto finish;
 
@@ -2034,10 +2038,10 @@ glDeleteRenderbuffers_evgl_api_thread_cmd(GLsizei n, const GLuint* renderbuffers
              goto finish;
           }
         /* 2. malloc & copy */
-        thread_param->renderbuffers_copied = eina_mempool_malloc(_mp_delete_object, copy_size);
-        if (thread_param->renderbuffers_copied)
+        thread_data->renderbuffers_copied = eina_mempool_malloc(_mp_delete_object, copy_size);
+        if (thread_data->renderbuffers_copied)
           {
-             memcpy(thread_param->renderbuffers_copied, renderbuffers, copy_size);
+             memcpy(thread_data->renderbuffers_copied, renderbuffers, copy_size);
           }
         else
           {
@@ -2045,20 +2049,20 @@ glDeleteRenderbuffers_evgl_api_thread_cmd(GLsizei n, const GLuint* renderbuffers
              goto finish;
           }
         /* 3. replace */
-        thread_param->renderbuffers = (const GLuint *)thread_param->renderbuffers_copied;
+        thread_data->renderbuffers = (const GLuint *)thread_data->renderbuffers_copied;
      }
    /* end of copy variable */
 
 finish:
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glDeleteRenderbuffers,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glDeleteShader(GLuint shader);
+ * void
+ * glDeleteShader(GLuint shader);
  */
 
 typedef struct
@@ -2073,13 +2077,13 @@ void (*orig_evgl_api_glDeleteShader)(GLuint shader);
 static void
 _evgl_api_thread_glDeleteShader(void *data)
 {
-   EVGL_API_Thread_Command_glDeleteShader *thread_param =
+   EVGL_API_Thread_Command_glDeleteShader *thread_data =
       (EVGL_API_Thread_Command_glDeleteShader *)data;
 
-   orig_evgl_api_glDeleteShader(thread_param->shader);
+   orig_evgl_api_glDeleteShader(thread_data->shader);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -2093,36 +2097,36 @@ glDeleteShader_evgl_api_thread_cmd(GLuint shader)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glDeleteShader thread_param_local;
-   EVGL_API_Thread_Command_glDeleteShader *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glDeleteShader thread_data_local;
+   EVGL_API_Thread_Command_glDeleteShader *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_API_Thread_Command_glDeleteShader *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_API_Thread_Command_glDeleteShader));
-        if (thread_param_new)
+        EVGL_API_Thread_Command_glDeleteShader *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_API_Thread_Command_glDeleteShader));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->shader = shader;
+   thread_data->shader = shader;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glDeleteShader,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glDeleteTextures(GLsizei n, const GLuint* textures);
+ * void
+ * glDeleteTextures(GLsizei n, const GLuint* textures);
  */
 
 typedef struct
@@ -2139,18 +2143,18 @@ void (*orig_evgl_api_glDeleteTextures)(GLsizei n, const GLuint* textures);
 static void
 _evgl_api_thread_glDeleteTextures(void *data)
 {
-   EVGL_API_Thread_Command_glDeleteTextures *thread_param =
+   EVGL_API_Thread_Command_glDeleteTextures *thread_data =
       (EVGL_API_Thread_Command_glDeleteTextures *)data;
 
-   orig_evgl_api_glDeleteTextures(thread_param->n,
-                                  thread_param->textures);
+   orig_evgl_api_glDeleteTextures(thread_data->n,
+                                  thread_data->textures);
 
 
-   if (thread_param->textures_copied)
-     eina_mempool_free(_mp_delete_object, thread_param->textures_copied);
+   if (thread_data->textures_copied)
+     eina_mempool_free(_mp_delete_object, thread_data->textures_copied);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -2164,29 +2168,29 @@ glDeleteTextures_evgl_api_thread_cmd(GLsizei n, const GLuint* textures)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glDeleteTextures thread_param_local;
-   EVGL_API_Thread_Command_glDeleteTextures *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glDeleteTextures thread_data_local;
+   EVGL_API_Thread_Command_glDeleteTextures *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_API_Thread_Command_glDeleteTextures *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_API_Thread_Command_glDeleteTextures));
-        if (thread_param_new)
+        EVGL_API_Thread_Command_glDeleteTextures *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_API_Thread_Command_glDeleteTextures));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->n = n;
-   thread_param->textures = textures;
+   thread_data->n = n;
+   thread_data->textures = textures;
 
-   thread_param->textures_copied = NULL;
+   thread_data->textures_copied = NULL;
    if (thread_mode == EVAS_GL_THREAD_MODE_FINISH)
      goto finish;
 
@@ -2201,10 +2205,10 @@ glDeleteTextures_evgl_api_thread_cmd(GLsizei n, const GLuint* textures)
              goto finish;
           }
         /* 2. malloc & copy */
-        thread_param->textures_copied = eina_mempool_malloc(_mp_delete_object, copy_size);
-        if (thread_param->textures_copied)
+        thread_data->textures_copied = eina_mempool_malloc(_mp_delete_object, copy_size);
+        if (thread_data->textures_copied)
           {
-             memcpy(thread_param->textures_copied, textures, copy_size);
+             memcpy(thread_data->textures_copied, textures, copy_size);
           }
         else
           {
@@ -2212,20 +2216,20 @@ glDeleteTextures_evgl_api_thread_cmd(GLsizei n, const GLuint* textures)
              goto finish;
           }
         /* 3. replace */
-        thread_param->textures = (const GLuint *)thread_param->textures_copied;
+        thread_data->textures = (const GLuint *)thread_data->textures_copied;
      }
    /* end of copy variable */
 
 finish:
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glDeleteTextures,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glDepthFunc(GLenum func);
+ * void
+ * glDepthFunc(GLenum func);
  */
 
 typedef struct
@@ -2239,10 +2243,10 @@ void (*orig_evgl_api_glDepthFunc)(GLenum func);
 static void
 _evgl_api_thread_glDepthFunc(void *data)
 {
-   EVGL_API_Thread_Command_glDepthFunc *thread_param =
+   EVGL_API_Thread_Command_glDepthFunc *thread_data =
       (EVGL_API_Thread_Command_glDepthFunc *)data;
 
-   orig_evgl_api_glDepthFunc(thread_param->func);
+   orig_evgl_api_glDepthFunc(thread_data->func);
 
 }
 
@@ -2257,20 +2261,20 @@ glDepthFunc_evgl_api_thread_cmd(GLenum func)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glDepthFunc thread_param_local;
-   EVGL_API_Thread_Command_glDepthFunc *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glDepthFunc thread_data_local;
+   EVGL_API_Thread_Command_glDepthFunc *thread_data = &thread_data_local;
 
-   thread_param->func = func;
+   thread_data->func = func;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glDepthFunc,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glDepthMask(GLboolean flag);
+ * void
+ * glDepthMask(GLboolean flag);
  */
 
 typedef struct
@@ -2285,13 +2289,13 @@ void (*orig_evgl_api_glDepthMask)(GLboolean flag);
 static void
 _evgl_api_thread_glDepthMask(void *data)
 {
-   EVGL_API_Thread_Command_glDepthMask *thread_param =
+   EVGL_API_Thread_Command_glDepthMask *thread_data =
       (EVGL_API_Thread_Command_glDepthMask *)data;
 
-   orig_evgl_api_glDepthMask(thread_param->flag);
+   orig_evgl_api_glDepthMask(thread_data->flag);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -2305,36 +2309,36 @@ glDepthMask_evgl_api_thread_cmd(GLboolean flag)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glDepthMask thread_param_local;
-   EVGL_API_Thread_Command_glDepthMask *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glDepthMask thread_data_local;
+   EVGL_API_Thread_Command_glDepthMask *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_API_Thread_Command_glDepthMask *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_API_Thread_Command_glDepthMask));
-        if (thread_param_new)
+        EVGL_API_Thread_Command_glDepthMask *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_API_Thread_Command_glDepthMask));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->flag = flag;
+   thread_data->flag = flag;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glDepthMask,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glDepthRangef(GLclampf zNear, GLclampf zFar);
+ * void
+ * glDepthRangef(GLclampf zNear, GLclampf zFar);
  */
 
 typedef struct
@@ -2349,11 +2353,11 @@ void (*orig_evgl_api_glDepthRangef)(GLclampf zNear, GLclampf zFar);
 static void
 _evgl_api_thread_glDepthRangef(void *data)
 {
-   EVGL_API_Thread_Command_glDepthRangef *thread_param =
+   EVGL_API_Thread_Command_glDepthRangef *thread_data =
       (EVGL_API_Thread_Command_glDepthRangef *)data;
 
-   orig_evgl_api_glDepthRangef(thread_param->zNear,
-                               thread_param->zFar);
+   orig_evgl_api_glDepthRangef(thread_data->zNear,
+                               thread_data->zFar);
 
 }
 
@@ -2368,21 +2372,21 @@ glDepthRangef_evgl_api_thread_cmd(GLclampf zNear, GLclampf zFar)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glDepthRangef thread_param_local;
-   EVGL_API_Thread_Command_glDepthRangef *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glDepthRangef thread_data_local;
+   EVGL_API_Thread_Command_glDepthRangef *thread_data = &thread_data_local;
 
-   thread_param->zNear = zNear;
-   thread_param->zFar = zFar;
+   thread_data->zNear = zNear;
+   thread_data->zFar = zFar;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glDepthRangef,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glDetachShader(GLuint program, GLuint shader);
+ * void
+ * glDetachShader(GLuint program, GLuint shader);
  */
 
 typedef struct
@@ -2398,14 +2402,14 @@ void (*orig_evgl_api_glDetachShader)(GLuint program, GLuint shader);
 static void
 _evgl_api_thread_glDetachShader(void *data)
 {
-   EVGL_API_Thread_Command_glDetachShader *thread_param =
+   EVGL_API_Thread_Command_glDetachShader *thread_data =
       (EVGL_API_Thread_Command_glDetachShader *)data;
 
-   orig_evgl_api_glDetachShader(thread_param->program,
-                                thread_param->shader);
+   orig_evgl_api_glDetachShader(thread_data->program,
+                                thread_data->shader);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -2419,37 +2423,37 @@ glDetachShader_evgl_api_thread_cmd(GLuint program, GLuint shader)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glDetachShader thread_param_local;
-   EVGL_API_Thread_Command_glDetachShader *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glDetachShader thread_data_local;
+   EVGL_API_Thread_Command_glDetachShader *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_API_Thread_Command_glDetachShader *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_API_Thread_Command_glDetachShader));
-        if (thread_param_new)
+        EVGL_API_Thread_Command_glDetachShader *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_API_Thread_Command_glDetachShader));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->program = program;
-   thread_param->shader = shader;
+   thread_data->program = program;
+   thread_data->shader = shader;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glDetachShader,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glDisable(GLenum cap);
+ * void
+ * glDisable(GLenum cap);
  */
 
 typedef struct
@@ -2464,13 +2468,13 @@ void (*orig_evgl_api_glDisable)(GLenum cap);
 static void
 _evgl_api_thread_glDisable(void *data)
 {
-   EVGL_API_Thread_Command_glDisable *thread_param =
+   EVGL_API_Thread_Command_glDisable *thread_data =
       (EVGL_API_Thread_Command_glDisable *)data;
 
-   orig_evgl_api_glDisable(thread_param->cap);
+   orig_evgl_api_glDisable(thread_data->cap);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -2484,36 +2488,36 @@ glDisable_evgl_api_thread_cmd(GLenum cap)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glDisable thread_param_local;
-   EVGL_API_Thread_Command_glDisable *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glDisable thread_data_local;
+   EVGL_API_Thread_Command_glDisable *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_API_Thread_Command_glDisable *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_API_Thread_Command_glDisable));
-        if (thread_param_new)
+        EVGL_API_Thread_Command_glDisable *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_API_Thread_Command_glDisable));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->cap = cap;
+   thread_data->cap = cap;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glDisable,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glDisableVertexAttribArray(GLuint index);
+ * void
+ * glDisableVertexAttribArray(GLuint index);
  */
 
 typedef struct
@@ -2528,13 +2532,13 @@ void (*orig_evgl_api_glDisableVertexAttribArray)(GLuint index);
 static void
 _evgl_api_thread_glDisableVertexAttribArray(void *data)
 {
-   EVGL_API_Thread_Command_glDisableVertexAttribArray *thread_param =
+   EVGL_API_Thread_Command_glDisableVertexAttribArray *thread_data =
       (EVGL_API_Thread_Command_glDisableVertexAttribArray *)data;
 
-   orig_evgl_api_glDisableVertexAttribArray(thread_param->index);
+   orig_evgl_api_glDisableVertexAttribArray(thread_data->index);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -2548,36 +2552,36 @@ glDisableVertexAttribArray_evgl_api_thread_cmd(GLuint index)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glDisableVertexAttribArray thread_param_local;
-   EVGL_API_Thread_Command_glDisableVertexAttribArray *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glDisableVertexAttribArray thread_data_local;
+   EVGL_API_Thread_Command_glDisableVertexAttribArray *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_API_Thread_Command_glDisableVertexAttribArray *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_API_Thread_Command_glDisableVertexAttribArray));
-        if (thread_param_new)
+        EVGL_API_Thread_Command_glDisableVertexAttribArray *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_API_Thread_Command_glDisableVertexAttribArray));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->index = index;
+   thread_data->index = index;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glDisableVertexAttribArray,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glDrawArrays(GLenum mode, GLint first, GLsizei count);
+ * void
+ * glDrawArrays(GLenum mode, GLint first, GLsizei count);
  */
 
 typedef struct
@@ -2593,12 +2597,12 @@ void (*orig_evgl_api_glDrawArrays)(GLenum mode, GLint first, GLsizei count);
 static void
 _evgl_api_thread_glDrawArrays(void *data)
 {
-   EVGL_API_Thread_Command_glDrawArrays *thread_param =
+   EVGL_API_Thread_Command_glDrawArrays *thread_data =
       (EVGL_API_Thread_Command_glDrawArrays *)data;
 
-   orig_evgl_api_glDrawArrays(thread_param->mode,
-                              thread_param->first,
-                              thread_param->count);
+   orig_evgl_api_glDrawArrays(thread_data->mode,
+                              thread_data->first,
+                              thread_data->count);
 
 }
 
@@ -2613,22 +2617,22 @@ glDrawArrays_evgl_api_thread_cmd(GLenum mode, GLint first, GLsizei count)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glDrawArrays thread_param_local;
-   EVGL_API_Thread_Command_glDrawArrays *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glDrawArrays thread_data_local;
+   EVGL_API_Thread_Command_glDrawArrays *thread_data = &thread_data_local;
 
-   thread_param->mode = mode;
-   thread_param->first = first;
-   thread_param->count = count;
+   thread_data->mode = mode;
+   thread_data->first = first;
+   thread_data->count = count;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glDrawArrays,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glDrawElements(GLenum mode, GLsizei count, GLenum type, const void* indices);
+ * void
+ * glDrawElements(GLenum mode, GLsizei count, GLenum type, const void* indices);
  */
 
 typedef struct
@@ -2645,13 +2649,13 @@ void (*orig_evgl_api_glDrawElements)(GLenum mode, GLsizei count, GLenum type, co
 static void
 _evgl_api_thread_glDrawElements(void *data)
 {
-   EVGL_API_Thread_Command_glDrawElements *thread_param =
+   EVGL_API_Thread_Command_glDrawElements *thread_data =
       (EVGL_API_Thread_Command_glDrawElements *)data;
 
-   orig_evgl_api_glDrawElements(thread_param->mode,
-                                thread_param->count,
-                                thread_param->type,
-                                thread_param->indices);
+   orig_evgl_api_glDrawElements(thread_data->mode,
+                                thread_data->count,
+                                thread_data->type,
+                                thread_data->indices);
 
 }
 
@@ -2666,23 +2670,23 @@ glDrawElements_evgl_api_thread_cmd(GLenum mode, GLsizei count, GLenum type, cons
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glDrawElements thread_param_local;
-   EVGL_API_Thread_Command_glDrawElements *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glDrawElements thread_data_local;
+   EVGL_API_Thread_Command_glDrawElements *thread_data = &thread_data_local;
 
-   thread_param->mode = mode;
-   thread_param->count = count;
-   thread_param->type = type;
-   thread_param->indices = indices;
+   thread_data->mode = mode;
+   thread_data->count = count;
+   thread_data->type = type;
+   thread_data->indices = indices;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glDrawElements,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glEnable(GLenum cap);
+ * void
+ * glEnable(GLenum cap);
  */
 
 typedef struct
@@ -2697,13 +2701,13 @@ void (*orig_evgl_api_glEnable)(GLenum cap);
 static void
 _evgl_api_thread_glEnable(void *data)
 {
-   EVGL_API_Thread_Command_glEnable *thread_param =
+   EVGL_API_Thread_Command_glEnable *thread_data =
       (EVGL_API_Thread_Command_glEnable *)data;
 
-   orig_evgl_api_glEnable(thread_param->cap);
+   orig_evgl_api_glEnable(thread_data->cap);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -2717,36 +2721,36 @@ glEnable_evgl_api_thread_cmd(GLenum cap)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glEnable thread_param_local;
-   EVGL_API_Thread_Command_glEnable *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glEnable thread_data_local;
+   EVGL_API_Thread_Command_glEnable *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_API_Thread_Command_glEnable *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_API_Thread_Command_glEnable));
-        if (thread_param_new)
+        EVGL_API_Thread_Command_glEnable *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_API_Thread_Command_glEnable));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->cap = cap;
+   thread_data->cap = cap;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glEnable,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glEnableVertexAttribArray(GLuint index);
+ * void
+ * glEnableVertexAttribArray(GLuint index);
  */
 
 typedef struct
@@ -2761,13 +2765,13 @@ void (*orig_evgl_api_glEnableVertexAttribArray)(GLuint index);
 static void
 _evgl_api_thread_glEnableVertexAttribArray(void *data)
 {
-   EVGL_API_Thread_Command_glEnableVertexAttribArray *thread_param =
+   EVGL_API_Thread_Command_glEnableVertexAttribArray *thread_data =
       (EVGL_API_Thread_Command_glEnableVertexAttribArray *)data;
 
-   orig_evgl_api_glEnableVertexAttribArray(thread_param->index);
+   orig_evgl_api_glEnableVertexAttribArray(thread_data->index);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -2781,36 +2785,36 @@ glEnableVertexAttribArray_evgl_api_thread_cmd(GLuint index)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glEnableVertexAttribArray thread_param_local;
-   EVGL_API_Thread_Command_glEnableVertexAttribArray *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glEnableVertexAttribArray thread_data_local;
+   EVGL_API_Thread_Command_glEnableVertexAttribArray *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_API_Thread_Command_glEnableVertexAttribArray *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_API_Thread_Command_glEnableVertexAttribArray));
-        if (thread_param_new)
+        EVGL_API_Thread_Command_glEnableVertexAttribArray *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_API_Thread_Command_glEnableVertexAttribArray));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->index = index;
+   thread_data->index = index;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glEnableVertexAttribArray,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glFinish(void);
+ * void
+ * glFinish(void);
  */
 
 void (*orig_evgl_api_glFinish)(void);
@@ -2840,8 +2844,8 @@ glFinish_evgl_api_thread_cmd(void)
 }
 
 /*
-   void
-   glFlush(void);
+ * void
+ * glFlush(void);
  */
 
 void (*orig_evgl_api_glFlush)(void);
@@ -2871,8 +2875,8 @@ glFlush_evgl_api_thread_cmd(void)
 }
 
 /*
-   void
-   glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer);
+ * void
+ * glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer);
  */
 
 typedef struct
@@ -2890,16 +2894,16 @@ void (*orig_evgl_api_glFramebufferRenderbuffer)(GLenum target, GLenum attachment
 static void
 _evgl_api_thread_glFramebufferRenderbuffer(void *data)
 {
-   EVGL_API_Thread_Command_glFramebufferRenderbuffer *thread_param =
+   EVGL_API_Thread_Command_glFramebufferRenderbuffer *thread_data =
       (EVGL_API_Thread_Command_glFramebufferRenderbuffer *)data;
 
-   orig_evgl_api_glFramebufferRenderbuffer(thread_param->target,
-                                           thread_param->attachment,
-                                           thread_param->renderbuffertarget,
-                                           thread_param->renderbuffer);
+   orig_evgl_api_glFramebufferRenderbuffer(thread_data->target,
+                                           thread_data->attachment,
+                                           thread_data->renderbuffertarget,
+                                           thread_data->renderbuffer);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -2913,39 +2917,39 @@ glFramebufferRenderbuffer_evgl_api_thread_cmd(GLenum target, GLenum attachment,
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glFramebufferRenderbuffer thread_param_local;
-   EVGL_API_Thread_Command_glFramebufferRenderbuffer *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glFramebufferRenderbuffer thread_data_local;
+   EVGL_API_Thread_Command_glFramebufferRenderbuffer *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_API_Thread_Command_glFramebufferRenderbuffer *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_API_Thread_Command_glFramebufferRenderbuffer));
-        if (thread_param_new)
+        EVGL_API_Thread_Command_glFramebufferRenderbuffer *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_API_Thread_Command_glFramebufferRenderbuffer));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->target = target;
-   thread_param->attachment = attachment;
-   thread_param->renderbuffertarget = renderbuffertarget;
-   thread_param->renderbuffer = renderbuffer;
+   thread_data->target = target;
+   thread_data->attachment = attachment;
+   thread_data->renderbuffertarget = renderbuffertarget;
+   thread_data->renderbuffer = renderbuffer;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glFramebufferRenderbuffer,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
+ * void
+ * glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
  */
 
 typedef struct
@@ -2964,17 +2968,17 @@ void (*orig_evgl_api_glFramebufferTexture2D)(GLenum target, GLenum attachment, G
 static void
 _evgl_api_thread_glFramebufferTexture2D(void *data)
 {
-   EVGL_API_Thread_Command_glFramebufferTexture2D *thread_param =
+   EVGL_API_Thread_Command_glFramebufferTexture2D *thread_data =
       (EVGL_API_Thread_Command_glFramebufferTexture2D *)data;
 
-   orig_evgl_api_glFramebufferTexture2D(thread_param->target,
-                                        thread_param->attachment,
-                                        thread_param->textarget,
-                                        thread_param->texture,
-                                        thread_param->level);
+   orig_evgl_api_glFramebufferTexture2D(thread_data->target,
+                                        thread_data->attachment,
+                                        thread_data->textarget,
+                                        thread_data->texture,
+                                        thread_data->level);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -2988,40 +2992,40 @@ glFramebufferTexture2D_evgl_api_thread_cmd(GLenum target, GLenum attachment, GLe
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glFramebufferTexture2D thread_param_local;
-   EVGL_API_Thread_Command_glFramebufferTexture2D *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glFramebufferTexture2D thread_data_local;
+   EVGL_API_Thread_Command_glFramebufferTexture2D *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_API_Thread_Command_glFramebufferTexture2D *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_API_Thread_Command_glFramebufferTexture2D));
-        if (thread_param_new)
+        EVGL_API_Thread_Command_glFramebufferTexture2D *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_API_Thread_Command_glFramebufferTexture2D));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->target = target;
-   thread_param->attachment = attachment;
-   thread_param->textarget = textarget;
-   thread_param->texture = texture;
-   thread_param->level = level;
+   thread_data->target = target;
+   thread_data->attachment = attachment;
+   thread_data->textarget = textarget;
+   thread_data->texture = texture;
+   thread_data->level = level;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glFramebufferTexture2D,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glFrontFace(GLenum mode);
+ * void
+ * glFrontFace(GLenum mode);
  */
 
 typedef struct
@@ -3035,10 +3039,10 @@ void (*orig_evgl_api_glFrontFace)(GLenum mode);
 static void
 _evgl_api_thread_glFrontFace(void *data)
 {
-   EVGL_API_Thread_Command_glFrontFace *thread_param =
+   EVGL_API_Thread_Command_glFrontFace *thread_data =
       (EVGL_API_Thread_Command_glFrontFace *)data;
 
-   orig_evgl_api_glFrontFace(thread_param->mode);
+   orig_evgl_api_glFrontFace(thread_data->mode);
 
 }
 
@@ -3053,20 +3057,20 @@ glFrontFace_evgl_api_thread_cmd(GLenum mode)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glFrontFace thread_param_local;
-   EVGL_API_Thread_Command_glFrontFace *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glFrontFace thread_data_local;
+   EVGL_API_Thread_Command_glFrontFace *thread_data = &thread_data_local;
 
-   thread_param->mode = mode;
+   thread_data->mode = mode;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glFrontFace,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGenBuffers(GLsizei n, GLuint* buffers);
+ * void
+ * glGenBuffers(GLsizei n, GLuint* buffers);
  */
 
 typedef struct
@@ -3081,11 +3085,11 @@ void (*orig_evgl_api_glGenBuffers)(GLsizei n, GLuint* buffers);
 static void
 _evgl_api_thread_glGenBuffers(void *data)
 {
-   EVGL_API_Thread_Command_glGenBuffers *thread_param =
+   EVGL_API_Thread_Command_glGenBuffers *thread_data =
       (EVGL_API_Thread_Command_glGenBuffers *)data;
 
-   orig_evgl_api_glGenBuffers(thread_param->n,
-                              thread_param->buffers);
+   orig_evgl_api_glGenBuffers(thread_data->n,
+                              thread_data->buffers);
 
 }
 
@@ -3100,21 +3104,21 @@ glGenBuffers_evgl_api_thread_cmd(GLsizei n, GLuint* buffers)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGenBuffers thread_param_local;
-   EVGL_API_Thread_Command_glGenBuffers *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGenBuffers thread_data_local;
+   EVGL_API_Thread_Command_glGenBuffers *thread_data = &thread_data_local;
 
-   thread_param->n = n;
-   thread_param->buffers = buffers;
+   thread_data->n = n;
+   thread_data->buffers = buffers;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGenBuffers,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGenerateMipmap(GLenum target);
+ * void
+ * glGenerateMipmap(GLenum target);
  */
 
 typedef struct
@@ -3128,10 +3132,10 @@ void (*orig_evgl_api_glGenerateMipmap)(GLenum target);
 static void
 _evgl_api_thread_glGenerateMipmap(void *data)
 {
-   EVGL_API_Thread_Command_glGenerateMipmap *thread_param =
+   EVGL_API_Thread_Command_glGenerateMipmap *thread_data =
       (EVGL_API_Thread_Command_glGenerateMipmap *)data;
 
-   orig_evgl_api_glGenerateMipmap(thread_param->target);
+   orig_evgl_api_glGenerateMipmap(thread_data->target);
 
 }
 
@@ -3146,20 +3150,20 @@ glGenerateMipmap_evgl_api_thread_cmd(GLenum target)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGenerateMipmap thread_param_local;
-   EVGL_API_Thread_Command_glGenerateMipmap *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGenerateMipmap thread_data_local;
+   EVGL_API_Thread_Command_glGenerateMipmap *thread_data = &thread_data_local;
 
-   thread_param->target = target;
+   thread_data->target = target;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGenerateMipmap,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGenFramebuffers(GLsizei n, GLuint* framebuffers);
+ * void
+ * glGenFramebuffers(GLsizei n, GLuint* framebuffers);
  */
 
 typedef struct
@@ -3174,11 +3178,11 @@ void (*orig_evgl_api_glGenFramebuffers)(GLsizei n, GLuint* framebuffers);
 static void
 _evgl_api_thread_glGenFramebuffers(void *data)
 {
-   EVGL_API_Thread_Command_glGenFramebuffers *thread_param =
+   EVGL_API_Thread_Command_glGenFramebuffers *thread_data =
       (EVGL_API_Thread_Command_glGenFramebuffers *)data;
 
-   orig_evgl_api_glGenFramebuffers(thread_param->n,
-                                   thread_param->framebuffers);
+   orig_evgl_api_glGenFramebuffers(thread_data->n,
+                                   thread_data->framebuffers);
 
 }
 
@@ -3193,21 +3197,21 @@ glGenFramebuffers_evgl_api_thread_cmd(GLsizei n, GLuint* framebuffers)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGenFramebuffers thread_param_local;
-   EVGL_API_Thread_Command_glGenFramebuffers *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGenFramebuffers thread_data_local;
+   EVGL_API_Thread_Command_glGenFramebuffers *thread_data = &thread_data_local;
 
-   thread_param->n = n;
-   thread_param->framebuffers = framebuffers;
+   thread_data->n = n;
+   thread_data->framebuffers = framebuffers;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGenFramebuffers,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGenRenderbuffers(GLsizei n, GLuint* renderbuffers);
+ * void
+ * glGenRenderbuffers(GLsizei n, GLuint* renderbuffers);
  */
 
 typedef struct
@@ -3222,11 +3226,11 @@ void (*orig_evgl_api_glGenRenderbuffers)(GLsizei n, GLuint* renderbuffers);
 static void
 _evgl_api_thread_glGenRenderbuffers(void *data)
 {
-   EVGL_API_Thread_Command_glGenRenderbuffers *thread_param =
+   EVGL_API_Thread_Command_glGenRenderbuffers *thread_data =
       (EVGL_API_Thread_Command_glGenRenderbuffers *)data;
 
-   orig_evgl_api_glGenRenderbuffers(thread_param->n,
-                                    thread_param->renderbuffers);
+   orig_evgl_api_glGenRenderbuffers(thread_data->n,
+                                    thread_data->renderbuffers);
 
 }
 
@@ -3241,21 +3245,21 @@ glGenRenderbuffers_evgl_api_thread_cmd(GLsizei n, GLuint* renderbuffers)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGenRenderbuffers thread_param_local;
-   EVGL_API_Thread_Command_glGenRenderbuffers *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGenRenderbuffers thread_data_local;
+   EVGL_API_Thread_Command_glGenRenderbuffers *thread_data = &thread_data_local;
 
-   thread_param->n = n;
-   thread_param->renderbuffers = renderbuffers;
+   thread_data->n = n;
+   thread_data->renderbuffers = renderbuffers;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGenRenderbuffers,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGenTextures(GLsizei n, GLuint* textures);
+ * void
+ * glGenTextures(GLsizei n, GLuint* textures);
  */
 
 typedef struct
@@ -3270,11 +3274,11 @@ void (*orig_evgl_api_glGenTextures)(GLsizei n, GLuint* textures);
 static void
 _evgl_api_thread_glGenTextures(void *data)
 {
-   EVGL_API_Thread_Command_glGenTextures *thread_param =
+   EVGL_API_Thread_Command_glGenTextures *thread_data =
       (EVGL_API_Thread_Command_glGenTextures *)data;
 
-   orig_evgl_api_glGenTextures(thread_param->n,
-                               thread_param->textures);
+   orig_evgl_api_glGenTextures(thread_data->n,
+                               thread_data->textures);
 
 }
 
@@ -3289,21 +3293,21 @@ glGenTextures_evgl_api_thread_cmd(GLsizei n, GLuint* textures)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGenTextures thread_param_local;
-   EVGL_API_Thread_Command_glGenTextures *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGenTextures thread_data_local;
+   EVGL_API_Thread_Command_glGenTextures *thread_data = &thread_data_local;
 
-   thread_param->n = n;
-   thread_param->textures = textures;
+   thread_data->n = n;
+   thread_data->textures = textures;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGenTextures,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name);
+ * void
+ * glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name);
  */
 
 typedef struct
@@ -3323,16 +3327,16 @@ void (*orig_evgl_api_glGetActiveAttrib)(GLuint program, GLuint index, GLsizei bu
 static void
 _evgl_api_thread_glGetActiveAttrib(void *data)
 {
-   EVGL_API_Thread_Command_glGetActiveAttrib *thread_param =
+   EVGL_API_Thread_Command_glGetActiveAttrib *thread_data =
       (EVGL_API_Thread_Command_glGetActiveAttrib *)data;
 
-   orig_evgl_api_glGetActiveAttrib(thread_param->program,
-                                   thread_param->index,
-                                   thread_param->bufsize,
-                                   thread_param->length,
-                                   thread_param->size,
-                                   thread_param->type,
-                                   thread_param->name);
+   orig_evgl_api_glGetActiveAttrib(thread_data->program,
+                                   thread_data->index,
+                                   thread_data->bufsize,
+                                   thread_data->length,
+                                   thread_data->size,
+                                   thread_data->type,
+                                   thread_data->name);
 
 }
 
@@ -3347,26 +3351,26 @@ glGetActiveAttrib_evgl_api_thread_cmd(GLuint program, GLuint index, GLsizei bufs
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGetActiveAttrib thread_param_local;
-   EVGL_API_Thread_Command_glGetActiveAttrib *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGetActiveAttrib thread_data_local;
+   EVGL_API_Thread_Command_glGetActiveAttrib *thread_data = &thread_data_local;
 
-   thread_param->program = program;
-   thread_param->index = index;
-   thread_param->bufsize = bufsize;
-   thread_param->length = length;
-   thread_param->size = size;
-   thread_param->type = type;
-   thread_param->name = name;
+   thread_data->program = program;
+   thread_data->index = index;
+   thread_data->bufsize = bufsize;
+   thread_data->length = length;
+   thread_data->size = size;
+   thread_data->type = type;
+   thread_data->name = name;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGetActiveAttrib,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGetActiveUniform(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name);
+ * void
+ * glGetActiveUniform(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name);
  */
 
 typedef struct
@@ -3386,16 +3390,16 @@ void (*orig_evgl_api_glGetActiveUniform)(GLuint program, GLuint index, GLsizei b
 static void
 _evgl_api_thread_glGetActiveUniform(void *data)
 {
-   EVGL_API_Thread_Command_glGetActiveUniform *thread_param =
+   EVGL_API_Thread_Command_glGetActiveUniform *thread_data =
       (EVGL_API_Thread_Command_glGetActiveUniform *)data;
 
-   orig_evgl_api_glGetActiveUniform(thread_param->program,
-                                    thread_param->index,
-                                    thread_param->bufsize,
-                                    thread_param->length,
-                                    thread_param->size,
-                                    thread_param->type,
-                                    thread_param->name);
+   orig_evgl_api_glGetActiveUniform(thread_data->program,
+                                    thread_data->index,
+                                    thread_data->bufsize,
+                                    thread_data->length,
+                                    thread_data->size,
+                                    thread_data->type,
+                                    thread_data->name);
 
 }
 
@@ -3410,26 +3414,26 @@ glGetActiveUniform_evgl_api_thread_cmd(GLuint program, GLuint index, GLsizei buf
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGetActiveUniform thread_param_local;
-   EVGL_API_Thread_Command_glGetActiveUniform *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGetActiveUniform thread_data_local;
+   EVGL_API_Thread_Command_glGetActiveUniform *thread_data = &thread_data_local;
 
-   thread_param->program = program;
-   thread_param->index = index;
-   thread_param->bufsize = bufsize;
-   thread_param->length = length;
-   thread_param->size = size;
-   thread_param->type = type;
-   thread_param->name = name;
+   thread_data->program = program;
+   thread_data->index = index;
+   thread_data->bufsize = bufsize;
+   thread_data->length = length;
+   thread_data->size = size;
+   thread_data->type = type;
+   thread_data->name = name;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGetActiveUniform,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGetAttachedShaders(GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders);
+ * void
+ * glGetAttachedShaders(GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders);
  */
 
 typedef struct
@@ -3446,13 +3450,13 @@ void (*orig_evgl_api_glGetAttachedShaders)(GLuint program, GLsizei maxcount, GLs
 static void
 _evgl_api_thread_glGetAttachedShaders(void *data)
 {
-   EVGL_API_Thread_Command_glGetAttachedShaders *thread_param =
+   EVGL_API_Thread_Command_glGetAttachedShaders *thread_data =
       (EVGL_API_Thread_Command_glGetAttachedShaders *)data;
 
-   orig_evgl_api_glGetAttachedShaders(thread_param->program,
-                                      thread_param->maxcount,
-                                      thread_param->count,
-                                      thread_param->shaders);
+   orig_evgl_api_glGetAttachedShaders(thread_data->program,
+                                      thread_data->maxcount,
+                                      thread_data->count,
+                                      thread_data->shaders);
 
 }
 
@@ -3467,23 +3471,23 @@ glGetAttachedShaders_evgl_api_thread_cmd(GLuint program, GLsizei maxcount, GLsiz
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGetAttachedShaders thread_param_local;
-   EVGL_API_Thread_Command_glGetAttachedShaders *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGetAttachedShaders thread_data_local;
+   EVGL_API_Thread_Command_glGetAttachedShaders *thread_data = &thread_data_local;
 
-   thread_param->program = program;
-   thread_param->maxcount = maxcount;
-   thread_param->count = count;
-   thread_param->shaders = shaders;
+   thread_data->program = program;
+   thread_data->maxcount = maxcount;
+   thread_data->count = count;
+   thread_data->shaders = shaders;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGetAttachedShaders,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   int
-   glGetAttribLocation(GLuint program, const char* name);
+ * int
+ * glGetAttribLocation(GLuint program, const char* name);
  */
 
 typedef struct
@@ -3499,11 +3503,11 @@ int (*orig_evgl_api_glGetAttribLocation)(GLuint program, const char* name);
 static void
 _evgl_api_thread_glGetAttribLocation(void *data)
 {
-   EVGL_API_Thread_Command_glGetAttribLocation *thread_param =
+   EVGL_API_Thread_Command_glGetAttribLocation *thread_data =
       (EVGL_API_Thread_Command_glGetAttribLocation *)data;
 
-   thread_param->return_value = orig_evgl_api_glGetAttribLocation(thread_param->program,
-                                                                  thread_param->name);
+   thread_data->return_value = orig_evgl_api_glGetAttribLocation(thread_data->program,
+                                                                 thread_data->name);
 
 }
 
@@ -3517,23 +3521,23 @@ glGetAttribLocation_evgl_api_thread_cmd(GLuint program, const char* name)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGetAttribLocation thread_param_local;
-   EVGL_API_Thread_Command_glGetAttribLocation *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGetAttribLocation thread_data_local;
+   EVGL_API_Thread_Command_glGetAttribLocation *thread_data = &thread_data_local;
 
-   thread_param->program = program;
-   thread_param->name = name;
+   thread_data->program = program;
+   thread_data->name = name;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGetAttribLocation,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
-   void
-   glGetBooleanv(GLenum pname, GLboolean* params);
+ * void
+ * glGetBooleanv(GLenum pname, GLboolean* params);
  */
 
 typedef struct
@@ -3548,11 +3552,11 @@ void (*orig_evgl_api_glGetBooleanv)(GLenum pname, GLboolean* params);
 static void
 _evgl_api_thread_glGetBooleanv(void *data)
 {
-   EVGL_API_Thread_Command_glGetBooleanv *thread_param =
+   EVGL_API_Thread_Command_glGetBooleanv *thread_data =
       (EVGL_API_Thread_Command_glGetBooleanv *)data;
 
-   orig_evgl_api_glGetBooleanv(thread_param->pname,
-                               thread_param->params);
+   orig_evgl_api_glGetBooleanv(thread_data->pname,
+                               thread_data->params);
 
 }
 
@@ -3567,21 +3571,21 @@ glGetBooleanv_evgl_api_thread_cmd(GLenum pname, GLboolean* params)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGetBooleanv thread_param_local;
-   EVGL_API_Thread_Command_glGetBooleanv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGetBooleanv thread_data_local;
+   EVGL_API_Thread_Command_glGetBooleanv *thread_data = &thread_data_local;
 
-   thread_param->pname = pname;
-   thread_param->params = params;
+   thread_data->pname = pname;
+   thread_data->params = params;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGetBooleanv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGetBufferParameteriv(GLenum target, GLenum pname, GLint* params);
+ * void
+ * glGetBufferParameteriv(GLenum target, GLenum pname, GLint* params);
  */
 
 typedef struct
@@ -3597,12 +3601,12 @@ void (*orig_evgl_api_glGetBufferParameteriv)(GLenum target, GLenum pname, GLint*
 static void
 _evgl_api_thread_glGetBufferParameteriv(void *data)
 {
-   EVGL_API_Thread_Command_glGetBufferParameteriv *thread_param =
+   EVGL_API_Thread_Command_glGetBufferParameteriv *thread_data =
       (EVGL_API_Thread_Command_glGetBufferParameteriv *)data;
 
-   orig_evgl_api_glGetBufferParameteriv(thread_param->target,
-                                        thread_param->pname,
-                                        thread_param->params);
+   orig_evgl_api_glGetBufferParameteriv(thread_data->target,
+                                        thread_data->pname,
+                                        thread_data->params);
 
 }
 
@@ -3617,22 +3621,22 @@ glGetBufferParameteriv_evgl_api_thread_cmd(GLenum target, GLenum pname, GLint* p
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGetBufferParameteriv thread_param_local;
-   EVGL_API_Thread_Command_glGetBufferParameteriv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGetBufferParameteriv thread_data_local;
+   EVGL_API_Thread_Command_glGetBufferParameteriv *thread_data = &thread_data_local;
 
-   thread_param->target = target;
-   thread_param->pname = pname;
-   thread_param->params = params;
+   thread_data->target = target;
+   thread_data->pname = pname;
+   thread_data->params = params;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGetBufferParameteriv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   GLenum
-   glGetError(void);
+ * GLenum
+ * glGetError(void);
  */
 
 typedef struct
@@ -3646,10 +3650,10 @@ GLenum (*orig_evgl_api_glGetError)(void);
 static void
 _evgl_api_thread_glGetError(void *data)
 {
-   EVGL_API_Thread_Command_glGetError *thread_param =
+   EVGL_API_Thread_Command_glGetError *thread_data =
       (EVGL_API_Thread_Command_glGetError *)data;
 
-   thread_param->return_value = orig_evgl_api_glGetError();
+   thread_data->return_value = orig_evgl_api_glGetError();
 
 }
 
@@ -3663,21 +3667,21 @@ glGetError_evgl_api_thread_cmd(void)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGetError thread_param_local;
-   EVGL_API_Thread_Command_glGetError *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGetError thread_data_local;
+   EVGL_API_Thread_Command_glGetError *thread_data = &thread_data_local;
 
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGetError,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
-   void
-   glGetFloatv(GLenum pname, GLfloat* params);
+ * void
+ * glGetFloatv(GLenum pname, GLfloat* params);
  */
 
 typedef struct
@@ -3692,11 +3696,11 @@ void (*orig_evgl_api_glGetFloatv)(GLenum pname, GLfloat* params);
 static void
 _evgl_api_thread_glGetFloatv(void *data)
 {
-   EVGL_API_Thread_Command_glGetFloatv *thread_param =
+   EVGL_API_Thread_Command_glGetFloatv *thread_data =
       (EVGL_API_Thread_Command_glGetFloatv *)data;
 
-   orig_evgl_api_glGetFloatv(thread_param->pname,
-                             thread_param->params);
+   orig_evgl_api_glGetFloatv(thread_data->pname,
+                             thread_data->params);
 
 }
 
@@ -3711,21 +3715,21 @@ glGetFloatv_evgl_api_thread_cmd(GLenum pname, GLfloat* params)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGetFloatv thread_param_local;
-   EVGL_API_Thread_Command_glGetFloatv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGetFloatv thread_data_local;
+   EVGL_API_Thread_Command_glGetFloatv *thread_data = &thread_data_local;
 
-   thread_param->pname = pname;
-   thread_param->params = params;
+   thread_data->pname = pname;
+   thread_data->params = params;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGetFloatv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint* params);
+ * void
+ * glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint* params);
  */
 
 typedef struct
@@ -3742,13 +3746,13 @@ void (*orig_evgl_api_glGetFramebufferAttachmentParameteriv)(GLenum target, GLenu
 static void
 _evgl_api_thread_glGetFramebufferAttachmentParameteriv(void *data)
 {
-   EVGL_API_Thread_Command_glGetFramebufferAttachmentParameteriv *thread_param =
+   EVGL_API_Thread_Command_glGetFramebufferAttachmentParameteriv *thread_data =
       (EVGL_API_Thread_Command_glGetFramebufferAttachmentParameteriv *)data;
 
-   orig_evgl_api_glGetFramebufferAttachmentParameteriv(thread_param->target,
-                                                       thread_param->attachment,
-                                                       thread_param->pname,
-                                                       thread_param->params);
+   orig_evgl_api_glGetFramebufferAttachmentParameteriv(thread_data->target,
+                                                       thread_data->attachment,
+                                                       thread_data->pname,
+                                                       thread_data->params);
 
 }
 
@@ -3763,23 +3767,23 @@ glGetFramebufferAttachmentParameteriv_evgl_api_thread_cmd(GLenum target, GLenum
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGetFramebufferAttachmentParameteriv thread_param_local;
-   EVGL_API_Thread_Command_glGetFramebufferAttachmentParameteriv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGetFramebufferAttachmentParameteriv thread_data_local;
+   EVGL_API_Thread_Command_glGetFramebufferAttachmentParameteriv *thread_data = &thread_data_local;
 
-   thread_param->target = target;
-   thread_param->attachment = attachment;
-   thread_param->pname = pname;
-   thread_param->params = params;
+   thread_data->target = target;
+   thread_data->attachment = attachment;
+   thread_data->pname = pname;
+   thread_data->params = params;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGetFramebufferAttachmentParameteriv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGetIntegerv(GLenum pname, GLint* params);
+ * void
+ * glGetIntegerv(GLenum pname, GLint* params);
  */
 
 typedef struct
@@ -3794,11 +3798,11 @@ void (*orig_evgl_api_glGetIntegerv)(GLenum pname, GLint* params);
 static void
 _evgl_api_thread_glGetIntegerv(void *data)
 {
-   EVGL_API_Thread_Command_glGetIntegerv *thread_param =
+   EVGL_API_Thread_Command_glGetIntegerv *thread_data =
       (EVGL_API_Thread_Command_glGetIntegerv *)data;
 
-   orig_evgl_api_glGetIntegerv(thread_param->pname,
-                               thread_param->params);
+   orig_evgl_api_glGetIntegerv(thread_data->pname,
+                               thread_data->params);
 
 }
 
@@ -3813,21 +3817,21 @@ glGetIntegerv_evgl_api_thread_cmd(GLenum pname, GLint* params)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGetIntegerv thread_param_local;
-   EVGL_API_Thread_Command_glGetIntegerv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGetIntegerv thread_data_local;
+   EVGL_API_Thread_Command_glGetIntegerv *thread_data = &thread_data_local;
 
-   thread_param->pname = pname;
-   thread_param->params = params;
+   thread_data->pname = pname;
+   thread_data->params = params;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGetIntegerv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGetProgramiv(GLuint program, GLenum pname, GLint* params);
+ * void
+ * glGetProgramiv(GLuint program, GLenum pname, GLint* params);
  */
 
 typedef struct
@@ -3843,12 +3847,12 @@ void (*orig_evgl_api_glGetProgramiv)(GLuint program, GLenum pname, GLint* params
 static void
 _evgl_api_thread_glGetProgramiv(void *data)
 {
-   EVGL_API_Thread_Command_glGetProgramiv *thread_param =
+   EVGL_API_Thread_Command_glGetProgramiv *thread_data =
       (EVGL_API_Thread_Command_glGetProgramiv *)data;
 
-   orig_evgl_api_glGetProgramiv(thread_param->program,
-                                thread_param->pname,
-                                thread_param->params);
+   orig_evgl_api_glGetProgramiv(thread_data->program,
+                                thread_data->pname,
+                                thread_data->params);
 
 }
 
@@ -3863,22 +3867,22 @@ glGetProgramiv_evgl_api_thread_cmd(GLuint program, GLenum pname, GLint* params)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGetProgramiv thread_param_local;
-   EVGL_API_Thread_Command_glGetProgramiv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGetProgramiv thread_data_local;
+   EVGL_API_Thread_Command_glGetProgramiv *thread_data = &thread_data_local;
 
-   thread_param->program = program;
-   thread_param->pname = pname;
-   thread_param->params = params;
+   thread_data->program = program;
+   thread_data->pname = pname;
+   thread_data->params = params;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGetProgramiv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGetProgramInfoLog(GLuint program, GLsizei bufsize, GLsizei* length, char* infolog);
+ * void
+ * glGetProgramInfoLog(GLuint program, GLsizei bufsize, GLsizei* length, char* infolog);
  */
 
 typedef struct
@@ -3895,13 +3899,13 @@ void (*orig_evgl_api_glGetProgramInfoLog)(GLuint program, GLsizei bufsize, GLsiz
 static void
 _evgl_api_thread_glGetProgramInfoLog(void *data)
 {
-   EVGL_API_Thread_Command_glGetProgramInfoLog *thread_param =
+   EVGL_API_Thread_Command_glGetProgramInfoLog *thread_data =
       (EVGL_API_Thread_Command_glGetProgramInfoLog *)data;
 
-   orig_evgl_api_glGetProgramInfoLog(thread_param->program,
-                                     thread_param->bufsize,
-                                     thread_param->length,
-                                     thread_param->infolog);
+   orig_evgl_api_glGetProgramInfoLog(thread_data->program,
+                                     thread_data->bufsize,
+                                     thread_data->length,
+                                     thread_data->infolog);
 
 }
 
@@ -3916,23 +3920,23 @@ glGetProgramInfoLog_evgl_api_thread_cmd(GLuint program, GLsizei bufsize, GLsizei
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGetProgramInfoLog thread_param_local;
-   EVGL_API_Thread_Command_glGetProgramInfoLog *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGetProgramInfoLog thread_data_local;
+   EVGL_API_Thread_Command_glGetProgramInfoLog *thread_data = &thread_data_local;
 
-   thread_param->program = program;
-   thread_param->bufsize = bufsize;
-   thread_param->length = length;
-   thread_param->infolog = infolog;
+   thread_data->program = program;
+   thread_data->bufsize = bufsize;
+   thread_data->length = length;
+   thread_data->infolog = infolog;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGetProgramInfoLog,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint* params);
+ * void
+ * glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint* params);
  */
 
 typedef struct
@@ -3948,12 +3952,12 @@ void (*orig_evgl_api_glGetRenderbufferParameteriv)(GLenum target, GLenum pname,
 static void
 _evgl_api_thread_glGetRenderbufferParameteriv(void *data)
 {
-   EVGL_API_Thread_Command_glGetRenderbufferParameteriv *thread_param =
+   EVGL_API_Thread_Command_glGetRenderbufferParameteriv *thread_data =
       (EVGL_API_Thread_Command_glGetRenderbufferParameteriv *)data;
 
-   orig_evgl_api_glGetRenderbufferParameteriv(thread_param->target,
-                                              thread_param->pname,
-                                              thread_param->params);
+   orig_evgl_api_glGetRenderbufferParameteriv(thread_data->target,
+                                              thread_data->pname,
+                                              thread_data->params);
 
 }
 
@@ -3968,22 +3972,22 @@ glGetRenderbufferParameteriv_evgl_api_thread_cmd(GLenum target, GLenum pname, GL
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGetRenderbufferParameteriv thread_param_local;
-   EVGL_API_Thread_Command_glGetRenderbufferParameteriv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGetRenderbufferParameteriv thread_data_local;
+   EVGL_API_Thread_Command_glGetRenderbufferParameteriv *thread_data = &thread_data_local;
 
-   thread_param->target = target;
-   thread_param->pname = pname;
-   thread_param->params = params;
+   thread_data->target = target;
+   thread_data->pname = pname;
+   thread_data->params = params;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGetRenderbufferParameteriv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGetShaderiv(GLuint shader, GLenum pname, GLint* params);
+ * void
+ * glGetShaderiv(GLuint shader, GLenum pname, GLint* params);
  */
 
 typedef struct
@@ -3999,12 +4003,12 @@ void (*orig_evgl_api_glGetShaderiv)(GLuint shader, GLenum pname, GLint* params);
 static void
 _evgl_api_thread_glGetShaderiv(void *data)
 {
-   EVGL_API_Thread_Command_glGetShaderiv *thread_param =
+   EVGL_API_Thread_Command_glGetShaderiv *thread_data =
       (EVGL_API_Thread_Command_glGetShaderiv *)data;
 
-   orig_evgl_api_glGetShaderiv(thread_param->shader,
-                               thread_param->pname,
-                               thread_param->params);
+   orig_evgl_api_glGetShaderiv(thread_data->shader,
+                               thread_data->pname,
+                               thread_data->params);
 
 }
 
@@ -4019,22 +4023,22 @@ glGetShaderiv_evgl_api_thread_cmd(GLuint shader, GLenum pname, GLint* params)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGetShaderiv thread_param_local;
-   EVGL_API_Thread_Command_glGetShaderiv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGetShaderiv thread_data_local;
+   EVGL_API_Thread_Command_glGetShaderiv *thread_data = &thread_data_local;
 
-   thread_param->shader = shader;
-   thread_param->pname = pname;
-   thread_param->params = params;
+   thread_data->shader = shader;
+   thread_data->pname = pname;
+   thread_data->params = params;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGetShaderiv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGetShaderInfoLog(GLuint shader, GLsizei bufsize, GLsizei* length, char* infolog);
+ * void
+ * glGetShaderInfoLog(GLuint shader, GLsizei bufsize, GLsizei* length, char* infolog);
  */
 
 typedef struct
@@ -4051,13 +4055,13 @@ void (*orig_evgl_api_glGetShaderInfoLog)(GLuint shader, GLsizei bufsize, GLsizei
 static void
 _evgl_api_thread_glGetShaderInfoLog(void *data)
 {
-   EVGL_API_Thread_Command_glGetShaderInfoLog *thread_param =
+   EVGL_API_Thread_Command_glGetShaderInfoLog *thread_data =
       (EVGL_API_Thread_Command_glGetShaderInfoLog *)data;
 
-   orig_evgl_api_glGetShaderInfoLog(thread_param->shader,
-                                    thread_param->bufsize,
-                                    thread_param->length,
-                                    thread_param->infolog);
+   orig_evgl_api_glGetShaderInfoLog(thread_data->shader,
+                                    thread_data->bufsize,
+                                    thread_data->length,
+                                    thread_data->infolog);
 
 }
 
@@ -4072,23 +4076,23 @@ glGetShaderInfoLog_evgl_api_thread_cmd(GLuint shader, GLsizei bufsize, GLsizei*
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGetShaderInfoLog thread_param_local;
-   EVGL_API_Thread_Command_glGetShaderInfoLog *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGetShaderInfoLog thread_data_local;
+   EVGL_API_Thread_Command_glGetShaderInfoLog *thread_data = &thread_data_local;
 
-   thread_param->shader = shader;
-   thread_param->bufsize = bufsize;
-   thread_param->length = length;
-   thread_param->infolog = infolog;
+   thread_data->shader = shader;
+   thread_data->bufsize = bufsize;
+   thread_data->length = length;
+   thread_data->infolog = infolog;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGetShaderInfoLog,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision);
+ * void
+ * glGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision);
  */
 
 typedef struct
@@ -4105,13 +4109,13 @@ void (*orig_evgl_api_glGetShaderPrecisionFormat)(GLenum shadertype, GLenum preci
 static void
 _evgl_api_thread_glGetShaderPrecisionFormat(void *data)
 {
-   EVGL_API_Thread_Command_glGetShaderPrecisionFormat *thread_param =
+   EVGL_API_Thread_Command_glGetShaderPrecisionFormat *thread_data =
       (EVGL_API_Thread_Command_glGetShaderPrecisionFormat *)data;
 
-   orig_evgl_api_glGetShaderPrecisionFormat(thread_param->shadertype,
-                                            thread_param->precisiontype,
-                                            thread_param->range,
-                                            thread_param->precision);
+   orig_evgl_api_glGetShaderPrecisionFormat(thread_data->shadertype,
+                                            thread_data->precisiontype,
+                                            thread_data->range,
+                                            thread_data->precision);
 
 }
 
@@ -4126,23 +4130,23 @@ glGetShaderPrecisionFormat_evgl_api_thread_cmd(GLenum shadertype, GLenum precisi
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGetShaderPrecisionFormat thread_param_local;
-   EVGL_API_Thread_Command_glGetShaderPrecisionFormat *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGetShaderPrecisionFormat thread_data_local;
+   EVGL_API_Thread_Command_glGetShaderPrecisionFormat *thread_data = &thread_data_local;
 
-   thread_param->shadertype = shadertype;
-   thread_param->precisiontype = precisiontype;
-   thread_param->range = range;
-   thread_param->precision = precision;
+   thread_data->shadertype = shadertype;
+   thread_data->precisiontype = precisiontype;
+   thread_data->range = range;
+   thread_data->precision = precision;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGetShaderPrecisionFormat,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGetShaderSource(GLuint shader, GLsizei bufsize, GLsizei* length, char* source);
+ * void
+ * glGetShaderSource(GLuint shader, GLsizei bufsize, GLsizei* length, char* source);
  */
 
 typedef struct
@@ -4159,13 +4163,13 @@ void (*orig_evgl_api_glGetShaderSource)(GLuint shader, GLsizei bufsize, GLsizei*
 static void
 _evgl_api_thread_glGetShaderSource(void *data)
 {
-   EVGL_API_Thread_Command_glGetShaderSource *thread_param =
+   EVGL_API_Thread_Command_glGetShaderSource *thread_data =
       (EVGL_API_Thread_Command_glGetShaderSource *)data;
 
-   orig_evgl_api_glGetShaderSource(thread_param->shader,
-                                   thread_param->bufsize,
-                                   thread_param->length,
-                                   thread_param->source);
+   orig_evgl_api_glGetShaderSource(thread_data->shader,
+                                   thread_data->bufsize,
+                                   thread_data->length,
+                                   thread_data->source);
 
 }
 
@@ -4180,23 +4184,23 @@ glGetShaderSource_evgl_api_thread_cmd(GLuint shader, GLsizei bufsize, GLsizei* l
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGetShaderSource thread_param_local;
-   EVGL_API_Thread_Command_glGetShaderSource *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGetShaderSource thread_data_local;
+   EVGL_API_Thread_Command_glGetShaderSource *thread_data = &thread_data_local;
 
-   thread_param->shader = shader;
-   thread_param->bufsize = bufsize;
-   thread_param->length = length;
-   thread_param->source = source;
+   thread_data->shader = shader;
+   thread_data->bufsize = bufsize;
+   thread_data->length = length;
+   thread_data->source = source;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGetShaderSource,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   const GLubyte*
-   glGetString(GLenum name);
+ * const GLubyte*
+ * glGetString(GLenum name);
  */
 
 typedef struct
@@ -4211,10 +4215,10 @@ const GLubyte* (*orig_evgl_api_glGetString)(GLenum name);
 static void
 _evgl_api_thread_glGetString(void *data)
 {
-   EVGL_API_Thread_Command_glGetString *thread_param =
+   EVGL_API_Thread_Command_glGetString *thread_data =
       (EVGL_API_Thread_Command_glGetString *)data;
 
-   thread_param->return_value = orig_evgl_api_glGetString(thread_param->name);
+   thread_data->return_value = orig_evgl_api_glGetString(thread_data->name);
 
 }
 
@@ -4228,22 +4232,22 @@ glGetString_evgl_api_thread_cmd(GLenum name)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGetString thread_param_local;
-   EVGL_API_Thread_Command_glGetString *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGetString thread_data_local;
+   EVGL_API_Thread_Command_glGetString *thread_data = &thread_data_local;
 
-   thread_param->name = name;
+   thread_data->name = name;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGetString,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
-   void
-   glGetTexParameterfv(GLenum target, GLenum pname, GLfloat* params);
+ * void
+ * glGetTexParameterfv(GLenum target, GLenum pname, GLfloat* params);
  */
 
 typedef struct
@@ -4259,12 +4263,12 @@ void (*orig_evgl_api_glGetTexParameterfv)(GLenum target, GLenum pname, GLfloat*
 static void
 _evgl_api_thread_glGetTexParameterfv(void *data)
 {
-   EVGL_API_Thread_Command_glGetTexParameterfv *thread_param =
+   EVGL_API_Thread_Command_glGetTexParameterfv *thread_data =
       (EVGL_API_Thread_Command_glGetTexParameterfv *)data;
 
-   orig_evgl_api_glGetTexParameterfv(thread_param->target,
-                                     thread_param->pname,
-                                     thread_param->params);
+   orig_evgl_api_glGetTexParameterfv(thread_data->target,
+                                     thread_data->pname,
+                                     thread_data->params);
 
 }
 
@@ -4279,22 +4283,22 @@ glGetTexParameterfv_evgl_api_thread_cmd(GLenum target, GLenum pname, GLfloat* pa
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGetTexParameterfv thread_param_local;
-   EVGL_API_Thread_Command_glGetTexParameterfv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGetTexParameterfv thread_data_local;
+   EVGL_API_Thread_Command_glGetTexParameterfv *thread_data = &thread_data_local;
 
-   thread_param->target = target;
-   thread_param->pname = pname;
-   thread_param->params = params;
+   thread_data->target = target;
+   thread_data->pname = pname;
+   thread_data->params = params;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGetTexParameterfv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGetTexParameteriv(GLenum target, GLenum pname, GLint* params);
+ * void
+ * glGetTexParameteriv(GLenum target, GLenum pname, GLint* params);
  */
 
 typedef struct
@@ -4310,12 +4314,12 @@ void (*orig_evgl_api_glGetTexParameteriv)(GLenum target, GLenum pname, GLint* pa
 static void
 _evgl_api_thread_glGetTexParameteriv(void *data)
 {
-   EVGL_API_Thread_Command_glGetTexParameteriv *thread_param =
+   EVGL_API_Thread_Command_glGetTexParameteriv *thread_data =
       (EVGL_API_Thread_Command_glGetTexParameteriv *)data;
 
-   orig_evgl_api_glGetTexParameteriv(thread_param->target,
-                                     thread_param->pname,
-                                     thread_param->params);
+   orig_evgl_api_glGetTexParameteriv(thread_data->target,
+                                     thread_data->pname,
+                                     thread_data->params);
 
 }
 
@@ -4330,22 +4334,22 @@ glGetTexParameteriv_evgl_api_thread_cmd(GLenum target, GLenum pname, GLint* para
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGetTexParameteriv thread_param_local;
-   EVGL_API_Thread_Command_glGetTexParameteriv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGetTexParameteriv thread_data_local;
+   EVGL_API_Thread_Command_glGetTexParameteriv *thread_data = &thread_data_local;
 
-   thread_param->target = target;
-   thread_param->pname = pname;
-   thread_param->params = params;
+   thread_data->target = target;
+   thread_data->pname = pname;
+   thread_data->params = params;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGetTexParameteriv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGetUniformfv(GLuint program, GLint location, GLfloat* params);
+ * void
+ * glGetUniformfv(GLuint program, GLint location, GLfloat* params);
  */
 
 typedef struct
@@ -4361,12 +4365,12 @@ void (*orig_evgl_api_glGetUniformfv)(GLuint program, GLint location, GLfloat* pa
 static void
 _evgl_api_thread_glGetUniformfv(void *data)
 {
-   EVGL_API_Thread_Command_glGetUniformfv *thread_param =
+   EVGL_API_Thread_Command_glGetUniformfv *thread_data =
       (EVGL_API_Thread_Command_glGetUniformfv *)data;
 
-   orig_evgl_api_glGetUniformfv(thread_param->program,
-                                thread_param->location,
-                                thread_param->params);
+   orig_evgl_api_glGetUniformfv(thread_data->program,
+                                thread_data->location,
+                                thread_data->params);
 
 }
 
@@ -4381,22 +4385,22 @@ glGetUniformfv_evgl_api_thread_cmd(GLuint program, GLint location, GLfloat* para
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGetUniformfv thread_param_local;
-   EVGL_API_Thread_Command_glGetUniformfv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGetUniformfv thread_data_local;
+   EVGL_API_Thread_Command_glGetUniformfv *thread_data = &thread_data_local;
 
-   thread_param->program = program;
-   thread_param->location = location;
-   thread_param->params = params;
+   thread_data->program = program;
+   thread_data->location = location;
+   thread_data->params = params;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGetUniformfv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGetUniformiv(GLuint program, GLint location, GLint* params);
+ * void
+ * glGetUniformiv(GLuint program, GLint location, GLint* params);
  */
 
 typedef struct
@@ -4412,12 +4416,12 @@ void (*orig_evgl_api_glGetUniformiv)(GLuint program, GLint location, GLint* para
 static void
 _evgl_api_thread_glGetUniformiv(void *data)
 {
-   EVGL_API_Thread_Command_glGetUniformiv *thread_param =
+   EVGL_API_Thread_Command_glGetUniformiv *thread_data =
       (EVGL_API_Thread_Command_glGetUniformiv *)data;
 
-   orig_evgl_api_glGetUniformiv(thread_param->program,
-                                thread_param->location,
-                                thread_param->params);
+   orig_evgl_api_glGetUniformiv(thread_data->program,
+                                thread_data->location,
+                                thread_data->params);
 
 }
 
@@ -4432,22 +4436,22 @@ glGetUniformiv_evgl_api_thread_cmd(GLuint program, GLint location, GLint* params
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGetUniformiv thread_param_local;
-   EVGL_API_Thread_Command_glGetUniformiv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGetUniformiv thread_data_local;
+   EVGL_API_Thread_Command_glGetUniformiv *thread_data = &thread_data_local;
 
-   thread_param->program = program;
-   thread_param->location = location;
-   thread_param->params = params;
+   thread_data->program = program;
+   thread_data->location = location;
+   thread_data->params = params;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGetUniformiv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   int
-   glGetUniformLocation(GLuint program, const char* name);
+ * int
+ * glGetUniformLocation(GLuint program, const char* name);
  */
 
 typedef struct
@@ -4463,11 +4467,11 @@ int (*orig_evgl_api_glGetUniformLocation)(GLuint program, const char* name);
 static void
 _evgl_api_thread_glGetUniformLocation(void *data)
 {
-   EVGL_API_Thread_Command_glGetUniformLocation *thread_param =
+   EVGL_API_Thread_Command_glGetUniformLocation *thread_data =
       (EVGL_API_Thread_Command_glGetUniformLocation *)data;
 
-   thread_param->return_value = orig_evgl_api_glGetUniformLocation(thread_param->program,
-                                                                   thread_param->name);
+   thread_data->return_value = orig_evgl_api_glGetUniformLocation(thread_data->program,
+                                                                  thread_data->name);
 
 }
 
@@ -4481,23 +4485,23 @@ glGetUniformLocation_evgl_api_thread_cmd(GLuint program, const char* name)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGetUniformLocation thread_param_local;
-   EVGL_API_Thread_Command_glGetUniformLocation *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGetUniformLocation thread_data_local;
+   EVGL_API_Thread_Command_glGetUniformLocation *thread_data = &thread_data_local;
 
-   thread_param->program = program;
-   thread_param->name = name;
+   thread_data->program = program;
+   thread_data->name = name;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGetUniformLocation,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
-   void
-   glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat* params);
+ * void
+ * glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat* params);
  */
 
 typedef struct
@@ -4513,12 +4517,12 @@ void (*orig_evgl_api_glGetVertexAttribfv)(GLuint index, GLenum pname, GLfloat* p
 static void
 _evgl_api_thread_glGetVertexAttribfv(void *data)
 {
-   EVGL_API_Thread_Command_glGetVertexAttribfv *thread_param =
+   EVGL_API_Thread_Command_glGetVertexAttribfv *thread_data =
       (EVGL_API_Thread_Command_glGetVertexAttribfv *)data;
 
-   orig_evgl_api_glGetVertexAttribfv(thread_param->index,
-                                     thread_param->pname,
-                                     thread_param->params);
+   orig_evgl_api_glGetVertexAttribfv(thread_data->index,
+                                     thread_data->pname,
+                                     thread_data->params);
 
 }
 
@@ -4533,22 +4537,22 @@ glGetVertexAttribfv_evgl_api_thread_cmd(GLuint index, GLenum pname, GLfloat* par
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGetVertexAttribfv thread_param_local;
-   EVGL_API_Thread_Command_glGetVertexAttribfv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGetVertexAttribfv thread_data_local;
+   EVGL_API_Thread_Command_glGetVertexAttribfv *thread_data = &thread_data_local;
 
-   thread_param->index = index;
-   thread_param->pname = pname;
-   thread_param->params = params;
+   thread_data->index = index;
+   thread_data->pname = pname;
+   thread_data->params = params;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGetVertexAttribfv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGetVertexAttribiv(GLuint index, GLenum pname, GLint* params);
+ * void
+ * glGetVertexAttribiv(GLuint index, GLenum pname, GLint* params);
  */
 
 typedef struct
@@ -4564,12 +4568,12 @@ void (*orig_evgl_api_glGetVertexAttribiv)(GLuint index, GLenum pname, GLint* par
 static void
 _evgl_api_thread_glGetVertexAttribiv(void *data)
 {
-   EVGL_API_Thread_Command_glGetVertexAttribiv *thread_param =
+   EVGL_API_Thread_Command_glGetVertexAttribiv *thread_data =
       (EVGL_API_Thread_Command_glGetVertexAttribiv *)data;
 
-   orig_evgl_api_glGetVertexAttribiv(thread_param->index,
-                                     thread_param->pname,
-                                     thread_param->params);
+   orig_evgl_api_glGetVertexAttribiv(thread_data->index,
+                                     thread_data->pname,
+                                     thread_data->params);
 
 }
 
@@ -4584,22 +4588,22 @@ glGetVertexAttribiv_evgl_api_thread_cmd(GLuint index, GLenum pname, GLint* param
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGetVertexAttribiv thread_param_local;
-   EVGL_API_Thread_Command_glGetVertexAttribiv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGetVertexAttribiv thread_data_local;
+   EVGL_API_Thread_Command_glGetVertexAttribiv *thread_data = &thread_data_local;
 
-   thread_param->index = index;
-   thread_param->pname = pname;
-   thread_param->params = params;
+   thread_data->index = index;
+   thread_data->pname = pname;
+   thread_data->params = params;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGetVertexAttribiv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGetVertexAttribPointerv(GLuint index, GLenum pname, void** pointer);
+ * void
+ * glGetVertexAttribPointerv(GLuint index, GLenum pname, void** pointer);
  */
 
 typedef struct
@@ -4615,12 +4619,12 @@ void (*orig_evgl_api_glGetVertexAttribPointerv)(GLuint index, GLenum pname, void
 static void
 _evgl_api_thread_glGetVertexAttribPointerv(void *data)
 {
-   EVGL_API_Thread_Command_glGetVertexAttribPointerv *thread_param =
+   EVGL_API_Thread_Command_glGetVertexAttribPointerv *thread_data =
       (EVGL_API_Thread_Command_glGetVertexAttribPointerv *)data;
 
-   orig_evgl_api_glGetVertexAttribPointerv(thread_param->index,
-                                           thread_param->pname,
-                                           thread_param->pointer);
+   orig_evgl_api_glGetVertexAttribPointerv(thread_data->index,
+                                           thread_data->pname,
+                                           thread_data->pointer);
 
 }
 
@@ -4635,22 +4639,22 @@ glGetVertexAttribPointerv_evgl_api_thread_cmd(GLuint index, GLenum pname, void**
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGetVertexAttribPointerv thread_param_local;
-   EVGL_API_Thread_Command_glGetVertexAttribPointerv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGetVertexAttribPointerv thread_data_local;
+   EVGL_API_Thread_Command_glGetVertexAttribPointerv *thread_data = &thread_data_local;
 
-   thread_param->index = index;
-   thread_param->pname = pname;
-   thread_param->pointer = pointer;
+   thread_data->index = index;
+   thread_data->pname = pname;
+   thread_data->pointer = pointer;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGetVertexAttribPointerv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glHint(GLenum target, GLenum mode);
+ * void
+ * glHint(GLenum target, GLenum mode);
  */
 
 typedef struct
@@ -4666,14 +4670,14 @@ void (*orig_evgl_api_glHint)(GLenum target, GLenum mode);
 static void
 _evgl_api_thread_glHint(void *data)
 {
-   EVGL_API_Thread_Command_glHint *thread_param =
+   EVGL_API_Thread_Command_glHint *thread_data =
       (EVGL_API_Thread_Command_glHint *)data;
 
-   orig_evgl_api_glHint(thread_param->target,
-                        thread_param->mode);
+   orig_evgl_api_glHint(thread_data->target,
+                        thread_data->mode);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -4687,37 +4691,37 @@ glHint_evgl_api_thread_cmd(GLenum target, GLenum mode)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glHint thread_param_local;
-   EVGL_API_Thread_Command_glHint *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glHint thread_data_local;
+   EVGL_API_Thread_Command_glHint *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_API_Thread_Command_glHint *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_API_Thread_Command_glHint));
-        if (thread_param_new)
+        EVGL_API_Thread_Command_glHint *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_API_Thread_Command_glHint));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->target = target;
-   thread_param->mode = mode;
+   thread_data->target = target;
+   thread_data->mode = mode;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glHint,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   GLboolean
-   glIsBuffer(GLuint buffer);
+ * GLboolean
+ * glIsBuffer(GLuint buffer);
  */
 
 typedef struct
@@ -4732,10 +4736,10 @@ GLboolean (*orig_evgl_api_glIsBuffer)(GLuint buffer);
 static void
 _evgl_api_thread_glIsBuffer(void *data)
 {
-   EVGL_API_Thread_Command_glIsBuffer *thread_param =
+   EVGL_API_Thread_Command_glIsBuffer *thread_data =
       (EVGL_API_Thread_Command_glIsBuffer *)data;
 
-   thread_param->return_value = orig_evgl_api_glIsBuffer(thread_param->buffer);
+   thread_data->return_value = orig_evgl_api_glIsBuffer(thread_data->buffer);
 
 }
 
@@ -4749,22 +4753,22 @@ glIsBuffer_evgl_api_thread_cmd(GLuint buffer)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glIsBuffer thread_param_local;
-   EVGL_API_Thread_Command_glIsBuffer *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glIsBuffer thread_data_local;
+   EVGL_API_Thread_Command_glIsBuffer *thread_data = &thread_data_local;
 
-   thread_param->buffer = buffer;
+   thread_data->buffer = buffer;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glIsBuffer,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
-   GLboolean
-   glIsEnabled(GLenum cap);
+ * GLboolean
+ * glIsEnabled(GLenum cap);
  */
 
 typedef struct
@@ -4779,10 +4783,10 @@ GLboolean (*orig_evgl_api_glIsEnabled)(GLenum cap);
 static void
 _evgl_api_thread_glIsEnabled(void *data)
 {
-   EVGL_API_Thread_Command_glIsEnabled *thread_param =
+   EVGL_API_Thread_Command_glIsEnabled *thread_data =
       (EVGL_API_Thread_Command_glIsEnabled *)data;
 
-   thread_param->return_value = orig_evgl_api_glIsEnabled(thread_param->cap);
+   thread_data->return_value = orig_evgl_api_glIsEnabled(thread_data->cap);
 
 }
 
@@ -4796,22 +4800,22 @@ glIsEnabled_evgl_api_thread_cmd(GLenum cap)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glIsEnabled thread_param_local;
-   EVGL_API_Thread_Command_glIsEnabled *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glIsEnabled thread_data_local;
+   EVGL_API_Thread_Command_glIsEnabled *thread_data = &thread_data_local;
 
-   thread_param->cap = cap;
+   thread_data->cap = cap;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glIsEnabled,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
-   GLboolean
-   glIsFramebuffer(GLuint framebuffer);
+ * GLboolean
+ * glIsFramebuffer(GLuint framebuffer);
  */
 
 typedef struct
@@ -4826,10 +4830,10 @@ GLboolean (*orig_evgl_api_glIsFramebuffer)(GLuint framebuffer);
 static void
 _evgl_api_thread_glIsFramebuffer(void *data)
 {
-   EVGL_API_Thread_Command_glIsFramebuffer *thread_param =
+   EVGL_API_Thread_Command_glIsFramebuffer *thread_data =
       (EVGL_API_Thread_Command_glIsFramebuffer *)data;
 
-   thread_param->return_value = orig_evgl_api_glIsFramebuffer(thread_param->framebuffer);
+   thread_data->return_value = orig_evgl_api_glIsFramebuffer(thread_data->framebuffer);
 
 }
 
@@ -4843,22 +4847,22 @@ glIsFramebuffer_evgl_api_thread_cmd(GLuint framebuffer)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glIsFramebuffer thread_param_local;
-   EVGL_API_Thread_Command_glIsFramebuffer *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glIsFramebuffer thread_data_local;
+   EVGL_API_Thread_Command_glIsFramebuffer *thread_data = &thread_data_local;
 
-   thread_param->framebuffer = framebuffer;
+   thread_data->framebuffer = framebuffer;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glIsFramebuffer,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
-   GLboolean
-   glIsProgram(GLuint program);
+ * GLboolean
+ * glIsProgram(GLuint program);
  */
 
 typedef struct
@@ -4873,10 +4877,10 @@ GLboolean (*orig_evgl_api_glIsProgram)(GLuint program);
 static void
 _evgl_api_thread_glIsProgram(void *data)
 {
-   EVGL_API_Thread_Command_glIsProgram *thread_param =
+   EVGL_API_Thread_Command_glIsProgram *thread_data =
       (EVGL_API_Thread_Command_glIsProgram *)data;
 
-   thread_param->return_value = orig_evgl_api_glIsProgram(thread_param->program);
+   thread_data->return_value = orig_evgl_api_glIsProgram(thread_data->program);
 
 }
 
@@ -4890,22 +4894,22 @@ glIsProgram_evgl_api_thread_cmd(GLuint program)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glIsProgram thread_param_local;
-   EVGL_API_Thread_Command_glIsProgram *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glIsProgram thread_data_local;
+   EVGL_API_Thread_Command_glIsProgram *thread_data = &thread_data_local;
 
-   thread_param->program = program;
+   thread_data->program = program;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glIsProgram,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
-   GLboolean
-   glIsRenderbuffer(GLuint renderbuffer);
+ * GLboolean
+ * glIsRenderbuffer(GLuint renderbuffer);
  */
 
 typedef struct
@@ -4920,10 +4924,10 @@ GLboolean (*orig_evgl_api_glIsRenderbuffer)(GLuint renderbuffer);
 static void
 _evgl_api_thread_glIsRenderbuffer(void *data)
 {
-   EVGL_API_Thread_Command_glIsRenderbuffer *thread_param =
+   EVGL_API_Thread_Command_glIsRenderbuffer *thread_data =
       (EVGL_API_Thread_Command_glIsRenderbuffer *)data;
 
-   thread_param->return_value = orig_evgl_api_glIsRenderbuffer(thread_param->renderbuffer);
+   thread_data->return_value = orig_evgl_api_glIsRenderbuffer(thread_data->renderbuffer);
 
 }
 
@@ -4937,22 +4941,22 @@ glIsRenderbuffer_evgl_api_thread_cmd(GLuint renderbuffer)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glIsRenderbuffer thread_param_local;
-   EVGL_API_Thread_Command_glIsRenderbuffer *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glIsRenderbuffer thread_data_local;
+   EVGL_API_Thread_Command_glIsRenderbuffer *thread_data = &thread_data_local;
 
-   thread_param->renderbuffer = renderbuffer;
+   thread_data->renderbuffer = renderbuffer;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glIsRenderbuffer,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
-   GLboolean
-   glIsShader(GLuint shader);
+ * GLboolean
+ * glIsShader(GLuint shader);
  */
 
 typedef struct
@@ -4967,10 +4971,10 @@ GLboolean (*orig_evgl_api_glIsShader)(GLuint shader);
 static void
 _evgl_api_thread_glIsShader(void *data)
 {
-   EVGL_API_Thread_Command_glIsShader *thread_param =
+   EVGL_API_Thread_Command_glIsShader *thread_data =
       (EVGL_API_Thread_Command_glIsShader *)data;
 
-   thread_param->return_value = orig_evgl_api_glIsShader(thread_param->shader);
+   thread_data->return_value = orig_evgl_api_glIsShader(thread_data->shader);
 
 }
 
@@ -4984,22 +4988,22 @@ glIsShader_evgl_api_thread_cmd(GLuint shader)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glIsShader thread_param_local;
-   EVGL_API_Thread_Command_glIsShader *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glIsShader thread_data_local;
+   EVGL_API_Thread_Command_glIsShader *thread_data = &thread_data_local;
 
-   thread_param->shader = shader;
+   thread_data->shader = shader;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glIsShader,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
-   GLboolean
-   glIsTexture(GLuint texture);
+ * GLboolean
+ * glIsTexture(GLuint texture);
  */
 
 typedef struct
@@ -5014,10 +5018,10 @@ GLboolean (*orig_evgl_api_glIsTexture)(GLuint texture);
 static void
 _evgl_api_thread_glIsTexture(void *data)
 {
-   EVGL_API_Thread_Command_glIsTexture *thread_param =
+   EVGL_API_Thread_Command_glIsTexture *thread_data =
       (EVGL_API_Thread_Command_glIsTexture *)data;
 
-   thread_param->return_value = orig_evgl_api_glIsTexture(thread_param->texture);
+   thread_data->return_value = orig_evgl_api_glIsTexture(thread_data->texture);
 
 }
 
@@ -5031,22 +5035,22 @@ glIsTexture_evgl_api_thread_cmd(GLuint texture)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glIsTexture thread_param_local;
-   EVGL_API_Thread_Command_glIsTexture *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glIsTexture thread_data_local;
+   EVGL_API_Thread_Command_glIsTexture *thread_data = &thread_data_local;
 
-   thread_param->texture = texture;
+   thread_data->texture = texture;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glIsTexture,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
-   void
-   glLineWidth(GLfloat width);
+ * void
+ * glLineWidth(GLfloat width);
  */
 
 typedef struct
@@ -5061,13 +5065,13 @@ void (*orig_evgl_api_glLineWidth)(GLfloat width);
 static void
 _evgl_api_thread_glLineWidth(void *data)
 {
-   EVGL_API_Thread_Command_glLineWidth *thread_param =
+   EVGL_API_Thread_Command_glLineWidth *thread_data =
       (EVGL_API_Thread_Command_glLineWidth *)data;
 
-   orig_evgl_api_glLineWidth(thread_param->width);
+   orig_evgl_api_glLineWidth(thread_data->width);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -5081,36 +5085,36 @@ glLineWidth_evgl_api_thread_cmd(GLfloat width)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glLineWidth thread_param_local;
-   EVGL_API_Thread_Command_glLineWidth *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glLineWidth thread_data_local;
+   EVGL_API_Thread_Command_glLineWidth *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_API_Thread_Command_glLineWidth *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_API_Thread_Command_glLineWidth));
-        if (thread_param_new)
+        EVGL_API_Thread_Command_glLineWidth *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_API_Thread_Command_glLineWidth));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->width = width;
+   thread_data->width = width;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glLineWidth,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glLinkProgram(GLuint program);
+ * void
+ * glLinkProgram(GLuint program);
  */
 
 typedef struct
@@ -5125,13 +5129,13 @@ void (*orig_evgl_api_glLinkProgram)(GLuint program);
 static void
 _evgl_api_thread_glLinkProgram(void *data)
 {
-   EVGL_API_Thread_Command_glLinkProgram *thread_param =
+   EVGL_API_Thread_Command_glLinkProgram *thread_data =
       (EVGL_API_Thread_Command_glLinkProgram *)data;
 
-   orig_evgl_api_glLinkProgram(thread_param->program);
+   orig_evgl_api_glLinkProgram(thread_data->program);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -5145,36 +5149,36 @@ glLinkProgram_evgl_api_thread_cmd(GLuint program)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glLinkProgram thread_param_local;
-   EVGL_API_Thread_Command_glLinkProgram *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glLinkProgram thread_data_local;
+   EVGL_API_Thread_Command_glLinkProgram *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_API_Thread_Command_glLinkProgram *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_API_Thread_Command_glLinkProgram));
-        if (thread_param_new)
+        EVGL_API_Thread_Command_glLinkProgram *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_API_Thread_Command_glLinkProgram));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->program = program;
+   thread_data->program = program;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glLinkProgram,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glPixelStorei(GLenum pname, GLint param);
+ * void
+ * glPixelStorei(GLenum pname, GLint param);
  */
 
 typedef struct
@@ -5190,14 +5194,14 @@ void (*orig_evgl_api_glPixelStorei)(GLenum pname, GLint param);
 static void
 _evgl_api_thread_glPixelStorei(void *data)
 {
-   EVGL_API_Thread_Command_glPixelStorei *thread_param =
+   EVGL_API_Thread_Command_glPixelStorei *thread_data =
       (EVGL_API_Thread_Command_glPixelStorei *)data;
 
-   orig_evgl_api_glPixelStorei(thread_param->pname,
-                               thread_param->param);
+   orig_evgl_api_glPixelStorei(thread_data->pname,
+                               thread_data->param);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -5211,37 +5215,37 @@ glPixelStorei_evgl_api_thread_cmd(GLenum pname, GLint param)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glPixelStorei thread_param_local;
-   EVGL_API_Thread_Command_glPixelStorei *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glPixelStorei thread_data_local;
+   EVGL_API_Thread_Command_glPixelStorei *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_API_Thread_Command_glPixelStorei *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_API_Thread_Command_glPixelStorei));
-        if (thread_param_new)
+        EVGL_API_Thread_Command_glPixelStorei *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_API_Thread_Command_glPixelStorei));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->pname = pname;
-   thread_param->param = param;
+   thread_data->pname = pname;
+   thread_data->param = param;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glPixelStorei,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glPolygonOffset(GLfloat factor, GLfloat units);
+ * void
+ * glPolygonOffset(GLfloat factor, GLfloat units);
  */
 
 typedef struct
@@ -5257,14 +5261,14 @@ void (*orig_evgl_api_glPolygonOffset)(GLfloat factor, GLfloat units);
 static void
 _evgl_api_thread_glPolygonOffset(void *data)
 {
-   EVGL_API_Thread_Command_glPolygonOffset *thread_param =
+   EVGL_API_Thread_Command_glPolygonOffset *thread_data =
       (EVGL_API_Thread_Command_glPolygonOffset *)data;
 
-   orig_evgl_api_glPolygonOffset(thread_param->factor,
-                                 thread_param->units);
+   orig_evgl_api_glPolygonOffset(thread_data->factor,
+                                 thread_data->units);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -5278,37 +5282,37 @@ glPolygonOffset_evgl_api_thread_cmd(GLfloat factor, GLfloat units)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glPolygonOffset thread_param_local;
-   EVGL_API_Thread_Command_glPolygonOffset *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glPolygonOffset thread_data_local;
+   EVGL_API_Thread_Command_glPolygonOffset *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_API_Thread_Command_glPolygonOffset *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_API_Thread_Command_glPolygonOffset));
-        if (thread_param_new)
+        EVGL_API_Thread_Command_glPolygonOffset *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_API_Thread_Command_glPolygonOffset));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->factor = factor;
-   thread_param->units = units;
+   thread_data->factor = factor;
+   thread_data->units = units;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glPolygonOffset,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void* pixels);
+ * void
+ * glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void* pixels);
  */
 
 typedef struct
@@ -5328,16 +5332,16 @@ void (*orig_evgl_api_glReadPixels)(GLint x, GLint y, GLsizei width, GLsizei heig
 static void
 _evgl_api_thread_glReadPixels(void *data)
 {
-   EVGL_API_Thread_Command_glReadPixels *thread_param =
+   EVGL_API_Thread_Command_glReadPixels *thread_data =
       (EVGL_API_Thread_Command_glReadPixels *)data;
 
-   orig_evgl_api_glReadPixels(thread_param->x,
-                              thread_param->y,
-                              thread_param->width,
-                              thread_param->height,
-                              thread_param->format,
-                              thread_param->type,
-                              thread_param->pixels);
+   orig_evgl_api_glReadPixels(thread_data->x,
+                              thread_data->y,
+                              thread_data->width,
+                              thread_data->height,
+                              thread_data->format,
+                              thread_data->type,
+                              thread_data->pixels);
 
 }
 
@@ -5352,26 +5356,26 @@ glReadPixels_evgl_api_thread_cmd(GLint x, GLint y, GLsizei width, GLsizei height
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glReadPixels thread_param_local;
-   EVGL_API_Thread_Command_glReadPixels *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glReadPixels thread_data_local;
+   EVGL_API_Thread_Command_glReadPixels *thread_data = &thread_data_local;
 
-   thread_param->x = x;
-   thread_param->y = y;
-   thread_param->width = width;
-   thread_param->height = height;
-   thread_param->format = format;
-   thread_param->type = type;
-   thread_param->pixels = pixels;
+   thread_data->x = x;
+   thread_data->y = y;
+   thread_data->width = width;
+   thread_data->height = height;
+   thread_data->format = format;
+   thread_data->type = type;
+   thread_data->pixels = pixels;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glReadPixels,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glReleaseShaderCompiler(void);
+ * void
+ * glReleaseShaderCompiler(void);
  */
 
 void (*orig_evgl_api_glReleaseShaderCompiler)(void);
@@ -5401,8 +5405,8 @@ glReleaseShaderCompiler_evgl_api_thread_cmd(void)
 }
 
 /*
-   void
-   glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height);
+ * void
+ * glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height);
  */
 
 typedef struct
@@ -5420,16 +5424,16 @@ void (*orig_evgl_api_glRenderbufferStorage)(GLenum target, GLenum internalformat
 static void
 _evgl_api_thread_glRenderbufferStorage(void *data)
 {
-   EVGL_API_Thread_Command_glRenderbufferStorage *thread_param =
+   EVGL_API_Thread_Command_glRenderbufferStorage *thread_data =
       (EVGL_API_Thread_Command_glRenderbufferStorage *)data;
 
-   orig_evgl_api_glRenderbufferStorage(thread_param->target,
-                                       thread_param->internalformat,
-                                       thread_param->width,
-                                       thread_param->height);
+   orig_evgl_api_glRenderbufferStorage(thread_data->target,
+                                       thread_data->internalformat,
+                                       thread_data->width,
+                                       thread_data->height);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -5443,39 +5447,39 @@ glRenderbufferStorage_evgl_api_thread_cmd(GLenum target, GLenum internalformat,
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glRenderbufferStorage thread_param_local;
-   EVGL_API_Thread_Command_glRenderbufferStorage *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glRenderbufferStorage thread_data_local;
+   EVGL_API_Thread_Command_glRenderbufferStorage *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_API_Thread_Command_glRenderbufferStorage *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_API_Thread_Command_glRenderbufferStorage));
-        if (thread_param_new)
+        EVGL_API_Thread_Command_glRenderbufferStorage *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_API_Thread_Command_glRenderbufferStorage));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->target = target;
-   thread_param->internalformat = internalformat;
-   thread_param->width = width;
-   thread_param->height = height;
+   thread_data->target = target;
+   thread_data->internalformat = internalformat;
+   thread_data->width = width;
+   thread_data->height = height;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glRenderbufferStorage,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glSampleCoverage(GLclampf value, GLboolean invert);
+ * void
+ * glSampleCoverage(GLclampf value, GLboolean invert);
  */
 
 typedef struct
@@ -5490,11 +5494,11 @@ void (*orig_evgl_api_glSampleCoverage)(GLclampf value, GLboolean invert);
 static void
 _evgl_api_thread_glSampleCoverage(void *data)
 {
-   EVGL_API_Thread_Command_glSampleCoverage *thread_param =
+   EVGL_API_Thread_Command_glSampleCoverage *thread_data =
       (EVGL_API_Thread_Command_glSampleCoverage *)data;
 
-   orig_evgl_api_glSampleCoverage(thread_param->value,
-                                  thread_param->invert);
+   orig_evgl_api_glSampleCoverage(thread_data->value,
+                                  thread_data->invert);
 
 }
 
@@ -5509,21 +5513,21 @@ glSampleCoverage_evgl_api_thread_cmd(GLclampf value, GLboolean invert)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glSampleCoverage thread_param_local;
-   EVGL_API_Thread_Command_glSampleCoverage *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glSampleCoverage thread_data_local;
+   EVGL_API_Thread_Command_glSampleCoverage *thread_data = &thread_data_local;
 
-   thread_param->value = value;
-   thread_param->invert = invert;
+   thread_data->value = value;
+   thread_data->invert = invert;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glSampleCoverage,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glScissor(GLint x, GLint y, GLsizei width, GLsizei height);
+ * void
+ * glScissor(GLint x, GLint y, GLsizei width, GLsizei height);
  */
 
 typedef struct
@@ -5541,16 +5545,16 @@ void (*orig_evgl_api_glScissor)(GLint x, GLint y, GLsizei width, GLsizei height)
 static void
 _evgl_api_thread_glScissor(void *data)
 {
-   EVGL_API_Thread_Command_glScissor *thread_param =
+   EVGL_API_Thread_Command_glScissor *thread_data =
       (EVGL_API_Thread_Command_glScissor *)data;
 
-   orig_evgl_api_glScissor(thread_param->x,
-                           thread_param->y,
-                           thread_param->width,
-                           thread_param->height);
+   orig_evgl_api_glScissor(thread_data->x,
+                           thread_data->y,
+                           thread_data->width,
+                           thread_data->height);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -5564,39 +5568,39 @@ glScissor_evgl_api_thread_cmd(GLint x, GLint y, GLsizei width, GLsizei height)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glScissor thread_param_local;
-   EVGL_API_Thread_Command_glScissor *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glScissor thread_data_local;
+   EVGL_API_Thread_Command_glScissor *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_API_Thread_Command_glScissor *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_API_Thread_Command_glScissor));
-        if (thread_param_new)
+        EVGL_API_Thread_Command_glScissor *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_API_Thread_Command_glScissor));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->x = x;
-   thread_param->y = y;
-   thread_param->width = width;
-   thread_param->height = height;
+   thread_data->x = x;
+   thread_data->y = y;
+   thread_data->width = width;
+   thread_data->height = height;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glScissor,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glShaderBinary(GLsizei n, const GLuint* shaders, GLenum binaryformat, const void* binary, GLsizei length);
+ * void
+ * glShaderBinary(GLsizei n, const GLuint* shaders, GLenum binaryformat, const void* binary, GLsizei length);
  */
 
 typedef struct
@@ -5614,14 +5618,14 @@ void (*orig_evgl_api_glShaderBinary)(GLsizei n, const GLuint* shaders, GLenum bi
 static void
 _evgl_api_thread_glShaderBinary(void *data)
 {
-   EVGL_API_Thread_Command_glShaderBinary *thread_param =
+   EVGL_API_Thread_Command_glShaderBinary *thread_data =
       (EVGL_API_Thread_Command_glShaderBinary *)data;
 
-   orig_evgl_api_glShaderBinary(thread_param->n,
-                                thread_param->shaders,
-                                thread_param->binaryformat,
-                                thread_param->binary,
-                                thread_param->length);
+   orig_evgl_api_glShaderBinary(thread_data->n,
+                                thread_data->shaders,
+                                thread_data->binaryformat,
+                                thread_data->binary,
+                                thread_data->length);
 
 }
 
@@ -5636,24 +5640,24 @@ glShaderBinary_evgl_api_thread_cmd(GLsizei n, const GLuint* shaders, GLenum bina
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glShaderBinary thread_param_local;
-   EVGL_API_Thread_Command_glShaderBinary *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glShaderBinary thread_data_local;
+   EVGL_API_Thread_Command_glShaderBinary *thread_data = &thread_data_local;
 
-   thread_param->n = n;
-   thread_param->shaders = shaders;
-   thread_param->binaryformat = binaryformat;
-   thread_param->binary = binary;
-   thread_param->length = length;
+   thread_data->n = n;
+   thread_data->shaders = shaders;
+   thread_data->binaryformat = binaryformat;
+   thread_data->binary = binary;
+   thread_data->length = length;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glShaderBinary,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glShaderSource(GLuint shader, GLsizei count, const char* const * string, const GLint* length);
+ * void
+ * glShaderSource(GLuint shader, GLsizei count, const char* const * string, const GLint* length);
  */
 
 typedef struct
@@ -5672,18 +5676,18 @@ void (*orig_evgl_api_glShaderSource)(GLuint shader, GLsizei count, const char* c
 static void
 _evgl_api_thread_glShaderSource(void *data)
 {
-   EVGL_API_Thread_Command_glShaderSource *thread_param =
+   EVGL_API_Thread_Command_glShaderSource *thread_data =
       (EVGL_API_Thread_Command_glShaderSource *)data;
 
-   orig_evgl_api_glShaderSource(thread_param->shader,
-                                thread_param->count,
-                                thread_param->string,
-                                thread_param->length);
+   orig_evgl_api_glShaderSource(thread_data->shader,
+                                thread_data->count,
+                                thread_data->string,
+                                thread_data->length);
 
    GLSHADERSOURCE_COPY_VARIABLE_FREE; /* TODO */
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -5697,29 +5701,29 @@ glShaderSource_evgl_api_thread_cmd(GLuint shader, GLsizei count, const char* con
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glShaderSource thread_param_local;
-   EVGL_API_Thread_Command_glShaderSource *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glShaderSource thread_data_local;
+   EVGL_API_Thread_Command_glShaderSource *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_API_Thread_Command_glShaderSource *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_API_Thread_Command_glShaderSource));
-        if (thread_param_new)
+        EVGL_API_Thread_Command_glShaderSource *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_API_Thread_Command_glShaderSource));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->shader = shader;
-   thread_param->count = count;
-   thread_param->string = string;
-   thread_param->length = length;
+   thread_data->shader = shader;
+   thread_data->count = count;
+   thread_data->string = string;
+   thread_data->length = length;
 
    GLSHADERSOURCE_COPY_VARIABLE_INIT; /* TODO */
 
@@ -5731,13 +5735,13 @@ glShaderSource_evgl_api_thread_cmd(GLuint shader, GLsizei count, const char* con
 finish:
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glShaderSource,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glStencilFunc(GLenum func, GLint ref, GLuint mask);
+ * void
+ * glStencilFunc(GLenum func, GLint ref, GLuint mask);
  */
 
 typedef struct
@@ -5753,12 +5757,12 @@ void (*orig_evgl_api_glStencilFunc)(GLenum func, GLint ref, GLuint mask);
 static void
 _evgl_api_thread_glStencilFunc(void *data)
 {
-   EVGL_API_Thread_Command_glStencilFunc *thread_param =
+   EVGL_API_Thread_Command_glStencilFunc *thread_data =
       (EVGL_API_Thread_Command_glStencilFunc *)data;
 
-   orig_evgl_api_glStencilFunc(thread_param->func,
-                               thread_param->ref,
-                               thread_param->mask);
+   orig_evgl_api_glStencilFunc(thread_data->func,
+                               thread_data->ref,
+                               thread_data->mask);
 
 }
 
@@ -5773,22 +5777,22 @@ glStencilFunc_evgl_api_thread_cmd(GLenum func, GLint ref, GLuint mask)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glStencilFunc thread_param_local;
-   EVGL_API_Thread_Command_glStencilFunc *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glStencilFunc thread_data_local;
+   EVGL_API_Thread_Command_glStencilFunc *thread_data = &thread_data_local;
 
-   thread_param->func = func;
-   thread_param->ref = ref;
-   thread_param->mask = mask;
+   thread_data->func = func;
+   thread_data->ref = ref;
+   thread_data->mask = mask;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glStencilFunc,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask);
+ * void
+ * glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask);
  */
 
 typedef struct
@@ -5805,13 +5809,13 @@ void (*orig_evgl_api_glStencilFuncSeparate)(GLenum face, GLenum func, GLint ref,
 static void
 _evgl_api_thread_glStencilFuncSeparate(void *data)
 {
-   EVGL_API_Thread_Command_glStencilFuncSeparate *thread_param =
+   EVGL_API_Thread_Command_glStencilFuncSeparate *thread_data =
       (EVGL_API_Thread_Command_glStencilFuncSeparate *)data;
 
-   orig_evgl_api_glStencilFuncSeparate(thread_param->face,
-                                       thread_param->func,
-                                       thread_param->ref,
-                                       thread_param->mask);
+   orig_evgl_api_glStencilFuncSeparate(thread_data->face,
+                                       thread_data->func,
+                                       thread_data->ref,
+                                       thread_data->mask);
 
 }
 
@@ -5826,23 +5830,23 @@ glStencilFuncSeparate_evgl_api_thread_cmd(GLenum face, GLenum func, GLint ref, G
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glStencilFuncSeparate thread_param_local;
-   EVGL_API_Thread_Command_glStencilFuncSeparate *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glStencilFuncSeparate thread_data_local;
+   EVGL_API_Thread_Command_glStencilFuncSeparate *thread_data = &thread_data_local;
 
-   thread_param->face = face;
-   thread_param->func = func;
-   thread_param->ref = ref;
-   thread_param->mask = mask;
+   thread_data->face = face;
+   thread_data->func = func;
+   thread_data->ref = ref;
+   thread_data->mask = mask;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glStencilFuncSeparate,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glStencilMask(GLuint mask);
+ * void
+ * glStencilMask(GLuint mask);
  */
 
 typedef struct
@@ -5856,10 +5860,10 @@ void (*orig_evgl_api_glStencilMask)(GLuint mask);
 static void
 _evgl_api_thread_glStencilMask(void *data)
 {
-   EVGL_API_Thread_Command_glStencilMask *thread_param =
+   EVGL_API_Thread_Command_glStencilMask *thread_data =
       (EVGL_API_Thread_Command_glStencilMask *)data;
 
-   orig_evgl_api_glStencilMask(thread_param->mask);
+   orig_evgl_api_glStencilMask(thread_data->mask);
 
 }
 
@@ -5874,20 +5878,20 @@ glStencilMask_evgl_api_thread_cmd(GLuint mask)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glStencilMask thread_param_local;
-   EVGL_API_Thread_Command_glStencilMask *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glStencilMask thread_data_local;
+   EVGL_API_Thread_Command_glStencilMask *thread_data = &thread_data_local;
 
-   thread_param->mask = mask;
+   thread_data->mask = mask;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glStencilMask,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glStencilMaskSeparate(GLenum face, GLuint mask);
+ * void
+ * glStencilMaskSeparate(GLenum face, GLuint mask);
  */
 
 typedef struct
@@ -5902,11 +5906,11 @@ void (*orig_evgl_api_glStencilMaskSeparate)(GLenum face, GLuint mask);
 static void
 _evgl_api_thread_glStencilMaskSeparate(void *data)
 {
-   EVGL_API_Thread_Command_glStencilMaskSeparate *thread_param =
+   EVGL_API_Thread_Command_glStencilMaskSeparate *thread_data =
       (EVGL_API_Thread_Command_glStencilMaskSeparate *)data;
 
-   orig_evgl_api_glStencilMaskSeparate(thread_param->face,
-                                       thread_param->mask);
+   orig_evgl_api_glStencilMaskSeparate(thread_data->face,
+                                       thread_data->mask);
 
 }
 
@@ -5921,21 +5925,21 @@ glStencilMaskSeparate_evgl_api_thread_cmd(GLenum face, GLuint mask)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glStencilMaskSeparate thread_param_local;
-   EVGL_API_Thread_Command_glStencilMaskSeparate *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glStencilMaskSeparate thread_data_local;
+   EVGL_API_Thread_Command_glStencilMaskSeparate *thread_data = &thread_data_local;
 
-   thread_param->face = face;
-   thread_param->mask = mask;
+   thread_data->face = face;
+   thread_data->mask = mask;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glStencilMaskSeparate,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glStencilOp(GLenum fail, GLenum zfail, GLenum zpass);
+ * void
+ * glStencilOp(GLenum fail, GLenum zfail, GLenum zpass);
  */
 
 typedef struct
@@ -5951,12 +5955,12 @@ void (*orig_evgl_api_glStencilOp)(GLenum fail, GLenum zfail, GLenum zpass);
 static void
 _evgl_api_thread_glStencilOp(void *data)
 {
-   EVGL_API_Thread_Command_glStencilOp *thread_param =
+   EVGL_API_Thread_Command_glStencilOp *thread_data =
       (EVGL_API_Thread_Command_glStencilOp *)data;
 
-   orig_evgl_api_glStencilOp(thread_param->fail,
-                             thread_param->zfail,
-                             thread_param->zpass);
+   orig_evgl_api_glStencilOp(thread_data->fail,
+                             thread_data->zfail,
+                             thread_data->zpass);
 
 }
 
@@ -5971,22 +5975,22 @@ glStencilOp_evgl_api_thread_cmd(GLenum fail, GLenum zfail, GLenum zpass)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glStencilOp thread_param_local;
-   EVGL_API_Thread_Command_glStencilOp *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glStencilOp thread_data_local;
+   EVGL_API_Thread_Command_glStencilOp *thread_data = &thread_data_local;
 
-   thread_param->fail = fail;
-   thread_param->zfail = zfail;
-   thread_param->zpass = zpass;
+   thread_data->fail = fail;
+   thread_data->zfail = zfail;
+   thread_data->zpass = zpass;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glStencilOp,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glStencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenum zpass);
+ * void
+ * glStencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenum zpass);
  */
 
 typedef struct
@@ -6003,13 +6007,13 @@ void (*orig_evgl_api_glStencilOpSeparate)(GLenum face, GLenum fail, GLenum zfail
 static void
 _evgl_api_thread_glStencilOpSeparate(void *data)
 {
-   EVGL_API_Thread_Command_glStencilOpSeparate *thread_param =
+   EVGL_API_Thread_Command_glStencilOpSeparate *thread_data =
       (EVGL_API_Thread_Command_glStencilOpSeparate *)data;
 
-   orig_evgl_api_glStencilOpSeparate(thread_param->face,
-                                     thread_param->fail,
-                                     thread_param->zfail,
-                                     thread_param->zpass);
+   orig_evgl_api_glStencilOpSeparate(thread_data->face,
+                                     thread_data->fail,
+                                     thread_data->zfail,
+                                     thread_data->zpass);
 
 }
 
@@ -6024,23 +6028,23 @@ glStencilOpSeparate_evgl_api_thread_cmd(GLenum face, GLenum fail, GLenum zfail,
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glStencilOpSeparate thread_param_local;
-   EVGL_API_Thread_Command_glStencilOpSeparate *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glStencilOpSeparate thread_data_local;
+   EVGL_API_Thread_Command_glStencilOpSeparate *thread_data = &thread_data_local;
 
-   thread_param->face = face;
-   thread_param->fail = fail;
-   thread_param->zfail = zfail;
-   thread_param->zpass = zpass;
+   thread_data->face = face;
+   thread_data->fail = fail;
+   thread_data->zfail = zfail;
+   thread_data->zpass = zpass;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glStencilOpSeparate,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void* pixels);
+ * void
+ * glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void* pixels);
  */
 
 typedef struct
@@ -6064,23 +6068,23 @@ void (*orig_evgl_api_glTexImage2D)(GLenum target, GLint level, GLint internalfor
 static void
 _evgl_api_thread_glTexImage2D(void *data)
 {
-   EVGL_API_Thread_Command_glTexImage2D *thread_param =
+   EVGL_API_Thread_Command_glTexImage2D *thread_data =
       (EVGL_API_Thread_Command_glTexImage2D *)data;
 
-   orig_evgl_api_glTexImage2D(thread_param->target,
-                              thread_param->level,
-                              thread_param->internalformat,
-                              thread_param->width,
-                              thread_param->height,
-                              thread_param->border,
-                              thread_param->format,
-                              thread_param->type,
-                              thread_param->pixels);
+   orig_evgl_api_glTexImage2D(thread_data->target,
+                              thread_data->level,
+                              thread_data->internalformat,
+                              thread_data->width,
+                              thread_data->height,
+                              thread_data->border,
+                              thread_data->format,
+                              thread_data->type,
+                              thread_data->pixels);
 
    GLTEXIMAGE2D_COPY_VARIABLE_FREE; /* TODO */
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -6094,34 +6098,34 @@ glTexImage2D_evgl_api_thread_cmd(GLenum target, GLint level, GLint internalforma
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glTexImage2D thread_param_local;
-   EVGL_API_Thread_Command_glTexImage2D *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glTexImage2D thread_data_local;
+   EVGL_API_Thread_Command_glTexImage2D *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_API_Thread_Command_glTexImage2D *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_API_Thread_Command_glTexImage2D));
-        if (thread_param_new)
+        EVGL_API_Thread_Command_glTexImage2D *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_API_Thread_Command_glTexImage2D));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->target = target;
-   thread_param->level = level;
-   thread_param->internalformat = internalformat;
-   thread_param->width = width;
-   thread_param->height = height;
-   thread_param->border = border;
-   thread_param->format = format;
-   thread_param->type = type;
-   thread_param->pixels = pixels;
+   thread_data->target = target;
+   thread_data->level = level;
+   thread_data->internalformat = internalformat;
+   thread_data->width = width;
+   thread_data->height = height;
+   thread_data->border = border;
+   thread_data->format = format;
+   thread_data->type = type;
+   thread_data->pixels = pixels;
 
    GLTEXIMAGE2D_COPY_VARIABLE_INIT; /* TODO */
 
@@ -6133,13 +6137,13 @@ glTexImage2D_evgl_api_thread_cmd(GLenum target, GLint level, GLint internalforma
 finish:
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glTexImage2D,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glTexParameterf(GLenum target, GLenum pname, GLfloat param);
+ * void
+ * glTexParameterf(GLenum target, GLenum pname, GLfloat param);
  */
 
 typedef struct
@@ -6156,15 +6160,15 @@ void (*orig_evgl_api_glTexParameterf)(GLenum target, GLenum pname, GLfloat param
 static void
 _evgl_api_thread_glTexParameterf(void *data)
 {
-   EVGL_API_Thread_Command_glTexParameterf *thread_param =
+   EVGL_API_Thread_Command_glTexParameterf *thread_data =
       (EVGL_API_Thread_Command_glTexParameterf *)data;
 
-   orig_evgl_api_glTexParameterf(thread_param->target,
-                                 thread_param->pname,
-                                 thread_param->param);
+   orig_evgl_api_glTexParameterf(thread_data->target,
+                                 thread_data->pname,
+                                 thread_data->param);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -6178,38 +6182,38 @@ glTexParameterf_evgl_api_thread_cmd(GLenum target, GLenum pname, GLfloat param)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glTexParameterf thread_param_local;
-   EVGL_API_Thread_Command_glTexParameterf *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glTexParameterf thread_data_local;
+   EVGL_API_Thread_Command_glTexParameterf *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_API_Thread_Command_glTexParameterf *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_API_Thread_Command_glTexParameterf));
-        if (thread_param_new)
+        EVGL_API_Thread_Command_glTexParameterf *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_API_Thread_Command_glTexParameterf));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->target = target;
-   thread_param->pname = pname;
-   thread_param->param = param;
+   thread_data->target = target;
+   thread_data->pname = pname;
+   thread_data->param = param;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glTexParameterf,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glTexParameterfv(GLenum target, GLenum pname, const GLfloat* params);
+ * void
+ * glTexParameterfv(GLenum target, GLenum pname, const GLfloat* params);
  */
 
 typedef struct
@@ -6227,19 +6231,19 @@ void (*orig_evgl_api_glTexParameterfv)(GLenum target, GLenum pname, const GLfloa
 static void
 _evgl_api_thread_glTexParameterfv(void *data)
 {
-   EVGL_API_Thread_Command_glTexParameterfv *thread_param =
+   EVGL_API_Thread_Command_glTexParameterfv *thread_data =
       (EVGL_API_Thread_Command_glTexParameterfv *)data;
 
-   orig_evgl_api_glTexParameterfv(thread_param->target,
-                                  thread_param->pname,
-                                  thread_param->params);
+   orig_evgl_api_glTexParameterfv(thread_data->target,
+                                  thread_data->pname,
+                                  thread_data->params);
 
 
-   if (thread_param->params_copied)
-     eina_mempool_free(_mp_default, thread_param->params_copied);
+   if (thread_data->params_copied)
+     eina_mempool_free(_mp_default, thread_data->params_copied);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -6253,30 +6257,30 @@ glTexParameterfv_evgl_api_thread_cmd(GLenum target, GLenum pname, const GLfloat*
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glTexParameterfv thread_param_local;
-   EVGL_API_Thread_Command_glTexParameterfv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glTexParameterfv thread_data_local;
+   EVGL_API_Thread_Command_glTexParameterfv *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_API_Thread_Command_glTexParameterfv *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_API_Thread_Command_glTexParameterfv));
-        if (thread_param_new)
+        EVGL_API_Thread_Command_glTexParameterfv *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_API_Thread_Command_glTexParameterfv));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->target = target;
-   thread_param->pname = pname;
-   thread_param->params = params;
+   thread_data->target = target;
+   thread_data->pname = pname;
+   thread_data->params = params;
 
-   thread_param->params_copied = NULL;
+   thread_data->params_copied = NULL;
    if (thread_mode == EVAS_GL_THREAD_MODE_FINISH)
      goto finish;
 
@@ -6291,10 +6295,10 @@ glTexParameterfv_evgl_api_thread_cmd(GLenum target, GLenum pname, const GLfloat*
              goto finish;
           }
         /* 2. malloc & copy */
-        thread_param->params_copied = eina_mempool_malloc(_mp_default, copy_size);
-        if (thread_param->params_copied)
+        thread_data->params_copied = eina_mempool_malloc(_mp_default, copy_size);
+        if (thread_data->params_copied)
           {
-             memcpy(thread_param->params_copied, params, copy_size);
+             memcpy(thread_data->params_copied, params, copy_size);
           }
         else
           {
@@ -6302,20 +6306,20 @@ glTexParameterfv_evgl_api_thread_cmd(GLenum target, GLenum pname, const GLfloat*
              goto finish;
           }
         /* 3. replace */
-        thread_param->params = (const GLfloat *)thread_param->params_copied;
+        thread_data->params = (const GLfloat *)thread_data->params_copied;
      }
    /* end of copy variable */
 
 finish:
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glTexParameterfv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glTexParameteri(GLenum target, GLenum pname, GLint param);
+ * void
+ * glTexParameteri(GLenum target, GLenum pname, GLint param);
  */
 
 typedef struct
@@ -6332,15 +6336,15 @@ void (*orig_evgl_api_glTexParameteri)(GLenum target, GLenum pname, GLint param);
 static void
 _evgl_api_thread_glTexParameteri(void *data)
 {
-   EVGL_API_Thread_Command_glTexParameteri *thread_param =
+   EVGL_API_Thread_Command_glTexParameteri *thread_data =
       (EVGL_API_Thread_Command_glTexParameteri *)data;
 
-   orig_evgl_api_glTexParameteri(thread_param->target,
-                                 thread_param->pname,
-                                 thread_param->param);
+   orig_evgl_api_glTexParameteri(thread_data->target,
+                                 thread_data->pname,
+                                 thread_data->param);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -6354,38 +6358,38 @@ glTexParameteri_evgl_api_thread_cmd(GLenum target, GLenum pname, GLint param)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glTexParameteri thread_param_local;
-   EVGL_API_Thread_Command_glTexParameteri *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glTexParameteri thread_data_local;
+   EVGL_API_Thread_Command_glTexParameteri *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_API_Thread_Command_glTexParameteri *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_API_Thread_Command_glTexParameteri));
-        if (thread_param_new)
+        EVGL_API_Thread_Command_glTexParameteri *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_API_Thread_Command_glTexParameteri));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->target = target;
-   thread_param->pname = pname;
-   thread_param->param = param;
+   thread_data->target = target;
+   thread_data->pname = pname;
+   thread_data->param = param;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glTexParameteri,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glTexParameteriv(GLenum target, GLenum pname, const GLint* params);
+ * void
+ * glTexParameteriv(GLenum target, GLenum pname, const GLint* params);
  */
 
 typedef struct
@@ -6403,19 +6407,19 @@ void (*orig_evgl_api_glTexParameteriv)(GLenum target, GLenum pname, const GLint*
 static void
 _evgl_api_thread_glTexParameteriv(void *data)
 {
-   EVGL_API_Thread_Command_glTexParameteriv *thread_param =
+   EVGL_API_Thread_Command_glTexParameteriv *thread_data =
       (EVGL_API_Thread_Command_glTexParameteriv *)data;
 
-   orig_evgl_api_glTexParameteriv(thread_param->target,
-                                  thread_param->pname,
-                                  thread_param->params);
+   orig_evgl_api_glTexParameteriv(thread_data->target,
+                                  thread_data->pname,
+                                  thread_data->params);
 
 
-   if (thread_param->params_copied)
-     eina_mempool_free(_mp_default, thread_param->params_copied);
+   if (thread_data->params_copied)
+     eina_mempool_free(_mp_default, thread_data->params_copied);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -6429,30 +6433,30 @@ glTexParameteriv_evgl_api_thread_cmd(GLenum target, GLenum pname, const GLint* p
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glTexParameteriv thread_param_local;
-   EVGL_API_Thread_Command_glTexParameteriv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glTexParameteriv thread_data_local;
+   EVGL_API_Thread_Command_glTexParameteriv *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_API_Thread_Command_glTexParameteriv *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_API_Thread_Command_glTexParameteriv));
-        if (thread_param_new)
+        EVGL_API_Thread_Command_glTexParameteriv *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_API_Thread_Command_glTexParameteriv));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->target = target;
-   thread_param->pname = pname;
-   thread_param->params = params;
+   thread_data->target = target;
+   thread_data->pname = pname;
+   thread_data->params = params;
 
-   thread_param->params_copied = NULL;
+   thread_data->params_copied = NULL;
    if (thread_mode == EVAS_GL_THREAD_MODE_FINISH)
      goto finish;
 
@@ -6467,10 +6471,10 @@ glTexParameteriv_evgl_api_thread_cmd(GLenum target, GLenum pname, const GLint* p
              goto finish;
           }
         /* 2. malloc & copy */
-        thread_param->params_copied = eina_mempool_malloc(_mp_default, copy_size);
-        if (thread_param->params_copied)
+        thread_data->params_copied = eina_mempool_malloc(_mp_default, copy_size);
+        if (thread_data->params_copied)
           {
-             memcpy(thread_param->params_copied, params, copy_size);
+             memcpy(thread_data->params_copied, params, copy_size);
           }
         else
           {
@@ -6478,20 +6482,20 @@ glTexParameteriv_evgl_api_thread_cmd(GLenum target, GLenum pname, const GLint* p
              goto finish;
           }
         /* 3. replace */
-        thread_param->params = (const GLint *)thread_param->params_copied;
+        thread_data->params = (const GLint *)thread_data->params_copied;
      }
    /* end of copy variable */
 
 finish:
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glTexParameteriv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void* pixels);
+ * void
+ * glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void* pixels);
  */
 
 typedef struct
@@ -6515,23 +6519,23 @@ void (*orig_evgl_api_glTexSubImage2D)(GLenum target, GLint level, GLint xoffset,
 static void
 _evgl_api_thread_glTexSubImage2D(void *data)
 {
-   EVGL_API_Thread_Command_glTexSubImage2D *thread_param =
+   EVGL_API_Thread_Command_glTexSubImage2D *thread_data =
       (EVGL_API_Thread_Command_glTexSubImage2D *)data;
 
-   orig_evgl_api_glTexSubImage2D(thread_param->target,
-                                 thread_param->level,
-                                 thread_param->xoffset,
-                                 thread_param->yoffset,
-                                 thread_param->width,
-                                 thread_param->height,
-                                 thread_param->format,
-                                 thread_param->type,
-                                 thread_param->pixels);
+   orig_evgl_api_glTexSubImage2D(thread_data->target,
+                                 thread_data->level,
+                                 thread_data->xoffset,
+                                 thread_data->yoffset,
+                                 thread_data->width,
+                                 thread_data->height,
+                                 thread_data->format,
+                                 thread_data->type,
+                                 thread_data->pixels);
 
    GLTEXSUBIMAGE2D_COPY_VARIABLE_FREE; /* TODO */
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -6545,34 +6549,34 @@ glTexSubImage2D_evgl_api_thread_cmd(GLenum target, GLint level, GLint xoffset, G
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glTexSubImage2D thread_param_local;
-   EVGL_API_Thread_Command_glTexSubImage2D *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glTexSubImage2D thread_data_local;
+   EVGL_API_Thread_Command_glTexSubImage2D *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_API_Thread_Command_glTexSubImage2D *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_API_Thread_Command_glTexSubImage2D));
-        if (thread_param_new)
+        EVGL_API_Thread_Command_glTexSubImage2D *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_API_Thread_Command_glTexSubImage2D));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->target = target;
-   thread_param->level = level;
-   thread_param->xoffset = xoffset;
-   thread_param->yoffset = yoffset;
-   thread_param->width = width;
-   thread_param->height = height;
-   thread_param->format = format;
-   thread_param->type = type;
-   thread_param->pixels = pixels;
+   thread_data->target = target;
+   thread_data->level = level;
+   thread_data->xoffset = xoffset;
+   thread_data->yoffset = yoffset;
+   thread_data->width = width;
+   thread_data->height = height;
+   thread_data->format = format;
+   thread_data->type = type;
+   thread_data->pixels = pixels;
 
    GLTEXSUBIMAGE2D_COPY_VARIABLE_INIT; /* TODO */
 
@@ -6584,13 +6588,13 @@ glTexSubImage2D_evgl_api_thread_cmd(GLenum target, GLint level, GLint xoffset, G
 finish:
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glTexSubImage2D,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glUniform1f(GLint location, GLfloat x);
+ * void
+ * glUniform1f(GLint location, GLfloat x);
  */
 
 typedef struct
@@ -6606,14 +6610,14 @@ void (*orig_evgl_api_glUniform1f)(GLint location, GLfloat x);
 static void
 _evgl_api_thread_glUniform1f(void *data)
 {
-   EVGL_API_Thread_Command_glUniform1f *thread_param =
+   EVGL_API_Thread_Command_glUniform1f *thread_data =
       (EVGL_API_Thread_Command_glUniform1f *)data;
 
-   orig_evgl_api_glUniform1f(thread_param->location,
-                             thread_param->x);
+   orig_evgl_api_glUniform1f(thread_data->location,
+                             thread_data->x);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -6627,37 +6631,37 @@ glUniform1f_evgl_api_thread_cmd(GLint location, GLfloat x)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glUniform1f thread_param_local;
-   EVGL_API_Thread_Command_glUniform1f *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glUniform1f thread_data_local;
+   EVGL_API_Thread_Command_glUniform1f *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_API_Thread_Command_glUniform1f *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_API_Thread_Command_glUniform1f));
-        if (thread_param_new)
+        EVGL_API_Thread_Command_glUniform1f *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_API_Thread_Command_glUniform1f));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->location = location;
-   thread_param->x = x;
+   thread_data->location = location;
+   thread_data->x = x;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glUniform1f,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glUniform1fv(GLint location, GLsizei count, const GLfloat* v);
+ * void
+ * glUniform1fv(GLint location, GLsizei count, const GLfloat* v);
  */
 
 typedef struct
@@ -6675,19 +6679,19 @@ void (*orig_evgl_api_glUniform1fv)(GLint location, GLsizei count, const GLfloat*
 static void
 _evgl_api_thread_glUniform1fv(void *data)
 {
-   EVGL_API_Thread_Command_glUniform1fv *thread_param =
+   EVGL_API_Thread_Command_glUniform1fv *thread_data =
       (EVGL_API_Thread_Command_glUniform1fv *)data;
 
-   orig_evgl_api_glUniform1fv(thread_param->location,
-                              thread_param->count,
-                              thread_param->v);
+   orig_evgl_api_glUniform1fv(thread_data->location,
+                              thread_data->count,
+                              thread_data->v);
 
 
-   if (thread_param->v_copied)
-     eina_mempool_free(_mp_uniform, thread_param->v_copied);
+   if (thread_data->v_copied)
+     eina_mempool_free(_mp_uniform, thread_data->v_copied);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -6701,30 +6705,30 @@ glUniform1fv_evgl_api_thread_cmd(GLint location, GLsizei count, const GLfloat* v
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glUniform1fv thread_param_local;
-   EVGL_API_Thread_Command_glUniform1fv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glUniform1fv thread_data_local;
+   EVGL_API_Thread_Command_glUniform1fv *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_API_Thread_Command_glUniform1fv *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_API_Thread_Command_glUniform1fv));
-        if (thread_param_new)
+        EVGL_API_Thread_Command_glUniform1fv *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_API_Thread_Command_glUniform1fv));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->location = location;
-   thread_param->count = count;
-   thread_param->v = v;
+   thread_data->location = location;
+   thread_data->count = count;
+   thread_data->v = v;
 
-   thread_param->v_copied = NULL;
+   thread_data->v_copied = NULL;
    if (thread_mode == EVAS_GL_THREAD_MODE_FINISH)
      goto finish;
 
@@ -6739,10 +6743,10 @@ glUniform1fv_evgl_api_thread_cmd(GLint location, GLsizei count, const GLfloat* v
              goto finish;
           }
         /* 2. malloc & copy */
-        thread_param->v_copied = eina_mempool_malloc(_mp_uniform, copy_size);
-        if (thread_param->v_copied)
+        thread_data->v_copied = eina_mempool_malloc(_mp_uniform, copy_size);
+        if (thread_data->v_copied)
           {
-             memcpy(thread_param->v_copied, v, copy_size);
+             memcpy(thread_data->v_copied, v, copy_size);
           }
         else
           {
@@ -6750,20 +6754,20 @@ glUniform1fv_evgl_api_thread_cmd(GLint location, GLsizei count, const GLfloat* v
              goto finish;
           }
         /* 3. replace */
-        thread_param->v = (const GLfloat *)thread_param->v_copied;
+        thread_data->v = (const GLfloat *)thread_data->v_copied;
      }
    /* end of copy variable */
 
 finish:
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glUniform1fv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glUniform1i(GLint location, GLint x);
+ * void
+ * glUniform1i(GLint location, GLint x);
  */
 
 typedef struct
@@ -6779,14 +6783,14 @@ void (*orig_evgl_api_glUniform1i)(GLint location, GLint x);
 static void
 _evgl_api_thread_glUniform1i(void *data)
 {
-   EVGL_API_Thread_Command_glUniform1i *thread_param =
+   EVGL_API_Thread_Command_glUniform1i *thread_data =
       (EVGL_API_Thread_Command_glUniform1i *)data;
 
-   orig_evgl_api_glUniform1i(thread_param->location,
-                             thread_param->x);
+   orig_evgl_api_glUniform1i(thread_data->location,
+                             thread_data->x);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -6800,37 +6804,37 @@ glUniform1i_evgl_api_thread_cmd(GLint location, GLint x)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glUniform1i thread_param_local;
-   EVGL_API_Thread_Command_glUniform1i *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glUniform1i thread_data_local;
+   EVGL_API_Thread_Command_glUniform1i *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_API_Thread_Command_glUniform1i *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_API_Thread_Command_glUniform1i));
-        if (thread_param_new)
+        EVGL_API_Thread_Command_glUniform1i *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_API_Thread_Command_glUniform1i));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->location = location;
-   thread_param->x = x;
+   thread_data->location = location;
+   thread_data->x = x;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glUniform1i,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glUniform1iv(GLint location, GLsizei count, const GLint* v);
+ * void
+ * glUniform1iv(GLint location, GLsizei count, const GLint* v);
  */
 
 typedef struct
@@ -6848,19 +6852,19 @@ void (*orig_evgl_api_glUniform1iv)(GLint location, GLsizei count, const GLint* v
 static void
 _evgl_api_thread_glUniform1iv(void *data)
 {
-   EVGL_API_Thread_Command_glUniform1iv *thread_param =
+   EVGL_API_Thread_Command_glUniform1iv *thread_data =
       (EVGL_API_Thread_Command_glUniform1iv *)data;
 
-   orig_evgl_api_glUniform1iv(thread_param->location,
-                              thread_param->count,
-                              thread_param->v);
+   orig_evgl_api_glUniform1iv(thread_data->location,
+                              thread_data->count,
+                              thread_data->v);
 
 
-   if (thread_param->v_copied)
-     eina_mempool_free(_mp_uniform, thread_param->v_copied);
+   if (thread_data->v_copied)
+     eina_mempool_free(_mp_uniform, thread_data->v_copied);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -6874,30 +6878,30 @@ glUniform1iv_evgl_api_thread_cmd(GLint location, GLsizei count, const GLint* v)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glUniform1iv thread_param_local;
-   EVGL_API_Thread_Command_glUniform1iv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glUniform1iv thread_data_local;
+   EVGL_API_Thread_Command_glUniform1iv *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_API_Thread_Command_glUniform1iv *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_API_Thread_Command_glUniform1iv));
-        if (thread_param_new)
+        EVGL_API_Thread_Command_glUniform1iv *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_API_Thread_Command_glUniform1iv));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->location = location;
-   thread_param->count = count;
-   thread_param->v = v;
+   thread_data->location = location;
+   thread_data->count = count;
+   thread_data->v = v;
 
-   thread_param->v_copied = NULL;
+   thread_data->v_copied = NULL;
    if (thread_mode == EVAS_GL_THREAD_MODE_FINISH)
      goto finish;
 
@@ -6912,10 +6916,10 @@ glUniform1iv_evgl_api_thread_cmd(GLint location, GLsizei count, const GLint* v)
              goto finish;
           }
         /* 2. malloc & copy */
-        thread_param->v_copied = eina_mempool_malloc(_mp_uniform, copy_size);
-        if (thread_param->v_copied)
+        thread_data->v_copied = eina_mempool_malloc(_mp_uniform, copy_size);
+        if (thread_data->v_copied)
           {
-             memcpy(thread_param->v_copied, v, copy_size);
+             memcpy(thread_data->v_copied, v, copy_size);
           }
         else
           {
@@ -6923,20 +6927,20 @@ glUniform1iv_evgl_api_thread_cmd(GLint location, GLsizei count, const GLint* v)
              goto finish;
           }
         /* 3. replace */
-        thread_param->v = (const GLint *)thread_param->v_copied;
+        thread_data->v = (const GLint *)thread_data->v_copied;
      }
    /* end of copy variable */
 
 finish:
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glUniform1iv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glUniform2f(GLint location, GLfloat x, GLfloat y);
+ * void
+ * glUniform2f(GLint location, GLfloat x, GLfloat y);
  */
 
 typedef struct
@@ -6953,15 +6957,15 @@ void (*orig_evgl_api_glUniform2f)(GLint location, GLfloat x, GLfloat y);
 static void
 _evgl_api_thread_glUniform2f(void *data)
 {
-   EVGL_API_Thread_Command_glUniform2f *thread_param =
+   EVGL_API_Thread_Command_glUniform2f *thread_data =
       (EVGL_API_Thread_Command_glUniform2f *)data;
 
-   orig_evgl_api_glUniform2f(thread_param->location,
-                             thread_param->x,
-                             thread_param->y);
+   orig_evgl_api_glUniform2f(thread_data->location,
+                             thread_data->x,
+                             thread_data->y);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -6975,38 +6979,38 @@ glUniform2f_evgl_api_thread_cmd(GLint location, GLfloat x, GLfloat y)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glUniform2f thread_param_local;
-   EVGL_API_Thread_Command_glUniform2f *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glUniform2f thread_data_local;
+   EVGL_API_Thread_Command_glUniform2f *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_API_Thread_Command_glUniform2f *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_API_Thread_Command_glUniform2f));
-        if (thread_param_new)
+        EVGL_API_Thread_Command_glUniform2f *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_API_Thread_Command_glUniform2f));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->location = location;
-   thread_param->x = x;
-   thread_param->y = y;
+   thread_data->location = location;
+   thread_data->x = x;
+   thread_data->y = y;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glUniform2f,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glUniform2fv(GLint location, GLsizei count, const GLfloat* v);
+ * void
+ * glUniform2fv(GLint location, GLsizei count, const GLfloat* v);
  */
 
 typedef struct
@@ -7024,19 +7028,19 @@ void (*orig_evgl_api_glUniform2fv)(GLint location, GLsizei count, const GLfloat*
 static void
 _evgl_api_thread_glUniform2fv(void *data)
 {
-   EVGL_API_Thread_Command_glUniform2fv *thread_param =
+   EVGL_API_Thread_Command_glUniform2fv *thread_data =
       (EVGL_API_Thread_Command_glUniform2fv *)data;
 
-   orig_evgl_api_glUniform2fv(thread_param->location,
-                              thread_param->count,
-                              thread_param->v);
+   orig_evgl_api_glUniform2fv(thread_data->location,
+                              thread_data->count,
+                              thread_data->v);
 
 
-   if (thread_param->v_copied)
-     eina_mempool_free(_mp_uniform, thread_param->v_copied);
+   if (thread_data->v_copied)
+     eina_mempool_free(_mp_uniform, thread_data->v_copied);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -7050,30 +7054,30 @@ glUniform2fv_evgl_api_thread_cmd(GLint location, GLsizei count, const GLfloat* v
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glUniform2fv thread_param_local;
-   EVGL_API_Thread_Command_glUniform2fv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glUniform2fv thread_data_local;
+   EVGL_API_Thread_Command_glUniform2fv *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_API_Thread_Command_glUniform2fv *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_API_Thread_Command_glUniform2fv));
-        if (thread_param_new)
+        EVGL_API_Thread_Command_glUniform2fv *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_API_Thread_Command_glUniform2fv));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->location = location;
-   thread_param->count = count;
-   thread_param->v = v;
+   thread_data->location = location;
+   thread_data->count = count;
+   thread_data->v = v;
 
-   thread_param->v_copied = NULL;
+   thread_data->v_copied = NULL;
    if (thread_mode == EVAS_GL_THREAD_MODE_FINISH)
      goto finish;
 
@@ -7088,10 +7092,10 @@ glUniform2fv_evgl_api_thread_cmd(GLint location, GLsizei count, const GLfloat* v
              goto finish;
           }
         /* 2. malloc & copy */
-        thread_param->v_copied = eina_mempool_malloc(_mp_uniform, copy_size);
-        if (thread_param->v_copied)
+        thread_data->v_copied = eina_mempool_malloc(_mp_uniform, copy_size);
+        if (thread_data->v_copied)
           {
-             memcpy(thread_param->v_copied, v, copy_size);
+             memcpy(thread_data->v_copied, v, copy_size);
           }
         else
           {
@@ -7099,20 +7103,20 @@ glUniform2fv_evgl_api_thread_cmd(GLint location, GLsizei count, const GLfloat* v
              goto finish;
           }
         /* 3. replace */
-        thread_param->v = (const GLfloat *)thread_param->v_copied;
+        thread_data->v = (const GLfloat *)thread_data->v_copied;
      }
    /* end of copy variable */
 
 finish:
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glUniform2fv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glUniform2i(GLint location, GLint x, GLint y);
+ * void
+ * glUniform2i(GLint location, GLint x, GLint y);
  */
 
 typedef struct
@@ -7129,15 +7133,15 @@ void (*orig_evgl_api_glUniform2i)(GLint location, GLint x, GLint y);
 static void
 _evgl_api_thread_glUniform2i(void *data)
 {
-   EVGL_API_Thread_Command_glUniform2i *thread_param =
+   EVGL_API_Thread_Command_glUniform2i *thread_data =
       (EVGL_API_Thread_Command_glUniform2i *)data;
 
-   orig_evgl_api_glUniform2i(thread_param->location,
-                             thread_param->x,
-                             thread_param->y);
+   orig_evgl_api_glUniform2i(thread_data->location,
+                             thread_data->x,
+                             thread_data->y);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -7151,38 +7155,38 @@ glUniform2i_evgl_api_thread_cmd(GLint location, GLint x, GLint y)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glUniform2i thread_param_local;
-   EVGL_API_Thread_Command_glUniform2i *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glUniform2i thread_data_local;
+   EVGL_API_Thread_Command_glUniform2i *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_API_Thread_Command_glUniform2i *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_API_Thread_Command_glUniform2i));
-        if (thread_param_new)
+        EVGL_API_Thread_Command_glUniform2i *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_API_Thread_Command_glUniform2i));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->location = location;
-   thread_param->x = x;
-   thread_param->y = y;
+   thread_data->location = location;
+   thread_data->x = x;
+   thread_data->y = y;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glUniform2i,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glUniform2iv(GLint location, GLsizei count, const GLint* v);
+ * void
+ * glUniform2iv(GLint location, GLsizei count, const GLint* v);
  */
 
 typedef struct
@@ -7200,19 +7204,19 @@ void (*orig_evgl_api_glUniform2iv)(GLint location, GLsizei count, const GLint* v
 static void
 _evgl_api_thread_glUniform2iv(void *data)
 {
-   EVGL_API_Thread_Command_glUniform2iv *thread_param =
+   EVGL_API_Thread_Command_glUniform2iv *thread_data =
       (EVGL_API_Thread_Command_glUniform2iv *)data;
 
-   orig_evgl_api_glUniform2iv(thread_param->location,
-                              thread_param->count,
-                              thread_param->v);
+   orig_evgl_api_glUniform2iv(thread_data->location,
+                              thread_data->count,
+                              thread_data->v);
 
 
-   if (thread_param->v_copied)
-     eina_mempool_free(_mp_uniform, thread_param->v_copied);
+   if (thread_data->v_copied)
+     eina_mempool_free(_mp_uniform, thread_data->v_copied);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -7226,30 +7230,30 @@ glUniform2iv_evgl_api_thread_cmd(GLint location, GLsizei count, const GLint* v)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glUniform2iv thread_param_local;
-   EVGL_API_Thread_Command_glUniform2iv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glUniform2iv thread_data_local;
+   EVGL_API_Thread_Command_glUniform2iv *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_API_Thread_Command_glUniform2iv *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_API_Thread_Command_glUniform2iv));
-        if (thread_param_new)
+        EVGL_API_Thread_Command_glUniform2iv *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_API_Thread_Command_glUniform2iv));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->location = location;
-   thread_param->count = count;
-   thread_param->v = v;
+   thread_data->location = location;
+   thread_data->count = count;
+   thread_data->v = v;
 
-   thread_param->v_copied = NULL;
+   thread_data->v_copied = NULL;
    if (thread_mode == EVAS_GL_THREAD_MODE_FINISH)
      goto finish;
 
@@ -7264,10 +7268,10 @@ glUniform2iv_evgl_api_thread_cmd(GLint location, GLsizei count, const GLint* v)
              goto finish;
           }
         /* 2. malloc & copy */
-        thread_param->v_copied = eina_mempool_malloc(_mp_uniform, copy_size);
-        if (thread_param->v_copied)
+        thread_data->v_copied = eina_mempool_malloc(_mp_uniform, copy_size);
+        if (thread_data->v_copied)
           {
-             memcpy(thread_param->v_copied, v, copy_size);
+             memcpy(thread_data->v_copied, v, copy_size);
           }
         else
           {
@@ -7275,20 +7279,20 @@ glUniform2iv_evgl_api_thread_cmd(GLint location, GLsizei count, const GLint* v)
              goto finish;
           }
         /* 3. replace */
-        thread_param->v = (const GLint *)thread_param->v_copied;
+        thread_data->v = (const GLint *)thread_data->v_copied;
      }
    /* end of copy variable */
 
 finish:
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glUniform2iv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glUniform3f(GLint location, GLfloat x, GLfloat y, GLfloat z);
+ * void
+ * glUniform3f(GLint location, GLfloat x, GLfloat y, GLfloat z);
  */
 
 typedef struct
@@ -7306,16 +7310,16 @@ void (*orig_evgl_api_glUniform3f)(GLint location, GLfloat x, GLfloat y, GLfloat
 static void
 _evgl_api_thread_glUniform3f(void *data)
 {
-   EVGL_API_Thread_Command_glUniform3f *thread_param =
+   EVGL_API_Thread_Command_glUniform3f *thread_data =
       (EVGL_API_Thread_Command_glUniform3f *)data;
 
-   orig_evgl_api_glUniform3f(thread_param->location,
-                             thread_param->x,
-                             thread_param->y,
-                             thread_param->z);
+   orig_evgl_api_glUniform3f(thread_data->location,
+                             thread_data->x,
+                             thread_data->y,
+                             thread_data->z);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -7329,39 +7333,39 @@ glUniform3f_evgl_api_thread_cmd(GLint location, GLfloat x, GLfloat y, GLfloat z)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glUniform3f thread_param_local;
-   EVGL_API_Thread_Command_glUniform3f *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glUniform3f thread_data_local;
+   EVGL_API_Thread_Command_glUniform3f *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_API_Thread_Command_glUniform3f *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_API_Thread_Command_glUniform3f));
-        if (thread_param_new)
+        EVGL_API_Thread_Command_glUniform3f *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_API_Thread_Command_glUniform3f));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->location = location;
-   thread_param->x = x;
-   thread_param->y = y;
-   thread_param->z = z;
+   thread_data->location = location;
+   thread_data->x = x;
+   thread_data->y = y;
+   thread_data->z = z;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glUniform3f,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glUniform3fv(GLint location, GLsizei count, const GLfloat* v);
+ * void
+ * glUniform3fv(GLint location, GLsizei count, const GLfloat* v);
  */
 
 typedef struct
@@ -7379,19 +7383,19 @@ void (*orig_evgl_api_glUniform3fv)(GLint location, GLsizei count, const GLfloat*
 static void
 _evgl_api_thread_glUniform3fv(void *data)
 {
-   EVGL_API_Thread_Command_glUniform3fv *thread_param =
+   EVGL_API_Thread_Command_glUniform3fv *thread_data =
       (EVGL_API_Thread_Command_glUniform3fv *)data;
 
-   orig_evgl_api_glUniform3fv(thread_param->location,
-                              thread_param->count,
-                              thread_param->v);
+   orig_evgl_api_glUniform3fv(thread_data->location,
+                              thread_data->count,
+                              thread_data->v);
 
 
-   if (thread_param->v_copied)
-     eina_mempool_free(_mp_uniform, thread_param->v_copied);
+   if (thread_data->v_copied)
+     eina_mempool_free(_mp_uniform, thread_data->v_copied);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -7405,30 +7409,30 @@ glUniform3fv_evgl_api_thread_cmd(GLint location, GLsizei count, const GLfloat* v
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glUniform3fv thread_param_local;
-   EVGL_API_Thread_Command_glUniform3fv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glUniform3fv thread_data_local;
+   EVGL_API_Thread_Command_glUniform3fv *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_API_Thread_Command_glUniform3fv *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_API_Thread_Command_glUniform3fv));
-        if (thread_param_new)
+        EVGL_API_Thread_Command_glUniform3fv *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_API_Thread_Command_glUniform3fv));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->location = location;
-   thread_param->count = count;
-   thread_param->v = v;
+   thread_data->location = location;
+   thread_data->count = count;
+   thread_data->v = v;
 
-   thread_param->v_copied = NULL;
+   thread_data->v_copied = NULL;
    if (thread_mode == EVAS_GL_THREAD_MODE_FINISH)
      goto finish;
 
@@ -7443,10 +7447,10 @@ glUniform3fv_evgl_api_thread_cmd(GLint location, GLsizei count, const GLfloat* v
              goto finish;
           }
         /* 2. malloc & copy */
-        thread_param->v_copied = eina_mempool_malloc(_mp_uniform, copy_size);
-        if (thread_param->v_copied)
+        thread_data->v_copied = eina_mempool_malloc(_mp_uniform, copy_size);
+        if (thread_data->v_copied)
           {
-             memcpy(thread_param->v_copied, v, copy_size);
+             memcpy(thread_data->v_copied, v, copy_size);
           }
         else
           {
@@ -7454,20 +7458,20 @@ glUniform3fv_evgl_api_thread_cmd(GLint location, GLsizei count, const GLfloat* v
              goto finish;
           }
         /* 3. replace */
-        thread_param->v = (const GLfloat *)thread_param->v_copied;
+        thread_data->v = (const GLfloat *)thread_data->v_copied;
      }
    /* end of copy variable */
 
 finish:
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glUniform3fv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glUniform3i(GLint location, GLint x, GLint y, GLint z);
+ * void
+ * glUniform3i(GLint location, GLint x, GLint y, GLint z);
  */
 
 typedef struct
@@ -7485,16 +7489,16 @@ void (*orig_evgl_api_glUniform3i)(GLint location, GLint x, GLint y, GLint z);
 static void
 _evgl_api_thread_glUniform3i(void *data)
 {
-   EVGL_API_Thread_Command_glUniform3i *thread_param =
+   EVGL_API_Thread_Command_glUniform3i *thread_data =
       (EVGL_API_Thread_Command_glUniform3i *)data;
 
-   orig_evgl_api_glUniform3i(thread_param->location,
-                             thread_param->x,
-                             thread_param->y,
-                             thread_param->z);
+   orig_evgl_api_glUniform3i(thread_data->location,
+                             thread_data->x,
+                             thread_data->y,
+                             thread_data->z);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -7508,39 +7512,39 @@ glUniform3i_evgl_api_thread_cmd(GLint location, GLint x, GLint y, GLint z)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glUniform3i thread_param_local;
-   EVGL_API_Thread_Command_glUniform3i *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glUniform3i thread_data_local;
+   EVGL_API_Thread_Command_glUniform3i *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_API_Thread_Command_glUniform3i *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_API_Thread_Command_glUniform3i));
-        if (thread_param_new)
+        EVGL_API_Thread_Command_glUniform3i *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_API_Thread_Command_glUniform3i));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->location = location;
-   thread_param->x = x;
-   thread_param->y = y;
-   thread_param->z = z;
+   thread_data->location = location;
+   thread_data->x = x;
+   thread_data->y = y;
+   thread_data->z = z;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glUniform3i,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glUniform3iv(GLint location, GLsizei count, const GLint* v);
+ * void
+ * glUniform3iv(GLint location, GLsizei count, const GLint* v);
  */
 
 typedef struct
@@ -7558,19 +7562,19 @@ void (*orig_evgl_api_glUniform3iv)(GLint location, GLsizei count, const GLint* v
 static void
 _evgl_api_thread_glUniform3iv(void *data)
 {
-   EVGL_API_Thread_Command_glUniform3iv *thread_param =
+   EVGL_API_Thread_Command_glUniform3iv *thread_data =
       (EVGL_API_Thread_Command_glUniform3iv *)data;
 
-   orig_evgl_api_glUniform3iv(thread_param->location,
-                              thread_param->count,
-                              thread_param->v);
+   orig_evgl_api_glUniform3iv(thread_data->location,
+                              thread_data->count,
+                              thread_data->v);
 
 
-   if (thread_param->v_copied)
-     eina_mempool_free(_mp_uniform, thread_param->v_copied);
+   if (thread_data->v_copied)
+     eina_mempool_free(_mp_uniform, thread_data->v_copied);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -7584,30 +7588,30 @@ glUniform3iv_evgl_api_thread_cmd(GLint location, GLsizei count, const GLint* v)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glUniform3iv thread_param_local;
-   EVGL_API_Thread_Command_glUniform3iv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glUniform3iv thread_data_local;
+   EVGL_API_Thread_Command_glUniform3iv *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_API_Thread_Command_glUniform3iv *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_API_Thread_Command_glUniform3iv));
-        if (thread_param_new)
+        EVGL_API_Thread_Command_glUniform3iv *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_API_Thread_Command_glUniform3iv));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->location = location;
-   thread_param->count = count;
-   thread_param->v = v;
+   thread_data->location = location;
+   thread_data->count = count;
+   thread_data->v = v;
 
-   thread_param->v_copied = NULL;
+   thread_data->v_copied = NULL;
    if (thread_mode == EVAS_GL_THREAD_MODE_FINISH)
      goto finish;
 
@@ -7622,10 +7626,10 @@ glUniform3iv_evgl_api_thread_cmd(GLint location, GLsizei count, const GLint* v)
              goto finish;
           }
         /* 2. malloc & copy */
-        thread_param->v_copied = eina_mempool_malloc(_mp_uniform, copy_size);
-        if (thread_param->v_copied)
+        thread_data->v_copied = eina_mempool_malloc(_mp_uniform, copy_size);
+        if (thread_data->v_copied)
           {
-             memcpy(thread_param->v_copied, v, copy_size);
+             memcpy(thread_data->v_copied, v, copy_size);
           }
         else
           {
@@ -7633,20 +7637,20 @@ glUniform3iv_evgl_api_thread_cmd(GLint location, GLsizei count, const GLint* v)
              goto finish;
           }
         /* 3. replace */
-        thread_param->v = (const GLint *)thread_param->v_copied;
+        thread_data->v = (const GLint *)thread_data->v_copied;
      }
    /* end of copy variable */
 
 finish:
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glUniform3iv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glUniform4f(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+ * void
+ * glUniform4f(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
  */
 
 typedef struct
@@ -7665,17 +7669,17 @@ void (*orig_evgl_api_glUniform4f)(GLint location, GLfloat x, GLfloat y, GLfloat
 static void
 _evgl_api_thread_glUniform4f(void *data)
 {
-   EVGL_API_Thread_Command_glUniform4f *thread_param =
+   EVGL_API_Thread_Command_glUniform4f *thread_data =
       (EVGL_API_Thread_Command_glUniform4f *)data;
 
-   orig_evgl_api_glUniform4f(thread_param->location,
-                             thread_param->x,
-                             thread_param->y,
-                             thread_param->z,
-                             thread_param->w);
+   orig_evgl_api_glUniform4f(thread_data->location,
+                             thread_data->x,
+                             thread_data->y,
+                             thread_data->z,
+                             thread_data->w);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -7689,40 +7693,40 @@ glUniform4f_evgl_api_thread_cmd(GLint location, GLfloat x, GLfloat y, GLfloat z,
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glUniform4f thread_param_local;
-   EVGL_API_Thread_Command_glUniform4f *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glUniform4f thread_data_local;
+   EVGL_API_Thread_Command_glUniform4f *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_API_Thread_Command_glUniform4f *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_API_Thread_Command_glUniform4f));
-        if (thread_param_new)
+        EVGL_API_Thread_Command_glUniform4f *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_API_Thread_Command_glUniform4f));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->location = location;
-   thread_param->x = x;
-   thread_param->y = y;
-   thread_param->z = z;
-   thread_param->w = w;
+   thread_data->location = location;
+   thread_data->x = x;
+   thread_data->y = y;
+   thread_data->z = z;
+   thread_data->w = w;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glUniform4f,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glUniform4fv(GLint location, GLsizei count, const GLfloat* v);
+ * void
+ * glUniform4fv(GLint location, GLsizei count, const GLfloat* v);
  */
 
 typedef struct
@@ -7740,19 +7744,19 @@ void (*orig_evgl_api_glUniform4fv)(GLint location, GLsizei count, const GLfloat*
 static void
 _evgl_api_thread_glUniform4fv(void *data)
 {
-   EVGL_API_Thread_Command_glUniform4fv *thread_param =
+   EVGL_API_Thread_Command_glUniform4fv *thread_data =
       (EVGL_API_Thread_Command_glUniform4fv *)data;
 
-   orig_evgl_api_glUniform4fv(thread_param->location,
-                              thread_param->count,
-                              thread_param->v);
+   orig_evgl_api_glUniform4fv(thread_data->location,
+                              thread_data->count,
+                              thread_data->v);
 
 
-   if (thread_param->v_copied)
-     eina_mempool_free(_mp_uniform, thread_param->v_copied);
+   if (thread_data->v_copied)
+     eina_mempool_free(_mp_uniform, thread_data->v_copied);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -7766,30 +7770,30 @@ glUniform4fv_evgl_api_thread_cmd(GLint location, GLsizei count, const GLfloat* v
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glUniform4fv thread_param_local;
-   EVGL_API_Thread_Command_glUniform4fv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glUniform4fv thread_data_local;
+   EVGL_API_Thread_Command_glUniform4fv *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_API_Thread_Command_glUniform4fv *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_API_Thread_Command_glUniform4fv));
-        if (thread_param_new)
+        EVGL_API_Thread_Command_glUniform4fv *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_API_Thread_Command_glUniform4fv));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->location = location;
-   thread_param->count = count;
-   thread_param->v = v;
+   thread_data->location = location;
+   thread_data->count = count;
+   thread_data->v = v;
 
-   thread_param->v_copied = NULL;
+   thread_data->v_copied = NULL;
    if (thread_mode == EVAS_GL_THREAD_MODE_FINISH)
      goto finish;
 
@@ -7804,10 +7808,10 @@ glUniform4fv_evgl_api_thread_cmd(GLint location, GLsizei count, const GLfloat* v
              goto finish;
           }
         /* 2. malloc & copy */
-        thread_param->v_copied = eina_mempool_malloc(_mp_uniform, copy_size);
-        if (thread_param->v_copied)
+        thread_data->v_copied = eina_mempool_malloc(_mp_uniform, copy_size);
+        if (thread_data->v_copied)
           {
-             memcpy(thread_param->v_copied, v, copy_size);
+             memcpy(thread_data->v_copied, v, copy_size);
           }
         else
           {
@@ -7815,20 +7819,20 @@ glUniform4fv_evgl_api_thread_cmd(GLint location, GLsizei count, const GLfloat* v
              goto finish;
           }
         /* 3. replace */
-        thread_param->v = (const GLfloat *)thread_param->v_copied;
+        thread_data->v = (const GLfloat *)thread_data->v_copied;
      }
    /* end of copy variable */
 
 finish:
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glUniform4fv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glUniform4i(GLint location, GLint x, GLint y, GLint z, GLint w);
+ * void
+ * glUniform4i(GLint location, GLint x, GLint y, GLint z, GLint w);
  */
 
 typedef struct
@@ -7847,17 +7851,17 @@ void (*orig_evgl_api_glUniform4i)(GLint location, GLint x, GLint y, GLint z, GLi
 static void
 _evgl_api_thread_glUniform4i(void *data)
 {
-   EVGL_API_Thread_Command_glUniform4i *thread_param =
+   EVGL_API_Thread_Command_glUniform4i *thread_data =
       (EVGL_API_Thread_Command_glUniform4i *)data;
 
-   orig_evgl_api_glUniform4i(thread_param->location,
-                             thread_param->x,
-                             thread_param->y,
-                             thread_param->z,
-                             thread_param->w);
+   orig_evgl_api_glUniform4i(thread_data->location,
+                             thread_data->x,
+                             thread_data->y,
+                             thread_data->z,
+                             thread_data->w);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -7871,40 +7875,40 @@ glUniform4i_evgl_api_thread_cmd(GLint location, GLint x, GLint y, GLint z, GLint
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glUniform4i thread_param_local;
-   EVGL_API_Thread_Command_glUniform4i *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glUniform4i thread_data_local;
+   EVGL_API_Thread_Command_glUniform4i *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_API_Thread_Command_glUniform4i *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_API_Thread_Command_glUniform4i));
-        if (thread_param_new)
+        EVGL_API_Thread_Command_glUniform4i *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_API_Thread_Command_glUniform4i));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->location = location;
-   thread_param->x = x;
-   thread_param->y = y;
-   thread_param->z = z;
-   thread_param->w = w;
+   thread_data->location = location;
+   thread_data->x = x;
+   thread_data->y = y;
+   thread_data->z = z;
+   thread_data->w = w;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glUniform4i,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glUniform4iv(GLint location, GLsizei count, const GLint* v);
+ * void
+ * glUniform4iv(GLint location, GLsizei count, const GLint* v);
  */
 
 typedef struct
@@ -7922,19 +7926,19 @@ void (*orig_evgl_api_glUniform4iv)(GLint location, GLsizei count, const GLint* v
 static void
 _evgl_api_thread_glUniform4iv(void *data)
 {
-   EVGL_API_Thread_Command_glUniform4iv *thread_param =
+   EVGL_API_Thread_Command_glUniform4iv *thread_data =
       (EVGL_API_Thread_Command_glUniform4iv *)data;
 
-   orig_evgl_api_glUniform4iv(thread_param->location,
-                              thread_param->count,
-                              thread_param->v);
+   orig_evgl_api_glUniform4iv(thread_data->location,
+                              thread_data->count,
+                              thread_data->v);
 
 
-   if (thread_param->v_copied)
-     eina_mempool_free(_mp_uniform, thread_param->v_copied);
+   if (thread_data->v_copied)
+     eina_mempool_free(_mp_uniform, thread_data->v_copied);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -7948,30 +7952,30 @@ glUniform4iv_evgl_api_thread_cmd(GLint location, GLsizei count, const GLint* v)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glUniform4iv thread_param_local;
-   EVGL_API_Thread_Command_glUniform4iv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glUniform4iv thread_data_local;
+   EVGL_API_Thread_Command_glUniform4iv *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_API_Thread_Command_glUniform4iv *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_API_Thread_Command_glUniform4iv));
-        if (thread_param_new)
+        EVGL_API_Thread_Command_glUniform4iv *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_API_Thread_Command_glUniform4iv));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->location = location;
-   thread_param->count = count;
-   thread_param->v = v;
+   thread_data->location = location;
+   thread_data->count = count;
+   thread_data->v = v;
 
-   thread_param->v_copied = NULL;
+   thread_data->v_copied = NULL;
    if (thread_mode == EVAS_GL_THREAD_MODE_FINISH)
      goto finish;
 
@@ -7986,10 +7990,10 @@ glUniform4iv_evgl_api_thread_cmd(GLint location, GLsizei count, const GLint* v)
              goto finish;
           }
         /* 2. malloc & copy */
-        thread_param->v_copied = eina_mempool_malloc(_mp_uniform, copy_size);
-        if (thread_param->v_copied)
+        thread_data->v_copied = eina_mempool_malloc(_mp_uniform, copy_size);
+        if (thread_data->v_copied)
           {
-             memcpy(thread_param->v_copied, v, copy_size);
+             memcpy(thread_data->v_copied, v, copy_size);
           }
         else
           {
@@ -7997,20 +8001,20 @@ glUniform4iv_evgl_api_thread_cmd(GLint location, GLsizei count, const GLint* v)
              goto finish;
           }
         /* 3. replace */
-        thread_param->v = (const GLint *)thread_param->v_copied;
+        thread_data->v = (const GLint *)thread_data->v_copied;
      }
    /* end of copy variable */
 
 finish:
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glUniform4iv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value);
+ * void
+ * glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value);
  */
 
 typedef struct
@@ -8029,20 +8033,20 @@ void (*orig_evgl_api_glUniformMatrix2fv)(GLint location, GLsizei count, GLboolea
 static void
 _evgl_api_thread_glUniformMatrix2fv(void *data)
 {
-   EVGL_API_Thread_Command_glUniformMatrix2fv *thread_param =
+   EVGL_API_Thread_Command_glUniformMatrix2fv *thread_data =
       (EVGL_API_Thread_Command_glUniformMatrix2fv *)data;
 
-   orig_evgl_api_glUniformMatrix2fv(thread_param->location,
-                                    thread_param->count,
-                                    thread_param->transpose,
-                                    thread_param->value);
+   orig_evgl_api_glUniformMatrix2fv(thread_data->location,
+                                    thread_data->count,
+                                    thread_data->transpose,
+                                    thread_data->value);
 
 
-   if (thread_param->value_copied)
-     eina_mempool_free(_mp_uniform, thread_param->value_copied);
+   if (thread_data->value_copied)
+     eina_mempool_free(_mp_uniform, thread_data->value_copied);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -8056,31 +8060,31 @@ glUniformMatrix2fv_evgl_api_thread_cmd(GLint location, GLsizei count, GLboolean
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glUniformMatrix2fv thread_param_local;
-   EVGL_API_Thread_Command_glUniformMatrix2fv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glUniformMatrix2fv thread_data_local;
+   EVGL_API_Thread_Command_glUniformMatrix2fv *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_API_Thread_Command_glUniformMatrix2fv *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_API_Thread_Command_glUniformMatrix2fv));
-        if (thread_param_new)
+        EVGL_API_Thread_Command_glUniformMatrix2fv *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_API_Thread_Command_glUniformMatrix2fv));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->location = location;
-   thread_param->count = count;
-   thread_param->transpose = transpose;
-   thread_param->value = value;
+   thread_data->location = location;
+   thread_data->count = count;
+   thread_data->transpose = transpose;
+   thread_data->value = value;
 
-   thread_param->value_copied = NULL;
+   thread_data->value_copied = NULL;
    if (thread_mode == EVAS_GL_THREAD_MODE_FINISH)
      goto finish;
 
@@ -8095,10 +8099,10 @@ glUniformMatrix2fv_evgl_api_thread_cmd(GLint location, GLsizei count, GLboolean
              goto finish;
           }
         /* 2. malloc & copy */
-        thread_param->value_copied = eina_mempool_malloc(_mp_uniform, copy_size);
-        if (thread_param->value_copied)
+        thread_data->value_copied = eina_mempool_malloc(_mp_uniform, copy_size);
+        if (thread_data->value_copied)
           {
-             memcpy(thread_param->value_copied, value, copy_size);
+             memcpy(thread_data->value_copied, value, copy_size);
           }
         else
           {
@@ -8106,20 +8110,20 @@ glUniformMatrix2fv_evgl_api_thread_cmd(GLint location, GLsizei count, GLboolean
              goto finish;
           }
         /* 3. replace */
-        thread_param->value = (const GLfloat *)thread_param->value_copied;
+        thread_data->value = (const GLfloat *)thread_data->value_copied;
      }
    /* end of copy variable */
 
 finish:
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glUniformMatrix2fv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value);
+ * void
+ * glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value);
  */
 
 typedef struct
@@ -8138,20 +8142,20 @@ void (*orig_evgl_api_glUniformMatrix3fv)(GLint location, GLsizei count, GLboolea
 static void
 _evgl_api_thread_glUniformMatrix3fv(void *data)
 {
-   EVGL_API_Thread_Command_glUniformMatrix3fv *thread_param =
+   EVGL_API_Thread_Command_glUniformMatrix3fv *thread_data =
       (EVGL_API_Thread_Command_glUniformMatrix3fv *)data;
 
-   orig_evgl_api_glUniformMatrix3fv(thread_param->location,
-                                    thread_param->count,
-                                    thread_param->transpose,
-                                    thread_param->value);
+   orig_evgl_api_glUniformMatrix3fv(thread_data->location,
+                                    thread_data->count,
+                                    thread_data->transpose,
+                                    thread_data->value);
 
 
-   if (thread_param->value_copied)
-     eina_mempool_free(_mp_uniform, thread_param->value_copied);
+   if (thread_data->value_copied)
+     eina_mempool_free(_mp_uniform, thread_data->value_copied);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -8165,31 +8169,31 @@ glUniformMatrix3fv_evgl_api_thread_cmd(GLint location, GLsizei count, GLboolean
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glUniformMatrix3fv thread_param_local;
-   EVGL_API_Thread_Command_glUniformMatrix3fv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glUniformMatrix3fv thread_data_local;
+   EVGL_API_Thread_Command_glUniformMatrix3fv *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_API_Thread_Command_glUniformMatrix3fv *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_API_Thread_Command_glUniformMatrix3fv));
-        if (thread_param_new)
+        EVGL_API_Thread_Command_glUniformMatrix3fv *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_API_Thread_Command_glUniformMatrix3fv));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->location = location;
-   thread_param->count = count;
-   thread_param->transpose = transpose;
-   thread_param->value = value;
+   thread_data->location = location;
+   thread_data->count = count;
+   thread_data->transpose = transpose;
+   thread_data->value = value;
 
-   thread_param->value_copied = NULL;
+   thread_data->value_copied = NULL;
    if (thread_mode == EVAS_GL_THREAD_MODE_FINISH)
      goto finish;
 
@@ -8204,10 +8208,10 @@ glUniformMatrix3fv_evgl_api_thread_cmd(GLint location, GLsizei count, GLboolean
              goto finish;
           }
         /* 2. malloc & copy */
-        thread_param->value_copied = eina_mempool_malloc(_mp_uniform, copy_size);
-        if (thread_param->value_copied)
+        thread_data->value_copied = eina_mempool_malloc(_mp_uniform, copy_size);
+        if (thread_data->value_copied)
           {
-             memcpy(thread_param->value_copied, value, copy_size);
+             memcpy(thread_data->value_copied, value, copy_size);
           }
         else
           {
@@ -8215,20 +8219,20 @@ glUniformMatrix3fv_evgl_api_thread_cmd(GLint location, GLsizei count, GLboolean
              goto finish;
           }
         /* 3. replace */
-        thread_param->value = (const GLfloat *)thread_param->value_copied;
+        thread_data->value = (const GLfloat *)thread_data->value_copied;
      }
    /* end of copy variable */
 
 finish:
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glUniformMatrix3fv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value);
+ * void
+ * glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value);
  */
 
 typedef struct
@@ -8247,20 +8251,20 @@ void (*orig_evgl_api_glUniformMatrix4fv)(GLint location, GLsizei count, GLboolea
 static void
 _evgl_api_thread_glUniformMatrix4fv(void *data)
 {
-   EVGL_API_Thread_Command_glUniformMatrix4fv *thread_param =
+   EVGL_API_Thread_Command_glUniformMatrix4fv *thread_data =
       (EVGL_API_Thread_Command_glUniformMatrix4fv *)data;
 
-   orig_evgl_api_glUniformMatrix4fv(thread_param->location,
-                                    thread_param->count,
-                                    thread_param->transpose,
-                                    thread_param->value);
+   orig_evgl_api_glUniformMatrix4fv(thread_data->location,
+                                    thread_data->count,
+                                    thread_data->transpose,
+                                    thread_data->value);
 
 
-   if (thread_param->value_copied)
-     eina_mempool_free(_mp_uniform, thread_param->value_copied);
+   if (thread_data->value_copied)
+     eina_mempool_free(_mp_uniform, thread_data->value_copied);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -8274,31 +8278,31 @@ glUniformMatrix4fv_evgl_api_thread_cmd(GLint location, GLsizei count, GLboolean
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glUniformMatrix4fv thread_param_local;
-   EVGL_API_Thread_Command_glUniformMatrix4fv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glUniformMatrix4fv thread_data_local;
+   EVGL_API_Thread_Command_glUniformMatrix4fv *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_API_Thread_Command_glUniformMatrix4fv *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_API_Thread_Command_glUniformMatrix4fv));
-        if (thread_param_new)
+        EVGL_API_Thread_Command_glUniformMatrix4fv *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_API_Thread_Command_glUniformMatrix4fv));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->location = location;
-   thread_param->count = count;
-   thread_param->transpose = transpose;
-   thread_param->value = value;
+   thread_data->location = location;
+   thread_data->count = count;
+   thread_data->transpose = transpose;
+   thread_data->value = value;
 
-   thread_param->value_copied = NULL;
+   thread_data->value_copied = NULL;
    if (thread_mode == EVAS_GL_THREAD_MODE_FINISH)
      goto finish;
 
@@ -8313,10 +8317,10 @@ glUniformMatrix4fv_evgl_api_thread_cmd(GLint location, GLsizei count, GLboolean
              goto finish;
           }
         /* 2. malloc & copy */
-        thread_param->value_copied = eina_mempool_malloc(_mp_uniform, copy_size);
-        if (thread_param->value_copied)
+        thread_data->value_copied = eina_mempool_malloc(_mp_uniform, copy_size);
+        if (thread_data->value_copied)
           {
-             memcpy(thread_param->value_copied, value, copy_size);
+             memcpy(thread_data->value_copied, value, copy_size);
           }
         else
           {
@@ -8324,20 +8328,20 @@ glUniformMatrix4fv_evgl_api_thread_cmd(GLint location, GLsizei count, GLboolean
              goto finish;
           }
         /* 3. replace */
-        thread_param->value = (const GLfloat *)thread_param->value_copied;
+        thread_data->value = (const GLfloat *)thread_data->value_copied;
      }
    /* end of copy variable */
 
 finish:
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glUniformMatrix4fv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glUseProgram(GLuint program);
+ * void
+ * glUseProgram(GLuint program);
  */
 
 typedef struct
@@ -8352,13 +8356,13 @@ void (*orig_evgl_api_glUseProgram)(GLuint program);
 static void
 _evgl_api_thread_glUseProgram(void *data)
 {
-   EVGL_API_Thread_Command_glUseProgram *thread_param =
+   EVGL_API_Thread_Command_glUseProgram *thread_data =
       (EVGL_API_Thread_Command_glUseProgram *)data;
 
-   orig_evgl_api_glUseProgram(thread_param->program);
+   orig_evgl_api_glUseProgram(thread_data->program);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -8372,36 +8376,36 @@ glUseProgram_evgl_api_thread_cmd(GLuint program)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glUseProgram thread_param_local;
-   EVGL_API_Thread_Command_glUseProgram *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glUseProgram thread_data_local;
+   EVGL_API_Thread_Command_glUseProgram *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_API_Thread_Command_glUseProgram *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_API_Thread_Command_glUseProgram));
-        if (thread_param_new)
+        EVGL_API_Thread_Command_glUseProgram *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_API_Thread_Command_glUseProgram));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->program = program;
+   thread_data->program = program;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glUseProgram,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glValidateProgram(GLuint program);
+ * void
+ * glValidateProgram(GLuint program);
  */
 
 typedef struct
@@ -8415,10 +8419,10 @@ void (*orig_evgl_api_glValidateProgram)(GLuint program);
 static void
 _evgl_api_thread_glValidateProgram(void *data)
 {
-   EVGL_API_Thread_Command_glValidateProgram *thread_param =
+   EVGL_API_Thread_Command_glValidateProgram *thread_data =
       (EVGL_API_Thread_Command_glValidateProgram *)data;
 
-   orig_evgl_api_glValidateProgram(thread_param->program);
+   orig_evgl_api_glValidateProgram(thread_data->program);
 
 }
 
@@ -8433,20 +8437,20 @@ glValidateProgram_evgl_api_thread_cmd(GLuint program)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glValidateProgram thread_param_local;
-   EVGL_API_Thread_Command_glValidateProgram *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glValidateProgram thread_data_local;
+   EVGL_API_Thread_Command_glValidateProgram *thread_data = &thread_data_local;
 
-   thread_param->program = program;
+   thread_data->program = program;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glValidateProgram,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glVertexAttrib1f(GLuint indx, GLfloat x);
+ * void
+ * glVertexAttrib1f(GLuint indx, GLfloat x);
  */
 
 typedef struct
@@ -8461,11 +8465,11 @@ void (*orig_evgl_api_glVertexAttrib1f)(GLuint indx, GLfloat x);
 static void
 _evgl_api_thread_glVertexAttrib1f(void *data)
 {
-   EVGL_API_Thread_Command_glVertexAttrib1f *thread_param =
+   EVGL_API_Thread_Command_glVertexAttrib1f *thread_data =
       (EVGL_API_Thread_Command_glVertexAttrib1f *)data;
 
-   orig_evgl_api_glVertexAttrib1f(thread_param->indx,
-                                  thread_param->x);
+   orig_evgl_api_glVertexAttrib1f(thread_data->indx,
+                                  thread_data->x);
 
 }
 
@@ -8480,21 +8484,21 @@ glVertexAttrib1f_evgl_api_thread_cmd(GLuint indx, GLfloat x)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glVertexAttrib1f thread_param_local;
-   EVGL_API_Thread_Command_glVertexAttrib1f *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glVertexAttrib1f thread_data_local;
+   EVGL_API_Thread_Command_glVertexAttrib1f *thread_data = &thread_data_local;
 
-   thread_param->indx = indx;
-   thread_param->x = x;
+   thread_data->indx = indx;
+   thread_data->x = x;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glVertexAttrib1f,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glVertexAttrib1fv(GLuint indx, const GLfloat* values);
+ * void
+ * glVertexAttrib1fv(GLuint indx, const GLfloat* values);
  */
 
 typedef struct
@@ -8509,11 +8513,11 @@ void (*orig_evgl_api_glVertexAttrib1fv)(GLuint indx, const GLfloat* values);
 static void
 _evgl_api_thread_glVertexAttrib1fv(void *data)
 {
-   EVGL_API_Thread_Command_glVertexAttrib1fv *thread_param =
+   EVGL_API_Thread_Command_glVertexAttrib1fv *thread_data =
       (EVGL_API_Thread_Command_glVertexAttrib1fv *)data;
 
-   orig_evgl_api_glVertexAttrib1fv(thread_param->indx,
-                                   thread_param->values);
+   orig_evgl_api_glVertexAttrib1fv(thread_data->indx,
+                                   thread_data->values);
 
 }
 
@@ -8528,21 +8532,21 @@ glVertexAttrib1fv_evgl_api_thread_cmd(GLuint indx, const GLfloat* values)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glVertexAttrib1fv thread_param_local;
-   EVGL_API_Thread_Command_glVertexAttrib1fv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glVertexAttrib1fv thread_data_local;
+   EVGL_API_Thread_Command_glVertexAttrib1fv *thread_data = &thread_data_local;
 
-   thread_param->indx = indx;
-   thread_param->values = values;
+   thread_data->indx = indx;
+   thread_data->values = values;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glVertexAttrib1fv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glVertexAttrib2f(GLuint indx, GLfloat x, GLfloat y);
+ * void
+ * glVertexAttrib2f(GLuint indx, GLfloat x, GLfloat y);
  */
 
 typedef struct
@@ -8558,12 +8562,12 @@ void (*orig_evgl_api_glVertexAttrib2f)(GLuint indx, GLfloat x, GLfloat y);
 static void
 _evgl_api_thread_glVertexAttrib2f(void *data)
 {
-   EVGL_API_Thread_Command_glVertexAttrib2f *thread_param =
+   EVGL_API_Thread_Command_glVertexAttrib2f *thread_data =
       (EVGL_API_Thread_Command_glVertexAttrib2f *)data;
 
-   orig_evgl_api_glVertexAttrib2f(thread_param->indx,
-                                  thread_param->x,
-                                  thread_param->y);
+   orig_evgl_api_glVertexAttrib2f(thread_data->indx,
+                                  thread_data->x,
+                                  thread_data->y);
 
 }
 
@@ -8578,22 +8582,22 @@ glVertexAttrib2f_evgl_api_thread_cmd(GLuint indx, GLfloat x, GLfloat y)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glVertexAttrib2f thread_param_local;
-   EVGL_API_Thread_Command_glVertexAttrib2f *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glVertexAttrib2f thread_data_local;
+   EVGL_API_Thread_Command_glVertexAttrib2f *thread_data = &thread_data_local;
 
-   thread_param->indx = indx;
-   thread_param->x = x;
-   thread_param->y = y;
+   thread_data->indx = indx;
+   thread_data->x = x;
+   thread_data->y = y;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glVertexAttrib2f,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glVertexAttrib2fv(GLuint indx, const GLfloat* values);
+ * void
+ * glVertexAttrib2fv(GLuint indx, const GLfloat* values);
  */
 
 typedef struct
@@ -8608,11 +8612,11 @@ void (*orig_evgl_api_glVertexAttrib2fv)(GLuint indx, const GLfloat* values);
 static void
 _evgl_api_thread_glVertexAttrib2fv(void *data)
 {
-   EVGL_API_Thread_Command_glVertexAttrib2fv *thread_param =
+   EVGL_API_Thread_Command_glVertexAttrib2fv *thread_data =
       (EVGL_API_Thread_Command_glVertexAttrib2fv *)data;
 
-   orig_evgl_api_glVertexAttrib2fv(thread_param->indx,
-                                   thread_param->values);
+   orig_evgl_api_glVertexAttrib2fv(thread_data->indx,
+                                   thread_data->values);
 
 }
 
@@ -8627,21 +8631,21 @@ glVertexAttrib2fv_evgl_api_thread_cmd(GLuint indx, const GLfloat* values)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glVertexAttrib2fv thread_param_local;
-   EVGL_API_Thread_Command_glVertexAttrib2fv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glVertexAttrib2fv thread_data_local;
+   EVGL_API_Thread_Command_glVertexAttrib2fv *thread_data = &thread_data_local;
 
-   thread_param->indx = indx;
-   thread_param->values = values;
+   thread_data->indx = indx;
+   thread_data->values = values;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glVertexAttrib2fv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glVertexAttrib3f(GLuint indx, GLfloat x, GLfloat y, GLfloat z);
+ * void
+ * glVertexAttrib3f(GLuint indx, GLfloat x, GLfloat y, GLfloat z);
  */
 
 typedef struct
@@ -8658,13 +8662,13 @@ void (*orig_evgl_api_glVertexAttrib3f)(GLuint indx, GLfloat x, GLfloat y, GLfloa
 static void
 _evgl_api_thread_glVertexAttrib3f(void *data)
 {
-   EVGL_API_Thread_Command_glVertexAttrib3f *thread_param =
+   EVGL_API_Thread_Command_glVertexAttrib3f *thread_data =
       (EVGL_API_Thread_Command_glVertexAttrib3f *)data;
 
-   orig_evgl_api_glVertexAttrib3f(thread_param->indx,
-                                  thread_param->x,
-                                  thread_param->y,
-                                  thread_param->z);
+   orig_evgl_api_glVertexAttrib3f(thread_data->indx,
+                                  thread_data->x,
+                                  thread_data->y,
+                                  thread_data->z);
 
 }
 
@@ -8679,23 +8683,23 @@ glVertexAttrib3f_evgl_api_thread_cmd(GLuint indx, GLfloat x, GLfloat y, GLfloat
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glVertexAttrib3f thread_param_local;
-   EVGL_API_Thread_Command_glVertexAttrib3f *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glVertexAttrib3f thread_data_local;
+   EVGL_API_Thread_Command_glVertexAttrib3f *thread_data = &thread_data_local;
 
-   thread_param->indx = indx;
-   thread_param->x = x;
-   thread_param->y = y;
-   thread_param->z = z;
+   thread_data->indx = indx;
+   thread_data->x = x;
+   thread_data->y = y;
+   thread_data->z = z;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glVertexAttrib3f,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glVertexAttrib3fv(GLuint indx, const GLfloat* values);
+ * void
+ * glVertexAttrib3fv(GLuint indx, const GLfloat* values);
  */
 
 typedef struct
@@ -8710,11 +8714,11 @@ void (*orig_evgl_api_glVertexAttrib3fv)(GLuint indx, const GLfloat* values);
 static void
 _evgl_api_thread_glVertexAttrib3fv(void *data)
 {
-   EVGL_API_Thread_Command_glVertexAttrib3fv *thread_param =
+   EVGL_API_Thread_Command_glVertexAttrib3fv *thread_data =
       (EVGL_API_Thread_Command_glVertexAttrib3fv *)data;
 
-   orig_evgl_api_glVertexAttrib3fv(thread_param->indx,
-                                   thread_param->values);
+   orig_evgl_api_glVertexAttrib3fv(thread_data->indx,
+                                   thread_data->values);
 
 }
 
@@ -8729,21 +8733,21 @@ glVertexAttrib3fv_evgl_api_thread_cmd(GLuint indx, const GLfloat* values)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glVertexAttrib3fv thread_param_local;
-   EVGL_API_Thread_Command_glVertexAttrib3fv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glVertexAttrib3fv thread_data_local;
+   EVGL_API_Thread_Command_glVertexAttrib3fv *thread_data = &thread_data_local;
 
-   thread_param->indx = indx;
-   thread_param->values = values;
+   thread_data->indx = indx;
+   thread_data->values = values;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glVertexAttrib3fv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glVertexAttrib4f(GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+ * void
+ * glVertexAttrib4f(GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
  */
 
 typedef struct
@@ -8761,14 +8765,14 @@ void (*orig_evgl_api_glVertexAttrib4f)(GLuint indx, GLfloat x, GLfloat y, GLfloa
 static void
 _evgl_api_thread_glVertexAttrib4f(void *data)
 {
-   EVGL_API_Thread_Command_glVertexAttrib4f *thread_param =
+   EVGL_API_Thread_Command_glVertexAttrib4f *thread_data =
       (EVGL_API_Thread_Command_glVertexAttrib4f *)data;
 
-   orig_evgl_api_glVertexAttrib4f(thread_param->indx,
-                                  thread_param->x,
-                                  thread_param->y,
-                                  thread_param->z,
-                                  thread_param->w);
+   orig_evgl_api_glVertexAttrib4f(thread_data->indx,
+                                  thread_data->x,
+                                  thread_data->y,
+                                  thread_data->z,
+                                  thread_data->w);
 
 }
 
@@ -8783,24 +8787,24 @@ glVertexAttrib4f_evgl_api_thread_cmd(GLuint indx, GLfloat x, GLfloat y, GLfloat
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glVertexAttrib4f thread_param_local;
-   EVGL_API_Thread_Command_glVertexAttrib4f *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glVertexAttrib4f thread_data_local;
+   EVGL_API_Thread_Command_glVertexAttrib4f *thread_data = &thread_data_local;
 
-   thread_param->indx = indx;
-   thread_param->x = x;
-   thread_param->y = y;
-   thread_param->z = z;
-   thread_param->w = w;
+   thread_data->indx = indx;
+   thread_data->x = x;
+   thread_data->y = y;
+   thread_data->z = z;
+   thread_data->w = w;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glVertexAttrib4f,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glVertexAttrib4fv(GLuint indx, const GLfloat* values);
+ * void
+ * glVertexAttrib4fv(GLuint indx, const GLfloat* values);
  */
 
 typedef struct
@@ -8815,11 +8819,11 @@ void (*orig_evgl_api_glVertexAttrib4fv)(GLuint indx, const GLfloat* values);
 static void
 _evgl_api_thread_glVertexAttrib4fv(void *data)
 {
-   EVGL_API_Thread_Command_glVertexAttrib4fv *thread_param =
+   EVGL_API_Thread_Command_glVertexAttrib4fv *thread_data =
       (EVGL_API_Thread_Command_glVertexAttrib4fv *)data;
 
-   orig_evgl_api_glVertexAttrib4fv(thread_param->indx,
-                                   thread_param->values);
+   orig_evgl_api_glVertexAttrib4fv(thread_data->indx,
+                                   thread_data->values);
 
 }
 
@@ -8834,21 +8838,21 @@ glVertexAttrib4fv_evgl_api_thread_cmd(GLuint indx, const GLfloat* values)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glVertexAttrib4fv thread_param_local;
-   EVGL_API_Thread_Command_glVertexAttrib4fv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glVertexAttrib4fv thread_data_local;
+   EVGL_API_Thread_Command_glVertexAttrib4fv *thread_data = &thread_data_local;
 
-   thread_param->indx = indx;
-   thread_param->values = values;
+   thread_data->indx = indx;
+   thread_data->values = values;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glVertexAttrib4fv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glVertexAttribPointer(GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void* ptr);
+ * void
+ * glVertexAttribPointer(GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void* ptr);
  */
 
 typedef struct
@@ -8867,15 +8871,15 @@ void (*orig_evgl_api_glVertexAttribPointer)(GLuint indx, GLint size, GLenum type
 static void
 _evgl_api_thread_glVertexAttribPointer(void *data)
 {
-   EVGL_API_Thread_Command_glVertexAttribPointer *thread_param =
+   EVGL_API_Thread_Command_glVertexAttribPointer *thread_data =
       (EVGL_API_Thread_Command_glVertexAttribPointer *)data;
 
-   orig_evgl_api_glVertexAttribPointer(thread_param->indx,
-                                       thread_param->size,
-                                       thread_param->type,
-                                       thread_param->normalized,
-                                       thread_param->stride,
-                                       thread_param->ptr);
+   orig_evgl_api_glVertexAttribPointer(thread_data->indx,
+                                       thread_data->size,
+                                       thread_data->type,
+                                       thread_data->normalized,
+                                       thread_data->stride,
+                                       thread_data->ptr);
 
 }
 
@@ -8890,25 +8894,25 @@ glVertexAttribPointer_evgl_api_thread_cmd(GLuint indx, GLint size, GLenum type,
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glVertexAttribPointer thread_param_local;
-   EVGL_API_Thread_Command_glVertexAttribPointer *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glVertexAttribPointer thread_data_local;
+   EVGL_API_Thread_Command_glVertexAttribPointer *thread_data = &thread_data_local;
 
-   thread_param->indx = indx;
-   thread_param->size = size;
-   thread_param->type = type;
-   thread_param->normalized = normalized;
-   thread_param->stride = stride;
-   thread_param->ptr = ptr;
+   thread_data->indx = indx;
+   thread_data->size = size;
+   thread_data->type = type;
+   thread_data->normalized = normalized;
+   thread_data->stride = stride;
+   thread_data->ptr = ptr;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glVertexAttribPointer,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glViewport(GLint x, GLint y, GLsizei width, GLsizei height);
+ * void
+ * glViewport(GLint x, GLint y, GLsizei width, GLsizei height);
  */
 
 typedef struct
@@ -8926,16 +8930,16 @@ void (*orig_evgl_api_glViewport)(GLint x, GLint y, GLsizei width, GLsizei height
 static void
 _evgl_api_thread_glViewport(void *data)
 {
-   EVGL_API_Thread_Command_glViewport *thread_param =
+   EVGL_API_Thread_Command_glViewport *thread_data =
       (EVGL_API_Thread_Command_glViewport *)data;
 
-   orig_evgl_api_glViewport(thread_param->x,
-                            thread_param->y,
-                            thread_param->width,
-                            thread_param->height);
+   orig_evgl_api_glViewport(thread_data->x,
+                            thread_data->y,
+                            thread_data->width,
+                            thread_data->height);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -8949,39 +8953,39 @@ glViewport_evgl_api_thread_cmd(GLint x, GLint y, GLsizei width, GLsizei height)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glViewport thread_param_local;
-   EVGL_API_Thread_Command_glViewport *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glViewport thread_data_local;
+   EVGL_API_Thread_Command_glViewport *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_API_Thread_Command_glViewport *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_API_Thread_Command_glViewport));
-        if (thread_param_new)
+        EVGL_API_Thread_Command_glViewport *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_API_Thread_Command_glViewport));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->x = x;
-   thread_param->y = y;
-   thread_param->width = width;
-   thread_param->height = height;
+   thread_data->x = x;
+   thread_data->y = y;
+   thread_data->width = width;
+   thread_data->height = height;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glViewport,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glEvasGLImageTargetTexture2DOES(GLenum target, EvasGLImage image);
+ * void
+ * glEvasGLImageTargetTexture2DOES(GLenum target, EvasGLImage image);
  */
 
 typedef struct
@@ -8996,11 +9000,11 @@ void (*orig_evgl_api_glEvasGLImageTargetTexture2DOES)(GLenum target, EvasGLImage
 static void
 _evgl_api_thread_glEvasGLImageTargetTexture2DOES(void *data)
 {
-   EVGL_API_Thread_Command_glEvasGLImageTargetTexture2DOES *thread_param =
+   EVGL_API_Thread_Command_glEvasGLImageTargetTexture2DOES *thread_data =
       (EVGL_API_Thread_Command_glEvasGLImageTargetTexture2DOES *)data;
 
-   orig_evgl_api_glEvasGLImageTargetTexture2DOES(thread_param->target,
-                                                 thread_param->image);
+   orig_evgl_api_glEvasGLImageTargetTexture2DOES(thread_data->target,
+                                                 thread_data->image);
 
 }
 
@@ -9015,21 +9019,21 @@ glEvasGLImageTargetTexture2DOES_evgl_api_thread_cmd(GLenum target, EvasGLImage i
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glEvasGLImageTargetTexture2DOES thread_param_local;
-   EVGL_API_Thread_Command_glEvasGLImageTargetTexture2DOES *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glEvasGLImageTargetTexture2DOES thread_data_local;
+   EVGL_API_Thread_Command_glEvasGLImageTargetTexture2DOES *thread_data = &thread_data_local;
 
-   thread_param->target = target;
-   thread_param->image = image;
+   thread_data->target = target;
+   thread_data->image = image;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glEvasGLImageTargetTexture2DOES,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glEvasGLImageTargetRenderbufferStorageOES(GLenum target, EvasGLImage image);
+ * void
+ * glEvasGLImageTargetRenderbufferStorageOES(GLenum target, EvasGLImage image);
  */
 
 typedef struct
@@ -9044,11 +9048,11 @@ void (*orig_evgl_api_glEvasGLImageTargetRenderbufferStorageOES)(GLenum target, E
 static void
 _evgl_api_thread_glEvasGLImageTargetRenderbufferStorageOES(void *data)
 {
-   EVGL_API_Thread_Command_glEvasGLImageTargetRenderbufferStorageOES *thread_param =
+   EVGL_API_Thread_Command_glEvasGLImageTargetRenderbufferStorageOES *thread_data =
       (EVGL_API_Thread_Command_glEvasGLImageTargetRenderbufferStorageOES *)data;
 
-   orig_evgl_api_glEvasGLImageTargetRenderbufferStorageOES(thread_param->target,
-                                                           thread_param->image);
+   orig_evgl_api_glEvasGLImageTargetRenderbufferStorageOES(thread_data->target,
+                                                           thread_data->image);
 
 }
 
@@ -9063,21 +9067,21 @@ glEvasGLImageTargetRenderbufferStorageOES_evgl_api_thread_cmd(GLenum target, Eva
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glEvasGLImageTargetRenderbufferStorageOES thread_param_local;
-   EVGL_API_Thread_Command_glEvasGLImageTargetRenderbufferStorageOES *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glEvasGLImageTargetRenderbufferStorageOES thread_data_local;
+   EVGL_API_Thread_Command_glEvasGLImageTargetRenderbufferStorageOES *thread_data = &thread_data_local;
 
-   thread_param->target = target;
-   thread_param->image = image;
+   thread_data->target = target;
+   thread_data->image = image;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glEvasGLImageTargetRenderbufferStorageOES,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGetProgramBinaryOES(GLuint program, GLsizei bufSize, GLsizei *length, GLenum *binaryFormat, void *binary);
+ * void
+ * glGetProgramBinaryOES(GLuint program, GLsizei bufSize, GLsizei *length, GLenum *binaryFormat, void *binary);
  */
 
 typedef struct
@@ -9095,14 +9099,14 @@ void (*orig_evgl_api_glGetProgramBinaryOES)(GLuint program, GLsizei bufSize, GLs
 static void
 _evgl_api_thread_glGetProgramBinaryOES(void *data)
 {
-   EVGL_API_Thread_Command_glGetProgramBinaryOES *thread_param =
+   EVGL_API_Thread_Command_glGetProgramBinaryOES *thread_data =
       (EVGL_API_Thread_Command_glGetProgramBinaryOES *)data;
 
-   orig_evgl_api_glGetProgramBinaryOES(thread_param->program,
-                                       thread_param->bufSize,
-                                       thread_param->length,
-                                       thread_param->binaryFormat,
-                                       thread_param->binary);
+   orig_evgl_api_glGetProgramBinaryOES(thread_data->program,
+                                       thread_data->bufSize,
+                                       thread_data->length,
+                                       thread_data->binaryFormat,
+                                       thread_data->binary);
 
 }
 
@@ -9117,24 +9121,24 @@ glGetProgramBinaryOES_evgl_api_thread_cmd(GLuint program, GLsizei bufSize, GLsiz
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGetProgramBinaryOES thread_param_local;
-   EVGL_API_Thread_Command_glGetProgramBinaryOES *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGetProgramBinaryOES thread_data_local;
+   EVGL_API_Thread_Command_glGetProgramBinaryOES *thread_data = &thread_data_local;
 
-   thread_param->program = program;
-   thread_param->bufSize = bufSize;
-   thread_param->length = length;
-   thread_param->binaryFormat = binaryFormat;
-   thread_param->binary = binary;
+   thread_data->program = program;
+   thread_data->bufSize = bufSize;
+   thread_data->length = length;
+   thread_data->binaryFormat = binaryFormat;
+   thread_data->binary = binary;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGetProgramBinaryOES,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glProgramBinaryOES(GLuint program, GLenum binaryFormat, const void *binary, GLint length);
+ * void
+ * glProgramBinaryOES(GLuint program, GLenum binaryFormat, const void *binary, GLint length);
  */
 
 typedef struct
@@ -9153,20 +9157,20 @@ void (*orig_evgl_api_glProgramBinaryOES)(GLuint program, GLenum binaryFormat, co
 static void
 _evgl_api_thread_glProgramBinaryOES(void *data)
 {
-   EVGL_API_Thread_Command_glProgramBinaryOES *thread_param =
+   EVGL_API_Thread_Command_glProgramBinaryOES *thread_data =
       (EVGL_API_Thread_Command_glProgramBinaryOES *)data;
 
-   orig_evgl_api_glProgramBinaryOES(thread_param->program,
-                                    thread_param->binaryFormat,
-                                    thread_param->binary,
-                                    thread_param->length);
+   orig_evgl_api_glProgramBinaryOES(thread_data->program,
+                                    thread_data->binaryFormat,
+                                    thread_data->binary,
+                                    thread_data->length);
 
 
-   if (thread_param->binary_copied)
-     eina_mempool_free(_mp_default, thread_param->binary_copied);
+   if (thread_data->binary_copied)
+     eina_mempool_free(_mp_default, thread_data->binary_copied);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -9180,31 +9184,31 @@ glProgramBinaryOES_evgl_api_thread_cmd(GLuint program, GLenum binaryFormat, cons
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glProgramBinaryOES thread_param_local;
-   EVGL_API_Thread_Command_glProgramBinaryOES *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glProgramBinaryOES thread_data_local;
+   EVGL_API_Thread_Command_glProgramBinaryOES *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_API_Thread_Command_glProgramBinaryOES *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_API_Thread_Command_glProgramBinaryOES));
-        if (thread_param_new)
+        EVGL_API_Thread_Command_glProgramBinaryOES *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_API_Thread_Command_glProgramBinaryOES));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->program = program;
-   thread_param->binaryFormat = binaryFormat;
-   thread_param->binary = binary;
-   thread_param->length = length;
+   thread_data->program = program;
+   thread_data->binaryFormat = binaryFormat;
+   thread_data->binary = binary;
+   thread_data->length = length;
 
-   thread_param->binary_copied = NULL;
+   thread_data->binary_copied = NULL;
    if (thread_mode == EVAS_GL_THREAD_MODE_FINISH)
      goto finish;
 
@@ -9219,10 +9223,10 @@ glProgramBinaryOES_evgl_api_thread_cmd(GLuint program, GLenum binaryFormat, cons
              goto finish;
           }
         /* 2. malloc & copy */
-        thread_param->binary_copied = eina_mempool_malloc(_mp_default, copy_size);
-        if (thread_param->binary_copied)
+        thread_data->binary_copied = eina_mempool_malloc(_mp_default, copy_size);
+        if (thread_data->binary_copied)
           {
-             memcpy(thread_param->binary_copied, binary, copy_size);
+             memcpy(thread_data->binary_copied, binary, copy_size);
           }
         else
           {
@@ -9230,20 +9234,20 @@ glProgramBinaryOES_evgl_api_thread_cmd(GLuint program, GLenum binaryFormat, cons
              goto finish;
           }
         /* 3. replace */
-        thread_param->binary = (const void  *)thread_param->binary_copied;
+        thread_data->binary = (const void  *)thread_data->binary_copied;
      }
    /* end of copy variable */
 
 finish:
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glProgramBinaryOES,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void *
-   glMapBufferOES(GLenum target, GLenum access);
+ * void *
+ * glMapBufferOES(GLenum target, GLenum access);
  */
 
 typedef struct
@@ -9259,11 +9263,11 @@ void * (*orig_evgl_api_glMapBufferOES)(GLenum target, GLenum access);
 static void
 _evgl_api_thread_glMapBufferOES(void *data)
 {
-   EVGL_API_Thread_Command_glMapBufferOES *thread_param =
+   EVGL_API_Thread_Command_glMapBufferOES *thread_data =
       (EVGL_API_Thread_Command_glMapBufferOES *)data;
 
-   thread_param->return_value = orig_evgl_api_glMapBufferOES(thread_param->target,
-                                                             thread_param->access);
+   thread_data->return_value = orig_evgl_api_glMapBufferOES(thread_data->target,
+                                                            thread_data->access);
 
 }
 
@@ -9277,23 +9281,23 @@ glMapBufferOES_evgl_api_thread_cmd(GLenum target, GLenum access)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glMapBufferOES thread_param_local;
-   EVGL_API_Thread_Command_glMapBufferOES *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glMapBufferOES thread_data_local;
+   EVGL_API_Thread_Command_glMapBufferOES *thread_data = &thread_data_local;
 
-   thread_param->target = target;
-   thread_param->access = access;
+   thread_data->target = target;
+   thread_data->access = access;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glMapBufferOES,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
-   GLboolean
-   glUnmapBufferOES(GLenum target);
+ * GLboolean
+ * glUnmapBufferOES(GLenum target);
  */
 
 typedef struct
@@ -9308,10 +9312,10 @@ GLboolean (*orig_evgl_api_glUnmapBufferOES)(GLenum target);
 static void
 _evgl_api_thread_glUnmapBufferOES(void *data)
 {
-   EVGL_API_Thread_Command_glUnmapBufferOES *thread_param =
+   EVGL_API_Thread_Command_glUnmapBufferOES *thread_data =
       (EVGL_API_Thread_Command_glUnmapBufferOES *)data;
 
-   thread_param->return_value = orig_evgl_api_glUnmapBufferOES(thread_param->target);
+   thread_data->return_value = orig_evgl_api_glUnmapBufferOES(thread_data->target);
 
 }
 
@@ -9325,22 +9329,22 @@ glUnmapBufferOES_evgl_api_thread_cmd(GLenum target)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glUnmapBufferOES thread_param_local;
-   EVGL_API_Thread_Command_glUnmapBufferOES *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glUnmapBufferOES thread_data_local;
+   EVGL_API_Thread_Command_glUnmapBufferOES *thread_data = &thread_data_local;
 
-   thread_param->target = target;
+   thread_data->target = target;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glUnmapBufferOES,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
-   void
-   glGetBufferPointervOES(GLenum target, GLenum pname, void** params);
+ * void
+ * glGetBufferPointervOES(GLenum target, GLenum pname, void** params);
  */
 
 typedef struct
@@ -9356,12 +9360,12 @@ void (*orig_evgl_api_glGetBufferPointervOES)(GLenum target, GLenum pname, void**
 static void
 _evgl_api_thread_glGetBufferPointervOES(void *data)
 {
-   EVGL_API_Thread_Command_glGetBufferPointervOES *thread_param =
+   EVGL_API_Thread_Command_glGetBufferPointervOES *thread_data =
       (EVGL_API_Thread_Command_glGetBufferPointervOES *)data;
 
-   orig_evgl_api_glGetBufferPointervOES(thread_param->target,
-                                        thread_param->pname,
-                                        thread_param->params);
+   orig_evgl_api_glGetBufferPointervOES(thread_data->target,
+                                        thread_data->pname,
+                                        thread_data->params);
 
 }
 
@@ -9376,22 +9380,22 @@ glGetBufferPointervOES_evgl_api_thread_cmd(GLenum target, GLenum pname, void** p
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGetBufferPointervOES thread_param_local;
-   EVGL_API_Thread_Command_glGetBufferPointervOES *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGetBufferPointervOES thread_data_local;
+   EVGL_API_Thread_Command_glGetBufferPointervOES *thread_data = &thread_data_local;
 
-   thread_param->target = target;
-   thread_param->pname = pname;
-   thread_param->params = params;
+   thread_data->target = target;
+   thread_data->pname = pname;
+   thread_data->params = params;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGetBufferPointervOES,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glTexImage3DOES(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void* pixels);
+ * void
+ * glTexImage3DOES(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void* pixels);
  */
 
 typedef struct
@@ -9414,19 +9418,19 @@ void (*orig_evgl_api_glTexImage3DOES)(GLenum target, GLint level, GLenum interna
 static void
 _evgl_api_thread_glTexImage3DOES(void *data)
 {
-   EVGL_API_Thread_Command_glTexImage3DOES *thread_param =
+   EVGL_API_Thread_Command_glTexImage3DOES *thread_data =
       (EVGL_API_Thread_Command_glTexImage3DOES *)data;
 
-   orig_evgl_api_glTexImage3DOES(thread_param->target,
-                                 thread_param->level,
-                                 thread_param->internalformat,
-                                 thread_param->width,
-                                 thread_param->height,
-                                 thread_param->depth,
-                                 thread_param->border,
-                                 thread_param->format,
-                                 thread_param->type,
-                                 thread_param->pixels);
+   orig_evgl_api_glTexImage3DOES(thread_data->target,
+                                 thread_data->level,
+                                 thread_data->internalformat,
+                                 thread_data->width,
+                                 thread_data->height,
+                                 thread_data->depth,
+                                 thread_data->border,
+                                 thread_data->format,
+                                 thread_data->type,
+                                 thread_data->pixels);
 
 }
 
@@ -9441,29 +9445,29 @@ glTexImage3DOES_evgl_api_thread_cmd(GLenum target, GLint level, GLenum internalf
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glTexImage3DOES thread_param_local;
-   EVGL_API_Thread_Command_glTexImage3DOES *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glTexImage3DOES thread_data_local;
+   EVGL_API_Thread_Command_glTexImage3DOES *thread_data = &thread_data_local;
 
-   thread_param->target = target;
-   thread_param->level = level;
-   thread_param->internalformat = internalformat;
-   thread_param->width = width;
-   thread_param->height = height;
-   thread_param->depth = depth;
-   thread_param->border = border;
-   thread_param->format = format;
-   thread_param->type = type;
-   thread_param->pixels = pixels;
+   thread_data->target = target;
+   thread_data->level = level;
+   thread_data->internalformat = internalformat;
+   thread_data->width = width;
+   thread_data->height = height;
+   thread_data->depth = depth;
+   thread_data->border = border;
+   thread_data->format = format;
+   thread_data->type = type;
+   thread_data->pixels = pixels;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glTexImage3DOES,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glTexSubImage3DOES(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void* pixels);
+ * void
+ * glTexSubImage3DOES(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void* pixels);
  */
 
 typedef struct
@@ -9487,20 +9491,20 @@ void (*orig_evgl_api_glTexSubImage3DOES)(GLenum target, GLint level, GLint xoffs
 static void
 _evgl_api_thread_glTexSubImage3DOES(void *data)
 {
-   EVGL_API_Thread_Command_glTexSubImage3DOES *thread_param =
+   EVGL_API_Thread_Command_glTexSubImage3DOES *thread_data =
       (EVGL_API_Thread_Command_glTexSubImage3DOES *)data;
 
-   orig_evgl_api_glTexSubImage3DOES(thread_param->target,
-                                    thread_param->level,
-                                    thread_param->xoffset,
-                                    thread_param->yoffset,
-                                    thread_param->zoffset,
-                                    thread_param->width,
-                                    thread_param->height,
-                                    thread_param->depth,
-                                    thread_param->format,
-                                    thread_param->type,
-                                    thread_param->pixels);
+   orig_evgl_api_glTexSubImage3DOES(thread_data->target,
+                                    thread_data->level,
+                                    thread_data->xoffset,
+                                    thread_data->yoffset,
+                                    thread_data->zoffset,
+                                    thread_data->width,
+                                    thread_data->height,
+                                    thread_data->depth,
+                                    thread_data->format,
+                                    thread_data->type,
+                                    thread_data->pixels);
 
 }
 
@@ -9515,30 +9519,30 @@ glTexSubImage3DOES_evgl_api_thread_cmd(GLenum target, GLint level, GLint xoffset
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glTexSubImage3DOES thread_param_local;
-   EVGL_API_Thread_Command_glTexSubImage3DOES *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glTexSubImage3DOES thread_data_local;
+   EVGL_API_Thread_Command_glTexSubImage3DOES *thread_data = &thread_data_local;
 
-   thread_param->target = target;
-   thread_param->level = level;
-   thread_param->xoffset = xoffset;
-   thread_param->yoffset = yoffset;
-   thread_param->zoffset = zoffset;
-   thread_param->width = width;
-   thread_param->height = height;
-   thread_param->depth = depth;
-   thread_param->format = format;
-   thread_param->type = type;
-   thread_param->pixels = pixels;
+   thread_data->target = target;
+   thread_data->level = level;
+   thread_data->xoffset = xoffset;
+   thread_data->yoffset = yoffset;
+   thread_data->zoffset = zoffset;
+   thread_data->width = width;
+   thread_data->height = height;
+   thread_data->depth = depth;
+   thread_data->format = format;
+   thread_data->type = type;
+   thread_data->pixels = pixels;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glTexSubImage3DOES,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glCopyTexSubImage3DOES(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height);
+ * void
+ * glCopyTexSubImage3DOES(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height);
  */
 
 typedef struct
@@ -9560,18 +9564,18 @@ void (*orig_evgl_api_glCopyTexSubImage3DOES)(GLenum target, GLint level, GLint x
 static void
 _evgl_api_thread_glCopyTexSubImage3DOES(void *data)
 {
-   EVGL_API_Thread_Command_glCopyTexSubImage3DOES *thread_param =
+   EVGL_API_Thread_Command_glCopyTexSubImage3DOES *thread_data =
       (EVGL_API_Thread_Command_glCopyTexSubImage3DOES *)data;
 
-   orig_evgl_api_glCopyTexSubImage3DOES(thread_param->target,
-                                        thread_param->level,
-                                        thread_param->xoffset,
-                                        thread_param->yoffset,
-                                        thread_param->zoffset,
-                                        thread_param->x,
-                                        thread_param->y,
-                                        thread_param->width,
-                                        thread_param->height);
+   orig_evgl_api_glCopyTexSubImage3DOES(thread_data->target,
+                                        thread_data->level,
+                                        thread_data->xoffset,
+                                        thread_data->yoffset,
+                                        thread_data->zoffset,
+                                        thread_data->x,
+                                        thread_data->y,
+                                        thread_data->width,
+                                        thread_data->height);
 
 }
 
@@ -9586,28 +9590,28 @@ glCopyTexSubImage3DOES_evgl_api_thread_cmd(GLenum target, GLint level, GLint xof
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glCopyTexSubImage3DOES thread_param_local;
-   EVGL_API_Thread_Command_glCopyTexSubImage3DOES *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glCopyTexSubImage3DOES thread_data_local;
+   EVGL_API_Thread_Command_glCopyTexSubImage3DOES *thread_data = &thread_data_local;
 
-   thread_param->target = target;
-   thread_param->level = level;
-   thread_param->xoffset = xoffset;
-   thread_param->yoffset = yoffset;
-   thread_param->zoffset = zoffset;
-   thread_param->x = x;
-   thread_param->y = y;
-   thread_param->width = width;
-   thread_param->height = height;
+   thread_data->target = target;
+   thread_data->level = level;
+   thread_data->xoffset = xoffset;
+   thread_data->yoffset = yoffset;
+   thread_data->zoffset = zoffset;
+   thread_data->x = x;
+   thread_data->y = y;
+   thread_data->width = width;
+   thread_data->height = height;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glCopyTexSubImage3DOES,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glCompressedTexImage3DOES(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void* data);
+ * void
+ * glCompressedTexImage3DOES(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void* data);
  */
 
 typedef struct
@@ -9629,18 +9633,18 @@ void (*orig_evgl_api_glCompressedTexImage3DOES)(GLenum target, GLint level, GLen
 static void
 _evgl_api_thread_glCompressedTexImage3DOES(void *data)
 {
-   EVGL_API_Thread_Command_glCompressedTexImage3DOES *thread_param =
+   EVGL_API_Thread_Command_glCompressedTexImage3DOES *thread_data =
       (EVGL_API_Thread_Command_glCompressedTexImage3DOES *)data;
 
-   orig_evgl_api_glCompressedTexImage3DOES(thread_param->target,
-                                           thread_param->level,
-                                           thread_param->internalformat,
-                                           thread_param->width,
-                                           thread_param->height,
-                                           thread_param->depth,
-                                           thread_param->border,
-                                           thread_param->imageSize,
-                                           thread_param->data);
+   orig_evgl_api_glCompressedTexImage3DOES(thread_data->target,
+                                           thread_data->level,
+                                           thread_data->internalformat,
+                                           thread_data->width,
+                                           thread_data->height,
+                                           thread_data->depth,
+                                           thread_data->border,
+                                           thread_data->imageSize,
+                                           thread_data->data);
 
 }
 
@@ -9655,28 +9659,28 @@ glCompressedTexImage3DOES_evgl_api_thread_cmd(GLenum target, GLint level, GLenum
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glCompressedTexImage3DOES thread_param_local;
-   EVGL_API_Thread_Command_glCompressedTexImage3DOES *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glCompressedTexImage3DOES thread_data_local;
+   EVGL_API_Thread_Command_glCompressedTexImage3DOES *thread_data = &thread_data_local;
 
-   thread_param->target = target;
-   thread_param->level = level;
-   thread_param->internalformat = internalformat;
-   thread_param->width = width;
-   thread_param->height = height;
-   thread_param->depth = depth;
-   thread_param->border = border;
-   thread_param->imageSize = imageSize;
-   thread_param->data = data;
+   thread_data->target = target;
+   thread_data->level = level;
+   thread_data->internalformat = internalformat;
+   thread_data->width = width;
+   thread_data->height = height;
+   thread_data->depth = depth;
+   thread_data->border = border;
+   thread_data->imageSize = imageSize;
+   thread_data->data = data;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glCompressedTexImage3DOES,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glCompressedTexSubImage3DOES(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void* data);
+ * void
+ * glCompressedTexSubImage3DOES(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void* data);
  */
 
 typedef struct
@@ -9700,20 +9704,20 @@ void (*orig_evgl_api_glCompressedTexSubImage3DOES)(GLenum target, GLint level, G
 static void
 _evgl_api_thread_glCompressedTexSubImage3DOES(void *data)
 {
-   EVGL_API_Thread_Command_glCompressedTexSubImage3DOES *thread_param =
+   EVGL_API_Thread_Command_glCompressedTexSubImage3DOES *thread_data =
       (EVGL_API_Thread_Command_glCompressedTexSubImage3DOES *)data;
 
-   orig_evgl_api_glCompressedTexSubImage3DOES(thread_param->target,
-                                              thread_param->level,
-                                              thread_param->xoffset,
-                                              thread_param->yoffset,
-                                              thread_param->zoffset,
-                                              thread_param->width,
-                                              thread_param->height,
-                                              thread_param->depth,
-                                              thread_param->format,
-                                              thread_param->imageSize,
-                                              thread_param->data);
+   orig_evgl_api_glCompressedTexSubImage3DOES(thread_data->target,
+                                              thread_data->level,
+                                              thread_data->xoffset,
+                                              thread_data->yoffset,
+                                              thread_data->zoffset,
+                                              thread_data->width,
+                                              thread_data->height,
+                                              thread_data->depth,
+                                              thread_data->format,
+                                              thread_data->imageSize,
+                                              thread_data->data);
 
 }
 
@@ -9728,30 +9732,30 @@ glCompressedTexSubImage3DOES_evgl_api_thread_cmd(GLenum target, GLint level, GLi
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glCompressedTexSubImage3DOES thread_param_local;
-   EVGL_API_Thread_Command_glCompressedTexSubImage3DOES *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glCompressedTexSubImage3DOES thread_data_local;
+   EVGL_API_Thread_Command_glCompressedTexSubImage3DOES *thread_data = &thread_data_local;
 
-   thread_param->target = target;
-   thread_param->level = level;
-   thread_param->xoffset = xoffset;
-   thread_param->yoffset = yoffset;
-   thread_param->zoffset = zoffset;
-   thread_param->width = width;
-   thread_param->height = height;
-   thread_param->depth = depth;
-   thread_param->format = format;
-   thread_param->imageSize = imageSize;
-   thread_param->data = data;
+   thread_data->target = target;
+   thread_data->level = level;
+   thread_data->xoffset = xoffset;
+   thread_data->yoffset = yoffset;
+   thread_data->zoffset = zoffset;
+   thread_data->width = width;
+   thread_data->height = height;
+   thread_data->depth = depth;
+   thread_data->format = format;
+   thread_data->imageSize = imageSize;
+   thread_data->data = data;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glCompressedTexSubImage3DOES,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glFramebufferTexture3DOES(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset);
+ * void
+ * glFramebufferTexture3DOES(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset);
  */
 
 typedef struct
@@ -9770,15 +9774,15 @@ void (*orig_evgl_api_glFramebufferTexture3DOES)(GLenum target, GLenum attachment
 static void
 _evgl_api_thread_glFramebufferTexture3DOES(void *data)
 {
-   EVGL_API_Thread_Command_glFramebufferTexture3DOES *thread_param =
+   EVGL_API_Thread_Command_glFramebufferTexture3DOES *thread_data =
       (EVGL_API_Thread_Command_glFramebufferTexture3DOES *)data;
 
-   orig_evgl_api_glFramebufferTexture3DOES(thread_param->target,
-                                           thread_param->attachment,
-                                           thread_param->textarget,
-                                           thread_param->texture,
-                                           thread_param->level,
-                                           thread_param->zoffset);
+   orig_evgl_api_glFramebufferTexture3DOES(thread_data->target,
+                                           thread_data->attachment,
+                                           thread_data->textarget,
+                                           thread_data->texture,
+                                           thread_data->level,
+                                           thread_data->zoffset);
 
 }
 
@@ -9793,25 +9797,25 @@ glFramebufferTexture3DOES_evgl_api_thread_cmd(GLenum target, GLenum attachment,
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glFramebufferTexture3DOES thread_param_local;
-   EVGL_API_Thread_Command_glFramebufferTexture3DOES *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glFramebufferTexture3DOES thread_data_local;
+   EVGL_API_Thread_Command_glFramebufferTexture3DOES *thread_data = &thread_data_local;
 
-   thread_param->target = target;
-   thread_param->attachment = attachment;
-   thread_param->textarget = textarget;
-   thread_param->texture = texture;
-   thread_param->level = level;
-   thread_param->zoffset = zoffset;
+   thread_data->target = target;
+   thread_data->attachment = attachment;
+   thread_data->textarget = textarget;
+   thread_data->texture = texture;
+   thread_data->level = level;
+   thread_data->zoffset = zoffset;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glFramebufferTexture3DOES,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGetPerfMonitorGroupsAMD(GLint* numGroups, GLsizei groupsSize, GLuint* groups);
+ * void
+ * glGetPerfMonitorGroupsAMD(GLint* numGroups, GLsizei groupsSize, GLuint* groups);
  */
 
 typedef struct
@@ -9827,12 +9831,12 @@ void (*orig_evgl_api_glGetPerfMonitorGroupsAMD)(GLint* numGroups, GLsizei groups
 static void
 _evgl_api_thread_glGetPerfMonitorGroupsAMD(void *data)
 {
-   EVGL_API_Thread_Command_glGetPerfMonitorGroupsAMD *thread_param =
+   EVGL_API_Thread_Command_glGetPerfMonitorGroupsAMD *thread_data =
       (EVGL_API_Thread_Command_glGetPerfMonitorGroupsAMD *)data;
 
-   orig_evgl_api_glGetPerfMonitorGroupsAMD(thread_param->numGroups,
-                                           thread_param->groupsSize,
-                                           thread_param->groups);
+   orig_evgl_api_glGetPerfMonitorGroupsAMD(thread_data->numGroups,
+                                           thread_data->groupsSize,
+                                           thread_data->groups);
 
 }
 
@@ -9847,22 +9851,22 @@ glGetPerfMonitorGroupsAMD_evgl_api_thread_cmd(GLint* numGroups, GLsizei groupsSi
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGetPerfMonitorGroupsAMD thread_param_local;
-   EVGL_API_Thread_Command_glGetPerfMonitorGroupsAMD *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGetPerfMonitorGroupsAMD thread_data_local;
+   EVGL_API_Thread_Command_glGetPerfMonitorGroupsAMD *thread_data = &thread_data_local;
 
-   thread_param->numGroups = numGroups;
-   thread_param->groupsSize = groupsSize;
-   thread_param->groups = groups;
+   thread_data->numGroups = numGroups;
+   thread_data->groupsSize = groupsSize;
+   thread_data->groups = groups;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGetPerfMonitorGroupsAMD,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGetPerfMonitorCountersAMD(GLuint group, GLint* numCounters, GLint* maxActiveCounters, GLsizei counterSize, GLuint* counters);
+ * void
+ * glGetPerfMonitorCountersAMD(GLuint group, GLint* numCounters, GLint* maxActiveCounters, GLsizei counterSize, GLuint* counters);
  */
 
 typedef struct
@@ -9880,14 +9884,14 @@ void (*orig_evgl_api_glGetPerfMonitorCountersAMD)(GLuint group, GLint* numCounte
 static void
 _evgl_api_thread_glGetPerfMonitorCountersAMD(void *data)
 {
-   EVGL_API_Thread_Command_glGetPerfMonitorCountersAMD *thread_param =
+   EVGL_API_Thread_Command_glGetPerfMonitorCountersAMD *thread_data =
       (EVGL_API_Thread_Command_glGetPerfMonitorCountersAMD *)data;
 
-   orig_evgl_api_glGetPerfMonitorCountersAMD(thread_param->group,
-                                             thread_param->numCounters,
-                                             thread_param->maxActiveCounters,
-                                             thread_param->counterSize,
-                                             thread_param->counters);
+   orig_evgl_api_glGetPerfMonitorCountersAMD(thread_data->group,
+                                             thread_data->numCounters,
+                                             thread_data->maxActiveCounters,
+                                             thread_data->counterSize,
+                                             thread_data->counters);
 
 }
 
@@ -9902,24 +9906,24 @@ glGetPerfMonitorCountersAMD_evgl_api_thread_cmd(GLuint group, GLint* numCounters
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGetPerfMonitorCountersAMD thread_param_local;
-   EVGL_API_Thread_Command_glGetPerfMonitorCountersAMD *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGetPerfMonitorCountersAMD thread_data_local;
+   EVGL_API_Thread_Command_glGetPerfMonitorCountersAMD *thread_data = &thread_data_local;
 
-   thread_param->group = group;
-   thread_param->numCounters = numCounters;
-   thread_param->maxActiveCounters = maxActiveCounters;
-   thread_param->counterSize = counterSize;
-   thread_param->counters = counters;
+   thread_data->group = group;
+   thread_data->numCounters = numCounters;
+   thread_data->maxActiveCounters = maxActiveCounters;
+   thread_data->counterSize = counterSize;
+   thread_data->counters = counters;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGetPerfMonitorCountersAMD,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGetPerfMonitorGroupStringAMD(GLuint group, GLsizei bufSize, GLsizei* length, char* groupString);
+ * void
+ * glGetPerfMonitorGroupStringAMD(GLuint group, GLsizei bufSize, GLsizei* length, char* groupString);
  */
 
 typedef struct
@@ -9936,13 +9940,13 @@ void (*orig_evgl_api_glGetPerfMonitorGroupStringAMD)(GLuint group, GLsizei bufSi
 static void
 _evgl_api_thread_glGetPerfMonitorGroupStringAMD(void *data)
 {
-   EVGL_API_Thread_Command_glGetPerfMonitorGroupStringAMD *thread_param =
+   EVGL_API_Thread_Command_glGetPerfMonitorGroupStringAMD *thread_data =
       (EVGL_API_Thread_Command_glGetPerfMonitorGroupStringAMD *)data;
 
-   orig_evgl_api_glGetPerfMonitorGroupStringAMD(thread_param->group,
-                                                thread_param->bufSize,
-                                                thread_param->length,
-                                                thread_param->groupString);
+   orig_evgl_api_glGetPerfMonitorGroupStringAMD(thread_data->group,
+                                                thread_data->bufSize,
+                                                thread_data->length,
+                                                thread_data->groupString);
 
 }
 
@@ -9957,23 +9961,23 @@ glGetPerfMonitorGroupStringAMD_evgl_api_thread_cmd(GLuint group, GLsizei bufSize
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGetPerfMonitorGroupStringAMD thread_param_local;
-   EVGL_API_Thread_Command_glGetPerfMonitorGroupStringAMD *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGetPerfMonitorGroupStringAMD thread_data_local;
+   EVGL_API_Thread_Command_glGetPerfMonitorGroupStringAMD *thread_data = &thread_data_local;
 
-   thread_param->group = group;
-   thread_param->bufSize = bufSize;
-   thread_param->length = length;
-   thread_param->groupString = groupString;
+   thread_data->group = group;
+   thread_data->bufSize = bufSize;
+   thread_data->length = length;
+   thread_data->groupString = groupString;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGetPerfMonitorGroupStringAMD,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGetPerfMonitorCounterStringAMD(GLuint group, GLuint counter, GLsizei bufSize, GLsizei* length, char* counterString);
+ * void
+ * glGetPerfMonitorCounterStringAMD(GLuint group, GLuint counter, GLsizei bufSize, GLsizei* length, char* counterString);
  */
 
 typedef struct
@@ -9991,14 +9995,14 @@ void (*orig_evgl_api_glGetPerfMonitorCounterStringAMD)(GLuint group, GLuint coun
 static void
 _evgl_api_thread_glGetPerfMonitorCounterStringAMD(void *data)
 {
-   EVGL_API_Thread_Command_glGetPerfMonitorCounterStringAMD *thread_param =
+   EVGL_API_Thread_Command_glGetPerfMonitorCounterStringAMD *thread_data =
       (EVGL_API_Thread_Command_glGetPerfMonitorCounterStringAMD *)data;
 
-   orig_evgl_api_glGetPerfMonitorCounterStringAMD(thread_param->group,
-                                                  thread_param->counter,
-                                                  thread_param->bufSize,
-                                                  thread_param->length,
-                                                  thread_param->counterString);
+   orig_evgl_api_glGetPerfMonitorCounterStringAMD(thread_data->group,
+                                                  thread_data->counter,
+                                                  thread_data->bufSize,
+                                                  thread_data->length,
+                                                  thread_data->counterString);
 
 }
 
@@ -10013,24 +10017,24 @@ glGetPerfMonitorCounterStringAMD_evgl_api_thread_cmd(GLuint group, GLuint counte
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGetPerfMonitorCounterStringAMD thread_param_local;
-   EVGL_API_Thread_Command_glGetPerfMonitorCounterStringAMD *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGetPerfMonitorCounterStringAMD thread_data_local;
+   EVGL_API_Thread_Command_glGetPerfMonitorCounterStringAMD *thread_data = &thread_data_local;
 
-   thread_param->group = group;
-   thread_param->counter = counter;
-   thread_param->bufSize = bufSize;
-   thread_param->length = length;
-   thread_param->counterString = counterString;
+   thread_data->group = group;
+   thread_data->counter = counter;
+   thread_data->bufSize = bufSize;
+   thread_data->length = length;
+   thread_data->counterString = counterString;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGetPerfMonitorCounterStringAMD,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGetPerfMonitorCounterInfoAMD(GLuint group, GLuint counter, GLenum pname, void* data);
+ * void
+ * glGetPerfMonitorCounterInfoAMD(GLuint group, GLuint counter, GLenum pname, void* data);
  */
 
 typedef struct
@@ -10047,13 +10051,13 @@ void (*orig_evgl_api_glGetPerfMonitorCounterInfoAMD)(GLuint group, GLuint counte
 static void
 _evgl_api_thread_glGetPerfMonitorCounterInfoAMD(void *data)
 {
-   EVGL_API_Thread_Command_glGetPerfMonitorCounterInfoAMD *thread_param =
+   EVGL_API_Thread_Command_glGetPerfMonitorCounterInfoAMD *thread_data =
       (EVGL_API_Thread_Command_glGetPerfMonitorCounterInfoAMD *)data;
 
-   orig_evgl_api_glGetPerfMonitorCounterInfoAMD(thread_param->group,
-                                                thread_param->counter,
-                                                thread_param->pname,
-                                                thread_param->data);
+   orig_evgl_api_glGetPerfMonitorCounterInfoAMD(thread_data->group,
+                                                thread_data->counter,
+                                                thread_data->pname,
+                                                thread_data->data);
 
 }
 
@@ -10068,23 +10072,23 @@ glGetPerfMonitorCounterInfoAMD_evgl_api_thread_cmd(GLuint group, GLuint counter,
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGetPerfMonitorCounterInfoAMD thread_param_local;
-   EVGL_API_Thread_Command_glGetPerfMonitorCounterInfoAMD *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGetPerfMonitorCounterInfoAMD thread_data_local;
+   EVGL_API_Thread_Command_glGetPerfMonitorCounterInfoAMD *thread_data = &thread_data_local;
 
-   thread_param->group = group;
-   thread_param->counter = counter;
-   thread_param->pname = pname;
-   thread_param->data = data;
+   thread_data->group = group;
+   thread_data->counter = counter;
+   thread_data->pname = pname;
+   thread_data->data = data;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGetPerfMonitorCounterInfoAMD,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGenPerfMonitorsAMD(GLsizei n, GLuint* monitors);
+ * void
+ * glGenPerfMonitorsAMD(GLsizei n, GLuint* monitors);
  */
 
 typedef struct
@@ -10099,11 +10103,11 @@ void (*orig_evgl_api_glGenPerfMonitorsAMD)(GLsizei n, GLuint* monitors);
 static void
 _evgl_api_thread_glGenPerfMonitorsAMD(void *data)
 {
-   EVGL_API_Thread_Command_glGenPerfMonitorsAMD *thread_param =
+   EVGL_API_Thread_Command_glGenPerfMonitorsAMD *thread_data =
       (EVGL_API_Thread_Command_glGenPerfMonitorsAMD *)data;
 
-   orig_evgl_api_glGenPerfMonitorsAMD(thread_param->n,
-                                      thread_param->monitors);
+   orig_evgl_api_glGenPerfMonitorsAMD(thread_data->n,
+                                      thread_data->monitors);
 
 }
 
@@ -10118,21 +10122,21 @@ glGenPerfMonitorsAMD_evgl_api_thread_cmd(GLsizei n, GLuint* monitors)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGenPerfMonitorsAMD thread_param_local;
-   EVGL_API_Thread_Command_glGenPerfMonitorsAMD *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGenPerfMonitorsAMD thread_data_local;
+   EVGL_API_Thread_Command_glGenPerfMonitorsAMD *thread_data = &thread_data_local;
 
-   thread_param->n = n;
-   thread_param->monitors = monitors;
+   thread_data->n = n;
+   thread_data->monitors = monitors;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGenPerfMonitorsAMD,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glDeletePerfMonitorsAMD(GLsizei n, GLuint* monitors);
+ * void
+ * glDeletePerfMonitorsAMD(GLsizei n, GLuint* monitors);
  */
 
 typedef struct
@@ -10147,11 +10151,11 @@ void (*orig_evgl_api_glDeletePerfMonitorsAMD)(GLsizei n, GLuint* monitors);
 static void
 _evgl_api_thread_glDeletePerfMonitorsAMD(void *data)
 {
-   EVGL_API_Thread_Command_glDeletePerfMonitorsAMD *thread_param =
+   EVGL_API_Thread_Command_glDeletePerfMonitorsAMD *thread_data =
       (EVGL_API_Thread_Command_glDeletePerfMonitorsAMD *)data;
 
-   orig_evgl_api_glDeletePerfMonitorsAMD(thread_param->n,
-                                         thread_param->monitors);
+   orig_evgl_api_glDeletePerfMonitorsAMD(thread_data->n,
+                                         thread_data->monitors);
 
 }
 
@@ -10166,21 +10170,21 @@ glDeletePerfMonitorsAMD_evgl_api_thread_cmd(GLsizei n, GLuint* monitors)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glDeletePerfMonitorsAMD thread_param_local;
-   EVGL_API_Thread_Command_glDeletePerfMonitorsAMD *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glDeletePerfMonitorsAMD thread_data_local;
+   EVGL_API_Thread_Command_glDeletePerfMonitorsAMD *thread_data = &thread_data_local;
 
-   thread_param->n = n;
-   thread_param->monitors = monitors;
+   thread_data->n = n;
+   thread_data->monitors = monitors;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glDeletePerfMonitorsAMD,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glSelectPerfMonitorCountersAMD(GLuint monitor, GLboolean enable, GLuint group, GLint numCounters, GLuint* countersList);
+ * void
+ * glSelectPerfMonitorCountersAMD(GLuint monitor, GLboolean enable, GLuint group, GLint numCounters, GLuint* countersList);
  */
 
 typedef struct
@@ -10198,14 +10202,14 @@ void (*orig_evgl_api_glSelectPerfMonitorCountersAMD)(GLuint monitor, GLboolean e
 static void
 _evgl_api_thread_glSelectPerfMonitorCountersAMD(void *data)
 {
-   EVGL_API_Thread_Command_glSelectPerfMonitorCountersAMD *thread_param =
+   EVGL_API_Thread_Command_glSelectPerfMonitorCountersAMD *thread_data =
       (EVGL_API_Thread_Command_glSelectPerfMonitorCountersAMD *)data;
 
-   orig_evgl_api_glSelectPerfMonitorCountersAMD(thread_param->monitor,
-                                                thread_param->enable,
-                                                thread_param->group,
-                                                thread_param->numCounters,
-                                                thread_param->countersList);
+   orig_evgl_api_glSelectPerfMonitorCountersAMD(thread_data->monitor,
+                                                thread_data->enable,
+                                                thread_data->group,
+                                                thread_data->numCounters,
+                                                thread_data->countersList);
 
 }
 
@@ -10220,24 +10224,24 @@ glSelectPerfMonitorCountersAMD_evgl_api_thread_cmd(GLuint monitor, GLboolean ena
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glSelectPerfMonitorCountersAMD thread_param_local;
-   EVGL_API_Thread_Command_glSelectPerfMonitorCountersAMD *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glSelectPerfMonitorCountersAMD thread_data_local;
+   EVGL_API_Thread_Command_glSelectPerfMonitorCountersAMD *thread_data = &thread_data_local;
 
-   thread_param->monitor = monitor;
-   thread_param->enable = enable;
-   thread_param->group = group;
-   thread_param->numCounters = numCounters;
-   thread_param->countersList = countersList;
+   thread_data->monitor = monitor;
+   thread_data->enable = enable;
+   thread_data->group = group;
+   thread_data->numCounters = numCounters;
+   thread_data->countersList = countersList;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glSelectPerfMonitorCountersAMD,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glBeginPerfMonitorAMD(GLuint monitor);
+ * void
+ * glBeginPerfMonitorAMD(GLuint monitor);
  */
 
 typedef struct
@@ -10251,10 +10255,10 @@ void (*orig_evgl_api_glBeginPerfMonitorAMD)(GLuint monitor);
 static void
 _evgl_api_thread_glBeginPerfMonitorAMD(void *data)
 {
-   EVGL_API_Thread_Command_glBeginPerfMonitorAMD *thread_param =
+   EVGL_API_Thread_Command_glBeginPerfMonitorAMD *thread_data =
       (EVGL_API_Thread_Command_glBeginPerfMonitorAMD *)data;
 
-   orig_evgl_api_glBeginPerfMonitorAMD(thread_param->monitor);
+   orig_evgl_api_glBeginPerfMonitorAMD(thread_data->monitor);
 
 }
 
@@ -10269,20 +10273,20 @@ glBeginPerfMonitorAMD_evgl_api_thread_cmd(GLuint monitor)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glBeginPerfMonitorAMD thread_param_local;
-   EVGL_API_Thread_Command_glBeginPerfMonitorAMD *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glBeginPerfMonitorAMD thread_data_local;
+   EVGL_API_Thread_Command_glBeginPerfMonitorAMD *thread_data = &thread_data_local;
 
-   thread_param->monitor = monitor;
+   thread_data->monitor = monitor;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glBeginPerfMonitorAMD,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glEndPerfMonitorAMD(GLuint monitor);
+ * void
+ * glEndPerfMonitorAMD(GLuint monitor);
  */
 
 typedef struct
@@ -10296,10 +10300,10 @@ void (*orig_evgl_api_glEndPerfMonitorAMD)(GLuint monitor);
 static void
 _evgl_api_thread_glEndPerfMonitorAMD(void *data)
 {
-   EVGL_API_Thread_Command_glEndPerfMonitorAMD *thread_param =
+   EVGL_API_Thread_Command_glEndPerfMonitorAMD *thread_data =
       (EVGL_API_Thread_Command_glEndPerfMonitorAMD *)data;
 
-   orig_evgl_api_glEndPerfMonitorAMD(thread_param->monitor);
+   orig_evgl_api_glEndPerfMonitorAMD(thread_data->monitor);
 
 }
 
@@ -10314,20 +10318,20 @@ glEndPerfMonitorAMD_evgl_api_thread_cmd(GLuint monitor)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glEndPerfMonitorAMD thread_param_local;
-   EVGL_API_Thread_Command_glEndPerfMonitorAMD *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glEndPerfMonitorAMD thread_data_local;
+   EVGL_API_Thread_Command_glEndPerfMonitorAMD *thread_data = &thread_data_local;
 
-   thread_param->monitor = monitor;
+   thread_data->monitor = monitor;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glEndPerfMonitorAMD,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGetPerfMonitorCounterDataAMD(GLuint monitor, GLenum pname, GLsizei dataSize, GLuint* data, GLint* bytesWritten);
+ * void
+ * glGetPerfMonitorCounterDataAMD(GLuint monitor, GLenum pname, GLsizei dataSize, GLuint* data, GLint* bytesWritten);
  */
 
 typedef struct
@@ -10345,14 +10349,14 @@ void (*orig_evgl_api_glGetPerfMonitorCounterDataAMD)(GLuint monitor, GLenum pnam
 static void
 _evgl_api_thread_glGetPerfMonitorCounterDataAMD(void *data)
 {
-   EVGL_API_Thread_Command_glGetPerfMonitorCounterDataAMD *thread_param =
+   EVGL_API_Thread_Command_glGetPerfMonitorCounterDataAMD *thread_data =
       (EVGL_API_Thread_Command_glGetPerfMonitorCounterDataAMD *)data;
 
-   orig_evgl_api_glGetPerfMonitorCounterDataAMD(thread_param->monitor,
-                                                thread_param->pname,
-                                                thread_param->dataSize,
-                                                thread_param->data,
-                                                thread_param->bytesWritten);
+   orig_evgl_api_glGetPerfMonitorCounterDataAMD(thread_data->monitor,
+                                                thread_data->pname,
+                                                thread_data->dataSize,
+                                                thread_data->data,
+                                                thread_data->bytesWritten);
 
 }
 
@@ -10367,24 +10371,24 @@ glGetPerfMonitorCounterDataAMD_evgl_api_thread_cmd(GLuint monitor, GLenum pname,
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGetPerfMonitorCounterDataAMD thread_param_local;
-   EVGL_API_Thread_Command_glGetPerfMonitorCounterDataAMD *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGetPerfMonitorCounterDataAMD thread_data_local;
+   EVGL_API_Thread_Command_glGetPerfMonitorCounterDataAMD *thread_data = &thread_data_local;
 
-   thread_param->monitor = monitor;
-   thread_param->pname = pname;
-   thread_param->dataSize = dataSize;
-   thread_param->data = data;
-   thread_param->bytesWritten = bytesWritten;
+   thread_data->monitor = monitor;
+   thread_data->pname = pname;
+   thread_data->dataSize = dataSize;
+   thread_data->data = data;
+   thread_data->bytesWritten = bytesWritten;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGetPerfMonitorCounterDataAMD,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glDiscardFramebuffer(GLenum target, GLsizei numAttachments, const GLenum* attachments);
+ * void
+ * glDiscardFramebuffer(GLenum target, GLsizei numAttachments, const GLenum* attachments);
  */
 
 typedef struct
@@ -10400,12 +10404,12 @@ void (*orig_evgl_api_glDiscardFramebuffer)(GLenum target, GLsizei numAttachments
 static void
 _evgl_api_thread_glDiscardFramebuffer(void *data)
 {
-   EVGL_API_Thread_Command_glDiscardFramebuffer *thread_param =
+   EVGL_API_Thread_Command_glDiscardFramebuffer *thread_data =
       (EVGL_API_Thread_Command_glDiscardFramebuffer *)data;
 
-   orig_evgl_api_glDiscardFramebuffer(thread_param->target,
-                                      thread_param->numAttachments,
-                                      thread_param->attachments);
+   orig_evgl_api_glDiscardFramebuffer(thread_data->target,
+                                      thread_data->numAttachments,
+                                      thread_data->attachments);
 
 }
 
@@ -10420,22 +10424,22 @@ glDiscardFramebuffer_evgl_api_thread_cmd(GLenum target, GLsizei numAttachments,
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glDiscardFramebuffer thread_param_local;
-   EVGL_API_Thread_Command_glDiscardFramebuffer *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glDiscardFramebuffer thread_data_local;
+   EVGL_API_Thread_Command_glDiscardFramebuffer *thread_data = &thread_data_local;
 
-   thread_param->target = target;
-   thread_param->numAttachments = numAttachments;
-   thread_param->attachments = attachments;
+   thread_data->target = target;
+   thread_data->numAttachments = numAttachments;
+   thread_data->attachments = attachments;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glDiscardFramebuffer,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glDiscardFramebufferEXT(GLenum target, GLsizei numAttachments, const GLenum* attachments);
+ * void
+ * glDiscardFramebufferEXT(GLenum target, GLsizei numAttachments, const GLenum* attachments);
  */
 
 typedef struct
@@ -10451,12 +10455,12 @@ void (*orig_evgl_api_glDiscardFramebufferEXT)(GLenum target, GLsizei numAttachme
 static void
 _evgl_api_thread_glDiscardFramebufferEXT(void *data)
 {
-   EVGL_API_Thread_Command_glDiscardFramebufferEXT *thread_param =
+   EVGL_API_Thread_Command_glDiscardFramebufferEXT *thread_data =
       (EVGL_API_Thread_Command_glDiscardFramebufferEXT *)data;
 
-   orig_evgl_api_glDiscardFramebufferEXT(thread_param->target,
-                                         thread_param->numAttachments,
-                                         thread_param->attachments);
+   orig_evgl_api_glDiscardFramebufferEXT(thread_data->target,
+                                         thread_data->numAttachments,
+                                         thread_data->attachments);
 
 }
 
@@ -10471,22 +10475,22 @@ glDiscardFramebufferEXT_evgl_api_thread_cmd(GLenum target, GLsizei numAttachment
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glDiscardFramebufferEXT thread_param_local;
-   EVGL_API_Thread_Command_glDiscardFramebufferEXT *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glDiscardFramebufferEXT thread_data_local;
+   EVGL_API_Thread_Command_glDiscardFramebufferEXT *thread_data = &thread_data_local;
 
-   thread_param->target = target;
-   thread_param->numAttachments = numAttachments;
-   thread_param->attachments = attachments;
+   thread_data->target = target;
+   thread_data->numAttachments = numAttachments;
+   thread_data->attachments = attachments;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glDiscardFramebufferEXT,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glMultiDrawArrays(GLenum mode, GLint* first, GLsizei* count, GLsizei primcount);
+ * void
+ * glMultiDrawArrays(GLenum mode, GLint* first, GLsizei* count, GLsizei primcount);
  */
 
 typedef struct
@@ -10503,13 +10507,13 @@ void (*orig_evgl_api_glMultiDrawArrays)(GLenum mode, GLint* first, GLsizei* coun
 static void
 _evgl_api_thread_glMultiDrawArrays(void *data)
 {
-   EVGL_API_Thread_Command_glMultiDrawArrays *thread_param =
+   EVGL_API_Thread_Command_glMultiDrawArrays *thread_data =
       (EVGL_API_Thread_Command_glMultiDrawArrays *)data;
 
-   orig_evgl_api_glMultiDrawArrays(thread_param->mode,
-                                   thread_param->first,
-                                   thread_param->count,
-                                   thread_param->primcount);
+   orig_evgl_api_glMultiDrawArrays(thread_data->mode,
+                                   thread_data->first,
+                                   thread_data->count,
+                                   thread_data->primcount);
 
 }
 
@@ -10524,23 +10528,23 @@ glMultiDrawArrays_evgl_api_thread_cmd(GLenum mode, GLint* first, GLsizei* count,
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glMultiDrawArrays thread_param_local;
-   EVGL_API_Thread_Command_glMultiDrawArrays *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glMultiDrawArrays thread_data_local;
+   EVGL_API_Thread_Command_glMultiDrawArrays *thread_data = &thread_data_local;
 
-   thread_param->mode = mode;
-   thread_param->first = first;
-   thread_param->count = count;
-   thread_param->primcount = primcount;
+   thread_data->mode = mode;
+   thread_data->first = first;
+   thread_data->count = count;
+   thread_data->primcount = primcount;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glMultiDrawArrays,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glMultiDrawArraysEXT(GLenum mode, GLint* first, GLsizei* count, GLsizei primcount);
+ * void
+ * glMultiDrawArraysEXT(GLenum mode, GLint* first, GLsizei* count, GLsizei primcount);
  */
 
 typedef struct
@@ -10557,13 +10561,13 @@ void (*orig_evgl_api_glMultiDrawArraysEXT)(GLenum mode, GLint* first, GLsizei* c
 static void
 _evgl_api_thread_glMultiDrawArraysEXT(void *data)
 {
-   EVGL_API_Thread_Command_glMultiDrawArraysEXT *thread_param =
+   EVGL_API_Thread_Command_glMultiDrawArraysEXT *thread_data =
       (EVGL_API_Thread_Command_glMultiDrawArraysEXT *)data;
 
-   orig_evgl_api_glMultiDrawArraysEXT(thread_param->mode,
-                                      thread_param->first,
-                                      thread_param->count,
-                                      thread_param->primcount);
+   orig_evgl_api_glMultiDrawArraysEXT(thread_data->mode,
+                                      thread_data->first,
+                                      thread_data->count,
+                                      thread_data->primcount);
 
 }
 
@@ -10578,23 +10582,23 @@ glMultiDrawArraysEXT_evgl_api_thread_cmd(GLenum mode, GLint* first, GLsizei* cou
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glMultiDrawArraysEXT thread_param_local;
-   EVGL_API_Thread_Command_glMultiDrawArraysEXT *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glMultiDrawArraysEXT thread_data_local;
+   EVGL_API_Thread_Command_glMultiDrawArraysEXT *thread_data = &thread_data_local;
 
-   thread_param->mode = mode;
-   thread_param->first = first;
-   thread_param->count = count;
-   thread_param->primcount = primcount;
+   thread_data->mode = mode;
+   thread_data->first = first;
+   thread_data->count = count;
+   thread_data->primcount = primcount;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glMultiDrawArraysEXT,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glMultiDrawElements(GLenum mode, const GLsizei* count, GLenum type, const GLvoid** indices, GLsizei primcount);
+ * void
+ * glMultiDrawElements(GLenum mode, const GLsizei* count, GLenum type, const GLvoid** indices, GLsizei primcount);
  */
 
 typedef struct
@@ -10612,14 +10616,14 @@ void (*orig_evgl_api_glMultiDrawElements)(GLenum mode, const GLsizei* count, GLe
 static void
 _evgl_api_thread_glMultiDrawElements(void *data)
 {
-   EVGL_API_Thread_Command_glMultiDrawElements *thread_param =
+   EVGL_API_Thread_Command_glMultiDrawElements *thread_data =
       (EVGL_API_Thread_Command_glMultiDrawElements *)data;
 
-   orig_evgl_api_glMultiDrawElements(thread_param->mode,
-                                     thread_param->count,
-                                     thread_param->type,
-                                     thread_param->indices,
-                                     thread_param->primcount);
+   orig_evgl_api_glMultiDrawElements(thread_data->mode,
+                                     thread_data->count,
+                                     thread_data->type,
+                                     thread_data->indices,
+                                     thread_data->primcount);
 
 }
 
@@ -10634,24 +10638,24 @@ glMultiDrawElements_evgl_api_thread_cmd(GLenum mode, const GLsizei* count, GLenu
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glMultiDrawElements thread_param_local;
-   EVGL_API_Thread_Command_glMultiDrawElements *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glMultiDrawElements thread_data_local;
+   EVGL_API_Thread_Command_glMultiDrawElements *thread_data = &thread_data_local;
 
-   thread_param->mode = mode;
-   thread_param->count = count;
-   thread_param->type = type;
-   thread_param->indices = indices;
-   thread_param->primcount = primcount;
+   thread_data->mode = mode;
+   thread_data->count = count;
+   thread_data->type = type;
+   thread_data->indices = indices;
+   thread_data->primcount = primcount;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glMultiDrawElements,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glMultiDrawElementsEXT(GLenum mode, const GLsizei* count, GLenum type, const GLvoid** indices, GLsizei primcount);
+ * void
+ * glMultiDrawElementsEXT(GLenum mode, const GLsizei* count, GLenum type, const GLvoid** indices, GLsizei primcount);
  */
 
 typedef struct
@@ -10669,14 +10673,14 @@ void (*orig_evgl_api_glMultiDrawElementsEXT)(GLenum mode, const GLsizei* count,
 static void
 _evgl_api_thread_glMultiDrawElementsEXT(void *data)
 {
-   EVGL_API_Thread_Command_glMultiDrawElementsEXT *thread_param =
+   EVGL_API_Thread_Command_glMultiDrawElementsEXT *thread_data =
       (EVGL_API_Thread_Command_glMultiDrawElementsEXT *)data;
 
-   orig_evgl_api_glMultiDrawElementsEXT(thread_param->mode,
-                                        thread_param->count,
-                                        thread_param->type,
-                                        thread_param->indices,
-                                        thread_param->primcount);
+   orig_evgl_api_glMultiDrawElementsEXT(thread_data->mode,
+                                        thread_data->count,
+                                        thread_data->type,
+                                        thread_data->indices,
+                                        thread_data->primcount);
 
 }
 
@@ -10691,24 +10695,24 @@ glMultiDrawElementsEXT_evgl_api_thread_cmd(GLenum mode, const GLsizei* count, GL
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glMultiDrawElementsEXT thread_param_local;
-   EVGL_API_Thread_Command_glMultiDrawElementsEXT *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glMultiDrawElementsEXT thread_data_local;
+   EVGL_API_Thread_Command_glMultiDrawElementsEXT *thread_data = &thread_data_local;
 
-   thread_param->mode = mode;
-   thread_param->count = count;
-   thread_param->type = type;
-   thread_param->indices = indices;
-   thread_param->primcount = primcount;
+   thread_data->mode = mode;
+   thread_data->count = count;
+   thread_data->type = type;
+   thread_data->indices = indices;
+   thread_data->primcount = primcount;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glMultiDrawElementsEXT,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glDeleteFencesNV(GLsizei n, const GLuint* fences);
+ * void
+ * glDeleteFencesNV(GLsizei n, const GLuint* fences);
  */
 
 typedef struct
@@ -10723,11 +10727,11 @@ void (*orig_evgl_api_glDeleteFencesNV)(GLsizei n, const GLuint* fences);
 static void
 _evgl_api_thread_glDeleteFencesNV(void *data)
 {
-   EVGL_API_Thread_Command_glDeleteFencesNV *thread_param =
+   EVGL_API_Thread_Command_glDeleteFencesNV *thread_data =
       (EVGL_API_Thread_Command_glDeleteFencesNV *)data;
 
-   orig_evgl_api_glDeleteFencesNV(thread_param->n,
-                                  thread_param->fences);
+   orig_evgl_api_glDeleteFencesNV(thread_data->n,
+                                  thread_data->fences);
 
 }
 
@@ -10742,21 +10746,21 @@ glDeleteFencesNV_evgl_api_thread_cmd(GLsizei n, const GLuint* fences)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glDeleteFencesNV thread_param_local;
-   EVGL_API_Thread_Command_glDeleteFencesNV *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glDeleteFencesNV thread_data_local;
+   EVGL_API_Thread_Command_glDeleteFencesNV *thread_data = &thread_data_local;
 
-   thread_param->n = n;
-   thread_param->fences = fences;
+   thread_data->n = n;
+   thread_data->fences = fences;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glDeleteFencesNV,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGenFencesNV(GLsizei n, GLuint* fences);
+ * void
+ * glGenFencesNV(GLsizei n, GLuint* fences);
  */
 
 typedef struct
@@ -10771,11 +10775,11 @@ void (*orig_evgl_api_glGenFencesNV)(GLsizei n, GLuint* fences);
 static void
 _evgl_api_thread_glGenFencesNV(void *data)
 {
-   EVGL_API_Thread_Command_glGenFencesNV *thread_param =
+   EVGL_API_Thread_Command_glGenFencesNV *thread_data =
       (EVGL_API_Thread_Command_glGenFencesNV *)data;
 
-   orig_evgl_api_glGenFencesNV(thread_param->n,
-                               thread_param->fences);
+   orig_evgl_api_glGenFencesNV(thread_data->n,
+                               thread_data->fences);
 
 }
 
@@ -10790,21 +10794,21 @@ glGenFencesNV_evgl_api_thread_cmd(GLsizei n, GLuint* fences)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGenFencesNV thread_param_local;
-   EVGL_API_Thread_Command_glGenFencesNV *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGenFencesNV thread_data_local;
+   EVGL_API_Thread_Command_glGenFencesNV *thread_data = &thread_data_local;
 
-   thread_param->n = n;
-   thread_param->fences = fences;
+   thread_data->n = n;
+   thread_data->fences = fences;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGenFencesNV,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   GLboolean
-   glIsFenceNV(GLuint fence);
+ * GLboolean
+ * glIsFenceNV(GLuint fence);
  */
 
 typedef struct
@@ -10819,10 +10823,10 @@ GLboolean (*orig_evgl_api_glIsFenceNV)(GLuint fence);
 static void
 _evgl_api_thread_glIsFenceNV(void *data)
 {
-   EVGL_API_Thread_Command_glIsFenceNV *thread_param =
+   EVGL_API_Thread_Command_glIsFenceNV *thread_data =
       (EVGL_API_Thread_Command_glIsFenceNV *)data;
 
-   thread_param->return_value = orig_evgl_api_glIsFenceNV(thread_param->fence);
+   thread_data->return_value = orig_evgl_api_glIsFenceNV(thread_data->fence);
 
 }
 
@@ -10836,22 +10840,22 @@ glIsFenceNV_evgl_api_thread_cmd(GLuint fence)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glIsFenceNV thread_param_local;
-   EVGL_API_Thread_Command_glIsFenceNV *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glIsFenceNV thread_data_local;
+   EVGL_API_Thread_Command_glIsFenceNV *thread_data = &thread_data_local;
 
-   thread_param->fence = fence;
+   thread_data->fence = fence;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glIsFenceNV,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
-   GLboolean
-   glTestFenceNV(GLuint fence);
+ * GLboolean
+ * glTestFenceNV(GLuint fence);
  */
 
 typedef struct
@@ -10866,10 +10870,10 @@ GLboolean (*orig_evgl_api_glTestFenceNV)(GLuint fence);
 static void
 _evgl_api_thread_glTestFenceNV(void *data)
 {
-   EVGL_API_Thread_Command_glTestFenceNV *thread_param =
+   EVGL_API_Thread_Command_glTestFenceNV *thread_data =
       (EVGL_API_Thread_Command_glTestFenceNV *)data;
 
-   thread_param->return_value = orig_evgl_api_glTestFenceNV(thread_param->fence);
+   thread_data->return_value = orig_evgl_api_glTestFenceNV(thread_data->fence);
 
 }
 
@@ -10883,22 +10887,22 @@ glTestFenceNV_evgl_api_thread_cmd(GLuint fence)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glTestFenceNV thread_param_local;
-   EVGL_API_Thread_Command_glTestFenceNV *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glTestFenceNV thread_data_local;
+   EVGL_API_Thread_Command_glTestFenceNV *thread_data = &thread_data_local;
 
-   thread_param->fence = fence;
+   thread_data->fence = fence;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glTestFenceNV,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
-   void
-   glGetFenceivNV(GLuint fence, GLenum pname, GLint* params);
+ * void
+ * glGetFenceivNV(GLuint fence, GLenum pname, GLint* params);
  */
 
 typedef struct
@@ -10914,12 +10918,12 @@ void (*orig_evgl_api_glGetFenceivNV)(GLuint fence, GLenum pname, GLint* params);
 static void
 _evgl_api_thread_glGetFenceivNV(void *data)
 {
-   EVGL_API_Thread_Command_glGetFenceivNV *thread_param =
+   EVGL_API_Thread_Command_glGetFenceivNV *thread_data =
       (EVGL_API_Thread_Command_glGetFenceivNV *)data;
 
-   orig_evgl_api_glGetFenceivNV(thread_param->fence,
-                                thread_param->pname,
-                                thread_param->params);
+   orig_evgl_api_glGetFenceivNV(thread_data->fence,
+                                thread_data->pname,
+                                thread_data->params);
 
 }
 
@@ -10934,22 +10938,22 @@ glGetFenceivNV_evgl_api_thread_cmd(GLuint fence, GLenum pname, GLint* params)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGetFenceivNV thread_param_local;
-   EVGL_API_Thread_Command_glGetFenceivNV *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGetFenceivNV thread_data_local;
+   EVGL_API_Thread_Command_glGetFenceivNV *thread_data = &thread_data_local;
 
-   thread_param->fence = fence;
-   thread_param->pname = pname;
-   thread_param->params = params;
+   thread_data->fence = fence;
+   thread_data->pname = pname;
+   thread_data->params = params;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGetFenceivNV,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glFinishFenceNV(GLuint fence);
+ * void
+ * glFinishFenceNV(GLuint fence);
  */
 
 typedef struct
@@ -10963,10 +10967,10 @@ void (*orig_evgl_api_glFinishFenceNV)(GLuint fence);
 static void
 _evgl_api_thread_glFinishFenceNV(void *data)
 {
-   EVGL_API_Thread_Command_glFinishFenceNV *thread_param =
+   EVGL_API_Thread_Command_glFinishFenceNV *thread_data =
       (EVGL_API_Thread_Command_glFinishFenceNV *)data;
 
-   orig_evgl_api_glFinishFenceNV(thread_param->fence);
+   orig_evgl_api_glFinishFenceNV(thread_data->fence);
 
 }
 
@@ -10981,20 +10985,20 @@ glFinishFenceNV_evgl_api_thread_cmd(GLuint fence)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glFinishFenceNV thread_param_local;
-   EVGL_API_Thread_Command_glFinishFenceNV *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glFinishFenceNV thread_data_local;
+   EVGL_API_Thread_Command_glFinishFenceNV *thread_data = &thread_data_local;
 
-   thread_param->fence = fence;
+   thread_data->fence = fence;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glFinishFenceNV,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glSetFenceNV(GLuint a, GLenum b);
+ * void
+ * glSetFenceNV(GLuint a, GLenum b);
  */
 
 typedef struct
@@ -11009,11 +11013,11 @@ void (*orig_evgl_api_glSetFenceNV)(GLuint a, GLenum b);
 static void
 _evgl_api_thread_glSetFenceNV(void *data)
 {
-   EVGL_API_Thread_Command_glSetFenceNV *thread_param =
+   EVGL_API_Thread_Command_glSetFenceNV *thread_data =
       (EVGL_API_Thread_Command_glSetFenceNV *)data;
 
-   orig_evgl_api_glSetFenceNV(thread_param->a,
-                              thread_param->b);
+   orig_evgl_api_glSetFenceNV(thread_data->a,
+                              thread_data->b);
 
 }
 
@@ -11028,21 +11032,21 @@ glSetFenceNV_evgl_api_thread_cmd(GLuint a, GLenum b)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glSetFenceNV thread_param_local;
-   EVGL_API_Thread_Command_glSetFenceNV *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glSetFenceNV thread_data_local;
+   EVGL_API_Thread_Command_glSetFenceNV *thread_data = &thread_data_local;
 
-   thread_param->a = a;
-   thread_param->b = b;
+   thread_data->a = a;
+   thread_data->b = b;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glSetFenceNV,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGetDriverControlsQCOM(GLint* num, GLsizei size, GLuint* driverControls);
+ * void
+ * glGetDriverControlsQCOM(GLint* num, GLsizei size, GLuint* driverControls);
  */
 
 typedef struct
@@ -11058,12 +11062,12 @@ void (*orig_evgl_api_glGetDriverControlsQCOM)(GLint* num, GLsizei size, GLuint*
 static void
 _evgl_api_thread_glGetDriverControlsQCOM(void *data)
 {
-   EVGL_API_Thread_Command_glGetDriverControlsQCOM *thread_param =
+   EVGL_API_Thread_Command_glGetDriverControlsQCOM *thread_data =
       (EVGL_API_Thread_Command_glGetDriverControlsQCOM *)data;
 
-   orig_evgl_api_glGetDriverControlsQCOM(thread_param->num,
-                                         thread_param->size,
-                                         thread_param->driverControls);
+   orig_evgl_api_glGetDriverControlsQCOM(thread_data->num,
+                                         thread_data->size,
+                                         thread_data->driverControls);
 
 }
 
@@ -11078,22 +11082,22 @@ glGetDriverControlsQCOM_evgl_api_thread_cmd(GLint* num, GLsizei size, GLuint* dr
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGetDriverControlsQCOM thread_param_local;
-   EVGL_API_Thread_Command_glGetDriverControlsQCOM *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGetDriverControlsQCOM thread_data_local;
+   EVGL_API_Thread_Command_glGetDriverControlsQCOM *thread_data = &thread_data_local;
 
-   thread_param->num = num;
-   thread_param->size = size;
-   thread_param->driverControls = driverControls;
+   thread_data->num = num;
+   thread_data->size = size;
+   thread_data->driverControls = driverControls;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGetDriverControlsQCOM,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGetDriverControlStringQCOM(GLuint driverControl, GLsizei bufSize, GLsizei* length, char* driverControlString);
+ * void
+ * glGetDriverControlStringQCOM(GLuint driverControl, GLsizei bufSize, GLsizei* length, char* driverControlString);
  */
 
 typedef struct
@@ -11110,13 +11114,13 @@ void (*orig_evgl_api_glGetDriverControlStringQCOM)(GLuint driverControl, GLsizei
 static void
 _evgl_api_thread_glGetDriverControlStringQCOM(void *data)
 {
-   EVGL_API_Thread_Command_glGetDriverControlStringQCOM *thread_param =
+   EVGL_API_Thread_Command_glGetDriverControlStringQCOM *thread_data =
       (EVGL_API_Thread_Command_glGetDriverControlStringQCOM *)data;
 
-   orig_evgl_api_glGetDriverControlStringQCOM(thread_param->driverControl,
-                                              thread_param->bufSize,
-                                              thread_param->length,
-                                              thread_param->driverControlString);
+   orig_evgl_api_glGetDriverControlStringQCOM(thread_data->driverControl,
+                                              thread_data->bufSize,
+                                              thread_data->length,
+                                              thread_data->driverControlString);
 
 }
 
@@ -11131,23 +11135,23 @@ glGetDriverControlStringQCOM_evgl_api_thread_cmd(GLuint driverControl, GLsizei b
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGetDriverControlStringQCOM thread_param_local;
-   EVGL_API_Thread_Command_glGetDriverControlStringQCOM *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGetDriverControlStringQCOM thread_data_local;
+   EVGL_API_Thread_Command_glGetDriverControlStringQCOM *thread_data = &thread_data_local;
 
-   thread_param->driverControl = driverControl;
-   thread_param->bufSize = bufSize;
-   thread_param->length = length;
-   thread_param->driverControlString = driverControlString;
+   thread_data->driverControl = driverControl;
+   thread_data->bufSize = bufSize;
+   thread_data->length = length;
+   thread_data->driverControlString = driverControlString;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGetDriverControlStringQCOM,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glEnableDriverControlQCOM(GLuint driverControl);
+ * void
+ * glEnableDriverControlQCOM(GLuint driverControl);
  */
 
 typedef struct
@@ -11161,10 +11165,10 @@ void (*orig_evgl_api_glEnableDriverControlQCOM)(GLuint driverControl);
 static void
 _evgl_api_thread_glEnableDriverControlQCOM(void *data)
 {
-   EVGL_API_Thread_Command_glEnableDriverControlQCOM *thread_param =
+   EVGL_API_Thread_Command_glEnableDriverControlQCOM *thread_data =
       (EVGL_API_Thread_Command_glEnableDriverControlQCOM *)data;
 
-   orig_evgl_api_glEnableDriverControlQCOM(thread_param->driverControl);
+   orig_evgl_api_glEnableDriverControlQCOM(thread_data->driverControl);
 
 }
 
@@ -11179,20 +11183,20 @@ glEnableDriverControlQCOM_evgl_api_thread_cmd(GLuint driverControl)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glEnableDriverControlQCOM thread_param_local;
-   EVGL_API_Thread_Command_glEnableDriverControlQCOM *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glEnableDriverControlQCOM thread_data_local;
+   EVGL_API_Thread_Command_glEnableDriverControlQCOM *thread_data = &thread_data_local;
 
-   thread_param->driverControl = driverControl;
+   thread_data->driverControl = driverControl;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glEnableDriverControlQCOM,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glDisableDriverControlQCOM(GLuint driverControl);
+ * void
+ * glDisableDriverControlQCOM(GLuint driverControl);
  */
 
 typedef struct
@@ -11206,10 +11210,10 @@ void (*orig_evgl_api_glDisableDriverControlQCOM)(GLuint driverControl);
 static void
 _evgl_api_thread_glDisableDriverControlQCOM(void *data)
 {
-   EVGL_API_Thread_Command_glDisableDriverControlQCOM *thread_param =
+   EVGL_API_Thread_Command_glDisableDriverControlQCOM *thread_data =
       (EVGL_API_Thread_Command_glDisableDriverControlQCOM *)data;
 
-   orig_evgl_api_glDisableDriverControlQCOM(thread_param->driverControl);
+   orig_evgl_api_glDisableDriverControlQCOM(thread_data->driverControl);
 
 }
 
@@ -11224,20 +11228,20 @@ glDisableDriverControlQCOM_evgl_api_thread_cmd(GLuint driverControl)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glDisableDriverControlQCOM thread_param_local;
-   EVGL_API_Thread_Command_glDisableDriverControlQCOM *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glDisableDriverControlQCOM thread_data_local;
+   EVGL_API_Thread_Command_glDisableDriverControlQCOM *thread_data = &thread_data_local;
 
-   thread_param->driverControl = driverControl;
+   thread_data->driverControl = driverControl;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glDisableDriverControlQCOM,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glExtGetTexturesQCOM(GLuint* textures, GLint maxTextures, GLint* numTextures);
+ * void
+ * glExtGetTexturesQCOM(GLuint* textures, GLint maxTextures, GLint* numTextures);
  */
 
 typedef struct
@@ -11253,12 +11257,12 @@ void (*orig_evgl_api_glExtGetTexturesQCOM)(GLuint* textures, GLint maxTextures,
 static void
 _evgl_api_thread_glExtGetTexturesQCOM(void *data)
 {
-   EVGL_API_Thread_Command_glExtGetTexturesQCOM *thread_param =
+   EVGL_API_Thread_Command_glExtGetTexturesQCOM *thread_data =
       (EVGL_API_Thread_Command_glExtGetTexturesQCOM *)data;
 
-   orig_evgl_api_glExtGetTexturesQCOM(thread_param->textures,
-                                      thread_param->maxTextures,
-                                      thread_param->numTextures);
+   orig_evgl_api_glExtGetTexturesQCOM(thread_data->textures,
+                                      thread_data->maxTextures,
+                                      thread_data->numTextures);
 
 }
 
@@ -11273,22 +11277,22 @@ glExtGetTexturesQCOM_evgl_api_thread_cmd(GLuint* textures, GLint maxTextures, GL
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glExtGetTexturesQCOM thread_param_local;
-   EVGL_API_Thread_Command_glExtGetTexturesQCOM *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glExtGetTexturesQCOM thread_data_local;
+   EVGL_API_Thread_Command_glExtGetTexturesQCOM *thread_data = &thread_data_local;
 
-   thread_param->textures = textures;
-   thread_param->maxTextures = maxTextures;
-   thread_param->numTextures = numTextures;
+   thread_data->textures = textures;
+   thread_data->maxTextures = maxTextures;
+   thread_data->numTextures = numTextures;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glExtGetTexturesQCOM,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glExtGetBuffersQCOM(GLuint* buffers, GLint maxBuffers, GLint* numBuffers);
+ * void
+ * glExtGetBuffersQCOM(GLuint* buffers, GLint maxBuffers, GLint* numBuffers);
  */
 
 typedef struct
@@ -11304,12 +11308,12 @@ void (*orig_evgl_api_glExtGetBuffersQCOM)(GLuint* buffers, GLint maxBuffers, GLi
 static void
 _evgl_api_thread_glExtGetBuffersQCOM(void *data)
 {
-   EVGL_API_Thread_Command_glExtGetBuffersQCOM *thread_param =
+   EVGL_API_Thread_Command_glExtGetBuffersQCOM *thread_data =
       (EVGL_API_Thread_Command_glExtGetBuffersQCOM *)data;
 
-   orig_evgl_api_glExtGetBuffersQCOM(thread_param->buffers,
-                                     thread_param->maxBuffers,
-                                     thread_param->numBuffers);
+   orig_evgl_api_glExtGetBuffersQCOM(thread_data->buffers,
+                                     thread_data->maxBuffers,
+                                     thread_data->numBuffers);
 
 }
 
@@ -11324,22 +11328,22 @@ glExtGetBuffersQCOM_evgl_api_thread_cmd(GLuint* buffers, GLint maxBuffers, GLint
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glExtGetBuffersQCOM thread_param_local;
-   EVGL_API_Thread_Command_glExtGetBuffersQCOM *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glExtGetBuffersQCOM thread_data_local;
+   EVGL_API_Thread_Command_glExtGetBuffersQCOM *thread_data = &thread_data_local;
 
-   thread_param->buffers = buffers;
-   thread_param->maxBuffers = maxBuffers;
-   thread_param->numBuffers = numBuffers;
+   thread_data->buffers = buffers;
+   thread_data->maxBuffers = maxBuffers;
+   thread_data->numBuffers = numBuffers;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glExtGetBuffersQCOM,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glExtGetRenderbuffersQCOM(GLuint* renderbuffers, GLint maxRenderbuffers, GLint* numRenderbuffers);
+ * void
+ * glExtGetRenderbuffersQCOM(GLuint* renderbuffers, GLint maxRenderbuffers, GLint* numRenderbuffers);
  */
 
 typedef struct
@@ -11355,12 +11359,12 @@ void (*orig_evgl_api_glExtGetRenderbuffersQCOM)(GLuint* renderbuffers, GLint max
 static void
 _evgl_api_thread_glExtGetRenderbuffersQCOM(void *data)
 {
-   EVGL_API_Thread_Command_glExtGetRenderbuffersQCOM *thread_param =
+   EVGL_API_Thread_Command_glExtGetRenderbuffersQCOM *thread_data =
       (EVGL_API_Thread_Command_glExtGetRenderbuffersQCOM *)data;
 
-   orig_evgl_api_glExtGetRenderbuffersQCOM(thread_param->renderbuffers,
-                                           thread_param->maxRenderbuffers,
-                                           thread_param->numRenderbuffers);
+   orig_evgl_api_glExtGetRenderbuffersQCOM(thread_data->renderbuffers,
+                                           thread_data->maxRenderbuffers,
+                                           thread_data->numRenderbuffers);
 
 }
 
@@ -11375,22 +11379,22 @@ glExtGetRenderbuffersQCOM_evgl_api_thread_cmd(GLuint* renderbuffers, GLint maxRe
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glExtGetRenderbuffersQCOM thread_param_local;
-   EVGL_API_Thread_Command_glExtGetRenderbuffersQCOM *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glExtGetRenderbuffersQCOM thread_data_local;
+   EVGL_API_Thread_Command_glExtGetRenderbuffersQCOM *thread_data = &thread_data_local;
 
-   thread_param->renderbuffers = renderbuffers;
-   thread_param->maxRenderbuffers = maxRenderbuffers;
-   thread_param->numRenderbuffers = numRenderbuffers;
+   thread_data->renderbuffers = renderbuffers;
+   thread_data->maxRenderbuffers = maxRenderbuffers;
+   thread_data->numRenderbuffers = numRenderbuffers;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glExtGetRenderbuffersQCOM,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glExtGetFramebuffersQCOM(GLuint* framebuffers, GLint maxFramebuffers, GLint* numFramebuffers);
+ * void
+ * glExtGetFramebuffersQCOM(GLuint* framebuffers, GLint maxFramebuffers, GLint* numFramebuffers);
  */
 
 typedef struct
@@ -11406,12 +11410,12 @@ void (*orig_evgl_api_glExtGetFramebuffersQCOM)(GLuint* framebuffers, GLint maxFr
 static void
 _evgl_api_thread_glExtGetFramebuffersQCOM(void *data)
 {
-   EVGL_API_Thread_Command_glExtGetFramebuffersQCOM *thread_param =
+   EVGL_API_Thread_Command_glExtGetFramebuffersQCOM *thread_data =
       (EVGL_API_Thread_Command_glExtGetFramebuffersQCOM *)data;
 
-   orig_evgl_api_glExtGetFramebuffersQCOM(thread_param->framebuffers,
-                                          thread_param->maxFramebuffers,
-                                          thread_param->numFramebuffers);
+   orig_evgl_api_glExtGetFramebuffersQCOM(thread_data->framebuffers,
+                                          thread_data->maxFramebuffers,
+                                          thread_data->numFramebuffers);
 
 }
 
@@ -11426,22 +11430,22 @@ glExtGetFramebuffersQCOM_evgl_api_thread_cmd(GLuint* framebuffers, GLint maxFram
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glExtGetFramebuffersQCOM thread_param_local;
-   EVGL_API_Thread_Command_glExtGetFramebuffersQCOM *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glExtGetFramebuffersQCOM thread_data_local;
+   EVGL_API_Thread_Command_glExtGetFramebuffersQCOM *thread_data = &thread_data_local;
 
-   thread_param->framebuffers = framebuffers;
-   thread_param->maxFramebuffers = maxFramebuffers;
-   thread_param->numFramebuffers = numFramebuffers;
+   thread_data->framebuffers = framebuffers;
+   thread_data->maxFramebuffers = maxFramebuffers;
+   thread_data->numFramebuffers = numFramebuffers;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glExtGetFramebuffersQCOM,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glExtGetTexLevelParameterivQCOM(GLuint texture, GLenum face, GLint level, GLenum pname, GLint* params);
+ * void
+ * glExtGetTexLevelParameterivQCOM(GLuint texture, GLenum face, GLint level, GLenum pname, GLint* params);
  */
 
 typedef struct
@@ -11459,14 +11463,14 @@ void (*orig_evgl_api_glExtGetTexLevelParameterivQCOM)(GLuint texture, GLenum fac
 static void
 _evgl_api_thread_glExtGetTexLevelParameterivQCOM(void *data)
 {
-   EVGL_API_Thread_Command_glExtGetTexLevelParameterivQCOM *thread_param =
+   EVGL_API_Thread_Command_glExtGetTexLevelParameterivQCOM *thread_data =
       (EVGL_API_Thread_Command_glExtGetTexLevelParameterivQCOM *)data;
 
-   orig_evgl_api_glExtGetTexLevelParameterivQCOM(thread_param->texture,
-                                                 thread_param->face,
-                                                 thread_param->level,
-                                                 thread_param->pname,
-                                                 thread_param->params);
+   orig_evgl_api_glExtGetTexLevelParameterivQCOM(thread_data->texture,
+                                                 thread_data->face,
+                                                 thread_data->level,
+                                                 thread_data->pname,
+                                                 thread_data->params);
 
 }
 
@@ -11481,24 +11485,24 @@ glExtGetTexLevelParameterivQCOM_evgl_api_thread_cmd(GLuint texture, GLenum face,
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glExtGetTexLevelParameterivQCOM thread_param_local;
-   EVGL_API_Thread_Command_glExtGetTexLevelParameterivQCOM *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glExtGetTexLevelParameterivQCOM thread_data_local;
+   EVGL_API_Thread_Command_glExtGetTexLevelParameterivQCOM *thread_data = &thread_data_local;
 
-   thread_param->texture = texture;
-   thread_param->face = face;
-   thread_param->level = level;
-   thread_param->pname = pname;
-   thread_param->params = params;
+   thread_data->texture = texture;
+   thread_data->face = face;
+   thread_data->level = level;
+   thread_data->pname = pname;
+   thread_data->params = params;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glExtGetTexLevelParameterivQCOM,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glExtTexObjectStateOverrideiQCOM(GLenum target, GLenum pname, GLint param);
+ * void
+ * glExtTexObjectStateOverrideiQCOM(GLenum target, GLenum pname, GLint param);
  */
 
 typedef struct
@@ -11514,12 +11518,12 @@ void (*orig_evgl_api_glExtTexObjectStateOverrideiQCOM)(GLenum target, GLenum pna
 static void
 _evgl_api_thread_glExtTexObjectStateOverrideiQCOM(void *data)
 {
-   EVGL_API_Thread_Command_glExtTexObjectStateOverrideiQCOM *thread_param =
+   EVGL_API_Thread_Command_glExtTexObjectStateOverrideiQCOM *thread_data =
       (EVGL_API_Thread_Command_glExtTexObjectStateOverrideiQCOM *)data;
 
-   orig_evgl_api_glExtTexObjectStateOverrideiQCOM(thread_param->target,
-                                                  thread_param->pname,
-                                                  thread_param->param);
+   orig_evgl_api_glExtTexObjectStateOverrideiQCOM(thread_data->target,
+                                                  thread_data->pname,
+                                                  thread_data->param);
 
 }
 
@@ -11534,22 +11538,22 @@ glExtTexObjectStateOverrideiQCOM_evgl_api_thread_cmd(GLenum target, GLenum pname
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glExtTexObjectStateOverrideiQCOM thread_param_local;
-   EVGL_API_Thread_Command_glExtTexObjectStateOverrideiQCOM *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glExtTexObjectStateOverrideiQCOM thread_data_local;
+   EVGL_API_Thread_Command_glExtTexObjectStateOverrideiQCOM *thread_data = &thread_data_local;
 
-   thread_param->target = target;
-   thread_param->pname = pname;
-   thread_param->param = param;
+   thread_data->target = target;
+   thread_data->pname = pname;
+   thread_data->param = param;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glExtTexObjectStateOverrideiQCOM,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glExtGetTexSubImageQCOM(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, void* texels);
+ * void
+ * glExtGetTexSubImageQCOM(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, void* texels);
  */
 
 typedef struct
@@ -11573,20 +11577,20 @@ void (*orig_evgl_api_glExtGetTexSubImageQCOM)(GLenum target, GLint level, GLint
 static void
 _evgl_api_thread_glExtGetTexSubImageQCOM(void *data)
 {
-   EVGL_API_Thread_Command_glExtGetTexSubImageQCOM *thread_param =
+   EVGL_API_Thread_Command_glExtGetTexSubImageQCOM *thread_data =
       (EVGL_API_Thread_Command_glExtGetTexSubImageQCOM *)data;
 
-   orig_evgl_api_glExtGetTexSubImageQCOM(thread_param->target,
-                                         thread_param->level,
-                                         thread_param->xoffset,
-                                         thread_param->yoffset,
-                                         thread_param->zoffset,
-                                         thread_param->width,
-                                         thread_param->height,
-                                         thread_param->depth,
-                                         thread_param->format,
-                                         thread_param->type,
-                                         thread_param->texels);
+   orig_evgl_api_glExtGetTexSubImageQCOM(thread_data->target,
+                                         thread_data->level,
+                                         thread_data->xoffset,
+                                         thread_data->yoffset,
+                                         thread_data->zoffset,
+                                         thread_data->width,
+                                         thread_data->height,
+                                         thread_data->depth,
+                                         thread_data->format,
+                                         thread_data->type,
+                                         thread_data->texels);
 
 }
 
@@ -11601,30 +11605,30 @@ glExtGetTexSubImageQCOM_evgl_api_thread_cmd(GLenum target, GLint level, GLint xo
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glExtGetTexSubImageQCOM thread_param_local;
-   EVGL_API_Thread_Command_glExtGetTexSubImageQCOM *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glExtGetTexSubImageQCOM thread_data_local;
+   EVGL_API_Thread_Command_glExtGetTexSubImageQCOM *thread_data = &thread_data_local;
 
-   thread_param->target = target;
-   thread_param->level = level;
-   thread_param->xoffset = xoffset;
-   thread_param->yoffset = yoffset;
-   thread_param->zoffset = zoffset;
-   thread_param->width = width;
-   thread_param->height = height;
-   thread_param->depth = depth;
-   thread_param->format = format;
-   thread_param->type = type;
-   thread_param->texels = texels;
+   thread_data->target = target;
+   thread_data->level = level;
+   thread_data->xoffset = xoffset;
+   thread_data->yoffset = yoffset;
+   thread_data->zoffset = zoffset;
+   thread_data->width = width;
+   thread_data->height = height;
+   thread_data->depth = depth;
+   thread_data->format = format;
+   thread_data->type = type;
+   thread_data->texels = texels;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glExtGetTexSubImageQCOM,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glExtGetBufferPointervQCOM(GLenum target, void** params);
+ * void
+ * glExtGetBufferPointervQCOM(GLenum target, void** params);
  */
 
 typedef struct
@@ -11639,11 +11643,11 @@ void (*orig_evgl_api_glExtGetBufferPointervQCOM)(GLenum target, void** params);
 static void
 _evgl_api_thread_glExtGetBufferPointervQCOM(void *data)
 {
-   EVGL_API_Thread_Command_glExtGetBufferPointervQCOM *thread_param =
+   EVGL_API_Thread_Command_glExtGetBufferPointervQCOM *thread_data =
       (EVGL_API_Thread_Command_glExtGetBufferPointervQCOM *)data;
 
-   orig_evgl_api_glExtGetBufferPointervQCOM(thread_param->target,
-                                            thread_param->params);
+   orig_evgl_api_glExtGetBufferPointervQCOM(thread_data->target,
+                                            thread_data->params);
 
 }
 
@@ -11658,21 +11662,21 @@ glExtGetBufferPointervQCOM_evgl_api_thread_cmd(GLenum target, void** params)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glExtGetBufferPointervQCOM thread_param_local;
-   EVGL_API_Thread_Command_glExtGetBufferPointervQCOM *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glExtGetBufferPointervQCOM thread_data_local;
+   EVGL_API_Thread_Command_glExtGetBufferPointervQCOM *thread_data = &thread_data_local;
 
-   thread_param->target = target;
-   thread_param->params = params;
+   thread_data->target = target;
+   thread_data->params = params;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glExtGetBufferPointervQCOM,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glExtGetShadersQCOM(GLuint* shaders, GLint maxShaders, GLint* numShaders);
+ * void
+ * glExtGetShadersQCOM(GLuint* shaders, GLint maxShaders, GLint* numShaders);
  */
 
 typedef struct
@@ -11688,12 +11692,12 @@ void (*orig_evgl_api_glExtGetShadersQCOM)(GLuint* shaders, GLint maxShaders, GLi
 static void
 _evgl_api_thread_glExtGetShadersQCOM(void *data)
 {
-   EVGL_API_Thread_Command_glExtGetShadersQCOM *thread_param =
+   EVGL_API_Thread_Command_glExtGetShadersQCOM *thread_data =
       (EVGL_API_Thread_Command_glExtGetShadersQCOM *)data;
 
-   orig_evgl_api_glExtGetShadersQCOM(thread_param->shaders,
-                                     thread_param->maxShaders,
-                                     thread_param->numShaders);
+   orig_evgl_api_glExtGetShadersQCOM(thread_data->shaders,
+                                     thread_data->maxShaders,
+                                     thread_data->numShaders);
 
 }
 
@@ -11708,22 +11712,22 @@ glExtGetShadersQCOM_evgl_api_thread_cmd(GLuint* shaders, GLint maxShaders, GLint
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glExtGetShadersQCOM thread_param_local;
-   EVGL_API_Thread_Command_glExtGetShadersQCOM *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glExtGetShadersQCOM thread_data_local;
+   EVGL_API_Thread_Command_glExtGetShadersQCOM *thread_data = &thread_data_local;
 
-   thread_param->shaders = shaders;
-   thread_param->maxShaders = maxShaders;
-   thread_param->numShaders = numShaders;
+   thread_data->shaders = shaders;
+   thread_data->maxShaders = maxShaders;
+   thread_data->numShaders = numShaders;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glExtGetShadersQCOM,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glExtGetProgramsQCOM(GLuint* programs, GLint maxPrograms, GLint* numPrograms);
+ * void
+ * glExtGetProgramsQCOM(GLuint* programs, GLint maxPrograms, GLint* numPrograms);
  */
 
 typedef struct
@@ -11739,12 +11743,12 @@ void (*orig_evgl_api_glExtGetProgramsQCOM)(GLuint* programs, GLint maxPrograms,
 static void
 _evgl_api_thread_glExtGetProgramsQCOM(void *data)
 {
-   EVGL_API_Thread_Command_glExtGetProgramsQCOM *thread_param =
+   EVGL_API_Thread_Command_glExtGetProgramsQCOM *thread_data =
       (EVGL_API_Thread_Command_glExtGetProgramsQCOM *)data;
 
-   orig_evgl_api_glExtGetProgramsQCOM(thread_param->programs,
-                                      thread_param->maxPrograms,
-                                      thread_param->numPrograms);
+   orig_evgl_api_glExtGetProgramsQCOM(thread_data->programs,
+                                      thread_data->maxPrograms,
+                                      thread_data->numPrograms);
 
 }
 
@@ -11759,22 +11763,22 @@ glExtGetProgramsQCOM_evgl_api_thread_cmd(GLuint* programs, GLint maxPrograms, GL
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glExtGetProgramsQCOM thread_param_local;
-   EVGL_API_Thread_Command_glExtGetProgramsQCOM *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glExtGetProgramsQCOM thread_data_local;
+   EVGL_API_Thread_Command_glExtGetProgramsQCOM *thread_data = &thread_data_local;
 
-   thread_param->programs = programs;
-   thread_param->maxPrograms = maxPrograms;
-   thread_param->numPrograms = numPrograms;
+   thread_data->programs = programs;
+   thread_data->maxPrograms = maxPrograms;
+   thread_data->numPrograms = numPrograms;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glExtGetProgramsQCOM,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   GLboolean
-   glExtIsProgramBinaryQCOM(GLuint program);
+ * GLboolean
+ * glExtIsProgramBinaryQCOM(GLuint program);
  */
 
 typedef struct
@@ -11789,10 +11793,10 @@ GLboolean (*orig_evgl_api_glExtIsProgramBinaryQCOM)(GLuint program);
 static void
 _evgl_api_thread_glExtIsProgramBinaryQCOM(void *data)
 {
-   EVGL_API_Thread_Command_glExtIsProgramBinaryQCOM *thread_param =
+   EVGL_API_Thread_Command_glExtIsProgramBinaryQCOM *thread_data =
       (EVGL_API_Thread_Command_glExtIsProgramBinaryQCOM *)data;
 
-   thread_param->return_value = orig_evgl_api_glExtIsProgramBinaryQCOM(thread_param->program);
+   thread_data->return_value = orig_evgl_api_glExtIsProgramBinaryQCOM(thread_data->program);
 
 }
 
@@ -11806,22 +11810,22 @@ glExtIsProgramBinaryQCOM_evgl_api_thread_cmd(GLuint program)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glExtIsProgramBinaryQCOM thread_param_local;
-   EVGL_API_Thread_Command_glExtIsProgramBinaryQCOM *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glExtIsProgramBinaryQCOM thread_data_local;
+   EVGL_API_Thread_Command_glExtIsProgramBinaryQCOM *thread_data = &thread_data_local;
 
-   thread_param->program = program;
+   thread_data->program = program;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glExtIsProgramBinaryQCOM,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
-   void
-   glExtGetProgramBinarySourceQCOM(GLuint program, GLenum shadertype, char* source, GLint* length);
+ * void
+ * glExtGetProgramBinarySourceQCOM(GLuint program, GLenum shadertype, char* source, GLint* length);
  */
 
 typedef struct
@@ -11838,13 +11842,13 @@ void (*orig_evgl_api_glExtGetProgramBinarySourceQCOM)(GLuint program, GLenum sha
 static void
 _evgl_api_thread_glExtGetProgramBinarySourceQCOM(void *data)
 {
-   EVGL_API_Thread_Command_glExtGetProgramBinarySourceQCOM *thread_param =
+   EVGL_API_Thread_Command_glExtGetProgramBinarySourceQCOM *thread_data =
       (EVGL_API_Thread_Command_glExtGetProgramBinarySourceQCOM *)data;
 
-   orig_evgl_api_glExtGetProgramBinarySourceQCOM(thread_param->program,
-                                                 thread_param->shadertype,
-                                                 thread_param->source,
-                                                 thread_param->length);
+   orig_evgl_api_glExtGetProgramBinarySourceQCOM(thread_data->program,
+                                                 thread_data->shadertype,
+                                                 thread_data->source,
+                                                 thread_data->length);
 
 }
 
@@ -11859,23 +11863,23 @@ glExtGetProgramBinarySourceQCOM_evgl_api_thread_cmd(GLuint program, GLenum shade
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glExtGetProgramBinarySourceQCOM thread_param_local;
-   EVGL_API_Thread_Command_glExtGetProgramBinarySourceQCOM *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glExtGetProgramBinarySourceQCOM thread_data_local;
+   EVGL_API_Thread_Command_glExtGetProgramBinarySourceQCOM *thread_data = &thread_data_local;
 
-   thread_param->program = program;
-   thread_param->shadertype = shadertype;
-   thread_param->source = source;
-   thread_param->length = length;
+   thread_data->program = program;
+   thread_data->shadertype = shadertype;
+   thread_data->source = source;
+   thread_data->length = length;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glExtGetProgramBinarySourceQCOM,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glAlphaFunc(GLenum func, GLclampf ref);
+ * void
+ * glAlphaFunc(GLenum func, GLclampf ref);
  */
 
 typedef struct
@@ -11890,11 +11894,11 @@ void (*orig_evgl_api_glAlphaFunc)(GLenum func, GLclampf ref);
 static void
 _evgl_api_thread_glAlphaFunc(void *data)
 {
-   EVGL_API_Thread_Command_glAlphaFunc *thread_param =
+   EVGL_API_Thread_Command_glAlphaFunc *thread_data =
       (EVGL_API_Thread_Command_glAlphaFunc *)data;
 
-   orig_evgl_api_glAlphaFunc(thread_param->func,
-                             thread_param->ref);
+   orig_evgl_api_glAlphaFunc(thread_data->func,
+                             thread_data->ref);
 
 }
 
@@ -11909,21 +11913,21 @@ glAlphaFunc_evgl_api_thread_cmd(GLenum func, GLclampf ref)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glAlphaFunc thread_param_local;
-   EVGL_API_Thread_Command_glAlphaFunc *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glAlphaFunc thread_data_local;
+   EVGL_API_Thread_Command_glAlphaFunc *thread_data = &thread_data_local;
 
-   thread_param->func = func;
-   thread_param->ref = ref;
+   thread_data->func = func;
+   thread_data->ref = ref;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glAlphaFunc,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glClipPlanef(GLenum plane, const GLfloat *equation);
+ * void
+ * glClipPlanef(GLenum plane, const GLfloat *equation);
  */
 
 typedef struct
@@ -11938,11 +11942,11 @@ void (*orig_evgl_api_glClipPlanef)(GLenum plane, const GLfloat *equation);
 static void
 _evgl_api_thread_glClipPlanef(void *data)
 {
-   EVGL_API_Thread_Command_glClipPlanef *thread_param =
+   EVGL_API_Thread_Command_glClipPlanef *thread_data =
       (EVGL_API_Thread_Command_glClipPlanef *)data;
 
-   orig_evgl_api_glClipPlanef(thread_param->plane,
-                              thread_param->equation);
+   orig_evgl_api_glClipPlanef(thread_data->plane,
+                              thread_data->equation);
 
 }
 
@@ -11957,21 +11961,21 @@ glClipPlanef_evgl_api_thread_cmd(GLenum plane, const GLfloat *equation)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glClipPlanef thread_param_local;
-   EVGL_API_Thread_Command_glClipPlanef *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glClipPlanef thread_data_local;
+   EVGL_API_Thread_Command_glClipPlanef *thread_data = &thread_data_local;
 
-   thread_param->plane = plane;
-   thread_param->equation = equation;
+   thread_data->plane = plane;
+   thread_data->equation = equation;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glClipPlanef,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
+ * void
+ * glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
  */
 
 typedef struct
@@ -11988,13 +11992,13 @@ void (*orig_evgl_api_glColor4f)(GLfloat red, GLfloat green, GLfloat blue, GLfloa
 static void
 _evgl_api_thread_glColor4f(void *data)
 {
-   EVGL_API_Thread_Command_glColor4f *thread_param =
+   EVGL_API_Thread_Command_glColor4f *thread_data =
       (EVGL_API_Thread_Command_glColor4f *)data;
 
-   orig_evgl_api_glColor4f(thread_param->red,
-                           thread_param->green,
-                           thread_param->blue,
-                           thread_param->alpha);
+   orig_evgl_api_glColor4f(thread_data->red,
+                           thread_data->green,
+                           thread_data->blue,
+                           thread_data->alpha);
 
 }
 
@@ -12009,23 +12013,23 @@ glColor4f_evgl_api_thread_cmd(GLfloat red, GLfloat green, GLfloat blue, GLfloat
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glColor4f thread_param_local;
-   EVGL_API_Thread_Command_glColor4f *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glColor4f thread_data_local;
+   EVGL_API_Thread_Command_glColor4f *thread_data = &thread_data_local;
 
-   thread_param->red = red;
-   thread_param->green = green;
-   thread_param->blue = blue;
-   thread_param->alpha = alpha;
+   thread_data->red = red;
+   thread_data->green = green;
+   thread_data->blue = blue;
+   thread_data->alpha = alpha;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glColor4f,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glFogf(GLenum pname, GLfloat param);
+ * void
+ * glFogf(GLenum pname, GLfloat param);
  */
 
 typedef struct
@@ -12040,11 +12044,11 @@ void (*orig_evgl_api_glFogf)(GLenum pname, GLfloat param);
 static void
 _evgl_api_thread_glFogf(void *data)
 {
-   EVGL_API_Thread_Command_glFogf *thread_param =
+   EVGL_API_Thread_Command_glFogf *thread_data =
       (EVGL_API_Thread_Command_glFogf *)data;
 
-   orig_evgl_api_glFogf(thread_param->pname,
-                        thread_param->param);
+   orig_evgl_api_glFogf(thread_data->pname,
+                        thread_data->param);
 
 }
 
@@ -12059,21 +12063,21 @@ glFogf_evgl_api_thread_cmd(GLenum pname, GLfloat param)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glFogf thread_param_local;
-   EVGL_API_Thread_Command_glFogf *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glFogf thread_data_local;
+   EVGL_API_Thread_Command_glFogf *thread_data = &thread_data_local;
 
-   thread_param->pname = pname;
-   thread_param->param = param;
+   thread_data->pname = pname;
+   thread_data->param = param;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glFogf,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glFogfv(GLenum pname, const GLfloat *params);
+ * void
+ * glFogfv(GLenum pname, const GLfloat *params);
  */
 
 typedef struct
@@ -12088,11 +12092,11 @@ void (*orig_evgl_api_glFogfv)(GLenum pname, const GLfloat *params);
 static void
 _evgl_api_thread_glFogfv(void *data)
 {
-   EVGL_API_Thread_Command_glFogfv *thread_param =
+   EVGL_API_Thread_Command_glFogfv *thread_data =
       (EVGL_API_Thread_Command_glFogfv *)data;
 
-   orig_evgl_api_glFogfv(thread_param->pname,
-                         thread_param->params);
+   orig_evgl_api_glFogfv(thread_data->pname,
+                         thread_data->params);
 
 }
 
@@ -12107,21 +12111,21 @@ glFogfv_evgl_api_thread_cmd(GLenum pname, const GLfloat *params)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glFogfv thread_param_local;
-   EVGL_API_Thread_Command_glFogfv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glFogfv thread_data_local;
+   EVGL_API_Thread_Command_glFogfv *thread_data = &thread_data_local;
 
-   thread_param->pname = pname;
-   thread_param->params = params;
+   thread_data->pname = pname;
+   thread_data->params = params;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glFogfv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glFrustumf(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar);
+ * void
+ * glFrustumf(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar);
  */
 
 typedef struct
@@ -12140,15 +12144,15 @@ void (*orig_evgl_api_glFrustumf)(GLfloat left, GLfloat right, GLfloat bottom, GL
 static void
 _evgl_api_thread_glFrustumf(void *data)
 {
-   EVGL_API_Thread_Command_glFrustumf *thread_param =
+   EVGL_API_Thread_Command_glFrustumf *thread_data =
       (EVGL_API_Thread_Command_glFrustumf *)data;
 
-   orig_evgl_api_glFrustumf(thread_param->left,
-                            thread_param->right,
-                            thread_param->bottom,
-                            thread_param->top,
-                            thread_param->zNear,
-                            thread_param->zFar);
+   orig_evgl_api_glFrustumf(thread_data->left,
+                            thread_data->right,
+                            thread_data->bottom,
+                            thread_data->top,
+                            thread_data->zNear,
+                            thread_data->zFar);
 
 }
 
@@ -12163,25 +12167,25 @@ glFrustumf_evgl_api_thread_cmd(GLfloat left, GLfloat right, GLfloat bottom, GLfl
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glFrustumf thread_param_local;
-   EVGL_API_Thread_Command_glFrustumf *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glFrustumf thread_data_local;
+   EVGL_API_Thread_Command_glFrustumf *thread_data = &thread_data_local;
 
-   thread_param->left = left;
-   thread_param->right = right;
-   thread_param->bottom = bottom;
-   thread_param->top = top;
-   thread_param->zNear = zNear;
-   thread_param->zFar = zFar;
+   thread_data->left = left;
+   thread_data->right = right;
+   thread_data->bottom = bottom;
+   thread_data->top = top;
+   thread_data->zNear = zNear;
+   thread_data->zFar = zFar;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glFrustumf,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGetClipPlanef(GLenum pname, GLfloat eqn[4]);
+ * void
+ * glGetClipPlanef(GLenum pname, GLfloat eqn[4]);
  */
 
 typedef struct
@@ -12196,11 +12200,11 @@ void (*orig_evgl_api_glGetClipPlanef)(GLenum pname, GLfloat eqn[4]);
 static void
 _evgl_api_thread_glGetClipPlanef(void *data)
 {
-   EVGL_API_Thread_Command_glGetClipPlanef *thread_param =
+   EVGL_API_Thread_Command_glGetClipPlanef *thread_data =
       (EVGL_API_Thread_Command_glGetClipPlanef *)data;
 
-   orig_evgl_api_glGetClipPlanef(thread_param->pname,
-                                 thread_param->eqn);
+   orig_evgl_api_glGetClipPlanef(thread_data->pname,
+                                 thread_data->eqn);
 
 }
 
@@ -12215,21 +12219,21 @@ glGetClipPlanef_evgl_api_thread_cmd(GLenum pname, GLfloat eqn[4])
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGetClipPlanef thread_param_local;
-   EVGL_API_Thread_Command_glGetClipPlanef *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGetClipPlanef thread_data_local;
+   EVGL_API_Thread_Command_glGetClipPlanef *thread_data = &thread_data_local;
 
-   thread_param->pname = pname;
-   memcpy(thread_param->eqn, &eqn, sizeof(eqn));
+   thread_data->pname = pname;
+   memcpy(thread_data->eqn, &eqn, sizeof(GLfloat) * 4);
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGetClipPlanef,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGetLightfv(GLenum light, GLenum pname, GLfloat *params);
+ * void
+ * glGetLightfv(GLenum light, GLenum pname, GLfloat *params);
  */
 
 typedef struct
@@ -12245,12 +12249,12 @@ void (*orig_evgl_api_glGetLightfv)(GLenum light, GLenum pname, GLfloat *params);
 static void
 _evgl_api_thread_glGetLightfv(void *data)
 {
-   EVGL_API_Thread_Command_glGetLightfv *thread_param =
+   EVGL_API_Thread_Command_glGetLightfv *thread_data =
       (EVGL_API_Thread_Command_glGetLightfv *)data;
 
-   orig_evgl_api_glGetLightfv(thread_param->light,
-                              thread_param->pname,
-                              thread_param->params);
+   orig_evgl_api_glGetLightfv(thread_data->light,
+                              thread_data->pname,
+                              thread_data->params);
 
 }
 
@@ -12265,22 +12269,22 @@ glGetLightfv_evgl_api_thread_cmd(GLenum light, GLenum pname, GLfloat *params)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGetLightfv thread_param_local;
-   EVGL_API_Thread_Command_glGetLightfv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGetLightfv thread_data_local;
+   EVGL_API_Thread_Command_glGetLightfv *thread_data = &thread_data_local;
 
-   thread_param->light = light;
-   thread_param->pname = pname;
-   thread_param->params = params;
+   thread_data->light = light;
+   thread_data->pname = pname;
+   thread_data->params = params;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGetLightfv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGetMaterialfv(GLenum face, GLenum pname, GLfloat *params);
+ * void
+ * glGetMaterialfv(GLenum face, GLenum pname, GLfloat *params);
  */
 
 typedef struct
@@ -12296,12 +12300,12 @@ void (*orig_evgl_api_glGetMaterialfv)(GLenum face, GLenum pname, GLfloat *params
 static void
 _evgl_api_thread_glGetMaterialfv(void *data)
 {
-   EVGL_API_Thread_Command_glGetMaterialfv *thread_param =
+   EVGL_API_Thread_Command_glGetMaterialfv *thread_data =
       (EVGL_API_Thread_Command_glGetMaterialfv *)data;
 
-   orig_evgl_api_glGetMaterialfv(thread_param->face,
-                                 thread_param->pname,
-                                 thread_param->params);
+   orig_evgl_api_glGetMaterialfv(thread_data->face,
+                                 thread_data->pname,
+                                 thread_data->params);
 
 }
 
@@ -12316,22 +12320,22 @@ glGetMaterialfv_evgl_api_thread_cmd(GLenum face, GLenum pname, GLfloat *params)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGetMaterialfv thread_param_local;
-   EVGL_API_Thread_Command_glGetMaterialfv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGetMaterialfv thread_data_local;
+   EVGL_API_Thread_Command_glGetMaterialfv *thread_data = &thread_data_local;
 
-   thread_param->face = face;
-   thread_param->pname = pname;
-   thread_param->params = params;
+   thread_data->face = face;
+   thread_data->pname = pname;
+   thread_data->params = params;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGetMaterialfv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGetTexEnvfv(GLenum env, GLenum pname, GLfloat *params);
+ * void
+ * glGetTexEnvfv(GLenum env, GLenum pname, GLfloat *params);
  */
 
 typedef struct
@@ -12347,12 +12351,12 @@ void (*orig_evgl_api_glGetTexEnvfv)(GLenum env, GLenum pname, GLfloat *params);
 static void
 _evgl_api_thread_glGetTexEnvfv(void *data)
 {
-   EVGL_API_Thread_Command_glGetTexEnvfv *thread_param =
+   EVGL_API_Thread_Command_glGetTexEnvfv *thread_data =
       (EVGL_API_Thread_Command_glGetTexEnvfv *)data;
 
-   orig_evgl_api_glGetTexEnvfv(thread_param->env,
-                               thread_param->pname,
-                               thread_param->params);
+   orig_evgl_api_glGetTexEnvfv(thread_data->env,
+                               thread_data->pname,
+                               thread_data->params);
 
 }
 
@@ -12367,22 +12371,22 @@ glGetTexEnvfv_evgl_api_thread_cmd(GLenum env, GLenum pname, GLfloat *params)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGetTexEnvfv thread_param_local;
-   EVGL_API_Thread_Command_glGetTexEnvfv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGetTexEnvfv thread_data_local;
+   EVGL_API_Thread_Command_glGetTexEnvfv *thread_data = &thread_data_local;
 
-   thread_param->env = env;
-   thread_param->pname = pname;
-   thread_param->params = params;
+   thread_data->env = env;
+   thread_data->pname = pname;
+   thread_data->params = params;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGetTexEnvfv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glLightModelf(GLenum pname, GLfloat param);
+ * void
+ * glLightModelf(GLenum pname, GLfloat param);
  */
 
 typedef struct
@@ -12397,11 +12401,11 @@ void (*orig_evgl_api_glLightModelf)(GLenum pname, GLfloat param);
 static void
 _evgl_api_thread_glLightModelf(void *data)
 {
-   EVGL_API_Thread_Command_glLightModelf *thread_param =
+   EVGL_API_Thread_Command_glLightModelf *thread_data =
       (EVGL_API_Thread_Command_glLightModelf *)data;
 
-   orig_evgl_api_glLightModelf(thread_param->pname,
-                               thread_param->param);
+   orig_evgl_api_glLightModelf(thread_data->pname,
+                               thread_data->param);
 
 }
 
@@ -12416,21 +12420,21 @@ glLightModelf_evgl_api_thread_cmd(GLenum pname, GLfloat param)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glLightModelf thread_param_local;
-   EVGL_API_Thread_Command_glLightModelf *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glLightModelf thread_data_local;
+   EVGL_API_Thread_Command_glLightModelf *thread_data = &thread_data_local;
 
-   thread_param->pname = pname;
-   thread_param->param = param;
+   thread_data->pname = pname;
+   thread_data->param = param;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glLightModelf,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glLightModelfv(GLenum pname, const GLfloat *params);
+ * void
+ * glLightModelfv(GLenum pname, const GLfloat *params);
  */
 
 typedef struct
@@ -12445,11 +12449,11 @@ void (*orig_evgl_api_glLightModelfv)(GLenum pname, const GLfloat *params);
 static void
 _evgl_api_thread_glLightModelfv(void *data)
 {
-   EVGL_API_Thread_Command_glLightModelfv *thread_param =
+   EVGL_API_Thread_Command_glLightModelfv *thread_data =
       (EVGL_API_Thread_Command_glLightModelfv *)data;
 
-   orig_evgl_api_glLightModelfv(thread_param->pname,
-                                thread_param->params);
+   orig_evgl_api_glLightModelfv(thread_data->pname,
+                                thread_data->params);
 
 }
 
@@ -12464,21 +12468,21 @@ glLightModelfv_evgl_api_thread_cmd(GLenum pname, const GLfloat *params)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glLightModelfv thread_param_local;
-   EVGL_API_Thread_Command_glLightModelfv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glLightModelfv thread_data_local;
+   EVGL_API_Thread_Command_glLightModelfv *thread_data = &thread_data_local;
 
-   thread_param->pname = pname;
-   thread_param->params = params;
+   thread_data->pname = pname;
+   thread_data->params = params;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glLightModelfv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glLightf(GLenum light, GLenum pname, GLfloat param);
+ * void
+ * glLightf(GLenum light, GLenum pname, GLfloat param);
  */
 
 typedef struct
@@ -12494,12 +12498,12 @@ void (*orig_evgl_api_glLightf)(GLenum light, GLenum pname, GLfloat param);
 static void
 _evgl_api_thread_glLightf(void *data)
 {
-   EVGL_API_Thread_Command_glLightf *thread_param =
+   EVGL_API_Thread_Command_glLightf *thread_data =
       (EVGL_API_Thread_Command_glLightf *)data;
 
-   orig_evgl_api_glLightf(thread_param->light,
-                          thread_param->pname,
-                          thread_param->param);
+   orig_evgl_api_glLightf(thread_data->light,
+                          thread_data->pname,
+                          thread_data->param);
 
 }
 
@@ -12514,22 +12518,22 @@ glLightf_evgl_api_thread_cmd(GLenum light, GLenum pname, GLfloat param)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glLightf thread_param_local;
-   EVGL_API_Thread_Command_glLightf *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glLightf thread_data_local;
+   EVGL_API_Thread_Command_glLightf *thread_data = &thread_data_local;
 
-   thread_param->light = light;
-   thread_param->pname = pname;
-   thread_param->param = param;
+   thread_data->light = light;
+   thread_data->pname = pname;
+   thread_data->param = param;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glLightf,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glLightfv(GLenum light, GLenum pname, const GLfloat *params);
+ * void
+ * glLightfv(GLenum light, GLenum pname, const GLfloat *params);
  */
 
 typedef struct
@@ -12545,12 +12549,12 @@ void (*orig_evgl_api_glLightfv)(GLenum light, GLenum pname, const GLfloat *param
 static void
 _evgl_api_thread_glLightfv(void *data)
 {
-   EVGL_API_Thread_Command_glLightfv *thread_param =
+   EVGL_API_Thread_Command_glLightfv *thread_data =
       (EVGL_API_Thread_Command_glLightfv *)data;
 
-   orig_evgl_api_glLightfv(thread_param->light,
-                           thread_param->pname,
-                           thread_param->params);
+   orig_evgl_api_glLightfv(thread_data->light,
+                           thread_data->pname,
+                           thread_data->params);
 
 }
 
@@ -12565,22 +12569,22 @@ glLightfv_evgl_api_thread_cmd(GLenum light, GLenum pname, const GLfloat *params)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glLightfv thread_param_local;
-   EVGL_API_Thread_Command_glLightfv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glLightfv thread_data_local;
+   EVGL_API_Thread_Command_glLightfv *thread_data = &thread_data_local;
 
-   thread_param->light = light;
-   thread_param->pname = pname;
-   thread_param->params = params;
+   thread_data->light = light;
+   thread_data->pname = pname;
+   thread_data->params = params;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glLightfv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glLoadMatrixf(const GLfloat *m);
+ * void
+ * glLoadMatrixf(const GLfloat *m);
  */
 
 typedef struct
@@ -12594,10 +12598,10 @@ void (*orig_evgl_api_glLoadMatrixf)(const GLfloat *m);
 static void
 _evgl_api_thread_glLoadMatrixf(void *data)
 {
-   EVGL_API_Thread_Command_glLoadMatrixf *thread_param =
+   EVGL_API_Thread_Command_glLoadMatrixf *thread_data =
       (EVGL_API_Thread_Command_glLoadMatrixf *)data;
 
-   orig_evgl_api_glLoadMatrixf(thread_param->m);
+   orig_evgl_api_glLoadMatrixf(thread_data->m);
 
 }
 
@@ -12612,20 +12616,20 @@ glLoadMatrixf_evgl_api_thread_cmd(const GLfloat *m)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glLoadMatrixf thread_param_local;
-   EVGL_API_Thread_Command_glLoadMatrixf *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glLoadMatrixf thread_data_local;
+   EVGL_API_Thread_Command_glLoadMatrixf *thread_data = &thread_data_local;
 
-   thread_param->m = m;
+   thread_data->m = m;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glLoadMatrixf,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glMaterialf(GLenum face, GLenum pname, GLfloat param);
+ * void
+ * glMaterialf(GLenum face, GLenum pname, GLfloat param);
  */
 
 typedef struct
@@ -12641,12 +12645,12 @@ void (*orig_evgl_api_glMaterialf)(GLenum face, GLenum pname, GLfloat param);
 static void
 _evgl_api_thread_glMaterialf(void *data)
 {
-   EVGL_API_Thread_Command_glMaterialf *thread_param =
+   EVGL_API_Thread_Command_glMaterialf *thread_data =
       (EVGL_API_Thread_Command_glMaterialf *)data;
 
-   orig_evgl_api_glMaterialf(thread_param->face,
-                             thread_param->pname,
-                             thread_param->param);
+   orig_evgl_api_glMaterialf(thread_data->face,
+                             thread_data->pname,
+                             thread_data->param);
 
 }
 
@@ -12661,22 +12665,22 @@ glMaterialf_evgl_api_thread_cmd(GLenum face, GLenum pname, GLfloat param)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glMaterialf thread_param_local;
-   EVGL_API_Thread_Command_glMaterialf *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glMaterialf thread_data_local;
+   EVGL_API_Thread_Command_glMaterialf *thread_data = &thread_data_local;
 
-   thread_param->face = face;
-   thread_param->pname = pname;
-   thread_param->param = param;
+   thread_data->face = face;
+   thread_data->pname = pname;
+   thread_data->param = param;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glMaterialf,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glMaterialfv(GLenum face, GLenum pname, const GLfloat *params);
+ * void
+ * glMaterialfv(GLenum face, GLenum pname, const GLfloat *params);
  */
 
 typedef struct
@@ -12692,12 +12696,12 @@ void (*orig_evgl_api_glMaterialfv)(GLenum face, GLenum pname, const GLfloat *par
 static void
 _evgl_api_thread_glMaterialfv(void *data)
 {
-   EVGL_API_Thread_Command_glMaterialfv *thread_param =
+   EVGL_API_Thread_Command_glMaterialfv *thread_data =
       (EVGL_API_Thread_Command_glMaterialfv *)data;
 
-   orig_evgl_api_glMaterialfv(thread_param->face,
-                              thread_param->pname,
-                              thread_param->params);
+   orig_evgl_api_glMaterialfv(thread_data->face,
+                              thread_data->pname,
+                              thread_data->params);
 
 }
 
@@ -12712,22 +12716,22 @@ glMaterialfv_evgl_api_thread_cmd(GLenum face, GLenum pname, const GLfloat *param
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glMaterialfv thread_param_local;
-   EVGL_API_Thread_Command_glMaterialfv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glMaterialfv thread_data_local;
+   EVGL_API_Thread_Command_glMaterialfv *thread_data = &thread_data_local;
 
-   thread_param->face = face;
-   thread_param->pname = pname;
-   thread_param->params = params;
+   thread_data->face = face;
+   thread_data->pname = pname;
+   thread_data->params = params;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glMaterialfv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glMultMatrixf(const GLfloat *m);
+ * void
+ * glMultMatrixf(const GLfloat *m);
  */
 
 typedef struct
@@ -12741,10 +12745,10 @@ void (*orig_evgl_api_glMultMatrixf)(const GLfloat *m);
 static void
 _evgl_api_thread_glMultMatrixf(void *data)
 {
-   EVGL_API_Thread_Command_glMultMatrixf *thread_param =
+   EVGL_API_Thread_Command_glMultMatrixf *thread_data =
       (EVGL_API_Thread_Command_glMultMatrixf *)data;
 
-   orig_evgl_api_glMultMatrixf(thread_param->m);
+   orig_evgl_api_glMultMatrixf(thread_data->m);
 
 }
 
@@ -12759,20 +12763,20 @@ glMultMatrixf_evgl_api_thread_cmd(const GLfloat *m)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glMultMatrixf thread_param_local;
-   EVGL_API_Thread_Command_glMultMatrixf *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glMultMatrixf thread_data_local;
+   EVGL_API_Thread_Command_glMultMatrixf *thread_data = &thread_data_local;
 
-   thread_param->m = m;
+   thread_data->m = m;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glMultMatrixf,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glMultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q);
+ * void
+ * glMultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q);
  */
 
 typedef struct
@@ -12790,14 +12794,14 @@ void (*orig_evgl_api_glMultiTexCoord4f)(GLenum target, GLfloat s, GLfloat t, GLf
 static void
 _evgl_api_thread_glMultiTexCoord4f(void *data)
 {
-   EVGL_API_Thread_Command_glMultiTexCoord4f *thread_param =
+   EVGL_API_Thread_Command_glMultiTexCoord4f *thread_data =
       (EVGL_API_Thread_Command_glMultiTexCoord4f *)data;
 
-   orig_evgl_api_glMultiTexCoord4f(thread_param->target,
-                                   thread_param->s,
-                                   thread_param->t,
-                                   thread_param->r,
-                                   thread_param->q);
+   orig_evgl_api_glMultiTexCoord4f(thread_data->target,
+                                   thread_data->s,
+                                   thread_data->t,
+                                   thread_data->r,
+                                   thread_data->q);
 
 }
 
@@ -12812,24 +12816,24 @@ glMultiTexCoord4f_evgl_api_thread_cmd(GLenum target, GLfloat s, GLfloat t, GLflo
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glMultiTexCoord4f thread_param_local;
-   EVGL_API_Thread_Command_glMultiTexCoord4f *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glMultiTexCoord4f thread_data_local;
+   EVGL_API_Thread_Command_glMultiTexCoord4f *thread_data = &thread_data_local;
 
-   thread_param->target = target;
-   thread_param->s = s;
-   thread_param->t = t;
-   thread_param->r = r;
-   thread_param->q = q;
+   thread_data->target = target;
+   thread_data->s = s;
+   thread_data->t = t;
+   thread_data->r = r;
+   thread_data->q = q;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glMultiTexCoord4f,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz);
+ * void
+ * glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz);
  */
 
 typedef struct
@@ -12845,12 +12849,12 @@ void (*orig_evgl_api_glNormal3f)(GLfloat nx, GLfloat ny, GLfloat nz);
 static void
 _evgl_api_thread_glNormal3f(void *data)
 {
-   EVGL_API_Thread_Command_glNormal3f *thread_param =
+   EVGL_API_Thread_Command_glNormal3f *thread_data =
       (EVGL_API_Thread_Command_glNormal3f *)data;
 
-   orig_evgl_api_glNormal3f(thread_param->nx,
-                            thread_param->ny,
-                            thread_param->nz);
+   orig_evgl_api_glNormal3f(thread_data->nx,
+                            thread_data->ny,
+                            thread_data->nz);
 
 }
 
@@ -12865,22 +12869,22 @@ glNormal3f_evgl_api_thread_cmd(GLfloat nx, GLfloat ny, GLfloat nz)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glNormal3f thread_param_local;
-   EVGL_API_Thread_Command_glNormal3f *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glNormal3f thread_data_local;
+   EVGL_API_Thread_Command_glNormal3f *thread_data = &thread_data_local;
 
-   thread_param->nx = nx;
-   thread_param->ny = ny;
-   thread_param->nz = nz;
+   thread_data->nx = nx;
+   thread_data->ny = ny;
+   thread_data->nz = nz;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glNormal3f,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glOrthof(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar);
+ * void
+ * glOrthof(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar);
  */
 
 typedef struct
@@ -12899,15 +12903,15 @@ void (*orig_evgl_api_glOrthof)(GLfloat left, GLfloat right, GLfloat bottom, GLfl
 static void
 _evgl_api_thread_glOrthof(void *data)
 {
-   EVGL_API_Thread_Command_glOrthof *thread_param =
+   EVGL_API_Thread_Command_glOrthof *thread_data =
       (EVGL_API_Thread_Command_glOrthof *)data;
 
-   orig_evgl_api_glOrthof(thread_param->left,
-                          thread_param->right,
-                          thread_param->bottom,
-                          thread_param->top,
-                          thread_param->zNear,
-                          thread_param->zFar);
+   orig_evgl_api_glOrthof(thread_data->left,
+                          thread_data->right,
+                          thread_data->bottom,
+                          thread_data->top,
+                          thread_data->zNear,
+                          thread_data->zFar);
 
 }
 
@@ -12922,25 +12926,25 @@ glOrthof_evgl_api_thread_cmd(GLfloat left, GLfloat right, GLfloat bottom, GLfloa
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glOrthof thread_param_local;
-   EVGL_API_Thread_Command_glOrthof *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glOrthof thread_data_local;
+   EVGL_API_Thread_Command_glOrthof *thread_data = &thread_data_local;
 
-   thread_param->left = left;
-   thread_param->right = right;
-   thread_param->bottom = bottom;
-   thread_param->top = top;
-   thread_param->zNear = zNear;
-   thread_param->zFar = zFar;
+   thread_data->left = left;
+   thread_data->right = right;
+   thread_data->bottom = bottom;
+   thread_data->top = top;
+   thread_data->zNear = zNear;
+   thread_data->zFar = zFar;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glOrthof,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glPointParameterf(GLenum pname, GLfloat param);
+ * void
+ * glPointParameterf(GLenum pname, GLfloat param);
  */
 
 typedef struct
@@ -12955,11 +12959,11 @@ void (*orig_evgl_api_glPointParameterf)(GLenum pname, GLfloat param);
 static void
 _evgl_api_thread_glPointParameterf(void *data)
 {
-   EVGL_API_Thread_Command_glPointParameterf *thread_param =
+   EVGL_API_Thread_Command_glPointParameterf *thread_data =
       (EVGL_API_Thread_Command_glPointParameterf *)data;
 
-   orig_evgl_api_glPointParameterf(thread_param->pname,
-                                   thread_param->param);
+   orig_evgl_api_glPointParameterf(thread_data->pname,
+                                   thread_data->param);
 
 }
 
@@ -12974,21 +12978,21 @@ glPointParameterf_evgl_api_thread_cmd(GLenum pname, GLfloat param)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glPointParameterf thread_param_local;
-   EVGL_API_Thread_Command_glPointParameterf *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glPointParameterf thread_data_local;
+   EVGL_API_Thread_Command_glPointParameterf *thread_data = &thread_data_local;
 
-   thread_param->pname = pname;
-   thread_param->param = param;
+   thread_data->pname = pname;
+   thread_data->param = param;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glPointParameterf,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glPointParameterfv(GLenum pname, const GLfloat *params);
+ * void
+ * glPointParameterfv(GLenum pname, const GLfloat *params);
  */
 
 typedef struct
@@ -13003,11 +13007,11 @@ void (*orig_evgl_api_glPointParameterfv)(GLenum pname, const GLfloat *params);
 static void
 _evgl_api_thread_glPointParameterfv(void *data)
 {
-   EVGL_API_Thread_Command_glPointParameterfv *thread_param =
+   EVGL_API_Thread_Command_glPointParameterfv *thread_data =
       (EVGL_API_Thread_Command_glPointParameterfv *)data;
 
-   orig_evgl_api_glPointParameterfv(thread_param->pname,
-                                    thread_param->params);
+   orig_evgl_api_glPointParameterfv(thread_data->pname,
+                                    thread_data->params);
 
 }
 
@@ -13022,21 +13026,21 @@ glPointParameterfv_evgl_api_thread_cmd(GLenum pname, const GLfloat *params)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glPointParameterfv thread_param_local;
-   EVGL_API_Thread_Command_glPointParameterfv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glPointParameterfv thread_data_local;
+   EVGL_API_Thread_Command_glPointParameterfv *thread_data = &thread_data_local;
 
-   thread_param->pname = pname;
-   thread_param->params = params;
+   thread_data->pname = pname;
+   thread_data->params = params;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glPointParameterfv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glPointSize(GLfloat size);
+ * void
+ * glPointSize(GLfloat size);
  */
 
 typedef struct
@@ -13050,10 +13054,10 @@ void (*orig_evgl_api_glPointSize)(GLfloat size);
 static void
 _evgl_api_thread_glPointSize(void *data)
 {
-   EVGL_API_Thread_Command_glPointSize *thread_param =
+   EVGL_API_Thread_Command_glPointSize *thread_data =
       (EVGL_API_Thread_Command_glPointSize *)data;
 
-   orig_evgl_api_glPointSize(thread_param->size);
+   orig_evgl_api_glPointSize(thread_data->size);
 
 }
 
@@ -13068,20 +13072,20 @@ glPointSize_evgl_api_thread_cmd(GLfloat size)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glPointSize thread_param_local;
-   EVGL_API_Thread_Command_glPointSize *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glPointSize thread_data_local;
+   EVGL_API_Thread_Command_glPointSize *thread_data = &thread_data_local;
 
-   thread_param->size = size;
+   thread_data->size = size;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glPointSize,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glPointSizePointerOES(GLenum type, GLsizei stride, const GLvoid * pointer);
+ * void
+ * glPointSizePointerOES(GLenum type, GLsizei stride, const GLvoid * pointer);
  */
 
 typedef struct
@@ -13097,12 +13101,12 @@ void (*orig_evgl_api_glPointSizePointerOES)(GLenum type, GLsizei stride, const G
 static void
 _evgl_api_thread_glPointSizePointerOES(void *data)
 {
-   EVGL_API_Thread_Command_glPointSizePointerOES *thread_param =
+   EVGL_API_Thread_Command_glPointSizePointerOES *thread_data =
       (EVGL_API_Thread_Command_glPointSizePointerOES *)data;
 
-   orig_evgl_api_glPointSizePointerOES(thread_param->type,
-                                       thread_param->stride,
-                                       thread_param->pointer);
+   orig_evgl_api_glPointSizePointerOES(thread_data->type,
+                                       thread_data->stride,
+                                       thread_data->pointer);
 
 }
 
@@ -13117,22 +13121,22 @@ glPointSizePointerOES_evgl_api_thread_cmd(GLenum type, GLsizei stride, const GLv
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glPointSizePointerOES thread_param_local;
-   EVGL_API_Thread_Command_glPointSizePointerOES *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glPointSizePointerOES thread_data_local;
+   EVGL_API_Thread_Command_glPointSizePointerOES *thread_data = &thread_data_local;
 
-   thread_param->type = type;
-   thread_param->stride = stride;
-   thread_param->pointer = pointer;
+   thread_data->type = type;
+   thread_data->stride = stride;
+   thread_data->pointer = pointer;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glPointSizePointerOES,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z);
+ * void
+ * glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z);
  */
 
 typedef struct
@@ -13149,13 +13153,13 @@ void (*orig_evgl_api_glRotatef)(GLfloat angle, GLfloat x, GLfloat y, GLfloat z);
 static void
 _evgl_api_thread_glRotatef(void *data)
 {
-   EVGL_API_Thread_Command_glRotatef *thread_param =
+   EVGL_API_Thread_Command_glRotatef *thread_data =
       (EVGL_API_Thread_Command_glRotatef *)data;
 
-   orig_evgl_api_glRotatef(thread_param->angle,
-                           thread_param->x,
-                           thread_param->y,
-                           thread_param->z);
+   orig_evgl_api_glRotatef(thread_data->angle,
+                           thread_data->x,
+                           thread_data->y,
+                           thread_data->z);
 
 }
 
@@ -13170,23 +13174,23 @@ glRotatef_evgl_api_thread_cmd(GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glRotatef thread_param_local;
-   EVGL_API_Thread_Command_glRotatef *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glRotatef thread_data_local;
+   EVGL_API_Thread_Command_glRotatef *thread_data = &thread_data_local;
 
-   thread_param->angle = angle;
-   thread_param->x = x;
-   thread_param->y = y;
-   thread_param->z = z;
+   thread_data->angle = angle;
+   thread_data->x = x;
+   thread_data->y = y;
+   thread_data->z = z;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glRotatef,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glScalef(GLfloat x, GLfloat y, GLfloat z);
+ * void
+ * glScalef(GLfloat x, GLfloat y, GLfloat z);
  */
 
 typedef struct
@@ -13202,12 +13206,12 @@ void (*orig_evgl_api_glScalef)(GLfloat x, GLfloat y, GLfloat z);
 static void
 _evgl_api_thread_glScalef(void *data)
 {
-   EVGL_API_Thread_Command_glScalef *thread_param =
+   EVGL_API_Thread_Command_glScalef *thread_data =
       (EVGL_API_Thread_Command_glScalef *)data;
 
-   orig_evgl_api_glScalef(thread_param->x,
-                          thread_param->y,
-                          thread_param->z);
+   orig_evgl_api_glScalef(thread_data->x,
+                          thread_data->y,
+                          thread_data->z);
 
 }
 
@@ -13222,22 +13226,22 @@ glScalef_evgl_api_thread_cmd(GLfloat x, GLfloat y, GLfloat z)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glScalef thread_param_local;
-   EVGL_API_Thread_Command_glScalef *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glScalef thread_data_local;
+   EVGL_API_Thread_Command_glScalef *thread_data = &thread_data_local;
 
-   thread_param->x = x;
-   thread_param->y = y;
-   thread_param->z = z;
+   thread_data->x = x;
+   thread_data->y = y;
+   thread_data->z = z;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glScalef,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glTexEnvf(GLenum target, GLenum pname, GLfloat param);
+ * void
+ * glTexEnvf(GLenum target, GLenum pname, GLfloat param);
  */
 
 typedef struct
@@ -13253,12 +13257,12 @@ void (*orig_evgl_api_glTexEnvf)(GLenum target, GLenum pname, GLfloat param);
 static void
 _evgl_api_thread_glTexEnvf(void *data)
 {
-   EVGL_API_Thread_Command_glTexEnvf *thread_param =
+   EVGL_API_Thread_Command_glTexEnvf *thread_data =
       (EVGL_API_Thread_Command_glTexEnvf *)data;
 
-   orig_evgl_api_glTexEnvf(thread_param->target,
-                           thread_param->pname,
-                           thread_param->param);
+   orig_evgl_api_glTexEnvf(thread_data->target,
+                           thread_data->pname,
+                           thread_data->param);
 
 }
 
@@ -13273,22 +13277,22 @@ glTexEnvf_evgl_api_thread_cmd(GLenum target, GLenum pname, GLfloat param)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glTexEnvf thread_param_local;
-   EVGL_API_Thread_Command_glTexEnvf *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glTexEnvf thread_data_local;
+   EVGL_API_Thread_Command_glTexEnvf *thread_data = &thread_data_local;
 
-   thread_param->target = target;
-   thread_param->pname = pname;
-   thread_param->param = param;
+   thread_data->target = target;
+   thread_data->pname = pname;
+   thread_data->param = param;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glTexEnvf,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glTexEnvfv(GLenum target, GLenum pname, const GLfloat *params);
+ * void
+ * glTexEnvfv(GLenum target, GLenum pname, const GLfloat *params);
  */
 
 typedef struct
@@ -13304,12 +13308,12 @@ void (*orig_evgl_api_glTexEnvfv)(GLenum target, GLenum pname, const GLfloat *par
 static void
 _evgl_api_thread_glTexEnvfv(void *data)
 {
-   EVGL_API_Thread_Command_glTexEnvfv *thread_param =
+   EVGL_API_Thread_Command_glTexEnvfv *thread_data =
       (EVGL_API_Thread_Command_glTexEnvfv *)data;
 
-   orig_evgl_api_glTexEnvfv(thread_param->target,
-                            thread_param->pname,
-                            thread_param->params);
+   orig_evgl_api_glTexEnvfv(thread_data->target,
+                            thread_data->pname,
+                            thread_data->params);
 
 }
 
@@ -13324,22 +13328,22 @@ glTexEnvfv_evgl_api_thread_cmd(GLenum target, GLenum pname, const GLfloat *param
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glTexEnvfv thread_param_local;
-   EVGL_API_Thread_Command_glTexEnvfv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glTexEnvfv thread_data_local;
+   EVGL_API_Thread_Command_glTexEnvfv *thread_data = &thread_data_local;
 
-   thread_param->target = target;
-   thread_param->pname = pname;
-   thread_param->params = params;
+   thread_data->target = target;
+   thread_data->pname = pname;
+   thread_data->params = params;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glTexEnvfv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glTranslatef(GLfloat x, GLfloat y, GLfloat z);
+ * void
+ * glTranslatef(GLfloat x, GLfloat y, GLfloat z);
  */
 
 typedef struct
@@ -13355,12 +13359,12 @@ void (*orig_evgl_api_glTranslatef)(GLfloat x, GLfloat y, GLfloat z);
 static void
 _evgl_api_thread_glTranslatef(void *data)
 {
-   EVGL_API_Thread_Command_glTranslatef *thread_param =
+   EVGL_API_Thread_Command_glTranslatef *thread_data =
       (EVGL_API_Thread_Command_glTranslatef *)data;
 
-   orig_evgl_api_glTranslatef(thread_param->x,
-                              thread_param->y,
-                              thread_param->z);
+   orig_evgl_api_glTranslatef(thread_data->x,
+                              thread_data->y,
+                              thread_data->z);
 
 }
 
@@ -13375,22 +13379,22 @@ glTranslatef_evgl_api_thread_cmd(GLfloat x, GLfloat y, GLfloat z)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glTranslatef thread_param_local;
-   EVGL_API_Thread_Command_glTranslatef *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glTranslatef thread_data_local;
+   EVGL_API_Thread_Command_glTranslatef *thread_data = &thread_data_local;
 
-   thread_param->x = x;
-   thread_param->y = y;
-   thread_param->z = z;
+   thread_data->x = x;
+   thread_data->y = y;
+   thread_data->z = z;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glTranslatef,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glAlphaFuncx(GLenum func, GLclampx ref);
+ * void
+ * glAlphaFuncx(GLenum func, GLclampx ref);
  */
 
 typedef struct
@@ -13405,11 +13409,11 @@ void (*orig_evgl_api_glAlphaFuncx)(GLenum func, GLclampx ref);
 static void
 _evgl_api_thread_glAlphaFuncx(void *data)
 {
-   EVGL_API_Thread_Command_glAlphaFuncx *thread_param =
+   EVGL_API_Thread_Command_glAlphaFuncx *thread_data =
       (EVGL_API_Thread_Command_glAlphaFuncx *)data;
 
-   orig_evgl_api_glAlphaFuncx(thread_param->func,
-                              thread_param->ref);
+   orig_evgl_api_glAlphaFuncx(thread_data->func,
+                              thread_data->ref);
 
 }
 
@@ -13424,21 +13428,21 @@ glAlphaFuncx_evgl_api_thread_cmd(GLenum func, GLclampx ref)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glAlphaFuncx thread_param_local;
-   EVGL_API_Thread_Command_glAlphaFuncx *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glAlphaFuncx thread_data_local;
+   EVGL_API_Thread_Command_glAlphaFuncx *thread_data = &thread_data_local;
 
-   thread_param->func = func;
-   thread_param->ref = ref;
+   thread_data->func = func;
+   thread_data->ref = ref;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glAlphaFuncx,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glClearColorx(GLclampx red, GLclampx green, GLclampx blue, GLclampx alpha);
+ * void
+ * glClearColorx(GLclampx red, GLclampx green, GLclampx blue, GLclampx alpha);
  */
 
 typedef struct
@@ -13455,13 +13459,13 @@ void (*orig_evgl_api_glClearColorx)(GLclampx red, GLclampx green, GLclampx blue,
 static void
 _evgl_api_thread_glClearColorx(void *data)
 {
-   EVGL_API_Thread_Command_glClearColorx *thread_param =
+   EVGL_API_Thread_Command_glClearColorx *thread_data =
       (EVGL_API_Thread_Command_glClearColorx *)data;
 
-   orig_evgl_api_glClearColorx(thread_param->red,
-                               thread_param->green,
-                               thread_param->blue,
-                               thread_param->alpha);
+   orig_evgl_api_glClearColorx(thread_data->red,
+                               thread_data->green,
+                               thread_data->blue,
+                               thread_data->alpha);
 
 }
 
@@ -13476,23 +13480,23 @@ glClearColorx_evgl_api_thread_cmd(GLclampx red, GLclampx green, GLclampx blue, G
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glClearColorx thread_param_local;
-   EVGL_API_Thread_Command_glClearColorx *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glClearColorx thread_data_local;
+   EVGL_API_Thread_Command_glClearColorx *thread_data = &thread_data_local;
 
-   thread_param->red = red;
-   thread_param->green = green;
-   thread_param->blue = blue;
-   thread_param->alpha = alpha;
+   thread_data->red = red;
+   thread_data->green = green;
+   thread_data->blue = blue;
+   thread_data->alpha = alpha;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glClearColorx,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glClearDepthx(GLclampx depth);
+ * void
+ * glClearDepthx(GLclampx depth);
  */
 
 typedef struct
@@ -13506,10 +13510,10 @@ void (*orig_evgl_api_glClearDepthx)(GLclampx depth);
 static void
 _evgl_api_thread_glClearDepthx(void *data)
 {
-   EVGL_API_Thread_Command_glClearDepthx *thread_param =
+   EVGL_API_Thread_Command_glClearDepthx *thread_data =
       (EVGL_API_Thread_Command_glClearDepthx *)data;
 
-   orig_evgl_api_glClearDepthx(thread_param->depth);
+   orig_evgl_api_glClearDepthx(thread_data->depth);
 
 }
 
@@ -13524,20 +13528,20 @@ glClearDepthx_evgl_api_thread_cmd(GLclampx depth)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glClearDepthx thread_param_local;
-   EVGL_API_Thread_Command_glClearDepthx *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glClearDepthx thread_data_local;
+   EVGL_API_Thread_Command_glClearDepthx *thread_data = &thread_data_local;
 
-   thread_param->depth = depth;
+   thread_data->depth = depth;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glClearDepthx,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glClientActiveTexture(GLenum texture);
+ * void
+ * glClientActiveTexture(GLenum texture);
  */
 
 typedef struct
@@ -13551,10 +13555,10 @@ void (*orig_evgl_api_glClientActiveTexture)(GLenum texture);
 static void
 _evgl_api_thread_glClientActiveTexture(void *data)
 {
-   EVGL_API_Thread_Command_glClientActiveTexture *thread_param =
+   EVGL_API_Thread_Command_glClientActiveTexture *thread_data =
       (EVGL_API_Thread_Command_glClientActiveTexture *)data;
 
-   orig_evgl_api_glClientActiveTexture(thread_param->texture);
+   orig_evgl_api_glClientActiveTexture(thread_data->texture);
 
 }
 
@@ -13569,20 +13573,20 @@ glClientActiveTexture_evgl_api_thread_cmd(GLenum texture)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glClientActiveTexture thread_param_local;
-   EVGL_API_Thread_Command_glClientActiveTexture *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glClientActiveTexture thread_data_local;
+   EVGL_API_Thread_Command_glClientActiveTexture *thread_data = &thread_data_local;
 
-   thread_param->texture = texture;
+   thread_data->texture = texture;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glClientActiveTexture,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glClipPlanex(GLenum plane, const GLfixed *equation);
+ * void
+ * glClipPlanex(GLenum plane, const GLfixed *equation);
  */
 
 typedef struct
@@ -13597,11 +13601,11 @@ void (*orig_evgl_api_glClipPlanex)(GLenum plane, const GLfixed *equation);
 static void
 _evgl_api_thread_glClipPlanex(void *data)
 {
-   EVGL_API_Thread_Command_glClipPlanex *thread_param =
+   EVGL_API_Thread_Command_glClipPlanex *thread_data =
       (EVGL_API_Thread_Command_glClipPlanex *)data;
 
-   orig_evgl_api_glClipPlanex(thread_param->plane,
-                              thread_param->equation);
+   orig_evgl_api_glClipPlanex(thread_data->plane,
+                              thread_data->equation);
 
 }
 
@@ -13616,21 +13620,21 @@ glClipPlanex_evgl_api_thread_cmd(GLenum plane, const GLfixed *equation)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glClipPlanex thread_param_local;
-   EVGL_API_Thread_Command_glClipPlanex *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glClipPlanex thread_data_local;
+   EVGL_API_Thread_Command_glClipPlanex *thread_data = &thread_data_local;
 
-   thread_param->plane = plane;
-   thread_param->equation = equation;
+   thread_data->plane = plane;
+   thread_data->equation = equation;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glClipPlanex,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha);
+ * void
+ * glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha);
  */
 
 typedef struct
@@ -13647,13 +13651,13 @@ void (*orig_evgl_api_glColor4ub)(GLubyte red, GLubyte green, GLubyte blue, GLuby
 static void
 _evgl_api_thread_glColor4ub(void *data)
 {
-   EVGL_API_Thread_Command_glColor4ub *thread_param =
+   EVGL_API_Thread_Command_glColor4ub *thread_data =
       (EVGL_API_Thread_Command_glColor4ub *)data;
 
-   orig_evgl_api_glColor4ub(thread_param->red,
-                            thread_param->green,
-                            thread_param->blue,
-                            thread_param->alpha);
+   orig_evgl_api_glColor4ub(thread_data->red,
+                            thread_data->green,
+                            thread_data->blue,
+                            thread_data->alpha);
 
 }
 
@@ -13668,23 +13672,23 @@ glColor4ub_evgl_api_thread_cmd(GLubyte red, GLubyte green, GLubyte blue, GLubyte
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glColor4ub thread_param_local;
-   EVGL_API_Thread_Command_glColor4ub *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glColor4ub thread_data_local;
+   EVGL_API_Thread_Command_glColor4ub *thread_data = &thread_data_local;
 
-   thread_param->red = red;
-   thread_param->green = green;
-   thread_param->blue = blue;
-   thread_param->alpha = alpha;
+   thread_data->red = red;
+   thread_data->green = green;
+   thread_data->blue = blue;
+   thread_data->alpha = alpha;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glColor4ub,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glColor4x(GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha);
+ * void
+ * glColor4x(GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha);
  */
 
 typedef struct
@@ -13701,13 +13705,13 @@ void (*orig_evgl_api_glColor4x)(GLfixed red, GLfixed green, GLfixed blue, GLfixe
 static void
 _evgl_api_thread_glColor4x(void *data)
 {
-   EVGL_API_Thread_Command_glColor4x *thread_param =
+   EVGL_API_Thread_Command_glColor4x *thread_data =
       (EVGL_API_Thread_Command_glColor4x *)data;
 
-   orig_evgl_api_glColor4x(thread_param->red,
-                           thread_param->green,
-                           thread_param->blue,
-                           thread_param->alpha);
+   orig_evgl_api_glColor4x(thread_data->red,
+                           thread_data->green,
+                           thread_data->blue,
+                           thread_data->alpha);
 
 }
 
@@ -13722,23 +13726,23 @@ glColor4x_evgl_api_thread_cmd(GLfixed red, GLfixed green, GLfixed blue, GLfixed
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glColor4x thread_param_local;
-   EVGL_API_Thread_Command_glColor4x *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glColor4x thread_data_local;
+   EVGL_API_Thread_Command_glColor4x *thread_data = &thread_data_local;
 
-   thread_param->red = red;
-   thread_param->green = green;
-   thread_param->blue = blue;
-   thread_param->alpha = alpha;
+   thread_data->red = red;
+   thread_data->green = green;
+   thread_data->blue = blue;
+   thread_data->alpha = alpha;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glColor4x,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
+ * void
+ * glColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
  */
 
 typedef struct
@@ -13755,13 +13759,13 @@ void (*orig_evgl_api_glColorPointer)(GLint size, GLenum type, GLsizei stride, co
 static void
 _evgl_api_thread_glColorPointer(void *data)
 {
-   EVGL_API_Thread_Command_glColorPointer *thread_param =
+   EVGL_API_Thread_Command_glColorPointer *thread_data =
       (EVGL_API_Thread_Command_glColorPointer *)data;
 
-   orig_evgl_api_glColorPointer(thread_param->size,
-                                thread_param->type,
-                                thread_param->stride,
-                                thread_param->pointer);
+   orig_evgl_api_glColorPointer(thread_data->size,
+                                thread_data->type,
+                                thread_data->stride,
+                                thread_data->pointer);
 
 }
 
@@ -13776,23 +13780,23 @@ glColorPointer_evgl_api_thread_cmd(GLint size, GLenum type, GLsizei stride, cons
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glColorPointer thread_param_local;
-   EVGL_API_Thread_Command_glColorPointer *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glColorPointer thread_data_local;
+   EVGL_API_Thread_Command_glColorPointer *thread_data = &thread_data_local;
 
-   thread_param->size = size;
-   thread_param->type = type;
-   thread_param->stride = stride;
-   thread_param->pointer = pointer;
+   thread_data->size = size;
+   thread_data->type = type;
+   thread_data->stride = stride;
+   thread_data->pointer = pointer;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glColorPointer,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glDepthRangex(GLclampx zNear, GLclampx zFar);
+ * void
+ * glDepthRangex(GLclampx zNear, GLclampx zFar);
  */
 
 typedef struct
@@ -13807,11 +13811,11 @@ void (*orig_evgl_api_glDepthRangex)(GLclampx zNear, GLclampx zFar);
 static void
 _evgl_api_thread_glDepthRangex(void *data)
 {
-   EVGL_API_Thread_Command_glDepthRangex *thread_param =
+   EVGL_API_Thread_Command_glDepthRangex *thread_data =
       (EVGL_API_Thread_Command_glDepthRangex *)data;
 
-   orig_evgl_api_glDepthRangex(thread_param->zNear,
-                               thread_param->zFar);
+   orig_evgl_api_glDepthRangex(thread_data->zNear,
+                               thread_data->zFar);
 
 }
 
@@ -13826,21 +13830,21 @@ glDepthRangex_evgl_api_thread_cmd(GLclampx zNear, GLclampx zFar)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glDepthRangex thread_param_local;
-   EVGL_API_Thread_Command_glDepthRangex *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glDepthRangex thread_data_local;
+   EVGL_API_Thread_Command_glDepthRangex *thread_data = &thread_data_local;
 
-   thread_param->zNear = zNear;
-   thread_param->zFar = zFar;
+   thread_data->zNear = zNear;
+   thread_data->zFar = zFar;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glDepthRangex,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glDisableClientState(GLenum array);
+ * void
+ * glDisableClientState(GLenum array);
  */
 
 typedef struct
@@ -13854,10 +13858,10 @@ void (*orig_evgl_api_glDisableClientState)(GLenum array);
 static void
 _evgl_api_thread_glDisableClientState(void *data)
 {
-   EVGL_API_Thread_Command_glDisableClientState *thread_param =
+   EVGL_API_Thread_Command_glDisableClientState *thread_data =
       (EVGL_API_Thread_Command_glDisableClientState *)data;
 
-   orig_evgl_api_glDisableClientState(thread_param->array);
+   orig_evgl_api_glDisableClientState(thread_data->array);
 
 }
 
@@ -13872,20 +13876,20 @@ glDisableClientState_evgl_api_thread_cmd(GLenum array)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glDisableClientState thread_param_local;
-   EVGL_API_Thread_Command_glDisableClientState *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glDisableClientState thread_data_local;
+   EVGL_API_Thread_Command_glDisableClientState *thread_data = &thread_data_local;
 
-   thread_param->array = array;
+   thread_data->array = array;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glDisableClientState,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glEnableClientState(GLenum array);
+ * void
+ * glEnableClientState(GLenum array);
  */
 
 typedef struct
@@ -13899,10 +13903,10 @@ void (*orig_evgl_api_glEnableClientState)(GLenum array);
 static void
 _evgl_api_thread_glEnableClientState(void *data)
 {
-   EVGL_API_Thread_Command_glEnableClientState *thread_param =
+   EVGL_API_Thread_Command_glEnableClientState *thread_data =
       (EVGL_API_Thread_Command_glEnableClientState *)data;
 
-   orig_evgl_api_glEnableClientState(thread_param->array);
+   orig_evgl_api_glEnableClientState(thread_data->array);
 
 }
 
@@ -13917,20 +13921,20 @@ glEnableClientState_evgl_api_thread_cmd(GLenum array)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glEnableClientState thread_param_local;
-   EVGL_API_Thread_Command_glEnableClientState *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glEnableClientState thread_data_local;
+   EVGL_API_Thread_Command_glEnableClientState *thread_data = &thread_data_local;
 
-   thread_param->array = array;
+   thread_data->array = array;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glEnableClientState,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glFogx(GLenum pname, GLfixed param);
+ * void
+ * glFogx(GLenum pname, GLfixed param);
  */
 
 typedef struct
@@ -13945,11 +13949,11 @@ void (*orig_evgl_api_glFogx)(GLenum pname, GLfixed param);
 static void
 _evgl_api_thread_glFogx(void *data)
 {
-   EVGL_API_Thread_Command_glFogx *thread_param =
+   EVGL_API_Thread_Command_glFogx *thread_data =
       (EVGL_API_Thread_Command_glFogx *)data;
 
-   orig_evgl_api_glFogx(thread_param->pname,
-                        thread_param->param);
+   orig_evgl_api_glFogx(thread_data->pname,
+                        thread_data->param);
 
 }
 
@@ -13964,21 +13968,21 @@ glFogx_evgl_api_thread_cmd(GLenum pname, GLfixed param)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glFogx thread_param_local;
-   EVGL_API_Thread_Command_glFogx *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glFogx thread_data_local;
+   EVGL_API_Thread_Command_glFogx *thread_data = &thread_data_local;
 
-   thread_param->pname = pname;
-   thread_param->param = param;
+   thread_data->pname = pname;
+   thread_data->param = param;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glFogx,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glFogxv(GLenum pname, const GLfixed *params);
+ * void
+ * glFogxv(GLenum pname, const GLfixed *params);
  */
 
 typedef struct
@@ -13993,11 +13997,11 @@ void (*orig_evgl_api_glFogxv)(GLenum pname, const GLfixed *params);
 static void
 _evgl_api_thread_glFogxv(void *data)
 {
-   EVGL_API_Thread_Command_glFogxv *thread_param =
+   EVGL_API_Thread_Command_glFogxv *thread_data =
       (EVGL_API_Thread_Command_glFogxv *)data;
 
-   orig_evgl_api_glFogxv(thread_param->pname,
-                         thread_param->params);
+   orig_evgl_api_glFogxv(thread_data->pname,
+                         thread_data->params);
 
 }
 
@@ -14012,21 +14016,21 @@ glFogxv_evgl_api_thread_cmd(GLenum pname, const GLfixed *params)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glFogxv thread_param_local;
-   EVGL_API_Thread_Command_glFogxv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glFogxv thread_data_local;
+   EVGL_API_Thread_Command_glFogxv *thread_data = &thread_data_local;
 
-   thread_param->pname = pname;
-   thread_param->params = params;
+   thread_data->pname = pname;
+   thread_data->params = params;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glFogxv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glFrustumx(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar);
+ * void
+ * glFrustumx(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar);
  */
 
 typedef struct
@@ -14045,15 +14049,15 @@ void (*orig_evgl_api_glFrustumx)(GLfixed left, GLfixed right, GLfixed bottom, GL
 static void
 _evgl_api_thread_glFrustumx(void *data)
 {
-   EVGL_API_Thread_Command_glFrustumx *thread_param =
+   EVGL_API_Thread_Command_glFrustumx *thread_data =
       (EVGL_API_Thread_Command_glFrustumx *)data;
 
-   orig_evgl_api_glFrustumx(thread_param->left,
-                            thread_param->right,
-                            thread_param->bottom,
-                            thread_param->top,
-                            thread_param->zNear,
-                            thread_param->zFar);
+   orig_evgl_api_glFrustumx(thread_data->left,
+                            thread_data->right,
+                            thread_data->bottom,
+                            thread_data->top,
+                            thread_data->zNear,
+                            thread_data->zFar);
 
 }
 
@@ -14068,25 +14072,25 @@ glFrustumx_evgl_api_thread_cmd(GLfixed left, GLfixed right, GLfixed bottom, GLfi
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glFrustumx thread_param_local;
-   EVGL_API_Thread_Command_glFrustumx *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glFrustumx thread_data_local;
+   EVGL_API_Thread_Command_glFrustumx *thread_data = &thread_data_local;
 
-   thread_param->left = left;
-   thread_param->right = right;
-   thread_param->bottom = bottom;
-   thread_param->top = top;
-   thread_param->zNear = zNear;
-   thread_param->zFar = zFar;
+   thread_data->left = left;
+   thread_data->right = right;
+   thread_data->bottom = bottom;
+   thread_data->top = top;
+   thread_data->zNear = zNear;
+   thread_data->zFar = zFar;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glFrustumx,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGetClipPlanex(GLenum pname, GLfixed eqn[4]);
+ * void
+ * glGetClipPlanex(GLenum pname, GLfixed eqn[4]);
  */
 
 typedef struct
@@ -14101,11 +14105,11 @@ void (*orig_evgl_api_glGetClipPlanex)(GLenum pname, GLfixed eqn[4]);
 static void
 _evgl_api_thread_glGetClipPlanex(void *data)
 {
-   EVGL_API_Thread_Command_glGetClipPlanex *thread_param =
+   EVGL_API_Thread_Command_glGetClipPlanex *thread_data =
       (EVGL_API_Thread_Command_glGetClipPlanex *)data;
 
-   orig_evgl_api_glGetClipPlanex(thread_param->pname,
-                                 thread_param->eqn);
+   orig_evgl_api_glGetClipPlanex(thread_data->pname,
+                                 thread_data->eqn);
 
 }
 
@@ -14120,21 +14124,21 @@ glGetClipPlanex_evgl_api_thread_cmd(GLenum pname, GLfixed eqn[4])
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGetClipPlanex thread_param_local;
-   EVGL_API_Thread_Command_glGetClipPlanex *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGetClipPlanex thread_data_local;
+   EVGL_API_Thread_Command_glGetClipPlanex *thread_data = &thread_data_local;
 
-   thread_param->pname = pname;
-   memcpy(thread_param->eqn, &eqn, sizeof(eqn));
+   thread_data->pname = pname;
+   memcpy(thread_data->eqn, &eqn, sizeof(GLfixed) * 4);
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGetClipPlanex,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGetFixedv(GLenum pname, GLfixed *params);
+ * void
+ * glGetFixedv(GLenum pname, GLfixed *params);
  */
 
 typedef struct
@@ -14149,11 +14153,11 @@ void (*orig_evgl_api_glGetFixedv)(GLenum pname, GLfixed *params);
 static void
 _evgl_api_thread_glGetFixedv(void *data)
 {
-   EVGL_API_Thread_Command_glGetFixedv *thread_param =
+   EVGL_API_Thread_Command_glGetFixedv *thread_data =
       (EVGL_API_Thread_Command_glGetFixedv *)data;
 
-   orig_evgl_api_glGetFixedv(thread_param->pname,
-                             thread_param->params);
+   orig_evgl_api_glGetFixedv(thread_data->pname,
+                             thread_data->params);
 
 }
 
@@ -14168,21 +14172,21 @@ glGetFixedv_evgl_api_thread_cmd(GLenum pname, GLfixed *params)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGetFixedv thread_param_local;
-   EVGL_API_Thread_Command_glGetFixedv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGetFixedv thread_data_local;
+   EVGL_API_Thread_Command_glGetFixedv *thread_data = &thread_data_local;
 
-   thread_param->pname = pname;
-   thread_param->params = params;
+   thread_data->pname = pname;
+   thread_data->params = params;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGetFixedv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGetLightxv(GLenum light, GLenum pname, GLfixed *params);
+ * void
+ * glGetLightxv(GLenum light, GLenum pname, GLfixed *params);
  */
 
 typedef struct
@@ -14198,12 +14202,12 @@ void (*orig_evgl_api_glGetLightxv)(GLenum light, GLenum pname, GLfixed *params);
 static void
 _evgl_api_thread_glGetLightxv(void *data)
 {
-   EVGL_API_Thread_Command_glGetLightxv *thread_param =
+   EVGL_API_Thread_Command_glGetLightxv *thread_data =
       (EVGL_API_Thread_Command_glGetLightxv *)data;
 
-   orig_evgl_api_glGetLightxv(thread_param->light,
-                              thread_param->pname,
-                              thread_param->params);
+   orig_evgl_api_glGetLightxv(thread_data->light,
+                              thread_data->pname,
+                              thread_data->params);
 
 }
 
@@ -14218,22 +14222,22 @@ glGetLightxv_evgl_api_thread_cmd(GLenum light, GLenum pname, GLfixed *params)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGetLightxv thread_param_local;
-   EVGL_API_Thread_Command_glGetLightxv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGetLightxv thread_data_local;
+   EVGL_API_Thread_Command_glGetLightxv *thread_data = &thread_data_local;
 
-   thread_param->light = light;
-   thread_param->pname = pname;
-   thread_param->params = params;
+   thread_data->light = light;
+   thread_data->pname = pname;
+   thread_data->params = params;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGetLightxv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGetMaterialxv(GLenum face, GLenum pname, GLfixed *params);
+ * void
+ * glGetMaterialxv(GLenum face, GLenum pname, GLfixed *params);
  */
 
 typedef struct
@@ -14249,12 +14253,12 @@ void (*orig_evgl_api_glGetMaterialxv)(GLenum face, GLenum pname, GLfixed *params
 static void
 _evgl_api_thread_glGetMaterialxv(void *data)
 {
-   EVGL_API_Thread_Command_glGetMaterialxv *thread_param =
+   EVGL_API_Thread_Command_glGetMaterialxv *thread_data =
       (EVGL_API_Thread_Command_glGetMaterialxv *)data;
 
-   orig_evgl_api_glGetMaterialxv(thread_param->face,
-                                 thread_param->pname,
-                                 thread_param->params);
+   orig_evgl_api_glGetMaterialxv(thread_data->face,
+                                 thread_data->pname,
+                                 thread_data->params);
 
 }
 
@@ -14269,22 +14273,22 @@ glGetMaterialxv_evgl_api_thread_cmd(GLenum face, GLenum pname, GLfixed *params)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGetMaterialxv thread_param_local;
-   EVGL_API_Thread_Command_glGetMaterialxv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGetMaterialxv thread_data_local;
+   EVGL_API_Thread_Command_glGetMaterialxv *thread_data = &thread_data_local;
 
-   thread_param->face = face;
-   thread_param->pname = pname;
-   thread_param->params = params;
+   thread_data->face = face;
+   thread_data->pname = pname;
+   thread_data->params = params;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGetMaterialxv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGetPointerv(GLenum pname, GLvoid **params);
+ * void
+ * glGetPointerv(GLenum pname, GLvoid **params);
  */
 
 typedef struct
@@ -14299,11 +14303,11 @@ void (*orig_evgl_api_glGetPointerv)(GLenum pname, GLvoid **params);
 static void
 _evgl_api_thread_glGetPointerv(void *data)
 {
-   EVGL_API_Thread_Command_glGetPointerv *thread_param =
+   EVGL_API_Thread_Command_glGetPointerv *thread_data =
       (EVGL_API_Thread_Command_glGetPointerv *)data;
 
-   orig_evgl_api_glGetPointerv(thread_param->pname,
-                               thread_param->params);
+   orig_evgl_api_glGetPointerv(thread_data->pname,
+                               thread_data->params);
 
 }
 
@@ -14318,21 +14322,21 @@ glGetPointerv_evgl_api_thread_cmd(GLenum pname, GLvoid **params)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGetPointerv thread_param_local;
-   EVGL_API_Thread_Command_glGetPointerv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGetPointerv thread_data_local;
+   EVGL_API_Thread_Command_glGetPointerv *thread_data = &thread_data_local;
 
-   thread_param->pname = pname;
-   thread_param->params = params;
+   thread_data->pname = pname;
+   thread_data->params = params;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGetPointerv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGetTexEnviv(GLenum env, GLenum pname, GLint *params);
+ * void
+ * glGetTexEnviv(GLenum env, GLenum pname, GLint *params);
  */
 
 typedef struct
@@ -14348,12 +14352,12 @@ void (*orig_evgl_api_glGetTexEnviv)(GLenum env, GLenum pname, GLint *params);
 static void
 _evgl_api_thread_glGetTexEnviv(void *data)
 {
-   EVGL_API_Thread_Command_glGetTexEnviv *thread_param =
+   EVGL_API_Thread_Command_glGetTexEnviv *thread_data =
       (EVGL_API_Thread_Command_glGetTexEnviv *)data;
 
-   orig_evgl_api_glGetTexEnviv(thread_param->env,
-                               thread_param->pname,
-                               thread_param->params);
+   orig_evgl_api_glGetTexEnviv(thread_data->env,
+                               thread_data->pname,
+                               thread_data->params);
 
 }
 
@@ -14368,22 +14372,22 @@ glGetTexEnviv_evgl_api_thread_cmd(GLenum env, GLenum pname, GLint *params)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGetTexEnviv thread_param_local;
-   EVGL_API_Thread_Command_glGetTexEnviv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGetTexEnviv thread_data_local;
+   EVGL_API_Thread_Command_glGetTexEnviv *thread_data = &thread_data_local;
 
-   thread_param->env = env;
-   thread_param->pname = pname;
-   thread_param->params = params;
+   thread_data->env = env;
+   thread_data->pname = pname;
+   thread_data->params = params;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGetTexEnviv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGetTexEnvxv(GLenum env, GLenum pname, GLfixed *params);
+ * void
+ * glGetTexEnvxv(GLenum env, GLenum pname, GLfixed *params);
  */
 
 typedef struct
@@ -14399,12 +14403,12 @@ void (*orig_evgl_api_glGetTexEnvxv)(GLenum env, GLenum pname, GLfixed *params);
 static void
 _evgl_api_thread_glGetTexEnvxv(void *data)
 {
-   EVGL_API_Thread_Command_glGetTexEnvxv *thread_param =
+   EVGL_API_Thread_Command_glGetTexEnvxv *thread_data =
       (EVGL_API_Thread_Command_glGetTexEnvxv *)data;
 
-   orig_evgl_api_glGetTexEnvxv(thread_param->env,
-                               thread_param->pname,
-                               thread_param->params);
+   orig_evgl_api_glGetTexEnvxv(thread_data->env,
+                               thread_data->pname,
+                               thread_data->params);
 
 }
 
@@ -14419,22 +14423,22 @@ glGetTexEnvxv_evgl_api_thread_cmd(GLenum env, GLenum pname, GLfixed *params)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGetTexEnvxv thread_param_local;
-   EVGL_API_Thread_Command_glGetTexEnvxv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGetTexEnvxv thread_data_local;
+   EVGL_API_Thread_Command_glGetTexEnvxv *thread_data = &thread_data_local;
 
-   thread_param->env = env;
-   thread_param->pname = pname;
-   thread_param->params = params;
+   thread_data->env = env;
+   thread_data->pname = pname;
+   thread_data->params = params;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGetTexEnvxv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGetTexParameterxv(GLenum target, GLenum pname, GLfixed *params);
+ * void
+ * glGetTexParameterxv(GLenum target, GLenum pname, GLfixed *params);
  */
 
 typedef struct
@@ -14450,12 +14454,12 @@ void (*orig_evgl_api_glGetTexParameterxv)(GLenum target, GLenum pname, GLfixed *
 static void
 _evgl_api_thread_glGetTexParameterxv(void *data)
 {
-   EVGL_API_Thread_Command_glGetTexParameterxv *thread_param =
+   EVGL_API_Thread_Command_glGetTexParameterxv *thread_data =
       (EVGL_API_Thread_Command_glGetTexParameterxv *)data;
 
-   orig_evgl_api_glGetTexParameterxv(thread_param->target,
-                                     thread_param->pname,
-                                     thread_param->params);
+   orig_evgl_api_glGetTexParameterxv(thread_data->target,
+                                     thread_data->pname,
+                                     thread_data->params);
 
 }
 
@@ -14470,22 +14474,22 @@ glGetTexParameterxv_evgl_api_thread_cmd(GLenum target, GLenum pname, GLfixed *pa
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGetTexParameterxv thread_param_local;
-   EVGL_API_Thread_Command_glGetTexParameterxv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGetTexParameterxv thread_data_local;
+   EVGL_API_Thread_Command_glGetTexParameterxv *thread_data = &thread_data_local;
 
-   thread_param->target = target;
-   thread_param->pname = pname;
-   thread_param->params = params;
+   thread_data->target = target;
+   thread_data->pname = pname;
+   thread_data->params = params;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGetTexParameterxv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glLightModelx(GLenum pname, GLfixed param);
+ * void
+ * glLightModelx(GLenum pname, GLfixed param);
  */
 
 typedef struct
@@ -14500,11 +14504,11 @@ void (*orig_evgl_api_glLightModelx)(GLenum pname, GLfixed param);
 static void
 _evgl_api_thread_glLightModelx(void *data)
 {
-   EVGL_API_Thread_Command_glLightModelx *thread_param =
+   EVGL_API_Thread_Command_glLightModelx *thread_data =
       (EVGL_API_Thread_Command_glLightModelx *)data;
 
-   orig_evgl_api_glLightModelx(thread_param->pname,
-                               thread_param->param);
+   orig_evgl_api_glLightModelx(thread_data->pname,
+                               thread_data->param);
 
 }
 
@@ -14519,21 +14523,21 @@ glLightModelx_evgl_api_thread_cmd(GLenum pname, GLfixed param)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glLightModelx thread_param_local;
-   EVGL_API_Thread_Command_glLightModelx *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glLightModelx thread_data_local;
+   EVGL_API_Thread_Command_glLightModelx *thread_data = &thread_data_local;
 
-   thread_param->pname = pname;
-   thread_param->param = param;
+   thread_data->pname = pname;
+   thread_data->param = param;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glLightModelx,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glLightModelxv(GLenum pname, const GLfixed *params);
+ * void
+ * glLightModelxv(GLenum pname, const GLfixed *params);
  */
 
 typedef struct
@@ -14548,11 +14552,11 @@ void (*orig_evgl_api_glLightModelxv)(GLenum pname, const GLfixed *params);
 static void
 _evgl_api_thread_glLightModelxv(void *data)
 {
-   EVGL_API_Thread_Command_glLightModelxv *thread_param =
+   EVGL_API_Thread_Command_glLightModelxv *thread_data =
       (EVGL_API_Thread_Command_glLightModelxv *)data;
 
-   orig_evgl_api_glLightModelxv(thread_param->pname,
-                                thread_param->params);
+   orig_evgl_api_glLightModelxv(thread_data->pname,
+                                thread_data->params);
 
 }
 
@@ -14567,21 +14571,21 @@ glLightModelxv_evgl_api_thread_cmd(GLenum pname, const GLfixed *params)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glLightModelxv thread_param_local;
-   EVGL_API_Thread_Command_glLightModelxv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glLightModelxv thread_data_local;
+   EVGL_API_Thread_Command_glLightModelxv *thread_data = &thread_data_local;
 
-   thread_param->pname = pname;
-   thread_param->params = params;
+   thread_data->pname = pname;
+   thread_data->params = params;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glLightModelxv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glLightx(GLenum light, GLenum pname, GLfixed param);
+ * void
+ * glLightx(GLenum light, GLenum pname, GLfixed param);
  */
 
 typedef struct
@@ -14597,12 +14601,12 @@ void (*orig_evgl_api_glLightx)(GLenum light, GLenum pname, GLfixed param);
 static void
 _evgl_api_thread_glLightx(void *data)
 {
-   EVGL_API_Thread_Command_glLightx *thread_param =
+   EVGL_API_Thread_Command_glLightx *thread_data =
       (EVGL_API_Thread_Command_glLightx *)data;
 
-   orig_evgl_api_glLightx(thread_param->light,
-                          thread_param->pname,
-                          thread_param->param);
+   orig_evgl_api_glLightx(thread_data->light,
+                          thread_data->pname,
+                          thread_data->param);
 
 }
 
@@ -14617,22 +14621,22 @@ glLightx_evgl_api_thread_cmd(GLenum light, GLenum pname, GLfixed param)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glLightx thread_param_local;
-   EVGL_API_Thread_Command_glLightx *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glLightx thread_data_local;
+   EVGL_API_Thread_Command_glLightx *thread_data = &thread_data_local;
 
-   thread_param->light = light;
-   thread_param->pname = pname;
-   thread_param->param = param;
+   thread_data->light = light;
+   thread_data->pname = pname;
+   thread_data->param = param;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glLightx,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glLightxv(GLenum light, GLenum pname, const GLfixed *params);
+ * void
+ * glLightxv(GLenum light, GLenum pname, const GLfixed *params);
  */
 
 typedef struct
@@ -14648,12 +14652,12 @@ void (*orig_evgl_api_glLightxv)(GLenum light, GLenum pname, const GLfixed *param
 static void
 _evgl_api_thread_glLightxv(void *data)
 {
-   EVGL_API_Thread_Command_glLightxv *thread_param =
+   EVGL_API_Thread_Command_glLightxv *thread_data =
       (EVGL_API_Thread_Command_glLightxv *)data;
 
-   orig_evgl_api_glLightxv(thread_param->light,
-                           thread_param->pname,
-                           thread_param->params);
+   orig_evgl_api_glLightxv(thread_data->light,
+                           thread_data->pname,
+                           thread_data->params);
 
 }
 
@@ -14668,22 +14672,22 @@ glLightxv_evgl_api_thread_cmd(GLenum light, GLenum pname, const GLfixed *params)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glLightxv thread_param_local;
-   EVGL_API_Thread_Command_glLightxv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glLightxv thread_data_local;
+   EVGL_API_Thread_Command_glLightxv *thread_data = &thread_data_local;
 
-   thread_param->light = light;
-   thread_param->pname = pname;
-   thread_param->params = params;
+   thread_data->light = light;
+   thread_data->pname = pname;
+   thread_data->params = params;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glLightxv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glLineWidthx(GLfixed width);
+ * void
+ * glLineWidthx(GLfixed width);
  */
 
 typedef struct
@@ -14697,10 +14701,10 @@ void (*orig_evgl_api_glLineWidthx)(GLfixed width);
 static void
 _evgl_api_thread_glLineWidthx(void *data)
 {
-   EVGL_API_Thread_Command_glLineWidthx *thread_param =
+   EVGL_API_Thread_Command_glLineWidthx *thread_data =
       (EVGL_API_Thread_Command_glLineWidthx *)data;
 
-   orig_evgl_api_glLineWidthx(thread_param->width);
+   orig_evgl_api_glLineWidthx(thread_data->width);
 
 }
 
@@ -14715,20 +14719,20 @@ glLineWidthx_evgl_api_thread_cmd(GLfixed width)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glLineWidthx thread_param_local;
-   EVGL_API_Thread_Command_glLineWidthx *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glLineWidthx thread_data_local;
+   EVGL_API_Thread_Command_glLineWidthx *thread_data = &thread_data_local;
 
-   thread_param->width = width;
+   thread_data->width = width;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glLineWidthx,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glLoadIdentity(void);
+ * void
+ * glLoadIdentity(void);
  */
 
 void (*orig_evgl_api_glLoadIdentity)(void);
@@ -14758,8 +14762,8 @@ glLoadIdentity_evgl_api_thread_cmd(void)
 }
 
 /*
-   void
-   glLoadMatrixx(const GLfixed *m);
+ * void
+ * glLoadMatrixx(const GLfixed *m);
  */
 
 typedef struct
@@ -14773,10 +14777,10 @@ void (*orig_evgl_api_glLoadMatrixx)(const GLfixed *m);
 static void
 _evgl_api_thread_glLoadMatrixx(void *data)
 {
-   EVGL_API_Thread_Command_glLoadMatrixx *thread_param =
+   EVGL_API_Thread_Command_glLoadMatrixx *thread_data =
       (EVGL_API_Thread_Command_glLoadMatrixx *)data;
 
-   orig_evgl_api_glLoadMatrixx(thread_param->m);
+   orig_evgl_api_glLoadMatrixx(thread_data->m);
 
 }
 
@@ -14791,20 +14795,20 @@ glLoadMatrixx_evgl_api_thread_cmd(const GLfixed *m)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glLoadMatrixx thread_param_local;
-   EVGL_API_Thread_Command_glLoadMatrixx *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glLoadMatrixx thread_data_local;
+   EVGL_API_Thread_Command_glLoadMatrixx *thread_data = &thread_data_local;
 
-   thread_param->m = m;
+   thread_data->m = m;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glLoadMatrixx,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glLogicOp(GLenum opcode);
+ * void
+ * glLogicOp(GLenum opcode);
  */
 
 typedef struct
@@ -14818,10 +14822,10 @@ void (*orig_evgl_api_glLogicOp)(GLenum opcode);
 static void
 _evgl_api_thread_glLogicOp(void *data)
 {
-   EVGL_API_Thread_Command_glLogicOp *thread_param =
+   EVGL_API_Thread_Command_glLogicOp *thread_data =
       (EVGL_API_Thread_Command_glLogicOp *)data;
 
-   orig_evgl_api_glLogicOp(thread_param->opcode);
+   orig_evgl_api_glLogicOp(thread_data->opcode);
 
 }
 
@@ -14836,20 +14840,20 @@ glLogicOp_evgl_api_thread_cmd(GLenum opcode)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glLogicOp thread_param_local;
-   EVGL_API_Thread_Command_glLogicOp *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glLogicOp thread_data_local;
+   EVGL_API_Thread_Command_glLogicOp *thread_data = &thread_data_local;
 
-   thread_param->opcode = opcode;
+   thread_data->opcode = opcode;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glLogicOp,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glMaterialx(GLenum face, GLenum pname, GLfixed param);
+ * void
+ * glMaterialx(GLenum face, GLenum pname, GLfixed param);
  */
 
 typedef struct
@@ -14865,12 +14869,12 @@ void (*orig_evgl_api_glMaterialx)(GLenum face, GLenum pname, GLfixed param);
 static void
 _evgl_api_thread_glMaterialx(void *data)
 {
-   EVGL_API_Thread_Command_glMaterialx *thread_param =
+   EVGL_API_Thread_Command_glMaterialx *thread_data =
       (EVGL_API_Thread_Command_glMaterialx *)data;
 
-   orig_evgl_api_glMaterialx(thread_param->face,
-                             thread_param->pname,
-                             thread_param->param);
+   orig_evgl_api_glMaterialx(thread_data->face,
+                             thread_data->pname,
+                             thread_data->param);
 
 }
 
@@ -14885,22 +14889,22 @@ glMaterialx_evgl_api_thread_cmd(GLenum face, GLenum pname, GLfixed param)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glMaterialx thread_param_local;
-   EVGL_API_Thread_Command_glMaterialx *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glMaterialx thread_data_local;
+   EVGL_API_Thread_Command_glMaterialx *thread_data = &thread_data_local;
 
-   thread_param->face = face;
-   thread_param->pname = pname;
-   thread_param->param = param;
+   thread_data->face = face;
+   thread_data->pname = pname;
+   thread_data->param = param;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glMaterialx,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glMaterialxv(GLenum face, GLenum pname, const GLfixed *params);
+ * void
+ * glMaterialxv(GLenum face, GLenum pname, const GLfixed *params);
  */
 
 typedef struct
@@ -14916,12 +14920,12 @@ void (*orig_evgl_api_glMaterialxv)(GLenum face, GLenum pname, const GLfixed *par
 static void
 _evgl_api_thread_glMaterialxv(void *data)
 {
-   EVGL_API_Thread_Command_glMaterialxv *thread_param =
+   EVGL_API_Thread_Command_glMaterialxv *thread_data =
       (EVGL_API_Thread_Command_glMaterialxv *)data;
 
-   orig_evgl_api_glMaterialxv(thread_param->face,
-                              thread_param->pname,
-                              thread_param->params);
+   orig_evgl_api_glMaterialxv(thread_data->face,
+                              thread_data->pname,
+                              thread_data->params);
 
 }
 
@@ -14936,22 +14940,22 @@ glMaterialxv_evgl_api_thread_cmd(GLenum face, GLenum pname, const GLfixed *param
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glMaterialxv thread_param_local;
-   EVGL_API_Thread_Command_glMaterialxv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glMaterialxv thread_data_local;
+   EVGL_API_Thread_Command_glMaterialxv *thread_data = &thread_data_local;
 
-   thread_param->face = face;
-   thread_param->pname = pname;
-   thread_param->params = params;
+   thread_data->face = face;
+   thread_data->pname = pname;
+   thread_data->params = params;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glMaterialxv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glMatrixMode(GLenum mode);
+ * void
+ * glMatrixMode(GLenum mode);
  */
 
 typedef struct
@@ -14965,10 +14969,10 @@ void (*orig_evgl_api_glMatrixMode)(GLenum mode);
 static void
 _evgl_api_thread_glMatrixMode(void *data)
 {
-   EVGL_API_Thread_Command_glMatrixMode *thread_param =
+   EVGL_API_Thread_Command_glMatrixMode *thread_data =
       (EVGL_API_Thread_Command_glMatrixMode *)data;
 
-   orig_evgl_api_glMatrixMode(thread_param->mode);
+   orig_evgl_api_glMatrixMode(thread_data->mode);
 
 }
 
@@ -14983,20 +14987,20 @@ glMatrixMode_evgl_api_thread_cmd(GLenum mode)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glMatrixMode thread_param_local;
-   EVGL_API_Thread_Command_glMatrixMode *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glMatrixMode thread_data_local;
+   EVGL_API_Thread_Command_glMatrixMode *thread_data = &thread_data_local;
 
-   thread_param->mode = mode;
+   thread_data->mode = mode;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glMatrixMode,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glMultMatrixx(const GLfixed *m);
+ * void
+ * glMultMatrixx(const GLfixed *m);
  */
 
 typedef struct
@@ -15010,10 +15014,10 @@ void (*orig_evgl_api_glMultMatrixx)(const GLfixed *m);
 static void
 _evgl_api_thread_glMultMatrixx(void *data)
 {
-   EVGL_API_Thread_Command_glMultMatrixx *thread_param =
+   EVGL_API_Thread_Command_glMultMatrixx *thread_data =
       (EVGL_API_Thread_Command_glMultMatrixx *)data;
 
-   orig_evgl_api_glMultMatrixx(thread_param->m);
+   orig_evgl_api_glMultMatrixx(thread_data->m);
 
 }
 
@@ -15028,20 +15032,20 @@ glMultMatrixx_evgl_api_thread_cmd(const GLfixed *m)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glMultMatrixx thread_param_local;
-   EVGL_API_Thread_Command_glMultMatrixx *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glMultMatrixx thread_data_local;
+   EVGL_API_Thread_Command_glMultMatrixx *thread_data = &thread_data_local;
 
-   thread_param->m = m;
+   thread_data->m = m;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glMultMatrixx,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glMultiTexCoord4x(GLenum target, GLfixed s, GLfixed t, GLfixed r, GLfixed q);
+ * void
+ * glMultiTexCoord4x(GLenum target, GLfixed s, GLfixed t, GLfixed r, GLfixed q);
  */
 
 typedef struct
@@ -15059,14 +15063,14 @@ void (*orig_evgl_api_glMultiTexCoord4x)(GLenum target, GLfixed s, GLfixed t, GLf
 static void
 _evgl_api_thread_glMultiTexCoord4x(void *data)
 {
-   EVGL_API_Thread_Command_glMultiTexCoord4x *thread_param =
+   EVGL_API_Thread_Command_glMultiTexCoord4x *thread_data =
       (EVGL_API_Thread_Command_glMultiTexCoord4x *)data;
 
-   orig_evgl_api_glMultiTexCoord4x(thread_param->target,
-                                   thread_param->s,
-                                   thread_param->t,
-                                   thread_param->r,
-                                   thread_param->q);
+   orig_evgl_api_glMultiTexCoord4x(thread_data->target,
+                                   thread_data->s,
+                                   thread_data->t,
+                                   thread_data->r,
+                                   thread_data->q);
 
 }
 
@@ -15081,24 +15085,24 @@ glMultiTexCoord4x_evgl_api_thread_cmd(GLenum target, GLfixed s, GLfixed t, GLfix
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glMultiTexCoord4x thread_param_local;
-   EVGL_API_Thread_Command_glMultiTexCoord4x *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glMultiTexCoord4x thread_data_local;
+   EVGL_API_Thread_Command_glMultiTexCoord4x *thread_data = &thread_data_local;
 
-   thread_param->target = target;
-   thread_param->s = s;
-   thread_param->t = t;
-   thread_param->r = r;
-   thread_param->q = q;
+   thread_data->target = target;
+   thread_data->s = s;
+   thread_data->t = t;
+   thread_data->r = r;
+   thread_data->q = q;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glMultiTexCoord4x,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glNormal3x(GLfixed nx, GLfixed ny, GLfixed nz);
+ * void
+ * glNormal3x(GLfixed nx, GLfixed ny, GLfixed nz);
  */
 
 typedef struct
@@ -15114,12 +15118,12 @@ void (*orig_evgl_api_glNormal3x)(GLfixed nx, GLfixed ny, GLfixed nz);
 static void
 _evgl_api_thread_glNormal3x(void *data)
 {
-   EVGL_API_Thread_Command_glNormal3x *thread_param =
+   EVGL_API_Thread_Command_glNormal3x *thread_data =
       (EVGL_API_Thread_Command_glNormal3x *)data;
 
-   orig_evgl_api_glNormal3x(thread_param->nx,
-                            thread_param->ny,
-                            thread_param->nz);
+   orig_evgl_api_glNormal3x(thread_data->nx,
+                            thread_data->ny,
+                            thread_data->nz);
 
 }
 
@@ -15134,22 +15138,22 @@ glNormal3x_evgl_api_thread_cmd(GLfixed nx, GLfixed ny, GLfixed nz)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glNormal3x thread_param_local;
-   EVGL_API_Thread_Command_glNormal3x *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glNormal3x thread_data_local;
+   EVGL_API_Thread_Command_glNormal3x *thread_data = &thread_data_local;
 
-   thread_param->nx = nx;
-   thread_param->ny = ny;
-   thread_param->nz = nz;
+   thread_data->nx = nx;
+   thread_data->ny = ny;
+   thread_data->nz = nz;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glNormal3x,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glNormalPointer(GLenum type, GLsizei stride, const GLvoid *pointer);
+ * void
+ * glNormalPointer(GLenum type, GLsizei stride, const GLvoid *pointer);
  */
 
 typedef struct
@@ -15165,12 +15169,12 @@ void (*orig_evgl_api_glNormalPointer)(GLenum type, GLsizei stride, const GLvoid
 static void
 _evgl_api_thread_glNormalPointer(void *data)
 {
-   EVGL_API_Thread_Command_glNormalPointer *thread_param =
+   EVGL_API_Thread_Command_glNormalPointer *thread_data =
       (EVGL_API_Thread_Command_glNormalPointer *)data;
 
-   orig_evgl_api_glNormalPointer(thread_param->type,
-                                 thread_param->stride,
-                                 thread_param->pointer);
+   orig_evgl_api_glNormalPointer(thread_data->type,
+                                 thread_data->stride,
+                                 thread_data->pointer);
 
 }
 
@@ -15185,22 +15189,22 @@ glNormalPointer_evgl_api_thread_cmd(GLenum type, GLsizei stride, const GLvoid *p
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glNormalPointer thread_param_local;
-   EVGL_API_Thread_Command_glNormalPointer *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glNormalPointer thread_data_local;
+   EVGL_API_Thread_Command_glNormalPointer *thread_data = &thread_data_local;
 
-   thread_param->type = type;
-   thread_param->stride = stride;
-   thread_param->pointer = pointer;
+   thread_data->type = type;
+   thread_data->stride = stride;
+   thread_data->pointer = pointer;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glNormalPointer,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glOrthox(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar);
+ * void
+ * glOrthox(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar);
  */
 
 typedef struct
@@ -15219,15 +15223,15 @@ void (*orig_evgl_api_glOrthox)(GLfixed left, GLfixed right, GLfixed bottom, GLfi
 static void
 _evgl_api_thread_glOrthox(void *data)
 {
-   EVGL_API_Thread_Command_glOrthox *thread_param =
+   EVGL_API_Thread_Command_glOrthox *thread_data =
       (EVGL_API_Thread_Command_glOrthox *)data;
 
-   orig_evgl_api_glOrthox(thread_param->left,
-                          thread_param->right,
-                          thread_param->bottom,
-                          thread_param->top,
-                          thread_param->zNear,
-                          thread_param->zFar);
+   orig_evgl_api_glOrthox(thread_data->left,
+                          thread_data->right,
+                          thread_data->bottom,
+                          thread_data->top,
+                          thread_data->zNear,
+                          thread_data->zFar);
 
 }
 
@@ -15242,25 +15246,25 @@ glOrthox_evgl_api_thread_cmd(GLfixed left, GLfixed right, GLfixed bottom, GLfixe
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glOrthox thread_param_local;
-   EVGL_API_Thread_Command_glOrthox *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glOrthox thread_data_local;
+   EVGL_API_Thread_Command_glOrthox *thread_data = &thread_data_local;
 
-   thread_param->left = left;
-   thread_param->right = right;
-   thread_param->bottom = bottom;
-   thread_param->top = top;
-   thread_param->zNear = zNear;
-   thread_param->zFar = zFar;
+   thread_data->left = left;
+   thread_data->right = right;
+   thread_data->bottom = bottom;
+   thread_data->top = top;
+   thread_data->zNear = zNear;
+   thread_data->zFar = zFar;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glOrthox,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glPointParameterx(GLenum pname, GLfixed param);
+ * void
+ * glPointParameterx(GLenum pname, GLfixed param);
  */
 
 typedef struct
@@ -15275,11 +15279,11 @@ void (*orig_evgl_api_glPointParameterx)(GLenum pname, GLfixed param);
 static void
 _evgl_api_thread_glPointParameterx(void *data)
 {
-   EVGL_API_Thread_Command_glPointParameterx *thread_param =
+   EVGL_API_Thread_Command_glPointParameterx *thread_data =
       (EVGL_API_Thread_Command_glPointParameterx *)data;
 
-   orig_evgl_api_glPointParameterx(thread_param->pname,
-                                   thread_param->param);
+   orig_evgl_api_glPointParameterx(thread_data->pname,
+                                   thread_data->param);
 
 }
 
@@ -15294,21 +15298,21 @@ glPointParameterx_evgl_api_thread_cmd(GLenum pname, GLfixed param)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glPointParameterx thread_param_local;
-   EVGL_API_Thread_Command_glPointParameterx *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glPointParameterx thread_data_local;
+   EVGL_API_Thread_Command_glPointParameterx *thread_data = &thread_data_local;
 
-   thread_param->pname = pname;
-   thread_param->param = param;
+   thread_data->pname = pname;
+   thread_data->param = param;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glPointParameterx,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glPointParameterxv(GLenum pname, const GLfixed *params);
+ * void
+ * glPointParameterxv(GLenum pname, const GLfixed *params);
  */
 
 typedef struct
@@ -15323,11 +15327,11 @@ void (*orig_evgl_api_glPointParameterxv)(GLenum pname, const GLfixed *params);
 static void
 _evgl_api_thread_glPointParameterxv(void *data)
 {
-   EVGL_API_Thread_Command_glPointParameterxv *thread_param =
+   EVGL_API_Thread_Command_glPointParameterxv *thread_data =
       (EVGL_API_Thread_Command_glPointParameterxv *)data;
 
-   orig_evgl_api_glPointParameterxv(thread_param->pname,
-                                    thread_param->params);
+   orig_evgl_api_glPointParameterxv(thread_data->pname,
+                                    thread_data->params);
 
 }
 
@@ -15342,21 +15346,21 @@ glPointParameterxv_evgl_api_thread_cmd(GLenum pname, const GLfixed *params)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glPointParameterxv thread_param_local;
-   EVGL_API_Thread_Command_glPointParameterxv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glPointParameterxv thread_data_local;
+   EVGL_API_Thread_Command_glPointParameterxv *thread_data = &thread_data_local;
 
-   thread_param->pname = pname;
-   thread_param->params = params;
+   thread_data->pname = pname;
+   thread_data->params = params;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glPointParameterxv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glPointSizex(GLfixed size);
+ * void
+ * glPointSizex(GLfixed size);
  */
 
 typedef struct
@@ -15370,10 +15374,10 @@ void (*orig_evgl_api_glPointSizex)(GLfixed size);
 static void
 _evgl_api_thread_glPointSizex(void *data)
 {
-   EVGL_API_Thread_Command_glPointSizex *thread_param =
+   EVGL_API_Thread_Command_glPointSizex *thread_data =
       (EVGL_API_Thread_Command_glPointSizex *)data;
 
-   orig_evgl_api_glPointSizex(thread_param->size);
+   orig_evgl_api_glPointSizex(thread_data->size);
 
 }
 
@@ -15388,20 +15392,20 @@ glPointSizex_evgl_api_thread_cmd(GLfixed size)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glPointSizex thread_param_local;
-   EVGL_API_Thread_Command_glPointSizex *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glPointSizex thread_data_local;
+   EVGL_API_Thread_Command_glPointSizex *thread_data = &thread_data_local;
 
-   thread_param->size = size;
+   thread_data->size = size;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glPointSizex,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glPolygonOffsetx(GLfixed factor, GLfixed units);
+ * void
+ * glPolygonOffsetx(GLfixed factor, GLfixed units);
  */
 
 typedef struct
@@ -15416,11 +15420,11 @@ void (*orig_evgl_api_glPolygonOffsetx)(GLfixed factor, GLfixed units);
 static void
 _evgl_api_thread_glPolygonOffsetx(void *data)
 {
-   EVGL_API_Thread_Command_glPolygonOffsetx *thread_param =
+   EVGL_API_Thread_Command_glPolygonOffsetx *thread_data =
       (EVGL_API_Thread_Command_glPolygonOffsetx *)data;
 
-   orig_evgl_api_glPolygonOffsetx(thread_param->factor,
-                                  thread_param->units);
+   orig_evgl_api_glPolygonOffsetx(thread_data->factor,
+                                  thread_data->units);
 
 }
 
@@ -15435,21 +15439,21 @@ glPolygonOffsetx_evgl_api_thread_cmd(GLfixed factor, GLfixed units)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glPolygonOffsetx thread_param_local;
-   EVGL_API_Thread_Command_glPolygonOffsetx *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glPolygonOffsetx thread_data_local;
+   EVGL_API_Thread_Command_glPolygonOffsetx *thread_data = &thread_data_local;
 
-   thread_param->factor = factor;
-   thread_param->units = units;
+   thread_data->factor = factor;
+   thread_data->units = units;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glPolygonOffsetx,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glPopMatrix(void);
+ * void
+ * glPopMatrix(void);
  */
 
 void (*orig_evgl_api_glPopMatrix)(void);
@@ -15479,8 +15483,8 @@ glPopMatrix_evgl_api_thread_cmd(void)
 }
 
 /*
-   void
-   glPushMatrix(void);
+ * void
+ * glPushMatrix(void);
  */
 
 void (*orig_evgl_api_glPushMatrix)(void);
@@ -15510,8 +15514,8 @@ glPushMatrix_evgl_api_thread_cmd(void)
 }
 
 /*
-   void
-   glRotatex(GLfixed angle, GLfixed x, GLfixed y, GLfixed z);
+ * void
+ * glRotatex(GLfixed angle, GLfixed x, GLfixed y, GLfixed z);
  */
 
 typedef struct
@@ -15528,13 +15532,13 @@ void (*orig_evgl_api_glRotatex)(GLfixed angle, GLfixed x, GLfixed y, GLfixed z);
 static void
 _evgl_api_thread_glRotatex(void *data)
 {
-   EVGL_API_Thread_Command_glRotatex *thread_param =
+   EVGL_API_Thread_Command_glRotatex *thread_data =
       (EVGL_API_Thread_Command_glRotatex *)data;
 
-   orig_evgl_api_glRotatex(thread_param->angle,
-                           thread_param->x,
-                           thread_param->y,
-                           thread_param->z);
+   orig_evgl_api_glRotatex(thread_data->angle,
+                           thread_data->x,
+                           thread_data->y,
+                           thread_data->z);
 
 }
 
@@ -15549,23 +15553,23 @@ glRotatex_evgl_api_thread_cmd(GLfixed angle, GLfixed x, GLfixed y, GLfixed z)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glRotatex thread_param_local;
-   EVGL_API_Thread_Command_glRotatex *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glRotatex thread_data_local;
+   EVGL_API_Thread_Command_glRotatex *thread_data = &thread_data_local;
 
-   thread_param->angle = angle;
-   thread_param->x = x;
-   thread_param->y = y;
-   thread_param->z = z;
+   thread_data->angle = angle;
+   thread_data->x = x;
+   thread_data->y = y;
+   thread_data->z = z;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glRotatex,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glSampleCoveragex(GLclampx value, GLboolean invert);
+ * void
+ * glSampleCoveragex(GLclampx value, GLboolean invert);
  */
 
 typedef struct
@@ -15580,11 +15584,11 @@ void (*orig_evgl_api_glSampleCoveragex)(GLclampx value, GLboolean invert);
 static void
 _evgl_api_thread_glSampleCoveragex(void *data)
 {
-   EVGL_API_Thread_Command_glSampleCoveragex *thread_param =
+   EVGL_API_Thread_Command_glSampleCoveragex *thread_data =
       (EVGL_API_Thread_Command_glSampleCoveragex *)data;
 
-   orig_evgl_api_glSampleCoveragex(thread_param->value,
-                                   thread_param->invert);
+   orig_evgl_api_glSampleCoveragex(thread_data->value,
+                                   thread_data->invert);
 
 }
 
@@ -15599,21 +15603,21 @@ glSampleCoveragex_evgl_api_thread_cmd(GLclampx value, GLboolean invert)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glSampleCoveragex thread_param_local;
-   EVGL_API_Thread_Command_glSampleCoveragex *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glSampleCoveragex thread_data_local;
+   EVGL_API_Thread_Command_glSampleCoveragex *thread_data = &thread_data_local;
 
-   thread_param->value = value;
-   thread_param->invert = invert;
+   thread_data->value = value;
+   thread_data->invert = invert;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glSampleCoveragex,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glScalex(GLfixed x, GLfixed y, GLfixed z);
+ * void
+ * glScalex(GLfixed x, GLfixed y, GLfixed z);
  */
 
 typedef struct
@@ -15629,12 +15633,12 @@ void (*orig_evgl_api_glScalex)(GLfixed x, GLfixed y, GLfixed z);
 static void
 _evgl_api_thread_glScalex(void *data)
 {
-   EVGL_API_Thread_Command_glScalex *thread_param =
+   EVGL_API_Thread_Command_glScalex *thread_data =
       (EVGL_API_Thread_Command_glScalex *)data;
 
-   orig_evgl_api_glScalex(thread_param->x,
-                          thread_param->y,
-                          thread_param->z);
+   orig_evgl_api_glScalex(thread_data->x,
+                          thread_data->y,
+                          thread_data->z);
 
 }
 
@@ -15649,22 +15653,22 @@ glScalex_evgl_api_thread_cmd(GLfixed x, GLfixed y, GLfixed z)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glScalex thread_param_local;
-   EVGL_API_Thread_Command_glScalex *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glScalex thread_data_local;
+   EVGL_API_Thread_Command_glScalex *thread_data = &thread_data_local;
 
-   thread_param->x = x;
-   thread_param->y = y;
-   thread_param->z = z;
+   thread_data->x = x;
+   thread_data->y = y;
+   thread_data->z = z;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glScalex,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glShadeModel(GLenum mode);
+ * void
+ * glShadeModel(GLenum mode);
  */
 
 typedef struct
@@ -15678,10 +15682,10 @@ void (*orig_evgl_api_glShadeModel)(GLenum mode);
 static void
 _evgl_api_thread_glShadeModel(void *data)
 {
-   EVGL_API_Thread_Command_glShadeModel *thread_param =
+   EVGL_API_Thread_Command_glShadeModel *thread_data =
       (EVGL_API_Thread_Command_glShadeModel *)data;
 
-   orig_evgl_api_glShadeModel(thread_param->mode);
+   orig_evgl_api_glShadeModel(thread_data->mode);
 
 }
 
@@ -15696,20 +15700,20 @@ glShadeModel_evgl_api_thread_cmd(GLenum mode)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glShadeModel thread_param_local;
-   EVGL_API_Thread_Command_glShadeModel *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glShadeModel thread_data_local;
+   EVGL_API_Thread_Command_glShadeModel *thread_data = &thread_data_local;
 
-   thread_param->mode = mode;
+   thread_data->mode = mode;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glShadeModel,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
+ * void
+ * glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
  */
 
 typedef struct
@@ -15726,13 +15730,13 @@ void (*orig_evgl_api_glTexCoordPointer)(GLint size, GLenum type, GLsizei stride,
 static void
 _evgl_api_thread_glTexCoordPointer(void *data)
 {
-   EVGL_API_Thread_Command_glTexCoordPointer *thread_param =
+   EVGL_API_Thread_Command_glTexCoordPointer *thread_data =
       (EVGL_API_Thread_Command_glTexCoordPointer *)data;
 
-   orig_evgl_api_glTexCoordPointer(thread_param->size,
-                                   thread_param->type,
-                                   thread_param->stride,
-                                   thread_param->pointer);
+   orig_evgl_api_glTexCoordPointer(thread_data->size,
+                                   thread_data->type,
+                                   thread_data->stride,
+                                   thread_data->pointer);
 
 }
 
@@ -15747,23 +15751,23 @@ glTexCoordPointer_evgl_api_thread_cmd(GLint size, GLenum type, GLsizei stride, c
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glTexCoordPointer thread_param_local;
-   EVGL_API_Thread_Command_glTexCoordPointer *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glTexCoordPointer thread_data_local;
+   EVGL_API_Thread_Command_glTexCoordPointer *thread_data = &thread_data_local;
 
-   thread_param->size = size;
-   thread_param->type = type;
-   thread_param->stride = stride;
-   thread_param->pointer = pointer;
+   thread_data->size = size;
+   thread_data->type = type;
+   thread_data->stride = stride;
+   thread_data->pointer = pointer;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glTexCoordPointer,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glTexEnvi(GLenum target, GLenum pname, GLint param);
+ * void
+ * glTexEnvi(GLenum target, GLenum pname, GLint param);
  */
 
 typedef struct
@@ -15779,12 +15783,12 @@ void (*orig_evgl_api_glTexEnvi)(GLenum target, GLenum pname, GLint param);
 static void
 _evgl_api_thread_glTexEnvi(void *data)
 {
-   EVGL_API_Thread_Command_glTexEnvi *thread_param =
+   EVGL_API_Thread_Command_glTexEnvi *thread_data =
       (EVGL_API_Thread_Command_glTexEnvi *)data;
 
-   orig_evgl_api_glTexEnvi(thread_param->target,
-                           thread_param->pname,
-                           thread_param->param);
+   orig_evgl_api_glTexEnvi(thread_data->target,
+                           thread_data->pname,
+                           thread_data->param);
 
 }
 
@@ -15799,22 +15803,22 @@ glTexEnvi_evgl_api_thread_cmd(GLenum target, GLenum pname, GLint param)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glTexEnvi thread_param_local;
-   EVGL_API_Thread_Command_glTexEnvi *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glTexEnvi thread_data_local;
+   EVGL_API_Thread_Command_glTexEnvi *thread_data = &thread_data_local;
 
-   thread_param->target = target;
-   thread_param->pname = pname;
-   thread_param->param = param;
+   thread_data->target = target;
+   thread_data->pname = pname;
+   thread_data->param = param;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glTexEnvi,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glTexEnvx(GLenum target, GLenum pname, GLfixed param);
+ * void
+ * glTexEnvx(GLenum target, GLenum pname, GLfixed param);
  */
 
 typedef struct
@@ -15830,12 +15834,12 @@ void (*orig_evgl_api_glTexEnvx)(GLenum target, GLenum pname, GLfixed param);
 static void
 _evgl_api_thread_glTexEnvx(void *data)
 {
-   EVGL_API_Thread_Command_glTexEnvx *thread_param =
+   EVGL_API_Thread_Command_glTexEnvx *thread_data =
       (EVGL_API_Thread_Command_glTexEnvx *)data;
 
-   orig_evgl_api_glTexEnvx(thread_param->target,
-                           thread_param->pname,
-                           thread_param->param);
+   orig_evgl_api_glTexEnvx(thread_data->target,
+                           thread_data->pname,
+                           thread_data->param);
 
 }
 
@@ -15850,22 +15854,22 @@ glTexEnvx_evgl_api_thread_cmd(GLenum target, GLenum pname, GLfixed param)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glTexEnvx thread_param_local;
-   EVGL_API_Thread_Command_glTexEnvx *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glTexEnvx thread_data_local;
+   EVGL_API_Thread_Command_glTexEnvx *thread_data = &thread_data_local;
 
-   thread_param->target = target;
-   thread_param->pname = pname;
-   thread_param->param = param;
+   thread_data->target = target;
+   thread_data->pname = pname;
+   thread_data->param = param;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glTexEnvx,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glTexEnviv(GLenum target, GLenum pname, const GLint *params);
+ * void
+ * glTexEnviv(GLenum target, GLenum pname, const GLint *params);
  */
 
 typedef struct
@@ -15881,12 +15885,12 @@ void (*orig_evgl_api_glTexEnviv)(GLenum target, GLenum pname, const GLint *param
 static void
 _evgl_api_thread_glTexEnviv(void *data)
 {
-   EVGL_API_Thread_Command_glTexEnviv *thread_param =
+   EVGL_API_Thread_Command_glTexEnviv *thread_data =
       (EVGL_API_Thread_Command_glTexEnviv *)data;
 
-   orig_evgl_api_glTexEnviv(thread_param->target,
-                            thread_param->pname,
-                            thread_param->params);
+   orig_evgl_api_glTexEnviv(thread_data->target,
+                            thread_data->pname,
+                            thread_data->params);
 
 }
 
@@ -15901,22 +15905,22 @@ glTexEnviv_evgl_api_thread_cmd(GLenum target, GLenum pname, const GLint *params)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glTexEnviv thread_param_local;
-   EVGL_API_Thread_Command_glTexEnviv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glTexEnviv thread_data_local;
+   EVGL_API_Thread_Command_glTexEnviv *thread_data = &thread_data_local;
 
-   thread_param->target = target;
-   thread_param->pname = pname;
-   thread_param->params = params;
+   thread_data->target = target;
+   thread_data->pname = pname;
+   thread_data->params = params;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glTexEnviv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glTexEnvxv(GLenum target, GLenum pname, const GLfixed *params);
+ * void
+ * glTexEnvxv(GLenum target, GLenum pname, const GLfixed *params);
  */
 
 typedef struct
@@ -15932,12 +15936,12 @@ void (*orig_evgl_api_glTexEnvxv)(GLenum target, GLenum pname, const GLfixed *par
 static void
 _evgl_api_thread_glTexEnvxv(void *data)
 {
-   EVGL_API_Thread_Command_glTexEnvxv *thread_param =
+   EVGL_API_Thread_Command_glTexEnvxv *thread_data =
       (EVGL_API_Thread_Command_glTexEnvxv *)data;
 
-   orig_evgl_api_glTexEnvxv(thread_param->target,
-                            thread_param->pname,
-                            thread_param->params);
+   orig_evgl_api_glTexEnvxv(thread_data->target,
+                            thread_data->pname,
+                            thread_data->params);
 
 }
 
@@ -15952,22 +15956,22 @@ glTexEnvxv_evgl_api_thread_cmd(GLenum target, GLenum pname, const GLfixed *param
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glTexEnvxv thread_param_local;
-   EVGL_API_Thread_Command_glTexEnvxv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glTexEnvxv thread_data_local;
+   EVGL_API_Thread_Command_glTexEnvxv *thread_data = &thread_data_local;
 
-   thread_param->target = target;
-   thread_param->pname = pname;
-   thread_param->params = params;
+   thread_data->target = target;
+   thread_data->pname = pname;
+   thread_data->params = params;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glTexEnvxv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glTexParameterx(GLenum target, GLenum pname, GLfixed param);
+ * void
+ * glTexParameterx(GLenum target, GLenum pname, GLfixed param);
  */
 
 typedef struct
@@ -15983,12 +15987,12 @@ void (*orig_evgl_api_glTexParameterx)(GLenum target, GLenum pname, GLfixed param
 static void
 _evgl_api_thread_glTexParameterx(void *data)
 {
-   EVGL_API_Thread_Command_glTexParameterx *thread_param =
+   EVGL_API_Thread_Command_glTexParameterx *thread_data =
       (EVGL_API_Thread_Command_glTexParameterx *)data;
 
-   orig_evgl_api_glTexParameterx(thread_param->target,
-                                 thread_param->pname,
-                                 thread_param->param);
+   orig_evgl_api_glTexParameterx(thread_data->target,
+                                 thread_data->pname,
+                                 thread_data->param);
 
 }
 
@@ -16003,22 +16007,22 @@ glTexParameterx_evgl_api_thread_cmd(GLenum target, GLenum pname, GLfixed param)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glTexParameterx thread_param_local;
-   EVGL_API_Thread_Command_glTexParameterx *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glTexParameterx thread_data_local;
+   EVGL_API_Thread_Command_glTexParameterx *thread_data = &thread_data_local;
 
-   thread_param->target = target;
-   thread_param->pname = pname;
-   thread_param->param = param;
+   thread_data->target = target;
+   thread_data->pname = pname;
+   thread_data->param = param;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glTexParameterx,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glTexParameterxv(GLenum target, GLenum pname, const GLfixed *params);
+ * void
+ * glTexParameterxv(GLenum target, GLenum pname, const GLfixed *params);
  */
 
 typedef struct
@@ -16034,12 +16038,12 @@ void (*orig_evgl_api_glTexParameterxv)(GLenum target, GLenum pname, const GLfixe
 static void
 _evgl_api_thread_glTexParameterxv(void *data)
 {
-   EVGL_API_Thread_Command_glTexParameterxv *thread_param =
+   EVGL_API_Thread_Command_glTexParameterxv *thread_data =
       (EVGL_API_Thread_Command_glTexParameterxv *)data;
 
-   orig_evgl_api_glTexParameterxv(thread_param->target,
-                                  thread_param->pname,
-                                  thread_param->params);
+   orig_evgl_api_glTexParameterxv(thread_data->target,
+                                  thread_data->pname,
+                                  thread_data->params);
 
 }
 
@@ -16054,22 +16058,22 @@ glTexParameterxv_evgl_api_thread_cmd(GLenum target, GLenum pname, const GLfixed
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glTexParameterxv thread_param_local;
-   EVGL_API_Thread_Command_glTexParameterxv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glTexParameterxv thread_data_local;
+   EVGL_API_Thread_Command_glTexParameterxv *thread_data = &thread_data_local;
 
-   thread_param->target = target;
-   thread_param->pname = pname;
-   thread_param->params = params;
+   thread_data->target = target;
+   thread_data->pname = pname;
+   thread_data->params = params;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glTexParameterxv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glTranslatex(GLfixed x, GLfixed y, GLfixed z);
+ * void
+ * glTranslatex(GLfixed x, GLfixed y, GLfixed z);
  */
 
 typedef struct
@@ -16085,12 +16089,12 @@ void (*orig_evgl_api_glTranslatex)(GLfixed x, GLfixed y, GLfixed z);
 static void
 _evgl_api_thread_glTranslatex(void *data)
 {
-   EVGL_API_Thread_Command_glTranslatex *thread_param =
+   EVGL_API_Thread_Command_glTranslatex *thread_data =
       (EVGL_API_Thread_Command_glTranslatex *)data;
 
-   orig_evgl_api_glTranslatex(thread_param->x,
-                              thread_param->y,
-                              thread_param->z);
+   orig_evgl_api_glTranslatex(thread_data->x,
+                              thread_data->y,
+                              thread_data->z);
 
 }
 
@@ -16105,22 +16109,22 @@ glTranslatex_evgl_api_thread_cmd(GLfixed x, GLfixed y, GLfixed z)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glTranslatex thread_param_local;
-   EVGL_API_Thread_Command_glTranslatex *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glTranslatex thread_data_local;
+   EVGL_API_Thread_Command_glTranslatex *thread_data = &thread_data_local;
 
-   thread_param->x = x;
-   thread_param->y = y;
-   thread_param->z = z;
+   thread_data->x = x;
+   thread_data->y = y;
+   thread_data->z = z;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glTranslatex,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glVertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
+ * void
+ * glVertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
  */
 
 typedef struct
@@ -16137,13 +16141,13 @@ void (*orig_evgl_api_glVertexPointer)(GLint size, GLenum type, GLsizei stride, c
 static void
 _evgl_api_thread_glVertexPointer(void *data)
 {
-   EVGL_API_Thread_Command_glVertexPointer *thread_param =
+   EVGL_API_Thread_Command_glVertexPointer *thread_data =
       (EVGL_API_Thread_Command_glVertexPointer *)data;
 
-   orig_evgl_api_glVertexPointer(thread_param->size,
-                                 thread_param->type,
-                                 thread_param->stride,
-                                 thread_param->pointer);
+   orig_evgl_api_glVertexPointer(thread_data->size,
+                                 thread_data->type,
+                                 thread_data->stride,
+                                 thread_data->pointer);
 
 }
 
@@ -16158,23 +16162,23 @@ glVertexPointer_evgl_api_thread_cmd(GLint size, GLenum type, GLsizei stride, con
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glVertexPointer thread_param_local;
-   EVGL_API_Thread_Command_glVertexPointer *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glVertexPointer thread_data_local;
+   EVGL_API_Thread_Command_glVertexPointer *thread_data = &thread_data_local;
 
-   thread_param->size = size;
-   thread_param->type = type;
-   thread_param->stride = stride;
-   thread_param->pointer = pointer;
+   thread_data->size = size;
+   thread_data->type = type;
+   thread_data->stride = stride;
+   thread_data->pointer = pointer;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glVertexPointer,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glBlendEquationSeparateOES(GLenum modeRGB, GLenum modeAlpha);
+ * void
+ * glBlendEquationSeparateOES(GLenum modeRGB, GLenum modeAlpha);
  */
 
 typedef struct
@@ -16189,11 +16193,11 @@ void (*orig_evgl_api_glBlendEquationSeparateOES)(GLenum modeRGB, GLenum modeAlph
 static void
 _evgl_api_thread_glBlendEquationSeparateOES(void *data)
 {
-   EVGL_API_Thread_Command_glBlendEquationSeparateOES *thread_param =
+   EVGL_API_Thread_Command_glBlendEquationSeparateOES *thread_data =
       (EVGL_API_Thread_Command_glBlendEquationSeparateOES *)data;
 
-   orig_evgl_api_glBlendEquationSeparateOES(thread_param->modeRGB,
-                                            thread_param->modeAlpha);
+   orig_evgl_api_glBlendEquationSeparateOES(thread_data->modeRGB,
+                                            thread_data->modeAlpha);
 
 }
 
@@ -16208,21 +16212,21 @@ glBlendEquationSeparateOES_evgl_api_thread_cmd(GLenum modeRGB, GLenum modeAlpha)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glBlendEquationSeparateOES thread_param_local;
-   EVGL_API_Thread_Command_glBlendEquationSeparateOES *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glBlendEquationSeparateOES thread_data_local;
+   EVGL_API_Thread_Command_glBlendEquationSeparateOES *thread_data = &thread_data_local;
 
-   thread_param->modeRGB = modeRGB;
-   thread_param->modeAlpha = modeAlpha;
+   thread_data->modeRGB = modeRGB;
+   thread_data->modeAlpha = modeAlpha;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glBlendEquationSeparateOES,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glBlendFuncSeparateOES(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha);
+ * void
+ * glBlendFuncSeparateOES(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha);
  */
 
 typedef struct
@@ -16239,13 +16243,13 @@ void (*orig_evgl_api_glBlendFuncSeparateOES)(GLenum srcRGB, GLenum dstRGB, GLenu
 static void
 _evgl_api_thread_glBlendFuncSeparateOES(void *data)
 {
-   EVGL_API_Thread_Command_glBlendFuncSeparateOES *thread_param =
+   EVGL_API_Thread_Command_glBlendFuncSeparateOES *thread_data =
       (EVGL_API_Thread_Command_glBlendFuncSeparateOES *)data;
 
-   orig_evgl_api_glBlendFuncSeparateOES(thread_param->srcRGB,
-                                        thread_param->dstRGB,
-                                        thread_param->srcAlpha,
-                                        thread_param->dstAlpha);
+   orig_evgl_api_glBlendFuncSeparateOES(thread_data->srcRGB,
+                                        thread_data->dstRGB,
+                                        thread_data->srcAlpha,
+                                        thread_data->dstAlpha);
 
 }
 
@@ -16260,23 +16264,23 @@ glBlendFuncSeparateOES_evgl_api_thread_cmd(GLenum srcRGB, GLenum dstRGB, GLenum
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glBlendFuncSeparateOES thread_param_local;
-   EVGL_API_Thread_Command_glBlendFuncSeparateOES *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glBlendFuncSeparateOES thread_data_local;
+   EVGL_API_Thread_Command_glBlendFuncSeparateOES *thread_data = &thread_data_local;
 
-   thread_param->srcRGB = srcRGB;
-   thread_param->dstRGB = dstRGB;
-   thread_param->srcAlpha = srcAlpha;
-   thread_param->dstAlpha = dstAlpha;
+   thread_data->srcRGB = srcRGB;
+   thread_data->dstRGB = dstRGB;
+   thread_data->srcAlpha = srcAlpha;
+   thread_data->dstAlpha = dstAlpha;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glBlendFuncSeparateOES,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glBlendEquationOES(GLenum mode);
+ * void
+ * glBlendEquationOES(GLenum mode);
  */
 
 typedef struct
@@ -16290,10 +16294,10 @@ void (*orig_evgl_api_glBlendEquationOES)(GLenum mode);
 static void
 _evgl_api_thread_glBlendEquationOES(void *data)
 {
-   EVGL_API_Thread_Command_glBlendEquationOES *thread_param =
+   EVGL_API_Thread_Command_glBlendEquationOES *thread_data =
       (EVGL_API_Thread_Command_glBlendEquationOES *)data;
 
-   orig_evgl_api_glBlendEquationOES(thread_param->mode);
+   orig_evgl_api_glBlendEquationOES(thread_data->mode);
 
 }
 
@@ -16308,20 +16312,20 @@ glBlendEquationOES_evgl_api_thread_cmd(GLenum mode)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glBlendEquationOES thread_param_local;
-   EVGL_API_Thread_Command_glBlendEquationOES *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glBlendEquationOES thread_data_local;
+   EVGL_API_Thread_Command_glBlendEquationOES *thread_data = &thread_data_local;
 
-   thread_param->mode = mode;
+   thread_data->mode = mode;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glBlendEquationOES,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glDrawTexsOES(GLshort x, GLshort y, GLshort z, GLshort width, GLshort height);
+ * void
+ * glDrawTexsOES(GLshort x, GLshort y, GLshort z, GLshort width, GLshort height);
  */
 
 typedef struct
@@ -16339,14 +16343,14 @@ void (*orig_evgl_api_glDrawTexsOES)(GLshort x, GLshort y, GLshort z, GLshort wid
 static void
 _evgl_api_thread_glDrawTexsOES(void *data)
 {
-   EVGL_API_Thread_Command_glDrawTexsOES *thread_param =
+   EVGL_API_Thread_Command_glDrawTexsOES *thread_data =
       (EVGL_API_Thread_Command_glDrawTexsOES *)data;
 
-   orig_evgl_api_glDrawTexsOES(thread_param->x,
-                               thread_param->y,
-                               thread_param->z,
-                               thread_param->width,
-                               thread_param->height);
+   orig_evgl_api_glDrawTexsOES(thread_data->x,
+                               thread_data->y,
+                               thread_data->z,
+                               thread_data->width,
+                               thread_data->height);
 
 }
 
@@ -16361,24 +16365,24 @@ glDrawTexsOES_evgl_api_thread_cmd(GLshort x, GLshort y, GLshort z, GLshort width
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glDrawTexsOES thread_param_local;
-   EVGL_API_Thread_Command_glDrawTexsOES *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glDrawTexsOES thread_data_local;
+   EVGL_API_Thread_Command_glDrawTexsOES *thread_data = &thread_data_local;
 
-   thread_param->x = x;
-   thread_param->y = y;
-   thread_param->z = z;
-   thread_param->width = width;
-   thread_param->height = height;
+   thread_data->x = x;
+   thread_data->y = y;
+   thread_data->z = z;
+   thread_data->width = width;
+   thread_data->height = height;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glDrawTexsOES,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glDrawTexiOES(GLint x, GLint y, GLint z, GLint width, GLint height);
+ * void
+ * glDrawTexiOES(GLint x, GLint y, GLint z, GLint width, GLint height);
  */
 
 typedef struct
@@ -16396,14 +16400,14 @@ void (*orig_evgl_api_glDrawTexiOES)(GLint x, GLint y, GLint z, GLint width, GLin
 static void
 _evgl_api_thread_glDrawTexiOES(void *data)
 {
-   EVGL_API_Thread_Command_glDrawTexiOES *thread_param =
+   EVGL_API_Thread_Command_glDrawTexiOES *thread_data =
       (EVGL_API_Thread_Command_glDrawTexiOES *)data;
 
-   orig_evgl_api_glDrawTexiOES(thread_param->x,
-                               thread_param->y,
-                               thread_param->z,
-                               thread_param->width,
-                               thread_param->height);
+   orig_evgl_api_glDrawTexiOES(thread_data->x,
+                               thread_data->y,
+                               thread_data->z,
+                               thread_data->width,
+                               thread_data->height);
 
 }
 
@@ -16418,24 +16422,24 @@ glDrawTexiOES_evgl_api_thread_cmd(GLint x, GLint y, GLint z, GLint width, GLint
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glDrawTexiOES thread_param_local;
-   EVGL_API_Thread_Command_glDrawTexiOES *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glDrawTexiOES thread_data_local;
+   EVGL_API_Thread_Command_glDrawTexiOES *thread_data = &thread_data_local;
 
-   thread_param->x = x;
-   thread_param->y = y;
-   thread_param->z = z;
-   thread_param->width = width;
-   thread_param->height = height;
+   thread_data->x = x;
+   thread_data->y = y;
+   thread_data->z = z;
+   thread_data->width = width;
+   thread_data->height = height;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glDrawTexiOES,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glDrawTexxOES(GLfixed x, GLfixed y, GLfixed z, GLfixed width, GLfixed height);
+ * void
+ * glDrawTexxOES(GLfixed x, GLfixed y, GLfixed z, GLfixed width, GLfixed height);
  */
 
 typedef struct
@@ -16453,14 +16457,14 @@ void (*orig_evgl_api_glDrawTexxOES)(GLfixed x, GLfixed y, GLfixed z, GLfixed wid
 static void
 _evgl_api_thread_glDrawTexxOES(void *data)
 {
-   EVGL_API_Thread_Command_glDrawTexxOES *thread_param =
+   EVGL_API_Thread_Command_glDrawTexxOES *thread_data =
       (EVGL_API_Thread_Command_glDrawTexxOES *)data;
 
-   orig_evgl_api_glDrawTexxOES(thread_param->x,
-                               thread_param->y,
-                               thread_param->z,
-                               thread_param->width,
-                               thread_param->height);
+   orig_evgl_api_glDrawTexxOES(thread_data->x,
+                               thread_data->y,
+                               thread_data->z,
+                               thread_data->width,
+                               thread_data->height);
 
 }
 
@@ -16475,24 +16479,24 @@ glDrawTexxOES_evgl_api_thread_cmd(GLfixed x, GLfixed y, GLfixed z, GLfixed width
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glDrawTexxOES thread_param_local;
-   EVGL_API_Thread_Command_glDrawTexxOES *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glDrawTexxOES thread_data_local;
+   EVGL_API_Thread_Command_glDrawTexxOES *thread_data = &thread_data_local;
 
-   thread_param->x = x;
-   thread_param->y = y;
-   thread_param->z = z;
-   thread_param->width = width;
-   thread_param->height = height;
+   thread_data->x = x;
+   thread_data->y = y;
+   thread_data->z = z;
+   thread_data->width = width;
+   thread_data->height = height;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glDrawTexxOES,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glDrawTexsvOES(const GLshort *coords);
+ * void
+ * glDrawTexsvOES(const GLshort *coords);
  */
 
 typedef struct
@@ -16506,10 +16510,10 @@ void (*orig_evgl_api_glDrawTexsvOES)(const GLshort *coords);
 static void
 _evgl_api_thread_glDrawTexsvOES(void *data)
 {
-   EVGL_API_Thread_Command_glDrawTexsvOES *thread_param =
+   EVGL_API_Thread_Command_glDrawTexsvOES *thread_data =
       (EVGL_API_Thread_Command_glDrawTexsvOES *)data;
 
-   orig_evgl_api_glDrawTexsvOES(thread_param->coords);
+   orig_evgl_api_glDrawTexsvOES(thread_data->coords);
 
 }
 
@@ -16524,20 +16528,20 @@ glDrawTexsvOES_evgl_api_thread_cmd(const GLshort *coords)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glDrawTexsvOES thread_param_local;
-   EVGL_API_Thread_Command_glDrawTexsvOES *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glDrawTexsvOES thread_data_local;
+   EVGL_API_Thread_Command_glDrawTexsvOES *thread_data = &thread_data_local;
 
-   thread_param->coords = coords;
+   thread_data->coords = coords;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glDrawTexsvOES,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glDrawTexivOES(const GLint *coords);
+ * void
+ * glDrawTexivOES(const GLint *coords);
  */
 
 typedef struct
@@ -16551,10 +16555,10 @@ void (*orig_evgl_api_glDrawTexivOES)(const GLint *coords);
 static void
 _evgl_api_thread_glDrawTexivOES(void *data)
 {
-   EVGL_API_Thread_Command_glDrawTexivOES *thread_param =
+   EVGL_API_Thread_Command_glDrawTexivOES *thread_data =
       (EVGL_API_Thread_Command_glDrawTexivOES *)data;
 
-   orig_evgl_api_glDrawTexivOES(thread_param->coords);
+   orig_evgl_api_glDrawTexivOES(thread_data->coords);
 
 }
 
@@ -16569,20 +16573,20 @@ glDrawTexivOES_evgl_api_thread_cmd(const GLint *coords)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glDrawTexivOES thread_param_local;
-   EVGL_API_Thread_Command_glDrawTexivOES *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glDrawTexivOES thread_data_local;
+   EVGL_API_Thread_Command_glDrawTexivOES *thread_data = &thread_data_local;
 
-   thread_param->coords = coords;
+   thread_data->coords = coords;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glDrawTexivOES,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glDrawTexxvOES(const GLfixed *coords);
+ * void
+ * glDrawTexxvOES(const GLfixed *coords);
  */
 
 typedef struct
@@ -16596,10 +16600,10 @@ void (*orig_evgl_api_glDrawTexxvOES)(const GLfixed *coords);
 static void
 _evgl_api_thread_glDrawTexxvOES(void *data)
 {
-   EVGL_API_Thread_Command_glDrawTexxvOES *thread_param =
+   EVGL_API_Thread_Command_glDrawTexxvOES *thread_data =
       (EVGL_API_Thread_Command_glDrawTexxvOES *)data;
 
-   orig_evgl_api_glDrawTexxvOES(thread_param->coords);
+   orig_evgl_api_glDrawTexxvOES(thread_data->coords);
 
 }
 
@@ -16614,20 +16618,20 @@ glDrawTexxvOES_evgl_api_thread_cmd(const GLfixed *coords)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glDrawTexxvOES thread_param_local;
-   EVGL_API_Thread_Command_glDrawTexxvOES *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glDrawTexxvOES thread_data_local;
+   EVGL_API_Thread_Command_glDrawTexxvOES *thread_data = &thread_data_local;
 
-   thread_param->coords = coords;
+   thread_data->coords = coords;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glDrawTexxvOES,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glDrawTexfOES(GLfloat x, GLfloat y, GLfloat z, GLfloat width, GLfloat height);
+ * void
+ * glDrawTexfOES(GLfloat x, GLfloat y, GLfloat z, GLfloat width, GLfloat height);
  */
 
 typedef struct
@@ -16645,14 +16649,14 @@ void (*orig_evgl_api_glDrawTexfOES)(GLfloat x, GLfloat y, GLfloat z, GLfloat wid
 static void
 _evgl_api_thread_glDrawTexfOES(void *data)
 {
-   EVGL_API_Thread_Command_glDrawTexfOES *thread_param =
+   EVGL_API_Thread_Command_glDrawTexfOES *thread_data =
       (EVGL_API_Thread_Command_glDrawTexfOES *)data;
 
-   orig_evgl_api_glDrawTexfOES(thread_param->x,
-                               thread_param->y,
-                               thread_param->z,
-                               thread_param->width,
-                               thread_param->height);
+   orig_evgl_api_glDrawTexfOES(thread_data->x,
+                               thread_data->y,
+                               thread_data->z,
+                               thread_data->width,
+                               thread_data->height);
 
 }
 
@@ -16667,24 +16671,24 @@ glDrawTexfOES_evgl_api_thread_cmd(GLfloat x, GLfloat y, GLfloat z, GLfloat width
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glDrawTexfOES thread_param_local;
-   EVGL_API_Thread_Command_glDrawTexfOES *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glDrawTexfOES thread_data_local;
+   EVGL_API_Thread_Command_glDrawTexfOES *thread_data = &thread_data_local;
 
-   thread_param->x = x;
-   thread_param->y = y;
-   thread_param->z = z;
-   thread_param->width = width;
-   thread_param->height = height;
+   thread_data->x = x;
+   thread_data->y = y;
+   thread_data->z = z;
+   thread_data->width = width;
+   thread_data->height = height;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glDrawTexfOES,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glDrawTexfvOES(const GLfloat *coords);
+ * void
+ * glDrawTexfvOES(const GLfloat *coords);
  */
 
 typedef struct
@@ -16698,10 +16702,10 @@ void (*orig_evgl_api_glDrawTexfvOES)(const GLfloat *coords);
 static void
 _evgl_api_thread_glDrawTexfvOES(void *data)
 {
-   EVGL_API_Thread_Command_glDrawTexfvOES *thread_param =
+   EVGL_API_Thread_Command_glDrawTexfvOES *thread_data =
       (EVGL_API_Thread_Command_glDrawTexfvOES *)data;
 
-   orig_evgl_api_glDrawTexfvOES(thread_param->coords);
+   orig_evgl_api_glDrawTexfvOES(thread_data->coords);
 
 }
 
@@ -16716,20 +16720,20 @@ glDrawTexfvOES_evgl_api_thread_cmd(const GLfloat *coords)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glDrawTexfvOES thread_param_local;
-   EVGL_API_Thread_Command_glDrawTexfvOES *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glDrawTexfvOES thread_data_local;
+   EVGL_API_Thread_Command_glDrawTexfvOES *thread_data = &thread_data_local;
 
-   thread_param->coords = coords;
+   thread_data->coords = coords;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glDrawTexfvOES,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glAlphaFuncxOES(GLenum func, GLclampx ref);
+ * void
+ * glAlphaFuncxOES(GLenum func, GLclampx ref);
  */
 
 typedef struct
@@ -16744,11 +16748,11 @@ void (*orig_evgl_api_glAlphaFuncxOES)(GLenum func, GLclampx ref);
 static void
 _evgl_api_thread_glAlphaFuncxOES(void *data)
 {
-   EVGL_API_Thread_Command_glAlphaFuncxOES *thread_param =
+   EVGL_API_Thread_Command_glAlphaFuncxOES *thread_data =
       (EVGL_API_Thread_Command_glAlphaFuncxOES *)data;
 
-   orig_evgl_api_glAlphaFuncxOES(thread_param->func,
-                                 thread_param->ref);
+   orig_evgl_api_glAlphaFuncxOES(thread_data->func,
+                                 thread_data->ref);
 
 }
 
@@ -16763,21 +16767,21 @@ glAlphaFuncxOES_evgl_api_thread_cmd(GLenum func, GLclampx ref)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glAlphaFuncxOES thread_param_local;
-   EVGL_API_Thread_Command_glAlphaFuncxOES *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glAlphaFuncxOES thread_data_local;
+   EVGL_API_Thread_Command_glAlphaFuncxOES *thread_data = &thread_data_local;
 
-   thread_param->func = func;
-   thread_param->ref = ref;
+   thread_data->func = func;
+   thread_data->ref = ref;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glAlphaFuncxOES,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glClearColorxOES(GLclampx red, GLclampx green, GLclampx blue, GLclampx alpha);
+ * void
+ * glClearColorxOES(GLclampx red, GLclampx green, GLclampx blue, GLclampx alpha);
  */
 
 typedef struct
@@ -16794,13 +16798,13 @@ void (*orig_evgl_api_glClearColorxOES)(GLclampx red, GLclampx green, GLclampx bl
 static void
 _evgl_api_thread_glClearColorxOES(void *data)
 {
-   EVGL_API_Thread_Command_glClearColorxOES *thread_param =
+   EVGL_API_Thread_Command_glClearColorxOES *thread_data =
       (EVGL_API_Thread_Command_glClearColorxOES *)data;
 
-   orig_evgl_api_glClearColorxOES(thread_param->red,
-                                  thread_param->green,
-                                  thread_param->blue,
-                                  thread_param->alpha);
+   orig_evgl_api_glClearColorxOES(thread_data->red,
+                                  thread_data->green,
+                                  thread_data->blue,
+                                  thread_data->alpha);
 
 }
 
@@ -16815,23 +16819,23 @@ glClearColorxOES_evgl_api_thread_cmd(GLclampx red, GLclampx green, GLclampx blue
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glClearColorxOES thread_param_local;
-   EVGL_API_Thread_Command_glClearColorxOES *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glClearColorxOES thread_data_local;
+   EVGL_API_Thread_Command_glClearColorxOES *thread_data = &thread_data_local;
 
-   thread_param->red = red;
-   thread_param->green = green;
-   thread_param->blue = blue;
-   thread_param->alpha = alpha;
+   thread_data->red = red;
+   thread_data->green = green;
+   thread_data->blue = blue;
+   thread_data->alpha = alpha;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glClearColorxOES,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glClearDepthxOES(GLclampx depth);
+ * void
+ * glClearDepthxOES(GLclampx depth);
  */
 
 typedef struct
@@ -16845,10 +16849,10 @@ void (*orig_evgl_api_glClearDepthxOES)(GLclampx depth);
 static void
 _evgl_api_thread_glClearDepthxOES(void *data)
 {
-   EVGL_API_Thread_Command_glClearDepthxOES *thread_param =
+   EVGL_API_Thread_Command_glClearDepthxOES *thread_data =
       (EVGL_API_Thread_Command_glClearDepthxOES *)data;
 
-   orig_evgl_api_glClearDepthxOES(thread_param->depth);
+   orig_evgl_api_glClearDepthxOES(thread_data->depth);
 
 }
 
@@ -16863,20 +16867,20 @@ glClearDepthxOES_evgl_api_thread_cmd(GLclampx depth)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glClearDepthxOES thread_param_local;
-   EVGL_API_Thread_Command_glClearDepthxOES *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glClearDepthxOES thread_data_local;
+   EVGL_API_Thread_Command_glClearDepthxOES *thread_data = &thread_data_local;
 
-   thread_param->depth = depth;
+   thread_data->depth = depth;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glClearDepthxOES,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glClipPlanexOES(GLenum plane, const GLfixed *equation);
+ * void
+ * glClipPlanexOES(GLenum plane, const GLfixed *equation);
  */
 
 typedef struct
@@ -16891,11 +16895,11 @@ void (*orig_evgl_api_glClipPlanexOES)(GLenum plane, const GLfixed *equation);
 static void
 _evgl_api_thread_glClipPlanexOES(void *data)
 {
-   EVGL_API_Thread_Command_glClipPlanexOES *thread_param =
+   EVGL_API_Thread_Command_glClipPlanexOES *thread_data =
       (EVGL_API_Thread_Command_glClipPlanexOES *)data;
 
-   orig_evgl_api_glClipPlanexOES(thread_param->plane,
-                                 thread_param->equation);
+   orig_evgl_api_glClipPlanexOES(thread_data->plane,
+                                 thread_data->equation);
 
 }
 
@@ -16910,21 +16914,21 @@ glClipPlanexOES_evgl_api_thread_cmd(GLenum plane, const GLfixed *equation)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glClipPlanexOES thread_param_local;
-   EVGL_API_Thread_Command_glClipPlanexOES *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glClipPlanexOES thread_data_local;
+   EVGL_API_Thread_Command_glClipPlanexOES *thread_data = &thread_data_local;
 
-   thread_param->plane = plane;
-   thread_param->equation = equation;
+   thread_data->plane = plane;
+   thread_data->equation = equation;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glClipPlanexOES,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glColor4xOES(GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha);
+ * void
+ * glColor4xOES(GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha);
  */
 
 typedef struct
@@ -16941,13 +16945,13 @@ void (*orig_evgl_api_glColor4xOES)(GLfixed red, GLfixed green, GLfixed blue, GLf
 static void
 _evgl_api_thread_glColor4xOES(void *data)
 {
-   EVGL_API_Thread_Command_glColor4xOES *thread_param =
+   EVGL_API_Thread_Command_glColor4xOES *thread_data =
       (EVGL_API_Thread_Command_glColor4xOES *)data;
 
-   orig_evgl_api_glColor4xOES(thread_param->red,
-                              thread_param->green,
-                              thread_param->blue,
-                              thread_param->alpha);
+   orig_evgl_api_glColor4xOES(thread_data->red,
+                              thread_data->green,
+                              thread_data->blue,
+                              thread_data->alpha);
 
 }
 
@@ -16962,23 +16966,23 @@ glColor4xOES_evgl_api_thread_cmd(GLfixed red, GLfixed green, GLfixed blue, GLfix
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glColor4xOES thread_param_local;
-   EVGL_API_Thread_Command_glColor4xOES *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glColor4xOES thread_data_local;
+   EVGL_API_Thread_Command_glColor4xOES *thread_data = &thread_data_local;
 
-   thread_param->red = red;
-   thread_param->green = green;
-   thread_param->blue = blue;
-   thread_param->alpha = alpha;
+   thread_data->red = red;
+   thread_data->green = green;
+   thread_data->blue = blue;
+   thread_data->alpha = alpha;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glColor4xOES,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glDepthRangexOES(GLclampx zNear, GLclampx zFar);
+ * void
+ * glDepthRangexOES(GLclampx zNear, GLclampx zFar);
  */
 
 typedef struct
@@ -16993,11 +16997,11 @@ void (*orig_evgl_api_glDepthRangexOES)(GLclampx zNear, GLclampx zFar);
 static void
 _evgl_api_thread_glDepthRangexOES(void *data)
 {
-   EVGL_API_Thread_Command_glDepthRangexOES *thread_param =
+   EVGL_API_Thread_Command_glDepthRangexOES *thread_data =
       (EVGL_API_Thread_Command_glDepthRangexOES *)data;
 
-   orig_evgl_api_glDepthRangexOES(thread_param->zNear,
-                                  thread_param->zFar);
+   orig_evgl_api_glDepthRangexOES(thread_data->zNear,
+                                  thread_data->zFar);
 
 }
 
@@ -17012,21 +17016,21 @@ glDepthRangexOES_evgl_api_thread_cmd(GLclampx zNear, GLclampx zFar)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glDepthRangexOES thread_param_local;
-   EVGL_API_Thread_Command_glDepthRangexOES *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glDepthRangexOES thread_data_local;
+   EVGL_API_Thread_Command_glDepthRangexOES *thread_data = &thread_data_local;
 
-   thread_param->zNear = zNear;
-   thread_param->zFar = zFar;
+   thread_data->zNear = zNear;
+   thread_data->zFar = zFar;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glDepthRangexOES,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glFogxOES(GLenum pname, GLfixed param);
+ * void
+ * glFogxOES(GLenum pname, GLfixed param);
  */
 
 typedef struct
@@ -17041,11 +17045,11 @@ void (*orig_evgl_api_glFogxOES)(GLenum pname, GLfixed param);
 static void
 _evgl_api_thread_glFogxOES(void *data)
 {
-   EVGL_API_Thread_Command_glFogxOES *thread_param =
+   EVGL_API_Thread_Command_glFogxOES *thread_data =
       (EVGL_API_Thread_Command_glFogxOES *)data;
 
-   orig_evgl_api_glFogxOES(thread_param->pname,
-                           thread_param->param);
+   orig_evgl_api_glFogxOES(thread_data->pname,
+                           thread_data->param);
 
 }
 
@@ -17060,21 +17064,21 @@ glFogxOES_evgl_api_thread_cmd(GLenum pname, GLfixed param)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glFogxOES thread_param_local;
-   EVGL_API_Thread_Command_glFogxOES *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glFogxOES thread_data_local;
+   EVGL_API_Thread_Command_glFogxOES *thread_data = &thread_data_local;
 
-   thread_param->pname = pname;
-   thread_param->param = param;
+   thread_data->pname = pname;
+   thread_data->param = param;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glFogxOES,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glFogxvOES(GLenum pname, const GLfixed *params);
+ * void
+ * glFogxvOES(GLenum pname, const GLfixed *params);
  */
 
 typedef struct
@@ -17089,11 +17093,11 @@ void (*orig_evgl_api_glFogxvOES)(GLenum pname, const GLfixed *params);
 static void
 _evgl_api_thread_glFogxvOES(void *data)
 {
-   EVGL_API_Thread_Command_glFogxvOES *thread_param =
+   EVGL_API_Thread_Command_glFogxvOES *thread_data =
       (EVGL_API_Thread_Command_glFogxvOES *)data;
 
-   orig_evgl_api_glFogxvOES(thread_param->pname,
-                            thread_param->params);
+   orig_evgl_api_glFogxvOES(thread_data->pname,
+                            thread_data->params);
 
 }
 
@@ -17108,21 +17112,21 @@ glFogxvOES_evgl_api_thread_cmd(GLenum pname, const GLfixed *params)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glFogxvOES thread_param_local;
-   EVGL_API_Thread_Command_glFogxvOES *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glFogxvOES thread_data_local;
+   EVGL_API_Thread_Command_glFogxvOES *thread_data = &thread_data_local;
 
-   thread_param->pname = pname;
-   thread_param->params = params;
+   thread_data->pname = pname;
+   thread_data->params = params;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glFogxvOES,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glFrustumxOES(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar);
+ * void
+ * glFrustumxOES(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar);
  */
 
 typedef struct
@@ -17141,15 +17145,15 @@ void (*orig_evgl_api_glFrustumxOES)(GLfixed left, GLfixed right, GLfixed bottom,
 static void
 _evgl_api_thread_glFrustumxOES(void *data)
 {
-   EVGL_API_Thread_Command_glFrustumxOES *thread_param =
+   EVGL_API_Thread_Command_glFrustumxOES *thread_data =
       (EVGL_API_Thread_Command_glFrustumxOES *)data;
 
-   orig_evgl_api_glFrustumxOES(thread_param->left,
-                               thread_param->right,
-                               thread_param->bottom,
-                               thread_param->top,
-                               thread_param->zNear,
-                               thread_param->zFar);
+   orig_evgl_api_glFrustumxOES(thread_data->left,
+                               thread_data->right,
+                               thread_data->bottom,
+                               thread_data->top,
+                               thread_data->zNear,
+                               thread_data->zFar);
 
 }
 
@@ -17164,25 +17168,25 @@ glFrustumxOES_evgl_api_thread_cmd(GLfixed left, GLfixed right, GLfixed bottom, G
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glFrustumxOES thread_param_local;
-   EVGL_API_Thread_Command_glFrustumxOES *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glFrustumxOES thread_data_local;
+   EVGL_API_Thread_Command_glFrustumxOES *thread_data = &thread_data_local;
 
-   thread_param->left = left;
-   thread_param->right = right;
-   thread_param->bottom = bottom;
-   thread_param->top = top;
-   thread_param->zNear = zNear;
-   thread_param->zFar = zFar;
+   thread_data->left = left;
+   thread_data->right = right;
+   thread_data->bottom = bottom;
+   thread_data->top = top;
+   thread_data->zNear = zNear;
+   thread_data->zFar = zFar;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glFrustumxOES,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGetClipPlanexOES(GLenum pname, GLfixed eqn[4]);
+ * void
+ * glGetClipPlanexOES(GLenum pname, GLfixed eqn[4]);
  */
 
 typedef struct
@@ -17197,11 +17201,11 @@ void (*orig_evgl_api_glGetClipPlanexOES)(GLenum pname, GLfixed eqn[4]);
 static void
 _evgl_api_thread_glGetClipPlanexOES(void *data)
 {
-   EVGL_API_Thread_Command_glGetClipPlanexOES *thread_param =
+   EVGL_API_Thread_Command_glGetClipPlanexOES *thread_data =
       (EVGL_API_Thread_Command_glGetClipPlanexOES *)data;
 
-   orig_evgl_api_glGetClipPlanexOES(thread_param->pname,
-                                    thread_param->eqn);
+   orig_evgl_api_glGetClipPlanexOES(thread_data->pname,
+                                    thread_data->eqn);
 
 }
 
@@ -17216,21 +17220,21 @@ glGetClipPlanexOES_evgl_api_thread_cmd(GLenum pname, GLfixed eqn[4])
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGetClipPlanexOES thread_param_local;
-   EVGL_API_Thread_Command_glGetClipPlanexOES *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGetClipPlanexOES thread_data_local;
+   EVGL_API_Thread_Command_glGetClipPlanexOES *thread_data = &thread_data_local;
 
-   thread_param->pname = pname;
-   memcpy(thread_param->eqn, &eqn, sizeof(eqn));
+   thread_data->pname = pname;
+   memcpy(thread_data->eqn, &eqn, sizeof(GLfixed) * 4);
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGetClipPlanexOES,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGetFixedvOES(GLenum pname, GLfixed *params);
+ * void
+ * glGetFixedvOES(GLenum pname, GLfixed *params);
  */
 
 typedef struct
@@ -17245,11 +17249,11 @@ void (*orig_evgl_api_glGetFixedvOES)(GLenum pname, GLfixed *params);
 static void
 _evgl_api_thread_glGetFixedvOES(void *data)
 {
-   EVGL_API_Thread_Command_glGetFixedvOES *thread_param =
+   EVGL_API_Thread_Command_glGetFixedvOES *thread_data =
       (EVGL_API_Thread_Command_glGetFixedvOES *)data;
 
-   orig_evgl_api_glGetFixedvOES(thread_param->pname,
-                                thread_param->params);
+   orig_evgl_api_glGetFixedvOES(thread_data->pname,
+                                thread_data->params);
 
 }
 
@@ -17264,21 +17268,21 @@ glGetFixedvOES_evgl_api_thread_cmd(GLenum pname, GLfixed *params)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGetFixedvOES thread_param_local;
-   EVGL_API_Thread_Command_glGetFixedvOES *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGetFixedvOES thread_data_local;
+   EVGL_API_Thread_Command_glGetFixedvOES *thread_data = &thread_data_local;
 
-   thread_param->pname = pname;
-   thread_param->params = params;
+   thread_data->pname = pname;
+   thread_data->params = params;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGetFixedvOES,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGetLightxvOES(GLenum light, GLenum pname, GLfixed *params);
+ * void
+ * glGetLightxvOES(GLenum light, GLenum pname, GLfixed *params);
  */
 
 typedef struct
@@ -17294,12 +17298,12 @@ void (*orig_evgl_api_glGetLightxvOES)(GLenum light, GLenum pname, GLfixed *param
 static void
 _evgl_api_thread_glGetLightxvOES(void *data)
 {
-   EVGL_API_Thread_Command_glGetLightxvOES *thread_param =
+   EVGL_API_Thread_Command_glGetLightxvOES *thread_data =
       (EVGL_API_Thread_Command_glGetLightxvOES *)data;
 
-   orig_evgl_api_glGetLightxvOES(thread_param->light,
-                                 thread_param->pname,
-                                 thread_param->params);
+   orig_evgl_api_glGetLightxvOES(thread_data->light,
+                                 thread_data->pname,
+                                 thread_data->params);
 
 }
 
@@ -17314,22 +17318,22 @@ glGetLightxvOES_evgl_api_thread_cmd(GLenum light, GLenum pname, GLfixed *params)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGetLightxvOES thread_param_local;
-   EVGL_API_Thread_Command_glGetLightxvOES *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGetLightxvOES thread_data_local;
+   EVGL_API_Thread_Command_glGetLightxvOES *thread_data = &thread_data_local;
 
-   thread_param->light = light;
-   thread_param->pname = pname;
-   thread_param->params = params;
+   thread_data->light = light;
+   thread_data->pname = pname;
+   thread_data->params = params;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGetLightxvOES,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGetMaterialxvOES(GLenum face, GLenum pname, GLfixed *params);
+ * void
+ * glGetMaterialxvOES(GLenum face, GLenum pname, GLfixed *params);
  */
 
 typedef struct
@@ -17345,12 +17349,12 @@ void (*orig_evgl_api_glGetMaterialxvOES)(GLenum face, GLenum pname, GLfixed *par
 static void
 _evgl_api_thread_glGetMaterialxvOES(void *data)
 {
-   EVGL_API_Thread_Command_glGetMaterialxvOES *thread_param =
+   EVGL_API_Thread_Command_glGetMaterialxvOES *thread_data =
       (EVGL_API_Thread_Command_glGetMaterialxvOES *)data;
 
-   orig_evgl_api_glGetMaterialxvOES(thread_param->face,
-                                    thread_param->pname,
-                                    thread_param->params);
+   orig_evgl_api_glGetMaterialxvOES(thread_data->face,
+                                    thread_data->pname,
+                                    thread_data->params);
 
 }
 
@@ -17365,22 +17369,22 @@ glGetMaterialxvOES_evgl_api_thread_cmd(GLenum face, GLenum pname, GLfixed *param
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGetMaterialxvOES thread_param_local;
-   EVGL_API_Thread_Command_glGetMaterialxvOES *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGetMaterialxvOES thread_data_local;
+   EVGL_API_Thread_Command_glGetMaterialxvOES *thread_data = &thread_data_local;
 
-   thread_param->face = face;
-   thread_param->pname = pname;
-   thread_param->params = params;
+   thread_data->face = face;
+   thread_data->pname = pname;
+   thread_data->params = params;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGetMaterialxvOES,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGetTexEnvxvOES(GLenum env, GLenum pname, GLfixed *params);
+ * void
+ * glGetTexEnvxvOES(GLenum env, GLenum pname, GLfixed *params);
  */
 
 typedef struct
@@ -17396,12 +17400,12 @@ void (*orig_evgl_api_glGetTexEnvxvOES)(GLenum env, GLenum pname, GLfixed *params
 static void
 _evgl_api_thread_glGetTexEnvxvOES(void *data)
 {
-   EVGL_API_Thread_Command_glGetTexEnvxvOES *thread_param =
+   EVGL_API_Thread_Command_glGetTexEnvxvOES *thread_data =
       (EVGL_API_Thread_Command_glGetTexEnvxvOES *)data;
 
-   orig_evgl_api_glGetTexEnvxvOES(thread_param->env,
-                                  thread_param->pname,
-                                  thread_param->params);
+   orig_evgl_api_glGetTexEnvxvOES(thread_data->env,
+                                  thread_data->pname,
+                                  thread_data->params);
 
 }
 
@@ -17416,22 +17420,22 @@ glGetTexEnvxvOES_evgl_api_thread_cmd(GLenum env, GLenum pname, GLfixed *params)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGetTexEnvxvOES thread_param_local;
-   EVGL_API_Thread_Command_glGetTexEnvxvOES *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGetTexEnvxvOES thread_data_local;
+   EVGL_API_Thread_Command_glGetTexEnvxvOES *thread_data = &thread_data_local;
 
-   thread_param->env = env;
-   thread_param->pname = pname;
-   thread_param->params = params;
+   thread_data->env = env;
+   thread_data->pname = pname;
+   thread_data->params = params;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGetTexEnvxvOES,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGetTexParameterxvOES(GLenum target, GLenum pname, GLfixed *params);
+ * void
+ * glGetTexParameterxvOES(GLenum target, GLenum pname, GLfixed *params);
  */
 
 typedef struct
@@ -17447,12 +17451,12 @@ void (*orig_evgl_api_glGetTexParameterxvOES)(GLenum target, GLenum pname, GLfixe
 static void
 _evgl_api_thread_glGetTexParameterxvOES(void *data)
 {
-   EVGL_API_Thread_Command_glGetTexParameterxvOES *thread_param =
+   EVGL_API_Thread_Command_glGetTexParameterxvOES *thread_data =
       (EVGL_API_Thread_Command_glGetTexParameterxvOES *)data;
 
-   orig_evgl_api_glGetTexParameterxvOES(thread_param->target,
-                                        thread_param->pname,
-                                        thread_param->params);
+   orig_evgl_api_glGetTexParameterxvOES(thread_data->target,
+                                        thread_data->pname,
+                                        thread_data->params);
 
 }
 
@@ -17467,22 +17471,22 @@ glGetTexParameterxvOES_evgl_api_thread_cmd(GLenum target, GLenum pname, GLfixed
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGetTexParameterxvOES thread_param_local;
-   EVGL_API_Thread_Command_glGetTexParameterxvOES *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGetTexParameterxvOES thread_data_local;
+   EVGL_API_Thread_Command_glGetTexParameterxvOES *thread_data = &thread_data_local;
 
-   thread_param->target = target;
-   thread_param->pname = pname;
-   thread_param->params = params;
+   thread_data->target = target;
+   thread_data->pname = pname;
+   thread_data->params = params;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGetTexParameterxvOES,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glLightModelxOES(GLenum pname, GLfixed param);
+ * void
+ * glLightModelxOES(GLenum pname, GLfixed param);
  */
 
 typedef struct
@@ -17497,11 +17501,11 @@ void (*orig_evgl_api_glLightModelxOES)(GLenum pname, GLfixed param);
 static void
 _evgl_api_thread_glLightModelxOES(void *data)
 {
-   EVGL_API_Thread_Command_glLightModelxOES *thread_param =
+   EVGL_API_Thread_Command_glLightModelxOES *thread_data =
       (EVGL_API_Thread_Command_glLightModelxOES *)data;
 
-   orig_evgl_api_glLightModelxOES(thread_param->pname,
-                                  thread_param->param);
+   orig_evgl_api_glLightModelxOES(thread_data->pname,
+                                  thread_data->param);
 
 }
 
@@ -17516,21 +17520,21 @@ glLightModelxOES_evgl_api_thread_cmd(GLenum pname, GLfixed param)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glLightModelxOES thread_param_local;
-   EVGL_API_Thread_Command_glLightModelxOES *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glLightModelxOES thread_data_local;
+   EVGL_API_Thread_Command_glLightModelxOES *thread_data = &thread_data_local;
 
-   thread_param->pname = pname;
-   thread_param->param = param;
+   thread_data->pname = pname;
+   thread_data->param = param;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glLightModelxOES,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glLightModelxvOES(GLenum pname, const GLfixed *params);
+ * void
+ * glLightModelxvOES(GLenum pname, const GLfixed *params);
  */
 
 typedef struct
@@ -17545,11 +17549,11 @@ void (*orig_evgl_api_glLightModelxvOES)(GLenum pname, const GLfixed *params);
 static void
 _evgl_api_thread_glLightModelxvOES(void *data)
 {
-   EVGL_API_Thread_Command_glLightModelxvOES *thread_param =
+   EVGL_API_Thread_Command_glLightModelxvOES *thread_data =
       (EVGL_API_Thread_Command_glLightModelxvOES *)data;
 
-   orig_evgl_api_glLightModelxvOES(thread_param->pname,
-                                   thread_param->params);
+   orig_evgl_api_glLightModelxvOES(thread_data->pname,
+                                   thread_data->params);
 
 }
 
@@ -17564,21 +17568,21 @@ glLightModelxvOES_evgl_api_thread_cmd(GLenum pname, const GLfixed *params)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glLightModelxvOES thread_param_local;
-   EVGL_API_Thread_Command_glLightModelxvOES *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glLightModelxvOES thread_data_local;
+   EVGL_API_Thread_Command_glLightModelxvOES *thread_data = &thread_data_local;
 
-   thread_param->pname = pname;
-   thread_param->params = params;
+   thread_data->pname = pname;
+   thread_data->params = params;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glLightModelxvOES,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glLightxOES(GLenum light, GLenum pname, GLfixed param);
+ * void
+ * glLightxOES(GLenum light, GLenum pname, GLfixed param);
  */
 
 typedef struct
@@ -17594,12 +17598,12 @@ void (*orig_evgl_api_glLightxOES)(GLenum light, GLenum pname, GLfixed param);
 static void
 _evgl_api_thread_glLightxOES(void *data)
 {
-   EVGL_API_Thread_Command_glLightxOES *thread_param =
+   EVGL_API_Thread_Command_glLightxOES *thread_data =
       (EVGL_API_Thread_Command_glLightxOES *)data;
 
-   orig_evgl_api_glLightxOES(thread_param->light,
-                             thread_param->pname,
-                             thread_param->param);
+   orig_evgl_api_glLightxOES(thread_data->light,
+                             thread_data->pname,
+                             thread_data->param);
 
 }
 
@@ -17614,22 +17618,22 @@ glLightxOES_evgl_api_thread_cmd(GLenum light, GLenum pname, GLfixed param)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glLightxOES thread_param_local;
-   EVGL_API_Thread_Command_glLightxOES *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glLightxOES thread_data_local;
+   EVGL_API_Thread_Command_glLightxOES *thread_data = &thread_data_local;
 
-   thread_param->light = light;
-   thread_param->pname = pname;
-   thread_param->param = param;
+   thread_data->light = light;
+   thread_data->pname = pname;
+   thread_data->param = param;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glLightxOES,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glLightxvOES(GLenum light, GLenum pname, const GLfixed *params);
+ * void
+ * glLightxvOES(GLenum light, GLenum pname, const GLfixed *params);
  */
 
 typedef struct
@@ -17645,12 +17649,12 @@ void (*orig_evgl_api_glLightxvOES)(GLenum light, GLenum pname, const GLfixed *pa
 static void
 _evgl_api_thread_glLightxvOES(void *data)
 {
-   EVGL_API_Thread_Command_glLightxvOES *thread_param =
+   EVGL_API_Thread_Command_glLightxvOES *thread_data =
       (EVGL_API_Thread_Command_glLightxvOES *)data;
 
-   orig_evgl_api_glLightxvOES(thread_param->light,
-                              thread_param->pname,
-                              thread_param->params);
+   orig_evgl_api_glLightxvOES(thread_data->light,
+                              thread_data->pname,
+                              thread_data->params);
 
 }
 
@@ -17665,22 +17669,22 @@ glLightxvOES_evgl_api_thread_cmd(GLenum light, GLenum pname, const GLfixed *para
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glLightxvOES thread_param_local;
-   EVGL_API_Thread_Command_glLightxvOES *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glLightxvOES thread_data_local;
+   EVGL_API_Thread_Command_glLightxvOES *thread_data = &thread_data_local;
 
-   thread_param->light = light;
-   thread_param->pname = pname;
-   thread_param->params = params;
+   thread_data->light = light;
+   thread_data->pname = pname;
+   thread_data->params = params;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glLightxvOES,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glLineWidthxOES(GLfixed width);
+ * void
+ * glLineWidthxOES(GLfixed width);
  */
 
 typedef struct
@@ -17694,10 +17698,10 @@ void (*orig_evgl_api_glLineWidthxOES)(GLfixed width);
 static void
 _evgl_api_thread_glLineWidthxOES(void *data)
 {
-   EVGL_API_Thread_Command_glLineWidthxOES *thread_param =
+   EVGL_API_Thread_Command_glLineWidthxOES *thread_data =
       (EVGL_API_Thread_Command_glLineWidthxOES *)data;
 
-   orig_evgl_api_glLineWidthxOES(thread_param->width);
+   orig_evgl_api_glLineWidthxOES(thread_data->width);
 
 }
 
@@ -17712,20 +17716,20 @@ glLineWidthxOES_evgl_api_thread_cmd(GLfixed width)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glLineWidthxOES thread_param_local;
-   EVGL_API_Thread_Command_glLineWidthxOES *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glLineWidthxOES thread_data_local;
+   EVGL_API_Thread_Command_glLineWidthxOES *thread_data = &thread_data_local;
 
-   thread_param->width = width;
+   thread_data->width = width;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glLineWidthxOES,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glLoadMatrixxOES(const GLfixed *m);
+ * void
+ * glLoadMatrixxOES(const GLfixed *m);
  */
 
 typedef struct
@@ -17739,10 +17743,10 @@ void (*orig_evgl_api_glLoadMatrixxOES)(const GLfixed *m);
 static void
 _evgl_api_thread_glLoadMatrixxOES(void *data)
 {
-   EVGL_API_Thread_Command_glLoadMatrixxOES *thread_param =
+   EVGL_API_Thread_Command_glLoadMatrixxOES *thread_data =
       (EVGL_API_Thread_Command_glLoadMatrixxOES *)data;
 
-   orig_evgl_api_glLoadMatrixxOES(thread_param->m);
+   orig_evgl_api_glLoadMatrixxOES(thread_data->m);
 
 }
 
@@ -17757,20 +17761,20 @@ glLoadMatrixxOES_evgl_api_thread_cmd(const GLfixed *m)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glLoadMatrixxOES thread_param_local;
-   EVGL_API_Thread_Command_glLoadMatrixxOES *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glLoadMatrixxOES thread_data_local;
+   EVGL_API_Thread_Command_glLoadMatrixxOES *thread_data = &thread_data_local;
 
-   thread_param->m = m;
+   thread_data->m = m;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glLoadMatrixxOES,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glMaterialxOES(GLenum face, GLenum pname, GLfixed param);
+ * void
+ * glMaterialxOES(GLenum face, GLenum pname, GLfixed param);
  */
 
 typedef struct
@@ -17786,12 +17790,12 @@ void (*orig_evgl_api_glMaterialxOES)(GLenum face, GLenum pname, GLfixed param);
 static void
 _evgl_api_thread_glMaterialxOES(void *data)
 {
-   EVGL_API_Thread_Command_glMaterialxOES *thread_param =
+   EVGL_API_Thread_Command_glMaterialxOES *thread_data =
       (EVGL_API_Thread_Command_glMaterialxOES *)data;
 
-   orig_evgl_api_glMaterialxOES(thread_param->face,
-                                thread_param->pname,
-                                thread_param->param);
+   orig_evgl_api_glMaterialxOES(thread_data->face,
+                                thread_data->pname,
+                                thread_data->param);
 
 }
 
@@ -17806,22 +17810,22 @@ glMaterialxOES_evgl_api_thread_cmd(GLenum face, GLenum pname, GLfixed param)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glMaterialxOES thread_param_local;
-   EVGL_API_Thread_Command_glMaterialxOES *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glMaterialxOES thread_data_local;
+   EVGL_API_Thread_Command_glMaterialxOES *thread_data = &thread_data_local;
 
-   thread_param->face = face;
-   thread_param->pname = pname;
-   thread_param->param = param;
+   thread_data->face = face;
+   thread_data->pname = pname;
+   thread_data->param = param;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glMaterialxOES,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glMaterialxvOES(GLenum face, GLenum pname, const GLfixed *params);
+ * void
+ * glMaterialxvOES(GLenum face, GLenum pname, const GLfixed *params);
  */
 
 typedef struct
@@ -17837,12 +17841,12 @@ void (*orig_evgl_api_glMaterialxvOES)(GLenum face, GLenum pname, const GLfixed *
 static void
 _evgl_api_thread_glMaterialxvOES(void *data)
 {
-   EVGL_API_Thread_Command_glMaterialxvOES *thread_param =
+   EVGL_API_Thread_Command_glMaterialxvOES *thread_data =
       (EVGL_API_Thread_Command_glMaterialxvOES *)data;
 
-   orig_evgl_api_glMaterialxvOES(thread_param->face,
-                                 thread_param->pname,
-                                 thread_param->params);
+   orig_evgl_api_glMaterialxvOES(thread_data->face,
+                                 thread_data->pname,
+                                 thread_data->params);
 
 }
 
@@ -17857,22 +17861,22 @@ glMaterialxvOES_evgl_api_thread_cmd(GLenum face, GLenum pname, const GLfixed *pa
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glMaterialxvOES thread_param_local;
-   EVGL_API_Thread_Command_glMaterialxvOES *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glMaterialxvOES thread_data_local;
+   EVGL_API_Thread_Command_glMaterialxvOES *thread_data = &thread_data_local;
 
-   thread_param->face = face;
-   thread_param->pname = pname;
-   thread_param->params = params;
+   thread_data->face = face;
+   thread_data->pname = pname;
+   thread_data->params = params;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glMaterialxvOES,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glMultMatrixxOES(const GLfixed *m);
+ * void
+ * glMultMatrixxOES(const GLfixed *m);
  */
 
 typedef struct
@@ -17886,10 +17890,10 @@ void (*orig_evgl_api_glMultMatrixxOES)(const GLfixed *m);
 static void
 _evgl_api_thread_glMultMatrixxOES(void *data)
 {
-   EVGL_API_Thread_Command_glMultMatrixxOES *thread_param =
+   EVGL_API_Thread_Command_glMultMatrixxOES *thread_data =
       (EVGL_API_Thread_Command_glMultMatrixxOES *)data;
 
-   orig_evgl_api_glMultMatrixxOES(thread_param->m);
+   orig_evgl_api_glMultMatrixxOES(thread_data->m);
 
 }
 
@@ -17904,20 +17908,20 @@ glMultMatrixxOES_evgl_api_thread_cmd(const GLfixed *m)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glMultMatrixxOES thread_param_local;
-   EVGL_API_Thread_Command_glMultMatrixxOES *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glMultMatrixxOES thread_data_local;
+   EVGL_API_Thread_Command_glMultMatrixxOES *thread_data = &thread_data_local;
 
-   thread_param->m = m;
+   thread_data->m = m;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glMultMatrixxOES,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glMultiTexCoord4xOES(GLenum target, GLfixed s, GLfixed t, GLfixed r, GLfixed q);
+ * void
+ * glMultiTexCoord4xOES(GLenum target, GLfixed s, GLfixed t, GLfixed r, GLfixed q);
  */
 
 typedef struct
@@ -17935,14 +17939,14 @@ void (*orig_evgl_api_glMultiTexCoord4xOES)(GLenum target, GLfixed s, GLfixed t,
 static void
 _evgl_api_thread_glMultiTexCoord4xOES(void *data)
 {
-   EVGL_API_Thread_Command_glMultiTexCoord4xOES *thread_param =
+   EVGL_API_Thread_Command_glMultiTexCoord4xOES *thread_data =
       (EVGL_API_Thread_Command_glMultiTexCoord4xOES *)data;
 
-   orig_evgl_api_glMultiTexCoord4xOES(thread_param->target,
-                                      thread_param->s,
-                                      thread_param->t,
-                                      thread_param->r,
-                                      thread_param->q);
+   orig_evgl_api_glMultiTexCoord4xOES(thread_data->target,
+                                      thread_data->s,
+                                      thread_data->t,
+                                      thread_data->r,
+                                      thread_data->q);
 
 }
 
@@ -17957,24 +17961,24 @@ glMultiTexCoord4xOES_evgl_api_thread_cmd(GLenum target, GLfixed s, GLfixed t, GL
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glMultiTexCoord4xOES thread_param_local;
-   EVGL_API_Thread_Command_glMultiTexCoord4xOES *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glMultiTexCoord4xOES thread_data_local;
+   EVGL_API_Thread_Command_glMultiTexCoord4xOES *thread_data = &thread_data_local;
 
-   thread_param->target = target;
-   thread_param->s = s;
-   thread_param->t = t;
-   thread_param->r = r;
-   thread_param->q = q;
+   thread_data->target = target;
+   thread_data->s = s;
+   thread_data->t = t;
+   thread_data->r = r;
+   thread_data->q = q;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glMultiTexCoord4xOES,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glNormal3xOES(GLfixed nx, GLfixed ny, GLfixed nz);
+ * void
+ * glNormal3xOES(GLfixed nx, GLfixed ny, GLfixed nz);
  */
 
 typedef struct
@@ -17990,12 +17994,12 @@ void (*orig_evgl_api_glNormal3xOES)(GLfixed nx, GLfixed ny, GLfixed nz);
 static void
 _evgl_api_thread_glNormal3xOES(void *data)
 {
-   EVGL_API_Thread_Command_glNormal3xOES *thread_param =
+   EVGL_API_Thread_Command_glNormal3xOES *thread_data =
       (EVGL_API_Thread_Command_glNormal3xOES *)data;
 
-   orig_evgl_api_glNormal3xOES(thread_param->nx,
-                               thread_param->ny,
-                               thread_param->nz);
+   orig_evgl_api_glNormal3xOES(thread_data->nx,
+                               thread_data->ny,
+                               thread_data->nz);
 
 }
 
@@ -18010,22 +18014,22 @@ glNormal3xOES_evgl_api_thread_cmd(GLfixed nx, GLfixed ny, GLfixed nz)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glNormal3xOES thread_param_local;
-   EVGL_API_Thread_Command_glNormal3xOES *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glNormal3xOES thread_data_local;
+   EVGL_API_Thread_Command_glNormal3xOES *thread_data = &thread_data_local;
 
-   thread_param->nx = nx;
-   thread_param->ny = ny;
-   thread_param->nz = nz;
+   thread_data->nx = nx;
+   thread_data->ny = ny;
+   thread_data->nz = nz;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glNormal3xOES,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glOrthoxOES(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar);
+ * void
+ * glOrthoxOES(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar);
  */
 
 typedef struct
@@ -18044,15 +18048,15 @@ void (*orig_evgl_api_glOrthoxOES)(GLfixed left, GLfixed right, GLfixed bottom, G
 static void
 _evgl_api_thread_glOrthoxOES(void *data)
 {
-   EVGL_API_Thread_Command_glOrthoxOES *thread_param =
+   EVGL_API_Thread_Command_glOrthoxOES *thread_data =
       (EVGL_API_Thread_Command_glOrthoxOES *)data;
 
-   orig_evgl_api_glOrthoxOES(thread_param->left,
-                             thread_param->right,
-                             thread_param->bottom,
-                             thread_param->top,
-                             thread_param->zNear,
-                             thread_param->zFar);
+   orig_evgl_api_glOrthoxOES(thread_data->left,
+                             thread_data->right,
+                             thread_data->bottom,
+                             thread_data->top,
+                             thread_data->zNear,
+                             thread_data->zFar);
 
 }
 
@@ -18067,25 +18071,25 @@ glOrthoxOES_evgl_api_thread_cmd(GLfixed left, GLfixed right, GLfixed bottom, GLf
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glOrthoxOES thread_param_local;
-   EVGL_API_Thread_Command_glOrthoxOES *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glOrthoxOES thread_data_local;
+   EVGL_API_Thread_Command_glOrthoxOES *thread_data = &thread_data_local;
 
-   thread_param->left = left;
-   thread_param->right = right;
-   thread_param->bottom = bottom;
-   thread_param->top = top;
-   thread_param->zNear = zNear;
-   thread_param->zFar = zFar;
+   thread_data->left = left;
+   thread_data->right = right;
+   thread_data->bottom = bottom;
+   thread_data->top = top;
+   thread_data->zNear = zNear;
+   thread_data->zFar = zFar;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glOrthoxOES,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glPointParameterxOES(GLenum pname, GLfixed param);
+ * void
+ * glPointParameterxOES(GLenum pname, GLfixed param);
  */
 
 typedef struct
@@ -18100,11 +18104,11 @@ void (*orig_evgl_api_glPointParameterxOES)(GLenum pname, GLfixed param);
 static void
 _evgl_api_thread_glPointParameterxOES(void *data)
 {
-   EVGL_API_Thread_Command_glPointParameterxOES *thread_param =
+   EVGL_API_Thread_Command_glPointParameterxOES *thread_data =
       (EVGL_API_Thread_Command_glPointParameterxOES *)data;
 
-   orig_evgl_api_glPointParameterxOES(thread_param->pname,
-                                      thread_param->param);
+   orig_evgl_api_glPointParameterxOES(thread_data->pname,
+                                      thread_data->param);
 
 }
 
@@ -18119,21 +18123,21 @@ glPointParameterxOES_evgl_api_thread_cmd(GLenum pname, GLfixed param)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glPointParameterxOES thread_param_local;
-   EVGL_API_Thread_Command_glPointParameterxOES *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glPointParameterxOES thread_data_local;
+   EVGL_API_Thread_Command_glPointParameterxOES *thread_data = &thread_data_local;
 
-   thread_param->pname = pname;
-   thread_param->param = param;
+   thread_data->pname = pname;
+   thread_data->param = param;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glPointParameterxOES,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glPointParameterxvOES(GLenum pname, const GLfixed *params);
+ * void
+ * glPointParameterxvOES(GLenum pname, const GLfixed *params);
  */
 
 typedef struct
@@ -18148,11 +18152,11 @@ void (*orig_evgl_api_glPointParameterxvOES)(GLenum pname, const GLfixed *params)
 static void
 _evgl_api_thread_glPointParameterxvOES(void *data)
 {
-   EVGL_API_Thread_Command_glPointParameterxvOES *thread_param =
+   EVGL_API_Thread_Command_glPointParameterxvOES *thread_data =
       (EVGL_API_Thread_Command_glPointParameterxvOES *)data;
 
-   orig_evgl_api_glPointParameterxvOES(thread_param->pname,
-                                       thread_param->params);
+   orig_evgl_api_glPointParameterxvOES(thread_data->pname,
+                                       thread_data->params);
 
 }
 
@@ -18167,21 +18171,21 @@ glPointParameterxvOES_evgl_api_thread_cmd(GLenum pname, const GLfixed *params)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glPointParameterxvOES thread_param_local;
-   EVGL_API_Thread_Command_glPointParameterxvOES *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glPointParameterxvOES thread_data_local;
+   EVGL_API_Thread_Command_glPointParameterxvOES *thread_data = &thread_data_local;
 
-   thread_param->pname = pname;
-   thread_param->params = params;
+   thread_data->pname = pname;
+   thread_data->params = params;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glPointParameterxvOES,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glPointSizexOES(GLfixed size);
+ * void
+ * glPointSizexOES(GLfixed size);
  */
 
 typedef struct
@@ -18195,10 +18199,10 @@ void (*orig_evgl_api_glPointSizexOES)(GLfixed size);
 static void
 _evgl_api_thread_glPointSizexOES(void *data)
 {
-   EVGL_API_Thread_Command_glPointSizexOES *thread_param =
+   EVGL_API_Thread_Command_glPointSizexOES *thread_data =
       (EVGL_API_Thread_Command_glPointSizexOES *)data;
 
-   orig_evgl_api_glPointSizexOES(thread_param->size);
+   orig_evgl_api_glPointSizexOES(thread_data->size);
 
 }
 
@@ -18213,20 +18217,20 @@ glPointSizexOES_evgl_api_thread_cmd(GLfixed size)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glPointSizexOES thread_param_local;
-   EVGL_API_Thread_Command_glPointSizexOES *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glPointSizexOES thread_data_local;
+   EVGL_API_Thread_Command_glPointSizexOES *thread_data = &thread_data_local;
 
-   thread_param->size = size;
+   thread_data->size = size;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glPointSizexOES,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glPolygonOffsetxOES(GLfixed factor, GLfixed units);
+ * void
+ * glPolygonOffsetxOES(GLfixed factor, GLfixed units);
  */
 
 typedef struct
@@ -18241,11 +18245,11 @@ void (*orig_evgl_api_glPolygonOffsetxOES)(GLfixed factor, GLfixed units);
 static void
 _evgl_api_thread_glPolygonOffsetxOES(void *data)
 {
-   EVGL_API_Thread_Command_glPolygonOffsetxOES *thread_param =
+   EVGL_API_Thread_Command_glPolygonOffsetxOES *thread_data =
       (EVGL_API_Thread_Command_glPolygonOffsetxOES *)data;
 
-   orig_evgl_api_glPolygonOffsetxOES(thread_param->factor,
-                                     thread_param->units);
+   orig_evgl_api_glPolygonOffsetxOES(thread_data->factor,
+                                     thread_data->units);
 
 }
 
@@ -18260,21 +18264,21 @@ glPolygonOffsetxOES_evgl_api_thread_cmd(GLfixed factor, GLfixed units)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glPolygonOffsetxOES thread_param_local;
-   EVGL_API_Thread_Command_glPolygonOffsetxOES *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glPolygonOffsetxOES thread_data_local;
+   EVGL_API_Thread_Command_glPolygonOffsetxOES *thread_data = &thread_data_local;
 
-   thread_param->factor = factor;
-   thread_param->units = units;
+   thread_data->factor = factor;
+   thread_data->units = units;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glPolygonOffsetxOES,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glRotatexOES(GLfixed angle, GLfixed x, GLfixed y, GLfixed z);
+ * void
+ * glRotatexOES(GLfixed angle, GLfixed x, GLfixed y, GLfixed z);
  */
 
 typedef struct
@@ -18291,13 +18295,13 @@ void (*orig_evgl_api_glRotatexOES)(GLfixed angle, GLfixed x, GLfixed y, GLfixed
 static void
 _evgl_api_thread_glRotatexOES(void *data)
 {
-   EVGL_API_Thread_Command_glRotatexOES *thread_param =
+   EVGL_API_Thread_Command_glRotatexOES *thread_data =
       (EVGL_API_Thread_Command_glRotatexOES *)data;
 
-   orig_evgl_api_glRotatexOES(thread_param->angle,
-                              thread_param->x,
-                              thread_param->y,
-                              thread_param->z);
+   orig_evgl_api_glRotatexOES(thread_data->angle,
+                              thread_data->x,
+                              thread_data->y,
+                              thread_data->z);
 
 }
 
@@ -18312,23 +18316,23 @@ glRotatexOES_evgl_api_thread_cmd(GLfixed angle, GLfixed x, GLfixed y, GLfixed z)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glRotatexOES thread_param_local;
-   EVGL_API_Thread_Command_glRotatexOES *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glRotatexOES thread_data_local;
+   EVGL_API_Thread_Command_glRotatexOES *thread_data = &thread_data_local;
 
-   thread_param->angle = angle;
-   thread_param->x = x;
-   thread_param->y = y;
-   thread_param->z = z;
+   thread_data->angle = angle;
+   thread_data->x = x;
+   thread_data->y = y;
+   thread_data->z = z;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glRotatexOES,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glSampleCoveragexOES(GLclampx value, GLboolean invert);
+ * void
+ * glSampleCoveragexOES(GLclampx value, GLboolean invert);
  */
 
 typedef struct
@@ -18343,11 +18347,11 @@ void (*orig_evgl_api_glSampleCoveragexOES)(GLclampx value, GLboolean invert);
 static void
 _evgl_api_thread_glSampleCoveragexOES(void *data)
 {
-   EVGL_API_Thread_Command_glSampleCoveragexOES *thread_param =
+   EVGL_API_Thread_Command_glSampleCoveragexOES *thread_data =
       (EVGL_API_Thread_Command_glSampleCoveragexOES *)data;
 
-   orig_evgl_api_glSampleCoveragexOES(thread_param->value,
-                                      thread_param->invert);
+   orig_evgl_api_glSampleCoveragexOES(thread_data->value,
+                                      thread_data->invert);
 
 }
 
@@ -18362,21 +18366,21 @@ glSampleCoveragexOES_evgl_api_thread_cmd(GLclampx value, GLboolean invert)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glSampleCoveragexOES thread_param_local;
-   EVGL_API_Thread_Command_glSampleCoveragexOES *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glSampleCoveragexOES thread_data_local;
+   EVGL_API_Thread_Command_glSampleCoveragexOES *thread_data = &thread_data_local;
 
-   thread_param->value = value;
-   thread_param->invert = invert;
+   thread_data->value = value;
+   thread_data->invert = invert;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glSampleCoveragexOES,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glScalexOES(GLfixed x, GLfixed y, GLfixed z);
+ * void
+ * glScalexOES(GLfixed x, GLfixed y, GLfixed z);
  */
 
 typedef struct
@@ -18392,12 +18396,12 @@ void (*orig_evgl_api_glScalexOES)(GLfixed x, GLfixed y, GLfixed z);
 static void
 _evgl_api_thread_glScalexOES(void *data)
 {
-   EVGL_API_Thread_Command_glScalexOES *thread_param =
+   EVGL_API_Thread_Command_glScalexOES *thread_data =
       (EVGL_API_Thread_Command_glScalexOES *)data;
 
-   orig_evgl_api_glScalexOES(thread_param->x,
-                             thread_param->y,
-                             thread_param->z);
+   orig_evgl_api_glScalexOES(thread_data->x,
+                             thread_data->y,
+                             thread_data->z);
 
 }
 
@@ -18412,22 +18416,22 @@ glScalexOES_evgl_api_thread_cmd(GLfixed x, GLfixed y, GLfixed z)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glScalexOES thread_param_local;
-   EVGL_API_Thread_Command_glScalexOES *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glScalexOES thread_data_local;
+   EVGL_API_Thread_Command_glScalexOES *thread_data = &thread_data_local;
 
-   thread_param->x = x;
-   thread_param->y = y;
-   thread_param->z = z;
+   thread_data->x = x;
+   thread_data->y = y;
+   thread_data->z = z;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glScalexOES,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glTexEnvxOES(GLenum target, GLenum pname, GLfixed param);
+ * void
+ * glTexEnvxOES(GLenum target, GLenum pname, GLfixed param);
  */
 
 typedef struct
@@ -18443,12 +18447,12 @@ void (*orig_evgl_api_glTexEnvxOES)(GLenum target, GLenum pname, GLfixed param);
 static void
 _evgl_api_thread_glTexEnvxOES(void *data)
 {
-   EVGL_API_Thread_Command_glTexEnvxOES *thread_param =
+   EVGL_API_Thread_Command_glTexEnvxOES *thread_data =
       (EVGL_API_Thread_Command_glTexEnvxOES *)data;
 
-   orig_evgl_api_glTexEnvxOES(thread_param->target,
-                              thread_param->pname,
-                              thread_param->param);
+   orig_evgl_api_glTexEnvxOES(thread_data->target,
+                              thread_data->pname,
+                              thread_data->param);
 
 }
 
@@ -18463,22 +18467,22 @@ glTexEnvxOES_evgl_api_thread_cmd(GLenum target, GLenum pname, GLfixed param)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glTexEnvxOES thread_param_local;
-   EVGL_API_Thread_Command_glTexEnvxOES *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glTexEnvxOES thread_data_local;
+   EVGL_API_Thread_Command_glTexEnvxOES *thread_data = &thread_data_local;
 
-   thread_param->target = target;
-   thread_param->pname = pname;
-   thread_param->param = param;
+   thread_data->target = target;
+   thread_data->pname = pname;
+   thread_data->param = param;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glTexEnvxOES,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glTexEnvxvOES(GLenum target, GLenum pname, const GLfixed *params);
+ * void
+ * glTexEnvxvOES(GLenum target, GLenum pname, const GLfixed *params);
  */
 
 typedef struct
@@ -18494,12 +18498,12 @@ void (*orig_evgl_api_glTexEnvxvOES)(GLenum target, GLenum pname, const GLfixed *
 static void
 _evgl_api_thread_glTexEnvxvOES(void *data)
 {
-   EVGL_API_Thread_Command_glTexEnvxvOES *thread_param =
+   EVGL_API_Thread_Command_glTexEnvxvOES *thread_data =
       (EVGL_API_Thread_Command_glTexEnvxvOES *)data;
 
-   orig_evgl_api_glTexEnvxvOES(thread_param->target,
-                               thread_param->pname,
-                               thread_param->params);
+   orig_evgl_api_glTexEnvxvOES(thread_data->target,
+                               thread_data->pname,
+                               thread_data->params);
 
 }
 
@@ -18514,22 +18518,22 @@ glTexEnvxvOES_evgl_api_thread_cmd(GLenum target, GLenum pname, const GLfixed *pa
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glTexEnvxvOES thread_param_local;
-   EVGL_API_Thread_Command_glTexEnvxvOES *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glTexEnvxvOES thread_data_local;
+   EVGL_API_Thread_Command_glTexEnvxvOES *thread_data = &thread_data_local;
 
-   thread_param->target = target;
-   thread_param->pname = pname;
-   thread_param->params = params;
+   thread_data->target = target;
+   thread_data->pname = pname;
+   thread_data->params = params;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glTexEnvxvOES,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glTexParameterxOES(GLenum target, GLenum pname, GLfixed param);
+ * void
+ * glTexParameterxOES(GLenum target, GLenum pname, GLfixed param);
  */
 
 typedef struct
@@ -18545,12 +18549,12 @@ void (*orig_evgl_api_glTexParameterxOES)(GLenum target, GLenum pname, GLfixed pa
 static void
 _evgl_api_thread_glTexParameterxOES(void *data)
 {
-   EVGL_API_Thread_Command_glTexParameterxOES *thread_param =
+   EVGL_API_Thread_Command_glTexParameterxOES *thread_data =
       (EVGL_API_Thread_Command_glTexParameterxOES *)data;
 
-   orig_evgl_api_glTexParameterxOES(thread_param->target,
-                                    thread_param->pname,
-                                    thread_param->param);
+   orig_evgl_api_glTexParameterxOES(thread_data->target,
+                                    thread_data->pname,
+                                    thread_data->param);
 
 }
 
@@ -18565,22 +18569,22 @@ glTexParameterxOES_evgl_api_thread_cmd(GLenum target, GLenum pname, GLfixed para
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glTexParameterxOES thread_param_local;
-   EVGL_API_Thread_Command_glTexParameterxOES *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glTexParameterxOES thread_data_local;
+   EVGL_API_Thread_Command_glTexParameterxOES *thread_data = &thread_data_local;
 
-   thread_param->target = target;
-   thread_param->pname = pname;
-   thread_param->param = param;
+   thread_data->target = target;
+   thread_data->pname = pname;
+   thread_data->param = param;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glTexParameterxOES,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glTexParameterxvOES(GLenum target, GLenum pname, const GLfixed *params);
+ * void
+ * glTexParameterxvOES(GLenum target, GLenum pname, const GLfixed *params);
  */
 
 typedef struct
@@ -18596,12 +18600,12 @@ void (*orig_evgl_api_glTexParameterxvOES)(GLenum target, GLenum pname, const GLf
 static void
 _evgl_api_thread_glTexParameterxvOES(void *data)
 {
-   EVGL_API_Thread_Command_glTexParameterxvOES *thread_param =
+   EVGL_API_Thread_Command_glTexParameterxvOES *thread_data =
       (EVGL_API_Thread_Command_glTexParameterxvOES *)data;
 
-   orig_evgl_api_glTexParameterxvOES(thread_param->target,
-                                     thread_param->pname,
-                                     thread_param->params);
+   orig_evgl_api_glTexParameterxvOES(thread_data->target,
+                                     thread_data->pname,
+                                     thread_data->params);
 
 }
 
@@ -18616,22 +18620,22 @@ glTexParameterxvOES_evgl_api_thread_cmd(GLenum target, GLenum pname, const GLfix
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glTexParameterxvOES thread_param_local;
-   EVGL_API_Thread_Command_glTexParameterxvOES *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glTexParameterxvOES thread_data_local;
+   EVGL_API_Thread_Command_glTexParameterxvOES *thread_data = &thread_data_local;
 
-   thread_param->target = target;
-   thread_param->pname = pname;
-   thread_param->params = params;
+   thread_data->target = target;
+   thread_data->pname = pname;
+   thread_data->params = params;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glTexParameterxvOES,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glTranslatexOES(GLfixed x, GLfixed y, GLfixed z);
+ * void
+ * glTranslatexOES(GLfixed x, GLfixed y, GLfixed z);
  */
 
 typedef struct
@@ -18647,12 +18651,12 @@ void (*orig_evgl_api_glTranslatexOES)(GLfixed x, GLfixed y, GLfixed z);
 static void
 _evgl_api_thread_glTranslatexOES(void *data)
 {
-   EVGL_API_Thread_Command_glTranslatexOES *thread_param =
+   EVGL_API_Thread_Command_glTranslatexOES *thread_data =
       (EVGL_API_Thread_Command_glTranslatexOES *)data;
 
-   orig_evgl_api_glTranslatexOES(thread_param->x,
-                                 thread_param->y,
-                                 thread_param->z);
+   orig_evgl_api_glTranslatexOES(thread_data->x,
+                                 thread_data->y,
+                                 thread_data->z);
 
 }
 
@@ -18667,22 +18671,22 @@ glTranslatexOES_evgl_api_thread_cmd(GLfixed x, GLfixed y, GLfixed z)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glTranslatexOES thread_param_local;
-   EVGL_API_Thread_Command_glTranslatexOES *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glTranslatexOES thread_data_local;
+   EVGL_API_Thread_Command_glTranslatexOES *thread_data = &thread_data_local;
 
-   thread_param->x = x;
-   thread_param->y = y;
-   thread_param->z = z;
+   thread_data->x = x;
+   thread_data->y = y;
+   thread_data->z = z;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glTranslatexOES,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   GLboolean
-   glIsRenderbufferOES(GLuint renderbuffer);
+ * GLboolean
+ * glIsRenderbufferOES(GLuint renderbuffer);
  */
 
 typedef struct
@@ -18697,10 +18701,10 @@ GLboolean (*orig_evgl_api_glIsRenderbufferOES)(GLuint renderbuffer);
 static void
 _evgl_api_thread_glIsRenderbufferOES(void *data)
 {
-   EVGL_API_Thread_Command_glIsRenderbufferOES *thread_param =
+   EVGL_API_Thread_Command_glIsRenderbufferOES *thread_data =
       (EVGL_API_Thread_Command_glIsRenderbufferOES *)data;
 
-   thread_param->return_value = orig_evgl_api_glIsRenderbufferOES(thread_param->renderbuffer);
+   thread_data->return_value = orig_evgl_api_glIsRenderbufferOES(thread_data->renderbuffer);
 
 }
 
@@ -18714,22 +18718,22 @@ glIsRenderbufferOES_evgl_api_thread_cmd(GLuint renderbuffer)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glIsRenderbufferOES thread_param_local;
-   EVGL_API_Thread_Command_glIsRenderbufferOES *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glIsRenderbufferOES thread_data_local;
+   EVGL_API_Thread_Command_glIsRenderbufferOES *thread_data = &thread_data_local;
 
-   thread_param->renderbuffer = renderbuffer;
+   thread_data->renderbuffer = renderbuffer;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glIsRenderbufferOES,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
-   void
-   glBindRenderbufferOES(GLenum target, GLuint renderbuffer);
+ * void
+ * glBindRenderbufferOES(GLenum target, GLuint renderbuffer);
  */
 
 typedef struct
@@ -18745,14 +18749,14 @@ void (*orig_evgl_api_glBindRenderbufferOES)(GLenum target, GLuint renderbuffer);
 static void
 _evgl_api_thread_glBindRenderbufferOES(void *data)
 {
-   EVGL_API_Thread_Command_glBindRenderbufferOES *thread_param =
+   EVGL_API_Thread_Command_glBindRenderbufferOES *thread_data =
       (EVGL_API_Thread_Command_glBindRenderbufferOES *)data;
 
-   orig_evgl_api_glBindRenderbufferOES(thread_param->target,
-                                       thread_param->renderbuffer);
+   orig_evgl_api_glBindRenderbufferOES(thread_data->target,
+                                       thread_data->renderbuffer);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -18766,37 +18770,37 @@ glBindRenderbufferOES_evgl_api_thread_cmd(GLenum target, GLuint renderbuffer)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glBindRenderbufferOES thread_param_local;
-   EVGL_API_Thread_Command_glBindRenderbufferOES *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glBindRenderbufferOES thread_data_local;
+   EVGL_API_Thread_Command_glBindRenderbufferOES *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_API_Thread_Command_glBindRenderbufferOES *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_API_Thread_Command_glBindRenderbufferOES));
-        if (thread_param_new)
+        EVGL_API_Thread_Command_glBindRenderbufferOES *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_API_Thread_Command_glBindRenderbufferOES));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->target = target;
-   thread_param->renderbuffer = renderbuffer;
+   thread_data->target = target;
+   thread_data->renderbuffer = renderbuffer;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glBindRenderbufferOES,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glDeleteRenderbuffersOES(GLsizei n, const GLuint* renderbuffers);
+ * void
+ * glDeleteRenderbuffersOES(GLsizei n, const GLuint* renderbuffers);
  */
 
 typedef struct
@@ -18813,18 +18817,18 @@ void (*orig_evgl_api_glDeleteRenderbuffersOES)(GLsizei n, const GLuint* renderbu
 static void
 _evgl_api_thread_glDeleteRenderbuffersOES(void *data)
 {
-   EVGL_API_Thread_Command_glDeleteRenderbuffersOES *thread_param =
+   EVGL_API_Thread_Command_glDeleteRenderbuffersOES *thread_data =
       (EVGL_API_Thread_Command_glDeleteRenderbuffersOES *)data;
 
-   orig_evgl_api_glDeleteRenderbuffersOES(thread_param->n,
-                                          thread_param->renderbuffers);
+   orig_evgl_api_glDeleteRenderbuffersOES(thread_data->n,
+                                          thread_data->renderbuffers);
 
 
-   if (thread_param->renderbuffers_copied)
-     eina_mempool_free(_mp_delete_object, thread_param->renderbuffers_copied);
+   if (thread_data->renderbuffers_copied)
+     eina_mempool_free(_mp_delete_object, thread_data->renderbuffers_copied);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -18838,29 +18842,29 @@ glDeleteRenderbuffersOES_evgl_api_thread_cmd(GLsizei n, const GLuint* renderbuff
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glDeleteRenderbuffersOES thread_param_local;
-   EVGL_API_Thread_Command_glDeleteRenderbuffersOES *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glDeleteRenderbuffersOES thread_data_local;
+   EVGL_API_Thread_Command_glDeleteRenderbuffersOES *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_API_Thread_Command_glDeleteRenderbuffersOES *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_API_Thread_Command_glDeleteRenderbuffersOES));
-        if (thread_param_new)
+        EVGL_API_Thread_Command_glDeleteRenderbuffersOES *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_API_Thread_Command_glDeleteRenderbuffersOES));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->n = n;
-   thread_param->renderbuffers = renderbuffers;
+   thread_data->n = n;
+   thread_data->renderbuffers = renderbuffers;
 
-   thread_param->renderbuffers_copied = NULL;
+   thread_data->renderbuffers_copied = NULL;
    if (thread_mode == EVAS_GL_THREAD_MODE_FINISH)
      goto finish;
 
@@ -18875,10 +18879,10 @@ glDeleteRenderbuffersOES_evgl_api_thread_cmd(GLsizei n, const GLuint* renderbuff
              goto finish;
           }
         /* 2. malloc & copy */
-        thread_param->renderbuffers_copied = eina_mempool_malloc(_mp_delete_object, copy_size);
-        if (thread_param->renderbuffers_copied)
+        thread_data->renderbuffers_copied = eina_mempool_malloc(_mp_delete_object, copy_size);
+        if (thread_data->renderbuffers_copied)
           {
-             memcpy(thread_param->renderbuffers_copied, renderbuffers, copy_size);
+             memcpy(thread_data->renderbuffers_copied, renderbuffers, copy_size);
           }
         else
           {
@@ -18886,20 +18890,20 @@ glDeleteRenderbuffersOES_evgl_api_thread_cmd(GLsizei n, const GLuint* renderbuff
              goto finish;
           }
         /* 3. replace */
-        thread_param->renderbuffers = (const GLuint *)thread_param->renderbuffers_copied;
+        thread_data->renderbuffers = (const GLuint *)thread_data->renderbuffers_copied;
      }
    /* end of copy variable */
 
 finish:
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glDeleteRenderbuffersOES,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGenRenderbuffersOES(GLsizei n, GLuint* renderbuffers);
+ * void
+ * glGenRenderbuffersOES(GLsizei n, GLuint* renderbuffers);
  */
 
 typedef struct
@@ -18914,11 +18918,11 @@ void (*orig_evgl_api_glGenRenderbuffersOES)(GLsizei n, GLuint* renderbuffers);
 static void
 _evgl_api_thread_glGenRenderbuffersOES(void *data)
 {
-   EVGL_API_Thread_Command_glGenRenderbuffersOES *thread_param =
+   EVGL_API_Thread_Command_glGenRenderbuffersOES *thread_data =
       (EVGL_API_Thread_Command_glGenRenderbuffersOES *)data;
 
-   orig_evgl_api_glGenRenderbuffersOES(thread_param->n,
-                                       thread_param->renderbuffers);
+   orig_evgl_api_glGenRenderbuffersOES(thread_data->n,
+                                       thread_data->renderbuffers);
 
 }
 
@@ -18933,21 +18937,21 @@ glGenRenderbuffersOES_evgl_api_thread_cmd(GLsizei n, GLuint* renderbuffers)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGenRenderbuffersOES thread_param_local;
-   EVGL_API_Thread_Command_glGenRenderbuffersOES *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGenRenderbuffersOES thread_data_local;
+   EVGL_API_Thread_Command_glGenRenderbuffersOES *thread_data = &thread_data_local;
 
-   thread_param->n = n;
-   thread_param->renderbuffers = renderbuffers;
+   thread_data->n = n;
+   thread_data->renderbuffers = renderbuffers;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGenRenderbuffersOES,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glRenderbufferStorageOES(GLenum target, GLenum internalformat, GLsizei width, GLsizei height);
+ * void
+ * glRenderbufferStorageOES(GLenum target, GLenum internalformat, GLsizei width, GLsizei height);
  */
 
 typedef struct
@@ -18965,16 +18969,16 @@ void (*orig_evgl_api_glRenderbufferStorageOES)(GLenum target, GLenum internalfor
 static void
 _evgl_api_thread_glRenderbufferStorageOES(void *data)
 {
-   EVGL_API_Thread_Command_glRenderbufferStorageOES *thread_param =
+   EVGL_API_Thread_Command_glRenderbufferStorageOES *thread_data =
       (EVGL_API_Thread_Command_glRenderbufferStorageOES *)data;
 
-   orig_evgl_api_glRenderbufferStorageOES(thread_param->target,
-                                          thread_param->internalformat,
-                                          thread_param->width,
-                                          thread_param->height);
+   orig_evgl_api_glRenderbufferStorageOES(thread_data->target,
+                                          thread_data->internalformat,
+                                          thread_data->width,
+                                          thread_data->height);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -18988,39 +18992,39 @@ glRenderbufferStorageOES_evgl_api_thread_cmd(GLenum target, GLenum internalforma
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glRenderbufferStorageOES thread_param_local;
-   EVGL_API_Thread_Command_glRenderbufferStorageOES *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glRenderbufferStorageOES thread_data_local;
+   EVGL_API_Thread_Command_glRenderbufferStorageOES *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_API_Thread_Command_glRenderbufferStorageOES *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_API_Thread_Command_glRenderbufferStorageOES));
-        if (thread_param_new)
+        EVGL_API_Thread_Command_glRenderbufferStorageOES *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_API_Thread_Command_glRenderbufferStorageOES));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->target = target;
-   thread_param->internalformat = internalformat;
-   thread_param->width = width;
-   thread_param->height = height;
+   thread_data->target = target;
+   thread_data->internalformat = internalformat;
+   thread_data->width = width;
+   thread_data->height = height;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glRenderbufferStorageOES,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGetRenderbufferParameterivOES(GLenum target, GLenum pname, GLint* params);
+ * void
+ * glGetRenderbufferParameterivOES(GLenum target, GLenum pname, GLint* params);
  */
 
 typedef struct
@@ -19036,12 +19040,12 @@ void (*orig_evgl_api_glGetRenderbufferParameterivOES)(GLenum target, GLenum pnam
 static void
 _evgl_api_thread_glGetRenderbufferParameterivOES(void *data)
 {
-   EVGL_API_Thread_Command_glGetRenderbufferParameterivOES *thread_param =
+   EVGL_API_Thread_Command_glGetRenderbufferParameterivOES *thread_data =
       (EVGL_API_Thread_Command_glGetRenderbufferParameterivOES *)data;
 
-   orig_evgl_api_glGetRenderbufferParameterivOES(thread_param->target,
-                                                 thread_param->pname,
-                                                 thread_param->params);
+   orig_evgl_api_glGetRenderbufferParameterivOES(thread_data->target,
+                                                 thread_data->pname,
+                                                 thread_data->params);
 
 }
 
@@ -19056,22 +19060,22 @@ glGetRenderbufferParameterivOES_evgl_api_thread_cmd(GLenum target, GLenum pname,
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGetRenderbufferParameterivOES thread_param_local;
-   EVGL_API_Thread_Command_glGetRenderbufferParameterivOES *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGetRenderbufferParameterivOES thread_data_local;
+   EVGL_API_Thread_Command_glGetRenderbufferParameterivOES *thread_data = &thread_data_local;
 
-   thread_param->target = target;
-   thread_param->pname = pname;
-   thread_param->params = params;
+   thread_data->target = target;
+   thread_data->pname = pname;
+   thread_data->params = params;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGetRenderbufferParameterivOES,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   GLboolean
-   glIsFramebufferOES(GLuint framebuffer);
+ * GLboolean
+ * glIsFramebufferOES(GLuint framebuffer);
  */
 
 typedef struct
@@ -19086,10 +19090,10 @@ GLboolean (*orig_evgl_api_glIsFramebufferOES)(GLuint framebuffer);
 static void
 _evgl_api_thread_glIsFramebufferOES(void *data)
 {
-   EVGL_API_Thread_Command_glIsFramebufferOES *thread_param =
+   EVGL_API_Thread_Command_glIsFramebufferOES *thread_data =
       (EVGL_API_Thread_Command_glIsFramebufferOES *)data;
 
-   thread_param->return_value = orig_evgl_api_glIsFramebufferOES(thread_param->framebuffer);
+   thread_data->return_value = orig_evgl_api_glIsFramebufferOES(thread_data->framebuffer);
 
 }
 
@@ -19103,22 +19107,22 @@ glIsFramebufferOES_evgl_api_thread_cmd(GLuint framebuffer)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glIsFramebufferOES thread_param_local;
-   EVGL_API_Thread_Command_glIsFramebufferOES *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glIsFramebufferOES thread_data_local;
+   EVGL_API_Thread_Command_glIsFramebufferOES *thread_data = &thread_data_local;
 
-   thread_param->framebuffer = framebuffer;
+   thread_data->framebuffer = framebuffer;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glIsFramebufferOES,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
-   void
-   glBindFramebufferOES(GLenum target, GLuint framebuffer);
+ * void
+ * glBindFramebufferOES(GLenum target, GLuint framebuffer);
  */
 
 typedef struct
@@ -19134,14 +19138,14 @@ void (*orig_evgl_api_glBindFramebufferOES)(GLenum target, GLuint framebuffer);
 static void
 _evgl_api_thread_glBindFramebufferOES(void *data)
 {
-   EVGL_API_Thread_Command_glBindFramebufferOES *thread_param =
+   EVGL_API_Thread_Command_glBindFramebufferOES *thread_data =
       (EVGL_API_Thread_Command_glBindFramebufferOES *)data;
 
-   orig_evgl_api_glBindFramebufferOES(thread_param->target,
-                                      thread_param->framebuffer);
+   orig_evgl_api_glBindFramebufferOES(thread_data->target,
+                                      thread_data->framebuffer);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -19155,37 +19159,37 @@ glBindFramebufferOES_evgl_api_thread_cmd(GLenum target, GLuint framebuffer)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glBindFramebufferOES thread_param_local;
-   EVGL_API_Thread_Command_glBindFramebufferOES *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glBindFramebufferOES thread_data_local;
+   EVGL_API_Thread_Command_glBindFramebufferOES *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_API_Thread_Command_glBindFramebufferOES *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_API_Thread_Command_glBindFramebufferOES));
-        if (thread_param_new)
+        EVGL_API_Thread_Command_glBindFramebufferOES *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_API_Thread_Command_glBindFramebufferOES));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->target = target;
-   thread_param->framebuffer = framebuffer;
+   thread_data->target = target;
+   thread_data->framebuffer = framebuffer;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glBindFramebufferOES,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glDeleteFramebuffersOES(GLsizei n, const GLuint* framebuffers);
+ * void
+ * glDeleteFramebuffersOES(GLsizei n, const GLuint* framebuffers);
  */
 
 typedef struct
@@ -19202,18 +19206,18 @@ void (*orig_evgl_api_glDeleteFramebuffersOES)(GLsizei n, const GLuint* framebuff
 static void
 _evgl_api_thread_glDeleteFramebuffersOES(void *data)
 {
-   EVGL_API_Thread_Command_glDeleteFramebuffersOES *thread_param =
+   EVGL_API_Thread_Command_glDeleteFramebuffersOES *thread_data =
       (EVGL_API_Thread_Command_glDeleteFramebuffersOES *)data;
 
-   orig_evgl_api_glDeleteFramebuffersOES(thread_param->n,
-                                         thread_param->framebuffers);
+   orig_evgl_api_glDeleteFramebuffersOES(thread_data->n,
+                                         thread_data->framebuffers);
 
 
-   if (thread_param->framebuffers_copied)
-     eina_mempool_free(_mp_delete_object, thread_param->framebuffers_copied);
+   if (thread_data->framebuffers_copied)
+     eina_mempool_free(_mp_delete_object, thread_data->framebuffers_copied);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -19227,29 +19231,29 @@ glDeleteFramebuffersOES_evgl_api_thread_cmd(GLsizei n, const GLuint* framebuffer
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glDeleteFramebuffersOES thread_param_local;
-   EVGL_API_Thread_Command_glDeleteFramebuffersOES *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glDeleteFramebuffersOES thread_data_local;
+   EVGL_API_Thread_Command_glDeleteFramebuffersOES *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_API_Thread_Command_glDeleteFramebuffersOES *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_API_Thread_Command_glDeleteFramebuffersOES));
-        if (thread_param_new)
+        EVGL_API_Thread_Command_glDeleteFramebuffersOES *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_API_Thread_Command_glDeleteFramebuffersOES));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->n = n;
-   thread_param->framebuffers = framebuffers;
+   thread_data->n = n;
+   thread_data->framebuffers = framebuffers;
 
-   thread_param->framebuffers_copied = NULL;
+   thread_data->framebuffers_copied = NULL;
    if (thread_mode == EVAS_GL_THREAD_MODE_FINISH)
      goto finish;
 
@@ -19264,10 +19268,10 @@ glDeleteFramebuffersOES_evgl_api_thread_cmd(GLsizei n, const GLuint* framebuffer
              goto finish;
           }
         /* 2. malloc & copy */
-        thread_param->framebuffers_copied = eina_mempool_malloc(_mp_delete_object, copy_size);
-        if (thread_param->framebuffers_copied)
+        thread_data->framebuffers_copied = eina_mempool_malloc(_mp_delete_object, copy_size);
+        if (thread_data->framebuffers_copied)
           {
-             memcpy(thread_param->framebuffers_copied, framebuffers, copy_size);
+             memcpy(thread_data->framebuffers_copied, framebuffers, copy_size);
           }
         else
           {
@@ -19275,20 +19279,20 @@ glDeleteFramebuffersOES_evgl_api_thread_cmd(GLsizei n, const GLuint* framebuffer
              goto finish;
           }
         /* 3. replace */
-        thread_param->framebuffers = (const GLuint *)thread_param->framebuffers_copied;
+        thread_data->framebuffers = (const GLuint *)thread_data->framebuffers_copied;
      }
    /* end of copy variable */
 
 finish:
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glDeleteFramebuffersOES,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGenFramebuffersOES(GLsizei n, GLuint* framebuffers);
+ * void
+ * glGenFramebuffersOES(GLsizei n, GLuint* framebuffers);
  */
 
 typedef struct
@@ -19303,11 +19307,11 @@ void (*orig_evgl_api_glGenFramebuffersOES)(GLsizei n, GLuint* framebuffers);
 static void
 _evgl_api_thread_glGenFramebuffersOES(void *data)
 {
-   EVGL_API_Thread_Command_glGenFramebuffersOES *thread_param =
+   EVGL_API_Thread_Command_glGenFramebuffersOES *thread_data =
       (EVGL_API_Thread_Command_glGenFramebuffersOES *)data;
 
-   orig_evgl_api_glGenFramebuffersOES(thread_param->n,
-                                      thread_param->framebuffers);
+   orig_evgl_api_glGenFramebuffersOES(thread_data->n,
+                                      thread_data->framebuffers);
 
 }
 
@@ -19322,21 +19326,21 @@ glGenFramebuffersOES_evgl_api_thread_cmd(GLsizei n, GLuint* framebuffers)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGenFramebuffersOES thread_param_local;
-   EVGL_API_Thread_Command_glGenFramebuffersOES *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGenFramebuffersOES thread_data_local;
+   EVGL_API_Thread_Command_glGenFramebuffersOES *thread_data = &thread_data_local;
 
-   thread_param->n = n;
-   thread_param->framebuffers = framebuffers;
+   thread_data->n = n;
+   thread_data->framebuffers = framebuffers;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGenFramebuffersOES,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   GLenum
-   glCheckFramebufferStatusOES(GLenum target);
+ * GLenum
+ * glCheckFramebufferStatusOES(GLenum target);
  */
 
 typedef struct
@@ -19351,10 +19355,10 @@ GLenum (*orig_evgl_api_glCheckFramebufferStatusOES)(GLenum target);
 static void
 _evgl_api_thread_glCheckFramebufferStatusOES(void *data)
 {
-   EVGL_API_Thread_Command_glCheckFramebufferStatusOES *thread_param =
+   EVGL_API_Thread_Command_glCheckFramebufferStatusOES *thread_data =
       (EVGL_API_Thread_Command_glCheckFramebufferStatusOES *)data;
 
-   thread_param->return_value = orig_evgl_api_glCheckFramebufferStatusOES(thread_param->target);
+   thread_data->return_value = orig_evgl_api_glCheckFramebufferStatusOES(thread_data->target);
 
 }
 
@@ -19368,22 +19372,22 @@ glCheckFramebufferStatusOES_evgl_api_thread_cmd(GLenum target)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glCheckFramebufferStatusOES thread_param_local;
-   EVGL_API_Thread_Command_glCheckFramebufferStatusOES *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glCheckFramebufferStatusOES thread_data_local;
+   EVGL_API_Thread_Command_glCheckFramebufferStatusOES *thread_data = &thread_data_local;
 
-   thread_param->target = target;
+   thread_data->target = target;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glCheckFramebufferStatusOES,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
-   void
-   glFramebufferRenderbufferOES(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer);
+ * void
+ * glFramebufferRenderbufferOES(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer);
  */
 
 typedef struct
@@ -19401,16 +19405,16 @@ void (*orig_evgl_api_glFramebufferRenderbufferOES)(GLenum target, GLenum attachm
 static void
 _evgl_api_thread_glFramebufferRenderbufferOES(void *data)
 {
-   EVGL_API_Thread_Command_glFramebufferRenderbufferOES *thread_param =
+   EVGL_API_Thread_Command_glFramebufferRenderbufferOES *thread_data =
       (EVGL_API_Thread_Command_glFramebufferRenderbufferOES *)data;
 
-   orig_evgl_api_glFramebufferRenderbufferOES(thread_param->target,
-                                              thread_param->attachment,
-                                              thread_param->renderbuffertarget,
-                                              thread_param->renderbuffer);
+   orig_evgl_api_glFramebufferRenderbufferOES(thread_data->target,
+                                              thread_data->attachment,
+                                              thread_data->renderbuffertarget,
+                                              thread_data->renderbuffer);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -19424,39 +19428,39 @@ glFramebufferRenderbufferOES_evgl_api_thread_cmd(GLenum target, GLenum attachmen
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glFramebufferRenderbufferOES thread_param_local;
-   EVGL_API_Thread_Command_glFramebufferRenderbufferOES *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glFramebufferRenderbufferOES thread_data_local;
+   EVGL_API_Thread_Command_glFramebufferRenderbufferOES *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_API_Thread_Command_glFramebufferRenderbufferOES *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_API_Thread_Command_glFramebufferRenderbufferOES));
-        if (thread_param_new)
+        EVGL_API_Thread_Command_glFramebufferRenderbufferOES *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_API_Thread_Command_glFramebufferRenderbufferOES));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->target = target;
-   thread_param->attachment = attachment;
-   thread_param->renderbuffertarget = renderbuffertarget;
-   thread_param->renderbuffer = renderbuffer;
+   thread_data->target = target;
+   thread_data->attachment = attachment;
+   thread_data->renderbuffertarget = renderbuffertarget;
+   thread_data->renderbuffer = renderbuffer;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glFramebufferRenderbufferOES,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glFramebufferTexture2DOES(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
+ * void
+ * glFramebufferTexture2DOES(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
  */
 
 typedef struct
@@ -19475,17 +19479,17 @@ void (*orig_evgl_api_glFramebufferTexture2DOES)(GLenum target, GLenum attachment
 static void
 _evgl_api_thread_glFramebufferTexture2DOES(void *data)
 {
-   EVGL_API_Thread_Command_glFramebufferTexture2DOES *thread_param =
+   EVGL_API_Thread_Command_glFramebufferTexture2DOES *thread_data =
       (EVGL_API_Thread_Command_glFramebufferTexture2DOES *)data;
 
-   orig_evgl_api_glFramebufferTexture2DOES(thread_param->target,
-                                           thread_param->attachment,
-                                           thread_param->textarget,
-                                           thread_param->texture,
-                                           thread_param->level);
+   orig_evgl_api_glFramebufferTexture2DOES(thread_data->target,
+                                           thread_data->attachment,
+                                           thread_data->textarget,
+                                           thread_data->texture,
+                                           thread_data->level);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -19499,40 +19503,40 @@ glFramebufferTexture2DOES_evgl_api_thread_cmd(GLenum target, GLenum attachment,
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glFramebufferTexture2DOES thread_param_local;
-   EVGL_API_Thread_Command_glFramebufferTexture2DOES *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glFramebufferTexture2DOES thread_data_local;
+   EVGL_API_Thread_Command_glFramebufferTexture2DOES *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_API_Thread_Command_glFramebufferTexture2DOES *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_API_Thread_Command_glFramebufferTexture2DOES));
-        if (thread_param_new)
+        EVGL_API_Thread_Command_glFramebufferTexture2DOES *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_API_Thread_Command_glFramebufferTexture2DOES));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->target = target;
-   thread_param->attachment = attachment;
-   thread_param->textarget = textarget;
-   thread_param->texture = texture;
-   thread_param->level = level;
+   thread_data->target = target;
+   thread_data->attachment = attachment;
+   thread_data->textarget = textarget;
+   thread_data->texture = texture;
+   thread_data->level = level;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glFramebufferTexture2DOES,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGetFramebufferAttachmentParameterivOES(GLenum target, GLenum attachment, GLenum pname, GLint* params);
+ * void
+ * glGetFramebufferAttachmentParameterivOES(GLenum target, GLenum attachment, GLenum pname, GLint* params);
  */
 
 typedef struct
@@ -19549,13 +19553,13 @@ void (*orig_evgl_api_glGetFramebufferAttachmentParameterivOES)(GLenum target, GL
 static void
 _evgl_api_thread_glGetFramebufferAttachmentParameterivOES(void *data)
 {
-   EVGL_API_Thread_Command_glGetFramebufferAttachmentParameterivOES *thread_param =
+   EVGL_API_Thread_Command_glGetFramebufferAttachmentParameterivOES *thread_data =
       (EVGL_API_Thread_Command_glGetFramebufferAttachmentParameterivOES *)data;
 
-   orig_evgl_api_glGetFramebufferAttachmentParameterivOES(thread_param->target,
-                                                          thread_param->attachment,
-                                                          thread_param->pname,
-                                                          thread_param->params);
+   orig_evgl_api_glGetFramebufferAttachmentParameterivOES(thread_data->target,
+                                                          thread_data->attachment,
+                                                          thread_data->pname,
+                                                          thread_data->params);
 
 }
 
@@ -19570,23 +19574,23 @@ glGetFramebufferAttachmentParameterivOES_evgl_api_thread_cmd(GLenum target, GLen
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGetFramebufferAttachmentParameterivOES thread_param_local;
-   EVGL_API_Thread_Command_glGetFramebufferAttachmentParameterivOES *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGetFramebufferAttachmentParameterivOES thread_data_local;
+   EVGL_API_Thread_Command_glGetFramebufferAttachmentParameterivOES *thread_data = &thread_data_local;
 
-   thread_param->target = target;
-   thread_param->attachment = attachment;
-   thread_param->pname = pname;
-   thread_param->params = params;
+   thread_data->target = target;
+   thread_data->attachment = attachment;
+   thread_data->pname = pname;
+   thread_data->params = params;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGetFramebufferAttachmentParameterivOES,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGenerateMipmapOES(GLenum target);
+ * void
+ * glGenerateMipmapOES(GLenum target);
  */
 
 typedef struct
@@ -19600,10 +19604,10 @@ void (*orig_evgl_api_glGenerateMipmapOES)(GLenum target);
 static void
 _evgl_api_thread_glGenerateMipmapOES(void *data)
 {
-   EVGL_API_Thread_Command_glGenerateMipmapOES *thread_param =
+   EVGL_API_Thread_Command_glGenerateMipmapOES *thread_data =
       (EVGL_API_Thread_Command_glGenerateMipmapOES *)data;
 
-   orig_evgl_api_glGenerateMipmapOES(thread_param->target);
+   orig_evgl_api_glGenerateMipmapOES(thread_data->target);
 
 }
 
@@ -19618,20 +19622,20 @@ glGenerateMipmapOES_evgl_api_thread_cmd(GLenum target)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGenerateMipmapOES thread_param_local;
-   EVGL_API_Thread_Command_glGenerateMipmapOES *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGenerateMipmapOES thread_data_local;
+   EVGL_API_Thread_Command_glGenerateMipmapOES *thread_data = &thread_data_local;
 
-   thread_param->target = target;
+   thread_data->target = target;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGenerateMipmapOES,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glCurrentPaletteMatrixOES(GLuint matrixpaletteindex);
+ * void
+ * glCurrentPaletteMatrixOES(GLuint matrixpaletteindex);
  */
 
 typedef struct
@@ -19645,10 +19649,10 @@ void (*orig_evgl_api_glCurrentPaletteMatrixOES)(GLuint matrixpaletteindex);
 static void
 _evgl_api_thread_glCurrentPaletteMatrixOES(void *data)
 {
-   EVGL_API_Thread_Command_glCurrentPaletteMatrixOES *thread_param =
+   EVGL_API_Thread_Command_glCurrentPaletteMatrixOES *thread_data =
       (EVGL_API_Thread_Command_glCurrentPaletteMatrixOES *)data;
 
-   orig_evgl_api_glCurrentPaletteMatrixOES(thread_param->matrixpaletteindex);
+   orig_evgl_api_glCurrentPaletteMatrixOES(thread_data->matrixpaletteindex);
 
 }
 
@@ -19663,20 +19667,20 @@ glCurrentPaletteMatrixOES_evgl_api_thread_cmd(GLuint matrixpaletteindex)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glCurrentPaletteMatrixOES thread_param_local;
-   EVGL_API_Thread_Command_glCurrentPaletteMatrixOES *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glCurrentPaletteMatrixOES thread_data_local;
+   EVGL_API_Thread_Command_glCurrentPaletteMatrixOES *thread_data = &thread_data_local;
 
-   thread_param->matrixpaletteindex = matrixpaletteindex;
+   thread_data->matrixpaletteindex = matrixpaletteindex;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glCurrentPaletteMatrixOES,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glLoadPaletteFromModelViewMatrixOES(void);
+ * void
+ * glLoadPaletteFromModelViewMatrixOES(void);
  */
 
 void (*orig_evgl_api_glLoadPaletteFromModelViewMatrixOES)(void);
@@ -19706,8 +19710,8 @@ glLoadPaletteFromModelViewMatrixOES_evgl_api_thread_cmd(void)
 }
 
 /*
-   void
-   glMatrixIndexPointerOES(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
+ * void
+ * glMatrixIndexPointerOES(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
  */
 
 typedef struct
@@ -19724,13 +19728,13 @@ void (*orig_evgl_api_glMatrixIndexPointerOES)(GLint size, GLenum type, GLsizei s
 static void
 _evgl_api_thread_glMatrixIndexPointerOES(void *data)
 {
-   EVGL_API_Thread_Command_glMatrixIndexPointerOES *thread_param =
+   EVGL_API_Thread_Command_glMatrixIndexPointerOES *thread_data =
       (EVGL_API_Thread_Command_glMatrixIndexPointerOES *)data;
 
-   orig_evgl_api_glMatrixIndexPointerOES(thread_param->size,
-                                         thread_param->type,
-                                         thread_param->stride,
-                                         thread_param->pointer);
+   orig_evgl_api_glMatrixIndexPointerOES(thread_data->size,
+                                         thread_data->type,
+                                         thread_data->stride,
+                                         thread_data->pointer);
 
 }
 
@@ -19745,23 +19749,23 @@ glMatrixIndexPointerOES_evgl_api_thread_cmd(GLint size, GLenum type, GLsizei str
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glMatrixIndexPointerOES thread_param_local;
-   EVGL_API_Thread_Command_glMatrixIndexPointerOES *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glMatrixIndexPointerOES thread_data_local;
+   EVGL_API_Thread_Command_glMatrixIndexPointerOES *thread_data = &thread_data_local;
 
-   thread_param->size = size;
-   thread_param->type = type;
-   thread_param->stride = stride;
-   thread_param->pointer = pointer;
+   thread_data->size = size;
+   thread_data->type = type;
+   thread_data->stride = stride;
+   thread_data->pointer = pointer;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glMatrixIndexPointerOES,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glWeightPointerOES(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
+ * void
+ * glWeightPointerOES(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
  */
 
 typedef struct
@@ -19778,13 +19782,13 @@ void (*orig_evgl_api_glWeightPointerOES)(GLint size, GLenum type, GLsizei stride
 static void
 _evgl_api_thread_glWeightPointerOES(void *data)
 {
-   EVGL_API_Thread_Command_glWeightPointerOES *thread_param =
+   EVGL_API_Thread_Command_glWeightPointerOES *thread_data =
       (EVGL_API_Thread_Command_glWeightPointerOES *)data;
 
-   orig_evgl_api_glWeightPointerOES(thread_param->size,
-                                    thread_param->type,
-                                    thread_param->stride,
-                                    thread_param->pointer);
+   orig_evgl_api_glWeightPointerOES(thread_data->size,
+                                    thread_data->type,
+                                    thread_data->stride,
+                                    thread_data->pointer);
 
 }
 
@@ -19799,23 +19803,23 @@ glWeightPointerOES_evgl_api_thread_cmd(GLint size, GLenum type, GLsizei stride,
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glWeightPointerOES thread_param_local;
-   EVGL_API_Thread_Command_glWeightPointerOES *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glWeightPointerOES thread_data_local;
+   EVGL_API_Thread_Command_glWeightPointerOES *thread_data = &thread_data_local;
 
-   thread_param->size = size;
-   thread_param->type = type;
-   thread_param->stride = stride;
-   thread_param->pointer = pointer;
+   thread_data->size = size;
+   thread_data->type = type;
+   thread_data->stride = stride;
+   thread_data->pointer = pointer;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glWeightPointerOES,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   GLbitfield
-   glQueryMatrixxOES(GLfixed mantissa[16], GLint exponent[16]);
+ * GLbitfield
+ * glQueryMatrixxOES(GLfixed mantissa[16], GLint exponent[16]);
  */
 
 typedef struct
@@ -19831,11 +19835,11 @@ GLbitfield (*orig_evgl_api_glQueryMatrixxOES)(GLfixed mantissa[16], GLint expone
 static void
 _evgl_api_thread_glQueryMatrixxOES(void *data)
 {
-   EVGL_API_Thread_Command_glQueryMatrixxOES *thread_param =
+   EVGL_API_Thread_Command_glQueryMatrixxOES *thread_data =
       (EVGL_API_Thread_Command_glQueryMatrixxOES *)data;
 
-   thread_param->return_value = orig_evgl_api_glQueryMatrixxOES(thread_param->mantissa,
-                                                                thread_param->exponent);
+   thread_data->return_value = orig_evgl_api_glQueryMatrixxOES(thread_data->mantissa,
+                                                               thread_data->exponent);
 
 }
 
@@ -19849,23 +19853,23 @@ glQueryMatrixxOES_evgl_api_thread_cmd(GLfixed mantissa[16], GLint exponent[16])
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glQueryMatrixxOES thread_param_local;
-   EVGL_API_Thread_Command_glQueryMatrixxOES *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glQueryMatrixxOES thread_data_local;
+   EVGL_API_Thread_Command_glQueryMatrixxOES *thread_data = &thread_data_local;
 
-   memcpy(thread_param->mantissa, &mantissa, sizeof(mantissa));
-   memcpy(thread_param->exponent, &exponent, sizeof(exponent));
+   memcpy(thread_data->mantissa, &mantissa, sizeof(GLfixed) * 16);
+   memcpy(thread_data->exponent, &exponent, sizeof(GLint) * 16);
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glQueryMatrixxOES,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
-   void
-   glDepthRangefOES(GLclampf zNear, GLclampf zFar);
+ * void
+ * glDepthRangefOES(GLclampf zNear, GLclampf zFar);
  */
 
 typedef struct
@@ -19880,11 +19884,11 @@ void (*orig_evgl_api_glDepthRangefOES)(GLclampf zNear, GLclampf zFar);
 static void
 _evgl_api_thread_glDepthRangefOES(void *data)
 {
-   EVGL_API_Thread_Command_glDepthRangefOES *thread_param =
+   EVGL_API_Thread_Command_glDepthRangefOES *thread_data =
       (EVGL_API_Thread_Command_glDepthRangefOES *)data;
 
-   orig_evgl_api_glDepthRangefOES(thread_param->zNear,
-                                  thread_param->zFar);
+   orig_evgl_api_glDepthRangefOES(thread_data->zNear,
+                                  thread_data->zFar);
 
 }
 
@@ -19899,21 +19903,21 @@ glDepthRangefOES_evgl_api_thread_cmd(GLclampf zNear, GLclampf zFar)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glDepthRangefOES thread_param_local;
-   EVGL_API_Thread_Command_glDepthRangefOES *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glDepthRangefOES thread_data_local;
+   EVGL_API_Thread_Command_glDepthRangefOES *thread_data = &thread_data_local;
 
-   thread_param->zNear = zNear;
-   thread_param->zFar = zFar;
+   thread_data->zNear = zNear;
+   thread_data->zFar = zFar;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glDepthRangefOES,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glFrustumfOES(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar);
+ * void
+ * glFrustumfOES(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar);
  */
 
 typedef struct
@@ -19932,15 +19936,15 @@ void (*orig_evgl_api_glFrustumfOES)(GLfloat left, GLfloat right, GLfloat bottom,
 static void
 _evgl_api_thread_glFrustumfOES(void *data)
 {
-   EVGL_API_Thread_Command_glFrustumfOES *thread_param =
+   EVGL_API_Thread_Command_glFrustumfOES *thread_data =
       (EVGL_API_Thread_Command_glFrustumfOES *)data;
 
-   orig_evgl_api_glFrustumfOES(thread_param->left,
-                               thread_param->right,
-                               thread_param->bottom,
-                               thread_param->top,
-                               thread_param->zNear,
-                               thread_param->zFar);
+   orig_evgl_api_glFrustumfOES(thread_data->left,
+                               thread_data->right,
+                               thread_data->bottom,
+                               thread_data->top,
+                               thread_data->zNear,
+                               thread_data->zFar);
 
 }
 
@@ -19955,25 +19959,25 @@ glFrustumfOES_evgl_api_thread_cmd(GLfloat left, GLfloat right, GLfloat bottom, G
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glFrustumfOES thread_param_local;
-   EVGL_API_Thread_Command_glFrustumfOES *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glFrustumfOES thread_data_local;
+   EVGL_API_Thread_Command_glFrustumfOES *thread_data = &thread_data_local;
 
-   thread_param->left = left;
-   thread_param->right = right;
-   thread_param->bottom = bottom;
-   thread_param->top = top;
-   thread_param->zNear = zNear;
-   thread_param->zFar = zFar;
+   thread_data->left = left;
+   thread_data->right = right;
+   thread_data->bottom = bottom;
+   thread_data->top = top;
+   thread_data->zNear = zNear;
+   thread_data->zFar = zFar;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glFrustumfOES,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glOrthofOES(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar);
+ * void
+ * glOrthofOES(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar);
  */
 
 typedef struct
@@ -19992,15 +19996,15 @@ void (*orig_evgl_api_glOrthofOES)(GLfloat left, GLfloat right, GLfloat bottom, G
 static void
 _evgl_api_thread_glOrthofOES(void *data)
 {
-   EVGL_API_Thread_Command_glOrthofOES *thread_param =
+   EVGL_API_Thread_Command_glOrthofOES *thread_data =
       (EVGL_API_Thread_Command_glOrthofOES *)data;
 
-   orig_evgl_api_glOrthofOES(thread_param->left,
-                             thread_param->right,
-                             thread_param->bottom,
-                             thread_param->top,
-                             thread_param->zNear,
-                             thread_param->zFar);
+   orig_evgl_api_glOrthofOES(thread_data->left,
+                             thread_data->right,
+                             thread_data->bottom,
+                             thread_data->top,
+                             thread_data->zNear,
+                             thread_data->zFar);
 
 }
 
@@ -20015,25 +20019,25 @@ glOrthofOES_evgl_api_thread_cmd(GLfloat left, GLfloat right, GLfloat bottom, GLf
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glOrthofOES thread_param_local;
-   EVGL_API_Thread_Command_glOrthofOES *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glOrthofOES thread_data_local;
+   EVGL_API_Thread_Command_glOrthofOES *thread_data = &thread_data_local;
 
-   thread_param->left = left;
-   thread_param->right = right;
-   thread_param->bottom = bottom;
-   thread_param->top = top;
-   thread_param->zNear = zNear;
-   thread_param->zFar = zFar;
+   thread_data->left = left;
+   thread_data->right = right;
+   thread_data->bottom = bottom;
+   thread_data->top = top;
+   thread_data->zNear = zNear;
+   thread_data->zFar = zFar;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glOrthofOES,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glClipPlanefOES(GLenum plane, const GLfloat *equation);
+ * void
+ * glClipPlanefOES(GLenum plane, const GLfloat *equation);
  */
 
 typedef struct
@@ -20048,11 +20052,11 @@ void (*orig_evgl_api_glClipPlanefOES)(GLenum plane, const GLfloat *equation);
 static void
 _evgl_api_thread_glClipPlanefOES(void *data)
 {
-   EVGL_API_Thread_Command_glClipPlanefOES *thread_param =
+   EVGL_API_Thread_Command_glClipPlanefOES *thread_data =
       (EVGL_API_Thread_Command_glClipPlanefOES *)data;
 
-   orig_evgl_api_glClipPlanefOES(thread_param->plane,
-                                 thread_param->equation);
+   orig_evgl_api_glClipPlanefOES(thread_data->plane,
+                                 thread_data->equation);
 
 }
 
@@ -20067,21 +20071,21 @@ glClipPlanefOES_evgl_api_thread_cmd(GLenum plane, const GLfloat *equation)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glClipPlanefOES thread_param_local;
-   EVGL_API_Thread_Command_glClipPlanefOES *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glClipPlanefOES thread_data_local;
+   EVGL_API_Thread_Command_glClipPlanefOES *thread_data = &thread_data_local;
 
-   thread_param->plane = plane;
-   thread_param->equation = equation;
+   thread_data->plane = plane;
+   thread_data->equation = equation;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glClipPlanefOES,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGetClipPlanefOES(GLenum pname, GLfloat eqn[4]);
+ * void
+ * glGetClipPlanefOES(GLenum pname, GLfloat eqn[4]);
  */
 
 typedef struct
@@ -20096,11 +20100,11 @@ void (*orig_evgl_api_glGetClipPlanefOES)(GLenum pname, GLfloat eqn[4]);
 static void
 _evgl_api_thread_glGetClipPlanefOES(void *data)
 {
-   EVGL_API_Thread_Command_glGetClipPlanefOES *thread_param =
+   EVGL_API_Thread_Command_glGetClipPlanefOES *thread_data =
       (EVGL_API_Thread_Command_glGetClipPlanefOES *)data;
 
-   orig_evgl_api_glGetClipPlanefOES(thread_param->pname,
-                                    thread_param->eqn);
+   orig_evgl_api_glGetClipPlanefOES(thread_data->pname,
+                                    thread_data->eqn);
 
 }
 
@@ -20115,21 +20119,21 @@ glGetClipPlanefOES_evgl_api_thread_cmd(GLenum pname, GLfloat eqn[4])
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGetClipPlanefOES thread_param_local;
-   EVGL_API_Thread_Command_glGetClipPlanefOES *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGetClipPlanefOES thread_data_local;
+   EVGL_API_Thread_Command_glGetClipPlanefOES *thread_data = &thread_data_local;
 
-   thread_param->pname = pname;
-   memcpy(thread_param->eqn, &eqn, sizeof(eqn));
+   thread_data->pname = pname;
+   memcpy(thread_data->eqn, &eqn, sizeof(GLfloat) * 4);
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGetClipPlanefOES,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glClearDepthfOES(GLclampf depth);
+ * void
+ * glClearDepthfOES(GLclampf depth);
  */
 
 typedef struct
@@ -20143,10 +20147,10 @@ void (*orig_evgl_api_glClearDepthfOES)(GLclampf depth);
 static void
 _evgl_api_thread_glClearDepthfOES(void *data)
 {
-   EVGL_API_Thread_Command_glClearDepthfOES *thread_param =
+   EVGL_API_Thread_Command_glClearDepthfOES *thread_data =
       (EVGL_API_Thread_Command_glClearDepthfOES *)data;
 
-   orig_evgl_api_glClearDepthfOES(thread_param->depth);
+   orig_evgl_api_glClearDepthfOES(thread_data->depth);
 
 }
 
@@ -20161,20 +20165,20 @@ glClearDepthfOES_evgl_api_thread_cmd(GLclampf depth)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glClearDepthfOES thread_param_local;
-   EVGL_API_Thread_Command_glClearDepthfOES *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glClearDepthfOES thread_data_local;
+   EVGL_API_Thread_Command_glClearDepthfOES *thread_data = &thread_data_local;
 
-   thread_param->depth = depth;
+   thread_data->depth = depth;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glClearDepthfOES,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glTexGenfOES(GLenum coord, GLenum pname, GLfloat param);
+ * void
+ * glTexGenfOES(GLenum coord, GLenum pname, GLfloat param);
  */
 
 typedef struct
@@ -20190,12 +20194,12 @@ void (*orig_evgl_api_glTexGenfOES)(GLenum coord, GLenum pname, GLfloat param);
 static void
 _evgl_api_thread_glTexGenfOES(void *data)
 {
-   EVGL_API_Thread_Command_glTexGenfOES *thread_param =
+   EVGL_API_Thread_Command_glTexGenfOES *thread_data =
       (EVGL_API_Thread_Command_glTexGenfOES *)data;
 
-   orig_evgl_api_glTexGenfOES(thread_param->coord,
-                              thread_param->pname,
-                              thread_param->param);
+   orig_evgl_api_glTexGenfOES(thread_data->coord,
+                              thread_data->pname,
+                              thread_data->param);
 
 }
 
@@ -20210,22 +20214,22 @@ glTexGenfOES_evgl_api_thread_cmd(GLenum coord, GLenum pname, GLfloat param)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glTexGenfOES thread_param_local;
-   EVGL_API_Thread_Command_glTexGenfOES *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glTexGenfOES thread_data_local;
+   EVGL_API_Thread_Command_glTexGenfOES *thread_data = &thread_data_local;
 
-   thread_param->coord = coord;
-   thread_param->pname = pname;
-   thread_param->param = param;
+   thread_data->coord = coord;
+   thread_data->pname = pname;
+   thread_data->param = param;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glTexGenfOES,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glTexGenfvOES(GLenum coord, GLenum pname, const GLfloat *params);
+ * void
+ * glTexGenfvOES(GLenum coord, GLenum pname, const GLfloat *params);
  */
 
 typedef struct
@@ -20241,12 +20245,12 @@ void (*orig_evgl_api_glTexGenfvOES)(GLenum coord, GLenum pname, const GLfloat *p
 static void
 _evgl_api_thread_glTexGenfvOES(void *data)
 {
-   EVGL_API_Thread_Command_glTexGenfvOES *thread_param =
+   EVGL_API_Thread_Command_glTexGenfvOES *thread_data =
       (EVGL_API_Thread_Command_glTexGenfvOES *)data;
 
-   orig_evgl_api_glTexGenfvOES(thread_param->coord,
-                               thread_param->pname,
-                               thread_param->params);
+   orig_evgl_api_glTexGenfvOES(thread_data->coord,
+                               thread_data->pname,
+                               thread_data->params);
 
 }
 
@@ -20261,22 +20265,22 @@ glTexGenfvOES_evgl_api_thread_cmd(GLenum coord, GLenum pname, const GLfloat *par
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glTexGenfvOES thread_param_local;
-   EVGL_API_Thread_Command_glTexGenfvOES *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glTexGenfvOES thread_data_local;
+   EVGL_API_Thread_Command_glTexGenfvOES *thread_data = &thread_data_local;
 
-   thread_param->coord = coord;
-   thread_param->pname = pname;
-   thread_param->params = params;
+   thread_data->coord = coord;
+   thread_data->pname = pname;
+   thread_data->params = params;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glTexGenfvOES,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glTexGeniOES(GLenum coord, GLenum pname, GLint param);
+ * void
+ * glTexGeniOES(GLenum coord, GLenum pname, GLint param);
  */
 
 typedef struct
@@ -20292,12 +20296,12 @@ void (*orig_evgl_api_glTexGeniOES)(GLenum coord, GLenum pname, GLint param);
 static void
 _evgl_api_thread_glTexGeniOES(void *data)
 {
-   EVGL_API_Thread_Command_glTexGeniOES *thread_param =
+   EVGL_API_Thread_Command_glTexGeniOES *thread_data =
       (EVGL_API_Thread_Command_glTexGeniOES *)data;
 
-   orig_evgl_api_glTexGeniOES(thread_param->coord,
-                              thread_param->pname,
-                              thread_param->param);
+   orig_evgl_api_glTexGeniOES(thread_data->coord,
+                              thread_data->pname,
+                              thread_data->param);
 
 }
 
@@ -20312,22 +20316,22 @@ glTexGeniOES_evgl_api_thread_cmd(GLenum coord, GLenum pname, GLint param)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glTexGeniOES thread_param_local;
-   EVGL_API_Thread_Command_glTexGeniOES *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glTexGeniOES thread_data_local;
+   EVGL_API_Thread_Command_glTexGeniOES *thread_data = &thread_data_local;
 
-   thread_param->coord = coord;
-   thread_param->pname = pname;
-   thread_param->param = param;
+   thread_data->coord = coord;
+   thread_data->pname = pname;
+   thread_data->param = param;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glTexGeniOES,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glTexGenivOES(GLenum coord, GLenum pname, const GLint *params);
+ * void
+ * glTexGenivOES(GLenum coord, GLenum pname, const GLint *params);
  */
 
 typedef struct
@@ -20343,12 +20347,12 @@ void (*orig_evgl_api_glTexGenivOES)(GLenum coord, GLenum pname, const GLint *par
 static void
 _evgl_api_thread_glTexGenivOES(void *data)
 {
-   EVGL_API_Thread_Command_glTexGenivOES *thread_param =
+   EVGL_API_Thread_Command_glTexGenivOES *thread_data =
       (EVGL_API_Thread_Command_glTexGenivOES *)data;
 
-   orig_evgl_api_glTexGenivOES(thread_param->coord,
-                               thread_param->pname,
-                               thread_param->params);
+   orig_evgl_api_glTexGenivOES(thread_data->coord,
+                               thread_data->pname,
+                               thread_data->params);
 
 }
 
@@ -20363,22 +20367,22 @@ glTexGenivOES_evgl_api_thread_cmd(GLenum coord, GLenum pname, const GLint *param
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glTexGenivOES thread_param_local;
-   EVGL_API_Thread_Command_glTexGenivOES *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glTexGenivOES thread_data_local;
+   EVGL_API_Thread_Command_glTexGenivOES *thread_data = &thread_data_local;
 
-   thread_param->coord = coord;
-   thread_param->pname = pname;
-   thread_param->params = params;
+   thread_data->coord = coord;
+   thread_data->pname = pname;
+   thread_data->params = params;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glTexGenivOES,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glTexGenxOES(GLenum coord, GLenum pname, GLfixed param);
+ * void
+ * glTexGenxOES(GLenum coord, GLenum pname, GLfixed param);
  */
 
 typedef struct
@@ -20394,12 +20398,12 @@ void (*orig_evgl_api_glTexGenxOES)(GLenum coord, GLenum pname, GLfixed param);
 static void
 _evgl_api_thread_glTexGenxOES(void *data)
 {
-   EVGL_API_Thread_Command_glTexGenxOES *thread_param =
+   EVGL_API_Thread_Command_glTexGenxOES *thread_data =
       (EVGL_API_Thread_Command_glTexGenxOES *)data;
 
-   orig_evgl_api_glTexGenxOES(thread_param->coord,
-                              thread_param->pname,
-                              thread_param->param);
+   orig_evgl_api_glTexGenxOES(thread_data->coord,
+                              thread_data->pname,
+                              thread_data->param);
 
 }
 
@@ -20414,22 +20418,22 @@ glTexGenxOES_evgl_api_thread_cmd(GLenum coord, GLenum pname, GLfixed param)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glTexGenxOES thread_param_local;
-   EVGL_API_Thread_Command_glTexGenxOES *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glTexGenxOES thread_data_local;
+   EVGL_API_Thread_Command_glTexGenxOES *thread_data = &thread_data_local;
 
-   thread_param->coord = coord;
-   thread_param->pname = pname;
-   thread_param->param = param;
+   thread_data->coord = coord;
+   thread_data->pname = pname;
+   thread_data->param = param;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glTexGenxOES,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glTexGenxvOES(GLenum coord, GLenum pname, const GLfixed *params);
+ * void
+ * glTexGenxvOES(GLenum coord, GLenum pname, const GLfixed *params);
  */
 
 typedef struct
@@ -20445,12 +20449,12 @@ void (*orig_evgl_api_glTexGenxvOES)(GLenum coord, GLenum pname, const GLfixed *p
 static void
 _evgl_api_thread_glTexGenxvOES(void *data)
 {
-   EVGL_API_Thread_Command_glTexGenxvOES *thread_param =
+   EVGL_API_Thread_Command_glTexGenxvOES *thread_data =
       (EVGL_API_Thread_Command_glTexGenxvOES *)data;
 
-   orig_evgl_api_glTexGenxvOES(thread_param->coord,
-                               thread_param->pname,
-                               thread_param->params);
+   orig_evgl_api_glTexGenxvOES(thread_data->coord,
+                               thread_data->pname,
+                               thread_data->params);
 
 }
 
@@ -20465,22 +20469,22 @@ glTexGenxvOES_evgl_api_thread_cmd(GLenum coord, GLenum pname, const GLfixed *par
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glTexGenxvOES thread_param_local;
-   EVGL_API_Thread_Command_glTexGenxvOES *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glTexGenxvOES thread_data_local;
+   EVGL_API_Thread_Command_glTexGenxvOES *thread_data = &thread_data_local;
 
-   thread_param->coord = coord;
-   thread_param->pname = pname;
-   thread_param->params = params;
+   thread_data->coord = coord;
+   thread_data->pname = pname;
+   thread_data->params = params;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glTexGenxvOES,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGetTexGenfvOES(GLenum coord, GLenum pname, GLfloat *params);
+ * void
+ * glGetTexGenfvOES(GLenum coord, GLenum pname, GLfloat *params);
  */
 
 typedef struct
@@ -20496,12 +20500,12 @@ void (*orig_evgl_api_glGetTexGenfvOES)(GLenum coord, GLenum pname, GLfloat *para
 static void
 _evgl_api_thread_glGetTexGenfvOES(void *data)
 {
-   EVGL_API_Thread_Command_glGetTexGenfvOES *thread_param =
+   EVGL_API_Thread_Command_glGetTexGenfvOES *thread_data =
       (EVGL_API_Thread_Command_glGetTexGenfvOES *)data;
 
-   orig_evgl_api_glGetTexGenfvOES(thread_param->coord,
-                                  thread_param->pname,
-                                  thread_param->params);
+   orig_evgl_api_glGetTexGenfvOES(thread_data->coord,
+                                  thread_data->pname,
+                                  thread_data->params);
 
 }
 
@@ -20516,22 +20520,22 @@ glGetTexGenfvOES_evgl_api_thread_cmd(GLenum coord, GLenum pname, GLfloat *params
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGetTexGenfvOES thread_param_local;
-   EVGL_API_Thread_Command_glGetTexGenfvOES *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGetTexGenfvOES thread_data_local;
+   EVGL_API_Thread_Command_glGetTexGenfvOES *thread_data = &thread_data_local;
 
-   thread_param->coord = coord;
-   thread_param->pname = pname;
-   thread_param->params = params;
+   thread_data->coord = coord;
+   thread_data->pname = pname;
+   thread_data->params = params;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGetTexGenfvOES,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGetTexGenivOES(GLenum coord, GLenum pname, GLint *params);
+ * void
+ * glGetTexGenivOES(GLenum coord, GLenum pname, GLint *params);
  */
 
 typedef struct
@@ -20547,12 +20551,12 @@ void (*orig_evgl_api_glGetTexGenivOES)(GLenum coord, GLenum pname, GLint *params
 static void
 _evgl_api_thread_glGetTexGenivOES(void *data)
 {
-   EVGL_API_Thread_Command_glGetTexGenivOES *thread_param =
+   EVGL_API_Thread_Command_glGetTexGenivOES *thread_data =
       (EVGL_API_Thread_Command_glGetTexGenivOES *)data;
 
-   orig_evgl_api_glGetTexGenivOES(thread_param->coord,
-                                  thread_param->pname,
-                                  thread_param->params);
+   orig_evgl_api_glGetTexGenivOES(thread_data->coord,
+                                  thread_data->pname,
+                                  thread_data->params);
 
 }
 
@@ -20567,22 +20571,22 @@ glGetTexGenivOES_evgl_api_thread_cmd(GLenum coord, GLenum pname, GLint *params)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGetTexGenivOES thread_param_local;
-   EVGL_API_Thread_Command_glGetTexGenivOES *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGetTexGenivOES thread_data_local;
+   EVGL_API_Thread_Command_glGetTexGenivOES *thread_data = &thread_data_local;
 
-   thread_param->coord = coord;
-   thread_param->pname = pname;
-   thread_param->params = params;
+   thread_data->coord = coord;
+   thread_data->pname = pname;
+   thread_data->params = params;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGetTexGenivOES,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGetTexGenxvOES(GLenum coord, GLenum pname, GLfixed *params);
+ * void
+ * glGetTexGenxvOES(GLenum coord, GLenum pname, GLfixed *params);
  */
 
 typedef struct
@@ -20598,12 +20602,12 @@ void (*orig_evgl_api_glGetTexGenxvOES)(GLenum coord, GLenum pname, GLfixed *para
 static void
 _evgl_api_thread_glGetTexGenxvOES(void *data)
 {
-   EVGL_API_Thread_Command_glGetTexGenxvOES *thread_param =
+   EVGL_API_Thread_Command_glGetTexGenxvOES *thread_data =
       (EVGL_API_Thread_Command_glGetTexGenxvOES *)data;
 
-   orig_evgl_api_glGetTexGenxvOES(thread_param->coord,
-                                  thread_param->pname,
-                                  thread_param->params);
+   orig_evgl_api_glGetTexGenxvOES(thread_data->coord,
+                                  thread_data->pname,
+                                  thread_data->params);
 
 }
 
@@ -20618,22 +20622,22 @@ glGetTexGenxvOES_evgl_api_thread_cmd(GLenum coord, GLenum pname, GLfixed *params
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGetTexGenxvOES thread_param_local;
-   EVGL_API_Thread_Command_glGetTexGenxvOES *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGetTexGenxvOES thread_data_local;
+   EVGL_API_Thread_Command_glGetTexGenxvOES *thread_data = &thread_data_local;
 
-   thread_param->coord = coord;
-   thread_param->pname = pname;
-   thread_param->params = params;
+   thread_data->coord = coord;
+   thread_data->pname = pname;
+   thread_data->params = params;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGetTexGenxvOES,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glBindVertexArrayOES(GLuint array);
+ * void
+ * glBindVertexArrayOES(GLuint array);
  */
 
 typedef struct
@@ -20647,10 +20651,10 @@ void (*orig_evgl_api_glBindVertexArrayOES)(GLuint array);
 static void
 _evgl_api_thread_glBindVertexArrayOES(void *data)
 {
-   EVGL_API_Thread_Command_glBindVertexArrayOES *thread_param =
+   EVGL_API_Thread_Command_glBindVertexArrayOES *thread_data =
       (EVGL_API_Thread_Command_glBindVertexArrayOES *)data;
 
-   orig_evgl_api_glBindVertexArrayOES(thread_param->array);
+   orig_evgl_api_glBindVertexArrayOES(thread_data->array);
 
 }
 
@@ -20665,20 +20669,20 @@ glBindVertexArrayOES_evgl_api_thread_cmd(GLuint array)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glBindVertexArrayOES thread_param_local;
-   EVGL_API_Thread_Command_glBindVertexArrayOES *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glBindVertexArrayOES thread_data_local;
+   EVGL_API_Thread_Command_glBindVertexArrayOES *thread_data = &thread_data_local;
 
-   thread_param->array = array;
+   thread_data->array = array;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glBindVertexArrayOES,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glDeleteVertexArraysOES(GLsizei n, const GLuint *arrays);
+ * void
+ * glDeleteVertexArraysOES(GLsizei n, const GLuint *arrays);
  */
 
 typedef struct
@@ -20693,11 +20697,11 @@ void (*orig_evgl_api_glDeleteVertexArraysOES)(GLsizei n, const GLuint *arrays);
 static void
 _evgl_api_thread_glDeleteVertexArraysOES(void *data)
 {
-   EVGL_API_Thread_Command_glDeleteVertexArraysOES *thread_param =
+   EVGL_API_Thread_Command_glDeleteVertexArraysOES *thread_data =
       (EVGL_API_Thread_Command_glDeleteVertexArraysOES *)data;
 
-   orig_evgl_api_glDeleteVertexArraysOES(thread_param->n,
-                                         thread_param->arrays);
+   orig_evgl_api_glDeleteVertexArraysOES(thread_data->n,
+                                         thread_data->arrays);
 
 }
 
@@ -20712,21 +20716,21 @@ glDeleteVertexArraysOES_evgl_api_thread_cmd(GLsizei n, const GLuint *arrays)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glDeleteVertexArraysOES thread_param_local;
-   EVGL_API_Thread_Command_glDeleteVertexArraysOES *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glDeleteVertexArraysOES thread_data_local;
+   EVGL_API_Thread_Command_glDeleteVertexArraysOES *thread_data = &thread_data_local;
 
-   thread_param->n = n;
-   thread_param->arrays = arrays;
+   thread_data->n = n;
+   thread_data->arrays = arrays;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glDeleteVertexArraysOES,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGenVertexArraysOES(GLsizei n, GLuint *arrays);
+ * void
+ * glGenVertexArraysOES(GLsizei n, GLuint *arrays);
  */
 
 typedef struct
@@ -20741,11 +20745,11 @@ void (*orig_evgl_api_glGenVertexArraysOES)(GLsizei n, GLuint *arrays);
 static void
 _evgl_api_thread_glGenVertexArraysOES(void *data)
 {
-   EVGL_API_Thread_Command_glGenVertexArraysOES *thread_param =
+   EVGL_API_Thread_Command_glGenVertexArraysOES *thread_data =
       (EVGL_API_Thread_Command_glGenVertexArraysOES *)data;
 
-   orig_evgl_api_glGenVertexArraysOES(thread_param->n,
-                                      thread_param->arrays);
+   orig_evgl_api_glGenVertexArraysOES(thread_data->n,
+                                      thread_data->arrays);
 
 }
 
@@ -20760,21 +20764,21 @@ glGenVertexArraysOES_evgl_api_thread_cmd(GLsizei n, GLuint *arrays)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGenVertexArraysOES thread_param_local;
-   EVGL_API_Thread_Command_glGenVertexArraysOES *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGenVertexArraysOES thread_data_local;
+   EVGL_API_Thread_Command_glGenVertexArraysOES *thread_data = &thread_data_local;
 
-   thread_param->n = n;
-   thread_param->arrays = arrays;
+   thread_data->n = n;
+   thread_data->arrays = arrays;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGenVertexArraysOES,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   GLboolean
-   glIsVertexArrayOES(GLuint array);
+ * GLboolean
+ * glIsVertexArrayOES(GLuint array);
  */
 
 typedef struct
@@ -20789,10 +20793,10 @@ GLboolean (*orig_evgl_api_glIsVertexArrayOES)(GLuint array);
 static void
 _evgl_api_thread_glIsVertexArrayOES(void *data)
 {
-   EVGL_API_Thread_Command_glIsVertexArrayOES *thread_param =
+   EVGL_API_Thread_Command_glIsVertexArrayOES *thread_data =
       (EVGL_API_Thread_Command_glIsVertexArrayOES *)data;
 
-   thread_param->return_value = orig_evgl_api_glIsVertexArrayOES(thread_param->array);
+   thread_data->return_value = orig_evgl_api_glIsVertexArrayOES(thread_data->array);
 
 }
 
@@ -20806,22 +20810,22 @@ glIsVertexArrayOES_evgl_api_thread_cmd(GLuint array)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glIsVertexArrayOES thread_param_local;
-   EVGL_API_Thread_Command_glIsVertexArrayOES *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glIsVertexArrayOES thread_data_local;
+   EVGL_API_Thread_Command_glIsVertexArrayOES *thread_data = &thread_data_local;
 
-   thread_param->array = array;
+   thread_data->array = array;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glIsVertexArrayOES,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
-   void
-   glCopyTextureLevelsAPPLE(GLuint destinationTexture, GLuint sourceTexture, GLint sourceBaseLevel, GLsizei sourceLevelCount);
+ * void
+ * glCopyTextureLevelsAPPLE(GLuint destinationTexture, GLuint sourceTexture, GLint sourceBaseLevel, GLsizei sourceLevelCount);
  */
 
 typedef struct
@@ -20838,13 +20842,13 @@ void (*orig_evgl_api_glCopyTextureLevelsAPPLE)(GLuint destinationTexture, GLuint
 static void
 _evgl_api_thread_glCopyTextureLevelsAPPLE(void *data)
 {
-   EVGL_API_Thread_Command_glCopyTextureLevelsAPPLE *thread_param =
+   EVGL_API_Thread_Command_glCopyTextureLevelsAPPLE *thread_data =
       (EVGL_API_Thread_Command_glCopyTextureLevelsAPPLE *)data;
 
-   orig_evgl_api_glCopyTextureLevelsAPPLE(thread_param->destinationTexture,
-                                          thread_param->sourceTexture,
-                                          thread_param->sourceBaseLevel,
-                                          thread_param->sourceLevelCount);
+   orig_evgl_api_glCopyTextureLevelsAPPLE(thread_data->destinationTexture,
+                                          thread_data->sourceTexture,
+                                          thread_data->sourceBaseLevel,
+                                          thread_data->sourceLevelCount);
 
 }
 
@@ -20859,23 +20863,23 @@ glCopyTextureLevelsAPPLE_evgl_api_thread_cmd(GLuint destinationTexture, GLuint s
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glCopyTextureLevelsAPPLE thread_param_local;
-   EVGL_API_Thread_Command_glCopyTextureLevelsAPPLE *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glCopyTextureLevelsAPPLE thread_data_local;
+   EVGL_API_Thread_Command_glCopyTextureLevelsAPPLE *thread_data = &thread_data_local;
 
-   thread_param->destinationTexture = destinationTexture;
-   thread_param->sourceTexture = sourceTexture;
-   thread_param->sourceBaseLevel = sourceBaseLevel;
-   thread_param->sourceLevelCount = sourceLevelCount;
+   thread_data->destinationTexture = destinationTexture;
+   thread_data->sourceTexture = sourceTexture;
+   thread_data->sourceBaseLevel = sourceBaseLevel;
+   thread_data->sourceLevelCount = sourceLevelCount;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glCopyTextureLevelsAPPLE,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glRenderbufferStorageMultisampleAPPLE(GLenum a, GLsizei b, GLenum c, GLsizei d, GLsizei e);
+ * void
+ * glRenderbufferStorageMultisampleAPPLE(GLenum a, GLsizei b, GLenum c, GLsizei d, GLsizei e);
  */
 
 typedef struct
@@ -20893,14 +20897,14 @@ void (*orig_evgl_api_glRenderbufferStorageMultisampleAPPLE)(GLenum a, GLsizei b,
 static void
 _evgl_api_thread_glRenderbufferStorageMultisampleAPPLE(void *data)
 {
-   EVGL_API_Thread_Command_glRenderbufferStorageMultisampleAPPLE *thread_param =
+   EVGL_API_Thread_Command_glRenderbufferStorageMultisampleAPPLE *thread_data =
       (EVGL_API_Thread_Command_glRenderbufferStorageMultisampleAPPLE *)data;
 
-   orig_evgl_api_glRenderbufferStorageMultisampleAPPLE(thread_param->a,
-                                                       thread_param->b,
-                                                       thread_param->c,
-                                                       thread_param->d,
-                                                       thread_param->e);
+   orig_evgl_api_glRenderbufferStorageMultisampleAPPLE(thread_data->a,
+                                                       thread_data->b,
+                                                       thread_data->c,
+                                                       thread_data->d,
+                                                       thread_data->e);
 
 }
 
@@ -20915,24 +20919,24 @@ glRenderbufferStorageMultisampleAPPLE_evgl_api_thread_cmd(GLenum a, GLsizei b, G
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glRenderbufferStorageMultisampleAPPLE thread_param_local;
-   EVGL_API_Thread_Command_glRenderbufferStorageMultisampleAPPLE *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glRenderbufferStorageMultisampleAPPLE thread_data_local;
+   EVGL_API_Thread_Command_glRenderbufferStorageMultisampleAPPLE *thread_data = &thread_data_local;
 
-   thread_param->a = a;
-   thread_param->b = b;
-   thread_param->c = c;
-   thread_param->d = d;
-   thread_param->e = e;
+   thread_data->a = a;
+   thread_data->b = b;
+   thread_data->c = c;
+   thread_data->d = d;
+   thread_data->e = e;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glRenderbufferStorageMultisampleAPPLE,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glResolveMultisampleFramebufferAPPLE(void);
+ * void
+ * glResolveMultisampleFramebufferAPPLE(void);
  */
 
 void (*orig_evgl_api_glResolveMultisampleFramebufferAPPLE)(void);
@@ -20962,8 +20966,8 @@ glResolveMultisampleFramebufferAPPLE_evgl_api_thread_cmd(void)
 }
 
 /*
-   GLsync
-   glFenceSyncAPPLE(GLenum condition, GLbitfield flags);
+ * GLsync
+ * glFenceSyncAPPLE(GLenum condition, GLbitfield flags);
  */
 
 typedef struct
@@ -20979,11 +20983,11 @@ GLsync (*orig_evgl_api_glFenceSyncAPPLE)(GLenum condition, GLbitfield flags);
 static void
 _evgl_api_thread_glFenceSyncAPPLE(void *data)
 {
-   EVGL_API_Thread_Command_glFenceSyncAPPLE *thread_param =
+   EVGL_API_Thread_Command_glFenceSyncAPPLE *thread_data =
       (EVGL_API_Thread_Command_glFenceSyncAPPLE *)data;
 
-   thread_param->return_value = orig_evgl_api_glFenceSyncAPPLE(thread_param->condition,
-                                                               thread_param->flags);
+   thread_data->return_value = orig_evgl_api_glFenceSyncAPPLE(thread_data->condition,
+                                                              thread_data->flags);
 
 }
 
@@ -20997,23 +21001,23 @@ glFenceSyncAPPLE_evgl_api_thread_cmd(GLenum condition, GLbitfield flags)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glFenceSyncAPPLE thread_param_local;
-   EVGL_API_Thread_Command_glFenceSyncAPPLE *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glFenceSyncAPPLE thread_data_local;
+   EVGL_API_Thread_Command_glFenceSyncAPPLE *thread_data = &thread_data_local;
 
-   thread_param->condition = condition;
-   thread_param->flags = flags;
+   thread_data->condition = condition;
+   thread_data->flags = flags;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glFenceSyncAPPLE,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
-   GLboolean
-   glIsSyncAPPLE(GLsync sync);
+ * GLboolean
+ * glIsSyncAPPLE(GLsync sync);
  */
 
 typedef struct
@@ -21028,10 +21032,10 @@ GLboolean (*orig_evgl_api_glIsSyncAPPLE)(GLsync sync);
 static void
 _evgl_api_thread_glIsSyncAPPLE(void *data)
 {
-   EVGL_API_Thread_Command_glIsSyncAPPLE *thread_param =
+   EVGL_API_Thread_Command_glIsSyncAPPLE *thread_data =
       (EVGL_API_Thread_Command_glIsSyncAPPLE *)data;
 
-   thread_param->return_value = orig_evgl_api_glIsSyncAPPLE(thread_param->sync);
+   thread_data->return_value = orig_evgl_api_glIsSyncAPPLE(thread_data->sync);
 
 }
 
@@ -21045,22 +21049,22 @@ glIsSyncAPPLE_evgl_api_thread_cmd(GLsync sync)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glIsSyncAPPLE thread_param_local;
-   EVGL_API_Thread_Command_glIsSyncAPPLE *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glIsSyncAPPLE thread_data_local;
+   EVGL_API_Thread_Command_glIsSyncAPPLE *thread_data = &thread_data_local;
 
-   thread_param->sync = sync;
+   thread_data->sync = sync;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glIsSyncAPPLE,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
-   void
-   glDeleteSyncAPPLE(GLsync sync);
+ * void
+ * glDeleteSyncAPPLE(GLsync sync);
  */
 
 typedef struct
@@ -21074,10 +21078,10 @@ void (*orig_evgl_api_glDeleteSyncAPPLE)(GLsync sync);
 static void
 _evgl_api_thread_glDeleteSyncAPPLE(void *data)
 {
-   EVGL_API_Thread_Command_glDeleteSyncAPPLE *thread_param =
+   EVGL_API_Thread_Command_glDeleteSyncAPPLE *thread_data =
       (EVGL_API_Thread_Command_glDeleteSyncAPPLE *)data;
 
-   orig_evgl_api_glDeleteSyncAPPLE(thread_param->sync);
+   orig_evgl_api_glDeleteSyncAPPLE(thread_data->sync);
 
 }
 
@@ -21092,20 +21096,20 @@ glDeleteSyncAPPLE_evgl_api_thread_cmd(GLsync sync)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glDeleteSyncAPPLE thread_param_local;
-   EVGL_API_Thread_Command_glDeleteSyncAPPLE *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glDeleteSyncAPPLE thread_data_local;
+   EVGL_API_Thread_Command_glDeleteSyncAPPLE *thread_data = &thread_data_local;
 
-   thread_param->sync = sync;
+   thread_data->sync = sync;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glDeleteSyncAPPLE,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   GLenum
-   glClientWaitSyncAPPLE(GLsync sync, GLbitfield flags, EvasGLuint64 timeout);
+ * GLenum
+ * glClientWaitSyncAPPLE(GLsync sync, GLbitfield flags, EvasGLuint64 timeout);
  */
 
 typedef struct
@@ -21122,12 +21126,12 @@ GLenum (*orig_evgl_api_glClientWaitSyncAPPLE)(GLsync sync, GLbitfield flags, Eva
 static void
 _evgl_api_thread_glClientWaitSyncAPPLE(void *data)
 {
-   EVGL_API_Thread_Command_glClientWaitSyncAPPLE *thread_param =
+   EVGL_API_Thread_Command_glClientWaitSyncAPPLE *thread_data =
       (EVGL_API_Thread_Command_glClientWaitSyncAPPLE *)data;
 
-   thread_param->return_value = orig_evgl_api_glClientWaitSyncAPPLE(thread_param->sync,
-                                                                    thread_param->flags,
-                                                                    thread_param->timeout);
+   thread_data->return_value = orig_evgl_api_glClientWaitSyncAPPLE(thread_data->sync,
+                                                                   thread_data->flags,
+                                                                   thread_data->timeout);
 
 }
 
@@ -21141,24 +21145,24 @@ glClientWaitSyncAPPLE_evgl_api_thread_cmd(GLsync sync, GLbitfield flags, EvasGLu
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glClientWaitSyncAPPLE thread_param_local;
-   EVGL_API_Thread_Command_glClientWaitSyncAPPLE *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glClientWaitSyncAPPLE thread_data_local;
+   EVGL_API_Thread_Command_glClientWaitSyncAPPLE *thread_data = &thread_data_local;
 
-   thread_param->sync = sync;
-   thread_param->flags = flags;
-   thread_param->timeout = timeout;
+   thread_data->sync = sync;
+   thread_data->flags = flags;
+   thread_data->timeout = timeout;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glClientWaitSyncAPPLE,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
-   void
-   glWaitSyncAPPLE(GLsync sync, GLbitfield flags, EvasGLuint64 timeout);
+ * void
+ * glWaitSyncAPPLE(GLsync sync, GLbitfield flags, EvasGLuint64 timeout);
  */
 
 typedef struct
@@ -21174,12 +21178,12 @@ void (*orig_evgl_api_glWaitSyncAPPLE)(GLsync sync, GLbitfield flags, EvasGLuint6
 static void
 _evgl_api_thread_glWaitSyncAPPLE(void *data)
 {
-   EVGL_API_Thread_Command_glWaitSyncAPPLE *thread_param =
+   EVGL_API_Thread_Command_glWaitSyncAPPLE *thread_data =
       (EVGL_API_Thread_Command_glWaitSyncAPPLE *)data;
 
-   orig_evgl_api_glWaitSyncAPPLE(thread_param->sync,
-                                 thread_param->flags,
-                                 thread_param->timeout);
+   orig_evgl_api_glWaitSyncAPPLE(thread_data->sync,
+                                 thread_data->flags,
+                                 thread_data->timeout);
 
 }
 
@@ -21194,22 +21198,22 @@ glWaitSyncAPPLE_evgl_api_thread_cmd(GLsync sync, GLbitfield flags, EvasGLuint64
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glWaitSyncAPPLE thread_param_local;
-   EVGL_API_Thread_Command_glWaitSyncAPPLE *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glWaitSyncAPPLE thread_data_local;
+   EVGL_API_Thread_Command_glWaitSyncAPPLE *thread_data = &thread_data_local;
 
-   thread_param->sync = sync;
-   thread_param->flags = flags;
-   thread_param->timeout = timeout;
+   thread_data->sync = sync;
+   thread_data->flags = flags;
+   thread_data->timeout = timeout;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glWaitSyncAPPLE,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGetInteger64vAPPLE(GLenum pname, EvasGLint64 *params);
+ * void
+ * glGetInteger64vAPPLE(GLenum pname, EvasGLint64 *params);
  */
 
 typedef struct
@@ -21224,11 +21228,11 @@ void (*orig_evgl_api_glGetInteger64vAPPLE)(GLenum pname, EvasGLint64 *params);
 static void
 _evgl_api_thread_glGetInteger64vAPPLE(void *data)
 {
-   EVGL_API_Thread_Command_glGetInteger64vAPPLE *thread_param =
+   EVGL_API_Thread_Command_glGetInteger64vAPPLE *thread_data =
       (EVGL_API_Thread_Command_glGetInteger64vAPPLE *)data;
 
-   orig_evgl_api_glGetInteger64vAPPLE(thread_param->pname,
-                                      thread_param->params);
+   orig_evgl_api_glGetInteger64vAPPLE(thread_data->pname,
+                                      thread_data->params);
 
 }
 
@@ -21243,21 +21247,21 @@ glGetInteger64vAPPLE_evgl_api_thread_cmd(GLenum pname, EvasGLint64 *params)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGetInteger64vAPPLE thread_param_local;
-   EVGL_API_Thread_Command_glGetInteger64vAPPLE *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGetInteger64vAPPLE thread_data_local;
+   EVGL_API_Thread_Command_glGetInteger64vAPPLE *thread_data = &thread_data_local;
 
-   thread_param->pname = pname;
-   thread_param->params = params;
+   thread_data->pname = pname;
+   thread_data->params = params;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGetInteger64vAPPLE,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGetSyncivAPPLE(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *values);
+ * void
+ * glGetSyncivAPPLE(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *values);
  */
 
 typedef struct
@@ -21275,14 +21279,14 @@ void (*orig_evgl_api_glGetSyncivAPPLE)(GLsync sync, GLenum pname, GLsizei bufSiz
 static void
 _evgl_api_thread_glGetSyncivAPPLE(void *data)
 {
-   EVGL_API_Thread_Command_glGetSyncivAPPLE *thread_param =
+   EVGL_API_Thread_Command_glGetSyncivAPPLE *thread_data =
       (EVGL_API_Thread_Command_glGetSyncivAPPLE *)data;
 
-   orig_evgl_api_glGetSyncivAPPLE(thread_param->sync,
-                                  thread_param->pname,
-                                  thread_param->bufSize,
-                                  thread_param->length,
-                                  thread_param->values);
+   orig_evgl_api_glGetSyncivAPPLE(thread_data->sync,
+                                  thread_data->pname,
+                                  thread_data->bufSize,
+                                  thread_data->length,
+                                  thread_data->values);
 
 }
 
@@ -21297,24 +21301,24 @@ glGetSyncivAPPLE_evgl_api_thread_cmd(GLsync sync, GLenum pname, GLsizei bufSize,
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGetSyncivAPPLE thread_param_local;
-   EVGL_API_Thread_Command_glGetSyncivAPPLE *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGetSyncivAPPLE thread_data_local;
+   EVGL_API_Thread_Command_glGetSyncivAPPLE *thread_data = &thread_data_local;
 
-   thread_param->sync = sync;
-   thread_param->pname = pname;
-   thread_param->bufSize = bufSize;
-   thread_param->length = length;
-   thread_param->values = values;
+   thread_data->sync = sync;
+   thread_data->pname = pname;
+   thread_data->bufSize = bufSize;
+   thread_data->length = length;
+   thread_data->values = values;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGetSyncivAPPLE,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void *
-   glMapBufferRangeEXT(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access);
+ * void *
+ * glMapBufferRangeEXT(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access);
  */
 
 typedef struct
@@ -21332,13 +21336,13 @@ void * (*orig_evgl_api_glMapBufferRangeEXT)(GLenum target, GLintptr offset, GLsi
 static void
 _evgl_api_thread_glMapBufferRangeEXT(void *data)
 {
-   EVGL_API_Thread_Command_glMapBufferRangeEXT *thread_param =
+   EVGL_API_Thread_Command_glMapBufferRangeEXT *thread_data =
       (EVGL_API_Thread_Command_glMapBufferRangeEXT *)data;
 
-   thread_param->return_value = orig_evgl_api_glMapBufferRangeEXT(thread_param->target,
-                                                                  thread_param->offset,
-                                                                  thread_param->length,
-                                                                  thread_param->access);
+   thread_data->return_value = orig_evgl_api_glMapBufferRangeEXT(thread_data->target,
+                                                                 thread_data->offset,
+                                                                 thread_data->length,
+                                                                 thread_data->access);
 
 }
 
@@ -21352,25 +21356,25 @@ glMapBufferRangeEXT_evgl_api_thread_cmd(GLenum target, GLintptr offset, GLsizeip
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glMapBufferRangeEXT thread_param_local;
-   EVGL_API_Thread_Command_glMapBufferRangeEXT *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glMapBufferRangeEXT thread_data_local;
+   EVGL_API_Thread_Command_glMapBufferRangeEXT *thread_data = &thread_data_local;
 
-   thread_param->target = target;
-   thread_param->offset = offset;
-   thread_param->length = length;
-   thread_param->access = access;
+   thread_data->target = target;
+   thread_data->offset = offset;
+   thread_data->length = length;
+   thread_data->access = access;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glMapBufferRangeEXT,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
-   void
-   glFlushMappedBufferRangeEXT(GLenum target, GLintptr offset, GLsizeiptr length);
+ * void
+ * glFlushMappedBufferRangeEXT(GLenum target, GLintptr offset, GLsizeiptr length);
  */
 
 typedef struct
@@ -21386,12 +21390,12 @@ void (*orig_evgl_api_glFlushMappedBufferRangeEXT)(GLenum target, GLintptr offset
 static void
 _evgl_api_thread_glFlushMappedBufferRangeEXT(void *data)
 {
-   EVGL_API_Thread_Command_glFlushMappedBufferRangeEXT *thread_param =
+   EVGL_API_Thread_Command_glFlushMappedBufferRangeEXT *thread_data =
       (EVGL_API_Thread_Command_glFlushMappedBufferRangeEXT *)data;
 
-   orig_evgl_api_glFlushMappedBufferRangeEXT(thread_param->target,
-                                             thread_param->offset,
-                                             thread_param->length);
+   orig_evgl_api_glFlushMappedBufferRangeEXT(thread_data->target,
+                                             thread_data->offset,
+                                             thread_data->length);
 
 }
 
@@ -21406,22 +21410,22 @@ glFlushMappedBufferRangeEXT_evgl_api_thread_cmd(GLenum target, GLintptr offset,
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glFlushMappedBufferRangeEXT thread_param_local;
-   EVGL_API_Thread_Command_glFlushMappedBufferRangeEXT *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glFlushMappedBufferRangeEXT thread_data_local;
+   EVGL_API_Thread_Command_glFlushMappedBufferRangeEXT *thread_data = &thread_data_local;
 
-   thread_param->target = target;
-   thread_param->offset = offset;
-   thread_param->length = length;
+   thread_data->target = target;
+   thread_data->offset = offset;
+   thread_data->length = length;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glFlushMappedBufferRangeEXT,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glRenderbufferStorageMultisampleEXT(GLenum a, GLsizei b, GLenum c, GLsizei d, GLsizei e);
+ * void
+ * glRenderbufferStorageMultisampleEXT(GLenum a, GLsizei b, GLenum c, GLsizei d, GLsizei e);
  */
 
 typedef struct
@@ -21439,14 +21443,14 @@ void (*orig_evgl_api_glRenderbufferStorageMultisampleEXT)(GLenum a, GLsizei b, G
 static void
 _evgl_api_thread_glRenderbufferStorageMultisampleEXT(void *data)
 {
-   EVGL_API_Thread_Command_glRenderbufferStorageMultisampleEXT *thread_param =
+   EVGL_API_Thread_Command_glRenderbufferStorageMultisampleEXT *thread_data =
       (EVGL_API_Thread_Command_glRenderbufferStorageMultisampleEXT *)data;
 
-   orig_evgl_api_glRenderbufferStorageMultisampleEXT(thread_param->a,
-                                                     thread_param->b,
-                                                     thread_param->c,
-                                                     thread_param->d,
-                                                     thread_param->e);
+   orig_evgl_api_glRenderbufferStorageMultisampleEXT(thread_data->a,
+                                                     thread_data->b,
+                                                     thread_data->c,
+                                                     thread_data->d,
+                                                     thread_data->e);
 
 }
 
@@ -21461,24 +21465,24 @@ glRenderbufferStorageMultisampleEXT_evgl_api_thread_cmd(GLenum a, GLsizei b, GLe
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glRenderbufferStorageMultisampleEXT thread_param_local;
-   EVGL_API_Thread_Command_glRenderbufferStorageMultisampleEXT *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glRenderbufferStorageMultisampleEXT thread_data_local;
+   EVGL_API_Thread_Command_glRenderbufferStorageMultisampleEXT *thread_data = &thread_data_local;
 
-   thread_param->a = a;
-   thread_param->b = b;
-   thread_param->c = c;
-   thread_param->d = d;
-   thread_param->e = e;
+   thread_data->a = a;
+   thread_data->b = b;
+   thread_data->c = c;
+   thread_data->d = d;
+   thread_data->e = e;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glRenderbufferStorageMultisampleEXT,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glFramebufferTexture2DMultisample(GLenum a, GLenum b, GLenum c, GLuint d, GLint e, GLsizei f);
+ * void
+ * glFramebufferTexture2DMultisample(GLenum a, GLenum b, GLenum c, GLuint d, GLint e, GLsizei f);
  */
 
 typedef struct
@@ -21498,18 +21502,18 @@ void (*orig_evgl_api_glFramebufferTexture2DMultisample)(GLenum a, GLenum b, GLen
 static void
 _evgl_api_thread_glFramebufferTexture2DMultisample(void *data)
 {
-   EVGL_API_Thread_Command_glFramebufferTexture2DMultisample *thread_param =
+   EVGL_API_Thread_Command_glFramebufferTexture2DMultisample *thread_data =
       (EVGL_API_Thread_Command_glFramebufferTexture2DMultisample *)data;
 
-   orig_evgl_api_glFramebufferTexture2DMultisample(thread_param->a,
-                                                   thread_param->b,
-                                                   thread_param->c,
-                                                   thread_param->d,
-                                                   thread_param->e,
-                                                   thread_param->f);
+   orig_evgl_api_glFramebufferTexture2DMultisample(thread_data->a,
+                                                   thread_data->b,
+                                                   thread_data->c,
+                                                   thread_data->d,
+                                                   thread_data->e,
+                                                   thread_data->f);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -21523,41 +21527,41 @@ glFramebufferTexture2DMultisample_evgl_api_thread_cmd(GLenum a, GLenum b, GLenum
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glFramebufferTexture2DMultisample thread_param_local;
-   EVGL_API_Thread_Command_glFramebufferTexture2DMultisample *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glFramebufferTexture2DMultisample thread_data_local;
+   EVGL_API_Thread_Command_glFramebufferTexture2DMultisample *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_API_Thread_Command_glFramebufferTexture2DMultisample *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_API_Thread_Command_glFramebufferTexture2DMultisample));
-        if (thread_param_new)
+        EVGL_API_Thread_Command_glFramebufferTexture2DMultisample *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_API_Thread_Command_glFramebufferTexture2DMultisample));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->a = a;
-   thread_param->b = b;
-   thread_param->c = c;
-   thread_param->d = d;
-   thread_param->e = e;
-   thread_param->f = f;
+   thread_data->a = a;
+   thread_data->b = b;
+   thread_data->c = c;
+   thread_data->d = d;
+   thread_data->e = e;
+   thread_data->f = f;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glFramebufferTexture2DMultisample,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glFramebufferTexture2DMultisampleEXT(GLenum a, GLenum b, GLenum c, GLuint d, GLint e, GLsizei f);
+ * void
+ * glFramebufferTexture2DMultisampleEXT(GLenum a, GLenum b, GLenum c, GLuint d, GLint e, GLsizei f);
  */
 
 typedef struct
@@ -21577,18 +21581,18 @@ void (*orig_evgl_api_glFramebufferTexture2DMultisampleEXT)(GLenum a, GLenum b, G
 static void
 _evgl_api_thread_glFramebufferTexture2DMultisampleEXT(void *data)
 {
-   EVGL_API_Thread_Command_glFramebufferTexture2DMultisampleEXT *thread_param =
+   EVGL_API_Thread_Command_glFramebufferTexture2DMultisampleEXT *thread_data =
       (EVGL_API_Thread_Command_glFramebufferTexture2DMultisampleEXT *)data;
 
-   orig_evgl_api_glFramebufferTexture2DMultisampleEXT(thread_param->a,
-                                                      thread_param->b,
-                                                      thread_param->c,
-                                                      thread_param->d,
-                                                      thread_param->e,
-                                                      thread_param->f);
+   orig_evgl_api_glFramebufferTexture2DMultisampleEXT(thread_data->a,
+                                                      thread_data->b,
+                                                      thread_data->c,
+                                                      thread_data->d,
+                                                      thread_data->e,
+                                                      thread_data->f);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -21602,41 +21606,41 @@ glFramebufferTexture2DMultisampleEXT_evgl_api_thread_cmd(GLenum a, GLenum b, GLe
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glFramebufferTexture2DMultisampleEXT thread_param_local;
-   EVGL_API_Thread_Command_glFramebufferTexture2DMultisampleEXT *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glFramebufferTexture2DMultisampleEXT thread_data_local;
+   EVGL_API_Thread_Command_glFramebufferTexture2DMultisampleEXT *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_API_Thread_Command_glFramebufferTexture2DMultisampleEXT *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_API_Thread_Command_glFramebufferTexture2DMultisampleEXT));
-        if (thread_param_new)
+        EVGL_API_Thread_Command_glFramebufferTexture2DMultisampleEXT *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_API_Thread_Command_glFramebufferTexture2DMultisampleEXT));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->a = a;
-   thread_param->b = b;
-   thread_param->c = c;
-   thread_param->d = d;
-   thread_param->e = e;
-   thread_param->f = f;
+   thread_data->a = a;
+   thread_data->b = b;
+   thread_data->c = c;
+   thread_data->d = d;
+   thread_data->e = e;
+   thread_data->f = f;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glFramebufferTexture2DMultisampleEXT,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   GLenum
-   glGetGraphicsResetStatus(void);
+ * GLenum
+ * glGetGraphicsResetStatus(void);
  */
 
 typedef struct
@@ -21650,10 +21654,10 @@ GLenum (*orig_evgl_api_glGetGraphicsResetStatus)(void);
 static void
 _evgl_api_thread_glGetGraphicsResetStatus(void *data)
 {
-   EVGL_API_Thread_Command_glGetGraphicsResetStatus *thread_param =
+   EVGL_API_Thread_Command_glGetGraphicsResetStatus *thread_data =
       (EVGL_API_Thread_Command_glGetGraphicsResetStatus *)data;
 
-   thread_param->return_value = orig_evgl_api_glGetGraphicsResetStatus();
+   thread_data->return_value = orig_evgl_api_glGetGraphicsResetStatus();
 
 }
 
@@ -21667,21 +21671,21 @@ glGetGraphicsResetStatus_evgl_api_thread_cmd(void)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGetGraphicsResetStatus thread_param_local;
-   EVGL_API_Thread_Command_glGetGraphicsResetStatus *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGetGraphicsResetStatus thread_data_local;
+   EVGL_API_Thread_Command_glGetGraphicsResetStatus *thread_data = &thread_data_local;
 
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGetGraphicsResetStatus,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
-   GLenum
-   glGetGraphicsResetStatusEXT(void);
+ * GLenum
+ * glGetGraphicsResetStatusEXT(void);
  */
 
 typedef struct
@@ -21695,10 +21699,10 @@ GLenum (*orig_evgl_api_glGetGraphicsResetStatusEXT)(void);
 static void
 _evgl_api_thread_glGetGraphicsResetStatusEXT(void *data)
 {
-   EVGL_API_Thread_Command_glGetGraphicsResetStatusEXT *thread_param =
+   EVGL_API_Thread_Command_glGetGraphicsResetStatusEXT *thread_data =
       (EVGL_API_Thread_Command_glGetGraphicsResetStatusEXT *)data;
 
-   thread_param->return_value = orig_evgl_api_glGetGraphicsResetStatusEXT();
+   thread_data->return_value = orig_evgl_api_glGetGraphicsResetStatusEXT();
 
 }
 
@@ -21712,21 +21716,21 @@ glGetGraphicsResetStatusEXT_evgl_api_thread_cmd(void)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGetGraphicsResetStatusEXT thread_param_local;
-   EVGL_API_Thread_Command_glGetGraphicsResetStatusEXT *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGetGraphicsResetStatusEXT thread_data_local;
+   EVGL_API_Thread_Command_glGetGraphicsResetStatusEXT *thread_data = &thread_data_local;
 
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGetGraphicsResetStatusEXT,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
-   void
-   glReadnPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLsizei bufSize, void *data);
+ * void
+ * glReadnPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLsizei bufSize, void *data);
  */
 
 typedef struct
@@ -21747,17 +21751,17 @@ void (*orig_evgl_api_glReadnPixels)(GLint x, GLint y, GLsizei width, GLsizei hei
 static void
 _evgl_api_thread_glReadnPixels(void *data)
 {
-   EVGL_API_Thread_Command_glReadnPixels *thread_param =
+   EVGL_API_Thread_Command_glReadnPixels *thread_data =
       (EVGL_API_Thread_Command_glReadnPixels *)data;
 
-   orig_evgl_api_glReadnPixels(thread_param->x,
-                               thread_param->y,
-                               thread_param->width,
-                               thread_param->height,
-                               thread_param->format,
-                               thread_param->type,
-                               thread_param->bufSize,
-                               thread_param->data);
+   orig_evgl_api_glReadnPixels(thread_data->x,
+                               thread_data->y,
+                               thread_data->width,
+                               thread_data->height,
+                               thread_data->format,
+                               thread_data->type,
+                               thread_data->bufSize,
+                               thread_data->data);
 
 }
 
@@ -21772,27 +21776,27 @@ glReadnPixels_evgl_api_thread_cmd(GLint x, GLint y, GLsizei width, GLsizei heigh
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glReadnPixels thread_param_local;
-   EVGL_API_Thread_Command_glReadnPixels *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glReadnPixels thread_data_local;
+   EVGL_API_Thread_Command_glReadnPixels *thread_data = &thread_data_local;
 
-   thread_param->x = x;
-   thread_param->y = y;
-   thread_param->width = width;
-   thread_param->height = height;
-   thread_param->format = format;
-   thread_param->type = type;
-   thread_param->bufSize = bufSize;
-   thread_param->data = data;
+   thread_data->x = x;
+   thread_data->y = y;
+   thread_data->width = width;
+   thread_data->height = height;
+   thread_data->format = format;
+   thread_data->type = type;
+   thread_data->bufSize = bufSize;
+   thread_data->data = data;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glReadnPixels,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glReadnPixelsEXT(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLsizei bufSize, void *data);
+ * void
+ * glReadnPixelsEXT(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLsizei bufSize, void *data);
  */
 
 typedef struct
@@ -21813,17 +21817,17 @@ void (*orig_evgl_api_glReadnPixelsEXT)(GLint x, GLint y, GLsizei width, GLsizei
 static void
 _evgl_api_thread_glReadnPixelsEXT(void *data)
 {
-   EVGL_API_Thread_Command_glReadnPixelsEXT *thread_param =
+   EVGL_API_Thread_Command_glReadnPixelsEXT *thread_data =
       (EVGL_API_Thread_Command_glReadnPixelsEXT *)data;
 
-   orig_evgl_api_glReadnPixelsEXT(thread_param->x,
-                                  thread_param->y,
-                                  thread_param->width,
-                                  thread_param->height,
-                                  thread_param->format,
-                                  thread_param->type,
-                                  thread_param->bufSize,
-                                  thread_param->data);
+   orig_evgl_api_glReadnPixelsEXT(thread_data->x,
+                                  thread_data->y,
+                                  thread_data->width,
+                                  thread_data->height,
+                                  thread_data->format,
+                                  thread_data->type,
+                                  thread_data->bufSize,
+                                  thread_data->data);
 
 }
 
@@ -21838,27 +21842,27 @@ glReadnPixelsEXT_evgl_api_thread_cmd(GLint x, GLint y, GLsizei width, GLsizei he
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glReadnPixelsEXT thread_param_local;
-   EVGL_API_Thread_Command_glReadnPixelsEXT *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glReadnPixelsEXT thread_data_local;
+   EVGL_API_Thread_Command_glReadnPixelsEXT *thread_data = &thread_data_local;
 
-   thread_param->x = x;
-   thread_param->y = y;
-   thread_param->width = width;
-   thread_param->height = height;
-   thread_param->format = format;
-   thread_param->type = type;
-   thread_param->bufSize = bufSize;
-   thread_param->data = data;
+   thread_data->x = x;
+   thread_data->y = y;
+   thread_data->width = width;
+   thread_data->height = height;
+   thread_data->format = format;
+   thread_data->type = type;
+   thread_data->bufSize = bufSize;
+   thread_data->data = data;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glReadnPixelsEXT,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGetnUniformfv(GLuint program, GLint location, GLsizei bufSize, float *params);
+ * void
+ * glGetnUniformfv(GLuint program, GLint location, GLsizei bufSize, float *params);
  */
 
 typedef struct
@@ -21875,13 +21879,13 @@ void (*orig_evgl_api_glGetnUniformfv)(GLuint program, GLint location, GLsizei bu
 static void
 _evgl_api_thread_glGetnUniformfv(void *data)
 {
-   EVGL_API_Thread_Command_glGetnUniformfv *thread_param =
+   EVGL_API_Thread_Command_glGetnUniformfv *thread_data =
       (EVGL_API_Thread_Command_glGetnUniformfv *)data;
 
-   orig_evgl_api_glGetnUniformfv(thread_param->program,
-                                 thread_param->location,
-                                 thread_param->bufSize,
-                                 thread_param->params);
+   orig_evgl_api_glGetnUniformfv(thread_data->program,
+                                 thread_data->location,
+                                 thread_data->bufSize,
+                                 thread_data->params);
 
 }
 
@@ -21896,23 +21900,23 @@ glGetnUniformfv_evgl_api_thread_cmd(GLuint program, GLint location, GLsizei bufS
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGetnUniformfv thread_param_local;
-   EVGL_API_Thread_Command_glGetnUniformfv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGetnUniformfv thread_data_local;
+   EVGL_API_Thread_Command_glGetnUniformfv *thread_data = &thread_data_local;
 
-   thread_param->program = program;
-   thread_param->location = location;
-   thread_param->bufSize = bufSize;
-   thread_param->params = params;
+   thread_data->program = program;
+   thread_data->location = location;
+   thread_data->bufSize = bufSize;
+   thread_data->params = params;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGetnUniformfv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGetnUniformfvEXT(GLuint program, GLint location, GLsizei bufSize, float *params);
+ * void
+ * glGetnUniformfvEXT(GLuint program, GLint location, GLsizei bufSize, float *params);
  */
 
 typedef struct
@@ -21929,13 +21933,13 @@ void (*orig_evgl_api_glGetnUniformfvEXT)(GLuint program, GLint location, GLsizei
 static void
 _evgl_api_thread_glGetnUniformfvEXT(void *data)
 {
-   EVGL_API_Thread_Command_glGetnUniformfvEXT *thread_param =
+   EVGL_API_Thread_Command_glGetnUniformfvEXT *thread_data =
       (EVGL_API_Thread_Command_glGetnUniformfvEXT *)data;
 
-   orig_evgl_api_glGetnUniformfvEXT(thread_param->program,
-                                    thread_param->location,
-                                    thread_param->bufSize,
-                                    thread_param->params);
+   orig_evgl_api_glGetnUniformfvEXT(thread_data->program,
+                                    thread_data->location,
+                                    thread_data->bufSize,
+                                    thread_data->params);
 
 }
 
@@ -21950,23 +21954,23 @@ glGetnUniformfvEXT_evgl_api_thread_cmd(GLuint program, GLint location, GLsizei b
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGetnUniformfvEXT thread_param_local;
-   EVGL_API_Thread_Command_glGetnUniformfvEXT *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGetnUniformfvEXT thread_data_local;
+   EVGL_API_Thread_Command_glGetnUniformfvEXT *thread_data = &thread_data_local;
 
-   thread_param->program = program;
-   thread_param->location = location;
-   thread_param->bufSize = bufSize;
-   thread_param->params = params;
+   thread_data->program = program;
+   thread_data->location = location;
+   thread_data->bufSize = bufSize;
+   thread_data->params = params;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGetnUniformfvEXT,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGetnUniformiv(GLuint program, GLint location, GLsizei bufSize, GLint *params);
+ * void
+ * glGetnUniformiv(GLuint program, GLint location, GLsizei bufSize, GLint *params);
  */
 
 typedef struct
@@ -21983,13 +21987,13 @@ void (*orig_evgl_api_glGetnUniformiv)(GLuint program, GLint location, GLsizei bu
 static void
 _evgl_api_thread_glGetnUniformiv(void *data)
 {
-   EVGL_API_Thread_Command_glGetnUniformiv *thread_param =
+   EVGL_API_Thread_Command_glGetnUniformiv *thread_data =
       (EVGL_API_Thread_Command_glGetnUniformiv *)data;
 
-   orig_evgl_api_glGetnUniformiv(thread_param->program,
-                                 thread_param->location,
-                                 thread_param->bufSize,
-                                 thread_param->params);
+   orig_evgl_api_glGetnUniformiv(thread_data->program,
+                                 thread_data->location,
+                                 thread_data->bufSize,
+                                 thread_data->params);
 
 }
 
@@ -22004,23 +22008,23 @@ glGetnUniformiv_evgl_api_thread_cmd(GLuint program, GLint location, GLsizei bufS
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGetnUniformiv thread_param_local;
-   EVGL_API_Thread_Command_glGetnUniformiv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGetnUniformiv thread_data_local;
+   EVGL_API_Thread_Command_glGetnUniformiv *thread_data = &thread_data_local;
 
-   thread_param->program = program;
-   thread_param->location = location;
-   thread_param->bufSize = bufSize;
-   thread_param->params = params;
+   thread_data->program = program;
+   thread_data->location = location;
+   thread_data->bufSize = bufSize;
+   thread_data->params = params;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGetnUniformiv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGetnUniformivEXT(GLuint program, GLint location, GLsizei bufSize, GLint *params);
+ * void
+ * glGetnUniformivEXT(GLuint program, GLint location, GLsizei bufSize, GLint *params);
  */
 
 typedef struct
@@ -22037,13 +22041,13 @@ void (*orig_evgl_api_glGetnUniformivEXT)(GLuint program, GLint location, GLsizei
 static void
 _evgl_api_thread_glGetnUniformivEXT(void *data)
 {
-   EVGL_API_Thread_Command_glGetnUniformivEXT *thread_param =
+   EVGL_API_Thread_Command_glGetnUniformivEXT *thread_data =
       (EVGL_API_Thread_Command_glGetnUniformivEXT *)data;
 
-   orig_evgl_api_glGetnUniformivEXT(thread_param->program,
-                                    thread_param->location,
-                                    thread_param->bufSize,
-                                    thread_param->params);
+   orig_evgl_api_glGetnUniformivEXT(thread_data->program,
+                                    thread_data->location,
+                                    thread_data->bufSize,
+                                    thread_data->params);
 
 }
 
@@ -22058,23 +22062,23 @@ glGetnUniformivEXT_evgl_api_thread_cmd(GLuint program, GLint location, GLsizei b
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGetnUniformivEXT thread_param_local;
-   EVGL_API_Thread_Command_glGetnUniformivEXT *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGetnUniformivEXT thread_data_local;
+   EVGL_API_Thread_Command_glGetnUniformivEXT *thread_data = &thread_data_local;
 
-   thread_param->program = program;
-   thread_param->location = location;
-   thread_param->bufSize = bufSize;
-   thread_param->params = params;
+   thread_data->program = program;
+   thread_data->location = location;
+   thread_data->bufSize = bufSize;
+   thread_data->params = params;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGetnUniformivEXT,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glTexStorage1DEXT(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width);
+ * void
+ * glTexStorage1DEXT(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width);
  */
 
 typedef struct
@@ -22091,13 +22095,13 @@ void (*orig_evgl_api_glTexStorage1DEXT)(GLenum target, GLsizei levels, GLenum in
 static void
 _evgl_api_thread_glTexStorage1DEXT(void *data)
 {
-   EVGL_API_Thread_Command_glTexStorage1DEXT *thread_param =
+   EVGL_API_Thread_Command_glTexStorage1DEXT *thread_data =
       (EVGL_API_Thread_Command_glTexStorage1DEXT *)data;
 
-   orig_evgl_api_glTexStorage1DEXT(thread_param->target,
-                                   thread_param->levels,
-                                   thread_param->internalformat,
-                                   thread_param->width);
+   orig_evgl_api_glTexStorage1DEXT(thread_data->target,
+                                   thread_data->levels,
+                                   thread_data->internalformat,
+                                   thread_data->width);
 
 }
 
@@ -22112,23 +22116,23 @@ glTexStorage1DEXT_evgl_api_thread_cmd(GLenum target, GLsizei levels, GLenum inte
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glTexStorage1DEXT thread_param_local;
-   EVGL_API_Thread_Command_glTexStorage1DEXT *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glTexStorage1DEXT thread_data_local;
+   EVGL_API_Thread_Command_glTexStorage1DEXT *thread_data = &thread_data_local;
 
-   thread_param->target = target;
-   thread_param->levels = levels;
-   thread_param->internalformat = internalformat;
-   thread_param->width = width;
+   thread_data->target = target;
+   thread_data->levels = levels;
+   thread_data->internalformat = internalformat;
+   thread_data->width = width;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glTexStorage1DEXT,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glTexStorage2DEXT(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height);
+ * void
+ * glTexStorage2DEXT(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height);
  */
 
 typedef struct
@@ -22146,14 +22150,14 @@ void (*orig_evgl_api_glTexStorage2DEXT)(GLenum target, GLsizei levels, GLenum in
 static void
 _evgl_api_thread_glTexStorage2DEXT(void *data)
 {
-   EVGL_API_Thread_Command_glTexStorage2DEXT *thread_param =
+   EVGL_API_Thread_Command_glTexStorage2DEXT *thread_data =
       (EVGL_API_Thread_Command_glTexStorage2DEXT *)data;
 
-   orig_evgl_api_glTexStorage2DEXT(thread_param->target,
-                                   thread_param->levels,
-                                   thread_param->internalformat,
-                                   thread_param->width,
-                                   thread_param->height);
+   orig_evgl_api_glTexStorage2DEXT(thread_data->target,
+                                   thread_data->levels,
+                                   thread_data->internalformat,
+                                   thread_data->width,
+                                   thread_data->height);
 
 }
 
@@ -22168,24 +22172,24 @@ glTexStorage2DEXT_evgl_api_thread_cmd(GLenum target, GLsizei levels, GLenum inte
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glTexStorage2DEXT thread_param_local;
-   EVGL_API_Thread_Command_glTexStorage2DEXT *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glTexStorage2DEXT thread_data_local;
+   EVGL_API_Thread_Command_glTexStorage2DEXT *thread_data = &thread_data_local;
 
-   thread_param->target = target;
-   thread_param->levels = levels;
-   thread_param->internalformat = internalformat;
-   thread_param->width = width;
-   thread_param->height = height;
+   thread_data->target = target;
+   thread_data->levels = levels;
+   thread_data->internalformat = internalformat;
+   thread_data->width = width;
+   thread_data->height = height;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glTexStorage2DEXT,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glTexStorage3DEXT(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth);
+ * void
+ * glTexStorage3DEXT(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth);
  */
 
 typedef struct
@@ -22204,15 +22208,15 @@ void (*orig_evgl_api_glTexStorage3DEXT)(GLenum target, GLsizei levels, GLenum in
 static void
 _evgl_api_thread_glTexStorage3DEXT(void *data)
 {
-   EVGL_API_Thread_Command_glTexStorage3DEXT *thread_param =
+   EVGL_API_Thread_Command_glTexStorage3DEXT *thread_data =
       (EVGL_API_Thread_Command_glTexStorage3DEXT *)data;
 
-   orig_evgl_api_glTexStorage3DEXT(thread_param->target,
-                                   thread_param->levels,
-                                   thread_param->internalformat,
-                                   thread_param->width,
-                                   thread_param->height,
-                                   thread_param->depth);
+   orig_evgl_api_glTexStorage3DEXT(thread_data->target,
+                                   thread_data->levels,
+                                   thread_data->internalformat,
+                                   thread_data->width,
+                                   thread_data->height,
+                                   thread_data->depth);
 
 }
 
@@ -22227,25 +22231,25 @@ glTexStorage3DEXT_evgl_api_thread_cmd(GLenum target, GLsizei levels, GLenum inte
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glTexStorage3DEXT thread_param_local;
-   EVGL_API_Thread_Command_glTexStorage3DEXT *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glTexStorage3DEXT thread_data_local;
+   EVGL_API_Thread_Command_glTexStorage3DEXT *thread_data = &thread_data_local;
 
-   thread_param->target = target;
-   thread_param->levels = levels;
-   thread_param->internalformat = internalformat;
-   thread_param->width = width;
-   thread_param->height = height;
-   thread_param->depth = depth;
+   thread_data->target = target;
+   thread_data->levels = levels;
+   thread_data->internalformat = internalformat;
+   thread_data->width = width;
+   thread_data->height = height;
+   thread_data->depth = depth;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glTexStorage3DEXT,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glTextureStorage1DEXT(GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width);
+ * void
+ * glTextureStorage1DEXT(GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width);
  */
 
 typedef struct
@@ -22263,14 +22267,14 @@ void (*orig_evgl_api_glTextureStorage1DEXT)(GLuint texture, GLenum target, GLsiz
 static void
 _evgl_api_thread_glTextureStorage1DEXT(void *data)
 {
-   EVGL_API_Thread_Command_glTextureStorage1DEXT *thread_param =
+   EVGL_API_Thread_Command_glTextureStorage1DEXT *thread_data =
       (EVGL_API_Thread_Command_glTextureStorage1DEXT *)data;
 
-   orig_evgl_api_glTextureStorage1DEXT(thread_param->texture,
-                                       thread_param->target,
-                                       thread_param->levels,
-                                       thread_param->internalformat,
-                                       thread_param->width);
+   orig_evgl_api_glTextureStorage1DEXT(thread_data->texture,
+                                       thread_data->target,
+                                       thread_data->levels,
+                                       thread_data->internalformat,
+                                       thread_data->width);
 
 }
 
@@ -22285,24 +22289,24 @@ glTextureStorage1DEXT_evgl_api_thread_cmd(GLuint texture, GLenum target, GLsizei
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glTextureStorage1DEXT thread_param_local;
-   EVGL_API_Thread_Command_glTextureStorage1DEXT *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glTextureStorage1DEXT thread_data_local;
+   EVGL_API_Thread_Command_glTextureStorage1DEXT *thread_data = &thread_data_local;
 
-   thread_param->texture = texture;
-   thread_param->target = target;
-   thread_param->levels = levels;
-   thread_param->internalformat = internalformat;
-   thread_param->width = width;
+   thread_data->texture = texture;
+   thread_data->target = target;
+   thread_data->levels = levels;
+   thread_data->internalformat = internalformat;
+   thread_data->width = width;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glTextureStorage1DEXT,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glTextureStorage2DEXT(GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height);
+ * void
+ * glTextureStorage2DEXT(GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height);
  */
 
 typedef struct
@@ -22321,15 +22325,15 @@ void (*orig_evgl_api_glTextureStorage2DEXT)(GLuint texture, GLenum target, GLsiz
 static void
 _evgl_api_thread_glTextureStorage2DEXT(void *data)
 {
-   EVGL_API_Thread_Command_glTextureStorage2DEXT *thread_param =
+   EVGL_API_Thread_Command_glTextureStorage2DEXT *thread_data =
       (EVGL_API_Thread_Command_glTextureStorage2DEXT *)data;
 
-   orig_evgl_api_glTextureStorage2DEXT(thread_param->texture,
-                                       thread_param->target,
-                                       thread_param->levels,
-                                       thread_param->internalformat,
-                                       thread_param->width,
-                                       thread_param->height);
+   orig_evgl_api_glTextureStorage2DEXT(thread_data->texture,
+                                       thread_data->target,
+                                       thread_data->levels,
+                                       thread_data->internalformat,
+                                       thread_data->width,
+                                       thread_data->height);
 
 }
 
@@ -22344,25 +22348,25 @@ glTextureStorage2DEXT_evgl_api_thread_cmd(GLuint texture, GLenum target, GLsizei
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glTextureStorage2DEXT thread_param_local;
-   EVGL_API_Thread_Command_glTextureStorage2DEXT *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glTextureStorage2DEXT thread_data_local;
+   EVGL_API_Thread_Command_glTextureStorage2DEXT *thread_data = &thread_data_local;
 
-   thread_param->texture = texture;
-   thread_param->target = target;
-   thread_param->levels = levels;
-   thread_param->internalformat = internalformat;
-   thread_param->width = width;
-   thread_param->height = height;
+   thread_data->texture = texture;
+   thread_data->target = target;
+   thread_data->levels = levels;
+   thread_data->internalformat = internalformat;
+   thread_data->width = width;
+   thread_data->height = height;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glTextureStorage2DEXT,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glTextureStorage3DEXT(GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth);
+ * void
+ * glTextureStorage3DEXT(GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth);
  */
 
 typedef struct
@@ -22382,16 +22386,16 @@ void (*orig_evgl_api_glTextureStorage3DEXT)(GLuint texture, GLenum target, GLsiz
 static void
 _evgl_api_thread_glTextureStorage3DEXT(void *data)
 {
-   EVGL_API_Thread_Command_glTextureStorage3DEXT *thread_param =
+   EVGL_API_Thread_Command_glTextureStorage3DEXT *thread_data =
       (EVGL_API_Thread_Command_glTextureStorage3DEXT *)data;
 
-   orig_evgl_api_glTextureStorage3DEXT(thread_param->texture,
-                                       thread_param->target,
-                                       thread_param->levels,
-                                       thread_param->internalformat,
-                                       thread_param->width,
-                                       thread_param->height,
-                                       thread_param->depth);
+   orig_evgl_api_glTextureStorage3DEXT(thread_data->texture,
+                                       thread_data->target,
+                                       thread_data->levels,
+                                       thread_data->internalformat,
+                                       thread_data->width,
+                                       thread_data->height,
+                                       thread_data->depth);
 
 }
 
@@ -22406,26 +22410,26 @@ glTextureStorage3DEXT_evgl_api_thread_cmd(GLuint texture, GLenum target, GLsizei
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glTextureStorage3DEXT thread_param_local;
-   EVGL_API_Thread_Command_glTextureStorage3DEXT *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glTextureStorage3DEXT thread_data_local;
+   EVGL_API_Thread_Command_glTextureStorage3DEXT *thread_data = &thread_data_local;
 
-   thread_param->texture = texture;
-   thread_param->target = target;
-   thread_param->levels = levels;
-   thread_param->internalformat = internalformat;
-   thread_param->width = width;
-   thread_param->height = height;
-   thread_param->depth = depth;
+   thread_data->texture = texture;
+   thread_data->target = target;
+   thread_data->levels = levels;
+   thread_data->internalformat = internalformat;
+   thread_data->width = width;
+   thread_data->height = height;
+   thread_data->depth = depth;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glTextureStorage3DEXT,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glClipPlanefIMG(GLenum a, const GLfloat * b);
+ * void
+ * glClipPlanefIMG(GLenum a, const GLfloat * b);
  */
 
 typedef struct
@@ -22440,11 +22444,11 @@ void (*orig_evgl_api_glClipPlanefIMG)(GLenum a, const GLfloat * b);
 static void
 _evgl_api_thread_glClipPlanefIMG(void *data)
 {
-   EVGL_API_Thread_Command_glClipPlanefIMG *thread_param =
+   EVGL_API_Thread_Command_glClipPlanefIMG *thread_data =
       (EVGL_API_Thread_Command_glClipPlanefIMG *)data;
 
-   orig_evgl_api_glClipPlanefIMG(thread_param->a,
-                                 thread_param->b);
+   orig_evgl_api_glClipPlanefIMG(thread_data->a,
+                                 thread_data->b);
 
 }
 
@@ -22459,21 +22463,21 @@ glClipPlanefIMG_evgl_api_thread_cmd(GLenum a, const GLfloat * b)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glClipPlanefIMG thread_param_local;
-   EVGL_API_Thread_Command_glClipPlanefIMG *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glClipPlanefIMG thread_data_local;
+   EVGL_API_Thread_Command_glClipPlanefIMG *thread_data = &thread_data_local;
 
-   thread_param->a = a;
-   thread_param->b = b;
+   thread_data->a = a;
+   thread_data->b = b;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glClipPlanefIMG,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glClipPlanexIMG(GLenum a, const GLfixed * b);
+ * void
+ * glClipPlanexIMG(GLenum a, const GLfixed * b);
  */
 
 typedef struct
@@ -22488,11 +22492,11 @@ void (*orig_evgl_api_glClipPlanexIMG)(GLenum a, const GLfixed * b);
 static void
 _evgl_api_thread_glClipPlanexIMG(void *data)
 {
-   EVGL_API_Thread_Command_glClipPlanexIMG *thread_param =
+   EVGL_API_Thread_Command_glClipPlanexIMG *thread_data =
       (EVGL_API_Thread_Command_glClipPlanexIMG *)data;
 
-   orig_evgl_api_glClipPlanexIMG(thread_param->a,
-                                 thread_param->b);
+   orig_evgl_api_glClipPlanexIMG(thread_data->a,
+                                 thread_data->b);
 
 }
 
@@ -22507,21 +22511,21 @@ glClipPlanexIMG_evgl_api_thread_cmd(GLenum a, const GLfixed * b)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glClipPlanexIMG thread_param_local;
-   EVGL_API_Thread_Command_glClipPlanexIMG *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glClipPlanexIMG thread_data_local;
+   EVGL_API_Thread_Command_glClipPlanexIMG *thread_data = &thread_data_local;
 
-   thread_param->a = a;
-   thread_param->b = b;
+   thread_data->a = a;
+   thread_data->b = b;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glClipPlanexIMG,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glRenderbufferStorageMultisampleIMG(GLenum a, GLsizei b, GLenum c, GLsizei d, GLsizei e);
+ * void
+ * glRenderbufferStorageMultisampleIMG(GLenum a, GLsizei b, GLenum c, GLsizei d, GLsizei e);
  */
 
 typedef struct
@@ -22540,17 +22544,17 @@ void (*orig_evgl_api_glRenderbufferStorageMultisampleIMG)(GLenum a, GLsizei b, G
 static void
 _evgl_api_thread_glRenderbufferStorageMultisampleIMG(void *data)
 {
-   EVGL_API_Thread_Command_glRenderbufferStorageMultisampleIMG *thread_param =
+   EVGL_API_Thread_Command_glRenderbufferStorageMultisampleIMG *thread_data =
       (EVGL_API_Thread_Command_glRenderbufferStorageMultisampleIMG *)data;
 
-   orig_evgl_api_glRenderbufferStorageMultisampleIMG(thread_param->a,
-                                                     thread_param->b,
-                                                     thread_param->c,
-                                                     thread_param->d,
-                                                     thread_param->e);
+   orig_evgl_api_glRenderbufferStorageMultisampleIMG(thread_data->a,
+                                                     thread_data->b,
+                                                     thread_data->c,
+                                                     thread_data->d,
+                                                     thread_data->e);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -22564,40 +22568,40 @@ glRenderbufferStorageMultisampleIMG_evgl_api_thread_cmd(GLenum a, GLsizei b, GLe
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glRenderbufferStorageMultisampleIMG thread_param_local;
-   EVGL_API_Thread_Command_glRenderbufferStorageMultisampleIMG *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glRenderbufferStorageMultisampleIMG thread_data_local;
+   EVGL_API_Thread_Command_glRenderbufferStorageMultisampleIMG *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_API_Thread_Command_glRenderbufferStorageMultisampleIMG *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_API_Thread_Command_glRenderbufferStorageMultisampleIMG));
-        if (thread_param_new)
+        EVGL_API_Thread_Command_glRenderbufferStorageMultisampleIMG *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_API_Thread_Command_glRenderbufferStorageMultisampleIMG));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->a = a;
-   thread_param->b = b;
-   thread_param->c = c;
-   thread_param->d = d;
-   thread_param->e = e;
+   thread_data->a = a;
+   thread_data->b = b;
+   thread_data->c = c;
+   thread_data->d = d;
+   thread_data->e = e;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glRenderbufferStorageMultisampleIMG,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glFramebufferTexture2DMultisampleIMG(GLenum a, GLenum b, GLenum c, GLuint d, GLint e, GLsizei f);
+ * void
+ * glFramebufferTexture2DMultisampleIMG(GLenum a, GLenum b, GLenum c, GLuint d, GLint e, GLsizei f);
  */
 
 typedef struct
@@ -22617,18 +22621,18 @@ void (*orig_evgl_api_glFramebufferTexture2DMultisampleIMG)(GLenum a, GLenum b, G
 static void
 _evgl_api_thread_glFramebufferTexture2DMultisampleIMG(void *data)
 {
-   EVGL_API_Thread_Command_glFramebufferTexture2DMultisampleIMG *thread_param =
+   EVGL_API_Thread_Command_glFramebufferTexture2DMultisampleIMG *thread_data =
       (EVGL_API_Thread_Command_glFramebufferTexture2DMultisampleIMG *)data;
 
-   orig_evgl_api_glFramebufferTexture2DMultisampleIMG(thread_param->a,
-                                                      thread_param->b,
-                                                      thread_param->c,
-                                                      thread_param->d,
-                                                      thread_param->e,
-                                                      thread_param->f);
+   orig_evgl_api_glFramebufferTexture2DMultisampleIMG(thread_data->a,
+                                                      thread_data->b,
+                                                      thread_data->c,
+                                                      thread_data->d,
+                                                      thread_data->e,
+                                                      thread_data->f);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -22642,41 +22646,41 @@ glFramebufferTexture2DMultisampleIMG_evgl_api_thread_cmd(GLenum a, GLenum b, GLe
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glFramebufferTexture2DMultisampleIMG thread_param_local;
-   EVGL_API_Thread_Command_glFramebufferTexture2DMultisampleIMG *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glFramebufferTexture2DMultisampleIMG thread_data_local;
+   EVGL_API_Thread_Command_glFramebufferTexture2DMultisampleIMG *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_API_Thread_Command_glFramebufferTexture2DMultisampleIMG *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_API_Thread_Command_glFramebufferTexture2DMultisampleIMG));
-        if (thread_param_new)
+        EVGL_API_Thread_Command_glFramebufferTexture2DMultisampleIMG *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_API_Thread_Command_glFramebufferTexture2DMultisampleIMG));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->a = a;
-   thread_param->b = b;
-   thread_param->c = c;
-   thread_param->d = d;
-   thread_param->e = e;
-   thread_param->f = f;
+   thread_data->a = a;
+   thread_data->b = b;
+   thread_data->c = c;
+   thread_data->d = d;
+   thread_data->e = e;
+   thread_data->f = f;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glFramebufferTexture2DMultisampleIMG,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glStartTilingQCOM(GLuint x, GLuint y, GLuint width, GLuint height, GLbitfield preserveMask);
+ * void
+ * glStartTilingQCOM(GLuint x, GLuint y, GLuint width, GLuint height, GLbitfield preserveMask);
  */
 
 typedef struct
@@ -22695,17 +22699,17 @@ void (*orig_evgl_api_glStartTilingQCOM)(GLuint x, GLuint y, GLuint width, GLuint
 static void
 _evgl_api_thread_glStartTilingQCOM(void *data)
 {
-   EVGL_API_Thread_Command_glStartTilingQCOM *thread_param =
+   EVGL_API_Thread_Command_glStartTilingQCOM *thread_data =
       (EVGL_API_Thread_Command_glStartTilingQCOM *)data;
 
-   orig_evgl_api_glStartTilingQCOM(thread_param->x,
-                                   thread_param->y,
-                                   thread_param->width,
-                                   thread_param->height,
-                                   thread_param->preserveMask);
+   orig_evgl_api_glStartTilingQCOM(thread_data->x,
+                                   thread_data->y,
+                                   thread_data->width,
+                                   thread_data->height,
+                                   thread_data->preserveMask);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -22719,40 +22723,40 @@ glStartTilingQCOM_evgl_api_thread_cmd(GLuint x, GLuint y, GLuint width, GLuint h
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glStartTilingQCOM thread_param_local;
-   EVGL_API_Thread_Command_glStartTilingQCOM *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glStartTilingQCOM thread_data_local;
+   EVGL_API_Thread_Command_glStartTilingQCOM *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_API_Thread_Command_glStartTilingQCOM *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_API_Thread_Command_glStartTilingQCOM));
-        if (thread_param_new)
+        EVGL_API_Thread_Command_glStartTilingQCOM *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_API_Thread_Command_glStartTilingQCOM));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->x = x;
-   thread_param->y = y;
-   thread_param->width = width;
-   thread_param->height = height;
-   thread_param->preserveMask = preserveMask;
+   thread_data->x = x;
+   thread_data->y = y;
+   thread_data->width = width;
+   thread_data->height = height;
+   thread_data->preserveMask = preserveMask;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glStartTilingQCOM,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glEndTilingQCOM(GLbitfield preserveMask);
+ * void
+ * glEndTilingQCOM(GLbitfield preserveMask);
  */
 
 typedef struct
@@ -22767,13 +22771,13 @@ void (*orig_evgl_api_glEndTilingQCOM)(GLbitfield preserveMask);
 static void
 _evgl_api_thread_glEndTilingQCOM(void *data)
 {
-   EVGL_API_Thread_Command_glEndTilingQCOM *thread_param =
+   EVGL_API_Thread_Command_glEndTilingQCOM *thread_data =
       (EVGL_API_Thread_Command_glEndTilingQCOM *)data;
 
-   orig_evgl_api_glEndTilingQCOM(thread_param->preserveMask);
+   orig_evgl_api_glEndTilingQCOM(thread_data->preserveMask);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -22787,36 +22791,36 @@ glEndTilingQCOM_evgl_api_thread_cmd(GLbitfield preserveMask)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glEndTilingQCOM thread_param_local;
-   EVGL_API_Thread_Command_glEndTilingQCOM *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glEndTilingQCOM thread_data_local;
+   EVGL_API_Thread_Command_glEndTilingQCOM *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_API_Thread_Command_glEndTilingQCOM *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_API_Thread_Command_glEndTilingQCOM));
-        if (thread_param_new)
+        EVGL_API_Thread_Command_glEndTilingQCOM *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_API_Thread_Command_glEndTilingQCOM));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->preserveMask = preserveMask;
+   thread_data->preserveMask = preserveMask;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glEndTilingQCOM,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glBeginQuery(GLenum target, GLuint id);
+ * void
+ * glBeginQuery(GLenum target, GLuint id);
  */
 
 typedef struct
@@ -22831,11 +22835,11 @@ void (*orig_evgl_api_glBeginQuery)(GLenum target, GLuint id);
 static void
 _evgl_api_thread_glBeginQuery(void *data)
 {
-   EVGL_API_Thread_Command_glBeginQuery *thread_param =
+   EVGL_API_Thread_Command_glBeginQuery *thread_data =
       (EVGL_API_Thread_Command_glBeginQuery *)data;
 
-   orig_evgl_api_glBeginQuery(thread_param->target,
-                              thread_param->id);
+   orig_evgl_api_glBeginQuery(thread_data->target,
+                              thread_data->id);
 
 }
 
@@ -22850,21 +22854,21 @@ glBeginQuery_evgl_api_thread_cmd(GLenum target, GLuint id)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glBeginQuery thread_param_local;
-   EVGL_API_Thread_Command_glBeginQuery *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glBeginQuery thread_data_local;
+   EVGL_API_Thread_Command_glBeginQuery *thread_data = &thread_data_local;
 
-   thread_param->target = target;
-   thread_param->id = id;
+   thread_data->target = target;
+   thread_data->id = id;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glBeginQuery,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glBeginTransformFeedback(GLenum primitiveMode);
+ * void
+ * glBeginTransformFeedback(GLenum primitiveMode);
  */
 
 typedef struct
@@ -22878,10 +22882,10 @@ void (*orig_evgl_api_glBeginTransformFeedback)(GLenum primitiveMode);
 static void
 _evgl_api_thread_glBeginTransformFeedback(void *data)
 {
-   EVGL_API_Thread_Command_glBeginTransformFeedback *thread_param =
+   EVGL_API_Thread_Command_glBeginTransformFeedback *thread_data =
       (EVGL_API_Thread_Command_glBeginTransformFeedback *)data;
 
-   orig_evgl_api_glBeginTransformFeedback(thread_param->primitiveMode);
+   orig_evgl_api_glBeginTransformFeedback(thread_data->primitiveMode);
 
 }
 
@@ -22896,20 +22900,20 @@ glBeginTransformFeedback_evgl_api_thread_cmd(GLenum primitiveMode)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glBeginTransformFeedback thread_param_local;
-   EVGL_API_Thread_Command_glBeginTransformFeedback *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glBeginTransformFeedback thread_data_local;
+   EVGL_API_Thread_Command_glBeginTransformFeedback *thread_data = &thread_data_local;
 
-   thread_param->primitiveMode = primitiveMode;
+   thread_data->primitiveMode = primitiveMode;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glBeginTransformFeedback,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glBindBufferBase(GLenum target, GLuint index, GLuint buffer);
+ * void
+ * glBindBufferBase(GLenum target, GLuint index, GLuint buffer);
  */
 
 typedef struct
@@ -22925,12 +22929,12 @@ void (*orig_evgl_api_glBindBufferBase)(GLenum target, GLuint index, GLuint buffe
 static void
 _evgl_api_thread_glBindBufferBase(void *data)
 {
-   EVGL_API_Thread_Command_glBindBufferBase *thread_param =
+   EVGL_API_Thread_Command_glBindBufferBase *thread_data =
       (EVGL_API_Thread_Command_glBindBufferBase *)data;
 
-   orig_evgl_api_glBindBufferBase(thread_param->target,
-                                  thread_param->index,
-                                  thread_param->buffer);
+   orig_evgl_api_glBindBufferBase(thread_data->target,
+                                  thread_data->index,
+                                  thread_data->buffer);
 
 }
 
@@ -22945,22 +22949,22 @@ glBindBufferBase_evgl_api_thread_cmd(GLenum target, GLuint index, GLuint buffer)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glBindBufferBase thread_param_local;
-   EVGL_API_Thread_Command_glBindBufferBase *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glBindBufferBase thread_data_local;
+   EVGL_API_Thread_Command_glBindBufferBase *thread_data = &thread_data_local;
 
-   thread_param->target = target;
-   thread_param->index = index;
-   thread_param->buffer = buffer;
+   thread_data->target = target;
+   thread_data->index = index;
+   thread_data->buffer = buffer;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glBindBufferBase,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glBindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size);
+ * void
+ * glBindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size);
  */
 
 typedef struct
@@ -22978,14 +22982,14 @@ void (*orig_evgl_api_glBindBufferRange)(GLenum target, GLuint index, GLuint buff
 static void
 _evgl_api_thread_glBindBufferRange(void *data)
 {
-   EVGL_API_Thread_Command_glBindBufferRange *thread_param =
+   EVGL_API_Thread_Command_glBindBufferRange *thread_data =
       (EVGL_API_Thread_Command_glBindBufferRange *)data;
 
-   orig_evgl_api_glBindBufferRange(thread_param->target,
-                                   thread_param->index,
-                                   thread_param->buffer,
-                                   thread_param->offset,
-                                   thread_param->size);
+   orig_evgl_api_glBindBufferRange(thread_data->target,
+                                   thread_data->index,
+                                   thread_data->buffer,
+                                   thread_data->offset,
+                                   thread_data->size);
 
 }
 
@@ -23000,24 +23004,24 @@ glBindBufferRange_evgl_api_thread_cmd(GLenum target, GLuint index, GLuint buffer
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glBindBufferRange thread_param_local;
-   EVGL_API_Thread_Command_glBindBufferRange *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glBindBufferRange thread_data_local;
+   EVGL_API_Thread_Command_glBindBufferRange *thread_data = &thread_data_local;
 
-   thread_param->target = target;
-   thread_param->index = index;
-   thread_param->buffer = buffer;
-   thread_param->offset = offset;
-   thread_param->size = size;
+   thread_data->target = target;
+   thread_data->index = index;
+   thread_data->buffer = buffer;
+   thread_data->offset = offset;
+   thread_data->size = size;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glBindBufferRange,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glBindSampler(GLuint unit, GLuint sampler);
+ * void
+ * glBindSampler(GLuint unit, GLuint sampler);
  */
 
 typedef struct
@@ -23032,11 +23036,11 @@ void (*orig_evgl_api_glBindSampler)(GLuint unit, GLuint sampler);
 static void
 _evgl_api_thread_glBindSampler(void *data)
 {
-   EVGL_API_Thread_Command_glBindSampler *thread_param =
+   EVGL_API_Thread_Command_glBindSampler *thread_data =
       (EVGL_API_Thread_Command_glBindSampler *)data;
 
-   orig_evgl_api_glBindSampler(thread_param->unit,
-                               thread_param->sampler);
+   orig_evgl_api_glBindSampler(thread_data->unit,
+                               thread_data->sampler);
 
 }
 
@@ -23051,21 +23055,21 @@ glBindSampler_evgl_api_thread_cmd(GLuint unit, GLuint sampler)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glBindSampler thread_param_local;
-   EVGL_API_Thread_Command_glBindSampler *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glBindSampler thread_data_local;
+   EVGL_API_Thread_Command_glBindSampler *thread_data = &thread_data_local;
 
-   thread_param->unit = unit;
-   thread_param->sampler = sampler;
+   thread_data->unit = unit;
+   thread_data->sampler = sampler;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glBindSampler,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glBindTransformFeedback(GLenum target, GLuint id);
+ * void
+ * glBindTransformFeedback(GLenum target, GLuint id);
  */
 
 typedef struct
@@ -23080,11 +23084,11 @@ void (*orig_evgl_api_glBindTransformFeedback)(GLenum target, GLuint id);
 static void
 _evgl_api_thread_glBindTransformFeedback(void *data)
 {
-   EVGL_API_Thread_Command_glBindTransformFeedback *thread_param =
+   EVGL_API_Thread_Command_glBindTransformFeedback *thread_data =
       (EVGL_API_Thread_Command_glBindTransformFeedback *)data;
 
-   orig_evgl_api_glBindTransformFeedback(thread_param->target,
-                                         thread_param->id);
+   orig_evgl_api_glBindTransformFeedback(thread_data->target,
+                                         thread_data->id);
 
 }
 
@@ -23099,21 +23103,21 @@ glBindTransformFeedback_evgl_api_thread_cmd(GLenum target, GLuint id)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glBindTransformFeedback thread_param_local;
-   EVGL_API_Thread_Command_glBindTransformFeedback *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glBindTransformFeedback thread_data_local;
+   EVGL_API_Thread_Command_glBindTransformFeedback *thread_data = &thread_data_local;
 
-   thread_param->target = target;
-   thread_param->id = id;
+   thread_data->target = target;
+   thread_data->id = id;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glBindTransformFeedback,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glBindVertexArray(GLuint array);
+ * void
+ * glBindVertexArray(GLuint array);
  */
 
 typedef struct
@@ -23127,10 +23131,10 @@ void (*orig_evgl_api_glBindVertexArray)(GLuint array);
 static void
 _evgl_api_thread_glBindVertexArray(void *data)
 {
-   EVGL_API_Thread_Command_glBindVertexArray *thread_param =
+   EVGL_API_Thread_Command_glBindVertexArray *thread_data =
       (EVGL_API_Thread_Command_glBindVertexArray *)data;
 
-   orig_evgl_api_glBindVertexArray(thread_param->array);
+   orig_evgl_api_glBindVertexArray(thread_data->array);
 
 }
 
@@ -23145,20 +23149,20 @@ glBindVertexArray_evgl_api_thread_cmd(GLuint array)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glBindVertexArray thread_param_local;
-   EVGL_API_Thread_Command_glBindVertexArray *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glBindVertexArray thread_data_local;
+   EVGL_API_Thread_Command_glBindVertexArray *thread_data = &thread_data_local;
 
-   thread_param->array = array;
+   thread_data->array = array;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glBindVertexArray,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter);
+ * void
+ * glBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter);
  */
 
 typedef struct
@@ -23181,19 +23185,19 @@ void (*orig_evgl_api_glBlitFramebuffer)(GLint srcX0, GLint srcY0, GLint srcX1, G
 static void
 _evgl_api_thread_glBlitFramebuffer(void *data)
 {
-   EVGL_API_Thread_Command_glBlitFramebuffer *thread_param =
+   EVGL_API_Thread_Command_glBlitFramebuffer *thread_data =
       (EVGL_API_Thread_Command_glBlitFramebuffer *)data;
 
-   orig_evgl_api_glBlitFramebuffer(thread_param->srcX0,
-                                   thread_param->srcY0,
-                                   thread_param->srcX1,
-                                   thread_param->srcY1,
-                                   thread_param->dstX0,
-                                   thread_param->dstY0,
-                                   thread_param->dstX1,
-                                   thread_param->dstY1,
-                                   thread_param->mask,
-                                   thread_param->filter);
+   orig_evgl_api_glBlitFramebuffer(thread_data->srcX0,
+                                   thread_data->srcY0,
+                                   thread_data->srcX1,
+                                   thread_data->srcY1,
+                                   thread_data->dstX0,
+                                   thread_data->dstY0,
+                                   thread_data->dstX1,
+                                   thread_data->dstY1,
+                                   thread_data->mask,
+                                   thread_data->filter);
 
 }
 
@@ -23208,29 +23212,29 @@ glBlitFramebuffer_evgl_api_thread_cmd(GLint srcX0, GLint srcY0, GLint srcX1, GLi
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glBlitFramebuffer thread_param_local;
-   EVGL_API_Thread_Command_glBlitFramebuffer *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glBlitFramebuffer thread_data_local;
+   EVGL_API_Thread_Command_glBlitFramebuffer *thread_data = &thread_data_local;
 
-   thread_param->srcX0 = srcX0;
-   thread_param->srcY0 = srcY0;
-   thread_param->srcX1 = srcX1;
-   thread_param->srcY1 = srcY1;
-   thread_param->dstX0 = dstX0;
-   thread_param->dstY0 = dstY0;
-   thread_param->dstX1 = dstX1;
-   thread_param->dstY1 = dstY1;
-   thread_param->mask = mask;
-   thread_param->filter = filter;
+   thread_data->srcX0 = srcX0;
+   thread_data->srcY0 = srcY0;
+   thread_data->srcX1 = srcX1;
+   thread_data->srcY1 = srcY1;
+   thread_data->dstX0 = dstX0;
+   thread_data->dstY0 = dstY0;
+   thread_data->dstX1 = dstX1;
+   thread_data->dstY1 = dstY1;
+   thread_data->mask = mask;
+   thread_data->filter = filter;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glBlitFramebuffer,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glClearBufferfi(GLenum buffer, GLint drawBuffer, GLfloat depth, GLint stencil);
+ * void
+ * glClearBufferfi(GLenum buffer, GLint drawBuffer, GLfloat depth, GLint stencil);
  */
 
 typedef struct
@@ -23247,13 +23251,13 @@ void (*orig_evgl_api_glClearBufferfi)(GLenum buffer, GLint drawBuffer, GLfloat d
 static void
 _evgl_api_thread_glClearBufferfi(void *data)
 {
-   EVGL_API_Thread_Command_glClearBufferfi *thread_param =
+   EVGL_API_Thread_Command_glClearBufferfi *thread_data =
       (EVGL_API_Thread_Command_glClearBufferfi *)data;
 
-   orig_evgl_api_glClearBufferfi(thread_param->buffer,
-                                 thread_param->drawBuffer,
-                                 thread_param->depth,
-                                 thread_param->stencil);
+   orig_evgl_api_glClearBufferfi(thread_data->buffer,
+                                 thread_data->drawBuffer,
+                                 thread_data->depth,
+                                 thread_data->stencil);
 
 }
 
@@ -23268,23 +23272,23 @@ glClearBufferfi_evgl_api_thread_cmd(GLenum buffer, GLint drawBuffer, GLfloat dep
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glClearBufferfi thread_param_local;
-   EVGL_API_Thread_Command_glClearBufferfi *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glClearBufferfi thread_data_local;
+   EVGL_API_Thread_Command_glClearBufferfi *thread_data = &thread_data_local;
 
-   thread_param->buffer = buffer;
-   thread_param->drawBuffer = drawBuffer;
-   thread_param->depth = depth;
-   thread_param->stencil = stencil;
+   thread_data->buffer = buffer;
+   thread_data->drawBuffer = drawBuffer;
+   thread_data->depth = depth;
+   thread_data->stencil = stencil;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glClearBufferfi,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glClearBufferfv(GLenum buffer, GLint drawBuffer, const GLfloat * value);
+ * void
+ * glClearBufferfv(GLenum buffer, GLint drawBuffer, const GLfloat * value);
  */
 
 typedef struct
@@ -23300,12 +23304,12 @@ void (*orig_evgl_api_glClearBufferfv)(GLenum buffer, GLint drawBuffer, const GLf
 static void
 _evgl_api_thread_glClearBufferfv(void *data)
 {
-   EVGL_API_Thread_Command_glClearBufferfv *thread_param =
+   EVGL_API_Thread_Command_glClearBufferfv *thread_data =
       (EVGL_API_Thread_Command_glClearBufferfv *)data;
 
-   orig_evgl_api_glClearBufferfv(thread_param->buffer,
-                                 thread_param->drawBuffer,
-                                 thread_param->value);
+   orig_evgl_api_glClearBufferfv(thread_data->buffer,
+                                 thread_data->drawBuffer,
+                                 thread_data->value);
 
 }
 
@@ -23320,22 +23324,22 @@ glClearBufferfv_evgl_api_thread_cmd(GLenum buffer, GLint drawBuffer, const GLflo
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glClearBufferfv thread_param_local;
-   EVGL_API_Thread_Command_glClearBufferfv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glClearBufferfv thread_data_local;
+   EVGL_API_Thread_Command_glClearBufferfv *thread_data = &thread_data_local;
 
-   thread_param->buffer = buffer;
-   thread_param->drawBuffer = drawBuffer;
-   thread_param->value = value;
+   thread_data->buffer = buffer;
+   thread_data->drawBuffer = drawBuffer;
+   thread_data->value = value;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glClearBufferfv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glClearBufferiv(GLenum buffer, GLint drawBuffer, const GLint * value);
+ * void
+ * glClearBufferiv(GLenum buffer, GLint drawBuffer, const GLint * value);
  */
 
 typedef struct
@@ -23351,12 +23355,12 @@ void (*orig_evgl_api_glClearBufferiv)(GLenum buffer, GLint drawBuffer, const GLi
 static void
 _evgl_api_thread_glClearBufferiv(void *data)
 {
-   EVGL_API_Thread_Command_glClearBufferiv *thread_param =
+   EVGL_API_Thread_Command_glClearBufferiv *thread_data =
       (EVGL_API_Thread_Command_glClearBufferiv *)data;
 
-   orig_evgl_api_glClearBufferiv(thread_param->buffer,
-                                 thread_param->drawBuffer,
-                                 thread_param->value);
+   orig_evgl_api_glClearBufferiv(thread_data->buffer,
+                                 thread_data->drawBuffer,
+                                 thread_data->value);
 
 }
 
@@ -23371,22 +23375,22 @@ glClearBufferiv_evgl_api_thread_cmd(GLenum buffer, GLint drawBuffer, const GLint
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glClearBufferiv thread_param_local;
-   EVGL_API_Thread_Command_glClearBufferiv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glClearBufferiv thread_data_local;
+   EVGL_API_Thread_Command_glClearBufferiv *thread_data = &thread_data_local;
 
-   thread_param->buffer = buffer;
-   thread_param->drawBuffer = drawBuffer;
-   thread_param->value = value;
+   thread_data->buffer = buffer;
+   thread_data->drawBuffer = drawBuffer;
+   thread_data->value = value;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glClearBufferiv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glClearBufferuiv(GLenum buffer, GLint drawBuffer, const GLuint * value);
+ * void
+ * glClearBufferuiv(GLenum buffer, GLint drawBuffer, const GLuint * value);
  */
 
 typedef struct
@@ -23402,12 +23406,12 @@ void (*orig_evgl_api_glClearBufferuiv)(GLenum buffer, GLint drawBuffer, const GL
 static void
 _evgl_api_thread_glClearBufferuiv(void *data)
 {
-   EVGL_API_Thread_Command_glClearBufferuiv *thread_param =
+   EVGL_API_Thread_Command_glClearBufferuiv *thread_data =
       (EVGL_API_Thread_Command_glClearBufferuiv *)data;
 
-   orig_evgl_api_glClearBufferuiv(thread_param->buffer,
-                                  thread_param->drawBuffer,
-                                  thread_param->value);
+   orig_evgl_api_glClearBufferuiv(thread_data->buffer,
+                                  thread_data->drawBuffer,
+                                  thread_data->value);
 
 }
 
@@ -23422,22 +23426,22 @@ glClearBufferuiv_evgl_api_thread_cmd(GLenum buffer, GLint drawBuffer, const GLui
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glClearBufferuiv thread_param_local;
-   EVGL_API_Thread_Command_glClearBufferuiv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glClearBufferuiv thread_data_local;
+   EVGL_API_Thread_Command_glClearBufferuiv *thread_data = &thread_data_local;
 
-   thread_param->buffer = buffer;
-   thread_param->drawBuffer = drawBuffer;
-   thread_param->value = value;
+   thread_data->buffer = buffer;
+   thread_data->drawBuffer = drawBuffer;
+   thread_data->value = value;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glClearBufferuiv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   GLenum
-   glClientWaitSync(GLsync sync, GLbitfield flags, EvasGLuint64 timeout);
+ * GLenum
+ * glClientWaitSync(GLsync sync, GLbitfield flags, EvasGLuint64 timeout);
  */
 
 typedef struct
@@ -23454,12 +23458,12 @@ GLenum (*orig_evgl_api_glClientWaitSync)(GLsync sync, GLbitfield flags, EvasGLui
 static void
 _evgl_api_thread_glClientWaitSync(void *data)
 {
-   EVGL_API_Thread_Command_glClientWaitSync *thread_param =
+   EVGL_API_Thread_Command_glClientWaitSync *thread_data =
       (EVGL_API_Thread_Command_glClientWaitSync *)data;
 
-   thread_param->return_value = orig_evgl_api_glClientWaitSync(thread_param->sync,
-                                                               thread_param->flags,
-                                                               thread_param->timeout);
+   thread_data->return_value = orig_evgl_api_glClientWaitSync(thread_data->sync,
+                                                              thread_data->flags,
+                                                              thread_data->timeout);
 
 }
 
@@ -23473,24 +23477,24 @@ glClientWaitSync_evgl_api_thread_cmd(GLsync sync, GLbitfield flags, EvasGLuint64
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glClientWaitSync thread_param_local;
-   EVGL_API_Thread_Command_glClientWaitSync *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glClientWaitSync thread_data_local;
+   EVGL_API_Thread_Command_glClientWaitSync *thread_data = &thread_data_local;
 
-   thread_param->sync = sync;
-   thread_param->flags = flags;
-   thread_param->timeout = timeout;
+   thread_data->sync = sync;
+   thread_data->flags = flags;
+   thread_data->timeout = timeout;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glClientWaitSync,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
-   void
-   glCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid * data);
+ * void
+ * glCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid * data);
  */
 
 typedef struct
@@ -23512,18 +23516,18 @@ void (*orig_evgl_api_glCompressedTexImage3D)(GLenum target, GLint level, GLenum
 static void
 _evgl_api_thread_glCompressedTexImage3D(void *data)
 {
-   EVGL_API_Thread_Command_glCompressedTexImage3D *thread_param =
+   EVGL_API_Thread_Command_glCompressedTexImage3D *thread_data =
       (EVGL_API_Thread_Command_glCompressedTexImage3D *)data;
 
-   orig_evgl_api_glCompressedTexImage3D(thread_param->target,
-                                        thread_param->level,
-                                        thread_param->internalformat,
-                                        thread_param->width,
-                                        thread_param->height,
-                                        thread_param->depth,
-                                        thread_param->border,
-                                        thread_param->imageSize,
-                                        thread_param->data);
+   orig_evgl_api_glCompressedTexImage3D(thread_data->target,
+                                        thread_data->level,
+                                        thread_data->internalformat,
+                                        thread_data->width,
+                                        thread_data->height,
+                                        thread_data->depth,
+                                        thread_data->border,
+                                        thread_data->imageSize,
+                                        thread_data->data);
 
 }
 
@@ -23538,28 +23542,28 @@ glCompressedTexImage3D_evgl_api_thread_cmd(GLenum target, GLint level, GLenum in
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glCompressedTexImage3D thread_param_local;
-   EVGL_API_Thread_Command_glCompressedTexImage3D *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glCompressedTexImage3D thread_data_local;
+   EVGL_API_Thread_Command_glCompressedTexImage3D *thread_data = &thread_data_local;
 
-   thread_param->target = target;
-   thread_param->level = level;
-   thread_param->internalformat = internalformat;
-   thread_param->width = width;
-   thread_param->height = height;
-   thread_param->depth = depth;
-   thread_param->border = border;
-   thread_param->imageSize = imageSize;
-   thread_param->data = data;
+   thread_data->target = target;
+   thread_data->level = level;
+   thread_data->internalformat = internalformat;
+   thread_data->width = width;
+   thread_data->height = height;
+   thread_data->depth = depth;
+   thread_data->border = border;
+   thread_data->imageSize = imageSize;
+   thread_data->data = data;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glCompressedTexImage3D,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid * data);
+ * void
+ * glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid * data);
  */
 
 typedef struct
@@ -23583,20 +23587,20 @@ void (*orig_evgl_api_glCompressedTexSubImage3D)(GLenum target, GLint level, GLin
 static void
 _evgl_api_thread_glCompressedTexSubImage3D(void *data)
 {
-   EVGL_API_Thread_Command_glCompressedTexSubImage3D *thread_param =
+   EVGL_API_Thread_Command_glCompressedTexSubImage3D *thread_data =
       (EVGL_API_Thread_Command_glCompressedTexSubImage3D *)data;
 
-   orig_evgl_api_glCompressedTexSubImage3D(thread_param->target,
-                                           thread_param->level,
-                                           thread_param->xoffset,
-                                           thread_param->yoffset,
-                                           thread_param->zoffset,
-                                           thread_param->width,
-                                           thread_param->height,
-                                           thread_param->depth,
-                                           thread_param->format,
-                                           thread_param->imageSize,
-                                           thread_param->data);
+   orig_evgl_api_glCompressedTexSubImage3D(thread_data->target,
+                                           thread_data->level,
+                                           thread_data->xoffset,
+                                           thread_data->yoffset,
+                                           thread_data->zoffset,
+                                           thread_data->width,
+                                           thread_data->height,
+                                           thread_data->depth,
+                                           thread_data->format,
+                                           thread_data->imageSize,
+                                           thread_data->data);
 
 }
 
@@ -23611,30 +23615,30 @@ glCompressedTexSubImage3D_evgl_api_thread_cmd(GLenum target, GLint level, GLint
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glCompressedTexSubImage3D thread_param_local;
-   EVGL_API_Thread_Command_glCompressedTexSubImage3D *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glCompressedTexSubImage3D thread_data_local;
+   EVGL_API_Thread_Command_glCompressedTexSubImage3D *thread_data = &thread_data_local;
 
-   thread_param->target = target;
-   thread_param->level = level;
-   thread_param->xoffset = xoffset;
-   thread_param->yoffset = yoffset;
-   thread_param->zoffset = zoffset;
-   thread_param->width = width;
-   thread_param->height = height;
-   thread_param->depth = depth;
-   thread_param->format = format;
-   thread_param->imageSize = imageSize;
-   thread_param->data = data;
+   thread_data->target = target;
+   thread_data->level = level;
+   thread_data->xoffset = xoffset;
+   thread_data->yoffset = yoffset;
+   thread_data->zoffset = zoffset;
+   thread_data->width = width;
+   thread_data->height = height;
+   thread_data->depth = depth;
+   thread_data->format = format;
+   thread_data->imageSize = imageSize;
+   thread_data->data = data;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glCompressedTexSubImage3D,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glCopyBufferSubData(GLenum readtarget, GLenum writetarget, GLintptr readoffset, GLintptr writeoffset, GLsizeiptr size);
+ * void
+ * glCopyBufferSubData(GLenum readtarget, GLenum writetarget, GLintptr readoffset, GLintptr writeoffset, GLsizeiptr size);
  */
 
 typedef struct
@@ -23652,14 +23656,14 @@ void (*orig_evgl_api_glCopyBufferSubData)(GLenum readtarget, GLenum writetarget,
 static void
 _evgl_api_thread_glCopyBufferSubData(void *data)
 {
-   EVGL_API_Thread_Command_glCopyBufferSubData *thread_param =
+   EVGL_API_Thread_Command_glCopyBufferSubData *thread_data =
       (EVGL_API_Thread_Command_glCopyBufferSubData *)data;
 
-   orig_evgl_api_glCopyBufferSubData(thread_param->readtarget,
-                                     thread_param->writetarget,
-                                     thread_param->readoffset,
-                                     thread_param->writeoffset,
-                                     thread_param->size);
+   orig_evgl_api_glCopyBufferSubData(thread_data->readtarget,
+                                     thread_data->writetarget,
+                                     thread_data->readoffset,
+                                     thread_data->writeoffset,
+                                     thread_data->size);
 
 }
 
@@ -23674,24 +23678,24 @@ glCopyBufferSubData_evgl_api_thread_cmd(GLenum readtarget, GLenum writetarget, G
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glCopyBufferSubData thread_param_local;
-   EVGL_API_Thread_Command_glCopyBufferSubData *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glCopyBufferSubData thread_data_local;
+   EVGL_API_Thread_Command_glCopyBufferSubData *thread_data = &thread_data_local;
 
-   thread_param->readtarget = readtarget;
-   thread_param->writetarget = writetarget;
-   thread_param->readoffset = readoffset;
-   thread_param->writeoffset = writeoffset;
-   thread_param->size = size;
+   thread_data->readtarget = readtarget;
+   thread_data->writetarget = writetarget;
+   thread_data->readoffset = readoffset;
+   thread_data->writeoffset = writeoffset;
+   thread_data->size = size;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glCopyBufferSubData,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height);
+ * void
+ * glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height);
  */
 
 typedef struct
@@ -23713,18 +23717,18 @@ void (*orig_evgl_api_glCopyTexSubImage3D)(GLenum target, GLint level, GLint xoff
 static void
 _evgl_api_thread_glCopyTexSubImage3D(void *data)
 {
-   EVGL_API_Thread_Command_glCopyTexSubImage3D *thread_param =
+   EVGL_API_Thread_Command_glCopyTexSubImage3D *thread_data =
       (EVGL_API_Thread_Command_glCopyTexSubImage3D *)data;
 
-   orig_evgl_api_glCopyTexSubImage3D(thread_param->target,
-                                     thread_param->level,
-                                     thread_param->xoffset,
-                                     thread_param->yoffset,
-                                     thread_param->zoffset,
-                                     thread_param->x,
-                                     thread_param->y,
-                                     thread_param->width,
-                                     thread_param->height);
+   orig_evgl_api_glCopyTexSubImage3D(thread_data->target,
+                                     thread_data->level,
+                                     thread_data->xoffset,
+                                     thread_data->yoffset,
+                                     thread_data->zoffset,
+                                     thread_data->x,
+                                     thread_data->y,
+                                     thread_data->width,
+                                     thread_data->height);
 
 }
 
@@ -23739,28 +23743,28 @@ glCopyTexSubImage3D_evgl_api_thread_cmd(GLenum target, GLint level, GLint xoffse
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glCopyTexSubImage3D thread_param_local;
-   EVGL_API_Thread_Command_glCopyTexSubImage3D *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glCopyTexSubImage3D thread_data_local;
+   EVGL_API_Thread_Command_glCopyTexSubImage3D *thread_data = &thread_data_local;
 
-   thread_param->target = target;
-   thread_param->level = level;
-   thread_param->xoffset = xoffset;
-   thread_param->yoffset = yoffset;
-   thread_param->zoffset = zoffset;
-   thread_param->x = x;
-   thread_param->y = y;
-   thread_param->width = width;
-   thread_param->height = height;
+   thread_data->target = target;
+   thread_data->level = level;
+   thread_data->xoffset = xoffset;
+   thread_data->yoffset = yoffset;
+   thread_data->zoffset = zoffset;
+   thread_data->x = x;
+   thread_data->y = y;
+   thread_data->width = width;
+   thread_data->height = height;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glCopyTexSubImage3D,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glDeleteQueries(GLsizei n, const GLuint * ids);
+ * void
+ * glDeleteQueries(GLsizei n, const GLuint * ids);
  */
 
 typedef struct
@@ -23775,11 +23779,11 @@ void (*orig_evgl_api_glDeleteQueries)(GLsizei n, const GLuint * ids);
 static void
 _evgl_api_thread_glDeleteQueries(void *data)
 {
-   EVGL_API_Thread_Command_glDeleteQueries *thread_param =
+   EVGL_API_Thread_Command_glDeleteQueries *thread_data =
       (EVGL_API_Thread_Command_glDeleteQueries *)data;
 
-   orig_evgl_api_glDeleteQueries(thread_param->n,
-                                 thread_param->ids);
+   orig_evgl_api_glDeleteQueries(thread_data->n,
+                                 thread_data->ids);
 
 }
 
@@ -23794,21 +23798,21 @@ glDeleteQueries_evgl_api_thread_cmd(GLsizei n, const GLuint * ids)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glDeleteQueries thread_param_local;
-   EVGL_API_Thread_Command_glDeleteQueries *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glDeleteQueries thread_data_local;
+   EVGL_API_Thread_Command_glDeleteQueries *thread_data = &thread_data_local;
 
-   thread_param->n = n;
-   thread_param->ids = ids;
+   thread_data->n = n;
+   thread_data->ids = ids;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glDeleteQueries,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glDeleteSamplers(GLsizei n, const GLuint * samplers);
+ * void
+ * glDeleteSamplers(GLsizei n, const GLuint * samplers);
  */
 
 typedef struct
@@ -23823,11 +23827,11 @@ void (*orig_evgl_api_glDeleteSamplers)(GLsizei n, const GLuint * samplers);
 static void
 _evgl_api_thread_glDeleteSamplers(void *data)
 {
-   EVGL_API_Thread_Command_glDeleteSamplers *thread_param =
+   EVGL_API_Thread_Command_glDeleteSamplers *thread_data =
       (EVGL_API_Thread_Command_glDeleteSamplers *)data;
 
-   orig_evgl_api_glDeleteSamplers(thread_param->n,
-                                  thread_param->samplers);
+   orig_evgl_api_glDeleteSamplers(thread_data->n,
+                                  thread_data->samplers);
 
 }
 
@@ -23842,21 +23846,21 @@ glDeleteSamplers_evgl_api_thread_cmd(GLsizei n, const GLuint * samplers)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glDeleteSamplers thread_param_local;
-   EVGL_API_Thread_Command_glDeleteSamplers *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glDeleteSamplers thread_data_local;
+   EVGL_API_Thread_Command_glDeleteSamplers *thread_data = &thread_data_local;
 
-   thread_param->n = n;
-   thread_param->samplers = samplers;
+   thread_data->n = n;
+   thread_data->samplers = samplers;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glDeleteSamplers,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glDeleteSync(GLsync sync);
+ * void
+ * glDeleteSync(GLsync sync);
  */
 
 typedef struct
@@ -23870,10 +23874,10 @@ void (*orig_evgl_api_glDeleteSync)(GLsync sync);
 static void
 _evgl_api_thread_glDeleteSync(void *data)
 {
-   EVGL_API_Thread_Command_glDeleteSync *thread_param =
+   EVGL_API_Thread_Command_glDeleteSync *thread_data =
       (EVGL_API_Thread_Command_glDeleteSync *)data;
 
-   orig_evgl_api_glDeleteSync(thread_param->sync);
+   orig_evgl_api_glDeleteSync(thread_data->sync);
 
 }
 
@@ -23888,20 +23892,20 @@ glDeleteSync_evgl_api_thread_cmd(GLsync sync)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glDeleteSync thread_param_local;
-   EVGL_API_Thread_Command_glDeleteSync *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glDeleteSync thread_data_local;
+   EVGL_API_Thread_Command_glDeleteSync *thread_data = &thread_data_local;
 
-   thread_param->sync = sync;
+   thread_data->sync = sync;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glDeleteSync,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glDeleteTransformFeedbacks(GLsizei n, const GLuint *ids);
+ * void
+ * glDeleteTransformFeedbacks(GLsizei n, const GLuint *ids);
  */
 
 typedef struct
@@ -23916,11 +23920,11 @@ void (*orig_evgl_api_glDeleteTransformFeedbacks)(GLsizei n, const GLuint *ids);
 static void
 _evgl_api_thread_glDeleteTransformFeedbacks(void *data)
 {
-   EVGL_API_Thread_Command_glDeleteTransformFeedbacks *thread_param =
+   EVGL_API_Thread_Command_glDeleteTransformFeedbacks *thread_data =
       (EVGL_API_Thread_Command_glDeleteTransformFeedbacks *)data;
 
-   orig_evgl_api_glDeleteTransformFeedbacks(thread_param->n,
-                                            thread_param->ids);
+   orig_evgl_api_glDeleteTransformFeedbacks(thread_data->n,
+                                            thread_data->ids);
 
 }
 
@@ -23935,21 +23939,21 @@ glDeleteTransformFeedbacks_evgl_api_thread_cmd(GLsizei n, const GLuint *ids)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glDeleteTransformFeedbacks thread_param_local;
-   EVGL_API_Thread_Command_glDeleteTransformFeedbacks *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glDeleteTransformFeedbacks thread_data_local;
+   EVGL_API_Thread_Command_glDeleteTransformFeedbacks *thread_data = &thread_data_local;
 
-   thread_param->n = n;
-   thread_param->ids = ids;
+   thread_data->n = n;
+   thread_data->ids = ids;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glDeleteTransformFeedbacks,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glDeleteVertexArrays(GLsizei n, const GLuint *arrays);
+ * void
+ * glDeleteVertexArrays(GLsizei n, const GLuint *arrays);
  */
 
 typedef struct
@@ -23964,11 +23968,11 @@ void (*orig_evgl_api_glDeleteVertexArrays)(GLsizei n, const GLuint *arrays);
 static void
 _evgl_api_thread_glDeleteVertexArrays(void *data)
 {
-   EVGL_API_Thread_Command_glDeleteVertexArrays *thread_param =
+   EVGL_API_Thread_Command_glDeleteVertexArrays *thread_data =
       (EVGL_API_Thread_Command_glDeleteVertexArrays *)data;
 
-   orig_evgl_api_glDeleteVertexArrays(thread_param->n,
-                                      thread_param->arrays);
+   orig_evgl_api_glDeleteVertexArrays(thread_data->n,
+                                      thread_data->arrays);
 
 }
 
@@ -23983,21 +23987,21 @@ glDeleteVertexArrays_evgl_api_thread_cmd(GLsizei n, const GLuint *arrays)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glDeleteVertexArrays thread_param_local;
-   EVGL_API_Thread_Command_glDeleteVertexArrays *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glDeleteVertexArrays thread_data_local;
+   EVGL_API_Thread_Command_glDeleteVertexArrays *thread_data = &thread_data_local;
 
-   thread_param->n = n;
-   thread_param->arrays = arrays;
+   thread_data->n = n;
+   thread_data->arrays = arrays;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glDeleteVertexArrays,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glDrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei primcount);
+ * void
+ * glDrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei primcount);
  */
 
 typedef struct
@@ -24014,13 +24018,13 @@ void (*orig_evgl_api_glDrawArraysInstanced)(GLenum mode, GLint first, GLsizei co
 static void
 _evgl_api_thread_glDrawArraysInstanced(void *data)
 {
-   EVGL_API_Thread_Command_glDrawArraysInstanced *thread_param =
+   EVGL_API_Thread_Command_glDrawArraysInstanced *thread_data =
       (EVGL_API_Thread_Command_glDrawArraysInstanced *)data;
 
-   orig_evgl_api_glDrawArraysInstanced(thread_param->mode,
-                                       thread_param->first,
-                                       thread_param->count,
-                                       thread_param->primcount);
+   orig_evgl_api_glDrawArraysInstanced(thread_data->mode,
+                                       thread_data->first,
+                                       thread_data->count,
+                                       thread_data->primcount);
 
 }
 
@@ -24035,23 +24039,23 @@ glDrawArraysInstanced_evgl_api_thread_cmd(GLenum mode, GLint first, GLsizei coun
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glDrawArraysInstanced thread_param_local;
-   EVGL_API_Thread_Command_glDrawArraysInstanced *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glDrawArraysInstanced thread_data_local;
+   EVGL_API_Thread_Command_glDrawArraysInstanced *thread_data = &thread_data_local;
 
-   thread_param->mode = mode;
-   thread_param->first = first;
-   thread_param->count = count;
-   thread_param->primcount = primcount;
+   thread_data->mode = mode;
+   thread_data->first = first;
+   thread_data->count = count;
+   thread_data->primcount = primcount;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glDrawArraysInstanced,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glDrawBuffers(GLsizei n, const GLenum *bufs);
+ * void
+ * glDrawBuffers(GLsizei n, const GLenum *bufs);
  */
 
 typedef struct
@@ -24066,11 +24070,11 @@ void (*orig_evgl_api_glDrawBuffers)(GLsizei n, const GLenum *bufs);
 static void
 _evgl_api_thread_glDrawBuffers(void *data)
 {
-   EVGL_API_Thread_Command_glDrawBuffers *thread_param =
+   EVGL_API_Thread_Command_glDrawBuffers *thread_data =
       (EVGL_API_Thread_Command_glDrawBuffers *)data;
 
-   orig_evgl_api_glDrawBuffers(thread_param->n,
-                               thread_param->bufs);
+   orig_evgl_api_glDrawBuffers(thread_data->n,
+                               thread_data->bufs);
 
 }
 
@@ -24085,21 +24089,21 @@ glDrawBuffers_evgl_api_thread_cmd(GLsizei n, const GLenum *bufs)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glDrawBuffers thread_param_local;
-   EVGL_API_Thread_Command_glDrawBuffers *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glDrawBuffers thread_data_local;
+   EVGL_API_Thread_Command_glDrawBuffers *thread_data = &thread_data_local;
 
-   thread_param->n = n;
-   thread_param->bufs = bufs;
+   thread_data->n = n;
+   thread_data->bufs = bufs;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glDrawBuffers,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glDrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const void * indices, GLsizei primcount);
+ * void
+ * glDrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const void * indices, GLsizei primcount);
  */
 
 typedef struct
@@ -24117,14 +24121,14 @@ void (*orig_evgl_api_glDrawElementsInstanced)(GLenum mode, GLsizei count, GLenum
 static void
 _evgl_api_thread_glDrawElementsInstanced(void *data)
 {
-   EVGL_API_Thread_Command_glDrawElementsInstanced *thread_param =
+   EVGL_API_Thread_Command_glDrawElementsInstanced *thread_data =
       (EVGL_API_Thread_Command_glDrawElementsInstanced *)data;
 
-   orig_evgl_api_glDrawElementsInstanced(thread_param->mode,
-                                         thread_param->count,
-                                         thread_param->type,
-                                         thread_param->indices,
-                                         thread_param->primcount);
+   orig_evgl_api_glDrawElementsInstanced(thread_data->mode,
+                                         thread_data->count,
+                                         thread_data->type,
+                                         thread_data->indices,
+                                         thread_data->primcount);
 
 }
 
@@ -24139,24 +24143,24 @@ glDrawElementsInstanced_evgl_api_thread_cmd(GLenum mode, GLsizei count, GLenum t
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glDrawElementsInstanced thread_param_local;
-   EVGL_API_Thread_Command_glDrawElementsInstanced *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glDrawElementsInstanced thread_data_local;
+   EVGL_API_Thread_Command_glDrawElementsInstanced *thread_data = &thread_data_local;
 
-   thread_param->mode = mode;
-   thread_param->count = count;
-   thread_param->type = type;
-   thread_param->indices = indices;
-   thread_param->primcount = primcount;
+   thread_data->mode = mode;
+   thread_data->count = count;
+   thread_data->type = type;
+   thread_data->indices = indices;
+   thread_data->primcount = primcount;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glDrawElementsInstanced,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid * indices);
+ * void
+ * glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid * indices);
  */
 
 typedef struct
@@ -24175,15 +24179,15 @@ void (*orig_evgl_api_glDrawRangeElements)(GLenum mode, GLuint start, GLuint end,
 static void
 _evgl_api_thread_glDrawRangeElements(void *data)
 {
-   EVGL_API_Thread_Command_glDrawRangeElements *thread_param =
+   EVGL_API_Thread_Command_glDrawRangeElements *thread_data =
       (EVGL_API_Thread_Command_glDrawRangeElements *)data;
 
-   orig_evgl_api_glDrawRangeElements(thread_param->mode,
-                                     thread_param->start,
-                                     thread_param->end,
-                                     thread_param->count,
-                                     thread_param->type,
-                                     thread_param->indices);
+   orig_evgl_api_glDrawRangeElements(thread_data->mode,
+                                     thread_data->start,
+                                     thread_data->end,
+                                     thread_data->count,
+                                     thread_data->type,
+                                     thread_data->indices);
 
 }
 
@@ -24198,25 +24202,25 @@ glDrawRangeElements_evgl_api_thread_cmd(GLenum mode, GLuint start, GLuint end, G
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glDrawRangeElements thread_param_local;
-   EVGL_API_Thread_Command_glDrawRangeElements *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glDrawRangeElements thread_data_local;
+   EVGL_API_Thread_Command_glDrawRangeElements *thread_data = &thread_data_local;
 
-   thread_param->mode = mode;
-   thread_param->start = start;
-   thread_param->end = end;
-   thread_param->count = count;
-   thread_param->type = type;
-   thread_param->indices = indices;
+   thread_data->mode = mode;
+   thread_data->start = start;
+   thread_data->end = end;
+   thread_data->count = count;
+   thread_data->type = type;
+   thread_data->indices = indices;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glDrawRangeElements,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glEndQuery(GLenum target);
+ * void
+ * glEndQuery(GLenum target);
  */
 
 typedef struct
@@ -24230,10 +24234,10 @@ void (*orig_evgl_api_glEndQuery)(GLenum target);
 static void
 _evgl_api_thread_glEndQuery(void *data)
 {
-   EVGL_API_Thread_Command_glEndQuery *thread_param =
+   EVGL_API_Thread_Command_glEndQuery *thread_data =
       (EVGL_API_Thread_Command_glEndQuery *)data;
 
-   orig_evgl_api_glEndQuery(thread_param->target);
+   orig_evgl_api_glEndQuery(thread_data->target);
 
 }
 
@@ -24248,20 +24252,20 @@ glEndQuery_evgl_api_thread_cmd(GLenum target)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glEndQuery thread_param_local;
-   EVGL_API_Thread_Command_glEndQuery *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glEndQuery thread_data_local;
+   EVGL_API_Thread_Command_glEndQuery *thread_data = &thread_data_local;
 
-   thread_param->target = target;
+   thread_data->target = target;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glEndQuery,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glEndTransformFeedback(void);
+ * void
+ * glEndTransformFeedback(void);
  */
 
 void (*orig_evgl_api_glEndTransformFeedback)(void);
@@ -24291,8 +24295,8 @@ glEndTransformFeedback_evgl_api_thread_cmd(void)
 }
 
 /*
-   GLsync
-   glFenceSync(GLenum condition, GLbitfield flags);
+ * GLsync
+ * glFenceSync(GLenum condition, GLbitfield flags);
  */
 
 typedef struct
@@ -24308,11 +24312,11 @@ GLsync (*orig_evgl_api_glFenceSync)(GLenum condition, GLbitfield flags);
 static void
 _evgl_api_thread_glFenceSync(void *data)
 {
-   EVGL_API_Thread_Command_glFenceSync *thread_param =
+   EVGL_API_Thread_Command_glFenceSync *thread_data =
       (EVGL_API_Thread_Command_glFenceSync *)data;
 
-   thread_param->return_value = orig_evgl_api_glFenceSync(thread_param->condition,
-                                                          thread_param->flags);
+   thread_data->return_value = orig_evgl_api_glFenceSync(thread_data->condition,
+                                                         thread_data->flags);
 
 }
 
@@ -24326,23 +24330,23 @@ glFenceSync_evgl_api_thread_cmd(GLenum condition, GLbitfield flags)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glFenceSync thread_param_local;
-   EVGL_API_Thread_Command_glFenceSync *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glFenceSync thread_data_local;
+   EVGL_API_Thread_Command_glFenceSync *thread_data = &thread_data_local;
 
-   thread_param->condition = condition;
-   thread_param->flags = flags;
+   thread_data->condition = condition;
+   thread_data->flags = flags;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glFenceSync,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
-   GLsync
-   glFlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length);
+ * GLsync
+ * glFlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length);
  */
 
 typedef struct
@@ -24359,12 +24363,12 @@ GLsync (*orig_evgl_api_glFlushMappedBufferRange)(GLenum target, GLintptr offset,
 static void
 _evgl_api_thread_glFlushMappedBufferRange(void *data)
 {
-   EVGL_API_Thread_Command_glFlushMappedBufferRange *thread_param =
+   EVGL_API_Thread_Command_glFlushMappedBufferRange *thread_data =
       (EVGL_API_Thread_Command_glFlushMappedBufferRange *)data;
 
-   thread_param->return_value = orig_evgl_api_glFlushMappedBufferRange(thread_param->target,
-                                                                       thread_param->offset,
-                                                                       thread_param->length);
+   thread_data->return_value = orig_evgl_api_glFlushMappedBufferRange(thread_data->target,
+                                                                      thread_data->offset,
+                                                                      thread_data->length);
 
 }
 
@@ -24378,24 +24382,24 @@ glFlushMappedBufferRange_evgl_api_thread_cmd(GLenum target, GLintptr offset, GLs
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glFlushMappedBufferRange thread_param_local;
-   EVGL_API_Thread_Command_glFlushMappedBufferRange *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glFlushMappedBufferRange thread_data_local;
+   EVGL_API_Thread_Command_glFlushMappedBufferRange *thread_data = &thread_data_local;
 
-   thread_param->target = target;
-   thread_param->offset = offset;
-   thread_param->length = length;
+   thread_data->target = target;
+   thread_data->offset = offset;
+   thread_data->length = length;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glFlushMappedBufferRange,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
-   void
-   glFramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer);
+ * void
+ * glFramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer);
  */
 
 typedef struct
@@ -24413,14 +24417,14 @@ void (*orig_evgl_api_glFramebufferTextureLayer)(GLenum target, GLenum attachment
 static void
 _evgl_api_thread_glFramebufferTextureLayer(void *data)
 {
-   EVGL_API_Thread_Command_glFramebufferTextureLayer *thread_param =
+   EVGL_API_Thread_Command_glFramebufferTextureLayer *thread_data =
       (EVGL_API_Thread_Command_glFramebufferTextureLayer *)data;
 
-   orig_evgl_api_glFramebufferTextureLayer(thread_param->target,
-                                           thread_param->attachment,
-                                           thread_param->texture,
-                                           thread_param->level,
-                                           thread_param->layer);
+   orig_evgl_api_glFramebufferTextureLayer(thread_data->target,
+                                           thread_data->attachment,
+                                           thread_data->texture,
+                                           thread_data->level,
+                                           thread_data->layer);
 
 }
 
@@ -24435,24 +24439,24 @@ glFramebufferTextureLayer_evgl_api_thread_cmd(GLenum target, GLenum attachment,
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glFramebufferTextureLayer thread_param_local;
-   EVGL_API_Thread_Command_glFramebufferTextureLayer *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glFramebufferTextureLayer thread_data_local;
+   EVGL_API_Thread_Command_glFramebufferTextureLayer *thread_data = &thread_data_local;
 
-   thread_param->target = target;
-   thread_param->attachment = attachment;
-   thread_param->texture = texture;
-   thread_param->level = level;
-   thread_param->layer = layer;
+   thread_data->target = target;
+   thread_data->attachment = attachment;
+   thread_data->texture = texture;
+   thread_data->level = level;
+   thread_data->layer = layer;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glFramebufferTextureLayer,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGenQueries(GLsizei n, GLuint * ids);
+ * void
+ * glGenQueries(GLsizei n, GLuint * ids);
  */
 
 typedef struct
@@ -24467,11 +24471,11 @@ void (*orig_evgl_api_glGenQueries)(GLsizei n, GLuint * ids);
 static void
 _evgl_api_thread_glGenQueries(void *data)
 {
-   EVGL_API_Thread_Command_glGenQueries *thread_param =
+   EVGL_API_Thread_Command_glGenQueries *thread_data =
       (EVGL_API_Thread_Command_glGenQueries *)data;
 
-   orig_evgl_api_glGenQueries(thread_param->n,
-                              thread_param->ids);
+   orig_evgl_api_glGenQueries(thread_data->n,
+                              thread_data->ids);
 
 }
 
@@ -24486,21 +24490,21 @@ glGenQueries_evgl_api_thread_cmd(GLsizei n, GLuint * ids)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGenQueries thread_param_local;
-   EVGL_API_Thread_Command_glGenQueries *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGenQueries thread_data_local;
+   EVGL_API_Thread_Command_glGenQueries *thread_data = &thread_data_local;
 
-   thread_param->n = n;
-   thread_param->ids = ids;
+   thread_data->n = n;
+   thread_data->ids = ids;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGenQueries,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGenSamplers(GLsizei n, GLuint *samplers);
+ * void
+ * glGenSamplers(GLsizei n, GLuint *samplers);
  */
 
 typedef struct
@@ -24515,11 +24519,11 @@ void (*orig_evgl_api_glGenSamplers)(GLsizei n, GLuint *samplers);
 static void
 _evgl_api_thread_glGenSamplers(void *data)
 {
-   EVGL_API_Thread_Command_glGenSamplers *thread_param =
+   EVGL_API_Thread_Command_glGenSamplers *thread_data =
       (EVGL_API_Thread_Command_glGenSamplers *)data;
 
-   orig_evgl_api_glGenSamplers(thread_param->n,
-                               thread_param->samplers);
+   orig_evgl_api_glGenSamplers(thread_data->n,
+                               thread_data->samplers);
 
 }
 
@@ -24534,21 +24538,21 @@ glGenSamplers_evgl_api_thread_cmd(GLsizei n, GLuint *samplers)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGenSamplers thread_param_local;
-   EVGL_API_Thread_Command_glGenSamplers *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGenSamplers thread_data_local;
+   EVGL_API_Thread_Command_glGenSamplers *thread_data = &thread_data_local;
 
-   thread_param->n = n;
-   thread_param->samplers = samplers;
+   thread_data->n = n;
+   thread_data->samplers = samplers;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGenSamplers,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGenTransformFeedbacks(GLsizei n, GLuint *ids);
+ * void
+ * glGenTransformFeedbacks(GLsizei n, GLuint *ids);
  */
 
 typedef struct
@@ -24563,11 +24567,11 @@ void (*orig_evgl_api_glGenTransformFeedbacks)(GLsizei n, GLuint *ids);
 static void
 _evgl_api_thread_glGenTransformFeedbacks(void *data)
 {
-   EVGL_API_Thread_Command_glGenTransformFeedbacks *thread_param =
+   EVGL_API_Thread_Command_glGenTransformFeedbacks *thread_data =
       (EVGL_API_Thread_Command_glGenTransformFeedbacks *)data;
 
-   orig_evgl_api_glGenTransformFeedbacks(thread_param->n,
-                                         thread_param->ids);
+   orig_evgl_api_glGenTransformFeedbacks(thread_data->n,
+                                         thread_data->ids);
 
 }
 
@@ -24582,21 +24586,21 @@ glGenTransformFeedbacks_evgl_api_thread_cmd(GLsizei n, GLuint *ids)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGenTransformFeedbacks thread_param_local;
-   EVGL_API_Thread_Command_glGenTransformFeedbacks *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGenTransformFeedbacks thread_data_local;
+   EVGL_API_Thread_Command_glGenTransformFeedbacks *thread_data = &thread_data_local;
 
-   thread_param->n = n;
-   thread_param->ids = ids;
+   thread_data->n = n;
+   thread_data->ids = ids;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGenTransformFeedbacks,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGenVertexArrays(GLsizei n, GLuint *arrays);
+ * void
+ * glGenVertexArrays(GLsizei n, GLuint *arrays);
  */
 
 typedef struct
@@ -24611,11 +24615,11 @@ void (*orig_evgl_api_glGenVertexArrays)(GLsizei n, GLuint *arrays);
 static void
 _evgl_api_thread_glGenVertexArrays(void *data)
 {
-   EVGL_API_Thread_Command_glGenVertexArrays *thread_param =
+   EVGL_API_Thread_Command_glGenVertexArrays *thread_data =
       (EVGL_API_Thread_Command_glGenVertexArrays *)data;
 
-   orig_evgl_api_glGenVertexArrays(thread_param->n,
-                                   thread_param->arrays);
+   orig_evgl_api_glGenVertexArrays(thread_data->n,
+                                   thread_data->arrays);
 
 }
 
@@ -24630,21 +24634,21 @@ glGenVertexArrays_evgl_api_thread_cmd(GLsizei n, GLuint *arrays)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGenVertexArrays thread_param_local;
-   EVGL_API_Thread_Command_glGenVertexArrays *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGenVertexArrays thread_data_local;
+   EVGL_API_Thread_Command_glGenVertexArrays *thread_data = &thread_data_local;
 
-   thread_param->n = n;
-   thread_param->arrays = arrays;
+   thread_data->n = n;
+   thread_data->arrays = arrays;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGenVertexArrays,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params);
+ * void
+ * glGetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params);
  */
 
 typedef struct
@@ -24661,13 +24665,13 @@ void (*orig_evgl_api_glGetActiveUniformBlockiv)(GLuint program, GLuint uniformBl
 static void
 _evgl_api_thread_glGetActiveUniformBlockiv(void *data)
 {
-   EVGL_API_Thread_Command_glGetActiveUniformBlockiv *thread_param =
+   EVGL_API_Thread_Command_glGetActiveUniformBlockiv *thread_data =
       (EVGL_API_Thread_Command_glGetActiveUniformBlockiv *)data;
 
-   orig_evgl_api_glGetActiveUniformBlockiv(thread_param->program,
-                                           thread_param->uniformBlockIndex,
-                                           thread_param->pname,
-                                           thread_param->params);
+   orig_evgl_api_glGetActiveUniformBlockiv(thread_data->program,
+                                           thread_data->uniformBlockIndex,
+                                           thread_data->pname,
+                                           thread_data->params);
 
 }
 
@@ -24682,23 +24686,23 @@ glGetActiveUniformBlockiv_evgl_api_thread_cmd(GLuint program, GLuint uniformBloc
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGetActiveUniformBlockiv thread_param_local;
-   EVGL_API_Thread_Command_glGetActiveUniformBlockiv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGetActiveUniformBlockiv thread_data_local;
+   EVGL_API_Thread_Command_glGetActiveUniformBlockiv *thread_data = &thread_data_local;
 
-   thread_param->program = program;
-   thread_param->uniformBlockIndex = uniformBlockIndex;
-   thread_param->pname = pname;
-   thread_param->params = params;
+   thread_data->program = program;
+   thread_data->uniformBlockIndex = uniformBlockIndex;
+   thread_data->pname = pname;
+   thread_data->params = params;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGetActiveUniformBlockiv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName);
+ * void
+ * glGetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName);
  */
 
 typedef struct
@@ -24716,14 +24720,14 @@ void (*orig_evgl_api_glGetActiveUniformBlockName)(GLuint program, GLuint uniform
 static void
 _evgl_api_thread_glGetActiveUniformBlockName(void *data)
 {
-   EVGL_API_Thread_Command_glGetActiveUniformBlockName *thread_param =
+   EVGL_API_Thread_Command_glGetActiveUniformBlockName *thread_data =
       (EVGL_API_Thread_Command_glGetActiveUniformBlockName *)data;
 
-   orig_evgl_api_glGetActiveUniformBlockName(thread_param->program,
-                                             thread_param->uniformBlockIndex,
-                                             thread_param->bufSize,
-                                             thread_param->length,
-                                             thread_param->uniformBlockName);
+   orig_evgl_api_glGetActiveUniformBlockName(thread_data->program,
+                                             thread_data->uniformBlockIndex,
+                                             thread_data->bufSize,
+                                             thread_data->length,
+                                             thread_data->uniformBlockName);
 
 }
 
@@ -24738,24 +24742,24 @@ glGetActiveUniformBlockName_evgl_api_thread_cmd(GLuint program, GLuint uniformBl
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGetActiveUniformBlockName thread_param_local;
-   EVGL_API_Thread_Command_glGetActiveUniformBlockName *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGetActiveUniformBlockName thread_data_local;
+   EVGL_API_Thread_Command_glGetActiveUniformBlockName *thread_data = &thread_data_local;
 
-   thread_param->program = program;
-   thread_param->uniformBlockIndex = uniformBlockIndex;
-   thread_param->bufSize = bufSize;
-   thread_param->length = length;
-   thread_param->uniformBlockName = uniformBlockName;
+   thread_data->program = program;
+   thread_data->uniformBlockIndex = uniformBlockIndex;
+   thread_data->bufSize = bufSize;
+   thread_data->length = length;
+   thread_data->uniformBlockName = uniformBlockName;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGetActiveUniformBlockName,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGetActiveUniformsiv(GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params);
+ * void
+ * glGetActiveUniformsiv(GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params);
  */
 
 typedef struct
@@ -24773,14 +24777,14 @@ void (*orig_evgl_api_glGetActiveUniformsiv)(GLuint program, GLsizei uniformCount
 static void
 _evgl_api_thread_glGetActiveUniformsiv(void *data)
 {
-   EVGL_API_Thread_Command_glGetActiveUniformsiv *thread_param =
+   EVGL_API_Thread_Command_glGetActiveUniformsiv *thread_data =
       (EVGL_API_Thread_Command_glGetActiveUniformsiv *)data;
 
-   orig_evgl_api_glGetActiveUniformsiv(thread_param->program,
-                                       thread_param->uniformCount,
-                                       thread_param->uniformIndices,
-                                       thread_param->pname,
-                                       thread_param->params);
+   orig_evgl_api_glGetActiveUniformsiv(thread_data->program,
+                                       thread_data->uniformCount,
+                                       thread_data->uniformIndices,
+                                       thread_data->pname,
+                                       thread_data->params);
 
 }
 
@@ -24795,24 +24799,24 @@ glGetActiveUniformsiv_evgl_api_thread_cmd(GLuint program, GLsizei uniformCount,
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGetActiveUniformsiv thread_param_local;
-   EVGL_API_Thread_Command_glGetActiveUniformsiv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGetActiveUniformsiv thread_data_local;
+   EVGL_API_Thread_Command_glGetActiveUniformsiv *thread_data = &thread_data_local;
 
-   thread_param->program = program;
-   thread_param->uniformCount = uniformCount;
-   thread_param->uniformIndices = uniformIndices;
-   thread_param->pname = pname;
-   thread_param->params = params;
+   thread_data->program = program;
+   thread_data->uniformCount = uniformCount;
+   thread_data->uniformIndices = uniformIndices;
+   thread_data->pname = pname;
+   thread_data->params = params;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGetActiveUniformsiv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGetBufferParameteri64v(GLenum target, GLenum value, EvasGLint64 * data);
+ * void
+ * glGetBufferParameteri64v(GLenum target, GLenum value, EvasGLint64 * data);
  */
 
 typedef struct
@@ -24828,12 +24832,12 @@ void (*orig_evgl_api_glGetBufferParameteri64v)(GLenum target, GLenum value, Evas
 static void
 _evgl_api_thread_glGetBufferParameteri64v(void *data)
 {
-   EVGL_API_Thread_Command_glGetBufferParameteri64v *thread_param =
+   EVGL_API_Thread_Command_glGetBufferParameteri64v *thread_data =
       (EVGL_API_Thread_Command_glGetBufferParameteri64v *)data;
 
-   orig_evgl_api_glGetBufferParameteri64v(thread_param->target,
-                                          thread_param->value,
-                                          thread_param->data);
+   orig_evgl_api_glGetBufferParameteri64v(thread_data->target,
+                                          thread_data->value,
+                                          thread_data->data);
 
 }
 
@@ -24848,22 +24852,22 @@ glGetBufferParameteri64v_evgl_api_thread_cmd(GLenum target, GLenum value, EvasGL
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGetBufferParameteri64v thread_param_local;
-   EVGL_API_Thread_Command_glGetBufferParameteri64v *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGetBufferParameteri64v thread_data_local;
+   EVGL_API_Thread_Command_glGetBufferParameteri64v *thread_data = &thread_data_local;
 
-   thread_param->target = target;
-   thread_param->value = value;
-   thread_param->data = data;
+   thread_data->target = target;
+   thread_data->value = value;
+   thread_data->data = data;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGetBufferParameteri64v,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGetBufferPointerv(GLenum target, GLenum pname, GLvoid ** params);
+ * void
+ * glGetBufferPointerv(GLenum target, GLenum pname, GLvoid ** params);
  */
 
 typedef struct
@@ -24879,12 +24883,12 @@ void (*orig_evgl_api_glGetBufferPointerv)(GLenum target, GLenum pname, GLvoid **
 static void
 _evgl_api_thread_glGetBufferPointerv(void *data)
 {
-   EVGL_API_Thread_Command_glGetBufferPointerv *thread_param =
+   EVGL_API_Thread_Command_glGetBufferPointerv *thread_data =
       (EVGL_API_Thread_Command_glGetBufferPointerv *)data;
 
-   orig_evgl_api_glGetBufferPointerv(thread_param->target,
-                                     thread_param->pname,
-                                     thread_param->params);
+   orig_evgl_api_glGetBufferPointerv(thread_data->target,
+                                     thread_data->pname,
+                                     thread_data->params);
 
 }
 
@@ -24899,22 +24903,22 @@ glGetBufferPointerv_evgl_api_thread_cmd(GLenum target, GLenum pname, GLvoid ** p
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGetBufferPointerv thread_param_local;
-   EVGL_API_Thread_Command_glGetBufferPointerv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGetBufferPointerv thread_data_local;
+   EVGL_API_Thread_Command_glGetBufferPointerv *thread_data = &thread_data_local;
 
-   thread_param->target = target;
-   thread_param->pname = pname;
-   thread_param->params = params;
+   thread_data->target = target;
+   thread_data->pname = pname;
+   thread_data->params = params;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGetBufferPointerv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   GLint
-   glGetFragDataLocation(GLuint program, const char * name);
+ * GLint
+ * glGetFragDataLocation(GLuint program, const char * name);
  */
 
 typedef struct
@@ -24930,11 +24934,11 @@ GLint (*orig_evgl_api_glGetFragDataLocation)(GLuint program, const char * name);
 static void
 _evgl_api_thread_glGetFragDataLocation(void *data)
 {
-   EVGL_API_Thread_Command_glGetFragDataLocation *thread_param =
+   EVGL_API_Thread_Command_glGetFragDataLocation *thread_data =
       (EVGL_API_Thread_Command_glGetFragDataLocation *)data;
 
-   thread_param->return_value = orig_evgl_api_glGetFragDataLocation(thread_param->program,
-                                                                    thread_param->name);
+   thread_data->return_value = orig_evgl_api_glGetFragDataLocation(thread_data->program,
+                                                                   thread_data->name);
 
 }
 
@@ -24948,23 +24952,23 @@ glGetFragDataLocation_evgl_api_thread_cmd(GLuint program, const char * name)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGetFragDataLocation thread_param_local;
-   EVGL_API_Thread_Command_glGetFragDataLocation *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGetFragDataLocation thread_data_local;
+   EVGL_API_Thread_Command_glGetFragDataLocation *thread_data = &thread_data_local;
 
-   thread_param->program = program;
-   thread_param->name = name;
+   thread_data->program = program;
+   thread_data->name = name;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGetFragDataLocation,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
-   void
-   glGetInteger64i_v(GLenum target, GLuint index, EvasGLint64 * data);
+ * void
+ * glGetInteger64i_v(GLenum target, GLuint index, EvasGLint64 * data);
  */
 
 typedef struct
@@ -24980,12 +24984,12 @@ void (*orig_evgl_api_glGetInteger64i_v)(GLenum target, GLuint index, EvasGLint64
 static void
 _evgl_api_thread_glGetInteger64i_v(void *data)
 {
-   EVGL_API_Thread_Command_glGetInteger64i_v *thread_param =
+   EVGL_API_Thread_Command_glGetInteger64i_v *thread_data =
       (EVGL_API_Thread_Command_glGetInteger64i_v *)data;
 
-   orig_evgl_api_glGetInteger64i_v(thread_param->target,
-                                   thread_param->index,
-                                   thread_param->data);
+   orig_evgl_api_glGetInteger64i_v(thread_data->target,
+                                   thread_data->index,
+                                   thread_data->data);
 
 }
 
@@ -25000,22 +25004,22 @@ glGetInteger64i_v_evgl_api_thread_cmd(GLenum target, GLuint index, EvasGLint64 *
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGetInteger64i_v thread_param_local;
-   EVGL_API_Thread_Command_glGetInteger64i_v *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGetInteger64i_v thread_data_local;
+   EVGL_API_Thread_Command_glGetInteger64i_v *thread_data = &thread_data_local;
 
-   thread_param->target = target;
-   thread_param->index = index;
-   thread_param->data = data;
+   thread_data->target = target;
+   thread_data->index = index;
+   thread_data->data = data;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGetInteger64i_v,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGetInteger64v(GLenum pname, EvasGLint64 * data);
+ * void
+ * glGetInteger64v(GLenum pname, EvasGLint64 * data);
  */
 
 typedef struct
@@ -25030,11 +25034,11 @@ void (*orig_evgl_api_glGetInteger64v)(GLenum pname, EvasGLint64 * data);
 static void
 _evgl_api_thread_glGetInteger64v(void *data)
 {
-   EVGL_API_Thread_Command_glGetInteger64v *thread_param =
+   EVGL_API_Thread_Command_glGetInteger64v *thread_data =
       (EVGL_API_Thread_Command_glGetInteger64v *)data;
 
-   orig_evgl_api_glGetInteger64v(thread_param->pname,
-                                 thread_param->data);
+   orig_evgl_api_glGetInteger64v(thread_data->pname,
+                                 thread_data->data);
 
 }
 
@@ -25049,21 +25053,21 @@ glGetInteger64v_evgl_api_thread_cmd(GLenum pname, EvasGLint64 * data)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGetInteger64v thread_param_local;
-   EVGL_API_Thread_Command_glGetInteger64v *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGetInteger64v thread_data_local;
+   EVGL_API_Thread_Command_glGetInteger64v *thread_data = &thread_data_local;
 
-   thread_param->pname = pname;
-   thread_param->data = data;
+   thread_data->pname = pname;
+   thread_data->data = data;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGetInteger64v,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGetIntegeri_v(GLenum target, GLuint index, GLint * data);
+ * void
+ * glGetIntegeri_v(GLenum target, GLuint index, GLint * data);
  */
 
 typedef struct
@@ -25079,12 +25083,12 @@ void (*orig_evgl_api_glGetIntegeri_v)(GLenum target, GLuint index, GLint * data)
 static void
 _evgl_api_thread_glGetIntegeri_v(void *data)
 {
-   EVGL_API_Thread_Command_glGetIntegeri_v *thread_param =
+   EVGL_API_Thread_Command_glGetIntegeri_v *thread_data =
       (EVGL_API_Thread_Command_glGetIntegeri_v *)data;
 
-   orig_evgl_api_glGetIntegeri_v(thread_param->target,
-                                 thread_param->index,
-                                 thread_param->data);
+   orig_evgl_api_glGetIntegeri_v(thread_data->target,
+                                 thread_data->index,
+                                 thread_data->data);
 
 }
 
@@ -25099,22 +25103,22 @@ glGetIntegeri_v_evgl_api_thread_cmd(GLenum target, GLuint index, GLint * data)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGetIntegeri_v thread_param_local;
-   EVGL_API_Thread_Command_glGetIntegeri_v *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGetIntegeri_v thread_data_local;
+   EVGL_API_Thread_Command_glGetIntegeri_v *thread_data = &thread_data_local;
 
-   thread_param->target = target;
-   thread_param->index = index;
-   thread_param->data = data;
+   thread_data->target = target;
+   thread_data->index = index;
+   thread_data->data = data;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGetIntegeri_v,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGetInternalformativ(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint *params);
+ * void
+ * glGetInternalformativ(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint *params);
  */
 
 typedef struct
@@ -25132,14 +25136,14 @@ void (*orig_evgl_api_glGetInternalformativ)(GLenum target, GLenum internalformat
 static void
 _evgl_api_thread_glGetInternalformativ(void *data)
 {
-   EVGL_API_Thread_Command_glGetInternalformativ *thread_param =
+   EVGL_API_Thread_Command_glGetInternalformativ *thread_data =
       (EVGL_API_Thread_Command_glGetInternalformativ *)data;
 
-   orig_evgl_api_glGetInternalformativ(thread_param->target,
-                                       thread_param->internalformat,
-                                       thread_param->pname,
-                                       thread_param->bufSize,
-                                       thread_param->params);
+   orig_evgl_api_glGetInternalformativ(thread_data->target,
+                                       thread_data->internalformat,
+                                       thread_data->pname,
+                                       thread_data->bufSize,
+                                       thread_data->params);
 
 }
 
@@ -25154,24 +25158,24 @@ glGetInternalformativ_evgl_api_thread_cmd(GLenum target, GLenum internalformat,
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGetInternalformativ thread_param_local;
-   EVGL_API_Thread_Command_glGetInternalformativ *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGetInternalformativ thread_data_local;
+   EVGL_API_Thread_Command_glGetInternalformativ *thread_data = &thread_data_local;
 
-   thread_param->target = target;
-   thread_param->internalformat = internalformat;
-   thread_param->pname = pname;
-   thread_param->bufSize = bufSize;
-   thread_param->params = params;
+   thread_data->target = target;
+   thread_data->internalformat = internalformat;
+   thread_data->pname = pname;
+   thread_data->bufSize = bufSize;
+   thread_data->params = params;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGetInternalformativ,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGetProgramBinary(GLuint program, GLsizei bufsize, GLsizei *length, GLenum *binaryFormat, void *binary);
+ * void
+ * glGetProgramBinary(GLuint program, GLsizei bufsize, GLsizei *length, GLenum *binaryFormat, void *binary);
  */
 
 typedef struct
@@ -25189,14 +25193,14 @@ void (*orig_evgl_api_glGetProgramBinary)(GLuint program, GLsizei bufsize, GLsize
 static void
 _evgl_api_thread_glGetProgramBinary(void *data)
 {
-   EVGL_API_Thread_Command_glGetProgramBinary *thread_param =
+   EVGL_API_Thread_Command_glGetProgramBinary *thread_data =
       (EVGL_API_Thread_Command_glGetProgramBinary *)data;
 
-   orig_evgl_api_glGetProgramBinary(thread_param->program,
-                                    thread_param->bufsize,
-                                    thread_param->length,
-                                    thread_param->binaryFormat,
-                                    thread_param->binary);
+   orig_evgl_api_glGetProgramBinary(thread_data->program,
+                                    thread_data->bufsize,
+                                    thread_data->length,
+                                    thread_data->binaryFormat,
+                                    thread_data->binary);
 
 }
 
@@ -25211,24 +25215,24 @@ glGetProgramBinary_evgl_api_thread_cmd(GLuint program, GLsizei bufsize, GLsizei
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGetProgramBinary thread_param_local;
-   EVGL_API_Thread_Command_glGetProgramBinary *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGetProgramBinary thread_data_local;
+   EVGL_API_Thread_Command_glGetProgramBinary *thread_data = &thread_data_local;
 
-   thread_param->program = program;
-   thread_param->bufsize = bufsize;
-   thread_param->length = length;
-   thread_param->binaryFormat = binaryFormat;
-   thread_param->binary = binary;
+   thread_data->program = program;
+   thread_data->bufsize = bufsize;
+   thread_data->length = length;
+   thread_data->binaryFormat = binaryFormat;
+   thread_data->binary = binary;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGetProgramBinary,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGetQueryiv(GLenum target, GLenum pname, GLint * params);
+ * void
+ * glGetQueryiv(GLenum target, GLenum pname, GLint * params);
  */
 
 typedef struct
@@ -25244,12 +25248,12 @@ void (*orig_evgl_api_glGetQueryiv)(GLenum target, GLenum pname, GLint * params);
 static void
 _evgl_api_thread_glGetQueryiv(void *data)
 {
-   EVGL_API_Thread_Command_glGetQueryiv *thread_param =
+   EVGL_API_Thread_Command_glGetQueryiv *thread_data =
       (EVGL_API_Thread_Command_glGetQueryiv *)data;
 
-   orig_evgl_api_glGetQueryiv(thread_param->target,
-                              thread_param->pname,
-                              thread_param->params);
+   orig_evgl_api_glGetQueryiv(thread_data->target,
+                              thread_data->pname,
+                              thread_data->params);
 
 }
 
@@ -25264,22 +25268,22 @@ glGetQueryiv_evgl_api_thread_cmd(GLenum target, GLenum pname, GLint * params)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGetQueryiv thread_param_local;
-   EVGL_API_Thread_Command_glGetQueryiv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGetQueryiv thread_data_local;
+   EVGL_API_Thread_Command_glGetQueryiv *thread_data = &thread_data_local;
 
-   thread_param->target = target;
-   thread_param->pname = pname;
-   thread_param->params = params;
+   thread_data->target = target;
+   thread_data->pname = pname;
+   thread_data->params = params;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGetQueryiv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGetQueryObjectuiv(GLuint id, GLenum pname, GLuint * params);
+ * void
+ * glGetQueryObjectuiv(GLuint id, GLenum pname, GLuint * params);
  */
 
 typedef struct
@@ -25295,12 +25299,12 @@ void (*orig_evgl_api_glGetQueryObjectuiv)(GLuint id, GLenum pname, GLuint * para
 static void
 _evgl_api_thread_glGetQueryObjectuiv(void *data)
 {
-   EVGL_API_Thread_Command_glGetQueryObjectuiv *thread_param =
+   EVGL_API_Thread_Command_glGetQueryObjectuiv *thread_data =
       (EVGL_API_Thread_Command_glGetQueryObjectuiv *)data;
 
-   orig_evgl_api_glGetQueryObjectuiv(thread_param->id,
-                                     thread_param->pname,
-                                     thread_param->params);
+   orig_evgl_api_glGetQueryObjectuiv(thread_data->id,
+                                     thread_data->pname,
+                                     thread_data->params);
 
 }
 
@@ -25315,22 +25319,22 @@ glGetQueryObjectuiv_evgl_api_thread_cmd(GLuint id, GLenum pname, GLuint * params
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGetQueryObjectuiv thread_param_local;
-   EVGL_API_Thread_Command_glGetQueryObjectuiv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGetQueryObjectuiv thread_data_local;
+   EVGL_API_Thread_Command_glGetQueryObjectuiv *thread_data = &thread_data_local;
 
-   thread_param->id = id;
-   thread_param->pname = pname;
-   thread_param->params = params;
+   thread_data->id = id;
+   thread_data->pname = pname;
+   thread_data->params = params;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGetQueryObjectuiv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat * params);
+ * void
+ * glGetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat * params);
  */
 
 typedef struct
@@ -25346,12 +25350,12 @@ void (*orig_evgl_api_glGetSamplerParameterfv)(GLuint sampler, GLenum pname, GLfl
 static void
 _evgl_api_thread_glGetSamplerParameterfv(void *data)
 {
-   EVGL_API_Thread_Command_glGetSamplerParameterfv *thread_param =
+   EVGL_API_Thread_Command_glGetSamplerParameterfv *thread_data =
       (EVGL_API_Thread_Command_glGetSamplerParameterfv *)data;
 
-   orig_evgl_api_glGetSamplerParameterfv(thread_param->sampler,
-                                         thread_param->pname,
-                                         thread_param->params);
+   orig_evgl_api_glGetSamplerParameterfv(thread_data->sampler,
+                                         thread_data->pname,
+                                         thread_data->params);
 
 }
 
@@ -25366,22 +25370,22 @@ glGetSamplerParameterfv_evgl_api_thread_cmd(GLuint sampler, GLenum pname, GLfloa
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGetSamplerParameterfv thread_param_local;
-   EVGL_API_Thread_Command_glGetSamplerParameterfv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGetSamplerParameterfv thread_data_local;
+   EVGL_API_Thread_Command_glGetSamplerParameterfv *thread_data = &thread_data_local;
 
-   thread_param->sampler = sampler;
-   thread_param->pname = pname;
-   thread_param->params = params;
+   thread_data->sampler = sampler;
+   thread_data->pname = pname;
+   thread_data->params = params;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGetSamplerParameterfv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGetSamplerParameteriv(GLuint sampler, GLenum pname, GLint * params);
+ * void
+ * glGetSamplerParameteriv(GLuint sampler, GLenum pname, GLint * params);
  */
 
 typedef struct
@@ -25397,12 +25401,12 @@ void (*orig_evgl_api_glGetSamplerParameteriv)(GLuint sampler, GLenum pname, GLin
 static void
 _evgl_api_thread_glGetSamplerParameteriv(void *data)
 {
-   EVGL_API_Thread_Command_glGetSamplerParameteriv *thread_param =
+   EVGL_API_Thread_Command_glGetSamplerParameteriv *thread_data =
       (EVGL_API_Thread_Command_glGetSamplerParameteriv *)data;
 
-   orig_evgl_api_glGetSamplerParameteriv(thread_param->sampler,
-                                         thread_param->pname,
-                                         thread_param->params);
+   orig_evgl_api_glGetSamplerParameteriv(thread_data->sampler,
+                                         thread_data->pname,
+                                         thread_data->params);
 
 }
 
@@ -25417,22 +25421,22 @@ glGetSamplerParameteriv_evgl_api_thread_cmd(GLuint sampler, GLenum pname, GLint
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGetSamplerParameteriv thread_param_local;
-   EVGL_API_Thread_Command_glGetSamplerParameteriv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGetSamplerParameteriv thread_data_local;
+   EVGL_API_Thread_Command_glGetSamplerParameteriv *thread_data = &thread_data_local;
 
-   thread_param->sampler = sampler;
-   thread_param->pname = pname;
-   thread_param->params = params;
+   thread_data->sampler = sampler;
+   thread_data->pname = pname;
+   thread_data->params = params;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGetSamplerParameteriv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   const GLubyte *
-   glGetStringi(GLenum name, GLuint index);
+ * const GLubyte *
+ * glGetStringi(GLenum name, GLuint index);
  */
 
 typedef struct
@@ -25448,11 +25452,11 @@ const GLubyte * (*orig_evgl_api_glGetStringi)(GLenum name, GLuint index);
 static void
 _evgl_api_thread_glGetStringi(void *data)
 {
-   EVGL_API_Thread_Command_glGetStringi *thread_param =
+   EVGL_API_Thread_Command_glGetStringi *thread_data =
       (EVGL_API_Thread_Command_glGetStringi *)data;
 
-   thread_param->return_value = orig_evgl_api_glGetStringi(thread_param->name,
-                                                           thread_param->index);
+   thread_data->return_value = orig_evgl_api_glGetStringi(thread_data->name,
+                                                          thread_data->index);
 
 }
 
@@ -25466,23 +25470,23 @@ glGetStringi_evgl_api_thread_cmd(GLenum name, GLuint index)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGetStringi thread_param_local;
-   EVGL_API_Thread_Command_glGetStringi *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGetStringi thread_data_local;
+   EVGL_API_Thread_Command_glGetStringi *thread_data = &thread_data_local;
 
-   thread_param->name = name;
-   thread_param->index = index;
+   thread_data->name = name;
+   thread_data->index = index;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGetStringi,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
-   void
-   glGetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *values);
+ * void
+ * glGetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *values);
  */
 
 typedef struct
@@ -25500,14 +25504,14 @@ void (*orig_evgl_api_glGetSynciv)(GLsync sync, GLenum pname, GLsizei bufSize, GL
 static void
 _evgl_api_thread_glGetSynciv(void *data)
 {
-   EVGL_API_Thread_Command_glGetSynciv *thread_param =
+   EVGL_API_Thread_Command_glGetSynciv *thread_data =
       (EVGL_API_Thread_Command_glGetSynciv *)data;
 
-   orig_evgl_api_glGetSynciv(thread_param->sync,
-                             thread_param->pname,
-                             thread_param->bufSize,
-                             thread_param->length,
-                             thread_param->values);
+   orig_evgl_api_glGetSynciv(thread_data->sync,
+                             thread_data->pname,
+                             thread_data->bufSize,
+                             thread_data->length,
+                             thread_data->values);
 
 }
 
@@ -25522,24 +25526,24 @@ glGetSynciv_evgl_api_thread_cmd(GLsync sync, GLenum pname, GLsizei bufSize, GLsi
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGetSynciv thread_param_local;
-   EVGL_API_Thread_Command_glGetSynciv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGetSynciv thread_data_local;
+   EVGL_API_Thread_Command_glGetSynciv *thread_data = &thread_data_local;
 
-   thread_param->sync = sync;
-   thread_param->pname = pname;
-   thread_param->bufSize = bufSize;
-   thread_param->length = length;
-   thread_param->values = values;
+   thread_data->sync = sync;
+   thread_data->pname = pname;
+   thread_data->bufSize = bufSize;
+   thread_data->length = length;
+   thread_data->values = values;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGetSynciv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei * length, GLsizei * size, GLenum * type, char * name);
+ * void
+ * glGetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei * length, GLsizei * size, GLenum * type, char * name);
  */
 
 typedef struct
@@ -25559,16 +25563,16 @@ void (*orig_evgl_api_glGetTransformFeedbackVarying)(GLuint program, GLuint index
 static void
 _evgl_api_thread_glGetTransformFeedbackVarying(void *data)
 {
-   EVGL_API_Thread_Command_glGetTransformFeedbackVarying *thread_param =
+   EVGL_API_Thread_Command_glGetTransformFeedbackVarying *thread_data =
       (EVGL_API_Thread_Command_glGetTransformFeedbackVarying *)data;
 
-   orig_evgl_api_glGetTransformFeedbackVarying(thread_param->program,
-                                               thread_param->index,
-                                               thread_param->bufSize,
-                                               thread_param->length,
-                                               thread_param->size,
-                                               thread_param->type,
-                                               thread_param->name);
+   orig_evgl_api_glGetTransformFeedbackVarying(thread_data->program,
+                                               thread_data->index,
+                                               thread_data->bufSize,
+                                               thread_data->length,
+                                               thread_data->size,
+                                               thread_data->type,
+                                               thread_data->name);
 
 }
 
@@ -25583,26 +25587,26 @@ glGetTransformFeedbackVarying_evgl_api_thread_cmd(GLuint program, GLuint index,
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGetTransformFeedbackVarying thread_param_local;
-   EVGL_API_Thread_Command_glGetTransformFeedbackVarying *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGetTransformFeedbackVarying thread_data_local;
+   EVGL_API_Thread_Command_glGetTransformFeedbackVarying *thread_data = &thread_data_local;
 
-   thread_param->program = program;
-   thread_param->index = index;
-   thread_param->bufSize = bufSize;
-   thread_param->length = length;
-   thread_param->size = size;
-   thread_param->type = type;
-   thread_param->name = name;
+   thread_data->program = program;
+   thread_data->index = index;
+   thread_data->bufSize = bufSize;
+   thread_data->length = length;
+   thread_data->size = size;
+   thread_data->type = type;
+   thread_data->name = name;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGetTransformFeedbackVarying,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   GLuint
-   glGetUniformBlockIndex(GLuint program, const GLchar *uniformBlockName);
+ * GLuint
+ * glGetUniformBlockIndex(GLuint program, const GLchar *uniformBlockName);
  */
 
 typedef struct
@@ -25618,11 +25622,11 @@ GLuint (*orig_evgl_api_glGetUniformBlockIndex)(GLuint program, const GLchar *uni
 static void
 _evgl_api_thread_glGetUniformBlockIndex(void *data)
 {
-   EVGL_API_Thread_Command_glGetUniformBlockIndex *thread_param =
+   EVGL_API_Thread_Command_glGetUniformBlockIndex *thread_data =
       (EVGL_API_Thread_Command_glGetUniformBlockIndex *)data;
 
-   thread_param->return_value = orig_evgl_api_glGetUniformBlockIndex(thread_param->program,
-                                                                     thread_param->uniformBlockName);
+   thread_data->return_value = orig_evgl_api_glGetUniformBlockIndex(thread_data->program,
+                                                                    thread_data->uniformBlockName);
 
 }
 
@@ -25636,23 +25640,23 @@ glGetUniformBlockIndex_evgl_api_thread_cmd(GLuint program, const GLchar *uniform
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGetUniformBlockIndex thread_param_local;
-   EVGL_API_Thread_Command_glGetUniformBlockIndex *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGetUniformBlockIndex thread_data_local;
+   EVGL_API_Thread_Command_glGetUniformBlockIndex *thread_data = &thread_data_local;
 
-   thread_param->program = program;
-   thread_param->uniformBlockName = uniformBlockName;
+   thread_data->program = program;
+   thread_data->uniformBlockName = uniformBlockName;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGetUniformBlockIndex,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
-   void
-   glGetUniformIndices(GLuint program, GLsizei uniformCount, const GLchar *const*uniformNames, GLuint *uniformIndices);
+ * void
+ * glGetUniformIndices(GLuint program, GLsizei uniformCount, const GLchar *const*uniformNames, GLuint *uniformIndices);
  */
 
 typedef struct
@@ -25669,13 +25673,13 @@ void (*orig_evgl_api_glGetUniformIndices)(GLuint program, GLsizei uniformCount,
 static void
 _evgl_api_thread_glGetUniformIndices(void *data)
 {
-   EVGL_API_Thread_Command_glGetUniformIndices *thread_param =
+   EVGL_API_Thread_Command_glGetUniformIndices *thread_data =
       (EVGL_API_Thread_Command_glGetUniformIndices *)data;
 
-   orig_evgl_api_glGetUniformIndices(thread_param->program,
-                                     thread_param->uniformCount,
-                                     thread_param->uniformNames,
-                                     thread_param->uniformIndices);
+   orig_evgl_api_glGetUniformIndices(thread_data->program,
+                                     thread_data->uniformCount,
+                                     thread_data->uniformNames,
+                                     thread_data->uniformIndices);
 
 }
 
@@ -25690,23 +25694,23 @@ glGetUniformIndices_evgl_api_thread_cmd(GLuint program, GLsizei uniformCount, co
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGetUniformIndices thread_param_local;
-   EVGL_API_Thread_Command_glGetUniformIndices *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGetUniformIndices thread_data_local;
+   EVGL_API_Thread_Command_glGetUniformIndices *thread_data = &thread_data_local;
 
-   thread_param->program = program;
-   thread_param->uniformCount = uniformCount;
-   thread_param->uniformNames = uniformNames;
-   thread_param->uniformIndices = uniformIndices;
+   thread_data->program = program;
+   thread_data->uniformCount = uniformCount;
+   thread_data->uniformNames = uniformNames;
+   thread_data->uniformIndices = uniformIndices;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGetUniformIndices,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGetUniformuiv(GLuint program, GLint location, GLuint* params);
+ * void
+ * glGetUniformuiv(GLuint program, GLint location, GLuint* params);
  */
 
 typedef struct
@@ -25722,12 +25726,12 @@ void (*orig_evgl_api_glGetUniformuiv)(GLuint program, GLint location, GLuint* pa
 static void
 _evgl_api_thread_glGetUniformuiv(void *data)
 {
-   EVGL_API_Thread_Command_glGetUniformuiv *thread_param =
+   EVGL_API_Thread_Command_glGetUniformuiv *thread_data =
       (EVGL_API_Thread_Command_glGetUniformuiv *)data;
 
-   orig_evgl_api_glGetUniformuiv(thread_param->program,
-                                 thread_param->location,
-                                 thread_param->params);
+   orig_evgl_api_glGetUniformuiv(thread_data->program,
+                                 thread_data->location,
+                                 thread_data->params);
 
 }
 
@@ -25742,22 +25746,22 @@ glGetUniformuiv_evgl_api_thread_cmd(GLuint program, GLint location, GLuint* para
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGetUniformuiv thread_param_local;
-   EVGL_API_Thread_Command_glGetUniformuiv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGetUniformuiv thread_data_local;
+   EVGL_API_Thread_Command_glGetUniformuiv *thread_data = &thread_data_local;
 
-   thread_param->program = program;
-   thread_param->location = location;
-   thread_param->params = params;
+   thread_data->program = program;
+   thread_data->location = location;
+   thread_data->params = params;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGetUniformuiv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGetVertexAttribIiv(GLuint index, GLenum pname, GLint *params);
+ * void
+ * glGetVertexAttribIiv(GLuint index, GLenum pname, GLint *params);
  */
 
 typedef struct
@@ -25773,12 +25777,12 @@ void (*orig_evgl_api_glGetVertexAttribIiv)(GLuint index, GLenum pname, GLint *pa
 static void
 _evgl_api_thread_glGetVertexAttribIiv(void *data)
 {
-   EVGL_API_Thread_Command_glGetVertexAttribIiv *thread_param =
+   EVGL_API_Thread_Command_glGetVertexAttribIiv *thread_data =
       (EVGL_API_Thread_Command_glGetVertexAttribIiv *)data;
 
-   orig_evgl_api_glGetVertexAttribIiv(thread_param->index,
-                                      thread_param->pname,
-                                      thread_param->params);
+   orig_evgl_api_glGetVertexAttribIiv(thread_data->index,
+                                      thread_data->pname,
+                                      thread_data->params);
 
 }
 
@@ -25793,22 +25797,22 @@ glGetVertexAttribIiv_evgl_api_thread_cmd(GLuint index, GLenum pname, GLint *para
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGetVertexAttribIiv thread_param_local;
-   EVGL_API_Thread_Command_glGetVertexAttribIiv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGetVertexAttribIiv thread_data_local;
+   EVGL_API_Thread_Command_glGetVertexAttribIiv *thread_data = &thread_data_local;
 
-   thread_param->index = index;
-   thread_param->pname = pname;
-   thread_param->params = params;
+   thread_data->index = index;
+   thread_data->pname = pname;
+   thread_data->params = params;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGetVertexAttribIiv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGetVertexAttribIuiv(GLuint index, GLenum pname, GLuint *params);
+ * void
+ * glGetVertexAttribIuiv(GLuint index, GLenum pname, GLuint *params);
  */
 
 typedef struct
@@ -25824,12 +25828,12 @@ void (*orig_evgl_api_glGetVertexAttribIuiv)(GLuint index, GLenum pname, GLuint *
 static void
 _evgl_api_thread_glGetVertexAttribIuiv(void *data)
 {
-   EVGL_API_Thread_Command_glGetVertexAttribIuiv *thread_param =
+   EVGL_API_Thread_Command_glGetVertexAttribIuiv *thread_data =
       (EVGL_API_Thread_Command_glGetVertexAttribIuiv *)data;
 
-   orig_evgl_api_glGetVertexAttribIuiv(thread_param->index,
-                                       thread_param->pname,
-                                       thread_param->params);
+   orig_evgl_api_glGetVertexAttribIuiv(thread_data->index,
+                                       thread_data->pname,
+                                       thread_data->params);
 
 }
 
@@ -25844,22 +25848,22 @@ glGetVertexAttribIuiv_evgl_api_thread_cmd(GLuint index, GLenum pname, GLuint *pa
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGetVertexAttribIuiv thread_param_local;
-   EVGL_API_Thread_Command_glGetVertexAttribIuiv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGetVertexAttribIuiv thread_data_local;
+   EVGL_API_Thread_Command_glGetVertexAttribIuiv *thread_data = &thread_data_local;
 
-   thread_param->index = index;
-   thread_param->pname = pname;
-   thread_param->params = params;
+   thread_data->index = index;
+   thread_data->pname = pname;
+   thread_data->params = params;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGetVertexAttribIuiv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glInvalidateFramebuffer(GLenum target, GLsizei numAttachments, const GLenum *attachments);
+ * void
+ * glInvalidateFramebuffer(GLenum target, GLsizei numAttachments, const GLenum *attachments);
  */
 
 typedef struct
@@ -25875,12 +25879,12 @@ void (*orig_evgl_api_glInvalidateFramebuffer)(GLenum target, GLsizei numAttachme
 static void
 _evgl_api_thread_glInvalidateFramebuffer(void *data)
 {
-   EVGL_API_Thread_Command_glInvalidateFramebuffer *thread_param =
+   EVGL_API_Thread_Command_glInvalidateFramebuffer *thread_data =
       (EVGL_API_Thread_Command_glInvalidateFramebuffer *)data;
 
-   orig_evgl_api_glInvalidateFramebuffer(thread_param->target,
-                                         thread_param->numAttachments,
-                                         thread_param->attachments);
+   orig_evgl_api_glInvalidateFramebuffer(thread_data->target,
+                                         thread_data->numAttachments,
+                                         thread_data->attachments);
 
 }
 
@@ -25895,22 +25899,22 @@ glInvalidateFramebuffer_evgl_api_thread_cmd(GLenum target, GLsizei numAttachment
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glInvalidateFramebuffer thread_param_local;
-   EVGL_API_Thread_Command_glInvalidateFramebuffer *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glInvalidateFramebuffer thread_data_local;
+   EVGL_API_Thread_Command_glInvalidateFramebuffer *thread_data = &thread_data_local;
 
-   thread_param->target = target;
-   thread_param->numAttachments = numAttachments;
-   thread_param->attachments = attachments;
+   thread_data->target = target;
+   thread_data->numAttachments = numAttachments;
+   thread_data->attachments = attachments;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glInvalidateFramebuffer,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glInvalidateSubFramebuffer(GLenum target, GLsizei numAttachments, const GLenum *attachments, GLint x, GLint y, GLsizei width, GLsizei height);
+ * void
+ * glInvalidateSubFramebuffer(GLenum target, GLsizei numAttachments, const GLenum *attachments, GLint x, GLint y, GLsizei width, GLsizei height);
  */
 
 typedef struct
@@ -25930,16 +25934,16 @@ void (*orig_evgl_api_glInvalidateSubFramebuffer)(GLenum target, GLsizei numAttac
 static void
 _evgl_api_thread_glInvalidateSubFramebuffer(void *data)
 {
-   EVGL_API_Thread_Command_glInvalidateSubFramebuffer *thread_param =
+   EVGL_API_Thread_Command_glInvalidateSubFramebuffer *thread_data =
       (EVGL_API_Thread_Command_glInvalidateSubFramebuffer *)data;
 
-   orig_evgl_api_glInvalidateSubFramebuffer(thread_param->target,
-                                            thread_param->numAttachments,
-                                            thread_param->attachments,
-                                            thread_param->x,
-                                            thread_param->y,
-                                            thread_param->width,
-                                            thread_param->height);
+   orig_evgl_api_glInvalidateSubFramebuffer(thread_data->target,
+                                            thread_data->numAttachments,
+                                            thread_data->attachments,
+                                            thread_data->x,
+                                            thread_data->y,
+                                            thread_data->width,
+                                            thread_data->height);
 
 }
 
@@ -25954,26 +25958,26 @@ glInvalidateSubFramebuffer_evgl_api_thread_cmd(GLenum target, GLsizei numAttachm
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glInvalidateSubFramebuffer thread_param_local;
-   EVGL_API_Thread_Command_glInvalidateSubFramebuffer *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glInvalidateSubFramebuffer thread_data_local;
+   EVGL_API_Thread_Command_glInvalidateSubFramebuffer *thread_data = &thread_data_local;
 
-   thread_param->target = target;
-   thread_param->numAttachments = numAttachments;
-   thread_param->attachments = attachments;
-   thread_param->x = x;
-   thread_param->y = y;
-   thread_param->width = width;
-   thread_param->height = height;
+   thread_data->target = target;
+   thread_data->numAttachments = numAttachments;
+   thread_data->attachments = attachments;
+   thread_data->x = x;
+   thread_data->y = y;
+   thread_data->width = width;
+   thread_data->height = height;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glInvalidateSubFramebuffer,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   GLboolean
-   glIsQuery(GLuint id);
+ * GLboolean
+ * glIsQuery(GLuint id);
  */
 
 typedef struct
@@ -25988,10 +25992,10 @@ GLboolean (*orig_evgl_api_glIsQuery)(GLuint id);
 static void
 _evgl_api_thread_glIsQuery(void *data)
 {
-   EVGL_API_Thread_Command_glIsQuery *thread_param =
+   EVGL_API_Thread_Command_glIsQuery *thread_data =
       (EVGL_API_Thread_Command_glIsQuery *)data;
 
-   thread_param->return_value = orig_evgl_api_glIsQuery(thread_param->id);
+   thread_data->return_value = orig_evgl_api_glIsQuery(thread_data->id);
 
 }
 
@@ -26005,22 +26009,22 @@ glIsQuery_evgl_api_thread_cmd(GLuint id)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glIsQuery thread_param_local;
-   EVGL_API_Thread_Command_glIsQuery *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glIsQuery thread_data_local;
+   EVGL_API_Thread_Command_glIsQuery *thread_data = &thread_data_local;
 
-   thread_param->id = id;
+   thread_data->id = id;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glIsQuery,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
-   GLboolean
-   glIsSampler(GLuint id);
+ * GLboolean
+ * glIsSampler(GLuint id);
  */
 
 typedef struct
@@ -26035,10 +26039,10 @@ GLboolean (*orig_evgl_api_glIsSampler)(GLuint id);
 static void
 _evgl_api_thread_glIsSampler(void *data)
 {
-   EVGL_API_Thread_Command_glIsSampler *thread_param =
+   EVGL_API_Thread_Command_glIsSampler *thread_data =
       (EVGL_API_Thread_Command_glIsSampler *)data;
 
-   thread_param->return_value = orig_evgl_api_glIsSampler(thread_param->id);
+   thread_data->return_value = orig_evgl_api_glIsSampler(thread_data->id);
 
 }
 
@@ -26052,22 +26056,22 @@ glIsSampler_evgl_api_thread_cmd(GLuint id)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glIsSampler thread_param_local;
-   EVGL_API_Thread_Command_glIsSampler *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glIsSampler thread_data_local;
+   EVGL_API_Thread_Command_glIsSampler *thread_data = &thread_data_local;
 
-   thread_param->id = id;
+   thread_data->id = id;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glIsSampler,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
-   GLboolean
-   glIsSync(GLsync sync);
+ * GLboolean
+ * glIsSync(GLsync sync);
  */
 
 typedef struct
@@ -26082,10 +26086,10 @@ GLboolean (*orig_evgl_api_glIsSync)(GLsync sync);
 static void
 _evgl_api_thread_glIsSync(void *data)
 {
-   EVGL_API_Thread_Command_glIsSync *thread_param =
+   EVGL_API_Thread_Command_glIsSync *thread_data =
       (EVGL_API_Thread_Command_glIsSync *)data;
 
-   thread_param->return_value = orig_evgl_api_glIsSync(thread_param->sync);
+   thread_data->return_value = orig_evgl_api_glIsSync(thread_data->sync);
 
 }
 
@@ -26099,22 +26103,22 @@ glIsSync_evgl_api_thread_cmd(GLsync sync)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glIsSync thread_param_local;
-   EVGL_API_Thread_Command_glIsSync *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glIsSync thread_data_local;
+   EVGL_API_Thread_Command_glIsSync *thread_data = &thread_data_local;
 
-   thread_param->sync = sync;
+   thread_data->sync = sync;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glIsSync,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
-   GLboolean
-   glIsTransformFeedback(GLuint id);
+ * GLboolean
+ * glIsTransformFeedback(GLuint id);
  */
 
 typedef struct
@@ -26129,10 +26133,10 @@ GLboolean (*orig_evgl_api_glIsTransformFeedback)(GLuint id);
 static void
 _evgl_api_thread_glIsTransformFeedback(void *data)
 {
-   EVGL_API_Thread_Command_glIsTransformFeedback *thread_param =
+   EVGL_API_Thread_Command_glIsTransformFeedback *thread_data =
       (EVGL_API_Thread_Command_glIsTransformFeedback *)data;
 
-   thread_param->return_value = orig_evgl_api_glIsTransformFeedback(thread_param->id);
+   thread_data->return_value = orig_evgl_api_glIsTransformFeedback(thread_data->id);
 
 }
 
@@ -26146,22 +26150,22 @@ glIsTransformFeedback_evgl_api_thread_cmd(GLuint id)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glIsTransformFeedback thread_param_local;
-   EVGL_API_Thread_Command_glIsTransformFeedback *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glIsTransformFeedback thread_data_local;
+   EVGL_API_Thread_Command_glIsTransformFeedback *thread_data = &thread_data_local;
 
-   thread_param->id = id;
+   thread_data->id = id;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glIsTransformFeedback,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
-   GLboolean
-   glIsVertexArray(GLuint array);
+ * GLboolean
+ * glIsVertexArray(GLuint array);
  */
 
 typedef struct
@@ -26176,10 +26180,10 @@ GLboolean (*orig_evgl_api_glIsVertexArray)(GLuint array);
 static void
 _evgl_api_thread_glIsVertexArray(void *data)
 {
-   EVGL_API_Thread_Command_glIsVertexArray *thread_param =
+   EVGL_API_Thread_Command_glIsVertexArray *thread_data =
       (EVGL_API_Thread_Command_glIsVertexArray *)data;
 
-   thread_param->return_value = orig_evgl_api_glIsVertexArray(thread_param->array);
+   thread_data->return_value = orig_evgl_api_glIsVertexArray(thread_data->array);
 
 }
 
@@ -26193,22 +26197,22 @@ glIsVertexArray_evgl_api_thread_cmd(GLuint array)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glIsVertexArray thread_param_local;
-   EVGL_API_Thread_Command_glIsVertexArray *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glIsVertexArray thread_data_local;
+   EVGL_API_Thread_Command_glIsVertexArray *thread_data = &thread_data_local;
 
-   thread_param->array = array;
+   thread_data->array = array;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glIsVertexArray,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
-   void *
-   glMapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access);
+ * void *
+ * glMapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access);
  */
 
 typedef struct
@@ -26226,13 +26230,13 @@ void * (*orig_evgl_api_glMapBufferRange)(GLenum target, GLintptr offset, GLsizei
 static void
 _evgl_api_thread_glMapBufferRange(void *data)
 {
-   EVGL_API_Thread_Command_glMapBufferRange *thread_param =
+   EVGL_API_Thread_Command_glMapBufferRange *thread_data =
       (EVGL_API_Thread_Command_glMapBufferRange *)data;
 
-   thread_param->return_value = orig_evgl_api_glMapBufferRange(thread_param->target,
-                                                               thread_param->offset,
-                                                               thread_param->length,
-                                                               thread_param->access);
+   thread_data->return_value = orig_evgl_api_glMapBufferRange(thread_data->target,
+                                                              thread_data->offset,
+                                                              thread_data->length,
+                                                              thread_data->access);
 
 }
 
@@ -26246,25 +26250,25 @@ glMapBufferRange_evgl_api_thread_cmd(GLenum target, GLintptr offset, GLsizeiptr
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glMapBufferRange thread_param_local;
-   EVGL_API_Thread_Command_glMapBufferRange *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glMapBufferRange thread_data_local;
+   EVGL_API_Thread_Command_glMapBufferRange *thread_data = &thread_data_local;
 
-   thread_param->target = target;
-   thread_param->offset = offset;
-   thread_param->length = length;
-   thread_param->access = access;
+   thread_data->target = target;
+   thread_data->offset = offset;
+   thread_data->length = length;
+   thread_data->access = access;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glMapBufferRange,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
-   void
-   glPauseTransformFeedback(void);
+ * void
+ * glPauseTransformFeedback(void);
  */
 
 void (*orig_evgl_api_glPauseTransformFeedback)(void);
@@ -26294,8 +26298,8 @@ glPauseTransformFeedback_evgl_api_thread_cmd(void)
 }
 
 /*
-   void
-   glProgramBinary(GLuint program, GLenum binaryFormat, const void *binary, GLsizei length);
+ * void
+ * glProgramBinary(GLuint program, GLenum binaryFormat, const void *binary, GLsizei length);
  */
 
 typedef struct
@@ -26314,20 +26318,20 @@ void (*orig_evgl_api_glProgramBinary)(GLuint program, GLenum binaryFormat, const
 static void
 _evgl_api_thread_glProgramBinary(void *data)
 {
-   EVGL_API_Thread_Command_glProgramBinary *thread_param =
+   EVGL_API_Thread_Command_glProgramBinary *thread_data =
       (EVGL_API_Thread_Command_glProgramBinary *)data;
 
-   orig_evgl_api_glProgramBinary(thread_param->program,
-                                 thread_param->binaryFormat,
-                                 thread_param->binary,
-                                 thread_param->length);
+   orig_evgl_api_glProgramBinary(thread_data->program,
+                                 thread_data->binaryFormat,
+                                 thread_data->binary,
+                                 thread_data->length);
 
 
-   if (thread_param->binary_copied)
-     eina_mempool_free(_mp_default, thread_param->binary_copied);
+   if (thread_data->binary_copied)
+     eina_mempool_free(_mp_default, thread_data->binary_copied);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -26341,31 +26345,31 @@ glProgramBinary_evgl_api_thread_cmd(GLuint program, GLenum binaryFormat, const v
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glProgramBinary thread_param_local;
-   EVGL_API_Thread_Command_glProgramBinary *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glProgramBinary thread_data_local;
+   EVGL_API_Thread_Command_glProgramBinary *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_API_Thread_Command_glProgramBinary *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_API_Thread_Command_glProgramBinary));
-        if (thread_param_new)
+        EVGL_API_Thread_Command_glProgramBinary *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_API_Thread_Command_glProgramBinary));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->program = program;
-   thread_param->binaryFormat = binaryFormat;
-   thread_param->binary = binary;
-   thread_param->length = length;
+   thread_data->program = program;
+   thread_data->binaryFormat = binaryFormat;
+   thread_data->binary = binary;
+   thread_data->length = length;
 
-   thread_param->binary_copied = NULL;
+   thread_data->binary_copied = NULL;
    if (thread_mode == EVAS_GL_THREAD_MODE_FINISH)
      goto finish;
 
@@ -26380,10 +26384,10 @@ glProgramBinary_evgl_api_thread_cmd(GLuint program, GLenum binaryFormat, const v
              goto finish;
           }
         /* 2. malloc & copy */
-        thread_param->binary_copied = eina_mempool_malloc(_mp_default, copy_size);
-        if (thread_param->binary_copied)
+        thread_data->binary_copied = eina_mempool_malloc(_mp_default, copy_size);
+        if (thread_data->binary_copied)
           {
-             memcpy(thread_param->binary_copied, binary, copy_size);
+             memcpy(thread_data->binary_copied, binary, copy_size);
           }
         else
           {
@@ -26391,20 +26395,20 @@ glProgramBinary_evgl_api_thread_cmd(GLuint program, GLenum binaryFormat, const v
              goto finish;
           }
         /* 3. replace */
-        thread_param->binary = (const void  *)thread_param->binary_copied;
+        thread_data->binary = (const void  *)thread_data->binary_copied;
      }
    /* end of copy variable */
 
 finish:
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glProgramBinary,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glProgramParameteri(GLuint program, GLenum pname, GLint value);
+ * void
+ * glProgramParameteri(GLuint program, GLenum pname, GLint value);
  */
 
 typedef struct
@@ -26420,12 +26424,12 @@ void (*orig_evgl_api_glProgramParameteri)(GLuint program, GLenum pname, GLint va
 static void
 _evgl_api_thread_glProgramParameteri(void *data)
 {
-   EVGL_API_Thread_Command_glProgramParameteri *thread_param =
+   EVGL_API_Thread_Command_glProgramParameteri *thread_data =
       (EVGL_API_Thread_Command_glProgramParameteri *)data;
 
-   orig_evgl_api_glProgramParameteri(thread_param->program,
-                                     thread_param->pname,
-                                     thread_param->value);
+   orig_evgl_api_glProgramParameteri(thread_data->program,
+                                     thread_data->pname,
+                                     thread_data->value);
 
 }
 
@@ -26440,22 +26444,22 @@ glProgramParameteri_evgl_api_thread_cmd(GLuint program, GLenum pname, GLint valu
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glProgramParameteri thread_param_local;
-   EVGL_API_Thread_Command_glProgramParameteri *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glProgramParameteri thread_data_local;
+   EVGL_API_Thread_Command_glProgramParameteri *thread_data = &thread_data_local;
 
-   thread_param->program = program;
-   thread_param->pname = pname;
-   thread_param->value = value;
+   thread_data->program = program;
+   thread_data->pname = pname;
+   thread_data->value = value;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glProgramParameteri,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glReadBuffer(GLenum src);
+ * void
+ * glReadBuffer(GLenum src);
  */
 
 typedef struct
@@ -26469,10 +26473,10 @@ void (*orig_evgl_api_glReadBuffer)(GLenum src);
 static void
 _evgl_api_thread_glReadBuffer(void *data)
 {
-   EVGL_API_Thread_Command_glReadBuffer *thread_param =
+   EVGL_API_Thread_Command_glReadBuffer *thread_data =
       (EVGL_API_Thread_Command_glReadBuffer *)data;
 
-   orig_evgl_api_glReadBuffer(thread_param->src);
+   orig_evgl_api_glReadBuffer(thread_data->src);
 
 }
 
@@ -26487,20 +26491,20 @@ glReadBuffer_evgl_api_thread_cmd(GLenum src)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glReadBuffer thread_param_local;
-   EVGL_API_Thread_Command_glReadBuffer *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glReadBuffer thread_data_local;
+   EVGL_API_Thread_Command_glReadBuffer *thread_data = &thread_data_local;
 
-   thread_param->src = src;
+   thread_data->src = src;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glReadBuffer,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glRenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height);
+ * void
+ * glRenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height);
  */
 
 typedef struct
@@ -26518,14 +26522,14 @@ void (*orig_evgl_api_glRenderbufferStorageMultisample)(GLenum target, GLsizei sa
 static void
 _evgl_api_thread_glRenderbufferStorageMultisample(void *data)
 {
-   EVGL_API_Thread_Command_glRenderbufferStorageMultisample *thread_param =
+   EVGL_API_Thread_Command_glRenderbufferStorageMultisample *thread_data =
       (EVGL_API_Thread_Command_glRenderbufferStorageMultisample *)data;
 
-   orig_evgl_api_glRenderbufferStorageMultisample(thread_param->target,
-                                                  thread_param->samples,
-                                                  thread_param->internalformat,
-                                                  thread_param->width,
-                                                  thread_param->height);
+   orig_evgl_api_glRenderbufferStorageMultisample(thread_data->target,
+                                                  thread_data->samples,
+                                                  thread_data->internalformat,
+                                                  thread_data->width,
+                                                  thread_data->height);
 
 }
 
@@ -26540,24 +26544,24 @@ glRenderbufferStorageMultisample_evgl_api_thread_cmd(GLenum target, GLsizei samp
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glRenderbufferStorageMultisample thread_param_local;
-   EVGL_API_Thread_Command_glRenderbufferStorageMultisample *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glRenderbufferStorageMultisample thread_data_local;
+   EVGL_API_Thread_Command_glRenderbufferStorageMultisample *thread_data = &thread_data_local;
 
-   thread_param->target = target;
-   thread_param->samples = samples;
-   thread_param->internalformat = internalformat;
-   thread_param->width = width;
-   thread_param->height = height;
+   thread_data->target = target;
+   thread_data->samples = samples;
+   thread_data->internalformat = internalformat;
+   thread_data->width = width;
+   thread_data->height = height;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glRenderbufferStorageMultisample,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glResumeTransformFeedback(void);
+ * void
+ * glResumeTransformFeedback(void);
  */
 
 void (*orig_evgl_api_glResumeTransformFeedback)(void);
@@ -26587,8 +26591,8 @@ glResumeTransformFeedback_evgl_api_thread_cmd(void)
 }
 
 /*
-   void
-   glSamplerParameterf(GLuint sampler, GLenum pname, GLfloat param);
+ * void
+ * glSamplerParameterf(GLuint sampler, GLenum pname, GLfloat param);
  */
 
 typedef struct
@@ -26604,12 +26608,12 @@ void (*orig_evgl_api_glSamplerParameterf)(GLuint sampler, GLenum pname, GLfloat
 static void
 _evgl_api_thread_glSamplerParameterf(void *data)
 {
-   EVGL_API_Thread_Command_glSamplerParameterf *thread_param =
+   EVGL_API_Thread_Command_glSamplerParameterf *thread_data =
       (EVGL_API_Thread_Command_glSamplerParameterf *)data;
 
-   orig_evgl_api_glSamplerParameterf(thread_param->sampler,
-                                     thread_param->pname,
-                                     thread_param->param);
+   orig_evgl_api_glSamplerParameterf(thread_data->sampler,
+                                     thread_data->pname,
+                                     thread_data->param);
 
 }
 
@@ -26624,22 +26628,22 @@ glSamplerParameterf_evgl_api_thread_cmd(GLuint sampler, GLenum pname, GLfloat pa
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glSamplerParameterf thread_param_local;
-   EVGL_API_Thread_Command_glSamplerParameterf *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glSamplerParameterf thread_data_local;
+   EVGL_API_Thread_Command_glSamplerParameterf *thread_data = &thread_data_local;
 
-   thread_param->sampler = sampler;
-   thread_param->pname = pname;
-   thread_param->param = param;
+   thread_data->sampler = sampler;
+   thread_data->pname = pname;
+   thread_data->param = param;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glSamplerParameterf,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glSamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat * params);
+ * void
+ * glSamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat * params);
  */
 
 typedef struct
@@ -26655,12 +26659,12 @@ void (*orig_evgl_api_glSamplerParameterfv)(GLuint sampler, GLenum pname, const G
 static void
 _evgl_api_thread_glSamplerParameterfv(void *data)
 {
-   EVGL_API_Thread_Command_glSamplerParameterfv *thread_param =
+   EVGL_API_Thread_Command_glSamplerParameterfv *thread_data =
       (EVGL_API_Thread_Command_glSamplerParameterfv *)data;
 
-   orig_evgl_api_glSamplerParameterfv(thread_param->sampler,
-                                      thread_param->pname,
-                                      thread_param->params);
+   orig_evgl_api_glSamplerParameterfv(thread_data->sampler,
+                                      thread_data->pname,
+                                      thread_data->params);
 
 }
 
@@ -26675,22 +26679,22 @@ glSamplerParameterfv_evgl_api_thread_cmd(GLuint sampler, GLenum pname, const GLf
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glSamplerParameterfv thread_param_local;
-   EVGL_API_Thread_Command_glSamplerParameterfv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glSamplerParameterfv thread_data_local;
+   EVGL_API_Thread_Command_glSamplerParameterfv *thread_data = &thread_data_local;
 
-   thread_param->sampler = sampler;
-   thread_param->pname = pname;
-   thread_param->params = params;
+   thread_data->sampler = sampler;
+   thread_data->pname = pname;
+   thread_data->params = params;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glSamplerParameterfv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glSamplerParameteri(GLuint sampler, GLenum pname, GLint param);
+ * void
+ * glSamplerParameteri(GLuint sampler, GLenum pname, GLint param);
  */
 
 typedef struct
@@ -26706,12 +26710,12 @@ void (*orig_evgl_api_glSamplerParameteri)(GLuint sampler, GLenum pname, GLint pa
 static void
 _evgl_api_thread_glSamplerParameteri(void *data)
 {
-   EVGL_API_Thread_Command_glSamplerParameteri *thread_param =
+   EVGL_API_Thread_Command_glSamplerParameteri *thread_data =
       (EVGL_API_Thread_Command_glSamplerParameteri *)data;
 
-   orig_evgl_api_glSamplerParameteri(thread_param->sampler,
-                                     thread_param->pname,
-                                     thread_param->param);
+   orig_evgl_api_glSamplerParameteri(thread_data->sampler,
+                                     thread_data->pname,
+                                     thread_data->param);
 
 }
 
@@ -26726,22 +26730,22 @@ glSamplerParameteri_evgl_api_thread_cmd(GLuint sampler, GLenum pname, GLint para
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glSamplerParameteri thread_param_local;
-   EVGL_API_Thread_Command_glSamplerParameteri *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glSamplerParameteri thread_data_local;
+   EVGL_API_Thread_Command_glSamplerParameteri *thread_data = &thread_data_local;
 
-   thread_param->sampler = sampler;
-   thread_param->pname = pname;
-   thread_param->param = param;
+   thread_data->sampler = sampler;
+   thread_data->pname = pname;
+   thread_data->param = param;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glSamplerParameteri,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glSamplerParameteriv(GLuint sampler, GLenum pname, const GLint * params);
+ * void
+ * glSamplerParameteriv(GLuint sampler, GLenum pname, const GLint * params);
  */
 
 typedef struct
@@ -26757,12 +26761,12 @@ void (*orig_evgl_api_glSamplerParameteriv)(GLuint sampler, GLenum pname, const G
 static void
 _evgl_api_thread_glSamplerParameteriv(void *data)
 {
-   EVGL_API_Thread_Command_glSamplerParameteriv *thread_param =
+   EVGL_API_Thread_Command_glSamplerParameteriv *thread_data =
       (EVGL_API_Thread_Command_glSamplerParameteriv *)data;
 
-   orig_evgl_api_glSamplerParameteriv(thread_param->sampler,
-                                      thread_param->pname,
-                                      thread_param->params);
+   orig_evgl_api_glSamplerParameteriv(thread_data->sampler,
+                                      thread_data->pname,
+                                      thread_data->params);
 
 }
 
@@ -26777,22 +26781,22 @@ glSamplerParameteriv_evgl_api_thread_cmd(GLuint sampler, GLenum pname, const GLi
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glSamplerParameteriv thread_param_local;
-   EVGL_API_Thread_Command_glSamplerParameteriv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glSamplerParameteriv thread_data_local;
+   EVGL_API_Thread_Command_glSamplerParameteriv *thread_data = &thread_data_local;
 
-   thread_param->sampler = sampler;
-   thread_param->pname = pname;
-   thread_param->params = params;
+   thread_data->sampler = sampler;
+   thread_data->pname = pname;
+   thread_data->params = params;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glSamplerParameteriv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glTexImage3D(GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid * data);
+ * void
+ * glTexImage3D(GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid * data);
  */
 
 typedef struct
@@ -26815,19 +26819,19 @@ void (*orig_evgl_api_glTexImage3D)(GLenum target, GLint level, GLint internalFor
 static void
 _evgl_api_thread_glTexImage3D(void *data)
 {
-   EVGL_API_Thread_Command_glTexImage3D *thread_param =
+   EVGL_API_Thread_Command_glTexImage3D *thread_data =
       (EVGL_API_Thread_Command_glTexImage3D *)data;
 
-   orig_evgl_api_glTexImage3D(thread_param->target,
-                              thread_param->level,
-                              thread_param->internalFormat,
-                              thread_param->width,
-                              thread_param->height,
-                              thread_param->depth,
-                              thread_param->border,
-                              thread_param->format,
-                              thread_param->type,
-                              thread_param->data);
+   orig_evgl_api_glTexImage3D(thread_data->target,
+                              thread_data->level,
+                              thread_data->internalFormat,
+                              thread_data->width,
+                              thread_data->height,
+                              thread_data->depth,
+                              thread_data->border,
+                              thread_data->format,
+                              thread_data->type,
+                              thread_data->data);
 
 }
 
@@ -26842,29 +26846,29 @@ glTexImage3D_evgl_api_thread_cmd(GLenum target, GLint level, GLint internalForma
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glTexImage3D thread_param_local;
-   EVGL_API_Thread_Command_glTexImage3D *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glTexImage3D thread_data_local;
+   EVGL_API_Thread_Command_glTexImage3D *thread_data = &thread_data_local;
 
-   thread_param->target = target;
-   thread_param->level = level;
-   thread_param->internalFormat = internalFormat;
-   thread_param->width = width;
-   thread_param->height = height;
-   thread_param->depth = depth;
-   thread_param->border = border;
-   thread_param->format = format;
-   thread_param->type = type;
-   thread_param->data = data;
+   thread_data->target = target;
+   thread_data->level = level;
+   thread_data->internalFormat = internalFormat;
+   thread_data->width = width;
+   thread_data->height = height;
+   thread_data->depth = depth;
+   thread_data->border = border;
+   thread_data->format = format;
+   thread_data->type = type;
+   thread_data->data = data;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glTexImage3D,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glTexStorage2D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height);
+ * void
+ * glTexStorage2D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height);
  */
 
 typedef struct
@@ -26882,14 +26886,14 @@ void (*orig_evgl_api_glTexStorage2D)(GLenum target, GLsizei levels, GLenum inter
 static void
 _evgl_api_thread_glTexStorage2D(void *data)
 {
-   EVGL_API_Thread_Command_glTexStorage2D *thread_param =
+   EVGL_API_Thread_Command_glTexStorage2D *thread_data =
       (EVGL_API_Thread_Command_glTexStorage2D *)data;
 
-   orig_evgl_api_glTexStorage2D(thread_param->target,
-                                thread_param->levels,
-                                thread_param->internalformat,
-                                thread_param->width,
-                                thread_param->height);
+   orig_evgl_api_glTexStorage2D(thread_data->target,
+                                thread_data->levels,
+                                thread_data->internalformat,
+                                thread_data->width,
+                                thread_data->height);
 
 }
 
@@ -26904,24 +26908,24 @@ glTexStorage2D_evgl_api_thread_cmd(GLenum target, GLsizei levels, GLenum interna
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glTexStorage2D thread_param_local;
-   EVGL_API_Thread_Command_glTexStorage2D *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glTexStorage2D thread_data_local;
+   EVGL_API_Thread_Command_glTexStorage2D *thread_data = &thread_data_local;
 
-   thread_param->target = target;
-   thread_param->levels = levels;
-   thread_param->internalformat = internalformat;
-   thread_param->width = width;
-   thread_param->height = height;
+   thread_data->target = target;
+   thread_data->levels = levels;
+   thread_data->internalformat = internalformat;
+   thread_data->width = width;
+   thread_data->height = height;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glTexStorage2D,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glTexStorage3D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth);
+ * void
+ * glTexStorage3D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth);
  */
 
 typedef struct
@@ -26940,15 +26944,15 @@ void (*orig_evgl_api_glTexStorage3D)(GLenum target, GLsizei levels, GLenum inter
 static void
 _evgl_api_thread_glTexStorage3D(void *data)
 {
-   EVGL_API_Thread_Command_glTexStorage3D *thread_param =
+   EVGL_API_Thread_Command_glTexStorage3D *thread_data =
       (EVGL_API_Thread_Command_glTexStorage3D *)data;
 
-   orig_evgl_api_glTexStorage3D(thread_param->target,
-                                thread_param->levels,
-                                thread_param->internalformat,
-                                thread_param->width,
-                                thread_param->height,
-                                thread_param->depth);
+   orig_evgl_api_glTexStorage3D(thread_data->target,
+                                thread_data->levels,
+                                thread_data->internalformat,
+                                thread_data->width,
+                                thread_data->height,
+                                thread_data->depth);
 
 }
 
@@ -26963,25 +26967,25 @@ glTexStorage3D_evgl_api_thread_cmd(GLenum target, GLsizei levels, GLenum interna
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glTexStorage3D thread_param_local;
-   EVGL_API_Thread_Command_glTexStorage3D *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glTexStorage3D thread_data_local;
+   EVGL_API_Thread_Command_glTexStorage3D *thread_data = &thread_data_local;
 
-   thread_param->target = target;
-   thread_param->levels = levels;
-   thread_param->internalformat = internalformat;
-   thread_param->width = width;
-   thread_param->height = height;
-   thread_param->depth = depth;
+   thread_data->target = target;
+   thread_data->levels = levels;
+   thread_data->internalformat = internalformat;
+   thread_data->width = width;
+   thread_data->height = height;
+   thread_data->depth = depth;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glTexStorage3D,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid * data);
+ * void
+ * glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid * data);
  */
 
 typedef struct
@@ -27005,20 +27009,20 @@ void (*orig_evgl_api_glTexSubImage3D)(GLenum target, GLint level, GLint xoffset,
 static void
 _evgl_api_thread_glTexSubImage3D(void *data)
 {
-   EVGL_API_Thread_Command_glTexSubImage3D *thread_param =
+   EVGL_API_Thread_Command_glTexSubImage3D *thread_data =
       (EVGL_API_Thread_Command_glTexSubImage3D *)data;
 
-   orig_evgl_api_glTexSubImage3D(thread_param->target,
-                                 thread_param->level,
-                                 thread_param->xoffset,
-                                 thread_param->yoffset,
-                                 thread_param->zoffset,
-                                 thread_param->width,
-                                 thread_param->height,
-                                 thread_param->depth,
-                                 thread_param->format,
-                                 thread_param->type,
-                                 thread_param->data);
+   orig_evgl_api_glTexSubImage3D(thread_data->target,
+                                 thread_data->level,
+                                 thread_data->xoffset,
+                                 thread_data->yoffset,
+                                 thread_data->zoffset,
+                                 thread_data->width,
+                                 thread_data->height,
+                                 thread_data->depth,
+                                 thread_data->format,
+                                 thread_data->type,
+                                 thread_data->data);
 
 }
 
@@ -27033,30 +27037,30 @@ glTexSubImage3D_evgl_api_thread_cmd(GLenum target, GLint level, GLint xoffset, G
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glTexSubImage3D thread_param_local;
-   EVGL_API_Thread_Command_glTexSubImage3D *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glTexSubImage3D thread_data_local;
+   EVGL_API_Thread_Command_glTexSubImage3D *thread_data = &thread_data_local;
 
-   thread_param->target = target;
-   thread_param->level = level;
-   thread_param->xoffset = xoffset;
-   thread_param->yoffset = yoffset;
-   thread_param->zoffset = zoffset;
-   thread_param->width = width;
-   thread_param->height = height;
-   thread_param->depth = depth;
-   thread_param->format = format;
-   thread_param->type = type;
-   thread_param->data = data;
+   thread_data->target = target;
+   thread_data->level = level;
+   thread_data->xoffset = xoffset;
+   thread_data->yoffset = yoffset;
+   thread_data->zoffset = zoffset;
+   thread_data->width = width;
+   thread_data->height = height;
+   thread_data->depth = depth;
+   thread_data->format = format;
+   thread_data->type = type;
+   thread_data->data = data;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glTexSubImage3D,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glTransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar *const* varyings, GLenum bufferMode);
+ * void
+ * glTransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar *const* varyings, GLenum bufferMode);
  */
 
 typedef struct
@@ -27073,13 +27077,13 @@ void (*orig_evgl_api_glTransformFeedbackVaryings)(GLuint program, GLsizei count,
 static void
 _evgl_api_thread_glTransformFeedbackVaryings(void *data)
 {
-   EVGL_API_Thread_Command_glTransformFeedbackVaryings *thread_param =
+   EVGL_API_Thread_Command_glTransformFeedbackVaryings *thread_data =
       (EVGL_API_Thread_Command_glTransformFeedbackVaryings *)data;
 
-   orig_evgl_api_glTransformFeedbackVaryings(thread_param->program,
-                                             thread_param->count,
-                                             thread_param->varyings,
-                                             thread_param->bufferMode);
+   orig_evgl_api_glTransformFeedbackVaryings(thread_data->program,
+                                             thread_data->count,
+                                             thread_data->varyings,
+                                             thread_data->bufferMode);
 
 }
 
@@ -27094,23 +27098,23 @@ glTransformFeedbackVaryings_evgl_api_thread_cmd(GLuint program, GLsizei count, c
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glTransformFeedbackVaryings thread_param_local;
-   EVGL_API_Thread_Command_glTransformFeedbackVaryings *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glTransformFeedbackVaryings thread_data_local;
+   EVGL_API_Thread_Command_glTransformFeedbackVaryings *thread_data = &thread_data_local;
 
-   thread_param->program = program;
-   thread_param->count = count;
-   thread_param->varyings = varyings;
-   thread_param->bufferMode = bufferMode;
+   thread_data->program = program;
+   thread_data->count = count;
+   thread_data->varyings = varyings;
+   thread_data->bufferMode = bufferMode;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glTransformFeedbackVaryings,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glUniform1ui(GLint location, GLuint v0);
+ * void
+ * glUniform1ui(GLint location, GLuint v0);
  */
 
 typedef struct
@@ -27125,11 +27129,11 @@ void (*orig_evgl_api_glUniform1ui)(GLint location, GLuint v0);
 static void
 _evgl_api_thread_glUniform1ui(void *data)
 {
-   EVGL_API_Thread_Command_glUniform1ui *thread_param =
+   EVGL_API_Thread_Command_glUniform1ui *thread_data =
       (EVGL_API_Thread_Command_glUniform1ui *)data;
 
-   orig_evgl_api_glUniform1ui(thread_param->location,
-                              thread_param->v0);
+   orig_evgl_api_glUniform1ui(thread_data->location,
+                              thread_data->v0);
 
 }
 
@@ -27144,21 +27148,21 @@ glUniform1ui_evgl_api_thread_cmd(GLint location, GLuint v0)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glUniform1ui thread_param_local;
-   EVGL_API_Thread_Command_glUniform1ui *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glUniform1ui thread_data_local;
+   EVGL_API_Thread_Command_glUniform1ui *thread_data = &thread_data_local;
 
-   thread_param->location = location;
-   thread_param->v0 = v0;
+   thread_data->location = location;
+   thread_data->v0 = v0;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glUniform1ui,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glUniform1uiv(GLint location, GLsizei count, const GLuint *value);
+ * void
+ * glUniform1uiv(GLint location, GLsizei count, const GLuint *value);
  */
 
 typedef struct
@@ -27174,12 +27178,12 @@ void (*orig_evgl_api_glUniform1uiv)(GLint location, GLsizei count, const GLuint
 static void
 _evgl_api_thread_glUniform1uiv(void *data)
 {
-   EVGL_API_Thread_Command_glUniform1uiv *thread_param =
+   EVGL_API_Thread_Command_glUniform1uiv *thread_data =
       (EVGL_API_Thread_Command_glUniform1uiv *)data;
 
-   orig_evgl_api_glUniform1uiv(thread_param->location,
-                               thread_param->count,
-                               thread_param->value);
+   orig_evgl_api_glUniform1uiv(thread_data->location,
+                               thread_data->count,
+                               thread_data->value);
 
 }
 
@@ -27194,22 +27198,22 @@ glUniform1uiv_evgl_api_thread_cmd(GLint location, GLsizei count, const GLuint *v
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glUniform1uiv thread_param_local;
-   EVGL_API_Thread_Command_glUniform1uiv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glUniform1uiv thread_data_local;
+   EVGL_API_Thread_Command_glUniform1uiv *thread_data = &thread_data_local;
 
-   thread_param->location = location;
-   thread_param->count = count;
-   thread_param->value = value;
+   thread_data->location = location;
+   thread_data->count = count;
+   thread_data->value = value;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glUniform1uiv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glUniform2ui(GLint location, GLuint v0, GLuint v1);
+ * void
+ * glUniform2ui(GLint location, GLuint v0, GLuint v1);
  */
 
 typedef struct
@@ -27225,12 +27229,12 @@ void (*orig_evgl_api_glUniform2ui)(GLint location, GLuint v0, GLuint v1);
 static void
 _evgl_api_thread_glUniform2ui(void *data)
 {
-   EVGL_API_Thread_Command_glUniform2ui *thread_param =
+   EVGL_API_Thread_Command_glUniform2ui *thread_data =
       (EVGL_API_Thread_Command_glUniform2ui *)data;
 
-   orig_evgl_api_glUniform2ui(thread_param->location,
-                              thread_param->v0,
-                              thread_param->v1);
+   orig_evgl_api_glUniform2ui(thread_data->location,
+                              thread_data->v0,
+                              thread_data->v1);
 
 }
 
@@ -27245,22 +27249,22 @@ glUniform2ui_evgl_api_thread_cmd(GLint location, GLuint v0, GLuint v1)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glUniform2ui thread_param_local;
-   EVGL_API_Thread_Command_glUniform2ui *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glUniform2ui thread_data_local;
+   EVGL_API_Thread_Command_glUniform2ui *thread_data = &thread_data_local;
 
-   thread_param->location = location;
-   thread_param->v0 = v0;
-   thread_param->v1 = v1;
+   thread_data->location = location;
+   thread_data->v0 = v0;
+   thread_data->v1 = v1;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glUniform2ui,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glUniform2uiv(GLint location, GLsizei count, const GLuint *value);
+ * void
+ * glUniform2uiv(GLint location, GLsizei count, const GLuint *value);
  */
 
 typedef struct
@@ -27276,12 +27280,12 @@ void (*orig_evgl_api_glUniform2uiv)(GLint location, GLsizei count, const GLuint
 static void
 _evgl_api_thread_glUniform2uiv(void *data)
 {
-   EVGL_API_Thread_Command_glUniform2uiv *thread_param =
+   EVGL_API_Thread_Command_glUniform2uiv *thread_data =
       (EVGL_API_Thread_Command_glUniform2uiv *)data;
 
-   orig_evgl_api_glUniform2uiv(thread_param->location,
-                               thread_param->count,
-                               thread_param->value);
+   orig_evgl_api_glUniform2uiv(thread_data->location,
+                               thread_data->count,
+                               thread_data->value);
 
 }
 
@@ -27296,22 +27300,22 @@ glUniform2uiv_evgl_api_thread_cmd(GLint location, GLsizei count, const GLuint *v
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glUniform2uiv thread_param_local;
-   EVGL_API_Thread_Command_glUniform2uiv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glUniform2uiv thread_data_local;
+   EVGL_API_Thread_Command_glUniform2uiv *thread_data = &thread_data_local;
 
-   thread_param->location = location;
-   thread_param->count = count;
-   thread_param->value = value;
+   thread_data->location = location;
+   thread_data->count = count;
+   thread_data->value = value;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glUniform2uiv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glUniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2);
+ * void
+ * glUniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2);
  */
 
 typedef struct
@@ -27328,13 +27332,13 @@ void (*orig_evgl_api_glUniform3ui)(GLint location, GLuint v0, GLuint v1, GLuint
 static void
 _evgl_api_thread_glUniform3ui(void *data)
 {
-   EVGL_API_Thread_Command_glUniform3ui *thread_param =
+   EVGL_API_Thread_Command_glUniform3ui *thread_data =
       (EVGL_API_Thread_Command_glUniform3ui *)data;
 
-   orig_evgl_api_glUniform3ui(thread_param->location,
-                              thread_param->v0,
-                              thread_param->v1,
-                              thread_param->v2);
+   orig_evgl_api_glUniform3ui(thread_data->location,
+                              thread_data->v0,
+                              thread_data->v1,
+                              thread_data->v2);
 
 }
 
@@ -27349,23 +27353,23 @@ glUniform3ui_evgl_api_thread_cmd(GLint location, GLuint v0, GLuint v1, GLuint v2
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glUniform3ui thread_param_local;
-   EVGL_API_Thread_Command_glUniform3ui *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glUniform3ui thread_data_local;
+   EVGL_API_Thread_Command_glUniform3ui *thread_data = &thread_data_local;
 
-   thread_param->location = location;
-   thread_param->v0 = v0;
-   thread_param->v1 = v1;
-   thread_param->v2 = v2;
+   thread_data->location = location;
+   thread_data->v0 = v0;
+   thread_data->v1 = v1;
+   thread_data->v2 = v2;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glUniform3ui,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glUniform3uiv(GLint location, GLsizei count, const GLuint *value);
+ * void
+ * glUniform3uiv(GLint location, GLsizei count, const GLuint *value);
  */
 
 typedef struct
@@ -27381,12 +27385,12 @@ void (*orig_evgl_api_glUniform3uiv)(GLint location, GLsizei count, const GLuint
 static void
 _evgl_api_thread_glUniform3uiv(void *data)
 {
-   EVGL_API_Thread_Command_glUniform3uiv *thread_param =
+   EVGL_API_Thread_Command_glUniform3uiv *thread_data =
       (EVGL_API_Thread_Command_glUniform3uiv *)data;
 
-   orig_evgl_api_glUniform3uiv(thread_param->location,
-                               thread_param->count,
-                               thread_param->value);
+   orig_evgl_api_glUniform3uiv(thread_data->location,
+                               thread_data->count,
+                               thread_data->value);
 
 }
 
@@ -27401,22 +27405,22 @@ glUniform3uiv_evgl_api_thread_cmd(GLint location, GLsizei count, const GLuint *v
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glUniform3uiv thread_param_local;
-   EVGL_API_Thread_Command_glUniform3uiv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glUniform3uiv thread_data_local;
+   EVGL_API_Thread_Command_glUniform3uiv *thread_data = &thread_data_local;
 
-   thread_param->location = location;
-   thread_param->count = count;
-   thread_param->value = value;
+   thread_data->location = location;
+   thread_data->count = count;
+   thread_data->value = value;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glUniform3uiv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glUniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3);
+ * void
+ * glUniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3);
  */
 
 typedef struct
@@ -27434,14 +27438,14 @@ void (*orig_evgl_api_glUniform4ui)(GLint location, GLuint v0, GLuint v1, GLuint
 static void
 _evgl_api_thread_glUniform4ui(void *data)
 {
-   EVGL_API_Thread_Command_glUniform4ui *thread_param =
+   EVGL_API_Thread_Command_glUniform4ui *thread_data =
       (EVGL_API_Thread_Command_glUniform4ui *)data;
 
-   orig_evgl_api_glUniform4ui(thread_param->location,
-                              thread_param->v0,
-                              thread_param->v1,
-                              thread_param->v2,
-                              thread_param->v3);
+   orig_evgl_api_glUniform4ui(thread_data->location,
+                              thread_data->v0,
+                              thread_data->v1,
+                              thread_data->v2,
+                              thread_data->v3);
 
 }
 
@@ -27456,24 +27460,24 @@ glUniform4ui_evgl_api_thread_cmd(GLint location, GLuint v0, GLuint v1, GLuint v2
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glUniform4ui thread_param_local;
-   EVGL_API_Thread_Command_glUniform4ui *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glUniform4ui thread_data_local;
+   EVGL_API_Thread_Command_glUniform4ui *thread_data = &thread_data_local;
 
-   thread_param->location = location;
-   thread_param->v0 = v0;
-   thread_param->v1 = v1;
-   thread_param->v2 = v2;
-   thread_param->v3 = v3;
+   thread_data->location = location;
+   thread_data->v0 = v0;
+   thread_data->v1 = v1;
+   thread_data->v2 = v2;
+   thread_data->v3 = v3;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glUniform4ui,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glUniform4uiv(GLint location, GLsizei count, const GLuint *value);
+ * void
+ * glUniform4uiv(GLint location, GLsizei count, const GLuint *value);
  */
 
 typedef struct
@@ -27489,12 +27493,12 @@ void (*orig_evgl_api_glUniform4uiv)(GLint location, GLsizei count, const GLuint
 static void
 _evgl_api_thread_glUniform4uiv(void *data)
 {
-   EVGL_API_Thread_Command_glUniform4uiv *thread_param =
+   EVGL_API_Thread_Command_glUniform4uiv *thread_data =
       (EVGL_API_Thread_Command_glUniform4uiv *)data;
 
-   orig_evgl_api_glUniform4uiv(thread_param->location,
-                               thread_param->count,
-                               thread_param->value);
+   orig_evgl_api_glUniform4uiv(thread_data->location,
+                               thread_data->count,
+                               thread_data->value);
 
 }
 
@@ -27509,22 +27513,22 @@ glUniform4uiv_evgl_api_thread_cmd(GLint location, GLsizei count, const GLuint *v
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glUniform4uiv thread_param_local;
-   EVGL_API_Thread_Command_glUniform4uiv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glUniform4uiv thread_data_local;
+   EVGL_API_Thread_Command_glUniform4uiv *thread_data = &thread_data_local;
 
-   thread_param->location = location;
-   thread_param->count = count;
-   thread_param->value = value;
+   thread_data->location = location;
+   thread_data->count = count;
+   thread_data->value = value;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glUniform4uiv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glUniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding);
+ * void
+ * glUniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding);
  */
 
 typedef struct
@@ -27540,12 +27544,12 @@ void (*orig_evgl_api_glUniformBlockBinding)(GLuint program, GLuint uniformBlockI
 static void
 _evgl_api_thread_glUniformBlockBinding(void *data)
 {
-   EVGL_API_Thread_Command_glUniformBlockBinding *thread_param =
+   EVGL_API_Thread_Command_glUniformBlockBinding *thread_data =
       (EVGL_API_Thread_Command_glUniformBlockBinding *)data;
 
-   orig_evgl_api_glUniformBlockBinding(thread_param->program,
-                                       thread_param->uniformBlockIndex,
-                                       thread_param->uniformBlockBinding);
+   orig_evgl_api_glUniformBlockBinding(thread_data->program,
+                                       thread_data->uniformBlockIndex,
+                                       thread_data->uniformBlockBinding);
 
 }
 
@@ -27560,22 +27564,22 @@ glUniformBlockBinding_evgl_api_thread_cmd(GLuint program, GLuint uniformBlockInd
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glUniformBlockBinding thread_param_local;
-   EVGL_API_Thread_Command_glUniformBlockBinding *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glUniformBlockBinding thread_data_local;
+   EVGL_API_Thread_Command_glUniformBlockBinding *thread_data = &thread_data_local;
 
-   thread_param->program = program;
-   thread_param->uniformBlockIndex = uniformBlockIndex;
-   thread_param->uniformBlockBinding = uniformBlockBinding;
+   thread_data->program = program;
+   thread_data->uniformBlockIndex = uniformBlockIndex;
+   thread_data->uniformBlockBinding = uniformBlockBinding;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glUniformBlockBinding,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glUniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+ * void
+ * glUniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
  */
 
 typedef struct
@@ -27592,13 +27596,13 @@ void (*orig_evgl_api_glUniformMatrix2x3fv)(GLint location, GLsizei count, GLbool
 static void
 _evgl_api_thread_glUniformMatrix2x3fv(void *data)
 {
-   EVGL_API_Thread_Command_glUniformMatrix2x3fv *thread_param =
+   EVGL_API_Thread_Command_glUniformMatrix2x3fv *thread_data =
       (EVGL_API_Thread_Command_glUniformMatrix2x3fv *)data;
 
-   orig_evgl_api_glUniformMatrix2x3fv(thread_param->location,
-                                      thread_param->count,
-                                      thread_param->transpose,
-                                      thread_param->value);
+   orig_evgl_api_glUniformMatrix2x3fv(thread_data->location,
+                                      thread_data->count,
+                                      thread_data->transpose,
+                                      thread_data->value);
 
 }
 
@@ -27613,23 +27617,23 @@ glUniformMatrix2x3fv_evgl_api_thread_cmd(GLint location, GLsizei count, GLboolea
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glUniformMatrix2x3fv thread_param_local;
-   EVGL_API_Thread_Command_glUniformMatrix2x3fv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glUniformMatrix2x3fv thread_data_local;
+   EVGL_API_Thread_Command_glUniformMatrix2x3fv *thread_data = &thread_data_local;
 
-   thread_param->location = location;
-   thread_param->count = count;
-   thread_param->transpose = transpose;
-   thread_param->value = value;
+   thread_data->location = location;
+   thread_data->count = count;
+   thread_data->transpose = transpose;
+   thread_data->value = value;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glUniformMatrix2x3fv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glUniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+ * void
+ * glUniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
  */
 
 typedef struct
@@ -27646,13 +27650,13 @@ void (*orig_evgl_api_glUniformMatrix3x2fv)(GLint location, GLsizei count, GLbool
 static void
 _evgl_api_thread_glUniformMatrix3x2fv(void *data)
 {
-   EVGL_API_Thread_Command_glUniformMatrix3x2fv *thread_param =
+   EVGL_API_Thread_Command_glUniformMatrix3x2fv *thread_data =
       (EVGL_API_Thread_Command_glUniformMatrix3x2fv *)data;
 
-   orig_evgl_api_glUniformMatrix3x2fv(thread_param->location,
-                                      thread_param->count,
-                                      thread_param->transpose,
-                                      thread_param->value);
+   orig_evgl_api_glUniformMatrix3x2fv(thread_data->location,
+                                      thread_data->count,
+                                      thread_data->transpose,
+                                      thread_data->value);
 
 }
 
@@ -27667,23 +27671,23 @@ glUniformMatrix3x2fv_evgl_api_thread_cmd(GLint location, GLsizei count, GLboolea
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glUniformMatrix3x2fv thread_param_local;
-   EVGL_API_Thread_Command_glUniformMatrix3x2fv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glUniformMatrix3x2fv thread_data_local;
+   EVGL_API_Thread_Command_glUniformMatrix3x2fv *thread_data = &thread_data_local;
 
-   thread_param->location = location;
-   thread_param->count = count;
-   thread_param->transpose = transpose;
-   thread_param->value = value;
+   thread_data->location = location;
+   thread_data->count = count;
+   thread_data->transpose = transpose;
+   thread_data->value = value;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glUniformMatrix3x2fv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glUniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+ * void
+ * glUniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
  */
 
 typedef struct
@@ -27700,13 +27704,13 @@ void (*orig_evgl_api_glUniformMatrix2x4fv)(GLint location, GLsizei count, GLbool
 static void
 _evgl_api_thread_glUniformMatrix2x4fv(void *data)
 {
-   EVGL_API_Thread_Command_glUniformMatrix2x4fv *thread_param =
+   EVGL_API_Thread_Command_glUniformMatrix2x4fv *thread_data =
       (EVGL_API_Thread_Command_glUniformMatrix2x4fv *)data;
 
-   orig_evgl_api_glUniformMatrix2x4fv(thread_param->location,
-                                      thread_param->count,
-                                      thread_param->transpose,
-                                      thread_param->value);
+   orig_evgl_api_glUniformMatrix2x4fv(thread_data->location,
+                                      thread_data->count,
+                                      thread_data->transpose,
+                                      thread_data->value);
 
 }
 
@@ -27721,23 +27725,23 @@ glUniformMatrix2x4fv_evgl_api_thread_cmd(GLint location, GLsizei count, GLboolea
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glUniformMatrix2x4fv thread_param_local;
-   EVGL_API_Thread_Command_glUniformMatrix2x4fv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glUniformMatrix2x4fv thread_data_local;
+   EVGL_API_Thread_Command_glUniformMatrix2x4fv *thread_data = &thread_data_local;
 
-   thread_param->location = location;
-   thread_param->count = count;
-   thread_param->transpose = transpose;
-   thread_param->value = value;
+   thread_data->location = location;
+   thread_data->count = count;
+   thread_data->transpose = transpose;
+   thread_data->value = value;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glUniformMatrix2x4fv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glUniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+ * void
+ * glUniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
  */
 
 typedef struct
@@ -27754,13 +27758,13 @@ void (*orig_evgl_api_glUniformMatrix4x2fv)(GLint location, GLsizei count, GLbool
 static void
 _evgl_api_thread_glUniformMatrix4x2fv(void *data)
 {
-   EVGL_API_Thread_Command_glUniformMatrix4x2fv *thread_param =
+   EVGL_API_Thread_Command_glUniformMatrix4x2fv *thread_data =
       (EVGL_API_Thread_Command_glUniformMatrix4x2fv *)data;
 
-   orig_evgl_api_glUniformMatrix4x2fv(thread_param->location,
-                                      thread_param->count,
-                                      thread_param->transpose,
-                                      thread_param->value);
+   orig_evgl_api_glUniformMatrix4x2fv(thread_data->location,
+                                      thread_data->count,
+                                      thread_data->transpose,
+                                      thread_data->value);
 
 }
 
@@ -27775,23 +27779,23 @@ glUniformMatrix4x2fv_evgl_api_thread_cmd(GLint location, GLsizei count, GLboolea
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glUniformMatrix4x2fv thread_param_local;
-   EVGL_API_Thread_Command_glUniformMatrix4x2fv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glUniformMatrix4x2fv thread_data_local;
+   EVGL_API_Thread_Command_glUniformMatrix4x2fv *thread_data = &thread_data_local;
 
-   thread_param->location = location;
-   thread_param->count = count;
-   thread_param->transpose = transpose;
-   thread_param->value = value;
+   thread_data->location = location;
+   thread_data->count = count;
+   thread_data->transpose = transpose;
+   thread_data->value = value;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glUniformMatrix4x2fv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glUniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+ * void
+ * glUniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
  */
 
 typedef struct
@@ -27808,13 +27812,13 @@ void (*orig_evgl_api_glUniformMatrix3x4fv)(GLint location, GLsizei count, GLbool
 static void
 _evgl_api_thread_glUniformMatrix3x4fv(void *data)
 {
-   EVGL_API_Thread_Command_glUniformMatrix3x4fv *thread_param =
+   EVGL_API_Thread_Command_glUniformMatrix3x4fv *thread_data =
       (EVGL_API_Thread_Command_glUniformMatrix3x4fv *)data;
 
-   orig_evgl_api_glUniformMatrix3x4fv(thread_param->location,
-                                      thread_param->count,
-                                      thread_param->transpose,
-                                      thread_param->value);
+   orig_evgl_api_glUniformMatrix3x4fv(thread_data->location,
+                                      thread_data->count,
+                                      thread_data->transpose,
+                                      thread_data->value);
 
 }
 
@@ -27829,23 +27833,23 @@ glUniformMatrix3x4fv_evgl_api_thread_cmd(GLint location, GLsizei count, GLboolea
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glUniformMatrix3x4fv thread_param_local;
-   EVGL_API_Thread_Command_glUniformMatrix3x4fv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glUniformMatrix3x4fv thread_data_local;
+   EVGL_API_Thread_Command_glUniformMatrix3x4fv *thread_data = &thread_data_local;
 
-   thread_param->location = location;
-   thread_param->count = count;
-   thread_param->transpose = transpose;
-   thread_param->value = value;
+   thread_data->location = location;
+   thread_data->count = count;
+   thread_data->transpose = transpose;
+   thread_data->value = value;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glUniformMatrix3x4fv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glUniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+ * void
+ * glUniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
  */
 
 typedef struct
@@ -27862,13 +27866,13 @@ void (*orig_evgl_api_glUniformMatrix4x3fv)(GLint location, GLsizei count, GLbool
 static void
 _evgl_api_thread_glUniformMatrix4x3fv(void *data)
 {
-   EVGL_API_Thread_Command_glUniformMatrix4x3fv *thread_param =
+   EVGL_API_Thread_Command_glUniformMatrix4x3fv *thread_data =
       (EVGL_API_Thread_Command_glUniformMatrix4x3fv *)data;
 
-   orig_evgl_api_glUniformMatrix4x3fv(thread_param->location,
-                                      thread_param->count,
-                                      thread_param->transpose,
-                                      thread_param->value);
+   orig_evgl_api_glUniformMatrix4x3fv(thread_data->location,
+                                      thread_data->count,
+                                      thread_data->transpose,
+                                      thread_data->value);
 
 }
 
@@ -27883,23 +27887,23 @@ glUniformMatrix4x3fv_evgl_api_thread_cmd(GLint location, GLsizei count, GLboolea
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glUniformMatrix4x3fv thread_param_local;
-   EVGL_API_Thread_Command_glUniformMatrix4x3fv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glUniformMatrix4x3fv thread_data_local;
+   EVGL_API_Thread_Command_glUniformMatrix4x3fv *thread_data = &thread_data_local;
 
-   thread_param->location = location;
-   thread_param->count = count;
-   thread_param->transpose = transpose;
-   thread_param->value = value;
+   thread_data->location = location;
+   thread_data->count = count;
+   thread_data->transpose = transpose;
+   thread_data->value = value;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glUniformMatrix4x3fv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   GLboolean
-   glUnmapBuffer(GLenum target);
+ * GLboolean
+ * glUnmapBuffer(GLenum target);
  */
 
 typedef struct
@@ -27914,10 +27918,10 @@ GLboolean (*orig_evgl_api_glUnmapBuffer)(GLenum target);
 static void
 _evgl_api_thread_glUnmapBuffer(void *data)
 {
-   EVGL_API_Thread_Command_glUnmapBuffer *thread_param =
+   EVGL_API_Thread_Command_glUnmapBuffer *thread_data =
       (EVGL_API_Thread_Command_glUnmapBuffer *)data;
 
-   thread_param->return_value = orig_evgl_api_glUnmapBuffer(thread_param->target);
+   thread_data->return_value = orig_evgl_api_glUnmapBuffer(thread_data->target);
 
 }
 
@@ -27931,22 +27935,22 @@ glUnmapBuffer_evgl_api_thread_cmd(GLenum target)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glUnmapBuffer thread_param_local;
-   EVGL_API_Thread_Command_glUnmapBuffer *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glUnmapBuffer thread_data_local;
+   EVGL_API_Thread_Command_glUnmapBuffer *thread_data = &thread_data_local;
 
-   thread_param->target = target;
+   thread_data->target = target;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glUnmapBuffer,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
-   void
-   glVertexAttribDivisor(GLuint index, GLuint divisor);
+ * void
+ * glVertexAttribDivisor(GLuint index, GLuint divisor);
  */
 
 typedef struct
@@ -27961,11 +27965,11 @@ void (*orig_evgl_api_glVertexAttribDivisor)(GLuint index, GLuint divisor);
 static void
 _evgl_api_thread_glVertexAttribDivisor(void *data)
 {
-   EVGL_API_Thread_Command_glVertexAttribDivisor *thread_param =
+   EVGL_API_Thread_Command_glVertexAttribDivisor *thread_data =
       (EVGL_API_Thread_Command_glVertexAttribDivisor *)data;
 
-   orig_evgl_api_glVertexAttribDivisor(thread_param->index,
-                                       thread_param->divisor);
+   orig_evgl_api_glVertexAttribDivisor(thread_data->index,
+                                       thread_data->divisor);
 
 }
 
@@ -27980,21 +27984,21 @@ glVertexAttribDivisor_evgl_api_thread_cmd(GLuint index, GLuint divisor)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glVertexAttribDivisor thread_param_local;
-   EVGL_API_Thread_Command_glVertexAttribDivisor *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glVertexAttribDivisor thread_data_local;
+   EVGL_API_Thread_Command_glVertexAttribDivisor *thread_data = &thread_data_local;
 
-   thread_param->index = index;
-   thread_param->divisor = divisor;
+   thread_data->index = index;
+   thread_data->divisor = divisor;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glVertexAttribDivisor,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glVertexAttribI4i(GLuint index, GLint v0, GLint v1, GLint v2, GLint v3);
+ * void
+ * glVertexAttribI4i(GLuint index, GLint v0, GLint v1, GLint v2, GLint v3);
  */
 
 typedef struct
@@ -28012,14 +28016,14 @@ void (*orig_evgl_api_glVertexAttribI4i)(GLuint index, GLint v0, GLint v1, GLint
 static void
 _evgl_api_thread_glVertexAttribI4i(void *data)
 {
-   EVGL_API_Thread_Command_glVertexAttribI4i *thread_param =
+   EVGL_API_Thread_Command_glVertexAttribI4i *thread_data =
       (EVGL_API_Thread_Command_glVertexAttribI4i *)data;
 
-   orig_evgl_api_glVertexAttribI4i(thread_param->index,
-                                   thread_param->v0,
-                                   thread_param->v1,
-                                   thread_param->v2,
-                                   thread_param->v3);
+   orig_evgl_api_glVertexAttribI4i(thread_data->index,
+                                   thread_data->v0,
+                                   thread_data->v1,
+                                   thread_data->v2,
+                                   thread_data->v3);
 
 }
 
@@ -28034,24 +28038,24 @@ glVertexAttribI4i_evgl_api_thread_cmd(GLuint index, GLint v0, GLint v1, GLint v2
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glVertexAttribI4i thread_param_local;
-   EVGL_API_Thread_Command_glVertexAttribI4i *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glVertexAttribI4i thread_data_local;
+   EVGL_API_Thread_Command_glVertexAttribI4i *thread_data = &thread_data_local;
 
-   thread_param->index = index;
-   thread_param->v0 = v0;
-   thread_param->v1 = v1;
-   thread_param->v2 = v2;
-   thread_param->v3 = v3;
+   thread_data->index = index;
+   thread_data->v0 = v0;
+   thread_data->v1 = v1;
+   thread_data->v2 = v2;
+   thread_data->v3 = v3;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glVertexAttribI4i,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glVertexAttribI4iv(GLuint index, const GLint *v);
+ * void
+ * glVertexAttribI4iv(GLuint index, const GLint *v);
  */
 
 typedef struct
@@ -28066,11 +28070,11 @@ void (*orig_evgl_api_glVertexAttribI4iv)(GLuint index, const GLint *v);
 static void
 _evgl_api_thread_glVertexAttribI4iv(void *data)
 {
-   EVGL_API_Thread_Command_glVertexAttribI4iv *thread_param =
+   EVGL_API_Thread_Command_glVertexAttribI4iv *thread_data =
       (EVGL_API_Thread_Command_glVertexAttribI4iv *)data;
 
-   orig_evgl_api_glVertexAttribI4iv(thread_param->index,
-                                    thread_param->v);
+   orig_evgl_api_glVertexAttribI4iv(thread_data->index,
+                                    thread_data->v);
 
 }
 
@@ -28085,21 +28089,21 @@ glVertexAttribI4iv_evgl_api_thread_cmd(GLuint index, const GLint *v)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glVertexAttribI4iv thread_param_local;
-   EVGL_API_Thread_Command_glVertexAttribI4iv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glVertexAttribI4iv thread_data_local;
+   EVGL_API_Thread_Command_glVertexAttribI4iv *thread_data = &thread_data_local;
 
-   thread_param->index = index;
-   thread_param->v = v;
+   thread_data->index = index;
+   thread_data->v = v;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glVertexAttribI4iv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glVertexAttribI4ui(GLuint index, GLuint v0, GLuint v1, GLuint v2, GLuint v3);
+ * void
+ * glVertexAttribI4ui(GLuint index, GLuint v0, GLuint v1, GLuint v2, GLuint v3);
  */
 
 typedef struct
@@ -28117,14 +28121,14 @@ void (*orig_evgl_api_glVertexAttribI4ui)(GLuint index, GLuint v0, GLuint v1, GLu
 static void
 _evgl_api_thread_glVertexAttribI4ui(void *data)
 {
-   EVGL_API_Thread_Command_glVertexAttribI4ui *thread_param =
+   EVGL_API_Thread_Command_glVertexAttribI4ui *thread_data =
       (EVGL_API_Thread_Command_glVertexAttribI4ui *)data;
 
-   orig_evgl_api_glVertexAttribI4ui(thread_param->index,
-                                    thread_param->v0,
-                                    thread_param->v1,
-                                    thread_param->v2,
-                                    thread_param->v3);
+   orig_evgl_api_glVertexAttribI4ui(thread_data->index,
+                                    thread_data->v0,
+                                    thread_data->v1,
+                                    thread_data->v2,
+                                    thread_data->v3);
 
 }
 
@@ -28139,24 +28143,24 @@ glVertexAttribI4ui_evgl_api_thread_cmd(GLuint index, GLuint v0, GLuint v1, GLuin
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glVertexAttribI4ui thread_param_local;
-   EVGL_API_Thread_Command_glVertexAttribI4ui *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glVertexAttribI4ui thread_data_local;
+   EVGL_API_Thread_Command_glVertexAttribI4ui *thread_data = &thread_data_local;
 
-   thread_param->index = index;
-   thread_param->v0 = v0;
-   thread_param->v1 = v1;
-   thread_param->v2 = v2;
-   thread_param->v3 = v3;
+   thread_data->index = index;
+   thread_data->v0 = v0;
+   thread_data->v1 = v1;
+   thread_data->v2 = v2;
+   thread_data->v3 = v3;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glVertexAttribI4ui,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glVertexAttribI4uiv(GLuint index, const GLuint *v);
+ * void
+ * glVertexAttribI4uiv(GLuint index, const GLuint *v);
  */
 
 typedef struct
@@ -28171,11 +28175,11 @@ void (*orig_evgl_api_glVertexAttribI4uiv)(GLuint index, const GLuint *v);
 static void
 _evgl_api_thread_glVertexAttribI4uiv(void *data)
 {
-   EVGL_API_Thread_Command_glVertexAttribI4uiv *thread_param =
+   EVGL_API_Thread_Command_glVertexAttribI4uiv *thread_data =
       (EVGL_API_Thread_Command_glVertexAttribI4uiv *)data;
 
-   orig_evgl_api_glVertexAttribI4uiv(thread_param->index,
-                                     thread_param->v);
+   orig_evgl_api_glVertexAttribI4uiv(thread_data->index,
+                                     thread_data->v);
 
 }
 
@@ -28190,21 +28194,21 @@ glVertexAttribI4uiv_evgl_api_thread_cmd(GLuint index, const GLuint *v)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glVertexAttribI4uiv thread_param_local;
-   EVGL_API_Thread_Command_glVertexAttribI4uiv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glVertexAttribI4uiv thread_data_local;
+   EVGL_API_Thread_Command_glVertexAttribI4uiv *thread_data = &thread_data_local;
 
-   thread_param->index = index;
-   thread_param->v = v;
+   thread_data->index = index;
+   thread_data->v = v;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glVertexAttribI4uiv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glVertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
+ * void
+ * glVertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
  */
 
 typedef struct
@@ -28222,14 +28226,14 @@ void (*orig_evgl_api_glVertexAttribIPointer)(GLuint index, GLint size, GLenum ty
 static void
 _evgl_api_thread_glVertexAttribIPointer(void *data)
 {
-   EVGL_API_Thread_Command_glVertexAttribIPointer *thread_param =
+   EVGL_API_Thread_Command_glVertexAttribIPointer *thread_data =
       (EVGL_API_Thread_Command_glVertexAttribIPointer *)data;
 
-   orig_evgl_api_glVertexAttribIPointer(thread_param->index,
-                                        thread_param->size,
-                                        thread_param->type,
-                                        thread_param->stride,
-                                        thread_param->pointer);
+   orig_evgl_api_glVertexAttribIPointer(thread_data->index,
+                                        thread_data->size,
+                                        thread_data->type,
+                                        thread_data->stride,
+                                        thread_data->pointer);
 
 }
 
@@ -28244,24 +28248,24 @@ glVertexAttribIPointer_evgl_api_thread_cmd(GLuint index, GLint size, GLenum type
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glVertexAttribIPointer thread_param_local;
-   EVGL_API_Thread_Command_glVertexAttribIPointer *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glVertexAttribIPointer thread_data_local;
+   EVGL_API_Thread_Command_glVertexAttribIPointer *thread_data = &thread_data_local;
 
-   thread_param->index = index;
-   thread_param->size = size;
-   thread_param->type = type;
-   thread_param->stride = stride;
-   thread_param->pointer = pointer;
+   thread_data->index = index;
+   thread_data->size = size;
+   thread_data->type = type;
+   thread_data->stride = stride;
+   thread_data->pointer = pointer;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glVertexAttribIPointer,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glWaitSync(GLsync sync, GLbitfield flags, EvasGLuint64 timeout);
+ * void
+ * glWaitSync(GLsync sync, GLbitfield flags, EvasGLuint64 timeout);
  */
 
 typedef struct
@@ -28277,12 +28281,12 @@ void (*orig_evgl_api_glWaitSync)(GLsync sync, GLbitfield flags, EvasGLuint64 tim
 static void
 _evgl_api_thread_glWaitSync(void *data)
 {
-   EVGL_API_Thread_Command_glWaitSync *thread_param =
+   EVGL_API_Thread_Command_glWaitSync *thread_data =
       (EVGL_API_Thread_Command_glWaitSync *)data;
 
-   orig_evgl_api_glWaitSync(thread_param->sync,
-                            thread_param->flags,
-                            thread_param->timeout);
+   orig_evgl_api_glWaitSync(thread_data->sync,
+                            thread_data->flags,
+                            thread_data->timeout);
 
 }
 
@@ -28297,22 +28301,22 @@ glWaitSync_evgl_api_thread_cmd(GLsync sync, GLbitfield flags, EvasGLuint64 timeo
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glWaitSync thread_param_local;
-   EVGL_API_Thread_Command_glWaitSync *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glWaitSync thread_data_local;
+   EVGL_API_Thread_Command_glWaitSync *thread_data = &thread_data_local;
 
-   thread_param->sync = sync;
-   thread_param->flags = flags;
-   thread_param->timeout = timeout;
+   thread_data->sync = sync;
+   thread_data->flags = flags;
+   thread_data->timeout = timeout;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glWaitSync,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glDispatchCompute(GLuint num_groups_x, GLuint num_groups_y, GLuint num_groups_z);
+ * void
+ * glDispatchCompute(GLuint num_groups_x, GLuint num_groups_y, GLuint num_groups_z);
  */
 
 typedef struct
@@ -28328,12 +28332,12 @@ void (*orig_evgl_api_glDispatchCompute)(GLuint num_groups_x, GLuint num_groups_y
 static void
 _evgl_api_thread_glDispatchCompute(void *data)
 {
-   EVGL_API_Thread_Command_glDispatchCompute *thread_param =
+   EVGL_API_Thread_Command_glDispatchCompute *thread_data =
       (EVGL_API_Thread_Command_glDispatchCompute *)data;
 
-   orig_evgl_api_glDispatchCompute(thread_param->num_groups_x,
-                                   thread_param->num_groups_y,
-                                   thread_param->num_groups_z);
+   orig_evgl_api_glDispatchCompute(thread_data->num_groups_x,
+                                   thread_data->num_groups_y,
+                                   thread_data->num_groups_z);
 
 }
 
@@ -28348,22 +28352,22 @@ glDispatchCompute_evgl_api_thread_cmd(GLuint num_groups_x, GLuint num_groups_y,
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glDispatchCompute thread_param_local;
-   EVGL_API_Thread_Command_glDispatchCompute *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glDispatchCompute thread_data_local;
+   EVGL_API_Thread_Command_glDispatchCompute *thread_data = &thread_data_local;
 
-   thread_param->num_groups_x = num_groups_x;
-   thread_param->num_groups_y = num_groups_y;
-   thread_param->num_groups_z = num_groups_z;
+   thread_data->num_groups_x = num_groups_x;
+   thread_data->num_groups_y = num_groups_y;
+   thread_data->num_groups_z = num_groups_z;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glDispatchCompute,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glDispatchComputeIndirect(GLintptr indirect);
+ * void
+ * glDispatchComputeIndirect(GLintptr indirect);
  */
 
 typedef struct
@@ -28377,10 +28381,10 @@ void (*orig_evgl_api_glDispatchComputeIndirect)(GLintptr indirect);
 static void
 _evgl_api_thread_glDispatchComputeIndirect(void *data)
 {
-   EVGL_API_Thread_Command_glDispatchComputeIndirect *thread_param =
+   EVGL_API_Thread_Command_glDispatchComputeIndirect *thread_data =
       (EVGL_API_Thread_Command_glDispatchComputeIndirect *)data;
 
-   orig_evgl_api_glDispatchComputeIndirect(thread_param->indirect);
+   orig_evgl_api_glDispatchComputeIndirect(thread_data->indirect);
 
 }
 
@@ -28395,20 +28399,20 @@ glDispatchComputeIndirect_evgl_api_thread_cmd(GLintptr indirect)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glDispatchComputeIndirect thread_param_local;
-   EVGL_API_Thread_Command_glDispatchComputeIndirect *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glDispatchComputeIndirect thread_data_local;
+   EVGL_API_Thread_Command_glDispatchComputeIndirect *thread_data = &thread_data_local;
 
-   thread_param->indirect = indirect;
+   thread_data->indirect = indirect;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glDispatchComputeIndirect,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glDrawArraysIndirect(GLenum mode, const void *indirect);
+ * void
+ * glDrawArraysIndirect(GLenum mode, const void *indirect);
  */
 
 typedef struct
@@ -28423,11 +28427,11 @@ void (*orig_evgl_api_glDrawArraysIndirect)(GLenum mode, const void *indirect);
 static void
 _evgl_api_thread_glDrawArraysIndirect(void *data)
 {
-   EVGL_API_Thread_Command_glDrawArraysIndirect *thread_param =
+   EVGL_API_Thread_Command_glDrawArraysIndirect *thread_data =
       (EVGL_API_Thread_Command_glDrawArraysIndirect *)data;
 
-   orig_evgl_api_glDrawArraysIndirect(thread_param->mode,
-                                      thread_param->indirect);
+   orig_evgl_api_glDrawArraysIndirect(thread_data->mode,
+                                      thread_data->indirect);
 
 }
 
@@ -28442,21 +28446,21 @@ glDrawArraysIndirect_evgl_api_thread_cmd(GLenum mode, const void *indirect)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glDrawArraysIndirect thread_param_local;
-   EVGL_API_Thread_Command_glDrawArraysIndirect *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glDrawArraysIndirect thread_data_local;
+   EVGL_API_Thread_Command_glDrawArraysIndirect *thread_data = &thread_data_local;
 
-   thread_param->mode = mode;
-   thread_param->indirect = indirect;
+   thread_data->mode = mode;
+   thread_data->indirect = indirect;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glDrawArraysIndirect,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glDrawElementsIndirect(GLenum mode, GLenum type, const void *indirect);
+ * void
+ * glDrawElementsIndirect(GLenum mode, GLenum type, const void *indirect);
  */
 
 typedef struct
@@ -28472,12 +28476,12 @@ void (*orig_evgl_api_glDrawElementsIndirect)(GLenum mode, GLenum type, const voi
 static void
 _evgl_api_thread_glDrawElementsIndirect(void *data)
 {
-   EVGL_API_Thread_Command_glDrawElementsIndirect *thread_param =
+   EVGL_API_Thread_Command_glDrawElementsIndirect *thread_data =
       (EVGL_API_Thread_Command_glDrawElementsIndirect *)data;
 
-   orig_evgl_api_glDrawElementsIndirect(thread_param->mode,
-                                        thread_param->type,
-                                        thread_param->indirect);
+   orig_evgl_api_glDrawElementsIndirect(thread_data->mode,
+                                        thread_data->type,
+                                        thread_data->indirect);
 
 }
 
@@ -28492,22 +28496,22 @@ glDrawElementsIndirect_evgl_api_thread_cmd(GLenum mode, GLenum type, const void
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glDrawElementsIndirect thread_param_local;
-   EVGL_API_Thread_Command_glDrawElementsIndirect *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glDrawElementsIndirect thread_data_local;
+   EVGL_API_Thread_Command_glDrawElementsIndirect *thread_data = &thread_data_local;
 
-   thread_param->mode = mode;
-   thread_param->type = type;
-   thread_param->indirect = indirect;
+   thread_data->mode = mode;
+   thread_data->type = type;
+   thread_data->indirect = indirect;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glDrawElementsIndirect,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glFramebufferParameteri(GLenum target, GLenum pname, GLint param);
+ * void
+ * glFramebufferParameteri(GLenum target, GLenum pname, GLint param);
  */
 
 typedef struct
@@ -28523,12 +28527,12 @@ void (*orig_evgl_api_glFramebufferParameteri)(GLenum target, GLenum pname, GLint
 static void
 _evgl_api_thread_glFramebufferParameteri(void *data)
 {
-   EVGL_API_Thread_Command_glFramebufferParameteri *thread_param =
+   EVGL_API_Thread_Command_glFramebufferParameteri *thread_data =
       (EVGL_API_Thread_Command_glFramebufferParameteri *)data;
 
-   orig_evgl_api_glFramebufferParameteri(thread_param->target,
-                                         thread_param->pname,
-                                         thread_param->param);
+   orig_evgl_api_glFramebufferParameteri(thread_data->target,
+                                         thread_data->pname,
+                                         thread_data->param);
 
 }
 
@@ -28543,22 +28547,22 @@ glFramebufferParameteri_evgl_api_thread_cmd(GLenum target, GLenum pname, GLint p
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glFramebufferParameteri thread_param_local;
-   EVGL_API_Thread_Command_glFramebufferParameteri *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glFramebufferParameteri thread_data_local;
+   EVGL_API_Thread_Command_glFramebufferParameteri *thread_data = &thread_data_local;
 
-   thread_param->target = target;
-   thread_param->pname = pname;
-   thread_param->param = param;
+   thread_data->target = target;
+   thread_data->pname = pname;
+   thread_data->param = param;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glFramebufferParameteri,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGetFramebufferParameteriv(GLenum target, GLenum pname, GLint *params);
+ * void
+ * glGetFramebufferParameteriv(GLenum target, GLenum pname, GLint *params);
  */
 
 typedef struct
@@ -28574,12 +28578,12 @@ void (*orig_evgl_api_glGetFramebufferParameteriv)(GLenum target, GLenum pname, G
 static void
 _evgl_api_thread_glGetFramebufferParameteriv(void *data)
 {
-   EVGL_API_Thread_Command_glGetFramebufferParameteriv *thread_param =
+   EVGL_API_Thread_Command_glGetFramebufferParameteriv *thread_data =
       (EVGL_API_Thread_Command_glGetFramebufferParameteriv *)data;
 
-   orig_evgl_api_glGetFramebufferParameteriv(thread_param->target,
-                                             thread_param->pname,
-                                             thread_param->params);
+   orig_evgl_api_glGetFramebufferParameteriv(thread_data->target,
+                                             thread_data->pname,
+                                             thread_data->params);
 
 }
 
@@ -28594,22 +28598,22 @@ glGetFramebufferParameteriv_evgl_api_thread_cmd(GLenum target, GLenum pname, GLi
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGetFramebufferParameteriv thread_param_local;
-   EVGL_API_Thread_Command_glGetFramebufferParameteriv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGetFramebufferParameteriv thread_data_local;
+   EVGL_API_Thread_Command_glGetFramebufferParameteriv *thread_data = &thread_data_local;
 
-   thread_param->target = target;
-   thread_param->pname = pname;
-   thread_param->params = params;
+   thread_data->target = target;
+   thread_data->pname = pname;
+   thread_data->params = params;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGetFramebufferParameteriv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGetProgramInterfaceiv(GLuint program, GLenum programInterface, GLenum pname, GLint *params);
+ * void
+ * glGetProgramInterfaceiv(GLuint program, GLenum programInterface, GLenum pname, GLint *params);
  */
 
 typedef struct
@@ -28626,13 +28630,13 @@ void (*orig_evgl_api_glGetProgramInterfaceiv)(GLuint program, GLenum programInte
 static void
 _evgl_api_thread_glGetProgramInterfaceiv(void *data)
 {
-   EVGL_API_Thread_Command_glGetProgramInterfaceiv *thread_param =
+   EVGL_API_Thread_Command_glGetProgramInterfaceiv *thread_data =
       (EVGL_API_Thread_Command_glGetProgramInterfaceiv *)data;
 
-   orig_evgl_api_glGetProgramInterfaceiv(thread_param->program,
-                                         thread_param->programInterface,
-                                         thread_param->pname,
-                                         thread_param->params);
+   orig_evgl_api_glGetProgramInterfaceiv(thread_data->program,
+                                         thread_data->programInterface,
+                                         thread_data->pname,
+                                         thread_data->params);
 
 }
 
@@ -28647,23 +28651,23 @@ glGetProgramInterfaceiv_evgl_api_thread_cmd(GLuint program, GLenum programInterf
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGetProgramInterfaceiv thread_param_local;
-   EVGL_API_Thread_Command_glGetProgramInterfaceiv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGetProgramInterfaceiv thread_data_local;
+   EVGL_API_Thread_Command_glGetProgramInterfaceiv *thread_data = &thread_data_local;
 
-   thread_param->program = program;
-   thread_param->programInterface = programInterface;
-   thread_param->pname = pname;
-   thread_param->params = params;
+   thread_data->program = program;
+   thread_data->programInterface = programInterface;
+   thread_data->pname = pname;
+   thread_data->params = params;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGetProgramInterfaceiv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   GLuint
-   glGetProgramResourceIndex(GLuint program, GLenum programInterface, const GLchar *name);
+ * GLuint
+ * glGetProgramResourceIndex(GLuint program, GLenum programInterface, const GLchar *name);
  */
 
 typedef struct
@@ -28680,12 +28684,12 @@ GLuint (*orig_evgl_api_glGetProgramResourceIndex)(GLuint program, GLenum program
 static void
 _evgl_api_thread_glGetProgramResourceIndex(void *data)
 {
-   EVGL_API_Thread_Command_glGetProgramResourceIndex *thread_param =
+   EVGL_API_Thread_Command_glGetProgramResourceIndex *thread_data =
       (EVGL_API_Thread_Command_glGetProgramResourceIndex *)data;
 
-   thread_param->return_value = orig_evgl_api_glGetProgramResourceIndex(thread_param->program,
-                                                                        thread_param->programInterface,
-                                                                        thread_param->name);
+   thread_data->return_value = orig_evgl_api_glGetProgramResourceIndex(thread_data->program,
+                                                                       thread_data->programInterface,
+                                                                       thread_data->name);
 
 }
 
@@ -28699,24 +28703,24 @@ glGetProgramResourceIndex_evgl_api_thread_cmd(GLuint program, GLenum programInte
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGetProgramResourceIndex thread_param_local;
-   EVGL_API_Thread_Command_glGetProgramResourceIndex *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGetProgramResourceIndex thread_data_local;
+   EVGL_API_Thread_Command_glGetProgramResourceIndex *thread_data = &thread_data_local;
 
-   thread_param->program = program;
-   thread_param->programInterface = programInterface;
-   thread_param->name = name;
+   thread_data->program = program;
+   thread_data->programInterface = programInterface;
+   thread_data->name = name;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGetProgramResourceIndex,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
-   void
-   glGetProgramResourceName(GLuint program, GLenum programInterface, GLuint index, GLsizei bufSize, GLsizei *length, GLchar *name);
+ * void
+ * glGetProgramResourceName(GLuint program, GLenum programInterface, GLuint index, GLsizei bufSize, GLsizei *length, GLchar *name);
  */
 
 typedef struct
@@ -28735,15 +28739,15 @@ void (*orig_evgl_api_glGetProgramResourceName)(GLuint program, GLenum programInt
 static void
 _evgl_api_thread_glGetProgramResourceName(void *data)
 {
-   EVGL_API_Thread_Command_glGetProgramResourceName *thread_param =
+   EVGL_API_Thread_Command_glGetProgramResourceName *thread_data =
       (EVGL_API_Thread_Command_glGetProgramResourceName *)data;
 
-   orig_evgl_api_glGetProgramResourceName(thread_param->program,
-                                          thread_param->programInterface,
-                                          thread_param->index,
-                                          thread_param->bufSize,
-                                          thread_param->length,
-                                          thread_param->name);
+   orig_evgl_api_glGetProgramResourceName(thread_data->program,
+                                          thread_data->programInterface,
+                                          thread_data->index,
+                                          thread_data->bufSize,
+                                          thread_data->length,
+                                          thread_data->name);
 
 }
 
@@ -28758,25 +28762,25 @@ glGetProgramResourceName_evgl_api_thread_cmd(GLuint program, GLenum programInter
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGetProgramResourceName thread_param_local;
-   EVGL_API_Thread_Command_glGetProgramResourceName *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGetProgramResourceName thread_data_local;
+   EVGL_API_Thread_Command_glGetProgramResourceName *thread_data = &thread_data_local;
 
-   thread_param->program = program;
-   thread_param->programInterface = programInterface;
-   thread_param->index = index;
-   thread_param->bufSize = bufSize;
-   thread_param->length = length;
-   thread_param->name = name;
+   thread_data->program = program;
+   thread_data->programInterface = programInterface;
+   thread_data->index = index;
+   thread_data->bufSize = bufSize;
+   thread_data->length = length;
+   thread_data->name = name;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGetProgramResourceName,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGetProgramResourceiv(GLuint program, GLenum programInterface, GLuint index, GLsizei propCount, const GLenum *props, GLsizei bufSize, GLsizei *length, GLint *params);
+ * void
+ * glGetProgramResourceiv(GLuint program, GLenum programInterface, GLuint index, GLsizei propCount, const GLenum *props, GLsizei bufSize, GLsizei *length, GLint *params);
  */
 
 typedef struct
@@ -28797,17 +28801,17 @@ void (*orig_evgl_api_glGetProgramResourceiv)(GLuint program, GLenum programInter
 static void
 _evgl_api_thread_glGetProgramResourceiv(void *data)
 {
-   EVGL_API_Thread_Command_glGetProgramResourceiv *thread_param =
+   EVGL_API_Thread_Command_glGetProgramResourceiv *thread_data =
       (EVGL_API_Thread_Command_glGetProgramResourceiv *)data;
 
-   orig_evgl_api_glGetProgramResourceiv(thread_param->program,
-                                        thread_param->programInterface,
-                                        thread_param->index,
-                                        thread_param->propCount,
-                                        thread_param->props,
-                                        thread_param->bufSize,
-                                        thread_param->length,
-                                        thread_param->params);
+   orig_evgl_api_glGetProgramResourceiv(thread_data->program,
+                                        thread_data->programInterface,
+                                        thread_data->index,
+                                        thread_data->propCount,
+                                        thread_data->props,
+                                        thread_data->bufSize,
+                                        thread_data->length,
+                                        thread_data->params);
 
 }
 
@@ -28822,27 +28826,27 @@ glGetProgramResourceiv_evgl_api_thread_cmd(GLuint program, GLenum programInterfa
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGetProgramResourceiv thread_param_local;
-   EVGL_API_Thread_Command_glGetProgramResourceiv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGetProgramResourceiv thread_data_local;
+   EVGL_API_Thread_Command_glGetProgramResourceiv *thread_data = &thread_data_local;
 
-   thread_param->program = program;
-   thread_param->programInterface = programInterface;
-   thread_param->index = index;
-   thread_param->propCount = propCount;
-   thread_param->props = props;
-   thread_param->bufSize = bufSize;
-   thread_param->length = length;
-   thread_param->params = params;
+   thread_data->program = program;
+   thread_data->programInterface = programInterface;
+   thread_data->index = index;
+   thread_data->propCount = propCount;
+   thread_data->props = props;
+   thread_data->bufSize = bufSize;
+   thread_data->length = length;
+   thread_data->params = params;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGetProgramResourceiv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   GLint
-   glGetProgramResourceLocation(GLuint program, GLenum programInterface, const GLchar *name);
+ * GLint
+ * glGetProgramResourceLocation(GLuint program, GLenum programInterface, const GLchar *name);
  */
 
 typedef struct
@@ -28859,12 +28863,12 @@ GLint (*orig_evgl_api_glGetProgramResourceLocation)(GLuint program, GLenum progr
 static void
 _evgl_api_thread_glGetProgramResourceLocation(void *data)
 {
-   EVGL_API_Thread_Command_glGetProgramResourceLocation *thread_param =
+   EVGL_API_Thread_Command_glGetProgramResourceLocation *thread_data =
       (EVGL_API_Thread_Command_glGetProgramResourceLocation *)data;
 
-   thread_param->return_value = orig_evgl_api_glGetProgramResourceLocation(thread_param->program,
-                                                                           thread_param->programInterface,
-                                                                           thread_param->name);
+   thread_data->return_value = orig_evgl_api_glGetProgramResourceLocation(thread_data->program,
+                                                                          thread_data->programInterface,
+                                                                          thread_data->name);
 
 }
 
@@ -28878,24 +28882,24 @@ glGetProgramResourceLocation_evgl_api_thread_cmd(GLuint program, GLenum programI
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGetProgramResourceLocation thread_param_local;
-   EVGL_API_Thread_Command_glGetProgramResourceLocation *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGetProgramResourceLocation thread_data_local;
+   EVGL_API_Thread_Command_glGetProgramResourceLocation *thread_data = &thread_data_local;
 
-   thread_param->program = program;
-   thread_param->programInterface = programInterface;
-   thread_param->name = name;
+   thread_data->program = program;
+   thread_data->programInterface = programInterface;
+   thread_data->name = name;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGetProgramResourceLocation,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
-   void
-   glUseProgramStages(GLuint pipeline, GLbitfield stages, GLuint program);
+ * void
+ * glUseProgramStages(GLuint pipeline, GLbitfield stages, GLuint program);
  */
 
 typedef struct
@@ -28911,12 +28915,12 @@ void (*orig_evgl_api_glUseProgramStages)(GLuint pipeline, GLbitfield stages, GLu
 static void
 _evgl_api_thread_glUseProgramStages(void *data)
 {
-   EVGL_API_Thread_Command_glUseProgramStages *thread_param =
+   EVGL_API_Thread_Command_glUseProgramStages *thread_data =
       (EVGL_API_Thread_Command_glUseProgramStages *)data;
 
-   orig_evgl_api_glUseProgramStages(thread_param->pipeline,
-                                    thread_param->stages,
-                                    thread_param->program);
+   orig_evgl_api_glUseProgramStages(thread_data->pipeline,
+                                    thread_data->stages,
+                                    thread_data->program);
 
 }
 
@@ -28931,22 +28935,22 @@ glUseProgramStages_evgl_api_thread_cmd(GLuint pipeline, GLbitfield stages, GLuin
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glUseProgramStages thread_param_local;
-   EVGL_API_Thread_Command_glUseProgramStages *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glUseProgramStages thread_data_local;
+   EVGL_API_Thread_Command_glUseProgramStages *thread_data = &thread_data_local;
 
-   thread_param->pipeline = pipeline;
-   thread_param->stages = stages;
-   thread_param->program = program;
+   thread_data->pipeline = pipeline;
+   thread_data->stages = stages;
+   thread_data->program = program;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glUseProgramStages,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glActiveShaderProgram(GLuint pipeline, GLuint program);
+ * void
+ * glActiveShaderProgram(GLuint pipeline, GLuint program);
  */
 
 typedef struct
@@ -28961,11 +28965,11 @@ void (*orig_evgl_api_glActiveShaderProgram)(GLuint pipeline, GLuint program);
 static void
 _evgl_api_thread_glActiveShaderProgram(void *data)
 {
-   EVGL_API_Thread_Command_glActiveShaderProgram *thread_param =
+   EVGL_API_Thread_Command_glActiveShaderProgram *thread_data =
       (EVGL_API_Thread_Command_glActiveShaderProgram *)data;
 
-   orig_evgl_api_glActiveShaderProgram(thread_param->pipeline,
-                                       thread_param->program);
+   orig_evgl_api_glActiveShaderProgram(thread_data->pipeline,
+                                       thread_data->program);
 
 }
 
@@ -28980,21 +28984,21 @@ glActiveShaderProgram_evgl_api_thread_cmd(GLuint pipeline, GLuint program)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glActiveShaderProgram thread_param_local;
-   EVGL_API_Thread_Command_glActiveShaderProgram *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glActiveShaderProgram thread_data_local;
+   EVGL_API_Thread_Command_glActiveShaderProgram *thread_data = &thread_data_local;
 
-   thread_param->pipeline = pipeline;
-   thread_param->program = program;
+   thread_data->pipeline = pipeline;
+   thread_data->program = program;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glActiveShaderProgram,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   GLuint
-   glCreateShaderProgramv(GLenum type, GLsizei count, const GLchar *const*strings);
+ * GLuint
+ * glCreateShaderProgramv(GLenum type, GLsizei count, const GLchar *const*strings);
  */
 
 typedef struct
@@ -29011,12 +29015,12 @@ GLuint (*orig_evgl_api_glCreateShaderProgramv)(GLenum type, GLsizei count, const
 static void
 _evgl_api_thread_glCreateShaderProgramv(void *data)
 {
-   EVGL_API_Thread_Command_glCreateShaderProgramv *thread_param =
+   EVGL_API_Thread_Command_glCreateShaderProgramv *thread_data =
       (EVGL_API_Thread_Command_glCreateShaderProgramv *)data;
 
-   thread_param->return_value = orig_evgl_api_glCreateShaderProgramv(thread_param->type,
-                                                                     thread_param->count,
-                                                                     thread_param->strings);
+   thread_data->return_value = orig_evgl_api_glCreateShaderProgramv(thread_data->type,
+                                                                    thread_data->count,
+                                                                    thread_data->strings);
 
 }
 
@@ -29030,24 +29034,24 @@ glCreateShaderProgramv_evgl_api_thread_cmd(GLenum type, GLsizei count, const GLc
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glCreateShaderProgramv thread_param_local;
-   EVGL_API_Thread_Command_glCreateShaderProgramv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glCreateShaderProgramv thread_data_local;
+   EVGL_API_Thread_Command_glCreateShaderProgramv *thread_data = &thread_data_local;
 
-   thread_param->type = type;
-   thread_param->count = count;
-   thread_param->strings = strings;
+   thread_data->type = type;
+   thread_data->count = count;
+   thread_data->strings = strings;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glCreateShaderProgramv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
-   void
-   glBindProgramPipeline(GLuint pipeline);
+ * void
+ * glBindProgramPipeline(GLuint pipeline);
  */
 
 typedef struct
@@ -29061,10 +29065,10 @@ void (*orig_evgl_api_glBindProgramPipeline)(GLuint pipeline);
 static void
 _evgl_api_thread_glBindProgramPipeline(void *data)
 {
-   EVGL_API_Thread_Command_glBindProgramPipeline *thread_param =
+   EVGL_API_Thread_Command_glBindProgramPipeline *thread_data =
       (EVGL_API_Thread_Command_glBindProgramPipeline *)data;
 
-   orig_evgl_api_glBindProgramPipeline(thread_param->pipeline);
+   orig_evgl_api_glBindProgramPipeline(thread_data->pipeline);
 
 }
 
@@ -29079,20 +29083,20 @@ glBindProgramPipeline_evgl_api_thread_cmd(GLuint pipeline)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glBindProgramPipeline thread_param_local;
-   EVGL_API_Thread_Command_glBindProgramPipeline *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glBindProgramPipeline thread_data_local;
+   EVGL_API_Thread_Command_glBindProgramPipeline *thread_data = &thread_data_local;
 
-   thread_param->pipeline = pipeline;
+   thread_data->pipeline = pipeline;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glBindProgramPipeline,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glDeleteProgramPipelines(GLsizei n, const GLuint *pipelines);
+ * void
+ * glDeleteProgramPipelines(GLsizei n, const GLuint *pipelines);
  */
 
 typedef struct
@@ -29107,11 +29111,11 @@ void (*orig_evgl_api_glDeleteProgramPipelines)(GLsizei n, const GLuint *pipeline
 static void
 _evgl_api_thread_glDeleteProgramPipelines(void *data)
 {
-   EVGL_API_Thread_Command_glDeleteProgramPipelines *thread_param =
+   EVGL_API_Thread_Command_glDeleteProgramPipelines *thread_data =
       (EVGL_API_Thread_Command_glDeleteProgramPipelines *)data;
 
-   orig_evgl_api_glDeleteProgramPipelines(thread_param->n,
-                                          thread_param->pipelines);
+   orig_evgl_api_glDeleteProgramPipelines(thread_data->n,
+                                          thread_data->pipelines);
 
 }
 
@@ -29126,21 +29130,21 @@ glDeleteProgramPipelines_evgl_api_thread_cmd(GLsizei n, const GLuint *pipelines)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glDeleteProgramPipelines thread_param_local;
-   EVGL_API_Thread_Command_glDeleteProgramPipelines *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glDeleteProgramPipelines thread_data_local;
+   EVGL_API_Thread_Command_glDeleteProgramPipelines *thread_data = &thread_data_local;
 
-   thread_param->n = n;
-   thread_param->pipelines = pipelines;
+   thread_data->n = n;
+   thread_data->pipelines = pipelines;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glDeleteProgramPipelines,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGenProgramPipelines(GLsizei n, GLuint *pipelines);
+ * void
+ * glGenProgramPipelines(GLsizei n, GLuint *pipelines);
  */
 
 typedef struct
@@ -29155,11 +29159,11 @@ void (*orig_evgl_api_glGenProgramPipelines)(GLsizei n, GLuint *pipelines);
 static void
 _evgl_api_thread_glGenProgramPipelines(void *data)
 {
-   EVGL_API_Thread_Command_glGenProgramPipelines *thread_param =
+   EVGL_API_Thread_Command_glGenProgramPipelines *thread_data =
       (EVGL_API_Thread_Command_glGenProgramPipelines *)data;
 
-   orig_evgl_api_glGenProgramPipelines(thread_param->n,
-                                       thread_param->pipelines);
+   orig_evgl_api_glGenProgramPipelines(thread_data->n,
+                                       thread_data->pipelines);
 
 }
 
@@ -29174,21 +29178,21 @@ glGenProgramPipelines_evgl_api_thread_cmd(GLsizei n, GLuint *pipelines)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGenProgramPipelines thread_param_local;
-   EVGL_API_Thread_Command_glGenProgramPipelines *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGenProgramPipelines thread_data_local;
+   EVGL_API_Thread_Command_glGenProgramPipelines *thread_data = &thread_data_local;
 
-   thread_param->n = n;
-   thread_param->pipelines = pipelines;
+   thread_data->n = n;
+   thread_data->pipelines = pipelines;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGenProgramPipelines,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   GLboolean
-   glIsProgramPipeline(GLuint pipeline);
+ * GLboolean
+ * glIsProgramPipeline(GLuint pipeline);
  */
 
 typedef struct
@@ -29203,10 +29207,10 @@ GLboolean (*orig_evgl_api_glIsProgramPipeline)(GLuint pipeline);
 static void
 _evgl_api_thread_glIsProgramPipeline(void *data)
 {
-   EVGL_API_Thread_Command_glIsProgramPipeline *thread_param =
+   EVGL_API_Thread_Command_glIsProgramPipeline *thread_data =
       (EVGL_API_Thread_Command_glIsProgramPipeline *)data;
 
-   thread_param->return_value = orig_evgl_api_glIsProgramPipeline(thread_param->pipeline);
+   thread_data->return_value = orig_evgl_api_glIsProgramPipeline(thread_data->pipeline);
 
 }
 
@@ -29220,22 +29224,22 @@ glIsProgramPipeline_evgl_api_thread_cmd(GLuint pipeline)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glIsProgramPipeline thread_param_local;
-   EVGL_API_Thread_Command_glIsProgramPipeline *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glIsProgramPipeline thread_data_local;
+   EVGL_API_Thread_Command_glIsProgramPipeline *thread_data = &thread_data_local;
 
-   thread_param->pipeline = pipeline;
+   thread_data->pipeline = pipeline;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glIsProgramPipeline,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
-   void
-   glGetProgramPipelineiv(GLuint pipeline, GLenum pname, GLint *params);
+ * void
+ * glGetProgramPipelineiv(GLuint pipeline, GLenum pname, GLint *params);
  */
 
 typedef struct
@@ -29251,12 +29255,12 @@ void (*orig_evgl_api_glGetProgramPipelineiv)(GLuint pipeline, GLenum pname, GLin
 static void
 _evgl_api_thread_glGetProgramPipelineiv(void *data)
 {
-   EVGL_API_Thread_Command_glGetProgramPipelineiv *thread_param =
+   EVGL_API_Thread_Command_glGetProgramPipelineiv *thread_data =
       (EVGL_API_Thread_Command_glGetProgramPipelineiv *)data;
 
-   orig_evgl_api_glGetProgramPipelineiv(thread_param->pipeline,
-                                        thread_param->pname,
-                                        thread_param->params);
+   orig_evgl_api_glGetProgramPipelineiv(thread_data->pipeline,
+                                        thread_data->pname,
+                                        thread_data->params);
 
 }
 
@@ -29271,22 +29275,22 @@ glGetProgramPipelineiv_evgl_api_thread_cmd(GLuint pipeline, GLenum pname, GLint
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGetProgramPipelineiv thread_param_local;
-   EVGL_API_Thread_Command_glGetProgramPipelineiv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGetProgramPipelineiv thread_data_local;
+   EVGL_API_Thread_Command_glGetProgramPipelineiv *thread_data = &thread_data_local;
 
-   thread_param->pipeline = pipeline;
-   thread_param->pname = pname;
-   thread_param->params = params;
+   thread_data->pipeline = pipeline;
+   thread_data->pname = pname;
+   thread_data->params = params;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGetProgramPipelineiv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glProgramUniform1i(GLuint program, GLint location, GLint v0);
+ * void
+ * glProgramUniform1i(GLuint program, GLint location, GLint v0);
  */
 
 typedef struct
@@ -29302,12 +29306,12 @@ void (*orig_evgl_api_glProgramUniform1i)(GLuint program, GLint location, GLint v
 static void
 _evgl_api_thread_glProgramUniform1i(void *data)
 {
-   EVGL_API_Thread_Command_glProgramUniform1i *thread_param =
+   EVGL_API_Thread_Command_glProgramUniform1i *thread_data =
       (EVGL_API_Thread_Command_glProgramUniform1i *)data;
 
-   orig_evgl_api_glProgramUniform1i(thread_param->program,
-                                    thread_param->location,
-                                    thread_param->v0);
+   orig_evgl_api_glProgramUniform1i(thread_data->program,
+                                    thread_data->location,
+                                    thread_data->v0);
 
 }
 
@@ -29322,22 +29326,22 @@ glProgramUniform1i_evgl_api_thread_cmd(GLuint program, GLint location, GLint v0)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glProgramUniform1i thread_param_local;
-   EVGL_API_Thread_Command_glProgramUniform1i *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glProgramUniform1i thread_data_local;
+   EVGL_API_Thread_Command_glProgramUniform1i *thread_data = &thread_data_local;
 
-   thread_param->program = program;
-   thread_param->location = location;
-   thread_param->v0 = v0;
+   thread_data->program = program;
+   thread_data->location = location;
+   thread_data->v0 = v0;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glProgramUniform1i,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glProgramUniform2i(GLuint program, GLint location, GLint v0, GLint v1);
+ * void
+ * glProgramUniform2i(GLuint program, GLint location, GLint v0, GLint v1);
  */
 
 typedef struct
@@ -29354,13 +29358,13 @@ void (*orig_evgl_api_glProgramUniform2i)(GLuint program, GLint location, GLint v
 static void
 _evgl_api_thread_glProgramUniform2i(void *data)
 {
-   EVGL_API_Thread_Command_glProgramUniform2i *thread_param =
+   EVGL_API_Thread_Command_glProgramUniform2i *thread_data =
       (EVGL_API_Thread_Command_glProgramUniform2i *)data;
 
-   orig_evgl_api_glProgramUniform2i(thread_param->program,
-                                    thread_param->location,
-                                    thread_param->v0,
-                                    thread_param->v1);
+   orig_evgl_api_glProgramUniform2i(thread_data->program,
+                                    thread_data->location,
+                                    thread_data->v0,
+                                    thread_data->v1);
 
 }
 
@@ -29375,23 +29379,23 @@ glProgramUniform2i_evgl_api_thread_cmd(GLuint program, GLint location, GLint v0,
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glProgramUniform2i thread_param_local;
-   EVGL_API_Thread_Command_glProgramUniform2i *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glProgramUniform2i thread_data_local;
+   EVGL_API_Thread_Command_glProgramUniform2i *thread_data = &thread_data_local;
 
-   thread_param->program = program;
-   thread_param->location = location;
-   thread_param->v0 = v0;
-   thread_param->v1 = v1;
+   thread_data->program = program;
+   thread_data->location = location;
+   thread_data->v0 = v0;
+   thread_data->v1 = v1;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glProgramUniform2i,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glProgramUniform3i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2);
+ * void
+ * glProgramUniform3i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2);
  */
 
 typedef struct
@@ -29409,14 +29413,14 @@ void (*orig_evgl_api_glProgramUniform3i)(GLuint program, GLint location, GLint v
 static void
 _evgl_api_thread_glProgramUniform3i(void *data)
 {
-   EVGL_API_Thread_Command_glProgramUniform3i *thread_param =
+   EVGL_API_Thread_Command_glProgramUniform3i *thread_data =
       (EVGL_API_Thread_Command_glProgramUniform3i *)data;
 
-   orig_evgl_api_glProgramUniform3i(thread_param->program,
-                                    thread_param->location,
-                                    thread_param->v0,
-                                    thread_param->v1,
-                                    thread_param->v2);
+   orig_evgl_api_glProgramUniform3i(thread_data->program,
+                                    thread_data->location,
+                                    thread_data->v0,
+                                    thread_data->v1,
+                                    thread_data->v2);
 
 }
 
@@ -29431,24 +29435,24 @@ glProgramUniform3i_evgl_api_thread_cmd(GLuint program, GLint location, GLint v0,
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glProgramUniform3i thread_param_local;
-   EVGL_API_Thread_Command_glProgramUniform3i *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glProgramUniform3i thread_data_local;
+   EVGL_API_Thread_Command_glProgramUniform3i *thread_data = &thread_data_local;
 
-   thread_param->program = program;
-   thread_param->location = location;
-   thread_param->v0 = v0;
-   thread_param->v1 = v1;
-   thread_param->v2 = v2;
+   thread_data->program = program;
+   thread_data->location = location;
+   thread_data->v0 = v0;
+   thread_data->v1 = v1;
+   thread_data->v2 = v2;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glProgramUniform3i,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glProgramUniform4i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3);
+ * void
+ * glProgramUniform4i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3);
  */
 
 typedef struct
@@ -29467,15 +29471,15 @@ void (*orig_evgl_api_glProgramUniform4i)(GLuint program, GLint location, GLint v
 static void
 _evgl_api_thread_glProgramUniform4i(void *data)
 {
-   EVGL_API_Thread_Command_glProgramUniform4i *thread_param =
+   EVGL_API_Thread_Command_glProgramUniform4i *thread_data =
       (EVGL_API_Thread_Command_glProgramUniform4i *)data;
 
-   orig_evgl_api_glProgramUniform4i(thread_param->program,
-                                    thread_param->location,
-                                    thread_param->v0,
-                                    thread_param->v1,
-                                    thread_param->v2,
-                                    thread_param->v3);
+   orig_evgl_api_glProgramUniform4i(thread_data->program,
+                                    thread_data->location,
+                                    thread_data->v0,
+                                    thread_data->v1,
+                                    thread_data->v2,
+                                    thread_data->v3);
 
 }
 
@@ -29490,25 +29494,25 @@ glProgramUniform4i_evgl_api_thread_cmd(GLuint program, GLint location, GLint v0,
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glProgramUniform4i thread_param_local;
-   EVGL_API_Thread_Command_glProgramUniform4i *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glProgramUniform4i thread_data_local;
+   EVGL_API_Thread_Command_glProgramUniform4i *thread_data = &thread_data_local;
 
-   thread_param->program = program;
-   thread_param->location = location;
-   thread_param->v0 = v0;
-   thread_param->v1 = v1;
-   thread_param->v2 = v2;
-   thread_param->v3 = v3;
+   thread_data->program = program;
+   thread_data->location = location;
+   thread_data->v0 = v0;
+   thread_data->v1 = v1;
+   thread_data->v2 = v2;
+   thread_data->v3 = v3;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glProgramUniform4i,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glProgramUniform1ui(GLuint program, GLint location, GLuint v0);
+ * void
+ * glProgramUniform1ui(GLuint program, GLint location, GLuint v0);
  */
 
 typedef struct
@@ -29524,12 +29528,12 @@ void (*orig_evgl_api_glProgramUniform1ui)(GLuint program, GLint location, GLuint
 static void
 _evgl_api_thread_glProgramUniform1ui(void *data)
 {
-   EVGL_API_Thread_Command_glProgramUniform1ui *thread_param =
+   EVGL_API_Thread_Command_glProgramUniform1ui *thread_data =
       (EVGL_API_Thread_Command_glProgramUniform1ui *)data;
 
-   orig_evgl_api_glProgramUniform1ui(thread_param->program,
-                                     thread_param->location,
-                                     thread_param->v0);
+   orig_evgl_api_glProgramUniform1ui(thread_data->program,
+                                     thread_data->location,
+                                     thread_data->v0);
 
 }
 
@@ -29544,22 +29548,22 @@ glProgramUniform1ui_evgl_api_thread_cmd(GLuint program, GLint location, GLuint v
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glProgramUniform1ui thread_param_local;
-   EVGL_API_Thread_Command_glProgramUniform1ui *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glProgramUniform1ui thread_data_local;
+   EVGL_API_Thread_Command_glProgramUniform1ui *thread_data = &thread_data_local;
 
-   thread_param->program = program;
-   thread_param->location = location;
-   thread_param->v0 = v0;
+   thread_data->program = program;
+   thread_data->location = location;
+   thread_data->v0 = v0;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glProgramUniform1ui,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glProgramUniform2ui(GLuint program, GLint location, GLuint v0, GLuint v1);
+ * void
+ * glProgramUniform2ui(GLuint program, GLint location, GLuint v0, GLuint v1);
  */
 
 typedef struct
@@ -29576,13 +29580,13 @@ void (*orig_evgl_api_glProgramUniform2ui)(GLuint program, GLint location, GLuint
 static void
 _evgl_api_thread_glProgramUniform2ui(void *data)
 {
-   EVGL_API_Thread_Command_glProgramUniform2ui *thread_param =
+   EVGL_API_Thread_Command_glProgramUniform2ui *thread_data =
       (EVGL_API_Thread_Command_glProgramUniform2ui *)data;
 
-   orig_evgl_api_glProgramUniform2ui(thread_param->program,
-                                     thread_param->location,
-                                     thread_param->v0,
-                                     thread_param->v1);
+   orig_evgl_api_glProgramUniform2ui(thread_data->program,
+                                     thread_data->location,
+                                     thread_data->v0,
+                                     thread_data->v1);
 
 }
 
@@ -29597,23 +29601,23 @@ glProgramUniform2ui_evgl_api_thread_cmd(GLuint program, GLint location, GLuint v
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glProgramUniform2ui thread_param_local;
-   EVGL_API_Thread_Command_glProgramUniform2ui *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glProgramUniform2ui thread_data_local;
+   EVGL_API_Thread_Command_glProgramUniform2ui *thread_data = &thread_data_local;
 
-   thread_param->program = program;
-   thread_param->location = location;
-   thread_param->v0 = v0;
-   thread_param->v1 = v1;
+   thread_data->program = program;
+   thread_data->location = location;
+   thread_data->v0 = v0;
+   thread_data->v1 = v1;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glProgramUniform2ui,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glProgramUniform3ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2);
+ * void
+ * glProgramUniform3ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2);
  */
 
 typedef struct
@@ -29631,14 +29635,14 @@ void (*orig_evgl_api_glProgramUniform3ui)(GLuint program, GLint location, GLuint
 static void
 _evgl_api_thread_glProgramUniform3ui(void *data)
 {
-   EVGL_API_Thread_Command_glProgramUniform3ui *thread_param =
+   EVGL_API_Thread_Command_glProgramUniform3ui *thread_data =
       (EVGL_API_Thread_Command_glProgramUniform3ui *)data;
 
-   orig_evgl_api_glProgramUniform3ui(thread_param->program,
-                                     thread_param->location,
-                                     thread_param->v0,
-                                     thread_param->v1,
-                                     thread_param->v2);
+   orig_evgl_api_glProgramUniform3ui(thread_data->program,
+                                     thread_data->location,
+                                     thread_data->v0,
+                                     thread_data->v1,
+                                     thread_data->v2);
 
 }
 
@@ -29653,24 +29657,24 @@ glProgramUniform3ui_evgl_api_thread_cmd(GLuint program, GLint location, GLuint v
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glProgramUniform3ui thread_param_local;
-   EVGL_API_Thread_Command_glProgramUniform3ui *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glProgramUniform3ui thread_data_local;
+   EVGL_API_Thread_Command_glProgramUniform3ui *thread_data = &thread_data_local;
 
-   thread_param->program = program;
-   thread_param->location = location;
-   thread_param->v0 = v0;
-   thread_param->v1 = v1;
-   thread_param->v2 = v2;
+   thread_data->program = program;
+   thread_data->location = location;
+   thread_data->v0 = v0;
+   thread_data->v1 = v1;
+   thread_data->v2 = v2;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glProgramUniform3ui,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glProgramUniform4ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3);
+ * void
+ * glProgramUniform4ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3);
  */
 
 typedef struct
@@ -29689,15 +29693,15 @@ void (*orig_evgl_api_glProgramUniform4ui)(GLuint program, GLint location, GLuint
 static void
 _evgl_api_thread_glProgramUniform4ui(void *data)
 {
-   EVGL_API_Thread_Command_glProgramUniform4ui *thread_param =
+   EVGL_API_Thread_Command_glProgramUniform4ui *thread_data =
       (EVGL_API_Thread_Command_glProgramUniform4ui *)data;
 
-   orig_evgl_api_glProgramUniform4ui(thread_param->program,
-                                     thread_param->location,
-                                     thread_param->v0,
-                                     thread_param->v1,
-                                     thread_param->v2,
-                                     thread_param->v3);
+   orig_evgl_api_glProgramUniform4ui(thread_data->program,
+                                     thread_data->location,
+                                     thread_data->v0,
+                                     thread_data->v1,
+                                     thread_data->v2,
+                                     thread_data->v3);
 
 }
 
@@ -29712,25 +29716,25 @@ glProgramUniform4ui_evgl_api_thread_cmd(GLuint program, GLint location, GLuint v
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glProgramUniform4ui thread_param_local;
-   EVGL_API_Thread_Command_glProgramUniform4ui *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glProgramUniform4ui thread_data_local;
+   EVGL_API_Thread_Command_glProgramUniform4ui *thread_data = &thread_data_local;
 
-   thread_param->program = program;
-   thread_param->location = location;
-   thread_param->v0 = v0;
-   thread_param->v1 = v1;
-   thread_param->v2 = v2;
-   thread_param->v3 = v3;
+   thread_data->program = program;
+   thread_data->location = location;
+   thread_data->v0 = v0;
+   thread_data->v1 = v1;
+   thread_data->v2 = v2;
+   thread_data->v3 = v3;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glProgramUniform4ui,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glProgramUniform1f(GLuint program, GLint location, GLfloat v0);
+ * void
+ * glProgramUniform1f(GLuint program, GLint location, GLfloat v0);
  */
 
 typedef struct
@@ -29746,12 +29750,12 @@ void (*orig_evgl_api_glProgramUniform1f)(GLuint program, GLint location, GLfloat
 static void
 _evgl_api_thread_glProgramUniform1f(void *data)
 {
-   EVGL_API_Thread_Command_glProgramUniform1f *thread_param =
+   EVGL_API_Thread_Command_glProgramUniform1f *thread_data =
       (EVGL_API_Thread_Command_glProgramUniform1f *)data;
 
-   orig_evgl_api_glProgramUniform1f(thread_param->program,
-                                    thread_param->location,
-                                    thread_param->v0);
+   orig_evgl_api_glProgramUniform1f(thread_data->program,
+                                    thread_data->location,
+                                    thread_data->v0);
 
 }
 
@@ -29766,22 +29770,22 @@ glProgramUniform1f_evgl_api_thread_cmd(GLuint program, GLint location, GLfloat v
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glProgramUniform1f thread_param_local;
-   EVGL_API_Thread_Command_glProgramUniform1f *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glProgramUniform1f thread_data_local;
+   EVGL_API_Thread_Command_glProgramUniform1f *thread_data = &thread_data_local;
 
-   thread_param->program = program;
-   thread_param->location = location;
-   thread_param->v0 = v0;
+   thread_data->program = program;
+   thread_data->location = location;
+   thread_data->v0 = v0;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glProgramUniform1f,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glProgramUniform2f(GLuint program, GLint location, GLfloat v0, GLfloat v1);
+ * void
+ * glProgramUniform2f(GLuint program, GLint location, GLfloat v0, GLfloat v1);
  */
 
 typedef struct
@@ -29798,13 +29802,13 @@ void (*orig_evgl_api_glProgramUniform2f)(GLuint program, GLint location, GLfloat
 static void
 _evgl_api_thread_glProgramUniform2f(void *data)
 {
-   EVGL_API_Thread_Command_glProgramUniform2f *thread_param =
+   EVGL_API_Thread_Command_glProgramUniform2f *thread_data =
       (EVGL_API_Thread_Command_glProgramUniform2f *)data;
 
-   orig_evgl_api_glProgramUniform2f(thread_param->program,
-                                    thread_param->location,
-                                    thread_param->v0,
-                                    thread_param->v1);
+   orig_evgl_api_glProgramUniform2f(thread_data->program,
+                                    thread_data->location,
+                                    thread_data->v0,
+                                    thread_data->v1);
 
 }
 
@@ -29819,23 +29823,23 @@ glProgramUniform2f_evgl_api_thread_cmd(GLuint program, GLint location, GLfloat v
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glProgramUniform2f thread_param_local;
-   EVGL_API_Thread_Command_glProgramUniform2f *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glProgramUniform2f thread_data_local;
+   EVGL_API_Thread_Command_glProgramUniform2f *thread_data = &thread_data_local;
 
-   thread_param->program = program;
-   thread_param->location = location;
-   thread_param->v0 = v0;
-   thread_param->v1 = v1;
+   thread_data->program = program;
+   thread_data->location = location;
+   thread_data->v0 = v0;
+   thread_data->v1 = v1;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glProgramUniform2f,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glProgramUniform3f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2);
+ * void
+ * glProgramUniform3f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2);
  */
 
 typedef struct
@@ -29853,14 +29857,14 @@ void (*orig_evgl_api_glProgramUniform3f)(GLuint program, GLint location, GLfloat
 static void
 _evgl_api_thread_glProgramUniform3f(void *data)
 {
-   EVGL_API_Thread_Command_glProgramUniform3f *thread_param =
+   EVGL_API_Thread_Command_glProgramUniform3f *thread_data =
       (EVGL_API_Thread_Command_glProgramUniform3f *)data;
 
-   orig_evgl_api_glProgramUniform3f(thread_param->program,
-                                    thread_param->location,
-                                    thread_param->v0,
-                                    thread_param->v1,
-                                    thread_param->v2);
+   orig_evgl_api_glProgramUniform3f(thread_data->program,
+                                    thread_data->location,
+                                    thread_data->v0,
+                                    thread_data->v1,
+                                    thread_data->v2);
 
 }
 
@@ -29875,24 +29879,24 @@ glProgramUniform3f_evgl_api_thread_cmd(GLuint program, GLint location, GLfloat v
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glProgramUniform3f thread_param_local;
-   EVGL_API_Thread_Command_glProgramUniform3f *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glProgramUniform3f thread_data_local;
+   EVGL_API_Thread_Command_glProgramUniform3f *thread_data = &thread_data_local;
 
-   thread_param->program = program;
-   thread_param->location = location;
-   thread_param->v0 = v0;
-   thread_param->v1 = v1;
-   thread_param->v2 = v2;
+   thread_data->program = program;
+   thread_data->location = location;
+   thread_data->v0 = v0;
+   thread_data->v1 = v1;
+   thread_data->v2 = v2;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glProgramUniform3f,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glProgramUniform4f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);
+ * void
+ * glProgramUniform4f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);
  */
 
 typedef struct
@@ -29911,15 +29915,15 @@ void (*orig_evgl_api_glProgramUniform4f)(GLuint program, GLint location, GLfloat
 static void
 _evgl_api_thread_glProgramUniform4f(void *data)
 {
-   EVGL_API_Thread_Command_glProgramUniform4f *thread_param =
+   EVGL_API_Thread_Command_glProgramUniform4f *thread_data =
       (EVGL_API_Thread_Command_glProgramUniform4f *)data;
 
-   orig_evgl_api_glProgramUniform4f(thread_param->program,
-                                    thread_param->location,
-                                    thread_param->v0,
-                                    thread_param->v1,
-                                    thread_param->v2,
-                                    thread_param->v3);
+   orig_evgl_api_glProgramUniform4f(thread_data->program,
+                                    thread_data->location,
+                                    thread_data->v0,
+                                    thread_data->v1,
+                                    thread_data->v2,
+                                    thread_data->v3);
 
 }
 
@@ -29934,25 +29938,25 @@ glProgramUniform4f_evgl_api_thread_cmd(GLuint program, GLint location, GLfloat v
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glProgramUniform4f thread_param_local;
-   EVGL_API_Thread_Command_glProgramUniform4f *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glProgramUniform4f thread_data_local;
+   EVGL_API_Thread_Command_glProgramUniform4f *thread_data = &thread_data_local;
 
-   thread_param->program = program;
-   thread_param->location = location;
-   thread_param->v0 = v0;
-   thread_param->v1 = v1;
-   thread_param->v2 = v2;
-   thread_param->v3 = v3;
+   thread_data->program = program;
+   thread_data->location = location;
+   thread_data->v0 = v0;
+   thread_data->v1 = v1;
+   thread_data->v2 = v2;
+   thread_data->v3 = v3;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glProgramUniform4f,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glProgramUniform1iv(GLuint program, GLint location, GLsizei count, const GLint *value);
+ * void
+ * glProgramUniform1iv(GLuint program, GLint location, GLsizei count, const GLint *value);
  */
 
 typedef struct
@@ -29969,13 +29973,13 @@ void (*orig_evgl_api_glProgramUniform1iv)(GLuint program, GLint location, GLsize
 static void
 _evgl_api_thread_glProgramUniform1iv(void *data)
 {
-   EVGL_API_Thread_Command_glProgramUniform1iv *thread_param =
+   EVGL_API_Thread_Command_glProgramUniform1iv *thread_data =
       (EVGL_API_Thread_Command_glProgramUniform1iv *)data;
 
-   orig_evgl_api_glProgramUniform1iv(thread_param->program,
-                                     thread_param->location,
-                                     thread_param->count,
-                                     thread_param->value);
+   orig_evgl_api_glProgramUniform1iv(thread_data->program,
+                                     thread_data->location,
+                                     thread_data->count,
+                                     thread_data->value);
 
 }
 
@@ -29990,23 +29994,23 @@ glProgramUniform1iv_evgl_api_thread_cmd(GLuint program, GLint location, GLsizei
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glProgramUniform1iv thread_param_local;
-   EVGL_API_Thread_Command_glProgramUniform1iv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glProgramUniform1iv thread_data_local;
+   EVGL_API_Thread_Command_glProgramUniform1iv *thread_data = &thread_data_local;
 
-   thread_param->program = program;
-   thread_param->location = location;
-   thread_param->count = count;
-   thread_param->value = value;
+   thread_data->program = program;
+   thread_data->location = location;
+   thread_data->count = count;
+   thread_data->value = value;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glProgramUniform1iv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glProgramUniform2iv(GLuint program, GLint location, GLsizei count, const GLint *value);
+ * void
+ * glProgramUniform2iv(GLuint program, GLint location, GLsizei count, const GLint *value);
  */
 
 typedef struct
@@ -30023,13 +30027,13 @@ void (*orig_evgl_api_glProgramUniform2iv)(GLuint program, GLint location, GLsize
 static void
 _evgl_api_thread_glProgramUniform2iv(void *data)
 {
-   EVGL_API_Thread_Command_glProgramUniform2iv *thread_param =
+   EVGL_API_Thread_Command_glProgramUniform2iv *thread_data =
       (EVGL_API_Thread_Command_glProgramUniform2iv *)data;
 
-   orig_evgl_api_glProgramUniform2iv(thread_param->program,
-                                     thread_param->location,
-                                     thread_param->count,
-                                     thread_param->value);
+   orig_evgl_api_glProgramUniform2iv(thread_data->program,
+                                     thread_data->location,
+                                     thread_data->count,
+                                     thread_data->value);
 
 }
 
@@ -30044,23 +30048,23 @@ glProgramUniform2iv_evgl_api_thread_cmd(GLuint program, GLint location, GLsizei
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glProgramUniform2iv thread_param_local;
-   EVGL_API_Thread_Command_glProgramUniform2iv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glProgramUniform2iv thread_data_local;
+   EVGL_API_Thread_Command_glProgramUniform2iv *thread_data = &thread_data_local;
 
-   thread_param->program = program;
-   thread_param->location = location;
-   thread_param->count = count;
-   thread_param->value = value;
+   thread_data->program = program;
+   thread_data->location = location;
+   thread_data->count = count;
+   thread_data->value = value;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glProgramUniform2iv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glProgramUniform3iv(GLuint program, GLint location, GLsizei count, const GLint *value);
+ * void
+ * glProgramUniform3iv(GLuint program, GLint location, GLsizei count, const GLint *value);
  */
 
 typedef struct
@@ -30077,13 +30081,13 @@ void (*orig_evgl_api_glProgramUniform3iv)(GLuint program, GLint location, GLsize
 static void
 _evgl_api_thread_glProgramUniform3iv(void *data)
 {
-   EVGL_API_Thread_Command_glProgramUniform3iv *thread_param =
+   EVGL_API_Thread_Command_glProgramUniform3iv *thread_data =
       (EVGL_API_Thread_Command_glProgramUniform3iv *)data;
 
-   orig_evgl_api_glProgramUniform3iv(thread_param->program,
-                                     thread_param->location,
-                                     thread_param->count,
-                                     thread_param->value);
+   orig_evgl_api_glProgramUniform3iv(thread_data->program,
+                                     thread_data->location,
+                                     thread_data->count,
+                                     thread_data->value);
 
 }
 
@@ -30098,23 +30102,23 @@ glProgramUniform3iv_evgl_api_thread_cmd(GLuint program, GLint location, GLsizei
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glProgramUniform3iv thread_param_local;
-   EVGL_API_Thread_Command_glProgramUniform3iv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glProgramUniform3iv thread_data_local;
+   EVGL_API_Thread_Command_glProgramUniform3iv *thread_data = &thread_data_local;
 
-   thread_param->program = program;
-   thread_param->location = location;
-   thread_param->count = count;
-   thread_param->value = value;
+   thread_data->program = program;
+   thread_data->location = location;
+   thread_data->count = count;
+   thread_data->value = value;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glProgramUniform3iv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glProgramUniform4iv(GLuint program, GLint location, GLsizei count, const GLint *value);
+ * void
+ * glProgramUniform4iv(GLuint program, GLint location, GLsizei count, const GLint *value);
  */
 
 typedef struct
@@ -30131,13 +30135,13 @@ void (*orig_evgl_api_glProgramUniform4iv)(GLuint program, GLint location, GLsize
 static void
 _evgl_api_thread_glProgramUniform4iv(void *data)
 {
-   EVGL_API_Thread_Command_glProgramUniform4iv *thread_param =
+   EVGL_API_Thread_Command_glProgramUniform4iv *thread_data =
       (EVGL_API_Thread_Command_glProgramUniform4iv *)data;
 
-   orig_evgl_api_glProgramUniform4iv(thread_param->program,
-                                     thread_param->location,
-                                     thread_param->count,
-                                     thread_param->value);
+   orig_evgl_api_glProgramUniform4iv(thread_data->program,
+                                     thread_data->location,
+                                     thread_data->count,
+                                     thread_data->value);
 
 }
 
@@ -30152,23 +30156,23 @@ glProgramUniform4iv_evgl_api_thread_cmd(GLuint program, GLint location, GLsizei
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glProgramUniform4iv thread_param_local;
-   EVGL_API_Thread_Command_glProgramUniform4iv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glProgramUniform4iv thread_data_local;
+   EVGL_API_Thread_Command_glProgramUniform4iv *thread_data = &thread_data_local;
 
-   thread_param->program = program;
-   thread_param->location = location;
-   thread_param->count = count;
-   thread_param->value = value;
+   thread_data->program = program;
+   thread_data->location = location;
+   thread_data->count = count;
+   thread_data->value = value;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glProgramUniform4iv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glProgramUniform1uiv(GLuint program, GLint location, GLsizei count, const GLuint *value);
+ * void
+ * glProgramUniform1uiv(GLuint program, GLint location, GLsizei count, const GLuint *value);
  */
 
 typedef struct
@@ -30185,13 +30189,13 @@ void (*orig_evgl_api_glProgramUniform1uiv)(GLuint program, GLint location, GLsiz
 static void
 _evgl_api_thread_glProgramUniform1uiv(void *data)
 {
-   EVGL_API_Thread_Command_glProgramUniform1uiv *thread_param =
+   EVGL_API_Thread_Command_glProgramUniform1uiv *thread_data =
       (EVGL_API_Thread_Command_glProgramUniform1uiv *)data;
 
-   orig_evgl_api_glProgramUniform1uiv(thread_param->program,
-                                      thread_param->location,
-                                      thread_param->count,
-                                      thread_param->value);
+   orig_evgl_api_glProgramUniform1uiv(thread_data->program,
+                                      thread_data->location,
+                                      thread_data->count,
+                                      thread_data->value);
 
 }
 
@@ -30206,23 +30210,23 @@ glProgramUniform1uiv_evgl_api_thread_cmd(GLuint program, GLint location, GLsizei
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glProgramUniform1uiv thread_param_local;
-   EVGL_API_Thread_Command_glProgramUniform1uiv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glProgramUniform1uiv thread_data_local;
+   EVGL_API_Thread_Command_glProgramUniform1uiv *thread_data = &thread_data_local;
 
-   thread_param->program = program;
-   thread_param->location = location;
-   thread_param->count = count;
-   thread_param->value = value;
+   thread_data->program = program;
+   thread_data->location = location;
+   thread_data->count = count;
+   thread_data->value = value;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glProgramUniform1uiv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glProgramUniform2uiv(GLuint program, GLint location, GLsizei count, const GLuint *value);
+ * void
+ * glProgramUniform2uiv(GLuint program, GLint location, GLsizei count, const GLuint *value);
  */
 
 typedef struct
@@ -30239,13 +30243,13 @@ void (*orig_evgl_api_glProgramUniform2uiv)(GLuint program, GLint location, GLsiz
 static void
 _evgl_api_thread_glProgramUniform2uiv(void *data)
 {
-   EVGL_API_Thread_Command_glProgramUniform2uiv *thread_param =
+   EVGL_API_Thread_Command_glProgramUniform2uiv *thread_data =
       (EVGL_API_Thread_Command_glProgramUniform2uiv *)data;
 
-   orig_evgl_api_glProgramUniform2uiv(thread_param->program,
-                                      thread_param->location,
-                                      thread_param->count,
-                                      thread_param->value);
+   orig_evgl_api_glProgramUniform2uiv(thread_data->program,
+                                      thread_data->location,
+                                      thread_data->count,
+                                      thread_data->value);
 
 }
 
@@ -30260,23 +30264,23 @@ glProgramUniform2uiv_evgl_api_thread_cmd(GLuint program, GLint location, GLsizei
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glProgramUniform2uiv thread_param_local;
-   EVGL_API_Thread_Command_glProgramUniform2uiv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glProgramUniform2uiv thread_data_local;
+   EVGL_API_Thread_Command_glProgramUniform2uiv *thread_data = &thread_data_local;
 
-   thread_param->program = program;
-   thread_param->location = location;
-   thread_param->count = count;
-   thread_param->value = value;
+   thread_data->program = program;
+   thread_data->location = location;
+   thread_data->count = count;
+   thread_data->value = value;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glProgramUniform2uiv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glProgramUniform3uiv(GLuint program, GLint location, GLsizei count, const GLuint *value);
+ * void
+ * glProgramUniform3uiv(GLuint program, GLint location, GLsizei count, const GLuint *value);
  */
 
 typedef struct
@@ -30293,13 +30297,13 @@ void (*orig_evgl_api_glProgramUniform3uiv)(GLuint program, GLint location, GLsiz
 static void
 _evgl_api_thread_glProgramUniform3uiv(void *data)
 {
-   EVGL_API_Thread_Command_glProgramUniform3uiv *thread_param =
+   EVGL_API_Thread_Command_glProgramUniform3uiv *thread_data =
       (EVGL_API_Thread_Command_glProgramUniform3uiv *)data;
 
-   orig_evgl_api_glProgramUniform3uiv(thread_param->program,
-                                      thread_param->location,
-                                      thread_param->count,
-                                      thread_param->value);
+   orig_evgl_api_glProgramUniform3uiv(thread_data->program,
+                                      thread_data->location,
+                                      thread_data->count,
+                                      thread_data->value);
 
 }
 
@@ -30314,23 +30318,23 @@ glProgramUniform3uiv_evgl_api_thread_cmd(GLuint program, GLint location, GLsizei
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glProgramUniform3uiv thread_param_local;
-   EVGL_API_Thread_Command_glProgramUniform3uiv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glProgramUniform3uiv thread_data_local;
+   EVGL_API_Thread_Command_glProgramUniform3uiv *thread_data = &thread_data_local;
 
-   thread_param->program = program;
-   thread_param->location = location;
-   thread_param->count = count;
-   thread_param->value = value;
+   thread_data->program = program;
+   thread_data->location = location;
+   thread_data->count = count;
+   thread_data->value = value;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glProgramUniform3uiv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glProgramUniform4uiv(GLuint program, GLint location, GLsizei count, const GLuint *value);
+ * void
+ * glProgramUniform4uiv(GLuint program, GLint location, GLsizei count, const GLuint *value);
  */
 
 typedef struct
@@ -30347,13 +30351,13 @@ void (*orig_evgl_api_glProgramUniform4uiv)(GLuint program, GLint location, GLsiz
 static void
 _evgl_api_thread_glProgramUniform4uiv(void *data)
 {
-   EVGL_API_Thread_Command_glProgramUniform4uiv *thread_param =
+   EVGL_API_Thread_Command_glProgramUniform4uiv *thread_data =
       (EVGL_API_Thread_Command_glProgramUniform4uiv *)data;
 
-   orig_evgl_api_glProgramUniform4uiv(thread_param->program,
-                                      thread_param->location,
-                                      thread_param->count,
-                                      thread_param->value);
+   orig_evgl_api_glProgramUniform4uiv(thread_data->program,
+                                      thread_data->location,
+                                      thread_data->count,
+                                      thread_data->value);
 
 }
 
@@ -30368,23 +30372,23 @@ glProgramUniform4uiv_evgl_api_thread_cmd(GLuint program, GLint location, GLsizei
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glProgramUniform4uiv thread_param_local;
-   EVGL_API_Thread_Command_glProgramUniform4uiv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glProgramUniform4uiv thread_data_local;
+   EVGL_API_Thread_Command_glProgramUniform4uiv *thread_data = &thread_data_local;
 
-   thread_param->program = program;
-   thread_param->location = location;
-   thread_param->count = count;
-   thread_param->value = value;
+   thread_data->program = program;
+   thread_data->location = location;
+   thread_data->count = count;
+   thread_data->value = value;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glProgramUniform4uiv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glProgramUniform1fv(GLuint program, GLint location, GLsizei count, const GLfloat *value);
+ * void
+ * glProgramUniform1fv(GLuint program, GLint location, GLsizei count, const GLfloat *value);
  */
 
 typedef struct
@@ -30401,13 +30405,13 @@ void (*orig_evgl_api_glProgramUniform1fv)(GLuint program, GLint location, GLsize
 static void
 _evgl_api_thread_glProgramUniform1fv(void *data)
 {
-   EVGL_API_Thread_Command_glProgramUniform1fv *thread_param =
+   EVGL_API_Thread_Command_glProgramUniform1fv *thread_data =
       (EVGL_API_Thread_Command_glProgramUniform1fv *)data;
 
-   orig_evgl_api_glProgramUniform1fv(thread_param->program,
-                                     thread_param->location,
-                                     thread_param->count,
-                                     thread_param->value);
+   orig_evgl_api_glProgramUniform1fv(thread_data->program,
+                                     thread_data->location,
+                                     thread_data->count,
+                                     thread_data->value);
 
 }
 
@@ -30422,23 +30426,23 @@ glProgramUniform1fv_evgl_api_thread_cmd(GLuint program, GLint location, GLsizei
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glProgramUniform1fv thread_param_local;
-   EVGL_API_Thread_Command_glProgramUniform1fv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glProgramUniform1fv thread_data_local;
+   EVGL_API_Thread_Command_glProgramUniform1fv *thread_data = &thread_data_local;
 
-   thread_param->program = program;
-   thread_param->location = location;
-   thread_param->count = count;
-   thread_param->value = value;
+   thread_data->program = program;
+   thread_data->location = location;
+   thread_data->count = count;
+   thread_data->value = value;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glProgramUniform1fv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glProgramUniform2fv(GLuint program, GLint location, GLsizei count, const GLfloat *value);
+ * void
+ * glProgramUniform2fv(GLuint program, GLint location, GLsizei count, const GLfloat *value);
  */
 
 typedef struct
@@ -30455,13 +30459,13 @@ void (*orig_evgl_api_glProgramUniform2fv)(GLuint program, GLint location, GLsize
 static void
 _evgl_api_thread_glProgramUniform2fv(void *data)
 {
-   EVGL_API_Thread_Command_glProgramUniform2fv *thread_param =
+   EVGL_API_Thread_Command_glProgramUniform2fv *thread_data =
       (EVGL_API_Thread_Command_glProgramUniform2fv *)data;
 
-   orig_evgl_api_glProgramUniform2fv(thread_param->program,
-                                     thread_param->location,
-                                     thread_param->count,
-                                     thread_param->value);
+   orig_evgl_api_glProgramUniform2fv(thread_data->program,
+                                     thread_data->location,
+                                     thread_data->count,
+                                     thread_data->value);
 
 }
 
@@ -30476,23 +30480,23 @@ glProgramUniform2fv_evgl_api_thread_cmd(GLuint program, GLint location, GLsizei
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glProgramUniform2fv thread_param_local;
-   EVGL_API_Thread_Command_glProgramUniform2fv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glProgramUniform2fv thread_data_local;
+   EVGL_API_Thread_Command_glProgramUniform2fv *thread_data = &thread_data_local;
 
-   thread_param->program = program;
-   thread_param->location = location;
-   thread_param->count = count;
-   thread_param->value = value;
+   thread_data->program = program;
+   thread_data->location = location;
+   thread_data->count = count;
+   thread_data->value = value;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glProgramUniform2fv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glProgramUniform3fv(GLuint program, GLint location, GLsizei count, const GLfloat *value);
+ * void
+ * glProgramUniform3fv(GLuint program, GLint location, GLsizei count, const GLfloat *value);
  */
 
 typedef struct
@@ -30509,13 +30513,13 @@ void (*orig_evgl_api_glProgramUniform3fv)(GLuint program, GLint location, GLsize
 static void
 _evgl_api_thread_glProgramUniform3fv(void *data)
 {
-   EVGL_API_Thread_Command_glProgramUniform3fv *thread_param =
+   EVGL_API_Thread_Command_glProgramUniform3fv *thread_data =
       (EVGL_API_Thread_Command_glProgramUniform3fv *)data;
 
-   orig_evgl_api_glProgramUniform3fv(thread_param->program,
-                                     thread_param->location,
-                                     thread_param->count,
-                                     thread_param->value);
+   orig_evgl_api_glProgramUniform3fv(thread_data->program,
+                                     thread_data->location,
+                                     thread_data->count,
+                                     thread_data->value);
 
 }
 
@@ -30530,23 +30534,23 @@ glProgramUniform3fv_evgl_api_thread_cmd(GLuint program, GLint location, GLsizei
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glProgramUniform3fv thread_param_local;
-   EVGL_API_Thread_Command_glProgramUniform3fv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glProgramUniform3fv thread_data_local;
+   EVGL_API_Thread_Command_glProgramUniform3fv *thread_data = &thread_data_local;
 
-   thread_param->program = program;
-   thread_param->location = location;
-   thread_param->count = count;
-   thread_param->value = value;
+   thread_data->program = program;
+   thread_data->location = location;
+   thread_data->count = count;
+   thread_data->value = value;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glProgramUniform3fv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glProgramUniform4fv(GLuint program, GLint location, GLsizei count, const GLfloat *value);
+ * void
+ * glProgramUniform4fv(GLuint program, GLint location, GLsizei count, const GLfloat *value);
  */
 
 typedef struct
@@ -30563,13 +30567,13 @@ void (*orig_evgl_api_glProgramUniform4fv)(GLuint program, GLint location, GLsize
 static void
 _evgl_api_thread_glProgramUniform4fv(void *data)
 {
-   EVGL_API_Thread_Command_glProgramUniform4fv *thread_param =
+   EVGL_API_Thread_Command_glProgramUniform4fv *thread_data =
       (EVGL_API_Thread_Command_glProgramUniform4fv *)data;
 
-   orig_evgl_api_glProgramUniform4fv(thread_param->program,
-                                     thread_param->location,
-                                     thread_param->count,
-                                     thread_param->value);
+   orig_evgl_api_glProgramUniform4fv(thread_data->program,
+                                     thread_data->location,
+                                     thread_data->count,
+                                     thread_data->value);
 
 }
 
@@ -30584,23 +30588,23 @@ glProgramUniform4fv_evgl_api_thread_cmd(GLuint program, GLint location, GLsizei
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glProgramUniform4fv thread_param_local;
-   EVGL_API_Thread_Command_glProgramUniform4fv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glProgramUniform4fv thread_data_local;
+   EVGL_API_Thread_Command_glProgramUniform4fv *thread_data = &thread_data_local;
 
-   thread_param->program = program;
-   thread_param->location = location;
-   thread_param->count = count;
-   thread_param->value = value;
+   thread_data->program = program;
+   thread_data->location = location;
+   thread_data->count = count;
+   thread_data->value = value;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glProgramUniform4fv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glProgramUniformMatrix2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+ * void
+ * glProgramUniformMatrix2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
  */
 
 typedef struct
@@ -30618,14 +30622,14 @@ void (*orig_evgl_api_glProgramUniformMatrix2fv)(GLuint program, GLint location,
 static void
 _evgl_api_thread_glProgramUniformMatrix2fv(void *data)
 {
-   EVGL_API_Thread_Command_glProgramUniformMatrix2fv *thread_param =
+   EVGL_API_Thread_Command_glProgramUniformMatrix2fv *thread_data =
       (EVGL_API_Thread_Command_glProgramUniformMatrix2fv *)data;
 
-   orig_evgl_api_glProgramUniformMatrix2fv(thread_param->program,
-                                           thread_param->location,
-                                           thread_param->count,
-                                           thread_param->transpose,
-                                           thread_param->value);
+   orig_evgl_api_glProgramUniformMatrix2fv(thread_data->program,
+                                           thread_data->location,
+                                           thread_data->count,
+                                           thread_data->transpose,
+                                           thread_data->value);
 
 }
 
@@ -30640,24 +30644,24 @@ glProgramUniformMatrix2fv_evgl_api_thread_cmd(GLuint program, GLint location, GL
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glProgramUniformMatrix2fv thread_param_local;
-   EVGL_API_Thread_Command_glProgramUniformMatrix2fv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glProgramUniformMatrix2fv thread_data_local;
+   EVGL_API_Thread_Command_glProgramUniformMatrix2fv *thread_data = &thread_data_local;
 
-   thread_param->program = program;
-   thread_param->location = location;
-   thread_param->count = count;
-   thread_param->transpose = transpose;
-   thread_param->value = value;
+   thread_data->program = program;
+   thread_data->location = location;
+   thread_data->count = count;
+   thread_data->transpose = transpose;
+   thread_data->value = value;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glProgramUniformMatrix2fv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glProgramUniformMatrix3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+ * void
+ * glProgramUniformMatrix3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
  */
 
 typedef struct
@@ -30675,14 +30679,14 @@ void (*orig_evgl_api_glProgramUniformMatrix3fv)(GLuint program, GLint location,
 static void
 _evgl_api_thread_glProgramUniformMatrix3fv(void *data)
 {
-   EVGL_API_Thread_Command_glProgramUniformMatrix3fv *thread_param =
+   EVGL_API_Thread_Command_glProgramUniformMatrix3fv *thread_data =
       (EVGL_API_Thread_Command_glProgramUniformMatrix3fv *)data;
 
-   orig_evgl_api_glProgramUniformMatrix3fv(thread_param->program,
-                                           thread_param->location,
-                                           thread_param->count,
-                                           thread_param->transpose,
-                                           thread_param->value);
+   orig_evgl_api_glProgramUniformMatrix3fv(thread_data->program,
+                                           thread_data->location,
+                                           thread_data->count,
+                                           thread_data->transpose,
+                                           thread_data->value);
 
 }
 
@@ -30697,24 +30701,24 @@ glProgramUniformMatrix3fv_evgl_api_thread_cmd(GLuint program, GLint location, GL
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glProgramUniformMatrix3fv thread_param_local;
-   EVGL_API_Thread_Command_glProgramUniformMatrix3fv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glProgramUniformMatrix3fv thread_data_local;
+   EVGL_API_Thread_Command_glProgramUniformMatrix3fv *thread_data = &thread_data_local;
 
-   thread_param->program = program;
-   thread_param->location = location;
-   thread_param->count = count;
-   thread_param->transpose = transpose;
-   thread_param->value = value;
+   thread_data->program = program;
+   thread_data->location = location;
+   thread_data->count = count;
+   thread_data->transpose = transpose;
+   thread_data->value = value;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glProgramUniformMatrix3fv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glProgramUniformMatrix4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+ * void
+ * glProgramUniformMatrix4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
  */
 
 typedef struct
@@ -30732,14 +30736,14 @@ void (*orig_evgl_api_glProgramUniformMatrix4fv)(GLuint program, GLint location,
 static void
 _evgl_api_thread_glProgramUniformMatrix4fv(void *data)
 {
-   EVGL_API_Thread_Command_glProgramUniformMatrix4fv *thread_param =
+   EVGL_API_Thread_Command_glProgramUniformMatrix4fv *thread_data =
       (EVGL_API_Thread_Command_glProgramUniformMatrix4fv *)data;
 
-   orig_evgl_api_glProgramUniformMatrix4fv(thread_param->program,
-                                           thread_param->location,
-                                           thread_param->count,
-                                           thread_param->transpose,
-                                           thread_param->value);
+   orig_evgl_api_glProgramUniformMatrix4fv(thread_data->program,
+                                           thread_data->location,
+                                           thread_data->count,
+                                           thread_data->transpose,
+                                           thread_data->value);
 
 }
 
@@ -30754,24 +30758,24 @@ glProgramUniformMatrix4fv_evgl_api_thread_cmd(GLuint program, GLint location, GL
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glProgramUniformMatrix4fv thread_param_local;
-   EVGL_API_Thread_Command_glProgramUniformMatrix4fv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glProgramUniformMatrix4fv thread_data_local;
+   EVGL_API_Thread_Command_glProgramUniformMatrix4fv *thread_data = &thread_data_local;
 
-   thread_param->program = program;
-   thread_param->location = location;
-   thread_param->count = count;
-   thread_param->transpose = transpose;
-   thread_param->value = value;
+   thread_data->program = program;
+   thread_data->location = location;
+   thread_data->count = count;
+   thread_data->transpose = transpose;
+   thread_data->value = value;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glProgramUniformMatrix4fv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glProgramUniformMatrix2x3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+ * void
+ * glProgramUniformMatrix2x3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
  */
 
 typedef struct
@@ -30789,14 +30793,14 @@ void (*orig_evgl_api_glProgramUniformMatrix2x3fv)(GLuint program, GLint location
 static void
 _evgl_api_thread_glProgramUniformMatrix2x3fv(void *data)
 {
-   EVGL_API_Thread_Command_glProgramUniformMatrix2x3fv *thread_param =
+   EVGL_API_Thread_Command_glProgramUniformMatrix2x3fv *thread_data =
       (EVGL_API_Thread_Command_glProgramUniformMatrix2x3fv *)data;
 
-   orig_evgl_api_glProgramUniformMatrix2x3fv(thread_param->program,
-                                             thread_param->location,
-                                             thread_param->count,
-                                             thread_param->transpose,
-                                             thread_param->value);
+   orig_evgl_api_glProgramUniformMatrix2x3fv(thread_data->program,
+                                             thread_data->location,
+                                             thread_data->count,
+                                             thread_data->transpose,
+                                             thread_data->value);
 
 }
 
@@ -30811,24 +30815,24 @@ glProgramUniformMatrix2x3fv_evgl_api_thread_cmd(GLuint program, GLint location,
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glProgramUniformMatrix2x3fv thread_param_local;
-   EVGL_API_Thread_Command_glProgramUniformMatrix2x3fv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glProgramUniformMatrix2x3fv thread_data_local;
+   EVGL_API_Thread_Command_glProgramUniformMatrix2x3fv *thread_data = &thread_data_local;
 
-   thread_param->program = program;
-   thread_param->location = location;
-   thread_param->count = count;
-   thread_param->transpose = transpose;
-   thread_param->value = value;
+   thread_data->program = program;
+   thread_data->location = location;
+   thread_data->count = count;
+   thread_data->transpose = transpose;
+   thread_data->value = value;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glProgramUniformMatrix2x3fv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glProgramUniformMatrix3x2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+ * void
+ * glProgramUniformMatrix3x2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
  */
 
 typedef struct
@@ -30846,14 +30850,14 @@ void (*orig_evgl_api_glProgramUniformMatrix3x2fv)(GLuint program, GLint location
 static void
 _evgl_api_thread_glProgramUniformMatrix3x2fv(void *data)
 {
-   EVGL_API_Thread_Command_glProgramUniformMatrix3x2fv *thread_param =
+   EVGL_API_Thread_Command_glProgramUniformMatrix3x2fv *thread_data =
       (EVGL_API_Thread_Command_glProgramUniformMatrix3x2fv *)data;
 
-   orig_evgl_api_glProgramUniformMatrix3x2fv(thread_param->program,
-                                             thread_param->location,
-                                             thread_param->count,
-                                             thread_param->transpose,
-                                             thread_param->value);
+   orig_evgl_api_glProgramUniformMatrix3x2fv(thread_data->program,
+                                             thread_data->location,
+                                             thread_data->count,
+                                             thread_data->transpose,
+                                             thread_data->value);
 
 }
 
@@ -30868,24 +30872,24 @@ glProgramUniformMatrix3x2fv_evgl_api_thread_cmd(GLuint program, GLint location,
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glProgramUniformMatrix3x2fv thread_param_local;
-   EVGL_API_Thread_Command_glProgramUniformMatrix3x2fv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glProgramUniformMatrix3x2fv thread_data_local;
+   EVGL_API_Thread_Command_glProgramUniformMatrix3x2fv *thread_data = &thread_data_local;
 
-   thread_param->program = program;
-   thread_param->location = location;
-   thread_param->count = count;
-   thread_param->transpose = transpose;
-   thread_param->value = value;
+   thread_data->program = program;
+   thread_data->location = location;
+   thread_data->count = count;
+   thread_data->transpose = transpose;
+   thread_data->value = value;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glProgramUniformMatrix3x2fv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glProgramUniformMatrix2x4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+ * void
+ * glProgramUniformMatrix2x4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
  */
 
 typedef struct
@@ -30903,14 +30907,14 @@ void (*orig_evgl_api_glProgramUniformMatrix2x4fv)(GLuint program, GLint location
 static void
 _evgl_api_thread_glProgramUniformMatrix2x4fv(void *data)
 {
-   EVGL_API_Thread_Command_glProgramUniformMatrix2x4fv *thread_param =
+   EVGL_API_Thread_Command_glProgramUniformMatrix2x4fv *thread_data =
       (EVGL_API_Thread_Command_glProgramUniformMatrix2x4fv *)data;
 
-   orig_evgl_api_glProgramUniformMatrix2x4fv(thread_param->program,
-                                             thread_param->location,
-                                             thread_param->count,
-                                             thread_param->transpose,
-                                             thread_param->value);
+   orig_evgl_api_glProgramUniformMatrix2x4fv(thread_data->program,
+                                             thread_data->location,
+                                             thread_data->count,
+                                             thread_data->transpose,
+                                             thread_data->value);
 
 }
 
@@ -30925,24 +30929,24 @@ glProgramUniformMatrix2x4fv_evgl_api_thread_cmd(GLuint program, GLint location,
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glProgramUniformMatrix2x4fv thread_param_local;
-   EVGL_API_Thread_Command_glProgramUniformMatrix2x4fv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glProgramUniformMatrix2x4fv thread_data_local;
+   EVGL_API_Thread_Command_glProgramUniformMatrix2x4fv *thread_data = &thread_data_local;
 
-   thread_param->program = program;
-   thread_param->location = location;
-   thread_param->count = count;
-   thread_param->transpose = transpose;
-   thread_param->value = value;
+   thread_data->program = program;
+   thread_data->location = location;
+   thread_data->count = count;
+   thread_data->transpose = transpose;
+   thread_data->value = value;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glProgramUniformMatrix2x4fv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glProgramUniformMatrix4x2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+ * void
+ * glProgramUniformMatrix4x2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
  */
 
 typedef struct
@@ -30960,14 +30964,14 @@ void (*orig_evgl_api_glProgramUniformMatrix4x2fv)(GLuint program, GLint location
 static void
 _evgl_api_thread_glProgramUniformMatrix4x2fv(void *data)
 {
-   EVGL_API_Thread_Command_glProgramUniformMatrix4x2fv *thread_param =
+   EVGL_API_Thread_Command_glProgramUniformMatrix4x2fv *thread_data =
       (EVGL_API_Thread_Command_glProgramUniformMatrix4x2fv *)data;
 
-   orig_evgl_api_glProgramUniformMatrix4x2fv(thread_param->program,
-                                             thread_param->location,
-                                             thread_param->count,
-                                             thread_param->transpose,
-                                             thread_param->value);
+   orig_evgl_api_glProgramUniformMatrix4x2fv(thread_data->program,
+                                             thread_data->location,
+                                             thread_data->count,
+                                             thread_data->transpose,
+                                             thread_data->value);
 
 }
 
@@ -30982,24 +30986,24 @@ glProgramUniformMatrix4x2fv_evgl_api_thread_cmd(GLuint program, GLint location,
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glProgramUniformMatrix4x2fv thread_param_local;
-   EVGL_API_Thread_Command_glProgramUniformMatrix4x2fv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glProgramUniformMatrix4x2fv thread_data_local;
+   EVGL_API_Thread_Command_glProgramUniformMatrix4x2fv *thread_data = &thread_data_local;
 
-   thread_param->program = program;
-   thread_param->location = location;
-   thread_param->count = count;
-   thread_param->transpose = transpose;
-   thread_param->value = value;
+   thread_data->program = program;
+   thread_data->location = location;
+   thread_data->count = count;
+   thread_data->transpose = transpose;
+   thread_data->value = value;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glProgramUniformMatrix4x2fv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glProgramUniformMatrix3x4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+ * void
+ * glProgramUniformMatrix3x4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
  */
 
 typedef struct
@@ -31017,14 +31021,14 @@ void (*orig_evgl_api_glProgramUniformMatrix3x4fv)(GLuint program, GLint location
 static void
 _evgl_api_thread_glProgramUniformMatrix3x4fv(void *data)
 {
-   EVGL_API_Thread_Command_glProgramUniformMatrix3x4fv *thread_param =
+   EVGL_API_Thread_Command_glProgramUniformMatrix3x4fv *thread_data =
       (EVGL_API_Thread_Command_glProgramUniformMatrix3x4fv *)data;
 
-   orig_evgl_api_glProgramUniformMatrix3x4fv(thread_param->program,
-                                             thread_param->location,
-                                             thread_param->count,
-                                             thread_param->transpose,
-                                             thread_param->value);
+   orig_evgl_api_glProgramUniformMatrix3x4fv(thread_data->program,
+                                             thread_data->location,
+                                             thread_data->count,
+                                             thread_data->transpose,
+                                             thread_data->value);
 
 }
 
@@ -31039,24 +31043,24 @@ glProgramUniformMatrix3x4fv_evgl_api_thread_cmd(GLuint program, GLint location,
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glProgramUniformMatrix3x4fv thread_param_local;
-   EVGL_API_Thread_Command_glProgramUniformMatrix3x4fv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glProgramUniformMatrix3x4fv thread_data_local;
+   EVGL_API_Thread_Command_glProgramUniformMatrix3x4fv *thread_data = &thread_data_local;
 
-   thread_param->program = program;
-   thread_param->location = location;
-   thread_param->count = count;
-   thread_param->transpose = transpose;
-   thread_param->value = value;
+   thread_data->program = program;
+   thread_data->location = location;
+   thread_data->count = count;
+   thread_data->transpose = transpose;
+   thread_data->value = value;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glProgramUniformMatrix3x4fv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glProgramUniformMatrix4x3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+ * void
+ * glProgramUniformMatrix4x3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
  */
 
 typedef struct
@@ -31074,14 +31078,14 @@ void (*orig_evgl_api_glProgramUniformMatrix4x3fv)(GLuint program, GLint location
 static void
 _evgl_api_thread_glProgramUniformMatrix4x3fv(void *data)
 {
-   EVGL_API_Thread_Command_glProgramUniformMatrix4x3fv *thread_param =
+   EVGL_API_Thread_Command_glProgramUniformMatrix4x3fv *thread_data =
       (EVGL_API_Thread_Command_glProgramUniformMatrix4x3fv *)data;
 
-   orig_evgl_api_glProgramUniformMatrix4x3fv(thread_param->program,
-                                             thread_param->location,
-                                             thread_param->count,
-                                             thread_param->transpose,
-                                             thread_param->value);
+   orig_evgl_api_glProgramUniformMatrix4x3fv(thread_data->program,
+                                             thread_data->location,
+                                             thread_data->count,
+                                             thread_data->transpose,
+                                             thread_data->value);
 
 }
 
@@ -31096,24 +31100,24 @@ glProgramUniformMatrix4x3fv_evgl_api_thread_cmd(GLuint program, GLint location,
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glProgramUniformMatrix4x3fv thread_param_local;
-   EVGL_API_Thread_Command_glProgramUniformMatrix4x3fv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glProgramUniformMatrix4x3fv thread_data_local;
+   EVGL_API_Thread_Command_glProgramUniformMatrix4x3fv *thread_data = &thread_data_local;
 
-   thread_param->program = program;
-   thread_param->location = location;
-   thread_param->count = count;
-   thread_param->transpose = transpose;
-   thread_param->value = value;
+   thread_data->program = program;
+   thread_data->location = location;
+   thread_data->count = count;
+   thread_data->transpose = transpose;
+   thread_data->value = value;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glProgramUniformMatrix4x3fv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glValidateProgramPipeline(GLuint pipeline);
+ * void
+ * glValidateProgramPipeline(GLuint pipeline);
  */
 
 typedef struct
@@ -31127,10 +31131,10 @@ void (*orig_evgl_api_glValidateProgramPipeline)(GLuint pipeline);
 static void
 _evgl_api_thread_glValidateProgramPipeline(void *data)
 {
-   EVGL_API_Thread_Command_glValidateProgramPipeline *thread_param =
+   EVGL_API_Thread_Command_glValidateProgramPipeline *thread_data =
       (EVGL_API_Thread_Command_glValidateProgramPipeline *)data;
 
-   orig_evgl_api_glValidateProgramPipeline(thread_param->pipeline);
+   orig_evgl_api_glValidateProgramPipeline(thread_data->pipeline);
 
 }
 
@@ -31145,20 +31149,20 @@ glValidateProgramPipeline_evgl_api_thread_cmd(GLuint pipeline)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glValidateProgramPipeline thread_param_local;
-   EVGL_API_Thread_Command_glValidateProgramPipeline *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glValidateProgramPipeline thread_data_local;
+   EVGL_API_Thread_Command_glValidateProgramPipeline *thread_data = &thread_data_local;
 
-   thread_param->pipeline = pipeline;
+   thread_data->pipeline = pipeline;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glValidateProgramPipeline,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGetProgramPipelineInfoLog(GLuint pipeline, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
+ * void
+ * glGetProgramPipelineInfoLog(GLuint pipeline, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
  */
 
 typedef struct
@@ -31175,13 +31179,13 @@ void (*orig_evgl_api_glGetProgramPipelineInfoLog)(GLuint pipeline, GLsizei bufSi
 static void
 _evgl_api_thread_glGetProgramPipelineInfoLog(void *data)
 {
-   EVGL_API_Thread_Command_glGetProgramPipelineInfoLog *thread_param =
+   EVGL_API_Thread_Command_glGetProgramPipelineInfoLog *thread_data =
       (EVGL_API_Thread_Command_glGetProgramPipelineInfoLog *)data;
 
-   orig_evgl_api_glGetProgramPipelineInfoLog(thread_param->pipeline,
-                                             thread_param->bufSize,
-                                             thread_param->length,
-                                             thread_param->infoLog);
+   orig_evgl_api_glGetProgramPipelineInfoLog(thread_data->pipeline,
+                                             thread_data->bufSize,
+                                             thread_data->length,
+                                             thread_data->infoLog);
 
 }
 
@@ -31196,23 +31200,23 @@ glGetProgramPipelineInfoLog_evgl_api_thread_cmd(GLuint pipeline, GLsizei bufSize
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGetProgramPipelineInfoLog thread_param_local;
-   EVGL_API_Thread_Command_glGetProgramPipelineInfoLog *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGetProgramPipelineInfoLog thread_data_local;
+   EVGL_API_Thread_Command_glGetProgramPipelineInfoLog *thread_data = &thread_data_local;
 
-   thread_param->pipeline = pipeline;
-   thread_param->bufSize = bufSize;
-   thread_param->length = length;
-   thread_param->infoLog = infoLog;
+   thread_data->pipeline = pipeline;
+   thread_data->bufSize = bufSize;
+   thread_data->length = length;
+   thread_data->infoLog = infoLog;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGetProgramPipelineInfoLog,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glBindImageTexture(GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLenum format);
+ * void
+ * glBindImageTexture(GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLenum format);
  */
 
 typedef struct
@@ -31232,16 +31236,16 @@ void (*orig_evgl_api_glBindImageTexture)(GLuint unit, GLuint texture, GLint leve
 static void
 _evgl_api_thread_glBindImageTexture(void *data)
 {
-   EVGL_API_Thread_Command_glBindImageTexture *thread_param =
+   EVGL_API_Thread_Command_glBindImageTexture *thread_data =
       (EVGL_API_Thread_Command_glBindImageTexture *)data;
 
-   orig_evgl_api_glBindImageTexture(thread_param->unit,
-                                    thread_param->texture,
-                                    thread_param->level,
-                                    thread_param->layered,
-                                    thread_param->layer,
-                                    thread_param->access,
-                                    thread_param->format);
+   orig_evgl_api_glBindImageTexture(thread_data->unit,
+                                    thread_data->texture,
+                                    thread_data->level,
+                                    thread_data->layered,
+                                    thread_data->layer,
+                                    thread_data->access,
+                                    thread_data->format);
 
 }
 
@@ -31256,26 +31260,26 @@ glBindImageTexture_evgl_api_thread_cmd(GLuint unit, GLuint texture, GLint level,
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glBindImageTexture thread_param_local;
-   EVGL_API_Thread_Command_glBindImageTexture *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glBindImageTexture thread_data_local;
+   EVGL_API_Thread_Command_glBindImageTexture *thread_data = &thread_data_local;
 
-   thread_param->unit = unit;
-   thread_param->texture = texture;
-   thread_param->level = level;
-   thread_param->layered = layered;
-   thread_param->layer = layer;
-   thread_param->access = access;
-   thread_param->format = format;
+   thread_data->unit = unit;
+   thread_data->texture = texture;
+   thread_data->level = level;
+   thread_data->layered = layered;
+   thread_data->layer = layer;
+   thread_data->access = access;
+   thread_data->format = format;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glBindImageTexture,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGetBooleani_v(GLenum target, GLuint index, GLboolean *data);
+ * void
+ * glGetBooleani_v(GLenum target, GLuint index, GLboolean *data);
  */
 
 typedef struct
@@ -31291,12 +31295,12 @@ void (*orig_evgl_api_glGetBooleani_v)(GLenum target, GLuint index, GLboolean *da
 static void
 _evgl_api_thread_glGetBooleani_v(void *data)
 {
-   EVGL_API_Thread_Command_glGetBooleani_v *thread_param =
+   EVGL_API_Thread_Command_glGetBooleani_v *thread_data =
       (EVGL_API_Thread_Command_glGetBooleani_v *)data;
 
-   orig_evgl_api_glGetBooleani_v(thread_param->target,
-                                 thread_param->index,
-                                 thread_param->data);
+   orig_evgl_api_glGetBooleani_v(thread_data->target,
+                                 thread_data->index,
+                                 thread_data->data);
 
 }
 
@@ -31311,22 +31315,22 @@ glGetBooleani_v_evgl_api_thread_cmd(GLenum target, GLuint index, GLboolean *data
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGetBooleani_v thread_param_local;
-   EVGL_API_Thread_Command_glGetBooleani_v *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGetBooleani_v thread_data_local;
+   EVGL_API_Thread_Command_glGetBooleani_v *thread_data = &thread_data_local;
 
-   thread_param->target = target;
-   thread_param->index = index;
-   thread_param->data = data;
+   thread_data->target = target;
+   thread_data->index = index;
+   thread_data->data = data;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGetBooleani_v,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glMemoryBarrier(GLbitfield barriers);
+ * void
+ * glMemoryBarrier(GLbitfield barriers);
  */
 
 typedef struct
@@ -31340,10 +31344,10 @@ void (*orig_evgl_api_glMemoryBarrier)(GLbitfield barriers);
 static void
 _evgl_api_thread_glMemoryBarrier(void *data)
 {
-   EVGL_API_Thread_Command_glMemoryBarrier *thread_param =
+   EVGL_API_Thread_Command_glMemoryBarrier *thread_data =
       (EVGL_API_Thread_Command_glMemoryBarrier *)data;
 
-   orig_evgl_api_glMemoryBarrier(thread_param->barriers);
+   orig_evgl_api_glMemoryBarrier(thread_data->barriers);
 
 }
 
@@ -31358,20 +31362,20 @@ glMemoryBarrier_evgl_api_thread_cmd(GLbitfield barriers)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glMemoryBarrier thread_param_local;
-   EVGL_API_Thread_Command_glMemoryBarrier *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glMemoryBarrier thread_data_local;
+   EVGL_API_Thread_Command_glMemoryBarrier *thread_data = &thread_data_local;
 
-   thread_param->barriers = barriers;
+   thread_data->barriers = barriers;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glMemoryBarrier,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glMemoryBarrierByRegion(GLbitfield barriers);
+ * void
+ * glMemoryBarrierByRegion(GLbitfield barriers);
  */
 
 typedef struct
@@ -31385,10 +31389,10 @@ void (*orig_evgl_api_glMemoryBarrierByRegion)(GLbitfield barriers);
 static void
 _evgl_api_thread_glMemoryBarrierByRegion(void *data)
 {
-   EVGL_API_Thread_Command_glMemoryBarrierByRegion *thread_param =
+   EVGL_API_Thread_Command_glMemoryBarrierByRegion *thread_data =
       (EVGL_API_Thread_Command_glMemoryBarrierByRegion *)data;
 
-   orig_evgl_api_glMemoryBarrierByRegion(thread_param->barriers);
+   orig_evgl_api_glMemoryBarrierByRegion(thread_data->barriers);
 
 }
 
@@ -31403,20 +31407,20 @@ glMemoryBarrierByRegion_evgl_api_thread_cmd(GLbitfield barriers)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glMemoryBarrierByRegion thread_param_local;
-   EVGL_API_Thread_Command_glMemoryBarrierByRegion *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glMemoryBarrierByRegion thread_data_local;
+   EVGL_API_Thread_Command_glMemoryBarrierByRegion *thread_data = &thread_data_local;
 
-   thread_param->barriers = barriers;
+   thread_data->barriers = barriers;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glMemoryBarrierByRegion,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glTexStorage2DMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations);
+ * void
+ * glTexStorage2DMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations);
  */
 
 typedef struct
@@ -31435,15 +31439,15 @@ void (*orig_evgl_api_glTexStorage2DMultisample)(GLenum target, GLsizei samples,
 static void
 _evgl_api_thread_glTexStorage2DMultisample(void *data)
 {
-   EVGL_API_Thread_Command_glTexStorage2DMultisample *thread_param =
+   EVGL_API_Thread_Command_glTexStorage2DMultisample *thread_data =
       (EVGL_API_Thread_Command_glTexStorage2DMultisample *)data;
 
-   orig_evgl_api_glTexStorage2DMultisample(thread_param->target,
-                                           thread_param->samples,
-                                           thread_param->internalformat,
-                                           thread_param->width,
-                                           thread_param->height,
-                                           thread_param->fixedsamplelocations);
+   orig_evgl_api_glTexStorage2DMultisample(thread_data->target,
+                                           thread_data->samples,
+                                           thread_data->internalformat,
+                                           thread_data->width,
+                                           thread_data->height,
+                                           thread_data->fixedsamplelocations);
 
 }
 
@@ -31458,25 +31462,25 @@ glTexStorage2DMultisample_evgl_api_thread_cmd(GLenum target, GLsizei samples, GL
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glTexStorage2DMultisample thread_param_local;
-   EVGL_API_Thread_Command_glTexStorage2DMultisample *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glTexStorage2DMultisample thread_data_local;
+   EVGL_API_Thread_Command_glTexStorage2DMultisample *thread_data = &thread_data_local;
 
-   thread_param->target = target;
-   thread_param->samples = samples;
-   thread_param->internalformat = internalformat;
-   thread_param->width = width;
-   thread_param->height = height;
-   thread_param->fixedsamplelocations = fixedsamplelocations;
+   thread_data->target = target;
+   thread_data->samples = samples;
+   thread_data->internalformat = internalformat;
+   thread_data->width = width;
+   thread_data->height = height;
+   thread_data->fixedsamplelocations = fixedsamplelocations;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glTexStorage2DMultisample,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGetMultisamplefv(GLenum pname, GLuint index, GLfloat *val);
+ * void
+ * glGetMultisamplefv(GLenum pname, GLuint index, GLfloat *val);
  */
 
 typedef struct
@@ -31492,12 +31496,12 @@ void (*orig_evgl_api_glGetMultisamplefv)(GLenum pname, GLuint index, GLfloat *va
 static void
 _evgl_api_thread_glGetMultisamplefv(void *data)
 {
-   EVGL_API_Thread_Command_glGetMultisamplefv *thread_param =
+   EVGL_API_Thread_Command_glGetMultisamplefv *thread_data =
       (EVGL_API_Thread_Command_glGetMultisamplefv *)data;
 
-   orig_evgl_api_glGetMultisamplefv(thread_param->pname,
-                                    thread_param->index,
-                                    thread_param->val);
+   orig_evgl_api_glGetMultisamplefv(thread_data->pname,
+                                    thread_data->index,
+                                    thread_data->val);
 
 }
 
@@ -31512,22 +31516,22 @@ glGetMultisamplefv_evgl_api_thread_cmd(GLenum pname, GLuint index, GLfloat *val)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGetMultisamplefv thread_param_local;
-   EVGL_API_Thread_Command_glGetMultisamplefv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGetMultisamplefv thread_data_local;
+   EVGL_API_Thread_Command_glGetMultisamplefv *thread_data = &thread_data_local;
 
-   thread_param->pname = pname;
-   thread_param->index = index;
-   thread_param->val = val;
+   thread_data->pname = pname;
+   thread_data->index = index;
+   thread_data->val = val;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGetMultisamplefv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glSampleMaski(GLuint maskNumber, GLbitfield mask);
+ * void
+ * glSampleMaski(GLuint maskNumber, GLbitfield mask);
  */
 
 typedef struct
@@ -31542,11 +31546,11 @@ void (*orig_evgl_api_glSampleMaski)(GLuint maskNumber, GLbitfield mask);
 static void
 _evgl_api_thread_glSampleMaski(void *data)
 {
-   EVGL_API_Thread_Command_glSampleMaski *thread_param =
+   EVGL_API_Thread_Command_glSampleMaski *thread_data =
       (EVGL_API_Thread_Command_glSampleMaski *)data;
 
-   orig_evgl_api_glSampleMaski(thread_param->maskNumber,
-                               thread_param->mask);
+   orig_evgl_api_glSampleMaski(thread_data->maskNumber,
+                               thread_data->mask);
 
 }
 
@@ -31561,21 +31565,21 @@ glSampleMaski_evgl_api_thread_cmd(GLuint maskNumber, GLbitfield mask)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glSampleMaski thread_param_local;
-   EVGL_API_Thread_Command_glSampleMaski *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glSampleMaski thread_data_local;
+   EVGL_API_Thread_Command_glSampleMaski *thread_data = &thread_data_local;
 
-   thread_param->maskNumber = maskNumber;
-   thread_param->mask = mask;
+   thread_data->maskNumber = maskNumber;
+   thread_data->mask = mask;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glSampleMaski,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params);
+ * void
+ * glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params);
  */
 
 typedef struct
@@ -31592,13 +31596,13 @@ void (*orig_evgl_api_glGetTexLevelParameteriv)(GLenum target, GLint level, GLenu
 static void
 _evgl_api_thread_glGetTexLevelParameteriv(void *data)
 {
-   EVGL_API_Thread_Command_glGetTexLevelParameteriv *thread_param =
+   EVGL_API_Thread_Command_glGetTexLevelParameteriv *thread_data =
       (EVGL_API_Thread_Command_glGetTexLevelParameteriv *)data;
 
-   orig_evgl_api_glGetTexLevelParameteriv(thread_param->target,
-                                          thread_param->level,
-                                          thread_param->pname,
-                                          thread_param->params);
+   orig_evgl_api_glGetTexLevelParameteriv(thread_data->target,
+                                          thread_data->level,
+                                          thread_data->pname,
+                                          thread_data->params);
 
 }
 
@@ -31613,23 +31617,23 @@ glGetTexLevelParameteriv_evgl_api_thread_cmd(GLenum target, GLint level, GLenum
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGetTexLevelParameteriv thread_param_local;
-   EVGL_API_Thread_Command_glGetTexLevelParameteriv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGetTexLevelParameteriv thread_data_local;
+   EVGL_API_Thread_Command_glGetTexLevelParameteriv *thread_data = &thread_data_local;
 
-   thread_param->target = target;
-   thread_param->level = level;
-   thread_param->pname = pname;
-   thread_param->params = params;
+   thread_data->target = target;
+   thread_data->level = level;
+   thread_data->pname = pname;
+   thread_data->params = params;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGetTexLevelParameteriv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params);
+ * void
+ * glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params);
  */
 
 typedef struct
@@ -31646,13 +31650,13 @@ void (*orig_evgl_api_glGetTexLevelParameterfv)(GLenum target, GLint level, GLenu
 static void
 _evgl_api_thread_glGetTexLevelParameterfv(void *data)
 {
-   EVGL_API_Thread_Command_glGetTexLevelParameterfv *thread_param =
+   EVGL_API_Thread_Command_glGetTexLevelParameterfv *thread_data =
       (EVGL_API_Thread_Command_glGetTexLevelParameterfv *)data;
 
-   orig_evgl_api_glGetTexLevelParameterfv(thread_param->target,
-                                          thread_param->level,
-                                          thread_param->pname,
-                                          thread_param->params);
+   orig_evgl_api_glGetTexLevelParameterfv(thread_data->target,
+                                          thread_data->level,
+                                          thread_data->pname,
+                                          thread_data->params);
 
 }
 
@@ -31667,23 +31671,23 @@ glGetTexLevelParameterfv_evgl_api_thread_cmd(GLenum target, GLint level, GLenum
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glGetTexLevelParameterfv thread_param_local;
-   EVGL_API_Thread_Command_glGetTexLevelParameterfv *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glGetTexLevelParameterfv thread_data_local;
+   EVGL_API_Thread_Command_glGetTexLevelParameterfv *thread_data = &thread_data_local;
 
-   thread_param->target = target;
-   thread_param->level = level;
-   thread_param->pname = pname;
-   thread_param->params = params;
+   thread_data->target = target;
+   thread_data->level = level;
+   thread_data->pname = pname;
+   thread_data->params = params;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glGetTexLevelParameterfv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glBindVertexBuffer(GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride);
+ * void
+ * glBindVertexBuffer(GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride);
  */
 
 typedef struct
@@ -31700,13 +31704,13 @@ void (*orig_evgl_api_glBindVertexBuffer)(GLuint bindingindex, GLuint buffer, GLi
 static void
 _evgl_api_thread_glBindVertexBuffer(void *data)
 {
-   EVGL_API_Thread_Command_glBindVertexBuffer *thread_param =
+   EVGL_API_Thread_Command_glBindVertexBuffer *thread_data =
       (EVGL_API_Thread_Command_glBindVertexBuffer *)data;
 
-   orig_evgl_api_glBindVertexBuffer(thread_param->bindingindex,
-                                    thread_param->buffer,
-                                    thread_param->offset,
-                                    thread_param->stride);
+   orig_evgl_api_glBindVertexBuffer(thread_data->bindingindex,
+                                    thread_data->buffer,
+                                    thread_data->offset,
+                                    thread_data->stride);
 
 }
 
@@ -31721,23 +31725,23 @@ glBindVertexBuffer_evgl_api_thread_cmd(GLuint bindingindex, GLuint buffer, GLint
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glBindVertexBuffer thread_param_local;
-   EVGL_API_Thread_Command_glBindVertexBuffer *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glBindVertexBuffer thread_data_local;
+   EVGL_API_Thread_Command_glBindVertexBuffer *thread_data = &thread_data_local;
 
-   thread_param->bindingindex = bindingindex;
-   thread_param->buffer = buffer;
-   thread_param->offset = offset;
-   thread_param->stride = stride;
+   thread_data->bindingindex = bindingindex;
+   thread_data->buffer = buffer;
+   thread_data->offset = offset;
+   thread_data->stride = stride;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glBindVertexBuffer,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glVertexAttribFormat(GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset);
+ * void
+ * glVertexAttribFormat(GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset);
  */
 
 typedef struct
@@ -31755,14 +31759,14 @@ void (*orig_evgl_api_glVertexAttribFormat)(GLuint attribindex, GLint size, GLenu
 static void
 _evgl_api_thread_glVertexAttribFormat(void *data)
 {
-   EVGL_API_Thread_Command_glVertexAttribFormat *thread_param =
+   EVGL_API_Thread_Command_glVertexAttribFormat *thread_data =
       (EVGL_API_Thread_Command_glVertexAttribFormat *)data;
 
-   orig_evgl_api_glVertexAttribFormat(thread_param->attribindex,
-                                      thread_param->size,
-                                      thread_param->type,
-                                      thread_param->normalized,
-                                      thread_param->relativeoffset);
+   orig_evgl_api_glVertexAttribFormat(thread_data->attribindex,
+                                      thread_data->size,
+                                      thread_data->type,
+                                      thread_data->normalized,
+                                      thread_data->relativeoffset);
 
 }
 
@@ -31777,24 +31781,24 @@ glVertexAttribFormat_evgl_api_thread_cmd(GLuint attribindex, GLint size, GLenum
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glVertexAttribFormat thread_param_local;
-   EVGL_API_Thread_Command_glVertexAttribFormat *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glVertexAttribFormat thread_data_local;
+   EVGL_API_Thread_Command_glVertexAttribFormat *thread_data = &thread_data_local;
 
-   thread_param->attribindex = attribindex;
-   thread_param->size = size;
-   thread_param->type = type;
-   thread_param->normalized = normalized;
-   thread_param->relativeoffset = relativeoffset;
+   thread_data->attribindex = attribindex;
+   thread_data->size = size;
+   thread_data->type = type;
+   thread_data->normalized = normalized;
+   thread_data->relativeoffset = relativeoffset;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glVertexAttribFormat,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glVertexAttribIFormat(GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset);
+ * void
+ * glVertexAttribIFormat(GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset);
  */
 
 typedef struct
@@ -31811,13 +31815,13 @@ void (*orig_evgl_api_glVertexAttribIFormat)(GLuint attribindex, GLint size, GLen
 static void
 _evgl_api_thread_glVertexAttribIFormat(void *data)
 {
-   EVGL_API_Thread_Command_glVertexAttribIFormat *thread_param =
+   EVGL_API_Thread_Command_glVertexAttribIFormat *thread_data =
       (EVGL_API_Thread_Command_glVertexAttribIFormat *)data;
 
-   orig_evgl_api_glVertexAttribIFormat(thread_param->attribindex,
-                                       thread_param->size,
-                                       thread_param->type,
-                                       thread_param->relativeoffset);
+   orig_evgl_api_glVertexAttribIFormat(thread_data->attribindex,
+                                       thread_data->size,
+                                       thread_data->type,
+                                       thread_data->relativeoffset);
 
 }
 
@@ -31832,23 +31836,23 @@ glVertexAttribIFormat_evgl_api_thread_cmd(GLuint attribindex, GLint size, GLenum
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glVertexAttribIFormat thread_param_local;
-   EVGL_API_Thread_Command_glVertexAttribIFormat *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glVertexAttribIFormat thread_data_local;
+   EVGL_API_Thread_Command_glVertexAttribIFormat *thread_data = &thread_data_local;
 
-   thread_param->attribindex = attribindex;
-   thread_param->size = size;
-   thread_param->type = type;
-   thread_param->relativeoffset = relativeoffset;
+   thread_data->attribindex = attribindex;
+   thread_data->size = size;
+   thread_data->type = type;
+   thread_data->relativeoffset = relativeoffset;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glVertexAttribIFormat,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glVertexAttribBinding(GLuint attribindex, GLuint bindingindex);
+ * void
+ * glVertexAttribBinding(GLuint attribindex, GLuint bindingindex);
  */
 
 typedef struct
@@ -31863,11 +31867,11 @@ void (*orig_evgl_api_glVertexAttribBinding)(GLuint attribindex, GLuint bindingin
 static void
 _evgl_api_thread_glVertexAttribBinding(void *data)
 {
-   EVGL_API_Thread_Command_glVertexAttribBinding *thread_param =
+   EVGL_API_Thread_Command_glVertexAttribBinding *thread_data =
       (EVGL_API_Thread_Command_glVertexAttribBinding *)data;
 
-   orig_evgl_api_glVertexAttribBinding(thread_param->attribindex,
-                                       thread_param->bindingindex);
+   orig_evgl_api_glVertexAttribBinding(thread_data->attribindex,
+                                       thread_data->bindingindex);
 
 }
 
@@ -31882,21 +31886,21 @@ glVertexAttribBinding_evgl_api_thread_cmd(GLuint attribindex, GLuint bindinginde
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glVertexAttribBinding thread_param_local;
-   EVGL_API_Thread_Command_glVertexAttribBinding *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glVertexAttribBinding thread_data_local;
+   EVGL_API_Thread_Command_glVertexAttribBinding *thread_data = &thread_data_local;
 
-   thread_param->attribindex = attribindex;
-   thread_param->bindingindex = bindingindex;
+   thread_data->attribindex = attribindex;
+   thread_data->bindingindex = bindingindex;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glVertexAttribBinding,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glVertexBindingDivisor(GLuint bindingindex, GLuint divisor);
+ * void
+ * glVertexBindingDivisor(GLuint bindingindex, GLuint divisor);
  */
 
 typedef struct
@@ -31911,11 +31915,11 @@ void (*orig_evgl_api_glVertexBindingDivisor)(GLuint bindingindex, GLuint divisor
 static void
 _evgl_api_thread_glVertexBindingDivisor(void *data)
 {
-   EVGL_API_Thread_Command_glVertexBindingDivisor *thread_param =
+   EVGL_API_Thread_Command_glVertexBindingDivisor *thread_data =
       (EVGL_API_Thread_Command_glVertexBindingDivisor *)data;
 
-   orig_evgl_api_glVertexBindingDivisor(thread_param->bindingindex,
-                                        thread_param->divisor);
+   orig_evgl_api_glVertexBindingDivisor(thread_data->bindingindex,
+                                        thread_data->divisor);
 
 }
 
@@ -31930,21 +31934,21 @@ glVertexBindingDivisor_evgl_api_thread_cmd(GLuint bindingindex, GLuint divisor)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glVertexBindingDivisor thread_param_local;
-   EVGL_API_Thread_Command_glVertexBindingDivisor *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glVertexBindingDivisor thread_data_local;
+   EVGL_API_Thread_Command_glVertexBindingDivisor *thread_data = &thread_data_local;
 
-   thread_param->bindingindex = bindingindex;
-   thread_param->divisor = divisor;
+   thread_data->bindingindex = bindingindex;
+   thread_data->divisor = divisor;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glVertexBindingDivisor,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glEGLImageTargetTexture2DOES(GLenum target, void *image);
+ * void
+ * glEGLImageTargetTexture2DOES(GLenum target, void *image);
  */
 
 typedef struct
@@ -31959,11 +31963,11 @@ void (*orig_evgl_api_glEGLImageTargetTexture2DOES)(GLenum target, void *image);
 static void
 _evgl_api_thread_glEGLImageTargetTexture2DOES(void *data)
 {
-   EVGL_API_Thread_Command_glEGLImageTargetTexture2DOES *thread_param =
+   EVGL_API_Thread_Command_glEGLImageTargetTexture2DOES *thread_data =
       (EVGL_API_Thread_Command_glEGLImageTargetTexture2DOES *)data;
 
-   orig_evgl_api_glEGLImageTargetTexture2DOES(thread_param->target,
-                                              thread_param->image);
+   orig_evgl_api_glEGLImageTargetTexture2DOES(thread_data->target,
+                                              thread_data->image);
 
 }
 
@@ -31978,21 +31982,21 @@ glEGLImageTargetTexture2DOES_evgl_api_thread_cmd(GLenum target, void *image)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glEGLImageTargetTexture2DOES thread_param_local;
-   EVGL_API_Thread_Command_glEGLImageTargetTexture2DOES *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glEGLImageTargetTexture2DOES thread_data_local;
+   EVGL_API_Thread_Command_glEGLImageTargetTexture2DOES *thread_data = &thread_data_local;
 
-   thread_param->target = target;
-   thread_param->image = image;
+   thread_data->target = target;
+   thread_data->image = image;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glEGLImageTargetTexture2DOES,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glEGLImageTargetRenderbufferStorageOES(GLenum target, void *image);
+ * void
+ * glEGLImageTargetRenderbufferStorageOES(GLenum target, void *image);
  */
 
 typedef struct
@@ -32008,14 +32012,14 @@ void (*orig_evgl_api_glEGLImageTargetRenderbufferStorageOES)(GLenum target, void
 static void
 _evgl_api_thread_glEGLImageTargetRenderbufferStorageOES(void *data)
 {
-   EVGL_API_Thread_Command_glEGLImageTargetRenderbufferStorageOES *thread_param =
+   EVGL_API_Thread_Command_glEGLImageTargetRenderbufferStorageOES *thread_data =
       (EVGL_API_Thread_Command_glEGLImageTargetRenderbufferStorageOES *)data;
 
-   orig_evgl_api_glEGLImageTargetRenderbufferStorageOES(thread_param->target,
-                                                        thread_param->image);
+   orig_evgl_api_glEGLImageTargetRenderbufferStorageOES(thread_data->target,
+                                                        thread_data->image);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -32029,37 +32033,37 @@ glEGLImageTargetRenderbufferStorageOES_evgl_api_thread_cmd(GLenum target, void *
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command_glEGLImageTargetRenderbufferStorageOES thread_param_local;
-   EVGL_API_Thread_Command_glEGLImageTargetRenderbufferStorageOES *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command_glEGLImageTargetRenderbufferStorageOES thread_data_local;
+   EVGL_API_Thread_Command_glEGLImageTargetRenderbufferStorageOES *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_API_Thread_Command_glEGLImageTargetRenderbufferStorageOES *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_API_Thread_Command_glEGLImageTargetRenderbufferStorageOES));
-        if (thread_param_new)
+        EVGL_API_Thread_Command_glEGLImageTargetRenderbufferStorageOES *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_API_Thread_Command_glEGLImageTargetRenderbufferStorageOES));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->target = target;
-   thread_param->image = image;
+   thread_data->target = target;
+   thread_data->image = image;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread_glEGLImageTargetRenderbufferStorageOES,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   _evgl_glDiscardFramebufferEXT(GLenum target, GLsizei numAttachments, const GLenum* attachments);
+ * void
+ * _evgl_glDiscardFramebufferEXT(GLenum target, GLsizei numAttachments, const GLenum* attachments);
  */
 
 typedef struct
@@ -32075,12 +32079,12 @@ void (*orig_evgl_api__evgl_glDiscardFramebufferEXT)(GLenum target, GLsizei numAt
 static void
 _evgl_api_thread__evgl_glDiscardFramebufferEXT(void *data)
 {
-   EVGL_API_Thread_Command__evgl_glDiscardFramebufferEXT *thread_param =
+   EVGL_API_Thread_Command__evgl_glDiscardFramebufferEXT *thread_data =
       (EVGL_API_Thread_Command__evgl_glDiscardFramebufferEXT *)data;
 
-   orig_evgl_api__evgl_glDiscardFramebufferEXT(thread_param->target,
-                                               thread_param->numAttachments,
-                                               thread_param->attachments);
+   orig_evgl_api__evgl_glDiscardFramebufferEXT(thread_data->target,
+                                               thread_data->numAttachments,
+                                               thread_data->attachments);
 
 }
 
@@ -32095,22 +32099,22 @@ _evgl_glDiscardFramebufferEXT_evgl_api_thread_cmd(GLenum target, GLsizei numAtta
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command__evgl_glDiscardFramebufferEXT thread_param_local;
-   EVGL_API_Thread_Command__evgl_glDiscardFramebufferEXT *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command__evgl_glDiscardFramebufferEXT thread_data_local;
+   EVGL_API_Thread_Command__evgl_glDiscardFramebufferEXT *thread_data = &thread_data_local;
 
-   thread_param->target = target;
-   thread_param->numAttachments = numAttachments;
-   thread_param->attachments = attachments;
+   thread_data->target = target;
+   thread_data->numAttachments = numAttachments;
+   thread_data->attachments = attachments;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread__evgl_glDiscardFramebufferEXT,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   _evgl_glEvasGLImageTargetTexture2D(GLenum target, EvasGLImage image);
+ * void
+ * _evgl_glEvasGLImageTargetTexture2D(GLenum target, EvasGLImage image);
  */
 
 typedef struct
@@ -32125,11 +32129,11 @@ void (*orig_evgl_api__evgl_glEvasGLImageTargetTexture2D)(GLenum target, EvasGLIm
 static void
 _evgl_api_thread__evgl_glEvasGLImageTargetTexture2D(void *data)
 {
-   EVGL_API_Thread_Command__evgl_glEvasGLImageTargetTexture2D *thread_param =
+   EVGL_API_Thread_Command__evgl_glEvasGLImageTargetTexture2D *thread_data =
       (EVGL_API_Thread_Command__evgl_glEvasGLImageTargetTexture2D *)data;
 
-   orig_evgl_api__evgl_glEvasGLImageTargetTexture2D(thread_param->target,
-                                                    thread_param->image);
+   orig_evgl_api__evgl_glEvasGLImageTargetTexture2D(thread_data->target,
+                                                    thread_data->image);
 
 }
 
@@ -32144,21 +32148,21 @@ _evgl_glEvasGLImageTargetTexture2D_evgl_api_thread_cmd(GLenum target, EvasGLImag
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command__evgl_glEvasGLImageTargetTexture2D thread_param_local;
-   EVGL_API_Thread_Command__evgl_glEvasGLImageTargetTexture2D *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command__evgl_glEvasGLImageTargetTexture2D thread_data_local;
+   EVGL_API_Thread_Command__evgl_glEvasGLImageTargetTexture2D *thread_data = &thread_data_local;
 
-   thread_param->target = target;
-   thread_param->image = image;
+   thread_data->target = target;
+   thread_data->image = image;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread__evgl_glEvasGLImageTargetTexture2D,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   _evgl_glEvasGLImageTargetRenderbufferStorage(GLenum target, EvasGLImage image);
+ * void
+ * _evgl_glEvasGLImageTargetRenderbufferStorage(GLenum target, EvasGLImage image);
  */
 
 typedef struct
@@ -32173,11 +32177,11 @@ void (*orig_evgl_api__evgl_glEvasGLImageTargetRenderbufferStorage)(GLenum target
 static void
 _evgl_api_thread__evgl_glEvasGLImageTargetRenderbufferStorage(void *data)
 {
-   EVGL_API_Thread_Command__evgl_glEvasGLImageTargetRenderbufferStorage *thread_param =
+   EVGL_API_Thread_Command__evgl_glEvasGLImageTargetRenderbufferStorage *thread_data =
       (EVGL_API_Thread_Command__evgl_glEvasGLImageTargetRenderbufferStorage *)data;
 
-   orig_evgl_api__evgl_glEvasGLImageTargetRenderbufferStorage(thread_param->target,
-                                                              thread_param->image);
+   orig_evgl_api__evgl_glEvasGLImageTargetRenderbufferStorage(thread_data->target,
+                                                              thread_data->image);
 
 }
 
@@ -32192,21 +32196,21 @@ _evgl_glEvasGLImageTargetRenderbufferStorage_evgl_api_thread_cmd(GLenum target,
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command__evgl_glEvasGLImageTargetRenderbufferStorage thread_param_local;
-   EVGL_API_Thread_Command__evgl_glEvasGLImageTargetRenderbufferStorage *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command__evgl_glEvasGLImageTargetRenderbufferStorage thread_data_local;
+   EVGL_API_Thread_Command__evgl_glEvasGLImageTargetRenderbufferStorage *thread_data = &thread_data_local;
 
-   thread_param->target = target;
-   thread_param->image = image;
+   thread_data->target = target;
+   thread_data->image = image;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread__evgl_glEvasGLImageTargetRenderbufferStorage,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   EvasGLImage
-   _evgl_evasglCreateImage(int target, void* buffer, const int *attrib_list);
+ * EvasGLImage
+ * _evgl_evasglCreateImage(int target, void* buffer, const int *attrib_list);
  */
 
 typedef struct
@@ -32223,12 +32227,12 @@ EvasGLImage (*orig_evgl_api__evgl_evasglCreateImage)(int target, void* buffer, c
 static void
 _evgl_api_thread__evgl_evasglCreateImage(void *data)
 {
-   EVGL_API_Thread_Command__evgl_evasglCreateImage *thread_param =
+   EVGL_API_Thread_Command__evgl_evasglCreateImage *thread_data =
       (EVGL_API_Thread_Command__evgl_evasglCreateImage *)data;
 
-   thread_param->return_value = orig_evgl_api__evgl_evasglCreateImage(thread_param->target,
-                                                                      thread_param->buffer,
-                                                                      thread_param->attrib_list);
+   thread_data->return_value = orig_evgl_api__evgl_evasglCreateImage(thread_data->target,
+                                                                     thread_data->buffer,
+                                                                     thread_data->attrib_list);
 
 }
 
@@ -32242,24 +32246,24 @@ _evgl_evasglCreateImage_evgl_api_thread_cmd(int target, void* buffer, const int
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command__evgl_evasglCreateImage thread_param_local;
-   EVGL_API_Thread_Command__evgl_evasglCreateImage *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command__evgl_evasglCreateImage thread_data_local;
+   EVGL_API_Thread_Command__evgl_evasglCreateImage *thread_data = &thread_data_local;
 
-   thread_param->target = target;
-   thread_param->buffer = buffer;
-   thread_param->attrib_list = attrib_list;
+   thread_data->target = target;
+   thread_data->buffer = buffer;
+   thread_data->attrib_list = attrib_list;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread__evgl_evasglCreateImage,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
-   void
-   _evgl_evasglDestroyImage(EvasGLImage image);
+ * void
+ * _evgl_evasglDestroyImage(EvasGLImage image);
  */
 
 typedef struct
@@ -32273,10 +32277,10 @@ void (*orig_evgl_api__evgl_evasglDestroyImage)(EvasGLImage image);
 static void
 _evgl_api_thread__evgl_evasglDestroyImage(void *data)
 {
-   EVGL_API_Thread_Command__evgl_evasglDestroyImage *thread_param =
+   EVGL_API_Thread_Command__evgl_evasglDestroyImage *thread_data =
       (EVGL_API_Thread_Command__evgl_evasglDestroyImage *)data;
 
-   orig_evgl_api__evgl_evasglDestroyImage(thread_param->image);
+   orig_evgl_api__evgl_evasglDestroyImage(thread_data->image);
 
 }
 
@@ -32291,20 +32295,20 @@ _evgl_evasglDestroyImage_evgl_api_thread_cmd(EvasGLImage image)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command__evgl_evasglDestroyImage thread_param_local;
-   EVGL_API_Thread_Command__evgl_evasglDestroyImage *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command__evgl_evasglDestroyImage thread_data_local;
+   EVGL_API_Thread_Command__evgl_evasglDestroyImage *thread_data = &thread_data_local;
 
-   thread_param->image = image;
+   thread_data->image = image;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread__evgl_evasglDestroyImage,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   EvasGLImage
-   _evgl_evasglCreateImageForContext(Evas_GL *evas_gl, Evas_GL_Context *ctx, int target, void* buffer, const int *attrib_list);
+ * EvasGLImage
+ * _evgl_evasglCreateImageForContext(Evas_GL *evas_gl, Evas_GL_Context *ctx, int target, void* buffer, const int *attrib_list);
  */
 
 typedef struct
@@ -32323,14 +32327,14 @@ EvasGLImage (*orig_evgl_api__evgl_evasglCreateImageForContext)(Evas_GL *evas_gl,
 static void
 _evgl_api_thread__evgl_evasglCreateImageForContext(void *data)
 {
-   EVGL_API_Thread_Command__evgl_evasglCreateImageForContext *thread_param =
+   EVGL_API_Thread_Command__evgl_evasglCreateImageForContext *thread_data =
       (EVGL_API_Thread_Command__evgl_evasglCreateImageForContext *)data;
 
-   thread_param->return_value = orig_evgl_api__evgl_evasglCreateImageForContext(thread_param->evas_gl,
-                                                                                thread_param->ctx,
-                                                                                thread_param->target,
-                                                                                thread_param->buffer,
-                                                                                thread_param->attrib_list);
+   thread_data->return_value = orig_evgl_api__evgl_evasglCreateImageForContext(thread_data->evas_gl,
+                                                                               thread_data->ctx,
+                                                                               thread_data->target,
+                                                                               thread_data->buffer,
+                                                                               thread_data->attrib_list);
 
 }
 
@@ -32344,26 +32348,26 @@ _evgl_evasglCreateImageForContext_evgl_api_thread_cmd(Evas_GL *evas_gl, Evas_GL_
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command__evgl_evasglCreateImageForContext thread_param_local;
-   EVGL_API_Thread_Command__evgl_evasglCreateImageForContext *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command__evgl_evasglCreateImageForContext thread_data_local;
+   EVGL_API_Thread_Command__evgl_evasglCreateImageForContext *thread_data = &thread_data_local;
 
-   thread_param->evas_gl = evas_gl;
-   thread_param->ctx = ctx;
-   thread_param->target = target;
-   thread_param->buffer = buffer;
-   thread_param->attrib_list = attrib_list;
+   thread_data->evas_gl = evas_gl;
+   thread_data->ctx = ctx;
+   thread_data->target = target;
+   thread_data->buffer = buffer;
+   thread_data->attrib_list = attrib_list;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread__evgl_evasglCreateImageForContext,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
-   EvasGLSync
-   _evgl_evasglCreateSync(Evas_GL *evas_gl, unsigned int type, const int *attrib_list);
+ * EvasGLSync
+ * _evgl_evasglCreateSync(Evas_GL *evas_gl, unsigned int type, const int *attrib_list);
  */
 
 typedef struct
@@ -32380,12 +32384,12 @@ EvasGLSync (*orig_evgl_api__evgl_evasglCreateSync)(Evas_GL *evas_gl, unsigned in
 static void
 _evgl_api_thread__evgl_evasglCreateSync(void *data)
 {
-   EVGL_API_Thread_Command__evgl_evasglCreateSync *thread_param =
+   EVGL_API_Thread_Command__evgl_evasglCreateSync *thread_data =
       (EVGL_API_Thread_Command__evgl_evasglCreateSync *)data;
 
-   thread_param->return_value = orig_evgl_api__evgl_evasglCreateSync(thread_param->evas_gl,
-                                                                     thread_param->type,
-                                                                     thread_param->attrib_list);
+   thread_data->return_value = orig_evgl_api__evgl_evasglCreateSync(thread_data->evas_gl,
+                                                                    thread_data->type,
+                                                                    thread_data->attrib_list);
 
 }
 
@@ -32399,24 +32403,24 @@ _evgl_evasglCreateSync_evgl_api_thread_cmd(Evas_GL *evas_gl, unsigned int type,
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command__evgl_evasglCreateSync thread_param_local;
-   EVGL_API_Thread_Command__evgl_evasglCreateSync *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command__evgl_evasglCreateSync thread_data_local;
+   EVGL_API_Thread_Command__evgl_evasglCreateSync *thread_data = &thread_data_local;
 
-   thread_param->evas_gl = evas_gl;
-   thread_param->type = type;
-   thread_param->attrib_list = attrib_list;
+   thread_data->evas_gl = evas_gl;
+   thread_data->type = type;
+   thread_data->attrib_list = attrib_list;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread__evgl_evasglCreateSync,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
-   Eina_Bool
-   _evgl_evasglDestroySync(Evas_GL *evas_gl, EvasGLSync sync);
+ * Eina_Bool
+ * _evgl_evasglDestroySync(Evas_GL *evas_gl, EvasGLSync sync);
  */
 
 typedef struct
@@ -32432,11 +32436,11 @@ Eina_Bool (*orig_evgl_api__evgl_evasglDestroySync)(Evas_GL *evas_gl, EvasGLSync
 static void
 _evgl_api_thread__evgl_evasglDestroySync(void *data)
 {
-   EVGL_API_Thread_Command__evgl_evasglDestroySync *thread_param =
+   EVGL_API_Thread_Command__evgl_evasglDestroySync *thread_data =
       (EVGL_API_Thread_Command__evgl_evasglDestroySync *)data;
 
-   thread_param->return_value = orig_evgl_api__evgl_evasglDestroySync(thread_param->evas_gl,
-                                                                      thread_param->sync);
+   thread_data->return_value = orig_evgl_api__evgl_evasglDestroySync(thread_data->evas_gl,
+                                                                     thread_data->sync);
 
 }
 
@@ -32450,23 +32454,23 @@ _evgl_evasglDestroySync_evgl_api_thread_cmd(Evas_GL *evas_gl, EvasGLSync sync)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command__evgl_evasglDestroySync thread_param_local;
-   EVGL_API_Thread_Command__evgl_evasglDestroySync *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command__evgl_evasglDestroySync thread_data_local;
+   EVGL_API_Thread_Command__evgl_evasglDestroySync *thread_data = &thread_data_local;
 
-   thread_param->evas_gl = evas_gl;
-   thread_param->sync = sync;
+   thread_data->evas_gl = evas_gl;
+   thread_data->sync = sync;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread__evgl_evasglDestroySync,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
-   int
-   _evgl_evasglClientWaitSync(Evas_GL *evas_gl, EvasGLSync sync);
+ * int
+ * _evgl_evasglClientWaitSync(Evas_GL *evas_gl, EvasGLSync sync);
  */
 
 typedef struct
@@ -32482,11 +32486,11 @@ int (*orig_evgl_api__evgl_evasglClientWaitSync)(Evas_GL *evas_gl, EvasGLSync syn
 static void
 _evgl_api_thread__evgl_evasglClientWaitSync(void *data)
 {
-   EVGL_API_Thread_Command__evgl_evasglClientWaitSync *thread_param =
+   EVGL_API_Thread_Command__evgl_evasglClientWaitSync *thread_data =
       (EVGL_API_Thread_Command__evgl_evasglClientWaitSync *)data;
 
-   thread_param->return_value = orig_evgl_api__evgl_evasglClientWaitSync(thread_param->evas_gl,
-                                                                         thread_param->sync);
+   thread_data->return_value = orig_evgl_api__evgl_evasglClientWaitSync(thread_data->evas_gl,
+                                                                        thread_data->sync);
 
 }
 
@@ -32500,23 +32504,23 @@ _evgl_evasglClientWaitSync_evgl_api_thread_cmd(Evas_GL *evas_gl, EvasGLSync sync
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command__evgl_evasglClientWaitSync thread_param_local;
-   EVGL_API_Thread_Command__evgl_evasglClientWaitSync *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command__evgl_evasglClientWaitSync thread_data_local;
+   EVGL_API_Thread_Command__evgl_evasglClientWaitSync *thread_data = &thread_data_local;
 
-   thread_param->evas_gl = evas_gl;
-   thread_param->sync = sync;
+   thread_data->evas_gl = evas_gl;
+   thread_data->sync = sync;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread__evgl_evasglClientWaitSync,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
-   Eina_Bool
-   _evgl_evasglGetSyncAttrib(Evas_GL *evas_gl, EvasGLSync sync, int attribute, int *value);
+ * Eina_Bool
+ * _evgl_evasglGetSyncAttrib(Evas_GL *evas_gl, EvasGLSync sync, int attribute, int *value);
  */
 
 typedef struct
@@ -32534,13 +32538,13 @@ Eina_Bool (*orig_evgl_api__evgl_evasglGetSyncAttrib)(Evas_GL *evas_gl, EvasGLSyn
 static void
 _evgl_api_thread__evgl_evasglGetSyncAttrib(void *data)
 {
-   EVGL_API_Thread_Command__evgl_evasglGetSyncAttrib *thread_param =
+   EVGL_API_Thread_Command__evgl_evasglGetSyncAttrib *thread_data =
       (EVGL_API_Thread_Command__evgl_evasglGetSyncAttrib *)data;
 
-   thread_param->return_value = orig_evgl_api__evgl_evasglGetSyncAttrib(thread_param->evas_gl,
-                                                                        thread_param->sync,
-                                                                        thread_param->attribute,
-                                                                        thread_param->value);
+   thread_data->return_value = orig_evgl_api__evgl_evasglGetSyncAttrib(thread_data->evas_gl,
+                                                                       thread_data->sync,
+                                                                       thread_data->attribute,
+                                                                       thread_data->value);
 
 }
 
@@ -32554,25 +32558,25 @@ _evgl_evasglGetSyncAttrib_evgl_api_thread_cmd(Evas_GL *evas_gl, EvasGLSync sync,
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command__evgl_evasglGetSyncAttrib thread_param_local;
-   EVGL_API_Thread_Command__evgl_evasglGetSyncAttrib *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command__evgl_evasglGetSyncAttrib thread_data_local;
+   EVGL_API_Thread_Command__evgl_evasglGetSyncAttrib *thread_data = &thread_data_local;
 
-   thread_param->evas_gl = evas_gl;
-   thread_param->sync = sync;
-   thread_param->attribute = attribute;
-   thread_param->value = value;
+   thread_data->evas_gl = evas_gl;
+   thread_data->sync = sync;
+   thread_data->attribute = attribute;
+   thread_data->value = value;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread__evgl_evasglGetSyncAttrib,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
-   Eina_Bool
-   _evgl_evasglSignalSync(Evas_GL *evas_gl, EvasGLSync sync, unsigned mode);
+ * Eina_Bool
+ * _evgl_evasglSignalSync(Evas_GL *evas_gl, EvasGLSync sync, unsigned mode);
  */
 
 typedef struct
@@ -32589,12 +32593,12 @@ Eina_Bool (*orig_evgl_api__evgl_evasglSignalSync)(Evas_GL *evas_gl, EvasGLSync s
 static void
 _evgl_api_thread__evgl_evasglSignalSync(void *data)
 {
-   EVGL_API_Thread_Command__evgl_evasglSignalSync *thread_param =
+   EVGL_API_Thread_Command__evgl_evasglSignalSync *thread_data =
       (EVGL_API_Thread_Command__evgl_evasglSignalSync *)data;
 
-   thread_param->return_value = orig_evgl_api__evgl_evasglSignalSync(thread_param->evas_gl,
-                                                                     thread_param->sync,
-                                                                     thread_param->mode);
+   thread_data->return_value = orig_evgl_api__evgl_evasglSignalSync(thread_data->evas_gl,
+                                                                    thread_data->sync,
+                                                                    thread_data->mode);
 
 }
 
@@ -32608,24 +32612,24 @@ _evgl_evasglSignalSync_evgl_api_thread_cmd(Evas_GL *evas_gl, EvasGLSync sync, un
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command__evgl_evasglSignalSync thread_param_local;
-   EVGL_API_Thread_Command__evgl_evasglSignalSync *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command__evgl_evasglSignalSync thread_data_local;
+   EVGL_API_Thread_Command__evgl_evasglSignalSync *thread_data = &thread_data_local;
 
-   thread_param->evas_gl = evas_gl;
-   thread_param->sync = sync;
-   thread_param->mode = mode;
+   thread_data->evas_gl = evas_gl;
+   thread_data->sync = sync;
+   thread_data->mode = mode;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread__evgl_evasglSignalSync,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
-   int
-   _evgl_evasglWaitSync(Evas_GL *evas_gl, EvasGLSync sync, int flags);
+ * int
+ * _evgl_evasglWaitSync(Evas_GL *evas_gl, EvasGLSync sync, int flags);
  */
 
 typedef struct
@@ -32642,12 +32646,12 @@ int (*orig_evgl_api__evgl_evasglWaitSync)(Evas_GL *evas_gl, EvasGLSync sync, int
 static void
 _evgl_api_thread__evgl_evasglWaitSync(void *data)
 {
-   EVGL_API_Thread_Command__evgl_evasglWaitSync *thread_param =
+   EVGL_API_Thread_Command__evgl_evasglWaitSync *thread_data =
       (EVGL_API_Thread_Command__evgl_evasglWaitSync *)data;
 
-   thread_param->return_value = orig_evgl_api__evgl_evasglWaitSync(thread_param->evas_gl,
-                                                                   thread_param->sync,
-                                                                   thread_param->flags);
+   thread_data->return_value = orig_evgl_api__evgl_evasglWaitSync(thread_data->evas_gl,
+                                                                  thread_data->sync,
+                                                                  thread_data->flags);
 
 }
 
@@ -32661,24 +32665,24 @@ _evgl_evasglWaitSync_evgl_api_thread_cmd(Evas_GL *evas_gl, EvasGLSync sync, int
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command__evgl_evasglWaitSync thread_param_local;
-   EVGL_API_Thread_Command__evgl_evasglWaitSync *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command__evgl_evasglWaitSync thread_data_local;
+   EVGL_API_Thread_Command__evgl_evasglWaitSync *thread_data = &thread_data_local;
 
-   thread_param->evas_gl = evas_gl;
-   thread_param->sync = sync;
-   thread_param->flags = flags;
+   thread_data->evas_gl = evas_gl;
+   thread_data->sync = sync;
+   thread_data->flags = flags;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread__evgl_evasglWaitSync,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
-   Eina_Bool
-   _evgl_evasglBindWaylandDisplay(Evas_GL *evas_gl, void *wl_display);
+ * Eina_Bool
+ * _evgl_evasglBindWaylandDisplay(Evas_GL *evas_gl, void *wl_display);
  */
 
 typedef struct
@@ -32694,11 +32698,11 @@ Eina_Bool (*orig_evgl_api__evgl_evasglBindWaylandDisplay)(Evas_GL *evas_gl, void
 static void
 _evgl_api_thread__evgl_evasglBindWaylandDisplay(void *data)
 {
-   EVGL_API_Thread_Command__evgl_evasglBindWaylandDisplay *thread_param =
+   EVGL_API_Thread_Command__evgl_evasglBindWaylandDisplay *thread_data =
       (EVGL_API_Thread_Command__evgl_evasglBindWaylandDisplay *)data;
 
-   thread_param->return_value = orig_evgl_api__evgl_evasglBindWaylandDisplay(thread_param->evas_gl,
-                                                                             thread_param->wl_display);
+   thread_data->return_value = orig_evgl_api__evgl_evasglBindWaylandDisplay(thread_data->evas_gl,
+                                                                            thread_data->wl_display);
 
 }
 
@@ -32712,23 +32716,23 @@ _evgl_evasglBindWaylandDisplay_evgl_api_thread_cmd(Evas_GL *evas_gl, void *wl_di
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command__evgl_evasglBindWaylandDisplay thread_param_local;
-   EVGL_API_Thread_Command__evgl_evasglBindWaylandDisplay *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command__evgl_evasglBindWaylandDisplay thread_data_local;
+   EVGL_API_Thread_Command__evgl_evasglBindWaylandDisplay *thread_data = &thread_data_local;
 
-   thread_param->evas_gl = evas_gl;
-   thread_param->wl_display = wl_display;
+   thread_data->evas_gl = evas_gl;
+   thread_data->wl_display = wl_display;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread__evgl_evasglBindWaylandDisplay,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
-   Eina_Bool
-   _evgl_evasglUnbindWaylandDisplay(Evas_GL *evas_gl, void *wl_display);
+ * Eina_Bool
+ * _evgl_evasglUnbindWaylandDisplay(Evas_GL *evas_gl, void *wl_display);
  */
 
 typedef struct
@@ -32744,11 +32748,11 @@ Eina_Bool (*orig_evgl_api__evgl_evasglUnbindWaylandDisplay)(Evas_GL *evas_gl, vo
 static void
 _evgl_api_thread__evgl_evasglUnbindWaylandDisplay(void *data)
 {
-   EVGL_API_Thread_Command__evgl_evasglUnbindWaylandDisplay *thread_param =
+   EVGL_API_Thread_Command__evgl_evasglUnbindWaylandDisplay *thread_data =
       (EVGL_API_Thread_Command__evgl_evasglUnbindWaylandDisplay *)data;
 
-   thread_param->return_value = orig_evgl_api__evgl_evasglUnbindWaylandDisplay(thread_param->evas_gl,
-                                                                               thread_param->wl_display);
+   thread_data->return_value = orig_evgl_api__evgl_evasglUnbindWaylandDisplay(thread_data->evas_gl,
+                                                                              thread_data->wl_display);
 
 }
 
@@ -32762,23 +32766,23 @@ _evgl_evasglUnbindWaylandDisplay_evgl_api_thread_cmd(Evas_GL *evas_gl, void *wl_
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command__evgl_evasglUnbindWaylandDisplay thread_param_local;
-   EVGL_API_Thread_Command__evgl_evasglUnbindWaylandDisplay *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command__evgl_evasglUnbindWaylandDisplay thread_data_local;
+   EVGL_API_Thread_Command__evgl_evasglUnbindWaylandDisplay *thread_data = &thread_data_local;
 
-   thread_param->evas_gl = evas_gl;
-   thread_param->wl_display = wl_display;
+   thread_data->evas_gl = evas_gl;
+   thread_data->wl_display = wl_display;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread__evgl_evasglUnbindWaylandDisplay,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
-   Eina_Bool
-   _evgl_evasglQueryWaylandBuffer(Evas_GL *evas_gl, void *buffer, int attribute, int *value);
+ * Eina_Bool
+ * _evgl_evasglQueryWaylandBuffer(Evas_GL *evas_gl, void *buffer, int attribute, int *value);
  */
 
 typedef struct
@@ -32796,13 +32800,13 @@ Eina_Bool (*orig_evgl_api__evgl_evasglQueryWaylandBuffer)(Evas_GL *evas_gl, void
 static void
 _evgl_api_thread__evgl_evasglQueryWaylandBuffer(void *data)
 {
-   EVGL_API_Thread_Command__evgl_evasglQueryWaylandBuffer *thread_param =
+   EVGL_API_Thread_Command__evgl_evasglQueryWaylandBuffer *thread_data =
       (EVGL_API_Thread_Command__evgl_evasglQueryWaylandBuffer *)data;
 
-   thread_param->return_value = orig_evgl_api__evgl_evasglQueryWaylandBuffer(thread_param->evas_gl,
-                                                                             thread_param->buffer,
-                                                                             thread_param->attribute,
-                                                                             thread_param->value);
+   thread_data->return_value = orig_evgl_api__evgl_evasglQueryWaylandBuffer(thread_data->evas_gl,
+                                                                            thread_data->buffer,
+                                                                            thread_data->attribute,
+                                                                            thread_data->value);
 
 }
 
@@ -32816,18 +32820,18 @@ _evgl_evasglQueryWaylandBuffer_evgl_api_thread_cmd(Evas_GL *evas_gl, void *buffe
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_API_Thread_Command__evgl_evasglQueryWaylandBuffer thread_param_local;
-   EVGL_API_Thread_Command__evgl_evasglQueryWaylandBuffer *thread_param = &thread_param_local;
+   EVGL_API_Thread_Command__evgl_evasglQueryWaylandBuffer thread_data_local;
+   EVGL_API_Thread_Command__evgl_evasglQueryWaylandBuffer *thread_data = &thread_data_local;
 
-   thread_param->evas_gl = evas_gl;
-   thread_param->buffer = buffer;
-   thread_param->attribute = attribute;
-   thread_param->value = value;
+   thread_data->evas_gl = evas_gl;
+   thread_data->buffer = buffer;
+   thread_data->attribute = attribute;
+   thread_data->value = value;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_api_thread__evgl_evasglQueryWaylandBuffer,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }

diff --git a/src/modules/evas/engines/gl_common/evas_gl_thread_evgl_api_generated.h b/src/modules/evas/engines/gl_common/evas_gl_thread_evgl_api_generated.h
index 85e3377..fc7b15f 100644 (file)
--- a/src/modules/evas/engines/gl_common/evas_gl_thread_evgl_api_generated.h
+++ b/src/modules/evas/engines/gl_common/evas_gl_thread_evgl_api_generated.h
@@ -1,5 +1,9 @@
-/* DO NOT MODIFY THIS FILE AS IT IS AUTO-GENERATED */
-
+/*
+ * This is an automatically generated file using a python script.
+ * ($EFL_HOME/src/utils/evas/generate_gl_thread_api.py)
+ * Recommend that you modify data files ($EFL_HOME/src/utils/evas/gl_api_def.txt)
+ * and make use of scripts if you need to fix them.
+ */
 
 #define EVAS_GL_NO_GL_H_CHECK 1
 #include "Evas_GL.h"

diff --git a/src/modules/evas/engines/gl_common/evas_gl_thread_evgl_generated.c b/src/modules/evas/engines/gl_common/evas_gl_thread_evgl_generated.c
index 9274763..16b267f 100644 (file)
--- a/src/modules/evas/engines/gl_common/evas_gl_thread_evgl_generated.c
+++ b/src/modules/evas/engines/gl_common/evas_gl_thread_evgl_generated.c
@@ -1,9 +1,13 @@
-/* DO NOT MODIFY THIS FILE AS IT IS AUTO-GENERATED */
-
+/*
+ * This is an automatically generated file using a python script.
+ * ($EFL_HOME/src/utils/evas/generate_gl_thread_api.py)
+ * Recommend that you modify data files ($EFL_HOME/src/utils/evas/gl_api_def.txt)
+ * and make use of scripts if you need to fix them.
+ */
 
 /*
-   GLenum
-   glGetError(void);
+ * GLenum
+ * glGetError(void);
  */
 
 typedef struct
@@ -15,10 +19,10 @@ typedef struct
 static void
 _evgl_thread_glGetError(void *data)
 {
-   EVGL_Thread_Command_glGetError *thread_param =
+   EVGL_Thread_Command_glGetError *thread_data =
       (EVGL_Thread_Command_glGetError *)data;
 
-   thread_param->return_value = glGetError();
+   thread_data->return_value = glGetError();
 
 }
 
@@ -32,21 +36,21 @@ glGetError_evgl_thread_cmd(void)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glGetError thread_param_local;
-   EVGL_Thread_Command_glGetError *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glGetError thread_data_local;
+   EVGL_Thread_Command_glGetError *thread_data = &thread_data_local;
 
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glGetError,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
-   void
-   glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void *pointer);
+ * void
+ * glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void *pointer);
  */
 
 typedef struct
@@ -63,15 +67,15 @@ typedef struct
 static void
 _evgl_thread_glVertexAttribPointer(void *data)
 {
-   EVGL_Thread_Command_glVertexAttribPointer *thread_param =
+   EVGL_Thread_Command_glVertexAttribPointer *thread_data =
       (EVGL_Thread_Command_glVertexAttribPointer *)data;
 
-   glVertexAttribPointer(thread_param->index,
-                         thread_param->size,
-                         thread_param->type,
-                         thread_param->normalized,
-                         thread_param->stride,
-                         thread_param->pointer);
+   glVertexAttribPointer(thread_data->index,
+                         thread_data->size,
+                         thread_data->type,
+                         thread_data->normalized,
+                         thread_data->stride,
+                         thread_data->pointer);
 
 }
 
@@ -86,25 +90,25 @@ glVertexAttribPointer_evgl_thread_cmd(GLuint index, GLint size, GLenum type, GLb
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glVertexAttribPointer thread_param_local;
-   EVGL_Thread_Command_glVertexAttribPointer *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glVertexAttribPointer thread_data_local;
+   EVGL_Thread_Command_glVertexAttribPointer *thread_data = &thread_data_local;
 
-   thread_param->index = index;
-   thread_param->size = size;
-   thread_param->type = type;
-   thread_param->normalized = normalized;
-   thread_param->stride = stride;
-   thread_param->pointer = pointer;
+   thread_data->index = index;
+   thread_data->size = size;
+   thread_data->type = type;
+   thread_data->normalized = normalized;
+   thread_data->stride = stride;
+   thread_data->pointer = pointer;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glVertexAttribPointer,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glEnableVertexAttribArray(GLuint index);
+ * void
+ * glEnableVertexAttribArray(GLuint index);
  */
 
 typedef struct
@@ -117,13 +121,13 @@ typedef struct
 static void
 _evgl_thread_glEnableVertexAttribArray(void *data)
 {
-   EVGL_Thread_Command_glEnableVertexAttribArray *thread_param =
+   EVGL_Thread_Command_glEnableVertexAttribArray *thread_data =
       (EVGL_Thread_Command_glEnableVertexAttribArray *)data;
 
-   glEnableVertexAttribArray(thread_param->index);
+   glEnableVertexAttribArray(thread_data->index);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -137,36 +141,36 @@ glEnableVertexAttribArray_evgl_thread_cmd(GLuint index)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glEnableVertexAttribArray thread_param_local;
-   EVGL_Thread_Command_glEnableVertexAttribArray *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glEnableVertexAttribArray thread_data_local;
+   EVGL_Thread_Command_glEnableVertexAttribArray *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_Thread_Command_glEnableVertexAttribArray *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_Thread_Command_glEnableVertexAttribArray));
-        if (thread_param_new)
+        EVGL_Thread_Command_glEnableVertexAttribArray *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_Thread_Command_glEnableVertexAttribArray));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->index = index;
+   thread_data->index = index;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glEnableVertexAttribArray,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glDisableVertexAttribArray(GLuint index);
+ * void
+ * glDisableVertexAttribArray(GLuint index);
  */
 
 typedef struct
@@ -179,13 +183,13 @@ typedef struct
 static void
 _evgl_thread_glDisableVertexAttribArray(void *data)
 {
-   EVGL_Thread_Command_glDisableVertexAttribArray *thread_param =
+   EVGL_Thread_Command_glDisableVertexAttribArray *thread_data =
       (EVGL_Thread_Command_glDisableVertexAttribArray *)data;
 
-   glDisableVertexAttribArray(thread_param->index);
+   glDisableVertexAttribArray(thread_data->index);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -199,36 +203,36 @@ glDisableVertexAttribArray_evgl_thread_cmd(GLuint index)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glDisableVertexAttribArray thread_param_local;
-   EVGL_Thread_Command_glDisableVertexAttribArray *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glDisableVertexAttribArray thread_data_local;
+   EVGL_Thread_Command_glDisableVertexAttribArray *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_Thread_Command_glDisableVertexAttribArray *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_Thread_Command_glDisableVertexAttribArray));
-        if (thread_param_new)
+        EVGL_Thread_Command_glDisableVertexAttribArray *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_Thread_Command_glDisableVertexAttribArray));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->index = index;
+   thread_data->index = index;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glDisableVertexAttribArray,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glDrawArrays(GLenum mode, GLint first, GLsizei count);
+ * void
+ * glDrawArrays(GLenum mode, GLint first, GLsizei count);
  */
 
 typedef struct
@@ -242,12 +246,12 @@ typedef struct
 static void
 _evgl_thread_glDrawArrays(void *data)
 {
-   EVGL_Thread_Command_glDrawArrays *thread_param =
+   EVGL_Thread_Command_glDrawArrays *thread_data =
       (EVGL_Thread_Command_glDrawArrays *)data;
 
-   glDrawArrays(thread_param->mode,
-                thread_param->first,
-                thread_param->count);
+   glDrawArrays(thread_data->mode,
+                thread_data->first,
+                thread_data->count);
 
 }
 
@@ -262,22 +266,22 @@ glDrawArrays_evgl_thread_cmd(GLenum mode, GLint first, GLsizei count)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glDrawArrays thread_param_local;
-   EVGL_Thread_Command_glDrawArrays *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glDrawArrays thread_data_local;
+   EVGL_Thread_Command_glDrawArrays *thread_data = &thread_data_local;
 
-   thread_param->mode = mode;
-   thread_param->first = first;
-   thread_param->count = count;
+   thread_data->mode = mode;
+   thread_data->first = first;
+   thread_data->count = count;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glDrawArrays,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glDrawElements(GLenum mode, GLsizei count, GLenum type, const void *indices);
+ * void
+ * glDrawElements(GLenum mode, GLsizei count, GLenum type, const void *indices);
  */
 
 typedef struct
@@ -292,13 +296,13 @@ typedef struct
 static void
 _evgl_thread_glDrawElements(void *data)
 {
-   EVGL_Thread_Command_glDrawElements *thread_param =
+   EVGL_Thread_Command_glDrawElements *thread_data =
       (EVGL_Thread_Command_glDrawElements *)data;
 
-   glDrawElements(thread_param->mode,
-                  thread_param->count,
-                  thread_param->type,
-                  thread_param->indices);
+   glDrawElements(thread_data->mode,
+                  thread_data->count,
+                  thread_data->type,
+                  thread_data->indices);
 
 }
 
@@ -313,23 +317,23 @@ glDrawElements_evgl_thread_cmd(GLenum mode, GLsizei count, GLenum type, const vo
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glDrawElements thread_param_local;
-   EVGL_Thread_Command_glDrawElements *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glDrawElements thread_data_local;
+   EVGL_Thread_Command_glDrawElements *thread_data = &thread_data_local;
 
-   thread_param->mode = mode;
-   thread_param->count = count;
-   thread_param->type = type;
-   thread_param->indices = indices;
+   thread_data->mode = mode;
+   thread_data->count = count;
+   thread_data->type = type;
+   thread_data->indices = indices;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glDrawElements,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGenBuffers(GLsizei n, GLuint *buffers);
+ * void
+ * glGenBuffers(GLsizei n, GLuint *buffers);
  */
 
 typedef struct
@@ -342,11 +346,11 @@ typedef struct
 static void
 _evgl_thread_glGenBuffers(void *data)
 {
-   EVGL_Thread_Command_glGenBuffers *thread_param =
+   EVGL_Thread_Command_glGenBuffers *thread_data =
       (EVGL_Thread_Command_glGenBuffers *)data;
 
-   glGenBuffers(thread_param->n,
-                thread_param->buffers);
+   glGenBuffers(thread_data->n,
+                thread_data->buffers);
 
 }
 
@@ -361,21 +365,21 @@ glGenBuffers_evgl_thread_cmd(GLsizei n, GLuint *buffers)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glGenBuffers thread_param_local;
-   EVGL_Thread_Command_glGenBuffers *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glGenBuffers thread_data_local;
+   EVGL_Thread_Command_glGenBuffers *thread_data = &thread_data_local;
 
-   thread_param->n = n;
-   thread_param->buffers = buffers;
+   thread_data->n = n;
+   thread_data->buffers = buffers;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glGenBuffers,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glDeleteBuffers(GLsizei n, const GLuint *buffers);
+ * void
+ * glDeleteBuffers(GLsizei n, const GLuint *buffers);
  */
 
 typedef struct
@@ -390,18 +394,18 @@ typedef struct
 static void
 _evgl_thread_glDeleteBuffers(void *data)
 {
-   EVGL_Thread_Command_glDeleteBuffers *thread_param =
+   EVGL_Thread_Command_glDeleteBuffers *thread_data =
       (EVGL_Thread_Command_glDeleteBuffers *)data;
 
-   glDeleteBuffers(thread_param->n,
-                   thread_param->buffers);
+   glDeleteBuffers(thread_data->n,
+                   thread_data->buffers);
 
 
-   if (thread_param->buffers_copied)
-     eina_mempool_free(_mp_delete_object, thread_param->buffers_copied);
+   if (thread_data->buffers_copied)
+     eina_mempool_free(_mp_delete_object, thread_data->buffers_copied);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -415,29 +419,29 @@ glDeleteBuffers_evgl_thread_cmd(GLsizei n, const GLuint *buffers)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glDeleteBuffers thread_param_local;
-   EVGL_Thread_Command_glDeleteBuffers *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glDeleteBuffers thread_data_local;
+   EVGL_Thread_Command_glDeleteBuffers *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_Thread_Command_glDeleteBuffers *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_Thread_Command_glDeleteBuffers));
-        if (thread_param_new)
+        EVGL_Thread_Command_glDeleteBuffers *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_Thread_Command_glDeleteBuffers));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->n = n;
-   thread_param->buffers = buffers;
+   thread_data->n = n;
+   thread_data->buffers = buffers;
 
-   thread_param->buffers_copied = NULL;
+   thread_data->buffers_copied = NULL;
    if (thread_mode == EVAS_GL_THREAD_MODE_FINISH)
      goto finish;
 
@@ -452,10 +456,10 @@ glDeleteBuffers_evgl_thread_cmd(GLsizei n, const GLuint *buffers)
              goto finish;
           }
         /* 2. malloc & copy */
-        thread_param->buffers_copied = eina_mempool_malloc(_mp_delete_object, copy_size);
-        if (thread_param->buffers_copied)
+        thread_data->buffers_copied = eina_mempool_malloc(_mp_delete_object, copy_size);
+        if (thread_data->buffers_copied)
           {
-             memcpy(thread_param->buffers_copied, buffers, copy_size);
+             memcpy(thread_data->buffers_copied, buffers, copy_size);
           }
         else
           {
@@ -463,20 +467,20 @@ glDeleteBuffers_evgl_thread_cmd(GLsizei n, const GLuint *buffers)
              goto finish;
           }
         /* 3. replace */
-        thread_param->buffers = (const GLuint  *)thread_param->buffers_copied;
+        thread_data->buffers = (const GLuint  *)thread_data->buffers_copied;
      }
    /* end of copy variable */
 
 finish:
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glDeleteBuffers,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glBindBuffer(GLenum target, GLuint buffer);
+ * void
+ * glBindBuffer(GLenum target, GLuint buffer);
  */
 
 typedef struct
@@ -490,14 +494,14 @@ typedef struct
 static void
 _evgl_thread_glBindBuffer(void *data)
 {
-   EVGL_Thread_Command_glBindBuffer *thread_param =
+   EVGL_Thread_Command_glBindBuffer *thread_data =
       (EVGL_Thread_Command_glBindBuffer *)data;
 
-   glBindBuffer(thread_param->target,
-                thread_param->buffer);
+   glBindBuffer(thread_data->target,
+                thread_data->buffer);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -511,37 +515,37 @@ glBindBuffer_evgl_thread_cmd(GLenum target, GLuint buffer)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glBindBuffer thread_param_local;
-   EVGL_Thread_Command_glBindBuffer *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glBindBuffer thread_data_local;
+   EVGL_Thread_Command_glBindBuffer *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_Thread_Command_glBindBuffer *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_Thread_Command_glBindBuffer));
-        if (thread_param_new)
+        EVGL_Thread_Command_glBindBuffer *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_Thread_Command_glBindBuffer));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->target = target;
-   thread_param->buffer = buffer;
+   thread_data->target = target;
+   thread_data->buffer = buffer;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glBindBuffer,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glBufferData(GLenum target, GLsizeiptr size, const void *data, GLenum usage);
+ * void
+ * glBufferData(GLenum target, GLsizeiptr size, const void *data, GLenum usage);
  */
 
 typedef struct
@@ -556,13 +560,13 @@ typedef struct
 static void
 _evgl_thread_glBufferData(void *data)
 {
-   EVGL_Thread_Command_glBufferData *thread_param =
+   EVGL_Thread_Command_glBufferData *thread_data =
       (EVGL_Thread_Command_glBufferData *)data;
 
-   glBufferData(thread_param->target,
-                thread_param->size,
-                thread_param->data,
-                thread_param->usage);
+   glBufferData(thread_data->target,
+                thread_data->size,
+                thread_data->data,
+                thread_data->usage);
 
 }
 
@@ -577,23 +581,23 @@ glBufferData_evgl_thread_cmd(GLenum target, GLsizeiptr size, const void *data, G
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glBufferData thread_param_local;
-   EVGL_Thread_Command_glBufferData *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glBufferData thread_data_local;
+   EVGL_Thread_Command_glBufferData *thread_data = &thread_data_local;
 
-   thread_param->target = target;
-   thread_param->size = size;
-   thread_param->data = data;
-   thread_param->usage = usage;
+   thread_data->target = target;
+   thread_data->size = size;
+   thread_data->data = data;
+   thread_data->usage = usage;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glBufferData,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   GLuint
-   glCreateShader(GLenum type);
+ * GLuint
+ * glCreateShader(GLenum type);
  */
 
 typedef struct
@@ -606,10 +610,10 @@ typedef struct
 static void
 _evgl_thread_glCreateShader(void *data)
 {
-   EVGL_Thread_Command_glCreateShader *thread_param =
+   EVGL_Thread_Command_glCreateShader *thread_data =
       (EVGL_Thread_Command_glCreateShader *)data;
 
-   thread_param->return_value = glCreateShader(thread_param->type);
+   thread_data->return_value = glCreateShader(thread_data->type);
 
 }
 
@@ -623,22 +627,22 @@ glCreateShader_evgl_thread_cmd(GLenum type)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glCreateShader thread_param_local;
-   EVGL_Thread_Command_glCreateShader *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glCreateShader thread_data_local;
+   EVGL_Thread_Command_glCreateShader *thread_data = &thread_data_local;
 
-   thread_param->type = type;
+   thread_data->type = type;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glCreateShader,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
-   void
-   glShaderSource(GLuint shader, GLsizei count, const GLchar **string, const GLint *length);
+ * void
+ * glShaderSource(GLuint shader, GLsizei count, const GLchar **string, const GLint *length);
  */
 
 typedef struct
@@ -655,18 +659,18 @@ typedef struct
 static void
 _evgl_thread_glShaderSource(void *data)
 {
-   EVGL_Thread_Command_glShaderSource *thread_param =
+   EVGL_Thread_Command_glShaderSource *thread_data =
       (EVGL_Thread_Command_glShaderSource *)data;
 
-   glShaderSource(thread_param->shader,
-                  thread_param->count,
-                  thread_param->string,
-                  thread_param->length);
+   glShaderSource(thread_data->shader,
+                  thread_data->count,
+                  thread_data->string,
+                  thread_data->length);
 
    GLSHADERSOURCE_COPY_VARIABLE_FREE; /* TODO */
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -680,29 +684,29 @@ glShaderSource_evgl_thread_cmd(GLuint shader, GLsizei count, const GLchar **stri
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glShaderSource thread_param_local;
-   EVGL_Thread_Command_glShaderSource *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glShaderSource thread_data_local;
+   EVGL_Thread_Command_glShaderSource *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_Thread_Command_glShaderSource *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_Thread_Command_glShaderSource));
-        if (thread_param_new)
+        EVGL_Thread_Command_glShaderSource *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_Thread_Command_glShaderSource));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->shader = shader;
-   thread_param->count = count;
-   thread_param->string = string;
-   thread_param->length = length;
+   thread_data->shader = shader;
+   thread_data->count = count;
+   thread_data->string = string;
+   thread_data->length = length;
 
    GLSHADERSOURCE_COPY_VARIABLE_INIT; /* TODO */
 
@@ -714,13 +718,13 @@ glShaderSource_evgl_thread_cmd(GLuint shader, GLsizei count, const GLchar **stri
 finish:
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glShaderSource,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glCompileShader(GLuint shader);
+ * void
+ * glCompileShader(GLuint shader);
  */
 
 typedef struct
@@ -733,13 +737,13 @@ typedef struct
 static void
 _evgl_thread_glCompileShader(void *data)
 {
-   EVGL_Thread_Command_glCompileShader *thread_param =
+   EVGL_Thread_Command_glCompileShader *thread_data =
       (EVGL_Thread_Command_glCompileShader *)data;
 
-   glCompileShader(thread_param->shader);
+   glCompileShader(thread_data->shader);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -753,36 +757,36 @@ glCompileShader_evgl_thread_cmd(GLuint shader)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glCompileShader thread_param_local;
-   EVGL_Thread_Command_glCompileShader *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glCompileShader thread_data_local;
+   EVGL_Thread_Command_glCompileShader *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_Thread_Command_glCompileShader *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_Thread_Command_glCompileShader));
-        if (thread_param_new)
+        EVGL_Thread_Command_glCompileShader *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_Thread_Command_glCompileShader));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->shader = shader;
+   thread_data->shader = shader;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glCompileShader,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glDeleteShader(GLuint shader);
+ * void
+ * glDeleteShader(GLuint shader);
  */
 
 typedef struct
@@ -795,13 +799,13 @@ typedef struct
 static void
 _evgl_thread_glDeleteShader(void *data)
 {
-   EVGL_Thread_Command_glDeleteShader *thread_param =
+   EVGL_Thread_Command_glDeleteShader *thread_data =
       (EVGL_Thread_Command_glDeleteShader *)data;
 
-   glDeleteShader(thread_param->shader);
+   glDeleteShader(thread_data->shader);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -815,36 +819,36 @@ glDeleteShader_evgl_thread_cmd(GLuint shader)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glDeleteShader thread_param_local;
-   EVGL_Thread_Command_glDeleteShader *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glDeleteShader thread_data_local;
+   EVGL_Thread_Command_glDeleteShader *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_Thread_Command_glDeleteShader *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_Thread_Command_glDeleteShader));
-        if (thread_param_new)
+        EVGL_Thread_Command_glDeleteShader *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_Thread_Command_glDeleteShader));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->shader = shader;
+   thread_data->shader = shader;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glDeleteShader,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   GLuint
-   glCreateProgram(void);
+ * GLuint
+ * glCreateProgram(void);
  */
 
 typedef struct
@@ -856,10 +860,10 @@ typedef struct
 static void
 _evgl_thread_glCreateProgram(void *data)
 {
-   EVGL_Thread_Command_glCreateProgram *thread_param =
+   EVGL_Thread_Command_glCreateProgram *thread_data =
       (EVGL_Thread_Command_glCreateProgram *)data;
 
-   thread_param->return_value = glCreateProgram();
+   thread_data->return_value = glCreateProgram();
 
 }
 
@@ -873,21 +877,21 @@ glCreateProgram_evgl_thread_cmd(void)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glCreateProgram thread_param_local;
-   EVGL_Thread_Command_glCreateProgram *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glCreateProgram thread_data_local;
+   EVGL_Thread_Command_glCreateProgram *thread_data = &thread_data_local;
 
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glCreateProgram,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
-   void
-   glAttachShader(GLuint program, GLuint shader);
+ * void
+ * glAttachShader(GLuint program, GLuint shader);
  */
 
 typedef struct
@@ -901,14 +905,14 @@ typedef struct
 static void
 _evgl_thread_glAttachShader(void *data)
 {
-   EVGL_Thread_Command_glAttachShader *thread_param =
+   EVGL_Thread_Command_glAttachShader *thread_data =
       (EVGL_Thread_Command_glAttachShader *)data;
 
-   glAttachShader(thread_param->program,
-                  thread_param->shader);
+   glAttachShader(thread_data->program,
+                  thread_data->shader);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -922,37 +926,37 @@ glAttachShader_evgl_thread_cmd(GLuint program, GLuint shader)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glAttachShader thread_param_local;
-   EVGL_Thread_Command_glAttachShader *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glAttachShader thread_data_local;
+   EVGL_Thread_Command_glAttachShader *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_Thread_Command_glAttachShader *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_Thread_Command_glAttachShader));
-        if (thread_param_new)
+        EVGL_Thread_Command_glAttachShader *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_Thread_Command_glAttachShader));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->program = program;
-   thread_param->shader = shader;
+   thread_data->program = program;
+   thread_data->shader = shader;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glAttachShader,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glDetachShader(GLuint program, GLuint shader);
+ * void
+ * glDetachShader(GLuint program, GLuint shader);
  */
 
 typedef struct
@@ -966,14 +970,14 @@ typedef struct
 static void
 _evgl_thread_glDetachShader(void *data)
 {
-   EVGL_Thread_Command_glDetachShader *thread_param =
+   EVGL_Thread_Command_glDetachShader *thread_data =
       (EVGL_Thread_Command_glDetachShader *)data;
 
-   glDetachShader(thread_param->program,
-                  thread_param->shader);
+   glDetachShader(thread_data->program,
+                  thread_data->shader);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -987,37 +991,37 @@ glDetachShader_evgl_thread_cmd(GLuint program, GLuint shader)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glDetachShader thread_param_local;
-   EVGL_Thread_Command_glDetachShader *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glDetachShader thread_data_local;
+   EVGL_Thread_Command_glDetachShader *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_Thread_Command_glDetachShader *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_Thread_Command_glDetachShader));
-        if (thread_param_new)
+        EVGL_Thread_Command_glDetachShader *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_Thread_Command_glDetachShader));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->program = program;
-   thread_param->shader = shader;
+   thread_data->program = program;
+   thread_data->shader = shader;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glDetachShader,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glLinkProgram(GLuint program);
+ * void
+ * glLinkProgram(GLuint program);
  */
 
 typedef struct
@@ -1030,13 +1034,13 @@ typedef struct
 static void
 _evgl_thread_glLinkProgram(void *data)
 {
-   EVGL_Thread_Command_glLinkProgram *thread_param =
+   EVGL_Thread_Command_glLinkProgram *thread_data =
       (EVGL_Thread_Command_glLinkProgram *)data;
 
-   glLinkProgram(thread_param->program);
+   glLinkProgram(thread_data->program);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -1050,36 +1054,36 @@ glLinkProgram_evgl_thread_cmd(GLuint program)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glLinkProgram thread_param_local;
-   EVGL_Thread_Command_glLinkProgram *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glLinkProgram thread_data_local;
+   EVGL_Thread_Command_glLinkProgram *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_Thread_Command_glLinkProgram *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_Thread_Command_glLinkProgram));
-        if (thread_param_new)
+        EVGL_Thread_Command_glLinkProgram *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_Thread_Command_glLinkProgram));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->program = program;
+   thread_data->program = program;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glLinkProgram,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glUseProgram(GLuint program);
+ * void
+ * glUseProgram(GLuint program);
  */
 
 typedef struct
@@ -1092,13 +1096,13 @@ typedef struct
 static void
 _evgl_thread_glUseProgram(void *data)
 {
-   EVGL_Thread_Command_glUseProgram *thread_param =
+   EVGL_Thread_Command_glUseProgram *thread_data =
       (EVGL_Thread_Command_glUseProgram *)data;
 
-   glUseProgram(thread_param->program);
+   glUseProgram(thread_data->program);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -1112,36 +1116,36 @@ glUseProgram_evgl_thread_cmd(GLuint program)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glUseProgram thread_param_local;
-   EVGL_Thread_Command_glUseProgram *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glUseProgram thread_data_local;
+   EVGL_Thread_Command_glUseProgram *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_Thread_Command_glUseProgram *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_Thread_Command_glUseProgram));
-        if (thread_param_new)
+        EVGL_Thread_Command_glUseProgram *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_Thread_Command_glUseProgram));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->program = program;
+   thread_data->program = program;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glUseProgram,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glDeleteProgram(GLuint program);
+ * void
+ * glDeleteProgram(GLuint program);
  */
 
 typedef struct
@@ -1154,13 +1158,13 @@ typedef struct
 static void
 _evgl_thread_glDeleteProgram(void *data)
 {
-   EVGL_Thread_Command_glDeleteProgram *thread_param =
+   EVGL_Thread_Command_glDeleteProgram *thread_data =
       (EVGL_Thread_Command_glDeleteProgram *)data;
 
-   glDeleteProgram(thread_param->program);
+   glDeleteProgram(thread_data->program);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -1174,36 +1178,36 @@ glDeleteProgram_evgl_thread_cmd(GLuint program)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glDeleteProgram thread_param_local;
-   EVGL_Thread_Command_glDeleteProgram *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glDeleteProgram thread_data_local;
+   EVGL_Thread_Command_glDeleteProgram *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_Thread_Command_glDeleteProgram *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_Thread_Command_glDeleteProgram));
-        if (thread_param_new)
+        EVGL_Thread_Command_glDeleteProgram *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_Thread_Command_glDeleteProgram));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->program = program;
+   thread_data->program = program;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glDeleteProgram,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGetProgramBinary(GLuint program, GLsizei bufSize, GLsizei *length, GLenum *binaryFormat, void *binary);
+ * void
+ * glGetProgramBinary(GLuint program, GLsizei bufSize, GLsizei *length, GLenum *binaryFormat, void *binary);
  */
 
 typedef struct
@@ -1233,14 +1237,14 @@ glGetProgramBinary_orig_evgl_get(void)
 static void
 _evgl_thread_glGetProgramBinary(void *data)
 {
-   EVGL_Thread_Command_glGetProgramBinary *thread_param =
+   EVGL_Thread_Command_glGetProgramBinary *thread_data =
       (EVGL_Thread_Command_glGetProgramBinary *)data;
 
-   orig_evgl_glGetProgramBinary(thread_param->program,
-                                thread_param->bufSize,
-                                thread_param->length,
-                                thread_param->binaryFormat,
-                                thread_param->binary);
+   orig_evgl_glGetProgramBinary(thread_data->program,
+                                thread_data->bufSize,
+                                thread_data->length,
+                                thread_data->binaryFormat,
+                                thread_data->binary);
 
 }
 
@@ -1255,24 +1259,24 @@ glGetProgramBinary_evgl_thread_cmd(GLuint program, GLsizei bufSize, GLsizei *len
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glGetProgramBinary thread_param_local;
-   EVGL_Thread_Command_glGetProgramBinary *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glGetProgramBinary thread_data_local;
+   EVGL_Thread_Command_glGetProgramBinary *thread_data = &thread_data_local;
 
-   thread_param->program = program;
-   thread_param->bufSize = bufSize;
-   thread_param->length = length;
-   thread_param->binaryFormat = binaryFormat;
-   thread_param->binary = binary;
+   thread_data->program = program;
+   thread_data->bufSize = bufSize;
+   thread_data->length = length;
+   thread_data->binaryFormat = binaryFormat;
+   thread_data->binary = binary;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glGetProgramBinary,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glProgramBinary(GLuint program, GLenum binaryFormat, const void *binary, GLint length);
+ * void
+ * glProgramBinary(GLuint program, GLenum binaryFormat, const void *binary, GLint length);
  */
 
 typedef struct
@@ -1303,20 +1307,20 @@ glProgramBinary_orig_evgl_get(void)
 static void
 _evgl_thread_glProgramBinary(void *data)
 {
-   EVGL_Thread_Command_glProgramBinary *thread_param =
+   EVGL_Thread_Command_glProgramBinary *thread_data =
       (EVGL_Thread_Command_glProgramBinary *)data;
 
-   orig_evgl_glProgramBinary(thread_param->program,
-                             thread_param->binaryFormat,
-                             thread_param->binary,
-                             thread_param->length);
+   orig_evgl_glProgramBinary(thread_data->program,
+                             thread_data->binaryFormat,
+                             thread_data->binary,
+                             thread_data->length);
 
 
-   if (thread_param->binary_copied)
-     eina_mempool_free(_mp_default, thread_param->binary_copied);
+   if (thread_data->binary_copied)
+     eina_mempool_free(_mp_default, thread_data->binary_copied);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -1330,31 +1334,31 @@ glProgramBinary_evgl_thread_cmd(GLuint program, GLenum binaryFormat, const void
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glProgramBinary thread_param_local;
-   EVGL_Thread_Command_glProgramBinary *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glProgramBinary thread_data_local;
+   EVGL_Thread_Command_glProgramBinary *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_Thread_Command_glProgramBinary *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_Thread_Command_glProgramBinary));
-        if (thread_param_new)
+        EVGL_Thread_Command_glProgramBinary *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_Thread_Command_glProgramBinary));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->program = program;
-   thread_param->binaryFormat = binaryFormat;
-   thread_param->binary = binary;
-   thread_param->length = length;
+   thread_data->program = program;
+   thread_data->binaryFormat = binaryFormat;
+   thread_data->binary = binary;
+   thread_data->length = length;
 
-   thread_param->binary_copied = NULL;
+   thread_data->binary_copied = NULL;
    if (thread_mode == EVAS_GL_THREAD_MODE_FINISH)
      goto finish;
 
@@ -1369,10 +1373,10 @@ glProgramBinary_evgl_thread_cmd(GLuint program, GLenum binaryFormat, const void
              goto finish;
           }
         /* 2. malloc & copy */
-        thread_param->binary_copied = eina_mempool_malloc(_mp_default, copy_size);
-        if (thread_param->binary_copied)
+        thread_data->binary_copied = eina_mempool_malloc(_mp_default, copy_size);
+        if (thread_data->binary_copied)
           {
-             memcpy(thread_param->binary_copied, binary, copy_size);
+             memcpy(thread_data->binary_copied, binary, copy_size);
           }
         else
           {
@@ -1380,20 +1384,20 @@ glProgramBinary_evgl_thread_cmd(GLuint program, GLenum binaryFormat, const void
              goto finish;
           }
         /* 3. replace */
-        thread_param->binary = (const void  *)thread_param->binary_copied;
+        thread_data->binary = (const void  *)thread_data->binary_copied;
      }
    /* end of copy variable */
 
 finish:
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glProgramBinary,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name);
+ * void
+ * glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name);
  */
 
 typedef struct
@@ -1411,16 +1415,16 @@ typedef struct
 static void
 _evgl_thread_glGetActiveAttrib(void *data)
 {
-   EVGL_Thread_Command_glGetActiveAttrib *thread_param =
+   EVGL_Thread_Command_glGetActiveAttrib *thread_data =
       (EVGL_Thread_Command_glGetActiveAttrib *)data;
 
-   glGetActiveAttrib(thread_param->program,
-                     thread_param->index,
-                     thread_param->bufSize,
-                     thread_param->length,
-                     thread_param->size,
-                     thread_param->type,
-                     thread_param->name);
+   glGetActiveAttrib(thread_data->program,
+                     thread_data->index,
+                     thread_data->bufSize,
+                     thread_data->length,
+                     thread_data->size,
+                     thread_data->type,
+                     thread_data->name);
 
 }
 
@@ -1435,26 +1439,26 @@ glGetActiveAttrib_evgl_thread_cmd(GLuint program, GLuint index, GLsizei bufSize,
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glGetActiveAttrib thread_param_local;
-   EVGL_Thread_Command_glGetActiveAttrib *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glGetActiveAttrib thread_data_local;
+   EVGL_Thread_Command_glGetActiveAttrib *thread_data = &thread_data_local;
 
-   thread_param->program = program;
-   thread_param->index = index;
-   thread_param->bufSize = bufSize;
-   thread_param->length = length;
-   thread_param->size = size;
-   thread_param->type = type;
-   thread_param->name = name;
+   thread_data->program = program;
+   thread_data->index = index;
+   thread_data->bufSize = bufSize;
+   thread_data->length = length;
+   thread_data->size = size;
+   thread_data->type = type;
+   thread_data->name = name;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glGetActiveAttrib,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   GLint
-   glGetAttribLocation(GLuint program, const GLchar *name);
+ * GLint
+ * glGetAttribLocation(GLuint program, const GLchar *name);
  */
 
 typedef struct
@@ -1468,11 +1472,11 @@ typedef struct
 static void
 _evgl_thread_glGetAttribLocation(void *data)
 {
-   EVGL_Thread_Command_glGetAttribLocation *thread_param =
+   EVGL_Thread_Command_glGetAttribLocation *thread_data =
       (EVGL_Thread_Command_glGetAttribLocation *)data;
 
-   thread_param->return_value = glGetAttribLocation(thread_param->program,
-                                                    thread_param->name);
+   thread_data->return_value = glGetAttribLocation(thread_data->program,
+                                                   thread_data->name);
 
 }
 
@@ -1486,23 +1490,23 @@ glGetAttribLocation_evgl_thread_cmd(GLuint program, const GLchar *name)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glGetAttribLocation thread_param_local;
-   EVGL_Thread_Command_glGetAttribLocation *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glGetAttribLocation thread_data_local;
+   EVGL_Thread_Command_glGetAttribLocation *thread_data = &thread_data_local;
 
-   thread_param->program = program;
-   thread_param->name = name;
+   thread_data->program = program;
+   thread_data->name = name;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glGetAttribLocation,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
-   void
-   glBindAttribLocation(GLuint program, GLuint index, const GLchar *name);
+ * void
+ * glBindAttribLocation(GLuint program, GLuint index, const GLchar *name);
  */
 
 typedef struct
@@ -1516,12 +1520,12 @@ typedef struct
 static void
 _evgl_thread_glBindAttribLocation(void *data)
 {
-   EVGL_Thread_Command_glBindAttribLocation *thread_param =
+   EVGL_Thread_Command_glBindAttribLocation *thread_data =
       (EVGL_Thread_Command_glBindAttribLocation *)data;
 
-   glBindAttribLocation(thread_param->program,
-                        thread_param->index,
-                        thread_param->name);
+   glBindAttribLocation(thread_data->program,
+                        thread_data->index,
+                        thread_data->name);
 
 }
 
@@ -1536,22 +1540,22 @@ glBindAttribLocation_evgl_thread_cmd(GLuint program, GLuint index, const GLchar
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glBindAttribLocation thread_param_local;
-   EVGL_Thread_Command_glBindAttribLocation *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glBindAttribLocation thread_data_local;
+   EVGL_Thread_Command_glBindAttribLocation *thread_data = &thread_data_local;
 
-   thread_param->program = program;
-   thread_param->index = index;
-   thread_param->name = name;
+   thread_data->program = program;
+   thread_data->index = index;
+   thread_data->name = name;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glBindAttribLocation,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   GLint
-   glGetUniformLocation(GLuint program, const GLchar *name);
+ * GLint
+ * glGetUniformLocation(GLuint program, const GLchar *name);
  */
 
 typedef struct
@@ -1565,11 +1569,11 @@ typedef struct
 static void
 _evgl_thread_glGetUniformLocation(void *data)
 {
-   EVGL_Thread_Command_glGetUniformLocation *thread_param =
+   EVGL_Thread_Command_glGetUniformLocation *thread_data =
       (EVGL_Thread_Command_glGetUniformLocation *)data;
 
-   thread_param->return_value = glGetUniformLocation(thread_param->program,
-                                                     thread_param->name);
+   thread_data->return_value = glGetUniformLocation(thread_data->program,
+                                                    thread_data->name);
 
 }
 
@@ -1583,23 +1587,23 @@ glGetUniformLocation_evgl_thread_cmd(GLuint program, const GLchar *name)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glGetUniformLocation thread_param_local;
-   EVGL_Thread_Command_glGetUniformLocation *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glGetUniformLocation thread_data_local;
+   EVGL_Thread_Command_glGetUniformLocation *thread_data = &thread_data_local;
 
-   thread_param->program = program;
-   thread_param->name = name;
+   thread_data->program = program;
+   thread_data->name = name;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glGetUniformLocation,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
-   void
-   glUniform1f(GLint location, GLfloat v0);
+ * void
+ * glUniform1f(GLint location, GLfloat v0);
  */
 
 typedef struct
@@ -1613,14 +1617,14 @@ typedef struct
 static void
 _evgl_thread_glUniform1f(void *data)
 {
-   EVGL_Thread_Command_glUniform1f *thread_param =
+   EVGL_Thread_Command_glUniform1f *thread_data =
       (EVGL_Thread_Command_glUniform1f *)data;
 
-   glUniform1f(thread_param->location,
-               thread_param->v0);
+   glUniform1f(thread_data->location,
+               thread_data->v0);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -1634,37 +1638,37 @@ glUniform1f_evgl_thread_cmd(GLint location, GLfloat v0)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glUniform1f thread_param_local;
-   EVGL_Thread_Command_glUniform1f *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glUniform1f thread_data_local;
+   EVGL_Thread_Command_glUniform1f *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_Thread_Command_glUniform1f *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_Thread_Command_glUniform1f));
-        if (thread_param_new)
+        EVGL_Thread_Command_glUniform1f *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_Thread_Command_glUniform1f));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->location = location;
-   thread_param->v0 = v0;
+   thread_data->location = location;
+   thread_data->v0 = v0;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glUniform1f,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glUniform1i(GLint location, GLint v0);
+ * void
+ * glUniform1i(GLint location, GLint v0);
  */
 
 typedef struct
@@ -1678,14 +1682,14 @@ typedef struct
 static void
 _evgl_thread_glUniform1i(void *data)
 {
-   EVGL_Thread_Command_glUniform1i *thread_param =
+   EVGL_Thread_Command_glUniform1i *thread_data =
       (EVGL_Thread_Command_glUniform1i *)data;
 
-   glUniform1i(thread_param->location,
-               thread_param->v0);
+   glUniform1i(thread_data->location,
+               thread_data->v0);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -1699,37 +1703,37 @@ glUniform1i_evgl_thread_cmd(GLint location, GLint v0)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glUniform1i thread_param_local;
-   EVGL_Thread_Command_glUniform1i *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glUniform1i thread_data_local;
+   EVGL_Thread_Command_glUniform1i *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_Thread_Command_glUniform1i *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_Thread_Command_glUniform1i));
-        if (thread_param_new)
+        EVGL_Thread_Command_glUniform1i *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_Thread_Command_glUniform1i));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->location = location;
-   thread_param->v0 = v0;
+   thread_data->location = location;
+   thread_data->v0 = v0;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glUniform1i,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glUniform2f(GLint location, GLfloat v0, GLfloat v1);
+ * void
+ * glUniform2f(GLint location, GLfloat v0, GLfloat v1);
  */
 
 typedef struct
@@ -1744,15 +1748,15 @@ typedef struct
 static void
 _evgl_thread_glUniform2f(void *data)
 {
-   EVGL_Thread_Command_glUniform2f *thread_param =
+   EVGL_Thread_Command_glUniform2f *thread_data =
       (EVGL_Thread_Command_glUniform2f *)data;
 
-   glUniform2f(thread_param->location,
-               thread_param->v0,
-               thread_param->v1);
+   glUniform2f(thread_data->location,
+               thread_data->v0,
+               thread_data->v1);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -1766,38 +1770,38 @@ glUniform2f_evgl_thread_cmd(GLint location, GLfloat v0, GLfloat v1)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glUniform2f thread_param_local;
-   EVGL_Thread_Command_glUniform2f *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glUniform2f thread_data_local;
+   EVGL_Thread_Command_glUniform2f *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_Thread_Command_glUniform2f *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_Thread_Command_glUniform2f));
-        if (thread_param_new)
+        EVGL_Thread_Command_glUniform2f *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_Thread_Command_glUniform2f));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->location = location;
-   thread_param->v0 = v0;
-   thread_param->v1 = v1;
+   thread_data->location = location;
+   thread_data->v0 = v0;
+   thread_data->v1 = v1;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glUniform2f,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glUniform2i(GLint location, GLint v0, GLint v1);
+ * void
+ * glUniform2i(GLint location, GLint v0, GLint v1);
  */
 
 typedef struct
@@ -1812,15 +1816,15 @@ typedef struct
 static void
 _evgl_thread_glUniform2i(void *data)
 {
-   EVGL_Thread_Command_glUniform2i *thread_param =
+   EVGL_Thread_Command_glUniform2i *thread_data =
       (EVGL_Thread_Command_glUniform2i *)data;
 
-   glUniform2i(thread_param->location,
-               thread_param->v0,
-               thread_param->v1);
+   glUniform2i(thread_data->location,
+               thread_data->v0,
+               thread_data->v1);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -1834,38 +1838,38 @@ glUniform2i_evgl_thread_cmd(GLint location, GLint v0, GLint v1)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glUniform2i thread_param_local;
-   EVGL_Thread_Command_glUniform2i *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glUniform2i thread_data_local;
+   EVGL_Thread_Command_glUniform2i *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_Thread_Command_glUniform2i *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_Thread_Command_glUniform2i));
-        if (thread_param_new)
+        EVGL_Thread_Command_glUniform2i *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_Thread_Command_glUniform2i));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->location = location;
-   thread_param->v0 = v0;
-   thread_param->v1 = v1;
+   thread_data->location = location;
+   thread_data->v0 = v0;
+   thread_data->v1 = v1;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glUniform2i,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glUniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2);
+ * void
+ * glUniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2);
  */
 
 typedef struct
@@ -1881,16 +1885,16 @@ typedef struct
 static void
 _evgl_thread_glUniform3f(void *data)
 {
-   EVGL_Thread_Command_glUniform3f *thread_param =
+   EVGL_Thread_Command_glUniform3f *thread_data =
       (EVGL_Thread_Command_glUniform3f *)data;
 
-   glUniform3f(thread_param->location,
-               thread_param->v0,
-               thread_param->v1,
-               thread_param->v2);
+   glUniform3f(thread_data->location,
+               thread_data->v0,
+               thread_data->v1,
+               thread_data->v2);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -1904,39 +1908,39 @@ glUniform3f_evgl_thread_cmd(GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glUniform3f thread_param_local;
-   EVGL_Thread_Command_glUniform3f *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glUniform3f thread_data_local;
+   EVGL_Thread_Command_glUniform3f *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_Thread_Command_glUniform3f *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_Thread_Command_glUniform3f));
-        if (thread_param_new)
+        EVGL_Thread_Command_glUniform3f *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_Thread_Command_glUniform3f));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->location = location;
-   thread_param->v0 = v0;
-   thread_param->v1 = v1;
-   thread_param->v2 = v2;
+   thread_data->location = location;
+   thread_data->v0 = v0;
+   thread_data->v1 = v1;
+   thread_data->v2 = v2;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glUniform3f,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glUniform3i(GLint location, GLint v0, GLint v1, GLint v2);
+ * void
+ * glUniform3i(GLint location, GLint v0, GLint v1, GLint v2);
  */
 
 typedef struct
@@ -1952,16 +1956,16 @@ typedef struct
 static void
 _evgl_thread_glUniform3i(void *data)
 {
-   EVGL_Thread_Command_glUniform3i *thread_param =
+   EVGL_Thread_Command_glUniform3i *thread_data =
       (EVGL_Thread_Command_glUniform3i *)data;
 
-   glUniform3i(thread_param->location,
-               thread_param->v0,
-               thread_param->v1,
-               thread_param->v2);
+   glUniform3i(thread_data->location,
+               thread_data->v0,
+               thread_data->v1,
+               thread_data->v2);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -1975,39 +1979,39 @@ glUniform3i_evgl_thread_cmd(GLint location, GLint v0, GLint v1, GLint v2)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glUniform3i thread_param_local;
-   EVGL_Thread_Command_glUniform3i *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glUniform3i thread_data_local;
+   EVGL_Thread_Command_glUniform3i *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_Thread_Command_glUniform3i *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_Thread_Command_glUniform3i));
-        if (thread_param_new)
+        EVGL_Thread_Command_glUniform3i *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_Thread_Command_glUniform3i));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->location = location;
-   thread_param->v0 = v0;
-   thread_param->v1 = v1;
-   thread_param->v2 = v2;
+   thread_data->location = location;
+   thread_data->v0 = v0;
+   thread_data->v1 = v1;
+   thread_data->v2 = v2;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glUniform3i,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glUniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);
+ * void
+ * glUniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);
  */
 
 typedef struct
@@ -2024,17 +2028,17 @@ typedef struct
 static void
 _evgl_thread_glUniform4f(void *data)
 {
-   EVGL_Thread_Command_glUniform4f *thread_param =
+   EVGL_Thread_Command_glUniform4f *thread_data =
       (EVGL_Thread_Command_glUniform4f *)data;
 
-   glUniform4f(thread_param->location,
-               thread_param->v0,
-               thread_param->v1,
-               thread_param->v2,
-               thread_param->v3);
+   glUniform4f(thread_data->location,
+               thread_data->v0,
+               thread_data->v1,
+               thread_data->v2,
+               thread_data->v3);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -2048,40 +2052,40 @@ glUniform4f_evgl_thread_cmd(GLint location, GLfloat v0, GLfloat v1, GLfloat v2,
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glUniform4f thread_param_local;
-   EVGL_Thread_Command_glUniform4f *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glUniform4f thread_data_local;
+   EVGL_Thread_Command_glUniform4f *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_Thread_Command_glUniform4f *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_Thread_Command_glUniform4f));
-        if (thread_param_new)
+        EVGL_Thread_Command_glUniform4f *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_Thread_Command_glUniform4f));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->location = location;
-   thread_param->v0 = v0;
-   thread_param->v1 = v1;
-   thread_param->v2 = v2;
-   thread_param->v3 = v3;
+   thread_data->location = location;
+   thread_data->v0 = v0;
+   thread_data->v1 = v1;
+   thread_data->v2 = v2;
+   thread_data->v3 = v3;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glUniform4f,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glUniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3);
+ * void
+ * glUniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3);
  */
 
 typedef struct
@@ -2098,17 +2102,17 @@ typedef struct
 static void
 _evgl_thread_glUniform4i(void *data)
 {
-   EVGL_Thread_Command_glUniform4i *thread_param =
+   EVGL_Thread_Command_glUniform4i *thread_data =
       (EVGL_Thread_Command_glUniform4i *)data;
 
-   glUniform4i(thread_param->location,
-               thread_param->v0,
-               thread_param->v1,
-               thread_param->v2,
-               thread_param->v3);
+   glUniform4i(thread_data->location,
+               thread_data->v0,
+               thread_data->v1,
+               thread_data->v2,
+               thread_data->v3);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -2122,40 +2126,40 @@ glUniform4i_evgl_thread_cmd(GLint location, GLint v0, GLint v1, GLint v2, GLint
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glUniform4i thread_param_local;
-   EVGL_Thread_Command_glUniform4i *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glUniform4i thread_data_local;
+   EVGL_Thread_Command_glUniform4i *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_Thread_Command_glUniform4i *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_Thread_Command_glUniform4i));
-        if (thread_param_new)
+        EVGL_Thread_Command_glUniform4i *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_Thread_Command_glUniform4i));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->location = location;
-   thread_param->v0 = v0;
-   thread_param->v1 = v1;
-   thread_param->v2 = v2;
-   thread_param->v3 = v3;
+   thread_data->location = location;
+   thread_data->v0 = v0;
+   thread_data->v1 = v1;
+   thread_data->v2 = v2;
+   thread_data->v3 = v3;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glUniform4i,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glUniform1fv(GLint location, GLsizei count, const GLfloat *value);
+ * void
+ * glUniform1fv(GLint location, GLsizei count, const GLfloat *value);
  */
 
 typedef struct
@@ -2171,19 +2175,19 @@ typedef struct
 static void
 _evgl_thread_glUniform1fv(void *data)
 {
-   EVGL_Thread_Command_glUniform1fv *thread_param =
+   EVGL_Thread_Command_glUniform1fv *thread_data =
       (EVGL_Thread_Command_glUniform1fv *)data;
 
-   glUniform1fv(thread_param->location,
-                thread_param->count,
-                thread_param->value);
+   glUniform1fv(thread_data->location,
+                thread_data->count,
+                thread_data->value);
 
 
-   if (thread_param->value_copied)
-     eina_mempool_free(_mp_uniform, thread_param->value_copied);
+   if (thread_data->value_copied)
+     eina_mempool_free(_mp_uniform, thread_data->value_copied);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -2197,30 +2201,30 @@ glUniform1fv_evgl_thread_cmd(GLint location, GLsizei count, const GLfloat *value
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glUniform1fv thread_param_local;
-   EVGL_Thread_Command_glUniform1fv *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glUniform1fv thread_data_local;
+   EVGL_Thread_Command_glUniform1fv *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_Thread_Command_glUniform1fv *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_Thread_Command_glUniform1fv));
-        if (thread_param_new)
+        EVGL_Thread_Command_glUniform1fv *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_Thread_Command_glUniform1fv));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->location = location;
-   thread_param->count = count;
-   thread_param->value = value;
+   thread_data->location = location;
+   thread_data->count = count;
+   thread_data->value = value;
 
-   thread_param->value_copied = NULL;
+   thread_data->value_copied = NULL;
    if (thread_mode == EVAS_GL_THREAD_MODE_FINISH)
      goto finish;
 
@@ -2235,10 +2239,10 @@ glUniform1fv_evgl_thread_cmd(GLint location, GLsizei count, const GLfloat *value
              goto finish;
           }
         /* 2. malloc & copy */
-        thread_param->value_copied = eina_mempool_malloc(_mp_uniform, copy_size);
-        if (thread_param->value_copied)
+        thread_data->value_copied = eina_mempool_malloc(_mp_uniform, copy_size);
+        if (thread_data->value_copied)
           {
-             memcpy(thread_param->value_copied, value, copy_size);
+             memcpy(thread_data->value_copied, value, copy_size);
           }
         else
           {
@@ -2246,20 +2250,20 @@ glUniform1fv_evgl_thread_cmd(GLint location, GLsizei count, const GLfloat *value
              goto finish;
           }
         /* 3. replace */
-        thread_param->value = (const GLfloat  *)thread_param->value_copied;
+        thread_data->value = (const GLfloat  *)thread_data->value_copied;
      }
    /* end of copy variable */
 
 finish:
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glUniform1fv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glUniform1iv(GLint location, GLsizei count, const GLint *value);
+ * void
+ * glUniform1iv(GLint location, GLsizei count, const GLint *value);
  */
 
 typedef struct
@@ -2275,19 +2279,19 @@ typedef struct
 static void
 _evgl_thread_glUniform1iv(void *data)
 {
-   EVGL_Thread_Command_glUniform1iv *thread_param =
+   EVGL_Thread_Command_glUniform1iv *thread_data =
       (EVGL_Thread_Command_glUniform1iv *)data;
 
-   glUniform1iv(thread_param->location,
-                thread_param->count,
-                thread_param->value);
+   glUniform1iv(thread_data->location,
+                thread_data->count,
+                thread_data->value);
 
 
-   if (thread_param->value_copied)
-     eina_mempool_free(_mp_uniform, thread_param->value_copied);
+   if (thread_data->value_copied)
+     eina_mempool_free(_mp_uniform, thread_data->value_copied);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -2301,30 +2305,30 @@ glUniform1iv_evgl_thread_cmd(GLint location, GLsizei count, const GLint *value)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glUniform1iv thread_param_local;
-   EVGL_Thread_Command_glUniform1iv *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glUniform1iv thread_data_local;
+   EVGL_Thread_Command_glUniform1iv *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_Thread_Command_glUniform1iv *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_Thread_Command_glUniform1iv));
-        if (thread_param_new)
+        EVGL_Thread_Command_glUniform1iv *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_Thread_Command_glUniform1iv));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->location = location;
-   thread_param->count = count;
-   thread_param->value = value;
+   thread_data->location = location;
+   thread_data->count = count;
+   thread_data->value = value;
 
-   thread_param->value_copied = NULL;
+   thread_data->value_copied = NULL;
    if (thread_mode == EVAS_GL_THREAD_MODE_FINISH)
      goto finish;
 
@@ -2339,10 +2343,10 @@ glUniform1iv_evgl_thread_cmd(GLint location, GLsizei count, const GLint *value)
              goto finish;
           }
         /* 2. malloc & copy */
-        thread_param->value_copied = eina_mempool_malloc(_mp_uniform, copy_size);
-        if (thread_param->value_copied)
+        thread_data->value_copied = eina_mempool_malloc(_mp_uniform, copy_size);
+        if (thread_data->value_copied)
           {
-             memcpy(thread_param->value_copied, value, copy_size);
+             memcpy(thread_data->value_copied, value, copy_size);
           }
         else
           {
@@ -2350,20 +2354,20 @@ glUniform1iv_evgl_thread_cmd(GLint location, GLsizei count, const GLint *value)
              goto finish;
           }
         /* 3. replace */
-        thread_param->value = (const GLint  *)thread_param->value_copied;
+        thread_data->value = (const GLint  *)thread_data->value_copied;
      }
    /* end of copy variable */
 
 finish:
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glUniform1iv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glUniform2fv(GLint location, GLsizei count, const GLfloat *value);
+ * void
+ * glUniform2fv(GLint location, GLsizei count, const GLfloat *value);
  */
 
 typedef struct
@@ -2379,19 +2383,19 @@ typedef struct
 static void
 _evgl_thread_glUniform2fv(void *data)
 {
-   EVGL_Thread_Command_glUniform2fv *thread_param =
+   EVGL_Thread_Command_glUniform2fv *thread_data =
       (EVGL_Thread_Command_glUniform2fv *)data;
 
-   glUniform2fv(thread_param->location,
-                thread_param->count,
-                thread_param->value);
+   glUniform2fv(thread_data->location,
+                thread_data->count,
+                thread_data->value);
 
 
-   if (thread_param->value_copied)
-     eina_mempool_free(_mp_uniform, thread_param->value_copied);
+   if (thread_data->value_copied)
+     eina_mempool_free(_mp_uniform, thread_data->value_copied);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -2405,30 +2409,30 @@ glUniform2fv_evgl_thread_cmd(GLint location, GLsizei count, const GLfloat *value
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glUniform2fv thread_param_local;
-   EVGL_Thread_Command_glUniform2fv *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glUniform2fv thread_data_local;
+   EVGL_Thread_Command_glUniform2fv *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_Thread_Command_glUniform2fv *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_Thread_Command_glUniform2fv));
-        if (thread_param_new)
+        EVGL_Thread_Command_glUniform2fv *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_Thread_Command_glUniform2fv));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->location = location;
-   thread_param->count = count;
-   thread_param->value = value;
+   thread_data->location = location;
+   thread_data->count = count;
+   thread_data->value = value;
 
-   thread_param->value_copied = NULL;
+   thread_data->value_copied = NULL;
    if (thread_mode == EVAS_GL_THREAD_MODE_FINISH)
      goto finish;
 
@@ -2443,10 +2447,10 @@ glUniform2fv_evgl_thread_cmd(GLint location, GLsizei count, const GLfloat *value
              goto finish;
           }
         /* 2. malloc & copy */
-        thread_param->value_copied = eina_mempool_malloc(_mp_uniform, copy_size);
-        if (thread_param->value_copied)
+        thread_data->value_copied = eina_mempool_malloc(_mp_uniform, copy_size);
+        if (thread_data->value_copied)
           {
-             memcpy(thread_param->value_copied, value, copy_size);
+             memcpy(thread_data->value_copied, value, copy_size);
           }
         else
           {
@@ -2454,20 +2458,20 @@ glUniform2fv_evgl_thread_cmd(GLint location, GLsizei count, const GLfloat *value
              goto finish;
           }
         /* 3. replace */
-        thread_param->value = (const GLfloat  *)thread_param->value_copied;
+        thread_data->value = (const GLfloat  *)thread_data->value_copied;
      }
    /* end of copy variable */
 
 finish:
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glUniform2fv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glUniform2iv(GLint location, GLsizei count, const GLint *value);
+ * void
+ * glUniform2iv(GLint location, GLsizei count, const GLint *value);
  */
 
 typedef struct
@@ -2483,19 +2487,19 @@ typedef struct
 static void
 _evgl_thread_glUniform2iv(void *data)
 {
-   EVGL_Thread_Command_glUniform2iv *thread_param =
+   EVGL_Thread_Command_glUniform2iv *thread_data =
       (EVGL_Thread_Command_glUniform2iv *)data;
 
-   glUniform2iv(thread_param->location,
-                thread_param->count,
-                thread_param->value);
+   glUniform2iv(thread_data->location,
+                thread_data->count,
+                thread_data->value);
 
 
-   if (thread_param->value_copied)
-     eina_mempool_free(_mp_uniform, thread_param->value_copied);
+   if (thread_data->value_copied)
+     eina_mempool_free(_mp_uniform, thread_data->value_copied);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -2509,30 +2513,30 @@ glUniform2iv_evgl_thread_cmd(GLint location, GLsizei count, const GLint *value)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glUniform2iv thread_param_local;
-   EVGL_Thread_Command_glUniform2iv *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glUniform2iv thread_data_local;
+   EVGL_Thread_Command_glUniform2iv *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_Thread_Command_glUniform2iv *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_Thread_Command_glUniform2iv));
-        if (thread_param_new)
+        EVGL_Thread_Command_glUniform2iv *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_Thread_Command_glUniform2iv));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->location = location;
-   thread_param->count = count;
-   thread_param->value = value;
+   thread_data->location = location;
+   thread_data->count = count;
+   thread_data->value = value;
 
-   thread_param->value_copied = NULL;
+   thread_data->value_copied = NULL;
    if (thread_mode == EVAS_GL_THREAD_MODE_FINISH)
      goto finish;
 
@@ -2547,10 +2551,10 @@ glUniform2iv_evgl_thread_cmd(GLint location, GLsizei count, const GLint *value)
              goto finish;
           }
         /* 2. malloc & copy */
-        thread_param->value_copied = eina_mempool_malloc(_mp_uniform, copy_size);
-        if (thread_param->value_copied)
+        thread_data->value_copied = eina_mempool_malloc(_mp_uniform, copy_size);
+        if (thread_data->value_copied)
           {
-             memcpy(thread_param->value_copied, value, copy_size);
+             memcpy(thread_data->value_copied, value, copy_size);
           }
         else
           {
@@ -2558,20 +2562,20 @@ glUniform2iv_evgl_thread_cmd(GLint location, GLsizei count, const GLint *value)
              goto finish;
           }
         /* 3. replace */
-        thread_param->value = (const GLint  *)thread_param->value_copied;
+        thread_data->value = (const GLint  *)thread_data->value_copied;
      }
    /* end of copy variable */
 
 finish:
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glUniform2iv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glUniform3fv(GLint location, GLsizei count, const GLfloat *value);
+ * void
+ * glUniform3fv(GLint location, GLsizei count, const GLfloat *value);
  */
 
 typedef struct
@@ -2587,19 +2591,19 @@ typedef struct
 static void
 _evgl_thread_glUniform3fv(void *data)
 {
-   EVGL_Thread_Command_glUniform3fv *thread_param =
+   EVGL_Thread_Command_glUniform3fv *thread_data =
       (EVGL_Thread_Command_glUniform3fv *)data;
 
-   glUniform3fv(thread_param->location,
-                thread_param->count,
-                thread_param->value);
+   glUniform3fv(thread_data->location,
+                thread_data->count,
+                thread_data->value);
 
 
-   if (thread_param->value_copied)
-     eina_mempool_free(_mp_uniform, thread_param->value_copied);
+   if (thread_data->value_copied)
+     eina_mempool_free(_mp_uniform, thread_data->value_copied);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -2613,30 +2617,30 @@ glUniform3fv_evgl_thread_cmd(GLint location, GLsizei count, const GLfloat *value
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glUniform3fv thread_param_local;
-   EVGL_Thread_Command_glUniform3fv *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glUniform3fv thread_data_local;
+   EVGL_Thread_Command_glUniform3fv *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_Thread_Command_glUniform3fv *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_Thread_Command_glUniform3fv));
-        if (thread_param_new)
+        EVGL_Thread_Command_glUniform3fv *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_Thread_Command_glUniform3fv));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->location = location;
-   thread_param->count = count;
-   thread_param->value = value;
+   thread_data->location = location;
+   thread_data->count = count;
+   thread_data->value = value;
 
-   thread_param->value_copied = NULL;
+   thread_data->value_copied = NULL;
    if (thread_mode == EVAS_GL_THREAD_MODE_FINISH)
      goto finish;
 
@@ -2651,10 +2655,10 @@ glUniform3fv_evgl_thread_cmd(GLint location, GLsizei count, const GLfloat *value
              goto finish;
           }
         /* 2. malloc & copy */
-        thread_param->value_copied = eina_mempool_malloc(_mp_uniform, copy_size);
-        if (thread_param->value_copied)
+        thread_data->value_copied = eina_mempool_malloc(_mp_uniform, copy_size);
+        if (thread_data->value_copied)
           {
-             memcpy(thread_param->value_copied, value, copy_size);
+             memcpy(thread_data->value_copied, value, copy_size);
           }
         else
           {
@@ -2662,20 +2666,20 @@ glUniform3fv_evgl_thread_cmd(GLint location, GLsizei count, const GLfloat *value
              goto finish;
           }
         /* 3. replace */
-        thread_param->value = (const GLfloat  *)thread_param->value_copied;
+        thread_data->value = (const GLfloat  *)thread_data->value_copied;
      }
    /* end of copy variable */
 
 finish:
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glUniform3fv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glUniform3iv(GLint location, GLsizei count, const GLint *value);
+ * void
+ * glUniform3iv(GLint location, GLsizei count, const GLint *value);
  */
 
 typedef struct
@@ -2691,19 +2695,19 @@ typedef struct
 static void
 _evgl_thread_glUniform3iv(void *data)
 {
-   EVGL_Thread_Command_glUniform3iv *thread_param =
+   EVGL_Thread_Command_glUniform3iv *thread_data =
       (EVGL_Thread_Command_glUniform3iv *)data;
 
-   glUniform3iv(thread_param->location,
-                thread_param->count,
-                thread_param->value);
+   glUniform3iv(thread_data->location,
+                thread_data->count,
+                thread_data->value);
 
 
-   if (thread_param->value_copied)
-     eina_mempool_free(_mp_uniform, thread_param->value_copied);
+   if (thread_data->value_copied)
+     eina_mempool_free(_mp_uniform, thread_data->value_copied);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -2717,30 +2721,30 @@ glUniform3iv_evgl_thread_cmd(GLint location, GLsizei count, const GLint *value)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glUniform3iv thread_param_local;
-   EVGL_Thread_Command_glUniform3iv *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glUniform3iv thread_data_local;
+   EVGL_Thread_Command_glUniform3iv *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_Thread_Command_glUniform3iv *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_Thread_Command_glUniform3iv));
-        if (thread_param_new)
+        EVGL_Thread_Command_glUniform3iv *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_Thread_Command_glUniform3iv));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->location = location;
-   thread_param->count = count;
-   thread_param->value = value;
+   thread_data->location = location;
+   thread_data->count = count;
+   thread_data->value = value;
 
-   thread_param->value_copied = NULL;
+   thread_data->value_copied = NULL;
    if (thread_mode == EVAS_GL_THREAD_MODE_FINISH)
      goto finish;
 
@@ -2755,10 +2759,10 @@ glUniform3iv_evgl_thread_cmd(GLint location, GLsizei count, const GLint *value)
              goto finish;
           }
         /* 2. malloc & copy */
-        thread_param->value_copied = eina_mempool_malloc(_mp_uniform, copy_size);
-        if (thread_param->value_copied)
+        thread_data->value_copied = eina_mempool_malloc(_mp_uniform, copy_size);
+        if (thread_data->value_copied)
           {
-             memcpy(thread_param->value_copied, value, copy_size);
+             memcpy(thread_data->value_copied, value, copy_size);
           }
         else
           {
@@ -2766,20 +2770,20 @@ glUniform3iv_evgl_thread_cmd(GLint location, GLsizei count, const GLint *value)
              goto finish;
           }
         /* 3. replace */
-        thread_param->value = (const GLint  *)thread_param->value_copied;
+        thread_data->value = (const GLint  *)thread_data->value_copied;
      }
    /* end of copy variable */
 
 finish:
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glUniform3iv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glUniform4fv(GLint location, GLsizei count, const GLfloat *value);
+ * void
+ * glUniform4fv(GLint location, GLsizei count, const GLfloat *value);
  */
 
 typedef struct
@@ -2795,19 +2799,19 @@ typedef struct
 static void
 _evgl_thread_glUniform4fv(void *data)
 {
-   EVGL_Thread_Command_glUniform4fv *thread_param =
+   EVGL_Thread_Command_glUniform4fv *thread_data =
       (EVGL_Thread_Command_glUniform4fv *)data;
 
-   glUniform4fv(thread_param->location,
-                thread_param->count,
-                thread_param->value);
+   glUniform4fv(thread_data->location,
+                thread_data->count,
+                thread_data->value);
 
 
-   if (thread_param->value_copied)
-     eina_mempool_free(_mp_uniform, thread_param->value_copied);
+   if (thread_data->value_copied)
+     eina_mempool_free(_mp_uniform, thread_data->value_copied);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -2821,30 +2825,30 @@ glUniform4fv_evgl_thread_cmd(GLint location, GLsizei count, const GLfloat *value
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glUniform4fv thread_param_local;
-   EVGL_Thread_Command_glUniform4fv *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glUniform4fv thread_data_local;
+   EVGL_Thread_Command_glUniform4fv *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_Thread_Command_glUniform4fv *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_Thread_Command_glUniform4fv));
-        if (thread_param_new)
+        EVGL_Thread_Command_glUniform4fv *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_Thread_Command_glUniform4fv));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->location = location;
-   thread_param->count = count;
-   thread_param->value = value;
+   thread_data->location = location;
+   thread_data->count = count;
+   thread_data->value = value;
 
-   thread_param->value_copied = NULL;
+   thread_data->value_copied = NULL;
    if (thread_mode == EVAS_GL_THREAD_MODE_FINISH)
      goto finish;
 
@@ -2859,10 +2863,10 @@ glUniform4fv_evgl_thread_cmd(GLint location, GLsizei count, const GLfloat *value
              goto finish;
           }
         /* 2. malloc & copy */
-        thread_param->value_copied = eina_mempool_malloc(_mp_uniform, copy_size);
-        if (thread_param->value_copied)
+        thread_data->value_copied = eina_mempool_malloc(_mp_uniform, copy_size);
+        if (thread_data->value_copied)
           {
-             memcpy(thread_param->value_copied, value, copy_size);
+             memcpy(thread_data->value_copied, value, copy_size);
           }
         else
           {
@@ -2870,20 +2874,20 @@ glUniform4fv_evgl_thread_cmd(GLint location, GLsizei count, const GLfloat *value
              goto finish;
           }
         /* 3. replace */
-        thread_param->value = (const GLfloat  *)thread_param->value_copied;
+        thread_data->value = (const GLfloat  *)thread_data->value_copied;
      }
    /* end of copy variable */
 
 finish:
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glUniform4fv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glUniform4iv(GLint location, GLsizei count, const GLint *value);
+ * void
+ * glUniform4iv(GLint location, GLsizei count, const GLint *value);
  */
 
 typedef struct
@@ -2899,19 +2903,19 @@ typedef struct
 static void
 _evgl_thread_glUniform4iv(void *data)
 {
-   EVGL_Thread_Command_glUniform4iv *thread_param =
+   EVGL_Thread_Command_glUniform4iv *thread_data =
       (EVGL_Thread_Command_glUniform4iv *)data;
 
-   glUniform4iv(thread_param->location,
-                thread_param->count,
-                thread_param->value);
+   glUniform4iv(thread_data->location,
+                thread_data->count,
+                thread_data->value);
 
 
-   if (thread_param->value_copied)
-     eina_mempool_free(_mp_uniform, thread_param->value_copied);
+   if (thread_data->value_copied)
+     eina_mempool_free(_mp_uniform, thread_data->value_copied);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -2925,30 +2929,30 @@ glUniform4iv_evgl_thread_cmd(GLint location, GLsizei count, const GLint *value)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glUniform4iv thread_param_local;
-   EVGL_Thread_Command_glUniform4iv *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glUniform4iv thread_data_local;
+   EVGL_Thread_Command_glUniform4iv *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_Thread_Command_glUniform4iv *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_Thread_Command_glUniform4iv));
-        if (thread_param_new)
+        EVGL_Thread_Command_glUniform4iv *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_Thread_Command_glUniform4iv));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->location = location;
-   thread_param->count = count;
-   thread_param->value = value;
+   thread_data->location = location;
+   thread_data->count = count;
+   thread_data->value = value;
 
-   thread_param->value_copied = NULL;
+   thread_data->value_copied = NULL;
    if (thread_mode == EVAS_GL_THREAD_MODE_FINISH)
      goto finish;
 
@@ -2963,10 +2967,10 @@ glUniform4iv_evgl_thread_cmd(GLint location, GLsizei count, const GLint *value)
              goto finish;
           }
         /* 2. malloc & copy */
-        thread_param->value_copied = eina_mempool_malloc(_mp_uniform, copy_size);
-        if (thread_param->value_copied)
+        thread_data->value_copied = eina_mempool_malloc(_mp_uniform, copy_size);
+        if (thread_data->value_copied)
           {
-             memcpy(thread_param->value_copied, value, copy_size);
+             memcpy(thread_data->value_copied, value, copy_size);
           }
         else
           {
@@ -2974,20 +2978,20 @@ glUniform4iv_evgl_thread_cmd(GLint location, GLsizei count, const GLint *value)
              goto finish;
           }
         /* 3. replace */
-        thread_param->value = (const GLint  *)thread_param->value_copied;
+        thread_data->value = (const GLint  *)thread_data->value_copied;
      }
    /* end of copy variable */
 
 finish:
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glUniform4iv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+ * void
+ * glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
  */
 
 typedef struct
@@ -3004,20 +3008,20 @@ typedef struct
 static void
 _evgl_thread_glUniformMatrix2fv(void *data)
 {
-   EVGL_Thread_Command_glUniformMatrix2fv *thread_param =
+   EVGL_Thread_Command_glUniformMatrix2fv *thread_data =
       (EVGL_Thread_Command_glUniformMatrix2fv *)data;
 
-   glUniformMatrix2fv(thread_param->location,
-                      thread_param->count,
-                      thread_param->transpose,
-                      thread_param->value);
+   glUniformMatrix2fv(thread_data->location,
+                      thread_data->count,
+                      thread_data->transpose,
+                      thread_data->value);
 
 
-   if (thread_param->value_copied)
-     eina_mempool_free(_mp_uniform, thread_param->value_copied);
+   if (thread_data->value_copied)
+     eina_mempool_free(_mp_uniform, thread_data->value_copied);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -3031,31 +3035,31 @@ glUniformMatrix2fv_evgl_thread_cmd(GLint location, GLsizei count, GLboolean tran
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glUniformMatrix2fv thread_param_local;
-   EVGL_Thread_Command_glUniformMatrix2fv *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glUniformMatrix2fv thread_data_local;
+   EVGL_Thread_Command_glUniformMatrix2fv *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_Thread_Command_glUniformMatrix2fv *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_Thread_Command_glUniformMatrix2fv));
-        if (thread_param_new)
+        EVGL_Thread_Command_glUniformMatrix2fv *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_Thread_Command_glUniformMatrix2fv));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->location = location;
-   thread_param->count = count;
-   thread_param->transpose = transpose;
-   thread_param->value = value;
+   thread_data->location = location;
+   thread_data->count = count;
+   thread_data->transpose = transpose;
+   thread_data->value = value;
 
-   thread_param->value_copied = NULL;
+   thread_data->value_copied = NULL;
    if (thread_mode == EVAS_GL_THREAD_MODE_FINISH)
      goto finish;
 
@@ -3070,10 +3074,10 @@ glUniformMatrix2fv_evgl_thread_cmd(GLint location, GLsizei count, GLboolean tran
              goto finish;
           }
         /* 2. malloc & copy */
-        thread_param->value_copied = eina_mempool_malloc(_mp_uniform, copy_size);
-        if (thread_param->value_copied)
+        thread_data->value_copied = eina_mempool_malloc(_mp_uniform, copy_size);
+        if (thread_data->value_copied)
           {
-             memcpy(thread_param->value_copied, value, copy_size);
+             memcpy(thread_data->value_copied, value, copy_size);
           }
         else
           {
@@ -3081,20 +3085,20 @@ glUniformMatrix2fv_evgl_thread_cmd(GLint location, GLsizei count, GLboolean tran
              goto finish;
           }
         /* 3. replace */
-        thread_param->value = (const GLfloat  *)thread_param->value_copied;
+        thread_data->value = (const GLfloat  *)thread_data->value_copied;
      }
    /* end of copy variable */
 
 finish:
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glUniformMatrix2fv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+ * void
+ * glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
  */
 
 typedef struct
@@ -3111,20 +3115,20 @@ typedef struct
 static void
 _evgl_thread_glUniformMatrix3fv(void *data)
 {
-   EVGL_Thread_Command_glUniformMatrix3fv *thread_param =
+   EVGL_Thread_Command_glUniformMatrix3fv *thread_data =
       (EVGL_Thread_Command_glUniformMatrix3fv *)data;
 
-   glUniformMatrix3fv(thread_param->location,
-                      thread_param->count,
-                      thread_param->transpose,
-                      thread_param->value);
+   glUniformMatrix3fv(thread_data->location,
+                      thread_data->count,
+                      thread_data->transpose,
+                      thread_data->value);
 
 
-   if (thread_param->value_copied)
-     eina_mempool_free(_mp_uniform, thread_param->value_copied);
+   if (thread_data->value_copied)
+     eina_mempool_free(_mp_uniform, thread_data->value_copied);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -3138,31 +3142,31 @@ glUniformMatrix3fv_evgl_thread_cmd(GLint location, GLsizei count, GLboolean tran
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glUniformMatrix3fv thread_param_local;
-   EVGL_Thread_Command_glUniformMatrix3fv *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glUniformMatrix3fv thread_data_local;
+   EVGL_Thread_Command_glUniformMatrix3fv *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_Thread_Command_glUniformMatrix3fv *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_Thread_Command_glUniformMatrix3fv));
-        if (thread_param_new)
+        EVGL_Thread_Command_glUniformMatrix3fv *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_Thread_Command_glUniformMatrix3fv));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->location = location;
-   thread_param->count = count;
-   thread_param->transpose = transpose;
-   thread_param->value = value;
+   thread_data->location = location;
+   thread_data->count = count;
+   thread_data->transpose = transpose;
+   thread_data->value = value;
 
-   thread_param->value_copied = NULL;
+   thread_data->value_copied = NULL;
    if (thread_mode == EVAS_GL_THREAD_MODE_FINISH)
      goto finish;
 
@@ -3177,10 +3181,10 @@ glUniformMatrix3fv_evgl_thread_cmd(GLint location, GLsizei count, GLboolean tran
              goto finish;
           }
         /* 2. malloc & copy */
-        thread_param->value_copied = eina_mempool_malloc(_mp_uniform, copy_size);
-        if (thread_param->value_copied)
+        thread_data->value_copied = eina_mempool_malloc(_mp_uniform, copy_size);
+        if (thread_data->value_copied)
           {
-             memcpy(thread_param->value_copied, value, copy_size);
+             memcpy(thread_data->value_copied, value, copy_size);
           }
         else
           {
@@ -3188,20 +3192,20 @@ glUniformMatrix3fv_evgl_thread_cmd(GLint location, GLsizei count, GLboolean tran
              goto finish;
           }
         /* 3. replace */
-        thread_param->value = (const GLfloat  *)thread_param->value_copied;
+        thread_data->value = (const GLfloat  *)thread_data->value_copied;
      }
    /* end of copy variable */
 
 finish:
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glUniformMatrix3fv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+ * void
+ * glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
  */
 
 typedef struct
@@ -3218,20 +3222,20 @@ typedef struct
 static void
 _evgl_thread_glUniformMatrix4fv(void *data)
 {
-   EVGL_Thread_Command_glUniformMatrix4fv *thread_param =
+   EVGL_Thread_Command_glUniformMatrix4fv *thread_data =
       (EVGL_Thread_Command_glUniformMatrix4fv *)data;
 
-   glUniformMatrix4fv(thread_param->location,
-                      thread_param->count,
-                      thread_param->transpose,
-                      thread_param->value);
+   glUniformMatrix4fv(thread_data->location,
+                      thread_data->count,
+                      thread_data->transpose,
+                      thread_data->value);
 
 
-   if (thread_param->value_copied)
-     eina_mempool_free(_mp_uniform, thread_param->value_copied);
+   if (thread_data->value_copied)
+     eina_mempool_free(_mp_uniform, thread_data->value_copied);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -3245,31 +3249,31 @@ glUniformMatrix4fv_evgl_thread_cmd(GLint location, GLsizei count, GLboolean tran
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glUniformMatrix4fv thread_param_local;
-   EVGL_Thread_Command_glUniformMatrix4fv *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glUniformMatrix4fv thread_data_local;
+   EVGL_Thread_Command_glUniformMatrix4fv *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_Thread_Command_glUniformMatrix4fv *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_Thread_Command_glUniformMatrix4fv));
-        if (thread_param_new)
+        EVGL_Thread_Command_glUniformMatrix4fv *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_Thread_Command_glUniformMatrix4fv));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->location = location;
-   thread_param->count = count;
-   thread_param->transpose = transpose;
-   thread_param->value = value;
+   thread_data->location = location;
+   thread_data->count = count;
+   thread_data->transpose = transpose;
+   thread_data->value = value;
 
-   thread_param->value_copied = NULL;
+   thread_data->value_copied = NULL;
    if (thread_mode == EVAS_GL_THREAD_MODE_FINISH)
      goto finish;
 
@@ -3284,10 +3288,10 @@ glUniformMatrix4fv_evgl_thread_cmd(GLint location, GLsizei count, GLboolean tran
              goto finish;
           }
         /* 2. malloc & copy */
-        thread_param->value_copied = eina_mempool_malloc(_mp_uniform, copy_size);
-        if (thread_param->value_copied)
+        thread_data->value_copied = eina_mempool_malloc(_mp_uniform, copy_size);
+        if (thread_data->value_copied)
           {
-             memcpy(thread_param->value_copied, value, copy_size);
+             memcpy(thread_data->value_copied, value, copy_size);
           }
         else
           {
@@ -3295,20 +3299,20 @@ glUniformMatrix4fv_evgl_thread_cmd(GLint location, GLsizei count, GLboolean tran
              goto finish;
           }
         /* 3. replace */
-        thread_param->value = (const GLfloat  *)thread_param->value_copied;
+        thread_data->value = (const GLfloat  *)thread_data->value_copied;
      }
    /* end of copy variable */
 
 finish:
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glUniformMatrix4fv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glViewport(GLint x, GLint y, GLsizei width, GLsizei height);
+ * void
+ * glViewport(GLint x, GLint y, GLsizei width, GLsizei height);
  */
 
 typedef struct
@@ -3324,16 +3328,16 @@ typedef struct
 static void
 _evgl_thread_glViewport(void *data)
 {
-   EVGL_Thread_Command_glViewport *thread_param =
+   EVGL_Thread_Command_glViewport *thread_data =
       (EVGL_Thread_Command_glViewport *)data;
 
-   glViewport(thread_param->x,
-              thread_param->y,
-              thread_param->width,
-              thread_param->height);
+   glViewport(thread_data->x,
+              thread_data->y,
+              thread_data->width,
+              thread_data->height);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -3347,39 +3351,39 @@ glViewport_evgl_thread_cmd(GLint x, GLint y, GLsizei width, GLsizei height)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glViewport thread_param_local;
-   EVGL_Thread_Command_glViewport *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glViewport thread_data_local;
+   EVGL_Thread_Command_glViewport *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_Thread_Command_glViewport *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_Thread_Command_glViewport));
-        if (thread_param_new)
+        EVGL_Thread_Command_glViewport *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_Thread_Command_glViewport));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->x = x;
-   thread_param->y = y;
-   thread_param->width = width;
-   thread_param->height = height;
+   thread_data->x = x;
+   thread_data->y = y;
+   thread_data->width = width;
+   thread_data->height = height;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glViewport,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glEnable(GLenum cap);
+ * void
+ * glEnable(GLenum cap);
  */
 
 typedef struct
@@ -3392,13 +3396,13 @@ typedef struct
 static void
 _evgl_thread_glEnable(void *data)
 {
-   EVGL_Thread_Command_glEnable *thread_param =
+   EVGL_Thread_Command_glEnable *thread_data =
       (EVGL_Thread_Command_glEnable *)data;
 
-   glEnable(thread_param->cap);
+   glEnable(thread_data->cap);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -3412,36 +3416,36 @@ glEnable_evgl_thread_cmd(GLenum cap)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glEnable thread_param_local;
-   EVGL_Thread_Command_glEnable *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glEnable thread_data_local;
+   EVGL_Thread_Command_glEnable *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_Thread_Command_glEnable *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_Thread_Command_glEnable));
-        if (thread_param_new)
+        EVGL_Thread_Command_glEnable *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_Thread_Command_glEnable));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->cap = cap;
+   thread_data->cap = cap;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glEnable,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glDisable(GLenum cap);
+ * void
+ * glDisable(GLenum cap);
  */
 
 typedef struct
@@ -3454,13 +3458,13 @@ typedef struct
 static void
 _evgl_thread_glDisable(void *data)
 {
-   EVGL_Thread_Command_glDisable *thread_param =
+   EVGL_Thread_Command_glDisable *thread_data =
       (EVGL_Thread_Command_glDisable *)data;
 
-   glDisable(thread_param->cap);
+   glDisable(thread_data->cap);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -3474,36 +3478,36 @@ glDisable_evgl_thread_cmd(GLenum cap)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glDisable thread_param_local;
-   EVGL_Thread_Command_glDisable *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glDisable thread_data_local;
+   EVGL_Thread_Command_glDisable *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_Thread_Command_glDisable *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_Thread_Command_glDisable));
-        if (thread_param_new)
+        EVGL_Thread_Command_glDisable *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_Thread_Command_glDisable));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->cap = cap;
+   thread_data->cap = cap;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glDisable,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glLineWidth(GLfloat width);
+ * void
+ * glLineWidth(GLfloat width);
  */
 
 typedef struct
@@ -3516,13 +3520,13 @@ typedef struct
 static void
 _evgl_thread_glLineWidth(void *data)
 {
-   EVGL_Thread_Command_glLineWidth *thread_param =
+   EVGL_Thread_Command_glLineWidth *thread_data =
       (EVGL_Thread_Command_glLineWidth *)data;
 
-   glLineWidth(thread_param->width);
+   glLineWidth(thread_data->width);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -3536,36 +3540,36 @@ glLineWidth_evgl_thread_cmd(GLfloat width)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glLineWidth thread_param_local;
-   EVGL_Thread_Command_glLineWidth *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glLineWidth thread_data_local;
+   EVGL_Thread_Command_glLineWidth *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_Thread_Command_glLineWidth *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_Thread_Command_glLineWidth));
-        if (thread_param_new)
+        EVGL_Thread_Command_glLineWidth *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_Thread_Command_glLineWidth));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->width = width;
+   thread_data->width = width;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glLineWidth,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glPolygonOffset(GLfloat factor, GLfloat units);
+ * void
+ * glPolygonOffset(GLfloat factor, GLfloat units);
  */
 
 typedef struct
@@ -3579,14 +3583,14 @@ typedef struct
 static void
 _evgl_thread_glPolygonOffset(void *data)
 {
-   EVGL_Thread_Command_glPolygonOffset *thread_param =
+   EVGL_Thread_Command_glPolygonOffset *thread_data =
       (EVGL_Thread_Command_glPolygonOffset *)data;
 
-   glPolygonOffset(thread_param->factor,
-                   thread_param->units);
+   glPolygonOffset(thread_data->factor,
+                   thread_data->units);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -3600,37 +3604,37 @@ glPolygonOffset_evgl_thread_cmd(GLfloat factor, GLfloat units)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glPolygonOffset thread_param_local;
-   EVGL_Thread_Command_glPolygonOffset *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glPolygonOffset thread_data_local;
+   EVGL_Thread_Command_glPolygonOffset *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_Thread_Command_glPolygonOffset *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_Thread_Command_glPolygonOffset));
-        if (thread_param_new)
+        EVGL_Thread_Command_glPolygonOffset *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_Thread_Command_glPolygonOffset));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->factor = factor;
-   thread_param->units = units;
+   thread_data->factor = factor;
+   thread_data->units = units;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glPolygonOffset,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glPixelStorei(GLenum pname, GLint param);
+ * void
+ * glPixelStorei(GLenum pname, GLint param);
  */
 
 typedef struct
@@ -3644,14 +3648,14 @@ typedef struct
 static void
 _evgl_thread_glPixelStorei(void *data)
 {
-   EVGL_Thread_Command_glPixelStorei *thread_param =
+   EVGL_Thread_Command_glPixelStorei *thread_data =
       (EVGL_Thread_Command_glPixelStorei *)data;
 
-   glPixelStorei(thread_param->pname,
-                 thread_param->param);
+   glPixelStorei(thread_data->pname,
+                 thread_data->param);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -3665,37 +3669,37 @@ glPixelStorei_evgl_thread_cmd(GLenum pname, GLint param)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glPixelStorei thread_param_local;
-   EVGL_Thread_Command_glPixelStorei *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glPixelStorei thread_data_local;
+   EVGL_Thread_Command_glPixelStorei *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_Thread_Command_glPixelStorei *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_Thread_Command_glPixelStorei));
-        if (thread_param_new)
+        EVGL_Thread_Command_glPixelStorei *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_Thread_Command_glPixelStorei));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->pname = pname;
-   thread_param->param = param;
+   thread_data->pname = pname;
+   thread_data->param = param;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glPixelStorei,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glActiveTexture(GLenum texture);
+ * void
+ * glActiveTexture(GLenum texture);
  */
 
 typedef struct
@@ -3708,13 +3712,13 @@ typedef struct
 static void
 _evgl_thread_glActiveTexture(void *data)
 {
-   EVGL_Thread_Command_glActiveTexture *thread_param =
+   EVGL_Thread_Command_glActiveTexture *thread_data =
       (EVGL_Thread_Command_glActiveTexture *)data;
 
-   glActiveTexture(thread_param->texture);
+   glActiveTexture(thread_data->texture);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -3728,36 +3732,36 @@ glActiveTexture_evgl_thread_cmd(GLenum texture)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glActiveTexture thread_param_local;
-   EVGL_Thread_Command_glActiveTexture *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glActiveTexture thread_data_local;
+   EVGL_Thread_Command_glActiveTexture *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_Thread_Command_glActiveTexture *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_Thread_Command_glActiveTexture));
-        if (thread_param_new)
+        EVGL_Thread_Command_glActiveTexture *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_Thread_Command_glActiveTexture));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->texture = texture;
+   thread_data->texture = texture;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glActiveTexture,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGenTextures(GLsizei n, GLuint *textures);
+ * void
+ * glGenTextures(GLsizei n, GLuint *textures);
  */
 
 typedef struct
@@ -3770,11 +3774,11 @@ typedef struct
 static void
 _evgl_thread_glGenTextures(void *data)
 {
-   EVGL_Thread_Command_glGenTextures *thread_param =
+   EVGL_Thread_Command_glGenTextures *thread_data =
       (EVGL_Thread_Command_glGenTextures *)data;
 
-   glGenTextures(thread_param->n,
-                 thread_param->textures);
+   glGenTextures(thread_data->n,
+                 thread_data->textures);
 
 }
 
@@ -3789,21 +3793,21 @@ glGenTextures_evgl_thread_cmd(GLsizei n, GLuint *textures)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glGenTextures thread_param_local;
-   EVGL_Thread_Command_glGenTextures *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glGenTextures thread_data_local;
+   EVGL_Thread_Command_glGenTextures *thread_data = &thread_data_local;
 
-   thread_param->n = n;
-   thread_param->textures = textures;
+   thread_data->n = n;
+   thread_data->textures = textures;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glGenTextures,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glBindTexture(GLenum target, GLuint texture);
+ * void
+ * glBindTexture(GLenum target, GLuint texture);
  */
 
 typedef struct
@@ -3817,14 +3821,14 @@ typedef struct
 static void
 _evgl_thread_glBindTexture(void *data)
 {
-   EVGL_Thread_Command_glBindTexture *thread_param =
+   EVGL_Thread_Command_glBindTexture *thread_data =
       (EVGL_Thread_Command_glBindTexture *)data;
 
-   glBindTexture(thread_param->target,
-                 thread_param->texture);
+   glBindTexture(thread_data->target,
+                 thread_data->texture);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -3838,37 +3842,37 @@ glBindTexture_evgl_thread_cmd(GLenum target, GLuint texture)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glBindTexture thread_param_local;
-   EVGL_Thread_Command_glBindTexture *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glBindTexture thread_data_local;
+   EVGL_Thread_Command_glBindTexture *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_Thread_Command_glBindTexture *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_Thread_Command_glBindTexture));
-        if (thread_param_new)
+        EVGL_Thread_Command_glBindTexture *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_Thread_Command_glBindTexture));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->target = target;
-   thread_param->texture = texture;
+   thread_data->target = target;
+   thread_data->texture = texture;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glBindTexture,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glDeleteTextures(GLsizei n, const GLuint *textures);
+ * void
+ * glDeleteTextures(GLsizei n, const GLuint *textures);
  */
 
 typedef struct
@@ -3883,18 +3887,18 @@ typedef struct
 static void
 _evgl_thread_glDeleteTextures(void *data)
 {
-   EVGL_Thread_Command_glDeleteTextures *thread_param =
+   EVGL_Thread_Command_glDeleteTextures *thread_data =
       (EVGL_Thread_Command_glDeleteTextures *)data;
 
-   glDeleteTextures(thread_param->n,
-                    thread_param->textures);
+   glDeleteTextures(thread_data->n,
+                    thread_data->textures);
 
 
-   if (thread_param->textures_copied)
-     eina_mempool_free(_mp_delete_object, thread_param->textures_copied);
+   if (thread_data->textures_copied)
+     eina_mempool_free(_mp_delete_object, thread_data->textures_copied);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -3908,29 +3912,29 @@ glDeleteTextures_evgl_thread_cmd(GLsizei n, const GLuint *textures)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glDeleteTextures thread_param_local;
-   EVGL_Thread_Command_glDeleteTextures *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glDeleteTextures thread_data_local;
+   EVGL_Thread_Command_glDeleteTextures *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_Thread_Command_glDeleteTextures *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_Thread_Command_glDeleteTextures));
-        if (thread_param_new)
+        EVGL_Thread_Command_glDeleteTextures *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_Thread_Command_glDeleteTextures));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->n = n;
-   thread_param->textures = textures;
+   thread_data->n = n;
+   thread_data->textures = textures;
 
-   thread_param->textures_copied = NULL;
+   thread_data->textures_copied = NULL;
    if (thread_mode == EVAS_GL_THREAD_MODE_FINISH)
      goto finish;
 
@@ -3945,10 +3949,10 @@ glDeleteTextures_evgl_thread_cmd(GLsizei n, const GLuint *textures)
              goto finish;
           }
         /* 2. malloc & copy */
-        thread_param->textures_copied = eina_mempool_malloc(_mp_delete_object, copy_size);
-        if (thread_param->textures_copied)
+        thread_data->textures_copied = eina_mempool_malloc(_mp_delete_object, copy_size);
+        if (thread_data->textures_copied)
           {
-             memcpy(thread_param->textures_copied, textures, copy_size);
+             memcpy(thread_data->textures_copied, textures, copy_size);
           }
         else
           {
@@ -3956,20 +3960,20 @@ glDeleteTextures_evgl_thread_cmd(GLsizei n, const GLuint *textures)
              goto finish;
           }
         /* 3. replace */
-        thread_param->textures = (const GLuint  *)thread_param->textures_copied;
+        thread_data->textures = (const GLuint  *)thread_data->textures_copied;
      }
    /* end of copy variable */
 
 finish:
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glDeleteTextures,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels);
+ * void
+ * glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels);
  */
 
 typedef struct
@@ -3991,23 +3995,23 @@ typedef struct
 static void
 _evgl_thread_glTexImage2D(void *data)
 {
-   EVGL_Thread_Command_glTexImage2D *thread_param =
+   EVGL_Thread_Command_glTexImage2D *thread_data =
       (EVGL_Thread_Command_glTexImage2D *)data;
 
-   glTexImage2D(thread_param->target,
-                thread_param->level,
-                thread_param->internalformat,
-                thread_param->width,
-                thread_param->height,
-                thread_param->border,
-                thread_param->format,
-                thread_param->type,
-                thread_param->pixels);
+   glTexImage2D(thread_data->target,
+                thread_data->level,
+                thread_data->internalformat,
+                thread_data->width,
+                thread_data->height,
+                thread_data->border,
+                thread_data->format,
+                thread_data->type,
+                thread_data->pixels);
 
    GLTEXIMAGE2D_COPY_VARIABLE_FREE; /* TODO */
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -4021,34 +4025,34 @@ glTexImage2D_evgl_thread_cmd(GLenum target, GLint level, GLint internalformat, G
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glTexImage2D thread_param_local;
-   EVGL_Thread_Command_glTexImage2D *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glTexImage2D thread_data_local;
+   EVGL_Thread_Command_glTexImage2D *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_Thread_Command_glTexImage2D *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_Thread_Command_glTexImage2D));
-        if (thread_param_new)
+        EVGL_Thread_Command_glTexImage2D *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_Thread_Command_glTexImage2D));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->target = target;
-   thread_param->level = level;
-   thread_param->internalformat = internalformat;
-   thread_param->width = width;
-   thread_param->height = height;
-   thread_param->border = border;
-   thread_param->format = format;
-   thread_param->type = type;
-   thread_param->pixels = pixels;
+   thread_data->target = target;
+   thread_data->level = level;
+   thread_data->internalformat = internalformat;
+   thread_data->width = width;
+   thread_data->height = height;
+   thread_data->border = border;
+   thread_data->format = format;
+   thread_data->type = type;
+   thread_data->pixels = pixels;
 
    GLTEXIMAGE2D_COPY_VARIABLE_INIT; /* TODO */
 
@@ -4060,13 +4064,13 @@ glTexImage2D_evgl_thread_cmd(GLenum target, GLint level, GLint internalformat, G
 finish:
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glTexImage2D,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels);
+ * void
+ * glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels);
  */
 
 typedef struct
@@ -4088,23 +4092,23 @@ typedef struct
 static void
 _evgl_thread_glTexSubImage2D(void *data)
 {
-   EVGL_Thread_Command_glTexSubImage2D *thread_param =
+   EVGL_Thread_Command_glTexSubImage2D *thread_data =
       (EVGL_Thread_Command_glTexSubImage2D *)data;
 
-   glTexSubImage2D(thread_param->target,
-                   thread_param->level,
-                   thread_param->xoffset,
-                   thread_param->yoffset,
-                   thread_param->width,
-                   thread_param->height,
-                   thread_param->format,
-                   thread_param->type,
-                   thread_param->pixels);
+   glTexSubImage2D(thread_data->target,
+                   thread_data->level,
+                   thread_data->xoffset,
+                   thread_data->yoffset,
+                   thread_data->width,
+                   thread_data->height,
+                   thread_data->format,
+                   thread_data->type,
+                   thread_data->pixels);
 
    GLTEXSUBIMAGE2D_COPY_VARIABLE_FREE; /* TODO */
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -4118,34 +4122,34 @@ glTexSubImage2D_evgl_thread_cmd(GLenum target, GLint level, GLint xoffset, GLint
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glTexSubImage2D thread_param_local;
-   EVGL_Thread_Command_glTexSubImage2D *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glTexSubImage2D thread_data_local;
+   EVGL_Thread_Command_glTexSubImage2D *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_Thread_Command_glTexSubImage2D *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_Thread_Command_glTexSubImage2D));
-        if (thread_param_new)
+        EVGL_Thread_Command_glTexSubImage2D *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_Thread_Command_glTexSubImage2D));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->target = target;
-   thread_param->level = level;
-   thread_param->xoffset = xoffset;
-   thread_param->yoffset = yoffset;
-   thread_param->width = width;
-   thread_param->height = height;
-   thread_param->format = format;
-   thread_param->type = type;
-   thread_param->pixels = pixels;
+   thread_data->target = target;
+   thread_data->level = level;
+   thread_data->xoffset = xoffset;
+   thread_data->yoffset = yoffset;
+   thread_data->width = width;
+   thread_data->height = height;
+   thread_data->format = format;
+   thread_data->type = type;
+   thread_data->pixels = pixels;
 
    GLTEXSUBIMAGE2D_COPY_VARIABLE_INIT; /* TODO */
 
@@ -4157,13 +4161,13 @@ glTexSubImage2D_evgl_thread_cmd(GLenum target, GLint level, GLint xoffset, GLint
 finish:
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glTexSubImage2D,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void *data);
+ * void
+ * glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void *data);
  */
 
 typedef struct
@@ -4184,22 +4188,22 @@ typedef struct
 static void
 _evgl_thread_glCompressedTexImage2D(void *data)
 {
-   EVGL_Thread_Command_glCompressedTexImage2D *thread_param =
+   EVGL_Thread_Command_glCompressedTexImage2D *thread_data =
       (EVGL_Thread_Command_glCompressedTexImage2D *)data;
 
-   glCompressedTexImage2D(thread_param->target,
-                          thread_param->level,
-                          thread_param->internalformat,
-                          thread_param->width,
-                          thread_param->height,
-                          thread_param->border,
-                          thread_param->imageSize,
-                          thread_param->data);
+   glCompressedTexImage2D(thread_data->target,
+                          thread_data->level,
+                          thread_data->internalformat,
+                          thread_data->width,
+                          thread_data->height,
+                          thread_data->border,
+                          thread_data->imageSize,
+                          thread_data->data);
 
    GLCOMPRESSEDTEXIMAGE2D_COPY_VARIABLE_FREE; /* TODO */
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -4213,33 +4217,33 @@ glCompressedTexImage2D_evgl_thread_cmd(GLenum target, GLint level, GLenum intern
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glCompressedTexImage2D thread_param_local;
-   EVGL_Thread_Command_glCompressedTexImage2D *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glCompressedTexImage2D thread_data_local;
+   EVGL_Thread_Command_glCompressedTexImage2D *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_Thread_Command_glCompressedTexImage2D *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_Thread_Command_glCompressedTexImage2D));
-        if (thread_param_new)
+        EVGL_Thread_Command_glCompressedTexImage2D *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_Thread_Command_glCompressedTexImage2D));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->target = target;
-   thread_param->level = level;
-   thread_param->internalformat = internalformat;
-   thread_param->width = width;
-   thread_param->height = height;
-   thread_param->border = border;
-   thread_param->imageSize = imageSize;
-   thread_param->data = data;
+   thread_data->target = target;
+   thread_data->level = level;
+   thread_data->internalformat = internalformat;
+   thread_data->width = width;
+   thread_data->height = height;
+   thread_data->border = border;
+   thread_data->imageSize = imageSize;
+   thread_data->data = data;
 
    GLCOMPRESSEDTEXIMAGE2D_COPY_VARIABLE_INIT; /* TODO */
 
@@ -4251,13 +4255,13 @@ glCompressedTexImage2D_evgl_thread_cmd(GLenum target, GLint level, GLenum intern
 finish:
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glCompressedTexImage2D,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *data);
+ * void
+ * glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *data);
  */
 
 typedef struct
@@ -4279,23 +4283,23 @@ typedef struct
 static void
 _evgl_thread_glCompressedTexSubImage2D(void *data)
 {
-   EVGL_Thread_Command_glCompressedTexSubImage2D *thread_param =
+   EVGL_Thread_Command_glCompressedTexSubImage2D *thread_data =
       (EVGL_Thread_Command_glCompressedTexSubImage2D *)data;
 
-   glCompressedTexSubImage2D(thread_param->target,
-                             thread_param->level,
-                             thread_param->xoffset,
-                             thread_param->yoffset,
-                             thread_param->width,
-                             thread_param->height,
-                             thread_param->format,
-                             thread_param->imageSize,
-                             thread_param->data);
+   glCompressedTexSubImage2D(thread_data->target,
+                             thread_data->level,
+                             thread_data->xoffset,
+                             thread_data->yoffset,
+                             thread_data->width,
+                             thread_data->height,
+                             thread_data->format,
+                             thread_data->imageSize,
+                             thread_data->data);
 
    GLCOMPRESSEDTEXSUBIMAGE2D_COPY_VARIABLE_FREE; /* TODO */
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -4309,34 +4313,34 @@ glCompressedTexSubImage2D_evgl_thread_cmd(GLenum target, GLint level, GLint xoff
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glCompressedTexSubImage2D thread_param_local;
-   EVGL_Thread_Command_glCompressedTexSubImage2D *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glCompressedTexSubImage2D thread_data_local;
+   EVGL_Thread_Command_glCompressedTexSubImage2D *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_Thread_Command_glCompressedTexSubImage2D *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_Thread_Command_glCompressedTexSubImage2D));
-        if (thread_param_new)
+        EVGL_Thread_Command_glCompressedTexSubImage2D *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_Thread_Command_glCompressedTexSubImage2D));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->target = target;
-   thread_param->level = level;
-   thread_param->xoffset = xoffset;
-   thread_param->yoffset = yoffset;
-   thread_param->width = width;
-   thread_param->height = height;
-   thread_param->format = format;
-   thread_param->imageSize = imageSize;
-   thread_param->data = data;
+   thread_data->target = target;
+   thread_data->level = level;
+   thread_data->xoffset = xoffset;
+   thread_data->yoffset = yoffset;
+   thread_data->width = width;
+   thread_data->height = height;
+   thread_data->format = format;
+   thread_data->imageSize = imageSize;
+   thread_data->data = data;
 
    GLCOMPRESSEDTEXSUBIMAGE2D_COPY_VARIABLE_INIT; /* TODO */
 
@@ -4348,13 +4352,13 @@ glCompressedTexSubImage2D_evgl_thread_cmd(GLenum target, GLint level, GLint xoff
 finish:
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glCompressedTexSubImage2D,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glTexParameterf(GLenum target, GLenum pname, GLfloat param);
+ * void
+ * glTexParameterf(GLenum target, GLenum pname, GLfloat param);
  */
 
 typedef struct
@@ -4369,15 +4373,15 @@ typedef struct
 static void
 _evgl_thread_glTexParameterf(void *data)
 {
-   EVGL_Thread_Command_glTexParameterf *thread_param =
+   EVGL_Thread_Command_glTexParameterf *thread_data =
       (EVGL_Thread_Command_glTexParameterf *)data;
 
-   glTexParameterf(thread_param->target,
-                   thread_param->pname,
-                   thread_param->param);
+   glTexParameterf(thread_data->target,
+                   thread_data->pname,
+                   thread_data->param);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -4391,38 +4395,38 @@ glTexParameterf_evgl_thread_cmd(GLenum target, GLenum pname, GLfloat param)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glTexParameterf thread_param_local;
-   EVGL_Thread_Command_glTexParameterf *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glTexParameterf thread_data_local;
+   EVGL_Thread_Command_glTexParameterf *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_Thread_Command_glTexParameterf *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_Thread_Command_glTexParameterf));
-        if (thread_param_new)
+        EVGL_Thread_Command_glTexParameterf *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_Thread_Command_glTexParameterf));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->target = target;
-   thread_param->pname = pname;
-   thread_param->param = param;
+   thread_data->target = target;
+   thread_data->pname = pname;
+   thread_data->param = param;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glTexParameterf,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params);
+ * void
+ * glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params);
  */
 
 typedef struct
@@ -4438,19 +4442,19 @@ typedef struct
 static void
 _evgl_thread_glTexParameterfv(void *data)
 {
-   EVGL_Thread_Command_glTexParameterfv *thread_param =
+   EVGL_Thread_Command_glTexParameterfv *thread_data =
       (EVGL_Thread_Command_glTexParameterfv *)data;
 
-   glTexParameterfv(thread_param->target,
-                    thread_param->pname,
-                    thread_param->params);
+   glTexParameterfv(thread_data->target,
+                    thread_data->pname,
+                    thread_data->params);
 
 
-   if (thread_param->params_copied)
-     eina_mempool_free(_mp_default, thread_param->params_copied);
+   if (thread_data->params_copied)
+     eina_mempool_free(_mp_default, thread_data->params_copied);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -4464,30 +4468,30 @@ glTexParameterfv_evgl_thread_cmd(GLenum target, GLenum pname, const GLfloat *par
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glTexParameterfv thread_param_local;
-   EVGL_Thread_Command_glTexParameterfv *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glTexParameterfv thread_data_local;
+   EVGL_Thread_Command_glTexParameterfv *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_Thread_Command_glTexParameterfv *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_Thread_Command_glTexParameterfv));
-        if (thread_param_new)
+        EVGL_Thread_Command_glTexParameterfv *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_Thread_Command_glTexParameterfv));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->target = target;
-   thread_param->pname = pname;
-   thread_param->params = params;
+   thread_data->target = target;
+   thread_data->pname = pname;
+   thread_data->params = params;
 
-   thread_param->params_copied = NULL;
+   thread_data->params_copied = NULL;
    if (thread_mode == EVAS_GL_THREAD_MODE_FINISH)
      goto finish;
 
@@ -4502,10 +4506,10 @@ glTexParameterfv_evgl_thread_cmd(GLenum target, GLenum pname, const GLfloat *par
              goto finish;
           }
         /* 2. malloc & copy */
-        thread_param->params_copied = eina_mempool_malloc(_mp_default, copy_size);
-        if (thread_param->params_copied)
+        thread_data->params_copied = eina_mempool_malloc(_mp_default, copy_size);
+        if (thread_data->params_copied)
           {
-             memcpy(thread_param->params_copied, params, copy_size);
+             memcpy(thread_data->params_copied, params, copy_size);
           }
         else
           {
@@ -4513,20 +4517,20 @@ glTexParameterfv_evgl_thread_cmd(GLenum target, GLenum pname, const GLfloat *par
              goto finish;
           }
         /* 3. replace */
-        thread_param->params = (const GLfloat  *)thread_param->params_copied;
+        thread_data->params = (const GLfloat  *)thread_data->params_copied;
      }
    /* end of copy variable */
 
 finish:
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glTexParameterfv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glTexParameteri(GLenum target, GLenum pname, GLint param);
+ * void
+ * glTexParameteri(GLenum target, GLenum pname, GLint param);
  */
 
 typedef struct
@@ -4541,15 +4545,15 @@ typedef struct
 static void
 _evgl_thread_glTexParameteri(void *data)
 {
-   EVGL_Thread_Command_glTexParameteri *thread_param =
+   EVGL_Thread_Command_glTexParameteri *thread_data =
       (EVGL_Thread_Command_glTexParameteri *)data;
 
-   glTexParameteri(thread_param->target,
-                   thread_param->pname,
-                   thread_param->param);
+   glTexParameteri(thread_data->target,
+                   thread_data->pname,
+                   thread_data->param);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -4563,38 +4567,38 @@ glTexParameteri_evgl_thread_cmd(GLenum target, GLenum pname, GLint param)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glTexParameteri thread_param_local;
-   EVGL_Thread_Command_glTexParameteri *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glTexParameteri thread_data_local;
+   EVGL_Thread_Command_glTexParameteri *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_Thread_Command_glTexParameteri *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_Thread_Command_glTexParameteri));
-        if (thread_param_new)
+        EVGL_Thread_Command_glTexParameteri *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_Thread_Command_glTexParameteri));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->target = target;
-   thread_param->pname = pname;
-   thread_param->param = param;
+   thread_data->target = target;
+   thread_data->pname = pname;
+   thread_data->param = param;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glTexParameteri,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glTexParameteriv(GLenum target, GLenum pname, const GLint *params);
+ * void
+ * glTexParameteriv(GLenum target, GLenum pname, const GLint *params);
  */
 
 typedef struct
@@ -4610,19 +4614,19 @@ typedef struct
 static void
 _evgl_thread_glTexParameteriv(void *data)
 {
-   EVGL_Thread_Command_glTexParameteriv *thread_param =
+   EVGL_Thread_Command_glTexParameteriv *thread_data =
       (EVGL_Thread_Command_glTexParameteriv *)data;
 
-   glTexParameteriv(thread_param->target,
-                    thread_param->pname,
-                    thread_param->params);
+   glTexParameteriv(thread_data->target,
+                    thread_data->pname,
+                    thread_data->params);
 
 
-   if (thread_param->params_copied)
-     eina_mempool_free(_mp_default, thread_param->params_copied);
+   if (thread_data->params_copied)
+     eina_mempool_free(_mp_default, thread_data->params_copied);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -4636,30 +4640,30 @@ glTexParameteriv_evgl_thread_cmd(GLenum target, GLenum pname, const GLint *param
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glTexParameteriv thread_param_local;
-   EVGL_Thread_Command_glTexParameteriv *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glTexParameteriv thread_data_local;
+   EVGL_Thread_Command_glTexParameteriv *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_Thread_Command_glTexParameteriv *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_Thread_Command_glTexParameteriv));
-        if (thread_param_new)
+        EVGL_Thread_Command_glTexParameteriv *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_Thread_Command_glTexParameteriv));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->target = target;
-   thread_param->pname = pname;
-   thread_param->params = params;
+   thread_data->target = target;
+   thread_data->pname = pname;
+   thread_data->params = params;
 
-   thread_param->params_copied = NULL;
+   thread_data->params_copied = NULL;
    if (thread_mode == EVAS_GL_THREAD_MODE_FINISH)
      goto finish;
 
@@ -4674,10 +4678,10 @@ glTexParameteriv_evgl_thread_cmd(GLenum target, GLenum pname, const GLint *param
              goto finish;
           }
         /* 2. malloc & copy */
-        thread_param->params_copied = eina_mempool_malloc(_mp_default, copy_size);
-        if (thread_param->params_copied)
+        thread_data->params_copied = eina_mempool_malloc(_mp_default, copy_size);
+        if (thread_data->params_copied)
           {
-             memcpy(thread_param->params_copied, params, copy_size);
+             memcpy(thread_data->params_copied, params, copy_size);
           }
         else
           {
@@ -4685,20 +4689,20 @@ glTexParameteriv_evgl_thread_cmd(GLenum target, GLenum pname, const GLint *param
              goto finish;
           }
         /* 3. replace */
-        thread_param->params = (const GLint  *)thread_param->params_copied;
+        thread_data->params = (const GLint  *)thread_data->params_copied;
      }
    /* end of copy variable */
 
 finish:
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glTexParameteriv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glScissor(GLint x, GLint y, GLsizei width, GLsizei height);
+ * void
+ * glScissor(GLint x, GLint y, GLsizei width, GLsizei height);
  */
 
 typedef struct
@@ -4714,16 +4718,16 @@ typedef struct
 static void
 _evgl_thread_glScissor(void *data)
 {
-   EVGL_Thread_Command_glScissor *thread_param =
+   EVGL_Thread_Command_glScissor *thread_data =
       (EVGL_Thread_Command_glScissor *)data;
 
-   glScissor(thread_param->x,
-             thread_param->y,
-             thread_param->width,
-             thread_param->height);
+   glScissor(thread_data->x,
+             thread_data->y,
+             thread_data->width,
+             thread_data->height);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -4737,39 +4741,39 @@ glScissor_evgl_thread_cmd(GLint x, GLint y, GLsizei width, GLsizei height)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glScissor thread_param_local;
-   EVGL_Thread_Command_glScissor *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glScissor thread_data_local;
+   EVGL_Thread_Command_glScissor *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_Thread_Command_glScissor *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_Thread_Command_glScissor));
-        if (thread_param_new)
+        EVGL_Thread_Command_glScissor *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_Thread_Command_glScissor));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->x = x;
-   thread_param->y = y;
-   thread_param->width = width;
-   thread_param->height = height;
+   thread_data->x = x;
+   thread_data->y = y;
+   thread_data->width = width;
+   thread_data->height = height;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glScissor,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glBlendFunc(GLenum sfactor, GLenum dfactor);
+ * void
+ * glBlendFunc(GLenum sfactor, GLenum dfactor);
  */
 
 typedef struct
@@ -4783,14 +4787,14 @@ typedef struct
 static void
 _evgl_thread_glBlendFunc(void *data)
 {
-   EVGL_Thread_Command_glBlendFunc *thread_param =
+   EVGL_Thread_Command_glBlendFunc *thread_data =
       (EVGL_Thread_Command_glBlendFunc *)data;
 
-   glBlendFunc(thread_param->sfactor,
-               thread_param->dfactor);
+   glBlendFunc(thread_data->sfactor,
+               thread_data->dfactor);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -4804,37 +4808,37 @@ glBlendFunc_evgl_thread_cmd(GLenum sfactor, GLenum dfactor)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glBlendFunc thread_param_local;
-   EVGL_Thread_Command_glBlendFunc *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glBlendFunc thread_data_local;
+   EVGL_Thread_Command_glBlendFunc *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_Thread_Command_glBlendFunc *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_Thread_Command_glBlendFunc));
-        if (thread_param_new)
+        EVGL_Thread_Command_glBlendFunc *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_Thread_Command_glBlendFunc));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->sfactor = sfactor;
-   thread_param->dfactor = dfactor;
+   thread_data->sfactor = sfactor;
+   thread_data->dfactor = dfactor;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glBlendFunc,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glBlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
+ * void
+ * glBlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
  */
 
 typedef struct
@@ -4850,16 +4854,16 @@ typedef struct
 static void
 _evgl_thread_glBlendColor(void *data)
 {
-   EVGL_Thread_Command_glBlendColor *thread_param =
+   EVGL_Thread_Command_glBlendColor *thread_data =
       (EVGL_Thread_Command_glBlendColor *)data;
 
-   glBlendColor(thread_param->red,
-                thread_param->green,
-                thread_param->blue,
-                thread_param->alpha);
+   glBlendColor(thread_data->red,
+                thread_data->green,
+                thread_data->blue,
+                thread_data->alpha);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -4873,39 +4877,39 @@ glBlendColor_evgl_thread_cmd(GLfloat red, GLfloat green, GLfloat blue, GLfloat a
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glBlendColor thread_param_local;
-   EVGL_Thread_Command_glBlendColor *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glBlendColor thread_data_local;
+   EVGL_Thread_Command_glBlendColor *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_Thread_Command_glBlendColor *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_Thread_Command_glBlendColor));
-        if (thread_param_new)
+        EVGL_Thread_Command_glBlendColor *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_Thread_Command_glBlendColor));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->red = red;
-   thread_param->green = green;
-   thread_param->blue = blue;
-   thread_param->alpha = alpha;
+   thread_data->red = red;
+   thread_data->green = green;
+   thread_data->blue = blue;
+   thread_data->alpha = alpha;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glBlendColor,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glDepthMask(GLboolean flag);
+ * void
+ * glDepthMask(GLboolean flag);
  */
 
 typedef struct
@@ -4918,13 +4922,13 @@ typedef struct
 static void
 _evgl_thread_glDepthMask(void *data)
 {
-   EVGL_Thread_Command_glDepthMask *thread_param =
+   EVGL_Thread_Command_glDepthMask *thread_data =
       (EVGL_Thread_Command_glDepthMask *)data;
 
-   glDepthMask(thread_param->flag);
+   glDepthMask(thread_data->flag);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -4938,36 +4942,36 @@ glDepthMask_evgl_thread_cmd(GLboolean flag)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glDepthMask thread_param_local;
-   EVGL_Thread_Command_glDepthMask *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glDepthMask thread_data_local;
+   EVGL_Thread_Command_glDepthMask *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_Thread_Command_glDepthMask *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_Thread_Command_glDepthMask));
-        if (thread_param_new)
+        EVGL_Thread_Command_glDepthMask *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_Thread_Command_glDepthMask));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->flag = flag;
+   thread_data->flag = flag;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glDepthMask,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glClear(GLbitfield mask);
+ * void
+ * glClear(GLbitfield mask);
  */
 
 typedef struct
@@ -4980,13 +4984,13 @@ typedef struct
 static void
 _evgl_thread_glClear(void *data)
 {
-   EVGL_Thread_Command_glClear *thread_param =
+   EVGL_Thread_Command_glClear *thread_data =
       (EVGL_Thread_Command_glClear *)data;
 
-   glClear(thread_param->mask);
+   glClear(thread_data->mask);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -5000,36 +5004,36 @@ glClear_evgl_thread_cmd(GLbitfield mask)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glClear thread_param_local;
-   EVGL_Thread_Command_glClear *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glClear thread_data_local;
+   EVGL_Thread_Command_glClear *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_Thread_Command_glClear *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_Thread_Command_glClear));
-        if (thread_param_new)
+        EVGL_Thread_Command_glClear *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_Thread_Command_glClear));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->mask = mask;
+   thread_data->mask = mask;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glClear,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
+ * void
+ * glClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
  */
 
 typedef struct
@@ -5045,16 +5049,16 @@ typedef struct
 static void
 _evgl_thread_glClearColor(void *data)
 {
-   EVGL_Thread_Command_glClearColor *thread_param =
+   EVGL_Thread_Command_glClearColor *thread_data =
       (EVGL_Thread_Command_glClearColor *)data;
 
-   glClearColor(thread_param->red,
-                thread_param->green,
-                thread_param->blue,
-                thread_param->alpha);
+   glClearColor(thread_data->red,
+                thread_data->green,
+                thread_data->blue,
+                thread_data->alpha);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -5068,39 +5072,39 @@ glClearColor_evgl_thread_cmd(GLfloat red, GLfloat green, GLfloat blue, GLfloat a
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glClearColor thread_param_local;
-   EVGL_Thread_Command_glClearColor *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glClearColor thread_data_local;
+   EVGL_Thread_Command_glClearColor *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_Thread_Command_glClearColor *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_Thread_Command_glClearColor));
-        if (thread_param_new)
+        EVGL_Thread_Command_glClearColor *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_Thread_Command_glClearColor));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->red = red;
-   thread_param->green = green;
-   thread_param->blue = blue;
-   thread_param->alpha = alpha;
+   thread_data->red = red;
+   thread_data->green = green;
+   thread_data->blue = blue;
+   thread_data->alpha = alpha;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glClearColor,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void *pixels);
+ * void
+ * glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void *pixels);
  */
 
 typedef struct
@@ -5118,16 +5122,16 @@ typedef struct
 static void
 _evgl_thread_glReadPixels(void *data)
 {
-   EVGL_Thread_Command_glReadPixels *thread_param =
+   EVGL_Thread_Command_glReadPixels *thread_data =
       (EVGL_Thread_Command_glReadPixels *)data;
 
-   glReadPixels(thread_param->x,
-                thread_param->y,
-                thread_param->width,
-                thread_param->height,
-                thread_param->format,
-                thread_param->type,
-                thread_param->pixels);
+   glReadPixels(thread_data->x,
+                thread_data->y,
+                thread_data->width,
+                thread_data->height,
+                thread_data->format,
+                thread_data->type,
+                thread_data->pixels);
 
 }
 
@@ -5142,26 +5146,26 @@ glReadPixels_evgl_thread_cmd(GLint x, GLint y, GLsizei width, GLsizei height, GL
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glReadPixels thread_param_local;
-   EVGL_Thread_Command_glReadPixels *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glReadPixels thread_data_local;
+   EVGL_Thread_Command_glReadPixels *thread_data = &thread_data_local;
 
-   thread_param->x = x;
-   thread_param->y = y;
-   thread_param->width = width;
-   thread_param->height = height;
-   thread_param->format = format;
-   thread_param->type = type;
-   thread_param->pixels = pixels;
+   thread_data->x = x;
+   thread_data->y = y;
+   thread_data->width = width;
+   thread_data->height = height;
+   thread_data->format = format;
+   thread_data->type = type;
+   thread_data->pixels = pixels;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glReadPixels,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGenFramebuffers(GLsizei n, GLuint *framebuffers);
+ * void
+ * glGenFramebuffers(GLsizei n, GLuint *framebuffers);
  */
 
 typedef struct
@@ -5174,11 +5178,11 @@ typedef struct
 static void
 _evgl_thread_glGenFramebuffers(void *data)
 {
-   EVGL_Thread_Command_glGenFramebuffers *thread_param =
+   EVGL_Thread_Command_glGenFramebuffers *thread_data =
       (EVGL_Thread_Command_glGenFramebuffers *)data;
 
-   glGenFramebuffers(thread_param->n,
-                     thread_param->framebuffers);
+   glGenFramebuffers(thread_data->n,
+                     thread_data->framebuffers);
 
 }
 
@@ -5193,21 +5197,21 @@ glGenFramebuffers_evgl_thread_cmd(GLsizei n, GLuint *framebuffers)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glGenFramebuffers thread_param_local;
-   EVGL_Thread_Command_glGenFramebuffers *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glGenFramebuffers thread_data_local;
+   EVGL_Thread_Command_glGenFramebuffers *thread_data = &thread_data_local;
 
-   thread_param->n = n;
-   thread_param->framebuffers = framebuffers;
+   thread_data->n = n;
+   thread_data->framebuffers = framebuffers;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glGenFramebuffers,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glBindFramebuffer(GLenum target, GLuint framebuffer);
+ * void
+ * glBindFramebuffer(GLenum target, GLuint framebuffer);
  */
 
 typedef struct
@@ -5221,14 +5225,14 @@ typedef struct
 static void
 _evgl_thread_glBindFramebuffer(void *data)
 {
-   EVGL_Thread_Command_glBindFramebuffer *thread_param =
+   EVGL_Thread_Command_glBindFramebuffer *thread_data =
       (EVGL_Thread_Command_glBindFramebuffer *)data;
 
-   glBindFramebuffer(thread_param->target,
-                     thread_param->framebuffer);
+   glBindFramebuffer(thread_data->target,
+                     thread_data->framebuffer);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -5242,37 +5246,37 @@ glBindFramebuffer_evgl_thread_cmd(GLenum target, GLuint framebuffer)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glBindFramebuffer thread_param_local;
-   EVGL_Thread_Command_glBindFramebuffer *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glBindFramebuffer thread_data_local;
+   EVGL_Thread_Command_glBindFramebuffer *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_Thread_Command_glBindFramebuffer *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_Thread_Command_glBindFramebuffer));
-        if (thread_param_new)
+        EVGL_Thread_Command_glBindFramebuffer *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_Thread_Command_glBindFramebuffer));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->target = target;
-   thread_param->framebuffer = framebuffer;
+   thread_data->target = target;
+   thread_data->framebuffer = framebuffer;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glBindFramebuffer,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glDeleteFramebuffers(GLsizei n, const GLuint *framebuffers);
+ * void
+ * glDeleteFramebuffers(GLsizei n, const GLuint *framebuffers);
  */
 
 typedef struct
@@ -5287,18 +5291,18 @@ typedef struct
 static void
 _evgl_thread_glDeleteFramebuffers(void *data)
 {
-   EVGL_Thread_Command_glDeleteFramebuffers *thread_param =
+   EVGL_Thread_Command_glDeleteFramebuffers *thread_data =
       (EVGL_Thread_Command_glDeleteFramebuffers *)data;
 
-   glDeleteFramebuffers(thread_param->n,
-                        thread_param->framebuffers);
+   glDeleteFramebuffers(thread_data->n,
+                        thread_data->framebuffers);
 
 
-   if (thread_param->framebuffers_copied)
-     eina_mempool_free(_mp_delete_object, thread_param->framebuffers_copied);
+   if (thread_data->framebuffers_copied)
+     eina_mempool_free(_mp_delete_object, thread_data->framebuffers_copied);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -5312,29 +5316,29 @@ glDeleteFramebuffers_evgl_thread_cmd(GLsizei n, const GLuint *framebuffers)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glDeleteFramebuffers thread_param_local;
-   EVGL_Thread_Command_glDeleteFramebuffers *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glDeleteFramebuffers thread_data_local;
+   EVGL_Thread_Command_glDeleteFramebuffers *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_Thread_Command_glDeleteFramebuffers *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_Thread_Command_glDeleteFramebuffers));
-        if (thread_param_new)
+        EVGL_Thread_Command_glDeleteFramebuffers *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_Thread_Command_glDeleteFramebuffers));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->n = n;
-   thread_param->framebuffers = framebuffers;
+   thread_data->n = n;
+   thread_data->framebuffers = framebuffers;
 
-   thread_param->framebuffers_copied = NULL;
+   thread_data->framebuffers_copied = NULL;
    if (thread_mode == EVAS_GL_THREAD_MODE_FINISH)
      goto finish;
 
@@ -5349,10 +5353,10 @@ glDeleteFramebuffers_evgl_thread_cmd(GLsizei n, const GLuint *framebuffers)
              goto finish;
           }
         /* 2. malloc & copy */
-        thread_param->framebuffers_copied = eina_mempool_malloc(_mp_delete_object, copy_size);
-        if (thread_param->framebuffers_copied)
+        thread_data->framebuffers_copied = eina_mempool_malloc(_mp_delete_object, copy_size);
+        if (thread_data->framebuffers_copied)
           {
-             memcpy(thread_param->framebuffers_copied, framebuffers, copy_size);
+             memcpy(thread_data->framebuffers_copied, framebuffers, copy_size);
           }
         else
           {
@@ -5360,20 +5364,20 @@ glDeleteFramebuffers_evgl_thread_cmd(GLsizei n, const GLuint *framebuffers)
              goto finish;
           }
         /* 3. replace */
-        thread_param->framebuffers = (const GLuint  *)thread_param->framebuffers_copied;
+        thread_data->framebuffers = (const GLuint  *)thread_data->framebuffers_copied;
      }
    /* end of copy variable */
 
 finish:
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glDeleteFramebuffers,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGenRenderbuffers(GLsizei n, GLuint *renderbuffers);
+ * void
+ * glGenRenderbuffers(GLsizei n, GLuint *renderbuffers);
  */
 
 typedef struct
@@ -5386,11 +5390,11 @@ typedef struct
 static void
 _evgl_thread_glGenRenderbuffers(void *data)
 {
-   EVGL_Thread_Command_glGenRenderbuffers *thread_param =
+   EVGL_Thread_Command_glGenRenderbuffers *thread_data =
       (EVGL_Thread_Command_glGenRenderbuffers *)data;
 
-   glGenRenderbuffers(thread_param->n,
-                      thread_param->renderbuffers);
+   glGenRenderbuffers(thread_data->n,
+                      thread_data->renderbuffers);
 
 }
 
@@ -5405,21 +5409,21 @@ glGenRenderbuffers_evgl_thread_cmd(GLsizei n, GLuint *renderbuffers)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glGenRenderbuffers thread_param_local;
-   EVGL_Thread_Command_glGenRenderbuffers *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glGenRenderbuffers thread_data_local;
+   EVGL_Thread_Command_glGenRenderbuffers *thread_data = &thread_data_local;
 
-   thread_param->n = n;
-   thread_param->renderbuffers = renderbuffers;
+   thread_data->n = n;
+   thread_data->renderbuffers = renderbuffers;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glGenRenderbuffers,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glBindRenderbuffer(GLenum target, GLuint renderbuffer);
+ * void
+ * glBindRenderbuffer(GLenum target, GLuint renderbuffer);
  */
 
 typedef struct
@@ -5433,14 +5437,14 @@ typedef struct
 static void
 _evgl_thread_glBindRenderbuffer(void *data)
 {
-   EVGL_Thread_Command_glBindRenderbuffer *thread_param =
+   EVGL_Thread_Command_glBindRenderbuffer *thread_data =
       (EVGL_Thread_Command_glBindRenderbuffer *)data;
 
-   glBindRenderbuffer(thread_param->target,
-                      thread_param->renderbuffer);
+   glBindRenderbuffer(thread_data->target,
+                      thread_data->renderbuffer);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -5454,37 +5458,37 @@ glBindRenderbuffer_evgl_thread_cmd(GLenum target, GLuint renderbuffer)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glBindRenderbuffer thread_param_local;
-   EVGL_Thread_Command_glBindRenderbuffer *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glBindRenderbuffer thread_data_local;
+   EVGL_Thread_Command_glBindRenderbuffer *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_Thread_Command_glBindRenderbuffer *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_Thread_Command_glBindRenderbuffer));
-        if (thread_param_new)
+        EVGL_Thread_Command_glBindRenderbuffer *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_Thread_Command_glBindRenderbuffer));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->target = target;
-   thread_param->renderbuffer = renderbuffer;
+   thread_data->target = target;
+   thread_data->renderbuffer = renderbuffer;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glBindRenderbuffer,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glDeleteRenderbuffers(GLsizei n, const GLuint *renderbuffers);
+ * void
+ * glDeleteRenderbuffers(GLsizei n, const GLuint *renderbuffers);
  */
 
 typedef struct
@@ -5499,18 +5503,18 @@ typedef struct
 static void
 _evgl_thread_glDeleteRenderbuffers(void *data)
 {
-   EVGL_Thread_Command_glDeleteRenderbuffers *thread_param =
+   EVGL_Thread_Command_glDeleteRenderbuffers *thread_data =
       (EVGL_Thread_Command_glDeleteRenderbuffers *)data;
 
-   glDeleteRenderbuffers(thread_param->n,
-                         thread_param->renderbuffers);
+   glDeleteRenderbuffers(thread_data->n,
+                         thread_data->renderbuffers);
 
 
-   if (thread_param->renderbuffers_copied)
-     eina_mempool_free(_mp_delete_object, thread_param->renderbuffers_copied);
+   if (thread_data->renderbuffers_copied)
+     eina_mempool_free(_mp_delete_object, thread_data->renderbuffers_copied);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -5524,29 +5528,29 @@ glDeleteRenderbuffers_evgl_thread_cmd(GLsizei n, const GLuint *renderbuffers)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glDeleteRenderbuffers thread_param_local;
-   EVGL_Thread_Command_glDeleteRenderbuffers *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glDeleteRenderbuffers thread_data_local;
+   EVGL_Thread_Command_glDeleteRenderbuffers *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_Thread_Command_glDeleteRenderbuffers *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_Thread_Command_glDeleteRenderbuffers));
-        if (thread_param_new)
+        EVGL_Thread_Command_glDeleteRenderbuffers *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_Thread_Command_glDeleteRenderbuffers));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->n = n;
-   thread_param->renderbuffers = renderbuffers;
+   thread_data->n = n;
+   thread_data->renderbuffers = renderbuffers;
 
-   thread_param->renderbuffers_copied = NULL;
+   thread_data->renderbuffers_copied = NULL;
    if (thread_mode == EVAS_GL_THREAD_MODE_FINISH)
      goto finish;
 
@@ -5561,10 +5565,10 @@ glDeleteRenderbuffers_evgl_thread_cmd(GLsizei n, const GLuint *renderbuffers)
              goto finish;
           }
         /* 2. malloc & copy */
-        thread_param->renderbuffers_copied = eina_mempool_malloc(_mp_delete_object, copy_size);
-        if (thread_param->renderbuffers_copied)
+        thread_data->renderbuffers_copied = eina_mempool_malloc(_mp_delete_object, copy_size);
+        if (thread_data->renderbuffers_copied)
           {
-             memcpy(thread_param->renderbuffers_copied, renderbuffers, copy_size);
+             memcpy(thread_data->renderbuffers_copied, renderbuffers, copy_size);
           }
         else
           {
@@ -5572,20 +5576,20 @@ glDeleteRenderbuffers_evgl_thread_cmd(GLsizei n, const GLuint *renderbuffers)
              goto finish;
           }
         /* 3. replace */
-        thread_param->renderbuffers = (const GLuint  *)thread_param->renderbuffers_copied;
+        thread_data->renderbuffers = (const GLuint  *)thread_data->renderbuffers_copied;
      }
    /* end of copy variable */
 
 finish:
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glDeleteRenderbuffers,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height);
+ * void
+ * glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height);
  */
 
 typedef struct
@@ -5601,16 +5605,16 @@ typedef struct
 static void
 _evgl_thread_glRenderbufferStorage(void *data)
 {
-   EVGL_Thread_Command_glRenderbufferStorage *thread_param =
+   EVGL_Thread_Command_glRenderbufferStorage *thread_data =
       (EVGL_Thread_Command_glRenderbufferStorage *)data;
 
-   glRenderbufferStorage(thread_param->target,
-                         thread_param->internalformat,
-                         thread_param->width,
-                         thread_param->height);
+   glRenderbufferStorage(thread_data->target,
+                         thread_data->internalformat,
+                         thread_data->width,
+                         thread_data->height);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -5624,39 +5628,39 @@ glRenderbufferStorage_evgl_thread_cmd(GLenum target, GLenum internalformat, GLsi
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glRenderbufferStorage thread_param_local;
-   EVGL_Thread_Command_glRenderbufferStorage *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glRenderbufferStorage thread_data_local;
+   EVGL_Thread_Command_glRenderbufferStorage *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_Thread_Command_glRenderbufferStorage *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_Thread_Command_glRenderbufferStorage));
-        if (thread_param_new)
+        EVGL_Thread_Command_glRenderbufferStorage *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_Thread_Command_glRenderbufferStorage));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->target = target;
-   thread_param->internalformat = internalformat;
-   thread_param->width = width;
-   thread_param->height = height;
+   thread_data->target = target;
+   thread_data->internalformat = internalformat;
+   thread_data->width = width;
+   thread_data->height = height;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glRenderbufferStorage,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer);
+ * void
+ * glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer);
  */
 
 typedef struct
@@ -5672,16 +5676,16 @@ typedef struct
 static void
 _evgl_thread_glFramebufferRenderbuffer(void *data)
 {
-   EVGL_Thread_Command_glFramebufferRenderbuffer *thread_param =
+   EVGL_Thread_Command_glFramebufferRenderbuffer *thread_data =
       (EVGL_Thread_Command_glFramebufferRenderbuffer *)data;
 
-   glFramebufferRenderbuffer(thread_param->target,
-                             thread_param->attachment,
-                             thread_param->renderbuffertarget,
-                             thread_param->renderbuffer);
+   glFramebufferRenderbuffer(thread_data->target,
+                             thread_data->attachment,
+                             thread_data->renderbuffertarget,
+                             thread_data->renderbuffer);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -5695,39 +5699,39 @@ glFramebufferRenderbuffer_evgl_thread_cmd(GLenum target, GLenum attachment, GLen
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glFramebufferRenderbuffer thread_param_local;
-   EVGL_Thread_Command_glFramebufferRenderbuffer *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glFramebufferRenderbuffer thread_data_local;
+   EVGL_Thread_Command_glFramebufferRenderbuffer *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_Thread_Command_glFramebufferRenderbuffer *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_Thread_Command_glFramebufferRenderbuffer));
-        if (thread_param_new)
+        EVGL_Thread_Command_glFramebufferRenderbuffer *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_Thread_Command_glFramebufferRenderbuffer));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->target = target;
-   thread_param->attachment = attachment;
-   thread_param->renderbuffertarget = renderbuffertarget;
-   thread_param->renderbuffer = renderbuffer;
+   thread_data->target = target;
+   thread_data->attachment = attachment;
+   thread_data->renderbuffertarget = renderbuffertarget;
+   thread_data->renderbuffer = renderbuffer;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glFramebufferRenderbuffer,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
+ * void
+ * glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
  */
 
 typedef struct
@@ -5744,17 +5748,17 @@ typedef struct
 static void
 _evgl_thread_glFramebufferTexture2D(void *data)
 {
-   EVGL_Thread_Command_glFramebufferTexture2D *thread_param =
+   EVGL_Thread_Command_glFramebufferTexture2D *thread_data =
       (EVGL_Thread_Command_glFramebufferTexture2D *)data;
 
-   glFramebufferTexture2D(thread_param->target,
-                          thread_param->attachment,
-                          thread_param->textarget,
-                          thread_param->texture,
-                          thread_param->level);
+   glFramebufferTexture2D(thread_data->target,
+                          thread_data->attachment,
+                          thread_data->textarget,
+                          thread_data->texture,
+                          thread_data->level);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -5768,40 +5772,40 @@ glFramebufferTexture2D_evgl_thread_cmd(GLenum target, GLenum attachment, GLenum
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glFramebufferTexture2D thread_param_local;
-   EVGL_Thread_Command_glFramebufferTexture2D *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glFramebufferTexture2D thread_data_local;
+   EVGL_Thread_Command_glFramebufferTexture2D *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_Thread_Command_glFramebufferTexture2D *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_Thread_Command_glFramebufferTexture2D));
-        if (thread_param_new)
+        EVGL_Thread_Command_glFramebufferTexture2D *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_Thread_Command_glFramebufferTexture2D));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->target = target;
-   thread_param->attachment = attachment;
-   thread_param->textarget = textarget;
-   thread_param->texture = texture;
-   thread_param->level = level;
+   thread_data->target = target;
+   thread_data->attachment = attachment;
+   thread_data->textarget = textarget;
+   thread_data->texture = texture;
+   thread_data->level = level;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glFramebufferTexture2D,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   GLenum
-   glCheckFramebufferStatus(GLenum target);
+ * GLenum
+ * glCheckFramebufferStatus(GLenum target);
  */
 
 typedef struct
@@ -5814,10 +5818,10 @@ typedef struct
 static void
 _evgl_thread_glCheckFramebufferStatus(void *data)
 {
-   EVGL_Thread_Command_glCheckFramebufferStatus *thread_param =
+   EVGL_Thread_Command_glCheckFramebufferStatus *thread_data =
       (EVGL_Thread_Command_glCheckFramebufferStatus *)data;
 
-   thread_param->return_value = glCheckFramebufferStatus(thread_param->target);
+   thread_data->return_value = glCheckFramebufferStatus(thread_data->target);
 
 }
 
@@ -5831,22 +5835,22 @@ glCheckFramebufferStatus_evgl_thread_cmd(GLenum target)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glCheckFramebufferStatus thread_param_local;
-   EVGL_Thread_Command_glCheckFramebufferStatus *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glCheckFramebufferStatus thread_data_local;
+   EVGL_Thread_Command_glCheckFramebufferStatus *thread_data = &thread_data_local;
 
-   thread_param->target = target;
+   thread_data->target = target;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glCheckFramebufferStatus,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
-   void
-   glFlush(void);
+ * void
+ * glFlush(void);
  */
 
 static void
@@ -5874,8 +5878,8 @@ glFlush_evgl_thread_cmd(void)
 }
 
 /*
-   void
-   glFinish(void);
+ * void
+ * glFinish(void);
  */
 
 static void
@@ -5903,8 +5907,8 @@ glFinish_evgl_thread_cmd(void)
 }
 
 /*
-   void
-   glHint(GLenum target, GLenum mode);
+ * void
+ * glHint(GLenum target, GLenum mode);
  */
 
 typedef struct
@@ -5918,14 +5922,14 @@ typedef struct
 static void
 _evgl_thread_glHint(void *data)
 {
-   EVGL_Thread_Command_glHint *thread_param =
+   EVGL_Thread_Command_glHint *thread_data =
       (EVGL_Thread_Command_glHint *)data;
 
-   glHint(thread_param->target,
-          thread_param->mode);
+   glHint(thread_data->target,
+          thread_data->mode);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -5939,37 +5943,37 @@ glHint_evgl_thread_cmd(GLenum target, GLenum mode)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glHint thread_param_local;
-   EVGL_Thread_Command_glHint *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glHint thread_data_local;
+   EVGL_Thread_Command_glHint *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        EVGL_Thread_Command_glHint *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(EVGL_Thread_Command_glHint));
-        if (thread_param_new)
+        EVGL_Thread_Command_glHint *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(EVGL_Thread_Command_glHint));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->target = target;
-   thread_param->mode = mode;
+   thread_data->target = target;
+   thread_data->mode = mode;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glHint,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   const GLubyte *
-   glGetString(GLenum name);
+ * const GLubyte *
+ * glGetString(GLenum name);
  */
 
 typedef struct
@@ -5982,10 +5986,10 @@ typedef struct
 static void
 _evgl_thread_glGetString(void *data)
 {
-   EVGL_Thread_Command_glGetString *thread_param =
+   EVGL_Thread_Command_glGetString *thread_data =
       (EVGL_Thread_Command_glGetString *)data;
 
-   thread_param->return_value = glGetString(thread_param->name);
+   thread_data->return_value = glGetString(thread_data->name);
 
 }
 
@@ -5999,22 +6003,22 @@ glGetString_evgl_thread_cmd(GLenum name)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glGetString thread_param_local;
-   EVGL_Thread_Command_glGetString *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glGetString thread_data_local;
+   EVGL_Thread_Command_glGetString *thread_data = &thread_data_local;
 
-   thread_param->name = name;
+   thread_data->name = name;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glGetString,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
-   void
-   glGetBooleanv(GLenum pname, GLboolean *data);
+ * void
+ * glGetBooleanv(GLenum pname, GLboolean *data);
  */
 
 typedef struct
@@ -6027,11 +6031,11 @@ typedef struct
 static void
 _evgl_thread_glGetBooleanv(void *data)
 {
-   EVGL_Thread_Command_glGetBooleanv *thread_param =
+   EVGL_Thread_Command_glGetBooleanv *thread_data =
       (EVGL_Thread_Command_glGetBooleanv *)data;
 
-   glGetBooleanv(thread_param->pname,
-                 thread_param->data);
+   glGetBooleanv(thread_data->pname,
+                 thread_data->data);
 
 }
 
@@ -6046,21 +6050,21 @@ glGetBooleanv_evgl_thread_cmd(GLenum pname, GLboolean *data)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glGetBooleanv thread_param_local;
-   EVGL_Thread_Command_glGetBooleanv *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glGetBooleanv thread_data_local;
+   EVGL_Thread_Command_glGetBooleanv *thread_data = &thread_data_local;
 
-   thread_param->pname = pname;
-   thread_param->data = data;
+   thread_data->pname = pname;
+   thread_data->data = data;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glGetBooleanv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGetFloatv(GLenum pname, GLfloat *data);
+ * void
+ * glGetFloatv(GLenum pname, GLfloat *data);
  */
 
 typedef struct
@@ -6073,11 +6077,11 @@ typedef struct
 static void
 _evgl_thread_glGetFloatv(void *data)
 {
-   EVGL_Thread_Command_glGetFloatv *thread_param =
+   EVGL_Thread_Command_glGetFloatv *thread_data =
       (EVGL_Thread_Command_glGetFloatv *)data;
 
-   glGetFloatv(thread_param->pname,
-               thread_param->data);
+   glGetFloatv(thread_data->pname,
+               thread_data->data);
 
 }
 
@@ -6092,21 +6096,21 @@ glGetFloatv_evgl_thread_cmd(GLenum pname, GLfloat *data)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glGetFloatv thread_param_local;
-   EVGL_Thread_Command_glGetFloatv *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glGetFloatv thread_data_local;
+   EVGL_Thread_Command_glGetFloatv *thread_data = &thread_data_local;
 
-   thread_param->pname = pname;
-   thread_param->data = data;
+   thread_data->pname = pname;
+   thread_data->data = data;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glGetFloatv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGetIntegerv(GLenum pname, GLint *data);
+ * void
+ * glGetIntegerv(GLenum pname, GLint *data);
  */
 
 typedef struct
@@ -6119,11 +6123,11 @@ typedef struct
 static void
 _evgl_thread_glGetIntegerv(void *data)
 {
-   EVGL_Thread_Command_glGetIntegerv *thread_param =
+   EVGL_Thread_Command_glGetIntegerv *thread_data =
       (EVGL_Thread_Command_glGetIntegerv *)data;
 
-   glGetIntegerv(thread_param->pname,
-                 thread_param->data);
+   glGetIntegerv(thread_data->pname,
+                 thread_data->data);
 
 }
 
@@ -6138,21 +6142,21 @@ glGetIntegerv_evgl_thread_cmd(GLenum pname, GLint *data)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glGetIntegerv thread_param_local;
-   EVGL_Thread_Command_glGetIntegerv *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glGetIntegerv thread_data_local;
+   EVGL_Thread_Command_glGetIntegerv *thread_data = &thread_data_local;
 
-   thread_param->pname = pname;
-   thread_param->data = data;
+   thread_data->pname = pname;
+   thread_data->data = data;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glGetIntegerv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   GLboolean
-   glIsBuffer(GLint buffer);
+ * GLboolean
+ * glIsBuffer(GLint buffer);
  */
 
 typedef struct
@@ -6165,10 +6169,10 @@ typedef struct
 static void
 _evgl_thread_glIsBuffer(void *data)
 {
-   EVGL_Thread_Command_glIsBuffer *thread_param =
+   EVGL_Thread_Command_glIsBuffer *thread_data =
       (EVGL_Thread_Command_glIsBuffer *)data;
 
-   thread_param->return_value = glIsBuffer(thread_param->buffer);
+   thread_data->return_value = glIsBuffer(thread_data->buffer);
 
 }
 
@@ -6182,22 +6186,22 @@ glIsBuffer_evgl_thread_cmd(GLint buffer)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glIsBuffer thread_param_local;
-   EVGL_Thread_Command_glIsBuffer *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glIsBuffer thread_data_local;
+   EVGL_Thread_Command_glIsBuffer *thread_data = &thread_data_local;
 
-   thread_param->buffer = buffer;
+   thread_data->buffer = buffer;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glIsBuffer,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
-   void
-   glGetBufferParameteriv(GLenum target, GLenum pname, GLint *params);
+ * void
+ * glGetBufferParameteriv(GLenum target, GLenum pname, GLint *params);
  */
 
 typedef struct
@@ -6211,12 +6215,12 @@ typedef struct
 static void
 _evgl_thread_glGetBufferParameteriv(void *data)
 {
-   EVGL_Thread_Command_glGetBufferParameteriv *thread_param =
+   EVGL_Thread_Command_glGetBufferParameteriv *thread_data =
       (EVGL_Thread_Command_glGetBufferParameteriv *)data;
 
-   glGetBufferParameteriv(thread_param->target,
-                          thread_param->pname,
-                          thread_param->params);
+   glGetBufferParameteriv(thread_data->target,
+                          thread_data->pname,
+                          thread_data->params);
 
 }
 
@@ -6231,22 +6235,22 @@ glGetBufferParameteriv_evgl_thread_cmd(GLenum target, GLenum pname, GLint *param
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glGetBufferParameteriv thread_param_local;
-   EVGL_Thread_Command_glGetBufferParameteriv *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glGetBufferParameteriv thread_data_local;
+   EVGL_Thread_Command_glGetBufferParameteriv *thread_data = &thread_data_local;
 
-   thread_param->target = target;
-   thread_param->pname = pname;
-   thread_param->params = params;
+   thread_data->target = target;
+   thread_data->pname = pname;
+   thread_data->params = params;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glGetBufferParameteriv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   GLboolean
-   glIsShader(GLuint shader);
+ * GLboolean
+ * glIsShader(GLuint shader);
  */
 
 typedef struct
@@ -6259,10 +6263,10 @@ typedef struct
 static void
 _evgl_thread_glIsShader(void *data)
 {
-   EVGL_Thread_Command_glIsShader *thread_param =
+   EVGL_Thread_Command_glIsShader *thread_data =
       (EVGL_Thread_Command_glIsShader *)data;
 
-   thread_param->return_value = glIsShader(thread_param->shader);
+   thread_data->return_value = glIsShader(thread_data->shader);
 
 }
 
@@ -6276,22 +6280,22 @@ glIsShader_evgl_thread_cmd(GLuint shader)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glIsShader thread_param_local;
-   EVGL_Thread_Command_glIsShader *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glIsShader thread_data_local;
+   EVGL_Thread_Command_glIsShader *thread_data = &thread_data_local;
 
-   thread_param->shader = shader;
+   thread_data->shader = shader;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glIsShader,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
-   void
-   glGetShaderiv(GLuint shader, GLenum pname, GLint *params);
+ * void
+ * glGetShaderiv(GLuint shader, GLenum pname, GLint *params);
  */
 
 typedef struct
@@ -6305,12 +6309,12 @@ typedef struct
 static void
 _evgl_thread_glGetShaderiv(void *data)
 {
-   EVGL_Thread_Command_glGetShaderiv *thread_param =
+   EVGL_Thread_Command_glGetShaderiv *thread_data =
       (EVGL_Thread_Command_glGetShaderiv *)data;
 
-   glGetShaderiv(thread_param->shader,
-                 thread_param->pname,
-                 thread_param->params);
+   glGetShaderiv(thread_data->shader,
+                 thread_data->pname,
+                 thread_data->params);
 
 }
 
@@ -6325,22 +6329,22 @@ glGetShaderiv_evgl_thread_cmd(GLuint shader, GLenum pname, GLint *params)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glGetShaderiv thread_param_local;
-   EVGL_Thread_Command_glGetShaderiv *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glGetShaderiv thread_data_local;
+   EVGL_Thread_Command_glGetShaderiv *thread_data = &thread_data_local;
 
-   thread_param->shader = shader;
-   thread_param->pname = pname;
-   thread_param->params = params;
+   thread_data->shader = shader;
+   thread_data->pname = pname;
+   thread_data->params = params;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glGetShaderiv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *shaders);
+ * void
+ * glGetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *shaders);
  */
 
 typedef struct
@@ -6355,13 +6359,13 @@ typedef struct
 static void
 _evgl_thread_glGetAttachedShaders(void *data)
 {
-   EVGL_Thread_Command_glGetAttachedShaders *thread_param =
+   EVGL_Thread_Command_glGetAttachedShaders *thread_data =
       (EVGL_Thread_Command_glGetAttachedShaders *)data;
 
-   glGetAttachedShaders(thread_param->program,
-                        thread_param->maxCount,
-                        thread_param->count,
-                        thread_param->shaders);
+   glGetAttachedShaders(thread_data->program,
+                        thread_data->maxCount,
+                        thread_data->count,
+                        thread_data->shaders);
 
 }
 
@@ -6376,23 +6380,23 @@ glGetAttachedShaders_evgl_thread_cmd(GLuint program, GLsizei maxCount, GLsizei *
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glGetAttachedShaders thread_param_local;
-   EVGL_Thread_Command_glGetAttachedShaders *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glGetAttachedShaders thread_data_local;
+   EVGL_Thread_Command_glGetAttachedShaders *thread_data = &thread_data_local;
 
-   thread_param->program = program;
-   thread_param->maxCount = maxCount;
-   thread_param->count = count;
-   thread_param->shaders = shaders;
+   thread_data->program = program;
+   thread_data->maxCount = maxCount;
+   thread_data->count = count;
+   thread_data->shaders = shaders;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glGetAttachedShaders,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGetShaderInfoLog(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
+ * void
+ * glGetShaderInfoLog(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
  */
 
 typedef struct
@@ -6407,13 +6411,13 @@ typedef struct
 static void
 _evgl_thread_glGetShaderInfoLog(void *data)
 {
-   EVGL_Thread_Command_glGetShaderInfoLog *thread_param =
+   EVGL_Thread_Command_glGetShaderInfoLog *thread_data =
       (EVGL_Thread_Command_glGetShaderInfoLog *)data;
 
-   glGetShaderInfoLog(thread_param->shader,
-                      thread_param->bufSize,
-                      thread_param->length,
-                      thread_param->infoLog);
+   glGetShaderInfoLog(thread_data->shader,
+                      thread_data->bufSize,
+                      thread_data->length,
+                      thread_data->infoLog);
 
 }
 
@@ -6428,23 +6432,23 @@ glGetShaderInfoLog_evgl_thread_cmd(GLuint shader, GLsizei bufSize, GLsizei *leng
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glGetShaderInfoLog thread_param_local;
-   EVGL_Thread_Command_glGetShaderInfoLog *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glGetShaderInfoLog thread_data_local;
+   EVGL_Thread_Command_glGetShaderInfoLog *thread_data = &thread_data_local;
 
-   thread_param->shader = shader;
-   thread_param->bufSize = bufSize;
-   thread_param->length = length;
-   thread_param->infoLog = infoLog;
+   thread_data->shader = shader;
+   thread_data->bufSize = bufSize;
+   thread_data->length = length;
+   thread_data->infoLog = infoLog;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glGetShaderInfoLog,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGetShaderSource(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source);
+ * void
+ * glGetShaderSource(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source);
  */
 
 typedef struct
@@ -6459,13 +6463,13 @@ typedef struct
 static void
 _evgl_thread_glGetShaderSource(void *data)
 {
-   EVGL_Thread_Command_glGetShaderSource *thread_param =
+   EVGL_Thread_Command_glGetShaderSource *thread_data =
       (EVGL_Thread_Command_glGetShaderSource *)data;
 
-   glGetShaderSource(thread_param->shader,
-                     thread_param->bufSize,
-                     thread_param->length,
-                     thread_param->source);
+   glGetShaderSource(thread_data->shader,
+                     thread_data->bufSize,
+                     thread_data->length,
+                     thread_data->source);
 
 }
 
@@ -6480,23 +6484,23 @@ glGetShaderSource_evgl_thread_cmd(GLuint shader, GLsizei bufSize, GLsizei *lengt
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glGetShaderSource thread_param_local;
-   EVGL_Thread_Command_glGetShaderSource *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glGetShaderSource thread_data_local;
+   EVGL_Thread_Command_glGetShaderSource *thread_data = &thread_data_local;
 
-   thread_param->shader = shader;
-   thread_param->bufSize = bufSize;
-   thread_param->length = length;
-   thread_param->source = source;
+   thread_data->shader = shader;
+   thread_data->bufSize = bufSize;
+   thread_data->length = length;
+   thread_data->source = source;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glGetShaderSource,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint *range, GLint *precision);
+ * void
+ * glGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint *range, GLint *precision);
  */
 
 typedef struct
@@ -6511,13 +6515,13 @@ typedef struct
 static void
 _evgl_thread_glGetShaderPrecisionFormat(void *data)
 {
-   EVGL_Thread_Command_glGetShaderPrecisionFormat *thread_param =
+   EVGL_Thread_Command_glGetShaderPrecisionFormat *thread_data =
       (EVGL_Thread_Command_glGetShaderPrecisionFormat *)data;
 
-   glGetShaderPrecisionFormat(thread_param->shadertype,
-                              thread_param->precisiontype,
-                              thread_param->range,
-                              thread_param->precision);
+   glGetShaderPrecisionFormat(thread_data->shadertype,
+                              thread_data->precisiontype,
+                              thread_data->range,
+                              thread_data->precision);
 
 }
 
@@ -6532,23 +6536,23 @@ glGetShaderPrecisionFormat_evgl_thread_cmd(GLenum shadertype, GLenum precisionty
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glGetShaderPrecisionFormat thread_param_local;
-   EVGL_Thread_Command_glGetShaderPrecisionFormat *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glGetShaderPrecisionFormat thread_data_local;
+   EVGL_Thread_Command_glGetShaderPrecisionFormat *thread_data = &thread_data_local;
 
-   thread_param->shadertype = shadertype;
-   thread_param->precisiontype = precisiontype;
-   thread_param->range = range;
-   thread_param->precision = precision;
+   thread_data->shadertype = shadertype;
+   thread_data->precisiontype = precisiontype;
+   thread_data->range = range;
+   thread_data->precision = precision;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glGetShaderPrecisionFormat,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params);
+ * void
+ * glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params);
  */
 
 typedef struct
@@ -6562,12 +6566,12 @@ typedef struct
 static void
 _evgl_thread_glGetVertexAttribfv(void *data)
 {
-   EVGL_Thread_Command_glGetVertexAttribfv *thread_param =
+   EVGL_Thread_Command_glGetVertexAttribfv *thread_data =
       (EVGL_Thread_Command_glGetVertexAttribfv *)data;
 
-   glGetVertexAttribfv(thread_param->index,
-                       thread_param->pname,
-                       thread_param->params);
+   glGetVertexAttribfv(thread_data->index,
+                       thread_data->pname,
+                       thread_data->params);
 
 }
 
@@ -6582,22 +6586,22 @@ glGetVertexAttribfv_evgl_thread_cmd(GLuint index, GLenum pname, GLfloat *params)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glGetVertexAttribfv thread_param_local;
-   EVGL_Thread_Command_glGetVertexAttribfv *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glGetVertexAttribfv thread_data_local;
+   EVGL_Thread_Command_glGetVertexAttribfv *thread_data = &thread_data_local;
 
-   thread_param->index = index;
-   thread_param->pname = pname;
-   thread_param->params = params;
+   thread_data->index = index;
+   thread_data->pname = pname;
+   thread_data->params = params;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glGetVertexAttribfv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGetVertexAttribiv(GLuint index, GLenum pname, GLint *params);
+ * void
+ * glGetVertexAttribiv(GLuint index, GLenum pname, GLint *params);
  */
 
 typedef struct
@@ -6611,12 +6615,12 @@ typedef struct
 static void
 _evgl_thread_glGetVertexAttribiv(void *data)
 {
-   EVGL_Thread_Command_glGetVertexAttribiv *thread_param =
+   EVGL_Thread_Command_glGetVertexAttribiv *thread_data =
       (EVGL_Thread_Command_glGetVertexAttribiv *)data;
 
-   glGetVertexAttribiv(thread_param->index,
-                       thread_param->pname,
-                       thread_param->params);
+   glGetVertexAttribiv(thread_data->index,
+                       thread_data->pname,
+                       thread_data->params);
 
 }
 
@@ -6631,22 +6635,22 @@ glGetVertexAttribiv_evgl_thread_cmd(GLuint index, GLenum pname, GLint *params)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glGetVertexAttribiv thread_param_local;
-   EVGL_Thread_Command_glGetVertexAttribiv *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glGetVertexAttribiv thread_data_local;
+   EVGL_Thread_Command_glGetVertexAttribiv *thread_data = &thread_data_local;
 
-   thread_param->index = index;
-   thread_param->pname = pname;
-   thread_param->params = params;
+   thread_data->index = index;
+   thread_data->pname = pname;
+   thread_data->params = params;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glGetVertexAttribiv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   GLboolean
-   glIsProgram(GLuint program);
+ * GLboolean
+ * glIsProgram(GLuint program);
  */
 
 typedef struct
@@ -6659,10 +6663,10 @@ typedef struct
 static void
 _evgl_thread_glIsProgram(void *data)
 {
-   EVGL_Thread_Command_glIsProgram *thread_param =
+   EVGL_Thread_Command_glIsProgram *thread_data =
       (EVGL_Thread_Command_glIsProgram *)data;
 
-   thread_param->return_value = glIsProgram(thread_param->program);
+   thread_data->return_value = glIsProgram(thread_data->program);
 
 }
 
@@ -6676,22 +6680,22 @@ glIsProgram_evgl_thread_cmd(GLuint program)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glIsProgram thread_param_local;
-   EVGL_Thread_Command_glIsProgram *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glIsProgram thread_data_local;
+   EVGL_Thread_Command_glIsProgram *thread_data = &thread_data_local;
 
-   thread_param->program = program;
+   thread_data->program = program;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glIsProgram,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
-   void
-   glGetProgramInfoLog(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
+ * void
+ * glGetProgramInfoLog(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
  */
 
 typedef struct
@@ -6706,13 +6710,13 @@ typedef struct
 static void
 _evgl_thread_glGetProgramInfoLog(void *data)
 {
-   EVGL_Thread_Command_glGetProgramInfoLog *thread_param =
+   EVGL_Thread_Command_glGetProgramInfoLog *thread_data =
       (EVGL_Thread_Command_glGetProgramInfoLog *)data;
 
-   glGetProgramInfoLog(thread_param->program,
-                       thread_param->bufSize,
-                       thread_param->length,
-                       thread_param->infoLog);
+   glGetProgramInfoLog(thread_data->program,
+                       thread_data->bufSize,
+                       thread_data->length,
+                       thread_data->infoLog);
 
 }
 
@@ -6727,23 +6731,23 @@ glGetProgramInfoLog_evgl_thread_cmd(GLuint program, GLsizei bufSize, GLsizei *le
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glGetProgramInfoLog thread_param_local;
-   EVGL_Thread_Command_glGetProgramInfoLog *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glGetProgramInfoLog thread_data_local;
+   EVGL_Thread_Command_glGetProgramInfoLog *thread_data = &thread_data_local;
 
-   thread_param->program = program;
-   thread_param->bufSize = bufSize;
-   thread_param->length = length;
-   thread_param->infoLog = infoLog;
+   thread_data->program = program;
+   thread_data->bufSize = bufSize;
+   thread_data->length = length;
+   thread_data->infoLog = infoLog;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glGetProgramInfoLog,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGetProgramiv(GLuint program, GLenum pname, GLint *params);
+ * void
+ * glGetProgramiv(GLuint program, GLenum pname, GLint *params);
  */
 
 typedef struct
@@ -6757,12 +6761,12 @@ typedef struct
 static void
 _evgl_thread_glGetProgramiv(void *data)
 {
-   EVGL_Thread_Command_glGetProgramiv *thread_param =
+   EVGL_Thread_Command_glGetProgramiv *thread_data =
       (EVGL_Thread_Command_glGetProgramiv *)data;
 
-   glGetProgramiv(thread_param->program,
-                  thread_param->pname,
-                  thread_param->params);
+   glGetProgramiv(thread_data->program,
+                  thread_data->pname,
+                  thread_data->params);
 
 }
 
@@ -6777,22 +6781,22 @@ glGetProgramiv_evgl_thread_cmd(GLuint program, GLenum pname, GLint *params)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glGetProgramiv thread_param_local;
-   EVGL_Thread_Command_glGetProgramiv *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glGetProgramiv thread_data_local;
+   EVGL_Thread_Command_glGetProgramiv *thread_data = &thread_data_local;
 
-   thread_param->program = program;
-   thread_param->pname = pname;
-   thread_param->params = params;
+   thread_data->program = program;
+   thread_data->pname = pname;
+   thread_data->params = params;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glGetProgramiv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   GLboolean
-   glIsFramebuffer(GLint framebuffer);
+ * GLboolean
+ * glIsFramebuffer(GLint framebuffer);
  */
 
 typedef struct
@@ -6805,10 +6809,10 @@ typedef struct
 static void
 _evgl_thread_glIsFramebuffer(void *data)
 {
-   EVGL_Thread_Command_glIsFramebuffer *thread_param =
+   EVGL_Thread_Command_glIsFramebuffer *thread_data =
       (EVGL_Thread_Command_glIsFramebuffer *)data;
 
-   thread_param->return_value = glIsFramebuffer(thread_param->framebuffer);
+   thread_data->return_value = glIsFramebuffer(thread_data->framebuffer);
 
 }
 
@@ -6822,22 +6826,22 @@ glIsFramebuffer_evgl_thread_cmd(GLint framebuffer)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glIsFramebuffer thread_param_local;
-   EVGL_Thread_Command_glIsFramebuffer *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glIsFramebuffer thread_data_local;
+   EVGL_Thread_Command_glIsFramebuffer *thread_data = &thread_data_local;
 
-   thread_param->framebuffer = framebuffer;
+   thread_data->framebuffer = framebuffer;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glIsFramebuffer,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
-   GLboolean
-   glIsRenderbuffer(GLint renderbuffer);
+ * GLboolean
+ * glIsRenderbuffer(GLint renderbuffer);
  */
 
 typedef struct
@@ -6850,10 +6854,10 @@ typedef struct
 static void
 _evgl_thread_glIsRenderbuffer(void *data)
 {
-   EVGL_Thread_Command_glIsRenderbuffer *thread_param =
+   EVGL_Thread_Command_glIsRenderbuffer *thread_data =
       (EVGL_Thread_Command_glIsRenderbuffer *)data;
 
-   thread_param->return_value = glIsRenderbuffer(thread_param->renderbuffer);
+   thread_data->return_value = glIsRenderbuffer(thread_data->renderbuffer);
 
 }
 
@@ -6867,22 +6871,22 @@ glIsRenderbuffer_evgl_thread_cmd(GLint renderbuffer)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glIsRenderbuffer thread_param_local;
-   EVGL_Thread_Command_glIsRenderbuffer *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glIsRenderbuffer thread_data_local;
+   EVGL_Thread_Command_glIsRenderbuffer *thread_data = &thread_data_local;
 
-   thread_param->renderbuffer = renderbuffer;
+   thread_data->renderbuffer = renderbuffer;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glIsRenderbuffer,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
-   void
-   glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint *params);
+ * void
+ * glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint *params);
  */
 
 typedef struct
@@ -6896,12 +6900,12 @@ typedef struct
 static void
 _evgl_thread_glGetRenderbufferParameteriv(void *data)
 {
-   EVGL_Thread_Command_glGetRenderbufferParameteriv *thread_param =
+   EVGL_Thread_Command_glGetRenderbufferParameteriv *thread_data =
       (EVGL_Thread_Command_glGetRenderbufferParameteriv *)data;
 
-   glGetRenderbufferParameteriv(thread_param->target,
-                                thread_param->pname,
-                                thread_param->params);
+   glGetRenderbufferParameteriv(thread_data->target,
+                                thread_data->pname,
+                                thread_data->params);
 
 }
 
@@ -6916,22 +6920,22 @@ glGetRenderbufferParameteriv_evgl_thread_cmd(GLenum target, GLenum pname, GLint
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glGetRenderbufferParameteriv thread_param_local;
-   EVGL_Thread_Command_glGetRenderbufferParameteriv *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glGetRenderbufferParameteriv thread_data_local;
+   EVGL_Thread_Command_glGetRenderbufferParameteriv *thread_data = &thread_data_local;
 
-   thread_param->target = target;
-   thread_param->pname = pname;
-   thread_param->params = params;
+   thread_data->target = target;
+   thread_data->pname = pname;
+   thread_data->params = params;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glGetRenderbufferParameteriv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   GLboolean
-   glIsTexture(GLint texture);
+ * GLboolean
+ * glIsTexture(GLint texture);
  */
 
 typedef struct
@@ -6944,10 +6948,10 @@ typedef struct
 static void
 _evgl_thread_glIsTexture(void *data)
 {
-   EVGL_Thread_Command_glIsTexture *thread_param =
+   EVGL_Thread_Command_glIsTexture *thread_data =
       (EVGL_Thread_Command_glIsTexture *)data;
 
-   thread_param->return_value = glIsTexture(thread_param->texture);
+   thread_data->return_value = glIsTexture(thread_data->texture);
 
 }
 
@@ -6961,15 +6965,15 @@ glIsTexture_evgl_thread_cmd(GLint texture)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glIsTexture thread_param_local;
-   EVGL_Thread_Command_glIsTexture *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glIsTexture thread_data_local;
+   EVGL_Thread_Command_glIsTexture *thread_data = &thread_data_local;
 
-   thread_param->texture = texture;
+   thread_data->texture = texture;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glIsTexture,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }

diff --git a/src/modules/evas/engines/gl_common/evas_gl_thread_evgl_generated.h b/src/modules/evas/engines/gl_common/evas_gl_thread_evgl_generated.h
index 5d72d80..33f95b8 100644 (file)
--- a/src/modules/evas/engines/gl_common/evas_gl_thread_evgl_generated.h
+++ b/src/modules/evas/engines/gl_common/evas_gl_thread_evgl_generated.h
@@ -1,5 +1,9 @@
-/* DO NOT MODIFY THIS FILE AS IT IS AUTO-GENERATED */
-
+/*
+ * This is an automatically generated file using a python script.
+ * ($EFL_HOME/src/utils/evas/generate_gl_thread_api.py)
+ * Recommend that you modify data files ($EFL_HOME/src/utils/evas/gl_api_def.txt)
+ * and make use of scripts if you need to fix them.
+ */
 
 #define EVAS_GL_NO_GL_H_CHECK 1
 #include "Evas_GL.h"

diff --git a/src/modules/evas/engines/gl_common/evas_gl_thread_evgl_link_generated.c b/src/modules/evas/engines/gl_common/evas_gl_thread_evgl_link_generated.c
index 0e2f5c3..6cbcf56 100644 (file)
--- a/src/modules/evas/engines/gl_common/evas_gl_thread_evgl_link_generated.c
+++ b/src/modules/evas/engines/gl_common/evas_gl_thread_evgl_link_generated.c
@@ -1,5 +1,9 @@
-/* DO NOT MODIFY THIS FILE AS IT IS AUTO-GENERATED */
-
+/*
+ * This is an automatically generated file using a python script.
+ * ($EFL_HOME/src/utils/evas/generate_gl_thread_api.py)
+ * Recommend that you modify data files ($EFL_HOME/src/utils/evas/gl_api_def.txt)
+ * and make use of scripts if you need to fix them.
+ */
 GLenum (*glGetError_evgl_thread_cmd)(void) = NULL;
 void (*glVertexAttribPointer_evgl_thread_cmd)(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void *pointer) = NULL;
 void (*glEnableVertexAttribArray_evgl_thread_cmd)(GLuint index) = NULL;
@@ -110,7 +114,8 @@ void (*glGetRenderbufferParameteriv_evgl_thread_cmd)(GLenum target, GLenum pname
 GLboolean (*glIsTexture_evgl_thread_cmd)(GLint texture) = NULL;
 
 
-void _evgl_thread_link_init()
+void
+_gl_thread_link_evgl_generated_init()
 {
 #define LINK2GENERIC(sym) \
    sym = dlsym(RTLD_DEFAULT, #sym); \

diff --git a/src/modules/evas/engines/gl_common/evas_gl_thread_evgl_link_generated.h b/src/modules/evas/engines/gl_common/evas_gl_thread_evgl_link_generated.h
index 3b51035..0d4e9ae 100644 (file)
--- a/src/modules/evas/engines/gl_common/evas_gl_thread_evgl_link_generated.h
+++ b/src/modules/evas/engines/gl_common/evas_gl_thread_evgl_link_generated.h
@@ -1,5 +1,9 @@
-/* DO NOT MODIFY THIS FILE AS IT IS AUTO-GENERATED */
-
+/*
+ * This is an automatically generated file using a python script.
+ * ($EFL_HOME/src/utils/evas/generate_gl_thread_api.py)
+ * Recommend that you modify data files ($EFL_HOME/src/utils/evas/gl_api_def.txt)
+ * and make use of scripts if you need to fix them.
+ */
 extern GLenum (*glGetError_evgl_thread_cmd)(void);
 extern void (*glVertexAttribPointer_evgl_thread_cmd)(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void *pointer);
 extern void (*glEnableVertexAttribArray_evgl_thread_cmd)(GLuint index);
@@ -110,4 +114,4 @@ extern void (*glGetRenderbufferParameteriv_evgl_thread_cmd)(GLenum target, GLenu
 extern GLboolean (*glIsTexture_evgl_thread_cmd)(GLint texture);
 
 
-extern void _gl_thread_link_init();
+extern void _gl_thread_link_evgl_generated_init();

diff --git a/src/modules/evas/engines/gl_common/evas_gl_thread_gl.c b/src/modules/evas/engines/gl_common/evas_gl_thread_gl.c
index 1dec009..b5b20f2 100644 (file)
--- a/src/modules/evas/engines/gl_common/evas_gl_thread_gl.c
+++ b/src/modules/evas/engines/gl_common/evas_gl_thread_gl.c
@@ -1,155 +1,178 @@
 #include "evas_gl_common.h"
-#include "evas_gl_thread.h"
 
 
-#ifdef EVAS_GL_RENDER_THREAD_IS_GENERIC
+#ifdef EVAS_GL_RENDER_THREAD_COMPILE_FOR_GL_GENERIC
 
 #define GLSHADERSOURCE_COPY_VARIABLE GLchar **string_copied
 #define GLSHADERSOURCE_COPY_VARIABLE_FREE \
-   if (thread_param->string_copied) { \
-      int i; \
-      for (i = 0; i < thread_param->count; i++) { \
-        if (thread_param->string_copied[i]) { \
-           eina_mempool_free(_mp_default, thread_param->string_copied[i]); \
-        } \
-      }\
-     eina_mempool_free(_mp_default, thread_param->string_copied); \
-   }
+   if (thread_data->string_copied) \
+     { \
+        int i; \
+        for (i = 0; i < thread_data->count; i++) \
+          { \
+             if (thread_data->string_copied[i]) \
+                eina_mempool_free(_mp_default, thread_data->string_copied[i]); \
+          }\
+        eina_mempool_free(_mp_default, thread_data->string_copied); \
+     }
 
 #define GLSHADERSOURCE_COPY_VARIABLE_INIT \
-   thread_param->string_copied = NULL;
+   thread_data->string_copied = NULL;
 
 #define GLSHADERSOURCE_COPY_TO_MEMPOOL \
-   if (string) { \
-      /* 1. check memory size */ \
-      if ((unsigned int)(sizeof(char *) * count) > _mp_default_memory_size) { \
-         thread_mode = EVAS_GL_THREAD_MODE_FINISH; \
-         goto finish; \
-      } \
+   if (string) \
+     { \
+        /* 1. check memory size */ \
+        if ((unsigned int)(sizeof(char *) * count) > _mp_default_memory_size) \
+          { \
+             thread_mode = EVAS_GL_THREAD_MODE_FINISH; \
+             goto finish; \
+          } \
       int i, len = 0; \
-      for (i = 0; i < count; i++) { \
-         if (length) len = length[i]; \
-         else        len = strlen(string[i]); \
-         if ((unsigned int)len + 1 > _mp_default_memory_size) { \
-            thread_mode = EVAS_GL_THREAD_MODE_FINISH; \
-            goto finish; \
-         } \
-      } \
+      for (i = 0; i < count; i++) \
+        { \
+           if (length) len = length[i]; \
+           else        len = strlen(string[i]); \
+           if ((unsigned int)len + 1 > _mp_default_memory_size) \
+             { \
+                thread_mode = EVAS_GL_THREAD_MODE_FINISH; \
+                goto finish; \
+             } \
+        } \
       /* 2. malloc & copy */ \
-      thread_param->string_copied = eina_mempool_malloc(_mp_default, sizeof(char *) * count); \
-      if (thread_param->string_copied) { \
-         memset(thread_param->string_copied, 0x00, sizeof(char *) * count); \
-            for (i = 0, len = 0; i < count; i++) { \
-               if (length) len = length[i]; \
-               else        len = strlen(string[i]); \
-               thread_param->string_copied[i] = eina_mempool_malloc(_mp_default, len + 1); \
-               if (thread_param->string_copied[i]) { \
-                  memcpy(thread_param->string_copied[i], string[i], len + 1); \
-               } \
-               else { \
-                  thread_mode = EVAS_GL_THREAD_MODE_FINISH; \
-                  goto finish; \
-               } \
-            } \
-      } \
-      else { \
-         thread_mode = EVAS_GL_THREAD_MODE_FINISH; \
-         goto finish; \
-      } \
+      thread_data->string_copied = eina_mempool_malloc(_mp_default, sizeof(char *) * count); \
+      if (thread_data->string_copied) \
+        { \
+           memset(thread_data->string_copied, 0x00, sizeof(char *) * count); \
+           for (i = 0, len = 0; i < count; i++) \
+             { \
+                if (length) len = length[i]; \
+                else        len = strlen(string[i]); \
+                thread_data->string_copied[i] = eina_mempool_malloc(_mp_default, len + 1); \
+                if (thread_data->string_copied[i]) \
+                  { \
+                     memcpy(thread_data->string_copied[i], string[i], len + 1); \
+                  } \
+                else \
+                  { \
+                     thread_mode = EVAS_GL_THREAD_MODE_FINISH; \
+                     goto finish; \
+                  } \
+             } \
+        } \
+      else \
+        { \
+           thread_mode = EVAS_GL_THREAD_MODE_FINISH; \
+           goto finish; \
+        } \
       /* 3. replace */ \
-      thread_param->string = (const GLchar **)thread_param->string_copied; \
+      thread_data->string = (const GLchar **)thread_data->string_copied; \
    }
 
-static int getSize(GLenum format, GLenum type)
+static int
+get_size(GLenum format, GLenum type)
 {
    int csize = 0, comp = 0;
-   switch(type)
-   {
+   switch (type)
+     {
 #ifdef GL_UNSIGNED_BYTE_3_3_2
-      case GL_UNSIGNED_BYTE_3_3_2:
+        case GL_UNSIGNED_BYTE_3_3_2:         csize = sizeof(GLubyte); comp = 1; break;
 #endif
 #ifdef GL_UNSIGNED_BYTE_2_3_3
-     case GL_UNSIGNED_BYTE_2_3_3:
+        case GL_UNSIGNED_BYTE_2_3_3:         csize = sizeof(GLubyte); comp = 1; break;
 #endif
-         csize = 1; comp = 1;
 
 #ifdef GL_UNSIGNED_SHORT_5_6_5
-      case GL_UNSIGNED_SHORT_5_6_5:
+        case GL_UNSIGNED_SHORT_5_6_5:        csize = sizeof(GLushort); comp = 1; break;
 #endif
-
 #ifdef GL_UNSIGNED_SHORT_5_6_5_REV
-     case GL_UNSIGNED_SHORT_5_6_5_REV:
+        case GL_UNSIGNED_SHORT_5_6_5_REV:    csize = sizeof(GLushort); comp = 1; break;
 #endif
-
 #ifdef GL_UNSIGNED_SHORT_4_4_4_4
-      case GL_UNSIGNED_SHORT_4_4_4_4:
+        case GL_UNSIGNED_SHORT_4_4_4_4:      csize = sizeof(GLushort); comp = 1; break;
 #endif
-
 #ifdef GL_UNSIGNED_SHORT_4_4_4_4_REV
-     case GL_UNSIGNED_SHORT_4_4_4_4_REV:
+        case GL_UNSIGNED_SHORT_4_4_4_4_REV:  csize = sizeof(GLushort); comp = 1; break;
 #endif
-
 #ifdef GL_UNSIGNED_SHORT_5_5_5_1
-      case GL_UNSIGNED_SHORT_5_5_5_1:
+        case GL_UNSIGNED_SHORT_5_5_5_1:      csize = sizeof(GLushort); comp = 1; break;
 #endif
-
 #ifdef GL_UNSIGNED_SHORT_1_5_5_5_REV
-     case GL_UNSIGNED_SHORT_1_5_5_5_REV:
+        case GL_UNSIGNED_SHORT_1_5_5_5_REV:  csize = sizeof(GLushort); comp = 1; break;
 #endif
-         csize = 2; comp = 1;
 
 #ifdef GL_UNSIGNED_INT_8_8_8_8
-      case GL_UNSIGNED_INT_8_8_8_8:
+        case GL_UNSIGNED_INT_8_8_8_8:        csize = sizeof(GLuint); comp = 1; break;
 #endif
-
 #ifdef GL_UNSIGNED_INT_8_8_8_8_REV
-     case GL_UNSIGNED_INT_8_8_8_8_REV:
+        case GL_UNSIGNED_INT_8_8_8_8_REV:    csize = sizeof(GLuint); comp = 1; break;
 #endif
-
 #ifdef GL_UNSIGNED_INT_10_10_10_2
-      case GL_UNSIGNED_INT_10_10_10_2:
+        case GL_UNSIGNED_INT_10_10_10_2:     csize = sizeof(GLuint); comp = 1; break;
 #endif
-
 #ifdef GL_UNSIGNED_INT_2_10_10_10_REV
-     case GL_UNSIGNED_INT_2_10_10_10_REV:
+        case GL_UNSIGNED_INT_2_10_10_10_REV: csize = sizeof(GLuint); comp = 1; break;
 #endif
-         csize = 4; comp = 1;
 
-      case GL_UNSIGNED_BYTE: case GL_BYTE:
-         csize = 1;
-#ifdef GL_UNGINED_SHORT
-      case GL_UNGINED_SHORT:
-#endif
-     case GL_SHORT:
-         csize = 2;
-      case GL_UNSIGNED_INT: case GL_INT:
-         csize = 4;
-      case GL_FLOAT:
-         csize = sizeof(float);
-      default:
-         return -1;
-   }
+        case GL_UNSIGNED_BYTE:
+        case GL_BYTE:
+           csize = sizeof(GLbyte);
+           break;
+
+        case GL_UNSIGNED_SHORT:
+        case GL_SHORT:
+           csize = sizeof(GLshort);
+           break;
 
-   if (comp == 0) {
-      switch(format)
-      {
-         case GL_RED: case GL_RG:
-            comp = 1;
-         case GL_RGB: case GL_BGR:
-         case GL_RGBA: case GL_BGRA:
-         case GL_RED_INTEGER: case GL_RG_INTEGER: case GL_RGB_INTEGER:
+        case GL_UNSIGNED_INT:
+        case GL_INT:
+           csize = sizeof(GLint);
+           break;
+
+        case GL_FLOAT:
+           csize = sizeof(GLfloat);
+           break;
+
+        default:
+           return -1;
+     }
+
+   if (comp == 0)
+     {
+        switch (format)
+          {
+             case GL_RED:
+             case GL_RED_INTEGER:
+                comp = 1;
+                break;
+
+             case GL_RG:
+             case GL_RG_INTEGER:
+                comp = 2;
+                break;
+
+             case GL_RGB:
+             case GL_RGB_INTEGER:
+             case GL_BGR:
 #ifdef GL_BGR_INTEGER
-         case GL_BGR_INTEGER:
+             case GL_BGR_INTEGER:
 #endif
-         case GL_RGBA_INTEGER:
+                comp = 3;
+                break;
+
+             case GL_RGBA:
+             case GL_BGRA:
+             case GL_RGBA_INTEGER:
 #ifdef GL_BGRA_INTEGER
-         case GL_BGRA_INTEGER:
+             case GL_BGRA_INTEGER:
 #endif
-            comp = 1;
-         default:
-            return -1;
-      }
-   }
+                comp = 4;
+                break;
+
+             default:
+                return -1;
+          }
+     }
 
    return csize * comp;
 }
@@ -157,129 +180,147 @@ static int getSize(GLenum format, GLenum type)
 
 #define GLTEXIMAGE2D_COPY_VARIABLE void *pixels_copied
 #define GLTEXIMAGE2D_COPY_VARIABLE_FREE \
-   if (thread_param->pixels_copied) \
-     eina_mempool_free(_mp_texture, thread_param->pixels_copied);
+   if (thread_data->pixels_copied) \
+      eina_mempool_free(_mp_texture, thread_data->pixels_copied);
 
 #define GLTEXIMAGE2D_COPY_VARIABLE_INIT \
-   thread_param->pixels_copied = NULL;
+   thread_data->pixels_copied = NULL;
 
 #define GLTEXIMAGE2D_COPY_TO_MEMPOOL \
-   int size = getSize(format, type); \
-   if (size < 0) { \
-      thread_mode = EVAS_GL_THREAD_MODE_FINISH; \
-      goto finish; \
-   } \
-   if (pixels) { \
-      /* 1. check memory size */ \
-      unsigned int copy_size = (width + (border * 2)) * (height + (border * 2)) * size; \
-      if (copy_size > _mp_texture_memory_size) { \
-         thread_mode = EVAS_GL_THREAD_MODE_FINISH; \
-         goto finish; \
-     } \
-      /* 2. malloc & copy */ \
-      thread_param->pixels_copied = eina_mempool_malloc(_mp_texture, copy_size); \
-     if (thread_param->pixels_copied) { \
-         memcpy(thread_param->pixels_copied, pixels, copy_size); \
+   int size = get_size(format, type); \
+   if (size < 0) \
+     { \
+        thread_mode = EVAS_GL_THREAD_MODE_FINISH; \
+        goto finish; \
      } \
-     else { \
-         thread_mode = EVAS_GL_THREAD_MODE_FINISH; \
-         goto finish; \
-     } \
-      /* 3. replace */ \
-     thread_param->pixels = (const void *)thread_param->pixels_copied; \
-   }
+   if (pixels) \
+     { \
+        /* 1. check memory size */ \
+        unsigned int copy_size = (width + (border * 2)) * (height + (border * 2)) * size; \
+        if (copy_size > _mp_texture_memory_size) \
+          { \
+             thread_mode = EVAS_GL_THREAD_MODE_FINISH; \
+             goto finish; \
+          } \
+        /* 2. malloc & copy */ \
+        thread_data->pixels_copied = eina_mempool_malloc(_mp_texture, copy_size); \
+        if (thread_data->pixels_copied) \
+          { \
+             memcpy(thread_data->pixels_copied, pixels, copy_size); \
+          } \
+        else \
+          { \
+             thread_mode = EVAS_GL_THREAD_MODE_FINISH; \
+             goto finish; \
+          } \
+        /* 3. replace */ \
+        thread_data->pixels = (const void *)thread_data->pixels_copied; \
+     }
 
 
 #define GLTEXSUBIMAGE2D_COPY_VARIABLE void *pixels_copied
 #define GLTEXSUBIMAGE2D_COPY_VARIABLE_FREE \
-   if (thread_param->pixels_copied) \
-     eina_mempool_free(_mp_texture, thread_param->pixels_copied);
+   if (thread_data->pixels_copied) \
+      eina_mempool_free(_mp_texture, thread_data->pixels_copied);
 
 #define GLTEXSUBIMAGE2D_COPY_VARIABLE_INIT \
-   thread_param->pixels_copied = NULL;
+   thread_data->pixels_copied = NULL;
 
 #define GLTEXSUBIMAGE2D_COPY_TO_MEMPOOL \
-   int size = getSize(format, type); \
-   if (size < 0) { \
-      thread_mode = EVAS_GL_THREAD_MODE_FINISH; \
-      goto finish; \
-   } \
-   if (pixels) { \
-      /* 1. check memory size */ \
-      unsigned int copy_size = width * height * size; \
-      if (copy_size > _mp_texture_memory_size) { \
-         thread_mode = EVAS_GL_THREAD_MODE_FINISH; \
-         goto finish; \
-     } \
-      /* 2. malloc & copy */ \
-      thread_param->pixels_copied = eina_mempool_malloc(_mp_texture, copy_size); \
-     if (thread_param->pixels_copied) { \
-         memcpy(thread_param->pixels_copied, pixels, copy_size); \
-     } \
-     else { \
-         thread_mode = EVAS_GL_THREAD_MODE_FINISH; \
-         goto finish; \
+   int size = get_size(format, type); \
+   if (size < 0) \
+     { \
+        thread_mode = EVAS_GL_THREAD_MODE_FINISH; \
+        goto finish; \
      } \
-      /* 3. replace */ \
-     thread_param->pixels = (const void *)thread_param->pixels_copied; \
-   }
+   if (pixels) \
+     { \
+        /* 1. check memory size */ \
+        unsigned int copy_size = width * height * size; \
+        if (copy_size > _mp_texture_memory_size) \
+          { \
+             thread_mode = EVAS_GL_THREAD_MODE_FINISH; \
+             goto finish; \
+          } \
+        /* 2. malloc & copy */ \
+        thread_data->pixels_copied = eina_mempool_malloc(_mp_texture, copy_size); \
+        if (thread_data->pixels_copied) \
+          { \
+             memcpy(thread_data->pixels_copied, pixels, copy_size); \
+          } \
+        else \
+          { \
+             thread_mode = EVAS_GL_THREAD_MODE_FINISH; \
+             goto finish; \
+          } \
+        /* 3. replace */ \
+        thread_data->pixels = (const void *)thread_data->pixels_copied; \
+     }
 
 #define GLCOMPRESSEDTEXIMAGE2D_COPY_VARIABLE void *data_copied
 #define GLCOMPRESSEDTEXIMAGE2D_COPY_VARIABLE_FREE \
-   if (thread_param->data_copied) \
-      eina_mempool_free(_mp_texture, thread_param->data_copied);
+   if (thread_data->data_copied) \
+      eina_mempool_free(_mp_texture, thread_data->data_copied);
 
 #define GLCOMPRESSEDTEXIMAGE2D_COPY_VARIABLE_INIT \
-   thread_param->data_copied = NULL;
+   thread_data->data_copied = NULL;
 
 #define GLCOMPRESSEDTEXIMAGE2D_COPY_TO_MEMPOOL \
-    if (data) { \
-      /* 1. check memory size */ \
-      if ((unsigned int)imageSize > _mp_texture_memory_size) { \
-         thread_mode = EVAS_GL_THREAD_MODE_FINISH; \
-         goto finish; \
-      } \
-      /* 2. malloc & copy */ \
-      thread_param->data_copied = eina_mempool_malloc(_mp_texture, imageSize); \
-      if (thread_param->data_copied) { \
-         memcpy(thread_param->data_copied, data, imageSize); \
-      } \
-      else { \
-         thread_mode = EVAS_GL_THREAD_MODE_FINISH; \
-         goto finish; \
-      } \
-      /* 3. replace */ \
-      thread_param->data = (const void *)thread_param->data_copied; \
-   }
+   if (data) \
+     { \
+        /* 1. check memory size */ \
+        if ((unsigned int)imageSize > _mp_texture_memory_size) \
+          { \
+             thread_mode = EVAS_GL_THREAD_MODE_FINISH; \
+             goto finish; \
+          } \
+        /* 2. malloc & copy */ \
+        thread_data->data_copied = eina_mempool_malloc(_mp_texture, imageSize); \
+        if (thread_data->data_copied) \
+          { \
+             memcpy(thread_data->data_copied, data, imageSize); \
+          } \
+        else \
+          { \
+             thread_mode = EVAS_GL_THREAD_MODE_FINISH; \
+             goto finish; \
+          } \
+        /* 3. replace */ \
+        thread_data->data = (const void *)thread_data->data_copied; \
+     }
 
 
 #define GLCOMPRESSEDTEXSUBIMAGE2D_COPY_VARIABLE void *data_copied
 #define GLCOMPRESSEDTEXSUBIMAGE2D_COPY_VARIABLE_FREE \
-   if (thread_param->data_copied) \
-      eina_mempool_free(_mp_texture, thread_param->data_copied);
+   if (thread_data->data_copied) \
+      eina_mempool_free(_mp_texture, thread_data->data_copied);
 
 #define GLCOMPRESSEDTEXSUBIMAGE2D_COPY_VARIABLE_INIT \
-   thread_param->data_copied = NULL;
+   thread_data->data_copied = NULL;
 
 #define GLCOMPRESSEDTEXSUBIMAGE2D_COPY_TO_MEMPOOL \
-    if (data) { \
-      /* 1. check memory size */ \
-      if ((unsigned int)imageSize > _mp_texture_memory_size) { \
-         thread_mode = EVAS_GL_THREAD_MODE_FINISH; \
-         goto finish; \
-      } \
-      /* 2. malloc & copy */ \
-      thread_param->data_copied = eina_mempool_malloc(_mp_texture, imageSize); \
-      if (thread_param->data_copied) { \
-         memcpy(thread_param->data_copied, data, imageSize); \
-      } \
-      else { \
-         thread_mode = EVAS_GL_THREAD_MODE_FINISH; \
-         goto finish; \
-      } \
-      /* 3. replace */ \
-      thread_param->data = (const void *)thread_param->data_copied; \
-   }
+   if (data) \
+     { \
+        /* 1. check memory size */ \
+        if ((unsigned int)imageSize > _mp_texture_memory_size) \
+          { \
+             thread_mode = EVAS_GL_THREAD_MODE_FINISH; \
+             goto finish; \
+          } \
+        /* 2. malloc & copy */ \
+        thread_data->data_copied = eina_mempool_malloc(_mp_texture, imageSize); \
+        if (thread_data->data_copied) \
+          { \
+             memcpy(thread_data->data_copied, data, imageSize); \
+          } \
+        else \
+          { \
+             thread_mode = EVAS_GL_THREAD_MODE_FINISH; \
+             goto finish; \
+          } \
+        /* 3. replace */ \
+        thread_data->data = (const void *)thread_data->data_copied; \
+     }
 
 
 #include "evas_gl_thread_gl_generated.c"
@@ -297,34 +338,34 @@ glTexSubImage2DEVAS_thread_cmd(int thread_push, GLenum target, GLint level, GLin
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glTexSubImage2D thread_param_local;
-   Thread_Command_glTexSubImage2D *thread_param = &thread_param_local;
+   Evas_Thread_Command_glTexSubImage2D thread_data_local;
+   Evas_Thread_Command_glTexSubImage2D *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        Thread_Command_glTexSubImage2D *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(Thread_Command_glTexSubImage2D));
-        if (thread_param_new)
+        Evas_Thread_Command_glTexSubImage2D *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                               sizeof(Evas_Thread_Command_glTexSubImage2D));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->target = target;
-   thread_param->level = level;
-   thread_param->xoffset = xoffset;
-   thread_param->yoffset = yoffset;
-   thread_param->width = width;
-   thread_param->height = height;
-   thread_param->format = format;
-   thread_param->type = type;
-   thread_param->pixels = pixels;
+   thread_data->target = target;
+   thread_data->level = level;
+   thread_data->xoffset = xoffset;
+   thread_data->yoffset = yoffset;
+   thread_data->width = width;
+   thread_data->height = height;
+   thread_data->format = format;
+   thread_data->type = type;
+   thread_data->pixels = pixels;
 
    GLTEXSUBIMAGE2D_COPY_VARIABLE_INIT; /* TODO */
 
@@ -344,12 +385,12 @@ glTexSubImage2DEVAS_thread_cmd(int thread_push, GLenum target, GLint level, GLin
 finish:
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glTexSubImage2D,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 
-#else  /* ! EVAS_GL_RENDER_THREAD_IS_GENERIC */
+#else  /* ! EVAS_GL_RENDER_THREAD_COMPILE_FOR_GL_GENERIC */
 
 
 #include <dlfcn.h>
@@ -358,4 +399,17 @@ finish:
 
 void (*glTexSubImage2DEVAS_thread_cmd)(int thread_push, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels) = NULL;
 
-#endif /* EVAS_GL_RENDER_THREAD_IS_GENERIC */
+void
+_gl_thread_link_init()
+{
+#define LINK2GENERIC(sym) \
+   sym = dlsym(RTLD_DEFAULT, #sym); \
+   if (!sym) ERR("Could not find function '%s'", #sym);
+
+   LINK2GENERIC(glGetError_thread_cmd);
+
+   _gl_thread_link_gl_generated_init();
+   _gl_thread_link_evgl_generated_init();
+}
+
+#endif /* EVAS_GL_RENDER_THREAD_COMPILE_FOR_GL_GENERIC */

diff --git a/src/modules/evas/engines/gl_common/evas_gl_thread_gl.h b/src/modules/evas/engines/gl_common/evas_gl_thread_gl.h
index db12337..221d3f5 100644 (file)
--- a/src/modules/evas/engines/gl_common/evas_gl_thread_gl.h
+++ b/src/modules/evas/engines/gl_common/evas_gl_thread_gl.h
@@ -1,7 +1,7 @@
 #ifndef EVAS_GL_THREAD_GL_H
 #define EVAS_GL_THREAD_GL_H
 
-#ifdef EVAS_GL_RENDER_THREAD_IS_GENERIC
+#ifdef EVAS_GL_RENDER_THREAD_COMPILE_FOR_GL_GENERIC
 
 #ifndef TIZEN
 /* We should clear platform dependencies for Evas_GL.h */
@@ -42,7 +42,7 @@ typedef uint64_t EvasGLuint64;
 EAPI void
 glTexSubImage2DEVAS_thread_cmd(int thread_push, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels);
 
-#else /* ! EVAS_GL_RENDER_THREAD_IS_GENERIC */
+#else /* ! EVAS_GL_RENDER_THREAD_COMPILE_FOR_GL_GENERIC */
 
 
 # include "evas_gl_thread_gl_link_generated.h"
@@ -50,6 +50,8 @@ glTexSubImage2DEVAS_thread_cmd(int thread_push, GLenum target, GLint level, GLin
 
 extern void (*glTexSubImage2DEVAS_thread_cmd)(int thread_push, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels);
 
-#endif /* EVAS_GL_RENDER_THREAD_IS_GENERIC */
+extern void _gl_thread_link_init();
+
+#endif /* EVAS_GL_RENDER_THREAD_COMPILE_FOR_GL_GENERIC */
 
 #endif /* EVAS_GL_THREAD_GL_H */

diff --git a/src/modules/evas/engines/gl_common/evas_gl_thread_gl_generated.c b/src/modules/evas/engines/gl_common/evas_gl_thread_gl_generated.c
index 5675e57..6e3b03e 100644 (file)
--- a/src/modules/evas/engines/gl_common/evas_gl_thread_gl_generated.c
+++ b/src/modules/evas/engines/gl_common/evas_gl_thread_gl_generated.c
@@ -1,24 +1,28 @@
-/* DO NOT MODIFY THIS FILE AS IT IS AUTO-GENERATED */
-
+/*
+ * This is an automatically generated file using a python script.
+ * ($EFL_HOME/src/utils/evas/generate_gl_thread_api.py)
+ * Recommend that you modify data files ($EFL_HOME/src/utils/evas/gl_api_def.txt)
+ * and make use of scripts if you need to fix them.
+ */
 
 /*
-   GLenum
-   glGetError(void);
+ * GLenum
+ * glGetError(void);
  */
 
 typedef struct
 {
    GLenum return_value;
 
-} Thread_Command_glGetError;
+} Evas_Thread_Command_glGetError;
 
 static void
 _gl_thread_glGetError(void *data)
 {
-   Thread_Command_glGetError *thread_param =
-      (Thread_Command_glGetError *)data;
+   Evas_Thread_Command_glGetError *thread_data =
+      (Evas_Thread_Command_glGetError *)data;
 
-   thread_param->return_value = glGetError();
+   thread_data->return_value = glGetError();
 
 }
 
@@ -32,21 +36,21 @@ glGetError_thread_cmd(void)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glGetError thread_param_local;
-   Thread_Command_glGetError *thread_param = &thread_param_local;
+   Evas_Thread_Command_glGetError thread_data_local;
+   Evas_Thread_Command_glGetError *thread_data = &thread_data_local;
 
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glGetError,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
-   void
-   glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void *pointer);
+ * void
+ * glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void *pointer);
  */
 
 typedef struct
@@ -58,20 +62,20 @@ typedef struct
    GLsizei stride;
    const void *pointer;
 
-} Thread_Command_glVertexAttribPointer;
+} Evas_Thread_Command_glVertexAttribPointer;
 
 static void
 _gl_thread_glVertexAttribPointer(void *data)
 {
-   Thread_Command_glVertexAttribPointer *thread_param =
-      (Thread_Command_glVertexAttribPointer *)data;
+   Evas_Thread_Command_glVertexAttribPointer *thread_data =
+      (Evas_Thread_Command_glVertexAttribPointer *)data;
 
-   glVertexAttribPointer(thread_param->index,
-                         thread_param->size,
-                         thread_param->type,
-                         thread_param->normalized,
-                         thread_param->stride,
-                         thread_param->pointer);
+   glVertexAttribPointer(thread_data->index,
+                         thread_data->size,
+                         thread_data->type,
+                         thread_data->normalized,
+                         thread_data->stride,
+                         thread_data->pointer);
 
 }
 
@@ -86,25 +90,25 @@ glVertexAttribPointer_thread_cmd(GLuint index, GLint size, GLenum type, GLboolea
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glVertexAttribPointer thread_param_local;
-   Thread_Command_glVertexAttribPointer *thread_param = &thread_param_local;
+   Evas_Thread_Command_glVertexAttribPointer thread_data_local;
+   Evas_Thread_Command_glVertexAttribPointer *thread_data = &thread_data_local;
 
-   thread_param->index = index;
-   thread_param->size = size;
-   thread_param->type = type;
-   thread_param->normalized = normalized;
-   thread_param->stride = stride;
-   thread_param->pointer = pointer;
+   thread_data->index = index;
+   thread_data->size = size;
+   thread_data->type = type;
+   thread_data->normalized = normalized;
+   thread_data->stride = stride;
+   thread_data->pointer = pointer;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glVertexAttribPointer,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glEnableVertexAttribArray(GLuint index);
+ * void
+ * glEnableVertexAttribArray(GLuint index);
  */
 
 typedef struct
@@ -112,18 +116,18 @@ typedef struct
    GLuint index;
    int command_allocated;
 
-} Thread_Command_glEnableVertexAttribArray;
+} Evas_Thread_Command_glEnableVertexAttribArray;
 
 static void
 _gl_thread_glEnableVertexAttribArray(void *data)
 {
-   Thread_Command_glEnableVertexAttribArray *thread_param =
-      (Thread_Command_glEnableVertexAttribArray *)data;
+   Evas_Thread_Command_glEnableVertexAttribArray *thread_data =
+      (Evas_Thread_Command_glEnableVertexAttribArray *)data;
 
-   glEnableVertexAttribArray(thread_param->index);
+   glEnableVertexAttribArray(thread_data->index);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -137,36 +141,36 @@ glEnableVertexAttribArray_thread_cmd(GLuint index)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glEnableVertexAttribArray thread_param_local;
-   Thread_Command_glEnableVertexAttribArray *thread_param = &thread_param_local;
+   Evas_Thread_Command_glEnableVertexAttribArray thread_data_local;
+   Evas_Thread_Command_glEnableVertexAttribArray *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        Thread_Command_glEnableVertexAttribArray *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(Thread_Command_glEnableVertexAttribArray));
-        if (thread_param_new)
+        Evas_Thread_Command_glEnableVertexAttribArray *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(Evas_Thread_Command_glEnableVertexAttribArray));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_ENQUEUE;
           }
      }
 
-   thread_param->index = index;
+   thread_data->index = index;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glEnableVertexAttribArray,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glDisableVertexAttribArray(GLuint index);
+ * void
+ * glDisableVertexAttribArray(GLuint index);
  */
 
 typedef struct
@@ -174,18 +178,18 @@ typedef struct
    GLuint index;
    int command_allocated;
 
-} Thread_Command_glDisableVertexAttribArray;
+} Evas_Thread_Command_glDisableVertexAttribArray;
 
 static void
 _gl_thread_glDisableVertexAttribArray(void *data)
 {
-   Thread_Command_glDisableVertexAttribArray *thread_param =
-      (Thread_Command_glDisableVertexAttribArray *)data;
+   Evas_Thread_Command_glDisableVertexAttribArray *thread_data =
+      (Evas_Thread_Command_glDisableVertexAttribArray *)data;
 
-   glDisableVertexAttribArray(thread_param->index);
+   glDisableVertexAttribArray(thread_data->index);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -199,36 +203,36 @@ glDisableVertexAttribArray_thread_cmd(GLuint index)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glDisableVertexAttribArray thread_param_local;
-   Thread_Command_glDisableVertexAttribArray *thread_param = &thread_param_local;
+   Evas_Thread_Command_glDisableVertexAttribArray thread_data_local;
+   Evas_Thread_Command_glDisableVertexAttribArray *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        Thread_Command_glDisableVertexAttribArray *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(Thread_Command_glDisableVertexAttribArray));
-        if (thread_param_new)
+        Evas_Thread_Command_glDisableVertexAttribArray *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(Evas_Thread_Command_glDisableVertexAttribArray));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_ENQUEUE;
           }
      }
 
-   thread_param->index = index;
+   thread_data->index = index;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glDisableVertexAttribArray,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glDrawArrays(GLenum mode, GLint first, GLsizei count);
+ * void
+ * glDrawArrays(GLenum mode, GLint first, GLsizei count);
  */
 
 typedef struct
@@ -237,17 +241,17 @@ typedef struct
    GLint first;
    GLsizei count;
 
-} Thread_Command_glDrawArrays;
+} Evas_Thread_Command_glDrawArrays;
 
 static void
 _gl_thread_glDrawArrays(void *data)
 {
-   Thread_Command_glDrawArrays *thread_param =
-      (Thread_Command_glDrawArrays *)data;
+   Evas_Thread_Command_glDrawArrays *thread_data =
+      (Evas_Thread_Command_glDrawArrays *)data;
 
-   glDrawArrays(thread_param->mode,
-                thread_param->first,
-                thread_param->count);
+   glDrawArrays(thread_data->mode,
+                thread_data->first,
+                thread_data->count);
 
 }
 
@@ -262,22 +266,22 @@ glDrawArrays_thread_cmd(GLenum mode, GLint first, GLsizei count)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glDrawArrays thread_param_local;
-   Thread_Command_glDrawArrays *thread_param = &thread_param_local;
+   Evas_Thread_Command_glDrawArrays thread_data_local;
+   Evas_Thread_Command_glDrawArrays *thread_data = &thread_data_local;
 
-   thread_param->mode = mode;
-   thread_param->first = first;
-   thread_param->count = count;
+   thread_data->mode = mode;
+   thread_data->first = first;
+   thread_data->count = count;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glDrawArrays,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glDrawElements(GLenum mode, GLsizei count, GLenum type, const void *indices);
+ * void
+ * glDrawElements(GLenum mode, GLsizei count, GLenum type, const void *indices);
  */
 
 typedef struct
@@ -287,18 +291,18 @@ typedef struct
    GLenum type;
    const void *indices;
 
-} Thread_Command_glDrawElements;
+} Evas_Thread_Command_glDrawElements;
 
 static void
 _gl_thread_glDrawElements(void *data)
 {
-   Thread_Command_glDrawElements *thread_param =
-      (Thread_Command_glDrawElements *)data;
+   Evas_Thread_Command_glDrawElements *thread_data =
+      (Evas_Thread_Command_glDrawElements *)data;
 
-   glDrawElements(thread_param->mode,
-                  thread_param->count,
-                  thread_param->type,
-                  thread_param->indices);
+   glDrawElements(thread_data->mode,
+                  thread_data->count,
+                  thread_data->type,
+                  thread_data->indices);
 
 }
 
@@ -313,23 +317,23 @@ glDrawElements_thread_cmd(GLenum mode, GLsizei count, GLenum type, const void *i
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glDrawElements thread_param_local;
-   Thread_Command_glDrawElements *thread_param = &thread_param_local;
+   Evas_Thread_Command_glDrawElements thread_data_local;
+   Evas_Thread_Command_glDrawElements *thread_data = &thread_data_local;
 
-   thread_param->mode = mode;
-   thread_param->count = count;
-   thread_param->type = type;
-   thread_param->indices = indices;
+   thread_data->mode = mode;
+   thread_data->count = count;
+   thread_data->type = type;
+   thread_data->indices = indices;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glDrawElements,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGenBuffers(GLsizei n, GLuint *buffers);
+ * void
+ * glGenBuffers(GLsizei n, GLuint *buffers);
  */
 
 typedef struct
@@ -337,16 +341,16 @@ typedef struct
    GLsizei n;
    GLuint *buffers;
 
-} Thread_Command_glGenBuffers;
+} Evas_Thread_Command_glGenBuffers;
 
 static void
 _gl_thread_glGenBuffers(void *data)
 {
-   Thread_Command_glGenBuffers *thread_param =
-      (Thread_Command_glGenBuffers *)data;
+   Evas_Thread_Command_glGenBuffers *thread_data =
+      (Evas_Thread_Command_glGenBuffers *)data;
 
-   glGenBuffers(thread_param->n,
-                thread_param->buffers);
+   glGenBuffers(thread_data->n,
+                thread_data->buffers);
 
 }
 
@@ -361,21 +365,21 @@ glGenBuffers_thread_cmd(GLsizei n, GLuint *buffers)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glGenBuffers thread_param_local;
-   Thread_Command_glGenBuffers *thread_param = &thread_param_local;
+   Evas_Thread_Command_glGenBuffers thread_data_local;
+   Evas_Thread_Command_glGenBuffers *thread_data = &thread_data_local;
 
-   thread_param->n = n;
-   thread_param->buffers = buffers;
+   thread_data->n = n;
+   thread_data->buffers = buffers;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glGenBuffers,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glDeleteBuffers(GLsizei n, const GLuint *buffers);
+ * void
+ * glDeleteBuffers(GLsizei n, const GLuint *buffers);
  */
 
 typedef struct
@@ -385,23 +389,23 @@ typedef struct
    void *buffers_copied; /* COPIED */
    int command_allocated;
 
-} Thread_Command_glDeleteBuffers;
+} Evas_Thread_Command_glDeleteBuffers;
 
 static void
 _gl_thread_glDeleteBuffers(void *data)
 {
-   Thread_Command_glDeleteBuffers *thread_param =
-      (Thread_Command_glDeleteBuffers *)data;
+   Evas_Thread_Command_glDeleteBuffers *thread_data =
+      (Evas_Thread_Command_glDeleteBuffers *)data;
 
-   glDeleteBuffers(thread_param->n,
-                   thread_param->buffers);
+   glDeleteBuffers(thread_data->n,
+                   thread_data->buffers);
 
 
-   if (thread_param->buffers_copied)
-     eina_mempool_free(_mp_delete_object, thread_param->buffers_copied);
+   if (thread_data->buffers_copied)
+     eina_mempool_free(_mp_delete_object, thread_data->buffers_copied);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -415,29 +419,29 @@ glDeleteBuffers_thread_cmd(GLsizei n, const GLuint *buffers)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glDeleteBuffers thread_param_local;
-   Thread_Command_glDeleteBuffers *thread_param = &thread_param_local;
+   Evas_Thread_Command_glDeleteBuffers thread_data_local;
+   Evas_Thread_Command_glDeleteBuffers *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        Thread_Command_glDeleteBuffers *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(Thread_Command_glDeleteBuffers));
-        if (thread_param_new)
+        Evas_Thread_Command_glDeleteBuffers *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(Evas_Thread_Command_glDeleteBuffers));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->n = n;
-   thread_param->buffers = buffers;
+   thread_data->n = n;
+   thread_data->buffers = buffers;
 
-   thread_param->buffers_copied = NULL;
+   thread_data->buffers_copied = NULL;
    if (thread_mode == EVAS_GL_THREAD_MODE_FINISH)
      goto finish;
 
@@ -452,10 +456,10 @@ glDeleteBuffers_thread_cmd(GLsizei n, const GLuint *buffers)
              goto finish;
           }
         /* 2. malloc & copy */
-        thread_param->buffers_copied = eina_mempool_malloc(_mp_delete_object, copy_size);
-        if (thread_param->buffers_copied)
+        thread_data->buffers_copied = eina_mempool_malloc(_mp_delete_object, copy_size);
+        if (thread_data->buffers_copied)
           {
-             memcpy(thread_param->buffers_copied, buffers, copy_size);
+             memcpy(thread_data->buffers_copied, buffers, copy_size);
           }
         else
           {
@@ -463,20 +467,20 @@ glDeleteBuffers_thread_cmd(GLsizei n, const GLuint *buffers)
              goto finish;
           }
         /* 3. replace */
-        thread_param->buffers = (const GLuint  *)thread_param->buffers_copied;
+        thread_data->buffers = (const GLuint  *)thread_data->buffers_copied;
      }
    /* end of copy variable */
 
 finish:
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glDeleteBuffers,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glBindBuffer(GLenum target, GLuint buffer);
+ * void
+ * glBindBuffer(GLenum target, GLuint buffer);
  */
 
 typedef struct
@@ -485,19 +489,19 @@ typedef struct
    GLuint buffer;
    int command_allocated;
 
-} Thread_Command_glBindBuffer;
+} Evas_Thread_Command_glBindBuffer;
 
 static void
 _gl_thread_glBindBuffer(void *data)
 {
-   Thread_Command_glBindBuffer *thread_param =
-      (Thread_Command_glBindBuffer *)data;
+   Evas_Thread_Command_glBindBuffer *thread_data =
+      (Evas_Thread_Command_glBindBuffer *)data;
 
-   glBindBuffer(thread_param->target,
-                thread_param->buffer);
+   glBindBuffer(thread_data->target,
+                thread_data->buffer);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -511,37 +515,37 @@ glBindBuffer_thread_cmd(GLenum target, GLuint buffer)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glBindBuffer thread_param_local;
-   Thread_Command_glBindBuffer *thread_param = &thread_param_local;
+   Evas_Thread_Command_glBindBuffer thread_data_local;
+   Evas_Thread_Command_glBindBuffer *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        Thread_Command_glBindBuffer *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(Thread_Command_glBindBuffer));
-        if (thread_param_new)
+        Evas_Thread_Command_glBindBuffer *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(Evas_Thread_Command_glBindBuffer));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->target = target;
-   thread_param->buffer = buffer;
+   thread_data->target = target;
+   thread_data->buffer = buffer;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glBindBuffer,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glBufferData(GLenum target, GLsizeiptr size, const void *data, GLenum usage);
+ * void
+ * glBufferData(GLenum target, GLsizeiptr size, const void *data, GLenum usage);
  */
 
 typedef struct
@@ -551,18 +555,18 @@ typedef struct
    const void *data;
    GLenum usage;
 
-} Thread_Command_glBufferData;
+} Evas_Thread_Command_glBufferData;
 
 static void
 _gl_thread_glBufferData(void *data)
 {
-   Thread_Command_glBufferData *thread_param =
-      (Thread_Command_glBufferData *)data;
+   Evas_Thread_Command_glBufferData *thread_data =
+      (Evas_Thread_Command_glBufferData *)data;
 
-   glBufferData(thread_param->target,
-                thread_param->size,
-                thread_param->data,
-                thread_param->usage);
+   glBufferData(thread_data->target,
+                thread_data->size,
+                thread_data->data,
+                thread_data->usage);
 
 }
 
@@ -577,23 +581,23 @@ glBufferData_thread_cmd(GLenum target, GLsizeiptr size, const void *data, GLenum
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glBufferData thread_param_local;
-   Thread_Command_glBufferData *thread_param = &thread_param_local;
+   Evas_Thread_Command_glBufferData thread_data_local;
+   Evas_Thread_Command_glBufferData *thread_data = &thread_data_local;
 
-   thread_param->target = target;
-   thread_param->size = size;
-   thread_param->data = data;
-   thread_param->usage = usage;
+   thread_data->target = target;
+   thread_data->size = size;
+   thread_data->data = data;
+   thread_data->usage = usage;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glBufferData,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void *
-   glMapBuffer(GLenum target, GLenum access);
+ * void *
+ * glMapBuffer(GLenum target, GLenum access);
  */
 
 typedef struct
@@ -602,7 +606,7 @@ typedef struct
    GLenum target;
    GLenum access;
 
-} Thread_Command_glMapBuffer;
+} Evas_Thread_Command_glMapBuffer;
 
 void * (*orig_evas_glMapBuffer)(GLenum target, GLenum access);
 
@@ -621,11 +625,11 @@ glMapBuffer_orig_evas_get(void)
 static void
 _gl_thread_glMapBuffer(void *data)
 {
-   Thread_Command_glMapBuffer *thread_param =
-      (Thread_Command_glMapBuffer *)data;
+   Evas_Thread_Command_glMapBuffer *thread_data =
+      (Evas_Thread_Command_glMapBuffer *)data;
 
-   thread_param->return_value = orig_evas_glMapBuffer(thread_param->target,
-                                                      thread_param->access);
+   thread_data->return_value = orig_evas_glMapBuffer(thread_data->target,
+                                                     thread_data->access);
 
 }
 
@@ -639,23 +643,23 @@ glMapBuffer_thread_cmd(GLenum target, GLenum access)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glMapBuffer thread_param_local;
-   Thread_Command_glMapBuffer *thread_param = &thread_param_local;
+   Evas_Thread_Command_glMapBuffer thread_data_local;
+   Evas_Thread_Command_glMapBuffer *thread_data = &thread_data_local;
 
-   thread_param->target = target;
-   thread_param->access = access;
+   thread_data->target = target;
+   thread_data->access = access;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glMapBuffer,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
-   GLboolean
-   glUnmapBuffer(GLenum target);
+ * GLboolean
+ * glUnmapBuffer(GLenum target);
  */
 
 typedef struct
@@ -663,7 +667,7 @@ typedef struct
    GLboolean return_value;
    GLenum target;
 
-} Thread_Command_glUnmapBuffer;
+} Evas_Thread_Command_glUnmapBuffer;
 
 GLboolean (*orig_evas_glUnmapBuffer)(GLenum target);
 
@@ -682,10 +686,10 @@ glUnmapBuffer_orig_evas_get(void)
 static void
 _gl_thread_glUnmapBuffer(void *data)
 {
-   Thread_Command_glUnmapBuffer *thread_param =
-      (Thread_Command_glUnmapBuffer *)data;
+   Evas_Thread_Command_glUnmapBuffer *thread_data =
+      (Evas_Thread_Command_glUnmapBuffer *)data;
 
-   thread_param->return_value = orig_evas_glUnmapBuffer(thread_param->target);
+   thread_data->return_value = orig_evas_glUnmapBuffer(thread_data->target);
 
 }
 
@@ -699,22 +703,22 @@ glUnmapBuffer_thread_cmd(GLenum target)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glUnmapBuffer thread_param_local;
-   Thread_Command_glUnmapBuffer *thread_param = &thread_param_local;
+   Evas_Thread_Command_glUnmapBuffer thread_data_local;
+   Evas_Thread_Command_glUnmapBuffer *thread_data = &thread_data_local;
 
-   thread_param->target = target;
+   thread_data->target = target;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glUnmapBuffer,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
-   GLuint
-   glCreateShader(GLenum type);
+ * GLuint
+ * glCreateShader(GLenum type);
  */
 
 typedef struct
@@ -722,15 +726,15 @@ typedef struct
    GLuint return_value;
    GLenum type;
 
-} Thread_Command_glCreateShader;
+} Evas_Thread_Command_glCreateShader;
 
 static void
 _gl_thread_glCreateShader(void *data)
 {
-   Thread_Command_glCreateShader *thread_param =
-      (Thread_Command_glCreateShader *)data;
+   Evas_Thread_Command_glCreateShader *thread_data =
+      (Evas_Thread_Command_glCreateShader *)data;
 
-   thread_param->return_value = glCreateShader(thread_param->type);
+   thread_data->return_value = glCreateShader(thread_data->type);
 
 }
 
@@ -744,22 +748,22 @@ glCreateShader_thread_cmd(GLenum type)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glCreateShader thread_param_local;
-   Thread_Command_glCreateShader *thread_param = &thread_param_local;
+   Evas_Thread_Command_glCreateShader thread_data_local;
+   Evas_Thread_Command_glCreateShader *thread_data = &thread_data_local;
 
-   thread_param->type = type;
+   thread_data->type = type;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glCreateShader,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
-   void
-   glShaderSource(GLuint shader, GLsizei count, const GLchar **string, const GLint *length);
+ * void
+ * glShaderSource(GLuint shader, GLsizei count, const GLchar **string, const GLint *length);
  */
 
 typedef struct
@@ -771,23 +775,23 @@ typedef struct
    int command_allocated;
    GLSHADERSOURCE_COPY_VARIABLE; /* TODO */
 
-} Thread_Command_glShaderSource;
+} Evas_Thread_Command_glShaderSource;
 
 static void
 _gl_thread_glShaderSource(void *data)
 {
-   Thread_Command_glShaderSource *thread_param =
-      (Thread_Command_glShaderSource *)data;
+   Evas_Thread_Command_glShaderSource *thread_data =
+      (Evas_Thread_Command_glShaderSource *)data;
 
-   glShaderSource(thread_param->shader,
-                  thread_param->count,
-                  thread_param->string,
-                  thread_param->length);
+   glShaderSource(thread_data->shader,
+                  thread_data->count,
+                  thread_data->string,
+                  thread_data->length);
 
    GLSHADERSOURCE_COPY_VARIABLE_FREE; /* TODO */
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -801,29 +805,29 @@ glShaderSource_thread_cmd(GLuint shader, GLsizei count, const GLchar **string, c
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glShaderSource thread_param_local;
-   Thread_Command_glShaderSource *thread_param = &thread_param_local;
+   Evas_Thread_Command_glShaderSource thread_data_local;
+   Evas_Thread_Command_glShaderSource *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        Thread_Command_glShaderSource *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(Thread_Command_glShaderSource));
-        if (thread_param_new)
+        Evas_Thread_Command_glShaderSource *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(Evas_Thread_Command_glShaderSource));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->shader = shader;
-   thread_param->count = count;
-   thread_param->string = string;
-   thread_param->length = length;
+   thread_data->shader = shader;
+   thread_data->count = count;
+   thread_data->string = string;
+   thread_data->length = length;
 
    GLSHADERSOURCE_COPY_VARIABLE_INIT; /* TODO */
 
@@ -835,13 +839,13 @@ glShaderSource_thread_cmd(GLuint shader, GLsizei count, const GLchar **string, c
 finish:
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glShaderSource,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glCompileShader(GLuint shader);
+ * void
+ * glCompileShader(GLuint shader);
  */
 
 typedef struct
@@ -849,18 +853,18 @@ typedef struct
    GLuint shader;
    int command_allocated;
 
-} Thread_Command_glCompileShader;
+} Evas_Thread_Command_glCompileShader;
 
 static void
 _gl_thread_glCompileShader(void *data)
 {
-   Thread_Command_glCompileShader *thread_param =
-      (Thread_Command_glCompileShader *)data;
+   Evas_Thread_Command_glCompileShader *thread_data =
+      (Evas_Thread_Command_glCompileShader *)data;
 
-   glCompileShader(thread_param->shader);
+   glCompileShader(thread_data->shader);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -874,36 +878,36 @@ glCompileShader_thread_cmd(GLuint shader)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glCompileShader thread_param_local;
-   Thread_Command_glCompileShader *thread_param = &thread_param_local;
+   Evas_Thread_Command_glCompileShader thread_data_local;
+   Evas_Thread_Command_glCompileShader *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        Thread_Command_glCompileShader *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(Thread_Command_glCompileShader));
-        if (thread_param_new)
+        Evas_Thread_Command_glCompileShader *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(Evas_Thread_Command_glCompileShader));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->shader = shader;
+   thread_data->shader = shader;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glCompileShader,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glReleaseShaderCompiler(void);
+ * void
+ * glReleaseShaderCompiler(void);
  */
 
 void (*orig_evas_glReleaseShaderCompiler)(void);
@@ -945,8 +949,8 @@ glReleaseShaderCompiler_thread_cmd(void)
 }
 
 /*
-   void
-   glDeleteShader(GLuint shader);
+ * void
+ * glDeleteShader(GLuint shader);
  */
 
 typedef struct
@@ -954,18 +958,18 @@ typedef struct
    GLuint shader;
    int command_allocated;
 
-} Thread_Command_glDeleteShader;
+} Evas_Thread_Command_glDeleteShader;
 
 static void
 _gl_thread_glDeleteShader(void *data)
 {
-   Thread_Command_glDeleteShader *thread_param =
-      (Thread_Command_glDeleteShader *)data;
+   Evas_Thread_Command_glDeleteShader *thread_data =
+      (Evas_Thread_Command_glDeleteShader *)data;
 
-   glDeleteShader(thread_param->shader);
+   glDeleteShader(thread_data->shader);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -979,51 +983,51 @@ glDeleteShader_thread_cmd(GLuint shader)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glDeleteShader thread_param_local;
-   Thread_Command_glDeleteShader *thread_param = &thread_param_local;
+   Evas_Thread_Command_glDeleteShader thread_data_local;
+   Evas_Thread_Command_glDeleteShader *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        Thread_Command_glDeleteShader *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(Thread_Command_glDeleteShader));
-        if (thread_param_new)
+        Evas_Thread_Command_glDeleteShader *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(Evas_Thread_Command_glDeleteShader));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->shader = shader;
+   thread_data->shader = shader;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glDeleteShader,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   GLuint
-   glCreateProgram(void);
+ * GLuint
+ * glCreateProgram(void);
  */
 
 typedef struct
 {
    GLuint return_value;
 
-} Thread_Command_glCreateProgram;
+} Evas_Thread_Command_glCreateProgram;
 
 static void
 _gl_thread_glCreateProgram(void *data)
 {
-   Thread_Command_glCreateProgram *thread_param =
-      (Thread_Command_glCreateProgram *)data;
+   Evas_Thread_Command_glCreateProgram *thread_data =
+      (Evas_Thread_Command_glCreateProgram *)data;
 
-   thread_param->return_value = glCreateProgram();
+   thread_data->return_value = glCreateProgram();
 
 }
 
@@ -1037,21 +1041,21 @@ glCreateProgram_thread_cmd(void)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glCreateProgram thread_param_local;
-   Thread_Command_glCreateProgram *thread_param = &thread_param_local;
+   Evas_Thread_Command_glCreateProgram thread_data_local;
+   Evas_Thread_Command_glCreateProgram *thread_data = &thread_data_local;
 
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glCreateProgram,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
-   void
-   glAttachShader(GLuint program, GLuint shader);
+ * void
+ * glAttachShader(GLuint program, GLuint shader);
  */
 
 typedef struct
@@ -1060,19 +1064,19 @@ typedef struct
    GLuint shader;
    int command_allocated;
 
-} Thread_Command_glAttachShader;
+} Evas_Thread_Command_glAttachShader;
 
 static void
 _gl_thread_glAttachShader(void *data)
 {
-   Thread_Command_glAttachShader *thread_param =
-      (Thread_Command_glAttachShader *)data;
+   Evas_Thread_Command_glAttachShader *thread_data =
+      (Evas_Thread_Command_glAttachShader *)data;
 
-   glAttachShader(thread_param->program,
-                  thread_param->shader);
+   glAttachShader(thread_data->program,
+                  thread_data->shader);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -1086,37 +1090,37 @@ glAttachShader_thread_cmd(GLuint program, GLuint shader)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glAttachShader thread_param_local;
-   Thread_Command_glAttachShader *thread_param = &thread_param_local;
+   Evas_Thread_Command_glAttachShader thread_data_local;
+   Evas_Thread_Command_glAttachShader *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        Thread_Command_glAttachShader *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(Thread_Command_glAttachShader));
-        if (thread_param_new)
+        Evas_Thread_Command_glAttachShader *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(Evas_Thread_Command_glAttachShader));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->program = program;
-   thread_param->shader = shader;
+   thread_data->program = program;
+   thread_data->shader = shader;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glAttachShader,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glDetachShader(GLuint program, GLuint shader);
+ * void
+ * glDetachShader(GLuint program, GLuint shader);
  */
 
 typedef struct
@@ -1125,19 +1129,19 @@ typedef struct
    GLuint shader;
    int command_allocated;
 
-} Thread_Command_glDetachShader;
+} Evas_Thread_Command_glDetachShader;
 
 static void
 _gl_thread_glDetachShader(void *data)
 {
-   Thread_Command_glDetachShader *thread_param =
-      (Thread_Command_glDetachShader *)data;
+   Evas_Thread_Command_glDetachShader *thread_data =
+      (Evas_Thread_Command_glDetachShader *)data;
 
-   glDetachShader(thread_param->program,
-                  thread_param->shader);
+   glDetachShader(thread_data->program,
+                  thread_data->shader);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -1151,37 +1155,37 @@ glDetachShader_thread_cmd(GLuint program, GLuint shader)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glDetachShader thread_param_local;
-   Thread_Command_glDetachShader *thread_param = &thread_param_local;
+   Evas_Thread_Command_glDetachShader thread_data_local;
+   Evas_Thread_Command_glDetachShader *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        Thread_Command_glDetachShader *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(Thread_Command_glDetachShader));
-        if (thread_param_new)
+        Evas_Thread_Command_glDetachShader *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(Evas_Thread_Command_glDetachShader));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->program = program;
-   thread_param->shader = shader;
+   thread_data->program = program;
+   thread_data->shader = shader;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glDetachShader,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glLinkProgram(GLuint program);
+ * void
+ * glLinkProgram(GLuint program);
  */
 
 typedef struct
@@ -1189,18 +1193,18 @@ typedef struct
    GLuint program;
    int command_allocated;
 
-} Thread_Command_glLinkProgram;
+} Evas_Thread_Command_glLinkProgram;
 
 static void
 _gl_thread_glLinkProgram(void *data)
 {
-   Thread_Command_glLinkProgram *thread_param =
-      (Thread_Command_glLinkProgram *)data;
+   Evas_Thread_Command_glLinkProgram *thread_data =
+      (Evas_Thread_Command_glLinkProgram *)data;
 
-   glLinkProgram(thread_param->program);
+   glLinkProgram(thread_data->program);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -1214,36 +1218,36 @@ glLinkProgram_thread_cmd(GLuint program)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glLinkProgram thread_param_local;
-   Thread_Command_glLinkProgram *thread_param = &thread_param_local;
+   Evas_Thread_Command_glLinkProgram thread_data_local;
+   Evas_Thread_Command_glLinkProgram *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        Thread_Command_glLinkProgram *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(Thread_Command_glLinkProgram));
-        if (thread_param_new)
+        Evas_Thread_Command_glLinkProgram *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(Evas_Thread_Command_glLinkProgram));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->program = program;
+   thread_data->program = program;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glLinkProgram,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glUseProgram(GLuint program);
+ * void
+ * glUseProgram(GLuint program);
  */
 
 typedef struct
@@ -1251,18 +1255,18 @@ typedef struct
    GLuint program;
    int command_allocated;
 
-} Thread_Command_glUseProgram;
+} Evas_Thread_Command_glUseProgram;
 
 static void
 _gl_thread_glUseProgram(void *data)
 {
-   Thread_Command_glUseProgram *thread_param =
-      (Thread_Command_glUseProgram *)data;
+   Evas_Thread_Command_glUseProgram *thread_data =
+      (Evas_Thread_Command_glUseProgram *)data;
 
-   glUseProgram(thread_param->program);
+   glUseProgram(thread_data->program);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -1276,36 +1280,36 @@ glUseProgram_thread_cmd(GLuint program)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glUseProgram thread_param_local;
-   Thread_Command_glUseProgram *thread_param = &thread_param_local;
+   Evas_Thread_Command_glUseProgram thread_data_local;
+   Evas_Thread_Command_glUseProgram *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        Thread_Command_glUseProgram *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(Thread_Command_glUseProgram));
-        if (thread_param_new)
+        Evas_Thread_Command_glUseProgram *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(Evas_Thread_Command_glUseProgram));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->program = program;
+   thread_data->program = program;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glUseProgram,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glProgramParameteri(GLuint program, GLenum pname, GLint value);
+ * void
+ * glProgramParameteri(GLuint program, GLenum pname, GLint value);
  */
 
 typedef struct
@@ -1315,7 +1319,7 @@ typedef struct
    GLint value;
    int command_allocated;
 
-} Thread_Command_glProgramParameteri;
+} Evas_Thread_Command_glProgramParameteri;
 
 void (*orig_evas_glProgramParameteri)(GLuint program, GLenum pname, GLint value);
 
@@ -1334,15 +1338,15 @@ glProgramParameteri_orig_evas_get(void)
 static void
 _gl_thread_glProgramParameteri(void *data)
 {
-   Thread_Command_glProgramParameteri *thread_param =
-      (Thread_Command_glProgramParameteri *)data;
+   Evas_Thread_Command_glProgramParameteri *thread_data =
+      (Evas_Thread_Command_glProgramParameteri *)data;
 
-   orig_evas_glProgramParameteri(thread_param->program,
-                                 thread_param->pname,
-                                 thread_param->value);
+   orig_evas_glProgramParameteri(thread_data->program,
+                                 thread_data->pname,
+                                 thread_data->value);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -1356,38 +1360,38 @@ glProgramParameteri_thread_cmd(GLuint program, GLenum pname, GLint value)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glProgramParameteri thread_param_local;
-   Thread_Command_glProgramParameteri *thread_param = &thread_param_local;
+   Evas_Thread_Command_glProgramParameteri thread_data_local;
+   Evas_Thread_Command_glProgramParameteri *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        Thread_Command_glProgramParameteri *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(Thread_Command_glProgramParameteri));
-        if (thread_param_new)
+        Evas_Thread_Command_glProgramParameteri *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(Evas_Thread_Command_glProgramParameteri));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->program = program;
-   thread_param->pname = pname;
-   thread_param->value = value;
+   thread_data->program = program;
+   thread_data->pname = pname;
+   thread_data->value = value;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glProgramParameteri,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glDeleteProgram(GLuint program);
+ * void
+ * glDeleteProgram(GLuint program);
  */
 
 typedef struct
@@ -1395,18 +1399,18 @@ typedef struct
    GLuint program;
    int command_allocated;
 
-} Thread_Command_glDeleteProgram;
+} Evas_Thread_Command_glDeleteProgram;
 
 static void
 _gl_thread_glDeleteProgram(void *data)
 {
-   Thread_Command_glDeleteProgram *thread_param =
-      (Thread_Command_glDeleteProgram *)data;
+   Evas_Thread_Command_glDeleteProgram *thread_data =
+      (Evas_Thread_Command_glDeleteProgram *)data;
 
-   glDeleteProgram(thread_param->program);
+   glDeleteProgram(thread_data->program);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -1420,36 +1424,36 @@ glDeleteProgram_thread_cmd(GLuint program)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glDeleteProgram thread_param_local;
-   Thread_Command_glDeleteProgram *thread_param = &thread_param_local;
+   Evas_Thread_Command_glDeleteProgram thread_data_local;
+   Evas_Thread_Command_glDeleteProgram *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        Thread_Command_glDeleteProgram *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(Thread_Command_glDeleteProgram));
-        if (thread_param_new)
+        Evas_Thread_Command_glDeleteProgram *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(Evas_Thread_Command_glDeleteProgram));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->program = program;
+   thread_data->program = program;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glDeleteProgram,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGetProgramBinary(GLuint program, GLsizei bufSize, GLsizei *length, GLenum *binaryFormat, void *binary);
+ * void
+ * glGetProgramBinary(GLuint program, GLsizei bufSize, GLsizei *length, GLenum *binaryFormat, void *binary);
  */
 
 typedef struct
@@ -1460,7 +1464,7 @@ typedef struct
    GLenum *binaryFormat;
    void *binary;
 
-} Thread_Command_glGetProgramBinary;
+} Evas_Thread_Command_glGetProgramBinary;
 
 void (*orig_evas_glGetProgramBinary)(GLuint program, GLsizei bufSize, GLsizei *length, GLenum *binaryFormat, void *binary);
 
@@ -1479,14 +1483,14 @@ glGetProgramBinary_orig_evas_get(void)
 static void
 _gl_thread_glGetProgramBinary(void *data)
 {
-   Thread_Command_glGetProgramBinary *thread_param =
-      (Thread_Command_glGetProgramBinary *)data;
+   Evas_Thread_Command_glGetProgramBinary *thread_data =
+      (Evas_Thread_Command_glGetProgramBinary *)data;
 
-   orig_evas_glGetProgramBinary(thread_param->program,
-                                thread_param->bufSize,
-                                thread_param->length,
-                                thread_param->binaryFormat,
-                                thread_param->binary);
+   orig_evas_glGetProgramBinary(thread_data->program,
+                                thread_data->bufSize,
+                                thread_data->length,
+                                thread_data->binaryFormat,
+                                thread_data->binary);
 
 }
 
@@ -1501,24 +1505,24 @@ glGetProgramBinary_thread_cmd(GLuint program, GLsizei bufSize, GLsizei *length,
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glGetProgramBinary thread_param_local;
-   Thread_Command_glGetProgramBinary *thread_param = &thread_param_local;
+   Evas_Thread_Command_glGetProgramBinary thread_data_local;
+   Evas_Thread_Command_glGetProgramBinary *thread_data = &thread_data_local;
 
-   thread_param->program = program;
-   thread_param->bufSize = bufSize;
-   thread_param->length = length;
-   thread_param->binaryFormat = binaryFormat;
-   thread_param->binary = binary;
+   thread_data->program = program;
+   thread_data->bufSize = bufSize;
+   thread_data->length = length;
+   thread_data->binaryFormat = binaryFormat;
+   thread_data->binary = binary;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glGetProgramBinary,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glProgramBinary(GLuint program, GLenum binaryFormat, const void *binary, GLint length);
+ * void
+ * glProgramBinary(GLuint program, GLenum binaryFormat, const void *binary, GLint length);
  */
 
 typedef struct
@@ -1530,7 +1534,7 @@ typedef struct
    void *binary_copied; /* COPIED */
    int command_allocated;
 
-} Thread_Command_glProgramBinary;
+} Evas_Thread_Command_glProgramBinary;
 
 void (*orig_evas_glProgramBinary)(GLuint program, GLenum binaryFormat, const void *binary, GLint length);
 
@@ -1549,20 +1553,20 @@ glProgramBinary_orig_evas_get(void)
 static void
 _gl_thread_glProgramBinary(void *data)
 {
-   Thread_Command_glProgramBinary *thread_param =
-      (Thread_Command_glProgramBinary *)data;
+   Evas_Thread_Command_glProgramBinary *thread_data =
+      (Evas_Thread_Command_glProgramBinary *)data;
 
-   orig_evas_glProgramBinary(thread_param->program,
-                             thread_param->binaryFormat,
-                             thread_param->binary,
-                             thread_param->length);
+   orig_evas_glProgramBinary(thread_data->program,
+                             thread_data->binaryFormat,
+                             thread_data->binary,
+                             thread_data->length);
 
 
-   if (thread_param->binary_copied)
-     eina_mempool_free(_mp_default, thread_param->binary_copied);
+   if (thread_data->binary_copied)
+     eina_mempool_free(_mp_default, thread_data->binary_copied);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -1576,31 +1580,31 @@ glProgramBinary_thread_cmd(GLuint program, GLenum binaryFormat, const void *bina
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glProgramBinary thread_param_local;
-   Thread_Command_glProgramBinary *thread_param = &thread_param_local;
+   Evas_Thread_Command_glProgramBinary thread_data_local;
+   Evas_Thread_Command_glProgramBinary *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        Thread_Command_glProgramBinary *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(Thread_Command_glProgramBinary));
-        if (thread_param_new)
+        Evas_Thread_Command_glProgramBinary *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(Evas_Thread_Command_glProgramBinary));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->program = program;
-   thread_param->binaryFormat = binaryFormat;
-   thread_param->binary = binary;
-   thread_param->length = length;
+   thread_data->program = program;
+   thread_data->binaryFormat = binaryFormat;
+   thread_data->binary = binary;
+   thread_data->length = length;
 
-   thread_param->binary_copied = NULL;
+   thread_data->binary_copied = NULL;
    if (thread_mode == EVAS_GL_THREAD_MODE_FINISH)
      goto finish;
 
@@ -1615,10 +1619,10 @@ glProgramBinary_thread_cmd(GLuint program, GLenum binaryFormat, const void *bina
              goto finish;
           }
         /* 2. malloc & copy */
-        thread_param->binary_copied = eina_mempool_malloc(_mp_default, copy_size);
-        if (thread_param->binary_copied)
+        thread_data->binary_copied = eina_mempool_malloc(_mp_default, copy_size);
+        if (thread_data->binary_copied)
           {
-             memcpy(thread_param->binary_copied, binary, copy_size);
+             memcpy(thread_data->binary_copied, binary, copy_size);
           }
         else
           {
@@ -1626,20 +1630,20 @@ glProgramBinary_thread_cmd(GLuint program, GLenum binaryFormat, const void *bina
              goto finish;
           }
         /* 3. replace */
-        thread_param->binary = (const void  *)thread_param->binary_copied;
+        thread_data->binary = (const void  *)thread_data->binary_copied;
      }
    /* end of copy variable */
 
 finish:
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glProgramBinary,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name);
+ * void
+ * glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name);
  */
 
 typedef struct
@@ -1652,21 +1656,21 @@ typedef struct
    GLenum *type;
    GLchar *name;
 
-} Thread_Command_glGetActiveAttrib;
+} Evas_Thread_Command_glGetActiveAttrib;
 
 static void
 _gl_thread_glGetActiveAttrib(void *data)
 {
-   Thread_Command_glGetActiveAttrib *thread_param =
-      (Thread_Command_glGetActiveAttrib *)data;
+   Evas_Thread_Command_glGetActiveAttrib *thread_data =
+      (Evas_Thread_Command_glGetActiveAttrib *)data;
 
-   glGetActiveAttrib(thread_param->program,
-                     thread_param->index,
-                     thread_param->bufSize,
-                     thread_param->length,
-                     thread_param->size,
-                     thread_param->type,
-                     thread_param->name);
+   glGetActiveAttrib(thread_data->program,
+                     thread_data->index,
+                     thread_data->bufSize,
+                     thread_data->length,
+                     thread_data->size,
+                     thread_data->type,
+                     thread_data->name);
 
 }
 
@@ -1681,26 +1685,26 @@ glGetActiveAttrib_thread_cmd(GLuint program, GLuint index, GLsizei bufSize, GLsi
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glGetActiveAttrib thread_param_local;
-   Thread_Command_glGetActiveAttrib *thread_param = &thread_param_local;
+   Evas_Thread_Command_glGetActiveAttrib thread_data_local;
+   Evas_Thread_Command_glGetActiveAttrib *thread_data = &thread_data_local;
 
-   thread_param->program = program;
-   thread_param->index = index;
-   thread_param->bufSize = bufSize;
-   thread_param->length = length;
-   thread_param->size = size;
-   thread_param->type = type;
-   thread_param->name = name;
+   thread_data->program = program;
+   thread_data->index = index;
+   thread_data->bufSize = bufSize;
+   thread_data->length = length;
+   thread_data->size = size;
+   thread_data->type = type;
+   thread_data->name = name;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glGetActiveAttrib,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   GLint
-   glGetAttribLocation(GLuint program, const GLchar *name);
+ * GLint
+ * glGetAttribLocation(GLuint program, const GLchar *name);
  */
 
 typedef struct
@@ -1709,16 +1713,16 @@ typedef struct
    GLuint program;
    const GLchar *name;
 
-} Thread_Command_glGetAttribLocation;
+} Evas_Thread_Command_glGetAttribLocation;
 
 static void
 _gl_thread_glGetAttribLocation(void *data)
 {
-   Thread_Command_glGetAttribLocation *thread_param =
-      (Thread_Command_glGetAttribLocation *)data;
+   Evas_Thread_Command_glGetAttribLocation *thread_data =
+      (Evas_Thread_Command_glGetAttribLocation *)data;
 
-   thread_param->return_value = glGetAttribLocation(thread_param->program,
-                                                    thread_param->name);
+   thread_data->return_value = glGetAttribLocation(thread_data->program,
+                                                   thread_data->name);
 
 }
 
@@ -1732,23 +1736,23 @@ glGetAttribLocation_thread_cmd(GLuint program, const GLchar *name)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glGetAttribLocation thread_param_local;
-   Thread_Command_glGetAttribLocation *thread_param = &thread_param_local;
+   Evas_Thread_Command_glGetAttribLocation thread_data_local;
+   Evas_Thread_Command_glGetAttribLocation *thread_data = &thread_data_local;
 
-   thread_param->program = program;
-   thread_param->name = name;
+   thread_data->program = program;
+   thread_data->name = name;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glGetAttribLocation,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
-   void
-   glBindAttribLocation(GLuint program, GLuint index, const GLchar *name);
+ * void
+ * glBindAttribLocation(GLuint program, GLuint index, const GLchar *name);
  */
 
 typedef struct
@@ -1757,17 +1761,17 @@ typedef struct
    GLuint index;
    const GLchar *name;
 
-} Thread_Command_glBindAttribLocation;
+} Evas_Thread_Command_glBindAttribLocation;
 
 static void
 _gl_thread_glBindAttribLocation(void *data)
 {
-   Thread_Command_glBindAttribLocation *thread_param =
-      (Thread_Command_glBindAttribLocation *)data;
+   Evas_Thread_Command_glBindAttribLocation *thread_data =
+      (Evas_Thread_Command_glBindAttribLocation *)data;
 
-   glBindAttribLocation(thread_param->program,
-                        thread_param->index,
-                        thread_param->name);
+   glBindAttribLocation(thread_data->program,
+                        thread_data->index,
+                        thread_data->name);
 
 }
 
@@ -1782,22 +1786,22 @@ glBindAttribLocation_thread_cmd(GLuint program, GLuint index, const GLchar *name
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glBindAttribLocation thread_param_local;
-   Thread_Command_glBindAttribLocation *thread_param = &thread_param_local;
+   Evas_Thread_Command_glBindAttribLocation thread_data_local;
+   Evas_Thread_Command_glBindAttribLocation *thread_data = &thread_data_local;
 
-   thread_param->program = program;
-   thread_param->index = index;
-   thread_param->name = name;
+   thread_data->program = program;
+   thread_data->index = index;
+   thread_data->name = name;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glBindAttribLocation,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   GLint
-   glGetUniformLocation(GLuint program, const GLchar *name);
+ * GLint
+ * glGetUniformLocation(GLuint program, const GLchar *name);
  */
 
 typedef struct
@@ -1806,16 +1810,16 @@ typedef struct
    GLuint program;
    const GLchar *name;
 
-} Thread_Command_glGetUniformLocation;
+} Evas_Thread_Command_glGetUniformLocation;
 
 static void
 _gl_thread_glGetUniformLocation(void *data)
 {
-   Thread_Command_glGetUniformLocation *thread_param =
-      (Thread_Command_glGetUniformLocation *)data;
+   Evas_Thread_Command_glGetUniformLocation *thread_data =
+      (Evas_Thread_Command_glGetUniformLocation *)data;
 
-   thread_param->return_value = glGetUniformLocation(thread_param->program,
-                                                     thread_param->name);
+   thread_data->return_value = glGetUniformLocation(thread_data->program,
+                                                    thread_data->name);
 
 }
 
@@ -1829,23 +1833,23 @@ glGetUniformLocation_thread_cmd(GLuint program, const GLchar *name)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glGetUniformLocation thread_param_local;
-   Thread_Command_glGetUniformLocation *thread_param = &thread_param_local;
+   Evas_Thread_Command_glGetUniformLocation thread_data_local;
+   Evas_Thread_Command_glGetUniformLocation *thread_data = &thread_data_local;
 
-   thread_param->program = program;
-   thread_param->name = name;
+   thread_data->program = program;
+   thread_data->name = name;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glGetUniformLocation,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
-   void
-   glUniform1f(GLint location, GLfloat v0);
+ * void
+ * glUniform1f(GLint location, GLfloat v0);
  */
 
 typedef struct
@@ -1854,19 +1858,19 @@ typedef struct
    GLfloat v0;
    int command_allocated;
 
-} Thread_Command_glUniform1f;
+} Evas_Thread_Command_glUniform1f;
 
 static void
 _gl_thread_glUniform1f(void *data)
 {
-   Thread_Command_glUniform1f *thread_param =
-      (Thread_Command_glUniform1f *)data;
+   Evas_Thread_Command_glUniform1f *thread_data =
+      (Evas_Thread_Command_glUniform1f *)data;
 
-   glUniform1f(thread_param->location,
-               thread_param->v0);
+   glUniform1f(thread_data->location,
+               thread_data->v0);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -1880,37 +1884,37 @@ glUniform1f_thread_cmd(GLint location, GLfloat v0)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glUniform1f thread_param_local;
-   Thread_Command_glUniform1f *thread_param = &thread_param_local;
+   Evas_Thread_Command_glUniform1f thread_data_local;
+   Evas_Thread_Command_glUniform1f *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        Thread_Command_glUniform1f *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(Thread_Command_glUniform1f));
-        if (thread_param_new)
+        Evas_Thread_Command_glUniform1f *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(Evas_Thread_Command_glUniform1f));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->location = location;
-   thread_param->v0 = v0;
+   thread_data->location = location;
+   thread_data->v0 = v0;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glUniform1f,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glUniform1i(GLint location, GLint v0);
+ * void
+ * glUniform1i(GLint location, GLint v0);
  */
 
 typedef struct
@@ -1919,19 +1923,19 @@ typedef struct
    GLint v0;
    int command_allocated;
 
-} Thread_Command_glUniform1i;
+} Evas_Thread_Command_glUniform1i;
 
 static void
 _gl_thread_glUniform1i(void *data)
 {
-   Thread_Command_glUniform1i *thread_param =
-      (Thread_Command_glUniform1i *)data;
+   Evas_Thread_Command_glUniform1i *thread_data =
+      (Evas_Thread_Command_glUniform1i *)data;
 
-   glUniform1i(thread_param->location,
-               thread_param->v0);
+   glUniform1i(thread_data->location,
+               thread_data->v0);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -1945,37 +1949,37 @@ glUniform1i_thread_cmd(GLint location, GLint v0)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glUniform1i thread_param_local;
-   Thread_Command_glUniform1i *thread_param = &thread_param_local;
+   Evas_Thread_Command_glUniform1i thread_data_local;
+   Evas_Thread_Command_glUniform1i *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        Thread_Command_glUniform1i *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(Thread_Command_glUniform1i));
-        if (thread_param_new)
+        Evas_Thread_Command_glUniform1i *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(Evas_Thread_Command_glUniform1i));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->location = location;
-   thread_param->v0 = v0;
+   thread_data->location = location;
+   thread_data->v0 = v0;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glUniform1i,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glUniform2f(GLint location, GLfloat v0, GLfloat v1);
+ * void
+ * glUniform2f(GLint location, GLfloat v0, GLfloat v1);
  */
 
 typedef struct
@@ -1985,20 +1989,20 @@ typedef struct
    GLfloat v1;
    int command_allocated;
 
-} Thread_Command_glUniform2f;
+} Evas_Thread_Command_glUniform2f;
 
 static void
 _gl_thread_glUniform2f(void *data)
 {
-   Thread_Command_glUniform2f *thread_param =
-      (Thread_Command_glUniform2f *)data;
+   Evas_Thread_Command_glUniform2f *thread_data =
+      (Evas_Thread_Command_glUniform2f *)data;
 
-   glUniform2f(thread_param->location,
-               thread_param->v0,
-               thread_param->v1);
+   glUniform2f(thread_data->location,
+               thread_data->v0,
+               thread_data->v1);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -2012,38 +2016,38 @@ glUniform2f_thread_cmd(GLint location, GLfloat v0, GLfloat v1)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glUniform2f thread_param_local;
-   Thread_Command_glUniform2f *thread_param = &thread_param_local;
+   Evas_Thread_Command_glUniform2f thread_data_local;
+   Evas_Thread_Command_glUniform2f *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        Thread_Command_glUniform2f *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(Thread_Command_glUniform2f));
-        if (thread_param_new)
+        Evas_Thread_Command_glUniform2f *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(Evas_Thread_Command_glUniform2f));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->location = location;
-   thread_param->v0 = v0;
-   thread_param->v1 = v1;
+   thread_data->location = location;
+   thread_data->v0 = v0;
+   thread_data->v1 = v1;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glUniform2f,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glUniform2i(GLint location, GLint v0, GLint v1);
+ * void
+ * glUniform2i(GLint location, GLint v0, GLint v1);
  */
 
 typedef struct
@@ -2053,20 +2057,20 @@ typedef struct
    GLint v1;
    int command_allocated;
 
-} Thread_Command_glUniform2i;
+} Evas_Thread_Command_glUniform2i;
 
 static void
 _gl_thread_glUniform2i(void *data)
 {
-   Thread_Command_glUniform2i *thread_param =
-      (Thread_Command_glUniform2i *)data;
+   Evas_Thread_Command_glUniform2i *thread_data =
+      (Evas_Thread_Command_glUniform2i *)data;
 
-   glUniform2i(thread_param->location,
-               thread_param->v0,
-               thread_param->v1);
+   glUniform2i(thread_data->location,
+               thread_data->v0,
+               thread_data->v1);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -2080,38 +2084,38 @@ glUniform2i_thread_cmd(GLint location, GLint v0, GLint v1)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glUniform2i thread_param_local;
-   Thread_Command_glUniform2i *thread_param = &thread_param_local;
+   Evas_Thread_Command_glUniform2i thread_data_local;
+   Evas_Thread_Command_glUniform2i *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        Thread_Command_glUniform2i *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(Thread_Command_glUniform2i));
-        if (thread_param_new)
+        Evas_Thread_Command_glUniform2i *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(Evas_Thread_Command_glUniform2i));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->location = location;
-   thread_param->v0 = v0;
-   thread_param->v1 = v1;
+   thread_data->location = location;
+   thread_data->v0 = v0;
+   thread_data->v1 = v1;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glUniform2i,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glUniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2);
+ * void
+ * glUniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2);
  */
 
 typedef struct
@@ -2122,21 +2126,21 @@ typedef struct
    GLfloat v2;
    int command_allocated;
 
-} Thread_Command_glUniform3f;
+} Evas_Thread_Command_glUniform3f;
 
 static void
 _gl_thread_glUniform3f(void *data)
 {
-   Thread_Command_glUniform3f *thread_param =
-      (Thread_Command_glUniform3f *)data;
+   Evas_Thread_Command_glUniform3f *thread_data =
+      (Evas_Thread_Command_glUniform3f *)data;
 
-   glUniform3f(thread_param->location,
-               thread_param->v0,
-               thread_param->v1,
-               thread_param->v2);
+   glUniform3f(thread_data->location,
+               thread_data->v0,
+               thread_data->v1,
+               thread_data->v2);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -2150,39 +2154,39 @@ glUniform3f_thread_cmd(GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glUniform3f thread_param_local;
-   Thread_Command_glUniform3f *thread_param = &thread_param_local;
+   Evas_Thread_Command_glUniform3f thread_data_local;
+   Evas_Thread_Command_glUniform3f *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        Thread_Command_glUniform3f *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(Thread_Command_glUniform3f));
-        if (thread_param_new)
+        Evas_Thread_Command_glUniform3f *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(Evas_Thread_Command_glUniform3f));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->location = location;
-   thread_param->v0 = v0;
-   thread_param->v1 = v1;
-   thread_param->v2 = v2;
+   thread_data->location = location;
+   thread_data->v0 = v0;
+   thread_data->v1 = v1;
+   thread_data->v2 = v2;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glUniform3f,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glUniform3i(GLint location, GLint v0, GLint v1, GLint v2);
+ * void
+ * glUniform3i(GLint location, GLint v0, GLint v1, GLint v2);
  */
 
 typedef struct
@@ -2193,21 +2197,21 @@ typedef struct
    GLint v2;
    int command_allocated;
 
-} Thread_Command_glUniform3i;
+} Evas_Thread_Command_glUniform3i;
 
 static void
 _gl_thread_glUniform3i(void *data)
 {
-   Thread_Command_glUniform3i *thread_param =
-      (Thread_Command_glUniform3i *)data;
+   Evas_Thread_Command_glUniform3i *thread_data =
+      (Evas_Thread_Command_glUniform3i *)data;
 
-   glUniform3i(thread_param->location,
-               thread_param->v0,
-               thread_param->v1,
-               thread_param->v2);
+   glUniform3i(thread_data->location,
+               thread_data->v0,
+               thread_data->v1,
+               thread_data->v2);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -2221,39 +2225,39 @@ glUniform3i_thread_cmd(GLint location, GLint v0, GLint v1, GLint v2)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glUniform3i thread_param_local;
-   Thread_Command_glUniform3i *thread_param = &thread_param_local;
+   Evas_Thread_Command_glUniform3i thread_data_local;
+   Evas_Thread_Command_glUniform3i *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        Thread_Command_glUniform3i *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(Thread_Command_glUniform3i));
-        if (thread_param_new)
+        Evas_Thread_Command_glUniform3i *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(Evas_Thread_Command_glUniform3i));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->location = location;
-   thread_param->v0 = v0;
-   thread_param->v1 = v1;
-   thread_param->v2 = v2;
+   thread_data->location = location;
+   thread_data->v0 = v0;
+   thread_data->v1 = v1;
+   thread_data->v2 = v2;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glUniform3i,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glUniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);
+ * void
+ * glUniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);
  */
 
 typedef struct
@@ -2265,22 +2269,22 @@ typedef struct
    GLfloat v3;
    int command_allocated;
 
-} Thread_Command_glUniform4f;
+} Evas_Thread_Command_glUniform4f;
 
 static void
 _gl_thread_glUniform4f(void *data)
 {
-   Thread_Command_glUniform4f *thread_param =
-      (Thread_Command_glUniform4f *)data;
+   Evas_Thread_Command_glUniform4f *thread_data =
+      (Evas_Thread_Command_glUniform4f *)data;
 
-   glUniform4f(thread_param->location,
-               thread_param->v0,
-               thread_param->v1,
-               thread_param->v2,
-               thread_param->v3);
+   glUniform4f(thread_data->location,
+               thread_data->v0,
+               thread_data->v1,
+               thread_data->v2,
+               thread_data->v3);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -2294,40 +2298,40 @@ glUniform4f_thread_cmd(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLflo
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glUniform4f thread_param_local;
-   Thread_Command_glUniform4f *thread_param = &thread_param_local;
+   Evas_Thread_Command_glUniform4f thread_data_local;
+   Evas_Thread_Command_glUniform4f *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        Thread_Command_glUniform4f *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(Thread_Command_glUniform4f));
-        if (thread_param_new)
+        Evas_Thread_Command_glUniform4f *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(Evas_Thread_Command_glUniform4f));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->location = location;
-   thread_param->v0 = v0;
-   thread_param->v1 = v1;
-   thread_param->v2 = v2;
-   thread_param->v3 = v3;
+   thread_data->location = location;
+   thread_data->v0 = v0;
+   thread_data->v1 = v1;
+   thread_data->v2 = v2;
+   thread_data->v3 = v3;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glUniform4f,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glUniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3);
+ * void
+ * glUniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3);
  */
 
 typedef struct
@@ -2339,22 +2343,22 @@ typedef struct
    GLint v3;
    int command_allocated;
 
-} Thread_Command_glUniform4i;
+} Evas_Thread_Command_glUniform4i;
 
 static void
 _gl_thread_glUniform4i(void *data)
 {
-   Thread_Command_glUniform4i *thread_param =
-      (Thread_Command_glUniform4i *)data;
+   Evas_Thread_Command_glUniform4i *thread_data =
+      (Evas_Thread_Command_glUniform4i *)data;
 
-   glUniform4i(thread_param->location,
-               thread_param->v0,
-               thread_param->v1,
-               thread_param->v2,
-               thread_param->v3);
+   glUniform4i(thread_data->location,
+               thread_data->v0,
+               thread_data->v1,
+               thread_data->v2,
+               thread_data->v3);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -2368,40 +2372,40 @@ glUniform4i_thread_cmd(GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glUniform4i thread_param_local;
-   Thread_Command_glUniform4i *thread_param = &thread_param_local;
+   Evas_Thread_Command_glUniform4i thread_data_local;
+   Evas_Thread_Command_glUniform4i *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        Thread_Command_glUniform4i *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(Thread_Command_glUniform4i));
-        if (thread_param_new)
+        Evas_Thread_Command_glUniform4i *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(Evas_Thread_Command_glUniform4i));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->location = location;
-   thread_param->v0 = v0;
-   thread_param->v1 = v1;
-   thread_param->v2 = v2;
-   thread_param->v3 = v3;
+   thread_data->location = location;
+   thread_data->v0 = v0;
+   thread_data->v1 = v1;
+   thread_data->v2 = v2;
+   thread_data->v3 = v3;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glUniform4i,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glUniform1fv(GLint location, GLsizei count, const GLfloat *value);
+ * void
+ * glUniform1fv(GLint location, GLsizei count, const GLfloat *value);
  */
 
 typedef struct
@@ -2412,24 +2416,24 @@ typedef struct
    void *value_copied; /* COPIED */
    int command_allocated;
 
-} Thread_Command_glUniform1fv;
+} Evas_Thread_Command_glUniform1fv;
 
 static void
 _gl_thread_glUniform1fv(void *data)
 {
-   Thread_Command_glUniform1fv *thread_param =
-      (Thread_Command_glUniform1fv *)data;
+   Evas_Thread_Command_glUniform1fv *thread_data =
+      (Evas_Thread_Command_glUniform1fv *)data;
 
-   glUniform1fv(thread_param->location,
-                thread_param->count,
-                thread_param->value);
+   glUniform1fv(thread_data->location,
+                thread_data->count,
+                thread_data->value);
 
 
-   if (thread_param->value_copied)
-     eina_mempool_free(_mp_uniform, thread_param->value_copied);
+   if (thread_data->value_copied)
+     eina_mempool_free(_mp_uniform, thread_data->value_copied);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -2443,30 +2447,30 @@ glUniform1fv_thread_cmd(GLint location, GLsizei count, const GLfloat *value)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glUniform1fv thread_param_local;
-   Thread_Command_glUniform1fv *thread_param = &thread_param_local;
+   Evas_Thread_Command_glUniform1fv thread_data_local;
+   Evas_Thread_Command_glUniform1fv *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        Thread_Command_glUniform1fv *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(Thread_Command_glUniform1fv));
-        if (thread_param_new)
+        Evas_Thread_Command_glUniform1fv *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(Evas_Thread_Command_glUniform1fv));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->location = location;
-   thread_param->count = count;
-   thread_param->value = value;
+   thread_data->location = location;
+   thread_data->count = count;
+   thread_data->value = value;
 
-   thread_param->value_copied = NULL;
+   thread_data->value_copied = NULL;
    if (thread_mode == EVAS_GL_THREAD_MODE_FINISH)
      goto finish;
 
@@ -2481,10 +2485,10 @@ glUniform1fv_thread_cmd(GLint location, GLsizei count, const GLfloat *value)
              goto finish;
           }
         /* 2. malloc & copy */
-        thread_param->value_copied = eina_mempool_malloc(_mp_uniform, copy_size);
-        if (thread_param->value_copied)
+        thread_data->value_copied = eina_mempool_malloc(_mp_uniform, copy_size);
+        if (thread_data->value_copied)
           {
-             memcpy(thread_param->value_copied, value, copy_size);
+             memcpy(thread_data->value_copied, value, copy_size);
           }
         else
           {
@@ -2492,20 +2496,20 @@ glUniform1fv_thread_cmd(GLint location, GLsizei count, const GLfloat *value)
              goto finish;
           }
         /* 3. replace */
-        thread_param->value = (const GLfloat  *)thread_param->value_copied;
+        thread_data->value = (const GLfloat  *)thread_data->value_copied;
      }
    /* end of copy variable */
 
 finish:
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glUniform1fv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glUniform1iv(GLint location, GLsizei count, const GLint *value);
+ * void
+ * glUniform1iv(GLint location, GLsizei count, const GLint *value);
  */
 
 typedef struct
@@ -2516,24 +2520,24 @@ typedef struct
    void *value_copied; /* COPIED */
    int command_allocated;
 
-} Thread_Command_glUniform1iv;
+} Evas_Thread_Command_glUniform1iv;
 
 static void
 _gl_thread_glUniform1iv(void *data)
 {
-   Thread_Command_glUniform1iv *thread_param =
-      (Thread_Command_glUniform1iv *)data;
+   Evas_Thread_Command_glUniform1iv *thread_data =
+      (Evas_Thread_Command_glUniform1iv *)data;
 
-   glUniform1iv(thread_param->location,
-                thread_param->count,
-                thread_param->value);
+   glUniform1iv(thread_data->location,
+                thread_data->count,
+                thread_data->value);
 
 
-   if (thread_param->value_copied)
-     eina_mempool_free(_mp_uniform, thread_param->value_copied);
+   if (thread_data->value_copied)
+     eina_mempool_free(_mp_uniform, thread_data->value_copied);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -2547,30 +2551,30 @@ glUniform1iv_thread_cmd(GLint location, GLsizei count, const GLint *value)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glUniform1iv thread_param_local;
-   Thread_Command_glUniform1iv *thread_param = &thread_param_local;
+   Evas_Thread_Command_glUniform1iv thread_data_local;
+   Evas_Thread_Command_glUniform1iv *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        Thread_Command_glUniform1iv *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(Thread_Command_glUniform1iv));
-        if (thread_param_new)
+        Evas_Thread_Command_glUniform1iv *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(Evas_Thread_Command_glUniform1iv));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->location = location;
-   thread_param->count = count;
-   thread_param->value = value;
+   thread_data->location = location;
+   thread_data->count = count;
+   thread_data->value = value;
 
-   thread_param->value_copied = NULL;
+   thread_data->value_copied = NULL;
    if (thread_mode == EVAS_GL_THREAD_MODE_FINISH)
      goto finish;
 
@@ -2585,10 +2589,10 @@ glUniform1iv_thread_cmd(GLint location, GLsizei count, const GLint *value)
              goto finish;
           }
         /* 2. malloc & copy */
-        thread_param->value_copied = eina_mempool_malloc(_mp_uniform, copy_size);
-        if (thread_param->value_copied)
+        thread_data->value_copied = eina_mempool_malloc(_mp_uniform, copy_size);
+        if (thread_data->value_copied)
           {
-             memcpy(thread_param->value_copied, value, copy_size);
+             memcpy(thread_data->value_copied, value, copy_size);
           }
         else
           {
@@ -2596,20 +2600,20 @@ glUniform1iv_thread_cmd(GLint location, GLsizei count, const GLint *value)
              goto finish;
           }
         /* 3. replace */
-        thread_param->value = (const GLint  *)thread_param->value_copied;
+        thread_data->value = (const GLint  *)thread_data->value_copied;
      }
    /* end of copy variable */
 
 finish:
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glUniform1iv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glUniform2fv(GLint location, GLsizei count, const GLfloat *value);
+ * void
+ * glUniform2fv(GLint location, GLsizei count, const GLfloat *value);
  */
 
 typedef struct
@@ -2620,24 +2624,24 @@ typedef struct
    void *value_copied; /* COPIED */
    int command_allocated;
 
-} Thread_Command_glUniform2fv;
+} Evas_Thread_Command_glUniform2fv;
 
 static void
 _gl_thread_glUniform2fv(void *data)
 {
-   Thread_Command_glUniform2fv *thread_param =
-      (Thread_Command_glUniform2fv *)data;
+   Evas_Thread_Command_glUniform2fv *thread_data =
+      (Evas_Thread_Command_glUniform2fv *)data;
 
-   glUniform2fv(thread_param->location,
-                thread_param->count,
-                thread_param->value);
+   glUniform2fv(thread_data->location,
+                thread_data->count,
+                thread_data->value);
 
 
-   if (thread_param->value_copied)
-     eina_mempool_free(_mp_uniform, thread_param->value_copied);
+   if (thread_data->value_copied)
+     eina_mempool_free(_mp_uniform, thread_data->value_copied);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -2651,30 +2655,30 @@ glUniform2fv_thread_cmd(GLint location, GLsizei count, const GLfloat *value)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glUniform2fv thread_param_local;
-   Thread_Command_glUniform2fv *thread_param = &thread_param_local;
+   Evas_Thread_Command_glUniform2fv thread_data_local;
+   Evas_Thread_Command_glUniform2fv *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        Thread_Command_glUniform2fv *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(Thread_Command_glUniform2fv));
-        if (thread_param_new)
+        Evas_Thread_Command_glUniform2fv *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(Evas_Thread_Command_glUniform2fv));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->location = location;
-   thread_param->count = count;
-   thread_param->value = value;
+   thread_data->location = location;
+   thread_data->count = count;
+   thread_data->value = value;
 
-   thread_param->value_copied = NULL;
+   thread_data->value_copied = NULL;
    if (thread_mode == EVAS_GL_THREAD_MODE_FINISH)
      goto finish;
 
@@ -2689,10 +2693,10 @@ glUniform2fv_thread_cmd(GLint location, GLsizei count, const GLfloat *value)
              goto finish;
           }
         /* 2. malloc & copy */
-        thread_param->value_copied = eina_mempool_malloc(_mp_uniform, copy_size);
-        if (thread_param->value_copied)
+        thread_data->value_copied = eina_mempool_malloc(_mp_uniform, copy_size);
+        if (thread_data->value_copied)
           {
-             memcpy(thread_param->value_copied, value, copy_size);
+             memcpy(thread_data->value_copied, value, copy_size);
           }
         else
           {
@@ -2700,20 +2704,20 @@ glUniform2fv_thread_cmd(GLint location, GLsizei count, const GLfloat *value)
              goto finish;
           }
         /* 3. replace */
-        thread_param->value = (const GLfloat  *)thread_param->value_copied;
+        thread_data->value = (const GLfloat  *)thread_data->value_copied;
      }
    /* end of copy variable */
 
 finish:
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glUniform2fv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glUniform2iv(GLint location, GLsizei count, const GLint *value);
+ * void
+ * glUniform2iv(GLint location, GLsizei count, const GLint *value);
  */
 
 typedef struct
@@ -2724,24 +2728,24 @@ typedef struct
    void *value_copied; /* COPIED */
    int command_allocated;
 
-} Thread_Command_glUniform2iv;
+} Evas_Thread_Command_glUniform2iv;
 
 static void
 _gl_thread_glUniform2iv(void *data)
 {
-   Thread_Command_glUniform2iv *thread_param =
-      (Thread_Command_glUniform2iv *)data;
+   Evas_Thread_Command_glUniform2iv *thread_data =
+      (Evas_Thread_Command_glUniform2iv *)data;
 
-   glUniform2iv(thread_param->location,
-                thread_param->count,
-                thread_param->value);
+   glUniform2iv(thread_data->location,
+                thread_data->count,
+                thread_data->value);
 
 
-   if (thread_param->value_copied)
-     eina_mempool_free(_mp_uniform, thread_param->value_copied);
+   if (thread_data->value_copied)
+     eina_mempool_free(_mp_uniform, thread_data->value_copied);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -2755,30 +2759,30 @@ glUniform2iv_thread_cmd(GLint location, GLsizei count, const GLint *value)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glUniform2iv thread_param_local;
-   Thread_Command_glUniform2iv *thread_param = &thread_param_local;
+   Evas_Thread_Command_glUniform2iv thread_data_local;
+   Evas_Thread_Command_glUniform2iv *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        Thread_Command_glUniform2iv *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(Thread_Command_glUniform2iv));
-        if (thread_param_new)
+        Evas_Thread_Command_glUniform2iv *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(Evas_Thread_Command_glUniform2iv));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->location = location;
-   thread_param->count = count;
-   thread_param->value = value;
+   thread_data->location = location;
+   thread_data->count = count;
+   thread_data->value = value;
 
-   thread_param->value_copied = NULL;
+   thread_data->value_copied = NULL;
    if (thread_mode == EVAS_GL_THREAD_MODE_FINISH)
      goto finish;
 
@@ -2793,10 +2797,10 @@ glUniform2iv_thread_cmd(GLint location, GLsizei count, const GLint *value)
              goto finish;
           }
         /* 2. malloc & copy */
-        thread_param->value_copied = eina_mempool_malloc(_mp_uniform, copy_size);
-        if (thread_param->value_copied)
+        thread_data->value_copied = eina_mempool_malloc(_mp_uniform, copy_size);
+        if (thread_data->value_copied)
           {
-             memcpy(thread_param->value_copied, value, copy_size);
+             memcpy(thread_data->value_copied, value, copy_size);
           }
         else
           {
@@ -2804,20 +2808,20 @@ glUniform2iv_thread_cmd(GLint location, GLsizei count, const GLint *value)
              goto finish;
           }
         /* 3. replace */
-        thread_param->value = (const GLint  *)thread_param->value_copied;
+        thread_data->value = (const GLint  *)thread_data->value_copied;
      }
    /* end of copy variable */
 
 finish:
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glUniform2iv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glUniform3fv(GLint location, GLsizei count, const GLfloat *value);
+ * void
+ * glUniform3fv(GLint location, GLsizei count, const GLfloat *value);
  */
 
 typedef struct
@@ -2828,24 +2832,24 @@ typedef struct
    void *value_copied; /* COPIED */
    int command_allocated;
 
-} Thread_Command_glUniform3fv;
+} Evas_Thread_Command_glUniform3fv;
 
 static void
 _gl_thread_glUniform3fv(void *data)
 {
-   Thread_Command_glUniform3fv *thread_param =
-      (Thread_Command_glUniform3fv *)data;
+   Evas_Thread_Command_glUniform3fv *thread_data =
+      (Evas_Thread_Command_glUniform3fv *)data;
 
-   glUniform3fv(thread_param->location,
-                thread_param->count,
-                thread_param->value);
+   glUniform3fv(thread_data->location,
+                thread_data->count,
+                thread_data->value);
 
 
-   if (thread_param->value_copied)
-     eina_mempool_free(_mp_uniform, thread_param->value_copied);
+   if (thread_data->value_copied)
+     eina_mempool_free(_mp_uniform, thread_data->value_copied);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -2859,30 +2863,30 @@ glUniform3fv_thread_cmd(GLint location, GLsizei count, const GLfloat *value)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glUniform3fv thread_param_local;
-   Thread_Command_glUniform3fv *thread_param = &thread_param_local;
+   Evas_Thread_Command_glUniform3fv thread_data_local;
+   Evas_Thread_Command_glUniform3fv *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        Thread_Command_glUniform3fv *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(Thread_Command_glUniform3fv));
-        if (thread_param_new)
+        Evas_Thread_Command_glUniform3fv *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(Evas_Thread_Command_glUniform3fv));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->location = location;
-   thread_param->count = count;
-   thread_param->value = value;
+   thread_data->location = location;
+   thread_data->count = count;
+   thread_data->value = value;
 
-   thread_param->value_copied = NULL;
+   thread_data->value_copied = NULL;
    if (thread_mode == EVAS_GL_THREAD_MODE_FINISH)
      goto finish;
 
@@ -2897,10 +2901,10 @@ glUniform3fv_thread_cmd(GLint location, GLsizei count, const GLfloat *value)
              goto finish;
           }
         /* 2. malloc & copy */
-        thread_param->value_copied = eina_mempool_malloc(_mp_uniform, copy_size);
-        if (thread_param->value_copied)
+        thread_data->value_copied = eina_mempool_malloc(_mp_uniform, copy_size);
+        if (thread_data->value_copied)
           {
-             memcpy(thread_param->value_copied, value, copy_size);
+             memcpy(thread_data->value_copied, value, copy_size);
           }
         else
           {
@@ -2908,20 +2912,20 @@ glUniform3fv_thread_cmd(GLint location, GLsizei count, const GLfloat *value)
              goto finish;
           }
         /* 3. replace */
-        thread_param->value = (const GLfloat  *)thread_param->value_copied;
+        thread_data->value = (const GLfloat  *)thread_data->value_copied;
      }
    /* end of copy variable */
 
 finish:
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glUniform3fv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glUniform3iv(GLint location, GLsizei count, const GLint *value);
+ * void
+ * glUniform3iv(GLint location, GLsizei count, const GLint *value);
  */
 
 typedef struct
@@ -2932,24 +2936,24 @@ typedef struct
    void *value_copied; /* COPIED */
    int command_allocated;
 
-} Thread_Command_glUniform3iv;
+} Evas_Thread_Command_glUniform3iv;
 
 static void
 _gl_thread_glUniform3iv(void *data)
 {
-   Thread_Command_glUniform3iv *thread_param =
-      (Thread_Command_glUniform3iv *)data;
+   Evas_Thread_Command_glUniform3iv *thread_data =
+      (Evas_Thread_Command_glUniform3iv *)data;
 
-   glUniform3iv(thread_param->location,
-                thread_param->count,
-                thread_param->value);
+   glUniform3iv(thread_data->location,
+                thread_data->count,
+                thread_data->value);
 
 
-   if (thread_param->value_copied)
-     eina_mempool_free(_mp_uniform, thread_param->value_copied);
+   if (thread_data->value_copied)
+     eina_mempool_free(_mp_uniform, thread_data->value_copied);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -2963,30 +2967,30 @@ glUniform3iv_thread_cmd(GLint location, GLsizei count, const GLint *value)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glUniform3iv thread_param_local;
-   Thread_Command_glUniform3iv *thread_param = &thread_param_local;
+   Evas_Thread_Command_glUniform3iv thread_data_local;
+   Evas_Thread_Command_glUniform3iv *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        Thread_Command_glUniform3iv *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(Thread_Command_glUniform3iv));
-        if (thread_param_new)
+        Evas_Thread_Command_glUniform3iv *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(Evas_Thread_Command_glUniform3iv));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->location = location;
-   thread_param->count = count;
-   thread_param->value = value;
+   thread_data->location = location;
+   thread_data->count = count;
+   thread_data->value = value;
 
-   thread_param->value_copied = NULL;
+   thread_data->value_copied = NULL;
    if (thread_mode == EVAS_GL_THREAD_MODE_FINISH)
      goto finish;
 
@@ -3001,10 +3005,10 @@ glUniform3iv_thread_cmd(GLint location, GLsizei count, const GLint *value)
              goto finish;
           }
         /* 2. malloc & copy */
-        thread_param->value_copied = eina_mempool_malloc(_mp_uniform, copy_size);
-        if (thread_param->value_copied)
+        thread_data->value_copied = eina_mempool_malloc(_mp_uniform, copy_size);
+        if (thread_data->value_copied)
           {
-             memcpy(thread_param->value_copied, value, copy_size);
+             memcpy(thread_data->value_copied, value, copy_size);
           }
         else
           {
@@ -3012,20 +3016,20 @@ glUniform3iv_thread_cmd(GLint location, GLsizei count, const GLint *value)
              goto finish;
           }
         /* 3. replace */
-        thread_param->value = (const GLint  *)thread_param->value_copied;
+        thread_data->value = (const GLint  *)thread_data->value_copied;
      }
    /* end of copy variable */
 
 finish:
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glUniform3iv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glUniform4fv(GLint location, GLsizei count, const GLfloat *value);
+ * void
+ * glUniform4fv(GLint location, GLsizei count, const GLfloat *value);
  */
 
 typedef struct
@@ -3036,24 +3040,24 @@ typedef struct
    void *value_copied; /* COPIED */
    int command_allocated;
 
-} Thread_Command_glUniform4fv;
+} Evas_Thread_Command_glUniform4fv;
 
 static void
 _gl_thread_glUniform4fv(void *data)
 {
-   Thread_Command_glUniform4fv *thread_param =
-      (Thread_Command_glUniform4fv *)data;
+   Evas_Thread_Command_glUniform4fv *thread_data =
+      (Evas_Thread_Command_glUniform4fv *)data;
 
-   glUniform4fv(thread_param->location,
-                thread_param->count,
-                thread_param->value);
+   glUniform4fv(thread_data->location,
+                thread_data->count,
+                thread_data->value);
 
 
-   if (thread_param->value_copied)
-     eina_mempool_free(_mp_uniform, thread_param->value_copied);
+   if (thread_data->value_copied)
+     eina_mempool_free(_mp_uniform, thread_data->value_copied);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -3067,30 +3071,30 @@ glUniform4fv_thread_cmd(GLint location, GLsizei count, const GLfloat *value)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glUniform4fv thread_param_local;
-   Thread_Command_glUniform4fv *thread_param = &thread_param_local;
+   Evas_Thread_Command_glUniform4fv thread_data_local;
+   Evas_Thread_Command_glUniform4fv *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        Thread_Command_glUniform4fv *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(Thread_Command_glUniform4fv));
-        if (thread_param_new)
+        Evas_Thread_Command_glUniform4fv *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(Evas_Thread_Command_glUniform4fv));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->location = location;
-   thread_param->count = count;
-   thread_param->value = value;
+   thread_data->location = location;
+   thread_data->count = count;
+   thread_data->value = value;
 
-   thread_param->value_copied = NULL;
+   thread_data->value_copied = NULL;
    if (thread_mode == EVAS_GL_THREAD_MODE_FINISH)
      goto finish;
 
@@ -3105,10 +3109,10 @@ glUniform4fv_thread_cmd(GLint location, GLsizei count, const GLfloat *value)
              goto finish;
           }
         /* 2. malloc & copy */
-        thread_param->value_copied = eina_mempool_malloc(_mp_uniform, copy_size);
-        if (thread_param->value_copied)
+        thread_data->value_copied = eina_mempool_malloc(_mp_uniform, copy_size);
+        if (thread_data->value_copied)
           {
-             memcpy(thread_param->value_copied, value, copy_size);
+             memcpy(thread_data->value_copied, value, copy_size);
           }
         else
           {
@@ -3116,20 +3120,20 @@ glUniform4fv_thread_cmd(GLint location, GLsizei count, const GLfloat *value)
              goto finish;
           }
         /* 3. replace */
-        thread_param->value = (const GLfloat  *)thread_param->value_copied;
+        thread_data->value = (const GLfloat  *)thread_data->value_copied;
      }
    /* end of copy variable */
 
 finish:
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glUniform4fv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glUniform4iv(GLint location, GLsizei count, const GLint *value);
+ * void
+ * glUniform4iv(GLint location, GLsizei count, const GLint *value);
  */
 
 typedef struct
@@ -3140,24 +3144,24 @@ typedef struct
    void *value_copied; /* COPIED */
    int command_allocated;
 
-} Thread_Command_glUniform4iv;
+} Evas_Thread_Command_glUniform4iv;
 
 static void
 _gl_thread_glUniform4iv(void *data)
 {
-   Thread_Command_glUniform4iv *thread_param =
-      (Thread_Command_glUniform4iv *)data;
+   Evas_Thread_Command_glUniform4iv *thread_data =
+      (Evas_Thread_Command_glUniform4iv *)data;
 
-   glUniform4iv(thread_param->location,
-                thread_param->count,
-                thread_param->value);
+   glUniform4iv(thread_data->location,
+                thread_data->count,
+                thread_data->value);
 
 
-   if (thread_param->value_copied)
-     eina_mempool_free(_mp_uniform, thread_param->value_copied);
+   if (thread_data->value_copied)
+     eina_mempool_free(_mp_uniform, thread_data->value_copied);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -3171,30 +3175,30 @@ glUniform4iv_thread_cmd(GLint location, GLsizei count, const GLint *value)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glUniform4iv thread_param_local;
-   Thread_Command_glUniform4iv *thread_param = &thread_param_local;
+   Evas_Thread_Command_glUniform4iv thread_data_local;
+   Evas_Thread_Command_glUniform4iv *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        Thread_Command_glUniform4iv *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(Thread_Command_glUniform4iv));
-        if (thread_param_new)
+        Evas_Thread_Command_glUniform4iv *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(Evas_Thread_Command_glUniform4iv));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->location = location;
-   thread_param->count = count;
-   thread_param->value = value;
+   thread_data->location = location;
+   thread_data->count = count;
+   thread_data->value = value;
 
-   thread_param->value_copied = NULL;
+   thread_data->value_copied = NULL;
    if (thread_mode == EVAS_GL_THREAD_MODE_FINISH)
      goto finish;
 
@@ -3209,10 +3213,10 @@ glUniform4iv_thread_cmd(GLint location, GLsizei count, const GLint *value)
              goto finish;
           }
         /* 2. malloc & copy */
-        thread_param->value_copied = eina_mempool_malloc(_mp_uniform, copy_size);
-        if (thread_param->value_copied)
+        thread_data->value_copied = eina_mempool_malloc(_mp_uniform, copy_size);
+        if (thread_data->value_copied)
           {
-             memcpy(thread_param->value_copied, value, copy_size);
+             memcpy(thread_data->value_copied, value, copy_size);
           }
         else
           {
@@ -3220,20 +3224,20 @@ glUniform4iv_thread_cmd(GLint location, GLsizei count, const GLint *value)
              goto finish;
           }
         /* 3. replace */
-        thread_param->value = (const GLint  *)thread_param->value_copied;
+        thread_data->value = (const GLint  *)thread_data->value_copied;
      }
    /* end of copy variable */
 
 finish:
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glUniform4iv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+ * void
+ * glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
  */
 
 typedef struct
@@ -3245,25 +3249,25 @@ typedef struct
    void *value_copied; /* COPIED */
    int command_allocated;
 
-} Thread_Command_glUniformMatrix2fv;
+} Evas_Thread_Command_glUniformMatrix2fv;
 
 static void
 _gl_thread_glUniformMatrix2fv(void *data)
 {
-   Thread_Command_glUniformMatrix2fv *thread_param =
-      (Thread_Command_glUniformMatrix2fv *)data;
+   Evas_Thread_Command_glUniformMatrix2fv *thread_data =
+      (Evas_Thread_Command_glUniformMatrix2fv *)data;
 
-   glUniformMatrix2fv(thread_param->location,
-                      thread_param->count,
-                      thread_param->transpose,
-                      thread_param->value);
+   glUniformMatrix2fv(thread_data->location,
+                      thread_data->count,
+                      thread_data->transpose,
+                      thread_data->value);
 
 
-   if (thread_param->value_copied)
-     eina_mempool_free(_mp_uniform, thread_param->value_copied);
+   if (thread_data->value_copied)
+     eina_mempool_free(_mp_uniform, thread_data->value_copied);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -3277,31 +3281,31 @@ glUniformMatrix2fv_thread_cmd(GLint location, GLsizei count, GLboolean transpose
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glUniformMatrix2fv thread_param_local;
-   Thread_Command_glUniformMatrix2fv *thread_param = &thread_param_local;
+   Evas_Thread_Command_glUniformMatrix2fv thread_data_local;
+   Evas_Thread_Command_glUniformMatrix2fv *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        Thread_Command_glUniformMatrix2fv *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(Thread_Command_glUniformMatrix2fv));
-        if (thread_param_new)
+        Evas_Thread_Command_glUniformMatrix2fv *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(Evas_Thread_Command_glUniformMatrix2fv));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->location = location;
-   thread_param->count = count;
-   thread_param->transpose = transpose;
-   thread_param->value = value;
+   thread_data->location = location;
+   thread_data->count = count;
+   thread_data->transpose = transpose;
+   thread_data->value = value;
 
-   thread_param->value_copied = NULL;
+   thread_data->value_copied = NULL;
    if (thread_mode == EVAS_GL_THREAD_MODE_FINISH)
      goto finish;
 
@@ -3316,10 +3320,10 @@ glUniformMatrix2fv_thread_cmd(GLint location, GLsizei count, GLboolean transpose
              goto finish;
           }
         /* 2. malloc & copy */
-        thread_param->value_copied = eina_mempool_malloc(_mp_uniform, copy_size);
-        if (thread_param->value_copied)
+        thread_data->value_copied = eina_mempool_malloc(_mp_uniform, copy_size);
+        if (thread_data->value_copied)
           {
-             memcpy(thread_param->value_copied, value, copy_size);
+             memcpy(thread_data->value_copied, value, copy_size);
           }
         else
           {
@@ -3327,20 +3331,20 @@ glUniformMatrix2fv_thread_cmd(GLint location, GLsizei count, GLboolean transpose
              goto finish;
           }
         /* 3. replace */
-        thread_param->value = (const GLfloat  *)thread_param->value_copied;
+        thread_data->value = (const GLfloat  *)thread_data->value_copied;
      }
    /* end of copy variable */
 
 finish:
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glUniformMatrix2fv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+ * void
+ * glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
  */
 
 typedef struct
@@ -3352,25 +3356,25 @@ typedef struct
    void *value_copied; /* COPIED */
    int command_allocated;
 
-} Thread_Command_glUniformMatrix3fv;
+} Evas_Thread_Command_glUniformMatrix3fv;
 
 static void
 _gl_thread_glUniformMatrix3fv(void *data)
 {
-   Thread_Command_glUniformMatrix3fv *thread_param =
-      (Thread_Command_glUniformMatrix3fv *)data;
+   Evas_Thread_Command_glUniformMatrix3fv *thread_data =
+      (Evas_Thread_Command_glUniformMatrix3fv *)data;
 
-   glUniformMatrix3fv(thread_param->location,
-                      thread_param->count,
-                      thread_param->transpose,
-                      thread_param->value);
+   glUniformMatrix3fv(thread_data->location,
+                      thread_data->count,
+                      thread_data->transpose,
+                      thread_data->value);
 
 
-   if (thread_param->value_copied)
-     eina_mempool_free(_mp_uniform, thread_param->value_copied);
+   if (thread_data->value_copied)
+     eina_mempool_free(_mp_uniform, thread_data->value_copied);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -3384,31 +3388,31 @@ glUniformMatrix3fv_thread_cmd(GLint location, GLsizei count, GLboolean transpose
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glUniformMatrix3fv thread_param_local;
-   Thread_Command_glUniformMatrix3fv *thread_param = &thread_param_local;
+   Evas_Thread_Command_glUniformMatrix3fv thread_data_local;
+   Evas_Thread_Command_glUniformMatrix3fv *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        Thread_Command_glUniformMatrix3fv *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(Thread_Command_glUniformMatrix3fv));
-        if (thread_param_new)
+        Evas_Thread_Command_glUniformMatrix3fv *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(Evas_Thread_Command_glUniformMatrix3fv));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->location = location;
-   thread_param->count = count;
-   thread_param->transpose = transpose;
-   thread_param->value = value;
+   thread_data->location = location;
+   thread_data->count = count;
+   thread_data->transpose = transpose;
+   thread_data->value = value;
 
-   thread_param->value_copied = NULL;
+   thread_data->value_copied = NULL;
    if (thread_mode == EVAS_GL_THREAD_MODE_FINISH)
      goto finish;
 
@@ -3423,10 +3427,10 @@ glUniformMatrix3fv_thread_cmd(GLint location, GLsizei count, GLboolean transpose
              goto finish;
           }
         /* 2. malloc & copy */
-        thread_param->value_copied = eina_mempool_malloc(_mp_uniform, copy_size);
-        if (thread_param->value_copied)
+        thread_data->value_copied = eina_mempool_malloc(_mp_uniform, copy_size);
+        if (thread_data->value_copied)
           {
-             memcpy(thread_param->value_copied, value, copy_size);
+             memcpy(thread_data->value_copied, value, copy_size);
           }
         else
           {
@@ -3434,20 +3438,20 @@ glUniformMatrix3fv_thread_cmd(GLint location, GLsizei count, GLboolean transpose
              goto finish;
           }
         /* 3. replace */
-        thread_param->value = (const GLfloat  *)thread_param->value_copied;
+        thread_data->value = (const GLfloat  *)thread_data->value_copied;
      }
    /* end of copy variable */
 
 finish:
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glUniformMatrix3fv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+ * void
+ * glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
  */
 
 typedef struct
@@ -3459,25 +3463,25 @@ typedef struct
    void *value_copied; /* COPIED */
    int command_allocated;
 
-} Thread_Command_glUniformMatrix4fv;
+} Evas_Thread_Command_glUniformMatrix4fv;
 
 static void
 _gl_thread_glUniformMatrix4fv(void *data)
 {
-   Thread_Command_glUniformMatrix4fv *thread_param =
-      (Thread_Command_glUniformMatrix4fv *)data;
+   Evas_Thread_Command_glUniformMatrix4fv *thread_data =
+      (Evas_Thread_Command_glUniformMatrix4fv *)data;
 
-   glUniformMatrix4fv(thread_param->location,
-                      thread_param->count,
-                      thread_param->transpose,
-                      thread_param->value);
+   glUniformMatrix4fv(thread_data->location,
+                      thread_data->count,
+                      thread_data->transpose,
+                      thread_data->value);
 
 
-   if (thread_param->value_copied)
-     eina_mempool_free(_mp_uniform, thread_param->value_copied);
+   if (thread_data->value_copied)
+     eina_mempool_free(_mp_uniform, thread_data->value_copied);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -3491,31 +3495,31 @@ glUniformMatrix4fv_thread_cmd(GLint location, GLsizei count, GLboolean transpose
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glUniformMatrix4fv thread_param_local;
-   Thread_Command_glUniformMatrix4fv *thread_param = &thread_param_local;
+   Evas_Thread_Command_glUniformMatrix4fv thread_data_local;
+   Evas_Thread_Command_glUniformMatrix4fv *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        Thread_Command_glUniformMatrix4fv *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(Thread_Command_glUniformMatrix4fv));
-        if (thread_param_new)
+        Evas_Thread_Command_glUniformMatrix4fv *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(Evas_Thread_Command_glUniformMatrix4fv));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->location = location;
-   thread_param->count = count;
-   thread_param->transpose = transpose;
-   thread_param->value = value;
+   thread_data->location = location;
+   thread_data->count = count;
+   thread_data->transpose = transpose;
+   thread_data->value = value;
 
-   thread_param->value_copied = NULL;
+   thread_data->value_copied = NULL;
    if (thread_mode == EVAS_GL_THREAD_MODE_FINISH)
      goto finish;
 
@@ -3530,10 +3534,10 @@ glUniformMatrix4fv_thread_cmd(GLint location, GLsizei count, GLboolean transpose
              goto finish;
           }
         /* 2. malloc & copy */
-        thread_param->value_copied = eina_mempool_malloc(_mp_uniform, copy_size);
-        if (thread_param->value_copied)
+        thread_data->value_copied = eina_mempool_malloc(_mp_uniform, copy_size);
+        if (thread_data->value_copied)
           {
-             memcpy(thread_param->value_copied, value, copy_size);
+             memcpy(thread_data->value_copied, value, copy_size);
           }
         else
           {
@@ -3541,20 +3545,20 @@ glUniformMatrix4fv_thread_cmd(GLint location, GLsizei count, GLboolean transpose
              goto finish;
           }
         /* 3. replace */
-        thread_param->value = (const GLfloat  *)thread_param->value_copied;
+        thread_data->value = (const GLfloat  *)thread_data->value_copied;
      }
    /* end of copy variable */
 
 finish:
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glUniformMatrix4fv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glViewport(GLint x, GLint y, GLsizei width, GLsizei height);
+ * void
+ * glViewport(GLint x, GLint y, GLsizei width, GLsizei height);
  */
 
 typedef struct
@@ -3565,21 +3569,21 @@ typedef struct
    GLsizei height;
    int command_allocated;
 
-} Thread_Command_glViewport;
+} Evas_Thread_Command_glViewport;
 
 static void
 _gl_thread_glViewport(void *data)
 {
-   Thread_Command_glViewport *thread_param =
-      (Thread_Command_glViewport *)data;
+   Evas_Thread_Command_glViewport *thread_data =
+      (Evas_Thread_Command_glViewport *)data;
 
-   glViewport(thread_param->x,
-              thread_param->y,
-              thread_param->width,
-              thread_param->height);
+   glViewport(thread_data->x,
+              thread_data->y,
+              thread_data->width,
+              thread_data->height);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -3593,39 +3597,39 @@ glViewport_thread_cmd(GLint x, GLint y, GLsizei width, GLsizei height)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glViewport thread_param_local;
-   Thread_Command_glViewport *thread_param = &thread_param_local;
+   Evas_Thread_Command_glViewport thread_data_local;
+   Evas_Thread_Command_glViewport *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        Thread_Command_glViewport *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(Thread_Command_glViewport));
-        if (thread_param_new)
+        Evas_Thread_Command_glViewport *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(Evas_Thread_Command_glViewport));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->x = x;
-   thread_param->y = y;
-   thread_param->width = width;
-   thread_param->height = height;
+   thread_data->x = x;
+   thread_data->y = y;
+   thread_data->width = width;
+   thread_data->height = height;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glViewport,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glEnable(GLenum cap);
+ * void
+ * glEnable(GLenum cap);
  */
 
 typedef struct
@@ -3633,18 +3637,18 @@ typedef struct
    GLenum cap;
    int command_allocated;
 
-} Thread_Command_glEnable;
+} Evas_Thread_Command_glEnable;
 
 static void
 _gl_thread_glEnable(void *data)
 {
-   Thread_Command_glEnable *thread_param =
-      (Thread_Command_glEnable *)data;
+   Evas_Thread_Command_glEnable *thread_data =
+      (Evas_Thread_Command_glEnable *)data;
 
-   glEnable(thread_param->cap);
+   glEnable(thread_data->cap);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -3658,36 +3662,36 @@ glEnable_thread_cmd(GLenum cap)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glEnable thread_param_local;
-   Thread_Command_glEnable *thread_param = &thread_param_local;
+   Evas_Thread_Command_glEnable thread_data_local;
+   Evas_Thread_Command_glEnable *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        Thread_Command_glEnable *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(Thread_Command_glEnable));
-        if (thread_param_new)
+        Evas_Thread_Command_glEnable *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(Evas_Thread_Command_glEnable));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_ENQUEUE;
           }
      }
 
-   thread_param->cap = cap;
+   thread_data->cap = cap;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glEnable,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glDisable(GLenum cap);
+ * void
+ * glDisable(GLenum cap);
  */
 
 typedef struct
@@ -3695,18 +3699,18 @@ typedef struct
    GLenum cap;
    int command_allocated;
 
-} Thread_Command_glDisable;
+} Evas_Thread_Command_glDisable;
 
 static void
 _gl_thread_glDisable(void *data)
 {
-   Thread_Command_glDisable *thread_param =
-      (Thread_Command_glDisable *)data;
+   Evas_Thread_Command_glDisable *thread_data =
+      (Evas_Thread_Command_glDisable *)data;
 
-   glDisable(thread_param->cap);
+   glDisable(thread_data->cap);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -3720,36 +3724,36 @@ glDisable_thread_cmd(GLenum cap)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glDisable thread_param_local;
-   Thread_Command_glDisable *thread_param = &thread_param_local;
+   Evas_Thread_Command_glDisable thread_data_local;
+   Evas_Thread_Command_glDisable *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        Thread_Command_glDisable *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(Thread_Command_glDisable));
-        if (thread_param_new)
+        Evas_Thread_Command_glDisable *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(Evas_Thread_Command_glDisable));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_ENQUEUE;
           }
      }
 
-   thread_param->cap = cap;
+   thread_data->cap = cap;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glDisable,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glLineWidth(GLfloat width);
+ * void
+ * glLineWidth(GLfloat width);
  */
 
 typedef struct
@@ -3757,18 +3761,18 @@ typedef struct
    GLfloat width;
    int command_allocated;
 
-} Thread_Command_glLineWidth;
+} Evas_Thread_Command_glLineWidth;
 
 static void
 _gl_thread_glLineWidth(void *data)
 {
-   Thread_Command_glLineWidth *thread_param =
-      (Thread_Command_glLineWidth *)data;
+   Evas_Thread_Command_glLineWidth *thread_data =
+      (Evas_Thread_Command_glLineWidth *)data;
 
-   glLineWidth(thread_param->width);
+   glLineWidth(thread_data->width);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -3782,36 +3786,36 @@ glLineWidth_thread_cmd(GLfloat width)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glLineWidth thread_param_local;
-   Thread_Command_glLineWidth *thread_param = &thread_param_local;
+   Evas_Thread_Command_glLineWidth thread_data_local;
+   Evas_Thread_Command_glLineWidth *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        Thread_Command_glLineWidth *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(Thread_Command_glLineWidth));
-        if (thread_param_new)
+        Evas_Thread_Command_glLineWidth *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(Evas_Thread_Command_glLineWidth));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->width = width;
+   thread_data->width = width;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glLineWidth,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glPolygonOffset(GLfloat factor, GLfloat units);
+ * void
+ * glPolygonOffset(GLfloat factor, GLfloat units);
  */
 
 typedef struct
@@ -3820,19 +3824,19 @@ typedef struct
    GLfloat units;
    int command_allocated;
 
-} Thread_Command_glPolygonOffset;
+} Evas_Thread_Command_glPolygonOffset;
 
 static void
 _gl_thread_glPolygonOffset(void *data)
 {
-   Thread_Command_glPolygonOffset *thread_param =
-      (Thread_Command_glPolygonOffset *)data;
+   Evas_Thread_Command_glPolygonOffset *thread_data =
+      (Evas_Thread_Command_glPolygonOffset *)data;
 
-   glPolygonOffset(thread_param->factor,
-                   thread_param->units);
+   glPolygonOffset(thread_data->factor,
+                   thread_data->units);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -3846,37 +3850,37 @@ glPolygonOffset_thread_cmd(GLfloat factor, GLfloat units)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glPolygonOffset thread_param_local;
-   Thread_Command_glPolygonOffset *thread_param = &thread_param_local;
+   Evas_Thread_Command_glPolygonOffset thread_data_local;
+   Evas_Thread_Command_glPolygonOffset *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        Thread_Command_glPolygonOffset *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(Thread_Command_glPolygonOffset));
-        if (thread_param_new)
+        Evas_Thread_Command_glPolygonOffset *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(Evas_Thread_Command_glPolygonOffset));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->factor = factor;
-   thread_param->units = units;
+   thread_data->factor = factor;
+   thread_data->units = units;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glPolygonOffset,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glPixelStorei(GLenum pname, GLint param);
+ * void
+ * glPixelStorei(GLenum pname, GLint param);
  */
 
 typedef struct
@@ -3885,19 +3889,19 @@ typedef struct
    GLint param;
    int command_allocated;
 
-} Thread_Command_glPixelStorei;
+} Evas_Thread_Command_glPixelStorei;
 
 static void
 _gl_thread_glPixelStorei(void *data)
 {
-   Thread_Command_glPixelStorei *thread_param =
-      (Thread_Command_glPixelStorei *)data;
+   Evas_Thread_Command_glPixelStorei *thread_data =
+      (Evas_Thread_Command_glPixelStorei *)data;
 
-   glPixelStorei(thread_param->pname,
-                 thread_param->param);
+   glPixelStorei(thread_data->pname,
+                 thread_data->param);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -3911,37 +3915,37 @@ glPixelStorei_thread_cmd(GLenum pname, GLint param)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glPixelStorei thread_param_local;
-   Thread_Command_glPixelStorei *thread_param = &thread_param_local;
+   Evas_Thread_Command_glPixelStorei thread_data_local;
+   Evas_Thread_Command_glPixelStorei *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        Thread_Command_glPixelStorei *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(Thread_Command_glPixelStorei));
-        if (thread_param_new)
+        Evas_Thread_Command_glPixelStorei *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(Evas_Thread_Command_glPixelStorei));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->pname = pname;
-   thread_param->param = param;
+   thread_data->pname = pname;
+   thread_data->param = param;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glPixelStorei,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glActiveTexture(GLenum texture);
+ * void
+ * glActiveTexture(GLenum texture);
  */
 
 typedef struct
@@ -3949,18 +3953,18 @@ typedef struct
    GLenum texture;
    int command_allocated;
 
-} Thread_Command_glActiveTexture;
+} Evas_Thread_Command_glActiveTexture;
 
 static void
 _gl_thread_glActiveTexture(void *data)
 {
-   Thread_Command_glActiveTexture *thread_param =
-      (Thread_Command_glActiveTexture *)data;
+   Evas_Thread_Command_glActiveTexture *thread_data =
+      (Evas_Thread_Command_glActiveTexture *)data;
 
-   glActiveTexture(thread_param->texture);
+   glActiveTexture(thread_data->texture);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -3974,36 +3978,36 @@ glActiveTexture_thread_cmd(GLenum texture)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glActiveTexture thread_param_local;
-   Thread_Command_glActiveTexture *thread_param = &thread_param_local;
+   Evas_Thread_Command_glActiveTexture thread_data_local;
+   Evas_Thread_Command_glActiveTexture *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        Thread_Command_glActiveTexture *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(Thread_Command_glActiveTexture));
-        if (thread_param_new)
+        Evas_Thread_Command_glActiveTexture *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(Evas_Thread_Command_glActiveTexture));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->texture = texture;
+   thread_data->texture = texture;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glActiveTexture,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGenTextures(GLsizei n, GLuint *textures);
+ * void
+ * glGenTextures(GLsizei n, GLuint *textures);
  */
 
 typedef struct
@@ -4011,16 +4015,16 @@ typedef struct
    GLsizei n;
    GLuint *textures;
 
-} Thread_Command_glGenTextures;
+} Evas_Thread_Command_glGenTextures;
 
 static void
 _gl_thread_glGenTextures(void *data)
 {
-   Thread_Command_glGenTextures *thread_param =
-      (Thread_Command_glGenTextures *)data;
+   Evas_Thread_Command_glGenTextures *thread_data =
+      (Evas_Thread_Command_glGenTextures *)data;
 
-   glGenTextures(thread_param->n,
-                 thread_param->textures);
+   glGenTextures(thread_data->n,
+                 thread_data->textures);
 
 }
 
@@ -4035,21 +4039,21 @@ glGenTextures_thread_cmd(GLsizei n, GLuint *textures)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glGenTextures thread_param_local;
-   Thread_Command_glGenTextures *thread_param = &thread_param_local;
+   Evas_Thread_Command_glGenTextures thread_data_local;
+   Evas_Thread_Command_glGenTextures *thread_data = &thread_data_local;
 
-   thread_param->n = n;
-   thread_param->textures = textures;
+   thread_data->n = n;
+   thread_data->textures = textures;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glGenTextures,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glBindTexture(GLenum target, GLuint texture);
+ * void
+ * glBindTexture(GLenum target, GLuint texture);
  */
 
 typedef struct
@@ -4058,19 +4062,19 @@ typedef struct
    GLuint texture;
    int command_allocated;
 
-} Thread_Command_glBindTexture;
+} Evas_Thread_Command_glBindTexture;
 
 static void
 _gl_thread_glBindTexture(void *data)
 {
-   Thread_Command_glBindTexture *thread_param =
-      (Thread_Command_glBindTexture *)data;
+   Evas_Thread_Command_glBindTexture *thread_data =
+      (Evas_Thread_Command_glBindTexture *)data;
 
-   glBindTexture(thread_param->target,
-                 thread_param->texture);
+   glBindTexture(thread_data->target,
+                 thread_data->texture);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -4084,37 +4088,37 @@ glBindTexture_thread_cmd(GLenum target, GLuint texture)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glBindTexture thread_param_local;
-   Thread_Command_glBindTexture *thread_param = &thread_param_local;
+   Evas_Thread_Command_glBindTexture thread_data_local;
+   Evas_Thread_Command_glBindTexture *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        Thread_Command_glBindTexture *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(Thread_Command_glBindTexture));
-        if (thread_param_new)
+        Evas_Thread_Command_glBindTexture *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(Evas_Thread_Command_glBindTexture));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->target = target;
-   thread_param->texture = texture;
+   thread_data->target = target;
+   thread_data->texture = texture;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glBindTexture,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glDeleteTextures(GLsizei n, const GLuint *textures);
+ * void
+ * glDeleteTextures(GLsizei n, const GLuint *textures);
  */
 
 typedef struct
@@ -4124,23 +4128,23 @@ typedef struct
    void *textures_copied; /* COPIED */
    int command_allocated;
 
-} Thread_Command_glDeleteTextures;
+} Evas_Thread_Command_glDeleteTextures;
 
 static void
 _gl_thread_glDeleteTextures(void *data)
 {
-   Thread_Command_glDeleteTextures *thread_param =
-      (Thread_Command_glDeleteTextures *)data;
+   Evas_Thread_Command_glDeleteTextures *thread_data =
+      (Evas_Thread_Command_glDeleteTextures *)data;
 
-   glDeleteTextures(thread_param->n,
-                    thread_param->textures);
+   glDeleteTextures(thread_data->n,
+                    thread_data->textures);
 
 
-   if (thread_param->textures_copied)
-     eina_mempool_free(_mp_delete_object, thread_param->textures_copied);
+   if (thread_data->textures_copied)
+     eina_mempool_free(_mp_delete_object, thread_data->textures_copied);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -4154,29 +4158,29 @@ glDeleteTextures_thread_cmd(GLsizei n, const GLuint *textures)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glDeleteTextures thread_param_local;
-   Thread_Command_glDeleteTextures *thread_param = &thread_param_local;
+   Evas_Thread_Command_glDeleteTextures thread_data_local;
+   Evas_Thread_Command_glDeleteTextures *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        Thread_Command_glDeleteTextures *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(Thread_Command_glDeleteTextures));
-        if (thread_param_new)
+        Evas_Thread_Command_glDeleteTextures *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(Evas_Thread_Command_glDeleteTextures));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->n = n;
-   thread_param->textures = textures;
+   thread_data->n = n;
+   thread_data->textures = textures;
 
-   thread_param->textures_copied = NULL;
+   thread_data->textures_copied = NULL;
    if (thread_mode == EVAS_GL_THREAD_MODE_FINISH)
      goto finish;
 
@@ -4191,10 +4195,10 @@ glDeleteTextures_thread_cmd(GLsizei n, const GLuint *textures)
              goto finish;
           }
         /* 2. malloc & copy */
-        thread_param->textures_copied = eina_mempool_malloc(_mp_delete_object, copy_size);
-        if (thread_param->textures_copied)
+        thread_data->textures_copied = eina_mempool_malloc(_mp_delete_object, copy_size);
+        if (thread_data->textures_copied)
           {
-             memcpy(thread_param->textures_copied, textures, copy_size);
+             memcpy(thread_data->textures_copied, textures, copy_size);
           }
         else
           {
@@ -4202,20 +4206,20 @@ glDeleteTextures_thread_cmd(GLsizei n, const GLuint *textures)
              goto finish;
           }
         /* 3. replace */
-        thread_param->textures = (const GLuint  *)thread_param->textures_copied;
+        thread_data->textures = (const GLuint  *)thread_data->textures_copied;
      }
    /* end of copy variable */
 
 finish:
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glDeleteTextures,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels);
+ * void
+ * glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels);
  */
 
 typedef struct
@@ -4232,28 +4236,28 @@ typedef struct
    int command_allocated;
    GLTEXIMAGE2D_COPY_VARIABLE; /* TODO */
 
-} Thread_Command_glTexImage2D;
+} Evas_Thread_Command_glTexImage2D;
 
 static void
 _gl_thread_glTexImage2D(void *data)
 {
-   Thread_Command_glTexImage2D *thread_param =
-      (Thread_Command_glTexImage2D *)data;
+   Evas_Thread_Command_glTexImage2D *thread_data =
+      (Evas_Thread_Command_glTexImage2D *)data;
 
-   glTexImage2D(thread_param->target,
-                thread_param->level,
-                thread_param->internalformat,
-                thread_param->width,
-                thread_param->height,
-                thread_param->border,
-                thread_param->format,
-                thread_param->type,
-                thread_param->pixels);
+   glTexImage2D(thread_data->target,
+                thread_data->level,
+                thread_data->internalformat,
+                thread_data->width,
+                thread_data->height,
+                thread_data->border,
+                thread_data->format,
+                thread_data->type,
+                thread_data->pixels);
 
    GLTEXIMAGE2D_COPY_VARIABLE_FREE; /* TODO */
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -4267,34 +4271,34 @@ glTexImage2D_thread_cmd(GLenum target, GLint level, GLint internalformat, GLsize
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glTexImage2D thread_param_local;
-   Thread_Command_glTexImage2D *thread_param = &thread_param_local;
+   Evas_Thread_Command_glTexImage2D thread_data_local;
+   Evas_Thread_Command_glTexImage2D *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        Thread_Command_glTexImage2D *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(Thread_Command_glTexImage2D));
-        if (thread_param_new)
+        Evas_Thread_Command_glTexImage2D *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(Evas_Thread_Command_glTexImage2D));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->target = target;
-   thread_param->level = level;
-   thread_param->internalformat = internalformat;
-   thread_param->width = width;
-   thread_param->height = height;
-   thread_param->border = border;
-   thread_param->format = format;
-   thread_param->type = type;
-   thread_param->pixels = pixels;
+   thread_data->target = target;
+   thread_data->level = level;
+   thread_data->internalformat = internalformat;
+   thread_data->width = width;
+   thread_data->height = height;
+   thread_data->border = border;
+   thread_data->format = format;
+   thread_data->type = type;
+   thread_data->pixels = pixels;
 
    GLTEXIMAGE2D_COPY_VARIABLE_INIT; /* TODO */
 
@@ -4306,13 +4310,13 @@ glTexImage2D_thread_cmd(GLenum target, GLint level, GLint internalformat, GLsize
 finish:
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glTexImage2D,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels);
+ * void
+ * glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels);
  */
 
 typedef struct
@@ -4329,28 +4333,28 @@ typedef struct
    int command_allocated;
    GLTEXSUBIMAGE2D_COPY_VARIABLE; /* TODO */
 
-} Thread_Command_glTexSubImage2D;
+} Evas_Thread_Command_glTexSubImage2D;
 
 static void
 _gl_thread_glTexSubImage2D(void *data)
 {
-   Thread_Command_glTexSubImage2D *thread_param =
-      (Thread_Command_glTexSubImage2D *)data;
+   Evas_Thread_Command_glTexSubImage2D *thread_data =
+      (Evas_Thread_Command_glTexSubImage2D *)data;
 
-   glTexSubImage2D(thread_param->target,
-                   thread_param->level,
-                   thread_param->xoffset,
-                   thread_param->yoffset,
-                   thread_param->width,
-                   thread_param->height,
-                   thread_param->format,
-                   thread_param->type,
-                   thread_param->pixels);
+   glTexSubImage2D(thread_data->target,
+                   thread_data->level,
+                   thread_data->xoffset,
+                   thread_data->yoffset,
+                   thread_data->width,
+                   thread_data->height,
+                   thread_data->format,
+                   thread_data->type,
+                   thread_data->pixels);
 
    GLTEXSUBIMAGE2D_COPY_VARIABLE_FREE; /* TODO */
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -4364,34 +4368,34 @@ glTexSubImage2D_thread_cmd(GLenum target, GLint level, GLint xoffset, GLint yoff
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glTexSubImage2D thread_param_local;
-   Thread_Command_glTexSubImage2D *thread_param = &thread_param_local;
+   Evas_Thread_Command_glTexSubImage2D thread_data_local;
+   Evas_Thread_Command_glTexSubImage2D *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        Thread_Command_glTexSubImage2D *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(Thread_Command_glTexSubImage2D));
-        if (thread_param_new)
+        Evas_Thread_Command_glTexSubImage2D *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(Evas_Thread_Command_glTexSubImage2D));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->target = target;
-   thread_param->level = level;
-   thread_param->xoffset = xoffset;
-   thread_param->yoffset = yoffset;
-   thread_param->width = width;
-   thread_param->height = height;
-   thread_param->format = format;
-   thread_param->type = type;
-   thread_param->pixels = pixels;
+   thread_data->target = target;
+   thread_data->level = level;
+   thread_data->xoffset = xoffset;
+   thread_data->yoffset = yoffset;
+   thread_data->width = width;
+   thread_data->height = height;
+   thread_data->format = format;
+   thread_data->type = type;
+   thread_data->pixels = pixels;
 
    GLTEXSUBIMAGE2D_COPY_VARIABLE_INIT; /* TODO */
 
@@ -4403,13 +4407,13 @@ glTexSubImage2D_thread_cmd(GLenum target, GLint level, GLint xoffset, GLint yoff
 finish:
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glTexSubImage2D,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void *data);
+ * void
+ * glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void *data);
  */
 
 typedef struct
@@ -4425,27 +4429,27 @@ typedef struct
    int command_allocated;
    GLCOMPRESSEDTEXIMAGE2D_COPY_VARIABLE; /* TODO */
 
-} Thread_Command_glCompressedTexImage2D;
+} Evas_Thread_Command_glCompressedTexImage2D;
 
 static void
 _gl_thread_glCompressedTexImage2D(void *data)
 {
-   Thread_Command_glCompressedTexImage2D *thread_param =
-      (Thread_Command_glCompressedTexImage2D *)data;
+   Evas_Thread_Command_glCompressedTexImage2D *thread_data =
+      (Evas_Thread_Command_glCompressedTexImage2D *)data;
 
-   glCompressedTexImage2D(thread_param->target,
-                          thread_param->level,
-                          thread_param->internalformat,
-                          thread_param->width,
-                          thread_param->height,
-                          thread_param->border,
-                          thread_param->imageSize,
-                          thread_param->data);
+   glCompressedTexImage2D(thread_data->target,
+                          thread_data->level,
+                          thread_data->internalformat,
+                          thread_data->width,
+                          thread_data->height,
+                          thread_data->border,
+                          thread_data->imageSize,
+                          thread_data->data);
 
    GLCOMPRESSEDTEXIMAGE2D_COPY_VARIABLE_FREE; /* TODO */
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -4459,33 +4463,33 @@ glCompressedTexImage2D_thread_cmd(GLenum target, GLint level, GLenum internalfor
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glCompressedTexImage2D thread_param_local;
-   Thread_Command_glCompressedTexImage2D *thread_param = &thread_param_local;
+   Evas_Thread_Command_glCompressedTexImage2D thread_data_local;
+   Evas_Thread_Command_glCompressedTexImage2D *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        Thread_Command_glCompressedTexImage2D *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(Thread_Command_glCompressedTexImage2D));
-        if (thread_param_new)
+        Evas_Thread_Command_glCompressedTexImage2D *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(Evas_Thread_Command_glCompressedTexImage2D));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->target = target;
-   thread_param->level = level;
-   thread_param->internalformat = internalformat;
-   thread_param->width = width;
-   thread_param->height = height;
-   thread_param->border = border;
-   thread_param->imageSize = imageSize;
-   thread_param->data = data;
+   thread_data->target = target;
+   thread_data->level = level;
+   thread_data->internalformat = internalformat;
+   thread_data->width = width;
+   thread_data->height = height;
+   thread_data->border = border;
+   thread_data->imageSize = imageSize;
+   thread_data->data = data;
 
    GLCOMPRESSEDTEXIMAGE2D_COPY_VARIABLE_INIT; /* TODO */
 
@@ -4497,13 +4501,13 @@ glCompressedTexImage2D_thread_cmd(GLenum target, GLint level, GLenum internalfor
 finish:
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glCompressedTexImage2D,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *data);
+ * void
+ * glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *data);
  */
 
 typedef struct
@@ -4520,28 +4524,28 @@ typedef struct
    int command_allocated;
    GLCOMPRESSEDTEXSUBIMAGE2D_COPY_VARIABLE; /* TODO */
 
-} Thread_Command_glCompressedTexSubImage2D;
+} Evas_Thread_Command_glCompressedTexSubImage2D;
 
 static void
 _gl_thread_glCompressedTexSubImage2D(void *data)
 {
-   Thread_Command_glCompressedTexSubImage2D *thread_param =
-      (Thread_Command_glCompressedTexSubImage2D *)data;
+   Evas_Thread_Command_glCompressedTexSubImage2D *thread_data =
+      (Evas_Thread_Command_glCompressedTexSubImage2D *)data;
 
-   glCompressedTexSubImage2D(thread_param->target,
-                             thread_param->level,
-                             thread_param->xoffset,
-                             thread_param->yoffset,
-                             thread_param->width,
-                             thread_param->height,
-                             thread_param->format,
-                             thread_param->imageSize,
-                             thread_param->data);
+   glCompressedTexSubImage2D(thread_data->target,
+                             thread_data->level,
+                             thread_data->xoffset,
+                             thread_data->yoffset,
+                             thread_data->width,
+                             thread_data->height,
+                             thread_data->format,
+                             thread_data->imageSize,
+                             thread_data->data);
 
    GLCOMPRESSEDTEXSUBIMAGE2D_COPY_VARIABLE_FREE; /* TODO */
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -4555,34 +4559,34 @@ glCompressedTexSubImage2D_thread_cmd(GLenum target, GLint level, GLint xoffset,
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glCompressedTexSubImage2D thread_param_local;
-   Thread_Command_glCompressedTexSubImage2D *thread_param = &thread_param_local;
+   Evas_Thread_Command_glCompressedTexSubImage2D thread_data_local;
+   Evas_Thread_Command_glCompressedTexSubImage2D *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        Thread_Command_glCompressedTexSubImage2D *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(Thread_Command_glCompressedTexSubImage2D));
-        if (thread_param_new)
+        Evas_Thread_Command_glCompressedTexSubImage2D *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(Evas_Thread_Command_glCompressedTexSubImage2D));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->target = target;
-   thread_param->level = level;
-   thread_param->xoffset = xoffset;
-   thread_param->yoffset = yoffset;
-   thread_param->width = width;
-   thread_param->height = height;
-   thread_param->format = format;
-   thread_param->imageSize = imageSize;
-   thread_param->data = data;
+   thread_data->target = target;
+   thread_data->level = level;
+   thread_data->xoffset = xoffset;
+   thread_data->yoffset = yoffset;
+   thread_data->width = width;
+   thread_data->height = height;
+   thread_data->format = format;
+   thread_data->imageSize = imageSize;
+   thread_data->data = data;
 
    GLCOMPRESSEDTEXSUBIMAGE2D_COPY_VARIABLE_INIT; /* TODO */
 
@@ -4594,13 +4598,13 @@ glCompressedTexSubImage2D_thread_cmd(GLenum target, GLint level, GLint xoffset,
 finish:
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glCompressedTexSubImage2D,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glTexParameterf(GLenum target, GLenum pname, GLfloat param);
+ * void
+ * glTexParameterf(GLenum target, GLenum pname, GLfloat param);
  */
 
 typedef struct
@@ -4610,20 +4614,20 @@ typedef struct
    GLfloat param;
    int command_allocated;
 
-} Thread_Command_glTexParameterf;
+} Evas_Thread_Command_glTexParameterf;
 
 static void
 _gl_thread_glTexParameterf(void *data)
 {
-   Thread_Command_glTexParameterf *thread_param =
-      (Thread_Command_glTexParameterf *)data;
+   Evas_Thread_Command_glTexParameterf *thread_data =
+      (Evas_Thread_Command_glTexParameterf *)data;
 
-   glTexParameterf(thread_param->target,
-                   thread_param->pname,
-                   thread_param->param);
+   glTexParameterf(thread_data->target,
+                   thread_data->pname,
+                   thread_data->param);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -4637,38 +4641,38 @@ glTexParameterf_thread_cmd(GLenum target, GLenum pname, GLfloat param)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glTexParameterf thread_param_local;
-   Thread_Command_glTexParameterf *thread_param = &thread_param_local;
+   Evas_Thread_Command_glTexParameterf thread_data_local;
+   Evas_Thread_Command_glTexParameterf *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        Thread_Command_glTexParameterf *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(Thread_Command_glTexParameterf));
-        if (thread_param_new)
+        Evas_Thread_Command_glTexParameterf *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(Evas_Thread_Command_glTexParameterf));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->target = target;
-   thread_param->pname = pname;
-   thread_param->param = param;
+   thread_data->target = target;
+   thread_data->pname = pname;
+   thread_data->param = param;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glTexParameterf,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params);
+ * void
+ * glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params);
  */
 
 typedef struct
@@ -4679,24 +4683,24 @@ typedef struct
    void *params_copied; /* COPIED */
    int command_allocated;
 
-} Thread_Command_glTexParameterfv;
+} Evas_Thread_Command_glTexParameterfv;
 
 static void
 _gl_thread_glTexParameterfv(void *data)
 {
-   Thread_Command_glTexParameterfv *thread_param =
-      (Thread_Command_glTexParameterfv *)data;
+   Evas_Thread_Command_glTexParameterfv *thread_data =
+      (Evas_Thread_Command_glTexParameterfv *)data;
 
-   glTexParameterfv(thread_param->target,
-                    thread_param->pname,
-                    thread_param->params);
+   glTexParameterfv(thread_data->target,
+                    thread_data->pname,
+                    thread_data->params);
 
 
-   if (thread_param->params_copied)
-     eina_mempool_free(_mp_default, thread_param->params_copied);
+   if (thread_data->params_copied)
+     eina_mempool_free(_mp_default, thread_data->params_copied);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -4710,30 +4714,30 @@ glTexParameterfv_thread_cmd(GLenum target, GLenum pname, const GLfloat *params)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glTexParameterfv thread_param_local;
-   Thread_Command_glTexParameterfv *thread_param = &thread_param_local;
+   Evas_Thread_Command_glTexParameterfv thread_data_local;
+   Evas_Thread_Command_glTexParameterfv *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        Thread_Command_glTexParameterfv *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(Thread_Command_glTexParameterfv));
-        if (thread_param_new)
+        Evas_Thread_Command_glTexParameterfv *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(Evas_Thread_Command_glTexParameterfv));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->target = target;
-   thread_param->pname = pname;
-   thread_param->params = params;
+   thread_data->target = target;
+   thread_data->pname = pname;
+   thread_data->params = params;
 
-   thread_param->params_copied = NULL;
+   thread_data->params_copied = NULL;
    if (thread_mode == EVAS_GL_THREAD_MODE_FINISH)
      goto finish;
 
@@ -4748,10 +4752,10 @@ glTexParameterfv_thread_cmd(GLenum target, GLenum pname, const GLfloat *params)
              goto finish;
           }
         /* 2. malloc & copy */
-        thread_param->params_copied = eina_mempool_malloc(_mp_default, copy_size);
-        if (thread_param->params_copied)
+        thread_data->params_copied = eina_mempool_malloc(_mp_default, copy_size);
+        if (thread_data->params_copied)
           {
-             memcpy(thread_param->params_copied, params, copy_size);
+             memcpy(thread_data->params_copied, params, copy_size);
           }
         else
           {
@@ -4759,20 +4763,20 @@ glTexParameterfv_thread_cmd(GLenum target, GLenum pname, const GLfloat *params)
              goto finish;
           }
         /* 3. replace */
-        thread_param->params = (const GLfloat  *)thread_param->params_copied;
+        thread_data->params = (const GLfloat  *)thread_data->params_copied;
      }
    /* end of copy variable */
 
 finish:
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glTexParameterfv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glTexParameteri(GLenum target, GLenum pname, GLint param);
+ * void
+ * glTexParameteri(GLenum target, GLenum pname, GLint param);
  */
 
 typedef struct
@@ -4782,20 +4786,20 @@ typedef struct
    GLint param;
    int command_allocated;
 
-} Thread_Command_glTexParameteri;
+} Evas_Thread_Command_glTexParameteri;
 
 static void
 _gl_thread_glTexParameteri(void *data)
 {
-   Thread_Command_glTexParameteri *thread_param =
-      (Thread_Command_glTexParameteri *)data;
+   Evas_Thread_Command_glTexParameteri *thread_data =
+      (Evas_Thread_Command_glTexParameteri *)data;
 
-   glTexParameteri(thread_param->target,
-                   thread_param->pname,
-                   thread_param->param);
+   glTexParameteri(thread_data->target,
+                   thread_data->pname,
+                   thread_data->param);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -4809,38 +4813,38 @@ glTexParameteri_thread_cmd(GLenum target, GLenum pname, GLint param)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glTexParameteri thread_param_local;
-   Thread_Command_glTexParameteri *thread_param = &thread_param_local;
+   Evas_Thread_Command_glTexParameteri thread_data_local;
+   Evas_Thread_Command_glTexParameteri *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        Thread_Command_glTexParameteri *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(Thread_Command_glTexParameteri));
-        if (thread_param_new)
+        Evas_Thread_Command_glTexParameteri *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(Evas_Thread_Command_glTexParameteri));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->target = target;
-   thread_param->pname = pname;
-   thread_param->param = param;
+   thread_data->target = target;
+   thread_data->pname = pname;
+   thread_data->param = param;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glTexParameteri,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glTexParameteriv(GLenum target, GLenum pname, const GLint *params);
+ * void
+ * glTexParameteriv(GLenum target, GLenum pname, const GLint *params);
  */
 
 typedef struct
@@ -4851,24 +4855,24 @@ typedef struct
    void *params_copied; /* COPIED */
    int command_allocated;
 
-} Thread_Command_glTexParameteriv;
+} Evas_Thread_Command_glTexParameteriv;
 
 static void
 _gl_thread_glTexParameteriv(void *data)
 {
-   Thread_Command_glTexParameteriv *thread_param =
-      (Thread_Command_glTexParameteriv *)data;
+   Evas_Thread_Command_glTexParameteriv *thread_data =
+      (Evas_Thread_Command_glTexParameteriv *)data;
 
-   glTexParameteriv(thread_param->target,
-                    thread_param->pname,
-                    thread_param->params);
+   glTexParameteriv(thread_data->target,
+                    thread_data->pname,
+                    thread_data->params);
 
 
-   if (thread_param->params_copied)
-     eina_mempool_free(_mp_default, thread_param->params_copied);
+   if (thread_data->params_copied)
+     eina_mempool_free(_mp_default, thread_data->params_copied);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -4882,30 +4886,30 @@ glTexParameteriv_thread_cmd(GLenum target, GLenum pname, const GLint *params)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glTexParameteriv thread_param_local;
-   Thread_Command_glTexParameteriv *thread_param = &thread_param_local;
+   Evas_Thread_Command_glTexParameteriv thread_data_local;
+   Evas_Thread_Command_glTexParameteriv *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        Thread_Command_glTexParameteriv *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(Thread_Command_glTexParameteriv));
-        if (thread_param_new)
+        Evas_Thread_Command_glTexParameteriv *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(Evas_Thread_Command_glTexParameteriv));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->target = target;
-   thread_param->pname = pname;
-   thread_param->params = params;
+   thread_data->target = target;
+   thread_data->pname = pname;
+   thread_data->params = params;
 
-   thread_param->params_copied = NULL;
+   thread_data->params_copied = NULL;
    if (thread_mode == EVAS_GL_THREAD_MODE_FINISH)
      goto finish;
 
@@ -4920,10 +4924,10 @@ glTexParameteriv_thread_cmd(GLenum target, GLenum pname, const GLint *params)
              goto finish;
           }
         /* 2. malloc & copy */
-        thread_param->params_copied = eina_mempool_malloc(_mp_default, copy_size);
-        if (thread_param->params_copied)
+        thread_data->params_copied = eina_mempool_malloc(_mp_default, copy_size);
+        if (thread_data->params_copied)
           {
-             memcpy(thread_param->params_copied, params, copy_size);
+             memcpy(thread_data->params_copied, params, copy_size);
           }
         else
           {
@@ -4931,20 +4935,20 @@ glTexParameteriv_thread_cmd(GLenum target, GLenum pname, const GLint *params)
              goto finish;
           }
         /* 3. replace */
-        thread_param->params = (const GLint  *)thread_param->params_copied;
+        thread_data->params = (const GLint  *)thread_data->params_copied;
      }
    /* end of copy variable */
 
 finish:
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glTexParameteriv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glScissor(GLint x, GLint y, GLsizei width, GLsizei height);
+ * void
+ * glScissor(GLint x, GLint y, GLsizei width, GLsizei height);
  */
 
 typedef struct
@@ -4955,21 +4959,21 @@ typedef struct
    GLsizei height;
    int command_allocated;
 
-} Thread_Command_glScissor;
+} Evas_Thread_Command_glScissor;
 
 static void
 _gl_thread_glScissor(void *data)
 {
-   Thread_Command_glScissor *thread_param =
-      (Thread_Command_glScissor *)data;
+   Evas_Thread_Command_glScissor *thread_data =
+      (Evas_Thread_Command_glScissor *)data;
 
-   glScissor(thread_param->x,
-             thread_param->y,
-             thread_param->width,
-             thread_param->height);
+   glScissor(thread_data->x,
+             thread_data->y,
+             thread_data->width,
+             thread_data->height);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -4983,39 +4987,39 @@ glScissor_thread_cmd(GLint x, GLint y, GLsizei width, GLsizei height)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glScissor thread_param_local;
-   Thread_Command_glScissor *thread_param = &thread_param_local;
+   Evas_Thread_Command_glScissor thread_data_local;
+   Evas_Thread_Command_glScissor *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        Thread_Command_glScissor *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(Thread_Command_glScissor));
-        if (thread_param_new)
+        Evas_Thread_Command_glScissor *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(Evas_Thread_Command_glScissor));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->x = x;
-   thread_param->y = y;
-   thread_param->width = width;
-   thread_param->height = height;
+   thread_data->x = x;
+   thread_data->y = y;
+   thread_data->width = width;
+   thread_data->height = height;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glScissor,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glBlendFunc(GLenum sfactor, GLenum dfactor);
+ * void
+ * glBlendFunc(GLenum sfactor, GLenum dfactor);
  */
 
 typedef struct
@@ -5024,19 +5028,19 @@ typedef struct
    GLenum dfactor;
    int command_allocated;
 
-} Thread_Command_glBlendFunc;
+} Evas_Thread_Command_glBlendFunc;
 
 static void
 _gl_thread_glBlendFunc(void *data)
 {
-   Thread_Command_glBlendFunc *thread_param =
-      (Thread_Command_glBlendFunc *)data;
+   Evas_Thread_Command_glBlendFunc *thread_data =
+      (Evas_Thread_Command_glBlendFunc *)data;
 
-   glBlendFunc(thread_param->sfactor,
-               thread_param->dfactor);
+   glBlendFunc(thread_data->sfactor,
+               thread_data->dfactor);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -5050,37 +5054,37 @@ glBlendFunc_thread_cmd(GLenum sfactor, GLenum dfactor)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glBlendFunc thread_param_local;
-   Thread_Command_glBlendFunc *thread_param = &thread_param_local;
+   Evas_Thread_Command_glBlendFunc thread_data_local;
+   Evas_Thread_Command_glBlendFunc *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        Thread_Command_glBlendFunc *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(Thread_Command_glBlendFunc));
-        if (thread_param_new)
+        Evas_Thread_Command_glBlendFunc *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(Evas_Thread_Command_glBlendFunc));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->sfactor = sfactor;
-   thread_param->dfactor = dfactor;
+   thread_data->sfactor = sfactor;
+   thread_data->dfactor = dfactor;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glBlendFunc,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glBlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
+ * void
+ * glBlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
  */
 
 typedef struct
@@ -5091,21 +5095,21 @@ typedef struct
    GLfloat alpha;
    int command_allocated;
 
-} Thread_Command_glBlendColor;
+} Evas_Thread_Command_glBlendColor;
 
 static void
 _gl_thread_glBlendColor(void *data)
 {
-   Thread_Command_glBlendColor *thread_param =
-      (Thread_Command_glBlendColor *)data;
+   Evas_Thread_Command_glBlendColor *thread_data =
+      (Evas_Thread_Command_glBlendColor *)data;
 
-   glBlendColor(thread_param->red,
-                thread_param->green,
-                thread_param->blue,
-                thread_param->alpha);
+   glBlendColor(thread_data->red,
+                thread_data->green,
+                thread_data->blue,
+                thread_data->alpha);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -5119,39 +5123,39 @@ glBlendColor_thread_cmd(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glBlendColor thread_param_local;
-   Thread_Command_glBlendColor *thread_param = &thread_param_local;
+   Evas_Thread_Command_glBlendColor thread_data_local;
+   Evas_Thread_Command_glBlendColor *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        Thread_Command_glBlendColor *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(Thread_Command_glBlendColor));
-        if (thread_param_new)
+        Evas_Thread_Command_glBlendColor *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(Evas_Thread_Command_glBlendColor));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->red = red;
-   thread_param->green = green;
-   thread_param->blue = blue;
-   thread_param->alpha = alpha;
+   thread_data->red = red;
+   thread_data->green = green;
+   thread_data->blue = blue;
+   thread_data->alpha = alpha;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glBlendColor,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glDepthMask(GLboolean flag);
+ * void
+ * glDepthMask(GLboolean flag);
  */
 
 typedef struct
@@ -5159,18 +5163,18 @@ typedef struct
    GLboolean flag;
    int command_allocated;
 
-} Thread_Command_glDepthMask;
+} Evas_Thread_Command_glDepthMask;
 
 static void
 _gl_thread_glDepthMask(void *data)
 {
-   Thread_Command_glDepthMask *thread_param =
-      (Thread_Command_glDepthMask *)data;
+   Evas_Thread_Command_glDepthMask *thread_data =
+      (Evas_Thread_Command_glDepthMask *)data;
 
-   glDepthMask(thread_param->flag);
+   glDepthMask(thread_data->flag);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -5184,36 +5188,36 @@ glDepthMask_thread_cmd(GLboolean flag)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glDepthMask thread_param_local;
-   Thread_Command_glDepthMask *thread_param = &thread_param_local;
+   Evas_Thread_Command_glDepthMask thread_data_local;
+   Evas_Thread_Command_glDepthMask *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        Thread_Command_glDepthMask *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(Thread_Command_glDepthMask));
-        if (thread_param_new)
+        Evas_Thread_Command_glDepthMask *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(Evas_Thread_Command_glDepthMask));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->flag = flag;
+   thread_data->flag = flag;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glDepthMask,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glClear(GLbitfield mask);
+ * void
+ * glClear(GLbitfield mask);
  */
 
 typedef struct
@@ -5221,18 +5225,18 @@ typedef struct
    GLbitfield mask;
    int command_allocated;
 
-} Thread_Command_glClear;
+} Evas_Thread_Command_glClear;
 
 static void
 _gl_thread_glClear(void *data)
 {
-   Thread_Command_glClear *thread_param =
-      (Thread_Command_glClear *)data;
+   Evas_Thread_Command_glClear *thread_data =
+      (Evas_Thread_Command_glClear *)data;
 
-   glClear(thread_param->mask);
+   glClear(thread_data->mask);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -5246,36 +5250,36 @@ glClear_thread_cmd(GLbitfield mask)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glClear thread_param_local;
-   Thread_Command_glClear *thread_param = &thread_param_local;
+   Evas_Thread_Command_glClear thread_data_local;
+   Evas_Thread_Command_glClear *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        Thread_Command_glClear *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(Thread_Command_glClear));
-        if (thread_param_new)
+        Evas_Thread_Command_glClear *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(Evas_Thread_Command_glClear));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->mask = mask;
+   thread_data->mask = mask;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glClear,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
+ * void
+ * glClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
  */
 
 typedef struct
@@ -5286,21 +5290,21 @@ typedef struct
    GLfloat alpha;
    int command_allocated;
 
-} Thread_Command_glClearColor;
+} Evas_Thread_Command_glClearColor;
 
 static void
 _gl_thread_glClearColor(void *data)
 {
-   Thread_Command_glClearColor *thread_param =
-      (Thread_Command_glClearColor *)data;
+   Evas_Thread_Command_glClearColor *thread_data =
+      (Evas_Thread_Command_glClearColor *)data;
 
-   glClearColor(thread_param->red,
-                thread_param->green,
-                thread_param->blue,
-                thread_param->alpha);
+   glClearColor(thread_data->red,
+                thread_data->green,
+                thread_data->blue,
+                thread_data->alpha);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -5314,39 +5318,39 @@ glClearColor_thread_cmd(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glClearColor thread_param_local;
-   Thread_Command_glClearColor *thread_param = &thread_param_local;
+   Evas_Thread_Command_glClearColor thread_data_local;
+   Evas_Thread_Command_glClearColor *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        Thread_Command_glClearColor *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(Thread_Command_glClearColor));
-        if (thread_param_new)
+        Evas_Thread_Command_glClearColor *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(Evas_Thread_Command_glClearColor));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->red = red;
-   thread_param->green = green;
-   thread_param->blue = blue;
-   thread_param->alpha = alpha;
+   thread_data->red = red;
+   thread_data->green = green;
+   thread_data->blue = blue;
+   thread_data->alpha = alpha;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glClearColor,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void *pixels);
+ * void
+ * glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void *pixels);
  */
 
 typedef struct
@@ -5359,21 +5363,21 @@ typedef struct
    GLenum type;
    void *pixels;
 
-} Thread_Command_glReadPixels;
+} Evas_Thread_Command_glReadPixels;
 
 static void
 _gl_thread_glReadPixels(void *data)
 {
-   Thread_Command_glReadPixels *thread_param =
-      (Thread_Command_glReadPixels *)data;
+   Evas_Thread_Command_glReadPixels *thread_data =
+      (Evas_Thread_Command_glReadPixels *)data;
 
-   glReadPixels(thread_param->x,
-                thread_param->y,
-                thread_param->width,
-                thread_param->height,
-                thread_param->format,
-                thread_param->type,
-                thread_param->pixels);
+   glReadPixels(thread_data->x,
+                thread_data->y,
+                thread_data->width,
+                thread_data->height,
+                thread_data->format,
+                thread_data->type,
+                thread_data->pixels);
 
 }
 
@@ -5388,26 +5392,26 @@ glReadPixels_thread_cmd(GLint x, GLint y, GLsizei width, GLsizei height, GLenum
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glReadPixels thread_param_local;
-   Thread_Command_glReadPixels *thread_param = &thread_param_local;
+   Evas_Thread_Command_glReadPixels thread_data_local;
+   Evas_Thread_Command_glReadPixels *thread_data = &thread_data_local;
 
-   thread_param->x = x;
-   thread_param->y = y;
-   thread_param->width = width;
-   thread_param->height = height;
-   thread_param->format = format;
-   thread_param->type = type;
-   thread_param->pixels = pixels;
+   thread_data->x = x;
+   thread_data->y = y;
+   thread_data->width = width;
+   thread_data->height = height;
+   thread_data->format = format;
+   thread_data->type = type;
+   thread_data->pixels = pixels;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glReadPixels,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGenFramebuffers(GLsizei n, GLuint *framebuffers);
+ * void
+ * glGenFramebuffers(GLsizei n, GLuint *framebuffers);
  */
 
 typedef struct
@@ -5415,7 +5419,7 @@ typedef struct
    GLsizei n;
    GLuint *framebuffers;
 
-} Thread_Command_glGenFramebuffers;
+} Evas_Thread_Command_glGenFramebuffers;
 
 void (*orig_evas_glGenFramebuffers)(GLsizei n, GLuint *framebuffers);
 
@@ -5434,11 +5438,11 @@ glGenFramebuffers_orig_evas_get(void)
 static void
 _gl_thread_glGenFramebuffers(void *data)
 {
-   Thread_Command_glGenFramebuffers *thread_param =
-      (Thread_Command_glGenFramebuffers *)data;
+   Evas_Thread_Command_glGenFramebuffers *thread_data =
+      (Evas_Thread_Command_glGenFramebuffers *)data;
 
-   orig_evas_glGenFramebuffers(thread_param->n,
-                               thread_param->framebuffers);
+   orig_evas_glGenFramebuffers(thread_data->n,
+                               thread_data->framebuffers);
 
 }
 
@@ -5453,21 +5457,21 @@ glGenFramebuffers_thread_cmd(GLsizei n, GLuint *framebuffers)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glGenFramebuffers thread_param_local;
-   Thread_Command_glGenFramebuffers *thread_param = &thread_param_local;
+   Evas_Thread_Command_glGenFramebuffers thread_data_local;
+   Evas_Thread_Command_glGenFramebuffers *thread_data = &thread_data_local;
 
-   thread_param->n = n;
-   thread_param->framebuffers = framebuffers;
+   thread_data->n = n;
+   thread_data->framebuffers = framebuffers;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glGenFramebuffers,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glBindFramebuffer(GLenum target, GLuint framebuffer);
+ * void
+ * glBindFramebuffer(GLenum target, GLuint framebuffer);
  */
 
 typedef struct
@@ -5476,7 +5480,7 @@ typedef struct
    GLuint framebuffer;
    int command_allocated;
 
-} Thread_Command_glBindFramebuffer;
+} Evas_Thread_Command_glBindFramebuffer;
 
 void (*orig_evas_glBindFramebuffer)(GLenum target, GLuint framebuffer);
 
@@ -5495,14 +5499,14 @@ glBindFramebuffer_orig_evas_get(void)
 static void
 _gl_thread_glBindFramebuffer(void *data)
 {
-   Thread_Command_glBindFramebuffer *thread_param =
-      (Thread_Command_glBindFramebuffer *)data;
+   Evas_Thread_Command_glBindFramebuffer *thread_data =
+      (Evas_Thread_Command_glBindFramebuffer *)data;
 
-   orig_evas_glBindFramebuffer(thread_param->target,
-                               thread_param->framebuffer);
+   orig_evas_glBindFramebuffer(thread_data->target,
+                               thread_data->framebuffer);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -5516,37 +5520,37 @@ glBindFramebuffer_thread_cmd(GLenum target, GLuint framebuffer)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glBindFramebuffer thread_param_local;
-   Thread_Command_glBindFramebuffer *thread_param = &thread_param_local;
+   Evas_Thread_Command_glBindFramebuffer thread_data_local;
+   Evas_Thread_Command_glBindFramebuffer *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        Thread_Command_glBindFramebuffer *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(Thread_Command_glBindFramebuffer));
-        if (thread_param_new)
+        Evas_Thread_Command_glBindFramebuffer *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(Evas_Thread_Command_glBindFramebuffer));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->target = target;
-   thread_param->framebuffer = framebuffer;
+   thread_data->target = target;
+   thread_data->framebuffer = framebuffer;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glBindFramebuffer,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glDeleteFramebuffers(GLsizei n, const GLuint *framebuffers);
+ * void
+ * glDeleteFramebuffers(GLsizei n, const GLuint *framebuffers);
  */
 
 typedef struct
@@ -5556,7 +5560,7 @@ typedef struct
    void *framebuffers_copied; /* COPIED */
    int command_allocated;
 
-} Thread_Command_glDeleteFramebuffers;
+} Evas_Thread_Command_glDeleteFramebuffers;
 
 void (*orig_evas_glDeleteFramebuffers)(GLsizei n, const GLuint *framebuffers);
 
@@ -5575,18 +5579,18 @@ glDeleteFramebuffers_orig_evas_get(void)
 static void
 _gl_thread_glDeleteFramebuffers(void *data)
 {
-   Thread_Command_glDeleteFramebuffers *thread_param =
-      (Thread_Command_glDeleteFramebuffers *)data;
+   Evas_Thread_Command_glDeleteFramebuffers *thread_data =
+      (Evas_Thread_Command_glDeleteFramebuffers *)data;
 
-   orig_evas_glDeleteFramebuffers(thread_param->n,
-                                  thread_param->framebuffers);
+   orig_evas_glDeleteFramebuffers(thread_data->n,
+                                  thread_data->framebuffers);
 
 
-   if (thread_param->framebuffers_copied)
-     eina_mempool_free(_mp_delete_object, thread_param->framebuffers_copied);
+   if (thread_data->framebuffers_copied)
+     eina_mempool_free(_mp_delete_object, thread_data->framebuffers_copied);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -5600,29 +5604,29 @@ glDeleteFramebuffers_thread_cmd(GLsizei n, const GLuint *framebuffers)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glDeleteFramebuffers thread_param_local;
-   Thread_Command_glDeleteFramebuffers *thread_param = &thread_param_local;
+   Evas_Thread_Command_glDeleteFramebuffers thread_data_local;
+   Evas_Thread_Command_glDeleteFramebuffers *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        Thread_Command_glDeleteFramebuffers *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(Thread_Command_glDeleteFramebuffers));
-        if (thread_param_new)
+        Evas_Thread_Command_glDeleteFramebuffers *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(Evas_Thread_Command_glDeleteFramebuffers));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->n = n;
-   thread_param->framebuffers = framebuffers;
+   thread_data->n = n;
+   thread_data->framebuffers = framebuffers;
 
-   thread_param->framebuffers_copied = NULL;
+   thread_data->framebuffers_copied = NULL;
    if (thread_mode == EVAS_GL_THREAD_MODE_FINISH)
      goto finish;
 
@@ -5637,10 +5641,10 @@ glDeleteFramebuffers_thread_cmd(GLsizei n, const GLuint *framebuffers)
              goto finish;
           }
         /* 2. malloc & copy */
-        thread_param->framebuffers_copied = eina_mempool_malloc(_mp_delete_object, copy_size);
-        if (thread_param->framebuffers_copied)
+        thread_data->framebuffers_copied = eina_mempool_malloc(_mp_delete_object, copy_size);
+        if (thread_data->framebuffers_copied)
           {
-             memcpy(thread_param->framebuffers_copied, framebuffers, copy_size);
+             memcpy(thread_data->framebuffers_copied, framebuffers, copy_size);
           }
         else
           {
@@ -5648,20 +5652,20 @@ glDeleteFramebuffers_thread_cmd(GLsizei n, const GLuint *framebuffers)
              goto finish;
           }
         /* 3. replace */
-        thread_param->framebuffers = (const GLuint  *)thread_param->framebuffers_copied;
+        thread_data->framebuffers = (const GLuint  *)thread_data->framebuffers_copied;
      }
    /* end of copy variable */
 
 finish:
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glDeleteFramebuffers,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGenRenderbuffers(GLsizei n, GLuint *renderbuffers);
+ * void
+ * glGenRenderbuffers(GLsizei n, GLuint *renderbuffers);
  */
 
 typedef struct
@@ -5669,16 +5673,16 @@ typedef struct
    GLsizei n;
    GLuint *renderbuffers;
 
-} Thread_Command_glGenRenderbuffers;
+} Evas_Thread_Command_glGenRenderbuffers;
 
 static void
 _gl_thread_glGenRenderbuffers(void *data)
 {
-   Thread_Command_glGenRenderbuffers *thread_param =
-      (Thread_Command_glGenRenderbuffers *)data;
+   Evas_Thread_Command_glGenRenderbuffers *thread_data =
+      (Evas_Thread_Command_glGenRenderbuffers *)data;
 
-   glGenRenderbuffers(thread_param->n,
-                      thread_param->renderbuffers);
+   glGenRenderbuffers(thread_data->n,
+                      thread_data->renderbuffers);
 
 }
 
@@ -5693,21 +5697,21 @@ glGenRenderbuffers_thread_cmd(GLsizei n, GLuint *renderbuffers)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glGenRenderbuffers thread_param_local;
-   Thread_Command_glGenRenderbuffers *thread_param = &thread_param_local;
+   Evas_Thread_Command_glGenRenderbuffers thread_data_local;
+   Evas_Thread_Command_glGenRenderbuffers *thread_data = &thread_data_local;
 
-   thread_param->n = n;
-   thread_param->renderbuffers = renderbuffers;
+   thread_data->n = n;
+   thread_data->renderbuffers = renderbuffers;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glGenRenderbuffers,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glBindRenderbuffer(GLenum target, GLuint renderbuffer);
+ * void
+ * glBindRenderbuffer(GLenum target, GLuint renderbuffer);
  */
 
 typedef struct
@@ -5716,19 +5720,19 @@ typedef struct
    GLuint renderbuffer;
    int command_allocated;
 
-} Thread_Command_glBindRenderbuffer;
+} Evas_Thread_Command_glBindRenderbuffer;
 
 static void
 _gl_thread_glBindRenderbuffer(void *data)
 {
-   Thread_Command_glBindRenderbuffer *thread_param =
-      (Thread_Command_glBindRenderbuffer *)data;
+   Evas_Thread_Command_glBindRenderbuffer *thread_data =
+      (Evas_Thread_Command_glBindRenderbuffer *)data;
 
-   glBindRenderbuffer(thread_param->target,
-                      thread_param->renderbuffer);
+   glBindRenderbuffer(thread_data->target,
+                      thread_data->renderbuffer);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -5742,37 +5746,37 @@ glBindRenderbuffer_thread_cmd(GLenum target, GLuint renderbuffer)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glBindRenderbuffer thread_param_local;
-   Thread_Command_glBindRenderbuffer *thread_param = &thread_param_local;
+   Evas_Thread_Command_glBindRenderbuffer thread_data_local;
+   Evas_Thread_Command_glBindRenderbuffer *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        Thread_Command_glBindRenderbuffer *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(Thread_Command_glBindRenderbuffer));
-        if (thread_param_new)
+        Evas_Thread_Command_glBindRenderbuffer *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(Evas_Thread_Command_glBindRenderbuffer));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->target = target;
-   thread_param->renderbuffer = renderbuffer;
+   thread_data->target = target;
+   thread_data->renderbuffer = renderbuffer;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glBindRenderbuffer,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glDeleteRenderbuffers(GLsizei n, const GLuint *renderbuffers);
+ * void
+ * glDeleteRenderbuffers(GLsizei n, const GLuint *renderbuffers);
  */
 
 typedef struct
@@ -5782,23 +5786,23 @@ typedef struct
    void *renderbuffers_copied; /* COPIED */
    int command_allocated;
 
-} Thread_Command_glDeleteRenderbuffers;
+} Evas_Thread_Command_glDeleteRenderbuffers;
 
 static void
 _gl_thread_glDeleteRenderbuffers(void *data)
 {
-   Thread_Command_glDeleteRenderbuffers *thread_param =
-      (Thread_Command_glDeleteRenderbuffers *)data;
+   Evas_Thread_Command_glDeleteRenderbuffers *thread_data =
+      (Evas_Thread_Command_glDeleteRenderbuffers *)data;
 
-   glDeleteRenderbuffers(thread_param->n,
-                         thread_param->renderbuffers);
+   glDeleteRenderbuffers(thread_data->n,
+                         thread_data->renderbuffers);
 
 
-   if (thread_param->renderbuffers_copied)
-     eina_mempool_free(_mp_delete_object, thread_param->renderbuffers_copied);
+   if (thread_data->renderbuffers_copied)
+     eina_mempool_free(_mp_delete_object, thread_data->renderbuffers_copied);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -5812,29 +5816,29 @@ glDeleteRenderbuffers_thread_cmd(GLsizei n, const GLuint *renderbuffers)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glDeleteRenderbuffers thread_param_local;
-   Thread_Command_glDeleteRenderbuffers *thread_param = &thread_param_local;
+   Evas_Thread_Command_glDeleteRenderbuffers thread_data_local;
+   Evas_Thread_Command_glDeleteRenderbuffers *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        Thread_Command_glDeleteRenderbuffers *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(Thread_Command_glDeleteRenderbuffers));
-        if (thread_param_new)
+        Evas_Thread_Command_glDeleteRenderbuffers *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(Evas_Thread_Command_glDeleteRenderbuffers));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->n = n;
-   thread_param->renderbuffers = renderbuffers;
+   thread_data->n = n;
+   thread_data->renderbuffers = renderbuffers;
 
-   thread_param->renderbuffers_copied = NULL;
+   thread_data->renderbuffers_copied = NULL;
    if (thread_mode == EVAS_GL_THREAD_MODE_FINISH)
      goto finish;
 
@@ -5849,10 +5853,10 @@ glDeleteRenderbuffers_thread_cmd(GLsizei n, const GLuint *renderbuffers)
              goto finish;
           }
         /* 2. malloc & copy */
-        thread_param->renderbuffers_copied = eina_mempool_malloc(_mp_delete_object, copy_size);
-        if (thread_param->renderbuffers_copied)
+        thread_data->renderbuffers_copied = eina_mempool_malloc(_mp_delete_object, copy_size);
+        if (thread_data->renderbuffers_copied)
           {
-             memcpy(thread_param->renderbuffers_copied, renderbuffers, copy_size);
+             memcpy(thread_data->renderbuffers_copied, renderbuffers, copy_size);
           }
         else
           {
@@ -5860,20 +5864,20 @@ glDeleteRenderbuffers_thread_cmd(GLsizei n, const GLuint *renderbuffers)
              goto finish;
           }
         /* 3. replace */
-        thread_param->renderbuffers = (const GLuint  *)thread_param->renderbuffers_copied;
+        thread_data->renderbuffers = (const GLuint  *)thread_data->renderbuffers_copied;
      }
    /* end of copy variable */
 
 finish:
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glDeleteRenderbuffers,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height);
+ * void
+ * glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height);
  */
 
 typedef struct
@@ -5884,21 +5888,21 @@ typedef struct
    GLsizei height;
    int command_allocated;
 
-} Thread_Command_glRenderbufferStorage;
+} Evas_Thread_Command_glRenderbufferStorage;
 
 static void
 _gl_thread_glRenderbufferStorage(void *data)
 {
-   Thread_Command_glRenderbufferStorage *thread_param =
-      (Thread_Command_glRenderbufferStorage *)data;
+   Evas_Thread_Command_glRenderbufferStorage *thread_data =
+      (Evas_Thread_Command_glRenderbufferStorage *)data;
 
-   glRenderbufferStorage(thread_param->target,
-                         thread_param->internalformat,
-                         thread_param->width,
-                         thread_param->height);
+   glRenderbufferStorage(thread_data->target,
+                         thread_data->internalformat,
+                         thread_data->width,
+                         thread_data->height);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -5912,39 +5916,39 @@ glRenderbufferStorage_thread_cmd(GLenum target, GLenum internalformat, GLsizei w
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glRenderbufferStorage thread_param_local;
-   Thread_Command_glRenderbufferStorage *thread_param = &thread_param_local;
+   Evas_Thread_Command_glRenderbufferStorage thread_data_local;
+   Evas_Thread_Command_glRenderbufferStorage *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        Thread_Command_glRenderbufferStorage *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(Thread_Command_glRenderbufferStorage));
-        if (thread_param_new)
+        Evas_Thread_Command_glRenderbufferStorage *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(Evas_Thread_Command_glRenderbufferStorage));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->target = target;
-   thread_param->internalformat = internalformat;
-   thread_param->width = width;
-   thread_param->height = height;
+   thread_data->target = target;
+   thread_data->internalformat = internalformat;
+   thread_data->width = width;
+   thread_data->height = height;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glRenderbufferStorage,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer);
+ * void
+ * glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer);
  */
 
 typedef struct
@@ -5955,21 +5959,21 @@ typedef struct
    GLuint renderbuffer;
    int command_allocated;
 
-} Thread_Command_glFramebufferRenderbuffer;
+} Evas_Thread_Command_glFramebufferRenderbuffer;
 
 static void
 _gl_thread_glFramebufferRenderbuffer(void *data)
 {
-   Thread_Command_glFramebufferRenderbuffer *thread_param =
-      (Thread_Command_glFramebufferRenderbuffer *)data;
+   Evas_Thread_Command_glFramebufferRenderbuffer *thread_data =
+      (Evas_Thread_Command_glFramebufferRenderbuffer *)data;
 
-   glFramebufferRenderbuffer(thread_param->target,
-                             thread_param->attachment,
-                             thread_param->renderbuffertarget,
-                             thread_param->renderbuffer);
+   glFramebufferRenderbuffer(thread_data->target,
+                             thread_data->attachment,
+                             thread_data->renderbuffertarget,
+                             thread_data->renderbuffer);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -5983,39 +5987,39 @@ glFramebufferRenderbuffer_thread_cmd(GLenum target, GLenum attachment, GLenum re
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glFramebufferRenderbuffer thread_param_local;
-   Thread_Command_glFramebufferRenderbuffer *thread_param = &thread_param_local;
+   Evas_Thread_Command_glFramebufferRenderbuffer thread_data_local;
+   Evas_Thread_Command_glFramebufferRenderbuffer *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        Thread_Command_glFramebufferRenderbuffer *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(Thread_Command_glFramebufferRenderbuffer));
-        if (thread_param_new)
+        Evas_Thread_Command_glFramebufferRenderbuffer *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(Evas_Thread_Command_glFramebufferRenderbuffer));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->target = target;
-   thread_param->attachment = attachment;
-   thread_param->renderbuffertarget = renderbuffertarget;
-   thread_param->renderbuffer = renderbuffer;
+   thread_data->target = target;
+   thread_data->attachment = attachment;
+   thread_data->renderbuffertarget = renderbuffertarget;
+   thread_data->renderbuffer = renderbuffer;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glFramebufferRenderbuffer,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
+ * void
+ * glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
  */
 
 typedef struct
@@ -6027,7 +6031,7 @@ typedef struct
    GLint level;
    int command_allocated;
 
-} Thread_Command_glFramebufferTexture2D;
+} Evas_Thread_Command_glFramebufferTexture2D;
 
 void (*orig_evas_glFramebufferTexture2D)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
 
@@ -6046,17 +6050,17 @@ glFramebufferTexture2D_orig_evas_get(void)
 static void
 _gl_thread_glFramebufferTexture2D(void *data)
 {
-   Thread_Command_glFramebufferTexture2D *thread_param =
-      (Thread_Command_glFramebufferTexture2D *)data;
+   Evas_Thread_Command_glFramebufferTexture2D *thread_data =
+      (Evas_Thread_Command_glFramebufferTexture2D *)data;
 
-   orig_evas_glFramebufferTexture2D(thread_param->target,
-                                    thread_param->attachment,
-                                    thread_param->textarget,
-                                    thread_param->texture,
-                                    thread_param->level);
+   orig_evas_glFramebufferTexture2D(thread_data->target,
+                                    thread_data->attachment,
+                                    thread_data->textarget,
+                                    thread_data->texture,
+                                    thread_data->level);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -6070,40 +6074,40 @@ glFramebufferTexture2D_thread_cmd(GLenum target, GLenum attachment, GLenum texta
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glFramebufferTexture2D thread_param_local;
-   Thread_Command_glFramebufferTexture2D *thread_param = &thread_param_local;
+   Evas_Thread_Command_glFramebufferTexture2D thread_data_local;
+   Evas_Thread_Command_glFramebufferTexture2D *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        Thread_Command_glFramebufferTexture2D *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(Thread_Command_glFramebufferTexture2D));
-        if (thread_param_new)
+        Evas_Thread_Command_glFramebufferTexture2D *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(Evas_Thread_Command_glFramebufferTexture2D));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->target = target;
-   thread_param->attachment = attachment;
-   thread_param->textarget = textarget;
-   thread_param->texture = texture;
-   thread_param->level = level;
+   thread_data->target = target;
+   thread_data->attachment = attachment;
+   thread_data->textarget = textarget;
+   thread_data->texture = texture;
+   thread_data->level = level;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glFramebufferTexture2D,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glFramebufferTexture2DMultisample(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLsizei samples);
+ * void
+ * glFramebufferTexture2DMultisample(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLsizei samples);
  */
 
 typedef struct
@@ -6116,7 +6120,7 @@ typedef struct
    GLsizei samples;
    int command_allocated;
 
-} Thread_Command_glFramebufferTexture2DMultisample;
+} Evas_Thread_Command_glFramebufferTexture2DMultisample;
 
 void (*orig_evas_glFramebufferTexture2DMultisample)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLsizei samples);
 
@@ -6135,18 +6139,18 @@ glFramebufferTexture2DMultisample_orig_evas_get(void)
 static void
 _gl_thread_glFramebufferTexture2DMultisample(void *data)
 {
-   Thread_Command_glFramebufferTexture2DMultisample *thread_param =
-      (Thread_Command_glFramebufferTexture2DMultisample *)data;
+   Evas_Thread_Command_glFramebufferTexture2DMultisample *thread_data =
+      (Evas_Thread_Command_glFramebufferTexture2DMultisample *)data;
 
-   orig_evas_glFramebufferTexture2DMultisample(thread_param->target,
-                                               thread_param->attachment,
-                                               thread_param->textarget,
-                                               thread_param->texture,
-                                               thread_param->level,
-                                               thread_param->samples);
+   orig_evas_glFramebufferTexture2DMultisample(thread_data->target,
+                                               thread_data->attachment,
+                                               thread_data->textarget,
+                                               thread_data->texture,
+                                               thread_data->level,
+                                               thread_data->samples);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -6160,41 +6164,41 @@ glFramebufferTexture2DMultisample_thread_cmd(GLenum target, GLenum attachment, G
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glFramebufferTexture2DMultisample thread_param_local;
-   Thread_Command_glFramebufferTexture2DMultisample *thread_param = &thread_param_local;
+   Evas_Thread_Command_glFramebufferTexture2DMultisample thread_data_local;
+   Evas_Thread_Command_glFramebufferTexture2DMultisample *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        Thread_Command_glFramebufferTexture2DMultisample *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(Thread_Command_glFramebufferTexture2DMultisample));
-        if (thread_param_new)
+        Evas_Thread_Command_glFramebufferTexture2DMultisample *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(Evas_Thread_Command_glFramebufferTexture2DMultisample));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->target = target;
-   thread_param->attachment = attachment;
-   thread_param->textarget = textarget;
-   thread_param->texture = texture;
-   thread_param->level = level;
-   thread_param->samples = samples;
+   thread_data->target = target;
+   thread_data->attachment = attachment;
+   thread_data->textarget = textarget;
+   thread_data->texture = texture;
+   thread_data->level = level;
+   thread_data->samples = samples;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glFramebufferTexture2DMultisample,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   GLenum
-   glCheckFramebufferStatus(GLenum target);
+ * GLenum
+ * glCheckFramebufferStatus(GLenum target);
  */
 
 typedef struct
@@ -6202,15 +6206,15 @@ typedef struct
    GLenum return_value;
    GLenum target;
 
-} Thread_Command_glCheckFramebufferStatus;
+} Evas_Thread_Command_glCheckFramebufferStatus;
 
 static void
 _gl_thread_glCheckFramebufferStatus(void *data)
 {
-   Thread_Command_glCheckFramebufferStatus *thread_param =
-      (Thread_Command_glCheckFramebufferStatus *)data;
+   Evas_Thread_Command_glCheckFramebufferStatus *thread_data =
+      (Evas_Thread_Command_glCheckFramebufferStatus *)data;
 
-   thread_param->return_value = glCheckFramebufferStatus(thread_param->target);
+   thread_data->return_value = glCheckFramebufferStatus(thread_data->target);
 
 }
 
@@ -6224,22 +6228,22 @@ glCheckFramebufferStatus_thread_cmd(GLenum target)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glCheckFramebufferStatus thread_param_local;
-   Thread_Command_glCheckFramebufferStatus *thread_param = &thread_param_local;
+   Evas_Thread_Command_glCheckFramebufferStatus thread_data_local;
+   Evas_Thread_Command_glCheckFramebufferStatus *thread_data = &thread_data_local;
 
-   thread_param->target = target;
+   thread_data->target = target;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glCheckFramebufferStatus,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
-   void
-   glFlush(void);
+ * void
+ * glFlush(void);
  */
 
 static void
@@ -6267,8 +6271,8 @@ glFlush_thread_cmd(void)
 }
 
 /*
-   void
-   glFinish(void);
+ * void
+ * glFinish(void);
  */
 
 static void
@@ -6296,8 +6300,8 @@ glFinish_thread_cmd(void)
 }
 
 /*
-   void
-   glHint(GLenum target, GLenum mode);
+ * void
+ * glHint(GLenum target, GLenum mode);
  */
 
 typedef struct
@@ -6306,19 +6310,19 @@ typedef struct
    GLenum mode;
    int command_allocated;
 
-} Thread_Command_glHint;
+} Evas_Thread_Command_glHint;
 
 static void
 _gl_thread_glHint(void *data)
 {
-   Thread_Command_glHint *thread_param =
-      (Thread_Command_glHint *)data;
+   Evas_Thread_Command_glHint *thread_data =
+      (Evas_Thread_Command_glHint *)data;
 
-   glHint(thread_param->target,
-          thread_param->mode);
+   glHint(thread_data->target,
+          thread_data->mode);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -6332,37 +6336,37 @@ glHint_thread_cmd(GLenum target, GLenum mode)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glHint thread_param_local;
-   Thread_Command_glHint *thread_param = &thread_param_local;
+   Evas_Thread_Command_glHint thread_data_local;
+   Evas_Thread_Command_glHint *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        Thread_Command_glHint *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(Thread_Command_glHint));
-        if (thread_param_new)
+        Evas_Thread_Command_glHint *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(Evas_Thread_Command_glHint));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->target = target;
-   thread_param->mode = mode;
+   thread_data->target = target;
+   thread_data->mode = mode;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glHint,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   const GLubyte *
-   glGetString(GLenum name);
+ * const GLubyte *
+ * glGetString(GLenum name);
  */
 
 typedef struct
@@ -6370,15 +6374,15 @@ typedef struct
    const GLubyte * return_value;
    GLenum name;
 
-} Thread_Command_glGetString;
+} Evas_Thread_Command_glGetString;
 
 static void
 _gl_thread_glGetString(void *data)
 {
-   Thread_Command_glGetString *thread_param =
-      (Thread_Command_glGetString *)data;
+   Evas_Thread_Command_glGetString *thread_data =
+      (Evas_Thread_Command_glGetString *)data;
 
-   thread_param->return_value = glGetString(thread_param->name);
+   thread_data->return_value = glGetString(thread_data->name);
 
 }
 
@@ -6392,22 +6396,22 @@ glGetString_thread_cmd(GLenum name)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glGetString thread_param_local;
-   Thread_Command_glGetString *thread_param = &thread_param_local;
+   Evas_Thread_Command_glGetString thread_data_local;
+   Evas_Thread_Command_glGetString *thread_data = &thread_data_local;
 
-   thread_param->name = name;
+   thread_data->name = name;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glGetString,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
-   void
-   glGetBooleanv(GLenum pname, GLboolean *data);
+ * void
+ * glGetBooleanv(GLenum pname, GLboolean *data);
  */
 
 typedef struct
@@ -6415,16 +6419,16 @@ typedef struct
    GLenum pname;
    GLboolean *data;
 
-} Thread_Command_glGetBooleanv;
+} Evas_Thread_Command_glGetBooleanv;
 
 static void
 _gl_thread_glGetBooleanv(void *data)
 {
-   Thread_Command_glGetBooleanv *thread_param =
-      (Thread_Command_glGetBooleanv *)data;
+   Evas_Thread_Command_glGetBooleanv *thread_data =
+      (Evas_Thread_Command_glGetBooleanv *)data;
 
-   glGetBooleanv(thread_param->pname,
-                 thread_param->data);
+   glGetBooleanv(thread_data->pname,
+                 thread_data->data);
 
 }
 
@@ -6439,21 +6443,21 @@ glGetBooleanv_thread_cmd(GLenum pname, GLboolean *data)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glGetBooleanv thread_param_local;
-   Thread_Command_glGetBooleanv *thread_param = &thread_param_local;
+   Evas_Thread_Command_glGetBooleanv thread_data_local;
+   Evas_Thread_Command_glGetBooleanv *thread_data = &thread_data_local;
 
-   thread_param->pname = pname;
-   thread_param->data = data;
+   thread_data->pname = pname;
+   thread_data->data = data;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glGetBooleanv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGetFloatv(GLenum pname, GLfloat *data);
+ * void
+ * glGetFloatv(GLenum pname, GLfloat *data);
  */
 
 typedef struct
@@ -6461,16 +6465,16 @@ typedef struct
    GLenum pname;
    GLfloat *data;
 
-} Thread_Command_glGetFloatv;
+} Evas_Thread_Command_glGetFloatv;
 
 static void
 _gl_thread_glGetFloatv(void *data)
 {
-   Thread_Command_glGetFloatv *thread_param =
-      (Thread_Command_glGetFloatv *)data;
+   Evas_Thread_Command_glGetFloatv *thread_data =
+      (Evas_Thread_Command_glGetFloatv *)data;
 
-   glGetFloatv(thread_param->pname,
-               thread_param->data);
+   glGetFloatv(thread_data->pname,
+               thread_data->data);
 
 }
 
@@ -6485,21 +6489,21 @@ glGetFloatv_thread_cmd(GLenum pname, GLfloat *data)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glGetFloatv thread_param_local;
-   Thread_Command_glGetFloatv *thread_param = &thread_param_local;
+   Evas_Thread_Command_glGetFloatv thread_data_local;
+   Evas_Thread_Command_glGetFloatv *thread_data = &thread_data_local;
 
-   thread_param->pname = pname;
-   thread_param->data = data;
+   thread_data->pname = pname;
+   thread_data->data = data;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glGetFloatv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGetIntegerv(GLenum pname, GLint *data);
+ * void
+ * glGetIntegerv(GLenum pname, GLint *data);
  */
 
 typedef struct
@@ -6507,16 +6511,16 @@ typedef struct
    GLenum pname;
    GLint *data;
 
-} Thread_Command_glGetIntegerv;
+} Evas_Thread_Command_glGetIntegerv;
 
 static void
 _gl_thread_glGetIntegerv(void *data)
 {
-   Thread_Command_glGetIntegerv *thread_param =
-      (Thread_Command_glGetIntegerv *)data;
+   Evas_Thread_Command_glGetIntegerv *thread_data =
+      (Evas_Thread_Command_glGetIntegerv *)data;
 
-   glGetIntegerv(thread_param->pname,
-                 thread_param->data);
+   glGetIntegerv(thread_data->pname,
+                 thread_data->data);
 
 }
 
@@ -6531,21 +6535,21 @@ glGetIntegerv_thread_cmd(GLenum pname, GLint *data)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glGetIntegerv thread_param_local;
-   Thread_Command_glGetIntegerv *thread_param = &thread_param_local;
+   Evas_Thread_Command_glGetIntegerv thread_data_local;
+   Evas_Thread_Command_glGetIntegerv *thread_data = &thread_data_local;
 
-   thread_param->pname = pname;
-   thread_param->data = data;
+   thread_data->pname = pname;
+   thread_data->data = data;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glGetIntegerv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   GLboolean
-   glIsBuffer(GLint buffer);
+ * GLboolean
+ * glIsBuffer(GLint buffer);
  */
 
 typedef struct
@@ -6553,15 +6557,15 @@ typedef struct
    GLboolean return_value;
    GLint buffer;
 
-} Thread_Command_glIsBuffer;
+} Evas_Thread_Command_glIsBuffer;
 
 static void
 _gl_thread_glIsBuffer(void *data)
 {
-   Thread_Command_glIsBuffer *thread_param =
-      (Thread_Command_glIsBuffer *)data;
+   Evas_Thread_Command_glIsBuffer *thread_data =
+      (Evas_Thread_Command_glIsBuffer *)data;
 
-   thread_param->return_value = glIsBuffer(thread_param->buffer);
+   thread_data->return_value = glIsBuffer(thread_data->buffer);
 
 }
 
@@ -6575,22 +6579,22 @@ glIsBuffer_thread_cmd(GLint buffer)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glIsBuffer thread_param_local;
-   Thread_Command_glIsBuffer *thread_param = &thread_param_local;
+   Evas_Thread_Command_glIsBuffer thread_data_local;
+   Evas_Thread_Command_glIsBuffer *thread_data = &thread_data_local;
 
-   thread_param->buffer = buffer;
+   thread_data->buffer = buffer;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glIsBuffer,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
-   void
-   glGetBufferParameteriv(GLenum target, GLenum pname, GLint *params);
+ * void
+ * glGetBufferParameteriv(GLenum target, GLenum pname, GLint *params);
  */
 
 typedef struct
@@ -6599,17 +6603,17 @@ typedef struct
    GLenum pname;
    GLint *params;
 
-} Thread_Command_glGetBufferParameteriv;
+} Evas_Thread_Command_glGetBufferParameteriv;
 
 static void
 _gl_thread_glGetBufferParameteriv(void *data)
 {
-   Thread_Command_glGetBufferParameteriv *thread_param =
-      (Thread_Command_glGetBufferParameteriv *)data;
+   Evas_Thread_Command_glGetBufferParameteriv *thread_data =
+      (Evas_Thread_Command_glGetBufferParameteriv *)data;
 
-   glGetBufferParameteriv(thread_param->target,
-                          thread_param->pname,
-                          thread_param->params);
+   glGetBufferParameteriv(thread_data->target,
+                          thread_data->pname,
+                          thread_data->params);
 
 }
 
@@ -6624,22 +6628,22 @@ glGetBufferParameteriv_thread_cmd(GLenum target, GLenum pname, GLint *params)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glGetBufferParameteriv thread_param_local;
-   Thread_Command_glGetBufferParameteriv *thread_param = &thread_param_local;
+   Evas_Thread_Command_glGetBufferParameteriv thread_data_local;
+   Evas_Thread_Command_glGetBufferParameteriv *thread_data = &thread_data_local;
 
-   thread_param->target = target;
-   thread_param->pname = pname;
-   thread_param->params = params;
+   thread_data->target = target;
+   thread_data->pname = pname;
+   thread_data->params = params;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glGetBufferParameteriv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   GLboolean
-   glIsShader(GLuint shader);
+ * GLboolean
+ * glIsShader(GLuint shader);
  */
 
 typedef struct
@@ -6647,15 +6651,15 @@ typedef struct
    GLboolean return_value;
    GLuint shader;
 
-} Thread_Command_glIsShader;
+} Evas_Thread_Command_glIsShader;
 
 static void
 _gl_thread_glIsShader(void *data)
 {
-   Thread_Command_glIsShader *thread_param =
-      (Thread_Command_glIsShader *)data;
+   Evas_Thread_Command_glIsShader *thread_data =
+      (Evas_Thread_Command_glIsShader *)data;
 
-   thread_param->return_value = glIsShader(thread_param->shader);
+   thread_data->return_value = glIsShader(thread_data->shader);
 
 }
 
@@ -6669,22 +6673,22 @@ glIsShader_thread_cmd(GLuint shader)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glIsShader thread_param_local;
-   Thread_Command_glIsShader *thread_param = &thread_param_local;
+   Evas_Thread_Command_glIsShader thread_data_local;
+   Evas_Thread_Command_glIsShader *thread_data = &thread_data_local;
 
-   thread_param->shader = shader;
+   thread_data->shader = shader;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glIsShader,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
-   void
-   glGetShaderiv(GLuint shader, GLenum pname, GLint *params);
+ * void
+ * glGetShaderiv(GLuint shader, GLenum pname, GLint *params);
  */
 
 typedef struct
@@ -6693,17 +6697,17 @@ typedef struct
    GLenum pname;
    GLint *params;
 
-} Thread_Command_glGetShaderiv;
+} Evas_Thread_Command_glGetShaderiv;
 
 static void
 _gl_thread_glGetShaderiv(void *data)
 {
-   Thread_Command_glGetShaderiv *thread_param =
-      (Thread_Command_glGetShaderiv *)data;
+   Evas_Thread_Command_glGetShaderiv *thread_data =
+      (Evas_Thread_Command_glGetShaderiv *)data;
 
-   glGetShaderiv(thread_param->shader,
-                 thread_param->pname,
-                 thread_param->params);
+   glGetShaderiv(thread_data->shader,
+                 thread_data->pname,
+                 thread_data->params);
 
 }
 
@@ -6718,22 +6722,22 @@ glGetShaderiv_thread_cmd(GLuint shader, GLenum pname, GLint *params)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glGetShaderiv thread_param_local;
-   Thread_Command_glGetShaderiv *thread_param = &thread_param_local;
+   Evas_Thread_Command_glGetShaderiv thread_data_local;
+   Evas_Thread_Command_glGetShaderiv *thread_data = &thread_data_local;
 
-   thread_param->shader = shader;
-   thread_param->pname = pname;
-   thread_param->params = params;
+   thread_data->shader = shader;
+   thread_data->pname = pname;
+   thread_data->params = params;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glGetShaderiv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *shaders);
+ * void
+ * glGetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *shaders);
  */
 
 typedef struct
@@ -6743,18 +6747,18 @@ typedef struct
    GLsizei *count;
    GLuint *shaders;
 
-} Thread_Command_glGetAttachedShaders;
+} Evas_Thread_Command_glGetAttachedShaders;
 
 static void
 _gl_thread_glGetAttachedShaders(void *data)
 {
-   Thread_Command_glGetAttachedShaders *thread_param =
-      (Thread_Command_glGetAttachedShaders *)data;
+   Evas_Thread_Command_glGetAttachedShaders *thread_data =
+      (Evas_Thread_Command_glGetAttachedShaders *)data;
 
-   glGetAttachedShaders(thread_param->program,
-                        thread_param->maxCount,
-                        thread_param->count,
-                        thread_param->shaders);
+   glGetAttachedShaders(thread_data->program,
+                        thread_data->maxCount,
+                        thread_data->count,
+                        thread_data->shaders);
 
 }
 
@@ -6769,23 +6773,23 @@ glGetAttachedShaders_thread_cmd(GLuint program, GLsizei maxCount, GLsizei *count
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glGetAttachedShaders thread_param_local;
-   Thread_Command_glGetAttachedShaders *thread_param = &thread_param_local;
+   Evas_Thread_Command_glGetAttachedShaders thread_data_local;
+   Evas_Thread_Command_glGetAttachedShaders *thread_data = &thread_data_local;
 
-   thread_param->program = program;
-   thread_param->maxCount = maxCount;
-   thread_param->count = count;
-   thread_param->shaders = shaders;
+   thread_data->program = program;
+   thread_data->maxCount = maxCount;
+   thread_data->count = count;
+   thread_data->shaders = shaders;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glGetAttachedShaders,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGetShaderInfoLog(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
+ * void
+ * glGetShaderInfoLog(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
  */
 
 typedef struct
@@ -6795,18 +6799,18 @@ typedef struct
    GLsizei *length;
    GLchar *infoLog;
 
-} Thread_Command_glGetShaderInfoLog;
+} Evas_Thread_Command_glGetShaderInfoLog;
 
 static void
 _gl_thread_glGetShaderInfoLog(void *data)
 {
-   Thread_Command_glGetShaderInfoLog *thread_param =
-      (Thread_Command_glGetShaderInfoLog *)data;
+   Evas_Thread_Command_glGetShaderInfoLog *thread_data =
+      (Evas_Thread_Command_glGetShaderInfoLog *)data;
 
-   glGetShaderInfoLog(thread_param->shader,
-                      thread_param->bufSize,
-                      thread_param->length,
-                      thread_param->infoLog);
+   glGetShaderInfoLog(thread_data->shader,
+                      thread_data->bufSize,
+                      thread_data->length,
+                      thread_data->infoLog);
 
 }
 
@@ -6821,23 +6825,23 @@ glGetShaderInfoLog_thread_cmd(GLuint shader, GLsizei bufSize, GLsizei *length, G
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glGetShaderInfoLog thread_param_local;
-   Thread_Command_glGetShaderInfoLog *thread_param = &thread_param_local;
+   Evas_Thread_Command_glGetShaderInfoLog thread_data_local;
+   Evas_Thread_Command_glGetShaderInfoLog *thread_data = &thread_data_local;
 
-   thread_param->shader = shader;
-   thread_param->bufSize = bufSize;
-   thread_param->length = length;
-   thread_param->infoLog = infoLog;
+   thread_data->shader = shader;
+   thread_data->bufSize = bufSize;
+   thread_data->length = length;
+   thread_data->infoLog = infoLog;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glGetShaderInfoLog,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGetShaderSource(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source);
+ * void
+ * glGetShaderSource(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source);
  */
 
 typedef struct
@@ -6847,18 +6851,18 @@ typedef struct
    GLsizei *length;
    GLchar *source;
 
-} Thread_Command_glGetShaderSource;
+} Evas_Thread_Command_glGetShaderSource;
 
 static void
 _gl_thread_glGetShaderSource(void *data)
 {
-   Thread_Command_glGetShaderSource *thread_param =
-      (Thread_Command_glGetShaderSource *)data;
+   Evas_Thread_Command_glGetShaderSource *thread_data =
+      (Evas_Thread_Command_glGetShaderSource *)data;
 
-   glGetShaderSource(thread_param->shader,
-                     thread_param->bufSize,
-                     thread_param->length,
-                     thread_param->source);
+   glGetShaderSource(thread_data->shader,
+                     thread_data->bufSize,
+                     thread_data->length,
+                     thread_data->source);
 
 }
 
@@ -6873,23 +6877,23 @@ glGetShaderSource_thread_cmd(GLuint shader, GLsizei bufSize, GLsizei *length, GL
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glGetShaderSource thread_param_local;
-   Thread_Command_glGetShaderSource *thread_param = &thread_param_local;
+   Evas_Thread_Command_glGetShaderSource thread_data_local;
+   Evas_Thread_Command_glGetShaderSource *thread_data = &thread_data_local;
 
-   thread_param->shader = shader;
-   thread_param->bufSize = bufSize;
-   thread_param->length = length;
-   thread_param->source = source;
+   thread_data->shader = shader;
+   thread_data->bufSize = bufSize;
+   thread_data->length = length;
+   thread_data->source = source;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glGetShaderSource,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint *range, GLint *precision);
+ * void
+ * glGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint *range, GLint *precision);
  */
 
 typedef struct
@@ -6899,18 +6903,18 @@ typedef struct
    GLint *range;
    GLint *precision;
 
-} Thread_Command_glGetShaderPrecisionFormat;
+} Evas_Thread_Command_glGetShaderPrecisionFormat;
 
 static void
 _gl_thread_glGetShaderPrecisionFormat(void *data)
 {
-   Thread_Command_glGetShaderPrecisionFormat *thread_param =
-      (Thread_Command_glGetShaderPrecisionFormat *)data;
+   Evas_Thread_Command_glGetShaderPrecisionFormat *thread_data =
+      (Evas_Thread_Command_glGetShaderPrecisionFormat *)data;
 
-   glGetShaderPrecisionFormat(thread_param->shadertype,
-                              thread_param->precisiontype,
-                              thread_param->range,
-                              thread_param->precision);
+   glGetShaderPrecisionFormat(thread_data->shadertype,
+                              thread_data->precisiontype,
+                              thread_data->range,
+                              thread_data->precision);
 
 }
 
@@ -6925,23 +6929,23 @@ glGetShaderPrecisionFormat_thread_cmd(GLenum shadertype, GLenum precisiontype, G
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glGetShaderPrecisionFormat thread_param_local;
-   Thread_Command_glGetShaderPrecisionFormat *thread_param = &thread_param_local;
+   Evas_Thread_Command_glGetShaderPrecisionFormat thread_data_local;
+   Evas_Thread_Command_glGetShaderPrecisionFormat *thread_data = &thread_data_local;
 
-   thread_param->shadertype = shadertype;
-   thread_param->precisiontype = precisiontype;
-   thread_param->range = range;
-   thread_param->precision = precision;
+   thread_data->shadertype = shadertype;
+   thread_data->precisiontype = precisiontype;
+   thread_data->range = range;
+   thread_data->precision = precision;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glGetShaderPrecisionFormat,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params);
+ * void
+ * glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params);
  */
 
 typedef struct
@@ -6950,17 +6954,17 @@ typedef struct
    GLenum pname;
    GLfloat *params;
 
-} Thread_Command_glGetVertexAttribfv;
+} Evas_Thread_Command_glGetVertexAttribfv;
 
 static void
 _gl_thread_glGetVertexAttribfv(void *data)
 {
-   Thread_Command_glGetVertexAttribfv *thread_param =
-      (Thread_Command_glGetVertexAttribfv *)data;
+   Evas_Thread_Command_glGetVertexAttribfv *thread_data =
+      (Evas_Thread_Command_glGetVertexAttribfv *)data;
 
-   glGetVertexAttribfv(thread_param->index,
-                       thread_param->pname,
-                       thread_param->params);
+   glGetVertexAttribfv(thread_data->index,
+                       thread_data->pname,
+                       thread_data->params);
 
 }
 
@@ -6975,22 +6979,22 @@ glGetVertexAttribfv_thread_cmd(GLuint index, GLenum pname, GLfloat *params)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glGetVertexAttribfv thread_param_local;
-   Thread_Command_glGetVertexAttribfv *thread_param = &thread_param_local;
+   Evas_Thread_Command_glGetVertexAttribfv thread_data_local;
+   Evas_Thread_Command_glGetVertexAttribfv *thread_data = &thread_data_local;
 
-   thread_param->index = index;
-   thread_param->pname = pname;
-   thread_param->params = params;
+   thread_data->index = index;
+   thread_data->pname = pname;
+   thread_data->params = params;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glGetVertexAttribfv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGetVertexAttribiv(GLuint index, GLenum pname, GLint *params);
+ * void
+ * glGetVertexAttribiv(GLuint index, GLenum pname, GLint *params);
  */
 
 typedef struct
@@ -6999,17 +7003,17 @@ typedef struct
    GLenum pname;
    GLint *params;
 
-} Thread_Command_glGetVertexAttribiv;
+} Evas_Thread_Command_glGetVertexAttribiv;
 
 static void
 _gl_thread_glGetVertexAttribiv(void *data)
 {
-   Thread_Command_glGetVertexAttribiv *thread_param =
-      (Thread_Command_glGetVertexAttribiv *)data;
+   Evas_Thread_Command_glGetVertexAttribiv *thread_data =
+      (Evas_Thread_Command_glGetVertexAttribiv *)data;
 
-   glGetVertexAttribiv(thread_param->index,
-                       thread_param->pname,
-                       thread_param->params);
+   glGetVertexAttribiv(thread_data->index,
+                       thread_data->pname,
+                       thread_data->params);
 
 }
 
@@ -7024,22 +7028,22 @@ glGetVertexAttribiv_thread_cmd(GLuint index, GLenum pname, GLint *params)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glGetVertexAttribiv thread_param_local;
-   Thread_Command_glGetVertexAttribiv *thread_param = &thread_param_local;
+   Evas_Thread_Command_glGetVertexAttribiv thread_data_local;
+   Evas_Thread_Command_glGetVertexAttribiv *thread_data = &thread_data_local;
 
-   thread_param->index = index;
-   thread_param->pname = pname;
-   thread_param->params = params;
+   thread_data->index = index;
+   thread_data->pname = pname;
+   thread_data->params = params;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glGetVertexAttribiv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   GLboolean
-   glIsProgram(GLuint program);
+ * GLboolean
+ * glIsProgram(GLuint program);
  */
 
 typedef struct
@@ -7047,15 +7051,15 @@ typedef struct
    GLboolean return_value;
    GLuint program;
 
-} Thread_Command_glIsProgram;
+} Evas_Thread_Command_glIsProgram;
 
 static void
 _gl_thread_glIsProgram(void *data)
 {
-   Thread_Command_glIsProgram *thread_param =
-      (Thread_Command_glIsProgram *)data;
+   Evas_Thread_Command_glIsProgram *thread_data =
+      (Evas_Thread_Command_glIsProgram *)data;
 
-   thread_param->return_value = glIsProgram(thread_param->program);
+   thread_data->return_value = glIsProgram(thread_data->program);
 
 }
 
@@ -7069,22 +7073,22 @@ glIsProgram_thread_cmd(GLuint program)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glIsProgram thread_param_local;
-   Thread_Command_glIsProgram *thread_param = &thread_param_local;
+   Evas_Thread_Command_glIsProgram thread_data_local;
+   Evas_Thread_Command_glIsProgram *thread_data = &thread_data_local;
 
-   thread_param->program = program;
+   thread_data->program = program;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glIsProgram,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
-   void
-   glGetProgramInfoLog(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
+ * void
+ * glGetProgramInfoLog(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
  */
 
 typedef struct
@@ -7094,18 +7098,18 @@ typedef struct
    GLsizei *length;
    GLchar *infoLog;
 
-} Thread_Command_glGetProgramInfoLog;
+} Evas_Thread_Command_glGetProgramInfoLog;
 
 static void
 _gl_thread_glGetProgramInfoLog(void *data)
 {
-   Thread_Command_glGetProgramInfoLog *thread_param =
-      (Thread_Command_glGetProgramInfoLog *)data;
+   Evas_Thread_Command_glGetProgramInfoLog *thread_data =
+      (Evas_Thread_Command_glGetProgramInfoLog *)data;
 
-   glGetProgramInfoLog(thread_param->program,
-                       thread_param->bufSize,
-                       thread_param->length,
-                       thread_param->infoLog);
+   glGetProgramInfoLog(thread_data->program,
+                       thread_data->bufSize,
+                       thread_data->length,
+                       thread_data->infoLog);
 
 }
 
@@ -7120,23 +7124,23 @@ glGetProgramInfoLog_thread_cmd(GLuint program, GLsizei bufSize, GLsizei *length,
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glGetProgramInfoLog thread_param_local;
-   Thread_Command_glGetProgramInfoLog *thread_param = &thread_param_local;
+   Evas_Thread_Command_glGetProgramInfoLog thread_data_local;
+   Evas_Thread_Command_glGetProgramInfoLog *thread_data = &thread_data_local;
 
-   thread_param->program = program;
-   thread_param->bufSize = bufSize;
-   thread_param->length = length;
-   thread_param->infoLog = infoLog;
+   thread_data->program = program;
+   thread_data->bufSize = bufSize;
+   thread_data->length = length;
+   thread_data->infoLog = infoLog;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glGetProgramInfoLog,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glGetProgramiv(GLuint program, GLenum pname, GLint *params);
+ * void
+ * glGetProgramiv(GLuint program, GLenum pname, GLint *params);
  */
 
 typedef struct
@@ -7145,17 +7149,17 @@ typedef struct
    GLenum pname;
    GLint *params;
 
-} Thread_Command_glGetProgramiv;
+} Evas_Thread_Command_glGetProgramiv;
 
 static void
 _gl_thread_glGetProgramiv(void *data)
 {
-   Thread_Command_glGetProgramiv *thread_param =
-      (Thread_Command_glGetProgramiv *)data;
+   Evas_Thread_Command_glGetProgramiv *thread_data =
+      (Evas_Thread_Command_glGetProgramiv *)data;
 
-   glGetProgramiv(thread_param->program,
-                  thread_param->pname,
-                  thread_param->params);
+   glGetProgramiv(thread_data->program,
+                  thread_data->pname,
+                  thread_data->params);
 
 }
 
@@ -7170,22 +7174,22 @@ glGetProgramiv_thread_cmd(GLuint program, GLenum pname, GLint *params)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glGetProgramiv thread_param_local;
-   Thread_Command_glGetProgramiv *thread_param = &thread_param_local;
+   Evas_Thread_Command_glGetProgramiv thread_data_local;
+   Evas_Thread_Command_glGetProgramiv *thread_data = &thread_data_local;
 
-   thread_param->program = program;
-   thread_param->pname = pname;
-   thread_param->params = params;
+   thread_data->program = program;
+   thread_data->pname = pname;
+   thread_data->params = params;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glGetProgramiv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   GLboolean
-   glIsFramebuffer(GLint framebuffer);
+ * GLboolean
+ * glIsFramebuffer(GLint framebuffer);
  */
 
 typedef struct
@@ -7193,15 +7197,15 @@ typedef struct
    GLboolean return_value;
    GLint framebuffer;
 
-} Thread_Command_glIsFramebuffer;
+} Evas_Thread_Command_glIsFramebuffer;
 
 static void
 _gl_thread_glIsFramebuffer(void *data)
 {
-   Thread_Command_glIsFramebuffer *thread_param =
-      (Thread_Command_glIsFramebuffer *)data;
+   Evas_Thread_Command_glIsFramebuffer *thread_data =
+      (Evas_Thread_Command_glIsFramebuffer *)data;
 
-   thread_param->return_value = glIsFramebuffer(thread_param->framebuffer);
+   thread_data->return_value = glIsFramebuffer(thread_data->framebuffer);
 
 }
 
@@ -7215,22 +7219,22 @@ glIsFramebuffer_thread_cmd(GLint framebuffer)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glIsFramebuffer thread_param_local;
-   Thread_Command_glIsFramebuffer *thread_param = &thread_param_local;
+   Evas_Thread_Command_glIsFramebuffer thread_data_local;
+   Evas_Thread_Command_glIsFramebuffer *thread_data = &thread_data_local;
 
-   thread_param->framebuffer = framebuffer;
+   thread_data->framebuffer = framebuffer;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glIsFramebuffer,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
-   void
-   glGetFramebufferParameteriv(GLenum target, GLenum pname, GLint *params);
+ * void
+ * glGetFramebufferParameteriv(GLenum target, GLenum pname, GLint *params);
  */
 
 typedef struct
@@ -7239,7 +7243,7 @@ typedef struct
    GLenum pname;
    GLint *params;
 
-} Thread_Command_glGetFramebufferParameteriv;
+} Evas_Thread_Command_glGetFramebufferParameteriv;
 
 void (*orig_evas_glGetFramebufferParameteriv)(GLenum target, GLenum pname, GLint *params);
 
@@ -7258,12 +7262,12 @@ glGetFramebufferParameteriv_orig_evas_get(void)
 static void
 _gl_thread_glGetFramebufferParameteriv(void *data)
 {
-   Thread_Command_glGetFramebufferParameteriv *thread_param =
-      (Thread_Command_glGetFramebufferParameteriv *)data;
+   Evas_Thread_Command_glGetFramebufferParameteriv *thread_data =
+      (Evas_Thread_Command_glGetFramebufferParameteriv *)data;
 
-   orig_evas_glGetFramebufferParameteriv(thread_param->target,
-                                         thread_param->pname,
-                                         thread_param->params);
+   orig_evas_glGetFramebufferParameteriv(thread_data->target,
+                                         thread_data->pname,
+                                         thread_data->params);
 
 }
 
@@ -7278,22 +7282,22 @@ glGetFramebufferParameteriv_thread_cmd(GLenum target, GLenum pname, GLint *param
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glGetFramebufferParameteriv thread_param_local;
-   Thread_Command_glGetFramebufferParameteriv *thread_param = &thread_param_local;
+   Evas_Thread_Command_glGetFramebufferParameteriv thread_data_local;
+   Evas_Thread_Command_glGetFramebufferParameteriv *thread_data = &thread_data_local;
 
-   thread_param->target = target;
-   thread_param->pname = pname;
-   thread_param->params = params;
+   thread_data->target = target;
+   thread_data->pname = pname;
+   thread_data->params = params;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glGetFramebufferParameteriv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   GLboolean
-   glIsRenderbuffer(GLint renderbuffer);
+ * GLboolean
+ * glIsRenderbuffer(GLint renderbuffer);
  */
 
 typedef struct
@@ -7301,15 +7305,15 @@ typedef struct
    GLboolean return_value;
    GLint renderbuffer;
 
-} Thread_Command_glIsRenderbuffer;
+} Evas_Thread_Command_glIsRenderbuffer;
 
 static void
 _gl_thread_glIsRenderbuffer(void *data)
 {
-   Thread_Command_glIsRenderbuffer *thread_param =
-      (Thread_Command_glIsRenderbuffer *)data;
+   Evas_Thread_Command_glIsRenderbuffer *thread_data =
+      (Evas_Thread_Command_glIsRenderbuffer *)data;
 
-   thread_param->return_value = glIsRenderbuffer(thread_param->renderbuffer);
+   thread_data->return_value = glIsRenderbuffer(thread_data->renderbuffer);
 
 }
 
@@ -7323,22 +7327,22 @@ glIsRenderbuffer_thread_cmd(GLint renderbuffer)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glIsRenderbuffer thread_param_local;
-   Thread_Command_glIsRenderbuffer *thread_param = &thread_param_local;
+   Evas_Thread_Command_glIsRenderbuffer thread_data_local;
+   Evas_Thread_Command_glIsRenderbuffer *thread_data = &thread_data_local;
 
-   thread_param->renderbuffer = renderbuffer;
+   thread_data->renderbuffer = renderbuffer;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glIsRenderbuffer,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
-   void
-   glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint *params);
+ * void
+ * glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint *params);
  */
 
 typedef struct
@@ -7347,17 +7351,17 @@ typedef struct
    GLenum pname;
    GLint *params;
 
-} Thread_Command_glGetRenderbufferParameteriv;
+} Evas_Thread_Command_glGetRenderbufferParameteriv;
 
 static void
 _gl_thread_glGetRenderbufferParameteriv(void *data)
 {
-   Thread_Command_glGetRenderbufferParameteriv *thread_param =
-      (Thread_Command_glGetRenderbufferParameteriv *)data;
+   Evas_Thread_Command_glGetRenderbufferParameteriv *thread_data =
+      (Evas_Thread_Command_glGetRenderbufferParameteriv *)data;
 
-   glGetRenderbufferParameteriv(thread_param->target,
-                                thread_param->pname,
-                                thread_param->params);
+   glGetRenderbufferParameteriv(thread_data->target,
+                                thread_data->pname,
+                                thread_data->params);
 
 }
 
@@ -7372,22 +7376,22 @@ glGetRenderbufferParameteriv_thread_cmd(GLenum target, GLenum pname, GLint *para
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glGetRenderbufferParameteriv thread_param_local;
-   Thread_Command_glGetRenderbufferParameteriv *thread_param = &thread_param_local;
+   Evas_Thread_Command_glGetRenderbufferParameteriv thread_data_local;
+   Evas_Thread_Command_glGetRenderbufferParameteriv *thread_data = &thread_data_local;
 
-   thread_param->target = target;
-   thread_param->pname = pname;
-   thread_param->params = params;
+   thread_data->target = target;
+   thread_data->pname = pname;
+   thread_data->params = params;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glGetRenderbufferParameteriv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   GLboolean
-   glIsTexture(GLint texture);
+ * GLboolean
+ * glIsTexture(GLint texture);
  */
 
 typedef struct
@@ -7395,15 +7399,15 @@ typedef struct
    GLboolean return_value;
    GLint texture;
 
-} Thread_Command_glIsTexture;
+} Evas_Thread_Command_glIsTexture;
 
 static void
 _gl_thread_glIsTexture(void *data)
 {
-   Thread_Command_glIsTexture *thread_param =
-      (Thread_Command_glIsTexture *)data;
+   Evas_Thread_Command_glIsTexture *thread_data =
+      (Evas_Thread_Command_glIsTexture *)data;
 
-   thread_param->return_value = glIsTexture(thread_param->texture);
+   thread_data->return_value = glIsTexture(thread_data->texture);
 
 }
 
@@ -7417,22 +7421,22 @@ glIsTexture_thread_cmd(GLint texture)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glIsTexture thread_param_local;
-   Thread_Command_glIsTexture *thread_param = &thread_param_local;
+   Evas_Thread_Command_glIsTexture thread_data_local;
+   Evas_Thread_Command_glIsTexture *thread_data = &thread_data_local;
 
-   thread_param->texture = texture;
+   thread_data->texture = texture;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glIsTexture,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
-   void
-   glStartTiling(GLuint a, GLuint b, GLuint c, GLuint d, GLuint e);
+ * void
+ * glStartTiling(GLuint a, GLuint b, GLuint c, GLuint d, GLuint e);
  */
 
 typedef struct
@@ -7444,7 +7448,7 @@ typedef struct
    GLuint e;
    int command_allocated;
 
-} Thread_Command_glStartTiling;
+} Evas_Thread_Command_glStartTiling;
 
 void (*orig_evas_glStartTiling)(GLuint a, GLuint b, GLuint c, GLuint d, GLuint e);
 
@@ -7463,17 +7467,17 @@ glStartTiling_orig_evas_get(void)
 static void
 _gl_thread_glStartTiling(void *data)
 {
-   Thread_Command_glStartTiling *thread_param =
-      (Thread_Command_glStartTiling *)data;
+   Evas_Thread_Command_glStartTiling *thread_data =
+      (Evas_Thread_Command_glStartTiling *)data;
 
-   orig_evas_glStartTiling(thread_param->a,
-                           thread_param->b,
-                           thread_param->c,
-                           thread_param->d,
-                           thread_param->e);
+   orig_evas_glStartTiling(thread_data->a,
+                           thread_data->b,
+                           thread_data->c,
+                           thread_data->d,
+                           thread_data->e);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -7487,40 +7491,40 @@ glStartTiling_thread_cmd(GLuint a, GLuint b, GLuint c, GLuint d, GLuint e)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glStartTiling thread_param_local;
-   Thread_Command_glStartTiling *thread_param = &thread_param_local;
+   Evas_Thread_Command_glStartTiling thread_data_local;
+   Evas_Thread_Command_glStartTiling *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        Thread_Command_glStartTiling *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(Thread_Command_glStartTiling));
-        if (thread_param_new)
+        Evas_Thread_Command_glStartTiling *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(Evas_Thread_Command_glStartTiling));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->a = a;
-   thread_param->b = b;
-   thread_param->c = c;
-   thread_param->d = d;
-   thread_param->e = e;
+   thread_data->a = a;
+   thread_data->b = b;
+   thread_data->c = c;
+   thread_data->d = d;
+   thread_data->e = e;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glStartTiling,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glEndTiling(GLuint a);
+ * void
+ * glEndTiling(GLuint a);
  */
 
 typedef struct
@@ -7528,7 +7532,7 @@ typedef struct
    GLuint a;
    int command_allocated;
 
-} Thread_Command_glEndTiling;
+} Evas_Thread_Command_glEndTiling;
 
 void (*orig_evas_glEndTiling)(GLuint a);
 
@@ -7547,13 +7551,13 @@ glEndTiling_orig_evas_get(void)
 static void
 _gl_thread_glEndTiling(void *data)
 {
-   Thread_Command_glEndTiling *thread_param =
-      (Thread_Command_glEndTiling *)data;
+   Evas_Thread_Command_glEndTiling *thread_data =
+      (Evas_Thread_Command_glEndTiling *)data;
 
-   orig_evas_glEndTiling(thread_param->a);
+   orig_evas_glEndTiling(thread_data->a);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -7567,36 +7571,36 @@ glEndTiling_thread_cmd(GLuint a)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glEndTiling thread_param_local;
-   Thread_Command_glEndTiling *thread_param = &thread_param_local;
+   Evas_Thread_Command_glEndTiling thread_data_local;
+   Evas_Thread_Command_glEndTiling *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        Thread_Command_glEndTiling *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(Thread_Command_glEndTiling));
-        if (thread_param_new)
+        Evas_Thread_Command_glEndTiling *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(Evas_Thread_Command_glEndTiling));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->a = a;
+   thread_data->a = a;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glEndTiling,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glActivateTile(GLuint a, GLuint b, GLuint c, GLuint d, GLuint e);
+ * void
+ * glActivateTile(GLuint a, GLuint b, GLuint c, GLuint d, GLuint e);
  */
 
 typedef struct
@@ -7608,7 +7612,7 @@ typedef struct
    GLuint e;
    int command_allocated;
 
-} Thread_Command_glActivateTile;
+} Evas_Thread_Command_glActivateTile;
 
 void (*orig_evas_glActivateTile)(GLuint a, GLuint b, GLuint c, GLuint d, GLuint e);
 
@@ -7627,17 +7631,17 @@ glActivateTile_orig_evas_get(void)
 static void
 _gl_thread_glActivateTile(void *data)
 {
-   Thread_Command_glActivateTile *thread_param =
-      (Thread_Command_glActivateTile *)data;
+   Evas_Thread_Command_glActivateTile *thread_data =
+      (Evas_Thread_Command_glActivateTile *)data;
 
-   orig_evas_glActivateTile(thread_param->a,
-                            thread_param->b,
-                            thread_param->c,
-                            thread_param->d,
-                            thread_param->e);
+   orig_evas_glActivateTile(thread_data->a,
+                            thread_data->b,
+                            thread_data->c,
+                            thread_data->d,
+                            thread_data->e);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -7651,40 +7655,40 @@ glActivateTile_thread_cmd(GLuint a, GLuint b, GLuint c, GLuint d, GLuint e)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glActivateTile thread_param_local;
-   Thread_Command_glActivateTile *thread_param = &thread_param_local;
+   Evas_Thread_Command_glActivateTile thread_data_local;
+   Evas_Thread_Command_glActivateTile *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        Thread_Command_glActivateTile *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(Thread_Command_glActivateTile));
-        if (thread_param_new)
+        Evas_Thread_Command_glActivateTile *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(Evas_Thread_Command_glActivateTile));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->a = a;
-   thread_param->b = b;
-   thread_param->c = c;
-   thread_param->d = d;
-   thread_param->e = e;
+   thread_data->a = a;
+   thread_data->b = b;
+   thread_data->c = c;
+   thread_data->d = d;
+   thread_data->e = e;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glActivateTile,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 /*
-   void
-   glEGLImageTargetTexture2DOES(GLenum target, void *image);
+ * void
+ * glEGLImageTargetTexture2DOES(GLenum target, void *image);
  */
 
 typedef struct
@@ -7692,7 +7696,7 @@ typedef struct
    GLenum target;
    void *image;
 
-} Thread_Command_glEGLImageTargetTexture2DOES;
+} Evas_Thread_Command_glEGLImageTargetTexture2DOES;
 
 void (*orig_evas_glEGLImageTargetTexture2DOES)(GLenum target, void *image);
 
@@ -7711,11 +7715,11 @@ glEGLImageTargetTexture2DOES_orig_evas_get(void)
 static void
 _gl_thread_glEGLImageTargetTexture2DOES(void *data)
 {
-   Thread_Command_glEGLImageTargetTexture2DOES *thread_param =
-      (Thread_Command_glEGLImageTargetTexture2DOES *)data;
+   Evas_Thread_Command_glEGLImageTargetTexture2DOES *thread_data =
+      (Evas_Thread_Command_glEGLImageTargetTexture2DOES *)data;
 
-   orig_evas_glEGLImageTargetTexture2DOES(thread_param->target,
-                                          thread_param->image);
+   orig_evas_glEGLImageTargetTexture2DOES(thread_data->target,
+                                          thread_data->image);
 
 }
 
@@ -7730,23 +7734,23 @@ glEGLImageTargetTexture2DOES_thread_cmd(GLenum target, void *image)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glEGLImageTargetTexture2DOES thread_param_local;
-   Thread_Command_glEGLImageTargetTexture2DOES *thread_param = &thread_param_local;
+   Evas_Thread_Command_glEGLImageTargetTexture2DOES thread_data_local;
+   Evas_Thread_Command_glEGLImageTargetTexture2DOES *thread_data = &thread_data_local;
 
-   thread_param->target = target;
-   thread_param->image = image;
+   thread_data->target = target;
+   thread_data->image = image;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glEGLImageTargetTexture2DOES,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
 #ifndef GL_GLES
 
 /*
-   void
-   glAlphaFunc(GLenum func, GLclampf ref);
+ * void
+ * glAlphaFunc(GLenum func, GLclampf ref);
  */
 
 typedef struct
@@ -7755,19 +7759,19 @@ typedef struct
    GLclampf ref;
    int command_allocated;
 
-} Thread_Command_glAlphaFunc;
+} Evas_Thread_Command_glAlphaFunc;
 
 static void
 _gl_thread_glAlphaFunc(void *data)
 {
-   Thread_Command_glAlphaFunc *thread_param =
-      (Thread_Command_glAlphaFunc *)data;
+   Evas_Thread_Command_glAlphaFunc *thread_data =
+      (Evas_Thread_Command_glAlphaFunc *)data;
 
-   glAlphaFunc(thread_param->func,
-               thread_param->ref);
+   glAlphaFunc(thread_data->func,
+               thread_data->ref);
 
-   if (thread_param->command_allocated)
-     eina_mempool_free(_mp_command, thread_param);
+   if (thread_data->command_allocated)
+     eina_mempool_free(_mp_command, thread_data);
 }
 
 EAPI void
@@ -7781,31 +7785,31 @@ glAlphaFunc_thread_cmd(GLenum func, GLclampf ref)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glAlphaFunc thread_param_local;
-   Thread_Command_glAlphaFunc *thread_param = &thread_param_local;
+   Evas_Thread_Command_glAlphaFunc thread_data_local;
+   Evas_Thread_Command_glAlphaFunc *thread_data = &thread_data_local;
 
    /* command_allocated flag init. */
-   thread_param->command_allocated = 0;
+   thread_data->command_allocated = 0;
 
    if (!evas_gl_thread_force_finish())
      { /* _flush */
-        Thread_Command_glAlphaFunc *thread_param_new;
-        thread_param_new = eina_mempool_malloc(_mp_command,
-                                               sizeof(Thread_Command_glAlphaFunc));
-        if (thread_param_new)
+        Evas_Thread_Command_glAlphaFunc *thread_data_new;
+        thread_data_new = eina_mempool_malloc(_mp_command,
+                                              sizeof(Evas_Thread_Command_glAlphaFunc));
+        if (thread_data_new)
           {
-             thread_param = thread_param_new;
-             thread_param->command_allocated = 1;
+             thread_data = thread_data_new;
+             thread_data->command_allocated = 1;
              thread_mode = EVAS_GL_THREAD_MODE_FLUSH;
           }
      }
 
-   thread_param->func = func;
-   thread_param->ref = ref;
+   thread_data->func = func;
+   thread_data->ref = ref;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glAlphaFunc,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 #endif
@@ -7813,8 +7817,8 @@ glAlphaFunc_thread_cmd(GLenum func, GLclampf ref)
 #ifndef GL_GLES
 
 /*
-   void
-   glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params);
+ * void
+ * glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params);
  */
 
 typedef struct
@@ -7824,18 +7828,18 @@ typedef struct
    GLenum pname;
    GLint *params;
 
-} Thread_Command_glGetTexLevelParameteriv;
+} Evas_Thread_Command_glGetTexLevelParameteriv;
 
 static void
 _gl_thread_glGetTexLevelParameteriv(void *data)
 {
-   Thread_Command_glGetTexLevelParameteriv *thread_param =
-      (Thread_Command_glGetTexLevelParameteriv *)data;
+   Evas_Thread_Command_glGetTexLevelParameteriv *thread_data =
+      (Evas_Thread_Command_glGetTexLevelParameteriv *)data;
 
-   glGetTexLevelParameteriv(thread_param->target,
-                            thread_param->level,
-                            thread_param->pname,
-                            thread_param->params);
+   glGetTexLevelParameteriv(thread_data->target,
+                            thread_data->level,
+                            thread_data->pname,
+                            thread_data->params);
 
 }
 
@@ -7850,17 +7854,17 @@ glGetTexLevelParameteriv_thread_cmd(GLenum target, GLint level, GLenum pname, GL
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glGetTexLevelParameteriv thread_param_local;
-   Thread_Command_glGetTexLevelParameteriv *thread_param = &thread_param_local;
+   Evas_Thread_Command_glGetTexLevelParameteriv thread_data_local;
+   Evas_Thread_Command_glGetTexLevelParameteriv *thread_data = &thread_data_local;
 
-   thread_param->target = target;
-   thread_param->level = level;
-   thread_param->pname = pname;
-   thread_param->params = params;
+   thread_data->target = target;
+   thread_data->level = level;
+   thread_data->pname = pname;
+   thread_data->params = params;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glGetTexLevelParameteriv,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 #endif
@@ -7868,8 +7872,8 @@ glGetTexLevelParameteriv_thread_cmd(GLenum target, GLint level, GLenum pname, GL
 #ifndef GL_GLES
 
 /*
-   void
-   glRenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height);
+ * void
+ * glRenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height);
  */
 
 typedef struct
@@ -7880,7 +7884,7 @@ typedef struct
    GLsizei width;
    GLsizei height;
 
-} Thread_Command_glRenderbufferStorageMultisample;
+} Evas_Thread_Command_glRenderbufferStorageMultisample;
 
 void (*orig_evas_glRenderbufferStorageMultisample)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height);
 
@@ -7899,14 +7903,14 @@ glRenderbufferStorageMultisample_orig_evas_get(void)
 static void
 _gl_thread_glRenderbufferStorageMultisample(void *data)
 {
-   Thread_Command_glRenderbufferStorageMultisample *thread_param =
-      (Thread_Command_glRenderbufferStorageMultisample *)data;
+   Evas_Thread_Command_glRenderbufferStorageMultisample *thread_data =
+      (Evas_Thread_Command_glRenderbufferStorageMultisample *)data;
 
-   orig_evas_glRenderbufferStorageMultisample(thread_param->target,
-                                              thread_param->samples,
-                                              thread_param->internalformat,
-                                              thread_param->width,
-                                              thread_param->height);
+   orig_evas_glRenderbufferStorageMultisample(thread_data->target,
+                                              thread_data->samples,
+                                              thread_data->internalformat,
+                                              thread_data->width,
+                                              thread_data->height);
 
 }
 
@@ -7921,25 +7925,25 @@ glRenderbufferStorageMultisample_thread_cmd(GLenum target, GLsizei samples, GLen
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glRenderbufferStorageMultisample thread_param_local;
-   Thread_Command_glRenderbufferStorageMultisample *thread_param = &thread_param_local;
+   Evas_Thread_Command_glRenderbufferStorageMultisample thread_data_local;
+   Evas_Thread_Command_glRenderbufferStorageMultisample *thread_data = &thread_data_local;
 
-   thread_param->target = target;
-   thread_param->samples = samples;
-   thread_param->internalformat = internalformat;
-   thread_param->width = width;
-   thread_param->height = height;
+   thread_data->target = target;
+   thread_data->samples = samples;
+   thread_data->internalformat = internalformat;
+   thread_data->width = width;
+   thread_data->height = height;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glRenderbufferStorageMultisample,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 #endif
 
 /*
-   const GLubyte *
-   glGetStringi(GLenum name, GLuint index);
+ * const GLubyte *
+ * glGetStringi(GLenum name, GLuint index);
  */
 
 typedef struct
@@ -7948,7 +7952,7 @@ typedef struct
    GLenum name;
    GLuint index;
 
-} Thread_Command_glGetStringi;
+} Evas_Thread_Command_glGetStringi;
 
 const GLubyte * (*orig_evas_glGetStringi)(GLenum name, GLuint index);
 
@@ -7967,11 +7971,11 @@ glGetStringi_orig_evas_get(void)
 static void
 _gl_thread_glGetStringi(void *data)
 {
-   Thread_Command_glGetStringi *thread_param =
-      (Thread_Command_glGetStringi *)data;
+   Evas_Thread_Command_glGetStringi *thread_data =
+      (Evas_Thread_Command_glGetStringi *)data;
 
-   thread_param->return_value = orig_evas_glGetStringi(thread_param->name,
-                                                       thread_param->index);
+   thread_data->return_value = orig_evas_glGetStringi(thread_data->name,
+                                                      thread_data->index);
 
 }
 
@@ -7985,16 +7989,16 @@ glGetStringi_thread_cmd(GLenum name, GLuint index)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glGetStringi thread_param_local;
-   Thread_Command_glGetStringi *thread_param = &thread_param_local;
+   Evas_Thread_Command_glGetStringi thread_data_local;
+   Evas_Thread_Command_glGetStringi *thread_data = &thread_data_local;
 
-   thread_param->name = name;
-   thread_param->index = index;
+   thread_data->name = name;
+   thread_data->index = index;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glGetStringi,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }

diff --git a/src/modules/evas/engines/gl_common/evas_gl_thread_gl_generated.h b/src/modules/evas/engines/gl_common/evas_gl_thread_gl_generated.h
index ad6eac2..2ad06a2 100644 (file)
--- a/src/modules/evas/engines/gl_common/evas_gl_thread_gl_generated.h
+++ b/src/modules/evas/engines/gl_common/evas_gl_thread_gl_generated.h
@@ -1,5 +1,9 @@
-/* DO NOT MODIFY THIS FILE AS IT IS AUTO-GENERATED */
-
+/*
+ * This is an automatically generated file using a python script.
+ * ($EFL_HOME/src/utils/evas/generate_gl_thread_api.py)
+ * Recommend that you modify data files ($EFL_HOME/src/utils/evas/gl_api_def.txt)
+ * and make use of scripts if you need to fix them.
+ */
 
 EAPI GLenum glGetError_thread_cmd(void);
 EAPI void glVertexAttribPointer_thread_cmd(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void *pointer);

diff --git a/src/modules/evas/engines/gl_common/evas_gl_thread_gl_link_generated.c b/src/modules/evas/engines/gl_common/evas_gl_thread_gl_link_generated.c
index 76a5bbc..709f6f3 100644 (file)
--- a/src/modules/evas/engines/gl_common/evas_gl_thread_gl_link_generated.c
+++ b/src/modules/evas/engines/gl_common/evas_gl_thread_gl_link_generated.c
@@ -1,5 +1,9 @@
-/* DO NOT MODIFY THIS FILE AS IT IS AUTO-GENERATED */
-
+/*
+ * This is an automatically generated file using a python script.
+ * ($EFL_HOME/src/utils/evas/generate_gl_thread_api.py)
+ * Recommend that you modify data files ($EFL_HOME/src/utils/evas/gl_api_def.txt)
+ * and make use of scripts if you need to fix them.
+ */
 GLenum (*glGetError_thread_cmd)(void) = NULL;
 void (*glVertexAttribPointer_thread_cmd)(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void *pointer) = NULL;
 void (*glEnableVertexAttribArray_thread_cmd)(GLuint index) = NULL;
@@ -165,7 +169,8 @@ void *(*glGetStringi_orig_evas_get)(void) = NULL;
 const GLubyte * (*glGetStringi_thread_cmd)(GLenum name, GLuint index) = NULL;
 
 
-void _gl_thread_link_init()
+void
+_gl_thread_link_gl_generated_init()
 {
 #define LINK2GENERIC(sym) \
    sym = dlsym(RTLD_DEFAULT, #sym); \

diff --git a/src/modules/evas/engines/gl_common/evas_gl_thread_gl_link_generated.h b/src/modules/evas/engines/gl_common/evas_gl_thread_gl_link_generated.h
index a198b46..48b3e63 100644 (file)
--- a/src/modules/evas/engines/gl_common/evas_gl_thread_gl_link_generated.h
+++ b/src/modules/evas/engines/gl_common/evas_gl_thread_gl_link_generated.h
@@ -1,5 +1,9 @@
-/* DO NOT MODIFY THIS FILE AS IT IS AUTO-GENERATED */
-
+/*
+ * This is an automatically generated file using a python script.
+ * ($EFL_HOME/src/utils/evas/generate_gl_thread_api.py)
+ * Recommend that you modify data files ($EFL_HOME/src/utils/evas/gl_api_def.txt)
+ * and make use of scripts if you need to fix them.
+ */
 extern GLenum (*glGetError_thread_cmd)(void);
 extern void (*glVertexAttribPointer_thread_cmd)(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void *pointer);
 extern void (*glEnableVertexAttribArray_thread_cmd)(GLuint index);
@@ -165,4 +169,4 @@ extern void *(*glGetStringi_orig_evas_get)(void);
 extern const GLubyte * (*glGetStringi_thread_cmd)(GLenum name, GLuint index);
 
 
-extern void _gl_thread_link_init();
+extern void _gl_thread_link_gl_generated_init();

diff --git a/src/modules/evas/engines/gl_common/evas_gl_thread_glx.c b/src/modules/evas/engines/gl_common/evas_gl_thread_glx.c
index bf17c01..bed7aec 100644 (file)
--- a/src/modules/evas/engines/gl_common/evas_gl_thread_glx.c
+++ b/src/modules/evas/engines/gl_common/evas_gl_thread_glx.c
@@ -1,11 +1,10 @@
-#include "evas_common_private.h"
 #include "evas_gl_thread.h"
 
 
 #ifndef GL_GLES
 
 
-#ifdef EVAS_GL_RENDER_THREAD_IS_GENERIC
+#ifdef EVAS_GL_RENDER_THREAD_COMPILE_FOR_GL_GENERIC
 
 
 /*
@@ -20,7 +19,7 @@ typedef struct
    int buffer;
    const int *attrib_list;
 
-} Thread_Command_glXBindTexImage;
+} Evas_Thread_Command_glXBindTexImage;
 
 void (*orig_evas_glXBindTexImage)(Display *dpy, GLXDrawable drawable, int buffer, const int *attrib_list);
 
@@ -39,13 +38,13 @@ glXBindTexImage_orig_evas_get(void)
 static void
 _gl_thread_glXBindTexImage(void *data)
 {
-   Thread_Command_glXBindTexImage *thread_param =
-      (Thread_Command_glXBindTexImage *)data;
+   Evas_Thread_Command_glXBindTexImage *thread_data =
+       (Evas_Thread_Command_glXBindTexImage *)data;
 
-   orig_evas_glXBindTexImage(thread_param->dpy,
-                             thread_param->drawable,
-                             thread_param->buffer,
-                             thread_param->attrib_list);
+   orig_evas_glXBindTexImage(thread_data->dpy,
+                             thread_data->drawable,
+                             thread_data->buffer,
+                             thread_data->attrib_list);
 
 }
 
@@ -60,17 +59,17 @@ glXBindTexImage_thread_cmd(Display *dpy, GLXDrawable drawable, int buffer, const
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glXBindTexImage thread_param_local;
-   Thread_Command_glXBindTexImage *thread_param = &thread_param_local;
+   Evas_Thread_Command_glXBindTexImage thread_data_local;
+   Evas_Thread_Command_glXBindTexImage *thread_data = &thread_data_local;
 
-   thread_param->dpy = dpy;
-   thread_param->drawable = drawable;
-   thread_param->buffer = buffer;
-   thread_param->attrib_list = attrib_list;
+   thread_data->dpy = dpy;
+   thread_data->drawable = drawable;
+   thread_data->buffer = buffer;
+   thread_data->attrib_list = attrib_list;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glXBindTexImage,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
@@ -87,18 +86,18 @@ typedef struct
    const int *attribList;
    int *nitems;
 
-} Thread_Command_glXChooseFBConfig;
+} Evas_Thread_Command_glXChooseFBConfig;
 
 static void
 _gl_thread_glXChooseFBConfig(void *data)
 {
-   Thread_Command_glXChooseFBConfig *thread_param =
-      (Thread_Command_glXChooseFBConfig *)data;
+   Evas_Thread_Command_glXChooseFBConfig *thread_data =
+       (Evas_Thread_Command_glXChooseFBConfig *)data;
 
-   thread_param->return_value = glXChooseFBConfig(thread_param->dpy,
-                                                  thread_param->screen,
-                                                  thread_param->attribList,
-                                                  thread_param->nitems);
+   thread_data->return_value = glXChooseFBConfig(thread_data->dpy,
+                                                 thread_data->screen,
+                                                 thread_data->attribList,
+                                                 thread_data->nitems);
 
 }
 
@@ -112,20 +111,20 @@ glXChooseFBConfig_thread_cmd(Display *dpy, int screen, const int *attribList, in
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glXChooseFBConfig thread_param_local;
-   Thread_Command_glXChooseFBConfig *thread_param = &thread_param_local;
+   Evas_Thread_Command_glXChooseFBConfig thread_data_local;
+   Evas_Thread_Command_glXChooseFBConfig *thread_data = &thread_data_local;
 
-   thread_param->dpy = dpy;
-   thread_param->screen = screen;
-   thread_param->attribList = attribList;
-   thread_param->nitems = nitems;
+   thread_data->dpy = dpy;
+   thread_data->screen = screen;
+   thread_data->attribList = attribList;
+   thread_data->nitems = nitems;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glXChooseFBConfig,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
@@ -141,18 +140,18 @@ typedef struct
    GLXContext shareList;
    Bool direct;
 
-} Thread_Command_glXCreateContext;
+} Evas_Thread_Command_glXCreateContext;
 
 static void
 _gl_thread_glXCreateContext(void *data)
 {
-   Thread_Command_glXCreateContext *thread_param =
-      (Thread_Command_glXCreateContext *)data;
+   Evas_Thread_Command_glXCreateContext *thread_data =
+       (Evas_Thread_Command_glXCreateContext *)data;
 
-   thread_param->return_value = glXCreateContext(thread_param->dpy,
-                                                 thread_param->vis,
-                                                 thread_param->shareList,
-                                                 thread_param->direct);
+   thread_data->return_value = glXCreateContext(thread_data->dpy,
+                                                thread_data->vis,
+                                                thread_data->shareList,
+                                                thread_data->direct);
 
 }
 
@@ -166,20 +165,20 @@ glXCreateContext_thread_cmd(Display *dpy, XVisualInfo *vis, GLXContext shareList
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glXCreateContext thread_param_local;
-   Thread_Command_glXCreateContext *thread_param = &thread_param_local;
+   Evas_Thread_Command_glXCreateContext thread_data_local;
+   Evas_Thread_Command_glXCreateContext *thread_data = &thread_data_local;
 
-   thread_param->dpy = dpy;
-   thread_param->vis = vis;
-   thread_param->shareList = shareList;
-   thread_param->direct = direct;
+   thread_data->dpy = dpy;
+   thread_data->vis = vis;
+   thread_data->shareList = shareList;
+   thread_data->direct = direct;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glXCreateContext,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
@@ -196,19 +195,19 @@ typedef struct
    GLXContext shareList;
    Bool direct;
 
-} Thread_Command_glXCreateNewContext;
+} Evas_Thread_Command_glXCreateNewContext;
 
 static void
 _gl_thread_glXCreateNewContext(void *data)
 {
-   Thread_Command_glXCreateNewContext *thread_param =
-      (Thread_Command_glXCreateNewContext *)data;
+   Evas_Thread_Command_glXCreateNewContext *thread_data =
+       (Evas_Thread_Command_glXCreateNewContext *)data;
 
-   thread_param->return_value = glXCreateNewContext(thread_param->dpy,
-                                                    thread_param->config,
-                                                    thread_param->renderType,
-                                                    thread_param->shareList,
-                                                    thread_param->direct);
+   thread_data->return_value = glXCreateNewContext(thread_data->dpy,
+                                                   thread_data->config,
+                                                   thread_data->renderType,
+                                                   thread_data->shareList,
+                                                   thread_data->direct);
 
 }
 
@@ -222,21 +221,21 @@ glXCreateNewContext_thread_cmd(Display *dpy, GLXFBConfig config, int renderType,
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glXCreateNewContext thread_param_local;
-   Thread_Command_glXCreateNewContext *thread_param = &thread_param_local;
+   Evas_Thread_Command_glXCreateNewContext thread_data_local;
+   Evas_Thread_Command_glXCreateNewContext *thread_data = &thread_data_local;
 
-   thread_param->dpy = dpy;
-   thread_param->config = config;
-   thread_param->renderType = renderType;
-   thread_param->shareList = shareList;
-   thread_param->direct = direct;
+   thread_data->dpy = dpy;
+   thread_data->config = config;
+   thread_data->renderType = renderType;
+   thread_data->shareList = shareList;
+   thread_data->direct = direct;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glXCreateNewContext,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
@@ -251,17 +250,17 @@ typedef struct
    GLXFBConfig config;
    const int *attribList;
 
-} Thread_Command_glXCreatePbuffer;
+} Evas_Thread_Command_glXCreatePbuffer;
 
 static void
 _gl_thread_glXCreatePbuffer(void *data)
 {
-   Thread_Command_glXCreatePbuffer *thread_param =
-      (Thread_Command_glXCreatePbuffer *)data;
+   Evas_Thread_Command_glXCreatePbuffer *thread_data =
+       (Evas_Thread_Command_glXCreatePbuffer *)data;
 
-   thread_param->return_value = glXCreatePbuffer(thread_param->dpy,
-                                                 thread_param->config,
-                                                 thread_param->attribList);
+   thread_data->return_value = glXCreatePbuffer(thread_data->dpy,
+                                                thread_data->config,
+                                                thread_data->attribList);
 
 }
 
@@ -275,19 +274,19 @@ glXCreatePbuffer_thread_cmd(Display *dpy, GLXFBConfig config, const int *attribL
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glXCreatePbuffer thread_param_local;
-   Thread_Command_glXCreatePbuffer *thread_param = &thread_param_local;
+   Evas_Thread_Command_glXCreatePbuffer thread_data_local;
+   Evas_Thread_Command_glXCreatePbuffer *thread_data = &thread_data_local;
 
-   thread_param->dpy = dpy;
-   thread_param->config = config;
-   thread_param->attribList = attribList;
+   thread_data->dpy = dpy;
+   thread_data->config = config;
+   thread_data->attribList = attribList;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glXCreatePbuffer,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
@@ -303,7 +302,7 @@ typedef struct
    Pixmap pixmap;
    const int *attribList;
 
-} Thread_Command_glXCreatePixmap;
+} Evas_Thread_Command_glXCreatePixmap;
 
 GLXPixmap (*orig_evas_glXCreatePixmap)(Display *dpy, GLXFBConfig config, Pixmap pixmap, const int *attribList);
 
@@ -323,13 +322,13 @@ glXCreatePixmap_orig_evas_get(void)
 static void
 _gl_thread_glXCreatePixmap(void *data)
 {
-   Thread_Command_glXCreatePixmap *thread_param =
-      (Thread_Command_glXCreatePixmap *)data;
+   Evas_Thread_Command_glXCreatePixmap *thread_data =
+       (Evas_Thread_Command_glXCreatePixmap *)data;
 
-   thread_param->return_value = orig_evas_glXCreatePixmap(thread_param->dpy,
-                                                          thread_param->config,
-                                                          thread_param->pixmap,
-                                                          thread_param->attribList);
+   thread_data->return_value = orig_evas_glXCreatePixmap(thread_data->dpy,
+                                                         thread_data->config,
+                                                         thread_data->pixmap,
+                                                         thread_data->attribList);
 
 }
 
@@ -343,20 +342,20 @@ glXCreatePixmap_thread_cmd(Display *dpy, GLXFBConfig config, Pixmap pixmap, cons
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glXCreatePixmap thread_param_local;
-   Thread_Command_glXCreatePixmap *thread_param = &thread_param_local;
+   Evas_Thread_Command_glXCreatePixmap thread_data_local;
+   Evas_Thread_Command_glXCreatePixmap *thread_data = &thread_data_local;
 
-   thread_param->dpy = dpy;
-   thread_param->config = config;
-   thread_param->pixmap = pixmap;
-   thread_param->attribList = attribList;
+   thread_data->dpy = dpy;
+   thread_data->config = config;
+   thread_data->pixmap = pixmap;
+   thread_data->attribList = attribList;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glXCreatePixmap,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
@@ -372,18 +371,18 @@ typedef struct
    Window win;
    const int *attribList;
 
-} Thread_Command_glXCreateWindow;
+} Evas_Thread_Command_glXCreateWindow;
 
 static void
 _gl_thread_glXCreateWindow(void *data)
 {
-   Thread_Command_glXCreateWindow *thread_param =
-      (Thread_Command_glXCreateWindow *)data;
+   Evas_Thread_Command_glXCreateWindow *thread_data =
+       (Evas_Thread_Command_glXCreateWindow *)data;
 
-   thread_param->return_value = glXCreateWindow(thread_param->dpy,
-                                                thread_param->config,
-                                                thread_param->win,
-                                                thread_param->attribList);
+   thread_data->return_value = glXCreateWindow(thread_data->dpy,
+                                               thread_data->config,
+                                               thread_data->win,
+                                               thread_data->attribList);
 
 }
 
@@ -397,20 +396,20 @@ glXCreateWindow_thread_cmd(Display *dpy, GLXFBConfig config, Window win, const i
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glXCreateWindow thread_param_local;
-   Thread_Command_glXCreateWindow *thread_param = &thread_param_local;
+   Evas_Thread_Command_glXCreateWindow thread_data_local;
+   Evas_Thread_Command_glXCreateWindow *thread_data = &thread_data_local;
 
-   thread_param->dpy = dpy;
-   thread_param->config = config;
-   thread_param->win = win;
-   thread_param->attribList = attribList;
+   thread_data->dpy = dpy;
+   thread_data->config = config;
+   thread_data->win = win;
+   thread_data->attribList = attribList;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glXCreateWindow,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
@@ -423,16 +422,16 @@ typedef struct
    Display *dpy;
    GLXPbuffer pbuf;
 
-} Thread_Command_glXDestroyPbuffer;
+} Evas_Thread_Command_glXDestroyPbuffer;
 
 static void
 _gl_thread_glXDestroyPbuffer(void *data)
 {
-   Thread_Command_glXDestroyPbuffer *thread_param =
-      (Thread_Command_glXDestroyPbuffer *)data;
+   Evas_Thread_Command_glXDestroyPbuffer *thread_data =
+       (Evas_Thread_Command_glXDestroyPbuffer *)data;
 
-   glXDestroyPbuffer(thread_param->dpy,
-                     thread_param->pbuf);
+   glXDestroyPbuffer(thread_data->dpy,
+                     thread_data->pbuf);
 
 }
 
@@ -447,15 +446,15 @@ glXDestroyPbuffer_thread_cmd(Display *dpy, GLXPbuffer pbuf)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glXDestroyPbuffer thread_param_local;
-   Thread_Command_glXDestroyPbuffer *thread_param = &thread_param_local;
+   Evas_Thread_Command_glXDestroyPbuffer thread_data_local;
+   Evas_Thread_Command_glXDestroyPbuffer *thread_data = &thread_data_local;
 
-   thread_param->dpy = dpy;
-   thread_param->pbuf = pbuf;
+   thread_data->dpy = dpy;
+   thread_data->pbuf = pbuf;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glXDestroyPbuffer,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
@@ -469,7 +468,7 @@ typedef struct
    Display *dpy;
    GLXPixmap pixmap;
 
-} Thread_Command_glXDestroyPixmap;
+} Evas_Thread_Command_glXDestroyPixmap;
 
 void (*orig_evas_glXDestroyPixmap)(Display *dpy, GLXPixmap pixmap);
 
@@ -488,11 +487,11 @@ glXDestroyPixmap_orig_evas_get(void)
 static void
 _gl_thread_glXDestroyPixmap(void *data)
 {
-   Thread_Command_glXDestroyPixmap *thread_param =
-      (Thread_Command_glXDestroyPixmap *)data;
+   Evas_Thread_Command_glXDestroyPixmap *thread_data =
+       (Evas_Thread_Command_glXDestroyPixmap *)data;
 
-   orig_evas_glXDestroyPixmap(thread_param->dpy,
-                              thread_param->pixmap);
+   orig_evas_glXDestroyPixmap(thread_data->dpy,
+                              thread_data->pixmap);
 
 }
 
@@ -507,15 +506,15 @@ glXDestroyPixmap_thread_cmd(Display *dpy, GLXPixmap pixmap)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glXDestroyPixmap thread_param_local;
-   Thread_Command_glXDestroyPixmap *thread_param = &thread_param_local;
+   Evas_Thread_Command_glXDestroyPixmap thread_data_local;
+   Evas_Thread_Command_glXDestroyPixmap *thread_data = &thread_data_local;
 
-   thread_param->dpy = dpy;
-   thread_param->pixmap = pixmap;
+   thread_data->dpy = dpy;
+   thread_data->pixmap = pixmap;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glXDestroyPixmap,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
@@ -529,16 +528,16 @@ typedef struct
    Display *dpy;
    GLXWindow window;
 
-} Thread_Command_glXDestroyWindow;
+} Evas_Thread_Command_glXDestroyWindow;
 
 static void
 _gl_thread_glXDestroyWindow(void *data)
 {
-   Thread_Command_glXDestroyWindow *thread_param =
-      (Thread_Command_glXDestroyWindow *)data;
+   Evas_Thread_Command_glXDestroyWindow *thread_data =
+       (Evas_Thread_Command_glXDestroyWindow *)data;
 
-   glXDestroyWindow(thread_param->dpy,
-                    thread_param->window);
+   glXDestroyWindow(thread_data->dpy,
+                    thread_data->window);
 
 }
 
@@ -553,15 +552,15 @@ glXDestroyWindow_thread_cmd(Display *dpy, GLXWindow window)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glXDestroyWindow thread_param_local;
-   Thread_Command_glXDestroyWindow *thread_param = &thread_param_local;
+   Evas_Thread_Command_glXDestroyWindow thread_data_local;
+   Evas_Thread_Command_glXDestroyWindow *thread_data = &thread_data_local;
 
-   thread_param->dpy = dpy;
-   thread_param->window = window;
+   thread_data->dpy = dpy;
+   thread_data->window = window;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glXDestroyWindow,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
@@ -578,18 +577,18 @@ typedef struct
    int attrib;
    int *value;
 
-} Thread_Command_glXGetConfig;
+} Evas_Thread_Command_glXGetConfig;
 
 static void
 _gl_thread_glXGetConfig(void *data)
 {
-   Thread_Command_glXGetConfig *thread_param =
-      (Thread_Command_glXGetConfig *)data;
+   Evas_Thread_Command_glXGetConfig *thread_data =
+       (Evas_Thread_Command_glXGetConfig *)data;
 
-   thread_param->return_value = glXGetConfig(thread_param->dpy,
-                                             thread_param->visual,
-                                             thread_param->attrib,
-                                             thread_param->value);
+   thread_data->return_value = glXGetConfig(thread_data->dpy,
+                                            thread_data->visual,
+                                            thread_data->attrib,
+                                            thread_data->value);
 
 }
 
@@ -603,20 +602,20 @@ glXGetConfig_thread_cmd(Display *dpy, XVisualInfo *visual, int attrib, int *valu
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glXGetConfig thread_param_local;
-   Thread_Command_glXGetConfig *thread_param = &thread_param_local;
+   Evas_Thread_Command_glXGetConfig thread_data_local;
+   Evas_Thread_Command_glXGetConfig *thread_data = &thread_data_local;
 
-   thread_param->dpy = dpy;
-   thread_param->visual = visual;
-   thread_param->attrib = attrib;
-   thread_param->value = value;
+   thread_data->dpy = dpy;
+   thread_data->visual = visual;
+   thread_data->attrib = attrib;
+   thread_data->value = value;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glXGetConfig,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
@@ -632,18 +631,18 @@ typedef struct
    int attribute;
    int *value;
 
-} Thread_Command_glXGetFBConfigAttrib;
+} Evas_Thread_Command_glXGetFBConfigAttrib;
 
 static void
 _gl_thread_glXGetFBConfigAttrib(void *data)
 {
-   Thread_Command_glXGetFBConfigAttrib *thread_param =
-      (Thread_Command_glXGetFBConfigAttrib *)data;
+   Evas_Thread_Command_glXGetFBConfigAttrib *thread_data =
+       (Evas_Thread_Command_glXGetFBConfigAttrib *)data;
 
-   thread_param->return_value = glXGetFBConfigAttrib(thread_param->dpy,
-                                                     thread_param->config,
-                                                     thread_param->attribute,
-                                                     thread_param->value);
+   thread_data->return_value = glXGetFBConfigAttrib(thread_data->dpy,
+                                                    thread_data->config,
+                                                    thread_data->attribute,
+                                                    thread_data->value);
 
 }
 
@@ -657,20 +656,20 @@ glXGetFBConfigAttrib_thread_cmd(Display *dpy, GLXFBConfig config, int attribute,
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glXGetFBConfigAttrib thread_param_local;
-   Thread_Command_glXGetFBConfigAttrib *thread_param = &thread_param_local;
+   Evas_Thread_Command_glXGetFBConfigAttrib thread_data_local;
+   Evas_Thread_Command_glXGetFBConfigAttrib *thread_data = &thread_data_local;
 
-   thread_param->dpy = dpy;
-   thread_param->config = config;
-   thread_param->attribute = attribute;
-   thread_param->value = value;
+   thread_data->dpy = dpy;
+   thread_data->config = config;
+   thread_data->attribute = attribute;
+   thread_data->value = value;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glXGetFBConfigAttrib,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
@@ -683,7 +682,7 @@ typedef struct
    int return_value;
    unsigned int *count;
 
-} Thread_Command_glXGetVideoSync;
+} Evas_Thread_Command_glXGetVideoSync;
 
 int (*orig_evas_glXGetVideoSync)(unsigned int *count);
 
@@ -702,10 +701,10 @@ glXGetVideoSync_orig_evas_get(void)
 static void
 _gl_thread_glXGetVideoSync(void *data)
 {
-   Thread_Command_glXGetVideoSync *thread_param =
-      (Thread_Command_glXGetVideoSync *)data;
+   Evas_Thread_Command_glXGetVideoSync *thread_data =
+       (Evas_Thread_Command_glXGetVideoSync *)data;
 
-   thread_param->return_value = orig_evas_glXGetVideoSync(thread_param->count);
+   thread_data->return_value = orig_evas_glXGetVideoSync(thread_data->count);
 
 }
 
@@ -719,17 +718,17 @@ glXGetVideoSync_thread_cmd(unsigned int *count)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glXGetVideoSync thread_param_local;
-   Thread_Command_glXGetVideoSync *thread_param = &thread_param_local;
+   Evas_Thread_Command_glXGetVideoSync thread_data_local;
+   Evas_Thread_Command_glXGetVideoSync *thread_data = &thread_data_local;
 
-   thread_param->count = count;
+   thread_data->count = count;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glXGetVideoSync,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
@@ -743,16 +742,16 @@ typedef struct
    Display *dpy;
    GLXFBConfig config;
 
-} Thread_Command_glXGetVisualFromFBConfig;
+} Evas_Thread_Command_glXGetVisualFromFBConfig;
 
 static void
 _gl_thread_glXGetVisualFromFBConfig(void *data)
 {
-   Thread_Command_glXGetVisualFromFBConfig *thread_param =
-      (Thread_Command_glXGetVisualFromFBConfig *)data;
+   Evas_Thread_Command_glXGetVisualFromFBConfig *thread_data =
+       (Evas_Thread_Command_glXGetVisualFromFBConfig *)data;
 
-   thread_param->return_value = glXGetVisualFromFBConfig(thread_param->dpy,
-                                                         thread_param->config);
+   thread_data->return_value = glXGetVisualFromFBConfig(thread_data->dpy,
+                                                        thread_data->config);
 
 }
 
@@ -766,18 +765,18 @@ glXGetVisualFromFBConfig_thread_cmd(Display *dpy, GLXFBConfig config)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glXGetVisualFromFBConfig thread_param_local;
-   Thread_Command_glXGetVisualFromFBConfig *thread_param = &thread_param_local;
+   Evas_Thread_Command_glXGetVisualFromFBConfig thread_data_local;
+   Evas_Thread_Command_glXGetVisualFromFBConfig *thread_data = &thread_data_local;
 
-   thread_param->dpy = dpy;
-   thread_param->config = config;
+   thread_data->dpy = dpy;
+   thread_data->config = config;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glXGetVisualFromFBConfig,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
@@ -793,34 +792,28 @@ typedef struct
    GLXDrawable read;
    GLXContext ctx;
 
-} Thread_Command_glXMakeContextCurrent;
+} Evas_Thread_Command_glXMakeContextCurrent;
 
 
-GLXContext current_thread_ctx = NULL;
-GLXDrawable current_thread_draw = NULL;
-GLXDrawable current_thread_read = NULL;
+GLXContext  current_thread_ctx  = (GLXContext)0;
 
 static void
 _gl_thread_glXMakeContextCurrent(void *data)
 {
-   Thread_Command_glXMakeContextCurrent *thread_param =
-      (Thread_Command_glXMakeContextCurrent *)data;
+   Evas_Thread_Command_glXMakeContextCurrent *thread_data =
+       (Evas_Thread_Command_glXMakeContextCurrent *)data;
 
-   fprintf(stderr,"THREAD >> OTHER THREAD MAKECONTEXTCURRENT : (%p, %p, %p, %p)\n",
-                                 thread_param->dpy, (void *)thread_param->draw,
-                                 (void* )thread_param->read, thread_param->ctx);
+   DBG("THREAD >> OTHER THREAD MAKECONTEXTCURRENT : (%p, %p, %p, %p)\n",
+           thread_data->dpy, (void *)thread_data->draw,
+           (void* )thread_data->read, thread_data->ctx);
 
-   thread_param->return_value = glXMakeContextCurrent(thread_param->dpy,
-                                                      thread_param->draw,
-                                                      thread_param->read,
-                                                      thread_param->ctx);
+   thread_data->return_value = glXMakeContextCurrent(thread_data->dpy,
+                                                     thread_data->draw,
+                                                     thread_data->read,
+                                                     thread_data->ctx);
 
-   if (thread_param->return_value)
-     {
-        current_thread_ctx = thread_param->ctx;
-        current_thread_draw = thread_param->draw;
-        current_thread_read = thread_param->read;
-     }
+   if (thread_data->return_value)
+      current_thread_ctx = thread_data->ctx;
 
 }
 
@@ -832,27 +825,22 @@ glXMakeContextCurrent_thread_cmd(Display *dpy, GLXDrawable draw, GLXDrawable rea
         return glXMakeContextCurrent(dpy, draw, read, ctx);
      }
 
-   if (current_thread_ctx == ctx &&
-       current_thread_draw == draw &&
-       current_thread_read == read)
-      return True;
-
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glXMakeContextCurrent thread_param_local;
-   Thread_Command_glXMakeContextCurrent *thread_param = &thread_param_local;
+   Evas_Thread_Command_glXMakeContextCurrent thread_data_local;
+   Evas_Thread_Command_glXMakeContextCurrent *thread_data = &thread_data_local;
 
-   thread_param->dpy = dpy;
-   thread_param->draw = draw;
-   thread_param->read = read;
-   thread_param->ctx = ctx;
+   thread_data->dpy = dpy;
+   thread_data->draw = draw;
+   thread_data->read = read;
+   thread_data->ctx = ctx;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glXMakeContextCurrent,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
@@ -881,16 +869,16 @@ typedef struct
    Display *dpy;
    GLXContext ctx;
 
-} Thread_Command_glXDestroyContext;
+} Evas_Thread_Command_glXDestroyContext;
 
 static void
 _gl_thread_glXDestroyContext(void *data)
 {
-   Thread_Command_glXDestroyContext *thread_param =
-      (Thread_Command_glXDestroyContext *)data;
+   Evas_Thread_Command_glXDestroyContext *thread_data =
+       (Evas_Thread_Command_glXDestroyContext *)data;
 
-   glXDestroyContext(thread_param->dpy,
-                     thread_param->ctx);
+   glXDestroyContext(thread_data->dpy,
+                     thread_data->ctx);
 
 }
 
@@ -905,15 +893,15 @@ glXDestroyContext_thread_cmd(Display *dpy, GLXContext ctx)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glXDestroyContext thread_param_local;
-   Thread_Command_glXDestroyContext *thread_param = &thread_param_local;
+   Evas_Thread_Command_glXDestroyContext thread_data_local;
+   Evas_Thread_Command_glXDestroyContext *thread_data = &thread_data_local;
 
-   thread_param->dpy = dpy;
-   thread_param->ctx = ctx;
+   thread_data->dpy = dpy;
+   thread_data->ctx = ctx;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glXDestroyContext,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
@@ -930,7 +918,7 @@ typedef struct
    int attribute;
    unsigned int *value;
 
-} Thread_Command_glXQueryDrawable;
+} Evas_Thread_Command_glXQueryDrawable;
 
 void (*orig_evas_glXQueryDrawable)(Display *dpy, GLXDrawable draw, int attribute, unsigned int *value);
 
@@ -949,13 +937,13 @@ glXQueryDrawable_orig_evas_get(void)
 static void
 _gl_thread_glXQueryDrawable(void *data)
 {
-   Thread_Command_glXQueryDrawable *thread_param =
-      (Thread_Command_glXQueryDrawable *)data;
+   Evas_Thread_Command_glXQueryDrawable *thread_data =
+       (Evas_Thread_Command_glXQueryDrawable *)data;
 
-   orig_evas_glXQueryDrawable(thread_param->dpy,
-                              thread_param->draw,
-                              thread_param->attribute,
-                              thread_param->value);
+   orig_evas_glXQueryDrawable(thread_data->dpy,
+                              thread_data->draw,
+                              thread_data->attribute,
+                              thread_data->value);
 
 }
 
@@ -970,17 +958,17 @@ glXQueryDrawable_thread_cmd(Display *dpy, GLXDrawable draw, int attribute, unsig
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glXQueryDrawable thread_param_local;
-   Thread_Command_glXQueryDrawable *thread_param = &thread_param_local;
+   Evas_Thread_Command_glXQueryDrawable thread_data_local;
+   Evas_Thread_Command_glXQueryDrawable *thread_data = &thread_data_local;
 
-   thread_param->dpy = dpy;
-   thread_param->draw = draw;
-   thread_param->attribute = attribute;
-   thread_param->value = value;
+   thread_data->dpy = dpy;
+   thread_data->draw = draw;
+   thread_data->attribute = attribute;
+   thread_data->value = value;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glXQueryDrawable,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
@@ -996,17 +984,17 @@ typedef struct
    int *errorb;
    int *event;
 
-} Thread_Command_glXQueryExtension;
+} Evas_Thread_Command_glXQueryExtension;
 
 static void
 _gl_thread_glXQueryExtension(void *data)
 {
-   Thread_Command_glXQueryExtension *thread_param =
-      (Thread_Command_glXQueryExtension *)data;
+   Evas_Thread_Command_glXQueryExtension *thread_data =
+       (Evas_Thread_Command_glXQueryExtension *)data;
 
-   thread_param->return_value = glXQueryExtension(thread_param->dpy,
-                                                  thread_param->errorb,
-                                                  thread_param->event);
+   thread_data->return_value = glXQueryExtension(thread_data->dpy,
+                                                 thread_data->errorb,
+                                                 thread_data->event);
 
 }
 
@@ -1020,19 +1008,19 @@ glXQueryExtension_thread_cmd(Display *dpy, int *errorb, int *event)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glXQueryExtension thread_param_local;
-   Thread_Command_glXQueryExtension *thread_param = &thread_param_local;
+   Evas_Thread_Command_glXQueryExtension thread_data_local;
+   Evas_Thread_Command_glXQueryExtension *thread_data = &thread_data_local;
 
-   thread_param->dpy = dpy;
-   thread_param->errorb = errorb;
-   thread_param->event = event;
+   thread_data->dpy = dpy;
+   thread_data->errorb = errorb;
+   thread_data->event = event;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glXQueryExtension,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
@@ -1046,16 +1034,16 @@ typedef struct
    Display *dpy;
    int screen;
 
-} Thread_Command_glXQueryExtensionsString;
+} Evas_Thread_Command_glXQueryExtensionsString;
 
 static void
 _gl_thread_glXQueryExtensionsString(void *data)
 {
-   Thread_Command_glXQueryExtensionsString *thread_param =
-      (Thread_Command_glXQueryExtensionsString *)data;
+   Evas_Thread_Command_glXQueryExtensionsString *thread_data =
+       (Evas_Thread_Command_glXQueryExtensionsString *)data;
 
-   thread_param->return_value = glXQueryExtensionsString(thread_param->dpy,
-                                                         thread_param->screen);
+   thread_data->return_value = glXQueryExtensionsString(thread_data->dpy,
+                                                        thread_data->screen);
 
 }
 
@@ -1069,18 +1057,18 @@ glXQueryExtensionsString_thread_cmd(Display *dpy, int screen)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glXQueryExtensionsString thread_param_local;
-   Thread_Command_glXQueryExtensionsString *thread_param = &thread_param_local;
+   Evas_Thread_Command_glXQueryExtensionsString thread_data_local;
+   Evas_Thread_Command_glXQueryExtensionsString *thread_data = &thread_data_local;
 
-   thread_param->dpy = dpy;
-   thread_param->screen = screen;
+   thread_data->dpy = dpy;
+   thread_data->screen = screen;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glXQueryExtensionsString,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
@@ -1094,7 +1082,7 @@ typedef struct
    Display *dpy;
    GLXDrawable drawable;
 
-} Thread_Command_glXReleaseBuffersMESA;
+} Evas_Thread_Command_glXReleaseBuffersMESA;
 
 Bool (*orig_evas_glXReleaseBuffersMESA)(Display *dpy, GLXDrawable drawable);
 
@@ -1113,11 +1101,11 @@ glXReleaseBuffersMESA_orig_evas_get(void)
 static void
 _gl_thread_glXReleaseBuffersMESA(void *data)
 {
-   Thread_Command_glXReleaseBuffersMESA *thread_param =
-      (Thread_Command_glXReleaseBuffersMESA *)data;
+   Evas_Thread_Command_glXReleaseBuffersMESA *thread_data =
+       (Evas_Thread_Command_glXReleaseBuffersMESA *)data;
 
-   thread_param->return_value = orig_evas_glXReleaseBuffersMESA(thread_param->dpy,
-                                                                thread_param->drawable);
+   thread_data->return_value = orig_evas_glXReleaseBuffersMESA(thread_data->dpy,
+                                                               thread_data->drawable);
 
 }
 
@@ -1131,18 +1119,18 @@ glXReleaseBuffersMESA_thread_cmd(Display *dpy, GLXDrawable drawable)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glXReleaseBuffersMESA thread_param_local;
-   Thread_Command_glXReleaseBuffersMESA *thread_param = &thread_param_local;
+   Evas_Thread_Command_glXReleaseBuffersMESA thread_data_local;
+   Evas_Thread_Command_glXReleaseBuffersMESA *thread_data = &thread_data_local;
 
-   thread_param->dpy = dpy;
-   thread_param->drawable = drawable;
+   thread_data->dpy = dpy;
+   thread_data->drawable = drawable;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glXReleaseBuffersMESA,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
@@ -1156,7 +1144,7 @@ typedef struct
    GLXDrawable drawable;
    int buffer;
 
-} Thread_Command_glXReleaseTexImage;
+} Evas_Thread_Command_glXReleaseTexImage;
 
 void (*orig_evas_glXReleaseTexImage)(Display *dpy, GLXDrawable drawable, int buffer);
 
@@ -1175,12 +1163,12 @@ glXReleaseTexImage_orig_evas_get(void)
 static void
 _gl_thread_glXReleaseTexImage(void *data)
 {
-   Thread_Command_glXReleaseTexImage *thread_param =
-      (Thread_Command_glXReleaseTexImage *)data;
+   Evas_Thread_Command_glXReleaseTexImage *thread_data =
+       (Evas_Thread_Command_glXReleaseTexImage *)data;
 
-   orig_evas_glXReleaseTexImage(thread_param->dpy,
-                                thread_param->drawable,
-                                thread_param->buffer);
+   orig_evas_glXReleaseTexImage(thread_data->dpy,
+                                thread_data->drawable,
+                                thread_data->buffer);
 
 }
 
@@ -1195,16 +1183,16 @@ glXReleaseTexImage_thread_cmd(Display *dpy, GLXDrawable drawable, int buffer)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glXReleaseTexImage thread_param_local;
-   Thread_Command_glXReleaseTexImage *thread_param = &thread_param_local;
+   Evas_Thread_Command_glXReleaseTexImage thread_data_local;
+   Evas_Thread_Command_glXReleaseTexImage *thread_data = &thread_data_local;
 
-   thread_param->dpy = dpy;
-   thread_param->drawable = drawable;
-   thread_param->buffer = buffer;
+   thread_data->dpy = dpy;
+   thread_data->drawable = drawable;
+   thread_data->buffer = buffer;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glXReleaseTexImage,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
@@ -1218,16 +1206,16 @@ typedef struct
    Display *dpy;
    GLXDrawable drawable;
 
-} Thread_Command_glXSwapBuffers;
+} Evas_Thread_Command_glXSwapBuffers;
 
 static void
 _gl_thread_glXSwapBuffers(void *data)
 {
-   Thread_Command_glXSwapBuffers *thread_param =
-      (Thread_Command_glXSwapBuffers *)data;
+   Evas_Thread_Command_glXSwapBuffers *thread_data =
+       (Evas_Thread_Command_glXSwapBuffers *)data;
 
-   glXSwapBuffers(thread_param->dpy,
-                  thread_param->drawable);
+   glXSwapBuffers(thread_data->dpy,
+                  thread_data->drawable);
 
 }
 
@@ -1242,15 +1230,15 @@ glXSwapBuffers_thread_cmd(Display *dpy, GLXDrawable drawable)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glXSwapBuffers thread_param_local;
-   Thread_Command_glXSwapBuffers *thread_param = &thread_param_local;
+   Evas_Thread_Command_glXSwapBuffers thread_data_local;
+   Evas_Thread_Command_glXSwapBuffers *thread_data = &thread_data_local;
 
-   thread_param->dpy = dpy;
-   thread_param->drawable = drawable;
+   thread_data->dpy = dpy;
+   thread_data->drawable = drawable;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glXSwapBuffers,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
@@ -1265,7 +1253,7 @@ typedef struct
    GLXDrawable drawable;
    int interval;
 
-} Thread_Command_glXSwapIntervalEXT;
+} Evas_Thread_Command_glXSwapIntervalEXT;
 
 void (*orig_evas_glXSwapIntervalEXT)(Display *dpy, GLXDrawable drawable, int interval);
 
@@ -1284,12 +1272,12 @@ glXSwapIntervalEXT_orig_evas_get(void)
 static void
 _gl_thread_glXSwapIntervalEXT(void *data)
 {
-   Thread_Command_glXSwapIntervalEXT *thread_param =
-      (Thread_Command_glXSwapIntervalEXT *)data;
+   Evas_Thread_Command_glXSwapIntervalEXT *thread_data =
+       (Evas_Thread_Command_glXSwapIntervalEXT *)data;
 
-   orig_evas_glXSwapIntervalEXT(thread_param->dpy,
-                                thread_param->drawable,
-                                thread_param->interval);
+   orig_evas_glXSwapIntervalEXT(thread_data->dpy,
+                                thread_data->drawable,
+                                thread_data->interval);
 
 }
 
@@ -1304,16 +1292,16 @@ glXSwapIntervalEXT_thread_cmd(Display *dpy, GLXDrawable drawable, int interval)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glXSwapIntervalEXT thread_param_local;
-   Thread_Command_glXSwapIntervalEXT *thread_param = &thread_param_local;
+   Evas_Thread_Command_glXSwapIntervalEXT thread_data_local;
+   Evas_Thread_Command_glXSwapIntervalEXT *thread_data = &thread_data_local;
 
-   thread_param->dpy = dpy;
-   thread_param->drawable = drawable;
-   thread_param->interval = interval;
+   thread_data->dpy = dpy;
+   thread_data->drawable = drawable;
+   thread_data->interval = interval;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glXSwapIntervalEXT,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
@@ -1327,7 +1315,7 @@ typedef struct
    int return_value;
    int interval;
 
-} Thread_Command_glXSwapIntervalSGI;
+} Evas_Thread_Command_glXSwapIntervalSGI;
 
 int (*orig_evas_glXSwapIntervalSGI)(int interval);
 
@@ -1346,10 +1334,10 @@ glXSwapIntervalSGI_orig_evas_get(void)
 static void
 _gl_thread_glXSwapIntervalSGI(void *data)
 {
-   Thread_Command_glXSwapIntervalSGI *thread_param =
-      (Thread_Command_glXSwapIntervalSGI *)data;
+   Evas_Thread_Command_glXSwapIntervalSGI *thread_data =
+       (Evas_Thread_Command_glXSwapIntervalSGI *)data;
 
-   thread_param->return_value = orig_evas_glXSwapIntervalSGI(thread_param->interval);
+   thread_data->return_value = orig_evas_glXSwapIntervalSGI(thread_data->interval);
 
 }
 
@@ -1363,17 +1351,17 @@ glXSwapIntervalSGI_thread_cmd(int interval)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glXSwapIntervalSGI thread_param_local;
-   Thread_Command_glXSwapIntervalSGI *thread_param = &thread_param_local;
+   Evas_Thread_Command_glXSwapIntervalSGI thread_data_local;
+   Evas_Thread_Command_glXSwapIntervalSGI *thread_data = &thread_data_local;
 
-   thread_param->interval = interval;
+   thread_data->interval = interval;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glXSwapIntervalSGI,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
@@ -1388,7 +1376,7 @@ typedef struct
    int remainder;
    unsigned int *count;
 
-} Thread_Command_glXWaitVideoSync;
+} Evas_Thread_Command_glXWaitVideoSync;
 
 int (*orig_evas_glXWaitVideoSync)(int divisor, int remainder, unsigned int *count);
 
@@ -1407,12 +1395,12 @@ glXWaitVideoSync_orig_evas_get(void)
 static void
 _gl_thread_glXWaitVideoSync(void *data)
 {
-   Thread_Command_glXWaitVideoSync *thread_param =
-      (Thread_Command_glXWaitVideoSync *)data;
+   Evas_Thread_Command_glXWaitVideoSync *thread_data =
+       (Evas_Thread_Command_glXWaitVideoSync *)data;
 
-   thread_param->return_value = orig_evas_glXWaitVideoSync(thread_param->divisor,
-                                                           thread_param->remainder,
-                                                           thread_param->count);
+   thread_data->return_value = orig_evas_glXWaitVideoSync(thread_data->divisor,
+                                                          thread_data->remainder,
+                                                          thread_data->count);
 
 }
 
@@ -1426,19 +1414,19 @@ glXWaitVideoSync_thread_cmd(int divisor, int remainder, unsigned int *count)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   Thread_Command_glXWaitVideoSync thread_param_local;
-   Thread_Command_glXWaitVideoSync *thread_param = &thread_param_local;
+   Evas_Thread_Command_glXWaitVideoSync thread_data_local;
+   Evas_Thread_Command_glXWaitVideoSync *thread_data = &thread_data_local;
 
-   thread_param->divisor = divisor;
-   thread_param->remainder = remainder;
-   thread_param->count = count;
+   thread_data->divisor = divisor;
+   thread_data->remainder = remainder;
+   thread_data->count = count;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
                               _gl_thread_glXWaitVideoSync,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /****** EVAS GL ******/
@@ -1473,13 +1461,13 @@ glXBindTexImage_orig_evgl_get(void)
 static void
 _evgl_thread_glXBindTexImage(void *data)
 {
-   EVGL_Thread_Command_glXBindTexImage *thread_param =
-      (EVGL_Thread_Command_glXBindTexImage *)data;
+   EVGL_Thread_Command_glXBindTexImage *thread_data =
+       (EVGL_Thread_Command_glXBindTexImage *)data;
 
-   orig_evgl_glXBindTexImage(thread_param->dpy,
-                             thread_param->drawable,
-                             thread_param->buffer,
-                             thread_param->attrib_list);
+   orig_evgl_glXBindTexImage(thread_data->dpy,
+                             thread_data->drawable,
+                             thread_data->buffer,
+                             thread_data->attrib_list);
 
 }
 
@@ -1494,17 +1482,17 @@ glXBindTexImage_evgl_thread_cmd(Display *dpy, GLXDrawable drawable, int buffer,
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glXBindTexImage thread_param_local;
-   EVGL_Thread_Command_glXBindTexImage *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glXBindTexImage thread_data_local;
+   EVGL_Thread_Command_glXBindTexImage *thread_data = &thread_data_local;
 
-   thread_param->dpy = dpy;
-   thread_param->drawable = drawable;
-   thread_param->buffer = buffer;
-   thread_param->attrib_list = attrib_list;
+   thread_data->dpy = dpy;
+   thread_data->drawable = drawable;
+   thread_data->buffer = buffer;
+   thread_data->attrib_list = attrib_list;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glXBindTexImage,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
@@ -1526,13 +1514,13 @@ typedef struct
 static void
 _evgl_thread_glXChooseFBConfig(void *data)
 {
-   EVGL_Thread_Command_glXChooseFBConfig *thread_param =
-      (EVGL_Thread_Command_glXChooseFBConfig *)data;
+   EVGL_Thread_Command_glXChooseFBConfig *thread_data =
+       (EVGL_Thread_Command_glXChooseFBConfig *)data;
 
-   thread_param->return_value = glXChooseFBConfig(thread_param->dpy,
-                                                  thread_param->screen,
-                                                  thread_param->attribList,
-                                                  thread_param->nitems);
+   thread_data->return_value = glXChooseFBConfig(thread_data->dpy,
+                                                 thread_data->screen,
+                                                 thread_data->attribList,
+                                                 thread_data->nitems);
 
 }
 
@@ -1546,20 +1534,20 @@ glXChooseFBConfig_evgl_thread_cmd(Display *dpy, int screen, const int *attribLis
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glXChooseFBConfig thread_param_local;
-   EVGL_Thread_Command_glXChooseFBConfig *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glXChooseFBConfig thread_data_local;
+   EVGL_Thread_Command_glXChooseFBConfig *thread_data = &thread_data_local;
 
-   thread_param->dpy = dpy;
-   thread_param->screen = screen;
-   thread_param->attribList = attribList;
-   thread_param->nitems = nitems;
+   thread_data->dpy = dpy;
+   thread_data->screen = screen;
+   thread_data->attribList = attribList;
+   thread_data->nitems = nitems;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glXChooseFBConfig,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
@@ -1580,13 +1568,13 @@ typedef struct
 static void
 _evgl_thread_glXCreateContext(void *data)
 {
-   EVGL_Thread_Command_glXCreateContext *thread_param =
-      (EVGL_Thread_Command_glXCreateContext *)data;
+   EVGL_Thread_Command_glXCreateContext *thread_data =
+       (EVGL_Thread_Command_glXCreateContext *)data;
 
-   thread_param->return_value = glXCreateContext(thread_param->dpy,
-                                                 thread_param->vis,
-                                                 thread_param->shareList,
-                                                 thread_param->direct);
+   thread_data->return_value = glXCreateContext(thread_data->dpy,
+                                                thread_data->vis,
+                                                thread_data->shareList,
+                                                thread_data->direct);
 
 }
 
@@ -1600,20 +1588,20 @@ glXCreateContext_evgl_thread_cmd(Display *dpy, XVisualInfo *vis, GLXContext shar
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glXCreateContext thread_param_local;
-   EVGL_Thread_Command_glXCreateContext *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glXCreateContext thread_data_local;
+   EVGL_Thread_Command_glXCreateContext *thread_data = &thread_data_local;
 
-   thread_param->dpy = dpy;
-   thread_param->vis = vis;
-   thread_param->shareList = shareList;
-   thread_param->direct = direct;
+   thread_data->dpy = dpy;
+   thread_data->vis = vis;
+   thread_data->shareList = shareList;
+   thread_data->direct = direct;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glXCreateContext,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
@@ -1635,14 +1623,14 @@ typedef struct
 static void
 _evgl_thread_glXCreateNewContext(void *data)
 {
-   EVGL_Thread_Command_glXCreateNewContext *thread_param =
-      (EVGL_Thread_Command_glXCreateNewContext *)data;
+   EVGL_Thread_Command_glXCreateNewContext *thread_data =
+       (EVGL_Thread_Command_glXCreateNewContext *)data;
 
-   thread_param->return_value = glXCreateNewContext(thread_param->dpy,
-                                                    thread_param->config,
-                                                    thread_param->renderType,
-                                                    thread_param->shareList,
-                                                    thread_param->direct);
+   thread_data->return_value = glXCreateNewContext(thread_data->dpy,
+                                                   thread_data->config,
+                                                   thread_data->renderType,
+                                                   thread_data->shareList,
+                                                   thread_data->direct);
 
 }
 
@@ -1656,21 +1644,21 @@ glXCreateNewContext_evgl_thread_cmd(Display *dpy, GLXFBConfig config, int render
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glXCreateNewContext thread_param_local;
-   EVGL_Thread_Command_glXCreateNewContext *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glXCreateNewContext thread_data_local;
+   EVGL_Thread_Command_glXCreateNewContext *thread_data = &thread_data_local;
 
-   thread_param->dpy = dpy;
-   thread_param->config = config;
-   thread_param->renderType = renderType;
-   thread_param->shareList = shareList;
-   thread_param->direct = direct;
+   thread_data->dpy = dpy;
+   thread_data->config = config;
+   thread_data->renderType = renderType;
+   thread_data->shareList = shareList;
+   thread_data->direct = direct;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glXCreateNewContext,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
@@ -1690,12 +1678,12 @@ typedef struct
 static void
 _evgl_thread_glXCreatePbuffer(void *data)
 {
-   EVGL_Thread_Command_glXCreatePbuffer *thread_param =
-      (EVGL_Thread_Command_glXCreatePbuffer *)data;
+   EVGL_Thread_Command_glXCreatePbuffer *thread_data =
+       (EVGL_Thread_Command_glXCreatePbuffer *)data;
 
-   thread_param->return_value = glXCreatePbuffer(thread_param->dpy,
-                                                 thread_param->config,
-                                                 thread_param->attribList);
+   thread_data->return_value = glXCreatePbuffer(thread_data->dpy,
+                                                thread_data->config,
+                                                thread_data->attribList);
 
 }
 
@@ -1709,19 +1697,19 @@ glXCreatePbuffer_evgl_thread_cmd(Display *dpy, GLXFBConfig config, const int *at
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glXCreatePbuffer thread_param_local;
-   EVGL_Thread_Command_glXCreatePbuffer *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glXCreatePbuffer thread_data_local;
+   EVGL_Thread_Command_glXCreatePbuffer *thread_data = &thread_data_local;
 
-   thread_param->dpy = dpy;
-   thread_param->config = config;
-   thread_param->attribList = attribList;
+   thread_data->dpy = dpy;
+   thread_data->config = config;
+   thread_data->attribList = attribList;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glXCreatePbuffer,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
@@ -1756,13 +1744,13 @@ glXCreatePixmap_orig_evgl_get(void)
 static void
 _evgl_thread_glXCreatePixmap(void *data)
 {
-   EVGL_Thread_Command_glXCreatePixmap *thread_param =
-      (EVGL_Thread_Command_glXCreatePixmap *)data;
+   EVGL_Thread_Command_glXCreatePixmap *thread_data =
+       (EVGL_Thread_Command_glXCreatePixmap *)data;
 
-   thread_param->return_value = orig_evgl_glXCreatePixmap(thread_param->dpy,
-                                                          thread_param->config,
-                                                          thread_param->pixmap,
-                                                          thread_param->attribList);
+   thread_data->return_value = orig_evgl_glXCreatePixmap(thread_data->dpy,
+                                                         thread_data->config,
+                                                         thread_data->pixmap,
+                                                         thread_data->attribList);
 
 }
 
@@ -1776,20 +1764,20 @@ glXCreatePixmap_evgl_thread_cmd(Display *dpy, GLXFBConfig config, Pixmap pixmap,
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glXCreatePixmap thread_param_local;
-   EVGL_Thread_Command_glXCreatePixmap *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glXCreatePixmap thread_data_local;
+   EVGL_Thread_Command_glXCreatePixmap *thread_data = &thread_data_local;
 
-   thread_param->dpy = dpy;
-   thread_param->config = config;
-   thread_param->pixmap = pixmap;
-   thread_param->attribList = attribList;
+   thread_data->dpy = dpy;
+   thread_data->config = config;
+   thread_data->pixmap = pixmap;
+   thread_data->attribList = attribList;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glXCreatePixmap,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
@@ -1810,13 +1798,13 @@ typedef struct
 static void
 _evgl_thread_glXCreateWindow(void *data)
 {
-   EVGL_Thread_Command_glXCreateWindow *thread_param =
-      (EVGL_Thread_Command_glXCreateWindow *)data;
+   EVGL_Thread_Command_glXCreateWindow *thread_data =
+       (EVGL_Thread_Command_glXCreateWindow *)data;
 
-   thread_param->return_value = glXCreateWindow(thread_param->dpy,
-                                                thread_param->config,
-                                                thread_param->win,
-                                                thread_param->attribList);
+   thread_data->return_value = glXCreateWindow(thread_data->dpy,
+                                               thread_data->config,
+                                               thread_data->win,
+                                               thread_data->attribList);
 
 }
 
@@ -1830,20 +1818,20 @@ glXCreateWindow_evgl_thread_cmd(Display *dpy, GLXFBConfig config, Window win, co
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glXCreateWindow thread_param_local;
-   EVGL_Thread_Command_glXCreateWindow *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glXCreateWindow thread_data_local;
+   EVGL_Thread_Command_glXCreateWindow *thread_data = &thread_data_local;
 
-   thread_param->dpy = dpy;
-   thread_param->config = config;
-   thread_param->win = win;
-   thread_param->attribList = attribList;
+   thread_data->dpy = dpy;
+   thread_data->config = config;
+   thread_data->win = win;
+   thread_data->attribList = attribList;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glXCreateWindow,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
@@ -1861,11 +1849,11 @@ typedef struct
 static void
 _evgl_thread_glXDestroyContext(void *data)
 {
-   EVGL_Thread_Command_glXDestroyContext *thread_param =
-      (EVGL_Thread_Command_glXDestroyContext *)data;
+   EVGL_Thread_Command_glXDestroyContext *thread_data =
+       (EVGL_Thread_Command_glXDestroyContext *)data;
 
-   glXDestroyContext(thread_param->dpy,
-                     thread_param->ctx);
+   glXDestroyContext(thread_data->dpy,
+                     thread_data->ctx);
 
 }
 
@@ -1880,15 +1868,15 @@ glXDestroyContext_evgl_thread_cmd(Display *dpy, GLXContext ctx)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glXDestroyContext thread_param_local;
-   EVGL_Thread_Command_glXDestroyContext *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glXDestroyContext thread_data_local;
+   EVGL_Thread_Command_glXDestroyContext *thread_data = &thread_data_local;
 
-   thread_param->dpy = dpy;
-   thread_param->ctx = ctx;
+   thread_data->dpy = dpy;
+   thread_data->ctx = ctx;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glXDestroyContext,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
@@ -1907,11 +1895,11 @@ typedef struct
 static void
 _evgl_thread_glXDestroyPbuffer(void *data)
 {
-   EVGL_Thread_Command_glXDestroyPbuffer *thread_param =
-      (EVGL_Thread_Command_glXDestroyPbuffer *)data;
+   EVGL_Thread_Command_glXDestroyPbuffer *thread_data =
+       (EVGL_Thread_Command_glXDestroyPbuffer *)data;
 
-   glXDestroyPbuffer(thread_param->dpy,
-                     thread_param->pbuf);
+   glXDestroyPbuffer(thread_data->dpy,
+                     thread_data->pbuf);
 
 }
 
@@ -1926,15 +1914,15 @@ glXDestroyPbuffer_evgl_thread_cmd(Display *dpy, GLXPbuffer pbuf)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glXDestroyPbuffer thread_param_local;
-   EVGL_Thread_Command_glXDestroyPbuffer *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glXDestroyPbuffer thread_data_local;
+   EVGL_Thread_Command_glXDestroyPbuffer *thread_data = &thread_data_local;
 
-   thread_param->dpy = dpy;
-   thread_param->pbuf = pbuf;
+   thread_data->dpy = dpy;
+   thread_data->pbuf = pbuf;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glXDestroyPbuffer,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
@@ -1967,11 +1955,11 @@ glXDestroyPixmap_orig_evgl_get(void)
 static void
 _evgl_thread_glXDestroyPixmap(void *data)
 {
-   EVGL_Thread_Command_glXDestroyPixmap *thread_param =
-      (EVGL_Thread_Command_glXDestroyPixmap *)data;
+   EVGL_Thread_Command_glXDestroyPixmap *thread_data =
+       (EVGL_Thread_Command_glXDestroyPixmap *)data;
 
-   orig_evgl_glXDestroyPixmap(thread_param->dpy,
-                              thread_param->pixmap);
+   orig_evgl_glXDestroyPixmap(thread_data->dpy,
+                              thread_data->pixmap);
 
 }
 
@@ -1986,15 +1974,15 @@ glXDestroyPixmap_evgl_thread_cmd(Display *dpy, GLXPixmap pixmap)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glXDestroyPixmap thread_param_local;
-   EVGL_Thread_Command_glXDestroyPixmap *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glXDestroyPixmap thread_data_local;
+   EVGL_Thread_Command_glXDestroyPixmap *thread_data = &thread_data_local;
 
-   thread_param->dpy = dpy;
-   thread_param->pixmap = pixmap;
+   thread_data->dpy = dpy;
+   thread_data->pixmap = pixmap;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glXDestroyPixmap,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
@@ -2013,11 +2001,11 @@ typedef struct
 static void
 _evgl_thread_glXDestroyWindow(void *data)
 {
-   EVGL_Thread_Command_glXDestroyWindow *thread_param =
-      (EVGL_Thread_Command_glXDestroyWindow *)data;
+   EVGL_Thread_Command_glXDestroyWindow *thread_data =
+       (EVGL_Thread_Command_glXDestroyWindow *)data;
 
-   glXDestroyWindow(thread_param->dpy,
-                    thread_param->window);
+   glXDestroyWindow(thread_data->dpy,
+                    thread_data->window);
 
 }
 
@@ -2032,15 +2020,15 @@ glXDestroyWindow_evgl_thread_cmd(Display *dpy, GLXWindow window)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glXDestroyWindow thread_param_local;
-   EVGL_Thread_Command_glXDestroyWindow *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glXDestroyWindow thread_data_local;
+   EVGL_Thread_Command_glXDestroyWindow *thread_data = &thread_data_local;
 
-   thread_param->dpy = dpy;
-   thread_param->window = window;
+   thread_data->dpy = dpy;
+   thread_data->window = window;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glXDestroyWindow,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
@@ -2062,13 +2050,13 @@ typedef struct
 static void
 _evgl_thread_glXGetConfig(void *data)
 {
-   EVGL_Thread_Command_glXGetConfig *thread_param =
-      (EVGL_Thread_Command_glXGetConfig *)data;
+   EVGL_Thread_Command_glXGetConfig *thread_data =
+       (EVGL_Thread_Command_glXGetConfig *)data;
 
-   thread_param->return_value = glXGetConfig(thread_param->dpy,
-                                             thread_param->visual,
-                                             thread_param->attrib,
-                                             thread_param->value);
+   thread_data->return_value = glXGetConfig(thread_data->dpy,
+                                            thread_data->visual,
+                                            thread_data->attrib,
+                                            thread_data->value);
 
 }
 
@@ -2082,20 +2070,20 @@ glXGetConfig_evgl_thread_cmd(Display *dpy, XVisualInfo *visual, int attrib, int
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glXGetConfig thread_param_local;
-   EVGL_Thread_Command_glXGetConfig *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glXGetConfig thread_data_local;
+   EVGL_Thread_Command_glXGetConfig *thread_data = &thread_data_local;
 
-   thread_param->dpy = dpy;
-   thread_param->visual = visual;
-   thread_param->attrib = attrib;
-   thread_param->value = value;
+   thread_data->dpy = dpy;
+   thread_data->visual = visual;
+   thread_data->attrib = attrib;
+   thread_data->value = value;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glXGetConfig,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
@@ -2116,13 +2104,13 @@ typedef struct
 static void
 _evgl_thread_glXGetFBConfigAttrib(void *data)
 {
-   EVGL_Thread_Command_glXGetFBConfigAttrib *thread_param =
-      (EVGL_Thread_Command_glXGetFBConfigAttrib *)data;
+   EVGL_Thread_Command_glXGetFBConfigAttrib *thread_data =
+       (EVGL_Thread_Command_glXGetFBConfigAttrib *)data;
 
-   thread_param->return_value = glXGetFBConfigAttrib(thread_param->dpy,
-                                                     thread_param->config,
-                                                     thread_param->attribute,
-                                                     thread_param->value);
+   thread_data->return_value = glXGetFBConfigAttrib(thread_data->dpy,
+                                                    thread_data->config,
+                                                    thread_data->attribute,
+                                                    thread_data->value);
 
 }
 
@@ -2136,20 +2124,20 @@ glXGetFBConfigAttrib_evgl_thread_cmd(Display *dpy, GLXFBConfig config, int attri
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glXGetFBConfigAttrib thread_param_local;
-   EVGL_Thread_Command_glXGetFBConfigAttrib *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glXGetFBConfigAttrib thread_data_local;
+   EVGL_Thread_Command_glXGetFBConfigAttrib *thread_data = &thread_data_local;
 
-   thread_param->dpy = dpy;
-   thread_param->config = config;
-   thread_param->attribute = attribute;
-   thread_param->value = value;
+   thread_data->dpy = dpy;
+   thread_data->config = config;
+   thread_data->attribute = attribute;
+   thread_data->value = value;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glXGetFBConfigAttrib,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
@@ -2181,10 +2169,10 @@ glXGetVideoSync_orig_evgl_get(void)
 static void
 _evgl_thread_glXGetVideoSync(void *data)
 {
-   EVGL_Thread_Command_glXGetVideoSync *thread_param =
-      (EVGL_Thread_Command_glXGetVideoSync *)data;
+   EVGL_Thread_Command_glXGetVideoSync *thread_data =
+       (EVGL_Thread_Command_glXGetVideoSync *)data;
 
-   thread_param->return_value = orig_evgl_glXGetVideoSync(thread_param->count);
+   thread_data->return_value = orig_evgl_glXGetVideoSync(thread_data->count);
 
 }
 
@@ -2198,17 +2186,17 @@ glXGetVideoSync_evgl_thread_cmd(unsigned int *count)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glXGetVideoSync thread_param_local;
-   EVGL_Thread_Command_glXGetVideoSync *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glXGetVideoSync thread_data_local;
+   EVGL_Thread_Command_glXGetVideoSync *thread_data = &thread_data_local;
 
-   thread_param->count = count;
+   thread_data->count = count;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glXGetVideoSync,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
@@ -2227,11 +2215,11 @@ typedef struct
 static void
 _evgl_thread_glXGetVisualFromFBConfig(void *data)
 {
-   EVGL_Thread_Command_glXGetVisualFromFBConfig *thread_param =
-      (EVGL_Thread_Command_glXGetVisualFromFBConfig *)data;
+   EVGL_Thread_Command_glXGetVisualFromFBConfig *thread_data =
+       (EVGL_Thread_Command_glXGetVisualFromFBConfig *)data;
 
-   thread_param->return_value = glXGetVisualFromFBConfig(thread_param->dpy,
-                                                         thread_param->config);
+   thread_data->return_value = glXGetVisualFromFBConfig(thread_data->dpy,
+                                                        thread_data->config);
 
 }
 
@@ -2245,18 +2233,18 @@ glXGetVisualFromFBConfig_evgl_thread_cmd(Display *dpy, GLXFBConfig config)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glXGetVisualFromFBConfig thread_param_local;
-   EVGL_Thread_Command_glXGetVisualFromFBConfig *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glXGetVisualFromFBConfig thread_data_local;
+   EVGL_Thread_Command_glXGetVisualFromFBConfig *thread_data = &thread_data_local;
 
-   thread_param->dpy = dpy;
-   thread_param->config = config;
+   thread_data->dpy = dpy;
+   thread_data->config = config;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glXGetVisualFromFBConfig,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
@@ -2274,31 +2262,25 @@ typedef struct
 
 } EVGL_Thread_Command_glXMakeContextCurrent;
 
-GLXContext current_evgl_thread_ctx = NULL;
-GLXDrawable current_evgl_thread_draw = NULL;
-GLXDrawable current_evgl_thread_read = NULL;
+GLXContext  current_evgl_thread_ctx  = (GLXContext)0;
 
 static void
 _evgl_thread_glXMakeContextCurrent(void *data)
 {
-   EVGL_Thread_Command_glXMakeContextCurrent *thread_param =
-      (EVGL_Thread_Command_glXMakeContextCurrent *)data;
+   EVGL_Thread_Command_glXMakeContextCurrent *thread_data =
+       (EVGL_Thread_Command_glXMakeContextCurrent *)data;
 
-   fprintf(stderr,"EVGL THREAD >> OTHER THREAD MAKECONTEXTCURRENT : (%p, %p, %p, %p)\n",
-                                 thread_param->dpy, (void *)thread_param->draw,
-                                 (void* )thread_param->read, thread_param->ctx);
+   DBG("EVGL THREAD >> OTHER THREAD MAKECONTEXTCURRENT : (%p, %p, %p, %p)\n",
+           thread_data->dpy, (void *)thread_data->draw,
+           (void* )thread_data->read, thread_data->ctx);
 
-   thread_param->return_value = glXMakeContextCurrent(thread_param->dpy,
-                                                      thread_param->draw,
-                                                      thread_param->read,
-                                                      thread_param->ctx);
+   thread_data->return_value = glXMakeContextCurrent(thread_data->dpy,
+                                                     thread_data->draw,
+                                                     thread_data->read,
+                                                     thread_data->ctx);
 
-   if (thread_param->return_value)
-     {
-        current_evgl_thread_ctx = thread_param->ctx;
-        current_evgl_thread_draw = thread_param->draw;
-        current_evgl_thread_read = thread_param->read;
-     }
+   if (thread_data->return_value)
+      current_evgl_thread_ctx = thread_data->ctx;
 
 }
 
@@ -2310,27 +2292,22 @@ glXMakeContextCurrent_evgl_thread_cmd(Display *dpy, GLXDrawable draw, GLXDrawabl
         return glXMakeContextCurrent(dpy, draw, read, ctx);
      }
 
-   if (current_evgl_thread_ctx == ctx &&
-       current_evgl_thread_draw == draw &&
-       current_evgl_thread_read == read)
-      return True;
-
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glXMakeContextCurrent thread_param_local;
-   EVGL_Thread_Command_glXMakeContextCurrent *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glXMakeContextCurrent thread_data_local;
+   EVGL_Thread_Command_glXMakeContextCurrent *thread_data = &thread_data_local;
 
-   thread_param->dpy = dpy;
-   thread_param->draw = draw;
-   thread_param->read = read;
-   thread_param->ctx = ctx;
+   thread_data->dpy = dpy;
+   thread_data->draw = draw;
+   thread_data->read = read;
+   thread_data->ctx = ctx;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glXMakeContextCurrent,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
@@ -2381,13 +2358,13 @@ glXQueryDrawable_orig_evgl_get(void)
 static void
 _evgl_thread_glXQueryDrawable(void *data)
 {
-   EVGL_Thread_Command_glXQueryDrawable *thread_param =
-      (EVGL_Thread_Command_glXQueryDrawable *)data;
+   EVGL_Thread_Command_glXQueryDrawable *thread_data =
+       (EVGL_Thread_Command_glXQueryDrawable *)data;
 
-   orig_evgl_glXQueryDrawable(thread_param->dpy,
-                              thread_param->draw,
-                              thread_param->attribute,
-                              thread_param->value);
+   orig_evgl_glXQueryDrawable(thread_data->dpy,
+                              thread_data->draw,
+                              thread_data->attribute,
+                              thread_data->value);
 
 }
 
@@ -2402,17 +2379,17 @@ glXQueryDrawable_evgl_thread_cmd(Display *dpy, GLXDrawable draw, int attribute,
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glXQueryDrawable thread_param_local;
-   EVGL_Thread_Command_glXQueryDrawable *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glXQueryDrawable thread_data_local;
+   EVGL_Thread_Command_glXQueryDrawable *thread_data = &thread_data_local;
 
-   thread_param->dpy = dpy;
-   thread_param->draw = draw;
-   thread_param->attribute = attribute;
-   thread_param->value = value;
+   thread_data->dpy = dpy;
+   thread_data->draw = draw;
+   thread_data->attribute = attribute;
+   thread_data->value = value;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glXQueryDrawable,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
@@ -2433,12 +2410,12 @@ typedef struct
 static void
 _evgl_thread_glXQueryExtension(void *data)
 {
-   EVGL_Thread_Command_glXQueryExtension *thread_param =
-      (EVGL_Thread_Command_glXQueryExtension *)data;
+   EVGL_Thread_Command_glXQueryExtension *thread_data =
+       (EVGL_Thread_Command_glXQueryExtension *)data;
 
-   thread_param->return_value = glXQueryExtension(thread_param->dpy,
-                                                  thread_param->errorb,
-                                                  thread_param->event);
+   thread_data->return_value = glXQueryExtension(thread_data->dpy,
+                                                 thread_data->errorb,
+                                                 thread_data->event);
 
 }
 
@@ -2452,19 +2429,19 @@ glXQueryExtension_evgl_thread_cmd(Display *dpy, int *errorb, int *event)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glXQueryExtension thread_param_local;
-   EVGL_Thread_Command_glXQueryExtension *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glXQueryExtension thread_data_local;
+   EVGL_Thread_Command_glXQueryExtension *thread_data = &thread_data_local;
 
-   thread_param->dpy = dpy;
-   thread_param->errorb = errorb;
-   thread_param->event = event;
+   thread_data->dpy = dpy;
+   thread_data->errorb = errorb;
+   thread_data->event = event;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glXQueryExtension,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
@@ -2483,11 +2460,11 @@ typedef struct
 static void
 _evgl_thread_glXQueryExtensionsString(void *data)
 {
-   EVGL_Thread_Command_glXQueryExtensionsString *thread_param =
-      (EVGL_Thread_Command_glXQueryExtensionsString *)data;
+   EVGL_Thread_Command_glXQueryExtensionsString *thread_data =
+       (EVGL_Thread_Command_glXQueryExtensionsString *)data;
 
-   thread_param->return_value = glXQueryExtensionsString(thread_param->dpy,
-                                                         thread_param->screen);
+   thread_data->return_value = glXQueryExtensionsString(thread_data->dpy,
+                                                        thread_data->screen);
 
 }
 
@@ -2501,18 +2478,18 @@ glXQueryExtensionsString_evgl_thread_cmd(Display *dpy, int screen)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glXQueryExtensionsString thread_param_local;
-   EVGL_Thread_Command_glXQueryExtensionsString *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glXQueryExtensionsString thread_data_local;
+   EVGL_Thread_Command_glXQueryExtensionsString *thread_data = &thread_data_local;
 
-   thread_param->dpy = dpy;
-   thread_param->screen = screen;
+   thread_data->dpy = dpy;
+   thread_data->screen = screen;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glXQueryExtensionsString,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
@@ -2545,11 +2522,11 @@ glXReleaseBuffersMESA_orig_evgl_get(void)
 static void
 _evgl_thread_glXReleaseBuffersMESA(void *data)
 {
-   EVGL_Thread_Command_glXReleaseBuffersMESA *thread_param =
-      (EVGL_Thread_Command_glXReleaseBuffersMESA *)data;
+   EVGL_Thread_Command_glXReleaseBuffersMESA *thread_data =
+       (EVGL_Thread_Command_glXReleaseBuffersMESA *)data;
 
-   thread_param->return_value = orig_evgl_glXReleaseBuffersMESA(thread_param->dpy,
-                                                                thread_param->drawable);
+   thread_data->return_value = orig_evgl_glXReleaseBuffersMESA(thread_data->dpy,
+                                                               thread_data->drawable);
 
 }
 
@@ -2563,18 +2540,18 @@ glXReleaseBuffersMESA_evgl_thread_cmd(Display *dpy, GLXDrawable drawable)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glXReleaseBuffersMESA thread_param_local;
-   EVGL_Thread_Command_glXReleaseBuffersMESA *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glXReleaseBuffersMESA thread_data_local;
+   EVGL_Thread_Command_glXReleaseBuffersMESA *thread_data = &thread_data_local;
 
-   thread_param->dpy = dpy;
-   thread_param->drawable = drawable;
+   thread_data->dpy = dpy;
+   thread_data->drawable = drawable;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glXReleaseBuffersMESA,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
@@ -2607,12 +2584,12 @@ glXReleaseTexImage_orig_evgl_get(void)
 static void
 _evgl_thread_glXReleaseTexImage(void *data)
 {
-   EVGL_Thread_Command_glXReleaseTexImage *thread_param =
-      (EVGL_Thread_Command_glXReleaseTexImage *)data;
+   EVGL_Thread_Command_glXReleaseTexImage *thread_data =
+       (EVGL_Thread_Command_glXReleaseTexImage *)data;
 
-   orig_evgl_glXReleaseTexImage(thread_param->dpy,
-                                thread_param->drawable,
-                                thread_param->buffer);
+   orig_evgl_glXReleaseTexImage(thread_data->dpy,
+                                thread_data->drawable,
+                                thread_data->buffer);
 
 }
 
@@ -2627,16 +2604,16 @@ glXReleaseTexImage_evgl_thread_cmd(Display *dpy, GLXDrawable drawable, int buffe
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glXReleaseTexImage thread_param_local;
-   EVGL_Thread_Command_glXReleaseTexImage *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glXReleaseTexImage thread_data_local;
+   EVGL_Thread_Command_glXReleaseTexImage *thread_data = &thread_data_local;
 
-   thread_param->dpy = dpy;
-   thread_param->drawable = drawable;
-   thread_param->buffer = buffer;
+   thread_data->dpy = dpy;
+   thread_data->drawable = drawable;
+   thread_data->buffer = buffer;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glXReleaseTexImage,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
@@ -2655,11 +2632,11 @@ typedef struct
 static void
 _evgl_thread_glXSwapBuffers(void *data)
 {
-   EVGL_Thread_Command_glXSwapBuffers *thread_param =
-      (EVGL_Thread_Command_glXSwapBuffers *)data;
+   EVGL_Thread_Command_glXSwapBuffers *thread_data =
+       (EVGL_Thread_Command_glXSwapBuffers *)data;
 
-   glXSwapBuffers(thread_param->dpy,
-                  thread_param->drawable);
+   glXSwapBuffers(thread_data->dpy,
+                  thread_data->drawable);
 
 }
 
@@ -2674,15 +2651,15 @@ glXSwapBuffers_evgl_thread_cmd(Display *dpy, GLXDrawable drawable)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glXSwapBuffers thread_param_local;
-   EVGL_Thread_Command_glXSwapBuffers *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glXSwapBuffers thread_data_local;
+   EVGL_Thread_Command_glXSwapBuffers *thread_data = &thread_data_local;
 
-   thread_param->dpy = dpy;
-   thread_param->drawable = drawable;
+   thread_data->dpy = dpy;
+   thread_data->drawable = drawable;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glXSwapBuffers,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
@@ -2716,12 +2693,12 @@ glXSwapIntervalEXT_orig_evgl_get(void)
 static void
 _evgl_thread_glXSwapIntervalEXT(void *data)
 {
-   EVGL_Thread_Command_glXSwapIntervalEXT *thread_param =
-      (EVGL_Thread_Command_glXSwapIntervalEXT *)data;
+   EVGL_Thread_Command_glXSwapIntervalEXT *thread_data =
+       (EVGL_Thread_Command_glXSwapIntervalEXT *)data;
 
-   orig_evgl_glXSwapIntervalEXT(thread_param->dpy,
-                                thread_param->drawable,
-                                thread_param->interval);
+   orig_evgl_glXSwapIntervalEXT(thread_data->dpy,
+                                thread_data->drawable,
+                                thread_data->interval);
 
 }
 
@@ -2736,16 +2713,16 @@ glXSwapIntervalEXT_evgl_thread_cmd(Display *dpy, GLXDrawable drawable, int inter
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glXSwapIntervalEXT thread_param_local;
-   EVGL_Thread_Command_glXSwapIntervalEXT *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glXSwapIntervalEXT thread_data_local;
+   EVGL_Thread_Command_glXSwapIntervalEXT *thread_data = &thread_data_local;
 
-   thread_param->dpy = dpy;
-   thread_param->drawable = drawable;
-   thread_param->interval = interval;
+   thread_data->dpy = dpy;
+   thread_data->drawable = drawable;
+   thread_data->interval = interval;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glXSwapIntervalEXT,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 }
 
@@ -2778,10 +2755,10 @@ glXSwapIntervalSGI_orig_evgl_get(void)
 static void
 _evgl_thread_glXSwapIntervalSGI(void *data)
 {
-   EVGL_Thread_Command_glXSwapIntervalSGI *thread_param =
-      (EVGL_Thread_Command_glXSwapIntervalSGI *)data;
+   EVGL_Thread_Command_glXSwapIntervalSGI *thread_data =
+       (EVGL_Thread_Command_glXSwapIntervalSGI *)data;
 
-   thread_param->return_value = orig_evgl_glXSwapIntervalSGI(thread_param->interval);
+   thread_data->return_value = orig_evgl_glXSwapIntervalSGI(thread_data->interval);
 
 }
 
@@ -2795,17 +2772,17 @@ glXSwapIntervalSGI_evgl_thread_cmd(int interval)
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glXSwapIntervalSGI thread_param_local;
-   EVGL_Thread_Command_glXSwapIntervalSGI *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glXSwapIntervalSGI thread_data_local;
+   EVGL_Thread_Command_glXSwapIntervalSGI *thread_data = &thread_data_local;
 
-   thread_param->interval = interval;
+   thread_data->interval = interval;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glXSwapIntervalSGI,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 /*
@@ -2839,12 +2816,12 @@ glXWaitVideoSync_orig_evgl_get(void)
 static void
 _evgl_thread_glXWaitVideoSync(void *data)
 {
-   EVGL_Thread_Command_glXWaitVideoSync *thread_param =
-      (EVGL_Thread_Command_glXWaitVideoSync *)data;
+   EVGL_Thread_Command_glXWaitVideoSync *thread_data =
+       (EVGL_Thread_Command_glXWaitVideoSync *)data;
 
-   thread_param->return_value = orig_evgl_glXWaitVideoSync(thread_param->divisor,
-                                                           thread_param->remainder,
-                                                           thread_param->count);
+   thread_data->return_value = orig_evgl_glXWaitVideoSync(thread_data->divisor,
+                                                          thread_data->remainder,
+                                                          thread_data->count);
 
 }
 
@@ -2858,123 +2835,122 @@ glXWaitVideoSync_evgl_thread_cmd(int divisor, int remainder, unsigned int *count
 
    int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
 
-   EVGL_Thread_Command_glXWaitVideoSync thread_param_local;
-   EVGL_Thread_Command_glXWaitVideoSync *thread_param = &thread_param_local;
+   EVGL_Thread_Command_glXWaitVideoSync thread_data_local;
+   EVGL_Thread_Command_glXWaitVideoSync *thread_data = &thread_data_local;
 
-   thread_param->divisor = divisor;
-   thread_param->remainder = remainder;
-   thread_param->count = count;
+   thread_data->divisor = divisor;
+   thread_data->remainder = remainder;
+   thread_data->count = count;
 
    evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
                               _evgl_thread_glXWaitVideoSync,
-                              thread_param,
+                              thread_data,
                               thread_mode);
 
-   return thread_param->return_value;
+   return thread_data->return_value;
 }
 
 
-#else /* EVAS_GL_RENDER_THREAD_IS_GENERIC */
-
+#else /* ! EVAS_GL_RENDER_THREAD_COMPILE_FOR_GL_GENERIC */
 
 #include <dlfcn.h>
 
 
-void (*glXBindTexImage_orig_evas_set)(void *func) = NULL;
-void *(*glXBindTexImage_orig_evas_get)(void) = NULL;
-void (*glXBindTexImage_thread_cmd)(Display *dpy, GLXDrawable drawable, int buffer, const int *attrib_list) = NULL;
-GLXFBConfig * (*glXChooseFBConfig_thread_cmd)(Display *dpy, int screen, const int *attribList, int *nitems) = NULL;
-GLXContext (*glXCreateContext_thread_cmd)(Display *dpy, XVisualInfo *vis, GLXContext shareList, Bool direct) = NULL;
-GLXContext (*glXCreateNewContext_thread_cmd)(Display *dpy, GLXFBConfig config, int renderType, GLXContext shareList, Bool direct) = NULL;
-GLXPbuffer (*glXCreatePbuffer_thread_cmd)(Display *dpy, GLXFBConfig config, const int *attribList) = NULL;
-void (*glXCreatePixmap_orig_evas_set)(void *func) = NULL;
-void *(*glXCreatePixmap_orig_evas_get)(void) = NULL;
-GLXPixmap (*glXCreatePixmap_thread_cmd)(Display *dpy, GLXFBConfig config, Pixmap pixmap, const int *attribList) = NULL;
-GLXWindow (*glXCreateWindow_thread_cmd)(Display *dpy, GLXFBConfig config, Window win, const int *attribList) = NULL;
-void (*glXDestroyContext_thread_cmd)(Display *dpy, GLXContext ctx) = NULL;
-void (*glXDestroyPbuffer_thread_cmd)(Display *dpy, GLXPbuffer pbuf) = NULL;
-void (*glXDestroyPixmap_orig_evas_set)(void *func) = NULL;
-void *(*glXDestroyPixmap_orig_evas_get)(void) = NULL;
-void (*glXDestroyPixmap_thread_cmd)(Display *dpy, GLXPixmap pixmap) = NULL;
-void (*glXDestroyWindow_thread_cmd)(Display *dpy, GLXWindow window) = NULL;
-int (*glXGetConfig_thread_cmd)(Display *dpy, XVisualInfo *visual, int attrib, int *value) = NULL;
-GLXContext (*glXGetCurrentContext_thread_cmd)(void) = NULL;
-int (*glXGetFBConfigAttrib_thread_cmd)(Display *dpy, GLXFBConfig config, int attribute, int *value) = NULL;
-void (*glXGetVideoSync_orig_evas_set)(void *func) = NULL;
-void *(*glXGetVideoSync_orig_evas_get)(void) = NULL;
-int (*glXGetVideoSync_thread_cmd)(unsigned int *count) = NULL;
-XVisualInfo * (*glXGetVisualFromFBConfig_thread_cmd)(Display *dpy, GLXFBConfig config) = NULL;
-Bool (*glXMakeContextCurrent_thread_cmd)(Display *dpy, GLXDrawable draw, GLXDrawable read, GLXContext ctx) = NULL;
-void (*glXQueryDrawable_orig_evas_set)(void *func) = NULL;
-void *(*glXQueryDrawable_orig_evas_get)(void) = NULL;
-void (*glXQueryDrawable_thread_cmd)(Display *dpy, GLXDrawable draw, int attribute, unsigned int *value) = NULL;
-Bool (*glXQueryExtension_thread_cmd)(Display *dpy, int *errorb, int *event) = NULL;
-const char * (*glXQueryExtensionsString_thread_cmd)(Display *dpy, int screen) = NULL;
-void (*glXReleaseBuffersMESA_orig_evas_set)(void *func) = NULL;
-void *(*glXReleaseBuffersMESA_orig_evas_get)(void) = NULL;
-Bool (*glXReleaseBuffersMESA_thread_cmd)(Display *dpy, GLXDrawable drawable) = NULL;
-void (*glXReleaseTexImage_orig_evas_set)(void *func) = NULL;
-void *(*glXReleaseTexImage_orig_evas_get)(void) = NULL;
-void (*glXReleaseTexImage_thread_cmd)(Display *dpy, GLXDrawable drawable, int buffer) = NULL;
-void (*glXSwapBuffers_thread_cmd)(Display *dpy, GLXDrawable drawable) = NULL;
-void (*glXSwapIntervalEXT_orig_evas_set)(void *func) = NULL;
-void *(*glXSwapIntervalEXT_orig_evas_get)(void) = NULL;
-void (*glXSwapIntervalEXT_thread_cmd)(Display *dpy, GLXDrawable drawable, int interval) = NULL;
-void (*glXSwapIntervalSGI_orig_evas_set)(void *func) = NULL;
-void *(*glXSwapIntervalSGI_orig_evas_get)(void) = NULL;
-int (*glXSwapIntervalSGI_thread_cmd)(int interval) = NULL;
-void (*glXWaitVideoSync_orig_evas_set)(void *func) = NULL;
-void *(*glXWaitVideoSync_orig_evas_get)(void) = NULL;
-int (*glXWaitVideoSync_thread_cmd)(int divisor, int remainder, unsigned int *count) = NULL;
+void          (*glXBindTexImage_orig_evas_set)(void *func) = NULL;
+void         *(*glXBindTexImage_orig_evas_get)(void) = NULL;
+void          (*glXBindTexImage_thread_cmd)(Display *dpy, GLXDrawable drawable, int buffer, const int *attrib_list) = NULL;
+GLXFBConfig  *(*glXChooseFBConfig_thread_cmd)(Display *dpy, int screen, const int *attribList, int *nitems) = NULL;
+GLXContext    (*glXCreateContext_thread_cmd)(Display *dpy, XVisualInfo *vis, GLXContext shareList, Bool direct) = NULL;
+GLXContext    (*glXCreateNewContext_thread_cmd)(Display *dpy, GLXFBConfig config, int renderType, GLXContext shareList, Bool direct) = NULL;
+GLXPbuffer    (*glXCreatePbuffer_thread_cmd)(Display *dpy, GLXFBConfig config, const int *attribList) = NULL;
+void          (*glXCreatePixmap_orig_evas_set)(void *func) = NULL;
+void         *(*glXCreatePixmap_orig_evas_get)(void) = NULL;
+GLXPixmap     (*glXCreatePixmap_thread_cmd)(Display *dpy, GLXFBConfig config, Pixmap pixmap, const int *attribList) = NULL;
+GLXWindow     (*glXCreateWindow_thread_cmd)(Display *dpy, GLXFBConfig config, Window win, const int *attribList) = NULL;
+void          (*glXDestroyContext_thread_cmd)(Display *dpy, GLXContext ctx) = NULL;
+void          (*glXDestroyPbuffer_thread_cmd)(Display *dpy, GLXPbuffer pbuf) = NULL;
+void          (*glXDestroyPixmap_orig_evas_set)(void *func) = NULL;
+void         *(*glXDestroyPixmap_orig_evas_get)(void) = NULL;
+void          (*glXDestroyPixmap_thread_cmd)(Display *dpy, GLXPixmap pixmap) = NULL;
+void          (*glXDestroyWindow_thread_cmd)(Display *dpy, GLXWindow window) = NULL;
+int           (*glXGetConfig_thread_cmd)(Display *dpy, XVisualInfo *visual, int attrib, int *value) = NULL;
+GLXContext    (*glXGetCurrentContext_thread_cmd)(void) = NULL;
+int           (*glXGetFBConfigAttrib_thread_cmd)(Display *dpy, GLXFBConfig config, int attribute, int *value) = NULL;
+void          (*glXGetVideoSync_orig_evas_set)(void *func) = NULL;
+void         *(*glXGetVideoSync_orig_evas_get)(void) = NULL;
+int           (*glXGetVideoSync_thread_cmd)(unsigned int *count) = NULL;
+XVisualInfo  *(*glXGetVisualFromFBConfig_thread_cmd)(Display *dpy, GLXFBConfig config) = NULL;
+Bool          (*glXMakeContextCurrent_thread_cmd)(Display *dpy, GLXDrawable draw, GLXDrawable read, GLXContext ctx) = NULL;
+void          (*glXQueryDrawable_orig_evas_set)(void *func) = NULL;
+void         *(*glXQueryDrawable_orig_evas_get)(void) = NULL;
+void          (*glXQueryDrawable_thread_cmd)(Display *dpy, GLXDrawable draw, int attribute, unsigned int *value) = NULL;
+Bool          (*glXQueryExtension_thread_cmd)(Display *dpy, int *errorb, int *event) = NULL;
+const char   *(*glXQueryExtensionsString_thread_cmd)(Display *dpy, int screen) = NULL;
+void          (*glXReleaseBuffersMESA_orig_evas_set)(void *func) = NULL;
+void         *(*glXReleaseBuffersMESA_orig_evas_get)(void) = NULL;
+Bool          (*glXReleaseBuffersMESA_thread_cmd)(Display *dpy, GLXDrawable drawable) = NULL;
+void          (*glXReleaseTexImage_orig_evas_set)(void *func) = NULL;
+void         *(*glXReleaseTexImage_orig_evas_get)(void) = NULL;
+void          (*glXReleaseTexImage_thread_cmd)(Display *dpy, GLXDrawable drawable, int buffer) = NULL;
+void          (*glXSwapBuffers_thread_cmd)(Display *dpy, GLXDrawable drawable) = NULL;
+void          (*glXSwapIntervalEXT_orig_evas_set)(void *func) = NULL;
+void         *(*glXSwapIntervalEXT_orig_evas_get)(void) = NULL;
+void          (*glXSwapIntervalEXT_thread_cmd)(Display *dpy, GLXDrawable drawable, int interval) = NULL;
+void          (*glXSwapIntervalSGI_orig_evas_set)(void *func) = NULL;
+void         *(*glXSwapIntervalSGI_orig_evas_get)(void) = NULL;
+int           (*glXSwapIntervalSGI_thread_cmd)(int interval) = NULL;
+void          (*glXWaitVideoSync_orig_evas_set)(void *func) = NULL;
+void         *(*glXWaitVideoSync_orig_evas_get)(void) = NULL;
+int           (*glXWaitVideoSync_thread_cmd)(int divisor, int remainder, unsigned int *count) = NULL;
 
 /****** EVAS GL ******/
 
-void (*glXBindTexImage_orig_evgl_set)(void *func) = NULL;
-void *(*glXBindTexImage_orig_evgl_get)(void) = NULL;
-void (*glXBindTexImage_evgl_thread_cmd)(Display *dpy, GLXDrawable drawable, int buffer, const int *attrib_list) = NULL;
-GLXFBConfig * (*glXChooseFBConfig_evgl_thread_cmd)(Display *dpy, int screen, const int *attribList, int *nitems) = NULL;
-GLXContext (*glXCreateContext_evgl_thread_cmd)(Display *dpy, XVisualInfo *vis, GLXContext shareList, Bool direct) = NULL;
-GLXContext (*glXCreateNewContext_evgl_thread_cmd)(Display *dpy, GLXFBConfig config, int renderType, GLXContext shareList, Bool direct) = NULL;
-GLXPbuffer (*glXCreatePbuffer_evgl_thread_cmd)(Display *dpy, GLXFBConfig config, const int *attribList) = NULL;
-void (*glXCreatePixmap_orig_evgl_set)(void *func) = NULL;
-void *(*glXCreatePixmap_orig_evgl_get)(void) = NULL;
-GLXPixmap (*glXCreatePixmap_evgl_thread_cmd)(Display *dpy, GLXFBConfig config, Pixmap pixmap, const int *attribList) = NULL;
-GLXWindow (*glXCreateWindow_evgl_thread_cmd)(Display *dpy, GLXFBConfig config, Window win, const int *attribList) = NULL;
-void (*glXDestroyContext_evgl_thread_cmd)(Display *dpy, GLXContext ctx) = NULL;
-void (*glXDestroyPbuffer_evgl_thread_cmd)(Display *dpy, GLXPbuffer pbuf) = NULL;
-void (*glXDestroyPixmap_orig_evgl_set)(void *func) = NULL;
-void *(*glXDestroyPixmap_orig_evgl_get)(void) = NULL;
-void (*glXDestroyPixmap_evgl_thread_cmd)(Display *dpy, GLXPixmap pixmap) = NULL;
-void (*glXDestroyWindow_evgl_thread_cmd)(Display *dpy, GLXWindow window) = NULL;
-int (*glXGetConfig_evgl_thread_cmd)(Display *dpy, XVisualInfo *visual, int attrib, int *value) = NULL;
-GLXContext (*glXGetCurrentContext_evgl_thread_cmd)(void) = NULL;
-int (*glXGetFBConfigAttrib_evgl_thread_cmd)(Display *dpy, GLXFBConfig config, int attribute, int *value) = NULL;
-void (*glXGetVideoSync_orig_evgl_set)(void *func) = NULL;
-void *(*glXGetVideoSync_orig_evgl_get)(void) = NULL;
-int (*glXGetVideoSync_evgl_thread_cmd)(unsigned int *count) = NULL;
-XVisualInfo * (*glXGetVisualFromFBConfig_evgl_thread_cmd)(Display *dpy, GLXFBConfig config) = NULL;
-Bool (*glXMakeContextCurrent_evgl_thread_cmd)(Display *dpy, GLXDrawable draw, GLXDrawable read, GLXContext ctx) = NULL;
-void (*glXQueryDrawable_orig_evgl_set)(void *func) = NULL;
-void *(*glXQueryDrawable_orig_evgl_get)(void) = NULL;
-void (*glXQueryDrawable_evgl_thread_cmd)(Display *dpy, GLXDrawable draw, int attribute, unsigned int *value) = NULL;
-Bool (*glXQueryExtension_evgl_thread_cmd)(Display *dpy, int *errorb, int *event) = NULL;
-const char * (*glXQueryExtensionsString_evgl_thread_cmd)(Display *dpy, int screen) = NULL;
-void (*glXReleaseBuffersMESA_orig_evgl_set)(void *func) = NULL;
-void *(*glXReleaseBuffersMESA_orig_evgl_get)(void) = NULL;
-Bool (*glXReleaseBuffersMESA_evgl_thread_cmd)(Display *dpy, GLXDrawable drawable) = NULL;
-void (*glXReleaseTexImage_orig_evgl_set)(void *func) = NULL;
-void *(*glXReleaseTexImage_orig_evgl_get)(void) = NULL;
-void (*glXReleaseTexImage_evgl_thread_cmd)(Display *dpy, GLXDrawable drawable, int buffer) = NULL;
-void (*glXSwapBuffers_evgl_thread_cmd)(Display *dpy, GLXDrawable drawable) = NULL;
-void (*glXSwapIntervalEXT_orig_evgl_set)(void *func) = NULL;
-void *(*glXSwapIntervalEXT_orig_evgl_get)(void) = NULL;
-void (*glXSwapIntervalEXT_evgl_thread_cmd)(Display *dpy, GLXDrawable drawable, int interval) = NULL;
-void (*glXSwapIntervalSGI_orig_evgl_set)(void *func) = NULL;
-void *(*glXSwapIntervalSGI_orig_evgl_get)(void) = NULL;
-int (*glXSwapIntervalSGI_evgl_thread_cmd)(int interval) = NULL;
-void (*glXWaitVideoSync_orig_evgl_set)(void *func) = NULL;
-void *(*glXWaitVideoSync_orig_evgl_get)(void) = NULL;
-int (*glXWaitVideoSync_evgl_thread_cmd)(int divisor, int remainder, unsigned int *count) = NULL;
+void          (*glXBindTexImage_orig_evgl_set)(void *func) = NULL;
+void         *(*glXBindTexImage_orig_evgl_get)(void) = NULL;
+void          (*glXBindTexImage_evgl_thread_cmd)(Display *dpy, GLXDrawable drawable, int buffer, const int *attrib_list) = NULL;
+GLXFBConfig  *(*glXChooseFBConfig_evgl_thread_cmd)(Display *dpy, int screen, const int *attribList, int *nitems) = NULL;
+GLXContext    (*glXCreateContext_evgl_thread_cmd)(Display *dpy, XVisualInfo *vis, GLXContext shareList, Bool direct) = NULL;
+GLXContext    (*glXCreateNewContext_evgl_thread_cmd)(Display *dpy, GLXFBConfig config, int renderType, GLXContext shareList, Bool direct) = NULL;
+GLXPbuffer    (*glXCreatePbuffer_evgl_thread_cmd)(Display *dpy, GLXFBConfig config, const int *attribList) = NULL;
+void          (*glXCreatePixmap_orig_evgl_set)(void *func) = NULL;
+void         *(*glXCreatePixmap_orig_evgl_get)(void) = NULL;
+GLXPixmap     (*glXCreatePixmap_evgl_thread_cmd)(Display *dpy, GLXFBConfig config, Pixmap pixmap, const int *attribList) = NULL;
+GLXWindow     (*glXCreateWindow_evgl_thread_cmd)(Display *dpy, GLXFBConfig config, Window win, const int *attribList) = NULL;
+void          (*glXDestroyContext_evgl_thread_cmd)(Display *dpy, GLXContext ctx) = NULL;
+void          (*glXDestroyPbuffer_evgl_thread_cmd)(Display *dpy, GLXPbuffer pbuf) = NULL;
+void          (*glXDestroyPixmap_orig_evgl_set)(void *func) = NULL;
+void         *(*glXDestroyPixmap_orig_evgl_get)(void) = NULL;
+void          (*glXDestroyPixmap_evgl_thread_cmd)(Display *dpy, GLXPixmap pixmap) = NULL;
+void          (*glXDestroyWindow_evgl_thread_cmd)(Display *dpy, GLXWindow window) = NULL;
+int           (*glXGetConfig_evgl_thread_cmd)(Display *dpy, XVisualInfo *visual, int attrib, int *value) = NULL;
+GLXContext    (*glXGetCurrentContext_evgl_thread_cmd)(void) = NULL;
+int           (*glXGetFBConfigAttrib_evgl_thread_cmd)(Display *dpy, GLXFBConfig config, int attribute, int *value) = NULL;
+void          (*glXGetVideoSync_orig_evgl_set)(void *func) = NULL;
+void         *(*glXGetVideoSync_orig_evgl_get)(void) = NULL;
+int           (*glXGetVideoSync_evgl_thread_cmd)(unsigned int *count) = NULL;
+XVisualInfo  *(*glXGetVisualFromFBConfig_evgl_thread_cmd)(Display *dpy, GLXFBConfig config) = NULL;
+Bool          (*glXMakeContextCurrent_evgl_thread_cmd)(Display *dpy, GLXDrawable draw, GLXDrawable read, GLXContext ctx) = NULL;
+void          (*glXQueryDrawable_orig_evgl_set)(void *func) = NULL;
+void         *(*glXQueryDrawable_orig_evgl_get)(void) = NULL;
+void          (*glXQueryDrawable_evgl_thread_cmd)(Display *dpy, GLXDrawable draw, int attribute, unsigned int *value) = NULL;
+Bool          (*glXQueryExtension_evgl_thread_cmd)(Display *dpy, int *errorb, int *event) = NULL;
+const char   *(*glXQueryExtensionsString_evgl_thread_cmd)(Display *dpy, int screen) = NULL;
+void          (*glXReleaseBuffersMESA_orig_evgl_set)(void *func) = NULL;
+void         *(*glXReleaseBuffersMESA_orig_evgl_get)(void) = NULL;
+Bool          (*glXReleaseBuffersMESA_evgl_thread_cmd)(Display *dpy, GLXDrawable drawable) = NULL;
+void          (*glXReleaseTexImage_orig_evgl_set)(void *func) = NULL;
+void         *(*glXReleaseTexImage_orig_evgl_get)(void) = NULL;
+void          (*glXReleaseTexImage_evgl_thread_cmd)(Display *dpy, GLXDrawable drawable, int buffer) = NULL;
+void          (*glXSwapBuffers_evgl_thread_cmd)(Display *dpy, GLXDrawable drawable) = NULL;
+void          (*glXSwapIntervalEXT_orig_evgl_set)(void *func) = NULL;
+void         *(*glXSwapIntervalEXT_orig_evgl_get)(void) = NULL;
+void          (*glXSwapIntervalEXT_evgl_thread_cmd)(Display *dpy, GLXDrawable drawable, int interval) = NULL;
+void          (*glXSwapIntervalSGI_orig_evgl_set)(void *func) = NULL;
+void         *(*glXSwapIntervalSGI_orig_evgl_get)(void) = NULL;
+int           (*glXSwapIntervalSGI_evgl_thread_cmd)(int interval) = NULL;
+void          (*glXWaitVideoSync_orig_evgl_set)(void *func) = NULL;
+void         *(*glXWaitVideoSync_orig_evgl_get)(void) = NULL;
+int           (*glXWaitVideoSync_evgl_thread_cmd)(int divisor, int remainder, unsigned int *count) = NULL;
 
 
 
@@ -3081,7 +3057,7 @@ void _glx_thread_link_init()
    LINK2GENERIC(glXWaitVideoSync_evgl_thread_cmd);
 }
 
-#endif /* EVAS_GL_RENDER_THREAD_IS_GENERIC */
+#endif /* EVAS_GL_RENDER_THREAD_COMPILE_FOR_GL_GENERIC */
 
 
 #endif /* ! GL_GLES */

diff --git a/src/modules/evas/engines/gl_common/evas_gl_thread_glx.h b/src/modules/evas/engines/gl_common/evas_gl_thread_glx.h
index 42912f7..56b54f7 100644 (file)
--- a/src/modules/evas/engines/gl_common/evas_gl_thread_glx.h
+++ b/src/modules/evas/engines/gl_common/evas_gl_thread_glx.h
@@ -5,7 +5,7 @@
 
 # include <GL/glx.h>
 
-#ifdef EVAS_GL_RENDER_THREAD_IS_GENERIC
+#ifdef EVAS_GL_RENDER_THREAD_COMPILE_FOR_GL_GENERIC
 
 #define GL_GLEXT_PROTOTYPES
 
@@ -36,221 +36,220 @@
 #endif /* ! _WIN32 */
 
 
-EAPI void glXBindTexImage_orig_evas_set(void *func);
-EAPI void *glXBindTexImage_orig_evas_get(void);
-EAPI void glXBindTexImage_thread_cmd(Display *dpy, GLXDrawable drawable, int buffer, const int *attrib_list);
-EAPI GLXFBConfig * glXChooseFBConfig_thread_cmd(Display *dpy, int screen, const int *attribList, int *nitems);
-EAPI GLXContext glXCreateContext_thread_cmd(Display *dpy, XVisualInfo *vis, GLXContext shareList, Bool direct);
-EAPI GLXContext glXCreateNewContext_thread_cmd(Display *dpy, GLXFBConfig config, int renderType, GLXContext shareList, Bool direct);
-EAPI GLXPbuffer glXCreatePbuffer_thread_cmd(Display *dpy, GLXFBConfig config, const int *attribList);
-EAPI void glXCreatePixmap_orig_evas_set(void *func);
-EAPI void *glXCreatePixmap_orig_evas_get(void);
-EAPI GLXPixmap glXCreatePixmap_thread_cmd(Display *dpy, GLXFBConfig config, Pixmap pixmap, const int *attribList);
-EAPI GLXWindow glXCreateWindow_thread_cmd(Display *dpy, GLXFBConfig config, Window win, const int *attribList);
-EAPI void glXDestroyContext_thread_cmd(Display *dpy, GLXContext ctx);
-EAPI void glXDestroyPbuffer_thread_cmd(Display *dpy, GLXPbuffer pbuf);
-EAPI void glXDestoyPixmap_orig_evas_set(void *func);
-EAPI void *glXDestoyPixmap_orig_evas_get(void);
-EAPI void glXDestroyPixmap_thread_cmd(Display *dpy, GLXPixmap pixmap);
-EAPI void glXDestroyWindow_thread_cmd(Display *dpy, GLXWindow window);
-EAPI int glXGetConfig_thread_cmd(Display *dpy, XVisualInfo *visual, int attrib, int *value);
-EAPI GLXContext glXGetCurrentContext_thread_cmd(void);
-EAPI int glXGetFBConfigAttrib_thread_cmd(Display *dpy, GLXFBConfig config, int attribute, int *value);
-
-EAPI void glXGetVideoSync_orig_evas_set(void *func);
-EAPI void *glXGetVideoSync_orig_evas_get(void);
-EAPI int glXGetVideoSync_thread_cmd(unsigned int *count);
-EAPI XVisualInfo * glXGetVisualFromFBConfig_thread_cmd(Display *dpy, GLXFBConfig config);
-EAPI Bool glXMakeContextCurrent_thread_cmd(Display *dpy, GLXDrawable draw, GLXDrawable read, GLXContext ctx);
-EAPI void glXQueryDrawable_orig_evas_set(void *func);
-EAPI void *glXQueryDrawable_orig_evas_get(void);
-EAPI void glXQueryDrawable_thread_cmd(Display *dpy, GLXDrawable draw, int attribute, unsigned int *value);
-EAPI Bool glXQueryExtension_thread_cmd(Display *dpy, int *errorb, int *event);
-EAPI const char * glXQueryExtensionsString_thread_cmd(Display *dpy, int screen);
-
-EAPI void glXReleaseBuffersMESA_orig_evas_set(void *func);
-EAPI void *glXReleaseBuffersMESA_orig_evas_get(void);
-EAPI Bool glXReleaseBuffersMESA_thread_cmd(Display *dpy, GLXDrawable drawable);
-
-EAPI void glXReleaseTexImageEXT_orig_evas_set(void *func);
-EAPI void *glXReleaseTexImageEXT_orig_evas_get(void);
-EAPI void glXReleaseTexImageEXT_thread_cmd(Display *dpy, GLXDrawable drawable, int buffer);
-EAPI void glXSwapBuffers_thread_cmd(Display *dpy, GLXDrawable drawable);
-
-EAPI void glXSwapIntervalEXT_orig_evas_set(void *func);
-EAPI void *glXSwapIntervalEXT_orig_evas_get(void);
-EAPI void glXSwapIntervalEXT_thread_cmd(Display *dpy, GLXDrawable drawable, int interval);
-
-EAPI void glXSwapIntervalSGI_orig_evas_set(void *func);
-EAPI void *glXSwapIntervalSGI_orig_evas_get(void);
-EAPI int glXSwapIntervalSGI_thread_cmd(int interval);
-
-EAPI void glXWaitVideoSync_orig_evas_set(void *func);
-EAPI void *glXWaitVideoSync_orig_evas_get(void);
-EAPI int glXWaitVideoSync_thread_cmd(int divisor, int remainder, unsigned int *count);
+EAPI void         glXBindTexImage_orig_evas_set(void *func);
+EAPI void        *glXBindTexImage_orig_evas_get(void);
+EAPI void         glXBindTexImage_thread_cmd(Display *dpy, GLXDrawable drawable, int buffer, const int *attrib_list);
+EAPI GLXFBConfig *glXChooseFBConfig_thread_cmd(Display *dpy, int screen, const int *attribList, int *nitems);
+EAPI GLXContext   glXCreateContext_thread_cmd(Display *dpy, XVisualInfo *vis, GLXContext shareList, Bool direct);
+EAPI GLXContext   glXCreateNewContext_thread_cmd(Display *dpy, GLXFBConfig config, int renderType, GLXContext shareList, Bool direct);
+EAPI GLXPbuffer   glXCreatePbuffer_thread_cmd(Display *dpy, GLXFBConfig config, const int *attribList);
+EAPI void         glXCreatePixmap_orig_evas_set(void *func);
+EAPI void        *glXCreatePixmap_orig_evas_get(void);
+EAPI GLXPixmap    glXCreatePixmap_thread_cmd(Display *dpy, GLXFBConfig config, Pixmap pixmap, const int *attribList);
+EAPI GLXWindow    glXCreateWindow_thread_cmd(Display *dpy, GLXFBConfig config, Window win, const int *attribList);
+EAPI void         glXDestroyContext_thread_cmd(Display *dpy, GLXContext ctx);
+EAPI void         glXDestroyPbuffer_thread_cmd(Display *dpy, GLXPbuffer pbuf);
+EAPI void         glXDestoyPixmap_orig_evas_set(void *func);
+EAPI void        *glXDestoyPixmap_orig_evas_get(void);
+EAPI void         glXDestroyPixmap_thread_cmd(Display *dpy, GLXPixmap pixmap);
+EAPI void         glXDestroyWindow_thread_cmd(Display *dpy, GLXWindow window);
+EAPI int          glXGetConfig_thread_cmd(Display *dpy, XVisualInfo *visual, int attrib, int *value);
+EAPI GLXContext   glXGetCurrentContext_thread_cmd(void);
+EAPI int          glXGetFBConfigAttrib_thread_cmd(Display *dpy, GLXFBConfig config, int attribute, int *value);
+
+EAPI void         glXGetVideoSync_orig_evas_set(void *func);
+EAPI void        *glXGetVideoSync_orig_evas_get(void);
+EAPI int          glXGetVideoSync_thread_cmd(unsigned int *count);
+EAPI XVisualInfo *glXGetVisualFromFBConfig_thread_cmd(Display *dpy, GLXFBConfig config);
+EAPI Bool         glXMakeContextCurrent_thread_cmd(Display *dpy, GLXDrawable draw, GLXDrawable read, GLXContext ctx);
+EAPI void         glXQueryDrawable_orig_evas_set(void *func);
+EAPI void        *glXQueryDrawable_orig_evas_get(void);
+EAPI void         glXQueryDrawable_thread_cmd(Display *dpy, GLXDrawable draw, int attribute, unsigned int *value);
+EAPI Bool         glXQueryExtension_thread_cmd(Display *dpy, int *errorb, int *event);
+EAPI const char  *glXQueryExtensionsString_thread_cmd(Display *dpy, int screen);
+
+EAPI void         glXReleaseBuffersMESA_orig_evas_set(void *func);
+EAPI void        *glXReleaseBuffersMESA_orig_evas_get(void);
+EAPI Bool         glXReleaseBuffersMESA_thread_cmd(Display *dpy, GLXDrawable drawable);
+
+EAPI void         glXReleaseTexImageEXT_orig_evas_set(void *func);
+EAPI void        *glXReleaseTexImageEXT_orig_evas_get(void);
+EAPI void         glXReleaseTexImageEXT_thread_cmd(Display *dpy, GLXDrawable drawable, int buffer);
+EAPI void         glXSwapBuffers_thread_cmd(Display *dpy, GLXDrawable drawable);
+
+EAPI void         glXSwapIntervalEXT_orig_evas_set(void *func);
+EAPI void        *glXSwapIntervalEXT_orig_evas_get(void);
+EAPI void         glXSwapIntervalEXT_thread_cmd(Display *dpy, GLXDrawable drawable, int interval);
+
+EAPI void         glXSwapIntervalSGI_orig_evas_set(void *func);
+EAPI void        *glXSwapIntervalSGI_orig_evas_get(void);
+EAPI int          glXSwapIntervalSGI_thread_cmd(int interval);
+
+EAPI void         glXWaitVideoSync_orig_evas_set(void *func);
+EAPI void        *glXWaitVideoSync_orig_evas_get(void);
+EAPI int          glXWaitVideoSync_thread_cmd(int divisor, int remainder, unsigned int *count);
 
 /****** EVAS GL ******/
-
-EAPI void glXBindTexImage_orig_evgl_set(void *func);
-EAPI void *glXBindTexImage_orig_evgl_get(void);
-EAPI void glXBindTexImage_evgl_thread_cmd(Display *dpy, GLXDrawable drawable, int buffer, const int *attrib_list);
-EAPI GLXFBConfig * glXChooseFBConfig_evgl_thread_cmd(Display *dpy, int screen, const int *attribList, int *nitems);
-EAPI GLXContext glXCreateContext_evgl_thread_cmd(Display *dpy, XVisualInfo *vis, GLXContext shareList, Bool direct);
-EAPI GLXContext glXCreateNewContext_evgl_thread_cmd(Display *dpy, GLXFBConfig config, int renderType, GLXContext shareList, Bool direct);
-EAPI GLXPbuffer glXCreatePbuffer_evgl_thread_cmd(Display *dpy, GLXFBConfig config, const int *attribList);
-
-EAPI void glXCreatePixmap_orig_evgl_set(void *func);
-EAPI void *glXCreatePixmap_orig_evgl_get(void);
-EAPI GLXPixmap glXCreatePixmap_evgl_thread_cmd(Display *dpy, GLXFBConfig config, Pixmap pixmap, const int *attribList);
-EAPI GLXWindow glXCreateWindow_evgl_thread_cmd(Display *dpy, GLXFBConfig config, Window win, const int *attribList);
-EAPI void glXDestroyContext_evgl_thread_cmd(Display *dpy, GLXContext ctx);
-EAPI void glXDestroyPbuffer_evgl_thread_cmd(Display *dpy, GLXPbuffer pbuf);
-
-EAPI void glXDestroyPixmap_orig_evgl_set(void *func);
-EAPI void *glXDestroyPixmap_orig_evgl_get(void);
-EAPI void glXDestroyPixmap_evgl_thread_cmd(Display *dpy, GLXPixmap pixmap);
-EAPI void glXDestroyWindow_evgl_thread_cmd(Display *dpy, GLXWindow window);
-EAPI int glXGetConfig_evgl_thread_cmd(Display *dpy, XVisualInfo *visual, int attrib, int *value);
-EAPI GLXContext glXGetCurrentContext_evgl_thread_cmd(void);
-EAPI int glXGetFBConfigAttrib_evgl_thread_cmd(Display *dpy, GLXFBConfig config, int attribute, int *value);
-
-EAPI void glXGetVideoSync_orig_evgl_set(void *func);
-EAPI void *glXGetVideoSync_orig_evgl_get(void);
-EAPI int glXGetVideoSync_evgl_thread_cmd(unsigned int *count);
-EAPI XVisualInfo * glXGetVisualFromFBConfig_evgl_thread_cmd(Display *dpy, GLXFBConfig config);
-EAPI Bool glXMakeContextCurrent_evgl_thread_cmd(Display *dpy, GLXDrawable draw, GLXDrawable read, GLXContext ctx);
-
-EAPI void glXQueryDrawable_orig_evgl_set(void *func);
-EAPI void *glXQueryDrawable_orig_evgl_get(void);
-EAPI void glXQueryDrawable_evgl_thread_cmd(Display *dpy, GLXDrawable draw, int attribute, unsigned int *value);
-EAPI Bool glXQueryExtension_evgl_thread_cmd(Display *dpy, int *errorb, int *event);
-EAPI const char * glXQueryExtensionsString_evgl_thread_cmd(Display *dpy, int screen);
-
-EAPI void glXReleaseBuffersMESA_orig_evgl_set(void *func);
-EAPI void *glXReleaseBuffersMESA_orig_evgl_get(void);
-EAPI Bool glXReleaseBuffersMESA_evgl_thread_cmd(Display *dpy, GLXDrawable drawable);
-
-EAPI void glXReleaseTexImage_orig_evgl_set(void *func);
-EAPI void *glXReleaseTexImage_orig_evgl_get(void);
-EAPI void glXReleaseTexImage_evgl_thread_cmd(Display *dpy, GLXDrawable drawable, int buffer);
-EAPI void glXSwapBuffers_evgl_thread_cmd(Display *dpy, GLXDrawable drawable);
-
-EAPI void glXSwapIntervalEXT_orig_evgl_set(void *func);
-EAPI void *glXSwapIntervalEXT_orig_evgl_get(void);
-EAPI void glXSwapIntervalEXT_evgl_thread_cmd(Display *dpy, GLXDrawable drawable, int interval);
-
-EAPI void glXSwapIntervalSGI_orig_evgl_set(void *func);
-EAPI void *glXSwapIntervalSGI_orig_evgl_get(void);
-EAPI int glXSwapIntervalSGI_evgl_thread_cmd(int interval);
-
-EAPI void glXWaitVideoSync_orig_evgl_set(void *func);
-EAPI void *glXWaitVideoSync_orig_evgl_get(void);
-EAPI int glXWaitVideoSync_evgl_thread_cmd(int divisor, int remainder, unsigned int *count);
-
-#else /* EVAS_GL_RENDER_THREAD_IS_GENERIC */
-
-
-extern void (*glXBindTexImage_orig_evas_set)(void *func);
-extern void *(*glXBindTexImage_orig_evas_get)(void);
-extern void (*glXBindTexImage_thread_cmd)(Display *dpy, GLXDrawable drawable, int buffer, const int *attrib_list);
-extern GLXFBConfig * (*glXChooseFBConfig_thread_cmd)(Display *dpy, int screen, const int *attribList, int *nitems);
-extern GLXContext (*glXCreateContext_thread_cmd)(Display *dpy, XVisualInfo *vis, GLXContext shareList, Bool direct);
-extern GLXContext (*glXCreateNewContext_thread_cmd)(Display *dpy, GLXFBConfig config, int renderType, GLXContext shareList, Bool direct);
-extern GLXPbuffer (*glXCreatePbuffer_thread_cmd)(Display *dpy, GLXFBConfig config, const int *attribList);
-extern void (*glXCreatePixmap_orig_evas_set)(void *func);
-extern void  *(*glXCreatePixmap_orig_evas_get)(void);
-extern GLXPixmap (*glXCreatePixmap_thread_cmd)(Display *dpy, GLXFBConfig config, Pixmap pixmap, const int *attribList);
-extern GLXWindow (*glXCreateWindow_thread_cmd)(Display *dpy, GLXFBConfig config, Window win, const int *attribList);
-extern void (*glXDestroyContext_thread_cmd)(Display *dpy, GLXContext ctx);
-extern void (*glXDestroyPbuffer_thread_cmd)(Display *dpy, GLXPbuffer pbuf);
-extern void (*glXDestroyPixmap_orig_evas_set)(void *func);
-extern void *(*glXDestroyPixmap_orig_evas_get)(void);
-extern void (*glXDestroyPixmap_thread_cmd)(Display *dpy, GLXPixmap pixmap);
-extern void (*glXDestroyWindow_thread_cmd)(Display *dpy, GLXWindow window);
-extern int (*glXGetConfig_thread_cmd)(Display *dpy, XVisualInfo *visual, int attrib, int *value);
-extern GLXContext (*glXGetCurrentContext_thread_cmd)(void);
-extern int (*glXGetFBConfigAttrib_thread_cmd)(Display *dpy, GLXFBConfig config, int attribute, int *value);
-extern void (*glXGetVideoSync_orig_evas_set)(void *func);
-extern void *(*glXGetVideoSync_orig_evas_get)(void);
-extern int (*glXGetVideoSync_thread_cmd)(unsigned int *count);
-extern XVisualInfo * (*glXGetVisualFromFBConfig_thread_cmd)(Display *dpy, GLXFBConfig config);
-extern Bool (*glXMakeContextCurrent_thread_cmd)(Display *dpy, GLXDrawable draw, GLXDrawable read, GLXContext ctx);
-extern void (*glXQueryDrawable_orig_evas_set)(void *func);
-extern void *(*glXQueryDrawable_orig_evas_get)(void);
-extern void (*glXQueryDrawable_thread_cmd)(Display *dpy, GLXDrawable draw, int attribute, unsigned int *value);
-extern Bool (*glXQueryExtension_thread_cmd)(Display *dpy, int *errorb, int *event);
-extern const char * (*glXQueryExtensionsString_thread_cmd)(Display *dpy, int screen);
-extern void (*glXReleaseBuffersMESA_orig_evas_set)(void *func);
-extern void *(*glXReleaseBuffersMESA_orig_evas_get)(void);
-extern Bool (*glXReleaseBuffersMESA_thread_cmd)(Display *dpy, GLXDrawable drawable);
-extern void (*glXReleaseTexImage_orig_evas_set)(void *func);
-extern void *(*glXReleaseTexImage_orig_evas_get)(void);
-extern void (*glXReleaseTexImage_thread_cmd)(Display *dpy, GLXDrawable drawable, int buffer);
-extern void (*glXSwapBuffers_thread_cmd)(Display *dpy, GLXDrawable drawable);
-extern void (*glXSwapIntervalEXT_orig_evas_set)(void *func);
-extern void *(*glXSwapIntervalEXT_orig_evas_get)(void);
-extern void (*glXSwapIntervalEXT_thread_cmd)(Display *dpy, GLXDrawable drawable, int interval);
-extern void (*glXSwapIntervalSGI_orig_evas_set)(void *func);
-extern void *(*glXSwapIntervalSGI_orig_evas_get)(void);
-extern int (*glXSwapIntervalSGI_thread_cmd)(int interval);
-extern void (*glXWaitVideoSync_orig_evas_set)(void *func);
-extern void *(*glXWaitVideoSync_orig_evas_get)(void);
-extern int (*glXWaitVideoSync_thread_cmd)(int divisor, int remainder, unsigned int *count);
+EAPI void         glXBindTexImage_orig_evgl_set(void *func);
+EAPI void        *glXBindTexImage_orig_evgl_get(void);
+EAPI void         glXBindTexImage_evgl_thread_cmd(Display *dpy, GLXDrawable drawable, int buffer, const int *attrib_list);
+EAPI GLXFBConfig *glXChooseFBConfig_evgl_thread_cmd(Display *dpy, int screen, const int *attribList, int *nitems);
+EAPI GLXContext   glXCreateContext_evgl_thread_cmd(Display *dpy, XVisualInfo *vis, GLXContext shareList, Bool direct);
+EAPI GLXContext   glXCreateNewContext_evgl_thread_cmd(Display *dpy, GLXFBConfig config, int renderType, GLXContext shareList, Bool direct);
+EAPI GLXPbuffer   glXCreatePbuffer_evgl_thread_cmd(Display *dpy, GLXFBConfig config, const int *attribList);
+
+EAPI void         glXCreatePixmap_orig_evgl_set(void *func);
+EAPI void        *glXCreatePixmap_orig_evgl_get(void);
+EAPI GLXPixmap    glXCreatePixmap_evgl_thread_cmd(Display *dpy, GLXFBConfig config, Pixmap pixmap, const int *attribList);
+EAPI GLXWindow    glXCreateWindow_evgl_thread_cmd(Display *dpy, GLXFBConfig config, Window win, const int *attribList);
+EAPI void         glXDestroyContext_evgl_thread_cmd(Display *dpy, GLXContext ctx);
+EAPI void         glXDestroyPbuffer_evgl_thread_cmd(Display *dpy, GLXPbuffer pbuf);
+
+EAPI void         glXDestroyPixmap_orig_evgl_set(void *func);
+EAPI void        *glXDestroyPixmap_orig_evgl_get(void);
+EAPI void         glXDestroyPixmap_evgl_thread_cmd(Display *dpy, GLXPixmap pixmap);
+EAPI void         glXDestroyWindow_evgl_thread_cmd(Display *dpy, GLXWindow window);
+EAPI int          glXGetConfig_evgl_thread_cmd(Display *dpy, XVisualInfo *visual, int attrib, int *value);
+EAPI GLXContext   glXGetCurrentContext_evgl_thread_cmd(void);
+EAPI int          glXGetFBConfigAttrib_evgl_thread_cmd(Display *dpy, GLXFBConfig config, int attribute, int *value);
+
+EAPI void         glXGetVideoSync_orig_evgl_set(void *func);
+EAPI void        *glXGetVideoSync_orig_evgl_get(void);
+EAPI int          glXGetVideoSync_evgl_thread_cmd(unsigned int *count);
+EAPI XVisualInfo *glXGetVisualFromFBConfig_evgl_thread_cmd(Display *dpy, GLXFBConfig config);
+EAPI Bool         glXMakeContextCurrent_evgl_thread_cmd(Display *dpy, GLXDrawable draw, GLXDrawable read, GLXContext ctx);
+
+EAPI void         glXQueryDrawable_orig_evgl_set(void *func);
+EAPI void        *glXQueryDrawable_orig_evgl_get(void);
+EAPI void         glXQueryDrawable_evgl_thread_cmd(Display *dpy, GLXDrawable draw, int attribute, unsigned int *value);
+EAPI Bool         glXQueryExtension_evgl_thread_cmd(Display *dpy, int *errorb, int *event);
+EAPI const char  *glXQueryExtensionsString_evgl_thread_cmd(Display *dpy, int screen);
+
+EAPI void         glXReleaseBuffersMESA_orig_evgl_set(void *func);
+EAPI void        *glXReleaseBuffersMESA_orig_evgl_get(void);
+EAPI Bool         glXReleaseBuffersMESA_evgl_thread_cmd(Display *dpy, GLXDrawable drawable);
+
+EAPI void         glXReleaseTexImage_orig_evgl_set(void *func);
+EAPI void        *glXReleaseTexImage_orig_evgl_get(void);
+EAPI void         glXReleaseTexImage_evgl_thread_cmd(Display *dpy, GLXDrawable drawable, int buffer);
+EAPI void         glXSwapBuffers_evgl_thread_cmd(Display *dpy, GLXDrawable drawable);
+
+EAPI void         glXSwapIntervalEXT_orig_evgl_set(void *func);
+EAPI void        *glXSwapIntervalEXT_orig_evgl_get(void);
+EAPI void         glXSwapIntervalEXT_evgl_thread_cmd(Display *dpy, GLXDrawable drawable, int interval);
+
+EAPI void         glXSwapIntervalSGI_orig_evgl_set(void *func);
+EAPI void        *glXSwapIntervalSGI_orig_evgl_get(void);
+EAPI int          glXSwapIntervalSGI_evgl_thread_cmd(int interval);
+
+EAPI void         glXWaitVideoSync_orig_evgl_set(void *func);
+EAPI void        *glXWaitVideoSync_orig_evgl_get(void);
+EAPI int          glXWaitVideoSync_evgl_thread_cmd(int divisor, int remainder, unsigned int *count);
+
+#else /* ! EVAS_GL_RENDER_THREAD_COMPILE_FOR_GL_GENERIC */
+
+
+extern void         (*glXBindTexImage_orig_evas_set)(void *func);
+extern void        *(*glXBindTexImage_orig_evas_get)(void);
+extern void         (*glXBindTexImage_thread_cmd)(Display *dpy, GLXDrawable drawable, int buffer, const int *attrib_list);
+extern GLXFBConfig *(*glXChooseFBConfig_thread_cmd)(Display *dpy, int screen, const int *attribList, int *nitems);
+extern GLXContext   (*glXCreateContext_thread_cmd)(Display *dpy, XVisualInfo *vis, GLXContext shareList, Bool direct);
+extern GLXContext   (*glXCreateNewContext_thread_cmd)(Display *dpy, GLXFBConfig config, int renderType, GLXContext shareList, Bool direct);
+extern GLXPbuffer   (*glXCreatePbuffer_thread_cmd)(Display *dpy, GLXFBConfig config, const int *attribList);
+extern void         (*glXCreatePixmap_orig_evas_set)(void *func);
+extern void        *(*glXCreatePixmap_orig_evas_get)(void);
+extern GLXPixmap    (*glXCreatePixmap_thread_cmd)(Display *dpy, GLXFBConfig config, Pixmap pixmap, const int *attribList);
+extern GLXWindow    (*glXCreateWindow_thread_cmd)(Display *dpy, GLXFBConfig config, Window win, const int *attribList);
+extern void         (*glXDestroyContext_thread_cmd)(Display *dpy, GLXContext ctx);
+extern void         (*glXDestroyPbuffer_thread_cmd)(Display *dpy, GLXPbuffer pbuf);
+extern void         (*glXDestroyPixmap_orig_evas_set)(void *func);
+extern void        *(*glXDestroyPixmap_orig_evas_get)(void);
+extern void         (*glXDestroyPixmap_thread_cmd)(Display *dpy, GLXPixmap pixmap);
+extern void         (*glXDestroyWindow_thread_cmd)(Display *dpy, GLXWindow window);
+extern int          (*glXGetConfig_thread_cmd)(Display *dpy, XVisualInfo *visual, int attrib, int *value);
+extern GLXContext   (*glXGetCurrentContext_thread_cmd)(void);
+extern int          (*glXGetFBConfigAttrib_thread_cmd)(Display *dpy, GLXFBConfig config, int attribute, int *value);
+extern void         (*glXGetVideoSync_orig_evas_set)(void *func);
+extern void        *(*glXGetVideoSync_orig_evas_get)(void);
+extern int          (*glXGetVideoSync_thread_cmd)(unsigned int *count);
+extern XVisualInfo *(*glXGetVisualFromFBConfig_thread_cmd)(Display *dpy, GLXFBConfig config);
+extern Bool         (*glXMakeContextCurrent_thread_cmd)(Display *dpy, GLXDrawable draw, GLXDrawable read, GLXContext ctx);
+extern void         (*glXQueryDrawable_orig_evas_set)(void *func);
+extern void        *(*glXQueryDrawable_orig_evas_get)(void);
+extern void         (*glXQueryDrawable_thread_cmd)(Display *dpy, GLXDrawable draw, int attribute, unsigned int *value);
+extern Bool         (*glXQueryExtension_thread_cmd)(Display *dpy, int *errorb, int *event);
+extern const char  *(*glXQueryExtensionsString_thread_cmd)(Display *dpy, int screen);
+extern void         (*glXReleaseBuffersMESA_orig_evas_set)(void *func);
+extern void        *(*glXReleaseBuffersMESA_orig_evas_get)(void);
+extern Bool         (*glXReleaseBuffersMESA_thread_cmd)(Display *dpy, GLXDrawable drawable);
+extern void         (*glXReleaseTexImage_orig_evas_set)(void *func);
+extern void        *(*glXReleaseTexImage_orig_evas_get)(void);
+extern void         (*glXReleaseTexImage_thread_cmd)(Display *dpy, GLXDrawable drawable, int buffer);
+extern void         (*glXSwapBuffers_thread_cmd)(Display *dpy, GLXDrawable drawable);
+extern void         (*glXSwapIntervalEXT_orig_evas_set)(void *func);
+extern void        *(*glXSwapIntervalEXT_orig_evas_get)(void);
+extern void         (*glXSwapIntervalEXT_thread_cmd)(Display *dpy, GLXDrawable drawable, int interval);
+extern void         (*glXSwapIntervalSGI_orig_evas_set)(void *func);
+extern void        *(*glXSwapIntervalSGI_orig_evas_get)(void);
+extern int          (*glXSwapIntervalSGI_thread_cmd)(int interval);
+extern void         (*glXWaitVideoSync_orig_evas_set)(void *func);
+extern void        *(*glXWaitVideoSync_orig_evas_get)(void);
+extern int          (*glXWaitVideoSync_thread_cmd)(int divisor, int remainder, unsigned int *count);
 
 /****** EVAS GL ******/
 
-extern void (*glXBindTexImage_orig_evgl_set)(void *func);
-extern void *(*glXBindTexImage_orig_evgl_get)(void);
-extern void (*glXBindTexImage_evgl_thread_cmd)(Display *dpy, GLXDrawable drawable, int buffer, const int *attrib_list);
-extern GLXFBConfig * (*glXChooseFBConfig_evgl_thread_cmd)(Display *dpy, int screen, const int *attribList, int *nitems);
-extern GLXContext (*glXCreateContext_evgl_thread_cmd)(Display *dpy, XVisualInfo *vis, GLXContext shareList, Bool direct);
-extern GLXContext (*glXCreateNewContext_evgl_thread_cmd)(Display *dpy, GLXFBConfig config, int renderType, GLXContext shareList, Bool direct);
-extern GLXPbuffer (*glXCreatePbuffer_evgl_thread_cmd)(Display *dpy, GLXFBConfig config, const int *attribList);
-extern void (*glXCreatePixmap_orig_evgl_set)(void *func);
-extern void *(*glXCreatePixmap_orig_evgl_get)(void);
-extern GLXPixmap (*glXCreatePixmap_evgl_thread_cmd)(Display *dpy, GLXFBConfig config, Pixmap pixmap, const int *attribList);
-extern GLXWindow (*glXCreateWindow_evgl_thread_cmd)(Display *dpy, GLXFBConfig config, Window win, const int *attribList);
-extern void (*glXDestroyContext_evgl_thread_cmd)(Display *dpy, GLXContext ctx);
-extern void (*glXDestroyPbuffer_evgl_thread_cmd)(Display *dpy, GLXPbuffer pbuf);
-extern void (*glXDestroyPixmap_orig_evgl_set)(void *func);
-extern void *(*glXDestroyPixmap_orig_evgl_get)(void);
-extern void (*glXDestroyPixmap_evgl_thread_cmd)(Display *dpy, GLXPixmap pixmap);
-extern void (*glXDestroyWindow_evgl_thread_cmd)(Display *dpy, GLXWindow window);
-extern int (*glXGetConfig_evgl_thread_cmd)(Display *dpy, XVisualInfo *visual, int attrib, int *value);
-extern GLXContext (*glXGetCurrentContext_evgl_thread_cmd)(void);
-extern int (*glXGetFBConfigAttrib_evgl_thread_cmd)(Display *dpy, GLXFBConfig config, int attribute, int *value);
-extern void (*glXGetVideoSync_orig_evgl_set)(void *func);
-extern void *(*glXGetVideoSync_orig_evgl_get)(void);
-extern int (*glXGetVideoSync_evgl_thread_cmd)(unsigned int *count);
-extern XVisualInfo * (*glXGetVisualFromFBConfig_evgl_thread_cmd)(Display *dpy, GLXFBConfig config);
-extern Bool (*glXMakeContextCurrent_evgl_thread_cmd)(Display *dpy, GLXDrawable draw, GLXDrawable read, GLXContext ctx);
-extern void (*glXQueryDrawable_orig_evgl_set)(void *func);
-extern void *(*glXQueryDrawable_orig_evgl_get)(void);
-extern void (*glXQueryDrawable_evgl_thread_cmd)(Display *dpy, GLXDrawable draw, int attribute, unsigned int *value);
-extern Bool (*glXQueryExtension_evgl_thread_cmd)(Display *dpy, int *errorb, int *event);
-extern const char * (*glXQueryExtensionsString_evgl_thread_cmd)(Display *dpy, int screen);
-extern void (*glXReleaseBuffersMESA_orig_evgl_set)(void *func);
-extern void *(*glXReleaseBuffersMESA_orig_evgl_get)(void);
-extern Bool (*glXReleaseBuffersMESA_evgl_thread_cmd)(Display *dpy, GLXDrawable drawable);
-extern void (*glXReleaseTexImage_orig_evgl_set)(void *func);
-extern void *(*glXReleaseTexImage_orig_evgl_get)(void);
-extern void (*glXReleaseTexImage_evgl_thread_cmd)(Display *dpy, GLXDrawable drawable, int buffer);
-extern void (*glXSwapBuffers_evgl_thread_cmd)(Display *dpy, GLXDrawable drawable);
-extern void (*glXSwapIntervalEXT_orig_evgl_set)(void *func);
-extern void *(*glXSwapIntervalEXT_orig_evgl_get)(void);
-extern void (*glXSwapIntervalEXT_evgl_thread_cmd)(Display *dpy, GLXDrawable drawable, int interval);
-extern void (*glXSwapIntervalSGI_orig_evgl_set)(void *func);
-extern void *(*glXSwapIntervalSGI_orig_evgl_get)(void);
-extern int (*glXSwapIntervalSGI_evgl_thread_cmd)(int interval);
-extern void (*glXWaitVideoSync_orig_evgl_set)(void *func);
-extern void *(*glXWaitVideoSync_orig_evgl_get)(void);
-extern int (*glXWaitVideoSync_evgl_thread_cmd)(int divisor, int remainder, unsigned int *count);
+extern void         (*glXBindTexImage_orig_evgl_set)(void *func);
+extern void        *(*glXBindTexImage_orig_evgl_get)(void);
+extern void         (*glXBindTexImage_evgl_thread_cmd)(Display *dpy, GLXDrawable drawable, int buffer, const int *attrib_list);
+extern GLXFBConfig *(*glXChooseFBConfig_evgl_thread_cmd)(Display *dpy, int screen, const int *attribList, int *nitems);
+extern GLXContext   (*glXCreateContext_evgl_thread_cmd)(Display *dpy, XVisualInfo *vis, GLXContext shareList, Bool direct);
+extern GLXContext   (*glXCreateNewContext_evgl_thread_cmd)(Display *dpy, GLXFBConfig config, int renderType, GLXContext shareList, Bool direct);
+extern GLXPbuffer   (*glXCreatePbuffer_evgl_thread_cmd)(Display *dpy, GLXFBConfig config, const int *attribList);
+extern void         (*glXCreatePixmap_orig_evgl_set)(void *func);
+extern void        *(*glXCreatePixmap_orig_evgl_get)(void);
+extern GLXPixmap    (*glXCreatePixmap_evgl_thread_cmd)(Display *dpy, GLXFBConfig config, Pixmap pixmap, const int *attribList);
+extern GLXWindow    (*glXCreateWindow_evgl_thread_cmd)(Display *dpy, GLXFBConfig config, Window win, const int *attribList);
+extern void         (*glXDestroyContext_evgl_thread_cmd)(Display *dpy, GLXContext ctx);
+extern void         (*glXDestroyPbuffer_evgl_thread_cmd)(Display *dpy, GLXPbuffer pbuf);
+extern void         (*glXDestroyPixmap_orig_evgl_set)(void *func);
+extern void        *(*glXDestroyPixmap_orig_evgl_get)(void);
+extern void         (*glXDestroyPixmap_evgl_thread_cmd)(Display *dpy, GLXPixmap pixmap);
+extern void         (*glXDestroyWindow_evgl_thread_cmd)(Display *dpy, GLXWindow window);
+extern int          (*glXGetConfig_evgl_thread_cmd)(Display *dpy, XVisualInfo *visual, int attrib, int *value);
+extern GLXContext   (*glXGetCurrentContext_evgl_thread_cmd)(void);
+extern int          (*glXGetFBConfigAttrib_evgl_thread_cmd)(Display *dpy, GLXFBConfig config, int attribute, int *value);
+extern void         (*glXGetVideoSync_orig_evgl_set)(void *func);
+extern void        *(*glXGetVideoSync_orig_evgl_get)(void);
+extern int          (*glXGetVideoSync_evgl_thread_cmd)(unsigned int *count);
+extern XVisualInfo *(*glXGetVisualFromFBConfig_evgl_thread_cmd)(Display *dpy, GLXFBConfig config);
+extern Bool         (*glXMakeContextCurrent_evgl_thread_cmd)(Display *dpy, GLXDrawable draw, GLXDrawable read, GLXContext ctx);
+extern void         (*glXQueryDrawable_orig_evgl_set)(void *func);
+extern void        *(*glXQueryDrawable_orig_evgl_get)(void);
+extern void         (*glXQueryDrawable_evgl_thread_cmd)(Display *dpy, GLXDrawable draw, int attribute, unsigned int *value);
+extern Bool         (*glXQueryExtension_evgl_thread_cmd)(Display *dpy, int *errorb, int *event);
+extern const char  *(*glXQueryExtensionsString_evgl_thread_cmd)(Display *dpy, int screen);
+extern void         (*glXReleaseBuffersMESA_orig_evgl_set)(void *func);
+extern void        *(*glXReleaseBuffersMESA_orig_evgl_get)(void);
+extern Bool         (*glXReleaseBuffersMESA_evgl_thread_cmd)(Display *dpy, GLXDrawable drawable);
+extern void         (*glXReleaseTexImage_orig_evgl_set)(void *func);
+extern void        *(*glXReleaseTexImage_orig_evgl_get)(void);
+extern void         (*glXReleaseTexImage_evgl_thread_cmd)(Display *dpy, GLXDrawable drawable, int buffer);
+extern void         (*glXSwapBuffers_evgl_thread_cmd)(Display *dpy, GLXDrawable drawable);
+extern void         (*glXSwapIntervalEXT_orig_evgl_set)(void *func);
+extern void        *(*glXSwapIntervalEXT_orig_evgl_get)(void);
+extern void         (*glXSwapIntervalEXT_evgl_thread_cmd)(Display *dpy, GLXDrawable drawable, int interval);
+extern void         (*glXSwapIntervalSGI_orig_evgl_set)(void *func);
+extern void        *(*glXSwapIntervalSGI_orig_evgl_get)(void);
+extern int          (*glXSwapIntervalSGI_evgl_thread_cmd)(int interval);
+extern void         (*glXWaitVideoSync_orig_evgl_set)(void *func);
+extern void        *(*glXWaitVideoSync_orig_evgl_get)(void);
+extern int          (*glXWaitVideoSync_evgl_thread_cmd)(int divisor, int remainder, unsigned int *count);
 
 
 extern void _glx_thread_link_init();
 
 
-#endif /* EVAS_GL_RENDER_THREAD_IS_GENERIC */
+#endif /* EVAS_GL_RENDER_THREAD_COMPILE_FOR_GL_GENERIC */
 
 #endif /* ! GL_GLES */
 

diff --git a/src/modules/evas/engines/gl_generic/Evas_Engine_GL_Generic.h b/src/modules/evas/engines/gl_generic/Evas_Engine_GL_Generic.h
index acf9b1f..e5743ee 100644 (file)
--- a/src/modules/evas/engines/gl_generic/Evas_Engine_GL_Generic.h
+++ b/src/modules/evas/engines/gl_generic/Evas_Engine_GL_Generic.h
@@ -5,7 +5,6 @@
 #include "../gl_common/evas_gl_common.h"
 #include "../gl_common/evas_gl_core.h"
 #include "../gl_common/evas_gl_core_private.h"
-#include "../gl_common/evas_gl_thread.h"
 
 typedef struct _Render_Engine_GL_Generic Render_Engine_GL_Generic;
 typedef struct _Context_3D Context_3D;

diff --git a/src/modules/evas/engines/gl_generic/evas_engine.c b/src/modules/evas/engines/gl_generic/evas_engine.c
index d78eee3..ca2bceb 100644 (file)
--- a/src/modules/evas/engines/gl_generic/evas_engine.c
+++ b/src/modules/evas/engines/gl_generic/evas_engine.c
@@ -13,7 +13,6 @@
 #endif
 
 #include "../gl_common/evas_gl_common.h"
-#include "../gl_common/evas_gl_thread_gl.h"
 
 #include "Evas_Engine_GL_Generic.h"
 
@@ -1134,7 +1133,6 @@ eng_image_draw(void *data, void *context, void *surface, void *image, int src_x,
                              direct_surface);
 
         // Call pixel get function
-        // IS DDDDDDDDDDDDIRECT RENDERING
         evgl_get_pixels_pre();
         re->func.get_pixels(re->func.get_pixels_data, re->func.obj);
         evgl_get_pixels_post();

diff --git a/src/modules/evas/engines/gl_x11/evas_engine.c b/src/modules/evas/engines/gl_x11/evas_engine.c
index 05b97f2..029bfa2 100644 (file)
--- a/src/modules/evas/engines/gl_x11/evas_engine.c
+++ b/src/modules/evas/engines/gl_x11/evas_engine.c
@@ -3,11 +3,6 @@
 #include "../gl_common/evas_gl_define.h"
 #include "../software_generic/evas_native_common.h"
 
-#ifdef GL_GLES
-#include "../gl_common/evas_gl_thread_egl.h"
-#endif
-#include "../gl_common/evas_gl_thread_gl.h"
-
 #ifdef HAVE_DLSYM
 # include <dlfcn.h>      /* dlopen,dlclose,etc */
 #else

diff --git a/src/modules/evas/engines/gl_x11/evas_x_main.c b/src/modules/evas/engines/gl_x11/evas_x_main.c
old mode 100755 (executable)
new mode 100644 (file)
index 5fcc3e7..7fd9367
--- a/src/modules/evas/engines/gl_x11/evas_x_main.c
+++ b/src/modules/evas/engines/gl_x11/evas_x_main.c
@@ -2,11 +2,6 @@
 #include "../gl_common/evas_gl_define.h"
 #include <dlfcn.h>
 
-#ifdef GL_GLES
-#include "../gl_common/evas_gl_thread_egl.h"
-#endif
-#include "../gl_common/evas_gl_thread_gl.h"
-
 # define SET_RESTORE_CONTEXT() do { if (glsym_evas_gl_common_context_restore_set) glsym_evas_gl_common_context_restore_set(EINA_TRUE); } while(0)
 
 static Eina_TLS _outbuf_key = 0;

diff --git a/src/utils/evas/generate_gl_thread_api.py b/src/utils/evas/generate_gl_thread_api.py
new file mode 100755 (executable)
index 0000000..a4f58bc
--- /dev/null
+++ b/src/utils/evas/generate_gl_thread_api.py
@@ -0,0 +1,1194 @@
+#
+# GL threaded API generate tool
+#
+import os, sys, re
+import argparse
+
+global g_verbose
+global g_print_err
+global g_debug_lvl
+
+global g_evas_total
+global g_evgl_total
+global g_evgl_api_total
+
+api_dic_list = list()
+
+_NEWLINE = "\n"
+_MAX_COLUMN = 8
+
+################################################################################
+# api_def data format:
+# 1.| {EVAS |EVAS GL |EVAS GL API} | : Wrapper API types
+# 2.| {return type} |
+# 3.| {api name} |
+# 4.| {paramter1, 2,..} |
+# 5.| {enqueue|flush|finish} | : queue operation
+# 6.| {ext|noext} | : extension API or not
+# 7.| {memory pool name, size, value| userDefined | ""} |
+# 8.| {GL| GLES} | ""} | : GL types
+
+def parse_apidef(api):
+       api_dic = {}
+       parse_result = { 'parse_fail':True, 'type':"", 'queue_opr':"", 'ext':False, 'warning':"",
+                            'needCopy':False, 'needUserDefinedCopy':False, 'gl_type':False }
+
+       L = api.split('|')
+
+       if len(L) < _MAX_COLUMN :
+               print "*warning*\nfew column, check format,..(%s)" %(api)
+               return parse_result # few column, invalid format
+
+       api_dic['type'] = L[1].strip()
+       if api_dic['type'] == "EVAS GL API" :
+               api_dic['func_ptr'] = "orig_evgl_api"
+
+       parse_result['type'] = L[1].strip()
+
+       api_dic['return_type'] = L[2].strip()
+       api_dic['api_name'] = L[3].strip()
+
+       # make parameter list and name list
+       para_list = list()
+       para_name_list = list()
+
+       p = re.compile('[a-zA-Z_+][_a-zA-Z0-9]*') # variable pattern
+
+       for para in L[4].split(','):
+               para_list.append(para.strip())
+
+               match_list = p.findall(para.strip())
+               if len(match_list) < 2 :
+                       pass # invalid type or variable name OR 'void'
+               else :
+                       para_name_list.append(match_list[len(match_list) -1])
+
+       api_dic['para_list'] = para_list
+       api_dic['para_name_list'] = para_name_list
+
+       api_dic['queue_opr'] = L[5].strip()
+       parse_result['queue_opr'] = L[5].strip()
+
+       api_dic['extYN'] = L[6].strip()
+       if L[6].strip() == "ext":
+               parse_result['ext'] = True
+               if api_dic['type'] == "EVAS" : api_dic['func_ptr'] = "orig_evas"
+               elif api_dic['type'] == "EVAS GL" : api_dic['func_ptr'] = "orig_evgl"
+
+       if len(L[7].strip()) > 0 and api_dic['queue_opr'] == "flush": # need copy
+               parse_result['needCopy'] = True
+               copy_info = L[7].split(',')
+
+               if copy_info[0].strip() == "userDefined" :
+                       api_dic['userDefinedCopy'] = True
+                       parse_result['needUserDefinedCopy'] = True
+               else :
+                       if len(copy_info) is 3 : # {memory pool name, size, val}
+                               api_dic['mp_name'] = copy_info[0].strip()
+                               api_dic['copy_size'] = copy_info[1].strip()
+                               api_dic['copy_val'] = copy_info[2].strip()
+                       else :
+                               parse_result['warning'] = "invalid copy info,..(%s)" %(api_dic['api_name'])
+
+       if len(L[8].strip()) > 0 : #if defiend gl_type
+               api_dic['gl_type'] = L[8].strip()
+               parse_result['gl_type'] = L[8].strip()
+
+       api_dic_list.append(api_dic)
+       parse_result['parse_fail'] = False
+
+       return parse_result
+
+#--------------------------------------------------------------
+def add_result(parse_result, result) :
+
+       if parse_result['parse_fail'] is True:
+               result['fail'] += 1
+       else :
+               result['success'] += 1
+
+       if parse_result['queue_opr'] == "flush" :
+               result['flush'] += 1
+       elif parse_result['queue_opr'] == "finish" :
+               result['finish'] += 1
+       elif parse_result['queue_opr'] == "enqueue" :
+               result['enqueue'] += 1
+
+       if parse_result['ext'] is True:
+               result['ext'] += 1
+       if parse_result['needCopy'] is True:
+               result['needCopy'] += 1
+       if parse_result['needUserDefinedCopy'] is True:
+               result['needUserDefinedCopy'] += 1
+       if parse_result['gl_type']  == "GL" :
+               result['gl'] += 1
+       if len(parse_result['warning']) > 0:
+               result['warning'].append(parse_result['warning'])
+
+
+def get_api_def(api_list_file) :
+
+       warning_msgs = list()
+       result  = list()
+       result_evas = { 'success':0, 'fail':0, 'warning':warning_msgs,
+                         'flush':0, 'finish':0, 'enqueue':0,
+                         'ext':0, 'needCopy':0, 'needUserDefinedCopy':0, 'gl':0 }
+       result_evgl = { 'success':0, 'fail':0, 'warning':warning_msgs,
+                           'flush':0, 'finish':0, 'enqueue':0,
+                           'ext':0, 'needCopy':0, 'needUserDefinedCopy':0, 'gl':0 }
+       result_evgl_api = { 'success':0, 'fail':0, 'warning':warning_msgs,
+                               'flush':0, 'finish':0, 'enqueue':0,
+                               'ext':0, 'needCopy':0, 'needUserDefinedCopy':0, 'gl':0 }
+       f = open(api_list_file, 'r')
+
+       lines = f.readlines()
+       f.close()
+
+       for line in lines :
+               api = line.strip()
+
+               if len(api) is 0 : #empty line
+                       continue
+
+               if api[0] is '/' and api[1] is '*' : # "/*" comment start
+                       continue
+               if api[0] is '*' or api[0] is '/' :
+                       continue
+
+               if api[0] is not '#' : # if not comment line
+                       parse_result = parse_apidef(api)
+                       if parse_result['type'] == "EVAS" :
+                               add_result(parse_result, result_evas)
+
+                       elif parse_result['type'] == "EVAS GL" :
+                               add_result(parse_result, result_evgl)
+
+                       elif parse_result['type'] == "EVAS GL API" :
+                               add_result(parse_result, result_evgl_api)
+
+
+       result.append(result_evas)
+       result.append(result_evgl)
+       result.append(result_evgl_api)
+
+       return result
+
+#--------------------------------------------------------------
+def list_to_str (name_list) :
+       name_str = ""
+       for p in name_list:
+               if (name_list.index(p) > 0) :
+                       name_str += ", "
+               name_str += p
+
+       return name_str
+
+# debug_lvl is 1 or 2
+def logging_and_counter (func_name) :
+
+       func_body = _NEWLINE
+       if g_print_err : func_body += "ERR(\"(counter:%d)\\n\", "
+       else           : func_body += "fprintf(stderr,\" %s(%d)\\n\", __func__, "
+       func_body += "%s_counter++);" %(func_name)
+       func_body += "\n"
+
+       return func_body
+
+# debug_lvl is 2
+def define_timeval() :
+       func_body = _NEWLINE
+       func_body += "struct timeval tv1, tv2; /* time value 1, 2 */"
+       func_body += _NEWLINE
+       func_body += "double et;               /* elapsed time */"
+       func_body += _NEWLINE
+
+       return func_body
+
+def elapsed_time (tv1, tv2) :
+
+       func_body = _NEWLINE
+       func_body += "et = (%s.tv_sec - %s.tv_sec) * 1000.0;\n" %(tv1, tv2)
+       func_body += "et += (%s.tv_usec - %s.tv_usec) / 1000.0;\n" %(tv1, tv2)
+       func_body += _NEWLINE
+
+       return func_body
+
+# debug_lvl is 3
+def check_glError() :
+
+       func_body = _NEWLINE
+       func_body += "/* for debug, check glError */\n"
+       func_body += "GLenum err = glGetError();\n"
+       func_body += "if (err != GL_NO_ERROR)\n"
+       func_body += "ERR(\"glGetError(%x)\", err);\n"
+       func_body += _NEWLINE
+
+       return func_body
+
+def LOG (buf) :
+       if g_verbose: print buf
+
+def FWRITE (fp, buf) :
+       fp.write(buf)
+
+################################################################################
+def gen_structure(api_def_dic):
+
+       api_type = api_def_dic['type']
+       return_type = api_def_dic['return_type']
+       api_name = api_def_dic['api_name'].strip()
+       para_list = api_def_dic['para_list']
+       para_name_list = api_def_dic['para_name_list']
+       queue_opr = api_def_dic['queue_opr']
+       if api_type == "EVAS" :
+               struct_name_prefix = "Evas_Thread_Command"
+       elif api_type == "EVAS GL" :
+               struct_name_prefix = "EVGL_Thread_Command"
+       elif api_type == "EVAS GL API" :
+               struct_name_prefix = "EVGL_API_Thread_Command"
+
+       s_member = ""
+       if (return_type == "void") and (len(para_name_list) == 0) and g_debug_lvl is not 2 :
+                       return ""
+
+       if g_debug_lvl is 2:
+               s_member += _NEWLINE
+               s_member += "struct timeval tv;"
+
+       if return_type != "void" :
+               s_member += _NEWLINE
+               s_member += return_type + " return_value;"
+       for p in para_list :
+               if p ==  "void":
+                       pass
+               else :
+                       s_member += _NEWLINE
+                       s_member += p + ";"
+
+       if 'copy_val' in api_def_dic :
+               s_member += _NEWLINE
+               s_member += "void *%s_copied; /* COPIED */" %(api_def_dic['copy_val'])
+
+       if queue_opr != "finish" :
+               s_member += _NEWLINE
+               s_member += "int command_allocated;"
+
+       if 'userDefinedCopy' in api_def_dic :
+               s_member += _NEWLINE
+               s_member += "%s_COPY_VARIABLE; /* TODO */" %(api_name.upper())
+       s_member += _NEWLINE
+
+       struct_data = """
+typedef struct
+{%s
+} %s_%s;
+""" %(s_member, struct_name_prefix, api_name)
+
+       return struct_data
+
+#--------------------------------------------------------------
+def gen_function_pointer(api_def_dic) :
+
+       if ('func_ptr' in api_def_dic) is False :
+               return ""
+
+       func_ptr = api_def_dic['func_ptr']
+       api_type = api_def_dic['type']
+       return_type = api_def_dic['return_type']
+       api_name = api_def_dic['api_name']
+       para_data = list_to_str(api_def_dic['para_list'])
+
+       fp_name = "%s_%s" %(func_ptr, api_name)
+       func_body = "\n%s (*%s)(%s);\n" %(return_type, fp_name, para_data)
+
+       if api_type == "EVAS GL API" :
+               return func_body
+       else :
+               func_body += """
+void
+%s_%s_set(void *func)
+{
+%s = func;
+}
+
+void *
+%s_%s_get(void)
+{
+return %s;
+}
+""" %(api_name, func_ptr, fp_name,
+         api_name, func_ptr, fp_name)
+
+       return func_body
+
+#--------------------------------------------------------------
+def gen_gl_thread_api(api_def_dic) :
+
+       api_type = api_def_dic['type']
+       api_name = api_def_dic['api_name']
+       return_type = api_def_dic['return_type']
+       para_name_list = api_def_dic['para_name_list']
+       extYN = api_def_dic['extYN']
+       queue_opr = api_def_dic['queue_opr']
+       gl_prefix = ""
+
+       if api_type == "EVAS" :
+               struct_name_prefix = "Evas_Thread_Command"
+               func_name_prefix = "_gl_thread"
+               if extYN == "ext" :     gl_prefix = "orig_evas_" # for extension
+       elif api_type == "EVAS GL" :
+               struct_name_prefix = "EVGL_Thread_Command"
+               func_name_prefix = "_evgl_thread"
+               if extYN == "ext" :     gl_prefix = "orig_evgl_" # for extension
+       elif api_type == "EVAS GL API" :
+               struct_name_prefix = "EVGL_API_Thread_Command"
+               func_name_prefix = "_evgl_api_thread"
+               gl_prefix = "orig_evgl_api_"
+
+       para_data = "void *data"
+       func_body = ""
+
+       # logging & increase counter
+       if g_debug_lvl is 1 :
+               func_body += logging_and_counter(func_name_prefix + "_" + api_name)
+       elif g_debug_lvl is 2 :
+               func_body += define_timeval()
+
+       if (return_type == "void") and (len(para_name_list) == 0) and g_debug_lvl is not 2:
+                       para_data += " EINA_UNUSED"
+
+       else :
+               func_body += _NEWLINE
+               func_body += "%s_%s *thread_data =\n" %(struct_name_prefix, api_name)
+               func_body += "(%s_%s *)data;\n" %(struct_name_prefix, api_name)
+
+       func_body += _NEWLINE
+
+       # get time of callback function call,..
+       if g_debug_lvl is 2:
+               func_body += "gettimeofday(&tv1, NULL);\n"
+               func_body += elapsed_time("tv1", "(thread_data->tv)")
+               func_body += "printf(\"[%f] callback(%s)\\n\", et, __func__);"
+               func_body += "\n\n"
+
+       if return_type != "void" :
+               if g_debug_lvl is 3 :
+                       func_body += "%s return_value = " %(return_type)
+               else :
+                       func_body += "thread_data->return_value = "
+
+       func_body += "%s%s(" %(gl_prefix, api_name) #GL API or function pointer call
+
+       for p in para_name_list:
+               if (para_name_list.index(p) > 0) :
+                       func_body += ","
+                       func_body += _NEWLINE
+               func_body += "thread_data->%s" %(p)
+       func_body += ");\n"
+
+       # get time of GL API done,..
+       if g_debug_lvl is 2:
+               func_body += _NEWLINE
+               func_body += "gettimeofday(&tv2, NULL);\n"
+               func_body += elapsed_time("tv2", "tv1")
+               func_body += "printf(\"\\t[%f] GL done.\\n\", et);"
+               func_body += _NEWLINE
+               func_body += "memcpy(&(thread_data->tv), &tv2, sizeof(struct timeval));\n"
+
+       if g_debug_lvl is 3 :
+               func_body += _NEWLINE
+               func_body += check_glError()
+               if return_type != "void" :
+                       func_body += "thread_data->return_value = return_value;\n"
+
+       # if copy variable, free
+       if 'copy_val' in api_def_dic:
+               func_body += "\n"
+               func_body += _NEWLINE
+               func_body += "if (thread_data->%s_copied)" %(api_def_dic['copy_val'])
+               func_body += _NEWLINE
+               func_body += "eina_mempool_free(%s, thread_data->%s_copied);\n" %(api_def_dic['mp_name'],
+                                                                   api_def_dic['copy_val'])
+
+       # if userDefinedCopy
+       if 'userDefinedCopy' in api_def_dic :
+               func_body += "\n"
+               func_body += "%s_COPY_VARIABLE_FREE; /* TODO */\n" %(api_name.upper())
+
+       # thread_data free
+       if (queue_opr != "finish") and len(para_name_list) > 0:
+               func_body += "\n"
+               func_body += "if (thread_data->command_allocated)\n"
+               func_body += "eina_mempool_free(_mp_command, thread_data);"
+
+       return """
+static void
+%s_%s(%s)
+{%s
+}
+""" %(func_name_prefix, api_name, para_data, func_body)
+
+#--------------------------------------------------------------
+def gen_thread_cmd_api(api_def_dic) :
+
+       api_type = api_def_dic['type']
+       api_name = api_def_dic['api_name']
+       return_type = api_def_dic['return_type']
+       para_list = api_def_dic['para_list']
+       para_name_list = api_def_dic['para_name_list']
+       queue_opr = api_def_dic['queue_opr']
+#      if queue_opr == "flush" or queue_opr == "enqueue" :
+#              print "(%s)%s:%s" %(api_type, api_name, queue_opr)
+       extYN = api_def_dic['extYN']
+       gl_prefix = ""
+       queue_type = ""
+       if 'copy_val' in api_def_dic :
+               mp_name = api_def_dic['mp_name']
+               copy_val = api_def_dic['copy_val']
+               copy_size = api_def_dic['copy_size']
+
+       if api_type == "EVAS" :
+               env_check = "!evas_gl_thread_enabled()"
+               struct_name_prefix = "Evas_Thread_Command"
+               func_name_prefix = "_gl_thread"
+               func_suffix = "thread_cmd"
+               queue_type = "EVAS_GL_THREAD_TYPE_GL"
+               if extYN == "ext" :     gl_prefix = "orig_evas_" # for extension
+       elif api_type == "EVAS GL" :
+               env_check = "!evas_evgl_thread_enabled()"
+               struct_name_prefix = "EVGL_Thread_Command"
+               queue_type = "EVAS_GL_THREAD_TYPE_EVGL"
+               func_name_prefix = "_evgl_thread"
+               func_suffix = "evgl_thread_cmd"
+               if extYN == "ext" :     gl_prefix = "orig_evgl_" # for extension
+       elif api_type == "EVAS GL API" :
+               env_check = "!evas_evgl_thread_enabled() || (_main_thread_id != eina_thread_self())"
+               struct_name_prefix = "EVGL_API_Thread_Command"
+               queue_type = "EVAS_GL_THREAD_TYPE_EVGL"
+               func_name_prefix = "_evgl_api_thread"
+               func_suffix = "evgl_api_thread_cmd"
+               gl_prefix = "orig_evgl_api_"
+
+       para_data = ""
+       func_body = ""
+
+       if len(para_name_list) == 0 :
+               para_data += "void"
+       else :
+               para_data += list_to_str(para_list)
+
+       para_val = "NULL"
+
+       # logging & increase counter
+       if g_debug_lvl is 1 :
+               func_body += logging_and_counter(api_name + "_" + func_suffix)
+       # if debug level 2, define timeval
+       elif g_debug_lvl is 2 :
+               func_body += _NEWLINE
+               func_body += "printf(\"%s\\n\", __func__);\n"
+               func_body += define_timeval()
+
+       # check use_gl_thread_cmd()
+       func_body += _NEWLINE
+       func_body += "if (%s)" %(env_check)
+       func_body += _NEWLINE
+       func_body += "{"
+       func_body += _NEWLINE
+
+       if g_debug_lvl is 2: # if debug level 2, check elapsed time
+               func_body += _NEWLINE
+               func_body += "gettimeofday(&tv1, NULL);\n"
+               func_body += _NEWLINE
+               if return_type != "void" :
+                       func_body += "%s rc;" %(return_type)
+                       func_body += _NEWLINE
+                       func_body += "rc = "
+               func_body += "%s%s(%s);\n" %(gl_prefix, api_name, list_to_str(para_name_list))
+               func_body += _NEWLINE
+               func_body += "gettimeofday(&tv2, NULL);\n"
+               func_body += elapsed_time("tv2", "tv1")
+               func_body += "printf(\"\\t[%f] GL done. RENDER_THREAD_OFF\\n\", et);\n"
+
+               if return_type != "void" :
+                       func_body += "return rc;"
+                       func_body += _NEWLINE
+               else :
+                       func_body += "return;"
+                       func_body += _NEWLINE
+
+       else : # not debug mode
+               if return_type == "void" :
+                       func_body += "%s%s(%s);" %(gl_prefix, api_name, list_to_str(para_name_list))
+                       func_body += _NEWLINE
+                       func_body += "return;"
+
+               else :
+                       func_body += "return %s%s(%s);" %(gl_prefix, api_name, list_to_str(para_name_list))
+               func_body += _NEWLINE
+
+       func_body += "}"
+       func_body += _NEWLINE
+
+       # thread_mode
+       func_body += _NEWLINE
+       func_body += "int thread_mode = EVAS_GL_THREAD_MODE_FINISH;\n"
+
+       # Has structure
+       if (return_type != "void") or (len(para_name_list) > 0) or (g_debug_lvl is 2):
+               para_val = "thread_data"
+               func_body += _NEWLINE
+               func_body += "%s_%s thread_data_local;\n" %(struct_name_prefix, api_name)
+               func_body += "%s_%s *thread_data = &thread_data_local;\n" %(struct_name_prefix,
+                                                                                                                                               api_name)
+
+               # check force_finish() before malloc
+               if queue_opr != "finish" :
+                       func_body += _NEWLINE
+                       func_body += "/* command_allocated flag init. */\n"
+                       func_body += "thread_data->command_allocated = 0;\n"
+                       func_body += _NEWLINE
+                       func_body += "if (!evas_gl_thread_force_finish())\n"
+                       func_body += "{ /* _flush */\n"
+                       func_body += "%s_%s *thread_data_new;\n" %(struct_name_prefix, api_name)
+                       func_body += "thread_data_new = eina_mempool_malloc(_mp_command,\n"
+                       func_body += "sizeof(%s_%s));\n" %(struct_name_prefix, api_name)
+                       func_body += "if (thread_data_new)\n"
+                       func_body += "{\n"
+                       func_body += "thread_data = thread_data_new;\n"
+                       func_body += "thread_data->command_allocated = 1;\n"
+                       func_body += "thread_mode = EVAS_GL_THREAD_MODE_%s;\n" %(queue_opr.upper())
+                       func_body += "}\n"
+                       func_body += "}\n"
+
+               # assign parameter to thread_data
+               for p in para_name_list :
+                       func_body += _NEWLINE
+
+                       idx = para_list[para_name_list.index(p)].find('[') # if parameter is array
+                       if idx > 0 :
+                               p_dat = para_list[para_name_list.index(p)].split() # type name[size]
+                               p_type = p_dat[0]               # get type
+                               p_temp = p_dat[1].split('[')    # get size
+                               p_size = p_temp[1].split(']')
+                               func_body += "memcpy(thread_data->%s, &%s, sizeof(%s) * %s);" %(p, p, p_type,
+                                                                                                                                                                       p_size[0])
+                       else :
+                               func_body += "thread_data->%s = %s;" %(p, p)
+
+               func_body += _NEWLINE
+               # end of assign
+
+               if 'copy_val' in api_def_dic :
+                       func_body += _NEWLINE
+                       func_body += "thread_data->%s_copied = NULL;" %(copy_val)
+
+               if 'userDefinedCopy' in api_def_dic :
+                       func_body += _NEWLINE
+                       func_body += "%s_COPY_VARIABLE_INIT; /* TODO */\n" %(api_name.upper())
+
+               if queue_opr != "finish" and ('copy_val' in api_def_dic or
+                                                                               'userDefinedCopy' in api_def_dic):
+                       func_body += _NEWLINE
+                       func_body += "if (thread_mode == EVAS_GL_THREAD_MODE_FINISH)\n"
+                       func_body += "goto finish;\n"
+
+               # if copy_val defined, copy to given memory pool
+               if 'copy_val' in api_def_dic :
+                       param = para_list[para_name_list.index(copy_val)]
+                       idx = param.find('*')
+                       p_type = param[:idx]
+
+                       func_body += _NEWLINE
+                       func_body += "/* copy variable */\n"
+                       func_body += "if (%s)\n" %(copy_val)
+                       func_body += "{\n"
+
+                       func_body += "/* 1. check memory size */\n"
+                       func_body += "unsigned int copy_size = %s;\n" %(copy_size)
+                       func_body += "if (copy_size > %s_memory_size)\n" %(mp_name)
+                       func_body += "{\n"
+                       func_body += "thread_mode = EVAS_GL_THREAD_MODE_FINISH;\n"
+                       func_body += "goto finish;\n"
+                       func_body += "}\n"
+
+                       func_body += "/* 2. malloc & copy */\n"
+                       func_body += "thread_data->%s_copied = " %(copy_val)
+                       func_body += "eina_mempool_malloc(%s, copy_size);\n" %(mp_name)
+                       func_body += "if (thread_data->%s_copied)\n" %(copy_val)
+                       func_body += "{\n"
+                       func_body += "memcpy(thread_data->%s_copied, %s, copy_size);\n" %(copy_val, copy_val)
+                       func_body += "}\n"
+                       func_body += "else\n"
+                       func_body += "{\n"
+                       func_body += "thread_mode = EVAS_GL_THREAD_MODE_FINISH;\n"
+                       func_body += "goto finish;\n"
+                       func_body += "}\n"
+
+                       func_body += "/* 3. replace */\n"
+                       func_body += "thread_data->%s = (%s *)thread_data->%s_copied;\n" %(copy_val, p_type, copy_val)
+                       func_body += "}\n"
+
+                       func_body += "/* end of copy variable */"
+                       func_body += _NEWLINE
+
+       # get time of enqueue
+       if g_debug_lvl is 2:
+               func_body += "gettimeofday(&tv1, NULL);\n"
+               func_body += "memcpy(&(thread_data->tv), &tv1, sizeof(struct timeval));"
+               func_body += _NEWLINE
+
+       if 'userDefinedCopy' in api_def_dic :
+               func_body += _NEWLINE
+               func_body += "%s_COPY_TO_MEMPOOL; /* TODO */" %(api_name.upper())
+               func_body += _NEWLINE
+
+       if queue_opr != "finish" and ('copy_val' in api_def_dic or 'userDefinedCopy' in api_def_dic):
+               func_body += _NEWLINE
+               func_body += "finish:"
+
+       func_body += _NEWLINE
+       func_body += "evas_gl_thread_cmd_enqueue(%s,\n" %(queue_type)
+       func_body += "%s_%s,\n" %(func_name_prefix, api_name)
+       func_body += "%s,\n" %(para_val)
+       func_body += "thread_mode);"
+       func_body += _NEWLINE
+
+       if g_debug_lvl is 2:
+               func_body += _NEWLINE
+               func_body += "gettimeofday(&tv2, NULL);\n"
+               func_body += elapsed_time("tv2", "(thread_data->tv)")
+               func_body += "printf(\"\\t\\t[%f] return\\n\", et);"
+               func_body += _NEWLINE
+               func_body += "gettimeofday(&tv2, NULL);\n"
+               func_body += elapsed_time("tv2", "tv1")
+               func_body += "printf(\"\\t\\t\\t[%f]\\n\", et);"
+               func_body += _NEWLINE
+
+       # Has return
+       if return_type != "void" :
+               func_body += _NEWLINE
+               func_body += "return thread_data->return_value;"
+               func_body += _NEWLINE
+
+       return """
+EAPI %s
+%s_%s(%s)
+{%s}
+""" %(return_type, api_name, func_suffix, para_data, func_body)
+
+#--------------------------------------------------------------
+def gen_wrapper_api_header(api_def_dic) :
+
+       api_type = api_def_dic['type']
+       api_name = api_def_dic['api_name']
+       return_type = api_def_dic['return_type']
+       para_data = list_to_str(api_def_dic['para_list'])
+       extYN = api_def_dic['extYN']
+       if api_type == "EVAS" :                  api_suffix = "thread_cmd"
+       elif api_type == "EVAS GL" :     api_suffix = "evgl_thread_cmd"
+       elif api_type == "EVAS GL API" : api_suffix = "evgl_api_thread_cmd"
+
+       header_data = ""
+
+       if 'func_ptr' in api_def_dic:
+               func_prefix = api_def_dic['func_ptr']
+               if api_type == "EVAS" or api_type == "EVAS GL" :
+                       header_data += _NEWLINE
+                       header_data += _NEWLINE
+                       header_data += "EAPI void %s_%s_set(void *func);" %(api_name, func_prefix)
+                       header_data += _NEWLINE
+                       header_data += "EAPI void *%s_%s_get(void);" %(api_name, func_prefix)
+               elif api_type == "EVAS GL API" :
+                       header_data += _NEWLINE
+                       header_data += _NEWLINE
+                       header_data += "extern %s (*%s_%s)(%s);" %(return_type, func_prefix,
+                                                                                                       api_name, para_data)
+
+       header_data += _NEWLINE
+       header_data += "EAPI %s %s_%s(%s);" %(return_type, api_name, api_suffix, para_data)
+       if 'gl_type' in api_def_dic and api_def_dic['gl_type'] == "GL" : header_data += _NEWLINE
+
+       return header_data
+
+#--------------------------------------------------------------
+def gen_init_func_data(func_type) :
+
+       init_func_data = "\n\nvoid\n_gl_thread_link_%s_generated_init()\n{\n" %(func_type)
+       init_func_data += \
+"""#define LINK2GENERIC(sym) \\
+       sym = dlsym(RTLD_DEFAULT, #sym); \\
+       if (!sym) ERR("Could not find function '%s'", #sym);
+"""
+       return init_func_data
+
+def gen_symload_set_get(api_dic) :
+
+       fp_name = "%s_%s" %(api_dic['api_name'], api_dic['func_ptr'])
+       symload_data = "LINK2GENERIC(%s_set);" %(fp_name)
+       symload_data += _NEWLINE
+       symload_data += "LINK2GENERIC(%s_get);" %(fp_name)
+       symload_data += _NEWLINE
+
+       return symload_data
+
+#--------------------------------------------------------------
+
+# for debug
+def api_define_print(api) :
+
+       return """
+/*
+* %s
+* %s(%s);
+*/
+""" %(api['return_type'], api['api_name'], list_to_str(api['para_list']))
+
+
+###############################################################################
+def generate_files(out_fname) :
+
+       gen_files = {} # {file name : file pointer}
+       if g_evas_total > 0 :
+               gl_src = out_fname + "_gl_generated.c"
+               gl_hdr = out_fname + "_gl_generated.h"
+
+               gen_files[gl_src] = open(gl_src, 'w')
+               gen_files[gl_hdr] = open(gl_hdr, 'w')
+
+               gl_link_src = out_fname + "_gl_link_generated.c"
+               gl_link_hdr = out_fname + "_gl_link_generated.h"
+
+               gen_files[gl_link_src] = open(gl_link_src, 'w')
+               gen_files[gl_link_hdr] = open(gl_link_hdr, 'w')
+
+       if g_evgl_total > 0 :
+               evgl_src = out_fname + "_evgl_generated.c"
+               evgl_hdr = out_fname + "_evgl_generated.h"
+
+               gen_files[evgl_src] = open(evgl_src, 'w')
+               gen_files[evgl_hdr] = open(evgl_hdr, 'w')
+
+               evgl_link_src = out_fname + "_evgl_link_generated.c"
+               evgl_link_hdr = out_fname + "_evgl_link_generated.h"
+
+               gen_files[evgl_link_src] = open(evgl_link_src, 'w')
+               gen_files[evgl_link_hdr] = open(evgl_link_hdr, 'w')
+
+       if g_evgl_api_total > 0 :
+               evgl_api_src = out_fname + "_evgl_api_generated.c"
+               evgl_api_hdr = out_fname + "_evgl_api_generated.h"
+
+               gen_files[evgl_api_src] = open(evgl_api_src, 'w')
+               gen_files[evgl_api_hdr] = open(evgl_api_hdr, 'w')
+
+       return gen_files
+#--------------------------------------------------------------
+def generate_code(out_files) :
+
+       auto_gen_msg = """/*
+* This is an automatically generated file using a python script.
+* ($EFL_HOME/src/utils/evas/generate_gl_thread_api.py)
+* Recommend that you modify data files ($EFL_HOME/src/utils/evas/gl_api_def.txt)
+* and make use of scripts if you need to fix them.
+*/
+"""
+       evgl_header_file_head = \
+"""
+#define EVAS_GL_NO_GL_H_CHECK 1
+#include "Evas_GL.h"
+
+#ifdef EAPI
+# undef EAPI
+#endif
+
+#ifdef _WIN32
+# ifdef EFL_EVAS_BUILD
+#  ifdef DLL_EXPORT
+#   define EAPI __declspec(dllexport)
+#  else
+#   define EAPI
+#  endif /* ! DLL_EXPORT */
+# else
+#  define EAPI __declspec(dllimport)
+# endif /* ! EFL_EVAS_BUILD */
+#else
+# ifdef __GNUC__
+#  if __GNUC__ >= 4
+#   define EAPI __attribute__ ((visibility("default")))
+#  else
+#   define EAPI
+#  endif
+# else
+#  define EAPI
+# endif
+#endif /* ! _WIN32 */
+"""
+
+       files = out_files.keys()
+
+       # get file pointer, init. files...
+       for f in files :
+               out_files[f].truncate()
+               out_files[f].write(auto_gen_msg)
+
+               # EVAS
+               if f.find("_gl_generated.c") > 0 :
+                       gl_source_file = out_files[f]
+                       if g_debug_lvl is 2 : gl_source_file.write("#include <sys/time.h>\n")
+               if f.find("_gl_generated.h") > 0 :
+                       gl_header_file = out_files[f]
+               if f.find("_gl_link_generated.c") > 0 :
+                       gl_link_source_file = out_files[f]
+               if f.find("_gl_link_generated.h") > 0 :
+                       gl_link_header_file = out_files[f]
+
+               # EVAS GL
+               if f.find("_evgl_generated.c") > 0 :
+                       evgl_source_file = out_files[f]
+                       if g_debug_lvl is 2 : evgl_source_file.write("#include <sys/time.h>\n")
+               if f.find("_evgl_generated.h") > 0 :
+                       evgl_header_file = out_files[f]
+                       evgl_header_file.write(evgl_header_file_head)
+               if f.find("_evgl_link_generated.c") > 0 :
+                       evgl_link_source_file = out_files[f]
+               if f.find("_evgl_link_generated.h") > 0 :
+                       evgl_link_header_file = out_files[f]
+
+               # EVAS GL API
+               if f.find("_evgl_api_generated.c") > 0 :
+                       evgl_api_source_file = out_files[f]
+                       if g_debug_lvl is 2 : evgl_api_source_file.write("#include <sys/time.h>\n")
+               if f.find("_evgl_api_generated.h") > 0 :
+                       evgl_api_header_file = out_files[f]
+                       evgl_api_header_file.write(evgl_header_file_head)
+
+       #print ">>> code generate START >>>"
+       #if debug mode, define counter variable
+       if g_debug_lvl is 1 :
+               if g_evas_total > 0 : gl_source_file.write("\n\n/* DEBUG */\n\n")
+               if g_evgl_total > 0 : evgl_source_file.write("\n\n/* DEBUG */\n\n")
+               if g_evgl_api_total > 0 : evgl_api_source_file.write("\n\n/* DEBUG */\n\n")
+
+               for api_dic in api_dic_list :
+                       if api_dic['type'] == "EVAS" :
+                               api_prefix = "_gl_thread"
+                               api_suffix = "thread_cmd"
+                               fp = gl_source_file
+                       elif api_dic['type'] == "EVAS GL" :
+                               api_prefix = "_evgl_thread"
+                               api_suffix = "evgl_thread_cmd"
+                               fp = evgl_source_file
+                       elif api_dic['type'] == "EVAS GL API" :
+                               api_prefix = "_evgl_api_thread"
+                               api_suffix = "evgl_api_thread_cmd"
+                               fp = evgl_api_source_file
+
+                       # check gl type,..
+                       ifdef_stmt = ""
+                       endif_stmt = ""
+                       if 'gl_type' in api_dic and api_dic['gl_type'] == "GL" :
+                               ifdef_stmt = "#ifndef GL_GLES\n"
+                               endif_stmt = "\n#endif\n"
+
+                       counter = ifdef_stmt
+                       counter += "int %s_%s_counter = 1;\n" %(api_prefix, api_dic['api_name'])
+                       counter += "int %s_%s_counter = 1;\n" %(api_dic['api_name'], api_suffix)
+                       counter += endif_stmt
+
+                       LOG(counter)
+                       FWRITE(fp, counter)
+
+       # generate wrapper API
+       for api_dic in api_dic_list :
+
+               api_name = api_dic['api_name']
+               return_type = api_dic['return_type']
+               para_data = list_to_str(api_dic['para_list'])
+               api_type = api_dic['type']
+
+               if api_type == "EVAS" :
+                       fp_src = gl_source_file
+                       fp_hdr = gl_header_file
+                       fp_link_src = gl_link_source_file
+                       fp_link_hdr = gl_link_header_file
+                       api_suffix = "thread_cmd"
+               elif api_type == "EVAS GL" :
+                       fp_src = evgl_source_file
+                       fp_hdr = evgl_header_file
+                       fp_link_src = evgl_link_source_file
+                       fp_link_hdr = evgl_link_header_file
+                       api_suffix = "evgl_thread_cmd"
+               elif api_type == "EVAS GL API" :
+                       fp_src = evgl_api_source_file
+                       fp_hdr = evgl_api_header_file
+                       api_suffix = "evgl_api_thread_cmd"
+
+               # check gl type,..
+               ifdef_stmt = ""
+               endif_stmt = ""
+               if 'gl_type' in api_dic and api_dic['gl_type'] == "GL" :
+                       ifdef_stmt = "\n#ifndef GL_GLES\n"
+                       endif_stmt = "#endif\n"
+
+               ### ifndef,...
+               LOG(ifdef_stmt)
+               FWRITE(fp_src, ifdef_stmt)
+
+               ### API prototype (for debug)
+               debug_msg = api_define_print(api_dic)
+               LOG(debug_msg)
+               FWRITE(fp_src, debug_msg)
+
+               ### data structure
+               struct_data = gen_structure(api_dic)
+               LOG(struct_data)
+               if len(struct_data) > 0 :
+                       FWRITE(fp_src, struct_data)
+
+               # define function pointer
+               if 'func_ptr' in api_dic :
+                       funcPtr_data = gen_function_pointer(api_dic)
+                       LOG(funcPtr_data)
+                       FWRITE(fp_src, funcPtr_data)
+
+               # generate call-back function
+               api_data = gen_gl_thread_api(api_dic)
+               LOG(api_data)
+               FWRITE(fp_src, api_data)
+
+               # generate wrapper function
+               api_data = gen_thread_cmd_api(api_dic)
+               LOG(api_data)
+               FWRITE(fp_src, api_data)
+
+               ###  endif
+               LOG(endif_stmt)
+               FWRITE(fp_src, endif_stmt)
+
+               ### header
+               header_data = ifdef_stmt
+               header_data += gen_wrapper_api_header(api_dic)
+               header_data += endif_stmt
+
+               LOG(header_data)
+               FWRITE(fp_hdr, header_data)
+
+               ### _link file
+               if api_type == "EVAS" or api_type == "EVAS GL" :
+
+                       LOG(ifdef_stmt)
+                       FWRITE(fp_link_src, ifdef_stmt)
+
+                       if 'func_ptr' in api_dic :
+                               fp_suffix = api_dic['func_ptr']
+                               set_func = "void (*%s_%s_set)(void *func) = NULL;\n" %(api_name, fp_suffix)
+                               get_func = "void *(*%s_%s_get)(void) = NULL;\n" %(api_name, fp_suffix)
+                               LOG(set_func + get_func)
+                               FWRITE(fp_link_src, set_func + get_func)
+
+                               LOG(ifdef_stmt)
+                               FWRITE(fp_link_hdr, ifdef_stmt)
+
+                               set_func2 = "extern void (*%s_%s_set)(void *func);\n" %(api_name, fp_suffix)
+                               get_func2 = "extern void *(*%s_%s_get)(void);\n" %(api_name, fp_suffix)
+                               LOG(set_func2 + get_func2)
+                               FWRITE(fp_link_hdr, set_func2 + get_func2)
+
+                       func_ptr_data = "%s (*%s_%s)(%s) = NULL;\n" %(return_type, api_name,
+                                                                                                                 api_suffix, para_data)
+                       LOG(func_ptr_data)
+                       FWRITE(fp_link_src, func_ptr_data)
+
+                       LOG(endif_stmt)
+                       FWRITE(fp_link_src, endif_stmt)
+
+                       # check gl types,...
+                       if not('func_ptr' in api_dic) and 'gl_type' in api_dic :
+                               LOG(ifdef_stmt)
+                               FWRITE(fp_link_hdr, ifdef_stmt)
+
+                       extern_func_ptr_data = "extern %s (*%s_%s)(%s);\n" %(return_type, api_name,
+                                                                                                                                api_suffix, para_data)
+                       LOG(extern_func_ptr_data)
+                       FWRITE(fp_link_hdr, extern_func_ptr_data)
+
+                       LOG(endif_stmt)
+                       FWRITE(fp_link_hdr, endif_stmt)
+
+       #print "END OF LOOP2"
+
+
+       ### init_symbol func. @_link file
+       if  g_evas_total > 0 :
+               init_func_data = gen_init_func_data("gl")
+               gl_link_source_file.write(init_func_data)
+
+               #print "LOOP3-1 START>>>"
+               symload_data = ""
+               for api_dic in api_dic_list :
+                       # check gl type,..
+                       ifdef_stmt = ""
+                       endif_stmt = ""
+                       if 'gl_type' in api_dic and api_dic['gl_type'] == "GL" :
+                               ifdef_stmt = "\n#ifndef GL_GLES\n"
+                               endif_stmt = "\n#endif\n"
+
+                       if api_dic['type'] == "EVAS" :
+                               symload_data += _NEWLINE
+                               symload_data += ifdef_stmt
+                               if 'func_ptr' in api_dic :
+                                       symload_data += gen_symload_set_get(api_dic)
+
+                               symload_data += "LINK2GENERIC(%s_thread_cmd);" %(api_dic['api_name'])
+                               symload_data += endif_stmt
+               LOG(symload_data)
+               FWRITE(gl_link_source_file, symload_data)
+
+               #print "END OF LOOP3"
+               FWRITE(gl_link_source_file, "\n}")
+               FWRITE(gl_link_header_file, "\n\nextern void _gl_thread_link_gl_generated_init();\n")
+
+       if  g_evgl_total > 0 :
+               init_func_data = gen_init_func_data("evgl")
+               evgl_link_source_file.write(init_func_data)
+
+               #print "LOOP3-2 START>>>"
+               symload_data = ""
+               ifdef_stmt = ""
+               endif_stmt = ""
+               for api_dic in api_dic_list :
+                       # check gl type,..
+                       ifdef_stmt = ""
+                       endif_stmt = ""
+                       if 'gl_type' in api_dic and api_dic['gl_type'] == "GL" :
+                               ifdef_stmt = "\n#ifndef GL_GLES\n"
+                               endif_stmt = "\n#endif\n"
+
+                       if api_dic['type'] == "EVAS GL" :
+                               symload_data += ifdef_stmt
+                               symload_data += _NEWLINE
+                               if 'func_ptr' in api_dic :
+                                       symload_data += gen_symload_set_get(api_dic)
+
+                               symload_data += "LINK2GENERIC(%s_evgl_thread_cmd);" %(api_dic['api_name'])
+                               symload_data += endif_stmt
+               LOG(symload_data)
+               FWRITE(evgl_link_source_file, symload_data)
+
+               #print "END OF LOOP3"
+               FWRITE(evgl_link_source_file, "\n}")
+               FWRITE(evgl_link_header_file, "\n\nextern void _gl_thread_link_evgl_generated_init();\n")
+
+       for f in files :
+               out_files[f].close()
+
+#############################################################
+def print_result(result):
+
+       print "* data parsing success: %d, failed: %d" %(result['success'], result['fail'])
+       if len(result['warning']) > 0 :
+               for msg in result['warning'] :
+                       print "- warning: %s" %(msg)
+       print "- enqueue: %d, flush: %d, finish: %d" %(result['enqueue'],
+                                                        result['flush'], result['finish'])
+       print "- extension API: %d" %(result['ext'])
+       print "- need Copy variable: %d, userDefinedCopy: %d" %(result['needCopy'],
+                                                                                                               result['needUserDefinedCopy'])
+       print "- GL types : %d" %(result['gl'])
+
+#-----------------------------------------------------------#
+if __name__ == '__main__':
+
+       parser = argparse.ArgumentParser()
+       parser.add_argument('-i',
+                                               required=True,
+                                               dest='input_data',
+                                               action='store',
+                                               help='API data file name')
+       parser.add_argument('-o',
+                                               dest='out_file_name',
+                                               action='store',
+                                               default='evas_gl_thread',
+                                               help='output (generated file) name prefix')
+       parser.add_argument('-d', '--debug',
+                                               type=int,
+                                               choices=range(0,4),
+                                               dest='debug_level',
+                                               action='store',
+                                               default='0',
+                                               help='set debug level')
+       parser.add_argument('--print-err',
+                                               dest='print_err',
+                                               action='store_true',
+                                               default=False,
+                                               help='use ERR(), when debug level 1')
+
+       parser.add_argument('--deploy',
+                                               dest='deploy',
+                                               action='store_true',
+                                               default=False,
+                                               help='copy output (generated) file to evas engines')
+       parser.add_argument('--verbose',
+                                               dest='verbose',
+                                               action='store_true',
+                                               default=False)
+       parser.add_argument('--version',
+                                               action='version',
+                                               version='%(prog)s 1.98')
+
+       args = parser.parse_args()
+       g_verbose = args.verbose
+       g_debug_lvl = args.debug_level
+       g_print_err = args.print_err
+       g_evas_total = 0
+       g_evgl_total = 0
+       g_evgl_api_total = 0
+
+       # parsing data file
+       result = get_api_def(args.input_data)
+
+       res_evas = result[0]
+       res_evgl = result[1]
+       res_evgl_api = result[2]
+
+       g_evas_total = res_evas['success'] + res_evas['fail']
+       g_evgl_total = res_evgl['success'] + res_evgl['fail']
+       g_evgl_api_total = res_evgl_api['success'] + res_evgl_api['fail']
+
+       
+       print "[EVAS:%d]" %(g_evas_total)
+       if g_evas_total > 0 : print_result(res_evas)
+
+       print "[EVAS GL:%d]" %(g_evgl_total)
+       if g_evgl_total > 0 : print_result(res_evgl)
+
+       print "[EVAS GL API:%d]" %(g_evgl_api_total)
+       if g_evgl_api_total > 0 : print_result(res_evgl_api)
+
+       print "* Total APIs: %d" %(g_evas_total + g_evgl_total + g_evgl_api_total)
+
+       # generate files
+       gen_files = generate_files(args.out_file_name)
+
+       # generate codes
+       generate_code(gen_files)
+
+       print "* generated files>>"
+       for f in gen_files :
+               print f
+
+
+       #eflindent
+       indent = """vim -c "set ts=8" -c "set sw=3" -c "set sts=3" -c "set expandtab" """
+       indent += """ -c "set cino=>5n-3f0^-2{2(0W1st0" -c "normal gg=G" -c "wq" """
+       for f in gen_files :
+               os.system(indent + f)
+       print "* eflindent done"
+
+       if args.deploy is True:
+               command = "cp %s*_generated.[ch] " %(args.out_file_name)
+               command += "./../../modules/evas/engines/gl_common"
+               os.system(command)
+               print command
+               print "* deploy done."
+

diff --git a/src/utils/evas/gl_api_def.txt b/src/utils/evas/gl_api_def.txt
new file mode 100755 (executable)
index 0000000..b281d3b
--- /dev/null
+++ b/src/utils/evas/gl_api_def.txt
@@ -0,0 +1,1058 @@
+################################################################################
+# GL API Data for generate wrapper API
+################################################################################
+# API definition data file format: (Requires at lease 8 columns)
+# 1.| {EVAS |EVAS GL |EVAS GL API} | : Wrapper API types
+# 2.| {return type} |
+# 3.| {api name} |
+# 4.| {paramter1, 2,..} | : parameter type and name (NOTE: it will be used as defined)
+# 5.| {enqueue|flush|finish} | : queue operation
+# 6.| {ext|noext} | : extension API or not
+# 7.| {memory pool name, size, value| userDefined | ""} | : if you need to copy variable
+# 8.| {GL| GLES} | ""} | : GL types
+################################################################################
+####################################################
+#
+# EVAS
+#
+####################################################
+# Errors
+| EVAS | GLenum | glGetError | void | finish | noext | | | |
+
+# Vertex Arrays
+## Vertex Array
+| EVAS | void | glVertexAttribPointer | GLuint index,GLint size,GLenum type,GLboolean normalized,GLsizei stride,const void *pointer | finish | noext | | |
+| EVAS | void | glEnableVertexAttribArray | GLuint index | enqueue | noext | | |
+| EVAS | void | glDisableVertexAttribArray | GLuint index | enqueue | noext | | |
+
+## Drawing
+| EVAS | void | glDrawArrays | GLenum mode,GLint first,GLsizei count | finish | noext | | |
+| EVAS | void | glDrawElements | GLenum mode,GLsizei count,GLenum type,const void *indices | finish | noext | | |
+
+# Buffer Objects
+| EVAS | void | glGenBuffers | GLsizei n,GLuint *buffers | finish | noext | | |
+| EVAS | void | glDeleteBuffers | GLsizei n,const GLuint *buffers | flush | noext | _mp_delete_object, n * sizeof(GLuint), buffers | |
+| EVAS | void | glBindBuffer | GLenum target,GLuint buffer | flush | noext | | |
+| EVAS | void | glBufferData | GLenum target,GLsizeiptr size,const void *data,GLenum usage | finish | noext | | |
+| EVAS | void * | glMapBuffer | GLenum target,GLenum access | finish | ext | | |
+| EVAS | GLboolean | glUnmapBuffer | GLenum target | finish | ext | | |
+
+# Vertex Shaders
+## Shader Objects
+| EVAS | GLuint | glCreateShader | GLenum type | finish | noext | | |
+| EVAS | void | glShaderSource | GLuint shader,GLsizei count,const GLchar **string,const GLint *length | flush | noext | userDefined | |
+| EVAS | void | glCompileShader | GLuint shader | flush | noext | | |
+| EVAS | void | glReleaseShaderCompiler | void | flush | ext | | |
+| EVAS | void | glDeleteShader | GLuint shader | flush | noext | | |
+
+## Program Objects
+| EVAS | GLuint | glCreateProgram | void | finish | noext | | |
+| EVAS | void | glAttachShader | GLuint program,GLuint shader | flush | noext | | |
+| EVAS | void | glDetachShader | GLuint program,GLuint shader | flush | noext | | |
+| EVAS | void | glLinkProgram | GLuint program | flush | noext | | |
+| EVAS | void | glUseProgram | GLuint program | flush | noext | | |
+| EVAS | void | glProgramParameteri | GLuint program,GLenum pname,GLint value | flush | ext | | |
+| EVAS | void | glDeleteProgram | GLuint program | flush | noext | | |
+
+## Program Binaries
+| EVAS | void | glGetProgramBinary | GLuint program,GLsizei bufSize,GLsizei *length,GLenum *binaryFormat,void *binary | finish | ext | | |
+| EVAS | void | glProgramBinary | GLuint program,GLenum binaryFormat,const void *binary,GLint length | flush | ext | _mp_default, length, binary | |
+
+## Vertex Attributes
+| EVAS | void | glGetActiveAttrib | GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name | finish | noext | | |
+| EVAS | GLint | glGetAttribLocation | GLuint program,const GLchar *name | finish | noext | | |
+| EVAS | void | glBindAttribLocation | GLuint program,GLuint index,const GLchar *name | finish | noext | _mp_default, strlen(name), name | |
+
+
+## Uniform Variables
+| EVAS | GLint | glGetUniformLocation | GLuint program,const GLchar *name | finish | noext | | |
+| EVAS | void | glUniform1f | GLint location,GLfloat v0 | flush | noext | | |
+| EVAS | void | glUniform1i | GLint location,GLint v0 | flush | noext | | |
+| EVAS | void | glUniform2f | GLint location,GLfloat v0, GLfloat v1 | flush | noext | | |
+| EVAS | void | glUniform2i | GLint location,GLint v0, GLint v1 | flush | noext | | |
+| EVAS | void | glUniform3f | GLint location,GLfloat v0,GLfloat v1,GLfloat v2 | flush | noext | | |
+| EVAS | void | glUniform3i | GLint location,GLint v0, GLint v1, GLint v2 | flush | noext | | |
+| EVAS | void | glUniform4f | GLint location,GLfloat v0,GLfloat v1,GLfloat v2,GLfloat v3 | flush | noext | | |
+| EVAS | void | glUniform4i | GLint location,GLint v0, GLint v1, GLint v2, GLint v3 | flush | noext | | |
+| EVAS | void | glUniform1fv | GLint location,GLsizei count, const GLfloat *value | flush | noext | _mp_uniform, 1 * count * sizeof(GLfloat), value | |
+| EVAS | void | glUniform1iv | GLint location,GLsizei count, const GLint *value | flush | noext | _mp_uniform, 1 * count * sizeof(GLint), value | |
+| EVAS | void | glUniform2fv | GLint location,GLsizei count,const GLfloat *value | flush | noext | _mp_uniform, 2 * count * sizeof(GLfloat), value | |
+| EVAS | void | glUniform2iv | GLint location,GLsizei count, const GLint *value | flush | noext | _mp_uniform, 2 * count * sizeof(GLint), value | |
+| EVAS | void | glUniform3fv | GLint location,GLsizei count, const GLfloat *value | flush | noext | _mp_uniform, 3 * count * sizeof(GLfloat), value | |
+| EVAS | void | glUniform3iv | GLint location,GLsizei count, const GLint *value | flush | noext | _mp_uniform, 3 * count * sizeof(GLint), value | |
+| EVAS | void | glUniform4fv | GLint location,GLsizei count,const GLfloat *value | flush | noext | _mp_uniform, 4 * count * sizeof(GLfloat), value | |
+| EVAS | void | glUniform4iv | GLint location,GLsizei count, const GLint *value | flush | noext | _mp_uniform, 4 * count * sizeof(GLint), value | |
+| EVAS | void | glUniformMatrix2fv | GLint location,GLsizei count,GLboolean transpose,const GLfloat *value | flush | noext | _mp_uniform, 4 * count * sizeof(GLfloat), value | |
+| EVAS | void | glUniformMatrix3fv | GLint location,GLsizei count,GLboolean transpose,const GLfloat *value | flush | noext | _mp_uniform, 9 * count * sizeof(GLfloat), value | |
+| EVAS | void | glUniformMatrix4fv | GLint location,GLsizei count,GLboolean transpose,const GLfloat *value | flush | noext | _mp_uniform, 16 * count * sizeof(GLfloat),value | |
+
+
+# Viewport
+| EVAS | void | glViewport | GLint x,GLint y,GLsizei width,GLsizei height | flush | noext | | |
+
+# Enable/Disable
+| EVAS | void | glEnable | GLenum cap | enqueue | noext | | |
+| EVAS | void | glDisable | GLenum cap | enqueue | noext | | |
+
+# Line segments
+| EVAS | void | glLineWidth | GLfloat width | flush | noext | | |
+
+# Polygon
+| EVAS | void | glPolygonOffset | GLfloat factor,GLfloat units | flush | noext | | |
+
+# Pixel Rectangles
+| EVAS | void | glPixelStorei | GLenum pname,GLint param | flush | noext | | |
+
+
+# Texturing
+| EVAS | void | glActiveTexture | GLenum texture | flush | noext | | |
+
+# Texture Objects
+| EVAS | void | glGenTextures | GLsizei n,GLuint *textures | finish | noext | | |
+| EVAS | void | glBindTexture | GLenum target,GLuint texture | flush | noext | | |
+| EVAS | void | glDeleteTextures | GLsizei n,const GLuint *textures | flush | noext | _mp_delete_object, n * sizeof(GLuint), textures | |
+
+
+# Texture Image Specification
+| EVAS | void | glTexImage2D | GLenum target,GLint level,GLint internalformat,GLsizei width,GLsizei height,GLint border,GLenum format,GLenum type,const void *pixels | flush | noext | userDefined | |
+| EVAS | void | glTexSubImage2D | GLenum target,GLint level,GLint xoffset,GLint yoffset,GLsizei width,GLsizei height,GLenum format,GLenum type,const void *pixels | flush | noext |  userDefined | |
+
+# Compressed Texture Images
+| EVAS | void | glCompressedTexImage2D | GLenum target,GLint level,GLenum internalformat,GLsizei width,GLsizei height,GLint border,GLsizei imageSize,const void *data | flush | noext | userDefined | |
+| EVAS | void | glCompressedTexSubImage2D | GLenum target,GLint level,GLint xoffset,GLint yoffset,GLsizei width,GLsizei height,GLenum format,GLsizei imageSize,const void *data | flush | noext | userDefined | |
+
+
+# Texture parameters
+| EVAS | void | glTexParameterf | GLenum target,GLenum pname,GLfloat param | flush | noext | | |
+| EVAS | void | glTexParameterfv | GLenum target, GLenum pname, const GLfloat *params | flush | noext | _mp_default, sizeof(GLfloat), params | |
+| EVAS | void | glTexParameteri | GLenum target,GLenum pname,GLint param | flush | noext | | |
+| EVAS | void | glTexParameteriv | GLenum target, GLenum pname, const GLint *params | flush | noext | _mp_default, sizeof(GLint), params | |
+
+# Scissor Test
+| EVAS | void | glScissor | GLint x,GLint y,GLsizei width,GLsizei height | flush | noext | | |
+
+## Blending
+| EVAS | void | glBlendFunc | GLenum sfactor,GLenum dfactor | flush | noext | | |
+| EVAS | void | glBlendColor | GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha | flush | noext | | |
+
+
+# Fine Control of Buffer Updates
+| EVAS | void | glDepthMask | GLboolean flag | flush | noext | | |
+
+# Clearing the Buffers
+| EVAS | void | glClear | GLbitfield mask | flush | noext | | |
+| EVAS | void | glClearColor | GLfloat red,GLfloat green,GLfloat blue,GLfloat alpha | flush | noext | | |
+
+# Reading and Copying Pixels
+| EVAS | void | glReadPixels | GLint x,GLint y,GLsizei width,GLsizei height,GLenum format,GLenum type,void *pixels | finish | noext | | |
+
+# Binding & Managing Framebuffer Objects
+| EVAS | void | glGenFramebuffers | GLsizei n,GLuint *framebuffers | finish | ext | | |
+| EVAS | void | glBindFramebuffer | GLenum target,GLuint framebuffer | flush | ext | | |
+| EVAS | void | glDeleteFramebuffers | GLsizei n,const GLuint *framebuffers | flush | ext | _mp_delete_object, n * sizeof(GLuint), framebuffers | |
+
+# Renderbuffer Objects
+| EVAS | void | glGenRenderbuffers | GLsizei n,GLuint *renderbuffers | finish | noext | | |
+| EVAS | void | glBindRenderbuffer | GLenum target,GLuint renderbuffer | flush | noext | | |
+| EVAS | void | glDeleteRenderbuffers | GLsizei n,const GLuint *renderbuffers | flush | noext | _mp_delete_object, n * sizeof(GLuint), renderbuffers | |
+| EVAS | void | glRenderbufferStorage | GLenum target,GLenum internalformat,GLsizei width,GLsizei height | flush | noext | | |
+
+# Attaching Renderbuffer Images to Framebuffer
+| EVAS | void | glFramebufferRenderbuffer | GLenum target,GLenum attachment,GLenum renderbuffertarget,GLuint renderbuffer | flush | noext | | |
+
+# Attaching Texture Images to a Framebuffer
+| EVAS | void | glFramebufferTexture2D | GLenum target,GLenum attachment,GLenum textarget,GLuint texture,GLint level | flush | ext | | |
+| EVAS | void | glFramebufferTexture2DMultisample | GLenum target,GLenum attachment,GLenum textarget,GLuint texture,GLint level,GLsizei samples | flush | ext | | |
+
+# Framebuffer Completeness
+| EVAS | GLenum | glCheckFramebufferStatus | GLenum target | finish | noext | | |
+
+
+# Special Functions
+| EVAS | void | glFlush | void | finish | noext | | |
+| EVAS | void | glFinish | void | finish | noext | | |
+| EVAS | void | glHint | GLenum target,GLenum mode | flush | noext | | |
+
+
+# State and State Requests
+| EVAS | const GLubyte * | glGetString | GLenum name | finish | noext | | |
+| EVAS | void | glGetBooleanv | GLenum pname,GLboolean *data | finish | noext | | |
+| EVAS | void | glGetFloatv | GLenum pname,GLfloat *data | finish | noext | | |
+| EVAS | void | glGetIntegerv | GLenum pname,GLint *data | finish | noext | | |
+
+# Buffer Queries
+| EVAS | GLboolean | glIsBuffer | GLint buffer | finish | noext | | |
+| EVAS | void | glGetBufferParameteriv | GLenum target, GLenum pname, GLint *params | finish | noext | | |
+
+# Shader and Program Queries
+| EVAS | GLboolean | glIsShader | GLuint shader | finish | noext | | |
+| EVAS | void | glGetShaderiv | GLuint shader,GLenum pname,GLint *params | finish | noext | | |
+| EVAS | void | glGetAttachedShaders | GLuint program, GLsizei maxCount, GLsizei *count, GLuint *shaders | finish | noext | | |
+| EVAS | void | glGetShaderInfoLog | GLuint shader,GLsizei bufSize,GLsizei *length,GLchar *infoLog | finish | noext | | |
+| EVAS | void | glGetShaderSource | GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source | finish | noext | | |
+| EVAS | void | glGetShaderPrecisionFormat | GLenum shadertype, GLenum precisiontype, GLint *range, GLint *precision | finish | noext | | |
+| EVAS | void | glGetVertexAttribfv | GLuint index, GLenum pname, GLfloat *params | finish | noext | | |
+| EVAS | void | glGetVertexAttribiv | GLuint index, GLenum pname, GLint *params | finish | noext | | |
+| EVAS | GLboolean | glIsProgram | GLuint program | finish | noext | | |
+| EVAS | void | glGetProgramInfoLog | GLuint program,GLsizei bufSize,GLsizei *length,GLchar *infoLog | finish | noext | | |
+| EVAS | void | glGetProgramiv | GLuint program,GLenum pname,GLint *params | finish | noext | | |
+
+
+# Framebuffer Objects Queries
+| EVAS | GLboolean | glIsFramebuffer | GLint framebuffer | finish | noext | | |
+| EVAS | void | glGetFramebufferParameteriv | GLenum target, GLenum pname, GLint *params | finish | ext | | |
+
+# Renderbuffer Object Queries
+| EVAS | GLboolean | glIsRenderbuffer | GLint renderbuffer | finish | noext | | |
+| EVAS | void | glGetRenderbufferParameteriv | GLenum target, GLenum pname, GLint *params | finish | noext | | |
+
+# Texture Queries
+| EVAS | GLboolean | glIsTexture | GLint texture | finish | noext | | |
+
+# Tiling
+| EVAS | void | glStartTiling | GLuint a,GLuint b,GLuint c,GLuint d,GLuint e | flush | ext | | |
+| EVAS | void | glEndTiling | GLuint a | flush | ext | | |
+| EVAS | void | glActivateTile | GLuint a,GLuint b,GLuint c,GLuint d,GLuint e | flush | ext | | |
+
+# EGLImage
+| EVAS | void | glEGLImageTargetTexture2DOES | GLenum target,void *image | finish | ext | | |
+
+# GL
+| EVAS | void | glAlphaFunc | GLenum func,GLclampf ref | flush | noext | | GL |
+| EVAS | void | glGetTexLevelParameteriv | GLenum target,GLint level,GLenum pname,GLint *params | finish | noext | | GL |
+| EVAS | void | glRenderbufferStorageMultisample | GLenum target,GLsizei samples,GLenum internalformat,GLsizei width,GLsizei height | finish | ext | | GL |
+
+# GLES3
+| EVAS | const GLubyte * | glGetStringi | GLenum name,GLuint index | finish | ext | | |
+
+####################################################
+#
+# EVAS GL
+#
+####################################################
+# Errors
+| EVAS GL | GLenum | glGetError | void | finish | noext | | | |
+
+# Vertex Arrays
+## Vertex Array
+| EVAS GL | void | glVertexAttribPointer | GLuint index,GLint size,GLenum type,GLboolean normalized,GLsizei stride,const void *pointer | finish | noext | | |
+| EVAS GL | void | glEnableVertexAttribArray | GLuint index | flush | noext | | |
+| EVAS GL | void | glDisableVertexAttribArray | GLuint index | flush | noext | | |
+
+## Drawing
+| EVAS GL | void | glDrawArrays | GLenum mode,GLint first,GLsizei count | finish | noext | | |
+| EVAS GL | void | glDrawElements | GLenum mode,GLsizei count,GLenum type,const void *indices | finish | noext | | |
+
+# Buffer Objects
+| EVAS GL | void | glGenBuffers | GLsizei n,GLuint *buffers | finish | noext | | |
+| EVAS GL | void | glDeleteBuffers | GLsizei n,const GLuint *buffers | flush | noext | _mp_delete_object, n * sizeof(GLuint), buffers | |
+| EVAS GL | void | glBindBuffer | GLenum target,GLuint buffer | flush | noext | | |
+| EVAS GL | void | glBufferData | GLenum target,GLsizeiptr size,const void *data,GLenum usage | finish | noext | | |
+
+# Vertex Shaders
+## Shader Objects
+| EVAS GL | GLuint | glCreateShader | GLenum type | finish | noext | | |
+| EVAS GL | void | glShaderSource | GLuint shader,GLsizei count,const GLchar **string,const GLint *length | flush | noext | userDefined | |
+| EVAS GL | void | glCompileShader | GLuint shader | flush | noext | | |
+| EVAS GL | void | glDeleteShader | GLuint shader | flush | noext | | |
+
+## Program Objects
+| EVAS GL | GLuint | glCreateProgram | void | finish | noext | | |
+| EVAS GL | void | glAttachShader | GLuint program,GLuint shader | flush | noext | | |
+| EVAS GL | void | glDetachShader | GLuint program,GLuint shader | flush | noext | | |
+| EVAS GL | void | glLinkProgram | GLuint program | flush | noext | | |
+| EVAS GL | void | glUseProgram | GLuint program | flush | noext | | |
+| EVAS GL | void | glDeleteProgram | GLuint program | flush | noext | | |
+
+## Program Binaries
+| EVAS GL | void | glGetProgramBinary | GLuint program,GLsizei bufSize,GLsizei *length,GLenum *binaryFormat,void *binary | finish | ext | | |
+| EVAS GL | void | glProgramBinary | GLuint program,GLenum binaryFormat,const void *binary,GLint length | flush | ext | _mp_default, length, binary | |
+
+## Vertex Attributes
+| EVAS GL | void | glGetActiveAttrib | GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name | finish | noext | | |
+| EVAS GL | GLint | glGetAttribLocation | GLuint program,const GLchar *name | finish | noext | | |
+| EVAS GL | void | glBindAttribLocation | GLuint program,GLuint index,const GLchar *name | finish | noext | _mp_default, strlen(name), name | |
+
+
+## Uniform Variables
+| EVAS GL | GLint | glGetUniformLocation | GLuint program,const GLchar *name | finish | noext | | |
+| EVAS GL | void | glUniform1f | GLint location,GLfloat v0 | flush | noext | | |
+| EVAS GL | void | glUniform1i | GLint location,GLint v0 | flush | noext | | |
+| EVAS GL | void | glUniform2f | GLint location,GLfloat v0, GLfloat v1 | flush | noext | | |
+| EVAS GL | void | glUniform2i | GLint location,GLint v0, GLint v1 | flush | noext | | |
+| EVAS GL | void | glUniform3f | GLint location,GLfloat v0,GLfloat v1,GLfloat v2 | flush | noext | | |
+| EVAS GL | void | glUniform3i | GLint location,GLint v0, GLint v1, GLint v2 | flush | noext | | |
+| EVAS GL | void | glUniform4f | GLint location,GLfloat v0,GLfloat v1,GLfloat v2,GLfloat v3 | flush | noext | | |
+| EVAS GL | void | glUniform4i | GLint location,GLint v0, GLint v1, GLint v2, GLint v3 | flush | noext | | |
+| EVAS GL | void | glUniform1fv | GLint location,GLsizei count, const GLfloat *value | flush | noext | _mp_uniform, 1 * count * sizeof(GLfloat), value | |
+| EVAS GL | void | glUniform1iv | GLint location,GLsizei count, const GLint *value | flush | noext | _mp_uniform, 1 * count * sizeof(GLint), value | |
+| EVAS GL | void | glUniform2fv | GLint location,GLsizei count,const GLfloat *value | flush | noext | _mp_uniform, 2 * count * sizeof(GLfloat), value | |
+| EVAS GL | void | glUniform2iv | GLint location,GLsizei count, const GLint *value | flush | noext | _mp_uniform, 2 * count * sizeof(GLint), value | |
+| EVAS GL | void | glUniform3fv | GLint location,GLsizei count, const GLfloat *value | flush | noext | _mp_uniform, 3 * count * sizeof(GLfloat), value | |
+| EVAS GL | void | glUniform3iv | GLint location,GLsizei count, const GLint *value | flush | noext | _mp_uniform, 3 * count * sizeof(GLint), value | |
+| EVAS GL | void | glUniform4fv | GLint location,GLsizei count,const GLfloat *value | flush | noext | _mp_uniform, 4 * count * sizeof(GLfloat), value | |
+| EVAS GL | void | glUniform4iv | GLint location,GLsizei count, const GLint *value | flush | noext | _mp_uniform, 4 * count * sizeof(GLint), value | |
+| EVAS GL | void | glUniformMatrix2fv | GLint location,GLsizei count,GLboolean transpose,const GLfloat *value | flush | noext | _mp_uniform, 4 * count * sizeof(GLfloat), value | |
+| EVAS GL | void | glUniformMatrix3fv | GLint location,GLsizei count,GLboolean transpose,const GLfloat *value | flush | noext | _mp_uniform, 9 * count * sizeof(GLfloat), value | |
+| EVAS GL | void | glUniformMatrix4fv | GLint location,GLsizei count,GLboolean transpose,const GLfloat *value | flush | noext | _mp_uniform, 16 * count * sizeof(GLfloat),value | |
+
+
+# Viewport
+| EVAS GL | void | glViewport | GLint x,GLint y,GLsizei width,GLsizei height | flush | noext | | |
+
+# Enable/Disable
+| EVAS GL | void | glEnable | GLenum cap | flush | noext | | |
+| EVAS GL | void | glDisable | GLenum cap | flush | noext | | |
+
+# Line segments
+| EVAS GL | void | glLineWidth | GLfloat width | flush | noext | | |
+
+# Polygon
+| EVAS GL | void | glPolygonOffset | GLfloat factor,GLfloat units | flush | noext | | |
+
+# Pixel Rectangles
+| EVAS GL | void | glPixelStorei | GLenum pname,GLint param | flush | noext | | |
+
+
+# Texturing
+| EVAS GL | void | glActiveTexture | GLenum texture | flush | noext | | |
+
+# Texture Objects
+| EVAS GL | void | glGenTextures | GLsizei n,GLuint *textures | finish | noext | | |
+| EVAS GL | void | glBindTexture | GLenum target,GLuint texture | flush | noext | | |
+| EVAS GL | void | glDeleteTextures | GLsizei n,const GLuint *textures | flush | noext | _mp_delete_object, n * sizeof(GLuint), textures | |
+
+
+# Texture Image Specification
+| EVAS GL | void | glTexImage2D | GLenum target,GLint level,GLint internalformat,GLsizei width,GLsizei height,GLint border,GLenum format,GLenum type,const void *pixels | flush | noext | userDefined | |
+| EVAS GL | void | glTexSubImage2D | GLenum target,GLint level,GLint xoffset,GLint yoffset,GLsizei width,GLsizei height,GLenum format,GLenum type,const void *pixels | flush | noext |  userDefined | |
+
+# Compressed Texture Images
+| EVAS GL | void | glCompressedTexImage2D | GLenum target,GLint level,GLenum internalformat,GLsizei width,GLsizei height,GLint border,GLsizei imageSize,const void *data | flush | noext | userDefined | |
+| EVAS GL | void | glCompressedTexSubImage2D | GLenum target,GLint level,GLint xoffset,GLint yoffset,GLsizei width,GLsizei height,GLenum format,GLsizei imageSize,const void *data | flush | noext | userDefined | |
+
+
+# Texture parameters
+| EVAS GL | void | glTexParameterf | GLenum target,GLenum pname,GLfloat param | flush | noext | | |
+| EVAS GL | void | glTexParameterfv | GLenum target, GLenum pname, const GLfloat *params | flush | noext | _mp_default, sizeof(GLfloat), params | |
+| EVAS GL | void | glTexParameteri | GLenum target,GLenum pname,GLint param | flush | noext | | |
+| EVAS GL | void | glTexParameteriv | GLenum target, GLenum pname, const GLint *params | flush | noext | _mp_default, sizeof(GLint), params | |
+
+# Scissor Test
+| EVAS GL | void | glScissor | GLint x,GLint y,GLsizei width,GLsizei height | flush | noext | | |
+
+## Blending
+| EVAS GL | void | glBlendFunc | GLenum sfactor,GLenum dfactor | flush | noext | | |
+| EVAS GL | void | glBlendColor | GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha | flush | noext | | |
+
+
+# Fine Control of Buffer Updates
+| EVAS GL | void | glDepthMask | GLboolean flag | flush | noext | | |
+
+# Clearing the Buffers
+| EVAS GL | void | glClear | GLbitfield mask | flush | noext | | |
+| EVAS GL | void | glClearColor | GLfloat red,GLfloat green,GLfloat blue,GLfloat alpha | flush | noext | | |
+
+# Reading and Copying Pixels
+| EVAS GL | void | glReadPixels | GLint x,GLint y,GLsizei width,GLsizei height,GLenum format,GLenum type,void *pixels | finish | noext | | |
+
+# Binding & Managing Framebuffer Objects (GLES2_XX)
+| EVAS GL | void | glGenFramebuffers | GLsizei n,GLuint *framebuffers | finish | noext | | |
+| EVAS GL | void | glBindFramebuffer | GLenum target,GLuint framebuffer | flush | noext | | |
+| EVAS GL | void | glDeleteFramebuffers | GLsizei n,const GLuint *framebuffers | flush | noext | _mp_delete_object, n * sizeof(GLuint), framebuffers | |
+
+# Renderbuffer Objects
+| EVAS GL | void | glGenRenderbuffers | GLsizei n,GLuint *renderbuffers | finish | noext | | |
+| EVAS GL | void | glBindRenderbuffer | GLenum target,GLuint renderbuffer | flush | noext | | |
+| EVAS GL | void | glDeleteRenderbuffers | GLsizei n,const GLuint *renderbuffers | flush | noext | _mp_delete_object, n * sizeof(GLuint), renderbuffers | |
+| EVAS GL | void | glRenderbufferStorage | GLenum target,GLenum internalformat,GLsizei width,GLsizei height | flush | noext | | |
+
+# Attaching Renderbuffer Images to Framebuffer
+| EVAS GL | void | glFramebufferRenderbuffer | GLenum target,GLenum attachment,GLenum renderbuffertarget,GLuint renderbuffer | flush | noext | | |
+
+# Attaching Texture Images to a Framebuffer (GLES2_XX)
+| EVAS GL | void | glFramebufferTexture2D | GLenum target,GLenum attachment,GLenum textarget,GLuint texture,GLint level | flush | noext | | |
+# Framebuffer Completeness (GLES2_XX)
+| EVAS GL | GLenum | glCheckFramebufferStatus | GLenum target | finish | noext | | |
+
+
+# Special Functions
+| EVAS GL | void | glFlush | void | finish | noext | | |
+| EVAS GL | void | glFinish | void | finish | noext | | |
+| EVAS GL | void | glHint | GLenum target,GLenum mode | flush | noext | | |
+
+
+# State and State Requests
+| EVAS GL | const GLubyte * | glGetString | GLenum name | finish | noext | | |
+| EVAS GL | void | glGetBooleanv | GLenum pname,GLboolean *data | finish | noext | | |
+| EVAS GL | void | glGetFloatv | GLenum pname,GLfloat *data | finish | noext | | |
+| EVAS GL | void | glGetIntegerv | GLenum pname,GLint *data | finish | noext | | |
+
+# Buffer Queries
+| EVAS GL | GLboolean | glIsBuffer | GLint buffer | finish | noext | | |
+| EVAS GL | void | glGetBufferParameteriv | GLenum target, GLenum pname, GLint *params | finish | noext | | |
+
+# Shader and Program Queries
+| EVAS GL | GLboolean | glIsShader | GLuint shader | finish | noext | | |
+| EVAS GL | void | glGetShaderiv | GLuint shader,GLenum pname,GLint *params | finish | noext | | |
+| EVAS GL | void | glGetAttachedShaders | GLuint program, GLsizei maxCount, GLsizei *count, GLuint *shaders | finish | noext | | |
+| EVAS GL | void | glGetShaderInfoLog | GLuint shader,GLsizei bufSize,GLsizei *length,GLchar *infoLog | finish | noext | | |
+| EVAS GL | void | glGetShaderSource | GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source | finish | noext | | |
+| EVAS GL | void | glGetShaderPrecisionFormat | GLenum shadertype, GLenum precisiontype, GLint *range, GLint *precision | finish | noext | | |
+| EVAS GL | void | glGetVertexAttribfv | GLuint index, GLenum pname, GLfloat *params | finish | noext | | |
+| EVAS GL | void | glGetVertexAttribiv | GLuint index, GLenum pname, GLint *params | finish | noext | | |
+| EVAS GL | GLboolean | glIsProgram | GLuint program | finish | noext | | |
+| EVAS GL | void | glGetProgramInfoLog | GLuint program,GLsizei bufSize,GLsizei *length,GLchar *infoLog | finish | noext | | |
+| EVAS GL | void | glGetProgramiv | GLuint program,GLenum pname,GLint *params | finish | noext | | |
+
+
+# Framebuffer Objects Queries
+| EVAS GL | GLboolean | glIsFramebuffer | GLint framebuffer | finish | noext | | |
+
+# Renderbuffer Object Queries
+| EVAS GL | GLboolean | glIsRenderbuffer | GLint renderbuffer | finish | noext | | |
+| EVAS GL | void | glGetRenderbufferParameteriv | GLenum target, GLenum pname, GLint *params | finish | noext | | |
+
+# Texture Queries
+| EVAS GL | GLboolean | glIsTexture | GLint texture | finish | noext | | |
+
+##################################################
+#
+# Evas GL APIs
+#
+##################################################
+# OpenGL-ES 2.0
+| EVAS GL API | void | glActiveTexture | GLenum texture | finish | noext | | |
+| EVAS GL API | void | glAttachShader | GLuint program, GLuint shader | flush | noext | | |
+| EVAS GL API | void | glBindAttribLocation | GLuint program, GLuint index, const char* name | finish | noext | _mp_default, strlen(name), name | |
+| EVAS GL API | void | glBindBuffer | GLenum target, GLuint buffer | flush | noext | | |
+| EVAS GL API | void | glBindFramebuffer | GLenum target, GLuint framebuffer | flush | noext | | |
+| EVAS GL API | void | glBindRenderbuffer | GLenum target, GLuint renderbuffer | flush | noext | | |
+| EVAS GL API | void | glBindTexture | GLenum target, GLuint texture | flush | noext | | |
+| EVAS GL API | void | glBlendColor | GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha | flush | noext | | |
+| EVAS GL API | void | glBlendEquation |  GLenum mode  | flush | noext | | |
+| EVAS GL API | void | glBlendEquationSeparate | GLenum modeRGB, GLenum modeAlpha | flush | noext | | |
+| EVAS GL API | void | glBlendFunc | GLenum sfactor, GLenum dfactor | flush | noext | | |
+| EVAS GL API | void | glBlendFuncSeparate | GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha | flush | noext | | |
+| EVAS GL API | void | glBufferData | GLenum target, GLsizeiptr size, const void* data, GLenum usage | finish | noext | | |
+| EVAS GL API | void | glBufferSubData | GLenum target, GLintptr offset, GLsizeiptr size, const void* data | finish | noext | | |
+| EVAS GL API | GLenum | glCheckFramebufferStatus | GLenum target | finish | noext | | |
+| EVAS GL API | void | glClear | GLbitfield mask | finish | noext | | |
+| EVAS GL API | void | glClearColor | GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha | finish | noext | | |
+| EVAS GL API | void | glClearDepthf | GLclampf depth | finish | noext | | |
+| EVAS GL API | void | glClearStencil | GLint s | finish | noext | | |
+| EVAS GL API | void | glColorMask | GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha | finish | noext | | |
+| EVAS GL API | void | glCompileShader | GLuint shader | flush | noext | | |
+| EVAS GL API | void | glCompressedTexImage2D | GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void* data | flush | noext | userDefined | |
+| EVAS GL API | void | glCompressedTexSubImage2D | GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void* data | flush | noext | userDefined | |
+| EVAS GL API | void | glCopyTexImage2D | GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border | finish | noext | | |
+| EVAS GL API | void | glCopyTexSubImage2D | GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height | finish | noext | | |
+| EVAS GL API | GLuint | glCreateProgram | void | finish | noext | | |
+| EVAS GL API | GLuint | glCreateShader | GLenum type | finish | noext | | |
+| EVAS GL API | void | glCullFace | GLenum mode | finish | noext | | |
+| EVAS GL API | void | glDeleteBuffers | GLsizei n, const GLuint* buffers | flush | noext | _mp_delete_object, n * sizeof(GLuint), buffers | |
+| EVAS GL API | void | glDeleteFramebuffers | GLsizei n, const GLuint* framebuffers | flush | noext | _mp_delete_object, n * sizeof(GLuint), framebuffers | |
+| EVAS GL API | void | glDeleteProgram | GLuint program | finish | noext | | |
+| EVAS GL API | void | glDeleteRenderbuffers | GLsizei n, const GLuint* renderbuffers | flush | noext | _mp_delete_object, n * sizeof(GLuint), renderbuffers | |
+| EVAS GL API | void | glDeleteShader | GLuint shader | flush | noext | | |
+| EVAS GL API | void | glDeleteTextures | GLsizei n, const GLuint* textures | flush | noext | _mp_delete_object, n * sizeof(GLuint), textures | |
+| EVAS GL API | void | glDepthFunc | GLenum func | finish | noext | | |
+| EVAS GL API | void | glDepthMask | GLboolean flag | flush | noext | | |
+| EVAS GL API | void | glDepthRangef | GLclampf zNear, GLclampf zFar | finish | noext | | |
+| EVAS GL API | void | glDetachShader | GLuint program, GLuint shader | flush | noext | | |
+| EVAS GL API | void | glDisable | GLenum cap | flush | noext | | |
+| EVAS GL API | void | glDisableVertexAttribArray | GLuint index | flush | noext | | |
+| EVAS GL API | void | glDrawArrays | GLenum mode, GLint first, GLsizei count | finish | noext | | |
+| EVAS GL API | void | glDrawElements | GLenum mode, GLsizei count, GLenum type, const void* indices | finish | noext | | |
+| EVAS GL API | void | glEnable | GLenum cap | flush | noext | | |
+| EVAS GL API | void | glEnableVertexAttribArray | GLuint index | flush | noext | | |
+| EVAS GL API | void | glFinish | void | finish | noext | | |
+| EVAS GL API | void | glFlush | void | finish | noext | | |
+| EVAS GL API | void | glFramebufferRenderbuffer | GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer | flush | noext | | |
+| EVAS GL API | void | glFramebufferTexture2D | GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level | flush | noext | | |
+| EVAS GL API | void | glFrontFace | GLenum mode | finish | noext | | |
+| EVAS GL API | void | glGenBuffers | GLsizei n, GLuint* buffers | finish | noext | | |
+| EVAS GL API | void | glGenerateMipmap | GLenum target | finish | noext | | |
+| EVAS GL API | void | glGenFramebuffers | GLsizei n, GLuint* framebuffers | finish | noext | | |
+| EVAS GL API | void | glGenRenderbuffers | GLsizei n, GLuint* renderbuffers | finish | noext | | |
+| EVAS GL API | void | glGenTextures | GLsizei n, GLuint* textures | finish | noext | | |
+| EVAS GL API | void | glGetActiveAttrib | GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name | finish | noext | | |
+| EVAS GL API | void | glGetActiveUniform | GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name | finish | noext | | |
+| EVAS GL API | void | glGetAttachedShaders | GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders | finish | noext | | |
+| EVAS GL API | int  | glGetAttribLocation | GLuint program, const char* name | finish | noext | | |
+| EVAS GL API | void | glGetBooleanv | GLenum pname, GLboolean* params | finish | noext | | |
+| EVAS GL API | void | glGetBufferParameteriv | GLenum target, GLenum pname, GLint* params | finish | noext | | |
+| EVAS GL API | GLenum | glGetError | void | finish | noext | | |
+| EVAS GL API | void | glGetFloatv | GLenum pname, GLfloat* params | finish | noext | | |
+| EVAS GL API | void | glGetFramebufferAttachmentParameteriv | GLenum target, GLenum attachment, GLenum pname, GLint* params | finish | noext | | |
+| EVAS GL API | void | glGetIntegerv | GLenum pname, GLint* params | finish | noext | | |
+| EVAS GL API | void | glGetProgramiv | GLuint program, GLenum pname, GLint* params | finish | noext | | |
+| EVAS GL API | void | glGetProgramInfoLog | GLuint program, GLsizei bufsize, GLsizei* length, char* infolog | finish | noext | | |
+| EVAS GL API | void | glGetRenderbufferParameteriv | GLenum target, GLenum pname, GLint* params | finish | noext | | |
+| EVAS GL API | void | glGetShaderiv | GLuint shader, GLenum pname, GLint* params | finish | noext | | |
+| EVAS GL API | void | glGetShaderInfoLog | GLuint shader, GLsizei bufsize, GLsizei* length, char* infolog | finish | noext | | |
+| EVAS GL API | void | glGetShaderPrecisionFormat | GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision | finish | noext | | |
+| EVAS GL API | void | glGetShaderSource | GLuint shader, GLsizei bufsize, GLsizei* length, char* source | finish | noext | | |
+| EVAS GL API | const GLubyte* | glGetString | GLenum name | finish | noext | | |
+| EVAS GL API | void | glGetTexParameterfv | GLenum target, GLenum pname, GLfloat* params | finish | noext | | |
+| EVAS GL API | void | glGetTexParameteriv | GLenum target, GLenum pname, GLint* params | finish | noext | | |
+| EVAS GL API | void | glGetUniformfv | GLuint program, GLint location, GLfloat* params | finish | noext | | |
+| EVAS GL API | void | glGetUniformiv | GLuint program, GLint location, GLint* params | finish | noext | | |
+| EVAS GL API | int | glGetUniformLocation | GLuint program, const char* name | finish | noext | | |
+| EVAS GL API | void | glGetVertexAttribfv | GLuint index, GLenum pname, GLfloat* params | finish | noext | | |
+| EVAS GL API | void | glGetVertexAttribiv | GLuint index, GLenum pname, GLint* params | finish | noext | | |
+| EVAS GL API | void | glGetVertexAttribPointerv | GLuint index, GLenum pname, void** pointer | finish | noext | | |
+| EVAS GL API | void | glHint | GLenum target, GLenum mode | flush | noext | | |
+| EVAS GL API | GLboolean | glIsBuffer | GLuint buffer | finish | noext | | |
+| EVAS GL API | GLboolean | glIsEnabled | GLenum cap | finish | noext | | |
+| EVAS GL API | GLboolean | glIsFramebuffer | GLuint framebuffer | finish | noext | | |
+| EVAS GL API | GLboolean | glIsProgram | GLuint program | finish | noext | | |
+| EVAS GL API | GLboolean | glIsRenderbuffer | GLuint renderbuffer | finish | noext | | |
+| EVAS GL API | GLboolean | glIsShader | GLuint shader | finish | noext | | |
+| EVAS GL API | GLboolean | glIsTexture | GLuint texture | finish | noext | | |
+| EVAS GL API | void | glLineWidth | GLfloat width | flush | noext | | |
+| EVAS GL API | void | glLinkProgram | GLuint program | flush | noext | | |
+| EVAS GL API | void | glPixelStorei | GLenum pname, GLint param | flush | noext | | |
+| EVAS GL API | void | glPolygonOffset | GLfloat factor, GLfloat units | flush | noext | | |
+| EVAS GL API | void | glReadPixels | GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void* pixels | finish | noext | | |
+| EVAS GL API | void | glReleaseShaderCompiler | void | flush | noext | | |
+| EVAS GL API | void | glRenderbufferStorage | GLenum target, GLenum internalformat, GLsizei width, GLsizei height | flush | noext | | |
+| EVAS GL API | void | glSampleCoverage | GLclampf value, GLboolean invert | finish | noext | | |
+| EVAS GL API | void | glScissor | GLint x, GLint y, GLsizei width, GLsizei height | flush | noext | | |
+| EVAS GL API | void | glShaderBinary | GLsizei n, const GLuint* shaders, GLenum binaryformat, const void* binary, GLsizei length | finish | noext | | |
+| EVAS GL API | void | glShaderSource | GLuint shader, GLsizei count, const char* const * string, const GLint* length | flush | noext | userDefined | |
+| EVAS GL API | void | glStencilFunc | GLenum func, GLint ref, GLuint mask | finish | noext | | |
+| EVAS GL API | void | glStencilFuncSeparate | GLenum face, GLenum func, GLint ref, GLuint mask | finish | noext | | |
+| EVAS GL API | void | glStencilMask | GLuint mask | finish | noext | | |
+| EVAS GL API | void | glStencilMaskSeparate | GLenum face, GLuint mask | finish | noext | | |
+| EVAS GL API | void | glStencilOp | GLenum fail, GLenum zfail, GLenum zpass | finish | noext | | |
+| EVAS GL API | void | glStencilOpSeparate | GLenum face, GLenum fail, GLenum zfail, GLenum zpass | finish | noext | | |
+| EVAS GL API | void | glTexImage2D | GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void* pixels | flush | noext | userDefined | |
+| EVAS GL API | void | glTexParameterf | GLenum target, GLenum pname, GLfloat param | flush | noext | | |
+| EVAS GL API | void | glTexParameterfv | GLenum target, GLenum pname, const GLfloat* params | flush | noext | _mp_default, sizeof(GLfloat), params | |
+| EVAS GL API | void | glTexParameteri | GLenum target, GLenum pname, GLint param | flush | noext | | |
+| EVAS GL API | void | glTexParameteriv | GLenum target, GLenum pname, const GLint* params | flush | noext | _mp_default, sizeof(GLint), params | |
+| EVAS GL API | void | glTexSubImage2D | GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void* pixels | flush | noext | userDefined | |
+| EVAS GL API | void | glUniform1f | GLint location, GLfloat x | flush | noext | | |
+| EVAS GL API | void | glUniform1fv | GLint location, GLsizei count, const GLfloat* v | flush | noext | _mp_uniform, 1 * count * sizeof(GLfloat), v | |
+| EVAS GL API | void | glUniform1i | GLint location, GLint x | flush | noext | | |
+| EVAS GL API | void | glUniform1iv | GLint location, GLsizei count, const GLint* v | flush | noext | _mp_uniform, 1 * count * sizeof(GLint), v | |
+| EVAS GL API | void | glUniform2f | GLint location, GLfloat x, GLfloat y | flush | noext | | |
+| EVAS GL API | void | glUniform2fv | GLint location, GLsizei count, const GLfloat* v | flush | noext |_mp_uniform, 2 * count * sizeof(GLfloat), v  | |
+| EVAS GL API | void | glUniform2i | GLint location, GLint x, GLint y | flush | noext | | |
+| EVAS GL API | void | glUniform2iv | GLint location, GLsizei count, const GLint* v | flush | noext | _mp_uniform, 2 * count * sizeof(GLint), v | |
+| EVAS GL API | void | glUniform3f | GLint location, GLfloat x, GLfloat y, GLfloat z | flush | noext | | |
+| EVAS GL API | void | glUniform3fv | GLint location, GLsizei count, const GLfloat* v | flush | noext |_mp_uniform, 3 * count * sizeof(GLfloat), v  | |
+| EVAS GL API | void | glUniform3i | GLint location, GLint x, GLint y, GLint z | flush | noext | | |
+| EVAS GL API | void | glUniform3iv | GLint location, GLsizei count, const GLint* v | flush | noext | _mp_uniform, 3 * count * sizeof(GLint), v | |
+| EVAS GL API | void | glUniform4f | GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w | flush | noext | | |
+| EVAS GL API | void | glUniform4fv | GLint location, GLsizei count, const GLfloat* v | flush | noext | _mp_uniform, 4 * count * sizeof(GLfloat), v | |
+| EVAS GL API | void | glUniform4i | GLint location, GLint x, GLint y, GLint z, GLint w | flush | noext | | |
+| EVAS GL API | void | glUniform4iv | GLint location, GLsizei count, const GLint* v | flush | noext | _mp_uniform, 4 * count * sizeof(GLint), v | |
+| EVAS GL API | void | glUniformMatrix2fv | GLint location, GLsizei count, GLboolean transpose, const GLfloat* value | flush | noext | _mp_uniform, 4 * count * sizeof(GLfloat), value | |
+| EVAS GL API | void | glUniformMatrix3fv | GLint location, GLsizei count, GLboolean transpose, const GLfloat* value | flush | noext |  _mp_uniform, 9 * count * sizeof(GLfloat), value| |
+| EVAS GL API | void | glUniformMatrix4fv | GLint location, GLsizei count, GLboolean transpose, const GLfloat* value | flush | noext |  _mp_uniform, 16 * count * sizeof(GLfloat), value| |
+| EVAS GL API | void | glUseProgram | GLuint program | flush | noext | | |
+| EVAS GL API | void | glValidateProgram | GLuint program | finish | noext | | |
+| EVAS GL API | void | glVertexAttrib1f | GLuint indx, GLfloat x | finish | noext | | |
+| EVAS GL API | void | glVertexAttrib1fv | GLuint indx, const GLfloat* values | finish | noext | | |
+| EVAS GL API | void | glVertexAttrib2f | GLuint indx, GLfloat x, GLfloat y | finish | noext | | |
+| EVAS GL API | void | glVertexAttrib2fv | GLuint indx, const GLfloat* values | finish | noext | | |
+| EVAS GL API | void | glVertexAttrib3f | GLuint indx, GLfloat x, GLfloat y, GLfloat z | finish | noext | | |
+| EVAS GL API | void | glVertexAttrib3fv | GLuint indx, const GLfloat* values | finish | noext | | |
+| EVAS GL API | void | glVertexAttrib4f | GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w | finish | noext | | |
+| EVAS GL API | void | glVertexAttrib4fv | GLuint indx, const GLfloat* values | finish | noext | | |
+| EVAS GL API | void | glVertexAttribPointer | GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void* ptr | finish | noext | | |
+| EVAS GL API | void | glViewport | GLint x, GLint y, GLsizei width, GLsizei height | flush | noext | | |
+# OpenGL-ES 2.0 extensions
+/* GL_OES_EGL_image */
+| EVAS GL API | void | glEvasGLImageTargetTexture2DOES | GLenum target, EvasGLImage image | finish | noext | | |
+| EVAS GL API | void | glEvasGLImageTargetRenderbufferStorageOES | GLenum target, EvasGLImage image | finish | noext | | |
+/* GL_OES_get_program_binary */
+| EVAS GL API | void | glGetProgramBinaryOES | GLuint program, GLsizei bufSize, GLsizei *length, GLenum *binaryFormat, void *binary | finish | noext | | |
+| EVAS GL API | void | glProgramBinaryOES | GLuint program, GLenum binaryFormat, const void *binary, GLint length | flush | noext | _mp_default, length, binary | |
+/* GL_OES_mapbuffer */
+| EVAS GL API | void * | glMapBufferOES | GLenum target, GLenum access | finish | noext | | |
+| EVAS GL API | GLboolean | glUnmapBufferOES | GLenum target | finish | noext | | |
+| EVAS GL API | void | glGetBufferPointervOES | GLenum target, GLenum pname, void** params | finish | noext | | |
+/* GL_OES_texture_3D */
+| EVAS GL API | void | glTexImage3DOES | GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void* pixels | finish | noext | | |
+| EVAS GL API | void | glTexSubImage3DOES | GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void* pixels | finish | noext | | |
+| EVAS GL API | void | glCopyTexSubImage3DOES | GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height | finish | noext | | |
+| EVAS GL API | void | glCompressedTexImage3DOES | GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void* data | finish | noext | | |
+| EVAS GL API | void | glCompressedTexSubImage3DOES | GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void* data | finish | noext | | |
+| EVAS GL API | void | glFramebufferTexture3DOES | GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset | finish | noext | | |
+/* AMD_performance_monitor */
+| EVAS GL API | void | glGetPerfMonitorGroupsAMD | GLint* numGroups, GLsizei groupsSize, GLuint* groups | finish | noext | | |
+| EVAS GL API | void | glGetPerfMonitorCountersAMD | GLuint group, GLint* numCounters, GLint* maxActiveCounters, GLsizei counterSize, GLuint* counters | finish | noext | | |
+| EVAS GL API | void | glGetPerfMonitorGroupStringAMD | GLuint group, GLsizei bufSize, GLsizei* length, char* groupString | finish | noext | | |
+| EVAS GL API | void | glGetPerfMonitorCounterStringAMD | GLuint group, GLuint counter, GLsizei bufSize, GLsizei* length, char* counterString | finish | noext | | |
+| EVAS GL API | void | glGetPerfMonitorCounterInfoAMD | GLuint group, GLuint counter, GLenum pname, void* data | finish | noext | | |
+| EVAS GL API | void | glGenPerfMonitorsAMD | GLsizei n, GLuint* monitors | finish | noext | | |
+| EVAS GL API | void | glDeletePerfMonitorsAMD | GLsizei n, GLuint* monitors | finish | noext | | |
+| EVAS GL API | void | glSelectPerfMonitorCountersAMD | GLuint monitor, GLboolean enable, GLuint group, GLint numCounters, GLuint* countersList | finish | noext | | |
+| EVAS GL API | void | glBeginPerfMonitorAMD | GLuint monitor | finish | noext | | |
+| EVAS GL API | void | glEndPerfMonitorAMD | GLuint monitor | finish | noext | | |
+| EVAS GL API | void | glGetPerfMonitorCounterDataAMD | GLuint monitor, GLenum pname, GLsizei dataSize, GLuint* data, GLint* bytesWritten | finish | noext | | |
+/* GL_EXT_discard_framebuffer */
+| EVAS GL API | void | glDiscardFramebuffer | GLenum target, GLsizei numAttachments, const GLenum* attachments | finish | noext | | |
+| EVAS GL API | void | glDiscardFramebufferEXT | GLenum target, GLsizei numAttachments, const GLenum* attachments | finish | noext | | |
+/* GL_EXT_multi_draw_arrays */
+| EVAS GL API | void | glMultiDrawArrays | GLenum mode, GLint* first, GLsizei* count, GLsizei primcount | finish | noext | | |
+| EVAS GL API | void | glMultiDrawArraysEXT | GLenum mode, GLint* first, GLsizei* count, GLsizei primcount | finish | noext | | |
+| EVAS GL API | void | glMultiDrawElements | GLenum mode, const GLsizei* count, GLenum type, const GLvoid** indices, GLsizei primcount | finish | noext | | |
+| EVAS GL API | void | glMultiDrawElementsEXT | GLenum mode, const GLsizei* count, GLenum type, const GLvoid** indices, GLsizei primcount | finish | noext | | |
+/* GL_NV_fence */
+| EVAS GL API | void | glDeleteFencesNV | GLsizei n, const GLuint* fences | finish | noext | | |
+| EVAS GL API | void | glGenFencesNV | GLsizei n, GLuint* fences | finish | noext | | |
+| EVAS GL API | GLboolean | glIsFenceNV | GLuint fence | finish | noext | | |
+| EVAS GL API | GLboolean | glTestFenceNV | GLuint fence | finish | noext | | |
+| EVAS GL API | void | glGetFenceivNV | GLuint fence, GLenum pname, GLint* params | finish | noext | | |
+| EVAS GL API | void | glFinishFenceNV | GLuint fence | finish | noext | | |
+| EVAS GL API | void | glSetFenceNV | GLuint a, GLenum b | finish | noext | | |
+/* GL_QCOM_driver_control */
+| EVAS GL API | void | glGetDriverControlsQCOM | GLint* num, GLsizei size, GLuint* driverControls | finish | noext | | |
+| EVAS GL API | void | glGetDriverControlStringQCOM | GLuint driverControl, GLsizei bufSize, GLsizei* length, char* driverControlString | finish | noext | | |
+| EVAS GL API | void | glEnableDriverControlQCOM | GLuint driverControl | finish | noext | | |
+| EVAS GL API | void | glDisableDriverControlQCOM | GLuint driverControl | finish | noext | | |
+/* GL_QCOM_extended_get */
+| EVAS GL API | void | glExtGetTexturesQCOM | GLuint* textures, GLint maxTextures, GLint* numTextures | finish | noext | | |
+| EVAS GL API | void | glExtGetBuffersQCOM | GLuint* buffers, GLint maxBuffers, GLint* numBuffers | finish | noext | | |
+| EVAS GL API | void | glExtGetRenderbuffersQCOM | GLuint* renderbuffers, GLint maxRenderbuffers, GLint* numRenderbuffers | finish | noext | | |
+| EVAS GL API | void | glExtGetFramebuffersQCOM | GLuint* framebuffers, GLint maxFramebuffers, GLint* numFramebuffers | finish | noext | | |
+| EVAS GL API | void | glExtGetTexLevelParameterivQCOM | GLuint texture, GLenum face, GLint level, GLenum pname, GLint* params | finish | noext | | |
+| EVAS GL API | void | glExtTexObjectStateOverrideiQCOM | GLenum target, GLenum pname, GLint param | finish | noext | | |
+| EVAS GL API | void | glExtGetTexSubImageQCOM | GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, void* texels | finish | noext | | |
+| EVAS GL API | void | glExtGetBufferPointervQCOM | GLenum target, void** params | finish | noext | | |
+/* GL_QCOM_extended_get2 */
+| EVAS GL API | void | glExtGetShadersQCOM | GLuint* shaders, GLint maxShaders, GLint* numShaders | finish | noext | | |
+| EVAS GL API | void | glExtGetProgramsQCOM | GLuint* programs, GLint maxPrograms, GLint* numPrograms | finish | noext | | |
+| EVAS GL API | GLboolean | glExtIsProgramBinaryQCOM | GLuint program | finish | noext | | |
+| EVAS GL API | void | glExtGetProgramBinarySourceQCOM | GLuint program, GLenum shadertype, char* source, GLint* length | finish | noext | | |
+# OpenGL-ES 1.1
+/* Available only in Common profile */
+| EVAS GL API | void | glAlphaFunc | GLenum func, GLclampf ref | finish | noext | | |
+| EVAS GL API | void | glClipPlanef | GLenum plane, const GLfloat *equation | finish | noext | | |
+| EVAS GL API | void | glColor4f | GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha | finish | noext | | |
+| EVAS GL API | void | glFogf | GLenum pname, GLfloat param | finish | noext | | |
+| EVAS GL API | void | glFogfv | GLenum pname, const GLfloat *params | finish | noext | | |
+| EVAS GL API | void | glFrustumf | GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar | finish | noext | | |
+| EVAS GL API | void | glGetClipPlanef | GLenum pname, GLfloat eqn[4] | finish | noext | | |
+| EVAS GL API | void | glGetLightfv | GLenum light, GLenum pname, GLfloat *params | finish | noext | | |
+| EVAS GL API | void | glGetMaterialfv | GLenum face, GLenum pname, GLfloat *params | finish | noext | | |
+| EVAS GL API | void | glGetTexEnvfv | GLenum env, GLenum pname, GLfloat *params | finish | noext | | |
+| EVAS GL API | void | glLightModelf | GLenum pname, GLfloat param | finish | noext | | |
+| EVAS GL API | void | glLightModelfv | GLenum pname, const GLfloat *params | finish | noext | | |
+| EVAS GL API | void | glLightf | GLenum light, GLenum pname, GLfloat param | finish | noext | | |
+| EVAS GL API | void | glLightfv | GLenum light, GLenum pname, const GLfloat *params | finish | noext | | |
+| EVAS GL API | void | glLoadMatrixf | const GLfloat *m | finish | noext | | |
+| EVAS GL API | void | glMaterialf | GLenum face, GLenum pname, GLfloat param | finish | noext | | |
+| EVAS GL API | void | glMaterialfv | GLenum face, GLenum pname, const GLfloat *params | finish | noext | | |
+| EVAS GL API | void | glMultMatrixf | const GLfloat *m | finish | noext | | |
+| EVAS GL API | void | glMultiTexCoord4f | GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q | finish | noext | | |
+| EVAS GL API | void | glNormal3f | GLfloat nx, GLfloat ny, GLfloat nz | finish | noext | | |
+| EVAS GL API | void | glOrthof | GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar | finish | noext | | |
+| EVAS GL API | void | glPointParameterf | GLenum pname, GLfloat param | finish | noext | | |
+| EVAS GL API | void | glPointParameterfv | GLenum pname, const GLfloat *params | finish | noext | | |
+| EVAS GL API | void | glPointSize | GLfloat size | finish | noext | | |
+| EVAS GL API | void | glPointSizePointerOES | GLenum type, GLsizei stride, const GLvoid * pointer | finish | noext | | |
+| EVAS GL API | void | glRotatef | GLfloat angle, GLfloat x, GLfloat y, GLfloat z | finish | noext | | |
+| EVAS GL API | void | glScalef | GLfloat x, GLfloat y, GLfloat z | finish | noext | | |
+| EVAS GL API | void | glTexEnvf | GLenum target, GLenum pname, GLfloat param | finish | noext | | |
+| EVAS GL API | void | glTexEnvfv | GLenum target, GLenum pname, const GLfloat *params | finish | noext | | |
+| EVAS GL API | void | glTranslatef | GLfloat x, GLfloat y, GLfloat z | finish | noext | | |
+/* Available in both Common and Common-Lite profiles */
+| EVAS GL API | void | glAlphaFuncx | GLenum func, GLclampx ref | finish | noext | | |
+| EVAS GL API | void | glClearColorx | GLclampx red, GLclampx green, GLclampx blue, GLclampx alpha | finish | noext | | |
+| EVAS GL API | void | glClearDepthx | GLclampx depth | finish | noext | | |
+| EVAS GL API | void | glClientActiveTexture | GLenum texture | finish | noext | | |
+| EVAS GL API | void | glClipPlanex | GLenum plane, const GLfixed *equation | finish | noext | | |
+| EVAS GL API | void | glColor4ub | GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha | finish | noext | | |
+| EVAS GL API | void | glColor4x | GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha | finish | noext | | |
+| EVAS GL API | void | glColorPointer | GLint size, GLenum type, GLsizei stride, const GLvoid *pointer | finish | noext | | |
+| EVAS GL API | void | glDepthRangex | GLclampx zNear, GLclampx zFar | finish | noext | | |
+| EVAS GL API | void | glDisableClientState | GLenum array | finish | noext | | |
+| EVAS GL API | void | glEnableClientState | GLenum array | finish | noext | | |
+| EVAS GL API | void | glFogx | GLenum pname, GLfixed param | finish | noext | | |
+| EVAS GL API | void | glFogxv | GLenum pname, const GLfixed *params | finish | noext | | |
+| EVAS GL API | void | glFrustumx | GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar | finish | noext | | |
+| EVAS GL API | void | glGetClipPlanex | GLenum pname, GLfixed eqn[4] | finish | noext | | |
+| EVAS GL API | void | glGetFixedv | GLenum pname, GLfixed *params | finish | noext | | |
+| EVAS GL API | void | glGetLightxv | GLenum light, GLenum pname, GLfixed *params | finish | noext | | |
+| EVAS GL API | void | glGetMaterialxv | GLenum face, GLenum pname, GLfixed *params | finish | noext | | |
+| EVAS GL API | void | glGetPointerv | GLenum pname, GLvoid **params | finish | noext | | |
+| EVAS GL API | void | glGetTexEnviv | GLenum env, GLenum pname, GLint *params | finish | noext | | |
+| EVAS GL API | void | glGetTexEnvxv | GLenum env, GLenum pname, GLfixed *params | finish | noext | | |
+| EVAS GL API | void | glGetTexParameterxv | GLenum target, GLenum pname, GLfixed *params | finish | noext | | |
+| EVAS GL API | void | glLightModelx | GLenum pname, GLfixed param | finish | noext | | |
+| EVAS GL API | void | glLightModelxv | GLenum pname, const GLfixed *params | finish | noext | | |
+| EVAS GL API | void | glLightx | GLenum light, GLenum pname, GLfixed param | finish | noext | | |
+| EVAS GL API | void | glLightxv | GLenum light, GLenum pname, const GLfixed *params | finish | noext | | |
+| EVAS GL API | void | glLineWidthx | GLfixed width | finish | noext | | |
+| EVAS GL API | void | glLoadIdentity | void | finish | noext | | |
+| EVAS GL API | void | glLoadMatrixx | const GLfixed *m | finish | noext | | |
+| EVAS GL API | void | glLogicOp | GLenum opcode | finish | noext | | |
+| EVAS GL API | void | glMaterialx | GLenum face, GLenum pname, GLfixed param | finish | noext | | |
+| EVAS GL API | void | glMaterialxv | GLenum face, GLenum pname, const GLfixed *params | finish | noext | | |
+| EVAS GL API | void | glMatrixMode | GLenum mode | finish | noext | | |
+| EVAS GL API | void | glMultMatrixx | const GLfixed *m | finish | noext | | |
+| EVAS GL API | void | glMultiTexCoord4x | GLenum target, GLfixed s, GLfixed t, GLfixed r, GLfixed q | finish | noext | | |
+| EVAS GL API | void | glNormal3x | GLfixed nx, GLfixed ny, GLfixed nz | finish | noext | | |
+| EVAS GL API | void | glNormalPointer | GLenum type, GLsizei stride, const GLvoid *pointer | finish | noext | | |
+| EVAS GL API | void | glOrthox | GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar | finish | noext | | |
+| EVAS GL API | void | glPointParameterx | GLenum pname, GLfixed param | finish | noext | | |
+| EVAS GL API | void | glPointParameterxv | GLenum pname, const GLfixed *params | finish | noext | | |
+| EVAS GL API | void | glPointSizex | GLfixed size | finish | noext | | |
+| EVAS GL API | void | glPolygonOffsetx | GLfixed factor, GLfixed units | finish | noext | | |
+| EVAS GL API | void | glPopMatrix | void | finish | noext | | |
+| EVAS GL API | void | glPushMatrix | void | finish | noext | | |
+| EVAS GL API | void | glRotatex | GLfixed angle, GLfixed x, GLfixed y, GLfixed z | finish | noext | | |
+| EVAS GL API | void | glSampleCoveragex | GLclampx value, GLboolean invert | finish | noext | | |
+| EVAS GL API | void | glScalex | GLfixed x, GLfixed y, GLfixed z | finish | noext | | |
+| EVAS GL API | void | glShadeModel | GLenum mode | finish | noext | | |
+| EVAS GL API | void | glTexCoordPointer | GLint size, GLenum type, GLsizei stride, const GLvoid *pointer | finish | noext | | |
+| EVAS GL API | void | glTexEnvi | GLenum target, GLenum pname, GLint param | finish | noext | | |
+| EVAS GL API | void | glTexEnvx | GLenum target, GLenum pname, GLfixed param | finish | noext | | |
+| EVAS GL API | void | glTexEnviv | GLenum target, GLenum pname, const GLint *params | finish | noext | | |
+| EVAS GL API | void | glTexEnvxv | GLenum target, GLenum pname, const GLfixed *params | finish | noext | | |
+| EVAS GL API | void | glTexParameterx | GLenum target, GLenum pname, GLfixed param | finish | noext | | |
+| EVAS GL API | void | glTexParameterxv | GLenum target, GLenum pname, const GLfixed *params | finish | noext | | |
+| EVAS GL API | void | glTranslatex | GLfixed x, GLfixed y, GLfixed z | finish | noext | | |
+| EVAS GL API | void | glVertexPointer | GLint size, GLenum type, GLsizei stride, const GLvoid *pointer | finish | noext | | |
+# OpenGL-ES 1.0
+/* GL_OES_blend_equation_separate */
+| EVAS GL API | void | glBlendEquationSeparateOES | GLenum modeRGB, GLenum modeAlpha | finish | noext | | |
+/* GL_OES_blend_func_separate */
+| EVAS GL API | void | glBlendFuncSeparateOES | GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha | finish | noext | | |
+/* GL_OES_blend_subtract */
+| EVAS GL API | void | glBlendEquationOES | GLenum mode | finish | noext | | |
+/* GL_OES_draw_texture */
+| EVAS GL API | void | glDrawTexsOES | GLshort x, GLshort y, GLshort z, GLshort width, GLshort height | finish | noext | | |
+| EVAS GL API | void | glDrawTexiOES | GLint x, GLint y, GLint z, GLint width, GLint height | finish | noext | | |
+| EVAS GL API | void | glDrawTexxOES | GLfixed x, GLfixed y, GLfixed z, GLfixed width, GLfixed height | finish | noext | | |
+| EVAS GL API | void | glDrawTexsvOES | const GLshort *coords | finish | noext | | |
+| EVAS GL API | void | glDrawTexivOES | const GLint *coords | finish | noext | | |
+| EVAS GL API | void | glDrawTexxvOES | const GLfixed *coords | finish | noext | | |
+| EVAS GL API | void | glDrawTexfOES | GLfloat x, GLfloat y, GLfloat z, GLfloat width, GLfloat height | finish | noext | | |
+| EVAS GL API | void | glDrawTexfvOES | const GLfloat *coords | finish | noext | | |
+/* GL_OES_fixed_point */
+| EVAS GL API | void | glAlphaFuncxOES | GLenum func, GLclampx ref | finish | noext | | |
+| EVAS GL API | void | glClearColorxOES | GLclampx red, GLclampx green, GLclampx blue, GLclampx alpha | finish | noext | | |
+| EVAS GL API | void | glClearDepthxOES | GLclampx depth | finish | noext | | |
+| EVAS GL API | void | glClipPlanexOES | GLenum plane, const GLfixed *equation | finish | noext | | |
+| EVAS GL API | void | glColor4xOES | GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha | finish | noext | | |
+| EVAS GL API | void | glDepthRangexOES | GLclampx zNear, GLclampx zFar | finish | noext | | |
+| EVAS GL API | void | glFogxOES | GLenum pname, GLfixed param | finish | noext | | |
+| EVAS GL API | void | glFogxvOES | GLenum pname, const GLfixed *params | finish | noext | | |
+| EVAS GL API | void | glFrustumxOES | GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar | finish | noext | | |
+| EVAS GL API | void | glGetClipPlanexOES | GLenum pname, GLfixed eqn[4] | finish | noext | | |
+| EVAS GL API | void | glGetFixedvOES | GLenum pname, GLfixed *params | finish | noext | | |
+| EVAS GL API | void | glGetLightxvOES | GLenum light, GLenum pname, GLfixed *params | finish | noext | | |
+| EVAS GL API | void | glGetMaterialxvOES | GLenum face, GLenum pname, GLfixed *params | finish | noext | | |
+| EVAS GL API | void | glGetTexEnvxvOES | GLenum env, GLenum pname, GLfixed *params | finish | noext | | |
+| EVAS GL API | void | glGetTexParameterxvOES | GLenum target, GLenum pname, GLfixed *params | finish | noext | | |
+| EVAS GL API | void | glLightModelxOES | GLenum pname, GLfixed param | finish | noext | | |
+| EVAS GL API | void | glLightModelxvOES | GLenum pname, const GLfixed *params | finish | noext | | |
+| EVAS GL API | void | glLightxOES | GLenum light, GLenum pname, GLfixed param | finish | noext | | |
+| EVAS GL API | void | glLightxvOES | GLenum light, GLenum pname, const GLfixed *params | finish | noext | | |
+| EVAS GL API | void | glLineWidthxOES | GLfixed width | finish | noext | | |
+| EVAS GL API | void | glLoadMatrixxOES | const GLfixed *m | finish | noext | | |
+| EVAS GL API | void | glMaterialxOES | GLenum face, GLenum pname, GLfixed param | finish | noext | | |
+| EVAS GL API | void | glMaterialxvOES | GLenum face, GLenum pname, const GLfixed *params | finish | noext | | |
+| EVAS GL API | void | glMultMatrixxOES | const GLfixed *m | finish | noext | | |
+| EVAS GL API | void | glMultiTexCoord4xOES | GLenum target, GLfixed s, GLfixed t, GLfixed r, GLfixed q | finish | noext | | |
+| EVAS GL API | void | glNormal3xOES | GLfixed nx, GLfixed ny, GLfixed nz | finish | noext | | |
+| EVAS GL API | void | glOrthoxOES | GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar | finish | noext | | |
+| EVAS GL API | void | glPointParameterxOES | GLenum pname, GLfixed param | finish | noext | | |
+| EVAS GL API | void | glPointParameterxvOES | GLenum pname, const GLfixed *params | finish | noext | | |
+| EVAS GL API | void | glPointSizexOES | GLfixed size | finish | noext | | |
+| EVAS GL API | void | glPolygonOffsetxOES | GLfixed factor, GLfixed units | finish | noext | | |
+| EVAS GL API | void | glRotatexOES | GLfixed angle, GLfixed x, GLfixed y, GLfixed z | finish | noext | | |
+| EVAS GL API | void | glSampleCoveragexOES | GLclampx value, GLboolean invert | finish | noext | | |
+| EVAS GL API | void | glScalexOES | GLfixed x, GLfixed y, GLfixed z | finish | noext | | |
+| EVAS GL API | void | glTexEnvxOES | GLenum target, GLenum pname, GLfixed param | finish | noext | | |
+| EVAS GL API | void | glTexEnvxvOES | GLenum target, GLenum pname, const GLfixed *params | finish | noext | | |
+| EVAS GL API | void | glTexParameterxOES | GLenum target, GLenum pname, GLfixed param | finish | noext | | |
+| EVAS GL API | void | glTexParameterxvOES | GLenum target, GLenum pname, const GLfixed *params | finish | noext | | |
+| EVAS GL API | void | glTranslatexOES | GLfixed x, GLfixed y, GLfixed z | finish | noext | | |
+/* GL_OES_framebuffer_object */
+| EVAS GL API | GLboolean | glIsRenderbufferOES | GLuint renderbuffer | finish | noext | | |
+| EVAS GL API | void | glBindRenderbufferOES | GLenum target, GLuint renderbuffer | flush | noext | | |
+| EVAS GL API | void | glDeleteRenderbuffersOES | GLsizei n, const GLuint* renderbuffers | flush | noext | _mp_delete_object, n * sizeof(GLuint), renderbuffers | |
+| EVAS GL API | void | glGenRenderbuffersOES | GLsizei n, GLuint* renderbuffers | finish | noext | | |
+| EVAS GL API | void | glRenderbufferStorageOES | GLenum target, GLenum internalformat, GLsizei width, GLsizei height | flush | noext | | |
+| EVAS GL API | void | glGetRenderbufferParameterivOES | GLenum target, GLenum pname, GLint* params | finish | noext | | |
+| EVAS GL API | GLboolean | glIsFramebufferOES | GLuint framebuffer | finish | noext | | |
+| EVAS GL API | void | glBindFramebufferOES | GLenum target, GLuint framebuffer | flush | noext | | |
+| EVAS GL API | void | glDeleteFramebuffersOES | GLsizei n, const GLuint* framebuffers | flush | noext |  _mp_delete_object, n * sizeof(GLuint), framebuffers| |
+| EVAS GL API | void | glGenFramebuffersOES | GLsizei n, GLuint* framebuffers | finish | noext | | |
+| EVAS GL API | GLenum | glCheckFramebufferStatusOES | GLenum target | finish | noext | | |
+| EVAS GL API | void | glFramebufferRenderbufferOES | GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer | flush | noext | | |
+| EVAS GL API | void | glFramebufferTexture2DOES | GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level | flush | noext | | |
+| EVAS GL API | void | glGetFramebufferAttachmentParameterivOES | GLenum target, GLenum attachment, GLenum pname, GLint* params | finish | noext | | |
+| EVAS GL API | void | glGenerateMipmapOES | GLenum target | finish | noext | | |
+/* GL_OES_matrix_palette */
+| EVAS GL API | void | glCurrentPaletteMatrixOES | GLuint matrixpaletteindex | finish | noext | | |
+| EVAS GL API | void | glLoadPaletteFromModelViewMatrixOES | void | finish | noext | | |
+| EVAS GL API | void | glMatrixIndexPointerOES | GLint size, GLenum type, GLsizei stride, const GLvoid *pointer | finish | noext | | |
+| EVAS GL API | void | glWeightPointerOES | GLint size, GLenum type, GLsizei stride, const GLvoid *pointer | finish | noext | | |
+/* GL_OES_query_matrix */
+| EVAS GL API | GLbitfield | glQueryMatrixxOES | GLfixed mantissa[16], GLint exponent[16] | finish | noext | | |
+/* GL_OES_single_precision */
+| EVAS GL API | void | glDepthRangefOES | GLclampf zNear, GLclampf zFar | finish | noext | | |
+| EVAS GL API | void | glFrustumfOES | GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar | finish | noext | | |
+| EVAS GL API | void | glOrthofOES | GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar | finish | noext | | |
+| EVAS GL API | void | glClipPlanefOES | GLenum plane, const GLfloat *equation | finish | noext | | |
+| EVAS GL API | void | glGetClipPlanefOES | GLenum pname, GLfloat eqn[4] | finish | noext | | |
+| EVAS GL API | void | glClearDepthfOES | GLclampf depth | finish | noext | | |
+/* GL_OES_texture_cube_map */
+| EVAS GL API | void | glTexGenfOES | GLenum coord, GLenum pname, GLfloat param | finish | noext | | |
+| EVAS GL API | void | glTexGenfvOES | GLenum coord, GLenum pname, const GLfloat *params | finish | noext | | |
+| EVAS GL API | void | glTexGeniOES | GLenum coord, GLenum pname, GLint param | finish | noext | | |
+| EVAS GL API | void | glTexGenivOES | GLenum coord, GLenum pname, const GLint *params | finish | noext | | |
+| EVAS GL API | void | glTexGenxOES | GLenum coord, GLenum pname, GLfixed param | finish | noext | | |
+| EVAS GL API | void | glTexGenxvOES | GLenum coord, GLenum pname, const GLfixed *params | finish | noext | | |
+| EVAS GL API | void | glGetTexGenfvOES | GLenum coord, GLenum pname, GLfloat *params | finish | noext | | |
+| EVAS GL API | void | glGetTexGenivOES | GLenum coord, GLenum pname, GLint *params | finish | noext | | |
+| EVAS GL API | void | glGetTexGenxvOES | GLenum coord, GLenum pname, GLfixed *params | finish | noext | | |
+/* GL_OES_vertex_array_object */
+| EVAS GL API | void | glBindVertexArrayOES | GLuint array | finish | noext | | |
+| EVAS GL API | void | glDeleteVertexArraysOES | GLsizei n, const GLuint *arrays | finish | noext | | |
+| EVAS GL API | void | glGenVertexArraysOES | GLsizei n, GLuint *arrays | finish | noext | | |
+| EVAS GL API | GLboolean | glIsVertexArrayOES | GLuint array | finish | noext | | |
+/* GL_APPLE_copy_texture_levels */
+| EVAS GL API | void | glCopyTextureLevelsAPPLE | GLuint destinationTexture, GLuint sourceTexture, GLint sourceBaseLevel, GLsizei sourceLevelCount | finish | noext | | |
+| EVAS GL API | void | glRenderbufferStorageMultisampleAPPLE | GLenum a, GLsizei b, GLenum c, GLsizei d, GLsizei e | finish | noext | | |
+| EVAS GL API | void | glResolveMultisampleFramebufferAPPLE | void | finish | noext | | |
+| EVAS GL API | GLsync | glFenceSyncAPPLE | GLenum condition, GLbitfield flags | finish | noext | | |
+| EVAS GL API | GLboolean | glIsSyncAPPLE | GLsync sync | finish | noext | | |
+| EVAS GL API | void | glDeleteSyncAPPLE | GLsync sync | finish | noext | | |
+| EVAS GL API | GLenum | glClientWaitSyncAPPLE | GLsync sync, GLbitfield flags, EvasGLuint64 timeout | finish | noext | | |
+| EVAS GL API | void | glWaitSyncAPPLE | GLsync sync, GLbitfield flags, EvasGLuint64 timeout | finish | noext | | |
+| EVAS GL API | void | glGetInteger64vAPPLE | GLenum pname, EvasGLint64 *params | finish | noext | | |
+| EVAS GL API | void | glGetSyncivAPPLE | GLsync sync, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *values | finish | noext | | |
+/* GL_EXT_map_buffer_range */
+| EVAS GL API | void * | glMapBufferRangeEXT | GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access | finish | noext | | |
+| EVAS GL API | void | glFlushMappedBufferRangeEXT | GLenum target, GLintptr offset, GLsizeiptr length | finish | noext | | |
+/* GL_EXT_multisampled_render_to_texture */
+| EVAS GL API | void | glRenderbufferStorageMultisampleEXT | GLenum a, GLsizei b, GLenum c, GLsizei d, GLsizei e| finish | noext | | |
+| EVAS GL API | void | glFramebufferTexture2DMultisample | GLenum a, GLenum b, GLenum c, GLuint d, GLint e, GLsizei f | flush | noext | | |
+| EVAS GL API | void | glFramebufferTexture2DMultisampleEXT | GLenum a, GLenum b, GLenum c, GLuint d, GLint e, GLsizei f | flush | noext | | |
+/* GL_EXT_robustness */
+| EVAS GL API | GLenum | glGetGraphicsResetStatus | void | finish | noext | | |
+| EVAS GL API | GLenum | glGetGraphicsResetStatusEXT | void | finish | noext | | |
+| EVAS GL API | void | glReadnPixels | GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLsizei bufSize, void *data | finish | noext | | |
+| EVAS GL API | void | glReadnPixelsEXT | GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLsizei bufSize, void *data | finish | noext | | |
+| EVAS GL API | void | glGetnUniformfv | GLuint program, GLint location, GLsizei bufSize, float *params | finish | noext | | |
+| EVAS GL API | void | glGetnUniformfvEXT | GLuint program, GLint location, GLsizei bufSize, float *params | finish | noext | | |
+| EVAS GL API | void | glGetnUniformiv | GLuint program, GLint location, GLsizei bufSize, GLint *params | finish | noext | | |
+| EVAS GL API | void | glGetnUniformivEXT | GLuint program, GLint location, GLsizei bufSize, GLint *params | finish | noext | | |
+/* GL_EXT_texture_storage */
+| EVAS GL API | void | glTexStorage1DEXT | GLenum target, GLsizei levels, GLenum internalformat, GLsizei width | finish | noext | | |
+| EVAS GL API | void | glTexStorage2DEXT | GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height | finish | noext | | |
+| EVAS GL API | void | glTexStorage3DEXT | GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth | finish | noext | | |
+| EVAS GL API | void | glTextureStorage1DEXT | GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width | finish | noext | | |
+| EVAS GL API | void | glTextureStorage2DEXT | GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height | finish | noext | | |
+| EVAS GL API | void | glTextureStorage3DEXT | GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth | finish | noext | | |
+/* GL_IMG_user_clip_plane */
+| EVAS GL API | void | glClipPlanefIMG | GLenum a, const GLfloat * b | finish | noext | | |
+| EVAS GL API | void | glClipPlanexIMG | GLenum a, const GLfixed * b | finish | noext | | |
+/* GL_IMG_multisampled_render_to_texture */
+| EVAS GL API | void | glRenderbufferStorageMultisampleIMG | GLenum a, GLsizei b, GLenum c, GLsizei d, GLsizei e | flush | noext | | |
+| EVAS GL API | void | glFramebufferTexture2DMultisampleIMG | GLenum a, GLenum b, GLenum c, GLuint d, GLint e, GLsizei f | flush | noext | | |
+/* GL_QCOM_tiled_rendering */
+| EVAS GL API | void | glStartTilingQCOM | GLuint x, GLuint y, GLuint width, GLuint height, GLbitfield preserveMask | flush | noext | | |
+| EVAS GL API | void | glEndTilingQCOM | GLbitfield preserveMask | flush | noext | | |
+# OpenGL-ES 3.0
+| EVAS GL API | void | glBeginQuery | GLenum target, GLuint id | finish | noext | | |
+| EVAS GL API | void | glBeginTransformFeedback | GLenum primitiveMode | finish | noext | | |
+| EVAS GL API | void | glBindBufferBase | GLenum target, GLuint index, GLuint buffer | finish | noext | | |
+| EVAS GL API | void | glBindBufferRange | GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size | finish | noext | | |
+| EVAS GL API | void | glBindSampler | GLuint unit, GLuint sampler | finish | noext | | |
+| EVAS GL API | void | glBindTransformFeedback | GLenum target, GLuint id | finish | noext | | |
+| EVAS GL API | void | glBindVertexArray | GLuint array | finish | noext | | |
+| EVAS GL API | void | glBlitFramebuffer | GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter | finish | noext | | |
+| EVAS GL API | void | glClearBufferfi | GLenum buffer, GLint drawBuffer, GLfloat depth, GLint stencil | finish | noext | | |
+| EVAS GL API | void | glClearBufferfv | GLenum buffer, GLint drawBuffer, const GLfloat * value | finish | noext | | |
+| EVAS GL API | void | glClearBufferiv | GLenum buffer, GLint drawBuffer, const GLint * value | finish | noext | | |
+| EVAS GL API | void | glClearBufferuiv | GLenum buffer, GLint drawBuffer, const GLuint * value | finish | noext | | |
+| EVAS GL API | GLenum | glClientWaitSync | GLsync sync, GLbitfield flags, EvasGLuint64 timeout | finish | noext | | |
+| EVAS GL API | void | glCompressedTexImage3D | GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid * data | finish | noext | | |
+| EVAS GL API | void | glCompressedTexSubImage3D | GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid * data | finish | noext | | |
+| EVAS GL API | void | glCopyBufferSubData | GLenum readtarget, GLenum writetarget, GLintptr readoffset, GLintptr writeoffset, GLsizeiptr size | finish | noext | | |
+| EVAS GL API | void | glCopyTexSubImage3D | GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height | finish | noext | | |
+| EVAS GL API | void | glDeleteQueries | GLsizei n, const GLuint * ids | finish | noext | | |
+| EVAS GL API | void | glDeleteSamplers | GLsizei n, const GLuint * samplers | finish | noext | | |
+| EVAS GL API | void | glDeleteSync | GLsync sync | finish | noext | | |
+| EVAS GL API | void | glDeleteTransformFeedbacks | GLsizei n, const GLuint *ids | finish | noext | | |
+| EVAS GL API | void | glDeleteVertexArrays | GLsizei n, const GLuint *arrays | finish | noext | | |
+| EVAS GL API | void | glDrawArraysInstanced | GLenum mode, GLint first, GLsizei count, GLsizei primcount | finish | noext | | |
+| EVAS GL API | void | glDrawBuffers | GLsizei n, const GLenum *bufs | finish | noext | | |
+| EVAS GL API | void | glDrawElementsInstanced | GLenum mode, GLsizei count, GLenum type, const void * indices, GLsizei primcount | finish | noext | | |
+| EVAS GL API | void | glDrawRangeElements | GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid * indices | finish | noext | | |
+| EVAS GL API | void | glEndQuery | GLenum target | finish | noext | | |
+| EVAS GL API | void | glEndTransformFeedback | void | finish | noext | | |
+| EVAS GL API | GLsync | glFenceSync | GLenum condition, GLbitfield flags | finish | noext | | |
+| EVAS GL API | GLsync | glFlushMappedBufferRange | GLenum target, GLintptr offset, GLsizeiptr length | finish | noext | | |
+| EVAS GL API | void | glFramebufferTextureLayer | GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer | finish | noext | | |
+| EVAS GL API | void | glGenQueries | GLsizei n, GLuint * ids | finish | noext | | |
+| EVAS GL API | void | glGenSamplers | GLsizei n, GLuint *samplers | finish | noext | | |
+| EVAS GL API | void | glGenTransformFeedbacks | GLsizei n, GLuint *ids | finish | noext | | |
+| EVAS GL API | void | glGenVertexArrays | GLsizei n, GLuint *arrays | finish | noext | | |
+| EVAS GL API | void | glGetActiveUniformBlockiv | GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params | finish | noext | | |
+| EVAS GL API | void | glGetActiveUniformBlockName | GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName | finish | noext | | |
+| EVAS GL API | void | glGetActiveUniformsiv | GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params | finish | noext | | |
+| EVAS GL API | void | glGetBufferParameteri64v | GLenum target, GLenum value, EvasGLint64 * data | finish | noext | | |
+| EVAS GL API | void | glGetBufferPointerv | GLenum target, GLenum pname, GLvoid ** params | finish | noext | | |
+| EVAS GL API | GLint | glGetFragDataLocation | GLuint program, const char * name | finish | noext | | |
+| EVAS GL API | void | glGetInteger64i_v | GLenum target, GLuint index, EvasGLint64 * data | finish | noext | | |
+| EVAS GL API | void | glGetInteger64v | GLenum pname, EvasGLint64 * data | finish | noext | | |
+| EVAS GL API | void | glGetIntegeri_v | GLenum target, GLuint index, GLint * data | finish | noext | | |
+| EVAS GL API | void | glGetInternalformativ | GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint *params | finish | noext | | |
+| EVAS GL API | void | glGetProgramBinary | GLuint program, GLsizei bufsize, GLsizei *length, GLenum *binaryFormat, void *binary | finish | noext | | |
+| EVAS GL API | void | glGetQueryiv | GLenum target, GLenum pname, GLint * params | finish | noext | | |
+| EVAS GL API | void | glGetQueryObjectuiv | GLuint id, GLenum pname, GLuint * params | finish | noext | | |
+| EVAS GL API | void | glGetSamplerParameterfv | GLuint sampler, GLenum pname, GLfloat * params | finish | noext | | |
+| EVAS GL API | void | glGetSamplerParameteriv | GLuint sampler, GLenum pname, GLint * params | finish | noext | | |
+| EVAS GL API | const GLubyte * | glGetStringi | GLenum name, GLuint index | finish | noext | | |
+| EVAS GL API | void | glGetSynciv | GLsync sync, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *values | finish | noext | | |
+| EVAS GL API | void | glGetTransformFeedbackVarying | GLuint program, GLuint index, GLsizei bufSize, GLsizei * length, GLsizei * size, GLenum * type, char * name | finish | noext | | |
+| EVAS GL API | GLuint | glGetUniformBlockIndex | GLuint program, const GLchar *uniformBlockName | finish | noext | | |
+| EVAS GL API | void | glGetUniformIndices | GLuint program, GLsizei uniformCount, const GLchar *const*uniformNames, GLuint *uniformIndices | finish | noext | | |
+| EVAS GL API | void | glGetUniformuiv | GLuint program, GLint location, GLuint* params | finish | noext | | |
+| EVAS GL API | void | glGetVertexAttribIiv | GLuint index, GLenum pname, GLint *params | finish | noext | | |
+| EVAS GL API | void | glGetVertexAttribIuiv | GLuint index, GLenum pname, GLuint *params | finish | noext | | |
+| EVAS GL API | void | glInvalidateFramebuffer | GLenum target, GLsizei numAttachments, const GLenum *attachments | finish | noext | | |
+| EVAS GL API | void | glInvalidateSubFramebuffer | GLenum target, GLsizei numAttachments, const GLenum *attachments, GLint x, GLint y, GLsizei width, GLsizei height | finish | noext | | |
+| EVAS GL API | GLboolean | glIsQuery | GLuint id | finish | noext | | |
+| EVAS GL API | GLboolean | glIsSampler | GLuint id | finish | noext | | |
+| EVAS GL API | GLboolean | glIsSync | GLsync sync | finish | noext | | |
+| EVAS GL API | GLboolean | glIsTransformFeedback | GLuint id | finish | noext | | |
+| EVAS GL API | GLboolean | glIsVertexArray | GLuint array | finish | noext | | |
+| EVAS GL API | void * | glMapBufferRange | GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access | finish | noext | | |
+| EVAS GL API | void | glPauseTransformFeedback | void | finish | noext | | |
+| EVAS GL API | void | glProgramBinary | GLuint program, GLenum binaryFormat, const void *binary, GLsizei length | flush | noext | _mp_default, length, binary | |
+| EVAS GL API | void | glProgramParameteri | GLuint program, GLenum pname, GLint value | finish | noext | | |
+| EVAS GL API | void | glReadBuffer | GLenum src | finish | noext | | |
+| EVAS GL API | void | glRenderbufferStorageMultisample | GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height | finish | noext | | |
+| EVAS GL API | void | glResumeTransformFeedback | void | finish | noext | | |
+| EVAS GL API | void | glSamplerParameterf | GLuint sampler, GLenum pname, GLfloat param | finish | noext | | |
+| EVAS GL API | void | glSamplerParameterfv | GLuint sampler, GLenum pname, const GLfloat * params | finish | noext | | |
+| EVAS GL API | void | glSamplerParameteri | GLuint sampler, GLenum pname, GLint param | finish | noext | | |
+| EVAS GL API | void | glSamplerParameteriv | GLuint sampler, GLenum pname, const GLint * params | finish | noext | | |
+| EVAS GL API | void | glTexImage3D | GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid * data | finish | noext | | |
+| EVAS GL API | void | glTexStorage2D | GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height | finish | noext | | |
+| EVAS GL API | void | glTexStorage3D | GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth | finish | noext | | |
+| EVAS GL API | void | glTexSubImage3D | GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid * data | finish | noext | | |
+| EVAS GL API | void | glTransformFeedbackVaryings | GLuint program, GLsizei count, const GLchar *const* varyings, GLenum bufferMode | finish | noext | | |
+| EVAS GL API | void | glUniform1ui | GLint location, GLuint v0 | finish | noext | | |
+| EVAS GL API | void | glUniform1uiv | GLint location, GLsizei count, const GLuint *value | finish | noext | | |
+| EVAS GL API | void | glUniform2ui | GLint location, GLuint v0, GLuint v1 | finish | noext | | |
+| EVAS GL API | void | glUniform2uiv | GLint location, GLsizei count, const GLuint *value | finish | noext | | |
+| EVAS GL API | void | glUniform3ui | GLint location, GLuint v0, GLuint v1, GLuint v2 | finish | noext | | |
+| EVAS GL API | void | glUniform3uiv | GLint location, GLsizei count, const GLuint *value | finish | noext | | |
+| EVAS GL API | void | glUniform4ui | GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3 | finish | noext | | |
+| EVAS GL API | void | glUniform4uiv | GLint location, GLsizei count, const GLuint *value | finish | noext | | |
+| EVAS GL API | void | glUniformBlockBinding | GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding | finish | noext | | |
+| EVAS GL API | void | glUniformMatrix2x3fv | GLint location, GLsizei count, GLboolean transpose, const GLfloat *value | finish | noext | | |
+| EVAS GL API | void | glUniformMatrix3x2fv | GLint location, GLsizei count, GLboolean transpose, const GLfloat *value | finish | noext | | |
+| EVAS GL API | void | glUniformMatrix2x4fv | GLint location, GLsizei count, GLboolean transpose, const GLfloat *value | finish | noext | | |
+| EVAS GL API | void | glUniformMatrix4x2fv | GLint location, GLsizei count, GLboolean transpose, const GLfloat *value | finish | noext | | |
+| EVAS GL API | void | glUniformMatrix3x4fv | GLint location, GLsizei count, GLboolean transpose, const GLfloat *value | finish | noext | | |
+| EVAS GL API | void | glUniformMatrix4x3fv | GLint location, GLsizei count, GLboolean transpose, const GLfloat *value | finish | noext | | |
+| EVAS GL API | GLboolean | glUnmapBuffer | GLenum target | finish | noext | | |
+| EVAS GL API | void | glVertexAttribDivisor | GLuint index, GLuint divisor | finish | noext | | |
+| EVAS GL API | void | glVertexAttribI4i | GLuint index, GLint v0, GLint v1, GLint v2, GLint v3 | finish | noext | | |
+| EVAS GL API | void | glVertexAttribI4iv | GLuint index, const GLint *v | finish | noext | | |
+| EVAS GL API | void | glVertexAttribI4ui | GLuint index, GLuint v0, GLuint v1, GLuint v2, GLuint v3 | finish | noext | | |
+| EVAS GL API | void | glVertexAttribI4uiv | GLuint index, const GLuint *v | finish | noext | | |
+| EVAS GL API | void | glVertexAttribIPointer | GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer | finish | noext | | |
+| EVAS GL API | void | glWaitSync | GLsync sync, GLbitfield flags, EvasGLuint64 timeout | finish | noext | | |
+# OpenGL-ES 3.1
+| EVAS GL API | void | glDispatchCompute | GLuint num_groups_x, GLuint num_groups_y, GLuint num_groups_z | finish | noext | | |
+| EVAS GL API | void | glDispatchComputeIndirect | GLintptr indirect | finish | noext | | |
+| EVAS GL API | void | glDrawArraysIndirect | GLenum mode, const void *indirect | finish | noext | | |
+| EVAS GL API | void | glDrawElementsIndirect | GLenum mode, GLenum type, const void *indirect | finish | noext | | |
+| EVAS GL API | void | glFramebufferParameteri | GLenum target, GLenum pname, GLint param | finish | noext | | |
+| EVAS GL API | void | glGetFramebufferParameteriv | GLenum target, GLenum pname, GLint *params | finish | noext | | |
+| EVAS GL API | void | glGetProgramInterfaceiv | GLuint program, GLenum programInterface, GLenum pname, GLint *params | finish | noext | | |
+| EVAS GL API | GLuint | glGetProgramResourceIndex | GLuint program, GLenum programInterface, const GLchar *name | finish | noext | | |
+| EVAS GL API | void | glGetProgramResourceName | GLuint program, GLenum programInterface, GLuint index, GLsizei bufSize, GLsizei *length, GLchar *name | finish | noext | | |
+| EVAS GL API | void | glGetProgramResourceiv | GLuint program, GLenum programInterface, GLuint index, GLsizei propCount, const GLenum *props, GLsizei bufSize, GLsizei *length, GLint *params | finish | noext | | |
+| EVAS GL API | GLint |glGetProgramResourceLocation | GLuint program, GLenum programInterface, const GLchar *name | finish | noext | | |
+| EVAS GL API | void | glUseProgramStages | GLuint pipeline, GLbitfield stages, GLuint program | finish | noext | | |
+| EVAS GL API | void | glActiveShaderProgram | GLuint pipeline, GLuint program | finish | noext | | |
+| EVAS GL API | GLuint | glCreateShaderProgramv | GLenum type, GLsizei count, const GLchar *const*strings | finish | noext | | |
+| EVAS GL API | void | glBindProgramPipeline | GLuint pipeline | finish | noext | | |
+| EVAS GL API | void | glDeleteProgramPipelines | GLsizei n, const GLuint *pipelines | finish | noext | | |
+| EVAS GL API | void | glGenProgramPipelines | GLsizei n, GLuint *pipelines | finish | noext | | |
+| EVAS GL API | GLboolean | glIsProgramPipeline | GLuint pipeline | finish | noext | | |
+| EVAS GL API | void | glGetProgramPipelineiv | GLuint pipeline, GLenum pname, GLint *params | finish | noext | | |
+| EVAS GL API | void | glProgramUniform1i | GLuint program, GLint location, GLint v0 | finish | noext | | |
+| EVAS GL API | void | glProgramUniform2i | GLuint program, GLint location, GLint v0, GLint v1 | finish | noext | | |
+| EVAS GL API | void | glProgramUniform3i | GLuint program, GLint location, GLint v0, GLint v1, GLint v2 | finish | noext | | |
+| EVAS GL API | void | glProgramUniform4i | GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3 | finish | noext | | |
+| EVAS GL API | void | glProgramUniform1ui | GLuint program, GLint location, GLuint v0 | finish | noext | | |
+| EVAS GL API | void | glProgramUniform2ui | GLuint program, GLint location, GLuint v0, GLuint v1 | finish | noext | | |
+| EVAS GL API | void | glProgramUniform3ui | GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2 | finish | noext | | |
+| EVAS GL API | void | glProgramUniform4ui | GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3 | finish | noext | | |
+| EVAS GL API | void | glProgramUniform1f | GLuint program, GLint location, GLfloat v0 | finish | noext | | |
+| EVAS GL API | void | glProgramUniform2f | GLuint program, GLint location, GLfloat v0, GLfloat v1 | finish | noext | | |
+| EVAS GL API | void | glProgramUniform3f | GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2 | finish | noext | | |
+| EVAS GL API | void | glProgramUniform4f | GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3 | finish | noext | | |
+| EVAS GL API | void | glProgramUniform1iv | GLuint program, GLint location, GLsizei count, const GLint *value | finish | noext | | |
+| EVAS GL API | void | glProgramUniform2iv | GLuint program, GLint location, GLsizei count, const GLint *value | finish | noext | | |
+| EVAS GL API | void | glProgramUniform3iv | GLuint program, GLint location, GLsizei count, const GLint *value | finish | noext | | |
+| EVAS GL API | void | glProgramUniform4iv | GLuint program, GLint location, GLsizei count, const GLint *value | finish | noext | | |
+| EVAS GL API | void | glProgramUniform1uiv | GLuint program, GLint location, GLsizei count, const GLuint *value | finish | noext | | |
+| EVAS GL API | void | glProgramUniform2uiv | GLuint program, GLint location, GLsizei count, const GLuint *value | finish | noext | | |
+| EVAS GL API | void | glProgramUniform3uiv | GLuint program, GLint location, GLsizei count, const GLuint *value | finish | noext | | |
+| EVAS GL API | void | glProgramUniform4uiv | GLuint program, GLint location, GLsizei count, const GLuint *value | finish | noext | | |
+| EVAS GL API | void | glProgramUniform1fv | GLuint program, GLint location, GLsizei count, const GLfloat *value | finish | noext | | |
+| EVAS GL API | void | glProgramUniform2fv | GLuint program, GLint location, GLsizei count, const GLfloat *value | finish | noext | | |
+| EVAS GL API | void | glProgramUniform3fv | GLuint program, GLint location, GLsizei count, const GLfloat *value | finish | noext | | |
+| EVAS GL API | void | glProgramUniform4fv | GLuint program, GLint location, GLsizei count, const GLfloat *value | finish | noext | | |
+| EVAS GL API | void | glProgramUniformMatrix2fv | GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value | finish | noext | | |
+| EVAS GL API | void | glProgramUniformMatrix3fv | GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value | finish | noext | | |
+| EVAS GL API | void | glProgramUniformMatrix4fv | GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value | finish | noext | | |
+| EVAS GL API | void | glProgramUniformMatrix2x3fv | GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value | finish | noext | | |
+| EVAS GL API | void | glProgramUniformMatrix3x2fv | GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value | finish | noext | | |
+| EVAS GL API | void | glProgramUniformMatrix2x4fv | GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value | finish | noext | | |
+| EVAS GL API | void | glProgramUniformMatrix4x2fv | GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value | finish | noext | | |
+| EVAS GL API | void | glProgramUniformMatrix3x4fv | GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value | finish | noext | | |
+| EVAS GL API | void | glProgramUniformMatrix4x3fv | GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value | finish | noext | | |
+| EVAS GL API | void | glValidateProgramPipeline | GLuint pipeline | finish | noext | | |
+| EVAS GL API | void | glGetProgramPipelineInfoLog | GLuint pipeline, GLsizei bufSize, GLsizei *length, GLchar *infoLog | finish | noext | | |
+| EVAS GL API | void | glBindImageTexture | GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLenum format | finish | noext | | |
+| EVAS GL API | void | glGetBooleani_v | GLenum target, GLuint index, GLboolean *data | finish | noext | | |
+| EVAS GL API | void | glMemoryBarrier | GLbitfield barriers | finish | noext | | |
+| EVAS GL API | void | glMemoryBarrierByRegion | GLbitfield barriers | finish | noext | | |
+| EVAS GL API | void | glTexStorage2DMultisample | GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations | finish | noext | | |
+| EVAS GL API | void | glGetMultisamplefv | GLenum pname, GLuint index, GLfloat *val | finish | noext | | |
+| EVAS GL API | void | glSampleMaski | GLuint maskNumber, GLbitfield mask | finish | noext | | |
+| EVAS GL API | void | glGetTexLevelParameteriv | GLenum target, GLint level, GLenum pname, GLint *params | finish | noext | | |
+| EVAS GL API | void | glGetTexLevelParameterfv | GLenum target, GLint level, GLenum pname, GLfloat *params | finish | noext | | |
+| EVAS GL API | void | glBindVertexBuffer | GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride | finish | noext | | |
+| EVAS GL API | void | glVertexAttribFormat | GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset | finish | noext | | |
+| EVAS GL API | void | glVertexAttribIFormat | GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset | finish | noext | | |
+| EVAS GL API | void | glVertexAttribBinding | GLuint attribindex, GLuint bindingindex | finish | noext | | |
+| EVAS GL API | void | glVertexBindingDivisor | GLuint bindingindex, GLuint divisor | finish | noext | | |
+###
+| EVAS GL API | void | glEGLImageTargetTexture2DOES | GLenum target,void *image | finish | ext | | |
+| EVAS GL API | void | glEGLImageTargetRenderbufferStorageOES | GLenum target, void *image | flush | ext | | |
+### Evas GL
+| EVAS GL API | void | _evgl_glDiscardFramebufferEXT | GLenum target, GLsizei numAttachments, const GLenum* attachments | finish | ext | | |
+| EVAS GL API | void | _evgl_glEvasGLImageTargetTexture2D | GLenum target, EvasGLImage image | finish | ext | | |
+| EVAS GL API | void | _evgl_glEvasGLImageTargetRenderbufferStorage | GLenum target, EvasGLImage image | finish | ext | | |
+| EVAS GL API | EvasGLImage | _evgl_evasglCreateImage | int target, void* buffer, const int *attrib_list | finish | ext | | |
+| EVAS GL API | void | _evgl_evasglDestroyImage | EvasGLImage image | finish | ext | | |
+| EVAS GL API | EvasGLImage | _evgl_evasglCreateImageForContext | Evas_GL *evas_gl, Evas_GL_Context *ctx, int target, void* buffer, const int *attrib_list | finish | ext | | |
+| EVAS GL API | EvasGLSync | _evgl_evasglCreateSync | Evas_GL *evas_gl, unsigned int type, const int *attrib_list | finish | ext | | |
+| EVAS GL API | Eina_Bool | _evgl_evasglDestroySync | Evas_GL *evas_gl, EvasGLSync sync | finish | ext | | |
+| EVAS GL API | int | _evgl_evasglClientWaitSync | Evas_GL *evas_gl, EvasGLSync sync | finish | ext | | |
+| EVAS GL API | Eina_Bool | _evgl_evasglGetSyncAttrib | Evas_GL *evas_gl, EvasGLSync sync, int attribute, int *value | finish | ext | | |
+| EVAS GL API | Eina_Bool | _evgl_evasglSignalSync | Evas_GL *evas_gl, EvasGLSync sync, unsigned mode | finish | ext | | |
+| EVAS GL API | int | _evgl_evasglWaitSync | Evas_GL *evas_gl, EvasGLSync sync, int flags | finish | ext | | |
+| EVAS GL API | Eina_Bool | _evgl_evasglBindWaylandDisplay | Evas_GL *evas_gl, void *wl_display | finish | ext | | |
+| EVAS GL API | Eina_Bool | _evgl_evasglUnbindWaylandDisplay | Evas_GL *evas_gl, void *wl_display | finish | ext | | |
+| EVAS GL API | Eina_Bool | _evgl_evasglQueryWaylandBuffer | Evas_GL *evas_gl, void *buffer, int attribute, int *value | finish | ext | | |