Merge branch 'dgud/wx/separate-opengl' into dev

* dgud/wx/separate-opengl:
  Fix non available opengl functions
  Add lib paths for *bsd variants
  Initilize opengl after setCurrent
  Update to OpenGL 4.1
  Remove ostype sub dirs below wx/priv
  Windows and Mac build issues
  Add dialyser spec
  Better make dependecies for api generation
  Split opengl functionality into separate dynamic library

11 files changed, 498 insertions, 183 deletions

diff --git a/lib/wx/api_gen/Makefile b/lib/wx/api_gen/Makefile
index c6b65b60bc..756ec598ce 100644
--- a/lib/wx/api_gen/Makefile
+++ b/lib/wx/api_gen/Makefile
@@ -1,7 +1,7 @@
 #
 # %CopyrightBegin%
 # 
-# Copyright Ericsson AB 2008-2009. All Rights Reserved.
+# Copyright Ericsson AB 2008-2010. All Rights Reserved.
 # 
 # The contents of this file are subject to the Erlang Public License,
 # Version 1.1, (the "License"); you may not use this file except in
@@ -39,14 +39,14 @@ TARGET_CDIR = ../c_src/gen
 C_TARGETS   = wxe_funcs.cpp
 GL_C_TARGETS = gl_funcs.cpp
 
-WX = $(TARGET_CDIR)/$(C_TARGETS)
+WX = wx_code_generated
 
-GL = $(TARGET_CDIR)/$(GL_C_TARGETS)
+GL = gl_code_generated
 
 opt:  $(WX) $(GL)
 
 $(WX): wxxml_generated $(COMPILER_T) wxapi.conf $(wildcard wx_extra/wx*.c_src) $(wildcard wx_extra/wx*.erl)
-	erl -noshell -run wx_gen code
+	erl -noshell -run wx_gen code && touch wx_code_generated
 
 wxxml_generated:  wx_doxygen.conf wx_extra/bugs.h wx_extra/wxe_evth.h
 	sed -e 's|@WXGTK_DIR@|$(WXGTK_DIR)|g' wx_doxygen.conf > wx_doxygen
@@ -56,9 +56,8 @@ glxml_generated: gl_doxygen.conf
 	sed -e 's|@GL_DIR@|$(GL_DIR)|g' gl_doxygen.conf > gl_doxygen
 	doxygen gl_doxygen && touch glxml_generated
 
-
 $(GL): glxml_generated $(GL_COMP_T) glapi.conf
-	erl -noshell -run gl_gen code
+	erl -noshell -run gl_gen code && touch gl_code_generated
 
 %.beam: %.erl wx_gen.hrl gl_gen.hrl
 	$(ERLC) -W $(ERL_FLAGS) $(ERL_COMPILE_FLAGS) $< -o$(EBIN)
@@ -66,7 +65,7 @@ $(GL): glxml_generated $(GL_COMP_T) glapi.conf
 # TODO split cleans into separate targets?
 complete_clean:
 	rm -f gl_doxygen wx_doxygen wx_xml/*.x* gl_xml/*.x* 
-	rm -f glxml_generated  wxxml_generated
+	rm -f *_generated
 	$(MAKE) clean
 clean: 
 	rm -f *~
diff --git a/lib/wx/api_gen/gen_util.erl b/lib/wx/api_gen/gen_util.erl
index 859317bdef..b53f817ce0 100644
--- a/lib/wx/api_gen/gen_util.erl
+++ b/lib/wx/api_gen/gen_util.erl
@@ -40,6 +40,10 @@ strip_name([H|R1],[H|R2]) ->
     strip_name(R1,R2);
 strip_name(String,[]) -> String.
 
+
+get_hook(_Type, undefined) -> ignore;
+get_hook(Type, List) -> proplists:get_value(Type, List, ignore).
+  
 open_write(File) ->
     %% io:format("Generating ~s~n",[File]),
     {ok, Fd} = file:open(File++".temp", [write]),
@@ -58,10 +62,10 @@ close() ->
 		[] -> 
 		    ok = file:delete(File ++ ".temp"),
 		    %% So that make understands that we have made this
-		    case os:getenv("CLEARCASE_ROOT") of
-			false -> os:cmd("touch " ++ File);
-			_ ->  ignore
-		    end,
+		    %% case os:getenv("CLEARCASE_ROOT") of
+		    %% 	false -> os:cmd("touch " ++ File);
+		    %% 	_ ->  ignore
+		    %% end,
 		    ok;
 		Diff ->
 		    case check_diff(Diff) of
diff --git a/lib/wx/api_gen/gl_gen.erl b/lib/wx/api_gen/gl_gen.erl
index 42802c6de7..374e0bd12b 100644
--- a/lib/wx/api_gen/gl_gen.erl
+++ b/lib/wx/api_gen/gl_gen.erl
@@ -67,7 +67,7 @@ gen_code() ->
 
     gl_gen_erl:gl_defines(GLDefines),
     gl_gen_erl:gl_api(GLFuncs),
-    gl_gen_erl:gen_debug(GLFuncs,GLUFuncs),
+    %%gl_gen_erl:gen_debug(GLFuncs,GLUFuncs),
     gl_gen_c:gen(GLFuncs,GLUFuncs),
     ok.
 
@@ -206,10 +206,10 @@ parse_define([], D, _Opts) ->
 
 parse_func(Xml, Opts) ->
     {Func,_} = foldl(fun(X,Acc) -> parse_func(X,Acc,Opts) end, {#func{},1}, Xml),
+    put(current_func, Func#func.name),
     #func{params=Args0,type=Type0} = Func,
     Args = filter(fun(#arg{type=void}) -> false; (_) -> true end, Args0),
-    #arg{type=Type} = 
-	patch_param(Func#func.name,#arg{name="result",type=Type0},Opts),
+    #arg{type=Type} = patch_param(Func#func.name,#arg{name="result",type=Type0},Opts),
     Func#func{params=reverse(Args), type=Type}.
 
 parse_func(#xmlElement{name=type, content=C}, {F,AC}, Os) ->
@@ -220,6 +220,7 @@ parse_func(#xmlElement{name=name, content=[#xmlText{value=C}]},{F,AC},Os) ->
     put(current_func, Func),
     {F#func{name=name(Func,Os)},AC};
 parse_func(#xmlElement{name=param, content=C},{F,AC},Os) -> 
+    put(current_func, F#func.name),
     Parse  = fun(Con, Ac) -> parse_param(Con, Ac, Os) end,
     Param0 = foldl(Parse, #arg{}, drop_empty(C)),
     Param = fix_param_name(Param0, F, AC),
@@ -314,11 +315,17 @@ handle_arg_opt(both, P) -> P#arg{in=both};
 handle_arg_opt(binary, P=#arg{type=T}) -> 
     P#arg{type=T#type{size=undefined,base=binary}};
 handle_arg_opt({binary,Sz}, P=#arg{type=T}) -> 
-    P#arg{type=T#type{size=Sz,base=binary}};
+    P#arg{type=T#type{size={Sz, Sz},base=binary}};
+handle_arg_opt({binary,Max, Sz}, P=#arg{type=T}) -> 
+    P#arg{type=T#type{size={Max, Sz},base=binary}};
 handle_arg_opt({type,Type}, P=#arg{type=T}) -> P#arg{type=T#type{name=Type}};
 handle_arg_opt({single,Opt},P=#arg{type=T}) -> P#arg{type=T#type{single=Opt}};
+handle_arg_opt({base,{Opt, Sz}},  P=#arg{type=T}) -> P#arg{type=T#type{base=Opt, size=Sz}};
 handle_arg_opt({base,Opt},  P=#arg{type=T}) -> P#arg{type=T#type{base=Opt}};
-handle_arg_opt({c_only,Opt},P) -> P#arg{where=c, alt=Opt}.
+handle_arg_opt({c_only,Opt},P) -> P#arg{where=c, alt=Opt};
+handle_arg_opt(string,  P=#arg{type=T}) -> P#arg{type=T#type{base=string}};
+handle_arg_opt({string,Max,Sz}, P=#arg{type=T}) ->
+    P#arg{type=T#type{base=string, size={Max,Sz}}}.
 
 parse_type([], _Os) -> void;
 parse_type(C, Os) -> 
@@ -367,6 +374,8 @@ parse_type2([N="GLbitfield"|R],T,Opts) ->
     parse_type2(R,T#type{name=N, size=4, base=int},Opts);
 parse_type2([N="GLvoid"|R],T,Opts) -> 
     parse_type2(R,T#type{name=N, base=idx_binary},Opts);
+parse_type2([N="GLsync"|R],T,Opts) -> 
+    parse_type2(R,T#type{name=N, base=int, size=8},Opts);
 
 parse_type2([N="GLbyte"|R],T,Opts) -> 
     parse_type2(R,T#type{name=N, size=1, base=int},Opts);
@@ -378,6 +387,11 @@ parse_type2([N="GLushort"|R],T,Opts) ->
     parse_type2(R,T#type{name=N, size=2, base=int},Opts);
 parse_type2([N="GLint"|R],T,Opts) -> 
     parse_type2(R,T#type{name=N, size=4, base=int},Opts);
+parse_type2([N="GLint64"|R],T,Opts) -> 
+    parse_type2(R,T#type{name=N, size=8, base=int},Opts);
+parse_type2([N="GLuint64"|R],T,Opts) -> 
+    parse_type2(R,T#type{name=N, size=8, base=int},Opts);
+
 parse_type2([N="GLuint"|R],T,Opts) -> 
     parse_type2(R,T#type{name=N, size=4, base=int},Opts);
 parse_type2([N="GLsizei"|R],T,Opts) -> 
@@ -548,8 +562,10 @@ setup_idx_binary(Name,Ext,_Opts) ->
 
     %% Ok warn if single is undefined
     lists:foreach(fun(#arg{type=#type{base=memory}}) -> ok;
+		     (#arg{type=#type{base=string}}) -> ok;
 		     (#arg{type=#type{base=idx_binary}}) -> ok;
 		     (#arg{type=#type{name="GLUquadric"}}) -> ok;
+		     (#arg{type=#type{base=binary, size=Sz}}) when Sz =/= undefined -> ok;
 		     (A=#arg{type=#type{single=undefined}}) -> 
 			  ?warning("~p Unknown size of~n ~p~n",
 				   [get(current_func),A]),
diff --git a/lib/wx/api_gen/gl_gen_c.erl b/lib/wx/api_gen/gl_gen_c.erl
index 3293050ab9..0f5cb0e1f4 100644
--- a/lib/wx/api_gen/gl_gen_c.erl
+++ b/lib/wx/api_gen/gl_gen_c.erl
@@ -47,34 +47,29 @@ gen(GLFuncs, GLUFuncs) ->
     w("/***** This file is generated do not edit ****/~n~n", []),
     w("#include <stdio.h>~n", []),
     w("#include <string.h>~n", []),    
-    w("#include \"../wxe_impl.h\"~n", []),
-    w("#include \"../wxe_gl.h\"~n", []),
-    w("#include \"gl_fdefs.h\"~n", []),
+    w("#include \"../egl_impl.h\"~n", []),
+    w("#include \"gl_fdefs.h\"~n~n", []),
+    w("extern gl_fns_t gl_fns[];~n~n", []),
 
-    w("~nint gl_error_op;~n", []),
-    w("void gl_dispatch(int op, char *bp,ErlDrvTermData caller,WXEBinRef *bins[]){~n",
+    w("void egl_dispatch(int op, char *bp, ErlDrvPort port, "
+      "ErlDrvTermData caller, char *bins[], int bins_sz[]){~n",
       []),
-    w(" gl_error_op = op;~n", []),
-    w(" if(caller != gl_active) {~n", []),
-    w("   wxGLCanvas * current = glc[caller];~n", []),
-    w("   if(current) { gl_active = caller; current->SetCurrent();}~n", []),
-    w("   else {~n "
-      "      ErlDrvTermData rt[] = // Error msg~n"
-      "      {ERL_DRV_ATOM, driver_mk_atom((char *) \"_wxe_error_\"),~n"
-      "       ERL_DRV_INT,  op,~n" 
-      "       ERL_DRV_ATOM, driver_mk_atom((char *) \"no_gl_context\"),~n"
-      "       ERL_DRV_TUPLE,3};~n"
-      "      driver_send_term(WXE_DRV_PORT,caller,rt,8);~n"
-      "      return ;~n   }~n };~n~n", []),
-
+    w(" try {~n",[]),
     w(" switch(op)~n{~n",[]),
-    w(" case 5000:~n   wxe_tess_impl(bp, caller);~n   break;~n", []),
-    w(" case WXE_BIN_INCR:~n   driver_binary_inc_refc(bins[0]->bin);~n   break;~n",[]),
-    w(" case WXE_BIN_DECR:~n   driver_binary_dec_refc(bins[0]->bin);~n   break;~n",[]),
+    w(" case 5000:~n   erl_tess_impl(bp, port, caller);~n   break;~n", []),
 
     [funcs(F) || F <- GLUFuncs],
     [funcs(F) || F <- GLFuncs],
     
+    w("}} catch (char *err_msg) {\n"
+      "int AP = 0; ErlDrvTermData rt[12];\n"
+      "rt[AP++] = ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) \"_egl_error_\");\n"
+      "rt[AP++] = ERL_DRV_INT; rt[AP++] = (int) op;\n"
+      "rt[AP++] = ERL_DRV_ATOM; rt[AP++] = driver_mk_atom((char *) err_msg);\n"
+      "// rt[AP++] = ERL_DRV_ATOM; rt[AP++] = driver_mk_atom((char *) gl_fns[op-GLE_GL_FUNC_START].name);\n"
+      "// rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;\n"
+      "rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 3;\n"
+      "driver_send_term(port,caller,rt,AP);\n", []),
     w("}} /* The End */~n~n",[]),
     
     close().
@@ -123,25 +118,53 @@ declare_var(A=#arg{name=N,in=false,type=#type{name=T,base=B,single={tuple,Sz}}})
     true = is_number(Sz), %% Assert
     w(" ~s ~s[~p] = {~s};~n", [T,N,Sz,args(fun zero/1,",",lists:duplicate(Sz,B))]),
     A;
-declare_var(A=#arg{name=N,in=false,type=#type{name=T,base=B,single={list,Sz}}}) when is_number(Sz) -> 
+declare_var(A=#arg{name=N,in=false,type=#type{name=T,base=B,single={list,Sz}}}) 
+  when is_number(Sz) -> 
     w(" ~s ~s[~p] = {~s};~n", [T,N,Sz,args(fun zero/1,",",lists:duplicate(Sz,B))]),
     A;
+declare_var(A=#arg{name=N,in=false,type=#type{name=T,base=string,size={Max,_}, single=Single}}) -> 
+    case is_integer(Max) of
+	true -> 
+	    w(" ~s ~s[~p];~n", [T,N,Max]);
+	false ->
+	    %% w(" ~s ~s[*~s];~n", [T,N,Max]),
+	    w(" ~s *~s;~n", [T,N]), 
+	    w(" ~s = (~s *) driver_alloc(sizeof(~s) * *~s);~n", [N,T,T,Max]),
+	    store_free(N)		
+	    %% case Single of
+	    %% 	{list, _, _} -> 
+	    %% 	    w(" ~s *~s_p = ~s;~n", [T,N,N]);
+	    %% 	_ -> ok
+	    %% end	    
+    end,
+    A;
+declare_var(A=#arg{name=N,in=false,type=#type{base=binary,size={MaxSz, _}}}) -> 
+    MaxSz == undefined andalso error({assert, A}),
+    case is_integer(MaxSz) of
+	true -> 
+	    w(" ErlDrvBinary *~s = driver_alloc_binary(~p);~n", [N,MaxSz]);
+	false ->
+	    w(" ErlDrvBinary *~s = driver_alloc_binary(*~s);~n", [N,MaxSz])
+    end,
+    A;
 declare_var(A=#arg{name=N,in=false,type=#type{name=T,single={list,ASz,_USz},mod=[]}}) -> 
     true = is_list(ASz), %% Assert
     w(" ~s *~s;~n", [T,N]), 
     w(" ~s = (~s *) driver_alloc(sizeof(~s) * *~s);~n", [N,T,T,ASz]),
     store_free(N),
-    A;
-declare_var(A=#arg{name=N,in=false,type=#type{name=T,base=binary,size=Sz}}) -> 
-    true = is_number(Sz), %% Assert
-    w(" ~s ~s[~p];~n", [T,N,Sz]),
+    %% w(" ~s ~s[*~s];~n", [T,N,ASz]),
     A;
 declare_var(A=#arg{in=false, type=#type{name="GLUquadric",by_val=false,single=true}}) ->
     A;
+declare_var(A=#arg{in=false, type=#type{base=string,by_val=false,single=true}}) ->
+    A;
 declare_var(A=#arg{name=N,in=false,
 		   type=#type{name=T,base=B,by_val=false,single=true}}) -> 
     w(" ~s ~s[1] = {~s};~n", [T,N,zero(B)]),
     A;
+declare_var(A=#arg{where=c, type=#type{name=T}, alt={size,Var}}) -> 
+    w(" ~s ~s_size = bins_sz[~p];~n", [T, Var, get(bin_count)]),
+    A;    
 declare_var(A=#arg{where=_}) -> 
     A.
 
@@ -171,10 +194,10 @@ decode_arg(P=#arg{where=c},A)   -> {P,A};
 decode_arg(P=#arg{in=false},A)  -> {P,A};
 
 decode_arg(P=#arg{name=Name,type=#type{name=Type,base=binary}},A0) ->
-    w(" ~s *~s = (~s *) bins[~p]->base;~n", [Type,Name,Type,next_id(bin_count)]),
+    w(" ~s *~s = (~s *) bins[~p];~n", [Type,Name,Type,next_id(bin_count)]),
     {P, A0};
 decode_arg(P=#arg{name=Name,type=#type{name=Type,base=memory}},A0) ->
-    w(" ~s *~s = (~s *) bins[~p]->base;~n", [Type,Name,Type,next_id(bin_count)]),
+    w(" ~s *~s = (~s *) bins[~p];~n", [Type,Name,Type,next_id(bin_count)]),
     {P, A0};
 decode_arg(P=#arg{name=Name,type=#type{name=T,base=string,single=list}},A0) ->
     A = align(4,A0),
@@ -219,7 +242,7 @@ decode_arg(P=#arg{name=Name,type=#type{name=Type,base=guard_int}},A0) ->
     {P, A};
 decode_arg(P=#arg{name=Name,type=#type{name=Type,base=string,single=true}},A0) ->
     w(" ~s *~s = (~s *) bp;~n", [Type,Name,Type]),
-    w(" int ~sLen = strlen((char *)~s); bp += ~sLen+1+((8-((1+~sLen+~p)%8))%8);~n",
+    w(" int ~sLen[1] = {strlen((char *)~s)}; bp += ~sLen[0]+1+((8-((1+~sLen[0]+~p)%8))%8);~n",
       [Name,Name,Name,Name,A0]),
     {P, 0};
 decode_arg(P=#arg{name=Name,
@@ -288,6 +311,8 @@ result_type(#type{name=T, ref=undefined}) ->    T;
 result_type(#type{name=T, ref={pointer,1}, mod=Mods}) ->  
     mod(Mods) ++ T ++ " * ".
 
+call_arg(#arg{alt={size,Alt},type=#type{}}) ->
+    Alt ++ "_size";
 call_arg(#arg{alt={length,Alt},type=#type{}}) ->
     "*" ++ Alt ++ "Len";
 call_arg(#arg{alt={constant,Alt},type=#type{}}) ->
@@ -298,6 +323,8 @@ call_arg(#arg{name=Name,type=#type{single={list, _}}}) ->
     Name;
 call_arg(#arg{name=Name,type=#type{size=8,base=int,ref=undefined}}) ->
     Name;
+call_arg(#arg{name=Name,in=false,type=#type{name=T, base=binary}}) ->
+    "(" ++ T ++ "*) " ++ Name ++ "->orig_bytes";
 call_arg(#arg{name=Name,type=#type{ref=undefined}}) ->
     "*" ++ Name;
 call_arg(#arg{name=Name,type=#type{base=guard_int}}) ->
@@ -318,27 +345,27 @@ build_return_vals(Type,As) ->
 		true ->
 		    w(" int AP = 0; ErlDrvTermData rt[6];~n",[]),
 		    w(" rt[AP++]=ERL_DRV_ATOM;"
-		      " rt[AP++]=driver_mk_atom((char *) \"_wxe_result_\");~n",[]),
+		      " rt[AP++]=driver_mk_atom((char *) \"_egl_result_\");~n",[]),
 		    w(" rt[AP++]=ERL_DRV_ATOM;"
 		      " rt[AP++]=driver_mk_atom((char *) \"ok\");~n",[]),
 		    w(" rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;~n",[]),
-		    w(" driver_send_term(WXE_DRV_PORT,caller,rt,AP);~n",[]),
+		    w(" driver_send_term(port,caller,rt,AP);~n",[]),
 		    ok
 	    end;
 	{Val,Vars,Cnt} ->
 	    ExtraTuple = if Cnt > 1 -> 2; true -> 0 end,
-	    CSize = if Vars =:= none -> 
-			    Sz = integer_to_list(Val+4+ExtraTuple),
-			    w(" int AP = 0; ErlDrvTermData rt[~s];~n",[Sz]),
-			    Sz;
-		       true -> 
-			    Sz = integer_to_list(Val+4+ExtraTuple) ++ " + " ++ Vars,
-			    w(" int AP = 0; ErlDrvTermData *rt;~n",[]),
-			    w(" rt = (ErlDrvTermData *) "
-			      "driver_alloc(sizeof(ErlDrvTermData)*(~s));~n", [Sz]),
-			    Sz
-		    end,
-	    w(" rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) \"_wxe_result_\");~n",[]),
+	    if Vars =:= none -> 
+		    Sz = integer_to_list(Val+4+ExtraTuple),
+		    w(" int AP = 0; ErlDrvTermData rt[~s];~n",[Sz]),
+		    Sz;
+	       true -> 
+		    Sz = integer_to_list(Val+4+ExtraTuple) ++ " + " ++ Vars,
+		    w(" int AP = 0; ErlDrvTermData *rt;~n",[]),
+		    w(" rt = (ErlDrvTermData *) "
+		      "driver_alloc(sizeof(ErlDrvTermData)*(~s));~n", [Sz]),
+		    Sz
+	    end,
+	    w(" rt[AP++]=ERL_DRV_ATOM; rt[AP++]=driver_mk_atom((char *) \"_egl_result_\");~n",[]),
 	    FreeList = build_ret_types(Type,As),
 	    case Cnt of
 		1 -> ok;
@@ -346,9 +373,9 @@ build_return_vals(Type,As) ->
 		    w(" rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = ~p;~n",[Cnt])
 	    end,
 	    w(" rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = 2;~n",[]),
-	    w(" if (AP != ~s )  fprintf(stderr, \"%d: ERROR AP mismatch %d %d\\r\\n\",__LINE__,AP,~s);~n",
-	      [CSize,CSize]),
-	    w(" driver_send_term(WXE_DRV_PORT,caller,rt,AP);~n",[]),
+	    %%w(" if (AP != ~s )  fprintf(stderr, \"%d: ERROR AP mismatch %d %d\\r\\n\",__LINE__,AP,~s);~n",
+	    %%  [CSize,CSize]),
+	    w(" driver_send_term(port,caller,rt,AP);~n",[]),
 	    case Vars of 
 		none -> ignore;
 		_ -> 		    
@@ -371,7 +398,7 @@ calc_sizes(Type,As) ->
 		       {Val, none} -> {Sz+Val, Vars, Cnt+1};
 		       {Val, Var} when Vars =:= none -> 			   
 			   {Sz+Val, Var,Cnt+1};
-		       {Val, Var} when Vars =:= none -> 
+		       {Val, Var}  -> 
 			   {Sz+Val, Var ++ " + " ++ Vars,Cnt+1}
 		   end;
 	      (_,Acc) -> Acc
@@ -379,13 +406,16 @@ calc_sizes(Type,As) ->
     foldl(Calc, TSz, As).
  
 return_size(_N,void) -> {0, none};
-return_size(_N,#type{base=binary}) ->                      {4, none};
-return_size(_N,#type{single=true}) ->                      {2,none};
 return_size(_N,#type{single={tuple,Sz}}) ->                {Sz*2+2, none};
-return_size(_N,#type{name="GLubyte",single={list,null}}) ->{3, none};
 return_size(_N,#type{single={list,Sz}})  ->                {Sz*2+3, none};
-return_size(_N,#type{base=string,single={list,_,_}}) ->    {3, none};
-return_size(_N,#type{single={list,_,Sz}}) ->               {3, "(*" ++Sz++")*2"}.
+return_size(_N,#type{base=string,single=true}) ->          {3, none};
+return_size(_N,#type{base=string,single=undefined}) ->     {3, none};
+return_size(_N,#type{base=string,single={list,_,"result"}}) ->   {3, "result*3"};
+return_size(_N,#type{base=string,single={list,_,Sz}}) ->   {3, "(*" ++Sz++")*3"};
+return_size(_N,#type{single={list,_,"result"}}) ->         {3, "result*2"};
+return_size(_N,#type{single={list,_,Sz}}) ->               {3, "(*" ++Sz++")*2"};
+return_size(_N,#type{base=binary}) ->                      {4, none};
+return_size(_N,#type{single=true}) ->                      {2, none}.
 
 
 build_ret_types(void,Ps) -> 
@@ -444,17 +474,27 @@ build_ret(Name,_Q,#type{name=T,base=_,single={tuple,Sz}}) ->
     [w(" rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) *~s++;~n", [Temp]) 
      || _ <- lists:seq(1,Sz)],
     w(" rt[AP++] = ERL_DRV_TUPLE; rt[AP++] = ~p;~n",[Sz]);
-build_ret(Name,_Q,#type{name="GLubyte",single={list,null}}) ->
+build_ret(Name,_Q,#type{base=string,size=1,single=true}) ->
     w(" rt[AP++] = ERL_DRV_STRING; rt[AP++] = (ErlDrvTermData) ~s;"
       " rt[AP++] = strlen((char *) ~s);\n", [Name, Name]);
-build_ret(Name,_Q,#type{base=string,single={list,_,Sz}}) ->
+build_ret(Name,_Q,#type{base=string, size={_Max,Sz}, single=S}) 
+  when S == true; S == undefined ->
     w(" rt[AP++] = ERL_DRV_STRING; rt[AP++] = (ErlDrvTermData) ~s;"
       " rt[AP++] = *~s;\n", [Name, Sz]);
+build_ret(Name,_Q,#type{name=_T,base=string,size={_, SSz}, single={list,_,Sz}}) ->
+    P = if Sz == "result" -> ["(int) "]; true -> "*" end,
+    w(" for(int i=0; i < ~s~s; i++) {\n", [P,Sz]),
+    w("    rt[AP++] = ERL_DRV_STRING; rt[AP++] = (ErlDrvTermData) ~s;"
+      " rt[AP++] = ~s[i]-1;\n", [Name, SSz]),
+    w("    ~s += ~s[i]; }~n", [Name, SSz]),
+    w(" rt[AP++] = ERL_DRV_NIL;", []),
+    w(" rt[AP++] = ERL_DRV_LIST; rt[AP++] = (~s~s)+1;~n",[P,Sz]);
 build_ret(Name,_Q,#type{name=_T,base=B,single={list,_,Sz}}) when B =/= float ->
-    w(" for(int i=0; i < *~s; i++) {\n", [Sz]),
+    P = if Sz == "result" -> ["(int) "]; true -> "*" end,
+    w(" for(int i=0; i < ~s~s; i++) {\n", [P,Sz]),
     w("    rt[AP++] = ERL_DRV_INT; rt[AP++] = (ErlDrvSInt) ~s[i];}~n", [Name]),    
     w(" rt[AP++] = ERL_DRV_NIL;", []),
-    w(" rt[AP++] = ERL_DRV_LIST; rt[AP++] = (*~s)+1;~n",[Sz]);
+    w(" rt[AP++] = ERL_DRV_LIST; rt[AP++] = (~s~s)+1;~n",[P,Sz]);
 build_ret(Name,_Q,#type{name=_T,size=FSz,base=float,single={list,Sz}}) ->
     Temp = Name ++ "Tmp",
     case FSz of
@@ -475,12 +515,14 @@ build_ret(Name,_Q,#type{name=T,base=_,single={list,Sz}}) ->
      || _ <- lists:seq(1,Sz)],
     w(" rt[AP++] = ERL_DRV_NIL;", []),
     w(" rt[AP++] = ERL_DRV_LIST; rt[AP++] = ~p+1;~n",[Sz]);
-build_ret(Name,_Q,#type{name="GLubyte",base=binary,size=Sz}) ->
-    w(" ErlDrvBinary * BinCopy = driver_alloc_binary(~p);~n", [Sz]), 
-    w(" memcpy(BinCopy->orig_bytes, ~s, ~p);~n",  [Name,Sz]),
-    w(" rt[AP++] = ERL_DRV_BINARY; rt[AP++] = (ErlDrvTermData) BinCopy;", []),
-    w(" rt[AP++] = ~p; rt[AP++] = 0;~n", [Sz]),
-    "driver_free_binary(BinCopy);";
+build_ret(Name,_Q,#type{base=binary,size={_,Sz}}) ->
+    w(" rt[AP++] = ERL_DRV_BINARY; rt[AP++] = (ErlDrvTermData) ~s;", [Name]),
+    if is_integer(Sz) ->
+	    w(" rt[AP++] = ~p; rt[AP++] = 0;~n", [Sz]);
+       is_list(Sz) ->
+	    w(" rt[AP++] = *~s; rt[AP++] = 0;~n", [Sz])
+    end,
+    "driver_free_binary(" ++ Name ++ ");";
 build_ret(Name,_Q,T=#type{}) ->
     io:format("{~p, {~p, {single,{tuple,X}}}}.~n", [get(current_func),Name]),
     io:format(" ~p~n",[T]).
@@ -496,6 +538,19 @@ gen_defines(GLFuncs,GLUFuncs) ->
     w("# define WXE_EXTERN~n", []),
     w("#else~n# define WXE_EXTERN extern~n", []),
     w("#endif~n~n", []),
+
+    w("typedef struct {\n"      
+      "   const char * name;\n"      
+      "   const char * alt;\n"
+      "   void * func;\n"
+      "} gl_fns_t;\n\n", []),
+
+    GLFirst = case hd(GLFuncs) of 
+		  [First|_] when is_list(First) -> get(First);
+		  First -> get(First)
+	      end,
+    w("#define GLE_GL_FUNC_START ~p~n", [GLFirst#func.id]),
+
     [fdefs(F) || F <- GLFuncs],
     [fdefs(F) || F <- GLUFuncs],
     close().
@@ -543,11 +598,7 @@ gl_gen_init(Funcs) ->
     open_write("../c_src/gen/gl_finit.h"),
     c_copyright(),
     w("/***** This file is generated do not edit ****/~n~n", []),
-    w("static struct {\n"      
-      "   const char * name;\n"      
-      "   const char * alt;\n"
-      "   void * func;\n"
-      "} gl_fns[] = \n"
+    w("gl_fns_t gl_fns[] = \n"
       "{\n", []),
     [finits(F) || F <- Funcs],
     w(" { NULL, NULL, NULL}};\n",[]),
diff --git a/lib/wx/api_gen/gl_gen_erl.erl b/lib/wx/api_gen/gl_gen_erl.erl
index ce35484561..f292c8723e 100644
--- a/lib/wx/api_gen/gl_gen_erl.erl
+++ b/lib/wx/api_gen/gl_gen_erl.erl
@@ -49,7 +49,7 @@ glu_defines(Defs) ->
     w("~n%% GLU DEFINITIONS~n~n", []),
     w("%% This file is generated DO NOT EDIT~n~n", []),
     [gen_define(Def) || Def=#def{} <- Defs],
-    close(), 
+    close(),
     ok.   
 
 gen_define(#def{name=N, val=Val, type=int}) ->
@@ -78,7 +78,11 @@ types() ->
      {"GLsizeiptr","64/native-unsigned"}, % 64 bits int, convert on c-side
      {"GLintptr",  "64/native-unsigned"}, % 64 bits int, convert on c-sidew
      {"GLUquadric", "64/native-unsigned"},% Handle 32bits aargh 64bits on mac64
-     {"GLhandleARB","64/native-unsigned"} % Handle 32bits aargh 64bits on mac64
+     {"GLhandleARB","64/native-unsigned"},% Handle 32bits aargh 64bits on mac64
+     
+     {"GLsync",     "64/native-unsigned"}, % Pointer to record
+     {"GLuint64",     "64/native-unsigned"},
+     {"GLint64",     "64/native-signed"}
     ].
 
 gl_api(Fs) ->
@@ -90,22 +94,53 @@ gl_api(Fs) ->
     w("%% See <a href=\"http://www.opengl.org/sdk/docs/man/\">www.opengl.org</a>~n",[]),
     w("%%~n", []),
     w("%% Booleans are represented by integers 0 and 1.~n~n", []),
-    w("%% @type wx_mem(). see wx.erl on memory allocation functions~n", []),
+    w("%% @type mem().    memory block~n", []),
     w("%% @type enum().   An integer defined in gl.hrl~n", []),    
     w("%% @type offset(). An integer which is an offset in an array~n", []),
     w("%% @type clamp().  A float clamped between 0.0 - 1.0~n", []),
     
     w("-module(gl).~n~n",[]),    
     w("-compile(inline).~n", []),
-    %%    w("-compile(export_all).~n~n", []),
-    %%    w("-compile(binary_comprehension).~n~n", []),
-    w("-include(\"wxe.hrl\").~n", []),
+%%    w("-include(\"wxe.hrl\").~n", []),
     [w("-define(~s,~s).~n", [GL,Erl]) || {GL,Erl} <- types()],
-    
+
+    gen_types(gl),
+   
     Exp = fun(F) -> gen_export(F) end,
     ExportList = lists:map(Exp,Fs),
     w("~n-export([~s]).~n~n", [args(fun(EF) -> EF end, ",", ExportList, 60)]),
-
+    w("-export([call/2, cast/2, send_bin/1]).~n",[]),
+    w("%% @hidden~n", []),
+    w("call(Op, Args) ->~n", []),
+    w("    Port = get(opengl_port), ~n", []),
+    w("    _ = erlang:port_control(Port,Op,Args),~n", []),
+    w("    rec().~n", []),
+    w("    ~n", []),
+    w("%% @hidden~n", []),
+    w("cast(Op, Args) ->~n", []),
+    w("    Port = get(opengl_port), ~n", []),
+    w("    _ = erlang:port_control(Port,Op,Args),~n", []),
+    w("    ok.~n", []),
+    w("    ~n", []),
+    w("%% @hidden~n", []),
+    w("rec() ->~n", []),
+    w("    receive ~n", []),
+    w("        {'_egl_result_', Res} -> Res;~n", []),
+    w("        {'_egl_error_',  Op, Res} -> error({error,Res,Op})~n", []),
+    w("    end. ~n", []),
+    w("~n", []),
+    w("%% @hidden~n", []),
+    w("send_bin(Bin) when is_binary(Bin) ->~n", []),
+    w("    Port = get(opengl_port), ~n", []),
+    w("    erlang:port_command(Port,Bin);~n", []),
+    w("send_bin(Tuple) when is_tuple(Tuple) ->~n", []),
+    w("    Port = get(opengl_port), ~n", []),
+    w("    case element(2, Tuple) of~n", []),
+    w("        Bin when is_binary(Bin) ->~n", []),
+    w("            erlang:port_command(Port,Bin)~n", []),
+    w("    end.~n", []),
+    w("~n", []),
+    
     w("~n%% API~n~n", []),
     [gen_funcs(F) || F <- Fs],
     close(), 
@@ -120,20 +155,22 @@ glu_api(Fs) ->
     w("%% See <a href=\"http://www.opengl.org/sdk/docs/man/\">www.opengl.org</a>~n",[]),
     w("%%~n", []),
     w("%% Booleans are represented by integers 0 and 1.~n~n", []),
-    w("%% @type wx_mem(). see wx.erl on memory allocation functions~n", []),
+    w("%% @type mem().    memory block~n", []),
     w("%% @type enum().   An integer defined in gl.hrl~n", []),    
     w("%% @type offset(). An integer which is an offset in an array~n", []),
     w("%% @type clamp().  A float clamped between 0.0 - 1.0~n~n", []),
 
     w("-module(glu).~n",[]),    
     w("-compile(inline).~n", []),
-    w("-include(\"wxe.hrl\").~n", []),
+    %%w("-include(\"wxe.hrl\").~n", []),
     [w("-define(~s,~s).~n", [GL,Erl]) || {GL,Erl} <- types()],
 
+    gen_types(glu),
+    
     Exp = fun(F) -> gen_export(F) end,
     ExportList = ["tesselate/2" | lists:map(Exp,Fs)],
     w("~n-export([~s]).~n~n", [args(fun(EF) -> EF end, ",", ExportList, 60)]),
-
+    w("-import(gl, [call/2,cast/2,send_bin/1]).", []),
     w("~n%% API~n~n", []),
 
     w("%% @spec (Vec3, [Vec3]) -> {Triangles, VertexPos}~n",[]),
@@ -148,13 +185,13 @@ glu_api(Fs) ->
       "%% may contain newly created vertices in the end.~n", []),
 
     w("tesselate({Nx,Ny,Nz}, Vs) ->~n",[]),
-    w("  wxe_util:call(5000, <<(length(Vs)):32/native,0:32,~n"
+    w("  call(5000, <<(length(Vs)):32/native,0:32,~n"
       "    Nx:?GLdouble,Ny:?GLdouble,Nz:?GLdouble,~n"
       "    (<< <<Vx:?GLdouble,Vy:?GLdouble,Vz:?GLdouble >>~n"
       "        || {Vx,Vy,Vz} <- Vs>>)/binary >>).~n~n", []),
 
     [gen_funcs(F) || F <- Fs],
-    close(), 
+    close(),
     ok.
 
 gen_funcs([F]) when is_list(F) ->
@@ -178,6 +215,17 @@ gen_funcs(F) ->
     erase(current_func),
     w(".~n~n",[]).
 
+gen_types(Where) ->    
+    case Where of
+	glu -> ignore;
+	gl ->
+	    w("-type clamp() :: float().~n", []),
+	    w("-type offset() :: non_neg_integer().~n", [])
+    end,
+    w("-type enum() :: non_neg_integer().~n", []),
+    w("-type mem() :: binary() | tuple().~n", []),
+    ok.
+
 gen_export(F) ->
     try gen_export_1(F)
     catch E:R ->
@@ -199,19 +247,27 @@ gen_export2(#func{name=Name,params=As0}) ->
     Args = lists:filter(fun(Arg) -> func_arg(Arg) =/= skip end, As0),
     erl_func_name(Name) ++ "/" ++ integer_to_list(length(Args)).
 
-
-gen_doc([#func{alt={vector,VecPos,Vec}}]) ->
+gen_doc([#func{name=Name, alt={vector,VecPos,Vec}}]) ->
     #func{type=T,params=As} = get(Vec), 
     {As1,As2} = lists:split(VecPos, As),
     Args1 = case args(fun func_arg/1, ",", As1) of [] -> []; Else -> Else++"," end,
     Args2 = args(fun func_arg/1, ",", As2),
-    w("%% @spec (~s{~s}) -> ~s~n",[Args1,Args2,doc_return_types(T,As)]), 
-    w("%% @equiv ~s(~s)~n",[erl_func_name(Vec), Args1++Args2]);
+    w("%% @spec (~s{~s}) -> ~s~n",[Args1,Args2,doc_return_types(T,As, doc)]), 
+    w("%% @equiv ~s(~s)~n",[erl_func_name(Vec), Args1++Args2]),
+    SA1 = case doc_arg_types(As1, spec) of [] -> []; E -> E++"," end,
+    SA2 = doc_arg_types(As2, spec),
+    w("-spec ~s(~s{~s}) -> ~s.~n",
+      [erl_func_name(Name), SA1, SA2, 
+       doc_return_types(T,As, spec)]);
+    
 gen_doc([#func{name=Name,type=T,params=As,alt=Alt}|_]) ->
-    w("%% @spec (~s) -> ~s~n", [doc_arg_types(As),doc_return_types(T,As)]),
+    w("%% @spec (~s) -> ~s~n", [doc_arg_types(As, doc),doc_return_types(T,As, doc)]),
     GLDoc = "http://www.opengl.org/sdk/docs/man/xhtml/",
     w("%% @doc See <a href=\"~s~s.xml\">external</a> documentation.~n",
-      [GLDoc, doc_name(Name,Alt)]).
+      [GLDoc, doc_name(Name,Alt)]),
+    w("-spec ~s(~s) -> ~s.~n",
+      [erl_func_name(Name), doc_arg_types(As, spec), doc_return_types(T,As, spec)]).
+
 
 gen_func(#func{name=Name,alt={vector,VecPos,Vec}}) ->
     #func{params=As} = get(Vec), 
@@ -229,9 +285,9 @@ gen_func(_F=#func{name=Name,type=T,params=As,id=MId}) ->
     {StrArgs,_} = marshal_args(PreAs),
     case have_return_vals(T,As) of
 	true ->
-	    w("  wxe_util:call(~p, <<~s>>)", [MId, StrArgs]);
+	    w("  call(~p, <<~s>>)", [MId, StrArgs]);
 	false ->
-	    w("  wxe_util:cast(~p, <<~s>>)", [MId, StrArgs])
+	    w("  cast(~p, <<~s>>)", [MId, StrArgs])
     end.
 
 func_arg(#arg{in=In,where=W,name=Name,type=Type}) 
@@ -249,60 +305,65 @@ func_arg(#arg{in=In,where=W,name=Name,type=Type})
     end;
 func_arg(_) -> skip.
 
-doc_arg_types(Ps0) ->
+doc_arg_types(Ps0, Type) ->
     Ps = [P || P=#arg{in=In, where=Where} <- Ps0,In =/= false, Where =/= c],
-    args(fun doc_arg_type/1, ",", Ps).
+    args(fun(Arg) -> doc_arg_type(Arg, Type) end, ",", Ps).
 
-doc_return_types(T, Ps0) ->
+doc_return_types(T, Ps0, Type) ->
     Ps = [P || P=#arg{in=In, where=Where} <- Ps0,In =/= true, Where =/= c],
-    doc_return_types2(T, Ps).
-
-doc_return_types2(void, []) ->    "ok";
-doc_return_types2(void, [#arg{type=T}]) ->     doc_arg_type2(T);
-doc_return_types2(T, []) ->                      doc_arg_type2(T);
-doc_return_types2(void, Ps) -> 
-    "{" ++ args(fun doc_arg_type/1,",",Ps) ++ "}";
-doc_return_types2(T, Ps) ->
-    "{" ++ doc_arg_type2(T) ++ "," ++ args(fun doc_arg_type/1,",",Ps) ++ "}".
-
-doc_arg_type(#arg{name=Name,type=T}) ->
+    doc_return_types2(T, Ps, Type).
+
+doc_return_types2(void, [], _) ->    "ok";
+doc_return_types2(void, [#arg{type=T}], _) ->     doc_arg_type2(T);
+doc_return_types2(T, [], _) ->                      doc_arg_type2(T);
+doc_return_types2(void, Ps, Type) -> 
+    "{" ++ args(fun(Arg) -> doc_arg_type(Arg, Type) end,",",Ps) ++ "}";
+doc_return_types2(T, Ps, Type) ->
+    "{" ++ doc_arg_type2(T) ++ "," ++ 
+	args(fun(Arg) -> doc_arg_type(Arg, Type) end,",",Ps) ++ "}".
+
+doc_arg_type(#arg{name=Name,type=T}, doc) ->
     try  
 	erl_arg_name(Name) ++ "::" ++ doc_arg_type2(T)
     catch _:Error ->
 	    io:format("Error: ~p ~p~n~p~n",[Name, Error, erlang:get_stacktrace()]),
 	    exit(error)
+    end;
+doc_arg_type(#arg{name=Name,type=T}, spec) ->
+    try  
+	doc_arg_type2(T)
+    catch _:Error ->
+	    io:format("Error spec: ~p ~p~n~p~n",[Name, Error, erlang:get_stacktrace()]),
+	    exit(error)
     end.
 
+
 doc_arg_type2(T=#type{single=true}) ->
     doc_arg_type3(T);
 doc_arg_type2(T=#type{single=undefined}) ->
     doc_arg_type3(T);
 doc_arg_type2(T=#type{single={tuple,undefined}}) ->
     "{" ++ doc_arg_type3(T) ++ "}";
-doc_arg_type2(T=#type{single={tuple,_Sz}}) ->
-    "{" ++ doc_arg_type3(T) ++ "}";
+doc_arg_type2(T=#type{single={tuple,Sz}}) ->
+    "{" ++ args(fun doc_arg_type3/1, ",", lists:duplicate(Sz,T)) ++ "}";
 doc_arg_type2(T=#type{single=list}) ->
     "[" ++ doc_arg_type3(T) ++ "]";
-doc_arg_type2(T=#type{single={list, Max}}) when is_integer(Max) ->
+doc_arg_type2(T=#type{single={list, _Max}}) ->
     "[" ++ doc_arg_type3(T) ++ "]";
-doc_arg_type2(_T=#type{single={list,null}}) ->
-    "string()";
-doc_arg_type2(T=#type{base=string}) ->
-    doc_arg_type3(T);
 doc_arg_type2(T=#type{single={list,_,_}}) ->
     "[" ++ doc_arg_type3(T) ++ "]";
-doc_arg_type2(T=#type{single={tuple_list,_TSz}}) ->
-    "[{" ++ doc_arg_type3(T) ++ "}]".
+doc_arg_type2(T=#type{single={tuple_list,Sz}}) ->
+    "[{" ++ args(fun doc_arg_type3/1, ",", lists:duplicate(Sz,T)) ++ "}]".
 
 doc_arg_type3(#type{name="GLenum"}) ->  "enum()";
 doc_arg_type3(#type{name="GLclamp"++_}) ->  "clamp()";
 doc_arg_type3(#type{base=int}) ->       "integer()";
 doc_arg_type3(#type{base=float}) ->     "float()";
-doc_arg_type3(#type{base=guard_int}) -> "offset()|binary()";
+doc_arg_type3(#type{base=guard_int}) -> "offset()|mem()";
 doc_arg_type3(#type{base=string}) ->    "string()";
 doc_arg_type3(#type{base=bool}) ->      "0|1";
 doc_arg_type3(#type{base=binary}) ->    "binary()";
-doc_arg_type3(#type{base=memory}) ->    "wx:wx_mem()".
+doc_arg_type3(#type{base=memory}) ->    "mem()".
 
 guard_test(As) -> 
     Str = args(fun(#arg{name=N,type=#type{base=guard_int}}) -> 
@@ -316,10 +377,10 @@ guard_test(As) ->
     end.	    
 
 pre_marshal([#arg{name=N,in=true,type=#type{base=binary}}|R]) -> 
-    w("  wxe_util:send_bin(~s),~n", [erl_arg_name(N)]),
+    w("  send_bin(~s),~n", [erl_arg_name(N)]),
     pre_marshal(R);
 pre_marshal([#arg{name=N,type=#type{base=memory}}|R]) -> 
-    w("  wxe_util:send_bin(~s#wx_mem.bin),~n", [erl_arg_name(N)]),
+    w("  send_bin(~s),~n", [erl_arg_name(N)]),
     pre_marshal(R);
 pre_marshal([A=#arg{name=N,type=#type{base=string,single=list}}|R]) ->
     %% With null terminations
@@ -595,6 +656,7 @@ gen_debug(GL, GLU) ->
     w("].~n~n", []),
     close().
 
+
 printd([F|R],Mod) when is_list(F) ->
     printd(F,Mod),
     printd(R,Mod);
diff --git a/lib/wx/api_gen/glapi.conf b/lib/wx/api_gen/glapi.conf
index f9ed7a1065..525ccf8b68 100644
--- a/lib/wx/api_gen/glapi.conf
+++ b/lib/wx/api_gen/glapi.conf
@@ -29,8 +29,35 @@
   "glMatrixIndexPointerARB",
   "glPixelTransformParameter", 
   %% OpengGL 3.0 
-  %"glGetTransformFeedbackVarying",  %% Jobbiga
-  %"glTransformFeedbackVaryings",
+
+  %% ARB 
+  "glCreateSyncFromCLeventARB",  % _cl_context _cl_event ??
+  "glDebugMessageCallbackARB",
+
+  "glGetn", %*
+  "glReadnPixels", %*
+  
+  "glVertexP2",  %*
+  "glVertexP3",  %*
+  "glVertexP4",  %*
+  "glTexCoordP1",  %*
+  "glTexCoordP2",  %*
+  "glTexCoordP3",  %*
+  "glTexCoordP4",  %*
+  "glMultiTexCoordP1",  %*
+  "glMultiTexCoordP2",  %*
+  "glMultiTexCoordP3",  %*
+  "glMultiTexCoordP4",  %*
+  "glNormalP3",  %*
+  "glColorP3",  %*
+  "glColorP4",  %*
+  "glSecondaryColorP3",  %*
+  "glVertexAttribP1",  %*
+  "glVertexAttribP2",  %*
+  "glVertexAttribP3",  %*
+  "glVertexAttribP4",  %*
+
+  "glGetActiveSubroutineUniformiv", %% Bad API don't know what to allocate needs to ask
 
   %% EXT
   %% By default skip these extensions
@@ -136,11 +163,12 @@
 
 {"glRect", [{"v1", {single,{tuple,2}}},{"v2", {single,{tuple,2}}}]}.
 
-{"glGetString",   {"result", {single,{list,null}}}}.
+{"glGetString",   {"result", string}}.
 {"glGetBooleanv", {"params", {single,{list,16}}}}.
 {"glGetDoublev",  {"params", {single,{list,16}}}}.
 {"glGetFloatv",   {"params", {single,{list,16}}}}.
 {"glGetIntegerv", {"params", {single,{list,16}}}}.
+{"glGetInteger64v", {"params", {single,{list,16}}}}.
 
 {"glFeedbackBuffer", {"buffer", [{base,memory}, in]}}.
 {"glSelectBuffer",   {"buffer", [{base,memory}, in]}}.
@@ -174,24 +202,24 @@
 {"glGetActiveAttribARB", [{"length",[skip,{single, true}]},
 			  {"size",  {single, true}},
 			  {"type",  {single, true}},
-			  {"name",  {single, {list,"maxLength","length"}}}
+			  {"name",  {string,"maxLength","length"}}
 			 ]}.
 
 {"glGetActiveAttrib", [{"length",[skip,{single, true}]},
 		       {"size",  {single, true}},
 		       {"type",  {single, true}},
-		       {"name",  {single, {list,"bufSize","length"}}}
+		       {"name",  {string,"bufSize","length"}}
 		      ]}.
 
 {"glGetActiveUniformARB", [{"length",[skip,{single, true}]},
 			   {"size",  {single, true}},
 			   {"type",  {single, true}},
-			   {"name",  {single, {list,"maxLength","length"}}}
+			   {"name",  {string,"maxLength","length"}}
 			  ]}.
 {"glGetActiveUniform", [{"length",[skip,{single, true}]},
 			{"size",  {single, true}},
 			{"type",  {single, true}},
-			{"name",  {single, {list,"bufSize","length"}}}
+			{"name",  {string,"bufSize","length"}}
 		       ]}.
 
 {"glGetAttachedShaders", [{"count", [skip,{single,true}]},
@@ -201,18 +229,18 @@
 {"glGetProgramiv", {"params", {single,true}}}.
 
 {"glGetProgramInfoLog", [{"length", [skip,{single,true}]},
-			 {"infoLog", {single, {list,"bufSize","length"}}}
+			 {"infoLog", {string,"bufSize","length"}}
 			]}.
 {"glGetShaderiv", {"params", {single,true}}}.
 {"glGetShaderInfoLog", [{"length", [skip,{single,true}]},
-			{"infoLog", {single, {list,"bufSize","length"}}}
+			{"infoLog", {string,"bufSize","length"}}
 		       ]}.
 
 {"glGetShaderSourceARB", [{"length", [skip,{single,true}]},
-			  {"source", {single, {list,"maxLength","length"}}}
+			  {"source", {string,"maxLength","length"}}
 			 ]}.
 {"glGetShaderSource", [{"length", [skip,{single,true}]},
-		       {"source", {single, {list,"bufSize","length"}}}
+		       {"source", {string,"bufSize","length"}}
 		      ]}.
 
 
@@ -239,7 +267,7 @@
 {"glMatrixIndex", [{"size",{c_only,{length,"indices"}}}, {"indices", {single,list}}]}.
 
 
-{"glProgramStringARB", [{"len",{c_only,{constant,"stringLen"}}},
+{"glProgramStringARB", [{"len",{c_only,{length,"string"}}},
 			{"string",[{base,string},{single,true}]}]}.
 {"glGetProgramStringARB", {"string", [in,{base,memory}]}}.
 {"glGenProgramsARB", {"programs", {single,{list,"n","n"}}}}.
@@ -250,7 +278,7 @@
 {"glGetProgramLocalParameter", {"params", {single,{tuple,4}}}}.
 {"glGetObjectParameter", {"params", {single,true}}}.
 {"glGetInfoLogARB", [{"length", [skip,{single,true}]},
-		     {"infoLog", {single, {list,"maxLength","length"}}}
+		     {"infoLog", {string,"maxLength","length"}}
 		    ]}.
 {"glGetAttachedObjectsARB", [{"count", [skip,{single,true}]},
 			     {"obj", {single, {list,"maxCount","count"}}}
@@ -280,9 +308,10 @@
 		  {"objW",[{single,true},out]}]}. 
 {"gluBuild", {"data", [binary]}}.
 {"gluScaleImage", [{"dataIn", [in, binary]}, {"dataOut", [in, {base, memory}]}]}.
-{"gluCheckExtension", [{"extName", {single, list}}, {"extString", {single, list}}]}.
-{"gluErrorString", {"result", {single, {list,null}}}}.
-{"gluGetString", {"result", {single, {list,null}}}}.
+{"gluCheckExtension", [{"extName", string}, 
+		       {"extString", string}]}.
+{"gluErrorString", {"result", string}}.
+{"gluGetString", {"result", string}}.
 
 {"gluDeleteQuadric", {"quad", in}}.
 {"gluQuadric",     {"quad", in}}.
@@ -291,15 +320,21 @@
 {"gluDisk",        {"quad", in}}.
 {"gluCylinder",    {"quad", in}}.
 
-%% OpenGL 3.0 
+%% OpenGL 3.0 and later
 {"glGetBooleani_v", {"data", {single,{list,16}}}}.
 {"glGetIntegeri_v", {"data", {single,{list,16}}}}.
+{"glGetFloati_v",   {"data", {single,{list,16}}}}.
+{"glGetDoublei_v",   {"data", {single,{list,16}}}}.
+{"glGetInteger64i_v", {"data", {single,{list,16}}}}.
+
+{"glGetBufferParameteriv", {"params", {single,{list,16}}}}.
+{"glGetBufferParameteri64v", {"params", {single,{list,16}}}}.
 
 {"glTransformFeedbackVaryings", [{"count", {c_only,{length,"varyings"}}},
 				 {"varyings", [{base,string}, {single,list}]}]}.
-{"glGetTransformFeedbackVarying", [{"size", {single, true}},{"type", {single, true}},				   
+{"glGetTransformFeedbackVarying", [{"size", {single, true}},{"type", {single, true}},
 				   {"length", [skip, {single, true}]},
-				   {"name", {single, {list,"bufSize","length"}}}]}.
+				   {"name", {string,"bufSize","length"}}]}.
 
 
 {"glGenRenderbuffers", {"renderbuffers", {single,{list,"n","n"}}}}.
@@ -327,7 +362,133 @@
 			   {"params", [out, {single, {list, "uniformIndicesLen", "uniformIndicesLen"}}]}]}.
 
 {"glGetActiveUniformName", [{"length",[skip,{single, true}]},
-			    {"uniformName", {single, {list,"bufSize","length"}}}]}.
+			    {"uniformName", {string,"bufSize","length"}}]}.
 {"glGetActiveUniformBlockName", [{"length",[skip,{single, true}]},
-				 {"uniformBlockName", {single, {list,"bufSize","length"}}}]}.
+				 {"uniformBlockName", {string,"bufSize","length"}}]}.
 {"glGetActiveUniformBlockiv", {"params", [in, {base,memory}]}}.
+
+
+{"glGetSynciv", [{"values", {single, {list, "bufSize","length"}}},
+		 {"length", [skip,{single, true}]}]}.
+
+{"glGetMultisamplefv", {"val", [out, {single, {tuple,2}}]}}.
+
+
+{"glNamedStringARB", [{"stringlen", {c_only, {length, "string"}}},
+		      {"namelen", {c_only, {length, "name"}}}]}.
+{"glDeleteNamedStringARB", [{"namelen", {c_only, {length, "name"}}}]}.
+{"glIsNamedStringARB", [{"namelen", {c_only, {length, "name"}}}]}.
+{"glGetNamedStringARB",[{"namelen", {c_only, {length, "name"}}},
+			{"stringlen",[skip,{single, true}]},
+			{"string", {string,"bufSize","stringlen"}}]}.
+{"glGetNamedStringivARB",[{"namelen", {c_only, {length, "name"}}},
+			  {"params",  [out, {single, true}]}]}.
+{"glCompileShaderIncludeARB", [{"length", {c_only,{constant,"NULL"}}},
+			       {"count",  {c_only,{length,"path"}}},
+			       {"path", {single,list}}]}.
+
+
+{"glGenSamplers", {"samplers", {single, {list,"count","count"}}}}.
+{"glDeleteSamplers", [{"count", {c_only, {length, "samplers"}}}, 
+		      {"samplers", {single, list}}]}.
+{"glGetSamplerParameter", {"params", {single, {list, 4}}}}.
+{"glSamplerParameterI", {"param", {single, list}}}.
+{"glSamplerParameterfv", {"param", {single, list}}}.
+{"glSamplerParameteriv", {"param", {single, list}}}.
+
+%{"glGetActiveSubroutineUniformiv", {"values", }}.
+{"glGetActiveSubroutineUniformName", [{"length",[skip,{single, true}]},
+				      {"name", {string,"bufsize","length"}}]}.
+{"glGetActiveSubroutineName", [{"length",[skip,{single, true}]},
+			       {"name", {string,"bufsize","length"}}]}.
+{"glGetProgramStageiv", {"values", {single, true}}}.
+{"glUniformSubroutinesuiv", [{"count",{c_only,{length,"indices"}}},{"indices", {single, list}}]}.
+
+{"glGenTransformFeedbacks", {"ids", {single, {list,"n","n"}}}}.
+{"glDeleteTransformFeedbacks", [{"n", {c_only, {length, "ids"}}},
+				{"ids", {single, list}}]}.
+
+{"glPatchParameterfv", {"values", {single, list}}}.
+
+
+{"glGetQueryIndexediv", {"params", {single, true} }}.
+{"glShaderBinary", [{"count", {c_only, {length, "shaders"}}},
+		    {"length", {c_only, {size, "binary"}}},
+		    {"shaders", {single, list}},
+		    {"binary", binary}
+		   ]}.
+{"glGetShaderPrecisionFormat", [{"range", {single, {tuple, 2}}},
+				{"precision", {single, true}}]}.
+
+{"glGetProgramBinary", [{"length",[skip,{single, true}]},
+			{"binary", [out, {binary, "bufSize", "length"}]},
+			{"binaryFormat", {single, true}}]}.
+{"glProgramBinary", [{"binary", binary}, {"length", {c_only, {size, "binary"}}}]}.
+
+{"glGenProgramPipelines", {"pipelines", {single, {list,"n","n"}}}}.
+{"glDeleteProgramPipelines", [{"n", {c_only, {length, "pipelines"}}}, 
+			      {"pipelines", {single, list}}]}.
+
+{"glCreateShaderProgramv", [{"count", {c_only, {length, "strings"}}},
+			    {"strings", {single, list}}]}.
+{"glGetProgramPipelineInfoLog", [{"length", [skip,{single, true}]},
+				 {"infoLog", {string,"bufSize","length"}}]}.
+{"glGetProgramPipelineiv", {"params", {single, true}}}.
+
+
+%% {"glCreateSyncFromCLeventARB", {"context", }}.
+
+{"glDebugMessageControlARB", [{"count", {c_only, {length, "ids"}}},
+			      {"ids", {single, list}}]}.
+{"glDebugMessageInsertARB", {"length", {c_only, {length, "buf"}}}}.
+{"glGetDebugMessageLogARB", [{"sources", {single, {list, "count", "result"}}},
+			     {"types", {single, {list, "count", "result"}}},
+			     {"ids", {single, {list, "count", "result"}}},
+			     {"severities", {single, {list, "count", "result"}}},
+			     {"lengths", [{c_only, undefined}, {single, {list, "count", "result"}}]},
+			     {"messageLog", [{string, "bufsize", "lengths"}, 
+					     {single, {list, "bufsize", "result"}}]}]}.
+
+
+{"glUniformMatrix2dv",   [{"count",{c_only,{length,"value"}}},{"value", [{single,{tuple_list,4}}]}]}.
+{"glUniformMatrix3dv",   [{"count",{c_only,{length,"value"}}},{"value", [{single,{tuple_list,9}}]}]}.
+{"glUniformMatrix4dv",   [{"count",{c_only,{length,"value"}}},{"value", [{single,{tuple_list,16}}]}]}.
+{"glUniformMatrix2x3dv", [{"count",{c_only,{length,"value"}}},{"value", [{single,{tuple_list,6}}]}]}.
+{"glUniformMatrix3x2dv", [{"count",{c_only,{length,"value"}}},{"value", [{single,{tuple_list,6}}]}]}.
+{"glUniformMatrix2x4dv", [{"count",{c_only,{length,"value"}}},{"value", [{single,{tuple_list,8}}]}]}.
+{"glUniformMatrix4x2dv", [{"count",{c_only,{length,"value"}}},{"value", [{single,{tuple_list,8}}]}]}.
+{"glUniformMatrix3x4dv", [{"count",{c_only,{length,"value"}}},{"value", [{single,{tuple_list,12}}]}]}.
+{"glUniformMatrix4x3dv", [{"count",{c_only,{length,"value"}}},{"value", [{single,{tuple_list,12}}]}]}.
+
+{"glProgramUniform1", [{"count",{c_only,{length,"value"}}}, {"value", [{single,list}]}]}.
+{"glProgramUniform2", [{"count",{c_only,{length,"value"}}}, {"value", [{single,{tuple_list,2}}]}]}.
+{"glProgramUniform3", [{"count",{c_only,{length,"value"}}}, {"value", [{single,{tuple_list,3}}]}]}.
+{"glProgramUniform4", [{"count",{c_only,{length,"value"}}}, {"value", [{single,{tuple_list,4}}]}]}.
+
+{"glProgramUniformMatrix2fv",   [{"count",{c_only,{length,"value"}}},{"value", [{single,{tuple_list,4}}]}]}.
+{"glProgramUniformMatrix2dv",   [{"count",{c_only,{length,"value"}}},{"value", [{single,{tuple_list,4}}]}]}.
+{"glProgramUniformMatrix3dv",   [{"count",{c_only,{length,"value"}}},{"value", [{single,{tuple_list,9}}]}]}.
+{"glProgramUniformMatrix3fv",   [{"count",{c_only,{length,"value"}}},{"value", [{single,{tuple_list,9}}]}]}.
+{"glProgramUniformMatrix4dv",   [{"count",{c_only,{length,"value"}}},{"value", [{single,{tuple_list,16}}]}]}.
+{"glProgramUniformMatrix4fv",   [{"count",{c_only,{length,"value"}}},{"value", [{single,{tuple_list,16}}]}]}.
+{"glProgramUniformMatrix2x3fv", [{"count",{c_only,{length,"value"}}},{"value", [{single,{tuple_list,6}}]}]}.
+{"glProgramUniformMatrix3x2fv", [{"count",{c_only,{length,"value"}}},{"value", [{single,{tuple_list,6}}]}]}.
+{"glProgramUniformMatrix2x4fv", [{"count",{c_only,{length,"value"}}},{"value", [{single,{tuple_list,8}}]}]}.
+{"glProgramUniformMatrix4x2fv", [{"count",{c_only,{length,"value"}}},{"value", [{single,{tuple_list,8}}]}]}.
+{"glProgramUniformMatrix3x4fv", [{"count",{c_only,{length,"value"}}},{"value", [{single,{tuple_list,12}}]}]}.
+{"glProgramUniformMatrix4x3fv", [{"count",{c_only,{length,"value"}}},{"value", [{single,{tuple_list,12}}]}]}.
+
+{"glProgramUniformMatrix2x3dv", [{"count",{c_only,{length,"value"}}},{"value", [{single,{tuple_list,6}}]}]}.
+{"glProgramUniformMatrix3x2dv", [{"count",{c_only,{length,"value"}}},{"value", [{single,{tuple_list,6}}]}]}.
+{"glProgramUniformMatrix2x4dv", [{"count",{c_only,{length,"value"}}},{"value", [{single,{tuple_list,8}}]}]}.
+{"glProgramUniformMatrix4x2dv", [{"count",{c_only,{length,"value"}}},{"value", [{single,{tuple_list,8}}]}]}.
+{"glProgramUniformMatrix3x4dv", [{"count",{c_only,{length,"value"}}},{"value", [{single,{tuple_list,12}}]}]}.
+{"glProgramUniformMatrix4x3dv", [{"count",{c_only,{length,"value"}}},{"value", [{single,{tuple_list,12}}]}]}.
+
+{"glViewportArrayv", [{"count",{c_only,{length,"v"}}}, {"v", [{single,{tuple_list,4}}]}]}.
+{"glViewportIndexedfv", {"v", {single,{tuple,4}}}}.
+{"glScissorArrayv", [{"count",{c_only,{length,"v"}}}, {"v", [{single,{tuple_list,4}}]}]}.
+{"glScissorIndexedv", {"v", {single,{tuple,4}}}}.
+{"glDepthRangeArrayv", [{"count",{c_only,{length,"v"}}}, {"v", [{single,{tuple_list,2}}]}]}.
+
+
diff --git a/lib/wx/api_gen/wx_gen.erl b/lib/wx/api_gen/wx_gen.erl
index c075324c1f..2f20c42a5d 100644
--- a/lib/wx/api_gen/wx_gen.erl
+++ b/lib/wx/api_gen/wx_gen.erl
@@ -887,7 +887,7 @@ add_method2(M0=#method{name=Name,params=Ps0,type=T0},#class{name=CName,parent=Pa
 		   id = next_id(func_id),
 		   pre_hook  = get_opt(pre_hook, Name, length(Ps), Opts),
 		   post_hook = get_opt(post_hook, Name, length(Ps), Opts),
-		   doc = get_opt(doc, Name, length(Ps), Opts) 
+		   doc = get_opt(doc, Name, length(Ps), Opts)
 		  },
     M = case Name of
 	    CName ->
diff --git a/lib/wx/api_gen/wx_gen.hrl b/lib/wx/api_gen/wx_gen.hrl
index 17265a2842..426e3adfae 100644
--- a/lib/wx/api_gen/wx_gen.hrl
+++ b/lib/wx/api_gen/wx_gen.hrl
@@ -43,9 +43,9 @@
 	  id          = undefined, % Id (integer)
 	  doc,                     % Extra documentation
 	  virtual,                 % Is virtual?
-	  pre_hook,                % Pre hook  before call in c-code
-	  post_hook                % Post hook after call in c-code
-	 }
+	  pre_hook    = [],        % Pre hook  before call in c-code
+	  post_hook   = []         % Post hook after call in c-code
+	}
        ).
 
 -record(param,
diff --git a/lib/wx/api_gen/wx_gen_cpp.erl b/lib/wx/api_gen/wx_gen_cpp.erl
index 846cec46c4..4b33068d8f 100644
--- a/lib/wx/api_gen/wx_gen_cpp.erl
+++ b/lib/wx/api_gen/wx_gen_cpp.erl
@@ -152,6 +152,7 @@ gen_funcs(Defs) ->
     w("#include \"../wxe_impl.h\"~n"),
     w("#include \"../wxe_events.h\"~n"),
     w("#include \"../wxe_return.h\"~n"),
+    w("#include \"../wxe_gl.h\"~n"),
     w("#include \"wxe_macros.h\"~n"),
     w("#include \"wxe_derived_dest.h\"~n~n"),
 
@@ -176,6 +177,9 @@ gen_funcs(Defs) ->
       "     rt.addAtom(\"ok\");~n"
       "     break;~n"
       " }~n"),
+    w(" case WXE_BIN_INCR:~n   driver_binary_inc_refc(Ecmd.bin[0]->bin);~n   break;~n",[]),
+    w(" case WXE_BIN_DECR:~n   driver_binary_dec_refc(Ecmd.bin[0]->bin);~n   break;~n",[]),
+    w(" case WXE_INIT_OPENGL:~n  wxe_initOpenGL(rt, bp);~n   break;~n",[]),
 
     Res = [gen_class(Class) || Class <- Defs],
 
@@ -265,13 +269,13 @@ gen_method(CName,  M=#method{name=N,params=Ps0,type=T,method_type=MT,id=MethodId
     Opts = [Opt || Opt = #param{def=Def,in=In,where=Where} <- Ps2, 
 		   Def =/= none, In =/= false, Where =/= c],
     decode_options(Opts, Align),
-    case M#method.pre_hook of
-	undefined -> skip;
+    case gen_util:get_hook(c, M#method.pre_hook) of
+	ignore -> skip;
 	Pre -> w(" ~s;~n", [Pre])
     end,
     Ps3 = call_wx(N,{MT,CName},T,Ps2),
-    case M#method.post_hook of
-	undefined -> skip;
+    case gen_util:get_hook(c, M#method.post_hook) of
+	ignore -> skip;
 	Post -> w(" ~s;~n", [Post])
     end,
     free_args(),
diff --git a/lib/wx/api_gen/wx_gen_erl.erl b/lib/wx/api_gen/wx_gen_erl.erl
index 7962dd9fbf..e1201ab0d4 100644
--- a/lib/wx/api_gen/wx_gen_erl.erl
+++ b/lib/wx/api_gen/wx_gen_erl.erl
@@ -270,6 +270,16 @@ gen_method2(M=#method{name=N,alias=A,params=Ps,type=T,method_type=MT,id=MethodId
     MId = arg_type_tests(Args, "?" ++ get_unique_name(MethodId)),
     {MArgs,Align} = marshal_args(Args),
     MOpts = marshal_opts(Optional, Align, Args),
+    case gen_util:get_hook(erl, M#method.pre_hook) of
+	ignore -> skip;
+	Pre -> w("  ~s~n", [Pre])
+    end,
+
+    case gen_util:get_hook(erl, M#method.post_hook) of
+	ignore -> skip;
+	_ -> w("  _Result =", [])
+    end,
+    
     case have_return_vals(T, Ps) of
 	_ when MT =:= constructor ->
 	    w("  wxe_util:construct(~s,~n  <<~s~s>>)", [MId, MArgs,MOpts]);
@@ -278,6 +288,13 @@ gen_method2(M=#method{name=N,alias=A,params=Ps,type=T,method_type=MT,id=MethodId
 	false -> 
 	    w("  wxe_util:cast(~s,~n  <<~s~s>>)", [MId, MArgs,MOpts])
     end,
+    case gen_util:get_hook(erl, M#method.post_hook) of
+	ignore -> skip;
+	Post -> 
+	    w(",~n  ~s~n", [Post]),
+	    w("  _Result", [])
+    end,
+   
     erase(current_func),
     M.
 
diff --git a/lib/wx/api_gen/wxapi.conf b/lib/wx/api_gen/wxapi.conf
index 6bafda5b9d..aec8a4944a 100644
--- a/lib/wx/api_gen/wxapi.conf
+++ b/lib/wx/api_gen/wxapi.conf
@@ -505,15 +505,15 @@
 	      {"data",[in,{base,binary}]},
 	      {"alpha",[in,{base,binary}]},
 	      {{4,pre_hook}, 
-	       "if(!static_data) {"
-	       "data = (unsigned char *) malloc(Ecmd.bin[0]->size);"
-	       "memcpy(data,Ecmd.bin[0]->base,Ecmd.bin[0]->size);}"},
+	       [{c, "if(!static_data) {"
+		 "data = (unsigned char *) malloc(Ecmd.bin[0]->size);"
+		 "memcpy(data,Ecmd.bin[0]->base,Ecmd.bin[0]->size);}"}]},
 	      {{5,pre_hook}, 
-	       "if(!static_data) {"
-	       " data = (unsigned char *) malloc(Ecmd.bin[0]->size);"
-	       " alpha = (unsigned char *) malloc(Ecmd.bin[1]->size);"
-	       " memcpy(data,Ecmd.bin[0]->base,Ecmd.bin[0]->size);"
-	       " memcpy(alpha,Ecmd.bin[1]->base,Ecmd.bin[1]->size);}"}
+	       [{c, "if(!static_data) {"
+		 " data = (unsigned char *) malloc(Ecmd.bin[0]->size);"
+		 " alpha = (unsigned char *) malloc(Ecmd.bin[1]->size);"
+		 " memcpy(data,Ecmd.bin[0]->base,Ecmd.bin[0]->size);"
+		 " memcpy(alpha,Ecmd.bin[1]->base,Ecmd.bin[1]->size);}"}]}
 	     ]},
   '~wxImage',%'AddHandler',
   'Blur','BlurHorizontal','BlurVertical', 
@@ -524,15 +524,15 @@
 	     {"data",[in,{base,binary}]},
 	     {"alpha",[in,{base,binary}]},
 	     {{4,pre_hook}, 
-	      "if(!static_data) {"
-	      "data = (unsigned char *) malloc(Ecmd.bin[0]->size);"
-	      "memcpy(data,Ecmd.bin[0]->base,Ecmd.bin[0]->size);}"},
+	      [{c, "if(!static_data) {"
+	       "data = (unsigned char *) malloc(Ecmd.bin[0]->size);"
+	       "memcpy(data,Ecmd.bin[0]->base,Ecmd.bin[0]->size);}"}]},
 	     {{5,pre_hook}, 
-	      "if(!static_data) {"
-	      " data =  (unsigned char *) malloc(Ecmd.bin[0]->size);"
-	      " alpha = (unsigned char *) malloc(Ecmd.bin[1]->size);"
-	      " memcpy(data,Ecmd.bin[0]->base,Ecmd.bin[0]->size);"
-	      " memcpy(alpha,Ecmd.bin[1]->base,Ecmd.bin[1]->size);}"}	     
+	      [{c, "if(!static_data) {"
+		" data =  (unsigned char *) malloc(Ecmd.bin[0]->size);"
+		" alpha = (unsigned char *) malloc(Ecmd.bin[1]->size);"
+		" memcpy(data,Ecmd.bin[0]->base,Ecmd.bin[0]->size);"
+		" memcpy(alpha,Ecmd.bin[1]->base,Ecmd.bin[1]->size);}"}]}
 	    ]},
   'Destroy','FindFirstUnusedColour', %  'FindHandler',
   'GetImageExtWildcard',
@@ -551,15 +551,15 @@
   'Rotate90','SaveFile','Scale','Size',
   {'SetAlpha', [{{2,"alpha"},[in,{base,binary}, {def, none}]},
 		{{2,pre_hook}, 
-		 "if(!static_data) {"
-		 "alpha = (unsigned char *) malloc(Ecmd.bin[0]->size);"
-		 "memcpy(alpha,Ecmd.bin[0]->base,Ecmd.bin[0]->size);}"}
+		 [{c, "if(!static_data) {"
+		   "alpha = (unsigned char *) malloc(Ecmd.bin[0]->size);"
+		   "memcpy(alpha,Ecmd.bin[0]->base,Ecmd.bin[0]->size);}"}]}
 	       ]},
   {'SetData',  [{"data",[in,{base,binary}]},
 		{pre_hook, 
-		 "if(!static_data) {"
-		 "data = (unsigned char *) malloc(Ecmd.bin[0]->size);"
-		 "memcpy(data,Ecmd.bin[0]->base,Ecmd.bin[0]->size);}"}
+		 [{c, "if(!static_data) {"
+		   "data = (unsigned char *) malloc(Ecmd.bin[0]->size);"
+		   "memcpy(data,Ecmd.bin[0]->base,Ecmd.bin[0]->size);}"}]}
 	       ]},
  'SetMask','SetMaskColour','SetMaskFromImage','SetOption',
   'SetPalette',
@@ -1148,7 +1148,8 @@
  [{skip, [{'SetCurrent', 2}]}], %% NA MAC
  [{'wxGLCanvas', [{"attribList", [in, {single,array}]}]},
   'GetContext',
-  {'SetCurrent', [{post_hook,"if(This->GetContext()) setActiveGL(Ecmd.caller,This)"}]},
+  {'SetCurrent', [{post_hook,[{c, "if(This->GetContext()) setActiveGL(Ecmd.caller,This)"},
+			      {erl, "{ok, _} = wxe_master:init_opengl(),"}]}]},
   %%{'SetColour', [{"colour", [in, {single,array}]}]},
   'SwapBuffers']}.