Fix buffer ascii export functions.

git-svn-id: svn://svn.lyx.org/lyx/lyx-devel/trunk@3267 a592a061-630c-0410-9148-cb99ea01b6c8

diff --git a/src/ChangeLog b/src/ChangeLog
index 5bacfc57530e495c85fd91d22ec6de6d8ff5dc3a..d211cea8db005d559a6d824ba0f299a276243de3 100644 (file)
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,3 +1,7 @@
+2001-12-27  Juergen Vigna  <jug@sad.it>
+
+       * buffer.C (asciiParagraph): rewrote to hopefully work as expected!
+
 2001-12-26  Jean-Marc Lasgouttes  <Jean-Marc.Lasgouttes@inria.fr>
 
        * tabular_funcs.C: use a "using std::getline" instead of the

diff --git a/src/buffer.C b/src/buffer.C
index acda02ef18a14878a951d80f4d3d94d71655e851..3ba5c4509326fac046d5e88243e4bb6ad7e33a0e 100644 (file)
--- a/src/buffer.C
+++ b/src/buffer.C
@@ -1768,9 +1768,10 @@ bool Buffer::writeFile(string const & fname, bool flag) const
 
 
 string const Buffer::asciiParagraph(Paragraph const * par,
-                                   unsigned int linelen) const
+                                    unsigned int linelen) const
 {
        ostringstream buffer;
+       ostringstream word;
        Paragraph::depth_type depth = 0;
        int ltype = 0;
        Paragraph::depth_type ltype_depth = 0;
@@ -1778,168 +1779,207 @@ string const Buffer::asciiParagraph(Paragraph const * par,
        bool ref_printed = false;
 
        int noparbreak = 0;
-       int islatex = 0;
-       if (!par->previous()) {
-               // begins or ends a deeper area ?
-               if (depth != par->params().depth()) {
-                       if (par->params().depth() > depth) {
-                               while (par->params().depth() > depth) {
-                                       ++depth;
-                               }
-                       } else {
-                               while (par->params().depth() < depth) {
-                                       --depth;
-                               }
+//     if (!par->previous()) {
+#if 0
+       // begins or ends a deeper area ?
+       if (depth != par->params().depth()) {
+               if (par->params().depth() > depth) {
+                       while (par->params().depth() > depth) {
+                               ++depth;
                        }
-               }
-               
-               // First write the layout
-               string const tmp = textclasslist.NameOfLayout(params.textclass, par->layout);
-               if (tmp == "Itemize") {
-                       ltype = 1;
-                       ltype_depth = depth + 1;
-               } else if (tmp == "Enumerate") {
-                       ltype = 2;
-                       ltype_depth = depth + 1;
-               } else if (contains(tmp, "ection")) {
-                       ltype = 3;
-                       ltype_depth = depth + 1;
-               } else if (contains(tmp, "aragraph")) {
-                       ltype = 4;
-                       ltype_depth = depth + 1;
-               } else if (tmp == "Description") {
-                       ltype = 5;
-                       ltype_depth = depth + 1;
-               } else if (tmp == "Abstract") {
-                       ltype = 6;
-                       ltype_depth = 0;
-               } else if (tmp == "Bibliography") {
-                       ltype = 7;
-                       ltype_depth = 0;
                } else {
-                       ltype = 0;
-                       ltype_depth = 0;
+                       while (par->params().depth() < depth) {
+                               --depth;
+                       }
                }
+       }
+#else
+       depth = par->params().depth();
+#endif
                
-               /* maybe some vertical spaces */ 
+       // First write the layout
+       string const tmp = textclasslist.NameOfLayout(params.textclass, par->layout);
+       if (tmp == "Itemize") {
+               ltype = 1;
+               ltype_depth = depth + 1;
+       } else if (tmp == "Enumerate") {
+               ltype = 2;
+               ltype_depth = depth + 1;
+       } else if (contains(tmp, "ection")) {
+               ltype = 3;
+               ltype_depth = depth + 1;
+       } else if (contains(tmp, "aragraph")) {
+               ltype = 4;
+               ltype_depth = depth + 1;
+       } else if (tmp == "Description") {
+               ltype = 5;
+               ltype_depth = depth + 1;
+       } else if (tmp == "Abstract") {
+               ltype = 6;
+               ltype_depth = 0;
+       } else if (tmp == "Bibliography") {
+               ltype = 7;
+               ltype_depth = 0;
+       } else {
+               ltype = 0;
+               ltype_depth = 0;
+       }
                
-               /* the labelwidthstring used in lists */ 
+       /* maybe some vertical spaces */ 
                
-               /* some lines? */ 
+       /* the labelwidthstring used in lists */ 
                
-               /* some pagebreaks? */ 
+       /* some lines? */ 
                
-               /* noindent ? */ 
+       /* some pagebreaks? */ 
                
-               /* what about the alignment */ 
-       } else {
-               lyxerr << "Should this ever happen?" << endl;
-       }
-
-       for (pos_type i = 0; i < par->size(); ++i) {
-               if (!i && !noparbreak) {
+       /* noindent ? */ 
+               
+       /* what about the alignment */ 
+//     } else {
+//             lyxerr << "Should this ever happen?" << endl;
+//     }
+
+       // linelen <= 0 is special and means we don't have pargraph breaks
+       if (!noparbreak) {
+               if (linelen > 0)
+                       buffer << "\n\n";
+               for (Paragraph::depth_type j = 0; j < depth; ++j)
+                       buffer << "  ";
+               currlinelen = depth * 2;
+               //--
+               // we should probably change to the paragraph language in the
+               // gettext here (if possible) so that strings are outputted in
+               // the correct language! (20012712 Jug)
+               //--    
+               switch (ltype) {
+               case 0: // Standard
+               case 4: // (Sub)Paragraph
+               case 5: // Description
+                       break;
+               case 6: // Abstract
                        if (linelen > 0)
-                               buffer << "\n\n";
-                       for (Paragraph::depth_type j = 0; j < depth; ++j)
-                               buffer << "  ";
-                       currlinelen = depth * 2;
-                       switch (ltype) {
-                       case 0: // Standard
-                       case 4: // (Sub)Paragraph
-                       case 5: // Description
-                               break;
-                       case 6: // Abstract
+                               buffer << _("Abstract") << "\n\n";
+                       else
+                               buffer << _("Abstract: ");
+                       break;
+               case 7: // Bibliography
+                       if (!ref_printed) {
                                if (linelen > 0)
-                                       buffer << "Abstract\n\n";
+                                       buffer << _("References") << "\n\n";
                                else
-                                       buffer << "Abstract: ";
-                               break;
-                       case 7: // Bibliography
-                               if (!ref_printed) {
-                                       if (linelen > 0)
-                                               buffer << "References\n\n";
-                                       else
-                                               buffer << "References: ";
-                                       ref_printed = true;
-                               }
-                               break;
-                       default:
-                               buffer << par->params().labelString() << " ";
-                               break;
+                                       buffer << _("References: ");
+                               ref_printed = true;
                        }
-                       if (ltype_depth > depth) {
-                               for (Paragraph::depth_type j = ltype_depth - 1; 
-                                    j > depth; --j)
-                                       buffer << "  ";
-                               currlinelen += (ltype_depth-depth)*2;
+                       break;
+               default:
+                       buffer << par->params().labelString() << " ";
+                       break;
+               }
+       }
+       string s = buffer.str();
+       if (s.rfind('\n') != string::npos) {
+               string dummy;
+               s = rsplit(buffer.str().c_str(), dummy, '\n');
+       }
+       currlinelen = s.length();
+       if (!currlinelen) {
+               for (Paragraph::depth_type j = 0; j < depth; ++j)
+                       buffer << "  ";
+               currlinelen = depth * 2;
+               if (ltype_depth > depth) {
+                       for (Paragraph::depth_type j = ltype_depth;
+                                j > depth; --j)
+                       {
+                               buffer << "  ";
                        }
+                       currlinelen += (ltype_depth-depth)*2;
                }
-               
+       }
+       // this is to change the linebreak to do it by word a bit more intelligent
+       // hopefully! (only in the case where we have a max linelenght!) (Jug)
+       for (pos_type i = 0; i < par->size(); ++i) {
                char c = par->getUChar(params, i);
-               if (islatex)
-                       continue;
                switch (c) {
                case Paragraph::META_INSET:
                {
                        Inset const * inset = par->getInset(i);
                        if (inset) {
-                               if (!inset->ascii(this, buffer)) {
+                               if (linelen > 0)
+                                       buffer << word.str();
+                               if (inset->ascii(this, buffer)) {
+                                       // to be sure it breaks paragraph
+                                       currlinelen += linelen;
+                               }
+#if 0
+                               else {
                                        string dummy;
                                        string const s =
                                                rsplit(buffer.str().c_str(),
                                                       dummy, '\n');
-                                       currlinelen += s.length();
-                               } else {
-                                       // to be sure it breaks paragraph
-                                       currlinelen += linelen;
+                                       currlinelen = s.length();
                                }
+#endif
                        }
                }
                break;
                
                case Paragraph::META_NEWLINE:
                        if (linelen > 0) {
-                               buffer << "\n";
+                               buffer << word.str() << "\n";
+                               word.str("");
                                for (Paragraph::depth_type j = 0; 
                                     j < depth; ++j)
                                        buffer << "  ";
-                       }
-                       currlinelen = depth * 2;
-                       if (ltype_depth > depth) {
-                               for (Paragraph::depth_type j = ltype_depth;
-                                    j > depth; --j)
-                                       buffer << "  ";
-                               currlinelen += (ltype_depth - depth) * 2;
+                               currlinelen = depth * 2;
+                               if (ltype_depth > depth) {
+                                       for (Paragraph::depth_type j = ltype_depth;
+                                                j > depth; --j)
+                                               buffer << "  ";
+                                       currlinelen += (ltype_depth - depth) * 2;
+                               }
                        }
                        break;
                        
-               case Paragraph::META_HFILL: 
-                       buffer << "\t";
+               case Paragraph::META_HFILL:
+                       buffer << word.str() << "\t";
+                       currlinelen += word.str().length() + 1;
+                       word.str("");
                        break;
 
                default:
-                       if ((linelen > 0) && (currlinelen > (linelen - 10)) &&
-                           (c == ' ') && ((i + 2) < par->size()))
-                       {
-                               buffer << "\n";
-                               for (Paragraph::depth_type j = 0; 
-                                    j < depth; ++j)
-                                       buffer << "  ";
-                               currlinelen = depth * 2;
-                               if (ltype_depth > depth) {
-                                       for (Paragraph::depth_type j = ltype_depth;
-                                           j > depth; --j)
+                       if (c == ' ') {
+                               buffer << word.str() << ' ';
+                               currlinelen += word.str().length() + 1;
+                               word.str("");
+                       } else {
+                               if (c != '\0') {
+                                       word << c;
+                               } else {
+                                       lyxerr[Debug::INFO] <<
+                                               "writeAsciiFile: NULL char in structure." << endl;
+                               }
+                               if ((linelen > 0) &&
+                                       (currlinelen+word.str().length()) > linelen)
+                               {
+                                       buffer << "\n";
+                                       for (Paragraph::depth_type j = 0; j < depth; ++j)
                                                buffer << "  ";
-                                       currlinelen += (ltype_depth-depth)*2;
+                                       currlinelen = depth * 2;
+                                       if (ltype_depth > depth) {
+                                               for (Paragraph::depth_type j = ltype_depth;
+                                                        j > depth; --j)
+                                               {
+                                                       buffer << "  ";
+                                               }
+                                               currlinelen += (ltype_depth-depth)*2;
+                                       }
                                }
-                       } else if (c != '\0') {
-                               buffer << c;
-                               ++currlinelen;
-                       } else
-                               lyxerr[Debug::INFO] << "writeAsciiFile: NULL char in structure." << endl;
+                       }
                        break;
                }
        }
+       buffer << word.str();
        return buffer.str().c_str();
 }
 

diff --git a/src/text2.C b/src/text2.C
index e9cca2e3a463784721779308542890fbe4ccf2c5..06fd74d68ddbb947ac5c105b8262ec894ad4c0da 100644 (file)
--- a/src/text2.C
+++ b/src/text2.C
@@ -1013,7 +1013,7 @@ void LyXText::setSelection(BufferView * bview)
 
 
 string const LyXText::selectionAsString(Buffer const * buffer,
-                                       bool label) const
+                                        bool label) const
 {
        if (!selection.set()) return string();
        string result;