
/***************************************************************************
                          xsldbgevent.c  -  event to notify app of
                                                   data from xsldbg
                             -------------------
    begin                : Fri Feb 1 2001
    copyright            : (C) 2001 by Keith Isdale
    email                : k_isdale@tpg.com.au
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/

#include <tqapplication.h>
#include <tqtimer.h>
#include <tqfile.h>
#include <kurl.h>
#include <tqtextstream.h>

#include <libxslt/xsltInternals.h>

#include "../libxsldbg/xsldbgevent.h"
#include "xsldbgdebuggerbase.h"
#include "../libxsldbg/arraylist.h"
#include "../libxsldbg/breakpoint.h"
#include "../libxsldbg/xsldbgmsg.h"
#include "../libxsldbg/xsldbgthread.h"
#include "../libxsldbg/options.h"
#include "../libxsldbg/files.h"

TQString updateText;

XsldbgEventData::XsldbgEventData()
{
  int column;

  for (column = 0; column < XSLDBGEVENT_COLUMNS; column++){
    textValues[column] = TQString();
  }

 for (column = 0; column < XSLDBGEVENT_COLUMNS; column++){
   intValues[column] = -1;
  }

}

XsldbgEventData::~XsldbgEventData()
{
}

void XsldbgEventData::setText(int column, TQString text)
{
  if ((column >= 0) && (column < XSLDBGEVENT_COLUMNS))
    textValues[column] = text;
}


TQString XsldbgEventData::getText(int column)
{
  if ((column >= 0) && (column < XSLDBGEVENT_COLUMNS))
    return textValues[column];
  else
    return TQString();
}


void XsldbgEventData::setInt(int column, int value)
{
  if ((column >= 0) && (column < XSLDBGEVENT_COLUMNS))
    intValues[column] = value;
}


int XsldbgEventData::getInt(int column)
{
  if ((column >= 0) && (column < XSLDBGEVENT_COLUMNS))
    return intValues[column];
  else
    return -1;
}


XsldbgEvent::XsldbgEvent(XsldbgMessageEnum type, const void *data)
  : TQEvent(TQEvent::User)
{
  XsldbgEventData *eventData;
  this->data = data;
  debugger = 0L;
  beenCreated = false;

  if (type == XSLDBG_MSG_LIST){             /* 23 : As list of messages  */
    notifyMessageListPtr msgList = (notifyMessageListPtr)data;
    void *msgData;
    /* If this is an included source message, which just continues a source message,
       we don't need to add an empty XsldbgEventData */
    if (msgList->type != XSLDBG_MSG_INCLUDED_SOURCE_CHANGED){
      /* add an empty event data item which indicates the start of a list */
      eventData  = new XsldbgEventData();
      if (eventData != 0L)
        list.append(eventData);
    }
    for (int index = 0; index < arrayListCount(msgList->list); index++){
      msgData = ::arrayListGet(msgList->list, index);
      eventData = createEventData(msgList->type, msgData);
      if (eventData != 0L)
        list.append(eventData);
    }
    ::arrayListFree(msgList->list);
    msgList->list = 0L;
    itemType = msgList->type;
  }else{
    eventData = createEventData(type, data);
    if (eventData != 0L)
      list.append(eventData);
    itemType = type;
  }

  beenCreated = true;
  /* remove any knowledge of orginal data */
  this->data = 0L;
}


XsldbgEvent::~XsldbgEvent()
{
}


XsldbgEventData *XsldbgEvent::createEventData(XsldbgMessageEnum type, const void *msgData)
{
  XsldbgEventData *result = new XsldbgEventData();

  if (result == 0L)
    return result;

 switch (type){

    case XSLDBG_MSG_THREAD_NOTUSED:  /* 0:  Thread are not to be used */
    case XSLDBG_MSG_THREAD_INIT:     /* 1: The xsldbg thread is initializing */
    case XSLDBG_MSG_THREAD_RUN:      /* 2: The xsldbg thread is running */
    case XSLDBG_MSG_THREAD_STOP:     /* 3: The xsldbg thread is about to die */
    case XSLDBG_MSG_THREAD_DEAD:     /* 4: The xsldbg thread died */
      /* we don't need to do anything extra with this message */
      break;

    /* input status ( once thread is running) */
    case XSLDBG_MSG_AWAITING_INPUT:  /* 5: Waiting for user input */
      /* we don't need to do anything extra with this message */
      break;

    case XSLDBG_MSG_READ_INPUT:      /* 6: Read user input */
      /* we don't need to do anything extra with this message */
      break;

    case XSLDBG_MSG_PROCESSING_INPUT:        /* 7: Processing user's request */
      /* we don't need to do anything extra with this message */
      break;

    /* provide more informatiom about state of xsldbg (optional) */
    case XSLDBG_MSG_PROCESSING_RESULT:       /* 8: An error occured performing command
                                         * requested command */
      if (msgData != 0L){
        xsldbgErrorMsgPtr msg = (xsldbgErrorMsgPtr)msgData;
        if (msg->text)
          result->setText(0, XsldbgDebuggerBase::fromUTF8(msg->text));
      }
      break;

    case XSLDBG_MSG_LINE_CHANGED:    /* 9: Changed to new line number
                                 * ie a step */
      handleLineNoChanged(result, msgData);
      break;

    case XSLDBG_MSG_FILE_CHANGED:    /* 10: Changed selection for source/data/output file */
      // not used
      break;

    case XSLDBG_MSG_BREAKPOINT_CHANGED:      /* 11: Response to a showbreak command */
      handleBreakpointItem(result, msgData);
      break;

    case XSLDBG_MSG_PARAMETER_CHANGED:       /* 12: Response to showparam command */
      handleParameterItem(result, msgData);
      break;

    case XSLDBG_MSG_TEXTOUT:         /* 13 : Free form text from xsldg */
      /* this is going to be most common and its so simple we can handle
       it here */
      result->setText(0, XsldbgDebuggerBase::fromUTF8((xmlChar*)msgData));
      break;

    case XSLDBG_MSG_FILEOUT:         /* 14 : Response to cat commmand, ie
                                 * Free form text in file */
      /* this is actualy the  file to load */
      {
        KURL url(XsldbgDebuggerBase::fromUTF8FileName((xmlChar*)msgData));
        if (!url.isLocalFile()){
          tqDebug("Remote path to temp file %s unsupported, unable to read message from xsldbg", url.prettyURL().local8Bit().data());
          break;
        }

        TQString fileName = url.path();
        TQString outputText;
        if (!fileName.isNull()){
          TQFile file (fileName);
          if (file.open(IO_ReadOnly)){
            TQTextStream textFile(&file);
            TQString textIn = "";
            textFile.setEncoding(TQTextStream::UnicodeUTF8);
            while (1){
              textIn = textFile.readLine();
              if (textIn.isNull())
                break;
              outputText.append(textIn).append("\n");
            }
            file.close();
          }
          outputText.append("\n");
          result->setText(0, outputText);
        }
      }
      break;

    case XSLDBG_MSG_LOCALVAR_CHANGED:        /* 15 : Response to locals command ie a
                                         * local variable */
      handleLocalVariableItem(result, msgData);
      break;

    case XSLDBG_MSG_GLOBALVAR_CHANGED:       /* 16 : Response to globals command
                                         * ie a global variable */
      handleGlobalVariableItem(result, msgData);
      break;

    case XSLDBG_MSG_TEMPLATE_CHANGED:        /* 17 : Response to templates commmand
                                         * ie template details */
      handleTemplateItem(result, msgData);
      break;

    case XSLDBG_MSG_SOURCE_CHANGED:  /* 18 : Response to stylesheets command,
                                 * a normal stylesheet */
      handleSourceItem(result, msgData);
      break;

    case XSLDBG_MSG_INCLUDED_SOURCE_CHANGED: /* 19: Response to stylesheets
                                         * command, a xmlNodeptr of
                                         * a included stylesheet */
      handleIncludedSourceItem(result, msgData);
      break;

    case XSLDBG_MSG_CALLSTACK_CHANGED:       /* 20: Response to where command,
                                         * ie a item on the call stack */
      handleCallStackItem(result, msgData);
      break;

    case XSLDBG_MSG_ENTITIY_CHANGED: /* 21: Response to entities
                                 * command */
      handleEntityItem(result, msgData);
      break;

    case XSLDBG_MSG_RESOLVE_CHANGE:  /* 22: Response to system or
                                 * public command */
      handleResolveItem(result, msgData);
    break;

    default:
      tqDebug("Unhandled type in createEventData %d", type);

    }
 return result;
}

void XsldbgEvent::emitMessage(XsldbgDebuggerBase *debugger)
{
  XsldbgEventData *eventData;

  this->debugger = debugger;

  for (eventData = list.first(); eventData != 0L; eventData = list.next()){
    emitMessage(eventData);
  }

  /* make sure that we only temporarily set the value for debugger*/
  this->debugger = 0L;
}


void XsldbgEvent::emitMessage(XsldbgEventData *eventData)
{

  if ((eventData == 0L) || (debugger == 0L)){
    tqDebug("emitMessage failed");
    if (eventData == 0L)
      tqDebug("Event data == NULL");
    if (debugger == 0L)
      tqDebug("Debugger == NULL");
    return;
  }

  /*
     Method use will end up like

    emit debugger->lineNoChanged("", 1, false);

  */

 switch (itemType){

    case XSLDBG_MSG_THREAD_NOTUSED:  /* 0:  Thread are not to be used */
    case XSLDBG_MSG_THREAD_INIT:     /* 1: The xsldbg thread is initializing */
    case XSLDBG_MSG_THREAD_RUN:      /* 2: The xsldbg thread is running */
      /* we don't need to do anything extra with this message */
      break;

    case XSLDBG_MSG_THREAD_STOP:     /* 3: The xsldbg thread is about to die */
    case XSLDBG_MSG_THREAD_DEAD:     /* 4: The xsldbg thread died */
      /* the debugger has stopped is about to stop */
      debugger->setInitialized(false);
      break;

    /* input status ( once thread is running) */
    case XSLDBG_MSG_AWAITING_INPUT:  /* 5: Waiting for user input */
      if  ((getInputReady() == 0) && (debugger->commandQueue().count() > 0)){
        tqDebug("Command queue not empty");
        TQTimerEvent *e = new TQTimerEvent(debugger->getUpdateTimerID());
        TQApplication::postEvent(debugger, e);
      }
      if (!updateText.isEmpty()){
        debugger->queueMessage(updateText);
        updateText = "";
      }
      break;

    case XSLDBG_MSG_READ_INPUT:      /* 6: Read user input */
      /* we don't need to do anything extra with this message */
      break;

    case XSLDBG_MSG_PROCESSING_INPUT:        /* 7: Processing user's request */
      /* we don't need to do anything extra with this message */
      break;

    /* provide more informatiom about state of xsldbg (optional) */
    case XSLDBG_MSG_PROCESSING_RESULT:       /* 8: An error occured performing command
                                         * requested command */
      if (!eventData->getText(0).isNull())
        updateText.append(eventData->getText(0));
      break;

    case XSLDBG_MSG_LINE_CHANGED:    /* 9: Changed to new line number
                                 * ie a step */
      handleLineNoChanged(eventData, 0L);
      break;

    case XSLDBG_MSG_FILE_CHANGED:    /* 10: Loaded source/data file */
      if (beenCreated == false){
        /* Empty data */
      }else{
        emit debugger->fileDetailsChanged();
      }
      break;

    case XSLDBG_MSG_BREAKPOINT_CHANGED:      /* 11: Response to a showbreak command */
      handleBreakpointItem(eventData, 0L);
      break;

    case XSLDBG_MSG_PARAMETER_CHANGED:       /* 12: Response to showparam command */
      handleParameterItem(eventData, 0L);
      break;

    case XSLDBG_MSG_TEXTOUT:         /* 13 : Free form text from xsldg */
      /* this is going to be most common and its so simple we can handle
       it here */
      /*
      emit debugger->showMessage(eventData->getText(0));
      */
      if (!eventData->getText(0).isNull())
        updateText.append(eventData->getText(0));
      break;

 case XSLDBG_MSG_FILEOUT:         /* 14 : Response to cat commmand */
      if (!eventData->getText(0).isNull())
        updateText.append(eventData->getText(0));
      break;

    case XSLDBG_MSG_LOCALVAR_CHANGED:        /* 15 : Response to locals command ie a
                                         * local variable */
      handleLocalVariableItem(eventData, 0L);
      break;

    case XSLDBG_MSG_GLOBALVAR_CHANGED:       /* 16 : Response to globals command
                                         * ie a global variable */
      handleGlobalVariableItem(eventData, 0L);
      break;

    case XSLDBG_MSG_TEMPLATE_CHANGED:        /* 17 : Response to templates commmand
                                         * ie template details */
      handleTemplateItem(eventData, 0L);
      break;

    case XSLDBG_MSG_SOURCE_CHANGED:  /* 18 : Response to stylesheets command,
                                 * a normal stylesheet */
      handleSourceItem(eventData, 0L);
      break;

    case XSLDBG_MSG_INCLUDED_SOURCE_CHANGED: /* 19: Response to stylesheets
                                         * command, a xmlNodeptr of
                                         * a included stylesheet */
      handleIncludedSourceItem(eventData, 0L);
      break;

    case XSLDBG_MSG_CALLSTACK_CHANGED:       /* 20: Response to where command,
                                         * ie a item on the call stack */
      handleCallStackItem(eventData, 0L);
      break;

    case XSLDBG_MSG_ENTITIY_CHANGED: /* 21: Response to entities
                                 * command */
      handleEntityItem(eventData, 0L);
      break;

    case XSLDBG_MSG_RESOLVE_CHANGE:  /* 22: Response to system or
                                 * public command */
      handleResolveItem(eventData, 0L);
    break;

    default:
      tqDebug("Unhandled type in emitMessage %d", itemType);
    }
}


void XsldbgEvent::handleLineNoChanged(XsldbgEventData *eventData, const  void *msgData)
{
  if (eventData != 0L){
    if (beenCreated == false){
      /* add our specific data to eventData*/
      if (xsldbgUrl() != 0L){
        eventData->setText(0, XsldbgDebuggerBase::fromUTF8FileName(xsldbgUrl()));
        eventData->setInt(0, xsldbgLineNo());
        eventData->setInt(1, msgData != 0L);
      }
    }else{
      /* emit the event data via debugger*/
      emit debugger->lineNoChanged(eventData->getText(0), eventData->getInt(0),
                                   eventData->getInt(1));
    }
  }
}


void XsldbgEvent::handleShowMessage(XsldbgEventData *eventData, const  void *msgData)
{
  if (eventData != 0L){
    if (beenCreated == false){
      /* add our specific data to eventData*/
      if (msgData != 0L){
        eventData->setText(0, XsldbgDebuggerBase::fromUTF8((xmlChar*)msgData));
      }
    }else{
      /* emit the event data via debugger*/
      emit debugger->showMessage(eventData->getText(0));
    }
  }
}


void XsldbgEvent::handleBreakpointItem(XsldbgEventData *eventData, const  void *msgData)
{
  if (eventData != 0L){
    if (beenCreated == false){
      /* add our specific data to eventData*/
      if (msgData != 0L){
        breakPointPtr breakItem = (breakPointPtr)msgData;
        /* set the file name*/
        eventData->setText(0, XsldbgDebuggerBase::fromUTF8FileName(breakItem->url));
        /* line number*/
        eventData->setInt(0, (int)breakItem->lineNo);

        /* templateName */
        eventData->setText(1, XsldbgDebuggerBase::fromUTF8(breakItem->templateName));

        /* modeName */
        eventData->setText(2, XsldbgDebuggerBase::fromUTF8(breakItem->modeName));
        /*  enabled state */
        eventData->setInt(1, (int)(breakItem->flags & BREAKPOINT_ENABLED));

        /* id value */
        eventData->setInt(2, (int)breakItem->id);
      }
    }else{
      /* emit the event data via debugger*/
      emit debugger->breakpointItem(eventData->getText(0), /* file name*/
                                    eventData->getInt(0), /* line number*/
                                    eventData->getText(1), /* template name */
                                    eventData->getText(2), /* mode name */
                                    eventData->getInt(1),  /* enabled state*/
                                    eventData->getInt(2)  /* id*/);
    }
  }
}


void XsldbgEvent::handleGlobalVariableItem(XsldbgEventData *eventData, const  void *msgData)
{
  if (eventData != 0L){
    if (beenCreated == false){
      /* add our specific data to eventData*/
      if (msgData != 0L){
        xsltStackElemPtr item = (xsltStackElemPtr)msgData;
        TQString name, fileName, selectXPath;
        int lineNumber = -1;

        /* variable name*/
        if (item->nameURI)
          name = (XsldbgDebuggerBase::fromUTF8FileName(item->nameURI)).append(":");
        name.append(XsldbgDebuggerBase::fromUTF8(item->name));



        if (item->computed && item->comp && item->comp->inst && item->comp->inst->doc){
          fileName = XsldbgDebuggerBase::fromUTF8FileName(item->comp->inst->doc->URL);
          lineNumber= xmlGetLineNo(item->comp->inst);
        }

        if (item->select)
          selectXPath   = XsldbgDebuggerBase::fromUTF8(item->select);

        eventData->setText(0, name);
        eventData->setText(1, "");
        eventData->setText(2, fileName);
        eventData->setText(3, selectXPath);
        eventData->setInt(0, lineNumber);
        eventData->setInt(1, 0);
      }
    }else{
      /* emit the event data via debugger*/
      emit debugger->variableItem(eventData->getText(0), /* variable name*/
                                  eventData->getText(1), /* templatecontext*/
                                  eventData->getText(2), /* file name */
                                  eventData->getInt(0), /* line number */
                                  eventData->getText(3), /* select XPath */
                                  eventData->getInt(1) /* Is this a local variable */ );
    }
  }
}


void XsldbgEvent::handleLocalVariableItem(XsldbgEventData *eventData, const  void *msgData)
{
  if (eventData != 0L){
    if (beenCreated == false){
      /* add our specific data to eventData*/
      if (msgData != 0L){
        xsltStackElemPtr item = (xsltStackElemPtr)msgData;
        TQString name, templateContext, fileName, selectXPath;
        int lineNumber = -1;
        xmlNodePtr varXmlNode;

        /* variable name */
        if (item->nameURI)
          name = (XsldbgDebuggerBase::fromUTF8FileName(item->nameURI)).append(":");
        name.append(XsldbgDebuggerBase::fromUTF8(item->name));

        if (item->computed && item->comp && item->comp->inst){
          varXmlNode = item->comp->inst;

          /* try to find out what template this variable belongs to */
          if (varXmlNode->parent && IS_XSLT_NAME(varXmlNode->parent, "template")) {
            xmlChar* value = xmlGetProp(varXmlNode->parent, (xmlChar *) "name");
            if (value) {
              templateContext   = XsldbgDebuggerBase::fromUTF8(value);
              xmlFree(value);
            }else{
              value = xmlGetProp(varXmlNode->parent, (xmlChar *) "match");
              if (value) {
                templateContext   = XsldbgDebuggerBase::fromUTF8(value);
                xmlFree(value);
              }
            }
          }

          if (varXmlNode->doc)  {
            fileName = XsldbgDebuggerBase::fromUTF8FileName(varXmlNode->doc->URL);
            lineNumber = xmlGetLineNo(varXmlNode);
          }

          if (item->select)
            selectXPath   = XsldbgDebuggerBase::fromUTF8(item->select);

          eventData->setText(0, name);
          eventData->setText(1, templateContext);
          eventData->setText(2, fileName);
          eventData->setText(3, selectXPath);
          eventData->setInt(0, lineNumber);
          eventData->setInt(1, 1);
        }
      }
    }else{
      /* emit the event data via debugger*/
      emit debugger->variableItem(eventData->getText(0), /* variable name*/
                                  eventData->getText(1), /* templatecontext*/
                                  eventData->getText(2), /* file name */
                                  eventData->getInt(0), /* line number */
                                  eventData->getText(3), /* select XPath */
                                  eventData->getInt(1) /* Is this a local variable */ );
    }
  }
}


void XsldbgEvent::handleTemplateItem(XsldbgEventData *eventData, const  void *msgData)
{
if (eventData != 0L){
    if (beenCreated == false){
      /* add our specific data to eventData*/
      if(msgData != 0L){
        xsltTemplatePtr item = (xsltTemplatePtr)msgData;
        TQString name, mode,  fileName;
        int lineNumber = -1;

        if (item->nameURI)
          name.append(XsldbgDebuggerBase::fromUTF8FileName(item->nameURI)).append(":");

        if (item->name)
          name.append(XsldbgDebuggerBase::fromUTF8(item->name));
        else if (item->match)
          name.append(XsldbgDebuggerBase::fromUTF8(item->match));

        mode = XsldbgDebuggerBase::fromUTF8(item->mode);

        if (item->elem && item->elem->doc){
          fileName = XsldbgDebuggerBase::fromUTF8FileName(item->elem->doc->URL);
          lineNumber = xmlGetLineNo(item->elem);
        }
        eventData->setText(0, name);
        eventData->setText(1, mode);
        eventData->setText(2, fileName);
        eventData->setInt(0, lineNumber);
      }
    }else{
      /* emit the event data via debugger*/
      emit debugger->templateItem(eventData->getText(0), /* tempalte name*/
                                  eventData->getText(1), /* mode*/
                                  eventData->getText(2), /* file name*/
                                  eventData->getInt(0) /* line number*/);
    }
  }

}


void XsldbgEvent::handleIncludedSourceItem(XsldbgEventData *eventData, const  void *msgData)
{
  if (eventData != 0L){
    if (beenCreated == false){
      /* add our specific data to eventData*/
      if (msgData != 0L){
        xmlNodePtr item = (xmlNodePtr)msgData;
        TQString name,  fileName;
        int lineNumber = -1;

        if (item->doc)
          name = XsldbgDebuggerBase::fromUTF8FileName(item->doc->URL);

        if (item->parent && item->parent->doc){
          fileName = XsldbgDebuggerBase::fromUTF8FileName(item->parent->doc->URL);
          lineNumber = xmlGetLineNo((xmlNodePtr)item->parent->doc);
        }
        eventData->setText(0, name);
        eventData->setText(1, fileName);
        eventData->setInt(0, lineNumber);
      }
    }else{
      /* emit the event data via debugger*/
      emit debugger->sourceItem(eventData->getText(0), /* file name*/
                                eventData->getText(1), /* parent file name*/
                                eventData->getInt(0) /* parent line number*/);
    }
  }
}

void XsldbgEvent::handleSourceItem(XsldbgEventData *eventData, const  void *msgData)
{
  if (eventData != 0L){
    if (beenCreated == false){
      /* add our specific data to eventData*/
      if (msgData != 0L){
        xsltStylesheetPtr item = (xsltStylesheetPtr)msgData;
        TQString name,  fileName;
        int lineNumber = -1;

        if (item->doc)
          name = XsldbgDebuggerBase::fromUTF8FileName(item->doc->URL);

        if (item->parent && item->parent->doc){
          fileName = XsldbgDebuggerBase::fromUTF8FileName(item->parent->doc->URL);
          lineNumber = xmlGetLineNo((xmlNodePtr)item->parent->doc);
        }

        eventData->setText(0, name);
        eventData->setText(1, fileName);
        eventData->setInt(0, lineNumber);
      }
    }else{
      /* emit the event data via debugger*/
      emit debugger->sourceItem(eventData->getText(0), /* name*/
                                eventData->getText(1), /* parent file name*/
                                eventData->getInt(0) /* parent line number*/);
    }
  }
}

void XsldbgEvent::handleParameterItem(XsldbgEventData *eventData, const  void *msgData)
{
  if (eventData != 0L){
    if (beenCreated == false){
      /* add our specific data to eventData*/
      if (msgData != 0L){
        parameterItemPtr paramItem = (parameterItemPtr)msgData;
        TQString name, value;

        name = XsldbgDebuggerBase::fromUTF8(paramItem->name);
        value = XsldbgDebuggerBase::fromUTF8(paramItem->value);

        eventData->setText(0, name);
        eventData->setText(1, value);
      }
    }else{
      /* emit the event data via debugger*/
      emit debugger->parameterItem(eventData->getText(0), /* param name*/
                                   eventData->getText(1) /* param value*/);
    }
  }
}


void XsldbgEvent::handleCallStackItem(XsldbgEventData *eventData, const  void *msgData)
{
  if (eventData != 0L){
    if (beenCreated == false){
      /* add our specific data to eventData*/
      if (msgData != 0L){
        callPointPtr item = (callPointPtr)msgData;
        TQString templateName,  fileName;
        int lineNumber = -1;

        /* template name */
        if (item->info){
          templateName = XsldbgDebuggerBase::fromUTF8(item->info->templateName);
          fileName = XsldbgDebuggerBase::fromUTF8FileName(item->info->url);
          lineNumber = item->lineNo;
        }

        eventData->setText(0, templateName);
        eventData->setText(1, fileName);
        eventData->setInt(0, lineNumber);
      }
    }else{
      /* emit the event data via debugger*/
      emit debugger->callStackItem(eventData->getText(0), /* template name*/
                                   eventData->getText(1), /* fileName */
                                   eventData->getInt(0) /* line number*/);
    }
  }
}


void XsldbgEvent::handleEntityItem(XsldbgEventData *eventData, const  void *msgData)
{
  if (eventData != 0L){
    if (beenCreated == false){
      /* add our specific data to eventData*/
      if (msgData != 0L){
        TQString SystemID, PublicID;

        entityInfoPtr info =  (entityInfoPtr)msgData;
        SystemID = XsldbgDebuggerBase::fromUTF8FileName(info->SystemID);
        PublicID = XsldbgDebuggerBase::fromUTF8(info->PublicID);

        eventData->setText(0, SystemID);
        eventData->setText(1, PublicID);
      }
    }else{
      /* emit the event data via debugger*/
      emit debugger->entityItem(eventData->getText(0), /* SystemID*/
                                eventData->getText(1) /* PublicID*/);
    }
  }
}


void XsldbgEvent::handleResolveItem(XsldbgEventData *eventData, const  void *msgData)
{
  if (eventData != 0L){
    if (beenCreated == false){
      /* add our specific data to eventData*/
      if (msgData != 0L){
        TQString URI = XsldbgDebuggerBase::fromUTF8FileName((const xmlChar*)msgData);

        eventData->setText(0, URI);
      }
    }else{
      /* emit the event data via debugger*/
      emit debugger->resolveItem(eventData->getText(0) /* URI */);
    }
  }
}


void XsldbgEvent::handleIntOptionItem(XsldbgEventData *eventData, const  void *msgData)
{
  if (eventData != 0L){
    if (beenCreated == false){
      /* add our specific data to eventData*/
      if (msgData != 0L){
        parameterItemPtr paramItem = (parameterItemPtr)msgData;
        eventData->setText(0, XsldbgDebuggerBase::fromUTF8(paramItem->name));
        eventData->setInt(0, paramItem->intValue);
      }
    }else{
      /* emit the event data via debugger*/
      emit debugger->intOptionItem(eventData->getText(0), /* option name*/
                                   eventData->getInt(0) /* value*/);
    }
  }
}


void XsldbgEvent::handleStringOptionItem(XsldbgEventData *eventData, const  void *msgData)
{
  if (eventData != 0L){
    if (beenCreated == false){
      /* add our specific data to eventData*/
      if (msgData != 0L){
        parameterItemPtr paramItem = (parameterItemPtr)msgData;
        eventData->setText(0, XsldbgDebuggerBase::fromUTF8(paramItem->name));
        eventData->setText(1, XsldbgDebuggerBase::fromUTF8(paramItem->value));
      }
    }else{
      /* emit the event data via debugger*/
      emit debugger->stringOptionItem(eventData->getText(0), /* option name*/
                                      eventData->getText(1) /* value*/);
    }
  }
}



void XsldbgEventDataList::deleteItem( TQPtrCollection::Item d )
{
    if ( del_item ) delete (XsldbgEventData *)d;
}
