/* This file is part of the KDE project Copyright (C) 2002, Dirk Schönberger 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 #include 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 &elementArray = m_arrayStack.top(); elementArray.push_back(element); } if (m_sink == DS_Block) { if (m_debug) tqDebug ("in mode block"); TQValueVector &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 array; m_arrayStack.push (array); m_sink = DS_Array; } void AIParserBase::gotBlockStart () { if (m_ignoring) return; if (m_debug) tqDebug ("got block start"); TQValueVector array; m_blockStack.push (array); m_sink = DS_Block; } void AIParserBase::gotArrayEnd () { if (m_ignoring) return; if (m_debug) tqDebug ("got array end"); TQValueVector 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 currentTOS = m_arrayStack.top(); currentTOS.push_back (stackArray); } } void AIParserBase::gotBlockEnd () { if (m_ignoring) return; if (m_debug) tqDebug ("got block end"); TQValueVector 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 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 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 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 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 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 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 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& 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& 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 encodingData = elem3.toElementArray(); if (m_textHandler) m_textHandler->gotFontEncoding (encodingData, oldFont.latin1(), newFont.latin1()); } */ void TextHandlerBase::gotFontEncoding (const TQValueVector& 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& 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 &/*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 &/*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 >&/*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"); } }