diff options
Diffstat (limited to 'filters/kword/ascii/asciiimport.cpp')
| -rw-r--r-- | filters/kword/ascii/asciiimport.cpp | 1035 |
1 files changed, 1035 insertions, 0 deletions
diff --git a/filters/kword/ascii/asciiimport.cpp b/filters/kword/ascii/asciiimport.cpp new file mode 100644 index 000000000..b7c4c0f5e --- /dev/null +++ b/filters/kword/ascii/asciiimport.cpp @@ -0,0 +1,1035 @@ +/* This file is part of the KDE project + Copyright (C) 1998, 1999 Reginald Stadlbauer <reggie@kde.org> + Copyright (C) 2000 Michael Johnson <mikej@xnet.com> + Copyright (C) 2001, 2002, 2004 Nicolas GOUTTE <goutte@kde.org> + + 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 <config.h> + +#ifdef HAVE_UNISTD_H +#include <unistd.h> +#endif + +#include <tqobject.h> +#include <tqstring.h> +// #include <tqregexp.h> // Currently not needed (due to disabled code) +#include <tqtextcodec.h> +#include <tqfile.h> +#include <tqtextstream.h> +#include <tqdom.h> +#include <tqfontinfo.h> + +#include <kdebug.h> +#include <tdeglobal.h> +#include <kgenericfactory.h> + +#include <KoGlobal.h> +#include <KoPageLayout.h> +#include <KoStore.h> +#include <KoFilterChain.h> +#include <KoFilterManager.h> + +#include <asciiimport.h> +#include <asciiimport.moc> +#include "ImportDialog.h" + +class ASCIIImportFactory : KGenericFactory<ASCIIImport, KoFilter> +{ +public: + ASCIIImportFactory(void) : KGenericFactory<ASCIIImport, KoFilter> ("kwordasciiimport") + {} +protected: + virtual void setupTranslations( void ) + { + TDEGlobal::locale()->insertCatalogue( "kofficefilters" ); + } +}; + +K_EXPORT_COMPONENT_FACTORY( libasciiimport, ASCIIImportFactory() ) + +ASCIIImport::ASCIIImport(KoFilter *, const char *, const TQStringList &) : + KoFilter() { +} + +void ASCIIImport::prepareDocument(TQDomDocument& mainDocument, TQDomElement& mainFramesetElement) +{ + // TODO: other paper formats + KoFormat paperFormat=PG_DIN_A4; // ISO A4 + KoOrientation paperOrientation=PG_PORTRAIT; + + mainDocument.appendChild( + mainDocument.createProcessingInstruction( + "xml","version=\"1.0\" encoding=\"UTF-8\"")); + + TQDomElement elementDoc; + elementDoc=mainDocument.createElement("DOC"); + elementDoc.setAttribute("editor","KWord's Plain Text Import Filter"); + elementDoc.setAttribute("mime","application/x-kword"); + // TODO: We claim to be syntax version 2, but we should verify that it is also true. + elementDoc.setAttribute("syntaxVersion",2); + mainDocument.appendChild(elementDoc); + + TQDomElement element; + element=mainDocument.createElement("ATTRIBUTES"); + element.setAttribute("processing",0); + element.setAttribute("standardpage",1); + element.setAttribute("hasHeader",0); + element.setAttribute("hasFooter",0); + //element.setAttribute("unit","mm"); // use KWord default instead + elementDoc.appendChild(element); + + TQDomElement elementPaper=mainDocument.createElement("PAPER"); + elementPaper.setAttribute("format",paperFormat); + elementPaper.setAttribute("width" ,KoPageFormat::width (paperFormat,paperOrientation) * 72.0 / 25.4); + elementPaper.setAttribute("height",KoPageFormat::height(paperFormat,paperOrientation) * 72.0 / 25.4); + elementPaper.setAttribute("orientation",PG_PORTRAIT); + elementPaper.setAttribute("columns",1); + elementPaper.setAttribute("columnspacing",2); + elementPaper.setAttribute("hType",0); + elementPaper.setAttribute("fType",0); + elementPaper.setAttribute("spHeadBody",9); + elementPaper.setAttribute("spFootBody",9); + elementPaper.setAttribute("zoom",100); + elementDoc.appendChild(elementPaper); + + element=mainDocument.createElement("PAPERBORDERS"); + element.setAttribute("left",28); + element.setAttribute("top",42); + element.setAttribute("right",28); + element.setAttribute("bottom",42); + elementPaper.appendChild(element); + + TQDomElement framesetsPluralElementOut=mainDocument.createElement("FRAMESETS"); + mainDocument.documentElement().appendChild(framesetsPluralElementOut); + + mainFramesetElement=mainDocument.createElement("FRAMESET"); + mainFramesetElement.setAttribute("frameType",1); + mainFramesetElement.setAttribute("frameInfo",0); + mainFramesetElement.setAttribute("autoCreateNewFrame",1); + mainFramesetElement.setAttribute("removable",0); + // TODO: "name" attribute (needs I18N) + framesetsPluralElementOut.appendChild(mainFramesetElement); + + TQDomElement frameElementOut=mainDocument.createElement("FRAME"); + frameElementOut.setAttribute("left",28); + frameElementOut.setAttribute("top",42); + frameElementOut.setAttribute("bottom",566); + frameElementOut.setAttribute("right",798); + frameElementOut.setAttribute("runaround",1); + mainFramesetElement.appendChild(frameElementOut); + + TQDomElement elementStylesPlural=mainDocument.createElement("STYLES"); + elementDoc.appendChild(elementStylesPlural); + + TQDomElement elementStyleStandard=mainDocument.createElement("STYLE"); + elementStylesPlural.appendChild(elementStyleStandard); + + element=mainDocument.createElement("NAME"); + element.setAttribute("value","Standard"); + elementStyleStandard.appendChild(element); + + element=mainDocument.createElement("FOLLOWING"); + element.setAttribute("name","Standard"); + elementStyleStandard.appendChild(element); + + TQDomElement elementFormat=mainDocument.createElement("FORMAT"); + elementStyleStandard.appendChild(elementFormat); + + // Use TQFontInfo, as it does not give back -1 as point size. + TQFontInfo defaultFontInfo(KoGlobal::defaultFont()); + + element=mainDocument.createElement("FONT"); + element.setAttribute("name",defaultFontInfo.family()); + elementFormat.appendChild(element); + + element=mainDocument.createElement("SIZE"); + element.setAttribute("value",defaultFontInfo.pointSize()); + elementFormat.appendChild(element); + + element=mainDocument.createElement("ITALIC"); + element.setAttribute("value",0); + elementFormat.appendChild(element); + + element=mainDocument.createElement("WEIGHT"); + element.setAttribute("value",50); + elementFormat.appendChild(element); + + element=mainDocument.createElement("UNDERLINE"); + element.setAttribute("value",0); + elementFormat.appendChild(element); + + element=mainDocument.createElement("STRIKEOUT"); + element.setAttribute("value",0); + elementFormat.appendChild(element); + + element=mainDocument.createElement("VERTALIGN"); + element.setAttribute("value",0); + elementFormat.appendChild(element); + + element=mainDocument.createElement("COLOR"); + element.setAttribute("red", -1); + element.setAttribute("green",1); + element.setAttribute("blue", -1); + elementFormat.appendChild(element); + + element=mainDocument.createElement("TEXTBACKGROUNDCOLOR"); + element.setAttribute("red", -1); + element.setAttribute("green",-1); + element.setAttribute("blue", -1); + elementFormat.appendChild(element); + +} + +KoFilter::ConversionStatus ASCIIImport::convert( const TQCString& from, const TQCString& to ) +{ + if (to!="application/x-kword" || from!="text/plain") + return KoFilter::NotImplemented; + + AsciiImportDialog* dialog = 0; + if (!m_chain->manager()->getBatchMode()) + { + dialog = new AsciiImportDialog(); + if (!dialog) + { + kdError(30502) << "Dialog has not been created! Aborting!" << endl; + return KoFilter::StupidError; + } + if (!dialog->exec()) + { + kdDebug(30502) << "Dialog was aborted! Aborting filter!" << endl; // this isn't an error! + return KoFilter::UserCancelled; + } + } + + TQTextCodec* codec; + int paragraphStrategy; + if (dialog) + { + codec = dialog->getCodec(); + paragraphStrategy=dialog->getParagraphStrategy(); + delete dialog; + } + else + { + codec = TQTextCodec::codecForName("UTF-8"); + paragraphStrategy=0; + } + + TQFile in(m_chain->inputFile()); + if(!in.open(IO_ReadOnly)) { + kdError(30502) << "Unable to open input file!" << endl; + in.close(); + return KoFilter::FileNotFound; + } + + TQString tbl; // string for table XML + + TQDomDocument mainDocument; + TQDomElement mainFramesetElement; + + prepareDocument(mainDocument,mainFramesetElement); + + TQTextStream stream(&in); + + if (!codec) + { + kdError(30502) << "Could not create TQTextCodec! Aborting" << endl; + in.close(); + return KoFilter::StupidError; + } + + kdDebug(30502) << "Charset used: " << codec->name() << endl; + + stream.setCodec(codec); + + if (1==paragraphStrategy) + sentenceConvert(stream, mainDocument, mainFramesetElement); + else if (999==paragraphStrategy) + oldWayConvert(stream, mainDocument, mainFramesetElement); + else + asIsConvert(stream, mainDocument, mainFramesetElement); + + +#if 0 + kdDebug(30502) << mainDocument.toString() << endl; +#endif + + KoStoreDevice* out=m_chain->storageFile( "root", KoStore::Write ); + if(!out) { + kdError(30502) << "Unable to open output file!" << endl; + in.close(); + return KoFilter::StorageCreationError; + } + TQCString cstr=mainDocument.toCString(); + // WARNING: we cannot use KoStore::write(const TQByteArray&) because it gives an extra NULL character at the end. + out->writeBlock(cstr,cstr.length()); + in.close(); + return KoFilter::OK; +} + +void ASCIIImport::oldWayConvert(TQTextStream& stream, TQDomDocument& mainDocument, + TQDomElement& mainFramesetElement) +{ + kdDebug(30502) << "Entering: ASCIIImport::oldWayConvert" << endl; + TQStringList paragraph; // lines of the paragraph + int linecount = 0; // line counter used to position tables + //int table_no = 0; // used for table identifiers + int numLines; // Number of lines of the paragraph + + bool lastCharWasCr=false; // Was the previous character a Carriage Return? + TQString strLine; + while(!stream.atEnd()) + { + paragraph.clear(); + // Read in paragraph + for(int line_no = numLines = 0; line_no < MAXLINES; line_no++, numLines++) + { + // We need to read a line + // NOTE: we cannot use TQStreamText::readLine, + // as it does not know anything about Carriage Returns + strLine=readLine(stream,lastCharWasCr); + if (strLine.isEmpty()) + { + paragraph.append(TQString()); + break; + } + + const int length = strLine.length(); + if (strLine.at(length-1) == '-') + // replace the hard hyphen - at line end by a soft hyphen + strLine.at(length-1)=TQChar(173); + else + strLine += ' '; // add space to end of line + + paragraph.append(strLine); + } // for(line_no = 0; + + // process tables +#if 0 + if ( Table( &Line[0], &linecount, numLines, table_no, tbl, str)) + table_no++; + else +#else + if (true) +#endif + { + // Process bullet and dash lists +#if 0 + if(ListItem( &Line[0], numLines, str)) + linecount += (numLines + 1); + else + { +#else + if (true) + { +#endif + processParagraph(mainDocument,mainFramesetElement,paragraph); + linecount += ( numLines + 1); // increment the line count + } // else + } // else + } // while(!eof) + +#if 0 + // Add table info + if( table_no > 0) str += tbl; +#endif +} + +void ASCIIImport::asIsConvert(TQTextStream& stream, TQDomDocument& mainDocument, + TQDomElement& mainFramesetElement) +// Paragraph strategy: one line, one paragraph +{ + kdDebug(30502) << "Entering: ASCIIImport::asIsConvert" << endl; + bool lastCharWasCr=false; // Was the previous character a Carriage Return? + TQString strLine; + while(!stream.atEnd()) + { + // Read one line and consider it being a paragraph + strLine=readLine(stream,lastCharWasCr); + writeOutParagraph(mainDocument,mainFramesetElement, "Standard", strLine, + 0, 0); + } +} + +void ASCIIImport::sentenceConvert(TQTextStream& stream, TQDomDocument& mainDocument, + TQDomElement& mainFramesetElement) +// Strategy: +// - end a paragraph when a line ends with a point or similar punctuation. +// - search the punctuation at the end of the line, even if the sentence is quoted or in parentheses. +// - an empty line also ends the paragraph +// TODO/FIXME: we have a little problem with empty lines. Perhaps we should not allow empty paragraphs! +{ + kdDebug(30502) << "Entering: ASCIIImport::sentenceConvert" << endl; + TQStringList paragraph; // lines of the paragraph + bool lastCharWasCr=false; // Was the previous character a Carriage Return? + TQString strLine; + TQString stoppingPunctuation(".!?"); + TQString skippingQuotes("\"')"); + while (!stream.atEnd()) + { + paragraph.clear(); + for(;;) + { + // We need to read a line + // NOTE: we cannot use TQStreamText::readLine, + // as it does not know anything about Carriage Returns + strLine=readLine(stream,lastCharWasCr); + if (strLine.isEmpty()) + { + break; + } + + paragraph.append(strLine); + + uint lastPos=strLine.length()-1; + TQChar lastChar; + // Skip a maximum of 10 quotes (or similar) at the end of the line + for (int i=0;i<10;i++) + { + lastChar=strLine[lastPos]; + if (lastChar.isNull()) + break; + else if (skippingQuotes.find(lastChar)==-1) + break; + else + lastPos--; + } + + lastChar=strLine[lastPos]; + if (lastChar.isNull()) + continue; + else if (stoppingPunctuation.find(lastChar)!=-1) + break; + } +#if 1 + writeOutParagraph(mainDocument,mainFramesetElement, "Standard", + paragraph.join(" ").simplifyWhiteSpace(), 0, 0); +#else + // FIXME/TODO: why is this not working? + //processParagraph(mainDocument,mainFramesetElement,paragraph); +#endif + } // while(!eof) +} + +void ASCIIImport::processParagraph(TQDomDocument& mainDocument, + TQDomElement& mainFramesetElement, const TQStringList& paragraph) +{ + // Paragraph with no tables or lists + TQString text; + TQStringList::ConstIterator it=paragraph.begin(); // Current line (at start, the first one) + TQStringList::ConstIterator previousLine=it; // The previous one (at start, also the first one) + int firstindent=Indent(*it); + + // We work with one line in advance (therefore the two it++) + for( it++; it!=paragraph.end(); it++) + { + text += *previousLine; // add previous line to paragraph + // check for a short line - if short make it a paragraph + if( (*previousLine).length() <= shortline) + { + if((*it).length() > shortline) + // skip if short last line of normal paragraph + { + const int secondindent = Indent(*previousLine); + writeOutParagraph(mainDocument,mainFramesetElement, + "Standard", text.simplifyWhiteSpace(), firstindent, secondindent); + + firstindent = Indent(*it); + text = TQString(); // reinitialize paragraph text + } + } + previousLine=it; + } + // write out paragraph begin to end + const int secondindent = Indent(*previousLine); + writeOutParagraph(mainDocument,mainFramesetElement, + "Standard", text.simplifyWhiteSpace(), firstindent, secondindent); +} + +void ASCIIImport::writeOutParagraph(TQDomDocument& mainDocument, + TQDomElement& mainFramesetElement, const TQString& name, + const TQString& text, const int firstindent, const int secondindent) +{ + TQDomElement paragraphElementOut=mainDocument.createElement("PARAGRAPH"); + mainFramesetElement.appendChild(paragraphElementOut); + TQDomElement textElement=mainDocument.createElement("TEXT"); + paragraphElementOut.appendChild(textElement); + //TQDomElement formatsPluralElementOut=mainDocument.createElement("FORMATS"); + //paragraphElementOut.appendChild(formatsPluralElementOut); + TQDomElement layoutElement=mainDocument.createElement("LAYOUT"); + paragraphElementOut.appendChild(layoutElement); + + TQDomElement element; + element=mainDocument.createElement("NAME"); + element.setAttribute("value",name); + layoutElement.appendChild(element); + + double size; + element=mainDocument.createElement("INDENTS"); + size = firstindent-secondindent; + size *= ptsperchar; // convert indent spaces to points + element.setAttribute("first",TQString::number(size)); + size = secondindent; + size *= ptsperchar; // convert indent spaces to points + element.setAttribute("left",TQString::number(size)); + element.setAttribute("right",0); + + textElement.appendChild(mainDocument.createTextNode(text)); + textElement.normalize(); // Put text together (not sure if needed) + +#if 0 + // If the paragraph is indented, write out indentation elements. + // TODO: why not always write identation? + if (firstindent > 0 || secondindent > 0) \ + WriteOutIndents( firstindent, secondindent, str); + + // If this is a bullet or a dash list, write out a COUNTER element + if(type.isEmpty()) + { + str += "<COUNTER type=\""; + str += type; // "6" = bullet "7" = dash + str += "\" depth=\"0\" start=\"1\" numberingtype=\"0\" lefttext=\"\" righttext=\".\" />\n"; + } + + str += "<FORMAT>\n"; + // for now we try with style (TODO: verify that KWord 1.2 works correctly) + //str += "<FONT name=\"times\"/>\n"; + str += "</FORMAT>\n"; + str += "</LAYOUT>\n"; + str += "</PARAGRAPH>\n"; +#endif +} // WriteOutParagraph + + /* The Indent method determines the equivalent number of spaces + at the beginning of a line */ + +int ASCIIImport::Indent(const TQString& line) const +{ + + TQChar c; // for reading string a character at a time + int count=0; // amount of white space at the begining of the line + + for( uint i = 0; i < line.length(); i++ ) + { + c = line.at(i); + if( c == TQChar(' ')) + count++; + else if( c == TQChar('\t')) + count += spacespertab; + else + break; + } + + return count; + +} // Indent + + /* The WriteOutTableCell method writes out a single table cell + in Kword XML to the output string str. The table is sized according + to the spacing in the ascii document. + Arguments + int table_no - used to keep the group number count + int row - row number + int col - column number + Position *pos - pointer to the table position + TQString str - the output string. + + Returns - void + */ + +#if 0 + void ASCIIImport::WriteOutTableCell( int table_no, int row, + int col, Position *pos, TQString &str) + { + + str += "<FRAMESET frameType=\"1\" frameInfo=\"0\" grpMgr=\"grpmgr_"; + + TQString buf = TQString::number(table_no); // convert int to string + str += buf; + + str += "\" row=\""; + buf = TQString::number(row); // convert row to string + str += buf; + + str += "\" col=\""; + buf = TQString::number(col); // convert col to string + str += buf; + + str += "\" rows=\"1\" cols=\"1\" removable=\"0\" visible=\"1\" name=\"Cell "; + buf = TQString::number(row); // convert row to string + str += buf; + str += ","; + buf = TQString::number(col); // convert col to string + str += buf; + + str += "\">\n"; + + str += "<FRAME left=\""; + buf = TQString::number(pos->left); // convert left coordinate to string + str += buf; + + str += "\" top=\""; + buf = TQString::number(pos->top); // convert top coordinate to string + str += buf; + + str += "\" right=\""; + buf = TQString::number(pos->right); // convert right coordinate to string + str += buf; + + str += "\" bottom=\""; + buf = TQString::number(pos->bottom); // convert bottom coordinate to string + str += buf; + + str += "\" runaround=\"0\" autoCreateNewFrame=\"0\" newFrameBehavior=\"1\" />\n"; + + return; + + } // WriteOutTableCell + + + + +bool ASCIIImport::Table( TQString *Line, int *linecount, int no_lines, + int table_no, TQString &tbl, TQString &str ) +{ + return false; // this method is disabled + + /* This method examines a paragraph for embedded tables. + If none are found, it returns. If tables are found then it + writes out the paragraph including the tables. It does not + check for embedded bullet or dash lists which is a seperate + method. + Arguments + TQString *Line - pointer to the array of text lines in the paragraph. + int *linecount - pointer to the line counter used to position tables + int no_lines - the number of lines in the paragraph + int *table_no - pointer to the table number counter + TQString str - the output string + Returns - enum value indicating wheterer a table was processed. */ + + enum LiType{paragraph, table} linetype[MAXLINES]; + struct Tabs tabs[MAXLINES]; // array of structures for tables + struct Position pos; // struct to pass cell position + int width[MAXCOLUMNS]; // array of column widths + TQString *currentline; // pointer to the current line + TQString *beginline; // pointer to the beginning line + TQString text; // text buffer + TQString text1; // another text buffer + TQString No_indents; // Line with leading white space removed + int index, index1, index2, index3; // used to define column positions in a line + + int no_cols; // column counter + int firstindent; + int secondindent; + int i; // counter + int j; // counter + int k; // counter + TQString *firstline; + firstline = Line; + int begin = 0; // beginning line number + int tabcount = 0; // counts tab characters + + // check all lines for tabs + for(i = 0; i < no_lines; i++) + { + no_cols = 0; // inilialize the number of columns + index = 0; // initialize the line index + + // check the line for leading tabs and indentation + if( (tabs[i].indent = Indent( *Line)) > 0) + { + // save and remove tabs at beginning of the line + text = *Line; // copy + Line->remove(TQRegExp("^[\\ \t]*")); + } + + // find column positions and record text fields + while((index2 = Line->find( TQRegExp("\t"),index)) > index + || (index3 = MultSpaces( *Line, index)) > index ) + { + index1 = kMax(index2, index3); + if( index2 > index3) + index1 = Line->find( TQRegExp("[^\t]"), index1); + tabcount++; + tabs[i].field[no_cols] = Line->mid(index, (index1 - index -1)); + tabs[i].width[no_cols] = index1 - index + spacespertab - 1; + + no_cols++; + index = index1; + } // while( (index1 = ... + + // record last column + if( no_cols > 0) + { + index1 = Line->length() - (index + 1); // +1 for space at line end + tabs[i].field[no_cols] = Line->mid(index,index1); + tabs[i].width[no_cols] = index1; + } + + if(tabs[i].indent > 0) *Line = text; // restore original line + Line++; // increment the line pointer + tabs[i].columns = no_cols; + } // for(i = 0; ... + // All lines of the paragraph have been checked for tabs + + // check for a tab in at least one line + if( tabcount == 0) return false; + tabcount = 0; + + Line = firstline; // reset the line pointer + + for(j = 0; j < MAXCOLUMNS; j++) width[j] = 0; + for( i = 0; i <= no_lines; i++) + { + if(tabs[i].columns == 0 ) // indicates no tabs in line + { + text += *Line; // add line of text to the paragraph + linetype[i] = paragraph; + } + + else // this means a tabulated line + { + linetype[i] = table; + + // calculate the column widths + for(j = 0; j <= tabs[i].columns; j++) + width[j] = kMax(tabs[i].width[j], width[j] ); + } // else + + if(i > 0) + { + if( linetype[i] != linetype[(i - 1)] || i == no_lines) // change of type + { + if( linetype[(begin)] == paragraph ) // write out a paragraph + { + text = ""; // initialize a null string for paragraph text + currentline = firstline; + currentline += begin; //starting line + beginline = currentline; + firstindent = Indent(*currentline); + currentline += 1; // second line + if( (i - begin) > 1) + secondindent = Indent( *currentline ); + else secondindent = 0; + + for( j= begin; j < i; j++) + { + text += *beginline; // form text entry + beginline++; // increment pointer + } + // process the white space to eliminate unwanted spaces + TQString text1 = text.simplifyWhiteSpace(); + WriteOutParagraph( "Standard", "", text1 , firstindent, secondindent, str); + *linecount += (i - begin); + + } // if( linetype[(i - 1)] + + else // this implies a table + { + // Write out a blank line to align text and table + WriteOutParagraph( "Standard", "", "" , 0, 0, str); + for( j = begin; j < i; j++ ) + { + int row = j - begin; + pos.top = (double)((*linecount) + 1) * ptsperline; + pos.bottom = pos.top + ptsperline; + // initialize position of first col + pos.left = leftmargin + (double)tabs[i].indent * ptsperchar; + + // write out a cell for each column + for( k = 0; k <= tabs[j].columns; k++) + { + + text = tabs[j].field[k]; + // process the white space to eliminate unwanted spaces + text1 = text.simplifyWhiteSpace(); + + // calculate position of table cell + pos.right = pos.left + (double)width[k] * ptsperchar; + + WriteOutTableCell( table_no, row, k, &pos, tbl); + WriteOutParagraph( "Standard", "", text1 , 0, 0, tbl); + tbl += "</FRAMESET>\n"; + pos.left += ptsperchar * (double)width[k]; + } // for( k = 0; ... + (*linecount) += 1; + } // for( j = begin; ... + + + } // else... + begin = i; + } // if( linetype[i]... + + } // if(i > 0) + Line++; + } // for( i = 0; ... + + (*linecount) += 1; + + return true; + } // end of Table() +#endif + + // the following method finds the location of multiple spaces in a string +int ASCIIImport::MultSpaces(const TQString& text, const int index) const +{ + + TQChar c; + TQChar lastchar = 'c'; // previous character - initialize non blank + bool found = false; + // kdDebug(30502) << "length = " << text.length() << endl; + for (uint i = index; i < text.length(); i++) + { + c = text.at(i); + // kdDebug(30502) << "i = " << i << " found = " << found << " c = " << c << " lastchar = " << lastchar << endl; + if ( (c != ' ') && found) + return i; + else if (c == ' ' && lastchar == ' ') + found = true; + lastchar = c; + } + return -1; +} // MultSpaces + +#if 0 + bool ASCIIImport::ListItem( TQString *Line, int no_lines, + TQString &str ) + { + + /* This method examines a paragraph for embedded lists. + If none are found, it returns. If lists are found then it + writes out the paragraph including the lists. + Arguments + TQString *Line - pointer to the array of text lines in the paragraph. + int *linecount - pointer to the line counter used to position tables + int no_lines - the number of lines in the paragraph + TQString &str - the output string + Returns - bool value indicating whether a list item was processed. */ + + + TQString *currentline; // pointer to the current line + enum Listtype{none, bullet, dash} listtype[MAXLINES]; + TQString type; // type of list - bullet or dash + TQString *firstline; + int i; // counter + int firstindent; + int secondindent; + int begin = 0; // beginning line number + int listcount = 0; // counts lines with list items + firstline = Line; + + // check all lines for list item indicators - or * + for(i = 0; i < no_lines; i++) + { + listtype[i] = none; // initialize + + // check for a bullet list item + if( IsListItem( *Line, TQChar('*'))) + { + listtype[i] = bullet; + listcount++; + } + // check for a dash list item + if( IsListItem( *Line, TQChar('-'))) + { + listtype[i] = dash; + listcount++; + } + + Line++; // increment the line pointer + } // for(i = 0; ... + // All lines of the paragraph have been checked for list items + + // check for at least one list + if( listcount == 0) return false; + + TQString text = ""; // initialize a null string for paragraph text + Line = firstline; // reset the line pointer + + for( i = 0; i < no_lines; i++) + { + + if(i > 0) + { + if( listtype[i] != none || Line->isEmpty()) // new list item + { + if( listtype[begin] == bullet) // write out a bullet list + { + type = "6"; + // delete * at beginning of line + text.remove( TQRegExp("^[ \t]*\\* ") ); + } + else if( listtype[begin] == dash) // write out a dash list + { + type = "7"; + // delete - at beginning of line + text.remove( TQRegExp("^[ \t]*\\- ") ); + } + else if( listtype[begin] == none) // write out a paragraph + type = ""; + + currentline = firstline; + currentline += begin; //starting line + firstindent = Indent(*currentline); + if( (i - begin) > 1) + { + currentline += 1; // second line + secondindent = Indent( *currentline ); + } + else secondindent = 0; + + // process the white space to eliminate unwanted spaces + TQString text1 = text.simplifyWhiteSpace(); + WriteOutParagraph( "Standard", type, text1 , firstindent, secondindent, str); + + begin = i; + text = ""; // reset text + + + } // if( listtype[i] != none + + + } // if(i > 0) + + text += *Line; // add text to paragraph + Line++; + + } // for( i = 0; ... + + // write out the last paragraph + if( listtype[begin] == bullet) // write out a bullet list + { + type = "6"; + // delete * at beginning of line + text.replace( TQRegExp("^[ \t]*\\* "), ""); + } + else if( listtype[begin] == dash) // write out a dash list + { + type = "7"; + // delete - at beginning of line + text.replace( TQRegExp("^[ \t]*\\- "), ""); + } + else if( listtype[begin] == none) // write out a paragraph + type = ""; + + currentline = firstline; + currentline += begin; //starting line + firstindent = Indent(*currentline); + if( (i - begin) > 1) + { + currentline += 1; // second line + secondindent = Indent( *currentline ); + } + else secondindent = 0; + + // process the white space to eliminate unwanted spaces + TQString text1 = text.simplifyWhiteSpace(); + WriteOutParagraph( "Standard", type, text1 , firstindent, secondindent, str); + + + + return true; + } // end of ListItem() +#endif + +/* The IsListItem method checks a paragraph's first line and determines if + the text appears to be a list item (bullet or dash). + + Arguments + TQString FirstLine the first line of text in a paragraph + TQChar mark the mark - or * that indicates a list item + + Return + true if the line appears as a list item, false if not. */ + +bool ASCIIImport::IsListItem( TQString FirstLine, TQChar mark ) + { + + int i; // counter + TQChar c; // to stream into one character at a time + + + + int k = FirstLine.find(mark); + + if( k < 0) return false; // list item mark not on line + + // find first non white character on the line + for( i=0; IsWhiteSpace( c = FirstLine.at((uint)i) ); i++); + + if(i != k ) return false; // mark is in wrong position + + c = FirstLine.at((uint)++i); + + return IsWhiteSpace(c); // character after the mark must be a white space + + } // IsListItem + + +bool ASCIIImport::IsWhiteSpace(const TQChar& c) const +{ + if ( c == TQChar(' ') || c == TQChar('\t') ) + return true; + else + return false; +} // IsWhiteSpace + +TQString ASCIIImport::readLine(TQTextStream& textstream, bool& lastCharWasCr) +{ + // We need to read a line, character by character + // NOTE: we cannot use TQStreamText::readLine, + // as it does not know anything about Carriage Returns + TQString strLine; + TQChar ch; + while (!textstream.atEnd()) + { + textstream >> ch; // Read one character + if (ch=="\n") + { + if (lastCharWasCr) + { + // We have a line feed following a Carriage Return + // As the Carriage Return has already ended the previous line, + // discard this Line Feed. + lastCharWasCr=false; + } + else + { + // We have a normal Line Feed, therefore we end the line + break; + } + } + else if (ch=="\r") + { + // We have a Carriage Return, therefore we end the line + lastCharWasCr=true; + break; + } + else if (ch==char(12)) // Form Feed + { + // Ignore the form feed + continue; + } + else + { + strLine+=ch; + lastCharWasCr=false; + } + } // while + return strLine; +} |