path: root/filters/karbon/ai/aiparserbase.cpp

/* This file is part of the KDE project
   Copyright (C) 2002, Dirk Schönberger <dirk.schoenberger@sz-online.de>

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

   This library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Library General Public License for more details.

   You should have received a copy of the GNU Library General Public License
   along with this library; see the file COPYING.LIB.  If not, write to
   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA 02110-1301, USA.
*/

#include "aiparserbase.h"
#include "ai88handler.h"
#include "ai3handler.h"
#include <tqregexp.h>
#include <tqstringlist.h>

typedef struct {
  char* op;
  AIOperation action;
} AIOperationMapping;

typedef struct {
  char* op;
  PSOperation action;
} PSOperationMapping;

typedef struct {
  char* op;
  CommentOperation action;
} CommentOperationMapping;

static AIOperationMapping aiMappings[] = {
  { "k", AIO_SetFillColorCMYK },
  { "K", AIO_SetStrokeColorCMYK },
  { "g", AIO_SetFillColorGray },
  { "G", AIO_SetStrokeColorGray },
  { "x", AIO_SetFillColorCustom },
  { "X", AIO_SetStrokeColorCustom },
  { "p", AIO_SetFillPattern },
  { "P", AIO_SetStrokePattern },
  { "O", AIO_SetFillOverprinting },
  { "R", AIO_SetStrokeOverprinting },
  { "i", AIO_SetFlatness },
  { "J", AIO_SetLineCap },
  { "j", AIO_SetLineJoin },
  { "M", AIO_SetMiterLimit },
  { "w", AIO_SetLineWidth },
  { "d", AIO_SetDash },
  { "q", AIO_BeginGroupClip },
  { "Q", AIO_EndGroupClip },
  { "m", AIO_MoveTo },
  { "l", AIO_LineToSmooth },
  { "L", AIO_LineToCorner },
  { "c", AIO_CurveToSmooth },
  { "C", AIO_CurveToCorner },

  { "v", AIO_CurveToOmitC1Smooth },
  { "V", AIO_CurveToOmitC1Corner },
  { "y", AIO_CurveToOmitC2Smooth },
  { "Y", AIO_CurveToOmitC2Corner },

  { "H", AIO_PathIgnoreNoReset },
  { "h", AIO_PathIgnoreNoResetClose },
  { "W", AIO_PathClipPath },
  { "N", AIO_PathIgnoreReset },
  { "n", AIO_PathIgnoreResetClose },
  { "F", AIO_PathFillNonZero },
  { "f", AIO_PathFillNonZeroClose },
  { "B", AIO_PathFillNoReset },
  { "b", AIO_PathFillNoResetClose },
  { "S", AIO_PathStroke },
  { "s", AIO_PathStrokeClose },
  { "D", AIO_SetWindingOrder },
  { "Z", AIO_FontEncoding },
  { "E", AIO_PatternDefinition },
  { "A", AIO_LockElement },

  { "z", AIO_SetCurrentText },
  { "a", AIO_TextBlockFillStroke },
  { "e", AIO_TextBlockFill },
  { "I", AIO_TextBlockAppend },
  { "o", AIO_TextBlockIgnore },
  { "r", AIO_TextBlockStroke },
  { "t", AIO_TextOutput },
  { "T", AIO_TextBlockEnd },
  { "`", AIO_GsaveIncludeDocument },
  { "~", AIO_Grestore },

  { "u", AIO_BeginGroupNoClip },
  { "U", AIO_EndGroupNoClip },
  { "*u", AIO_BeginCombination },
  { "*U", AIO_EndCombination },

  { "XR", AIO_SetFillMode },

  { NULL, AIO_Other }
};

static PSOperationMapping psMappings[] = {
  { "get", PSO_Get },
  { "exec", PSO_Exec },
  { "string", PSO_String },
  { "bind", PSO_Bind },
  { "def", PSO_Def },
  { "userdict", PSO_Userdict },
  { "dict", PSO_Dict },
  { "dup", PSO_Dup },
  { "begin", PSO_Begin },
  { "put", PSO_Put },
  { NULL, PSO_Other },
};

static CommentOperationMapping commentMappings[] = {
  { "BeginProlog", CO_BeginProlog },
  { "BeginSetup", CO_BeginSetup },
  { "BeginProcSet", CO_BeginProcSet },
  { "BeginResource", CO_BeginResource },
  { "BeginEncoding", CO_BeginEncoding },
  { "BeginPattern", CO_BeginPattern },
  { "BeginDocument", CO_BeginPattern },
  { "Trailer", CO_Trailer },
  { "EndProlog", CO_EndProlog },
  { "EndSetup", CO_EndSetup },
  { "EndProcSet", CO_EndProcSet },
  { "EndResource", CO_EndResource },
  { "EndEncoding", CO_EndEncoding },
  { "EndPattern", CO_EndPattern },
  { "EndDocument", CO_EndDocument },

  { "Title", CO_Title },
  { "Creator", CO_Creator },

  { "EOF", CO_Ignore },
  { "Note", CO_Ignore },
  { "EndComments", CO_Ignore },
  { "PS-Adobe", CO_Ignore },

  { "BoundingBox", CO_BoundingBox },
  { "TemplateBox", CO_TemplateBox },
  { "AI3_Margin", CO_Margin },

  { "For", CO_For },
  { "CreationDate",  CO_CreationDate },
  { "DocumentFonts",  CO_DocumentFonts },
  { "DocumentFiles",  CO_DocumentFiles },
  { "ColorUsage",  CO_ColorUsage },
  { "DocumentProcSets",  CO_DocumentProcSets },
  { "DocumentSuppliedProcSets", CO_DocumentSuppliedProcSets },

  { "DocumentProcessColors",  CO_DocumentProcessColors },
  { "DocumentCustomColors",  CO_DocumentCustomColors },
  { "CMYKCustomColor", CO_CMYKCustomColor },
  { "TileBox",  CO_TileBox },
  { "%+",  CO_Continuation },

  { "Template",  CO_Template },
  { "PageOrigin",  CO_PageOrigin },
  { "PrinterName",  CO_PrinterName },
  { "PrinterRect",  CO_PrinterRect },
  { "Note",  CO_Note },

  { "DocumentNeededResources", CO_DocumentNeededResources },


  { "IncludeFont",  CO_IncludeFont },
  { "BeginBrushPattern", CO_BeginBrushPattern },
  { "EndBrushPattern", CO_EndBrushPattern },
  { "BeginGradient", CO_BeginGradient },
  { "EndGradient", CO_EndGradient },
  { "BeginPalette", CO_BeginPalette },
  { "EndPalette", CO_EndPalette },

  { "IncludeFile", CO_IncludeFile },
  { "IncludeResource", CO_IncludeResource },

  { NULL, CO_Other }
};

AIParserBase::AIParserBase() : m_debug(false), m_ignoring(false), m_sink (DS_Other), m_continuationMode(CM_None)
 {
  m_gstateHandler = NULL;
  m_structureHandler = NULL;
  m_pathHandler = NULL;
  m_miscGStateHandler = NULL;
  m_documentHandler = NULL;
  m_moduleHandler = NULL;
  m_embeddedHandler = NULL;
  m_ai88Handler = new AI88Handler(this);
  m_ai3Handler = new AI3Handler(this);
}

AIParserBase::~AIParserBase(){
  delete m_ai88Handler;
  delete m_ai3Handler;

}

bool AIParserBase::parse (TQIODevice& fin){
  return AILexer::parse (fin);
}

void AIParserBase::gotComment (const char *value) {
  int llx, lly, urx, ury;

  CommentOperation cop = getCommentOperation (value);
  switch (cop) {
    case CO_BeginDocument :
       if (m_moduleHandler) m_moduleHandler->gotBeginSection (ST_Document, value);
       break;
    case CO_EndDocument :
       if (m_moduleHandler) m_moduleHandler->gotBeginSection (ST_Document, value);
       break;
    case CO_BeginPattern :
       if (m_moduleHandler) m_moduleHandler->gotBeginSection (ST_Pattern, value);
       break;
    case CO_EndPattern :
       if (m_moduleHandler) m_moduleHandler->gotBeginSection (ST_Pattern, value);
       break;
    case CO_BeginProlog :
       if (m_moduleHandler) m_moduleHandler->gotBeginSection (ST_Prolog, value);
       break;
    case CO_BeginProcSet :
       if (m_moduleHandler) m_moduleHandler->gotBeginSection (ST_ProcSet, value);
       if (m_debug) tqDebug ("start ignoring");
       m_ignoring = true;
       break;
    case CO_BeginResource :
       if (m_moduleHandler) m_moduleHandler->gotBeginSection (ST_Resource, value);
       if (m_debug) tqDebug ("start ignoring");
       m_ignoring = true;
       break;
    case CO_BeginEncoding :
       if (m_moduleHandler) m_moduleHandler->gotBeginSection (ST_Encoding, value);
       m_ignoring = false;
       break;
    case CO_IncludeFont :
       if (m_debug) tqDebug ("start ignoring");
       m_ignoring = true;
       break;
    case CO_BeginBrushPattern :
       if (m_moduleHandler) m_moduleHandler->gotBeginSection (ST_BrushPattern, value);
       break;
    case CO_BeginGradient :
       if (m_moduleHandler) m_moduleHandler->gotBeginSection (ST_Gradient, value);
       break;
    case CO_Trailer :
       if (m_debug) tqDebug ("start ignoring");
       m_ignoring = true;
       break;
    case CO_BeginPalette :
       if (m_moduleHandler) m_moduleHandler->gotBeginSection (ST_Palette, value);
       break;
    case CO_BeginSetup :
       if (m_moduleHandler) m_moduleHandler->gotBeginSection (ST_Setup, value);
       break;
    case CO_EndSetup :
       cleanupArrays();
       if (m_moduleHandler) m_moduleHandler->gotEndSection (ST_Setup, value);
       break;
    case CO_EndProlog :
       if (m_moduleHandler) m_moduleHandler->gotEndSection (ST_Prolog, value);
       break;
    case CO_EndProcSet :
       if (m_moduleHandler) m_moduleHandler->gotEndSection (ST_ProcSet, value);
       if (m_debug) tqDebug ("stop ignoring");
       m_ignoring = false;
       break;
    case CO_EndResource :
       if (m_moduleHandler) m_moduleHandler->gotEndSection (ST_Resource, value);
       if (m_debug) tqDebug ("stop ignoring");
       m_ignoring = false;
       break;
    case CO_EndEncoding :
       cleanupArrays();
       if (m_moduleHandler) m_moduleHandler->gotEndSection (ST_Encoding, value);
       break;
    case CO_EndBrushPattern :
       cleanupArrays();
       if (m_moduleHandler) m_moduleHandler->gotEndSection (ST_BrushPattern, value);
       break;
    case CO_EndGradient :
       cleanupArrays();
       if (m_moduleHandler) m_moduleHandler->gotEndSection (ST_Gradient, value);
       break;
    case CO_EndPalette :
       cleanupArrays();
       if (m_moduleHandler) m_moduleHandler->gotEndSection (ST_Palette, value);
       break;
    case CO_Ignore :
      break;
    case CO_BoundingBox :
      if (getRectangle (value, llx, lly, urx, ury))
      {
        if (m_documentHandler) m_documentHandler->gotBoundingBox (llx, lly, urx, ury);
      }
      break;
    case CO_TemplateBox :
      if (getRectangle (value, llx, lly, urx, ury))
      {
        if (m_documentHandler) m_documentHandler->gotTemplateBox (llx, lly, urx, ury);
      }
      break;
    case CO_Margin :
      if (getRectangle (value, llx, lly, urx, ury))
      {
        if (m_documentHandler) m_documentHandler->gotMargin (llx, lly, urx, ury);
      }
      break;
    case CO_Title :
      if (m_documentHandler) m_documentHandler->gotTitle (getValue (value));
      break;
    case CO_Creator :
      if (m_documentHandler) m_documentHandler->gotCreator (getValue (value));
      break;
    case CO_DocumentFonts :
      _handleDocumentFonts (value);
      m_continuationMode = CM_DocumentFonts;
      break;
    case CO_DocumentFiles :
      _handleDocumentFiles (value);
      m_continuationMode = CM_DocumentFiles;
      break;
    case CO_DocumentCustomColors :
      _handleDocumentCustomColors (value);
      m_continuationMode = CM_DocumentFiles;
      break;
    case CO_CMYKCustomColor :
      _handleCMYKCustomColor (value);
      m_continuationMode = CM_CMYKCustomColor;
      break;
    case CO_DocumentNeededResources :
      _handleDocumentNeededResources (value);
      m_continuationMode = CM_DocumentNeededResources;
      break;
    case CO_DocumentProcessColors :
      _handleDocumentProcessColors (value);
      break;
    case CO_CreationDate :
      _handleCreationDate (value);
      break;
    case CO_IncludeFile :
      break;
    case CO_IncludeResource :
      _handleIncludeResource (value);
      break;
    case CO_Continuation :
      switch (m_continuationMode) {
        case CM_DocumentFonts : _handleDocumentFonts (value); break;
        case CM_DocumentFiles : _handleDocumentFiles (value); break;
        case CM_DocumentCustomColors : _handleDocumentCustomColors (value); break;
        case CM_CMYKCustomColor :  _handleCMYKCustomColor (value); break;
        case CM_DocumentNeededResources :  _handleDocumentNeededResources (value); break;

        default : tqWarning ("unknown continuation mode %d",m_continuationMode);
      }
      break;

    default :
      tqWarning( "unhandled comment: %s", value );
  }
}

void AIParserBase::handleElement (AIElement &element)
{
  if (m_ignoring) return;

  if (m_sink == DS_Array)
  {
    if (m_debug) tqDebug ("in mode array");
    TQValueVector<AIElement> &elementArray = m_arrayStack.top();
    elementArray.push_back(element);
  }
  if (m_sink == DS_Block)
  {
    if (m_debug) tqDebug ("in mode block");
    TQValueVector<AIElement> &elementArray = m_blockStack.top();
    elementArray.push_back(element);
  }
  else
  {
    if (m_debug) tqDebug ("in mode stack");
    m_stack.push (element);
  }
}

void AIParserBase::gotIntValue (int value) {
  if (m_debug) tqDebug ("got int value");
  if (m_ignoring) return;
  AIElement element (value);
  handleElement (element);
  if (m_debug) tqDebug ("/got int value");
}

void AIParserBase::gotDoubleValue (double value) {
  if (m_debug) tqDebug ("got double value");
  if (m_ignoring) return;
  AIElement element (value);
  handleElement (element);
  if (m_debug) tqDebug ("/got double value");
}

void AIParserBase::gotStringValue (const char *value) {
  if (m_debug) tqDebug ("got string value");
  if (m_ignoring) return;
  if (value == NULL) value = "";
  if (m_debug) tqDebug ("string: %s", value);
  AIElement element (value);
  handleElement (element);
  if (m_debug) tqDebug ("/got string value");

}

void AIParserBase::gotReference (const char *value) {
  if (m_debug) tqDebug ("got reference value");

  if (m_ignoring) return;
  if (value == NULL) value = "";
  if (m_debug) tqDebug ("reference: %s", value);
  TQString string(value);
  AIElement element (string, AIElement::Reference);
  handleElement (element);
  if (m_debug) tqDebug ("/got reference value");

}

void AIParserBase::gotByte (uchar value) {
  if (m_debug) tqDebug ("got byte value");

  if (m_ignoring) return;
  AIElement element (value);
  handleElement (element);
  if (m_debug) tqDebug ("/got byte value");
}

void AIParserBase::gotByteArray (const TQByteArray &data) {
  if (m_ignoring) return;
  AIElement element (data);
  handleElement (element);
}


void AIParserBase::gotArrayStart () {
  if (m_ignoring) return;
  if (m_debug) tqDebug ("got array start");

  TQValueVector<AIElement> array;
  m_arrayStack.push (array);

  m_sink = DS_Array;
}

void AIParserBase::gotBlockStart () {
  if (m_ignoring) return;
  if (m_debug) tqDebug ("got block start");

  TQValueVector<AIElement> array;
  m_blockStack.push (array);

  m_sink = DS_Block;
}

void AIParserBase::gotArrayEnd () {
  if (m_ignoring) return;
  if (m_debug) tqDebug ("got array end");

  TQValueVector<AIElement> stackArray = m_arrayStack.pop();

  if (m_arrayStack.empty())
  {
    if (m_debug) tqDebug ("put elements to stack");
    AIElement realElement (stackArray);

    if (m_debug) {
      tqDebug ("going to stack");
      elementtoa (realElement);
      tqDebug ("done");
    }
    m_stack.push (realElement);

    m_sink = DS_Other;
  }
  else
  {
    if (m_debug) tqDebug ("put elements to nest stack level");
    TQValueVector<AIElement> currentTOS = m_arrayStack.top();
    currentTOS.push_back (stackArray);
  }
}

void AIParserBase::gotBlockEnd () {
  if (m_ignoring) return;
  if (m_debug) tqDebug ("got block end");

  TQValueVector<AIElement> stackArray = m_blockStack.pop();

  if (m_blockStack.empty())
  {
    if (m_debug) tqDebug ("put elements to stack");
    AIElement realElement (stackArray, AIElement::Block);

    if (m_debug) {
      tqDebug ("going to stack");
      elementtoa (realElement);
      tqDebug ("done");
    }
    m_stack.push (realElement);

    m_sink = DS_Other;
  }
  else
  {
    if (m_debug) tqDebug ("put elements to nest stack level");
    TQValueVector<AIElement> currentTOS = m_blockStack.top();
    currentTOS.push_back (stackArray);
  }
}

/*Ai88*/ /* void AIParserBase::_handleSetDash()
{
  double fval = getDoubleValue();

  AIElement elem (m_stack.top());
  m_stack.pop();

  const TQValueVector<AIElement> aval = elem.toElementArray();
  if (m_gstateHandler) m_gstateHandler->gotDash (aval, fval);
} */

/*Ai88*/ /* void AIParserBase::_handleSetFillColorCMYK()
{
  double k = getDoubleValue();
  double y = getDoubleValue();
  double m = getDoubleValue();
  double c = getDoubleValue();

  if (m_debug) tqDebug ("values 1 are %f %f %f %f",c,m,y,k);
  AIColor color (c,m,y,k);

  if (m_gstateHandler) m_gstateHandler->gotFillColor (color);
} */

/*Ai88*/ /* void AIParserBase::_handleSetFillPattern()
{
  AIElement elem (m_stack.top());
  m_stack.pop();

  const TQValueVector<AIElement> aval = elem.toElementArray();

  double ka = getDoubleValue();
  double k = getDoubleValue();
  double r = getDoubleValue();
  double rf = getDoubleValue();
  double angle = getDoubleValue();
  double sy = getDoubleValue();
  double sx = getDoubleValue();
  double py = getDoubleValue();
  double px = getDoubleValue();

  AIElement elem2 (m_stack.top());
  m_stack.pop();

  const TQString &name = elem2.toString();
  if (m_gstateHandler) m_gstateHandler->gotFillPattern (name.latin1(), px, py, sx, sy, angle, rf, r, k, ka, aval);
} */

/*Ai88*/ /* void AIParserBase::_handleSetStrokePattern()
{
  AIElement elem (m_stack.top());
  m_stack.pop();

  const TQValueVector<AIElement> aval = elem.toElementArray();

  double ka = getDoubleValue();
  double k = getDoubleValue();
  double r = getDoubleValue();
  double rf = getDoubleValue();
  double angle = getDoubleValue();
  double sy = getDoubleValue();
  double sx = getDoubleValue();
  double py = getDoubleValue();
  double px = getDoubleValue();

  AIElement elem2 (m_stack.top());
  m_stack.pop();

  const TQString &name = elem2.toString();
  if (m_gstateHandler) m_gstateHandler->gotStrokePattern (name.latin1(), px, py, sx, sy, angle, rf, r, k, ka, aval);
} */

/*Ai88*/ /* void AIParserBase::_handleSetStrokeColorCMYK()
{
  double k = getDoubleValue();
  double y = getDoubleValue();
  double m = getDoubleValue();
  double c = getDoubleValue();
  if (m_debug) tqDebug ("values 2 are %f %f %f %f",c,m,y,k);

  AIColor color (c,m,y,k);

  if (m_gstateHandler) m_gstateHandler->gotStrokeColor (color);
} */

/*Ai88*/ /* void AIParserBase::_handleSetFillColorGray()
{
  double g = getDoubleValue();
  if (m_debug) tqDebug ("values 3 are %f",g);

  AIColor color (g);

  if (m_gstateHandler) m_gstateHandler->gotFillColor (color);
} */

/*Ai88*/ /* void AIParserBase::_handleSetStrokeColorGray()
{
  double g = getDoubleValue();
  if (m_debug) tqDebug ("values 4 are %f",g);

  AIColor color (g);

  if (m_gstateHandler) m_gstateHandler->gotStrokeColor (color);
} */

/*Ai88*/ /* void AIParserBase::_handleSetFillColorCustom()
{
  double g = getDoubleValue();
  const TQString &name = getStringValue();
  double k = getDoubleValue();
  double y = getDoubleValue();
  double m = getDoubleValue();
  double c = getDoubleValue();
  if (m_debug) tqDebug ("values 5 are %f %f %f %f",c,m,y,k);

  AIColor color (c,m,y,k,name.latin1(),g);

  if (m_gstateHandler) m_gstateHandler->gotFillColor (color);
} */

void AIParserBase::_handlePSGet() {
  m_stack.pop();
  m_stack.pop();

  TQString name ("xxx");
  AIElement ref (name,AIElement::Reference);
  m_stack.push (ref);
}

void AIParserBase::_handlePSExec() {
  m_stack.pop();
}

void AIParserBase::_handlePSString() {
  m_stack.pop();

  TQString name ("stringval");
  AIElement ref (name,AIElement::Reference);
  m_stack.push (ref);
}

void AIParserBase::_handlePSBind() {
  m_stack.pop();

  TQString name ("bindentry");
  AIElement ref (name,AIElement::Reference);
  m_stack.push (ref);
}

void AIParserBase::_handlePSUserdict() {
  TQString name ("userdict");
  AIElement ref (name,AIElement::Reference);
  m_stack.push (ref);
}

void AIParserBase::_handlePSDict() {
  m_stack.pop();
  m_stack.pop();
  m_stack.pop();

  TQString name ("dict");
  AIElement ref (name,AIElement::Reference);
  m_stack.push (ref);
}

void AIParserBase::_handlePSDup() {
  AIElement &tos = m_stack.top();

  AIElement copy (tos);
  m_stack.push (copy);
}

void AIParserBase::_handlePSBegin() {
  m_stack.pop();

  TQString name ("dictionary begin");
  AIElement ref (name,AIElement::Reference);
  m_stack.push (ref);
}

void AIParserBase::_handlePSPut() {
  m_stack.pop();
  m_stack.pop();
}

/*Ai88*/ /* void AIParserBase::_handlePatternDefinition()
{
  AIElement elem (m_stack.top());
  m_stack.pop();

  const TQValueVector<AIElement> aval = elem.toElementArray();

  double ury = getDoubleValue();
  double urx = getDoubleValue();
  double lly = getDoubleValue();
  double llx = getDoubleValue();

  AIElement elem2 (m_stack.top());
  m_stack.pop();

  const TQString &name = elem2.toString();

  if (m_documentHandler) m_documentHandler->gotPatternDefinition (name.latin1(), aval, llx, lly, urx, ury);
} */

void AIParserBase::_handlePSDef() {
  // name ref
  m_stack.pop();

  // impl
  m_stack.pop();
}

/*Ai88*/ /* void AIParserBase::_handleSetStrokeColorCustom()
{
  double g = getDoubleValue();
  const TQString &name = getStringValue();
  double k = getDoubleValue();
  double y = getDoubleValue();
  double m = getDoubleValue();
  double c = getDoubleValue();
  if (m_debug) tqDebug ("values 6 are %f %f %f %f",c,m,y,k);

  AIColor color (c,m,y,k,name.latin1(),g);

  if (m_gstateHandler) m_gstateHandler->gotStrokeColor (color);
} */

void AIParserBase::_handleDocumentFonts(const char *) {
}

void AIParserBase::_handleDocumentFiles(const char *) {
}

void AIParserBase::_handleDocumentCustomColors(const char *) {
}

void AIParserBase::_handleDocumentNeededResources(const char *data) {
  if (!data) return;
  TQStringList items = TQStringList::split (' ', data);

  TQString itemType = items[1];
  TQString name = items[2];
  TQString version = items[3];
  TQString release = items[4];
}

void AIParserBase::_handleIncludeResource(const char *data) {
  if (!data) return;
  TQStringList items = TQStringList::split (' ', data);

  TQString itemType = items[1];
  TQString name = items[2];
  TQString version = items[3];
  TQString release = items[4];

  m_modules.push_back (name);
}

void AIParserBase::_handleDocumentProcessColors(const char *data) {
  if (!data) return;

  int colorSet = 0;
  TQString tmp (data);

  signed int index;

  index = tmp.find ("Cyan");
  if (index > 0) colorSet |= PC_Cyan;

  index = tmp.find ("Magenta");
  if (index > 0) colorSet |= PC_Magenta;

  index = tmp.find ("Yellow");
  if (index > 0) colorSet |= PC_Yellow;

  index = tmp.find ("Black");
  if (index > 0) colorSet |= PC_Black;

  if (m_documentHandler) m_documentHandler->gotProcessColors (colorSet);
}

void AIParserBase::_handleCMYKCustomColor(const char *) {
}

/*Ai88*/ /* void AIParserBase::_handleGsaveIncludeDocument() {
  AIElement elem2 (m_stack.top());
  m_stack.pop();

  const TQString &name = elem2.toString();

  int ury = getIntValue();
  int urx = getIntValue();
  int lly = getIntValue();
  int llx = getIntValue();

  AIElement elem (m_stack.top());
  m_stack.pop();

  const TQValueVector<AIElement> aval = elem.toElementArray();

  if (m_embeddedHandler) m_embeddedHandler->gotGsaveIncludeDocument (aval, llx,lly,urx,ury,name.latin1());
} */

/*Ai88*/ /* void AIParserBase::_handleSetCurrentText() {
  int iAlign = getIntValue();
  TextAlign ta = TA_HLeft;

  switch (iAlign)
  {
    case 0 : ta = TA_HLeft; break;
    case 1 : ta = TA_HCenter; break;
    case 2 : ta = TA_HRight; break;
    case 3:  ta = TA_VTop; break;
    case 4 : ta = TA_VCenter; break;
    case 5 : ta = TA_VBottom; break;
  }

  double kerning = getDoubleValue();
  double leading = getDoubleValue();
  double size = getDoubleValue();

  AIElement elem2 (m_stack.top());
  m_stack.pop();

  const TQString &fontname = elem2.toReference();

  if (m_textHandler) m_textHandler->gotFontDefinition (fontname.latin1(), size, leading, kerning, ta);
} */

/*Ai88*/ /* void AIParserBase::_handleTextBlock (TextOperation to) {
  AIElement elem (m_stack.top());
  tqDebug ("to element is (%s)",elem.typeName());
  m_stack.pop();

  const TQValueVector<AIElement> aval = elem.toElementArray();

  if (m_textHandler) m_textHandler->gotTextBlockBegin (aval, to);
} */

/*Ai88*/ /* void AIParserBase::_handleTextOutput () {
  AIElement elem (m_stack.top());
  m_stack.pop();

  const TQString &text = elem.toString();

  int length = -1;

  if (m_stack.empty())
  {
    AIElement elem2 (m_stack.top());
    if (elem2.type() == AIElement::Int)
    {
      length = elem2.asInt();
      m_stack.pop();
    }
  }
  if (m_textHandler) m_textHandler->gotTextOutput (text.latin1(), length);
} */

void AIParserBase::_handleCreationDate (const char *data)
{
  if (!data) return;

  TQRegExp test ("\\((.+)\\) \\((.+)\\)");
  if (test.search (data))
  {
    TQString val1 = test.cap(1);
    TQString val2 = test.cap(2);

   if (m_documentHandler) m_documentHandler->gotCreationDate (val1.latin1(),val2.latin1());
  }
}

void AIParserBase::gotToken (const char *value) {
  if (m_debug) tqDebug ("got token");

  if (m_ignoring) return;
  if (m_debug) tqDebug ("token: %s", value);

  if (m_sink == DS_Array)
  {
    if (m_debug) tqDebug ("token in array");
    TQString op (value);
    AIElement realElement (op, AIElement::Operator);
    handleElement (realElement);

    return;
  }
  if (m_sink == DS_Block)
  {
    if (m_debug) tqDebug ("token in block");
    TQString op (value);
    AIElement realElement (op, AIElement::Operator);
    handleElement (realElement);

    return;
  }

  if (m_debug) tqDebug ("get ai operation");

  AIOperation op = getAIOperation (value);
//  PathElement pathElement;
//  double fval;
//  int ival;

   bool handled = false;

   handled = m_ai88Handler->handleAIOperation (op);
   if (!handled) handled = m_ai3Handler->handleAIOperation (op);

   if (!handled)
   {
      if (m_sink == DS_Other)
      {
        if (handlePS (value)) return;
      }
      tqWarning ( "unknown operator: %s", value );

      TQString string(value);

      if (m_modules.findIndex(string) != -1)
      {
        AIElement element (string, AIElement::Reference);
        handleElement (element);
        return;
      }

      if (m_debug) stacktoa (m_stack);
      tqWarning ( "pushing %s to stack", value );
      AIElement element (string, AIElement::Operator);
      handleElement (element);
  }

  if (m_debug) tqDebug ("/got token value");
}

bool AIParserBase::handlePS (const char *operand){
  if (m_ignoring) return false;

  PSOperation psop = getPSOperation (operand);

  switch (psop)
  {
    case PSO_Get :
      _handlePSGet ();
      return true;
    case PSO_Exec :
      _handlePSExec ();
      return true;
    case PSO_Def :
      _handlePSDef ();
      return true;
    case PSO_String :
      _handlePSString ();
      return true;
    case PSO_Bind :
      _handlePSBind ();
      return true;
    case PSO_Userdict :
      _handlePSUserdict ();
      return true;
    case PSO_Dict :
      _handlePSDict ();
      return true;
    case PSO_Dup :
      _handlePSDup ();
      return true;
    case PSO_Begin :
      _handlePSBegin ();
      return true;
    case PSO_Put :
      _handlePSPut ();
      return true;
    default: break;
  }
  return false;
}

const double AIParserBase::getDoubleValue(void) {
  const AIElement &elem = m_stack.pop();

  return elem.toDouble();
}

const int AIParserBase::getIntValue(void) {
  const AIElement &elem = m_stack.pop();

  return elem.toInt();
}

const bool AIParserBase::getBoolValue(void) {
  return getIntValue() == 1;
}

const TQString AIParserBase::getStringValue(void) {
  const AIElement &elem = m_stack.pop();

  return elem.toString();
}

const TQString AIParserBase::getOperatorValue(void) {
  const AIElement &elem = m_stack.pop();

  return elem.toOperator();
}

AIOperation AIParserBase::getAIOperation (const char *operand)
{
  int i=0;
  TQString cmpValue (operand);

  for(;;) {    AIOperationMapping map = aiMappings[i];
    if (map.op == NULL) return AIO_Other;
    if (cmpValue.compare (map.op) == 0) return map.action;

    i++;
  }
}

PSOperation AIParserBase::getPSOperation (const char *operand)
{
  int i=0;
  TQString cmpValue (operand);

  for(;;) {    PSOperationMapping map = psMappings[i];
    if (map.op == NULL) return PSO_Other;
    if (cmpValue.compare (map.op) == 0) return map.action;

    i++;
  }
}

CommentOperation AIParserBase::getCommentOperation (const char *command) {
  TQString data (command);

  signed int index;

  int i=0;

  for(;;) {
    CommentOperationMapping map = commentMappings[i];
    if (map.op == NULL) return CO_Other;
    index = data.find (map.op);
    if (index >= 0) return map.action;
    i++;
  }
}

void GStateHandlerBase::gotFillPattern (const char *pname, double px, double py, double sx, double sy, double angle, double rf, double r, double k, double ka, const TQValueVector<AIElement>& transformData) {
  tqDebug ( "got fill pattern %s %f %f %f %f %f %f %f %f %f", pname, px, py, sx, sy, angle, rf, r, k, ka);
  arraytoa (transformData);
  tqDebug ("/got fill pattern");
}

void GStateHandlerBase::gotStrokePattern (const char *pname, double px, double py, double sx, double sy, double angle, double rf, double r, double k, double ka, const TQValueVector<AIElement>& transformData) {
  tqDebug ( "got stroke pattern %s %f %f %f %f %f %f %f %f %f", pname, px, py, sx, sy, angle, rf, r, k, ka);
  arraytoa (transformData);
  tqDebug ("/got stroke pattern");
}

const char *AIParserBase::getValue (const char *input) {
  TQString data(input);

  signed int index = data.find (':');
  if (index < 0) return "";
  index++;
  while (data.at(index) == ' ') index++;
  return data.mid(index).latin1();
}

bool AIParserBase::getRectangle (const char* input, int &llx, int &lly, int &urx, int &ury) {
  if (input == NULL) return false;

  TQString s(input);
  if (s.contains ("(atend)")) return false;
  TQStringList values = TQStringList::split (" ", input);
  if (values.size() < 5) return false;
  llx = values[1].toInt();
  lly = values[2].toInt();
  urx = values[3].toInt();
  ury = values[4].toInt();

  return true;
}

bool AIParserBase::getPoint (const char* input, int &x, int &y) {
  if (input == NULL) return false;

  TQString s(input);
  TQStringList values = TQStringList::split (" ", input);

  if (values.size() < 3) return false;

  x = values[1].toInt();
  y = values[2].toInt();

  return true;
}

void AIParserBase::cleanupArrays()
{
  if (m_sink == DS_Array) tqDebug ("unclosed array(s).");
  while (m_sink == DS_Array) gotArrayEnd ();
  stacktoa (m_stack);
}

/*Ai88*/ /* void AIParserBase::_handleFontEncoding()
{
  while (m_stack.top().type() != AIElement::Reference) {
    m_stack.pop();
  }

  AIElement elem (m_stack.top());
  m_stack.pop();
  const TQString &oldFont = elem.toReference();

  AIElement elem2 (m_stack.top());
  m_stack.pop();
  const TQString &newFont = elem2.toReference();

  AIElement elem3 (m_stack.top());
  m_stack.pop();
  const TQValueVector<AIElement> encodingData = elem3.toElementArray();

  if (m_textHandler) m_textHandler->gotFontEncoding (encodingData, oldFont.latin1(), newFont.latin1());
} */

void TextHandlerBase::gotFontEncoding (const TQValueVector<AIElement>& encodingData, const char*oldFontName, const char*newFontName)
{
  tqDebug ("font encoding %s to %s",oldFontName, newFontName);
  arraytoa (encodingData);
  tqDebug ("/font encoding");
}

void TextHandlerBase::gotFontDefinition (const char*fontName, double size, double leading, double kerning, TextAlign align)
{
  tqDebug ("font definition: name %s size %f leading %f kerning %f align %d", fontName, size, leading, kerning, align);
}

void TextHandlerBase::gotTextBlockBegin (const TQValueVector<AIElement>& transData, TextOperation mode)
{
  tqDebug ("text block begin %d",mode);
  arraytoa (transData);
  tqDebug ("/text block begin");
}

void TextHandlerBase::gotTextOutput (const char*text, int length)
{
  tqDebug ("text output (%s) %d",text,length);
}

void TextHandlerBase::gotTextBlockEnd ()
{
  tqDebug ("text block end");
}

const void elementtoa (const AIElement &/*data*/)
{
/*  AIElement::Type type = data.type();
  tqDebug ("type: %s", AIElement::typeToName (type));

  switch (type)
  {
    case AIElement::String :
    case AIElement::CString :
    case AIElement::Int :
    case AIElement::UInt :
    case AIElement::Double :
      tqDebug ("string value : %s",data.toString().latin1());
      break;
    case AIElement::Reference :
      tqDebug ("string value : %s",data.toReference().latin1());
      break;
    case AIElement::Operator :
      tqDebug ("string value : %s",data.toOperator().latin1());
      break;
    case AIElement::ElementArray :
      arraytoa (data.toElementArray());
      break;
    case AIElement::Block :
      arraytoa (data.toBlock());
      break;

    default :
      tqDebug ("could not fetch data");
  } */
}

const void arraytoa (const TQValueVector<AIElement> &/*data*/)
{
/*  tqDebug ("array size is %d ",data.size());
  if (data.size() > 0)
  {
    tqDebug ("[[[[[[[[[[[[[[[[[[[[");
    for (uint i=0; i< data.size(); i++)
    {
      elementtoa (data[i]);
    }
    tqDebug ("]]]]]]]]]]]]]]]]]]]]");
  } */
}

const void stacktoa (const TQValueStack<AIElement> &/*data*/)
{
/*  tqDebug ("stack size is %d",data.size());
  if (data.size() > 0)
  {
    tqDebug ("<<<<<<<<<<<<<<<<<<");
    for (uint i=0; i< data.size(); i++)
    {
      elementtoa (data[i]);
    }
  }
  tqDebug (">>>>>>>>>>>>>>>>>>"); */
}

const void stacktoa2 (const TQValueStack<TQValueVector<AIElement> >&/*data*/)
{
/*  tqDebug ("stack size is %d",data.size());

  if (data.size() > 0)
  {
    tqDebug ("(((((((((((((((((((((((");
    for (uint i=0; i< data.size(); i++)
    {
      arraytoa (data[i]);
    }
    tqDebug (")))))))))))))))))))))))");
  } */
}

const void aiotoa (AIOperation &data)
{
  switch (data)
  {
    case AIO_SetFillColorCMYK : tqDebug ("AIO_SetFillColorCMYK"); break;
    case AIO_SetStrokeColorCMYK : tqDebug ("AIO_SetStrokeColorCMYK"); break;
    case AIO_SetFillColorGray : tqDebug ("AIO_SetFillColorGray"); break;
    case AIO_SetStrokeColorGray : tqDebug ("AIO_SetStrokeColorGray"); break;
    case AIO_SetFillColorCustom : tqDebug ("AIO_SetFillColorCustom"); break;
    case AIO_SetStrokeColorCustom : tqDebug ("AIO_SetStrokeColorCustom"); break;
    case AIO_SetFillPattern : tqDebug ("AIO_SetFillPattern"); break;
    case AIO_SetStrokePattern : tqDebug ("AIO_SetStrokePattern"); break;
    case AIO_SetFillOverprinting : tqDebug ("AIO_SetFillOverprinting"); break;
    case AIO_SetStrokeOverprinting : tqDebug ("AIO_SetStrokeOverprinting"); break;
    case AIO_SetFlatness : tqDebug ("AIO_SetFlatness"); break;
    case AIO_SetLineCap : tqDebug ("AIO_SetLineCap"); break;
    case AIO_SetLineJoin : tqDebug ("AIO_SetLineJoin"); break;
    case AIO_SetLineWidth : tqDebug ("AIO_SetLineWidth"); break;
    case AIO_SetMiterLimit : tqDebug ("AIO_SetMiterLimit"); break;
    case AIO_SetDash : tqDebug ("AIO_SetDash"); break;
    case AIO_BeginGroupClip : tqDebug ("AIO_BeginGroupClip"); break;
    case AIO_EndGroupClip : tqDebug ("AIO_EndGroupClip"); break;
    case AIO_MoveTo : tqDebug ("AIO_MoveTo"); break;
    case AIO_LineToCorner : tqDebug ("AIO_LineToCorner"); break;
    case AIO_LineToSmooth : tqDebug ("AIO_LineToSmooth"); break;
    case AIO_CurveToSmooth : tqDebug ("AIO_CurveToSmooth"); break;
    case AIO_CurveToCorner : tqDebug ("AIO_CurveToCorner"); break;
    case AIO_CurveToOmitC1Smooth : tqDebug ("AIO_CurveToOmitC1Smooth"); break;
    case AIO_CurveToOmitC1Corner : tqDebug ("AIO_CurveToOmitC1Corner"); break;
    case AIO_CurveToOmitC2Smooth : tqDebug ("AIO_CurveToOmitC2Smooth"); break;
    case AIO_CurveToOmitC2Corner : tqDebug ("AIO_CurveToOmitC2Corner"); break;
    case AIO_PathIgnoreNoReset : tqDebug ("AIO_PathIgnoreNoReset"); break;
    case AIO_PathIgnoreNoResetClose : tqDebug ("AIO_PathIgnoreNoResetClose"); break;
    case AIO_PathClipPath : tqDebug ("AIO_PathClipPath"); break;
    case AIO_PathIgnoreReset : tqDebug ("AIO_PathIgnoreReset"); break;
    case AIO_PathIgnoreResetClose : tqDebug ("AIO_PathIgnoreResetClose"); break;
    case AIO_PathFillNonZero : tqDebug ("AIO_PathFillNonZero"); break;
    case AIO_PathFillNonZeroClose : tqDebug ("AIO_PathFillNonZeroClose"); break;
    case AIO_PathStroke : tqDebug ("AIO_PathStroke"); break;
    case AIO_PathStrokeClose : tqDebug ("AIO_PathStrokeClose"); break;
    case AIO_PathFillNoReset : tqDebug ("AIO_PathFillNoReset"); break;
    case AIO_PathFillNoResetClose : tqDebug ("AIO_PathFillNoResetClose"); break;
    case AIO_FontEncoding : tqDebug ("AIO_FontEncoding"); break;
    case AIO_PatternDefinition : tqDebug ("AIO_PatternDefinition"); break;
    case AIO_SetCurrentText : tqDebug ("AIO_SetCurrentText"); break;
    case AIO_TextBlockFillStroke : tqDebug ("AIO_TextBlockFillStroke"); break;
    case AIO_TextBlockFill : tqDebug ("AIO_TextBlockFill"); break;
    case AIO_TextBlockAppend : tqDebug ("AIO_TextBlockAppend"); break;
    case AIO_TextBlockIgnore : tqDebug ("AIO_TextBlockIgnore"); break;
    case AIO_TextBlockStroke : tqDebug ("AIO_TextBlockStroke"); break;
    case AIO_TextOutput : tqDebug ("AIO_TextOutput"); break;
    case AIO_TextBlockEnd : tqDebug ("AIO_TextBlockEnd"); break;
    case AIO_GsaveIncludeDocument : tqDebug ("AIO_GsaveIncludeDocument"); break;
    case AIO_Grestore : tqDebug ("AIO_Grestore"); break;
    case AIO_LockElement : tqDebug ("AIO_LockElement"); break;
    case AIO_SetWindingOrder : tqDebug ("AIO_SetWindingOrder"); break;
    default : tqDebug ("unknown");
  }
}

const void sttoa (SectionType &data, bool begin)
{
  switch (data)
  {
    case ST_Setup : begin ? tqDebug ("start setup") : tqDebug ("end setup"); break;
    case ST_Prolog : begin ? tqDebug ("start prolog") : tqDebug ("end prolog"); break;
    case ST_ProcSet : begin ? tqDebug ("start procset") : tqDebug ("end procset"); break;
    case ST_Encoding : begin ? tqDebug ("start encoding") : tqDebug ("end encoding"); break;
    case ST_Pattern : begin ? tqDebug ("start pattern") : tqDebug ("end pattern"); break;
    case ST_Document : begin ? tqDebug ("start document") : tqDebug ("end document"); break;
    case ST_BrushPattern : begin ? tqDebug ("start brush pattern") : tqDebug ("end brush pattern"); break;
    case ST_Gradient : begin ? tqDebug ("start gradient") : tqDebug ("end gradient"); break;
    case ST_Palette : begin ? tqDebug ("start palette") : tqDebug ("end palette"); break;
    case ST_Resource : begin ? tqDebug ("start resource") : tqDebug ("end resouce"); break;

    default : begin ? tqDebug ("unknown") : tqDebug ("end unknown");
  }
}