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 / text2.C < prev    next >
C/C++ Source or Header  |  1998-04-23  |  99KB  |  3,487 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. #include <ctype.h>
  14. #include FORMS_H_LOCATION
  15.  
  16. #ifdef __GNUG__
  17. #pragma implementation "lyxtext.h"
  18. #pragma implementation "undo.h"
  19. #endif
  20.  
  21. #include "LString.h"
  22. #include "lyxparagraph.h"
  23. #include "inseterror.h"
  24. #include "layout.h"
  25. #include "LyXView.h"
  26. #include "textutils.h"
  27. #include "lyx_cb.h"
  28. #include "undo.h"
  29. #include "minibuffer.h"
  30. #include "buffer.h"
  31. #include "bufferparams.h"
  32. #include "lyx_gui_misc.h"
  33. #include "lyxtext.h"
  34. #include "gettext.h"
  35.  
  36. //     $Id: text2.C,v 1.1.1.1 1998/04/23 16:02:58 larsbj Exp $    
  37.  
  38. #if !defined(lint) && !defined(WITH_WARNINGS)
  39. static char vcid[] = "$Id: text2.C,v 1.1.1.1 1998/04/23 16:02:58 larsbj Exp $";
  40. #endif /* lint */
  41.  
  42. extern MiniBuffer *minibuffer;
  43.  
  44. // Constructor
  45. LyXText::LyXText(int pw, Buffer *p)
  46. {
  47.     firstrow = NULL;
  48.     lastrow = NULL;
  49.     currentrow = NULL;
  50.     currentrow_y = 0;
  51.     paperwidth = pw;
  52.     parameters = &p->params;
  53.     params = p;
  54.     number_of_rows = 0;
  55.     refresh_y= 0;
  56.     status = LyXText::UNCHANGED;
  57.     LyXParagraph *par = p->paragraph;
  58.     current_font = GetFont(par, 0);
  59.    
  60.     height = 0;
  61.    
  62.     while (par) {
  63.         InsertParagraph(par, lastrow);
  64.         par = par->Next();
  65.     }
  66.     /* set cursor at the very top position */
  67.     selection = true;               /* these setting is necessary 
  68.                         * because of the delete-empty-
  69.                         * paragraph mechanism in
  70.                         * SetCursor */
  71.     SetCursor(firstrow->par, 0);
  72.     sel_cursor = cursor;
  73.     selection = false;
  74.     mark_set = false;
  75.    
  76.     /* no rebreak necessary */ 
  77.     need_break_row = NULL;
  78.    
  79.     undo_finished = true;
  80.     undo_frozen = false;
  81.  
  82.     // Default layouttype for copy environment type
  83.     copylayouttype = 0;
  84. }
  85.  
  86.  
  87. // Destructor
  88. LyXText::~LyXText()
  89. {
  90.     // Delete all rows, this does not touch the paragraphs!
  91.     Row *tmprow = firstrow;
  92.     while (firstrow) {
  93.         tmprow = firstrow->next;
  94.         delete firstrow;
  95.         firstrow = tmprow;
  96.     }
  97. }
  98.  
  99.  
  100. // Gets the fully instantiated font at a given position in a paragraph
  101. // Basically the same routine as LyXParagraph::getFont() in paragraph.C.
  102. // The difference is that this one is used for displaying, and thus we
  103. // are allowed to make cosmetic improvements. For instance make footnotes
  104. // smaller. (Asger)
  105. // If position is -1, we get the layout font of the paragraph.
  106. // If position is -2, we get the font of the manual label of the paragraph.
  107. LyXFont LyXText::GetFont(LyXParagraph* par, int pos)
  108. {
  109.     LyXLayout *layout = 
  110.         lyxstyle.Style(parameters->textclass, par->GetLayout());
  111.  
  112.     char par_depth = par->GetDepth();
  113.     // We specialize the 95% common case:
  114.     if (par->footnoteflag == LyXParagraph::NO_FOOTNOTE && !par_depth) {
  115.         if (pos >= 0){
  116.             // 95% goes here
  117.             if (layout->labeltype == LABEL_MANUAL
  118.                 && pos < BeginningOfMainBody(par)) {
  119.                 // 1% goes here
  120.                 return par->GetFontSettings(pos).
  121.                         realize(layout->reslabelfont);
  122.             } else
  123.                 return par->GetFontSettings(pos).
  124.                         realize(layout->resfont);
  125.         } else {
  126.             // 5% goes here.
  127.             // process layoutfont for pos == -1 and labelfont for pos < -1
  128.             if (pos == -1)
  129.                 return layout->resfont;
  130.             else
  131.                 return layout->reslabelfont;
  132.         }
  133.     }
  134.  
  135.     // The uncommon case need not be optimized as much
  136.  
  137.     LyXFont layoutfont, tmpfont;
  138.  
  139.     if (pos >= 0){
  140.         // 95% goes here
  141.         if (pos < BeginningOfMainBody(par)) {
  142.             // 1% goes here
  143.             layoutfont = layout->labelfont;
  144.         } else {
  145.             // 99% goes here
  146.             layoutfont = layout->font;
  147.         }
  148.         tmpfont = par->GetFontSettings(pos);
  149.         tmpfont.realize(layoutfont);
  150.     } else{
  151.         // 5% goes here.
  152.         // process layoutfont for pos == -1 and labelfont for pos < -1
  153.         if (pos == -1)
  154.             tmpfont = layout->font;
  155.         else
  156.             tmpfont = layout->labelfont;
  157.     }
  158.  
  159.     // Resolve against environment font information
  160.     //if (par->GetDepth()){ // already in while condition
  161.         while (par && par_depth && !tmpfont.resolved()) {
  162.             par = par->DepthHook(par_depth - 1);
  163.             if (par) {
  164.                 tmpfont.realize(lyxstyle.
  165.                         Style(parameters->textclass,
  166.                               par->GetLayout())->font);
  167.                 par_depth = par->GetDepth();
  168.             }
  169.         }
  170.     //}
  171.  
  172.     tmpfont.realize(lyxstyle.TextClass(parameters->textclass)->defaultfont);
  173.  
  174.     // Cosmetic improvement: If this is an open footnote, make the font 
  175.     // smaller.
  176.     if (par->footnoteflag == LyXParagraph::OPEN_FOOTNOTE
  177.         && par->footnotekind == LyXParagraph::FOOTNOTE) {
  178.         tmpfont.decSize();
  179.     }
  180.  
  181.     return tmpfont;
  182. }
  183.  
  184.  
  185. void LyXText::SetCharFont(LyXParagraph *par, int pos, LyXFont font)
  186. {
  187.     /* let the insets convert their font */ 
  188.     if (par->GetChar(pos) == LYX_META_INSET) {
  189.         if (par->GetInset(pos))
  190.             font = par->GetInset(pos)->ConvertFont(font);
  191.     }
  192.  
  193.     LyXLayout *layout = lyxstyle.Style(parameters->textclass,
  194.                        par->GetLayout());
  195.  
  196.     // Get concrete layout font to reduce against
  197.     LyXFont layoutfont;
  198.  
  199.     if (pos < BeginningOfMainBody(par))
  200.         layoutfont = layout->labelfont;
  201.     else
  202.         layoutfont = layout->font;
  203.  
  204.     // Realize against environment font information
  205.     if (par->GetDepth()){
  206.         LyXParagraph * tp = par;
  207.         while (!layoutfont.resolved() && tp && tp->GetDepth()) {
  208.             tp = tp->DepthHook(tp->GetDepth()-1);
  209.             if (tp)
  210.                 layoutfont.realize(lyxstyle.
  211.                         Style(parameters->textclass,
  212.                               tp->GetLayout())->font);
  213.         }
  214.     }
  215.  
  216.     layoutfont.realize(lyxstyle.TextClass(parameters->textclass)->defaultfont);
  217.  
  218.     if (par->footnoteflag == LyXParagraph::OPEN_FOOTNOTE
  219.         && par->footnotekind == LyXParagraph::FOOTNOTE) {
  220.         layoutfont.decSize();
  221.     }
  222.  
  223.     // Now, reduce font against full layout font
  224.     font.reduce(layoutfont);
  225.  
  226.     par->SetFont(pos, font);
  227. }
  228.  
  229.  
  230. /* inserts a new row behind the specified row, increments
  231.  * the touched counters */
  232. void LyXText::InsertRow(Row *row, LyXParagraph *par, int pos)
  233. {
  234.     Row *tmprow = new Row;
  235.     if (!row) {
  236.         tmprow->previous = NULL;
  237.         tmprow->next = firstrow;
  238.         firstrow = tmprow;
  239.     }
  240.     else {
  241.         tmprow->previous = row;
  242.         tmprow->next = row->next;
  243.         row->next = tmprow;
  244.     }
  245.    
  246.     if (tmprow->next)
  247.         tmprow->next->previous = tmprow;
  248.    
  249.     if (tmprow->previous)
  250.         tmprow->previous->next = tmprow;
  251.    
  252.    
  253.     tmprow->par = par;
  254.     tmprow->pos = pos;
  255.    
  256.     if (row == lastrow)
  257.         lastrow = tmprow;
  258.     number_of_rows++;                   /* one more row  */
  259. }
  260.  
  261.  
  262. /* removes the row and reset the touched counters */
  263. void LyXText::RemoveRow(Row *row)
  264. {
  265.     /* this must not happen before the currentrow for clear reasons.
  266.        so the trick is just to set the current row onto the previous
  267.        row of this row */
  268.     long unused_y;
  269.     GetRow(row->par, row->pos, unused_y);
  270.     currentrow = currentrow->previous;
  271.     if (currentrow)
  272.         currentrow_y -= currentrow->height;
  273.     else
  274.         currentrow_y = 0;
  275.    
  276.     if (row->next)
  277.         row->next->previous = row->previous;
  278.     if (!row->previous) {
  279.         firstrow = row->next;
  280.     }
  281.     else  {
  282.         row->previous->next = row->next;
  283.     }
  284.     if (row == lastrow)
  285.         lastrow = row->previous;
  286.    
  287.     height -= row->height;           /* the text becomes smaller  */
  288.    
  289.     delete row;
  290.     number_of_rows--;                   /* one row less  */
  291. }
  292.  
  293. /* remove all following rows of the paragraph of the specified row. */
  294. void LyXText::RemoveParagraph(Row *row)
  295. {
  296.     LyXParagraph *tmppar;
  297.     Row *tmprow;
  298.  
  299.     tmppar = row->par;
  300.     row = row->next;
  301.     
  302.     while (row && row->par == tmppar) {
  303.         tmprow = row->next;
  304.         RemoveRow(row);
  305.         row = tmprow;
  306.     }
  307. }
  308.    
  309.   
  310. /* insert the specified paragraph behind the specified row */
  311. void LyXText::InsertParagraph(LyXParagraph *par, Row *row)
  312. {
  313.     InsertRow(row, par, 0);           /* insert a new row, starting 
  314.                     * at postition 0 */
  315.  
  316.     SetCounter(par);               /* set the counters  */
  317.    
  318.     /* and now append the whole paragraph behind the new row */
  319.     if (!row) {
  320.         firstrow->height = 0;
  321.         AppendParagraph(firstrow);
  322.     }
  323.     else {
  324.         row->next->height = 0;
  325.         AppendParagraph(row->next);
  326.     }
  327. }
  328.     
  329.  
  330. void LyXText::ToggleFootnote()
  331. {
  332.     LyXParagraph *par;
  333.    
  334.     par = cursor.par->ParFromPos(cursor.pos);
  335.     if (par->next && par->next->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE){
  336.         OpenFootnote();
  337.         minibuffer->Set(_("Opened float"));
  338.     }
  339.     else {
  340.         minibuffer->Set(_("Closed float"));
  341.         CloseFootnote();
  342.     }
  343. }
  344.  
  345.  
  346. void LyXText::OpenStuff()
  347. {
  348.     if (cursor.pos < cursor.par->Last() 
  349.         && cursor.par->GetChar(cursor.pos) == LYX_META_INSET
  350.         && cursor.par->GetInset(cursor.pos)->Editable()) {
  351.         minibuffer->Set(cursor.par->GetInset(cursor.pos)->EditMessage());
  352.         if (cursor.par->GetInset(cursor.pos)->Editable() != 2)
  353.             SetCursorParUndo();
  354.         cursor.par->GetInset(cursor.pos)->Edit(0,0);
  355.     }
  356.     else {
  357.         ToggleFootnote();
  358.     }
  359. }
  360.  
  361.  
  362. void LyXText::CloseFootnote()
  363. {
  364.     LyXParagraph *par, *endpar,*tmppar;
  365.     Row *row;
  366.    
  367.     par = cursor.par->ParFromPos(cursor.pos);
  368.    
  369.     /* if the cursor is not in an open footnote, or 
  370.      * there is no open footnote in this paragraph, just return. */ 
  371.     if (cursor.par->footnoteflag != LyXParagraph::OPEN_FOOTNOTE) {
  372.       
  373.         if (!par->next
  374.             || par->next->footnoteflag != LyXParagraph::OPEN_FOOTNOTE) {
  375.             minibuffer->Set(_("Nothing to do"));
  376.             return;
  377.         }
  378.    
  379.         /* ok, move the cursor right before the footnote */ 
  380.  
  381.         /* just a little faster than using CursorRight() */
  382.         for (cursor.pos=0; cursor.par->ParFromPos(cursor.pos)!=par; cursor.pos++);
  383.         /* now the cursor is at the beginning of the physical par */
  384.         SetCursor(cursor.par, cursor.pos + cursor.par->ParFromPos(cursor.pos)->last);
  385.     }
  386.     else  {
  387.         /* we are in a footnote, so let us move at the beginning */ 
  388.         /*      while (cursor.par->footnoteflag == LyXParagraph::OPEN_FOOTNOTE)
  389.             cursor.par = cursor.par->Previous();
  390.            
  391.             SetCursor(cursor.par, cursor.par->Last()); */
  392.         /* this is just faster than using just CursorLeft() */ 
  393.        
  394.         tmppar = cursor.par;
  395.         while (tmppar->footnoteflag == LyXParagraph::OPEN_FOOTNOTE) {
  396.             /* just a little bit faster than movin the cursor */
  397.             tmppar = tmppar->Previous();
  398.         }
  399.         SetCursor(tmppar, tmppar->Last());
  400.     }
  401.    
  402.     /* the cursor must be exactly before the footnote */ 
  403.     par = cursor.par->ParFromPos(cursor.pos);
  404.    
  405.     status = LyXText::NEED_MORE_REFRESH;
  406.     refresh_row = cursor.row;
  407.     refresh_y = cursor.y - cursor.row->baseline;
  408.    
  409.     tmppar = cursor.par;
  410.     endpar = par->NextAfterFootnote()->Next();
  411.     row = cursor.row;
  412.    
  413.     tmppar->CloseFootnote(cursor.pos);
  414.  
  415.     /* set the dimensions of the cursor row */
  416.     /* row->fill = Fill(row, paperwidth);
  417.        SetHeightOfRow(row);  */ 
  418.    
  419.     while (tmppar != endpar) {
  420.         RemoveRow(row->next);
  421.         if (row->next)
  422.             tmppar = row->next->par;
  423.         else
  424.             tmppar = NULL;
  425.     }
  426.    
  427.     AppendParagraph(cursor.row);
  428.    
  429.     SetCursor(cursor.par, cursor.pos);
  430.     sel_cursor = cursor;
  431.    
  432.     /* just necessary */
  433.     if (cursor.row->next)
  434.         SetHeightOfRow(cursor.row->next);
  435. }
  436.  
  437.  
  438. /* used in setlayout */
  439. // Asger is not sure we want to do this...
  440. void LyXText::MakeFontEntriesLayoutSpecific(LyXParagraph *par)
  441. {
  442.     LyXFont layoutfont, tmpfont;
  443.    
  444.     int pos;
  445.    
  446.     LyXLayout* layout = lyxstyle.Style(parameters->textclass, par->GetLayout());
  447.    
  448.     for (pos = 0; pos < par->Last(); pos++) {
  449.         if (pos < BeginningOfMainBody(par))
  450.             layoutfont = layout->labelfont;
  451.         else
  452.             layoutfont = layout->font;
  453.       
  454.         tmpfont = par->GetFontSettings(pos);
  455.         tmpfont.reduce(layoutfont);
  456.         par->SetFont(pos, tmpfont);
  457.     }
  458. }
  459.  
  460.  
  461. /* set layout over selection and make a total rebreak of those paragraphs */
  462. void  LyXText::SetLayout(char layout)
  463. {
  464.     LyXCursor tmpcursor;
  465.  
  466.     /* if there is no selection just set the layout of the current paragraph  */
  467.     if (!selection) {
  468.         sel_start_cursor = cursor;       /* dummy selection  */
  469.         sel_end_cursor = cursor;
  470.     }
  471.  
  472.     LyXParagraph *endpar = sel_end_cursor.par->LastPhysicalPar()->Next();
  473.     LyXParagraph *undoendpar = endpar;
  474.  
  475.     if (endpar && endpar->GetDepth()) {
  476.         while (endpar && endpar->GetDepth()) {
  477.             //endpar->depth = 0;
  478.             endpar = endpar->LastPhysicalPar()->Next();
  479.             undoendpar = endpar;
  480.         }
  481.     }
  482.     else if (endpar) {
  483.         endpar = endpar->Next();           /* because of parindents etc.  */
  484.     }
  485.    
  486.     SetUndo(Undo::EDIT, 
  487.         sel_start_cursor.par->ParFromPos(sel_start_cursor.pos)->previous, 
  488.         undoendpar);
  489.  
  490.     tmpcursor = cursor;               /* store the current cursor  */
  491.  
  492.     /* ok we have a selection. This is always between sel_start_cursor
  493.      * and sel_end cursor */ 
  494.     cursor = sel_start_cursor;
  495.    
  496.     LyXLayout * lyxlayout = lyxstyle.Style(parameters->textclass, layout);
  497.    
  498.     while (cursor.par != sel_end_cursor.par) {
  499.         if (cursor.par->footnoteflag ==
  500.             sel_start_cursor.par->footnoteflag) {
  501.             cursor.par->SetLayout(layout);
  502.             MakeFontEntriesLayoutSpecific(cursor.par);
  503.             cursor.par->FirstPhysicalPar()->added_space_top = lyxlayout->fill_top ? VSpace::VFILL : VSpace::NONE;
  504.             cursor.par->FirstPhysicalPar()->added_space_bottom = lyxlayout->fill_bottom ? VSpace::VFILL : VSpace::NONE;
  505.             if (lyxlayout->margintype == MARGIN_MANUAL)
  506.                 cursor.par->SetLabelWidthString(lyxlayout->labelstring);
  507.         }
  508.         cursor.par = cursor.par->Next();
  509.     }
  510.     if (cursor.par->footnoteflag ==
  511.         sel_start_cursor.par->footnoteflag) {
  512.         cursor.par->SetLayout(layout);
  513.         MakeFontEntriesLayoutSpecific(cursor.par);
  514.         cursor.par->FirstPhysicalPar()->added_space_top = lyxlayout->fill_top ? VSpace::VFILL : VSpace::NONE;
  515.         cursor.par->FirstPhysicalPar()->added_space_bottom = lyxlayout->fill_bottom ? VSpace::VFILL : VSpace::NONE;
  516.         if (lyxlayout->margintype == MARGIN_MANUAL)
  517.             cursor.par->SetLabelWidthString(lyxlayout->labelstring);
  518.     }
  519.    
  520.     RedoParagraphs(sel_start_cursor, endpar);
  521.    
  522.     /* we have to reset the selection, because the
  523.      * geometry could have changed */ 
  524.     SetCursor(sel_start_cursor.par, sel_start_cursor.pos);
  525.     sel_cursor = cursor;
  526.     SetCursor(sel_end_cursor.par, sel_end_cursor.pos);
  527.     UpdateCounters(cursor.row);
  528.     ClearSelection();
  529.     SetSelection();
  530.     SetCursor(tmpcursor.par, tmpcursor.pos);
  531. }
  532.  
  533.  
  534. /* increment depth over selection and
  535.  * make a total rebreak of those paragraphs */
  536. void  LyXText::IncDepth()
  537. {
  538.     // If there is no selection, just use the current paragraph
  539.     if (!selection) {
  540.         sel_start_cursor = cursor;       /* dummy selection */
  541.         sel_end_cursor = cursor;
  542.     }
  543.  
  544.     // We end at the next paragraph with depth 0
  545.     LyXParagraph *endpar = sel_end_cursor.par->LastPhysicalPar()->Next();
  546.     LyXParagraph *undoendpar = endpar;
  547.  
  548.     if (endpar && endpar->GetDepth()) {
  549.         while (endpar && endpar->GetDepth()) {
  550.             endpar = endpar->LastPhysicalPar()->Next();
  551.             undoendpar = endpar;
  552.         }
  553.     }
  554.     else if (endpar) {
  555.         endpar = endpar->Next();           /* because of parindents etc.  */
  556.     }
  557.     
  558.     SetUndo(Undo::EDIT, 
  559.         sel_start_cursor.par->ParFromPos(sel_start_cursor.pos)->previous, 
  560.         undoendpar);
  561.  
  562.     LyXCursor tmpcursor = cursor;         /* store the current cursor  */
  563.  
  564.     /* ok we have a selection. This is always between sel_start_cursor
  565.      * and sel_end cursor */ 
  566.     cursor = sel_start_cursor;
  567.    
  568.     bool anything_changed = false;
  569.    
  570.     while (true) {
  571.         // NOTE: you can't change the depth of a bibliography entry
  572.         if (cursor.par->footnoteflag ==
  573.             sel_start_cursor.par->footnoteflag
  574.             && lyxstyle.Style(parameters->textclass,
  575.                       cursor.par->GetLayout()
  576.                      )->labeltype != LABEL_BIBLIO) {
  577.             LyXParagraph * prev = cursor.par->FirstPhysicalPar()->Previous();
  578.             if (prev 
  579.                 && (prev->GetDepth() - cursor.par->GetDepth() > 0
  580.                 || (prev->GetDepth() == cursor.par->GetDepth()
  581.                     && lyxstyle.Style(parameters->textclass,
  582.                               prev->GetLayout())->isEnvironment()))) {
  583.                 cursor.par->FirstPhysicalPar()->depth++;
  584.                 anything_changed = true;
  585.                 }
  586.         }
  587.         if (cursor.par == sel_end_cursor.par)
  588.                        break;
  589.         cursor.par = cursor.par->Next();
  590.     }
  591.    
  592.     /* if nothing changed set all depth to 0 */ 
  593.     if (!anything_changed) {
  594.         cursor = sel_start_cursor;
  595.         while (cursor.par != sel_end_cursor.par) {
  596.             cursor.par->FirstPhysicalPar()->depth = 0;
  597.             cursor.par = cursor.par->Next();
  598.         }
  599.         if (cursor.par->footnoteflag == sel_start_cursor.par->footnoteflag)
  600.             cursor.par->FirstPhysicalPar()->depth = 0;
  601.     }
  602.    
  603.     RedoParagraphs(sel_start_cursor, endpar);
  604.    
  605.     /* we have to reset the selection, because the
  606.      * geometry could have changed */ 
  607.     SetCursor(sel_start_cursor.par, sel_start_cursor.pos);
  608.     sel_cursor = cursor;
  609.     SetCursor(sel_end_cursor.par, sel_end_cursor.pos);
  610.     UpdateCounters(cursor.row);
  611.     ClearSelection();
  612.     SetSelection();
  613.     SetCursor(tmpcursor.par, tmpcursor.pos);
  614. }
  615.  
  616.  
  617. /* decrement depth over selection and
  618.  * make a total rebreak of those paragraphs */
  619. void  LyXText::DecDepth()
  620. {
  621.     /* if there is no selection just set the layout of the current paragraph  */
  622.     if (!selection) {
  623.         sel_start_cursor = cursor;       /* dummy selection  */
  624.         sel_end_cursor = cursor;
  625.     }
  626.    
  627.     LyXParagraph *endpar = sel_end_cursor.par->LastPhysicalPar()->Next();
  628.     LyXParagraph *undoendpar = endpar;
  629.  
  630.     if (endpar && endpar->GetDepth()) {
  631.         while (endpar && endpar->GetDepth()) {
  632.             endpar = endpar->LastPhysicalPar()->Next();
  633.             undoendpar = endpar;
  634.         }
  635.     }
  636.     else if (endpar) {
  637.         endpar = endpar->Next();           /* because of parindents etc.  */
  638.     }
  639.    
  640.     SetUndo(Undo::EDIT, 
  641.         sel_start_cursor.par->ParFromPos(sel_start_cursor.pos)->previous, 
  642.         undoendpar);
  643.  
  644.     LyXCursor tmpcursor = cursor;               /* store the current cursor  */
  645.  
  646.     /* ok we have a selection. This is always between sel_start_cursor
  647.      * and sel_end cursor */ 
  648.     cursor = sel_start_cursor;
  649.  
  650.     while (true) {
  651.         if (cursor.par->footnoteflag ==
  652.             sel_start_cursor.par->footnoteflag) {
  653.             if (cursor.par->FirstPhysicalPar()->depth)
  654.                 cursor.par->FirstPhysicalPar()->depth--;
  655.         }
  656.         if (cursor.par == sel_end_cursor.par)
  657.             break;
  658.         cursor.par = cursor.par->Next();
  659.     }
  660.  
  661.     RedoParagraphs(sel_start_cursor, endpar);
  662.    
  663.     /* we have to reset the selection, because the
  664.      * geometry could have changed */ 
  665.     SetCursor(sel_start_cursor.par, sel_start_cursor.pos);
  666.     sel_cursor = cursor;
  667.     SetCursor(sel_end_cursor.par, sel_end_cursor.pos);
  668.     UpdateCounters(cursor.row);
  669.     ClearSelection();
  670.     SetSelection();
  671.     SetCursor(tmpcursor.par, tmpcursor.pos);
  672. }
  673.  
  674.  
  675. /* set font over selection and make a total rebreak of those paragraphs */
  676. void  LyXText::SetFont(LyXFont font)
  677. {
  678.     /* if there is no selection just set the current_font */
  679.     if (!selection) {
  680.         // Determine basis font
  681.         LyXFont layoutfont;
  682.         if (cursor.pos < BeginningOfMainBody(cursor.par))
  683.             layoutfont = GetFont(cursor.par, -2);
  684.         else
  685.             layoutfont = GetFont(cursor.par, -1);
  686.  
  687.         // Update current font
  688.         real_current_font.update(font);
  689.  
  690.         // Reduce to implicit settings
  691.         current_font = real_current_font;
  692.         current_font.reduce(layoutfont);
  693.         // And resolve it completely
  694.         real_current_font.realize(layoutfont);
  695.         return;
  696.     }
  697.  
  698.     LyXCursor tmpcursor = cursor;               /* store the current cursor  */
  699.    
  700.     /* ok we have a selection. This is always between sel_start_cursor
  701.      * and sel_end cursor */ 
  702.    
  703.     SetUndo(Undo::EDIT, 
  704.         sel_start_cursor.par->ParFromPos(sel_start_cursor.pos)->previous, 
  705.         sel_end_cursor.par->ParFromPos(sel_end_cursor.pos)->next); 
  706.     cursor = sel_start_cursor;
  707.     while (cursor.par != sel_end_cursor.par ||
  708.            (cursor.par->footnoteflag == sel_start_cursor.par->footnoteflag
  709.         && cursor.pos < sel_end_cursor.pos)) 
  710.     {
  711.         if (cursor.pos < cursor.par->Last()
  712.             && cursor.par->footnoteflag
  713.             == sel_start_cursor.par->footnoteflag) {   /* an open footnote
  714.                                 * should behave
  715.                                 * like a closed */
  716.             LyXFont newfont = GetFont(cursor.par,cursor.pos);
  717.             newfont.update(font);
  718.             SetCharFont(cursor.par, cursor.pos, newfont);
  719.             cursor.pos++;
  720.         } else {
  721.             cursor.pos = 0;
  722.             cursor.par = cursor.par->Next();
  723.         }
  724.     }
  725.    
  726.     RedoParagraphs(sel_start_cursor, sel_end_cursor.par->Next());
  727.    
  728.     /* we have to reset the selection, because the
  729.      * geometry could have changed */ 
  730.     SetCursor(sel_start_cursor.par, sel_start_cursor.pos);
  731.     sel_cursor = cursor;
  732.     SetCursor(sel_end_cursor.par, sel_end_cursor.pos);
  733.     ClearSelection();
  734.     SetSelection();
  735.     SetCursor(tmpcursor.par, tmpcursor.pos);
  736. }
  737.  
  738.  
  739. void LyXText::RedoHeightOfParagraph(LyXCursor cursor)
  740. {
  741.     Row *tmprow;
  742.     LyXParagraph *first_phys_par;
  743.     long y;
  744.    
  745.     tmprow = cursor.row;
  746.    
  747.     y = cursor.y - tmprow->baseline;
  748.     SetHeightOfRow(tmprow);
  749.     first_phys_par = tmprow->par->FirstPhysicalPar();
  750.     /* find the first row of the paragraph */
  751.     if (first_phys_par != tmprow->par)
  752.         while (tmprow->previous && tmprow->previous->par != first_phys_par)  {
  753.             tmprow = tmprow->previous;
  754.             y -= tmprow->height;
  755.             SetHeightOfRow(tmprow);
  756.         }
  757.     while (tmprow->previous && tmprow->previous->par == first_phys_par)  {
  758.         tmprow = tmprow->previous;
  759.         y -= tmprow->height;
  760.         SetHeightOfRow(tmprow);
  761.     }
  762.    
  763.     /* we can set the refreshing parameters now */
  764.     status = LyXText::NEED_MORE_REFRESH;
  765.     refresh_y = y;
  766.     refresh_row = tmprow;
  767.     SetCursor(cursor.par, cursor.pos);
  768. }
  769.  
  770.  
  771. void LyXText::RedoDrawingOfParagraph(LyXCursor cursor)
  772. {
  773.     Row *tmprow;
  774.     LyXParagraph *first_phys_par;
  775.     long y;
  776.    
  777.     tmprow = cursor.row;
  778.    
  779.     y = cursor.y - tmprow->baseline;
  780.     SetHeightOfRow(tmprow);
  781.     first_phys_par = tmprow->par->FirstPhysicalPar();
  782.     /* find the first row of the paragraph */
  783.     if (first_phys_par != tmprow->par)
  784.         while (tmprow->previous && tmprow->previous->par != first_phys_par)  {
  785.             tmprow = tmprow->previous;
  786.             y -= tmprow->height;
  787.         }
  788.     while (tmprow->previous && tmprow->previous->par == first_phys_par)  {
  789.         tmprow = tmprow->previous;
  790.         y -= tmprow->height;
  791.       
  792.     }
  793.    
  794.     /* we can set the refreshing parameters now */
  795.     if (status == LyXText::UNCHANGED || y < refresh_y) {
  796.         refresh_y = y;
  797.         refresh_row = tmprow;
  798.     }
  799.     status = LyXText::NEED_MORE_REFRESH;
  800.     SetCursor(cursor.par, cursor.pos);
  801. }
  802.  
  803.  
  804. /* deletes and inserts again all paragaphs between the cursor
  805. * and the specified par 
  806. * This function is needed after SetLayout and SetFont etc. */
  807. void LyXText::RedoParagraphs(LyXCursor cursor, LyXParagraph *endpar)
  808. {
  809.     Row *tmprow, *tmprow2;
  810.     LyXParagraph *tmppar, *first_phys_par;
  811.     long y;
  812.    
  813.     tmprow = cursor.row;
  814.    
  815.     y = cursor.y - tmprow->baseline;
  816.    
  817.     if (!tmprow->previous){
  818.         first_phys_par = FirstParagraph();   // a trick/hack for UNDO
  819.     }
  820.     else {
  821.         first_phys_par = tmprow->par->FirstPhysicalPar();
  822.         /* find the first row of the paragraph */
  823.         if (first_phys_par != tmprow->par)
  824.             while (tmprow->previous && tmprow->previous->par != first_phys_par)  {
  825.                 tmprow = tmprow->previous;
  826.                 y -= tmprow->height;
  827.             }
  828.         while (tmprow->previous && tmprow->previous->par == first_phys_par)  {
  829.             tmprow = tmprow->previous;
  830.             y -= tmprow->height;
  831.         }
  832.     }
  833.    
  834.     /* we can set the refreshing parameters now */
  835.     status = LyXText::NEED_MORE_REFRESH;
  836.     refresh_y = y;
  837.     refresh_row = tmprow->previous;           /* the real refresh row will
  838.                         * be deleted, so I store
  839.                         * the previous here */ 
  840.     /* remove it */
  841.     if (tmprow->next)
  842.         tmppar = tmprow->next->par;
  843.     else
  844.         tmppar = NULL;
  845.     while (tmppar != endpar) {
  846.         RemoveRow(tmprow->next);
  847.         if (tmprow->next)
  848.             tmppar = tmprow->next->par;
  849.         else
  850.             tmppar = NULL;
  851.     }  
  852.    
  853.     /* remove the first one */
  854.     tmprow2 = tmprow;               /* this is because tmprow->previous
  855.                         * can be NULL */
  856.     tmprow = tmprow->previous;
  857.     RemoveRow(tmprow2);
  858.    
  859.     tmppar = first_phys_par;
  860.  
  861.     do {
  862.         if (tmppar) {
  863.             InsertParagraph(tmppar, tmprow);
  864.             if (!tmprow)
  865.                 tmprow = firstrow;
  866.             while (tmprow->next && tmprow->next->par == tmppar)
  867.                 tmprow = tmprow->next;
  868.             tmppar = tmppar->Next();
  869.      
  870.         }
  871.     }
  872.     while (tmppar != endpar);
  873.    
  874.     /* this is because of layout changes */ 
  875.     if (refresh_row) {
  876.         refresh_y -= refresh_row->height;
  877.         SetHeightOfRow(refresh_row);   
  878.     }
  879.     else {
  880.         refresh_row = firstrow;
  881.         refresh_y = 0;
  882.         SetHeightOfRow(refresh_row);   
  883.     }
  884.    
  885.     if (tmprow && tmprow->next)
  886.         SetHeightOfRow(tmprow->next);
  887.    
  888.     /* restore the correct refresh row  */
  889. /*    if (refresh_row)
  890.       refresh_row = refresh_row->next;
  891.       else
  892.       refresh_row = firstrow;*/ 
  893. }
  894.  
  895.  
  896. int LyXText::FullRebreak()
  897. {
  898.     if (need_break_row) {
  899.         BreakAgain(need_break_row);
  900.         need_break_row = NULL;
  901.         return 1;
  902.     }
  903.     return 0;
  904. }
  905.  
  906.  
  907. /* important for the screen */
  908.  
  909.  
  910. /* the cursor set functions have a special mechanism. When they
  911. * realize, that you left an empty paragraph, they will delete it.
  912. * They also delet the corresponding row */
  913.    
  914. /* need the selection cursor: */ 
  915. void LyXText::SetSelection()
  916. {
  917.     if (!selection) {
  918.         last_sel_cursor = sel_cursor;
  919.         sel_start_cursor = sel_cursor;
  920.         sel_end_cursor = sel_cursor;
  921.     }
  922.    
  923.     selection = True;
  924.    
  925.     /* first the toggling area */ 
  926.     if (cursor.y < last_sel_cursor.y ||
  927.         (cursor.y == last_sel_cursor.y && cursor.x < last_sel_cursor.x)) {
  928.         toggle_end_cursor = last_sel_cursor;
  929.         toggle_cursor = cursor;
  930.     }
  931.     else {
  932.         toggle_end_cursor = cursor;
  933.         toggle_cursor = last_sel_cursor;
  934.     }
  935.    
  936.     last_sel_cursor = cursor;
  937.    
  938.     /* and now the whole selection */ 
  939.    
  940.     if (sel_cursor.y < cursor.y ||
  941.         (sel_cursor.y == cursor.y && sel_cursor.x < cursor.x)) {
  942.         sel_end_cursor = cursor;
  943.         sel_start_cursor = sel_cursor;
  944.     }
  945.     else {
  946.         sel_end_cursor = sel_cursor; 
  947.         sel_start_cursor = cursor;
  948.     }
  949.    
  950.     /* a selection with no contents is not a selection */ 
  951.     if (sel_start_cursor.x == sel_end_cursor.x && 
  952.         sel_start_cursor.y == sel_end_cursor.y)
  953.         selection = false;
  954. }
  955.  
  956.  
  957. void LyXText::ClearSelection()
  958. {
  959.     selection = false;
  960.     mark_set = false;
  961. }
  962.  
  963.  
  964. void  LyXText::CursorHome()
  965. {
  966.     SetCursor(cursor.par, cursor.row->pos);
  967. }
  968.  
  969.  
  970. void  LyXText::CursorEnd()
  971. {
  972.     if (!cursor.row->next || cursor.row->next->par != cursor.row->par)
  973.         SetCursor(cursor.par, RowLast(cursor.row) + 1);
  974.     else {
  975.         if (cursor.par->Last() && 
  976.             (cursor.par->GetChar(RowLast(cursor.row)) == ' '
  977.              || cursor.par->IsNewline(RowLast(cursor.row))))
  978.             SetCursor(cursor.par, RowLast(cursor.row));
  979.         else
  980.             SetCursor(cursor.par, RowLast(cursor.row) + 1);
  981.     }
  982.         if (cursor.par->table) {
  983.                 int cell = NumberOfCell(cursor.par, cursor.pos);
  984.                 if (cursor.par->table->RowHasContRow(cell) &&
  985.                     cursor.par->table->CellHasContRow(cell)<0) {
  986.                         if (!cursor.row->next || cursor.row->next->par != cursor.row->par)
  987.                                 SetCursor(cursor.par, RowLast(cursor.row) + 1);
  988.                         else {
  989.                                 if (cursor.par->Last() && 
  990.                                     (cursor.par->GetChar(RowLast(cursor.row)) == ' '
  991.                                      || cursor.par->IsNewline(RowLast(cursor.row))))
  992.                                         SetCursor(cursor.par, RowLast(cursor.row));
  993.                                 else
  994.                                         SetCursor(cursor.par, RowLast(cursor.row) + 1);
  995.                         }
  996.                 }
  997.         }
  998. }
  999.  
  1000.  
  1001. void  LyXText::CursorTop()
  1002. {
  1003.     while (cursor.par->Previous())
  1004.         cursor.par = cursor.par->Previous();
  1005.     SetCursor(cursor.par, 0);
  1006. }
  1007.  
  1008.  
  1009. void  LyXText::CursorBottom()
  1010. {
  1011.     while (cursor.par->Next())
  1012.         cursor.par = cursor.par->Next();
  1013.     SetCursor(cursor.par, cursor.par->Last());
  1014. }
  1015.    
  1016.    
  1017. /* returns a pointer to the row near the specified y-coordinate
  1018. * (relative to the whole text). y is set to the real beginning
  1019. * of this row */ 
  1020. Row* LyXText::GetRowNearY(long& y)
  1021. {
  1022.     Row* tmprow;
  1023.     long tmpy;
  1024.    
  1025.     if (currentrow){
  1026.         tmprow = currentrow;
  1027.         tmpy = currentrow_y;
  1028.     }
  1029.     else {
  1030.         tmprow = firstrow;
  1031.         tmpy = 0;
  1032.     }
  1033.  
  1034.     if (tmpy<=y)
  1035.         while (tmprow->next && tmpy + tmprow->height <= y) {
  1036.             tmpy += tmprow->height;
  1037.             tmprow = tmprow->next;
  1038.         }
  1039.     else
  1040.         while (tmprow->previous && tmpy > y) {
  1041.             tmprow = tmprow->previous;
  1042.             tmpy -= tmprow->height;
  1043.         }
  1044.  
  1045.     currentrow = tmprow;
  1046.     currentrow_y = tmpy;
  1047.  
  1048.     y = tmpy;                   /* return the real y  */
  1049.     return tmprow;
  1050. }
  1051.    
  1052.  
  1053. void LyXText::ToggleFree(LyXFont font)
  1054. {
  1055.     // If the mask is completely neutral, tell user
  1056.     if (font == LyXFont(LyXFont::ALL_IGNORE)){
  1057.         // Could only happen with user style
  1058.         minibuffer->Set(_("No font change defined. Use Character under"
  1059.                   " the Layout menu to define font change."));
  1060.         return;
  1061.     }
  1062.  
  1063.     // Try implicit word selection
  1064.     LyXCursor resetCursor = cursor;
  1065.     int implicitSelection = SelectWordWhenUnderCursor();
  1066.  
  1067.     // Set font
  1068.     SetFont(font);
  1069.     minibuffer->Set(_("Font style changed"));
  1070.  
  1071.     /* Implicit selections are cleared afterwards and cursor is set to the
  1072.        original position. */
  1073.     if ( implicitSelection ) {
  1074.         ClearSelection();
  1075.         cursor = resetCursor;
  1076.         SetCursor( cursor.par, cursor.pos );
  1077.         sel_cursor = cursor;
  1078.     }
  1079. }
  1080.  
  1081.  
  1082. int LyXText::BeginningOfMainBody(LyXParagraph *par)
  1083. {
  1084.     if (lyxstyle.Style(parameters->textclass, par->GetLayout())->labeltype != LABEL_MANUAL)
  1085.         return 0;
  1086.     else
  1087.         return par->BeginningOfMainBody();
  1088. }
  1089.  
  1090.  
  1091. /* if there is a selection, reset every environment you can find
  1092. * in the selection, otherwise just the environment you are in */ 
  1093. void LyXText::MeltFootnoteEnvironment()
  1094. {
  1095.     LyXParagraph *tmppar, *firsttmppar;
  1096.    
  1097.     ClearSelection();
  1098.    
  1099.     /* is is only allowed, if the cursor is IN an open footnote.
  1100.      * Otherwise it is too dangerous */ 
  1101.     if (cursor.par->footnoteflag != LyXParagraph::OPEN_FOOTNOTE)
  1102.         return;
  1103.    
  1104.     SetUndo(Undo::FINISH, 
  1105.         cursor.par->PreviousBeforeFootnote()->previous,
  1106.         cursor.par->NextAfterFootnote()->next);
  1107.  
  1108.     /* ok, move to the beginning of the footnote. */ 
  1109.     while (cursor.par->footnoteflag == LyXParagraph::OPEN_FOOTNOTE)
  1110.         cursor.par = cursor.par->Previous();
  1111.    
  1112.     SetCursor(cursor.par, cursor.par->Last());
  1113.     /* this is just faster than using CursorLeft(); */ 
  1114.    
  1115.     firsttmppar = cursor.par->ParFromPos(cursor.pos);
  1116.     tmppar = firsttmppar;
  1117.     /* tmppar is now the paragraph right before the footnote */
  1118.    
  1119.     char first_footnote_par_is_not_empty = tmppar->next->last;
  1120.    
  1121.     while (tmppar->next && tmppar->next->footnoteflag == LyXParagraph::OPEN_FOOTNOTE) {
  1122.         tmppar = tmppar->next;           /* I use next instead of Next(),
  1123.                         * because there cannot be any
  1124.                         * footnotes in a footnote
  1125.                         * environment */
  1126.         tmppar->footnoteflag = LyXParagraph::NO_FOOTNOTE;
  1127.       
  1128.         /* remember the captions and empty paragraphs */
  1129.         if ((lyxstyle.Style(parameters->textclass,
  1130.                     tmppar->GetLayout())->labeltype == LABEL_SENSITIVE)
  1131.             || !tmppar->Last())
  1132.             tmppar->SetLayout(0);
  1133.     }
  1134.    
  1135.     /* now we will paste the ex-footnote, if the layouts allow it */
  1136.     /* first restore the layout of the paragraph right behind the footnote*/ 
  1137.     if (tmppar->next) 
  1138.         tmppar->next->MakeSameLayout(cursor.par);
  1139.  
  1140.     /* first the end */ 
  1141.     if ((!tmppar->GetLayout() && !tmppar->table)
  1142.         || (tmppar->Next() && (!tmppar->Next()->Last()
  1143.                    || tmppar->Next()->HasSameLayout(tmppar)))) {
  1144.         if (tmppar->Next()->Last() && tmppar->Next()->IsLineSeparator(0))
  1145.             tmppar->Next()->Erase(0);
  1146.         tmppar->PasteParagraph();
  1147.     }
  1148.  
  1149.     tmppar = tmppar->Next();           /* make shure tmppar cannot be touched
  1150.                         * by the pasting of the beginning */
  1151.  
  1152.     /* then the beginning */ 
  1153.     /* if there is no space between the text and the footnote, so we insert
  1154.      * a blank 
  1155.      * (only if the previous par and the footnotepar are not empty!) */
  1156.     if ((!firsttmppar->next->GetLayout() && !firsttmppar->next->table)
  1157.         || firsttmppar->HasSameLayout(firsttmppar->next)) {
  1158.         if (firsttmppar->last
  1159.             && !firsttmppar->IsSeparator(firsttmppar->last - 1)
  1160.             && first_footnote_par_is_not_empty) {
  1161.             firsttmppar->next->InsertChar(0, ' ');
  1162.         }
  1163.         firsttmppar->PasteParagraph();
  1164.     }
  1165.    
  1166.     /* now redo the paragaphs */
  1167.     RedoParagraphs(cursor, tmppar);
  1168.    
  1169.     SetCursor(cursor.par, cursor.pos);
  1170.    
  1171.     /* sometimes it can happen, that there is a counter change */ 
  1172.     Row *row = cursor.row;
  1173.     while (row->next && row->par != tmppar && row->next->par != tmppar)
  1174.         row = row->next;
  1175.     UpdateCounters(row);
  1176.    
  1177.    
  1178.     ClearSelection();
  1179. }
  1180.  
  1181.  
  1182. /* the DTP switches for paragraphs. LyX will store them in the 
  1183. * first physicla paragraph. When a paragraph is broken, the top settings 
  1184. * rest, the bottom settings are given to the new one. So I can make shure, 
  1185. * they do not duplicate themself and you cannnot make dirty things with 
  1186. * them!  */ 
  1187.  
  1188. void LyXText::SetParagraph(bool line_top, bool line_bottom,
  1189.                bool pagebreak_top, bool pagebreak_bottom,
  1190.                VSpace space_top, VSpace space_bottom,
  1191.                char align, 
  1192.                LString labelwidthstring,
  1193.                bool noindent) 
  1194. {
  1195.     LyXCursor tmpcursor;
  1196.     tmpcursor = cursor;
  1197.     LyXParagraph *tmppar;
  1198.     if (!selection) {
  1199.         sel_start_cursor = cursor;
  1200.         sel_end_cursor = cursor;
  1201.     }
  1202.  
  1203.     // make sure that the depth behind the selection are restored, too
  1204.     LyXParagraph *endpar = sel_end_cursor.par->LastPhysicalPar()->Next();
  1205.     LyXParagraph *undoendpar = endpar;
  1206.  
  1207.     if (endpar && endpar->GetDepth()) {
  1208.         while (endpar && endpar->GetDepth()) {
  1209.             endpar = endpar->LastPhysicalPar()->Next();
  1210.             undoendpar = endpar;
  1211.         }
  1212.     }
  1213.     else if (endpar) {
  1214.         endpar = endpar->Next(); /* because of parindents etc.  */
  1215.     }
  1216.    
  1217.     SetUndo(Undo::EDIT, 
  1218.         sel_start_cursor.par->ParFromPos(sel_start_cursor.pos)->previous, 
  1219.         undoendpar);
  1220.  
  1221.     
  1222.     tmppar = sel_end_cursor.par;
  1223.     while (tmppar != sel_start_cursor.par->FirstPhysicalPar()->Previous())
  1224.         {
  1225.             SetCursor(tmppar->FirstPhysicalPar(), 0);
  1226.             status = LyXText::NEED_MORE_REFRESH;
  1227.             refresh_row = cursor.row;
  1228.             refresh_y = cursor.y - cursor.row->baseline;
  1229.             if (cursor.par->footnoteflag ==
  1230.                 sel_start_cursor.par->footnoteflag) {
  1231.                 cursor.par->line_top = line_top;
  1232.                 cursor.par->line_bottom = line_bottom;
  1233.                 cursor.par->pagebreak_top = pagebreak_top;
  1234.                 cursor.par->pagebreak_bottom = pagebreak_bottom;
  1235.                 cursor.par->added_space_top = space_top;
  1236.                 cursor.par->added_space_bottom = space_bottom;
  1237.                 /* does the layout allow the new alignment? */ 
  1238.                 if (align == LYX_ALIGN_LAYOUT)
  1239.                     align = lyxstyle.Style(parameters->textclass, cursor.par->GetLayout())->align;
  1240.                 if (align & lyxstyle.Style(parameters->textclass, cursor.par->GetLayout())->alignpossible) {
  1241.                     if (align == lyxstyle.Style(parameters->textclass, cursor.par->GetLayout())->align)
  1242.                         cursor.par->align = LYX_ALIGN_LAYOUT;
  1243.                     else
  1244.                         cursor.par->align = align;
  1245.                 }
  1246.                 cursor.par->SetLabelWidthString(labelwidthstring);
  1247.                 cursor.par->noindent = noindent;
  1248.             }
  1249.        
  1250.             /* 
  1251.                tmprow = cursor.row;
  1252.                while (tmprow->next && tmprow->next->par->previous != cursor.par->LastPhysicalPar())
  1253.                tmprow = tmprow->next;
  1254.                SetHeightOfRow(tmprow);
  1255.                SetHeightOfRow(cursor.row); */ 
  1256.             tmppar = cursor.par->FirstPhysicalPar()->Previous();
  1257.         }
  1258.     
  1259.     RedoParagraphs(sel_start_cursor, endpar);
  1260.     
  1261.     ClearSelection();
  1262.     SetCursor(sel_start_cursor.par, sel_start_cursor.pos);
  1263.     sel_cursor = cursor;
  1264.     SetCursor(sel_end_cursor.par, sel_end_cursor.pos);
  1265.     SetSelection();
  1266.     SetCursor(tmpcursor.par, tmpcursor.pos);
  1267. }
  1268.  
  1269.  
  1270. void LyXText::SetParagraphExtraOpt(int type,
  1271.                                    const char *width,
  1272.                                    const char *widthp,
  1273.                                    int alignment, bool hfill,
  1274.                                    bool start_minipage)
  1275. {
  1276.     LyXCursor tmpcursor;
  1277.     tmpcursor = cursor;
  1278.     LyXParagraph *tmppar;
  1279.     if (!selection) {
  1280.         sel_start_cursor = cursor;
  1281.         sel_end_cursor = cursor;
  1282.     }
  1283.  
  1284.     // make sure that the depth behind the selection are restored, too
  1285.     LyXParagraph *endpar = sel_end_cursor.par->LastPhysicalPar()->Next();
  1286.     LyXParagraph *undoendpar = endpar;
  1287.  
  1288.     if (endpar && endpar->GetDepth()) {
  1289.         while (endpar && endpar->GetDepth()) {
  1290.             endpar = endpar->LastPhysicalPar()->Next();
  1291.             undoendpar = endpar;
  1292.         }
  1293.     }
  1294.     else if (endpar) {
  1295.         endpar = endpar->Next(); /* because of parindents etc.  */
  1296.     }
  1297.    
  1298.     SetUndo(Undo::EDIT, 
  1299.         sel_start_cursor.par->ParFromPos(sel_start_cursor.pos)->previous, 
  1300.         undoendpar);
  1301.     
  1302.     tmppar = sel_end_cursor.par;
  1303.     while(tmppar != sel_start_cursor.par->FirstPhysicalPar()->Previous()) {
  1304.                 SetCursor(tmppar->FirstPhysicalPar(), 0);
  1305.                 status = LyXText::NEED_MORE_REFRESH;
  1306.                 refresh_row = cursor.row;
  1307.                 refresh_y = cursor.y - cursor.row->baseline;
  1308.                 if (cursor.par->footnoteflag ==
  1309.                     sel_start_cursor.par->footnoteflag) {
  1310.                         if (type == PEXTRA_NONE) {
  1311.                                 if (cursor.par->pextra_type != PEXTRA_NONE) {
  1312.                                         cursor.par->UnsetPExtraType();
  1313.                                         cursor.par->pextra_type=PEXTRA_NONE;
  1314.                                 }
  1315.                         } else {
  1316.                                 cursor.par->SetPExtraType(type,width,widthp);
  1317.                                 cursor.par->pextra_hfill = hfill;
  1318.                                 cursor.par->pextra_start_minipage = start_minipage;
  1319.                                 cursor.par->pextra_alignment = alignment;
  1320.                         }
  1321.                 }
  1322.                 tmppar = cursor.par->FirstPhysicalPar()->Previous();
  1323.         }
  1324.     RedoParagraphs(sel_start_cursor, endpar);
  1325.     ClearSelection();
  1326.     SetCursor(sel_start_cursor.par, sel_start_cursor.pos);
  1327.     sel_cursor = cursor;
  1328.     SetCursor(sel_end_cursor.par, sel_end_cursor.pos);
  1329.     SetSelection();
  1330.     SetCursor(tmpcursor.par, tmpcursor.pos);
  1331. }
  1332.  
  1333.  
  1334. /* set the counter of a paragraph. This includes the labels */ 
  1335. void LyXText::SetCounter(LyXParagraph *par)
  1336. {
  1337.     int i;
  1338.    
  1339.     /* this is only relevant for the beginning of paragraph */ 
  1340.     par = par->FirstPhysicalPar();
  1341.  
  1342.     LyXLayout* layout = lyxstyle.Style(parameters->textclass, 
  1343.                        par->GetLayout());
  1344.  
  1345.     LyXTextClass *textclass = lyxstyle.TextClass(parameters->textclass);
  1346.  
  1347.     /* copy the prev-counters to this one, unless this is the start of a 
  1348.        footnote or of a bibliography or the very first paragraph */
  1349.     if (par->Previous()
  1350.         && !(par->Previous()->footnoteflag == LyXParagraph::NO_FOOTNOTE 
  1351.             && par->footnoteflag == LyXParagraph::OPEN_FOOTNOTE
  1352.             && par->footnotekind == LyXParagraph::FOOTNOTE)
  1353.         && !(lyxstyle.Style(parameters->textclass,
  1354.                 par->Previous()->GetLayout()
  1355.                 )->labeltype != LABEL_BIBLIO
  1356.          && layout->labeltype == LABEL_BIBLIO)) {
  1357.         for (i=0; i<10; i++) {
  1358.             par->counter[i]=par->Previous()->GetCounter(i);
  1359.         }
  1360.         par->enumdepth = par->Previous()->FirstPhysicalPar()->enumdepth;
  1361.         par->itemdepth = par->Previous()->FirstPhysicalPar()->itemdepth;
  1362.     }
  1363.     else {
  1364.         for (i=0; i<10; i++) {
  1365.             par->counter[i]=0;
  1366.         }  
  1367.         par->enumdepth = 0;
  1368.         par->itemdepth = 0;
  1369.     }
  1370.  
  1371.         // if this is an open marginnote and this is the first
  1372.         // entry in the marginnote and the enclosing
  1373.         // environment is an enum/item then correct for the
  1374.         // LaTeX behaviour (ARRae)
  1375.         if(par->footnoteflag == LyXParagraph::OPEN_FOOTNOTE
  1376.        && par->footnotekind == LyXParagraph::MARGIN
  1377.            && par->Previous()
  1378.            && par->Previous()->footnoteflag != LyXParagraph::OPEN_FOOTNOTE
  1379.            && (par->PreviousBeforeFootnote()
  1380.                && lyxstyle.Style(parameters->textclass,
  1381.                                  par->PreviousBeforeFootnote()->GetLayout()
  1382.                  )->labeltype >= LABEL_COUNTER_ENUMI)) {
  1383.                 // Any itemize or enumerate environment in a marginnote
  1384.                 // that is embedded in an itemize or enumerate
  1385.                 // paragraph is seen by LaTeX as being at a deeper
  1386.                 // level within that enclosing itemization/enumeration
  1387.                 // even if there is a "standard" layout at the start of
  1388.                 // the marginnote.
  1389.                 par->enumdepth++;
  1390.                 par->itemdepth++;
  1391.         }
  1392.  
  1393.     /* Maybe we have to increment the enumeration depth.
  1394.      * BUT, enumeration in a footnote is considered in isolation from its
  1395.      *    surrounding paragraph so don't increment if this is the
  1396.      *    first line of the footnote
  1397.      * AND, bibliographies can't have their depth changed ie. they
  1398.      *    are always of depth 0
  1399.      */
  1400.     if (par->Previous()
  1401.         && par->Previous()->GetDepth() < par->GetDepth()
  1402.         && lyxstyle.Style(parameters->textclass,
  1403.                   par->Previous()->GetLayout()
  1404.                  )->labeltype == LABEL_COUNTER_ENUMI
  1405.         && par->enumdepth < 3
  1406.         && !(par->Previous()->footnoteflag == LyXParagraph::NO_FOOTNOTE 
  1407.             && par->footnoteflag == LyXParagraph::OPEN_FOOTNOTE
  1408.             && par->footnotekind == LyXParagraph::FOOTNOTE)
  1409.         && layout->labeltype != LABEL_BIBLIO) {
  1410.         par->enumdepth++;
  1411.     }
  1412.  
  1413.     /* Maybe we have to decrement the enumeration depth, see note above */
  1414.     if (par->Previous()
  1415.         && par->Previous()->GetDepth() > par->GetDepth()
  1416.         && !(par->Previous()->footnoteflag == LyXParagraph::NO_FOOTNOTE
  1417.             && par->footnoteflag == LyXParagraph::OPEN_FOOTNOTE
  1418.             && par->footnotekind == LyXParagraph::FOOTNOTE)
  1419.         && layout->labeltype != LABEL_BIBLIO) {
  1420.         par->enumdepth = par->DepthHook(par->GetDepth())->enumdepth;
  1421.         par->counter[6 + par->enumdepth] =
  1422.             par->DepthHook(par->GetDepth())->counter[6 + par->enumdepth];
  1423.         /* reset the counters.
  1424.          * A depth change is like a breaking layout
  1425.          */
  1426.         for (i=6 + par->enumdepth + 1; i<10;i++)
  1427.             par->counter[i]=0;
  1428.     }
  1429.    
  1430.     if (!par->labelstring.empty()) {
  1431.         par->labelstring.erase();
  1432.     }
  1433.    
  1434.     if (layout->margintype == MARGIN_MANUAL) {
  1435.         if (par->labelwidthstring.empty()) {
  1436.             par->SetLabelWidthString(layout->labelstring);
  1437.         }
  1438.     }
  1439.     else {
  1440.         par->SetLabelWidthString(LString());
  1441.     }
  1442.    
  1443.     /* is it a layout that has an automatic label ? */ 
  1444.     if (layout->labeltype >=  LABEL_FIRST_COUNTER) {
  1445.       
  1446.         i = layout->labeltype - LABEL_FIRST_COUNTER;
  1447.         if (i>=0 && i<=parameters->secnumdepth) {
  1448.             par->counter[i]++;    // increment the counter  
  1449.      
  1450.             char * s = new char[50];
  1451.  
  1452.             // Is there a label? Useful for Chapter layout
  1453.             if (!layout->labelstring.empty()) {
  1454.                 par->labelstring = layout->labelstring;
  1455.             } else {
  1456.                 par->labelstring.erase();
  1457.             }
  1458.  
  1459.             switch (2 * LABEL_FIRST_COUNTER - textclass->maxcounter + i) {
  1460.                 case LABEL_COUNTER_CHAPTER:
  1461.                     sprintf(s, "%d", par->counter[i]);
  1462.                     break;
  1463.                 case LABEL_COUNTER_SECTION:
  1464.                     sprintf(s, "%d.%d", par->counter[i - 1], par->counter[i]);
  1465.                     break;
  1466.                 case LABEL_COUNTER_SUBSECTION:
  1467.                     sprintf(s, "%d.%d.%d", par->counter[i-2], par->counter[i-1],par->counter[i]);
  1468.                     break;
  1469.                 case LABEL_COUNTER_SUBSUBSECTION:
  1470.                     sprintf(s, "%d.%d.%d.%d", par->counter[i-3], par->counter[i-2],par->counter[i-1],par->counter[i]);
  1471.                     break;
  1472.                 case LABEL_COUNTER_PARAGRAPH:
  1473.                     sprintf(s, "%d.%d.%d.%d.%d", par->counter[i-4], par->counter[i-3], par->counter[i-2],par->counter[i-1],par->counter[i]);
  1474.                     break;
  1475.                 case LABEL_COUNTER_SUBPARAGRAPH:
  1476.                     sprintf(s, "%d.%d.%d.%d.%d.%d", par->counter[i-5], par->counter[i-4], par->counter[i-3], par->counter[i-2],par->counter[i-1],par->counter[i]);
  1477.                     break;
  1478.                 default:
  1479.                     sprintf(s, "%d.", par->counter[i]);
  1480.                     break;
  1481.             }
  1482.      
  1483.             par->labelstring += s;
  1484.             delete[] s;
  1485.      
  1486.             for (i++; i<10; i++) {
  1487.                 /* reset the following counters  */
  1488.                 par->counter[i]=0;
  1489.             }
  1490.         } else if (layout->labeltype < LABEL_COUNTER_ENUMI) {
  1491.             for (i++; i<10; i++) {
  1492.                 /* reset the following counters  */
  1493.                 par->counter[i]=0;
  1494.             }
  1495.         } else if (layout->labeltype == LABEL_COUNTER_ENUMI) {
  1496.             par->counter[i + par->enumdepth]++;
  1497.             char * s = new char[25];
  1498.             int number = par->counter[i + par->enumdepth];
  1499.             switch (par->enumdepth) {
  1500.             case 1:
  1501.                 sprintf(s, "(%c)", (number % 27) + 'a' - 1);
  1502.                 break;
  1503.             case 2:
  1504.                 switch (number) {
  1505.                 case 1: sprintf(s, "i."); break;
  1506.                 case 2: sprintf(s, "ii."); break;
  1507.                 case 3: sprintf(s, "iii."); break;
  1508.                 case 4: sprintf(s, "iv."); break;
  1509.                 case 5: sprintf(s, "v."); break;
  1510.                 case 6: sprintf(s, "vi."); break;
  1511.                 case 7: sprintf(s, "vii."); break;
  1512.                 case 8: sprintf(s, "viii."); break;
  1513.                 case 9: sprintf(s, "ix."); break;
  1514.                 case 10: sprintf(s, "x."); break;
  1515.                 case 11: sprintf(s, "xi."); break;
  1516.                 case 12: sprintf(s, "xii."); break;
  1517.                 case 13: sprintf(s, "xiii."); break;
  1518.                 default:
  1519.                     sprintf(s, "\\roman{%d}.", number);
  1520.                     break;
  1521.                 }
  1522.                 break;
  1523.             case 3:
  1524.                 sprintf(s, "%c.", (number % 27) + 'A' - 1);
  1525.                 break;
  1526.             default:
  1527.                 sprintf(s, "%d.", number);
  1528.                 break;
  1529.             }
  1530.             par->labelstring = s;
  1531.             delete[] s;
  1532.  
  1533.             for (i += par->enumdepth + 1;i<10;i++)
  1534.                 par->counter[i]=0;      /* reset the following counters  */
  1535.      
  1536.         } 
  1537.     } else if (layout->labeltype == LABEL_BIBLIO) {// ale970302
  1538.         i = LABEL_COUNTER_ENUMI - LABEL_FIRST_COUNTER + par->enumdepth;
  1539.         par->counter[i]++;
  1540.         int number = par->counter[i];
  1541.         if (!par->bibkey)
  1542.           par->bibkey = new InsetBibKey();
  1543.         par->bibkey->setCounter(number);
  1544.         par->labelstring = layout->labelstring;
  1545.         
  1546.         // In biblio should't be following counters but...
  1547.     }                        
  1548.     else  {
  1549.         LString s = layout->labelstring;
  1550.       
  1551.         /* the caption hack: */
  1552.       
  1553.         if (layout->labeltype == LABEL_SENSITIVE) {
  1554.             if (par->footnoteflag != LyXParagraph::NO_FOOTNOTE
  1555.                 && (par->footnotekind == LyXParagraph::FIG
  1556.                 || par->footnotekind == LyXParagraph::WIDE_FIG))
  1557.                 s = "Figure:";
  1558.             else if (par->footnoteflag != LyXParagraph::NO_FOOTNOTE
  1559.                  && (par->footnotekind == LyXParagraph::TAB
  1560.                  || par->footnotekind == LyXParagraph::WIDE_TAB))
  1561.                 s = "Table:";
  1562.             else if (par->footnoteflag != LyXParagraph::NO_FOOTNOTE
  1563.                  && par->footnotekind == LyXParagraph::ALGORITHM)
  1564.                 s = "Algorithm:";
  1565.             else {
  1566.                 /* par->SetLayout(0); 
  1567.                    s = layout->labelstring;  */
  1568.                 s = "Senseless: "; 
  1569.        
  1570.             }
  1571.         }
  1572.         par->labelstring = s;
  1573.       
  1574.         /* reset the enumeration counter. They are always resetted
  1575.          * when there is any other layout between */ 
  1576.         for (i=6 + par->enumdepth; i<10;i++)
  1577.             par->counter[i]=0;
  1578.     }
  1579. }
  1580.  
  1581.  
  1582. /* Updates all counters BEHIND the row. Changed paragraphs
  1583. * with a dynamic left margin will be rebroken. */ 
  1584. void LyXText::UpdateCounters(Row *row)
  1585. {
  1586.     LyXParagraph *par;
  1587.     if (!row) {
  1588.         row = firstrow;
  1589.         par = row->par;
  1590.     }
  1591.     else {
  1592.         if (row->par->next && row->par->next->footnoteflag != LyXParagraph::OPEN_FOOTNOTE) {
  1593.             par = row->par->LastPhysicalPar()->Next();
  1594.         } else {
  1595.             par = row->par->next;
  1596.         }
  1597.     }
  1598.  
  1599.     while (par) {
  1600.         while (row->par != par)
  1601.             row = row->next;
  1602.       
  1603.         SetCounter(par);
  1604.       
  1605.         /* now  check for the headline layouts. remember that they
  1606.          * have a dynamic left margin */ 
  1607.         if (!par->IsDummy()
  1608.             && ( lyxstyle.Style(parameters->textclass, par->layout)->margintype == MARGIN_DYNAMIC
  1609.              || lyxstyle.Style(parameters->textclass, par->layout)->labeltype == LABEL_SENSITIVE)
  1610.             ){
  1611.      
  1612.             /* Rebreak the paragraph */ 
  1613.             RemoveParagraph(row);
  1614.             AppendParagraph(row);
  1615.        
  1616.             /* think about the damned open footnotes! */ 
  1617.             while (par->Next() &&
  1618.                    (par->Next()->footnoteflag == LyXParagraph::OPEN_FOOTNOTE
  1619.                 || par->Next()->IsDummy())){
  1620.                 par = par->Next();
  1621.                 if (par->IsDummy()) {
  1622.                     while (row->par != par)
  1623.                         row = row->next;
  1624.                     RemoveParagraph(row);
  1625.                     AppendParagraph(row);
  1626.                 }
  1627.             }
  1628.         }
  1629.      
  1630.         par = par->LastPhysicalPar()->Next();
  1631.      
  1632.     }
  1633. }
  1634.  
  1635.  
  1636. /* insets an inset. */ 
  1637. void LyXText::InsertInset(Inset *inset)
  1638. {
  1639.     SetUndo(Undo::INSERT, 
  1640.         cursor.par->ParFromPos(cursor.pos)->previous, 
  1641.         cursor.par->ParFromPos(cursor.pos)->next);
  1642.     cursor.par->InsertChar(cursor.pos, LYX_META_INSET);
  1643.     cursor.par->InsertInset(cursor.pos, inset);
  1644.     InsertChar(LYX_META_INSET);  /* just to rebreak and refresh correctly.
  1645.                       * The character will not be inserted a
  1646.                       * second time */
  1647. }
  1648.  
  1649.  
  1650. /* this is for the simple cut and paste mechanism */ 
  1651. static LyXParagraph *simple_cut_buffer = NULL;
  1652. static char simple_cut_buffer_textclass = 0;
  1653.  
  1654. void DeleteSimpleCutBuffer()
  1655. {
  1656.     if (!simple_cut_buffer)
  1657.         return;
  1658.     LyXParagraph *tmppar;
  1659.  
  1660.     while (simple_cut_buffer) {
  1661.         tmppar =  simple_cut_buffer;
  1662.         simple_cut_buffer = simple_cut_buffer->next;
  1663.         delete tmppar;
  1664.     }
  1665.     simple_cut_buffer = NULL;
  1666. }
  1667.  
  1668.  
  1669. void LyXText::copyEnvironmentType()
  1670. {
  1671.     copylayouttype = cursor.par->GetLayout();
  1672. }
  1673.  
  1674.  
  1675. void LyXText::pasteEnvironmentType()
  1676. {
  1677.     SetLayout(copylayouttype);
  1678. }
  1679.  
  1680.  
  1681. void LyXText::CutSelection(bool doclear)
  1682. {
  1683.     /* This doesn't make sense, if there is no selection */ 
  1684.     if (!selection) {
  1685.         return;
  1686.     }
  1687.    
  1688.     /* OK, we have a selection. This is always between sel_start_cursor
  1689.      * and sel_end cursor */
  1690.     LyXParagraph *tmppar;
  1691.     int i;
  1692.    
  1693.     /* Check whether there are half footnotes in the selection */
  1694.     if (sel_start_cursor.par->footnoteflag != LyXParagraph::NO_FOOTNOTE
  1695.         || sel_end_cursor.par->footnoteflag != LyXParagraph::NO_FOOTNOTE){
  1696.         tmppar = sel_start_cursor.par;
  1697.         while (tmppar != sel_end_cursor.par){
  1698.             if (tmppar->footnoteflag != sel_end_cursor.par->footnoteflag){
  1699.                 WriteAlert(_("Impossible operation"), _("Don't know what to do with half floats."), _("sorry."));
  1700.                 return;
  1701.             }
  1702.             tmppar = tmppar->Next();
  1703.         }
  1704.     }
  1705.  
  1706.     /* table stuff -- begin*/
  1707.     if (sel_start_cursor.par->table || sel_end_cursor.par->table){
  1708.         if ( sel_start_cursor.par != sel_end_cursor.par){
  1709.             WriteAlert(_("Impossible operation"), _("Don't know what to do with half tables."), _("sorry."));
  1710.             return;
  1711.         }
  1712.         sel_start_cursor.par->table->Reinit();
  1713.     }
  1714.     /* table stuff -- end*/
  1715.  
  1716.     // make sure that the depth behind the selection are restored, too
  1717.     LyXParagraph *endpar = sel_end_cursor.par->LastPhysicalPar()->Next();
  1718.     LyXParagraph *undoendpar = endpar;
  1719.  
  1720.     if (endpar && endpar->GetDepth()) {
  1721.         while (endpar && endpar->GetDepth()) {
  1722.             endpar = endpar->LastPhysicalPar()->Next();
  1723.             undoendpar = endpar;
  1724.         }
  1725.     }
  1726.     else if (endpar) {
  1727.         endpar = endpar->Next();           /* because of parindents etc.  */
  1728.     }
  1729.    
  1730.     SetUndo(Undo::DELETE, 
  1731.         sel_start_cursor.par->ParFromPos(sel_start_cursor.pos)->previous, 
  1732.         undoendpar);
  1733.    
  1734.     /* delete the simple_cut_buffer */ 
  1735.     DeleteSimpleCutBuffer();
  1736.    
  1737.     /* set the textclass */
  1738.     simple_cut_buffer_textclass = parameters->textclass;
  1739.  
  1740. #ifdef WITH_WARNINGS
  1741. #warning Asger: Make cut more intelligent here.
  1742. #endif
  1743. /* 
  1744. White paper for "intelligent" cutting:
  1745.  
  1746. Example: "This is our text."
  1747. Using " our " as selection, cutting will give "This istext.".
  1748. Using "our" as selection, cutting will give "This is text.".
  1749. Using " our" as selection, cutting will give "This is text.".
  1750. Using "our " as selection, cutting will give "This is text.".
  1751.  
  1752. All those four selections will (however) paste identically:
  1753. Pasting with the cursor right after the "is" will give the
  1754. original text with all four selections.
  1755.  
  1756. The rationale is to be intelligent such that words are copied,
  1757. cut and pasted in a functional manner.
  1758.  
  1759. This is not implemented yet.
  1760. */
  1761.  
  1762.     char space_wrapped =
  1763.         sel_end_cursor.par->IsLineSeparator(sel_end_cursor.pos);
  1764.     if (sel_end_cursor.pos > 0
  1765.         && sel_end_cursor.par->IsLineSeparator(sel_end_cursor.pos - 1)) {
  1766.         sel_end_cursor.pos--;           /* please break before a space at
  1767.                     * the end */
  1768.         space_wrapped = True;
  1769.     }
  1770.  
  1771.     // cut behind a space if there is one
  1772.     while (sel_start_cursor.par->Last() > sel_start_cursor.pos
  1773.            && sel_start_cursor.par->IsLineSeparator(sel_start_cursor.pos)
  1774.            && (sel_start_cursor.par != sel_end_cursor.par
  1775.            || sel_start_cursor.pos < sel_end_cursor.pos))
  1776.         sel_start_cursor.pos++; 
  1777.    
  1778.    /* there are two cases: cut only within one paragraph or
  1779.     * more than one paragraph */
  1780.    
  1781.     if (sel_start_cursor.par->ParFromPos(sel_start_cursor.pos) 
  1782.         == sel_end_cursor.par->ParFromPos(sel_end_cursor.pos)) {
  1783.         /* only within one paragraph */
  1784.         simple_cut_buffer = new LyXParagraph();
  1785.         for (i=sel_start_cursor.pos; i< sel_end_cursor.pos; i++){
  1786.             /* table stuff -- begin*/
  1787.             if (sel_start_cursor.par->table
  1788.                 && sel_start_cursor.par->IsNewline(sel_start_cursor.pos)){
  1789.                 sel_start_cursor.par->CopyIntoMinibuffer(sel_start_cursor.pos);
  1790.                 sel_start_cursor.pos++;
  1791.             } else {
  1792.                 /* table stuff -- end*/
  1793.                 sel_start_cursor.par->CutIntoMinibuffer(sel_start_cursor.pos);
  1794.                 sel_start_cursor.par->Erase(sel_start_cursor.pos);
  1795.             }
  1796.             simple_cut_buffer->InsertFromMinibuffer(simple_cut_buffer->Last());
  1797.         }
  1798.         /* check for double spaces */
  1799.         if (sel_start_cursor.pos &&
  1800.             sel_start_cursor.par->Last()>sel_start_cursor.pos &&
  1801.             sel_start_cursor.par->IsLineSeparator(sel_start_cursor.pos - 1) &&
  1802.             sel_start_cursor.par->IsLineSeparator(sel_start_cursor.pos)){
  1803.             sel_start_cursor.par->Erase(sel_start_cursor.pos);
  1804.         }
  1805.         if (space_wrapped)
  1806.             simple_cut_buffer->InsertChar(i - sel_start_cursor.pos, ' ');
  1807.         endpar = sel_end_cursor.par->Next();
  1808.     }
  1809.     else {
  1810.         /* cut more than one paragraph */ 
  1811.    
  1812.         sel_end_cursor.par->BreakParagraphConservative(sel_end_cursor.pos);
  1813.         /* insert a space at the end if there was one */
  1814.         if (space_wrapped)
  1815.             sel_end_cursor.par->InsertChar(sel_end_cursor.par->Last(), ' ');
  1816.    
  1817.         sel_end_cursor.par = sel_end_cursor.par->Next();
  1818.         sel_end_cursor.pos = 0;
  1819.    
  1820.         cursor = sel_end_cursor;
  1821.    
  1822.         /* please break behind a space, if there is one. The space should
  1823.       * be copied too */ 
  1824.         if (sel_start_cursor.par->IsLineSeparator(sel_start_cursor.pos))
  1825.             sel_start_cursor.pos++;
  1826.    
  1827.         sel_start_cursor.par->BreakParagraphConservative(sel_start_cursor.pos);
  1828.         if (!sel_start_cursor.pos
  1829.             || sel_start_cursor.par->IsLineSeparator(sel_start_cursor.pos - 1)
  1830.             || sel_start_cursor.par->IsNewline(sel_start_cursor.pos - 1)) {
  1831.             sel_start_cursor.par->Next()->InsertChar(0, ' ');
  1832.         }
  1833.    
  1834.         /* store the endparagraph for redoing later */
  1835.         endpar = sel_end_cursor.par->Next();   /* needed because
  1836.                             * the sel_end_
  1837.                             * cursor.par
  1838.                             * will be pasted!*/
  1839.    
  1840.      /*store the selection */ 
  1841.         simple_cut_buffer = sel_start_cursor.par->ParFromPos(sel_start_cursor.pos)->next;
  1842.         simple_cut_buffer->previous = NULL;
  1843.         sel_end_cursor.par->previous->next = NULL;
  1844.  
  1845.         /* cut the selection */ 
  1846.         sel_start_cursor.par->ParFromPos(sel_start_cursor.pos)->next 
  1847.             = sel_end_cursor.par;
  1848.    
  1849.         sel_end_cursor.par->previous 
  1850.             = sel_start_cursor.par->ParFromPos(sel_start_cursor.pos);
  1851.  
  1852.      /* care about footnotes */
  1853.         if (simple_cut_buffer->footnoteflag) {
  1854.             LyXParagraph *tmppar = simple_cut_buffer;
  1855.             while (tmppar){
  1856.                 tmppar->footnoteflag = LyXParagraph::NO_FOOTNOTE;
  1857.                 tmppar = tmppar->next;
  1858.             }
  1859.         }
  1860.  
  1861.         /* the cut selection should begin with standard layout */
  1862.         simple_cut_buffer->Clear(); 
  1863.    
  1864.         /* paste the paragraphs again, if possible  */
  1865.         if (doclear)
  1866.             sel_start_cursor.par->Next()->ClearParagraph();
  1867.         if (sel_start_cursor.par->FirstPhysicalPar()->HasSameLayout(sel_start_cursor.par->Next())
  1868.             || 
  1869.             !sel_start_cursor.par->Next()->Last())
  1870.             sel_start_cursor.par->ParFromPos(sel_start_cursor.pos)->PasteParagraph();
  1871.  
  1872.    
  1873.    /* maybe a forgotten blank */
  1874.         if (sel_start_cursor.pos 
  1875.             && sel_start_cursor.par->IsLineSeparator(sel_start_cursor.pos)
  1876.             && sel_start_cursor.par->IsLineSeparator(sel_start_cursor.pos - 1)) {
  1877.             sel_start_cursor.par->Erase(sel_start_cursor.pos);
  1878.         }
  1879.     }   
  1880.  
  1881.  
  1882.     /* sometimes necessary */
  1883.     if (doclear)
  1884.         sel_start_cursor.par->ClearParagraph();
  1885.  
  1886.     RedoParagraphs(sel_start_cursor, endpar);
  1887.    
  1888.     ClearSelection();
  1889.     cursor = sel_start_cursor;
  1890.     SetCursor(cursor.par, cursor.pos);
  1891.     sel_cursor = cursor;
  1892.     UpdateCounters(cursor.row);
  1893. }
  1894.  
  1895.     
  1896. void LyXText::CopySelection()
  1897. {
  1898.     int i=0;
  1899.    
  1900.     /* this doesnt make sense, if there is no selection */ 
  1901.     if (!selection) {
  1902.         return;
  1903.     }
  1904.  
  1905.     /* ok we have a selection. This is always between sel_start_cursor
  1906.      * and sel_end cursor */
  1907.     LyXParagraph *tmppar;
  1908.    
  1909.     /* check wether there are half footnotes in the selection */
  1910.     if (sel_start_cursor.par->footnoteflag != LyXParagraph::NO_FOOTNOTE
  1911.         || sel_end_cursor.par->footnoteflag != LyXParagraph::NO_FOOTNOTE){
  1912.         tmppar = sel_start_cursor.par;
  1913.         while (tmppar != sel_end_cursor.par){
  1914.             if (tmppar->footnoteflag != sel_end_cursor.par->footnoteflag){
  1915.                 WriteAlert(_("Impossible operation"), _("Don't know what to do with half floats."), _("sorry."));
  1916.                 return;
  1917.             }
  1918.             tmppar = tmppar->Next();
  1919.         }
  1920.     }
  1921.  
  1922.     /* table stuff -- begin*/
  1923.     if (sel_start_cursor.par->table || sel_end_cursor.par->table){
  1924.         if ( sel_start_cursor.par != sel_end_cursor.par){
  1925.             WriteAlert(_("Impossible operation"), _("Don't know what to do with half tables."), _("sorry."));
  1926.             return;
  1927.         }
  1928.     }
  1929.     /* table stuff -- end*/
  1930.    
  1931.     /* delete the simple_cut_buffer */ 
  1932.     DeleteSimpleCutBuffer();
  1933.  
  1934.     /* set the textclass */
  1935.     simple_cut_buffer_textclass = parameters->textclass;
  1936.  
  1937.     // copy behind a space if there is one
  1938.     while (sel_start_cursor.par->Last() > sel_start_cursor.pos
  1939.            && sel_start_cursor.par->IsLineSeparator(sel_start_cursor.pos)
  1940.            && (sel_start_cursor.par != sel_end_cursor.par
  1941.            || sel_start_cursor.pos < sel_end_cursor.pos))
  1942.         sel_start_cursor.pos++; 
  1943.  
  1944.     /* there are two cases: copy only within one paragraph or more than one paragraph */
  1945.     if (sel_start_cursor.par->ParFromPos(sel_start_cursor.pos) 
  1946.         == sel_end_cursor.par->ParFromPos(sel_end_cursor.pos)) {
  1947.         /* only within one paragraph */
  1948.         simple_cut_buffer = new LyXParagraph();
  1949.         for (i=sel_start_cursor.pos; i< sel_end_cursor.pos; i++){
  1950.             sel_start_cursor.par->CopyIntoMinibuffer(i);
  1951.             simple_cut_buffer->InsertFromMinibuffer(i - sel_start_cursor.pos);
  1952.         }
  1953.     }
  1954.     else {
  1955.         /* copy more than one paragraph */ 
  1956.         /* clone the paragraphs within the selection*/
  1957.         tmppar = sel_start_cursor.par->ParFromPos(sel_start_cursor.pos);
  1958.         simple_cut_buffer = tmppar->Clone();
  1959.         LyXParagraph *tmppar2 = simple_cut_buffer;
  1960.      
  1961.         while (tmppar != sel_end_cursor.par->ParFromPos(sel_end_cursor.pos)
  1962.                && tmppar->next) {
  1963.             tmppar = tmppar->next;
  1964.             tmppar2->next = tmppar->Clone();
  1965.             tmppar2->next->previous = tmppar2;
  1966.             tmppar2=tmppar2->next;
  1967.         }
  1968.         tmppar2->next = NULL;
  1969.  
  1970.         /* care about footnotes */
  1971.         if (simple_cut_buffer->footnoteflag) {
  1972.             tmppar = simple_cut_buffer;
  1973.             while (tmppar){
  1974.                 tmppar->footnoteflag = LyXParagraph::NO_FOOTNOTE;
  1975.                 tmppar = tmppar->next;
  1976.             }
  1977.         }
  1978.      
  1979.         /* the simple_cut_buffer paragraph is too big */
  1980.         int tmpi2;
  1981.  
  1982.         tmpi2 = sel_start_cursor.par->PositionInParFromPos(sel_start_cursor.pos);
  1983.         for (;tmpi2;tmpi2--)
  1984.             simple_cut_buffer->Erase(0);
  1985.  
  1986.         /* now tmppar 2 is too big, delete all after sel_end_cursor.pos */
  1987.      
  1988.         tmpi2 = sel_end_cursor.par->PositionInParFromPos(sel_end_cursor.pos);
  1989.         while (tmppar2->last > tmpi2) {
  1990.             tmppar2->Erase(tmppar2->last-1);
  1991.         }
  1992.  
  1993.     }
  1994. }
  1995.           
  1996.  
  1997. void LyXText::PasteSelection()
  1998. {
  1999.     /* this does not make sense, if there is nothing to paste */ 
  2000.     if (!simple_cut_buffer)
  2001.         return;
  2002.  
  2003.     LyXParagraph *tmppar;
  2004.     LyXParagraph *endpar;
  2005.  
  2006.     LyXCursor tmpcursor;
  2007.  
  2008.     /* be carefull with footnotes in footnotes */ 
  2009.     if (cursor.par->footnoteflag != LyXParagraph::NO_FOOTNOTE) {
  2010.       
  2011.         /* check whether the cut_buffer includes a footnote */
  2012.         tmppar = simple_cut_buffer;
  2013.         while (tmppar && tmppar->footnoteflag == LyXParagraph::NO_FOOTNOTE)
  2014.             tmppar = tmppar->next;
  2015.       
  2016.         if (tmppar) {
  2017.             WriteAlert(_("Impossible operation"),
  2018.                    _("Can't paste float into float!"), _("Sorry."));
  2019.             return;
  2020.         }
  2021.     }
  2022.  
  2023.     /* table stuff -- begin*/
  2024.     if (cursor.par->table){
  2025.         if (simple_cut_buffer->next){
  2026.             WriteAlert(_("Impossible operation"),
  2027.                    _("Table cell cannot include more than one paragraph!"),
  2028.                    _("Sorry."));
  2029.             return;
  2030.         }
  2031.     }
  2032.     /* table stuff -- end*/
  2033.    
  2034.     SetUndo(Undo::INSERT, 
  2035.         cursor.par->ParFromPos(cursor.pos)->previous, 
  2036.         cursor.par->ParFromPos(cursor.pos)->next); 
  2037.  
  2038.     tmpcursor = cursor;
  2039.  
  2040.     /* There are two cases: cutbuffer only one paragraph or many */
  2041.     if (!simple_cut_buffer->next) {
  2042.         /* only within a paragraph */
  2043.      
  2044.         /* please break behind a space, if there is one */
  2045.         while (tmpcursor.par->Last() > tmpcursor.pos
  2046.                && tmpcursor.par->IsLineSeparator(tmpcursor.pos))
  2047.             tmpcursor.pos++; 
  2048.  
  2049.         tmppar = simple_cut_buffer->Clone();
  2050.         /* table stuff -- begin*/
  2051.         bool table_too_small = false;
  2052.         if (tmpcursor.par->table) {
  2053.             while (simple_cut_buffer->last && !table_too_small){
  2054.                 if (simple_cut_buffer->IsNewline(0)){
  2055.                     while(tmpcursor.pos < tmpcursor.par->Last() && !tmpcursor.par->IsNewline(tmpcursor.pos))
  2056.                         tmpcursor.pos++;
  2057.                     simple_cut_buffer->Erase(0);
  2058.                     if (tmpcursor.pos < tmpcursor.par->Last())
  2059.                         tmpcursor.pos++;
  2060.                     else
  2061.                         table_too_small = true;
  2062.                 } else {
  2063.                     simple_cut_buffer->CutIntoMinibuffer(0);
  2064.                     simple_cut_buffer->Erase(0);
  2065.                     tmpcursor.par->InsertFromMinibuffer(tmpcursor.pos);
  2066.                     tmpcursor.pos++;
  2067.                 }
  2068.             }
  2069.         } else {
  2070.             /* table stuff -- end*/
  2071.             while (simple_cut_buffer->last){
  2072.                 simple_cut_buffer->CutIntoMinibuffer(0);
  2073.                 simple_cut_buffer->Erase(0);
  2074.                 tmpcursor.par->InsertFromMinibuffer(tmpcursor.pos);
  2075.                 tmpcursor.pos++;
  2076.             }
  2077.         }
  2078.  
  2079.         delete simple_cut_buffer;
  2080.         simple_cut_buffer = tmppar;
  2081.         endpar = tmpcursor.par->Next();
  2082.     } else {
  2083.         /* many paragraphs */
  2084.  
  2085.         /* make a copy of the simple cut_buffer */
  2086.         tmppar = simple_cut_buffer;
  2087.         LyXParagraph *simple_cut_clone = tmppar->Clone();
  2088.         LyXParagraph *tmppar2 = simple_cut_clone;
  2089.         if (cursor.par->footnoteflag){
  2090.             tmppar->footnoteflag = cursor.par->footnoteflag;
  2091.             tmppar->footnotekind = cursor.par->footnotekind;
  2092.         }
  2093.         while (tmppar->next) {
  2094.             tmppar = tmppar->next;
  2095.             tmppar2->next = tmppar->Clone();
  2096.             tmppar2->next->previous = tmppar2;
  2097.             tmppar2=tmppar2->next;
  2098.             if (cursor.par->footnoteflag){
  2099.                 tmppar->footnoteflag = cursor.par->footnoteflag;
  2100.                 tmppar->footnotekind = cursor.par->footnotekind;
  2101.             }
  2102.         }
  2103.      
  2104.         /* make sure there is no class difference */ 
  2105.         SwitchLayoutsBetweenClasses(simple_cut_buffer_textclass,
  2106.                         parameters->textclass,
  2107.                         simple_cut_buffer);
  2108.      
  2109.         /* make the simple_cut_buffer exactly the same layout than
  2110.            the cursor paragraph */
  2111.         simple_cut_buffer->MakeSameLayout(cursor.par);
  2112.      
  2113.         /* find the end of the buffer */ 
  2114.         LyXParagraph *lastbuffer = simple_cut_buffer;
  2115.         while (lastbuffer->Next())
  2116.             lastbuffer=lastbuffer->Next();
  2117.      
  2118.         /* find the physical end of the buffer */ 
  2119.         lastbuffer = simple_cut_buffer;
  2120.         while (lastbuffer->Next())
  2121.             lastbuffer=lastbuffer->Next();
  2122.      
  2123.         /* please break behind a space, if there is one. The space 
  2124.          * should be copied too */
  2125.         if (cursor.par->Last() > cursor.pos && cursor.par->IsLineSeparator(cursor.pos))
  2126.             cursor.pos++; 
  2127.      
  2128.         bool paste_the_end = false;
  2129.  
  2130.         /* open the paragraph for inserting the simple_cut_buffer
  2131.            if necessary */
  2132.         if (cursor.par->Last() > cursor.pos || !cursor.par->Next()){
  2133.             cursor.par->BreakParagraphConservative(cursor.pos);
  2134.             paste_the_end = true;
  2135.         }
  2136.      
  2137.         /* be careful with double spaces */ 
  2138.         if ((!cursor.par->Last()
  2139.              || cursor.par->IsLineSeparator(cursor.pos - 1)
  2140.              || cursor.par->IsNewline(cursor.pos - 1))
  2141.             && simple_cut_buffer->last
  2142.             && simple_cut_buffer->IsLineSeparator(0))
  2143.             simple_cut_buffer->Erase(0);
  2144.      
  2145.         /* set the end for redoing later */ 
  2146.         endpar = cursor.par->ParFromPos(cursor.pos)->next->Next();
  2147.      
  2148.         /* paste it! */ 
  2149.         lastbuffer->ParFromPos(lastbuffer->Last())->next = cursor.par->ParFromPos(cursor.pos)->next;
  2150.         cursor.par->ParFromPos(cursor.pos)->next->previous = lastbuffer->ParFromPos(lastbuffer->Last());
  2151.      
  2152.         cursor.par->ParFromPos(cursor.pos)->next = simple_cut_buffer;
  2153.         simple_cut_buffer->previous = cursor.par->ParFromPos(cursor.pos);
  2154.    
  2155.         if (cursor.par->ParFromPos(cursor.pos)->Next() == lastbuffer)
  2156.             lastbuffer = cursor.par;
  2157.      
  2158.         cursor.par->ParFromPos(cursor.pos)->PasteParagraph();
  2159.      
  2160.         /* store the new cursor position  */
  2161.         tmpcursor.par = lastbuffer;
  2162.         tmpcursor.pos = lastbuffer->Last();
  2163.      
  2164.         /* maybe some pasting */ 
  2165.         if (lastbuffer->Next() && paste_the_end) {
  2166.             if (lastbuffer->Next()->HasSameLayout(lastbuffer)) {
  2167.      
  2168.                 /* be careful witth double spaces */ 
  2169.                 if ((!lastbuffer->Last()
  2170.                      || lastbuffer->IsLineSeparator(lastbuffer->Last() - 1)
  2171.                      || lastbuffer->IsNewline(lastbuffer->Last() - 1))
  2172.                     && lastbuffer->Next()->Last()
  2173.                     && lastbuffer->Next()->IsLineSeparator(0))
  2174.                     lastbuffer->Next()->Erase(0);
  2175.      
  2176.                 lastbuffer->ParFromPos(lastbuffer->Last())->PasteParagraph();
  2177.      
  2178.             }
  2179.             else if (!lastbuffer->Next()->Last()) {
  2180.                 lastbuffer->Next()->MakeSameLayout(lastbuffer);
  2181.      
  2182.                 /* be careful witth double spaces */ 
  2183.                 if ((!lastbuffer->Last()
  2184.                      || lastbuffer->IsLineSeparator(lastbuffer->Last() - 1)
  2185.                      || lastbuffer->IsNewline(lastbuffer->Last() - 1))
  2186.                     && lastbuffer->Next()->Last()
  2187.                     && lastbuffer->Next()->IsLineSeparator(0))
  2188.                     lastbuffer->Next()->Erase(0);
  2189.      
  2190.                 lastbuffer->ParFromPos(lastbuffer->Last())->PasteParagraph();
  2191.      
  2192.             }
  2193.             else if (!lastbuffer->Last()) {
  2194.                 lastbuffer->MakeSameLayout(lastbuffer->next);
  2195.      
  2196.                 /* be careful witth double spaces */ 
  2197.                 if ((!lastbuffer->Last()
  2198.                      || lastbuffer->IsLineSeparator(lastbuffer->Last() - 1)
  2199.                      || lastbuffer->IsNewline(lastbuffer->Last() - 1))
  2200.                     && lastbuffer->Next()->Last()
  2201.                     && lastbuffer->Next()->IsLineSeparator(0))
  2202.                     lastbuffer->Next()->Erase(0);
  2203.      
  2204.                 lastbuffer->ParFromPos(lastbuffer->Last())->PasteParagraph();
  2205.      
  2206.             }
  2207.             else lastbuffer->Next()->ClearParagraph();
  2208.         }
  2209.  
  2210.         /* restore the simple cut buffer */
  2211.         simple_cut_buffer = simple_cut_clone;
  2212.     }
  2213.  
  2214.     RedoParagraphs(cursor, endpar);
  2215.     
  2216.     SetCursor(cursor.par, cursor.pos);
  2217.     ClearSelection();
  2218.    
  2219.     sel_cursor = cursor;
  2220.     SetCursor(tmpcursor.par, tmpcursor.pos);
  2221.     SetSelection();
  2222.     UpdateCounters(cursor.row);
  2223. }
  2224.    
  2225.  
  2226. /* returns a pointer to the very first LyXParagraph */ 
  2227. LyXParagraph* LyXText::FirstParagraph()
  2228. {
  2229.     return params->paragraph;
  2230. }
  2231.  
  2232.  
  2233. /* returns true if the specified string is at the specified position */
  2234. bool LyXText::IsStringInText(LyXParagraph *par, int pos, char const* string)
  2235. {
  2236.     if (par) {
  2237.         int i = 0;
  2238.         while (pos+i < par->Last() && string[i] && 
  2239.                string[i]==par->GetChar(pos+i))
  2240.         {
  2241.             i++;
  2242.         }
  2243.  
  2244.         if (!string[i])
  2245.             return true;
  2246.     }
  2247.     return false;
  2248. }
  2249.  
  2250.  
  2251. /* sets the selection over the number of characters of string, no check!! */
  2252. void LyXText::SetSelectionOverString(char const* string)
  2253. {
  2254.     sel_cursor = cursor;
  2255.     int i;
  2256.     for (i=0; string[i]; i++)
  2257.         CursorRight();
  2258.     SetSelection();
  2259. }
  2260.  
  2261.  
  2262. /* simple replacing. The font of the first selected character is used */
  2263. void LyXText::ReplaceSelectionWithString(char const* string)
  2264. {
  2265.     SetCursorParUndo();
  2266.     FreezeUndo();
  2267.  
  2268.     if (!selection) { /* create a dummy selection */
  2269.         sel_end_cursor = cursor;
  2270.         sel_start_cursor = cursor;
  2271.     }
  2272.  
  2273.     // Get font setting before we cut
  2274.     int pos = sel_end_cursor.pos;
  2275.     LyXFont font = sel_end_cursor.par->GetFontSettings(pos);
  2276.  
  2277.     // Insert the new string
  2278.     for (int i=0; string[i];i++) {
  2279.         sel_end_cursor.par->InsertChar(pos, string[i]);
  2280.         sel_end_cursor.par->SetFont(pos, font);
  2281.         pos++;
  2282.     }
  2283.  
  2284.     // Cut the selection
  2285.     CutSelection();
  2286.  
  2287.     UnFreezeUndo();
  2288. }
  2289.  
  2290.  
  2291. /* if the string can be found: return true and set the cursor to
  2292.  * the new position */
  2293. bool LyXText::SearchForward(char const* string)
  2294. {
  2295.     LyXParagraph *par = cursor.par;
  2296.     int pos = cursor.pos;
  2297.  
  2298.     while (par && !IsStringInText(par,pos,string)) {
  2299.         if (pos<par->Last()-1)
  2300.             pos++;
  2301.         else {
  2302.             pos = 0;
  2303.             par = par->Next();
  2304.         }
  2305.     }
  2306.     if (par) {
  2307.         SetCursor(par,pos);
  2308.         return true;
  2309.     }
  2310.     else
  2311.         return false;
  2312. }
  2313.  
  2314.  
  2315. bool LyXText::SearchBackward(char const* string)
  2316. {
  2317.     LyXParagraph *par = cursor.par;
  2318.     int pos = cursor.pos;
  2319.  
  2320.     do {
  2321.         if (pos>0)
  2322.             pos--;
  2323.         else {
  2324.             // We skip empty paragraphs (Asger)
  2325.             do {
  2326.                 par = par->Previous();
  2327.                 if (par)
  2328.                     pos = par->Last()-1;
  2329.             } while (par && pos<0);
  2330.         }
  2331.     } while (par && !IsStringInText(par,pos,string));
  2332.   
  2333.     if (par) {
  2334.         SetCursor(par,pos);
  2335.         return true;
  2336.     }
  2337.     else
  2338.         return false;
  2339. }
  2340.  
  2341.  
  2342. /* needed to insert the selection */
  2343. void LyXText::InsertStringA(char* string)
  2344. {
  2345.     LyXParagraph *par = cursor.par;
  2346.     int pos = cursor.pos;
  2347.     int a = 0;
  2348.         int cell = 0;
  2349.     LyXParagraph *endpar = cursor.par->Next();
  2350.  
  2351.     SetCursorParUndo();
  2352.  
  2353.     char flag = lyxstyle.Style(parameters->textclass, 
  2354.                    cursor.par->GetLayout())->isEnvironment();
  2355.     /* only to be sure, should not be neccessary */ 
  2356.     ClearSelection();
  2357.    
  2358.     /* insert the string, don't insert doublespace */ 
  2359.     int i=0;
  2360.     int i2 = 0;
  2361.  
  2362.     for (i2=i;string[i2]&&string[i2]!='\n';i2++);
  2363.     par->Enlarge(pos, i2 - i);
  2364.     while (string[i]) {
  2365.         if (string[i]!='\n') {
  2366.             if (string[i]==' ' && (string[i+1]!=' ')
  2367.                 && pos && par->GetChar(pos-1)!=' ') {
  2368.                 par->InsertChar(pos,' ');
  2369.                 pos++;
  2370.             }
  2371.                         else if (par->table) {
  2372.                             if (string[i] == '\t') {
  2373.                                 while((pos < par->last) &&
  2374.                                       (par->GetChar(pos) != LYX_META_NEWLINE))
  2375.                                         pos++;
  2376.                                 if (pos < par->last)
  2377.                                         pos++;
  2378.                                 else // no more fields to fill skip the rest
  2379.                                         break;
  2380.                             } else if ((string[i] != 13) &&
  2381.                                 (((unsigned char) string[i] & 127) >= ' ')) {
  2382.                                 par->InsertChar(pos,string[i]);
  2383.                                 pos++;
  2384.                             }
  2385.                         }
  2386.             else if (string[i]==' ') {
  2387.                 par->InsertChar(pos,LYX_META_PROTECTED_SEPARATOR);
  2388.                 pos++;
  2389.             }
  2390.             else if (string[i]=='\t') {
  2391.                 for (a=pos; a<(pos/8+1)*8 ; a++) {
  2392.                     par->InsertChar(a,LYX_META_PROTECTED_SEPARATOR);
  2393.                 }
  2394.                 pos = a;
  2395.             }
  2396.             else if (string[i]!=13 && 
  2397.                  // Ignore unprintables
  2398.                  ((unsigned char) string[i] & 127) >= ' ') {
  2399.                 par->InsertChar(pos,string[i]);
  2400.                 pos++;
  2401.             }
  2402.         } else {
  2403.                         if (par->table) {
  2404.                                 if (!string[i+1]) {
  2405.                                         pos++;
  2406.                                         break;
  2407.                                 }
  2408.                                 while((pos < par->last) &&
  2409.                                       (par->GetChar(pos) != LYX_META_NEWLINE))
  2410.                                         pos++;
  2411.                                 pos++;
  2412.                                 cell=NumberOfCell(par,pos);
  2413.                                 while((pos < par->last) &&
  2414.                                       !(par->table->IsFirstCell(cell))) {
  2415.                                         while((pos < par->last) &&
  2416.                                               (par->GetChar(pos) != LYX_META_NEWLINE))
  2417.                                                 pos++;
  2418.                                         pos++;
  2419.                                         cell=NumberOfCell(par,pos);
  2420.                                 }
  2421.                                 if (pos >= par->last)
  2422.                                         // no more fields to fill skip the rest
  2423.                                         break;
  2424.                         } else {
  2425.                                 if (!par->last) {
  2426.                                         par->InsertChar(pos,LYX_META_PROTECTED_SEPARATOR);
  2427.                                         pos++;
  2428.                                 }
  2429.                                 par->BreakParagraph(pos, flag);
  2430.                                 par = par->Next();
  2431.                                 pos = 0;
  2432.                         }
  2433.             for (i2=i;string[i2]&&string[i2]!='\n';i2++);
  2434.             par->Enlarge(pos, i2 - i);
  2435.         }
  2436.       
  2437.         i++;
  2438.     }
  2439.    
  2440.     RedoParagraphs(cursor,endpar);
  2441.     SetCursor(cursor.par, cursor.pos);
  2442.     sel_cursor = cursor;
  2443.     SetCursor(par, pos);
  2444.     SetSelection();
  2445. }
  2446.  
  2447. /* turns double-CR to single CR, others where converted into one blank and 13s 
  2448.  * that are ignored .Double spaces are also converted into one. Spaces at
  2449.  * the beginning of a paragraph are forbidden. tabs are converted into one
  2450.  * space. then InsertStringA is called */ 
  2451. void LyXText::InsertStringB(char* string)
  2452. {
  2453.     LyXParagraph *par = cursor.par;
  2454.     int i=1;
  2455.     while (string[i]) {
  2456.         if (string[i]=='\t' && !par->table)
  2457.             string[i] = ' ';
  2458.         if (string[i]==' ' && string[i+1]==' ')
  2459.             string[i] = 13;
  2460.         if (string[i]=='\n' && string[i+1] && !par->table){
  2461.             if (string[i+1]!='\n') {
  2462.                 if (string[i-1]!=' ')
  2463.                     string[i]=' ';
  2464.                 else
  2465.                     string[i]= 13;
  2466.             }
  2467.             while (string[i+1] && (string[i+1]==' '
  2468.                            || string[i+1]=='\t'
  2469.                            || string[i+1]=='\n'
  2470.                            || string[i+1]==13)) {
  2471.                 string[i+1]=13;
  2472.                 i++;
  2473.             }
  2474.         }
  2475.         i++;
  2476.     }
  2477.     InsertStringA(string);
  2478. }
  2479.  
  2480.  
  2481. bool LyXText::GotoNextError()
  2482. {
  2483.     LyXCursor res=cursor;
  2484.     do {
  2485.         if (res.pos < res.par->Last()-1) {
  2486.             res.pos++;
  2487.         }
  2488.         else  {
  2489.             res.par=res.par->Next();
  2490.             res.pos = 0;
  2491.         }
  2492.       
  2493.     } while (res.par && 
  2494.          !(res.par->GetChar(res.pos)==LYX_META_INSET
  2495.            && res.par->GetInset(res.pos)->AutoDelete()));
  2496.    
  2497.     if (res.par) {
  2498.         SetCursor(res.par, res.pos);
  2499.         return true;
  2500.     }
  2501.    
  2502.     return false;
  2503. }
  2504.  
  2505.  
  2506. bool LyXText::GotoNextNote()
  2507. {
  2508.     LyXCursor res=cursor;
  2509.     do {
  2510.         if (res.pos < res.par->Last()-1) {
  2511.             res.pos++;
  2512.         }
  2513.         else  {
  2514.             res.par=res.par->Next();
  2515.             res.pos = 0;
  2516.         }
  2517.       
  2518.     } while (res.par && 
  2519.          !(res.par->GetChar(res.pos)==LYX_META_INSET
  2520.            && res.par->GetInset(res.pos)->LyxCode()==Inset::IGNORE_CODE));
  2521.    
  2522.     if (res.par) {
  2523.         SetCursor(res.par, res.pos);
  2524.         return true;
  2525.     }
  2526.    
  2527.     return false;
  2528. }
  2529.  
  2530.  
  2531. int LyXText::SwitchLayoutsBetweenClasses(char class1, char class2,
  2532.                      LyXParagraph *par)
  2533. {
  2534.     InsetError * new_inset = NULL;
  2535.     int ret = 0;
  2536.     if (!par || class1 == class2)
  2537.         return ret;
  2538.     par = par->FirstPhysicalPar();
  2539.     while (par) {
  2540.         LString name = lyxstyle.NameOfLayout(class1, par->layout);
  2541.         int lay = lyxstyle.NumberOfLayout(class2, name);
  2542.         if (lay == -1) // layout not found
  2543.             // use default layout "Stadard" (0)
  2544.             lay = 0;
  2545.         par->layout = lay;
  2546.       
  2547.         if (name != lyxstyle.NameOfLayout(class2, par->layout)) {
  2548.             ret++;
  2549.             LString s= "Layout had to be changed from\n"
  2550.                 + name + " to " + lyxstyle.NameOfLayout(class2, par->layout)
  2551.                 + "\nbecause of class conversion from\n"
  2552.                 + lyxstyle.NameOfClass(class1) + " to "
  2553.                 + lyxstyle.NameOfClass(class2);
  2554.             new_inset = new InsetError(s);
  2555.             par->InsertChar(0, LYX_META_INSET);
  2556.             par->InsertInset(0, new_inset);
  2557.         }
  2558.       
  2559.         par = par->next;
  2560.     }
  2561.     return ret;
  2562. }
  2563.  
  2564.  
  2565. void LyXText::CheckParagraph(LyXParagraph* par, int pos)
  2566. {
  2567.   
  2568.     LyXCursor tmpcursor;
  2569.  
  2570.     /* table stuff -- begin*/
  2571.    
  2572.     if (par->table) {
  2573.         CheckParagraphInTable(par, pos);
  2574.     }
  2575.     else {
  2576.         /* table stuff -- end*/
  2577.      
  2578.         long y = 0;
  2579.         int z;
  2580.      
  2581.         Row* row = GetRow(par, pos, y);
  2582.      
  2583.         /* is there a break one row above */ 
  2584.         if (row->previous && row->previous->par == row->par) {
  2585.             z = NextBreakPoint(row->previous, paperwidth);
  2586.             if ( z >= row->pos) {
  2587.                 /* set the dimensions of the row above  */ 
  2588.                 y -= row->previous->height;
  2589.                 refresh_y = y;
  2590.                 refresh_row = row->previous;
  2591.                 status = LyXText::NEED_MORE_REFRESH;
  2592.        
  2593.                 BreakAgain(row->previous);
  2594.  
  2595.                 /* set the cursor again. Otherwise dungling pointers are possible */
  2596.                 SetCursor(cursor.par, cursor.pos);
  2597.                 sel_cursor = cursor;
  2598.                 return;
  2599.             }
  2600.         }
  2601.  
  2602.         int tmpheight = row->height;
  2603.         int tmplast = RowLast(row);
  2604.         refresh_y = y;
  2605.         refresh_row = row;
  2606.  
  2607.         BreakAgain(row);
  2608.         if (row->height == tmpheight && RowLast(row) == tmplast)
  2609.             status = LyXText::NEED_VERY_LITTLE_REFRESH;
  2610.         else
  2611.             status = LyXText::NEED_MORE_REFRESH; 
  2612.    
  2613.         /* check the special right address boxes */
  2614.         if (lyxstyle.Style(parameters->textclass, par->GetLayout())->margintype == MARGIN_RIGHT_ADDRESS_BOX) {
  2615.             tmpcursor.par = par;
  2616.             tmpcursor.row = row;
  2617.             tmpcursor.y = y;
  2618.             tmpcursor.x = 0;
  2619.             tmpcursor.pos = pos;
  2620.             RedoDrawingOfParagraph(tmpcursor); 
  2621.         }
  2622.    
  2623.     }
  2624.  
  2625.     /* set the cursor again. Otherwise dangling pointers are possible */
  2626.     // also set the selection
  2627.    
  2628.     if (selection){
  2629.         tmpcursor = cursor;
  2630.         SetCursorIntern(sel_cursor.par, sel_cursor.pos);
  2631.         sel_cursor = cursor; 
  2632.         SetCursorIntern(sel_start_cursor.par, sel_start_cursor.pos);
  2633.         sel_start_cursor = cursor; 
  2634.         SetCursorIntern(sel_end_cursor.par, sel_end_cursor.pos);
  2635.         sel_end_cursor = cursor; 
  2636.         SetCursorIntern(last_sel_cursor.par, last_sel_cursor.pos);
  2637.         last_sel_cursor = cursor; 
  2638.         cursor = tmpcursor;
  2639.     }
  2640.     SetCursorIntern(cursor.par, cursor.pos);
  2641. }
  2642.  
  2643.  
  2644. /* returns 0 if inset wasn't found */
  2645. int LyXText::UpdateInset(Inset* inset)
  2646. {
  2647.     int pos;
  2648.     LyXParagraph *par;
  2649.  
  2650.     /* first check the current paragraph */
  2651.     pos = cursor.par->GetPositionOfInset(inset);
  2652.     if (pos != -1){
  2653.         CheckParagraph(cursor.par, pos);
  2654.         return 1;
  2655.     }
  2656.   
  2657.     /* check every paragraph */
  2658.   
  2659.     par = FirstParagraph();
  2660.     do {
  2661.         /* make sure the paragraph is open */
  2662.         if (par->footnoteflag != LyXParagraph::CLOSED_FOOTNOTE){
  2663.             pos = par->GetPositionOfInset(inset);
  2664.             if (pos != -1){
  2665.                 CheckParagraph(par, pos);
  2666.                 return 1;
  2667.             }
  2668.         }
  2669.         par = par->Next();
  2670.     } while (par);
  2671.   
  2672.     return 0;
  2673. }
  2674.  
  2675.  
  2676. void LyXText::SetCursor(LyXParagraph *par, int pos)
  2677. {
  2678.     LyXCursor old_cursor = cursor;
  2679.     SetCursorIntern(par, pos);
  2680.     DeleteEmptyParagraphMechanism(old_cursor);
  2681. }
  2682.  
  2683.  
  2684. void LyXText::SetCursorIntern(LyXParagraph *par, int pos)
  2685. {
  2686.     long y;
  2687.     Row *row;
  2688.     int left_margin;
  2689.     LyXParagraph *tmppar;
  2690.    
  2691.     /* correct the cursor position if impossible */
  2692.     if (pos > par->Last()){
  2693.         tmppar = par->ParFromPos(pos);
  2694.         pos = par->PositionInParFromPos(pos);
  2695.         par = tmppar;
  2696.     }
  2697.     if (par->IsDummy() && par->previous && 
  2698.         par->previous->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) {
  2699.         while (par->previous && 
  2700.                par->previous->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE){
  2701.             par = par->previous ;
  2702.         }
  2703.         if (par->previous) {
  2704.             par = par->previous;
  2705.         }
  2706.         pos += par->last + 1;
  2707.     }
  2708.  
  2709.     cursor.par = par;
  2710.     cursor.pos = pos;
  2711.  
  2712.     /* get the cursor y position in text  */
  2713.     row = GetRow(par, pos, y);
  2714.     /* y is now the beginning of the cursor row */ 
  2715.     y += row->baseline;
  2716.     /* y is now the cursor baseline */ 
  2717.     cursor.y = y;
  2718.    
  2719.     /* now get the cursors x position */
  2720.    
  2721.     float x;
  2722.     float fill_separator, fill_hfill, fill_label_hfill;
  2723.     left_margin = LabelEnd(row);
  2724.     PrepareToPrint(row, x, fill_separator, fill_hfill, fill_label_hfill);
  2725.     int main_body = BeginningOfMainBody(row->par);
  2726.       
  2727.     /* table stuff -- begin*/
  2728.     if (row->par->table) {
  2729.         int cell = NumberOfCell(row->par, row->pos);
  2730.         float x_old = x;
  2731.         x += row->par->table->GetBeginningOfTextInCell(cell);
  2732.         for (pos = row->pos; pos < cursor.pos; pos++)  {
  2733.             if (row->par->IsNewline(pos)) {
  2734.                 x = x_old + row->par->table->WidthOfColumn(cell);
  2735.                 x_old = x;
  2736.                 cell++;
  2737.                 x += row->par->table->GetBeginningOfTextInCell(cell);
  2738.             } else {
  2739.                 x += SingleWidth(row->par, pos);
  2740.             }
  2741.         }
  2742.     } else
  2743.         /* table stuff -- end*/
  2744.  
  2745.         for (pos = row->pos; pos < cursor.pos; pos++)  {
  2746.             if (pos && pos == main_body
  2747.                 && !row->par->IsLineSeparator(pos - 1)) {
  2748.                 x += GetFont(row->par, -2).stringWidth(
  2749.                             lyxstyle.Style(parameters->textclass, row->par->GetLayout())->labelsep);
  2750.                 if (x < left_margin)
  2751.                     x = left_margin;
  2752.             }
  2753.       
  2754.             x += SingleWidth(row->par, pos);
  2755.             if (HfillExpansion(row, pos)) {
  2756.                 if (pos >= main_body)
  2757.                     x += fill_hfill;
  2758.                 else 
  2759.                     x += fill_label_hfill;
  2760.             }
  2761.             else if (pos >= main_body && row->par->IsSeparator(pos)) {
  2762.                 x+= fill_separator;
  2763.             }
  2764.       
  2765.             if (pos + 1 == main_body
  2766.                 && row->par->IsLineSeparator(pos)) {
  2767.                 x += GetFont(row->par, -2).stringWidth(
  2768.                             lyxstyle.Style(parameters->textclass, row->par->GetLayout())->labelsep);
  2769.                 if (row->par->IsLineSeparator(pos))
  2770.                     x-= SingleWidth(row->par, pos);
  2771.                 if (x < left_margin)
  2772.                     x = left_margin;
  2773.             }
  2774.         }
  2775.    
  2776.     cursor.x = int(x);
  2777.    
  2778.     cursor.x_fix = cursor.x;
  2779.     cursor.row = row;
  2780.    
  2781.     if (cursor.pos && 
  2782.         (cursor.pos == cursor.par->Last() || cursor.par->IsSeparator(cursor.pos)
  2783.          || (cursor.pos && cursor.pos == BeginningOfMainBody(cursor.par)
  2784.          && !cursor.par->IsSeparator(cursor.pos))
  2785.             )) {
  2786.         current_font = cursor.par->GetFontSettings(cursor.pos - 1);
  2787.         real_current_font = GetFont(cursor.par, cursor.pos - 1);
  2788.     } else {
  2789.         current_font = cursor.par->GetFontSettings(cursor.pos);
  2790.         real_current_font = GetFont(cursor.par, cursor.pos);
  2791.     }
  2792. }
  2793.  
  2794.  
  2795. void LyXText::SetCursorFromCoordinates(int x, long y)
  2796. {
  2797.     Row *row;
  2798.     int column;
  2799.  
  2800.     LyXCursor old_cursor;
  2801.    
  2802.     old_cursor = cursor;
  2803.    
  2804.     /* get the row first */ 
  2805.    
  2806.     row = GetRowNearY(y);
  2807.    
  2808.     cursor.par = row->par;
  2809.    
  2810.     column = GetColumnNearX(row, x);
  2811.     cursor.pos = row->pos + column;
  2812.     cursor.x = x;
  2813.     cursor.y = y + row->baseline;
  2814.    
  2815.     cursor.row = row;
  2816.     
  2817.     if (cursor.pos && 
  2818.         (cursor.pos == cursor.par->Last()
  2819.          || cursor.par->IsSeparator(cursor.pos)
  2820.          || (cursor.pos && cursor.pos == BeginningOfMainBody(cursor.par)
  2821.          && !cursor.par->IsSeparator(cursor.pos))
  2822.             )) {
  2823.         current_font = cursor.par->GetFontSettings(cursor.pos - 1);
  2824.         real_current_font = GetFont(cursor.par, cursor.pos - 1);
  2825.     } else {
  2826.         current_font = cursor.par->GetFontSettings(cursor.pos);
  2827.         real_current_font = GetFont(cursor.par, cursor.pos);
  2828.     }
  2829.     DeleteEmptyParagraphMechanism(old_cursor);
  2830. }
  2831.  
  2832.  
  2833. void LyXText::CursorLeft()
  2834. {
  2835.     CursorLeftIntern();
  2836.         if (cursor.par->table) {
  2837.                 int cell = NumberOfCell(cursor.par, cursor.pos);
  2838.                 if (cursor.par->table->IsContRow(cell) &&
  2839.                     cursor.par->table->CellHasContRow(cursor.par->table->GetCellAbove(cell))<0) {
  2840.                         CursorUp();
  2841.                 }
  2842.         }
  2843. }
  2844.  
  2845.  
  2846. void LyXText::CursorLeftIntern()
  2847. {
  2848.     if (cursor.pos > 0) {
  2849.         SetCursor(cursor.par, cursor.pos - 1);
  2850.     }
  2851.     else if (cursor.par->Previous()) {
  2852.         SetCursor(cursor.par->Previous(), cursor.par->Previous()->Last());
  2853.     }
  2854. }
  2855.  
  2856.  
  2857. void LyXText::CursorRight()
  2858. {
  2859.     CursorRightIntern();
  2860.         if (cursor.par->table) {
  2861.                 int cell = NumberOfCell(cursor.par, cursor.pos);
  2862.                 if (cursor.par->table->IsContRow(cell) &&
  2863.                     cursor.par->table->CellHasContRow(cursor.par->table->GetCellAbove(cell))<0) {
  2864.                         CursorUp();
  2865.                 }
  2866.         }
  2867. }
  2868.  
  2869.  
  2870. void LyXText::CursorRightIntern()
  2871. {
  2872.     if (cursor.pos < cursor.par->Last()) {
  2873.         SetCursor(cursor.par, cursor.pos + 1);
  2874.     }
  2875.     else if (cursor.par->Next()) {
  2876.         SetCursor(cursor.par->Next(), 0);
  2877.     }
  2878. }
  2879.  
  2880.  
  2881. void LyXText::CursorUp()
  2882. {
  2883.     SetCursorFromCoordinates(cursor.x_fix, 
  2884.                  cursor.y - cursor.row->baseline - 1);
  2885.         if (cursor.par->table) {
  2886.                 int cell = NumberOfCell(cursor.par, cursor.pos);
  2887.                 if (cursor.par->table->IsContRow(cell) &&
  2888.                     cursor.par->table->CellHasContRow(cursor.par->table->GetCellAbove(cell))<0) {
  2889.                         CursorUp();
  2890.                 }
  2891.         }
  2892. }
  2893.  
  2894.  
  2895. void LyXText::CursorDown()
  2896. {
  2897.         if (cursor.par->table &&
  2898.             cursor.par->table->ShouldBeVeryLastRow(NumberOfCell(cursor.par, cursor.pos)) &&
  2899.             !cursor.par->next)
  2900.                 return;
  2901.     SetCursorFromCoordinates(cursor.x_fix, 
  2902.                  cursor.y - cursor.row->baseline
  2903.                  + cursor.row->height + 1);
  2904.         if (cursor.par->table) {
  2905.                 int cell = NumberOfCell(cursor.par, cursor.pos);
  2906.                 int cell_above = cursor.par->table->GetCellAbove(cell);
  2907.                 while(cursor.par->table &&
  2908.                       cursor.par->table->IsContRow(cell) &&
  2909.                       (cursor.par->table->CellHasContRow(cell_above)<0)) {
  2910.                     SetCursorFromCoordinates(cursor.x_fix, 
  2911.                                              cursor.y - cursor.row->baseline
  2912.                                              + cursor.row->height + 1);
  2913.                     if (cursor.par->table) {
  2914.                         cell = NumberOfCell(cursor.par, cursor.pos);
  2915.                         cell_above = cursor.par->table->GetCellAbove(cell);
  2916.                     }
  2917.                 }
  2918.         }
  2919. }
  2920.  
  2921.  
  2922. void LyXText::CursorUpParagraph()
  2923. {
  2924.     if (cursor.pos > 0) {
  2925.         SetCursor(cursor.par, 0);
  2926.     }
  2927.     else if (cursor.par->Previous()) {
  2928.         SetCursor(cursor.par->Previous(), 0);
  2929.     }
  2930. }
  2931.  
  2932.  
  2933. void LyXText::CursorDownParagraph()
  2934. {
  2935.     if (cursor.par->Next()) {
  2936.         SetCursor(cursor.par->Next(), 0);
  2937.     } else {
  2938.         SetCursor(cursor.par,cursor.par->Last());
  2939.     }
  2940. }
  2941.  
  2942.  
  2943.  
  2944. void LyXText::DeleteEmptyParagraphMechanism(LyXCursor old_cursor)
  2945. {
  2946.     bool deleted = false;
  2947.     
  2948.     /* this is the delete-empty-paragraph-mechanism. */ 
  2949.     if (selection)
  2950.         return;
  2951.  
  2952.     // Paragraph should not be deleted if empty
  2953.     if ((lyxstyle.Style(parameters->textclass,
  2954.                         old_cursor.par->GetLayout()))->keepempty)
  2955.         return;
  2956.  
  2957.     LyXCursor tmpcursor;
  2958.  
  2959.     if (old_cursor.par != cursor.par) {
  2960.         if ( (old_cursor.par->Last() == 0
  2961.               || (old_cursor.par->Last() == 1
  2962.                   && (old_cursor.par->IsLineSeparator(0))))
  2963.              && old_cursor.par->FirstPhysicalPar()
  2964.              == old_cursor.par->LastPhysicalPar()
  2965.              //&& (
  2966.              // impossible to insert your own \caption with
  2967.              // this set. made it impossible to use the
  2968.              // optional argument...
  2969.              // also empty pars in fig or tab never was removed(?)(Lgb)
  2970.              //lyxstyle.Style(parameters->textclass,
  2971. //                     old_cursor.par->GetLayout())->labeltype!=LABEL_SENSITIVE || 
  2972.              //     (old_cursor.par->footnoteflag == LyXParagraph::NO_FOOTNOTE
  2973.              //|| (old_cursor.par->footnotekind != LyXParagraph::FIG
  2974.              //      && old_cursor.par->footnotekind != LyXParagraph::TAB)))
  2975.              ) {
  2976.             
  2977.             /* ok, we will delete anything */ 
  2978.             
  2979.             // make sure that you do not delete any environments
  2980.             if ((old_cursor.par->footnoteflag != LyXParagraph::OPEN_FOOTNOTE &&
  2981.                  !(old_cursor.row->previous 
  2982.                    && old_cursor.row->previous->par->footnoteflag == LyXParagraph::OPEN_FOOTNOTE)
  2983.                  && !(old_cursor.row->next 
  2984.                       && old_cursor.row->next->par->footnoteflag == LyXParagraph::OPEN_FOOTNOTE))
  2985.                 || 
  2986.                 (old_cursor.par->footnoteflag == LyXParagraph::OPEN_FOOTNOTE &&
  2987.                  ((old_cursor.row->previous 
  2988.                    && old_cursor.row->previous->par->footnoteflag == LyXParagraph::OPEN_FOOTNOTE)
  2989.                   || 
  2990.                   (old_cursor.row->next
  2991.                    && old_cursor.row->next->par->footnoteflag == LyXParagraph::OPEN_FOOTNOTE))
  2992.                  )){
  2993.                 status = LyXText::NEED_MORE_REFRESH;
  2994.                 deleted = true;
  2995.                 
  2996.                 if (old_cursor.row->previous) {
  2997.                     refresh_row = old_cursor.row->previous;
  2998.                     refresh_y = old_cursor.y - old_cursor.row->baseline - refresh_row->height;
  2999.                     tmpcursor = cursor;
  3000.                     cursor = old_cursor; // that undo can restore the right cursor position
  3001.                     LyXParagraph *endpar = old_cursor.par->next;
  3002.                     if (endpar && endpar->GetDepth()) {
  3003.                         while (endpar && endpar->GetDepth()) {
  3004.                             endpar = endpar->LastPhysicalPar()->Next();
  3005.                         }
  3006.                     }
  3007.                     SetUndo(Undo::DELETE,
  3008.                             old_cursor.par->previous,
  3009.                             endpar);
  3010.                     cursor = tmpcursor;
  3011.  
  3012.                     /* delete old row */ 
  3013.                     RemoveRow(old_cursor.row);
  3014.                     if (params->paragraph == old_cursor.par) {
  3015.                         params->paragraph = params->paragraph->next;
  3016.                     }
  3017.                     /* delete old par */ 
  3018.                     delete old_cursor.par;
  3019.                     
  3020.                     /* Breakagain the next par. Needed
  3021.                      * because of the parindent that
  3022.                      * can occur or dissappear. The
  3023.                      * next row can change its height,
  3024.                      * if there is another layout before */
  3025.                     if (refresh_row->next) {
  3026.                         BreakAgain(refresh_row->next);
  3027.                         UpdateCounters(refresh_row);
  3028.                     }
  3029.                     SetHeightOfRow(refresh_row);
  3030.                 }
  3031.                 else {
  3032.                     refresh_row = old_cursor.row->next;
  3033.                     refresh_y = old_cursor.y - old_cursor.row->baseline;
  3034.                     
  3035.                     tmpcursor = cursor;
  3036.                     cursor = old_cursor; // that undo can restore the right cursor position
  3037.                     LyXParagraph *endpar = old_cursor.par->next;
  3038.                     if (endpar && endpar->GetDepth()) {
  3039.                         while (endpar && endpar->GetDepth()) {
  3040.                             endpar = endpar->LastPhysicalPar()->Next();
  3041.                         }
  3042.                     }
  3043.                     SetUndo(Undo::DELETE,
  3044.                             old_cursor.par->previous,
  3045.                             endpar);
  3046.                     cursor = tmpcursor;
  3047.  
  3048.                     /* delete old row */ 
  3049.                     RemoveRow(old_cursor.row);
  3050.                     /* delete old par */ 
  3051.                     if (params->paragraph == old_cursor.par) {
  3052.                         params->paragraph = params->paragraph->next;
  3053.                     }
  3054.                     delete old_cursor.par;
  3055.                     
  3056.                     /* Breakagain the next par. Needed because of
  3057.                      * the parindent that can occur or dissappear.
  3058.                      * The next row can change its height, if there
  3059.                      * is another layout before */ 
  3060.                     if (refresh_row) {
  3061.                         BreakAgain(refresh_row);
  3062.                         UpdateCounters(refresh_row->previous);
  3063.                     }
  3064.                 }
  3065.                 
  3066.                 /* correct cursor y */
  3067.                 SetCursor(cursor.par, cursor.pos);
  3068.              
  3069.                 /* if (cursor.y > old_cursor.y)
  3070.                    cursor.y -= old_cursor.row->height; */ 
  3071.      
  3072.                 if (sel_cursor.par  == old_cursor.par
  3073.                     && sel_cursor.pos == sel_cursor.pos) {
  3074.                     /* correct selection*/ 
  3075.                     sel_cursor = cursor;
  3076.                 }
  3077.             }
  3078.        
  3079.         }
  3080.         if (!deleted){
  3081.             if (old_cursor.par->ClearParagraph()){
  3082.                 RedoParagraphs(old_cursor, old_cursor.par->Next());
  3083.                 /* correct cursor y */
  3084.                 SetCursor(cursor.par, cursor.pos);
  3085.                 sel_cursor = cursor;
  3086.             }
  3087.         }
  3088.     } else if (cursor.par->table && (cursor.row != old_cursor.row)) {
  3089.         int cell = NumberOfCell(old_cursor.par, old_cursor.pos);
  3090.         if (old_cursor.par->table->IsContRow(cell) &&
  3091.             IsEmptyTableRow(&old_cursor)) {
  3092.             RemoveTableRow(&old_cursor);
  3093.             RedoParagraph();
  3094.         }
  3095.     }
  3096. }
  3097.  
  3098.  
  3099. LyXParagraph* LyXText::GetParFromID(int id)
  3100. {
  3101.     LyXParagraph* result = FirstParagraph();
  3102.     while (result && result->GetID() != id)
  3103.         result = result->next;
  3104.     return result;
  3105. }
  3106.  
  3107.  
  3108. // undo functions
  3109. bool  LyXText::TextUndo()
  3110. { // returns false if no undo possible
  3111.     Undo *undo = params->undostack.Pop();
  3112.     if (undo){
  3113.         FinishUndo();
  3114.         if (!undo_frozen)
  3115.             params->redostack.Push(CreateUndo(undo->kind, 
  3116.                               GetParFromID(undo->number_of_before_par),
  3117.                               GetParFromID(undo->number_of_behind_par)));
  3118.     }
  3119.     return TextHandleUndo(undo);
  3120. }
  3121.  
  3122.  
  3123. bool LyXText::TextRedo()
  3124. { // returns false if no redo possible
  3125.     Undo *undo = params->redostack.Pop();
  3126.     if (undo){
  3127.         FinishUndo();
  3128.         if (!undo_frozen)
  3129.             params->undostack.Push(CreateUndo(undo->kind, 
  3130.                               GetParFromID(undo->number_of_before_par),
  3131.                               GetParFromID(undo->number_of_behind_par)));
  3132.     }
  3133.     return TextHandleUndo(undo);
  3134. }
  3135.  
  3136.  
  3137. bool LyXText::TextHandleUndo(Undo* undo){ // returns false if no undo possible
  3138.     bool result = false;
  3139.     if (undo){
  3140.         LyXParagraph* before = GetParFromID(undo->number_of_before_par); 
  3141.         LyXParagraph* behind = GetParFromID(undo->number_of_behind_par); 
  3142.         LyXParagraph* tmppar;
  3143.         LyXParagraph* tmppar2;
  3144.         LyXParagraph* tmppar3;
  3145.         LyXParagraph* tmppar4;
  3146.         LyXParagraph* endpar;
  3147.         LyXParagraph* tmppar5;
  3148.     
  3149.         /*
  3150.           if (before){
  3151.           before->text[before->last] = 0;
  3152.           printf("before: %s\n", before->text);
  3153.           }
  3154.           if (behind){
  3155.           behind->text[behind->last] = 0;
  3156.           printf("behind: %s\n", behind->text);
  3157.           }
  3158.           */ 
  3159.  
  3160.         // if there's no before take the beginning of the document for redoing
  3161.         if (!before)
  3162.             SetCursorIntern(FirstParagraph(), 0);
  3163.  
  3164.         // replace the paragraphs with the undo informations
  3165.  
  3166.         tmppar3 = undo->par;
  3167.         undo->par = NULL; // otherwise the undo destructor would delete the paragraph
  3168.         tmppar4 = tmppar3;
  3169.         if (tmppar4){
  3170.             while (tmppar4->next)
  3171.                 tmppar4 = tmppar4->next;
  3172.         } // get last undo par
  3173.     
  3174.         // now remove the old text if there is any
  3175.         if (before != behind || (!behind && !before)){
  3176.             if (before)
  3177.                 tmppar5 = before->next;
  3178.             else
  3179.                 tmppar5 = params->paragraph;
  3180.             tmppar2 = tmppar3;
  3181.             while (tmppar5 && tmppar5 != behind){
  3182.                 tmppar = tmppar5;
  3183.                 tmppar5 = tmppar5->next;
  3184.                 // a memory optimization for edit: Only layout information
  3185.                 // is stored in the undo. So restore the text informations.
  3186.                 if (undo->kind == Undo::EDIT){
  3187.                     tmppar2->text = tmppar->text;
  3188.                     tmppar->text = NULL;
  3189.                     tmppar2 = tmppar2->next;
  3190.                 }
  3191.                 if ( currentrow && currentrow->par == tmppar )
  3192.                     currentrow = currentrow -> previous;
  3193.                 delete tmppar;
  3194.             }
  3195.         }
  3196.     
  3197.         // put the new stuff in the list if there is one
  3198.         if (tmppar3){
  3199.             if (before)
  3200.                 before->next = tmppar3;
  3201.             else
  3202.                 params->paragraph = tmppar3;
  3203.             tmppar3->previous = before;
  3204.         }
  3205.         else {
  3206.             if (!before)
  3207.                 params->paragraph = behind;
  3208.         }
  3209.         if (tmppar4) {
  3210.             tmppar4->next = behind;
  3211.             if (behind)
  3212.                 behind->previous = tmppar4;
  3213.         }
  3214.     
  3215.     
  3216.         // Set the cursor for redoing
  3217.         if (before){
  3218.             SetCursorIntern(before->FirstSelfrowPar(), 0);
  3219.             // check wether before points to a closed float and open it if necessary
  3220.             if (before && before->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE
  3221.                 && before->next && before->next->footnoteflag != LyXParagraph::NO_FOOTNOTE){
  3222.                 tmppar4 =before;
  3223.                 while (tmppar4->previous && 
  3224.                        tmppar4->previous->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE)
  3225.                     tmppar4 = tmppar4->previous;
  3226.                 while (tmppar4 && tmppar4->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE){
  3227.                     tmppar4->footnoteflag = LyXParagraph::OPEN_FOOTNOTE;
  3228.                     tmppar4 = tmppar4->next;
  3229.                 }
  3230.             }
  3231.         }
  3232.     
  3233.         // open a cosed footnote at the end if necessary
  3234.         if (behind && behind->previous && 
  3235.             behind->previous->footnoteflag != LyXParagraph::NO_FOOTNOTE &&
  3236.             behind->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE){
  3237.             while (behind && behind->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE){
  3238.                 behind->footnoteflag = LyXParagraph::OPEN_FOOTNOTE;
  3239.                 behind = behind->next;
  3240.             }
  3241.         }
  3242.     
  3243.         // calculate the endpar for redoing the paragraphs.
  3244.         if (behind){
  3245.             if (behind->footnoteflag != LyXParagraph::CLOSED_FOOTNOTE)
  3246.                 endpar = behind->LastPhysicalPar()->Next();
  3247.             else
  3248.                 endpar = behind->NextAfterFootnote()->LastPhysicalPar()->Next();
  3249.         }
  3250.         else
  3251.             endpar = behind;
  3252.     
  3253.         tmppar = GetParFromID(undo->number_of_cursor_par);
  3254.         RedoParagraphs(cursor, endpar); 
  3255.         if (tmppar){
  3256.             SetCursorIntern(tmppar, undo->cursor_pos);
  3257.             UpdateCounters(cursor.row);
  3258.         }
  3259.         result = true;
  3260.         delete undo;
  3261.     }
  3262.     FinishUndo();
  3263.     return result;
  3264. }
  3265.  
  3266.  
  3267. void LyXText::FinishUndo()
  3268. { // makes sure the next operation will be stored
  3269.     undo_finished = True;
  3270. }
  3271.  
  3272.  
  3273. void LyXText::FreezeUndo()
  3274. { // this is dangerous and for internal use only
  3275.     undo_frozen = True;
  3276. }
  3277.  
  3278.  
  3279. void LyXText::UnFreezeUndo()
  3280. { // this is dangerous and for internal use only
  3281.     undo_frozen = false;
  3282. }
  3283.  
  3284.  
  3285. void LyXText::SetUndo(Undo::undo_kind kind, LyXParagraph *before, LyXParagraph *behind)
  3286. {
  3287.     if (!undo_frozen)
  3288.         params->undostack.Push(CreateUndo(kind, before, behind));
  3289.     params->redostack.Clear();
  3290. }
  3291.  
  3292.  
  3293. void LyXText::SetRedo(Undo::undo_kind kind, LyXParagraph *before, LyXParagraph *behind)
  3294. {
  3295.     params->redostack.Push(CreateUndo(kind, before, behind));
  3296. }
  3297.  
  3298.  
  3299. Undo* LyXText::CreateUndo(Undo::undo_kind kind, LyXParagraph *before,
  3300.               LyXParagraph *behind)
  3301. {
  3302.     int before_number = -1;
  3303.     int behind_number = -1;
  3304.     if (before)
  3305.         before_number = before->GetID();
  3306.     if (behind)
  3307.         behind_number = behind->GetID();
  3308.     // Undo::EDIT  and Undo::FINISH are
  3309.     // always finished. (no overlapping there)
  3310.     // overlapping only with insert and delete inside one paragraph: 
  3311.     // Nobody wants all removed  character
  3312.     // appear one by one when undoing. 
  3313.     // EDIT is special since only layout information, not the
  3314.     // contents of a paragaph are stored.
  3315.     if (!undo_finished && kind != Undo::EDIT && 
  3316.         kind != Undo::FINISH){
  3317.         // check wether storing is needed
  3318.         if (params->undostack.Top() && 
  3319.             params->undostack.Top()->kind == kind &&
  3320.             params->undostack.Top()->number_of_before_par ==  before_number &&
  3321.             params->undostack.Top()->number_of_behind_par ==  behind_number ){
  3322.             // no undo needed
  3323.             return NULL;
  3324.         }
  3325.     }
  3326.     // create a new Undo
  3327.     LyXParagraph* undopar;
  3328.     LyXParagraph* tmppar;
  3329.     LyXParagraph *tmppar2;
  3330.  
  3331.     LyXParagraph* start = NULL;
  3332.     LyXParagraph* end = NULL;
  3333.   
  3334.     if (before)
  3335.         start = before->next;
  3336.     else
  3337.         start = FirstParagraph();
  3338.     if (behind)
  3339.         end = behind->previous;
  3340.     else {
  3341.         end = FirstParagraph();
  3342.         while (end->next)
  3343.             end = end->next;
  3344.     }
  3345.  
  3346.     if (start && end && start != end->next && (before != behind || (!before && !behind))) {
  3347.         tmppar = start;
  3348.         tmppar2 = tmppar->Clone();
  3349.         tmppar2->SetID(tmppar->GetID());
  3350.  
  3351.         // a memory optimization: Just store the layout information when only edit
  3352.         if (kind == Undo::EDIT){
  3353.             if (tmppar2->text)
  3354.                 delete[] tmppar2->text;
  3355.             tmppar2->text = NULL;
  3356.         }
  3357.  
  3358.         undopar = tmppar2;
  3359.   
  3360.         while (tmppar != end && tmppar->next) {
  3361.             tmppar = tmppar->next;
  3362.             tmppar2->next = tmppar->Clone();
  3363.             tmppar2->next->SetID(tmppar->GetID());
  3364.             // a memory optimization: Just store the layout information when only edit
  3365.             if (kind == Undo::EDIT){
  3366.                 if (tmppar2->next->text)
  3367.                     delete[] tmppar2->next->text;
  3368.                 tmppar2->next->text = NULL;
  3369.             }
  3370.             tmppar2->next->previous = tmppar2;
  3371.             tmppar2=tmppar2->next;
  3372.         }
  3373.         tmppar2->next = NULL;
  3374.     }
  3375.     else
  3376.         undopar = NULL; // nothing to replace (undo of delete maybe)
  3377.   
  3378.     int cursor_par = cursor.par->ParFromPos(cursor.pos)->GetID();
  3379.     int cursor_pos =  cursor.par->PositionInParFromPos(cursor.pos);
  3380.  
  3381.     Undo* undo = new Undo(kind, 
  3382.                   before_number, behind_number,  
  3383.                   cursor_par, cursor_pos, 
  3384.                   undopar);
  3385.   
  3386.     undo_finished = false;
  3387.     return undo;
  3388. }
  3389.  
  3390.  
  3391. void LyXText::SetCursorParUndo()
  3392. {
  3393.     SetUndo(Undo::FINISH, 
  3394.         cursor.par->ParFromPos(cursor.pos)->previous, 
  3395.         cursor.par->ParFromPos(cursor.pos)->next); 
  3396. }
  3397.  
  3398. void LyXText::RemoveTableRow(LyXCursor *cursor)
  3399. {
  3400.     int
  3401.         cell_act,
  3402.         cell = -1,
  3403.         cell_org = 0;
  3404.     
  3405.     do {
  3406.         /* move to the previous row */
  3407.         cell_act = NumberOfCell(cursor->par, cursor->pos);
  3408.         if (cell < 0)
  3409.             cell = cell_act;
  3410.         while (cursor->pos && !cursor->par->IsNewline(cursor->pos-1))
  3411.             cursor->pos--;
  3412.         while (cursor->pos && 
  3413.                !cursor->par->table->IsFirstCell(cell_act)){
  3414.             cursor->pos--;
  3415.             while (cursor->pos && !cursor->par->IsNewline(cursor->pos-1))
  3416.                 cursor->pos--;
  3417.             cell--;
  3418.             cell_act--;
  3419.         }
  3420.         /* now we have to pay attention if the actual table is the
  3421.            main row of TableContRows and if yes to delete all of them */
  3422.         if (!cell_org)
  3423.             cell_org = cell;
  3424.         /* delete up to the next row */
  3425.         while (cursor->pos < cursor->par->Last() && 
  3426.                (cell_act == cell_org
  3427.                 || !cursor->par->table->IsFirstCell(cell_act))){
  3428.             while (cursor->pos < cursor->par->Last() && !cursor->par->IsNewline(cursor->pos))
  3429.                 cursor->par->Erase(cursor->pos);
  3430.             cell++;
  3431.             cell_act++;
  3432.             if (cursor->pos < cursor->par->Last())
  3433.                 cursor->par-> Erase(cursor->pos);
  3434.         }
  3435.         if (cursor->pos && cursor->pos == cursor->par->Last()){
  3436.             cursor->pos--;
  3437.             cursor->par->Erase(cursor->pos); // no newline at the very end!
  3438.         }
  3439.     } while (!cursor->par->table->IsContRow(cell_org) &&
  3440.              cursor->par->table->IsContRow(cell));
  3441.     cursor->par->table->DeleteRow(cell_org);
  3442.     return;
  3443. }
  3444.  
  3445. bool LyXText::IsEmptyTableRow(LyXCursor *old_cursor)
  3446. {
  3447.     if (!old_cursor->par->table)
  3448.         return false;
  3449. #ifdef I_DONT_KNOW_IF_I_SHOULD_DO_THIS
  3450.     int
  3451.         pos = old_cursor->pos,
  3452.         cell = NumberOfCell(old_cursor->par, pos);
  3453.  
  3454.     // search first charater of this table row
  3455.     while (pos && !old_cursor->par->table->IsFirstCell(cell)) {
  3456.         pos--;
  3457.         while (pos && !old_cursor->par->IsNewline(pos-1))
  3458.             pos--;
  3459.         cell--;
  3460.     }
  3461.     if (!old_cursor->par->IsNewline(pos))
  3462.         return false;
  3463.     cell++;
  3464.     pos++;
  3465.     while ((pos < old_cursor->par->Last()) &&
  3466.            !old_cursor->par->table->IsFirstCell(cell)) {
  3467.         if (!old_cursor->par->IsNewline(pos))
  3468.             return false;
  3469.         pos++;
  3470.         cell++;
  3471.     }
  3472.     return true;
  3473. #endif
  3474.     return false;
  3475. }
  3476.  
  3477.  
  3478. bool LyXText::IsEmptyTableCell()
  3479. {
  3480.     int pos = cursor.pos - 1;
  3481.     
  3482.     while ((pos>0) && (pos < cursor.par->Last()) &&
  3483.            !cursor.par->IsNewline(pos))
  3484.         pos--;
  3485.     return cursor.par->IsNewline(pos+1);
  3486. }
  3487.