The R13B03 release.OTP_R13B03

1 files changed, 863 insertions, 0 deletions

diff --git a/lib/wx/c_src/wxe_impl.cpp b/lib/wx/c_src/wxe_impl.cpp
new file mode 100644
index 0000000000..d115bb2243
--- /dev/null
+++ b/lib/wx/c_src/wxe_impl.cpp
@@ -0,0 +1,863 @@
+/*
+ * %CopyrightBegin%
+ * 
+ * Copyright Ericsson AB 2008-2009. 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
+ * compliance with the License. You should have received a copy of the
+ * Erlang Public License along with this software. If not, it can be
+ * retrieved online at http://www.erlang.org/.
+ * 
+ * Software distributed under the License is distributed on an "AS IS"
+ * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+ * the License for the specific language governing rights and limitations
+ * under the License.
+ * 
+ * %CopyrightEnd% 
+ */
+
+#include <stdio.h>
+#include <signal.h>
+
+
+#include <wx/wx.h>
+
+// Avoid including these in dcbuffer below
+#include "wx/dcmemory.h"
+#include "wx/dcclient.h"
+#include "wx/window.h"
+// Ok ugly but needed for wxBufferedDC crash workaround
+#define private public
+#include <wx/dcbuffer.h>
+#undef private
+
+#include "wxe_impl.h"
+#include "wxe_events.h"
+#include "wxe_return.h"
+
+IMPLEMENT_APP_NO_MAIN(WxeApp)
+
+DECLARE_APP(WxeApp)
+
+DEFINE_EVENT_TYPE(wxeEVT_META_COMMAND)
+
+#define WXE_NOT_INITIATED 0
+#define WXE_INITIATED     1
+#define WXE_EXITED        2
+#define WXE_ERROR        -1
+
+#define WXE_NORMAL      0
+#define WXE_CALLBACK    1
+#define WXE_STORED      2 
+
+ErlDrvTid wxe_thread;
+
+ErlDrvMutex *wxe_status_m;
+ErlDrvCond  *wxe_status_c;
+
+ErlDrvMutex * wxe_batch_locker_m;
+ErlDrvCond  * wxe_batch_locker_c;
+
+static int wxe_status = WXE_NOT_INITIATED;
+
+wxList * wxe_batch = NULL;
+wxList * wxe_batch_cb_saved = NULL;
+
+ErlDrvTermData  wxe_batch_caller = 0;
+ErlDrvTermData  init_caller = 0;
+
+// extern opengl 
+extern int gl_initiated;
+void gl_dispatch(int op, char *bp, ErlDrvTermData caller, WXEBinRef *bins[]);
+
+
+// Until fixed in emulator
+#ifndef _WIN32
+extern "C" {
+extern void erts_thread_disable_fpe(void);
+}
+#endif
+
+void *wxe_main_loop(void * );
+
+/* ************************************************************
+ *  START AND STOP of driver thread
+ * ************************************************************/
+
+int load_native_gui() 
+{
+  return 1;
+}
+
+int start_native_gui(wxe_data *sd)
+{
+  int res;
+  wxe_status_m = erl_drv_mutex_create((char *) "wxe_status_m");
+  wxe_status_c = erl_drv_cond_create((char *)"wxe_status_c");
+
+  wxe_batch_locker_m = erl_drv_mutex_create((char *)"wxe_batch_locker_m");
+  wxe_batch_locker_c = erl_drv_cond_create((char *)"wxe_batch_locker_c");
+  init_caller = driver_connected(sd->port); 
+
+  if((res = erl_drv_thread_create((char *)"wxwidgets",
+				  &wxe_thread,wxe_main_loop,NULL,NULL)) == 0) {
+    erl_drv_mutex_lock(wxe_status_m);
+    for(;wxe_status == WXE_NOT_INITIATED;) {
+      erl_drv_cond_wait(wxe_status_c, wxe_status_m);
+    }
+    erl_drv_mutex_unlock(wxe_status_m);
+    return wxe_status;
+  } else {
+    wxString msg;
+    msg.Printf(wxT("Erlang failed to create wxe-thread %d\r\n"), res);
+    send_msg("error", &msg);
+    return -1;
+  }
+}
+
+void stop_native_gui(wxe_data *sd)
+{
+  erl_drv_thread_join(wxe_thread, NULL);
+  erl_drv_mutex_destroy(wxe_status_m);
+  erl_drv_cond_destroy(wxe_status_c);
+  erl_drv_mutex_destroy(wxe_batch_locker_m);
+  erl_drv_cond_destroy(wxe_batch_locker_c);
+}
+
+void unload_native_gui() 
+{
+  
+}
+
+/* ************************************************************
+ *  Commands from erlang
+ *    Called by emulator thread
+ * ************************************************************/
+
+void push_command(int op,char * buf,int len, wxe_data *sd) 
+{  
+  // fprintf(stderr, "Op %d %d\r\n", op, (int) driver_caller(sd->port)),fflush(stderr);
+  wxeCommand *Cmd = new wxeCommand(op, buf, len, sd);
+  erl_drv_mutex_lock(wxe_batch_locker_m);
+  wxe_batch->Append(Cmd);
+  
+  if(wxe_batch_caller > 0) {
+    // wx-thread is waiting on batch end in cond_wait
+    erl_drv_cond_signal(wxe_batch_locker_c);
+  } else {
+    // wx-thread is waiting gui-events
+    if(op == WXE_BATCH_BEGIN) {
+      wxe_batch_caller = 1;
+    }
+    erl_drv_cond_signal(wxe_batch_locker_c);
+    wxWakeUpIdle();
+  }  
+  erl_drv_mutex_unlock(wxe_batch_locker_m);
+}
+
+void meta_command(int what, wxe_data *sd) {  
+  if(what == PING_PORT) {
+    erl_drv_mutex_lock(wxe_batch_locker_m);
+    if(wxe_batch_caller > 0) {
+      wxeCommand *Cmd = new wxeCommand(WXE_DEBUG_PING, NULL, 0, sd);
+      wxe_batch->Append(Cmd);
+      erl_drv_cond_signal(wxe_batch_locker_c);
+    } else {
+      wxWakeUpIdle();
+    }
+    erl_drv_mutex_unlock(wxe_batch_locker_m);
+  } else {
+    if(sd) {
+      wxeMetaCommand Cmd(sd, what);
+      wxTheApp->AddPendingEvent(Cmd);
+    }
+  }
+}
+
+/* ************************************************************
+ *  wxWidgets Thread 
+ * ************************************************************/
+
+void *wxe_main_loop(void * not_used)
+{
+  int result; 
+  int  argc = 1;
+  char * temp = (char *) "Erlang\0";
+  char ** argv = &temp;
+
+  // ErlDrvSysInfo einfo;
+  // driver_system_info(&einfo, sizeof(ErlDrvSysInfo));
+  // Disable floating point execption if they are on.
+  // This should be done in emulator but it's not in yet.
+#ifndef _WIN32
+  erts_thread_disable_fpe();
+#endif
+  
+  result = wxEntry(argc, argv);
+  // fprintf(stderr, "WXWidgets quits main loop %d \r\n", result);
+  if(result >= 0 && wxe_status == WXE_INITIATED) {
+    /* We are done try to make a clean exit */
+    wxe_status = WXE_EXITED;
+    erl_drv_thread_exit(NULL);
+    return NULL;
+  } else {
+    erl_drv_mutex_lock(wxe_status_m);
+    wxe_status = WXE_ERROR;
+    erl_drv_cond_signal(wxe_status_c);
+    erl_drv_mutex_unlock(wxe_status_m);
+    return NULL;    
+  }
+}
+
+wxFrame * dummy_window;
+
+void create_dummy_window() {
+  dummy_window = new wxFrame(NULL,-1, wxT("wx driver"), 
+			     wxDefaultPosition, wxSize(5,5), 
+			     wxFRAME_NO_TASKBAR);
+  dummy_window->Connect(wxID_ANY, wxEVT_CLOSE_WINDOW, 
+			(wxObjectEventFunction) (wxEventFunction) &WxeApp::dummy_close);
+}
+
+// wxMac really wants a top level window which command-q quits if there are no
+// windows open, and this will kill the thread, so restart the dummy_window each
+// time a we receive a close.
+void WxeApp::dummy_close(wxEvent& Ev) {
+  // fprintf(stderr, "Tried to close dummy window\r\n"); fflush(stderr);
+  create_dummy_window();
+}
+
+// Init wx-widgets thread 
+bool WxeApp::OnInit()
+{
+  wxe_ps_init();
+
+  global_me = new wxeMemEnv();
+  wxe_batch = new wxList;
+  wxe_batch_cb_saved = new wxList;
+
+  wxIdleEvent::SetMode(wxIDLE_PROCESS_SPECIFIED);
+
+  this->Connect(wxID_ANY, wxEVT_IDLE, 
+		(wxObjectEventFunction) (wxEventFunction) &WxeApp::idle);
+  this->Connect(CREATE_PORT, wxeEVT_META_COMMAND, 
+		(wxObjectEventFunction) (wxEventFunction) &WxeApp::newMemEnv);
+  this->Connect(DELETE_PORT, wxeEVT_META_COMMAND, 
+		(wxObjectEventFunction) (wxEventFunction) &WxeApp::destroyMemEnv);
+  this->Connect(WXE_SHUTDOWN, wxeEVT_META_COMMAND, 
+		(wxObjectEventFunction) (wxEventFunction) &WxeApp::shutdown);
+
+//   fprintf(stderr, "Size void* %d: long %d long long %d int64 %d \r\n",
+// 	  sizeof(void *), sizeof(long), sizeof(long long), sizeof(wxInt64));
+  initEventTable();
+  wxInitAllImageHandlers();
+
+  /* Create a dummy window so wxWidgets don't automagicly quits the main loop 
+     after the last window */
+  create_dummy_window();  
+
+  init_nonconsts(global_me, init_caller);
+  erl_drv_mutex_lock(wxe_status_m);
+  wxe_status = WXE_INITIATED;
+  gl_initiated = FALSE;   
+  erl_drv_cond_signal(wxe_status_c);
+  erl_drv_mutex_unlock(wxe_status_m);
+  return TRUE;
+}
+
+void WxeApp::shutdown(wxeMetaCommand& Ecmd) {
+  delete dummy_window;
+  ExitMainLoop();
+}
+
+void send_msg(const char * type, wxString * msg) {
+  wxeReturn rt = wxeReturn(WXE_DRV_PORT, init_caller);
+  rt.addAtom((char *) "wxe_driver");
+  rt.addAtom((char *) type);
+  rt.add(msg);  
+  rt.addTupleCount(3);
+  rt.send();
+}
+
+/* ************************************************************
+ *  Erlang Command execution  *    
+ * ************************************************************/
+
+/* Callback from printer and event callbacks */ 
+void pre_callback()
+{
+  // no-op 
+}
+
+void handle_event_callback(ErlDrvPort port, ErlDrvTermData process)
+{
+  WxeApp * app = (WxeApp *) wxTheApp;
+  ErlDrvMonitor monitor;
+  driver_monitor_process(port, process, &monitor);
+  // Should we be able to handle commands when recursing? probably
+  erl_drv_mutex_lock(wxe_batch_locker_m);
+  //fprintf(stderr, "\r\nCB Start ");fflush(stderr);
+  app->dispatch_cb(wxe_batch, wxe_batch_cb_saved, process);
+  //fprintf(stderr, ".. done \r\n");fflush(stderr);
+  wxe_batch_caller = 0;
+  erl_drv_mutex_unlock(wxe_batch_locker_m);
+  driver_demonitor_process(port, &monitor);
+}
+
+void handle_callback_batch(ErlDrvPort port)
+{
+  WxeApp * app = (WxeApp *) wxTheApp;
+  // Should we be able to handle commands when recursing? probably
+  erl_drv_mutex_lock(wxe_batch_locker_m);
+  app->dispatch(wxe_batch, 0, WXE_CALLBACK);
+  wxe_batch_caller = 0;
+  erl_drv_mutex_unlock(wxe_batch_locker_m);
+}
+
+// Called by wx thread
+void WxeApp::idle(wxIdleEvent& event) {
+  dispatch_cmds();
+}
+ 
+void WxeApp::dispatch_cmds() {
+  erl_drv_mutex_lock(wxe_batch_locker_m);
+  int level = dispatch(wxe_batch_cb_saved, 0, WXE_STORED);
+  dispatch(wxe_batch, level, WXE_NORMAL);
+  wxe_batch_caller = 0;
+  erl_drv_mutex_unlock(wxe_batch_locker_m);
+}
+
+// Should have  erl_drv_mutex_lock(wxe_batch_locker_m); 
+// when entering this function and it should be released 
+// afterwards
+int WxeApp::dispatch(wxList * batch, int blevel, int list_type) 
+{
+  int ping = 0;
+  // erl_drv_mutex_lock(wxe_batch_locker_m);  must be locked already
+  while(true) 
+    {
+      if (batch->size() > 0) {
+	for( wxList::compatibility_iterator node = batch->GetFirst();
+	     node;
+	     node = batch->GetFirst())
+	  {
+	    wxeCommand *event = (wxeCommand *)node->GetData();
+	    batch->Erase(node);
+	    switch(event->op) {
+	    case WXE_BATCH_END:
+	      {--blevel; }
+	      break;
+	    case WXE_BATCH_BEGIN:
+	      {blevel++; }
+	      break;
+	    case WXE_DEBUG_PING:
+	      // When in debugger we don't want to hang waiting for a BATCH_END 
+	      // that never comes, because a breakpoint have hit.
+	      ping++;
+	      if(ping > 2) 
+		blevel = 0;
+	      break;
+	    case WXE_CB_RETURN:
+	      // erl_drv_mutex_unlock(wxe_batch_locker_m); should be called after
+	      // whatever cleaning is necessary
+	      memcpy(cb_buff, event->buffer, event->len);
+	      return blevel;
+	    default:
+	      erl_drv_mutex_unlock(wxe_batch_locker_m);	      
+	      if(event->op < OPENGL_START) {
+		// fprintf(stderr, "  c %d (%d) \r\n", event->op, blevel);
+		wxe_dispatch(*event);
+	      } else {
+		gl_dispatch(event->op,event->buffer,event->caller,event->bin);
+	      }
+	      erl_drv_mutex_lock(wxe_batch_locker_m);
+	      break;
+	    }
+	    delete event;
+	  }
+      } else {
+	if((list_type == WXE_STORED) || (blevel <= 0 && list_type == WXE_NORMAL)) {
+	  // erl_drv_mutex_unlock(wxe_batch_locker_m); should be called after
+	  // whatever cleaning is necessary
+	  return blevel;
+	}
+	// sleep until something happens
+	//fprintf(stderr, "%s:%d sleep %d %d %d %d \r\n", __FILE__, __LINE__, batch->size(), callback_returned, blevel, is_callback);fflush(stderr);
+	wxe_batch_caller++;
+	while(batch->size() == 0) {
+	  erl_drv_cond_wait(wxe_batch_locker_c, wxe_batch_locker_m);
+	}
+      }
+    }
+}
+
+void WxeApp::dispatch_cb(wxList * batch, wxList * temp, ErlDrvTermData process) {
+  int callback_returned = 0;
+  while(true) {
+    if (batch->size() > 0) {
+      for( wxList::compatibility_iterator node = batch->GetFirst();
+	   node;
+	   node = batch->GetFirst())
+	{
+	  wxeCommand *event = (wxeCommand *)node->GetData();
+	  batch->Erase(node);
+	  if(event->caller == process ||  // Callbacks from CB process only 
+	     event->op == WXE_CB_START || // Recursive event callback allow
+	     // Allow connect_cb during CB i.e. msg from wxe_server.
+	     event->caller == driver_connected(event->port)) 
+	    {
+	      switch(event->op) {
+	      case WXE_BATCH_END:
+	      case WXE_BATCH_BEGIN:
+	      case WXE_DEBUG_PING:
+		break;
+	      case WXE_CB_RETURN:
+		memcpy(cb_buff, event->buffer, event->len);
+		callback_returned = 1;
+		return;
+	      case WXE_CB_START:
+		// CB start from now accept message from CB process only
+		process = event->caller;
+		break;
+	      default:
+		erl_drv_mutex_unlock(wxe_batch_locker_m);
+		if(event->op < OPENGL_START) {
+		  // fprintf(stderr, "  cb %d \r\n", event->op);
+		  wxe_dispatch(*event);
+		} else {
+		  gl_dispatch(event->op,event->buffer,event->caller,event->bin);
+		}
+		erl_drv_mutex_lock(wxe_batch_locker_m);
+		break;
+		if(callback_returned) 
+		  return;
+	      }
+	      delete event;
+	    } else {
+	    // fprintf(stderr, "  sav %d \r\n", event->op);
+	    temp->Append(event);
+	  }
+	}
+    } else {
+      if(callback_returned) {
+	return;
+      }
+      // sleep until something happens
+      //fprintf(stderr, "%s:%d sleep %d %d %d %d \r\n", __FILE__, __LINE__, batch->size(), callback_returned, blevel, is_callback);fflush(stderr);
+      while(batch->size() == 0) {
+	erl_drv_cond_wait(wxe_batch_locker_c, wxe_batch_locker_m);
+      }
+    }
+  }
+}
+
+/* Memory handling */
+
+void WxeApp::newMemEnv(wxeMetaCommand& Ecmd) {
+  wxeMemEnv * memenv = new wxeMemEnv();
+  for(int i = 0; i < global_me->next; i++) {
+    memenv->ref2ptr[i] = global_me->ref2ptr[i];    
+  }
+  memenv->next = global_me->next;
+  refmap[(ErlDrvTermData) Ecmd.port] = memenv;
+  memenv->owner = Ecmd.caller;
+
+  ErlDrvTermData rt[] = {ERL_DRV_ATOM, driver_mk_atom((char *)"wx_port_initiated")};  
+  driver_send_term(WXE_DRV_PORT,Ecmd.caller,rt,2);
+}
+
+void WxeApp::destroyMemEnv(wxeMetaCommand& Ecmd) {
+  // Clear incoming cmd queue first
+  // dispatch_cmds();
+  wxWindow *parent = NULL;
+  wxeMemEnv * memenv = refmap[(ErlDrvTermData) Ecmd.port];
+
+  if(wxe_debug) {
+    wxString msg;
+    msg.Printf(wxT("Destroying all memory "));
+    send_msg("debug", &msg);
+  }
+
+  // pre-pass delete all dialogs first since they might crash erlang otherwise
+  for(int i=1; i < memenv->next; i++) {
+    wxObject * ptr = (wxObject *) memenv->ref2ptr[i];
+    if(ptr) { 
+      ptrMap::iterator it = ptr2ref.find(ptr);
+      if(it != ptr2ref.end()) {
+	wxeRefData *refd = it->second;
+	if(refd->alloc_in_erl) {
+	  if(refd->type == 2) {
+	    wxDialog *win = (wxDialog *) ptr; 
+	    if(win->IsModal()) {
+	      win->EndModal(-1);
+	    }
+	    parent = win->GetParent();
+	    if(parent) {
+	      ptrMap::iterator parentRef = ptr2ref.find(parent);
+	      if(parentRef == ptr2ref.end()) {
+		// The parent is already dead delete the parent ref
+		win->SetParent(NULL);
+	      } 
+	    }
+	    delete win;
+	  } 
+	}
+      }
+    }
+  }
+  // First pass, delete all top parents/windows of all linked objects 
+  //   fprintf(stderr, "close port %x\r\n", Ecmd.port);fflush(stderr);
+
+  for(int i=1; i < memenv->next; i++) {
+    void * ptr = memenv->ref2ptr[i];
+    if(ptr) { 
+      ptrMap::iterator it = ptr2ref.find(ptr);
+      if(it != ptr2ref.end()) {
+	wxeRefData *refd = it->second;
+	if(refd->alloc_in_erl && refd->type == 0) {
+	  parent = (wxWindow *) ptr; 
+	  // fprintf(stderr, "window %x %d\r\n", (int) parent, refd->ref);
+	  while(parent->GetParent()) {
+	    parent = parent->GetParent();
+	    // fprintf(stderr, "  parent %x \r\n", (int) parent);
+	  }
+	  ptrMap::iterator pdata = ptr2ref.find(parent);
+	  if(pdata != ptr2ref.end()) {
+	    delete parent;
+	  } // else parent is already deleted
+	}
+      } else {
+	// fprintf(stderr, "Error found no ref in %d => %x\r\n", i, ptr);
+      }
+    }
+  }
+  // Second pass delete everything else allocated
+  // everything linked from windows should now be deleted
+  for(int i=1; i < memenv->next; i++) {
+    void * ptr = memenv->ref2ptr[i];
+    if(ptr) { 
+      ptrMap::iterator it = ptr2ref.find(ptr);
+      if(it != ptr2ref.end()) {
+	wxeRefData *refd = it->second;
+	if(refd->alloc_in_erl) {
+	  int type = refd->type;
+	  if((refd->type == 1) && ((wxObject *)ptr)->IsKindOf(CLASSINFO(wxBufferedDC))) {
+	    ((wxBufferedDC *)ptr)->m_dc = NULL; // Workaround
+	  }
+	  wxString msg;
+	  if((refd->type == 0)) { // Maybe also class 1
+	    wxClassInfo *cinfo = ((wxObject *)ptr)->GetClassInfo();
+	    msg.Printf(wxT("Memory leak: {wx_ref, %d, %s}"), 
+		       refd->ref, cinfo->GetClassName());
+	    send_msg("error", &msg);
+	  } else {
+	    delete_object(ptr, refd);
+	  }
+	  if(type == 0 || type > 3) { 
+	    // Delete refs for leaks and non overridden allocs 
+	    delete refd;
+	    ptr2ref.erase(it);
+	  } // overridden allocs deletes meta-data in clearPtr
+	} else { // Not alloced in erl just delete references
+	  if(refd->ref >= global_me->next) { // if it is not part of global ptrs
+	    delete refd; 
+	    ptr2ref.erase(it);
+	  }
+	}
+      }
+    }
+  }  
+  // Assert ?
+//   for(ptrMap::iterator it = ptr2ref.begin(); it != ptr2ref.end(); it++) {
+//     wxeRefData *refd = it->second;
+//     if(refd->ref >= global_me->next)
+//       fprintf(stderr, "L %d  %d\r\n", refd->ref, refd->alloc_in_erl);
+//   }
+//   fflush(stderr);
+  delete memenv;
+  refmap.erase((ErlDrvTermData) Ecmd.port);
+}
+
+wxeMemEnv * WxeApp::getMemEnv(ErlDrvPort port) {
+  return refmap[(ErlDrvTermData) port];
+}
+
+int WxeApp::newPtr(void * ptr, int type, wxeMemEnv *memenv) {
+  int ref;
+  intList free = memenv->free;
+  
+  if(free.IsEmpty()) {
+    ref = memenv->next++;
+  } else {
+    ref = free.Pop();
+  };
+  if(ref >= memenv->max) {
+    memenv->max *= 2;
+    memenv->ref2ptr = 
+      (void **) driver_realloc(memenv->ref2ptr,memenv->max * sizeof(void*));    
+  }
+  memenv->ref2ptr[ref] = ptr;
+
+  if(wxe_debug) {
+    wxString msg;
+    msg.Printf(wxT("Creating {wx_ref, %d, unknown} at %p "), ref, ptr);
+    send_msg("debug", &msg);
+  }
+
+  ptr2ref[ptr] = new wxeRefData(ref, type, true, memenv);
+  // fprintf(stderr, "ptr %x id %d\r\n", (int) ptr,ref);
+  return ref;
+}
+
+int WxeApp::getRef(void * ptr, wxeMemEnv *memenv) {
+  if(!ptr) return 0;  // NULL and zero is the same
+  ptrMap::iterator it = ptr2ref.find(ptr);
+  if(it != ptr2ref.end()) {
+    wxeRefData *refd = it->second;
+    return refd->ref;
+  } else { // New Ptr
+    int ref;
+    intList free = memenv->free;
+    
+    if(free.IsEmpty()) {
+      ref = memenv->next++;
+    } else {
+      ref = free.Pop();
+    };
+    if(ref >= memenv->max) {
+      memenv->max *= 2;
+      memenv->ref2ptr = 
+	(void **) driver_realloc(memenv->ref2ptr,memenv->max * sizeof(void*));
+    }
+
+    memenv->ref2ptr[ref] = ptr;
+    ptr2ref[ptr] = new wxeRefData(ref, 0, false, memenv);
+    return ref;
+  }
+}
+
+void WxeApp::clearPtr(void * ptr) {
+  ptrMap::iterator it;
+  it = ptr2ref.find(ptr);
+
+  if(it != ptr2ref.end()) {
+    wxeRefData *refd = it->second;
+    intList free = refd->memenv->free;
+    int ref = refd->ref;    
+    refd->memenv->ref2ptr[ref] = NULL;
+    free.Append(ref);
+
+    if(wxe_debug) {
+      wxString msg;
+      msg.Printf(wxT("Deleting {wx_ref, %d, unknown} at %p "), ref, ptr);
+      send_msg("debug", &msg);
+    }
+    
+    if(refd->pid != -1) {  
+      // Send terminate pid to owner
+      wxeReturn rt = wxeReturn(WXE_DRV_PORT,refd->memenv->owner, false);
+      rt.addAtom("_wxe_destroy_");
+      rt.add(ERL_DRV_PID, refd->pid);
+      rt.addTupleCount(2);
+      rt.send();
+      refd->pid = -1;
+    };
+    if(refd->type == 1 && ((wxObject*)ptr)->IsKindOf(CLASSINFO(wxSizer))) {
+      wxSizerItemList list = ((wxSizer*)ptr)->GetChildren();
+      for(wxSizerItemList::compatibility_iterator node = list.GetFirst();
+	  node; node = node->GetNext()) { 
+	wxSizerItem *item = node->GetData();
+	wxObject *content=NULL;
+	if((content = item->GetWindow())) 
+	  if(ptr2ref.end() == ptr2ref.find(content)) {
+	    wxString msg;
+	    wxClassInfo *cinfo = ((wxObject *)ptr)->GetClassInfo();
+	    msg.Printf(wxT("Double usage detected of window at %p in sizer {wx_ref, %d, %s}"),
+		       content, ref, cinfo->GetClassName());
+	    send_msg("error", &msg);
+	    ((wxSizer*)ptr)->Detach((wxWindow*)content);	    
+	  }
+	if((content = item->GetSizer())) 
+	  if(ptr2ref.end() == ptr2ref.find(content)) {
+	    wxString msg;
+	    wxClassInfo *cinfo = ((wxObject *)ptr)->GetClassInfo();
+	    msg.Printf(wxT("Double usage detected of sizer at %p in sizer {wx_ref, %d, %s}"),
+		       content, ref, cinfo->GetClassName());
+	    send_msg("error", &msg);
+	    ((wxSizer*)ptr)->Detach((wxSizer*)content);	
+	  }
+      }
+    }
+    
+    delete refd;
+    ptr2ref.erase(it);
+  }
+}
+
+void * WxeApp::getPtr(char * bp, wxeMemEnv *memenv) {
+  int index = *(int *) bp;
+  if(!memenv) 
+    throw wxe_badarg(index);
+  void * temp = memenv->ref2ptr[index];
+  if((index < memenv->next) && ((index == 0) || (temp > NULL)))
+    return temp;
+  else 
+    throw wxe_badarg(index);
+}
+
+void WxeApp::registerPid(char * bp, ErlDrvTermData pid, wxeMemEnv * memenv) {
+  int index = *(int *) bp;
+  if(!memenv) 
+    throw wxe_badarg(index);
+  void * temp = memenv->ref2ptr[index];
+  if((index < memenv->next) && ((index == 0) || (temp > NULL))) {
+    ptrMap::iterator it;
+    it = ptr2ref.find(temp);
+    if(it != ptr2ref.end()) {
+      wxeRefData *refd = it->second;
+      refd->pid = pid;
+      return ;
+    }
+  };
+  throw wxe_badarg(index);
+}
+
+
+/* ************************************************************
+ *  Misc utility classes
+ * ************************************************************/
+
+/* **************************************************************************** 
+ * Memory handling  
+ * ****************************************************************************/
+
+wxeMemEnv::wxeMemEnv() {
+  ref2ptr = (void **) driver_alloc(128*sizeof(void *));  
+  ref2ptr[0] = NULL;
+  next = 1; 
+  max = 128;
+}
+
+wxeMemEnv::~wxeMemEnv() {
+  driver_free(ref2ptr);
+}
+
+/* **************************************************************************** 
+ * Erlang Commands (don't need to be derived of wxEvent anymore should
+ * be re-written to own class struct)
+ * ****************************************************************************/
+
+wxeCommand::wxeCommand(int fc,char * cbuf,int buflen, wxe_data *sd) 
+  : wxObject()
+{
+  WXEBinRef *temp, *start, *prev;
+  int n = 0;
+  caller = driver_caller(sd->port);
+  port   = sd->port;
+  op = fc;
+  len = buflen;
+  bin[0] = NULL;
+  bin[1] = NULL;
+  bin[2] = NULL;
+
+  if(cbuf) {
+    buffer = (char *) driver_alloc(len);
+    memcpy((void *) buffer, (void *) cbuf, len);;
+    
+    temp = sd->bin;
+    
+    prev  = NULL;
+    start = temp;
+    
+    while(temp) {
+      if(caller == temp->from) {
+	bin[n++] = temp;
+	if(prev) {
+	  prev->next = temp->next;
+	} else {
+	  start = temp->next;
+	}
+	temp = temp->next;
+      } else {
+	prev = temp;
+	temp = temp->next;
+      }
+    }
+    sd->bin = start;
+  } else {   // No-op only PING currently
+    buffer = NULL;
+  }
+}
+
+wxeCommand::~wxeCommand() {
+  int n = 0;
+  if(buffer) {
+    while(bin[n]) {
+      if(bin[n]->bin) 
+	driver_free_binary(bin[n]->bin);
+      driver_free(bin[n++]);
+    }
+    driver_free(buffer);
+  }
+}
+
+/* **************************************************************************** 
+ * TreeItemData 
+ * ****************************************************************************/
+
+wxETreeItemData::wxETreeItemData(int sz, char * data) { 
+  size = sz;
+  bin = (char *) driver_alloc(sz);
+  memcpy(bin, data, sz);
+}
+
+wxETreeItemData::~wxETreeItemData() 
+{
+  driver_free(bin);
+}
+
+/* **************************************************************************** 
+ * CallbackData *
+ * ****************************************************************************/
+
+wxeCallbackData::wxeCallbackData(ErlDrvTermData caller,void * req, char *req_type, 
+				 int funcb, int skip_ev, wxeErlTerm * userData)
+  : wxObject()
+{
+  listener = caller;
+  obj = req;
+  fun_id = funcb;
+  strcpy(class_name, req_type);
+  skip = skip_ev;
+  user_data = userData;
+}
+
+wxeCallbackData::~wxeCallbackData() {
+  // fprintf(stderr, "CBD Deleteing %x %s\r\n", (unsigned int) this, class_name); fflush(stderr);
+  if(user_data) {
+    delete user_data;
+  }
+}
+
+/* ****************************************************************************
+ * wxListCtrlCompare wrapper
+ * ****************************************************************************/
+
+int wxCALLBACK wxEListCtrlCompare(long item1, long item2, long callbackInfoPtr)
+{
+  callbackInfo * cb = (callbackInfo *)callbackInfoPtr;
+  wxeMemEnv * memenv =  ((WxeApp *) wxTheApp)->getMemEnv(cb->port);
+  char * bp = ((WxeApp *) wxTheApp)->cb_buff;
+  
+  wxeReturn rt = wxeReturn(WXE_DRV_PORT, memenv->owner, false);
+  rt.addInt(cb->callbackID);
+  rt.addInt(item1);
+  rt.addInt(item2);
+  rt.endList(2);
+  rt.addAtom("_wx_invoke_cb_");
+  rt.addTupleCount(3);
+  rt.send();
+  handle_callback_batch(cb->port);
+  return *(int*) bp;
+}