/* This file is part of the KDE project Copyright (C) 1998, 1999 Reginald Stadlbauer Copyright (C) 2000 Michael Johnson Copyright (C) 2001, 2002, 2004 Nicolas GOUTTE 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 #ifdef HAVE_UNISTD_H #include #endif #include #include // #include // Currently not needed (due to disabled code) #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "ImportDialog.h" class ASCIIImportFactory : KGenericFactory { public: ASCIIImportFactory(void) : KGenericFactory ("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 += "\n"; } str += "\n"; // for now we try with style (TODO: verify that KWord 1.2 works correctly) //str += "\n"; str += "\n"; str += "\n"; str += "\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 += "\n"; str += "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 += "\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; }