guithread.cpp

Go to the documentation of this file.

#define TCL_THREADS
// fies: Wenn nicht definiert, funktionieren die Mutexes etc. nicht
#include <tk.h>
#include <tcl.h>
#include <cstdio>
#include <malloc.h>
#include <cmath>
#include <cstring>
#include <iostream>
//#include <windows.h>
//#undef min
// #undef max
// Grrr - stupid "windows.h" defines min and max as macro
// it clashes with valarray::max
#include "imgclass.hpp"
#include "xgray_tcl.hpp"
#include "guithread.hpp"

using namespace std;

extern "C" int Xgray_Init(Tcl_Interp *);


TCL_DECLARE_MUTEX(threadMutex)

struct ThreadEvent  {
    Tcl_Event event;            /* Must be first */
    char *script;               /* The script to execute. */
    Tcl_Interp *interp;
    
    struct ThreadEventResult *resultPtr;
                                /* To communicate the result.  This is
                                 * NULL if we don't care about it. */
};

struct ThreadEventResult {
    Tcl_Condition done;         /* Signaled when the script completes */
    int code;                   /* Return value of Tcl_Eval */
    char *result;               /* Result from the script */
    char *errorInfo;            /* Copy of errorInfo variable */
    char *errorCode;            /* Copy of errorCode variable */
    Tcl_ThreadId srcThreadId;   /* Id of sending thread, in case it dies */
    Tcl_ThreadId dstThreadId;   /* Id of target thread, in case it dies */
    struct ThreadEvent *eventPtr;       /* Back pointer */
    struct ThreadEventResult *nextPtr;  /* List for cleanup */
    struct ThreadEventResult *prevPtr;

};

static void
ThreadFreeProc(ClientData clientData)
{
    if (clientData) {
        ckfree((char *) clientData);
    }
}

static int ThreadEventProc(
    Tcl_Event *evPtr,           /* Really ThreadEvent */
    int mask)
{
    ThreadEvent *threadEventPtr = (ThreadEvent *)evPtr;
    ThreadEventResult *resultPtr = threadEventPtr->resultPtr;
    Tcl_Interp *interp = threadEventPtr->interp;
    int code;
    const char *result, *errorCode, *errorInfo;

    if (interp == NULL) {
        code = TCL_ERROR;
        result = "no target interp!";
        errorCode = "THREAD";
        errorInfo = "";
    } else {
        Tcl_Preserve((ClientData) interp);
        Tcl_ResetResult(interp);
        Tcl_CreateThreadExitHandler(ThreadFreeProc,
                (ClientData) threadEventPtr->script);
        code = Tcl_GlobalEval(interp, threadEventPtr->script);
        Tcl_DeleteThreadExitHandler(ThreadFreeProc,
                (ClientData) threadEventPtr->script);
        if (code != TCL_OK) {
            errorCode = Tcl_GetVar(interp, "errorCode", TCL_GLOBAL_ONLY);
            errorInfo = Tcl_GetVar(interp, "errorInfo", TCL_GLOBAL_ONLY);
        } else {
            errorCode = errorInfo = NULL;
        }
        result = Tcl_GetStringResult(interp);
    }
    ckfree(threadEventPtr->script);
    if (interp != NULL) {
        Tcl_Release((ClientData) interp);
    }
    return 1;
}


int tcl_thread_send(Tcl_ThreadId id, Tcl_Interp* interp, const char *script)
 {
    ThreadEvent *threadEventPtr;
    ThreadEventResult *resultPtr;
    int found, code;
    Tcl_ThreadId threadId = (Tcl_ThreadId) id;

    Tcl_MutexLock(&threadMutex);
    /* 
     * Create the event for its event queue.
     */

    threadEventPtr = (ThreadEvent *) ckalloc(sizeof(ThreadEvent));
    threadEventPtr->script = ckalloc(strlen(script) + 1);
    threadEventPtr->interp = interp;
    strcpy(threadEventPtr->script, script);
    resultPtr = threadEventPtr->resultPtr = NULL;
   
    /*
     * Queue the event and poke the other thread's notifier.
     */

    threadEventPtr->event.proc = ThreadEventProc;
    Tcl_ThreadQueueEvent(threadId, (Tcl_Event *)threadEventPtr, 
            TCL_QUEUE_TAIL);
    Tcl_ThreadAlert(threadId);

    
    Tcl_MutexUnlock(&threadMutex);
    return TCL_OK;
}



extern "C" {
 static int AppInit(Tcl_Interp *interp);
 static Tcl_ThreadCreateType slaveinterpreter (ClientData dummy);
}


 
  static Tcl_ThreadId displaythreadId=0;
  static Tcl_Interp *interp=NULL;
  static int argc=0;
  static const char ** argv=NULL;
  static Tcl_Condition startup_condition=NULL;
  static volatile bool started=false;
  
int AppInit(Tcl_Interp *interp_) {
        interp = interp_;

        Tcl_SetVar(interp, "tcl_interactive", "0", TCL_GLOBAL_ONLY);
        if(Tcl_Init(interp) == TCL_ERROR) return TCL_ERROR;
        if(Tk_Init(interp) == TCL_ERROR) return TCL_ERROR;
        if (Xgray_Init(interp)==TCL_ERROR) return TCL_ERROR;
       

        cout<<"T2"<<endl<<flush;
        Tcl_MutexLock(&threadMutex);
        
        // Doof: Ich muss noch eine extra Variable setzen
        // ConditionWait kann auch so zurückkommen ???
        started=true;
        Tcl_ConditionNotify(&startup_condition);
        Tcl_MutexUnlock(&threadMutex);
        // Der Start gelang
        return TCL_OK;
}

Tcl_ThreadCreateType slaveinterpreter (ClientData dummy) {
    Tcl_Channel  outChannel;
    
    Tcl_Interp *interp = Tcl_CreateInterp();
    /*
     * Ensure that we are getting the matching version of Tcl.  This is
     * really only an issue when Tk is loaded dynamically.
     */

    if (Tcl_InitStubs(interp, TCL_VERSION, 1) == NULL) {
        abort();
    }
    

#ifdef MAC_OSX_TK
    {
        TkMacOSXDefaultStartupScript();
    }
#endif
    
    /*
     * Set the "tcl_interactive" variable.
     */

    Tcl_SetVar(interp, "tcl_interactive", "0", TCL_GLOBAL_ONLY);

    /*
     * Invoke application-specific initialization.
     */

    if (AppInit(interp) != TCL_OK) {
        return 0;
    }

    /*
     * Invoke the script specified on the command line, if any.
     */

   
    outChannel = Tcl_GetStdChannel(TCL_STDOUT);
    if (outChannel) {
        Tcl_Flush(outChannel);
    }
    
    Tcl_ResetResult(interp);

    /*
     * Loop infinitely, waiting for commands to execute.  When there
     * are no windows left, Tk_MainLoop returns and we exit.
     */

    Tk_MainLoop();
    Tcl_DeleteInterp(interp);
    /*Tcl_Exit(0);*/

  return 0;
} 


Tclthread::Tclthread(int argc_, const char **argv_)
{
  int result;
  argc=argc_;
  argv=argv_;
  
  
  Tcl_FindExecutable(argv[0]);
  Tcl_MutexLock(&threadMutex);
  result=Tcl_CreateThread(&displaythreadId, slaveinterpreter, (ClientData)0, TCL_THREAD_STACK_DEFAULT, TCL_THREAD_NOFLAGS);

  // hier sollte irgendein ConditionWait feststellen,
  // ob der Interpreter wirklich läuft
  int nr=0;
  while (!started) {
    Tcl_ConditionWait(&startup_condition, &threadMutex, NULL);
    nr++;
  }
  
  operator() (
#include "inlinedisplay.c++"
 );
  // Startupskript ausführen
  Tcl_MutexUnlock(&threadMutex);
  cout<<"T1 "<<nr<<endl<<flush;
}


void Tclthread::operator () (const char *script) {
  tcl_thread_send(displaythreadId, interp, script);
  // fire and forget
}  

---