home *** CD-ROM | disk | FTP | other *** search
/ Dream 52 / Amiga_Dream_52.iso / Linux / Divers / lyx-0.13.2.tar.gz / lyx-0.13.2.tar / lyx-0.13.2 / src / paragraph.C < prev    next >
C/C++ Source or Header  |  1998-04-23  |  96KB  |  3,752 lines
  1. /* This file is part of
  2. * ======================================================
  3. * 
  4. *           LyX, The Document Processor
  5. *      
  6. *        Copyright (C) 1995 Matthias Ettrich
  7. *           Copyright (C) 1995-1998 The LyX Team. 
  8. *
  9. *======================================================*/
  10.  
  11. #include <config.h>
  12.  
  13. #ifdef __GNUG__
  14. #pragma implementation "lyxparagraph.h"
  15. #endif
  16.  
  17. #include "lyxparagraph.h"
  18. #include "lyxrc.h"
  19. #include "layout.h"
  20. #include "tex-strings.h"
  21. #include "bufferparams.h"
  22. #include "FileInfo.h"
  23. #include "error.h"
  24. #include "LaTeXFeatures.h"
  25. #include "insetinclude.h"
  26. #include "filetools.h"
  27. #include "lyx_gui_misc.h"
  28. #include "texrow.h"
  29.  
  30. //     $Id: paragraph.C,v 1.1.1.1 1998/04/23 16:02:56 larsbj Exp $    
  31.  
  32. #if !defined(lint) && !defined(WITH_WARNINGS)
  33. static char vcid[] = "$Id: paragraph.C,v 1.1.1.1 1998/04/23 16:02:56 larsbj Exp $";
  34. #endif /* lint */
  35.  
  36. #define INITIAL_SIZE_PAR 10 /*Number of bytes in one paragraph*/
  37. #define STEP_SIZE_PAR 10 /*Number of bytes added when reallocated*/
  38.  
  39. extern unsigned char GetCurrentTextClass(); // this should be fixed/removed
  40. int tex_code_break_column;
  41. // this is a bad idea, but how can LyXParagraph find its buffer to get
  42. // parameters? (JMarc)
  43. extern BufferView *current_view;
  44. extern LyXRC *lyxrc;
  45.  
  46.  
  47. // ale970405
  48. extern LString bibitemWidthest();
  49.  
  50. /* this is a minibuffer */
  51. static char minibuffer_char;
  52. static LyXFont minibuffer_font;
  53. static Inset *minibuffer_inset;
  54.  
  55.  
  56. /* the counter for the paragraph id's */ 
  57. static paragraph_id = 0;
  58.  
  59.  
  60. LyXParagraph::LyXParagraph()
  61. {
  62.     size = INITIAL_SIZE_PAR;
  63.     last = 0;
  64.     text = new char[size];
  65.     for (int i=0; i<10; i++) counter[i] = 0;
  66.     enumdepth = 0;
  67.     itemdepth = 0;
  68.     next = NULL;
  69.     previous = NULL;
  70.     fonttable = NULL;
  71.     insettable = NULL;
  72.     footnoteflag = LyXParagraph::NO_FOOTNOTE;
  73.  
  74.     align = LYX_ALIGN_BLOCK;
  75.  
  76.     /* table stuff -- begin*/ 
  77.     table = NULL;
  78.     /* table stuff -- end*/ 
  79.     id = paragraph_id++;
  80.         bibkey = NULL; // ale970302
  81.     Clear();
  82. }
  83.  
  84.  
  85. /* this konstruktor inserts the new paragraph in a list */ 
  86. LyXParagraph::LyXParagraph(LyXParagraph *par)
  87. {
  88.     size = INITIAL_SIZE_PAR;
  89.     last = 0;
  90.     text = new char[size];
  91.     for (int i=0; i<10; i++) counter[i] = 0;
  92.     enumdepth = 0;
  93.     itemdepth = 0;
  94.     next = par->next;
  95.     if (next)
  96.         next->previous = this;
  97.     previous = par;
  98.     previous->next = this;
  99.     fonttable = NULL;
  100.     insettable = NULL;
  101.     footnoteflag = LyXParagraph::NO_FOOTNOTE;
  102.     footnotekind = LyXParagraph::FOOTNOTE;
  103.     
  104.     /* table stuff -- begin*/ 
  105.     table = NULL;
  106.     /* table stuff -- end*/ 
  107.     id = paragraph_id++;
  108.  
  109.         bibkey = NULL; // ale970302        
  110.         // ale970302
  111. //        fprintf(stderr, "new bib "); fflush(stderr);    
  112. //        if (par->bibkey) {
  113. //        bibkey = new InsetBibKey(par->bibkey);
  114. //        }
  115.     
  116.     Clear();
  117. }
  118.  
  119. /// Used by the spellchecker
  120. bool LyXParagraph::IsLetter(int pos){
  121.     unsigned char c = GetChar(pos);
  122.     if (IsLetterChar(c))
  123.         return true;
  124.     // We want to pass the ' and escape chars to ispell
  125.     LString extra = lyxrc->isp_esc_chars + '\'';
  126.     char ch[2];
  127.     ch[0] = c;
  128.     ch[1] = 0;
  129.     return extra.contains(ch);
  130. }
  131.  
  132.  
  133. void LyXParagraph::writeFile(FILE *file, BufferParams ¶ms,
  134.                  char footflag, char dth)
  135. {
  136.     LyXFont font1, font2;
  137.     Inset *inset;
  138.     int column = 0;
  139.     int h = 0;
  140.     char c = 0;
  141.  
  142.     if (footnoteflag != LyXParagraph::NO_FOOTNOTE
  143.         || !previous
  144.         || previous->footnoteflag == LyXParagraph::NO_FOOTNOTE){
  145.         
  146.         /* The beginning or the end of a footnote environment? */ 
  147.         if (footflag != footnoteflag) {
  148.             footflag = footnoteflag;
  149.             if (footflag) {
  150.                 fprintf(file, "\n\\begin_float %s ", 
  151.                     string_footnotekinds[footnotekind]);
  152.             }
  153.             else {
  154.                 fprintf(file, "\n\\end_float ");
  155.             }
  156.         }
  157.  
  158.         /* The beginning or end of a deeper (i.e. nested) area? */
  159.         if (dth != depth) {
  160.             if (depth > dth) {
  161.                 while (depth > dth) {
  162.                     fprintf(file, "\n\\begin_deeper ");
  163.                     dth++;
  164.                 }
  165.             }
  166.             else {
  167.                 while (depth < dth) {
  168.                     fprintf(file, "\n\\end_deeper ");
  169.                     dth--;
  170.                 }
  171.             }
  172.         }
  173.  
  174.         /* First write the layout */ 
  175.         fprintf(file, "\n\\layout %s\n",
  176.             lyxstyle.NameOfLayout(params.textclass,layout).c_str());
  177.  
  178.         /* maybe some vertical spaces */ 
  179.         if (added_space_top.kind() != VSpace::NONE)
  180.             fprintf(file, "\\added_space_top %s ", 
  181.                 added_space_top.asLyXCommand().c_str());
  182.         if (added_space_bottom.kind() != VSpace::NONE)
  183.             fprintf(file, "\\added_space_bottom %s ",
  184.                 added_space_bottom.asLyXCommand().c_str());
  185.             
  186.         /* The labelwidth string used in lists */
  187.         if (!labelwidthstring.empty())
  188.             fprintf(file, "\\labelwidthstring %s\n",
  189.                 labelwidthstring.c_str());
  190.  
  191.         /* Lines above or below? */
  192.         if (line_top)
  193.             fprintf(file, "\\line_top ");
  194.         if (line_bottom)
  195.             fprintf(file, "\\line_bottom ");
  196.  
  197.         /* Pagebreaks above or below? */
  198.         if (pagebreak_top)
  199.             fprintf(file, "\\pagebreak_top ");
  200.         if (pagebreak_bottom)
  201.             fprintf(file, "\\pagebreak_bottom ");
  202.             
  203.         /* Noindent? */
  204.         if (noindent)
  205.             fprintf(file, "\\noindent ");
  206.             
  207.         /* Alignment? */
  208.         if (align != LYX_ALIGN_LAYOUT) {
  209.             switch (align) {
  210.             case LYX_ALIGN_LEFT: h = 1; break;
  211.             case LYX_ALIGN_RIGHT: h = 2; break;
  212.             case LYX_ALIGN_CENTER: h = 3; break;
  213.             default: h = 0; break;
  214.             }
  215.             fprintf(file, "\\align %s ", string_align[h]);
  216.         }
  217.                 if (pextra_type != PEXTRA_NONE) {
  218.                         fprintf(file, "\\pextra_type %d", pextra_type);
  219.                         if (pextra_type == PEXTRA_MINIPAGE) {
  220.                 fprintf(file, " \\pextra_alignment %d",
  221.                     pextra_alignment);
  222.                 if (pextra_hfill)
  223.                     fprintf(file, " \\pextra_hfill %d",
  224.                         pextra_hfill);
  225.                 if (pextra_start_minipage)
  226.                     fprintf(file, " \\pextra_start_minipage %d",
  227.                         pextra_start_minipage);
  228.                         }
  229.                         if (!pextra_width.empty()) {
  230.                 fprintf(file, " \\pextra_width %s",
  231.                                         VSpace(pextra_width).asLyXCommand().c_str());
  232.                         } else if (!pextra_widthp.empty()) {
  233.                 fprintf(file, " \\pextra_widthp %s",pextra_widthp.c_str());
  234.                         }
  235.                         fprintf(file,"\n");
  236.                 }
  237.     }
  238.     else {
  239.            /* Dummy layout. This means that a footnote ended */
  240.         fprintf(file, "\n\\end_float ");
  241.         footflag = LyXParagraph::NO_FOOTNOTE;
  242.     }
  243.         
  244.     /* It might be a table */ 
  245.     if (table){
  246.         fprintf(file, "\\LyXTable\n");
  247.         table->Write(file);
  248.     }
  249.  
  250.     // bibitem  ale970302
  251.     if (bibkey)
  252.         bibkey->Write(file);
  253.  
  254.     font1 = LyXFont(LyXFont::ALL_INHERIT);
  255.  
  256.     column = 0;
  257.     for (int i = 0; i < last; i++) {
  258.         if (!i){
  259.             fprintf(file, "\n");
  260.             column = 0;
  261.         }
  262.  
  263.         // Write font changes
  264.         font2 = GetFontSettings(i);
  265.         if (font2 != font1) {
  266.             font2.lyxWriteChanges(font1, file);
  267.             column = 0;
  268.             font1 = font2;
  269.         }
  270.  
  271.         c = GetChar(i);
  272.         switch (c) {
  273.         case LYX_META_INSET:
  274.             inset = GetInset(i);
  275.             if (inset)
  276.                 if (inset->DirectWrite()) {
  277.                     // international char, let it write
  278.                     // code directly so it's shorter in
  279.                     // the file
  280.                     inset->Write(file);
  281.                 } else {
  282.                     fprintf(file, "\n\\begin_inset ");
  283.                     inset->Write(file);
  284.                     fprintf(file, "\n\\end_inset \n");
  285.                     fprintf(file, "\n");
  286.                     column = 0;
  287.                 }
  288.             break;
  289.         case LYX_META_NEWLINE: 
  290.             fprintf(file, "\n\\newline \n");
  291.             column = 0;
  292.             break;
  293.         case LYX_META_HFILL: 
  294.             fprintf(file, "\n\\hfill \n");
  295.             column = 0;
  296.             break;
  297.         case LYX_META_PROTECTED_SEPARATOR: 
  298.             fprintf(file, "\n\\protected_separator \n");
  299.             column = 0;
  300.             break;
  301.         case '\\': 
  302.             fprintf(file, "\n\\backslash \n");
  303.             column = 0;
  304.             break;
  305.         case '.':
  306.             if (i + 1 < last && GetChar(i + 1) == ' ') {
  307.                 fprintf(file, ".\n");
  308.                 column = 0;
  309.             } else
  310.                 fprintf(file, ".");
  311.             break;
  312.         default:
  313.             if ((column > 70 && c==' ')
  314.                 || column > 79){
  315.                 fprintf(file, "\n");
  316.                 column = 0;
  317.             }
  318.             // this check is to amend a bug. LyX sometimes
  319.             // inserts '\0' this could cause problems.
  320.             if (c != '\0')
  321.                 fprintf(file, "%c", c);
  322.             else
  323.                 lyxerr.print("ERROR (LyXParagraph::writeFile):"
  324.                          " NULL char in structure.");
  325.             column++;
  326.             break;
  327.         }
  328.     }
  329.  
  330.     // now write the next paragraph
  331.     if (next)
  332.         next->writeFile(file, params, footflag, dth);
  333. }
  334.  
  335.  
  336. void LyXParagraph::validate(LaTeXFeatures &features)
  337. {
  338.     // this will be useful later
  339.     LyXLayout *layout = lyxstyle.Style(GetCurrentTextClass(), 
  340.                        GetLayout());
  341.     
  342.     // check the params.
  343.     if (line_top || line_bottom)
  344.         features.lyxline = true;
  345.     
  346.     // then the layouts
  347.     features.layout[GetLayout()] = true;
  348.  
  349.     // then the fonts
  350.     FontTable *tmpfonttable = fonttable;
  351.     while (tmpfonttable) {
  352.         if (tmpfonttable->font.noun() == LyXFont::ON) {
  353.             lyxerr.debug(LString("font.noun: ") 
  354.                      + int(tmpfonttable->font.noun()),
  355.                      Error::LATEX);
  356.             features.noun = true;
  357.             lyxerr.debug("Noun enabled. Font: "
  358.                      +tmpfonttable->font.stateText(),
  359.                      Error::LATEX);
  360.         }
  361.         switch (tmpfonttable->font.color()) {
  362.         case LyXFont::NONE: 
  363.         case LyXFont::INHERIT_COLOR:
  364.         case LyXFont::IGNORE_COLOR:
  365.             break;
  366.         default:
  367.             features.color = true;
  368.             lyxerr.debug("Color enabled. Font: "
  369.                      +tmpfonttable->font.stateText(),
  370.                      Error::LATEX);
  371.         }
  372.         tmpfonttable = tmpfonttable->next;
  373.     }
  374.     
  375.     // then the insets
  376.     InsetTable *tmpinsettable = insettable;
  377.     while (tmpinsettable) {
  378.         if (tmpinsettable->inset) {
  379.             tmpinsettable->inset->Validate(features);
  380.         }
  381.         tmpinsettable = tmpinsettable->next;
  382.     }
  383.         if (table && table->IsLongTable())
  384.         features.longtable = true;
  385.         if (pextra_type == PEXTRA_INDENT)
  386.                 features.LyXParagraphIndent = true;
  387.         if (pextra_type == PEXTRA_FLOATFLT)
  388.                 features.floatflt = true;
  389.         if (layout->needprotect 
  390.         && next && next->footnoteflag != LyXParagraph::NO_FOOTNOTE)
  391.         features.NeedLyXFootnoteCode = true;
  392.         if ((current_view->currentBuffer()->params.paragraph_separation == LYX_PARSEP_INDENT) &&
  393.             (pextra_type == PEXTRA_MINIPAGE))
  394.         features.NeedLyXMinipageIndent = true;
  395.         if (table && table->NeedRotating())
  396.         features.rotating = true;
  397. }
  398.  
  399.  
  400. /* first few functions needed for cut and paste and paragraph breaking */
  401. void LyXParagraph::CopyIntoMinibuffer(int pos)
  402. {
  403.     minibuffer_char = GetChar(pos);
  404.     minibuffer_font = GetFontSettings(pos);
  405.     if (minibuffer_char == LYX_META_INSET) {
  406.         if (GetInset(pos)) {
  407.             minibuffer_inset = GetInset(pos)->Clone();
  408.         } else {
  409.             minibuffer_inset = NULL;
  410.             minibuffer_char = ' ';
  411.             // This reflects what GetInset() does (ARRae)
  412.         }
  413.     }
  414. }
  415.  
  416.  
  417. void LyXParagraph::CutIntoMinibuffer(int pos)
  418. {
  419.     minibuffer_char = GetChar(pos);
  420.     minibuffer_font = GetFontSettings(pos);
  421.     if (minibuffer_char == LYX_META_INSET) {
  422.         if (GetInset(pos)) {
  423.             minibuffer_inset = GetInset(pos);
  424.         } else {
  425.             minibuffer_inset = NULL;
  426.             minibuffer_char = ' ';
  427.             // This reflects what GetInset() does (ARRae)
  428.         }
  429.  
  430.         /* this is a little hack since I want exactly the inset,
  431.            not just a clone. Otherwise the inset would be deleted
  432.            when calling Erase(pos) */
  433.         /* and it's only useful inside the if{} above 
  434.            since the else{} means its not there (ARRae) */
  435.  
  436.         /* find the entry */ 
  437.         InsetTable *tmpi = insettable;
  438.         while (tmpi && tmpi->pos != pos) {
  439.             tmpi=tmpi->next;
  440.         }
  441.         if (tmpi) {               /* this should always be true */
  442.             tmpi->inset = NULL;
  443.         }
  444.     }
  445.  
  446.     /* Erase(pos); now the caller is responsible for that*/
  447. }
  448.  
  449.  
  450. void LyXParagraph::InsertFromMinibuffer(int pos)
  451. {
  452.     InsertChar(pos, minibuffer_char);
  453.     SetFont(pos, minibuffer_font);
  454.     if (minibuffer_char == LYX_META_INSET)
  455.         InsertInset(pos, minibuffer_inset);
  456. }
  457.  
  458. /* end of minibuffer */ 
  459.  
  460.  
  461.  
  462. void LyXParagraph::Clear()
  463. {
  464.     line_top = false;
  465.     line_bottom = false;
  466.    
  467.     pagebreak_top = false;
  468.     pagebreak_bottom = false;
  469.  
  470.     added_space_top = VSpace::NONE;
  471.     added_space_bottom = VSpace::NONE;
  472.  
  473.     align = LYX_ALIGN_LAYOUT;
  474.     depth = 0;
  475.     noindent = false;
  476.  
  477.         pextra_type = PEXTRA_NONE;
  478.         pextra_width.erase();
  479.         pextra_widthp.erase();
  480.         pextra_alignment = MINIPAGE_ALIGN_TOP;
  481.         pextra_hfill = false;
  482.         pextra_start_minipage = false;
  483.  
  484.         labelstring.erase();
  485.     labelwidthstring.erase();
  486.     layout = 0;
  487. }
  488.  
  489.  
  490. /* the destructor removes the new paragraph from the list */ 
  491. LyXParagraph::~LyXParagraph()
  492. {
  493.     if (previous)
  494.         previous->next = next;
  495.     if (next)
  496.         next->previous = previous;
  497.  
  498.     if (text)
  499.         delete[] text;
  500.    
  501.     InsetTable *tmpinset;
  502.     while (insettable) {
  503.         tmpinset = insettable;
  504.         insettable = insettable->next;
  505.         if (tmpinset->inset)
  506.             delete tmpinset->inset;
  507.         delete tmpinset;
  508.         if (insettable && insettable->next == insettable) {
  509.             // somehow this recursion appears occasionally
  510.             // but I can't find where.  This bandaid
  511.             // helps but isn't the best fix. (ARRae)
  512.             if (insettable->inset) {
  513.                 delete insettable->inset;
  514.             }
  515.             delete insettable;
  516.             break;
  517.         }
  518.     }
  519.  
  520.     FontTable *tmpfont;
  521.     while (fonttable) {
  522.         tmpfont = fonttable;
  523.         fonttable = fonttable->next;
  524.         delete tmpfont;
  525.     }
  526.  
  527.     /* table stuff -- begin*/ 
  528.     if (table)
  529.         delete table;
  530.     /* table stuff -- end*/ 
  531.  
  532.         // ale970302
  533.     if (bibkey)
  534.             delete bibkey;
  535. }
  536.  
  537.  
  538. void LyXParagraph::Erase(int pos)
  539. {
  540.     int i;
  541.  
  542.     /* > because last is the next unused position, and you can 
  543.      * use it if you want  */
  544.     if (pos > last) {
  545.         if (next && next->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) 
  546.             NextAfterFootnote()->Erase(pos - last - 1);
  547.         else 
  548.             lyxerr.print("ERROR (LyXParagraph::Erase): position does not exist.");
  549.         return;
  550.     }
  551.     if (pos < last) { // last is free for insertation, but should be empty
  552.       
  553.         /* if it is an inset, delete the inset entry */ 
  554.         if (text[pos] == LYX_META_INSET) {
  555.             /* find the entry */ 
  556.             InsetTable *tmpi = insettable;
  557.             InsetTable *tmpi2 = tmpi;
  558.             while (tmpi && tmpi->pos != pos) {
  559.                 tmpi2=tmpi;
  560.                 tmpi=tmpi->next;
  561.             }
  562.             if (tmpi) {    // this should always be true
  563.                 if (tmpi->inset) // delete the inset if it exists
  564.                     delete tmpi->inset;
  565.                 if (tmpi == insettable)
  566.                     insettable = tmpi->next;
  567.                 else 
  568.                     tmpi2->next = tmpi->next;
  569.                 delete tmpi;
  570.             }
  571.         }
  572.  
  573.         // Shift rest of text      
  574.         for (i = pos; i < last - 1; i++) {
  575.             text[i]=text[i+1];
  576.         }
  577.         last--;
  578.  
  579.         /* erase entries in the tables */ 
  580.         int found = 0;
  581.         FontTable *tmp = fonttable;
  582.         FontTable *prev = NULL;
  583.         while (tmp && !found) {
  584.             if (pos >= tmp->pos && pos <= tmp->pos_end)
  585.                 found = 1;
  586.             else {
  587.                 prev = tmp;
  588.                 tmp = tmp->next;
  589.             }
  590.         }
  591.       
  592.         if (found && tmp->pos == tmp->pos_end) {  
  593.             /* if it is a multi-character font entry, we just make 
  594.              * it smaller (see update below), otherwise we should 
  595.              * delete it */
  596.             if (prev)
  597.                 prev->next = tmp->next;
  598.             else
  599.                 fonttable = tmp->next;
  600.      
  601.             delete tmp;
  602.         }
  603.  
  604.         /* update all other entries */
  605.  
  606.         tmp = fonttable;
  607.         while (tmp) {
  608.             if (tmp->pos > pos)
  609.                 tmp->pos--;
  610.             if (tmp->pos_end >= pos)
  611.                 tmp->pos_end--;
  612.             tmp = tmp->next;
  613.         }
  614.       
  615.         /* update the inset table */ 
  616.         InsetTable *tmpi = insettable;
  617.         while (tmpi) {
  618.             if (tmpi->pos > pos)
  619.                 tmpi->pos--;
  620.             tmpi=tmpi->next;
  621.         }
  622.       
  623.     } else {
  624.         lyxerr.print("ERROR (LyXParagraph::Erase): can't erase non-existant char.");
  625.     }
  626. }
  627.  
  628.  
  629. /* pos is needed to specify the paragraph correctly. Remember the
  630. * closed footnotes */ 
  631. void LyXParagraph::Enlarge(int pos, int number)
  632. {
  633.     int i;
  634.  
  635.     /* > because last is the next unused position, and you can 
  636.      * use it if you want  */
  637.     if (pos > last) {
  638.         if (next && next->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) 
  639.             NextAfterFootnote()->Enlarge(pos - last - 1, number);
  640.         else 
  641.             lyxerr.print("ERROR (LyXParagraph::Enlarge): position does not exist.");
  642.         return;
  643.     }
  644.  
  645.     if (size - last < number) {
  646.         size += number - size + last + STEP_SIZE_PAR;
  647.         char *tmp = new char[size];
  648.         for (i = 0; i < last; i++)
  649.             tmp[i] = text[i];
  650.         delete[] text;
  651.         text = tmp;
  652.     }
  653. }
  654.  
  655.  
  656. /* make the allocated memory fit to the needed size */
  657. /* used to make a paragraph smaller */
  658. void LyXParagraph::FitSize()
  659. {
  660.     int i;
  661.   
  662.     if (size - last > STEP_SIZE_PAR) {
  663.         size = last + STEP_SIZE_PAR;
  664.         char *tmp = new char[size];
  665.         for (i = 0; i < last; i++)
  666.             tmp[i] = text[i];
  667.         delete[] text;
  668.         text = tmp;
  669.     }
  670. }
  671.  
  672.  
  673. void LyXParagraph::InsertChar(int pos, char c)
  674. {
  675.     register int i;
  676.    
  677.     /* > because last is the next unused position, and you can 
  678.      * use it if you want  */
  679.     if (pos > last) {
  680.         if (next && next->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) 
  681.             NextAfterFootnote()->InsertChar(pos - last - 1, c);
  682.         else 
  683.             lyxerr.debug("ERROR (LyXParagraph::InsertChar): "
  684.                      "position does not exist.");
  685.         return;
  686.     }
  687.  
  688.     // Are we full? If so, enlarge.
  689.     if (last == size) {
  690.         size += STEP_SIZE_PAR;
  691.         char *tmp = new char[size];
  692.         for (i = 0; i < last; i++)
  693.             tmp[i] = text[i];
  694.         delete[] text;
  695.         text = tmp;
  696.     }
  697.  
  698.     // Shift rest of character
  699.     for (i = last; i>pos; i--) {
  700.         text[i]=text[i-1];
  701.     }
  702.  
  703.     text[pos]=c;
  704.     last++;
  705.    
  706.     /* update the font table */ 
  707.     FontTable *tmp = fonttable;
  708.     while (tmp) {
  709.         if (tmp->pos >= pos)
  710.             tmp->pos++;
  711.         if (tmp->pos_end >= pos)
  712.             tmp->pos_end++;
  713.         tmp = tmp->next;
  714.     }
  715.    
  716.     /* update the inset table */ 
  717.     InsetTable *tmpi = insettable;
  718.     while (tmpi) {
  719.         if (tmpi->pos >= pos)
  720.             tmpi->pos++;
  721.         tmpi=tmpi->next;
  722.     }
  723. }
  724.  
  725.  
  726. void LyXParagraph::InsertInset(int pos, Inset *inset)
  727. {
  728.     /* > because last is the next unused position, and you can 
  729.      * use it if you want  */
  730.     if (pos > last) {
  731.         if (next && next->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) 
  732.             NextAfterFootnote()->InsertInset(pos - last - 1, inset);
  733.         else 
  734.             lyxerr.print("ERROR (LyXParagraph::InsertInset): " 
  735.                      "position does not exist: " + pos);
  736.         return;
  737.     }
  738.  
  739.     if (text[pos]!=LYX_META_INSET) {
  740.         lyxerr.print("ERROR (LyXParagraph::InsertInset): "
  741.                  "there is no LYX_META_INSET");
  742.         return;
  743.     }
  744.  
  745.     if (inset) {
  746.         /* add a new entry in the inset table */ 
  747.         InsetTable *tmpi = new InsetTable;
  748.         tmpi->pos = pos;
  749.         tmpi->inset = inset;
  750.         tmpi->next = insettable;
  751.         insettable = tmpi;
  752.     }
  753. }
  754.  
  755.  
  756. Inset* LyXParagraph::GetInset(int pos)
  757. {
  758.     if (pos >= last) {
  759.         if (next && next->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) 
  760.             return NextAfterFootnote()->GetInset(pos - last - 1);
  761.         else { 
  762.                 lyxerr.print(LString("ERROR (LyXParagraph::GetInset): position does not exist: ") + pos);
  763.         }
  764.         return NULL;
  765.     }
  766.  
  767.     /* find the inset */ 
  768.     InsetTable *tmpi = insettable;
  769.  
  770.     while (tmpi && tmpi->pos != pos)
  771.         tmpi = tmpi->next;
  772.  
  773.     if (tmpi)
  774.         return tmpi->inset;
  775.     else {
  776.         lyxerr.print(LString("ERROR (LyXParagraph::GetInset): "
  777.                      "Inset does not exist: ") + pos);
  778.         text[pos] = ' '; /// WHY!!! does this set the pos to ' '????
  779.         // Did this commenting out introduce a bug? So far I have not
  780.         // seen any, please enlighten me. (Lgb)
  781.         // My guess is that since the inset does not exist, we might
  782.         // as well replace it with a space to prevent crashes. (Asger)
  783.         return NULL;
  784.     }
  785. }
  786.  
  787.  
  788. // Gets uninstantiated font setting at position.
  789. // Optimized after profiling. (Asger)
  790. LyXFont LyXParagraph::GetFontSettings(int pos)
  791. {
  792.     if (pos < last) {
  793.         FontTable *tmp = fonttable;
  794.         while (tmp) {
  795.             if (pos >= tmp->pos && pos <= tmp->pos_end) 
  796.                 return tmp->font;
  797.             tmp = tmp->next;
  798.         }
  799.     }
  800.  
  801.     /* > because last is the next unused position, and you can 
  802.      * use it if you want  */
  803.     else if (pos > last) {
  804.         if (next && next->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) 
  805.             return NextAfterFootnote()->GetFontSettings(pos - last - 1);
  806.         else {
  807.             // Why is it an error to ask for the font of a
  808.             // position that does not exist? Would it be
  809.             // enough for this to be anable on debug?
  810.             // We want strict error checking, but it's ok to only
  811.             // have it when debugging. (Asger)
  812.             lyxerr.print(
  813.                 LString("ERROR (LyXParagraph::GetFontSettings): "
  814.                     "position does not exist. ") + pos);
  815.         }
  816.     } else if (pos) {
  817.         return GetFontSettings(pos - 1);
  818.     }
  819.     return LyXFont(LyXFont::ALL_INHERIT);
  820. }
  821.  
  822.  
  823. // Gets the fully instantiated font at a given position in a paragraph
  824. // This is basically the same function as LyXText::GetFont() in text2.C.
  825. // The difference is that this one is used for generating the LaTeX file,
  826. // and thus cosmetic "improvements" are disallowed: This has to deliver
  827. // the true picture of the buffer. (Asger)
  828. // If position is -1, we get the layout font of the paragraph.
  829. // If position is -2, we get the font of the manual label of the paragraph.
  830. LyXFont LyXParagraph::getFont(int pos)
  831. {
  832.     LyXFont tmpfont;
  833.     LyXLayout *layout = lyxstyle.Style(GetCurrentTextClass(), 
  834.                        GetLayout());
  835.    
  836.     int main_body=0;
  837.     if (layout->labeltype == LABEL_MANUAL)
  838.         main_body = BeginningOfMainBody();
  839.  
  840.     if (pos >= 0){
  841.         LyXFont layoutfont;
  842.         if (pos < main_body)
  843.             layoutfont = layout->labelfont;
  844.         else
  845.             layoutfont = layout->font;
  846.         tmpfont = GetFontSettings(pos);
  847.         tmpfont.realize(layoutfont);
  848.     } else {
  849.         // process layoutfont for pos == -1 and labelfont for pos < -1
  850.         if (pos == -1)
  851.             tmpfont = layout->font;
  852.         else
  853.             tmpfont = layout->labelfont;
  854.     }
  855.  
  856.     // check for environment font information
  857.     char par_depth = GetDepth();
  858.     LyXParagraph * par = this;
  859.     while (par && par_depth && !tmpfont.resolved()) {
  860.         par = par->DepthHook(par_depth - 1);
  861.         if (par) {
  862.             tmpfont.realize(lyxstyle.
  863.                     Style(GetCurrentTextClass(),
  864.                           par->GetLayout())->font);
  865.             par_depth = par->GetDepth();
  866.         }
  867.     }
  868.  
  869.     tmpfont.realize(lyxstyle.TextClass(GetCurrentTextClass())->defaultfont);
  870.     return tmpfont;
  871. }
  872.  
  873.  
  874. /// Returns the height of the highest font in range
  875. LyXFont::FONT_SIZE LyXParagraph::HighestFontInRange(int startpos, int endpos) const
  876. {
  877.     LyXFont::FONT_SIZE maxsize = LyXFont::SIZE_TINY;
  878.  
  879.     FontTable *tmp = fonttable;
  880.     while (tmp) {
  881.         if (startpos <= tmp->pos_end && endpos >= tmp->pos) {
  882.             LyXFont::FONT_SIZE size = tmp->font.size();
  883.             if (size > maxsize && size<=LyXFont::SIZE_HUGER)
  884.                 maxsize = size;
  885.         }
  886.         tmp = tmp->next;
  887.     }
  888.     return maxsize;
  889. }
  890.  
  891.  
  892. char LyXParagraph::GetChar(int pos)
  893. {
  894. #ifdef DEVEL_VERSION
  895.     /* a workaround to 'fix' some bugs in text-class */
  896.     if (pos < 0) {
  897.         // This function is important. It should not work around bugs.
  898.         // Let's find the bugs instead and fix them. (Asger)
  899.         lyxerr.print(LString("FATAL ERROR (LyXParagraph::GetChar):"
  900.                      " bad position ") + pos);
  901.         abort();
  902.     }
  903. #endif
  904.  
  905.     if (pos < last) {
  906.         return text[pos];
  907.     }
  908.  
  909.     /* > because last is the next unused position, and you can 
  910.      * use it if you want  */
  911.     else if (pos > last) {
  912.         if (next && next->footnoteflag != LyXParagraph::NO_FOOTNOTE) 
  913.             return NextAfterFootnote()->GetChar(pos - last - 1);
  914.         else 
  915.             lyxerr.print("ERROR (LyXParagraph::GetChar): "
  916.                      "position does not exist.");
  917.         return 'F';
  918.     } else { // pos==last
  919.         /* we should have a footnote environment */ 
  920.         if (!next || next->footnoteflag == LyXParagraph::NO_FOOTNOTE) {
  921. // Notice that LyX does request the last char from time to time. (Asger)
  922. //            lyxerr.print("ERROR (LyXParagraph::GetChar): "
  923. //                      "expected footnote.");
  924.             return 'F';
  925.         }
  926.         switch (next->footnotekind) {
  927.         case LyXParagraph::FOOTNOTE:
  928.             return LYX_META_FOOTNOTE;
  929.         case LyXParagraph::MARGIN:
  930.             return LYX_META_MARGIN;
  931.         case LyXParagraph::FIG:
  932.         case LyXParagraph::WIDE_FIG:
  933.             return LYX_META_FIG;
  934.         case LyXParagraph::TAB:
  935.         case LyXParagraph::WIDE_TAB:
  936.             return LYX_META_TAB;
  937.         case LyXParagraph::ALGORITHM:
  938.             return LYX_META_ALGORITHM;
  939.         }
  940. //         if (next->footnotekind == LyXParagraph::FOOTNOTE)
  941. //             return LYX_META_FOOTNOTE;
  942. //         if (next->footnotekind == LyXParagraph::MARGIN)
  943. //             return LYX_META_MARGIN;
  944. //         if (next->footnotekind == LyXParagraph::FIG)
  945. //             return LYX_META_FIG;
  946. //         if (next->footnotekind == LyXParagraph::TAB)
  947. //             return LYX_META_TAB;
  948. //         if (next->footnotekind == LyXParagraph::ALGORITHM)
  949. //             return LYX_META_ALGORITHM;
  950. //         lyxerr.print("ERROR (LyXParagraph::GetChar): "
  951. //                   "unknown footnote kind.");
  952. //         return 'F';        /* this should not happen!  */
  953.         // This _can_ not happen, due to the type of next->footnotekind
  954.         // being LyXParagraph::footnot_kind
  955.         return 'F'; // to shut up gcc
  956.     }
  957. }
  958.  
  959.  
  960. int LyXParagraph::Last()
  961. {
  962.     if (next && next->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE)
  963.         return last + NextAfterFootnote()->Last() + 1;   /* the 1 is the symbol
  964.                                   * for the footnote */
  965.     else
  966.         return last;
  967. }
  968.  
  969.  
  970. LyXParagraph *LyXParagraph::ParFromPos(int pos)
  971. {
  972.     /* > because last is the next unused position, and you can 
  973.      * use it if you want  */
  974.     if (pos > last) {
  975.         if (next && next->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) 
  976.             return NextAfterFootnote()->ParFromPos(pos - last - 1);
  977.         else 
  978.             lyxerr.print("ERROR (LyXParagraph::ParFromPos): "
  979.                      "position does not exist.");
  980.         return this;
  981.     }
  982.     else
  983.         return this;
  984. }
  985.  
  986.  
  987. int LyXParagraph::PositionInParFromPos(int pos)
  988. {
  989.     /* > because last is the next unused position, and you can 
  990.      * use it if you want  */
  991.     if (pos > last) {
  992.         if (next && next->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) 
  993.             return NextAfterFootnote()->PositionInParFromPos(pos - last - 1);
  994.         else 
  995.             lyxerr.print(
  996.                 "ERROR (LyXParagraph::PositionInParFromPos): "
  997.                 "position does not exist.");
  998.         return pos;
  999.     }
  1000.     else
  1001.         return pos;
  1002. }
  1003.  
  1004.  
  1005. void LyXParagraph::SetFont(int pos, LyXFont const & font)
  1006. {
  1007.     /* > because last is the next unused position, and you can 
  1008.      * use it if you want  */
  1009.     if (pos > last) {
  1010.         if (next && next->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) {
  1011.             NextAfterFootnote()->SetFont(pos - last - 1, font);
  1012.         } else {
  1013.             lyxerr.print("ERROR (LyXParagraph::SetFont): "
  1014.                      "position does not exist.");
  1015.         }
  1016.         return;
  1017.     }
  1018.  
  1019.     LyXFont patternfont(LyXFont::ALL_INHERIT);
  1020.  
  1021. // First, reduce font against layout/label font
  1022. // Update: The SetCharFont() routine in text2.C already reduces font, so
  1023. // we don't need to do that here. (Asger)
  1024. // No need to simplify this because it will disappear in a new kernel. (Asger)
  1025.  
  1026.     // Next search font table
  1027.     FontTable *tmp2;
  1028.  
  1029.     bool found = false;
  1030.     FontTable *tmp = fonttable;
  1031.     while (tmp && !found) {
  1032.         if (pos >= tmp->pos && pos <= tmp->pos_end)
  1033.             found = true;
  1034.         else
  1035.             tmp = tmp->next;
  1036.     }
  1037.  
  1038.     if (!found) {
  1039.         /* if we did not find a font entry, but if the font at hand
  1040.          * is the same as default, we just forget it */
  1041.         if (font == patternfont)
  1042.             return;
  1043.  
  1044.         /* ok, we did not find a font entry. But maybe there is exactly
  1045.          * the needed font entry one position left */ 
  1046.         found = false;
  1047.         tmp2 = fonttable;
  1048.         while (tmp2 && !found) {
  1049.             if (pos - 1 >= tmp2->pos && pos - 1 <= tmp2->pos_end)
  1050.                 found = true;
  1051.             else
  1052.                 tmp2 = tmp2->next;
  1053.         }
  1054.         if (found) {
  1055.             /* ok there is one. maybe it is exactly the needed font */
  1056.             if (tmp2->font == font) {
  1057.                 /* put the position under the font */ 
  1058.                 tmp2->pos_end++;
  1059.                 return;
  1060.             }
  1061.         }
  1062.         /* Add a new entry in the 
  1063.          * fonttable for the position */
  1064.         tmp = new FontTable;
  1065.         tmp->pos = pos;
  1066.         tmp->pos_end = pos;
  1067.         tmp->font = patternfont;
  1068.         tmp->next = fonttable;
  1069.         fonttable = tmp;
  1070.     }
  1071.     else {
  1072.         /* we found a font entry. maybe we have to split it and create
  1073.          * a new one */ 
  1074.  
  1075.         if (tmp->pos != tmp->pos_end) {  /* more than one character  */
  1076.  
  1077.             if (pos == tmp->pos) {
  1078.                 /* maybe we could enlarge the left fonttable */ 
  1079.  
  1080.                 found = false;
  1081.                 tmp2 = fonttable;
  1082.                 while (tmp2 && !found) {
  1083.                     if (pos - 1 >= tmp2->pos && pos - 1 <= tmp2->pos_end)
  1084.                         found = true;
  1085.                     else
  1086.                         tmp2 = tmp2->next;
  1087.                 }
  1088.  
  1089.                 /* Is there is one, and is it exactly the needed font? */
  1090.                 if (found && tmp2->font == font) {
  1091.                     /* put the position under the font */ 
  1092.                     tmp2->pos_end++;
  1093.                     tmp->pos++;
  1094.                     return;
  1095.                 }
  1096.  
  1097.                 /* Add a new entry in the 
  1098.                  * fonttable for the position */
  1099.                 tmp2 = new FontTable;
  1100.                 tmp2->pos = pos + 1;
  1101.                 tmp2->pos_end = tmp->pos_end;
  1102.                 tmp2->font = tmp->font;
  1103.                 tmp->pos_end = pos;
  1104.                 tmp2->next = fonttable;
  1105.                 fonttable = tmp2;
  1106.             }
  1107.             else if (pos == tmp->pos_end) {
  1108.                 /* Add a new entry in the 
  1109.                  * fonttable for the position */
  1110.                 tmp2 = new FontTable;
  1111.                 tmp2->pos = tmp->pos;
  1112.                 tmp2->pos_end = tmp->pos_end - 1;
  1113.                 tmp2->font = tmp->font;
  1114.                 tmp->pos = tmp->pos_end;
  1115.                 tmp2->next = fonttable;
  1116.                 fonttable = tmp2;
  1117.             }
  1118.             else {
  1119.                 /* Add a new entry in the 
  1120.                  * fonttable for the position */
  1121.                 tmp2 = new FontTable;
  1122.                 tmp2->pos = tmp->pos;
  1123.                 tmp2->pos_end = pos - 1;
  1124.                 tmp2->font = tmp->font;
  1125.                 tmp2->next = fonttable;
  1126.                 fonttable = tmp2;
  1127.         
  1128.                 tmp2 = new FontTable;
  1129.                 tmp2->pos = pos + 1;
  1130.                 tmp2->pos_end = tmp->pos_end;
  1131.                 tmp2->font = tmp->font;
  1132.                 tmp2->next = fonttable;
  1133.                 fonttable = tmp2;
  1134.         
  1135.                 tmp->pos = pos;
  1136.                 tmp->pos_end = pos;
  1137.             }
  1138.         }
  1139.     }
  1140.  
  1141.     tmp->font = font;
  1142. }
  1143.  
  1144.    
  1145. /* this function is able to hide closed footnotes */
  1146. LyXParagraph *LyXParagraph::Next()
  1147. {
  1148.     LyXParagraph *tmp;
  1149.     if (next && next->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) {
  1150.         tmp = next;
  1151.         while (tmp && tmp->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE)
  1152.             tmp = tmp->next;
  1153.         if (tmp && tmp->footnoteflag != LyXParagraph::CLOSED_FOOTNOTE) 
  1154.             return tmp->Next(); /* there can be more than one footnote
  1155.                          * in a logical paragraph */
  1156.         else
  1157.             return next;    /* this should never happen! */
  1158.     }
  1159.     else
  1160.         return next;
  1161. }
  1162.  
  1163.  
  1164. LyXParagraph *LyXParagraph::NextAfterFootnote()
  1165. {
  1166.     LyXParagraph *tmp;
  1167.     if (next && next->footnoteflag != LyXParagraph::NO_FOOTNOTE) {
  1168.         tmp = next;
  1169.         while (tmp && tmp->footnoteflag != LyXParagraph::NO_FOOTNOTE)
  1170.             tmp = tmp->next;
  1171.         if (tmp && tmp->footnoteflag != LyXParagraph::CLOSED_FOOTNOTE) 
  1172.             return tmp;           /* there can be more than one footnote
  1173.                         * in a logical paragraph */
  1174.         else
  1175.             return next;                /* this should never happen! */
  1176.     }
  1177.     else
  1178.         return next;
  1179. }
  1180.  
  1181.  
  1182. LyXParagraph *LyXParagraph::PreviousBeforeFootnote()
  1183. {
  1184.     LyXParagraph *tmp;
  1185.     if (previous && previous->footnoteflag != LyXParagraph::NO_FOOTNOTE) {
  1186.         tmp = next;
  1187.         while (tmp && tmp->footnoteflag != LyXParagraph::NO_FOOTNOTE)
  1188.             tmp = tmp->previous;
  1189.         if (tmp && tmp->footnoteflag != LyXParagraph::CLOSED_FOOTNOTE) 
  1190.             return tmp;           /* there can be more than one footnote
  1191.                         * in a logical paragraph */
  1192.         else
  1193.             return previous;                /* this should never happen! */
  1194.     }
  1195.     else
  1196.         return previous;
  1197. }
  1198.  
  1199.  
  1200. LyXParagraph *LyXParagraph::LastPhysicalPar()
  1201. {
  1202.     LyXParagraph *tmp;
  1203.     if (footnoteflag != LyXParagraph::NO_FOOTNOTE)
  1204.         return this;
  1205.    
  1206.     tmp = this;
  1207.     while (tmp->next && tmp->next->footnoteflag != LyXParagraph::NO_FOOTNOTE)
  1208.         tmp = tmp->NextAfterFootnote();
  1209.    
  1210.     return tmp;
  1211.    
  1212. }
  1213.  
  1214.  
  1215. LyXParagraph *LyXParagraph::FirstPhysicalPar()
  1216. {
  1217.     if (!IsDummy())
  1218.         return this;
  1219.     LyXParagraph *tmppar = this;
  1220.  
  1221.     while (tmppar && (tmppar->IsDummy()
  1222.               || tmppar->footnoteflag != LyXParagraph::NO_FOOTNOTE))
  1223.         tmppar = tmppar->previous;
  1224.    
  1225.     if (!tmppar)
  1226.         return this;           /* this should never happen!  */
  1227.     else
  1228.         return tmppar;
  1229. }
  1230.  
  1231.  
  1232. /* this function is able to hide closed footnotes */
  1233. LyXParagraph *LyXParagraph::Previous()
  1234. {
  1235.     LyXParagraph *tmp = previous;
  1236.     if (!tmp)
  1237.         return tmp;
  1238.    
  1239.     if (tmp->previous && tmp->previous->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) {
  1240.         tmp = tmp->previous;
  1241.         while (tmp && tmp->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE)
  1242.             tmp = tmp->previous;
  1243.         if (tmp && tmp->footnoteflag != LyXParagraph::CLOSED_FOOTNOTE) 
  1244.             return tmp->next->Previous();    
  1245.  
  1246.         else
  1247.             return previous; 
  1248.     }
  1249.     else
  1250.         return previous;
  1251. }
  1252.  
  1253.    
  1254. void LyXParagraph::BreakParagraph(int pos, int flag)
  1255. {
  1256.     int i, pos_end, pos_first;
  1257.  
  1258.     /* create a new paragraph */
  1259.     LyXParagraph *par = ParFromPos(pos);
  1260.     LyXParagraph *firstpar = FirstPhysicalPar();
  1261.    
  1262.     LyXParagraph *tmp = new LyXParagraph(par);
  1263.    
  1264.     tmp->footnoteflag = footnoteflag;
  1265.     tmp->footnotekind = footnotekind;
  1266.    
  1267.     /* this is an idea for a more userfriendly layout handling, I will
  1268.      * see what the users say */
  1269.    
  1270.     /* layout stays the same with latex-environments */ 
  1271.     if (flag) {
  1272.         tmp->SetOnlyLayout(firstpar->layout);
  1273.         tmp->SetLabelWidthString(firstpar->labelwidthstring);
  1274.     }
  1275.  
  1276.     if (Last() > pos || !Last() || flag == 2) {
  1277.         tmp->SetOnlyLayout(firstpar->layout);
  1278.         tmp->align = firstpar->align;
  1279.         tmp->SetLabelWidthString(firstpar->labelwidthstring);
  1280.       
  1281.         tmp->line_bottom = firstpar->line_bottom;
  1282.         firstpar->line_bottom = false;
  1283.         tmp->pagebreak_bottom = firstpar->pagebreak_bottom;
  1284.         firstpar->pagebreak_bottom = false;
  1285.         tmp->added_space_bottom = firstpar->added_space_bottom;
  1286.         firstpar->added_space_bottom = VSpace::NONE;
  1287.       
  1288.         tmp->depth = firstpar->depth;
  1289.         tmp->noindent = firstpar->noindent;
  1290.    
  1291.         /* copy everything behind the break-position to the new paragraph */
  1292.         pos_first = 0;
  1293.         while (ParFromPos(pos_first) != par)
  1294.             pos_first++;
  1295.    
  1296.         pos_end = pos_first + par->last - 1;
  1297.    
  1298.         /* make sure there is enough memory for the now larger
  1299.            paragraph. This is not neccessary, because
  1300.            InsertFromMinibuffer will enlarge the memory (it uses
  1301.            InsertChar of course). But doing it by hand
  1302.            is MUCH faster! (only one time, not thousend times!!) */
  1303.  
  1304.         tmp->Enlarge(0, pos_end - pos);
  1305.  
  1306.         for (i = pos; i <= pos_end; i++) {
  1307.             par->CutIntoMinibuffer(i - pos_first);
  1308.             tmp->InsertFromMinibuffer(i - pos);
  1309.         }
  1310.  
  1311.         for (i = pos_end; i >= pos; i--)
  1312.             par->Erase(i - pos_first);
  1313.         /* free memory of the now shorter paragraph*/
  1314.         par->FitSize();
  1315.     }
  1316.  
  1317.     /* just an idea of me */ 
  1318.     if (!pos) {
  1319.         tmp->line_top = firstpar->line_top;
  1320.         tmp->pagebreak_top = firstpar->pagebreak_top;
  1321.         tmp->added_space_top = firstpar->added_space_top;
  1322.         firstpar->Clear();
  1323.         /* layout stays the same with latex-environments */ 
  1324.         if (flag) {
  1325.             firstpar->SetOnlyLayout(tmp->layout);
  1326.             firstpar->SetLabelWidthString(tmp->labelwidthstring);
  1327.             firstpar->depth = tmp->depth;
  1328.         }
  1329.     }
  1330. }
  1331.  
  1332.  
  1333. void LyXParagraph::MakeSameLayout(LyXParagraph *par)
  1334. {
  1335.     par = par->FirstPhysicalPar();
  1336.     footnoteflag = par->footnoteflag;
  1337.     footnotekind = par->footnotekind;
  1338.  
  1339.     layout = par->layout;
  1340.     align = par-> align;
  1341.     SetLabelWidthString(par->labelwidthstring);
  1342.  
  1343.     line_bottom = par->line_bottom;
  1344.     pagebreak_bottom = par->pagebreak_bottom;
  1345.     added_space_bottom = par->added_space_bottom;
  1346.  
  1347.     line_top = par->line_top;
  1348.     pagebreak_top = par->pagebreak_top;
  1349.     added_space_top = par->added_space_top;
  1350.  
  1351.         pextra_type = par->pextra_type;
  1352.         pextra_width = par->pextra_width;
  1353.         pextra_widthp = par->pextra_widthp;
  1354.         pextra_alignment = par->pextra_alignment;
  1355.         pextra_hfill = par->pextra_hfill;
  1356.         pextra_start_minipage = par->pextra_start_minipage;
  1357.  
  1358.     noindent = par->noindent;
  1359.     depth = par->depth;
  1360. }
  1361.  
  1362.  
  1363. LyXParagraph *LyXParagraph::FirstSelfrowPar()
  1364. {
  1365.     LyXParagraph *tmppar;
  1366.    
  1367.     tmppar = this;
  1368.     while (tmppar && (
  1369.         (tmppar->IsDummy() && tmppar->previous->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE)
  1370.         || tmppar->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE))
  1371.         tmppar = tmppar->previous;
  1372.    
  1373.     if (!tmppar)
  1374.         return this;           /* this should never happen!  */
  1375.     else
  1376.         return tmppar;
  1377. }
  1378.  
  1379.  
  1380. LyXParagraph *LyXParagraph::Clone()
  1381. {
  1382.     int i;
  1383.    
  1384.     /* create a new paragraph */
  1385.     LyXParagraph *result = new LyXParagraph();
  1386.    
  1387.     result->MakeSameLayout(this);
  1388.  
  1389.     /* this is because of the dummy layout of the paragraphs that
  1390.        follow footnotes */
  1391.     result->layout = layout;
  1392.    
  1393.     /* table stuff -- begin*/ 
  1394.     if (table)
  1395.         result->table = table->Clone();
  1396.     else
  1397.         result->table = NULL;
  1398.     /* table stuff -- end*/ 
  1399.    
  1400.         // ale970302
  1401.         result->bibkey = (bibkey) ? new InsetBibKey(bibkey): 0;
  1402.                
  1403.     
  1404.     /* copy everything behind the break-position to the new paragraph */
  1405.    
  1406.     /* make shure there is enough memory for the now larger paragraph.
  1407.      * This is not neccessary, because InsertFromMinibuffer will enlarge
  1408.      * the memory (it uses InsertChar of course). But doing it by hand
  1409.      * is MUCH faster! (only one time, not thousend times!!) */
  1410.    
  1411.     result->Enlarge(0, last+2);
  1412.    
  1413.     for (i = 0; i < last; i++) {
  1414.      
  1415.         CopyIntoMinibuffer(i);
  1416.         result->InsertFromMinibuffer(i);
  1417.     }
  1418.     return result;
  1419. }
  1420.  
  1421.  
  1422. bool LyXParagraph::HasSameLayout(LyXParagraph* par)
  1423. {
  1424.     par = par->FirstPhysicalPar();
  1425.  
  1426.     return (
  1427.         par->footnoteflag == footnoteflag &&
  1428.         par->footnotekind == footnotekind &&
  1429.  
  1430.         par->layout == layout &&
  1431.  
  1432.         par->align == align &&
  1433.  
  1434.         par->line_bottom == line_bottom &&
  1435.         par->pagebreak_bottom == pagebreak_bottom &&
  1436.         par->added_space_bottom == added_space_bottom &&
  1437.  
  1438.         par->line_top == line_top &&
  1439.         par->pagebreak_top == pagebreak_top &&
  1440.         par->added_space_top == added_space_top &&
  1441.  
  1442.                 par->pextra_type == pextra_type &&
  1443.                 par->pextra_width == pextra_width && 
  1444.                 par->pextra_widthp == pextra_widthp && 
  1445.                 par->pextra_alignment == pextra_alignment && 
  1446.                 par->pextra_hfill == pextra_hfill && 
  1447.                 par->pextra_start_minipage == pextra_start_minipage && 
  1448.  
  1449.         par->table == table && // what means: NO TABLE AT ALL 
  1450.  
  1451.         par->noindent == noindent &&
  1452.         par->depth == depth);
  1453. }
  1454.  
  1455.  
  1456. void LyXParagraph::BreakParagraphConservative(int pos)
  1457. {
  1458.     int i, pos_end, pos_first;
  1459.    
  1460.     /* create a new paragraph */
  1461.     LyXParagraph *par = ParFromPos(pos);
  1462.  
  1463.     LyXParagraph *tmp = new LyXParagraph(par);
  1464.    
  1465.     tmp->MakeSameLayout(par);
  1466.    
  1467.     if (Last() > pos) {   
  1468.         /* copy everything behind the break-position to the new
  1469.            paragraph */
  1470.         pos_first = 0;
  1471.         while (ParFromPos(pos_first) != par)
  1472.             pos_first++;
  1473.    
  1474.         pos_end = pos_first + par->last - 1;
  1475.    
  1476.         /* make shure there is enough memory for the now larger
  1477.            paragraph. This is not neccessary, because
  1478.            InsertFromMinibuffer will enlarge the memory (it uses
  1479.            InsertChar of course). But doing it by hand
  1480.            is MUCH faster! (only one time, not thousend times!!) */
  1481.    
  1482.         tmp->Enlarge(0, pos_end - pos);
  1483.    
  1484.         for (i = pos; i <= pos_end; i++) {
  1485.       
  1486.             par->CutIntoMinibuffer(i - pos_first);
  1487.             tmp->InsertFromMinibuffer(i - pos);
  1488.         }
  1489.         for (i = pos_end; i >= pos; i--)
  1490.             par->Erase(i - pos_first);
  1491.  
  1492.         /* free memory of the now shorter paragraph*/
  1493.         par->FitSize();
  1494.     }
  1495. }
  1496.    
  1497.  
  1498. /* be carefull, this does not make any check at all */ 
  1499. void LyXParagraph::PasteParagraph()
  1500. {
  1501.     int i, pos_end, pos_insert;
  1502.     LyXParagraph *the_next;
  1503.    
  1504.     /* copy the next paragraph to this one */
  1505.     the_next = Next();
  1506.    
  1507.     LyXParagraph *firstpar = FirstPhysicalPar();
  1508.    
  1509.     /* first the DTP-stuff */ 
  1510.     firstpar->line_bottom = the_next->line_bottom;
  1511.     firstpar->added_space_bottom = the_next->added_space_bottom;
  1512.     firstpar->pagebreak_bottom = the_next->pagebreak_bottom;
  1513.    
  1514.     pos_end = the_next->last - 1;
  1515.     pos_insert = Last();
  1516.    
  1517.     /* enlarge the paragraph. This is faster than enlarge it
  1518.      * every 10th insertion. */ 
  1519.     if (pos_end >= 0)
  1520.         Enlarge(pos_insert, pos_end);
  1521.       
  1522.     /* ok, now copy the paragraph */ 
  1523.     for (i = 0; i <= pos_end; i++) {
  1524.         the_next->CutIntoMinibuffer(i);
  1525.         InsertFromMinibuffer(pos_insert + i);
  1526.     }
  1527.    
  1528.     /* delete the next paragraph */
  1529.     delete the_next;
  1530. }
  1531.  
  1532.  
  1533. void LyXParagraph::OpenFootnote(int pos)
  1534. {
  1535.     LyXParagraph *par = ParFromPos(pos);
  1536.     par = par->next;
  1537.     while (par && par->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) {
  1538.         par->footnoteflag = LyXParagraph::OPEN_FOOTNOTE;
  1539.         par = par->next;
  1540.     }
  1541. }
  1542.  
  1543.  
  1544. void LyXParagraph::CloseFootnote(int pos)
  1545. {
  1546.     LyXParagraph *par = ParFromPos(pos);
  1547.     par = par->next;
  1548.     while (par && par->footnoteflag == LyXParagraph::OPEN_FOOTNOTE) {
  1549.         par->footnoteflag = LyXParagraph::CLOSED_FOOTNOTE;
  1550.         par = par->next;
  1551.     }
  1552. }
  1553.  
  1554.  
  1555. int LyXParagraph::GetLayout()
  1556. {
  1557.     return FirstPhysicalPar()->layout;
  1558. }
  1559.  
  1560.  
  1561. char LyXParagraph::GetDepth()
  1562. {
  1563.     return FirstPhysicalPar()->depth;
  1564. }
  1565.  
  1566.  
  1567. char LyXParagraph::GetAlign()
  1568. {
  1569.     return FirstPhysicalPar()->align;
  1570. }
  1571.  
  1572.  
  1573. LString LyXParagraph::GetLabelString()
  1574. {
  1575.     return FirstPhysicalPar()->labelstring;
  1576. }
  1577.  
  1578.  
  1579. unsigned char LyXParagraph::GetCounter(int i)
  1580. {
  1581.     return FirstPhysicalPar()->counter[i];
  1582. }
  1583.  
  1584.  
  1585. /* the next two functions are for the manual labels */ 
  1586. LString LyXParagraph::GetLabelWidthString()
  1587. {
  1588.     if (!FirstPhysicalPar()->labelwidthstring.empty())
  1589.         return FirstPhysicalPar()->labelwidthstring;
  1590.     else
  1591.         return _("Senseless with this layout!");
  1592. }
  1593.  
  1594.  
  1595. void LyXParagraph::SetLabelWidthString(LString const & s)
  1596. {
  1597.     LyXParagraph *par = FirstPhysicalPar();
  1598.  
  1599.     par->labelwidthstring = s;
  1600. }
  1601.  
  1602.  
  1603. void LyXParagraph::SetOnlyLayout(char new_layout)
  1604. {
  1605.     LyXParagraph
  1606.         *par = FirstPhysicalPar(),
  1607.         *ppar = NULL,
  1608.                 *npar = NULL;
  1609.  
  1610.     par->layout = new_layout;
  1611.     /* table stuff -- begin*/ 
  1612.     if (table) 
  1613.         par->layout = 0;
  1614.     /* table stuff -- end*/ 
  1615.         if (par->pextra_type == PEXTRA_NONE) {
  1616.                 if (par->Previous()) {
  1617.                         ppar = par->Previous()->FirstPhysicalPar();
  1618.                         while(ppar
  1619.                   && ppar->Previous()
  1620.                   && (ppar->depth > par->depth))
  1621.                                 ppar = ppar->Previous()->FirstPhysicalPar();
  1622.                 }
  1623.                 if (par->Next()) {
  1624.                         npar = par->Next()->NextAfterFootnote();
  1625.                         while(npar
  1626.                   && npar->Next()
  1627.                   && (npar->depth > par->depth))
  1628.                                 npar = npar->Next()->NextAfterFootnote();
  1629.                 }
  1630.                 if (ppar && (ppar->pextra_type != PEXTRA_NONE)) {
  1631.                         LString
  1632.                                 p1 = ppar->pextra_width,
  1633.                                 p2 = ppar->pextra_widthp;
  1634.                         ppar->SetPExtraType(ppar->pextra_type,
  1635.                                             p1.c_str(),p2.c_str());
  1636.                 }
  1637.                 if ((par->pextra_type == PEXTRA_NONE) &&
  1638.                     npar && (npar->pextra_type != PEXTRA_NONE)) {
  1639.                         LString
  1640.                                 p1 = npar->pextra_width,
  1641.                                 p2 = npar->pextra_widthp;
  1642.                         npar->SetPExtraType(npar->pextra_type,
  1643.                                             p1.c_str(),p2.c_str());
  1644.                 }
  1645.         }
  1646. }
  1647.  
  1648.  
  1649. void LyXParagraph::SetLayout(char new_layout)
  1650. {
  1651.     LyXParagraph
  1652.         *par = FirstPhysicalPar(),
  1653.         *ppar = NULL,
  1654.         *npar = NULL;
  1655.  
  1656.         par->layout = new_layout;
  1657.     par->labelwidthstring.erase();
  1658.     par->align = LYX_ALIGN_LAYOUT;
  1659.     //par->depth = 0;
  1660.     par->added_space_top = VSpace::NONE;
  1661.     par->added_space_bottom = VSpace::NONE;
  1662.     /* table stuff -- begin*/ 
  1663.     if (table) 
  1664.         par->layout = 0;
  1665.     /* table stuff -- end*/
  1666.         if (par->pextra_type == PEXTRA_NONE) {
  1667.                 if (par->Previous()) {
  1668.                         ppar = par->Previous()->FirstPhysicalPar();
  1669.                         while(ppar
  1670.                   && ppar->Previous()
  1671.                   && (ppar->depth > par->depth))
  1672.                                 ppar = ppar->Previous()->FirstPhysicalPar();
  1673.                 }
  1674.                 if (par->Next()) {
  1675.                         npar = par->Next()->NextAfterFootnote();
  1676.                         while(npar
  1677.                   && npar->Next()
  1678.                   && (npar->depth > par->depth))
  1679.                                 npar = npar->Next()->NextAfterFootnote();
  1680.                 }
  1681.                 if (ppar && (ppar->pextra_type != PEXTRA_NONE)) {
  1682.                         LString
  1683.                                 p1 = ppar->pextra_width,
  1684.                                 p2 = ppar->pextra_widthp;
  1685.                         ppar->SetPExtraType(ppar->pextra_type,
  1686.                                             p1.c_str(),p2.c_str());
  1687.                 }
  1688.                 if ((par->pextra_type == PEXTRA_NONE) &&
  1689.                     npar && (npar->pextra_type != PEXTRA_NONE)) {
  1690.                         LString
  1691.                                 p1 = npar->pextra_width,
  1692.                                 p2 = npar->pextra_widthp;
  1693.                         npar->SetPExtraType(npar->pextra_type,
  1694.                                             p1.c_str(),p2.c_str());
  1695.                 }
  1696.         }
  1697. }
  1698.  
  1699.  
  1700. /* if the layout of a paragraph contains a manual label, the beginning of the 
  1701. * main body is the beginning of the second word. This is what the par-
  1702. * function returns. If the layout does not contain a label, the main
  1703. * body always starts with position 0. This differentiation is necessary,
  1704. * because there cannot be a newline or a blank <= the beginning of the 
  1705. * main body in TeX. */ 
  1706.  
  1707. int LyXParagraph::BeginningOfMainBody()
  1708. {
  1709.     if (FirstPhysicalPar() != this)
  1710.         return -1;
  1711.    
  1712.     int i = 0;
  1713.    
  1714. //    while (i < last   &&  !(i > 1 && GetChar(i-1)==' ')
  1715. //           && GetChar(i)!=LYX_META_NEWLINE)
  1716. //        i++;
  1717. // Unroll the first two cycles of this loop
  1718. // and remember the previous character to remove unnecessary GetChar() calls
  1719.  
  1720.     if (i < last
  1721.         && GetChar(i) != LYX_META_NEWLINE) {
  1722.         ++i;
  1723.         char previous_char, temp;
  1724.         if (i < last
  1725.             && (previous_char = GetChar(i)) != LYX_META_NEWLINE) {
  1726.             // Yes, this  ^ is supposed to be "=" not "=="
  1727.             ++i;
  1728.             while (i < last
  1729.                    && previous_char != ' '
  1730.                    && (temp = GetChar(i)) != LYX_META_NEWLINE) {
  1731.                 ++i;
  1732.                 previous_char = temp;
  1733.             }
  1734.         }
  1735.     }
  1736.  
  1737.     if (i==0 && i == last &&
  1738.         !(footnoteflag==LyXParagraph::NO_FOOTNOTE
  1739.           && next && next->footnoteflag != LyXParagraph::NO_FOOTNOTE)
  1740.         )
  1741.         i++;                   /* the cursor should not jump  
  1742.                         * to the main body if there
  1743.                         * is nothing in! */
  1744.     return i;
  1745. }
  1746.  
  1747.  
  1748. LyXParagraph* LyXParagraph::DepthHook(int deth)
  1749. {
  1750.     LyXParagraph *newpar = this;
  1751.     if (deth < 0)
  1752.         return NULL;
  1753.    
  1754.     do {
  1755.         newpar = newpar->FirstPhysicalPar()->Previous();
  1756.     } while (newpar && newpar->GetDepth() > deth
  1757.          && newpar->footnoteflag == footnoteflag);
  1758.    
  1759.     if (!newpar) {
  1760.         if (Previous() || GetDepth())
  1761.             lyxerr.print("ERROR (LyXParagraph::DepthHook): "
  1762.                      "no hook.");
  1763.         newpar = this;
  1764.     }
  1765.     return newpar->FirstPhysicalPar();
  1766. }
  1767.  
  1768.  
  1769. int LyXParagraph::AutoDeleteInsets()
  1770. {
  1771.     InsetTable *tmpi = insettable;
  1772.     InsetTable *tmpi2 = tmpi;
  1773.     int i=0;
  1774.     while (tmpi) {
  1775.         tmpi2 = tmpi;
  1776.         tmpi = tmpi->next;
  1777.         if (tmpi2->inset)
  1778.             if (tmpi2->inset->AutoDelete()) {
  1779.                 i++;
  1780.                 Erase(tmpi2->pos);
  1781.             } else {}
  1782.         else
  1783.             lyxerr.print(
  1784.                 "ERROR (LyXParagraph::AutoDeleteInsets): "
  1785.                 "cannot auto-delete insets");
  1786.     }
  1787.     return i;
  1788. }
  1789.  
  1790.  
  1791. Inset* LyXParagraph::ReturnNextInsetPointer(int &pos)
  1792. {
  1793.     InsetTable *tmpi = insettable;
  1794.     InsetTable *tmpi2 = NULL;
  1795.     while (tmpi){
  1796.         if (tmpi->pos >= pos) {
  1797.             if (!tmpi2 || tmpi->pos < tmpi2->pos)
  1798.                 tmpi2 = tmpi;
  1799.         }
  1800.         tmpi=tmpi->next;
  1801.     }
  1802.     if (tmpi2){
  1803.         pos = tmpi2->pos;
  1804.         return tmpi2->inset;
  1805.     }
  1806.     else
  1807.         return NULL;
  1808. }
  1809.  
  1810.  
  1811. /* returns -1 if inset not found */
  1812. int LyXParagraph::GetPositionOfInset(Inset* inset)
  1813. {
  1814.     /* find the entry */ 
  1815.     InsetTable *tmpi = insettable;
  1816.     while (tmpi && tmpi->inset != inset) {
  1817.         tmpi=tmpi->next;
  1818.     }
  1819.     if (tmpi && tmpi->inset)
  1820.         return tmpi->pos;
  1821.     else{
  1822.         /* think about footnotes */
  1823.         if (footnoteflag == LyXParagraph::NO_FOOTNOTE 
  1824.             && next && next->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) {
  1825.             int further =
  1826.                 NextAfterFootnote()->GetPositionOfInset(inset);
  1827.             if (further != -1)
  1828.                 return last + 1 + further;
  1829.         }
  1830.         return -1;
  1831.     }
  1832. }
  1833.  
  1834.  
  1835. void LyXParagraph::readSimpleWholeFile(FILE *myfile)
  1836. {
  1837.     char c;
  1838.  
  1839.     FileInfo fileInfo(fileno(myfile));
  1840.     long file_size = fileInfo.getSize();
  1841.     /* it is horrible, I know, but faster.
  1842.      * I should not use InsertString for that :-( */
  1843.    
  1844.     /* I will write a better insertion in the future */ 
  1845.     Enlarge(0, file_size + 10);
  1846.    
  1847.     rewind(myfile);
  1848.    
  1849.     if (!feof(myfile)) {
  1850.         do {
  1851.             c = fgetc(myfile);
  1852.             InsertChar(last,c);
  1853.         } while (!feof(myfile));
  1854.       
  1855.     }
  1856. }
  1857.  
  1858.  
  1859. LyXParagraph* LyXParagraph::TeXOnePar(LString &file, TexRow &texrow,
  1860.                       LString &foot, TexRow &foot_texrow,
  1861.                       int &foot_count)
  1862. {
  1863.     lyxerr.debug(LString("TeXOnePar...     ") + (long)this, Error::LATEX);
  1864.     LyXParagraph *par = next;
  1865.     LyXLayout * style = lyxstyle.Style(GetCurrentTextClass(), layout);
  1866.  
  1867.     bool further_blank_line = false;
  1868.     if (IsDummy())
  1869.         lyxerr.print("ERROR (LyXParagraph::TeXOnePar) is dummy.");
  1870.  
  1871.     if (tex_code_break_column && style->isCommand()){
  1872.         file += '\n';
  1873.         texrow.newline();
  1874.     }
  1875.  
  1876.     if (pagebreak_top) {
  1877.         file += "\\newpage";
  1878.         further_blank_line = true;
  1879.     }
  1880.     if (added_space_top.kind() != VSpace::NONE) {
  1881.         file += added_space_top.asLatexCommand();
  1882.         further_blank_line = true;
  1883.     }
  1884.       
  1885.     if (line_top) {
  1886.         file += "\\lyxline{\\" + getFont(0).latexSize() + '}';
  1887.         file += "\\vspace{-1\\parskip}";
  1888.         further_blank_line = true;
  1889.     }
  1890.  
  1891.     if (further_blank_line){
  1892.         file += '\n';
  1893.         texrow.newline();
  1894.     }
  1895.  
  1896.     switch (style->latextype) {
  1897.     case LATEX_COMMAND:
  1898.                 //arrae970411
  1899.         if (style->latexparam.empty()) { 
  1900.             file += '\\';
  1901.             file += style->latexname;
  1902.         } else {
  1903.             file += '\\';
  1904.             file += style->latexname;
  1905.             file += '[';
  1906.             file += style->latexparam;
  1907.             file += ']';
  1908.         }
  1909.         break;
  1910.     case LATEX_ITEM_ENVIRONMENT:
  1911.             if (bibkey) 
  1912.             bibkey->Latex(file, false);
  1913.         else
  1914.             file += "\\item ";
  1915.         break;
  1916.     case LATEX_LIST_ENVIRONMENT:
  1917.         file += "\\item ";
  1918.         break;
  1919.     default:
  1920.         break;
  1921.     }
  1922.  
  1923.     bool need_par = SimpleTeXOnePar(file, texrow);
  1924.  
  1925.     // Spit out footnotes
  1926.     while (par && par->footnoteflag != LyXParagraph::NO_FOOTNOTE
  1927.            && par->footnoteflag != footnoteflag) {
  1928.         par = par->TeXFootnote(file, texrow,
  1929.                        foot, foot_texrow, foot_count);
  1930.             par->SimpleTeXOnePar(file, texrow);
  1931.             par = par->next;
  1932.     }
  1933.  
  1934.     // Make sure that \\par is done with the font of the last
  1935.     // character if this has another size as the default.
  1936.     // This is necessary because LaTeX (and LyX on the screen)
  1937.     // calculates the space between the baselines according
  1938.     // to this font. (Matthias)
  1939.     LyXFont font = getFont(Last()-1);
  1940.     if (need_par) {
  1941.         if (style->resfont.size() != font.size()) {
  1942.             file += '\\';
  1943.             file += font.latexSize();
  1944.             file += ' ';
  1945.         }
  1946.         file += "\\par}";
  1947.     } else if (lyxstyle.Style(GetCurrentTextClass(),
  1948.                   GetLayout())->isCommand()){
  1949.         if (style->resfont.size() != font.size()) {
  1950.             file += '\\';
  1951.             file += font.latexSize();
  1952.             file += ' ';
  1953.         }
  1954.         file += '}';
  1955.     } else if (style->resfont.size() != font.size()){
  1956.         file += "{\\" + font.latexSize() + " \\par}";
  1957.     }
  1958.     
  1959.     switch (style->latextype) {
  1960.     case LATEX_ITEM_ENVIRONMENT:
  1961.     case LATEX_LIST_ENVIRONMENT:
  1962.                 if (par && (depth < par->depth)) {
  1963.                         file += '\n';
  1964.                         texrow.newline();
  1965.                 }
  1966.         break;
  1967.     case LATEX_ENVIRONMENT:
  1968.         // if its the last paragraph of the current environment
  1969.         // skip it otherwise fall through
  1970.         if (par
  1971.             && !par->HasSameLayout(this)) {
  1972.             break;
  1973.         }
  1974.     default:
  1975.         file += '\n';
  1976.         texrow.newline();
  1977.     }
  1978.     
  1979.     further_blank_line = false;
  1980.     if (line_bottom) {
  1981.         file += "\\lyxline{\\" + getFont(Last()-1).latexSize() + '}';
  1982.         further_blank_line = true;
  1983.     }
  1984.  
  1985.     if (added_space_bottom.kind() != VSpace::NONE) {
  1986.         file += added_space_bottom.asLatexCommand();
  1987.         further_blank_line = true;
  1988.     }
  1989.       
  1990.     if (pagebreak_bottom) {
  1991.         file += "\\newpage";
  1992.         further_blank_line = true;
  1993.     }
  1994.  
  1995.     if (further_blank_line){
  1996.         file += '\n';
  1997.         texrow.newline();
  1998.     }
  1999.  
  2000.     if (!(footnoteflag != LyXParagraph::NO_FOOTNOTE && par &&
  2001.               par->footnoteflag == LyXParagraph::NO_FOOTNOTE) // &&
  2002. //            (pextra_type != PEXTRA_MINIPAGE ||
  2003. /*             (par && !par->pextra_type == PEXTRA_MINIPAGE)) */ ) {
  2004.         file += '\n';
  2005.         texrow.newline();
  2006.     }
  2007.  
  2008.     lyxerr.debug(LString("TeXOnePar...done ") + (long)par, Error::LATEX);
  2009.     return par;
  2010. }
  2011.  
  2012.  
  2013. // This one spits out the text of the paragraph
  2014. bool LyXParagraph::SimpleTeXOnePar(LString &file, TexRow &texrow)
  2015. {
  2016.     lyxerr.debug(LString("SimpleTeXOnePar...     ")+(long)this, Error::LATEX);
  2017.     if (table)
  2018.         return SimpleTeXOneTablePar(file, texrow);
  2019.     char c;
  2020.     Inset *inset;
  2021.     int main_body;
  2022.     int column;
  2023.     
  2024.     bool return_value = false;
  2025.     //bool underbar = false;
  2026.  
  2027.     LyXLayout * style = lyxstyle.Style(GetCurrentTextClass(), GetLayout());
  2028.     LyXFont basefont;
  2029.  
  2030.     /* maybe we have to create a optional argument */ 
  2031.     if (style->labeltype != LABEL_MANUAL)
  2032.         main_body = 0;
  2033.     else
  2034.         main_body = BeginningOfMainBody();
  2035.  
  2036.     if (main_body > 0) {
  2037.         file += '[';
  2038.         basefont = getFont(-2); // Get label font
  2039.     } else
  2040.         basefont = getFont(-1); // Get layout font
  2041.  
  2042.     column = 0;
  2043.  
  2044.     if (main_body >= 0 && !last && !IsDummy()){
  2045.  
  2046.         if (style->isCommand()) {
  2047.             file += '{';
  2048.             column++;
  2049.         } else if (align != LYX_ALIGN_LAYOUT) {
  2050.             file += '{';
  2051.             column++;
  2052.             return_value = true;
  2053.         }
  2054.     }
  2055.  
  2056.     // Which font is currently active?
  2057.     LyXFont running_font = basefont;
  2058.     // Do we have an open font change?
  2059.     bool open_font = false;
  2060.  
  2061.     texrow.start(this, 0);
  2062.  
  2063.     for (int i = 0; i < last; i++) {
  2064.         column++;
  2065.         // First char in paragraph or after label?
  2066.         if (i == main_body && !IsDummy()) {
  2067.             if (main_body > 0) {
  2068.                 if (open_font) {
  2069.                     column += running_font.latexWriteEndChanges(file, basefont);
  2070.                     open_font = false;
  2071.                 }
  2072.                 basefont = getFont(-1); // Now use the layout font
  2073.                 running_font = basefont;
  2074.                 file += ']';
  2075.                 column++;
  2076.             }
  2077.             if (style->isCommand()) {
  2078.                 file += '{';
  2079.                 column++;
  2080.             } else if (align != LYX_ALIGN_LAYOUT) {
  2081.                 file += '{';
  2082.                 column++;
  2083.                 return_value = true;
  2084.             }
  2085.  
  2086.             if (noindent) {
  2087.                 file += "\\noindent ";
  2088.                 column += 10;
  2089.             }
  2090.             switch (align) {
  2091.             case LYX_ALIGN_LEFT:
  2092.                 file += "\\raggedright ";
  2093.                 column+=13;
  2094.                 break;
  2095.             case LYX_ALIGN_RIGHT:
  2096.                 file += "\\raggedleft ";
  2097.                 column+=12;
  2098.                 break;
  2099.             case LYX_ALIGN_CENTER:
  2100.                 file += "\\centering ";
  2101.                 column+=11;
  2102.                 break;
  2103.             }     
  2104.         }
  2105.  
  2106.         c = GetChar(i);
  2107.  
  2108.         // Fully instantiated font
  2109.         LyXFont font = getFont(i);
  2110.  
  2111.         // Spaces at end of font change are simulated to be outside font change.
  2112.         // i.e. we write "\textXX{text} " rather than "\textXX{text }". (Asger)
  2113.         if (open_font && c == ' ' && i <= last-2 
  2114.             && getFont(i+1) != running_font && getFont(i+1) != font) {
  2115.             font = getFont(i+1);
  2116.         }
  2117.  
  2118.         // We end font definition before blanks
  2119.         if (font != running_font && open_font) {
  2120.             column += running_font.latexWriteEndChanges(file, basefont);
  2121.             running_font = basefont;
  2122.             open_font = false;
  2123.         }
  2124.  
  2125.         // Blanks are printed before start of fontswitch
  2126.         if (c==' '){
  2127.             // Do not print the separation of the optional argument
  2128.             if (i != main_body - 1) {
  2129.                 if (column > tex_code_break_column
  2130.                     && i && GetChar(i-1) != ' '
  2131.                     && (i < last-1) 
  2132.                     // In LaTeX mode, we don't want to
  2133.                     // break lines since some commands
  2134.                     // do not like this
  2135.                     && font.latex() != LyXFont::ON 
  2136.                     // same in FreeSpacing mode
  2137.                     && !style->free_spacing
  2138.                     // In typewriter mode, we want to avoid 
  2139.                     // ! . ? : at the end of a line
  2140.                     && !(font.family() == LyXFont::TYPEWRITER_FAMILY 
  2141.                      && (GetChar(i-1) == '.' 
  2142.                          || GetChar(i-1) == '?' 
  2143.                          || GetChar(i-1) == ':' 
  2144.                          || GetChar(i-1) == '!'))) {
  2145.                     file += '\n';
  2146.                     texrow.newline();
  2147.                     texrow.start(this, i+1);
  2148.                     column = 0;
  2149.                 } 
  2150.                 else if (font.latex() == LyXFont::OFF) {
  2151.                     if (font.family() == LyXFont::TYPEWRITER_FAMILY)
  2152.                         file += '~';
  2153.                     else
  2154.                         file += ' ';
  2155.                 }
  2156.             }
  2157.         }
  2158.  
  2159.         // Do we need to change font?
  2160.         if (font != running_font) {
  2161.             column += font.latexWriteStartChanges(file, basefont);
  2162.             running_font = font;
  2163.             open_font = true;
  2164.         }
  2165.  
  2166.         // Do we need to turn on LaTeX mode?
  2167.         if (font.latex() != running_font.latex()) {
  2168.             if (font.latex() == LyXFont::ON
  2169.                 && style->needprotect)
  2170.                 {
  2171.                     file += "\\protect ";
  2172.                     column += 9;
  2173.                 }
  2174.         }
  2175.  
  2176.         if (c == LYX_META_INSET) {
  2177.             inset = GetInset(i);
  2178.             if (inset) {
  2179.                 int len = file.length();
  2180.                 int tmp = inset->Latex(file, style->isCommand());
  2181.                 if (tmp)
  2182.                     column = 0;
  2183.                 else
  2184.                     column += file.length() - len;
  2185.                 //for (;tmp>0;tmp--)
  2186.                 for (;tmp--;)
  2187.                     texrow.newline();
  2188.             }
  2189.         } else {
  2190.             // Are we in LaTeX mode?
  2191.             if (font.latex() == LyXFont::ON) {
  2192.                 switch (c) {
  2193.                 case LYX_META_NEWLINE: 
  2194.                     if (!style->newline_allowed)
  2195.                         file += '\n';
  2196.                     else {
  2197.                         if (open_font) {
  2198.                             column += running_font.latexWriteEndChanges(file, basefont);
  2199.                             open_font = false;
  2200.                         }
  2201.                         basefont = getFont(-1);
  2202.                         running_font = basefont;
  2203.                         file += "\\\\\n";
  2204.                     }
  2205.                     texrow.newline();
  2206.                     texrow.start(this, i+1);
  2207.                     column = 0;
  2208.                     break;  
  2209.                 case LYX_META_HFILL: 
  2210.                     file += "\\hfill{}";
  2211.                     column+=7;
  2212.                     break;
  2213.                 case LYX_META_PROTECTED_SEPARATOR: 
  2214.                     file += '~';
  2215.                     break;
  2216.                 default:
  2217.                     // make sure that we will not print
  2218.                     // error generating chars to the tex
  2219.                     // file. This test would not be needed
  2220.                     // if it were done in the buffer
  2221.                     // itself.
  2222.                     if (c != '\0')
  2223.                         file += c;
  2224.                     break;
  2225.                 }
  2226.             } else {
  2227.                 // Plain mode (i.e. not LaTeX)
  2228.                 switch (c) {
  2229.                 case LYX_META_NEWLINE: 
  2230.                     if (!style->newline_allowed)
  2231.                         file += '\n';
  2232.                     else {
  2233.                         if (open_font) {
  2234.                             column += running_font.latexWriteEndChanges(file, basefont);
  2235.                             open_font = false;
  2236.                         }
  2237.                         basefont = getFont(-1);
  2238.                         running_font = basefont;
  2239.                         file += "\\\\\n";
  2240.                     }
  2241.                     texrow.newline();
  2242.                     texrow.start(this, i+1);
  2243.                     column = 0;
  2244.                     break;
  2245.                 case LYX_META_HFILL: 
  2246.                     file += "\\hfill{}";
  2247.                     column+=7;
  2248.                     break;
  2249.                 case LYX_META_PROTECTED_SEPARATOR: 
  2250.                     file += '~';
  2251.                     break;
  2252.                 case '\\': 
  2253.                     if (lyxrc->fontenc=="T1" 
  2254.                         || font.family() == LyXFont::TYPEWRITER_FAMILY){ 
  2255.                         file += "\\char`\\\\{}";
  2256.                         column+=9;
  2257.                     }
  2258.                     else {
  2259.                         file += "\\ensuremath{\\backslash}";
  2260.                         column+=22;
  2261.                     }
  2262.                     break;
  2263.                 case '░': case '▒': case '▓': case '│':  
  2264.                 case '╫': case '≈': case '╣': case '¬':
  2265.                 case '║': case '¼': case '╡':
  2266.                     if (current_view->currentBuffer()->params.inputenc == "latin1") {
  2267.                         file += "\\ensuremath{";
  2268.                         file += c;
  2269.                         file += '}';
  2270.                         column+=13;
  2271.                     } else
  2272.                         file += c;
  2273.                     break;
  2274.                 case '|': case '<': case '>':
  2275.                     if (lyxrc->fontenc=="T1") {
  2276.                         if ((c=='>' ||c=='<')
  2277.                             && i <= last-2 
  2278.                             && GetChar(i+1)==c){
  2279.                             file += c;
  2280.                             file += "\\textcompwordmark{}";
  2281.                             column+=19;
  2282.                         } else 
  2283.                             file += c;
  2284.                     } else if(font.family() == LyXFont::TYPEWRITER_FAMILY)
  2285.                         file += c;
  2286.                     else {
  2287.                         file +="\\ensuremath{";
  2288.                         file += c;
  2289.                         file += '}';
  2290.                         column+=13;
  2291.                     }
  2292.                     break;
  2293.                 case '-': // "--" in Typewriter mode -> "-{}-"
  2294.                     if (i <= last-2 
  2295.                         && GetChar(i+1) == '-'
  2296.                         && font.family() == LyXFont::TYPEWRITER_FAMILY) {
  2297.                         file += "-{}";
  2298.                         column += 2;
  2299.                     } else
  2300.                         file += '-';
  2301.                     break;
  2302.                 case '\"': 
  2303.                     file += "\\char`\\\"{}";
  2304.                     column+=9;
  2305.                     break;
  2306.                 case 'ú':
  2307.                     if (current_view->currentBuffer()->params.inputenc == "default") {
  2308.                         file += "\\pounds{}";
  2309.                         column+=8;
  2310.                     } else
  2311.                         file += c;
  2312.                     break;
  2313.                 case '$': case '&': 
  2314.                 case '%': case '#': case '{':   
  2315.                 case '}': case '_': 
  2316.                     file += '\\';
  2317.                     file += c;
  2318.                     column +=1;
  2319.                     break;
  2320.                 case '^': case '~':
  2321.                     file += '\\';
  2322.                     file += c;
  2323.                     file += "{}";
  2324.                     column +=3;
  2325.                     break;
  2326.                 case '*': case '[': case ']':
  2327.                     // avoid being mistaken for optional arguments
  2328.                     file += '{';
  2329.                     file += c;
  2330.                     file += '}';
  2331.                     column +=2;
  2332.                     break;
  2333.                 case ' ':
  2334.                     /* blanks are printed before font switching */
  2335.                     // Sure? I am not! (try nice-latex)
  2336.                     // I am sure it's correct. LyX might be smarter
  2337.                     // in the future, but for now, nothing wrong is
  2338.                     // written. (Asger)
  2339.                     break;
  2340.                 default:
  2341.                     /* idea for labels --- begin*/ 
  2342.  
  2343.                     /* check for LyX */ 
  2344.                     if (c ==  'L' && i <= last-3 
  2345.                         && font.family() 
  2346.                               != LyXFont::TYPEWRITER_FAMILY
  2347.                         && GetChar(i+1) == 'y'
  2348.                         && GetChar(i+2) == 'X'){
  2349.                         file += "\\LyX{}";
  2350.                         i+=2;
  2351.                         column += 5;
  2352.                     }
  2353.                     /* check for TeX */ 
  2354.                     else if (c ==  'T' && i <= last-3 
  2355.                          && font.family() 
  2356.                               != LyXFont::TYPEWRITER_FAMILY
  2357.                          && GetChar(i+1) == 'e'
  2358.                          && GetChar(i+2) == 'X'){
  2359.                         file += "\\TeX{}";
  2360.                         i+=2;
  2361.                         column += 5;
  2362.                     }
  2363.                     /* check for LaTeX2e */ 
  2364.                     else if (c ==  'L' && i <= last-7 
  2365.                          && font.family() 
  2366.                               != LyXFont::TYPEWRITER_FAMILY
  2367.                          && GetChar(i+1) == 'a'
  2368.                          && GetChar(i+2) == 'T'
  2369.                          && GetChar(i+3) == 'e'
  2370.                          && GetChar(i+4) == 'X'
  2371.                          && GetChar(i+5) == '2'
  2372.                          && GetChar(i+6) == 'e'){
  2373.                         file += "\\LaTeXe{}";
  2374.                         i+=6;
  2375.                         column += 8;
  2376.                     }
  2377.                     /* check for LaTeX */ 
  2378.                     else if (c ==  'L' && i <= last-5 
  2379.                          && font.family() 
  2380.                               != LyXFont::TYPEWRITER_FAMILY
  2381.                          && GetChar(i+1) == 'a'
  2382.                          && GetChar(i+2) == 'T'
  2383.                          && GetChar(i+3) == 'e'
  2384.                          && GetChar(i+4) == 'X'){
  2385.                         file += "\\LaTeX{}";
  2386.                         i+=4;
  2387.                         column += 7;
  2388.                     }
  2389.                     else
  2390.                         /* idea for labels --- end*/ 
  2391.                         // same test as above
  2392.                         if (c != '\0')
  2393.                             file += c;
  2394.                     break;
  2395.                 }
  2396.             }
  2397.         }
  2398.     }
  2399.  
  2400.     // If we have an open font definition, we have to close it
  2401.     if (open_font) {
  2402.         running_font.latexWriteEndChanges(file, basefont);
  2403.     }
  2404.  
  2405.     /* needed if there is an optional argument but no contents */ 
  2406.     if (main_body > 0 && main_body == last) {
  2407.         file += "]~";
  2408.         return_value = false;
  2409.     }
  2410.  
  2411.     lyxerr.debug(LString("SimpleTeXOnePar...done ") + (long)this, Error::LATEX);
  2412.     return return_value;
  2413. }
  2414.  
  2415.  
  2416. // This one spits out the text of a table paragraph
  2417. bool LyXParagraph::SimpleTeXOneTablePar(LString &file, TexRow &texrow)
  2418. {
  2419.     lyxerr.debug(LString("SimpleTeXOneTablePar...     ")+(long)this, Error::LATEX);
  2420.     char c;
  2421.     Inset *inset;
  2422.     int column, tmp;
  2423.    
  2424.     bool return_value = false;
  2425.     int current_cell_number = -1;
  2426.  
  2427.     LyXLayout * style = lyxstyle.Style(GetCurrentTextClass(), GetLayout());
  2428.     LyXFont basefont;
  2429.  
  2430.     basefont = getFont(-1); // Get layout font
  2431.     // Which font is currently active?
  2432.     LyXFont running_font = basefont;
  2433.     // Do we have an open font change?
  2434.     bool open_font = false;
  2435.  
  2436.     column = 0;
  2437. #ifdef THIS_IS_WRONG
  2438.     if (!last && !IsDummy()){
  2439.         if (style->isCommand()) {
  2440.             file += '{';
  2441.             column++;
  2442.         } else if (align != LYX_ALIGN_LAYOUT) {
  2443.             file += '{';
  2444.             column++;
  2445.             return_value = true;
  2446.         }
  2447.     } else if (last && !IsDummy())
  2448. #else
  2449.         if (!IsDummy())
  2450. #endif
  2451.             {
  2452.                 if (style->isCommand()) {
  2453.                     file += '{';
  2454.                     column++;
  2455.                 } else if (align != LYX_ALIGN_LAYOUT) {
  2456.                     file += '{';
  2457.                     column++;
  2458.                     return_value = true;
  2459.                 }
  2460.                 if (noindent) {
  2461.                     file += "\\noindent ";
  2462.                     column += 10;
  2463.                 }
  2464.                 switch (align) {
  2465.                 case LYX_ALIGN_LEFT:
  2466.                     file += "\\raggedright ";
  2467.                     column+=13;
  2468.                     break;
  2469.                 case LYX_ALIGN_RIGHT:
  2470.                     file += "\\raggedleft ";
  2471.                     column+=12;
  2472.                     break;
  2473.                 case LYX_ALIGN_CENTER:
  2474.                     file += "\\centering ";
  2475.                     column+=11;
  2476.                     break;
  2477.                 }     
  2478.                 current_cell_number = -1;
  2479.                 tmp = table->TexEndOfCell(file,current_cell_number);
  2480.                 for (;tmp>0;tmp--)
  2481.                     texrow.newline();
  2482.             }
  2483.  
  2484.     texrow.start(this, 0);
  2485.  
  2486.     for (int i = 0; i < last; i++) {
  2487.         c = GetChar(i);
  2488.         if (table->IsContRow(current_cell_number+1)) {
  2489.             if (c == LYX_META_NEWLINE)
  2490.                 current_cell_number++;
  2491.             continue;
  2492.         }
  2493.         column++;
  2494.         
  2495.         // Fully instantiated font
  2496.         LyXFont font = getFont(i);
  2497.         
  2498.         // We end font definition before blanks
  2499.         if (font != running_font && open_font) {
  2500.             column += running_font.latexWriteEndChanges(file, basefont);
  2501.             running_font = basefont;
  2502.             open_font = false;
  2503.         }
  2504.         // Blanks are printed before start of fontswitch
  2505.         if (c==' '){
  2506.             if (column > tex_code_break_column
  2507.                 && i && GetChar(i-1) != ' '
  2508.                 && (i < last-1) &&
  2509.                 // In LaTeX mode, we don't want to
  2510.                 // break lines since some commands
  2511.                 // do not like this
  2512.                 ! (font.latex() == LyXFont::ON) &&
  2513.                 // In typewriter mode, we want to avoid 
  2514.                 // ! . ? : at the end of a line
  2515.                 !(font.family() == LyXFont::TYPEWRITER_FAMILY &&
  2516.                   (GetChar(i-1) == '.' || GetChar(i-1) == '?' ||
  2517.                    GetChar(i-1) == ':' || GetChar(i-1) == '!')))
  2518.                 {
  2519.                     file += '\n';
  2520.                     texrow.newline();
  2521.                     texrow.start(this, i+1);
  2522.                     column = 0;
  2523.                 } else if (font.latex() == LyXFont::OFF) {
  2524.                     if (font.family() == LyXFont::TYPEWRITER_FAMILY)
  2525.                         file += '~';
  2526.                     else
  2527.                         file += ' ';
  2528.                 }
  2529.         }
  2530.         // Do we need to change font?
  2531.         if (font != running_font) {
  2532.             column += font.latexWriteStartChanges(file, basefont);
  2533.             running_font = font;
  2534.             open_font = true;
  2535.         }
  2536.         // Do we need to turn on LaTeX mode?
  2537.         if (font.latex() != running_font.latex()) {
  2538.             if (font.latex() == LyXFont::ON
  2539.                 && style->needprotect)
  2540.                 {
  2541.                     file += "\\protect ";
  2542.                     column += 9;
  2543.                 }
  2544.         }
  2545.         if (c == LYX_META_INSET) {
  2546.             inset = GetInset(i);
  2547.             if (inset) {
  2548.                 tmp = inset->Latex(file, style->isCommand());
  2549.                 if (tmp)
  2550.                     column = 0;
  2551.                 for (;tmp--;)
  2552.                     texrow.newline();
  2553.             }
  2554.         } else {
  2555.             // Are we in LaTeX mode?
  2556.             if (font.latex() == LyXFont::ON) {
  2557.                 switch (c) {
  2558.                 case LYX_META_NEWLINE: 
  2559.                     if (open_font) {
  2560.                         column += running_font.latexWriteEndChanges(file, basefont);
  2561.                         open_font = false;
  2562.                     }
  2563.                     basefont = getFont(-1);
  2564.                     running_font = basefont;
  2565.                     current_cell_number++;
  2566.                     if (table->CellHasContRow(current_cell_number)>=0)
  2567.                         TeXContTableRows(file, i+1,current_cell_number,column, texrow);
  2568.                     // if this cell follow only ContRows til end don't
  2569.                     // put the EndOfCell because it is put after the
  2570.                     // for(...)
  2571.                     if (table->ShouldBeVeryLastCell(current_cell_number))
  2572.                         break;
  2573.                     tmp = table->TexEndOfCell(file, current_cell_number);
  2574.                     if (tmp>0)
  2575.                         column = 0;
  2576.                     else if (tmp < 0)
  2577.                         tmp = -tmp;
  2578.                     for (;tmp--;)
  2579.                         texrow.newline();
  2580.                     texrow.start(this, i+1);
  2581.                     break;  
  2582.                 case LYX_META_HFILL: 
  2583.                     file += "\\hfill{}";
  2584.                     column+=7;
  2585.                     break;
  2586.                 case LYX_META_PROTECTED_SEPARATOR: 
  2587.                     file += '~';
  2588.                     break;
  2589.                 default:
  2590.                     // make sure that we will not print
  2591.                     // error generating chars to the tex
  2592.                     // file. This test would not be needed
  2593.                     // if it were done in the buffer
  2594.                     // itself.
  2595.                     if (c != '\0')
  2596.                         file += c;
  2597.                     break;
  2598.                 }
  2599.             } else {
  2600.                 // Plain mode (i.e. not LaTeX)
  2601.                 switch (c) {
  2602.                 case LYX_META_NEWLINE: 
  2603.                     if (open_font) {
  2604.                         column += running_font.latexWriteEndChanges(file, basefont);
  2605.                         open_font = false;
  2606.                     }
  2607.                     basefont = getFont(-1);
  2608.                     running_font = basefont;
  2609.  
  2610.                     current_cell_number++;
  2611.                     if (table->CellHasContRow(current_cell_number)>=0)
  2612.                         TeXContTableRows(file,i+1,current_cell_number,column, texrow);
  2613.                     // if this cell follow only ContRows til end don't
  2614.                     // put the EndOfCell because it is put after the
  2615.                     // for(...)
  2616.                     if (table->ShouldBeVeryLastCell(current_cell_number))
  2617.                         break;
  2618.                     tmp = table->TexEndOfCell(file, current_cell_number);
  2619.                     if (tmp>0)
  2620.                         column = 0;
  2621.                     else if (tmp < 0)
  2622.                         tmp = -tmp;
  2623.                     for (;tmp>0;tmp--)
  2624.                         texrow.newline();
  2625.                     texrow.start(this, i+1);
  2626.                     break;
  2627.                 case LYX_META_HFILL: 
  2628.                     file += "\\hfill{}";
  2629.                     column+=7;
  2630.                     break;
  2631.                 case LYX_META_PROTECTED_SEPARATOR: 
  2632.                     file += '~';
  2633.                     break;
  2634.                 case '\\': 
  2635.                     if (lyxrc->fontenc=="T1" 
  2636.                         || font.family() == LyXFont::TYPEWRITER_FAMILY){ 
  2637.                         file += "\\char`\\\\{}";
  2638.                         column+=9;
  2639.                     } else {
  2640.                         file += "\\ensuremath{\\backslash}";
  2641.                         column+=22;
  2642.                     }
  2643.                     break;
  2644.                 case '░': case '▒': case '▓': case '│':  
  2645.                 case '╫': case '≈': case '╣': case '¬':
  2646.                 case '║': case '¼': case '╡':
  2647.                     if (current_view->currentBuffer()->params.inputenc == "latin1") {
  2648.                         file += "\\ensuremath{";
  2649.                         file += c;
  2650.                         file += '}';
  2651.                         column+=13;
  2652.                     } else
  2653.                         file += c;
  2654.                     break;
  2655.                 case '|': case '<': case '>':
  2656.                     if (lyxrc->fontenc=="T1") {
  2657.                         if ((c=='>' ||c=='<')
  2658.                             && i <= last-2 
  2659.                             && GetChar(i+1)==c){
  2660.                             file += c;
  2661.                             file += "\\textcompwordmark{}";
  2662.                             column+=19;
  2663.                         } else 
  2664.                             file += c;
  2665.                     } else if(font.family() == LyXFont::TYPEWRITER_FAMILY)
  2666.                         file += c;
  2667.                     else {
  2668.                         file += "\\ensuremath{";
  2669.                         file += c;
  2670.                         file += '}';
  2671.                         column+=13;
  2672.                     }
  2673.                     break;
  2674.                 case '-': // "--" in Typewriter mode -> "-{}-"
  2675.                     if (i <= last-2 
  2676.                         && GetChar(i+1) == '-'
  2677.                         && font.family() == LyXFont::TYPEWRITER_FAMILY) {
  2678.                         file += "-{}";
  2679.                         column += 2;
  2680.                     } else
  2681.                         file += '-';
  2682.                     break;
  2683.                 case '\"': 
  2684.                     file += "\\char`\\\"{}";
  2685.                     column+=9;
  2686.                     break;
  2687.                 case 'ú':
  2688.                     if (current_view->currentBuffer()->params.inputenc == "default") {
  2689.                         file += "\\pounds{}";
  2690.                         column+=8;
  2691.                     } else
  2692.                         file += c;
  2693.                     break;
  2694.                 case '$': case '&': 
  2695.                 case '%': case '#': case '{':   
  2696.                 case '}': case '_': 
  2697.                     file += '\\';
  2698.                     file += c;
  2699.                     column +=1;
  2700.                     break;
  2701.                 case '^': case '~':
  2702.                     file += '\\';
  2703.                     file += c;
  2704.                     file += "{}";
  2705.                     column +=3;
  2706.                     break;
  2707.                 case '*': case '[': case ']':
  2708.                     // avoid being mistaken for optional arguments
  2709.                     file += '{';
  2710.                     file += c;
  2711.                     file += '}';
  2712.                     column +=2;
  2713.                     break;
  2714.                 case ' ':
  2715.                     /* blanks are printed before font switching */
  2716.                     // Sure? I am not! (try nice-latex)
  2717.                     // I am sure it's correct. LyX might be smarter
  2718.                     // in the future, but for now, nothing wrong is
  2719.                     // written. (Asger)
  2720.                     break;
  2721.                 default:
  2722.                     /* idea for labels --- begin*/ 
  2723.  
  2724.                     /* check for LyX */ 
  2725.                     if (c ==  'L' && i <= last-3
  2726.                         && font.family() 
  2727.                            != LyXFont::TYPEWRITER_FAMILY
  2728.                         && GetChar(i+1) == 'y'
  2729.                         && GetChar(i+2) == 'X'){
  2730.                         file += "\\LyX{}";
  2731.                         i+=2;
  2732.                         column += 5;
  2733.                     }
  2734.                     /* check for TeX */ 
  2735.                     else if (c ==  'T' && i <= last-3
  2736.                          && font.family() 
  2737.                           != LyXFont::TYPEWRITER_FAMILY
  2738.                          && GetChar(i+1) == 'e'
  2739.                          && GetChar(i+2) == 'X'){
  2740.                         file += "\\TeX{}";
  2741.                         i+=2;
  2742.                         column += 5;
  2743.                     }
  2744.                     /* check for LaTeX2e */ 
  2745.                     else if (c ==  'L' && i <= last-7 
  2746.                          && font.family() 
  2747.                           != LyXFont::TYPEWRITER_FAMILY
  2748.                          && GetChar(i+1) == 'a'
  2749.                          && GetChar(i+2) == 'T'
  2750.                          && GetChar(i+3) == 'e'
  2751.                          && GetChar(i+4) == 'X'
  2752.                          && GetChar(i+5) == '2'
  2753.                          && GetChar(i+6) == 'e'){
  2754.                         file += "\\LaTeXe{}";
  2755.                         i+=6;
  2756.                         column += 8;
  2757.                     }
  2758.                     /* check for LaTeX */ 
  2759.                     else if (c ==  'L' && i <= last-5 
  2760.                          && font.family() 
  2761.                           != LyXFont::TYPEWRITER_FAMILY
  2762.                          && GetChar(i+1) == 'a'
  2763.                          && GetChar(i+2) == 'T'
  2764.                          && GetChar(i+3) == 'e'
  2765.                          && GetChar(i+4) == 'X'){
  2766.                         file += "\\LaTeX{}";
  2767.                         i+=4;
  2768.                         column += 7;
  2769.                     } else
  2770.                         /* idea for labels --- end*/ 
  2771.                         // same test as above
  2772.                         if (c != '\0')
  2773.                             file += c;
  2774.                     break;
  2775.                 }
  2776.             }
  2777.         }
  2778.     }
  2779.  
  2780.     // If we have an open font definition, we have to close it
  2781.     if (open_font) {
  2782.         running_font.latexWriteEndChanges(file, basefont);
  2783.     }
  2784.     current_cell_number++;
  2785.     tmp = table->TexEndOfCell(file, current_cell_number);
  2786.     for (;tmp>0;tmp--)
  2787.         texrow.newline();
  2788.     lyxerr.debug(LString("SimpleTeXOneTablePar...done ")+(long)this, Error::LATEX);
  2789.     return return_value;
  2790. }
  2791.  
  2792.  
  2793. // This one spits out the text off ContRows in tables
  2794. bool LyXParagraph::TeXContTableRows(LString &file, int i,
  2795.                     int current_cell_number,
  2796.                     int &column, TexRow &texrow)
  2797. {
  2798.     lyxerr.debug(LString("TeXContTableRows...     ")+(long)this, Error::LATEX);
  2799.     if (!table)
  2800.         return false;
  2801.     
  2802.     char c;
  2803.     Inset *inset;
  2804.     int tmp, cell;
  2805.     int lastpos;
  2806.    
  2807.     bool return_value = false;
  2808.     LyXLayout * style = lyxstyle.Style(GetCurrentTextClass(), GetLayout());
  2809.     LyXFont basefont;
  2810.  
  2811.     basefont = getFont(-1); // Get layout font
  2812.     // Which font is currently active?
  2813.     LyXFont running_font = basefont;
  2814.     // Do we have an open font change?
  2815.     bool open_font = false;
  2816.  
  2817.     lastpos = i;
  2818.     cell = table->CellHasContRow(current_cell_number);
  2819.     current_cell_number++;
  2820.     while(cell >= 0) {
  2821.         // first find the right position
  2822.         i = lastpos;
  2823.         for (; (i<last) && (current_cell_number<cell); i++) {
  2824.             c = GetChar(i);
  2825.             if (c == LYX_META_NEWLINE)
  2826.                 current_cell_number++;
  2827.         }
  2828.         lastpos = i;
  2829.         c=GetChar(i);
  2830.         if (table->Linebreaks(table->FirstVirtualCell(cell))) {
  2831.             file += " \\\\\n";
  2832.             texrow.newline();
  2833.             column = 0;
  2834.         } else if ((c != ' ') && (c != LYX_META_NEWLINE))
  2835.             file += ' ';
  2836.         for (; (i < last) && ((c=GetChar(i)) != LYX_META_NEWLINE); i++) {
  2837.             column++;
  2838.  
  2839.             // Fully instantiated font
  2840.             LyXFont font = getFont(i);
  2841.             
  2842.             // We end font definition before blanks
  2843.             if (font != running_font && open_font) {
  2844.                 column += running_font.latexWriteEndChanges(file, basefont);
  2845.                 running_font = basefont;
  2846.                 open_font = false;
  2847.             }
  2848.             // Blanks are printed before start of fontswitch
  2849.             if (c==' '){
  2850.                 if (column > tex_code_break_column
  2851.                     && i && GetChar(i-1) != ' '
  2852.                     && (i < last-1) &&
  2853.                     // In LaTeX mode, we don't want to
  2854.                     // break lines since some commands
  2855.                     // do not like this
  2856.                     ! (font.latex() == LyXFont::ON) &&
  2857.                     // In typewriter mode, we want to avoid 
  2858.                     // ! . ? : at the end of a line
  2859.                     !(font.family() == LyXFont::TYPEWRITER_FAMILY &&
  2860.                       (GetChar(i-1) == '.' || GetChar(i-1) == '?' ||
  2861.                        GetChar(i-1) == ':' || GetChar(i-1) == '!')))
  2862.                     {
  2863.                         file += '\n';
  2864.                         texrow.newline();
  2865.                         texrow.start(this, i+1);
  2866.                         column = 0;
  2867.                     } else if (font.latex() == LyXFont::OFF) {
  2868.                         if (font.family() == LyXFont::TYPEWRITER_FAMILY)
  2869.                             file += '~';
  2870.                         else
  2871.                             file += ' ';
  2872.                     }
  2873.             }
  2874.             // Do we need to change font?
  2875.             if (font != running_font) {
  2876.                 column += font.latexWriteStartChanges(file, basefont);
  2877.                 running_font = font;
  2878.                 open_font = true;
  2879.             }
  2880.             // Do we need to turn on LaTeX mode?
  2881.             if (font.latex() != running_font.latex()) {
  2882.                 if (font.latex() == LyXFont::ON
  2883.                     && style->needprotect)
  2884.                     {
  2885.                         file += "\\protect ";
  2886.                         column += 9;
  2887.                     }
  2888.             }
  2889.             if (c == LYX_META_INSET) {
  2890.                 inset = GetInset(i);
  2891.                 if (inset) {
  2892.                     tmp = inset->Latex(file, style->isCommand());
  2893.                     if (tmp)
  2894.                         column = 0;
  2895.                     for (;tmp--;)
  2896.                         texrow.newline();
  2897.                 }
  2898.             } else {
  2899.                 // Are we in LaTeX mode?
  2900.                 if (font.latex() == LyXFont::ON) {
  2901.                     switch (c) {
  2902.                     case LYX_META_NEWLINE: 
  2903.                         if (open_font) {
  2904.                             column += running_font.latexWriteEndChanges(file, basefont);
  2905.                             open_font = false;
  2906.                         }
  2907.                         basefont = getFont(-1);
  2908.                         running_font = basefont;
  2909.                         break;  
  2910.                     case LYX_META_HFILL: 
  2911.                         file += "\\hfill{}";
  2912.                         column+=7;
  2913.                         break;
  2914.                     case LYX_META_PROTECTED_SEPARATOR: 
  2915.                         file += '~';
  2916.                         break;
  2917.                     default:
  2918.                         // make sure that we will not print
  2919.                         // error generating chars to the tex
  2920.                         // file. This test would not be needed
  2921.                         // if it were done in the buffer
  2922.                         // itself.
  2923.                         if (c != '\0')
  2924.                             file += (char)c;
  2925.                         break;
  2926.                     }
  2927.                 } else {
  2928.                     // Plain mode (i.e. not LaTeX)
  2929.                     switch (c) {
  2930.                     case LYX_META_NEWLINE: 
  2931.                         if (open_font) {
  2932.                             column += running_font.latexWriteEndChanges(file, basefont);
  2933.                             open_font = false;
  2934.                         }
  2935.                         basefont = getFont(-1);
  2936.                         running_font = basefont;
  2937.                         break;
  2938.                     case LYX_META_HFILL: 
  2939.                         file += "\\hfill{}";
  2940.                         column+=7;
  2941.                         break;
  2942.                     case LYX_META_PROTECTED_SEPARATOR: 
  2943.                         file += '~';
  2944.                         break;
  2945.                     case '\\': 
  2946.                         if (lyxrc->fontenc=="T1" 
  2947.                             || font.family() == LyXFont::TYPEWRITER_FAMILY){ 
  2948.                             file += "\\char`\\\\{}";
  2949.                             column+=9;
  2950.                         } else {
  2951.                             file += "\\ensuremath{\\backslash}";
  2952.                             column+=22;
  2953.                         }
  2954.                         break;
  2955.                     case '░': case '▒': case '▓': case '│':  
  2956.                     case '╫': case '≈': case '╣': case '¬':
  2957.                     case '║': case '¼': case '╡':
  2958.                         if (current_view->currentBuffer()->params.inputenc == "latin1") {
  2959.                             file += "\\ensuremath{";
  2960.                             file += c;
  2961.                             file += '}';
  2962.                             column+=13;
  2963.                         } else
  2964.                             file += c;
  2965.                         break;
  2966.                     case '|': case '<': case '>':
  2967.                         if (lyxrc->fontenc=="T1") {
  2968.                             if ((c=='>' ||c=='<')
  2969.                                 && i <= last-2 
  2970.                                 && GetChar(i+1)==c){
  2971.                                 file += c;
  2972.                                 file += "\\textcompwordmark{}";
  2973.                                 column+=19;
  2974.                             } else 
  2975.                                 file += c;
  2976.                         } else if(font.family() == LyXFont::TYPEWRITER_FAMILY)
  2977.                             file += c;
  2978.                         else {
  2979.                             file += "\\ensuremath{";
  2980.                             file += c;
  2981.                             file += '}';
  2982.                             column+=13;
  2983.                         }
  2984.                         break;
  2985.                     case '-': // "--" in Typewriter mode -> "-{}-"
  2986.                         if (i <= last-2 
  2987.                             && GetChar(i+1) == '-'
  2988.                             && font.family() == LyXFont::TYPEWRITER_FAMILY) {
  2989.                             file += "-{}";
  2990.                             column += 2;
  2991.                         } else
  2992.                             file += '-';
  2993.                         break;
  2994.                     case '\"': 
  2995.                         file += "\\char`\\\"{}";
  2996.                         column+=9;
  2997.                         break;
  2998.                     case 'ú':
  2999.                     if (current_view->currentBuffer()->params.inputenc == "default") {
  3000.                         file += "\\pounds{}";
  3001.                         column+=8;
  3002.                     } else
  3003.                         file += c;
  3004.                         break;
  3005.                     case '$': case '&': 
  3006.                     case '%': case '#': case '{':   
  3007.                     case '}': case '_': 
  3008.                         file += '\\';
  3009.                         file += c;
  3010.                         column +=1;
  3011.                         break;
  3012.                     case '^': case '~':
  3013.                         file += '\\';
  3014.                         file += c;
  3015.                         file += "{}";
  3016.                         column +=3;
  3017.                         break;
  3018.                     case '*': case '[': case ']':
  3019.                         // avoid being mistaken for optional arguments
  3020.                         file += '{';
  3021.                         file += c;
  3022.                         file += '}';
  3023.                         column +=2;
  3024.                         break;
  3025.                     case ' ':
  3026.                         /* blanks are printed before font switching */
  3027.                         // Sure? I am not! (try nice-latex)
  3028.                         // I am sure it's correct. LyX might be smarter
  3029.                         // in the future, but for now, nothing wrong is
  3030.                         // written. (Asger)
  3031.                         break;
  3032.                     default:
  3033.                         /* idea for labels --- begin*/ 
  3034.  
  3035.                         /* check for LyX */ 
  3036.                         if (c ==  'L' && i <= last-3
  3037.                                    && font.family() 
  3038.                              != LyXFont::TYPEWRITER_FAMILY
  3039.                             && GetChar(i+1) == 'y'
  3040.                             && GetChar(i+2) == 'X'){
  3041.                             file += "\\LyX{}";
  3042.                             i+=2;
  3043.                             column += 5;
  3044.                         }
  3045.                         /* check for TeX */ 
  3046.                         else if (c ==  'T' && i <= last-3 
  3047.                              && font.family() 
  3048.                               != LyXFont::TYPEWRITER_FAMILY
  3049.                              && GetChar(i+1) == 'e'
  3050.                              && GetChar(i+2) == 'X'){
  3051.                             file += "\\TeX{}";
  3052.                             i+=2;
  3053.                             column += 5;
  3054.                         }
  3055.                         /* check for LaTeX2e */ 
  3056.                         else if (c ==  'L' && i <= last-7 
  3057.                              && font.family() 
  3058.                               != LyXFont::TYPEWRITER_FAMILY
  3059.                              && GetChar(i+1) == 'a'
  3060.                              && GetChar(i+2) == 'T'
  3061.                              && GetChar(i+3) == 'e'
  3062.                              && GetChar(i+4) == 'X'
  3063.                              && GetChar(i+5) == '2'
  3064.                              && GetChar(i+6) == 'e'){
  3065.                             file += "\\LaTeXe{}";
  3066.                             i+=6;
  3067.                             column += 8;
  3068.                         }
  3069.                         /* check for LaTeX */ 
  3070.                         else if (c ==  'L' && i <= last-5 
  3071.                              && font.family() 
  3072.                                   != LyXFont::TYPEWRITER_FAMILY
  3073.                              && GetChar(i+1) == 'a'
  3074.                              && GetChar(i+2) == 'T'
  3075.                              && GetChar(i+3) == 'e'
  3076.                              && GetChar(i+4) == 'X'){
  3077.                             file += "\\LaTeX{}";
  3078.                             i+=4;
  3079.                             column += 7;
  3080.                         } else
  3081.                             /* idea for labels --- end*/ 
  3082.                             // same test as above
  3083.                             if (c != '\0')
  3084.                                 file += c;
  3085.                         break;
  3086.                     }
  3087.                 }
  3088.             }
  3089.         }
  3090.         // If we have an open font definition, we have to close it
  3091.         if (open_font) {
  3092.             running_font.latexWriteEndChanges(file, basefont);
  3093.             open_font=false;
  3094.         }
  3095.         basefont = getFont(-1);
  3096.         running_font = basefont;
  3097.         cell = table->CellHasContRow(current_cell_number);
  3098.     }
  3099.     lyxerr.debug(LString("TeXContTableRows...done ")+(long)this, Error::LATEX);
  3100.     return return_value;
  3101. }
  3102.  
  3103. bool LyXParagraph::RoffContTableRows(FILE *fp, int i, int actcell)
  3104. {
  3105.     if (!table)
  3106.         return false;
  3107.  
  3108.     LyXFont
  3109.         font1 = LyXFont(LyXFont::ALL_INHERIT),
  3110.         font2;
  3111.     Inset
  3112.         *inset;
  3113.     int
  3114.         lastpos, cell;
  3115.     char
  3116.         c;
  3117.     LString
  3118.         fname2;
  3119.     FILE
  3120.         *fp2;
  3121.  
  3122.     fname2 = TmpFileName(LString(),"RAT2");
  3123.     lastpos = i;
  3124.     cell = table->CellHasContRow(actcell);
  3125.     actcell++;
  3126.     while(cell >= 0) {
  3127.         // first find the right position
  3128.         i = lastpos;
  3129.         for (; (i<last) && (actcell<cell); i++) {
  3130.             c = GetChar(i);
  3131.             if (c == LYX_META_NEWLINE)
  3132.                 actcell++;
  3133.         }
  3134.         lastpos = i;
  3135.         c=GetChar(i);
  3136.         if ((c != ' ') && (c != LYX_META_NEWLINE))
  3137.             fprintf(fp," ");
  3138.         for (; (i < last) && ((c=GetChar(i)) != LYX_META_NEWLINE); i++) {
  3139.             font2 = GetFontSettings(i);
  3140.             if (font1.latex() != font2.latex()) {
  3141.                 if (font2.latex() != LyXFont::OFF)
  3142.                     continue;
  3143.             }
  3144.             c = GetChar(i);
  3145.             switch (c) {
  3146.             case LYX_META_INSET:
  3147.                 if ((inset = GetInset(i))) {
  3148.                     if (!(fp2=fopen(fname2.c_str(),"w+"))) {
  3149.                         WriteAlert(_("LYX_ERROR:"), _("Cannot open temporary file:"), fname2);
  3150.                         return false;
  3151.                     }
  3152.                     inset->Latex(fp2,-1);
  3153.                     rewind(fp2);
  3154.                     c = fgetc(fp2);
  3155.                     while(!feof(fp2)) {
  3156.                         if (c == '\\')
  3157.                             fprintf(fp,"\\\\");
  3158.                         else
  3159.                             fputc(c,fp);
  3160.                         c = fgetc(fp2);
  3161.                     }
  3162.                     fclose(fp2);
  3163.                 }
  3164.                 break;
  3165.             case LYX_META_NEWLINE:
  3166.                 break;
  3167.             case LYX_META_HFILL: 
  3168.                 break;
  3169.             case LYX_META_PROTECTED_SEPARATOR:
  3170.                 break;
  3171.             case '\\': 
  3172.                 fprintf(fp, "\\\\");
  3173.                 break;
  3174.             default:
  3175.                 if (c != '\0')
  3176.                     fprintf(fp, "%c", c);
  3177.                 else
  3178.                     lyxerr.debug("RoffAsciiTable: NULL char in structure.");
  3179.                 break;
  3180.             }
  3181.         }
  3182.         cell = table->CellHasContRow(actcell);
  3183.     }
  3184.     return true;
  3185. }
  3186.  
  3187. LyXParagraph * LyXParagraph::TeXDeeper(LString &file, TexRow &texrow,
  3188.                        LString &foot, TexRow &foot_texrow,
  3189.                        int &foot_count)
  3190. {
  3191.     lyxerr.debug(LString("TeXDeeper...     ") + (long)this, Error::LATEX);
  3192.     LyXParagraph *par = this;
  3193.  
  3194.     while (par && par->depth == depth) {
  3195.         if (par->IsDummy())
  3196.             lyxerr.print("ERROR (LyXParagraph::TeXDeeper)");
  3197.         if (lyxstyle.Style(GetCurrentTextClass(), 
  3198.                    par->layout)->isEnvironment()
  3199.             || par->pextra_type != PEXTRA_NONE) 
  3200.             {
  3201.                 par = par->TeXEnvironment(file, texrow,
  3202.                               foot, foot_texrow,
  3203.                               foot_count);
  3204.             } else {
  3205.                 par = par->TeXOnePar(file, texrow,
  3206.                              foot, foot_texrow,
  3207.                              foot_count);
  3208.             }
  3209.     }
  3210.     lyxerr.debug(LString("TeXDeeper...done ") + (long)par, Error::LATEX);
  3211.  
  3212.     return par;
  3213. }
  3214.  
  3215.  
  3216. LyXParagraph* LyXParagraph::TeXEnvironment(LString &file, TexRow &texrow,
  3217.                        LString &foot, TexRow &foot_texrow,
  3218.                        int &foot_count)
  3219. {
  3220.     bool
  3221.         eindent_open = false;
  3222.         static bool
  3223.         minipage_open = false;
  3224.         static int
  3225.                 minipage_open_depth = 0;
  3226.     char
  3227.         par_sep = current_view->currentBuffer()->params.paragraph_separation;
  3228.     
  3229.     lyxerr.debug(LString("TeXEnvironment...     ") + long(this), Error::LATEX);
  3230.     if (IsDummy())
  3231.         lyxerr.print("ERROR (LyXParagraph::TeXEnvironment)");
  3232.  
  3233.     LyXLayout * style = lyxstyle.Style(GetCurrentTextClass(), layout);
  3234.        
  3235.     if (pextra_type == PEXTRA_INDENT) {
  3236.         if (!pextra_width.empty()) {
  3237.             file += "\\begin{LyXParagraphIndent}{"
  3238.                 + pextra_width + "}\n";
  3239.         } else {
  3240.             //float ib = atof(pextra_widthp.c_str())/100;
  3241.             // LString can't handle floats at present (971109)
  3242.             // so I'll do a conversion by hand knowing that
  3243.             // the limits are 0.0 to 1.0. ARRae.
  3244.             file += "\\begin{LyXParagraphIndent}{";
  3245.             switch (pextra_widthp.length()) {
  3246.             case 3:
  3247.                 file += "1.00";
  3248.                 break;
  3249.             case 2:
  3250.                 file += "0.";
  3251.                 file += pextra_widthp;
  3252.                 break;
  3253.             case 1:
  3254.                 file += "0.0";
  3255.                 file += pextra_widthp;
  3256.             }
  3257.             file += "\\columnwidth}\n";
  3258.         }
  3259.         texrow.newline();
  3260.         eindent_open = true;
  3261.     }
  3262.     if ((pextra_type == PEXTRA_MINIPAGE) && !minipage_open) {
  3263.         if (pextra_hfill && Previous() &&
  3264.             (Previous()->pextra_type == PEXTRA_MINIPAGE)) {
  3265.             file += "\\hfill{}\n";
  3266.             texrow.newline();
  3267.         }
  3268.         if (par_sep == LYX_PARSEP_INDENT) {
  3269.             file += "{\\setlength\\parindent{0pt}\n";
  3270.             texrow.newline();
  3271.         }
  3272.         file += "\\begin{minipage}";
  3273.         switch(pextra_alignment) {
  3274.         case MINIPAGE_ALIGN_TOP:
  3275.             file += "[t]";
  3276.             break;
  3277.         case MINIPAGE_ALIGN_MIDDLE:
  3278.             file += "[m]";
  3279.             break;
  3280.         case MINIPAGE_ALIGN_BOTTOM:
  3281.             file += "[b]";
  3282.             break;
  3283.         }
  3284.         if (!pextra_width.empty()) {
  3285.             file += '{';
  3286.             file += pextra_width + "}\n";
  3287.         } else {
  3288.             //float ib = atof(par->pextra_width.c_str())/100;
  3289.             // LString can't handle floats at present
  3290.             // so I'll do a conversion by hand knowing that
  3291.             // the limits are 0.0 to 1.0. ARRae.
  3292.             file += '{';
  3293.             switch (pextra_widthp.length()) {
  3294.             case 3:
  3295.                 file += "1.00";
  3296.                 break;
  3297.             case 2:
  3298.                 file += "0.";
  3299.                 file += pextra_widthp;
  3300.                 break;
  3301.             case 1:
  3302.                 file += "0.0";
  3303.                 file += pextra_widthp;
  3304.             }
  3305.             file += "\\columnwidth}\n";
  3306.         }
  3307.         texrow.newline();
  3308.         if (par_sep == LYX_PARSEP_INDENT) {
  3309.             file += "\\setlength\\parindent{\\LyXMinipageIndent}\n";
  3310.             texrow.newline();
  3311.         }
  3312.         minipage_open = true;
  3313.                 minipage_open_depth = depth;
  3314.     }
  3315.     if (style->isEnvironment()){
  3316.         if (style->latextype == LATEX_LIST_ENVIRONMENT)
  3317.             file += "\\begin{" + style->latexname + "}{"
  3318.                 + labelwidthstring + "}\n";
  3319.         else if (style->labeltype == LABEL_BIBLIO) {
  3320.             // ale970405
  3321.             file += "\\begin{" + style->latexname + "}{"
  3322.                 + bibitemWidthest() + "}\n";
  3323.         }
  3324.         //arrae970411
  3325.         else if (style->latexparam.empty())
  3326.             file += "\\begin{" + style->latexname + "}\n";
  3327.         else
  3328.             file += "\\begin{" + style->latexname + "}{"
  3329.                 + style->latexparam + "}\n";
  3330.         texrow.newline();
  3331.     }
  3332.     LyXParagraph *par = this;
  3333.     do {
  3334.         par = par->TeXOnePar(file, texrow,
  3335.                      foot, foot_texrow, foot_count);
  3336. #if 0
  3337.         if (eindent_open && par && par->pextra_type != PEXTRA_INDENT) {
  3338.             file += "\\end{LyXParagraphIndent}\n";
  3339.             texrow.newline();
  3340.             eindent_open = false;
  3341.             if (!style->isEnvironment())
  3342.                 break;
  3343.         }
  3344. #endif
  3345.                 if (minipage_open && par && !style->isEnvironment() &&
  3346.                     (par->pextra_type == PEXTRA_MINIPAGE) &&
  3347.                     par->pextra_start_minipage) {
  3348.                     file += "\\end{minipage}\n";
  3349.                     texrow.newline();
  3350.                     if (par_sep == LYX_PARSEP_INDENT) {
  3351.                         file += "}\n";
  3352.             texrow.newline();
  3353.                     }
  3354.                     minipage_open = false;
  3355.                 }
  3356.         if (par && par->depth > depth) {
  3357.             if (lyxstyle.Style(GetCurrentTextClass(),
  3358.                        par->layout)->isParagraph()
  3359.                 && !par->table
  3360.                 && !file.suffixIs("\n\n")) {
  3361.                 // There should be at least one '\n' already
  3362.                 // but we need there to be two for Standard 
  3363.                 // paragraphs that are depth-increment'ed to be
  3364.                 // output correctly.  However, tables can also be
  3365.                 // paragraphs so don't adjust them.  ARRae
  3366.                 file += '\n';
  3367.                 texrow.newline();
  3368.             }
  3369.             par = par->TeXDeeper(file, texrow,
  3370.                          foot, foot_texrow, foot_count);
  3371.         }
  3372.         if (par && par->layout == layout && par->depth == depth &&
  3373.             (par->pextra_type == PEXTRA_MINIPAGE) && !minipage_open) {
  3374.             if (par->pextra_hfill && par->Previous() &&
  3375.                 (par->Previous()->pextra_type == PEXTRA_MINIPAGE))
  3376.                 file += "\\hfill{}\n";
  3377.             else
  3378.                 file += '\n';
  3379.             texrow.newline();
  3380.             if (par_sep == LYX_PARSEP_INDENT) {
  3381.                 file += "{\\setlength\\parindent{0pt}\n";
  3382.                 texrow.newline();
  3383.             }
  3384.             file += "\\begin{minipage}";
  3385.             switch(par->pextra_alignment) {
  3386.             case MINIPAGE_ALIGN_TOP:
  3387.                 file += "[t]";
  3388.                 break;
  3389.             case MINIPAGE_ALIGN_MIDDLE:
  3390.                 file += "[m]";
  3391.                 break;
  3392.             case MINIPAGE_ALIGN_BOTTOM:
  3393.                 file += "[b]";
  3394.                 break;
  3395.             }
  3396.             if (!par->pextra_width.empty()) {
  3397.                 file += '{';
  3398.                 file += par->pextra_width;
  3399.                 file += "}\n";
  3400.             } else {
  3401.                 //float ib = atof(par->pextra_widthp.c_str())/100;
  3402.                 // LString can't handle floats at present
  3403.                 // so I'll do a conversion by hand knowing that
  3404.                 // the limits are 0.0 to 1.0. ARRae.
  3405.                 file += '{';
  3406.                 switch (par->pextra_widthp.length()) {
  3407.                 case 3:
  3408.                     file += "1.00";
  3409.                     break;
  3410.                 case 2:
  3411.                     file += "0.";
  3412.                     file += par->pextra_widthp;
  3413.                     break;
  3414.                 case 1:
  3415.                     file += "0.0";
  3416.                     file += par->pextra_widthp;
  3417.                 }
  3418.                 file += "\\columnwidth}\n";
  3419.             }
  3420.             texrow.newline();
  3421.             if (par_sep == LYX_PARSEP_INDENT) {
  3422.                 file += "\\setlength\\parindent{\\LyXMinipageIndent}\n";
  3423.                 texrow.newline();
  3424.             }
  3425.             minipage_open = true;
  3426.                         minipage_open_depth = par->depth;
  3427.         }
  3428.     } while (par
  3429.          && par->layout == layout
  3430.          && par->depth == depth
  3431.          && par->pextra_type == pextra_type);
  3432.  
  3433.     if (style->isEnvironment()) {
  3434.         file += "\\end{" + style->latexname + '}';
  3435.         //texrow.newline();
  3436.     }
  3437.         if (minipage_open && (minipage_open_depth == depth) &&
  3438.             (!par || par->pextra_start_minipage ||
  3439.              par->pextra_type != PEXTRA_MINIPAGE)) {
  3440.                 file += "\\end{minipage}\n";
  3441.         texrow.newline();
  3442.                 if (par_sep == LYX_PARSEP_INDENT) {
  3443.                         file += "}\n";
  3444.             texrow.newline();
  3445.                 }
  3446.                 if (par && par->pextra_type != PEXTRA_MINIPAGE) {
  3447.                         file += "\\medskip\n\n";
  3448.             texrow.newline();
  3449.             texrow.newline();
  3450.                 }
  3451.                 minipage_open = false;
  3452.         }
  3453.     if (eindent_open) {
  3454.         file += "\\end{LyXParagraphIndent}\n";
  3455.         texrow.newline();
  3456.     }
  3457. //    if (tex_code_break_column){
  3458.         if (!(par && (par->pextra_type==PEXTRA_MINIPAGE) 
  3459.           && par->pextra_hfill)) {
  3460.                 file += '\n';
  3461.         texrow.newline();
  3462.     }
  3463.     lyxerr.debug(LString("TeXEnvironment...done ") 
  3464.              + (long)par, Error::LATEX);
  3465.     return par;  // ale970302
  3466. }
  3467.  
  3468.  
  3469. LyXParagraph * LyXParagraph::TeXFootnote(LString &file, TexRow &texrow,
  3470.                      LString &foot, TexRow &foot_texrow,
  3471.                      int &foot_count)
  3472. {
  3473.     lyxerr.debug(LString("TeXFootnote...     ") 
  3474.              + (long)this, Error::LATEX);
  3475.     if (footnoteflag == LyXParagraph::NO_FOOTNOTE)
  3476.         lyxerr.print("ERROR (LyXParagraph::TeXFootnote): "
  3477.                  "No footnote!");
  3478.  
  3479.     LyXParagraph *par = this;
  3480.     LyXLayout * style = lyxstyle.Style(GetCurrentTextClass(), 
  3481.                        previous->GetLayout());
  3482.     
  3483.     if (style->needprotect && footnotekind != LyXParagraph::FOOTNOTE){
  3484.         lyxerr.print("ERROR (LyXParagraph::TeXFootnote): "
  3485.                  "Float other than footnote in command"
  3486.                  " with moving argument is illegal");
  3487.     }
  3488.  
  3489.     BufferParams *params = ¤t_view->currentBuffer()->params;
  3490.     bool footer_in_body = true;
  3491.     switch (footnotekind) {
  3492.     case LyXParagraph::FOOTNOTE:
  3493.         if (style->intitle) {
  3494.             file += "\\thanks{\n";
  3495.             footer_in_body = false;
  3496.         } else {
  3497.             if (foot_count == -1) {
  3498.                 // we're at depth 0 so we can use:
  3499.                 file += "\\footnote{\n";
  3500.                 footer_in_body = false;
  3501.             } else {
  3502.                 file += "\\footnotemark{}\n";
  3503.                 if (foot_count) {
  3504.                     // we only need this when there are
  3505.                     // multiple footnotes
  3506.                     foot += "\\stepcounter{footnote}";
  3507.                 }
  3508.                 foot += "\\footnotetext{\n";
  3509.                 foot_texrow.start(this,0);
  3510.                 foot_texrow.newline();
  3511.                 ++foot_count;
  3512.             }
  3513.         }
  3514.         break;
  3515.     case LyXParagraph::MARGIN:
  3516.         file += "\\marginpar{\n";
  3517.         break;
  3518.     case LyXParagraph::FIG:
  3519.         if (pextra_type == PEXTRA_FLOATFLT
  3520.             && (!pextra_width.empty()
  3521.             || !pextra_widthp.empty())) {
  3522.             char bufr[80];
  3523.             if (!pextra_width.empty())
  3524.                 sprintf(bufr, "\\begin{floatingfigure}{%s}\n",
  3525.                     pextra_width.c_str());
  3526.             else
  3527.                 sprintf(bufr, "\\begin{floatingfigure}{%f\\textwidth}\n",
  3528.                     atoi(pextra_widthp.c_str())/100.0);
  3529.             file += bufr;
  3530.         } else {
  3531.             file += "\\begin{figure}";
  3532.             if (!params->float_placement.empty()) { 
  3533.                 file += '[';
  3534.                 file += params->float_placement;
  3535.                 file += "]\n";
  3536.             } else {
  3537.                 file += '\n';
  3538.             }
  3539.         }
  3540.         break;
  3541.     case LyXParagraph::TAB:
  3542.         file += "\\begin{table}";
  3543.         if (!params->float_placement.empty()) { 
  3544.             file += '[';
  3545.             file += params->float_placement;
  3546.             file += "]\n";
  3547.         } else {
  3548.             file += '\n';
  3549.         }
  3550.         break;
  3551.     case LyXParagraph::WIDE_FIG:
  3552.         file += "\\begin{figure*}";
  3553.         if (!params->float_placement.empty()) { 
  3554.             file += '[';
  3555.             file += params->float_placement;
  3556.             file += "]\n";
  3557.         } else {
  3558.             file += '\n';
  3559.         }
  3560.         break;
  3561.     case LyXParagraph::WIDE_TAB:
  3562.         file += "\\begin{table*}";
  3563.         if (!params->float_placement.empty()) { 
  3564.             file += '[';
  3565.             file += params->float_placement;
  3566.             file += "]\n";
  3567.         } else {
  3568.             file += '\n';
  3569.         }
  3570.         break;
  3571.     case LyXParagraph::ALGORITHM:
  3572.         file += "\\begin{algorithm}\n";
  3573.         break;
  3574.     }
  3575.     texrow.newline();
  3576.    
  3577.     if (footnotekind != LyXParagraph::FOOTNOTE
  3578.         || !footer_in_body) {
  3579.         // Process text for all floats except footnotes in body
  3580.         do {
  3581.             LyXLayout *style = lyxstyle.Style(GetCurrentTextClass(),
  3582.                               par->layout);
  3583.             if (par->IsDummy())
  3584.                 lyxerr.print("ERROR (LyXParagraph::TeXFootnote)");
  3585.             if (style->isEnvironment()) {
  3586.                 par = par->TeXEnvironment(file, texrow,
  3587.                               foot, foot_texrow,
  3588.                               foot_count);
  3589.             } else {
  3590.                 par = par->TeXOnePar(file, texrow,
  3591.                              foot, foot_texrow,
  3592.                              foot_count);
  3593.             }
  3594.             
  3595.             if (par && !par->IsDummy() && par->depth > depth) {
  3596.                 par = par->TeXDeeper(file, texrow,
  3597.                              foot, foot_texrow,
  3598.                              foot_count);
  3599.             }
  3600.         } while (par && par->footnoteflag != LyXParagraph::NO_FOOTNOTE);
  3601.     } else {
  3602.         // process footnotes > depth 0 or in environments separately
  3603.         // NOTE: Currently don't support footnotes within footnotes
  3604.         //       even though that is possible using the \footnotemark
  3605.         LString dummy;
  3606.         TexRow dummy_texrow;
  3607.         int dummy_count = 0;
  3608.         do {
  3609.             LyXLayout *style = lyxstyle.Style(GetCurrentTextClass(),
  3610.                               par->layout);
  3611.             if (par->IsDummy())
  3612.                 lyxerr.print("ERROR (LyXParagraph::TeXFootnote)");
  3613.             if (style->isEnvironment()) {
  3614.                 par = par->TeXEnvironment(foot, foot_texrow,
  3615.                               dummy, dummy_texrow,
  3616.                               dummy_count);
  3617.             } else {
  3618.                 par = par->TeXOnePar(foot, foot_texrow,
  3619.                              dummy, dummy_texrow,
  3620.                              dummy_count);
  3621.             }
  3622.  
  3623.             if (par && !par->IsDummy() && par->depth > depth) {
  3624.                 par = par->TeXDeeper(foot, foot_texrow,
  3625.                              dummy, dummy_texrow,
  3626.                              dummy_count);
  3627.             }
  3628.         } while (par && par->footnoteflag != LyXParagraph::NO_FOOTNOTE);
  3629.         if (dummy_count) {
  3630.             lyxerr.print("ERROR (LyXParagraph::TeXFootnote): "
  3631.                      "Footnote in a Footnote -- not supported");
  3632.         }
  3633.     }
  3634.  
  3635.     switch (footnotekind) {
  3636.     case LyXParagraph::FOOTNOTE:
  3637.         if (footer_in_body) {
  3638.             // This helps tell which of the multiple
  3639.             // footnotetexts an error was in.
  3640.             foot += "}%\n";
  3641.             foot_texrow.newline();
  3642.         } else {
  3643.             file += '}';
  3644.         }
  3645.         break;
  3646.     case LyXParagraph::MARGIN:
  3647.         file += '}';
  3648.         break;
  3649.     case LyXParagraph::FIG:
  3650.         if (pextra_type == PEXTRA_FLOATFLT
  3651.             && (!pextra_width.empty()
  3652.             || !pextra_widthp.empty()))
  3653.             file += "\\end{floatingfigure}";
  3654.         else
  3655.             file += "\\end{figure}";
  3656.         break;
  3657.     case LyXParagraph::TAB:
  3658.         file += "\\end{table} ";
  3659.         break;
  3660.     case LyXParagraph::WIDE_FIG:
  3661.         file += "\\end{figure*} ";
  3662.         break;
  3663.     case LyXParagraph::WIDE_TAB:
  3664.         file += "\\end{table*} ";
  3665.         break;
  3666.     case LyXParagraph::ALGORITHM:
  3667.         file += "\\end{algorithm} ";
  3668.         break;
  3669.     }
  3670.     lyxerr.debug(LString("TeXFootnote...done ") +
  3671.              long(par->next), Error::LATEX);
  3672.     return par;
  3673. }
  3674.  
  3675.  
  3676. void LyXParagraph::SetPExtraType(int type, const char *width,const char *widthp)
  3677. {
  3678.     pextra_type = type;
  3679.     pextra_width = width;
  3680.     pextra_widthp = widthp;
  3681.  
  3682.     if (lyxstyle.Style(GetCurrentTextClass(), 
  3683.                        layout)->isEnvironment()) {
  3684.         LyXParagraph
  3685.             *par = this,
  3686.             *ppar = par;
  3687.  
  3688.         while (par && (par->layout == layout) && (par->depth == depth)) {
  3689.             ppar = par;
  3690.             par = par->Previous();
  3691.             if (par)
  3692.                 par = par->FirstPhysicalPar();
  3693.             while (par && par->depth > depth) {
  3694.                 par = par->Previous();
  3695.                 if (par)
  3696.                     par = par->FirstPhysicalPar();
  3697.             }
  3698.         }
  3699.         par = ppar;
  3700.         while (par && (par->layout == layout) && (par->depth == depth)) {
  3701.             par->pextra_type = type;
  3702.             par->pextra_width = width;
  3703.             par->pextra_widthp = widthp;
  3704.             par = par->NextAfterFootnote();
  3705.             if (par && (par->depth > depth))
  3706.                 par->SetPExtraType(type,width,widthp);
  3707.             while (par && ((par->depth > depth) || par->IsDummy()))
  3708.                 par = par->NextAfterFootnote();
  3709.         }
  3710.     }
  3711. }
  3712.  
  3713. void LyXParagraph::UnsetPExtraType()
  3714. {
  3715.     if (pextra_type == PEXTRA_NONE)
  3716.         return;
  3717.     
  3718.     pextra_type = PEXTRA_NONE;
  3719.     pextra_width.erase();
  3720.     pextra_widthp.erase();
  3721.  
  3722.     if (lyxstyle.Style(GetCurrentTextClass(), 
  3723.                        layout)->isEnvironment()) {
  3724.         LyXParagraph
  3725.             *par = this,
  3726.             *ppar = par;
  3727.  
  3728.         while (par && (par->layout == layout) && (par->depth == depth)) {
  3729.             ppar = par;
  3730.             par = par->Previous();
  3731.             if (par)
  3732.                 par = par->FirstPhysicalPar();
  3733.             while (par && par->depth > depth) {
  3734.                 par = par->Previous();
  3735.                 if (par)
  3736.                     par = par->FirstPhysicalPar();
  3737.             }
  3738.         }
  3739.         par = ppar;
  3740.         while (par && (par->layout == layout) && (par->depth == depth)) {
  3741.             par->pextra_type = PEXTRA_NONE;
  3742.             par->pextra_width.erase();
  3743.             par->pextra_widthp.erase();
  3744.             par = par->NextAfterFootnote();
  3745.             if (par && (par->depth > depth))
  3746.                 par->UnsetPExtraType();
  3747.             while (par && ((par->depth > depth) || par->IsDummy()))
  3748.                 par = par->NextAfterFootnote();
  3749.         }
  3750.     }
  3751. }
  3752.