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 / text.C < prev    next >
C/C++ Source or Header  |  1998-04-23  |  120KB  |  4,059 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. #include <stdlib.h>
  13. #include <ctype.h>
  14.  
  15. #ifdef __GNUG__
  16. #pragma implementation "table.h"
  17. #endif
  18.  
  19. #include "layout.h"
  20. #include "lyxparagraph.h"
  21. #include "lyxtext.h"
  22. #include "textutils.h"
  23. #include "lyx_gui_misc.h"
  24. #include "lyxdraw.h"
  25. #include "gettext.h"
  26. #include "bufferparams.h"
  27. #include "lyxscreen.h"
  28.  
  29. //     $Id: text.C,v 1.1.1.1 1998/04/23 16:02:57 larsbj Exp $    
  30.  
  31. #if !defined(lint) && !defined(WITH_WARNINGS)
  32. static char vcid[] = "$Id: text.C,v 1.1.1.1 1998/04/23 16:02:57 larsbj Exp $";
  33. #endif /* lint */
  34.  
  35.  
  36. static const int LYX_PAPER_MARGIN = 20;
  37.  
  38. extern int reverse_video;
  39.  
  40. // ale070405
  41. extern int bibitemMaxWidth(const class LyXFont &);
  42.  
  43.  
  44. int LyXText::SingleWidth(LyXParagraph *par, int pos)
  45. {
  46.     char c = par->GetChar(pos);
  47.     return SingleWidth(par, pos, c);
  48. }
  49.  
  50.  
  51. int LyXText::SingleWidth(LyXParagraph *par, int pos, char c)
  52. {
  53.     LyXFont font = GetFont(par, pos);
  54.  
  55.     // The most common case is handled first (Asger)
  56.     if (IsPrintable(c)) {
  57.         return font.width(c);
  58.  
  59.     } else if (IsHfillChar(c)) {
  60.         return 3;    /* because of the representation
  61.                  * as vertical lines */
  62.  
  63.     } else if (c == LYX_META_FOOTNOTE ||
  64.            c == LYX_META_MARGIN ||
  65.            c == LYX_META_FIG ||
  66.            c == LYX_META_TAB ||
  67.            c == LYX_META_WIDE_FIG ||
  68.            c == LYX_META_WIDE_TAB ||
  69.            c == LYX_META_ALGORITHM) 
  70.     {
  71.         LString fs;
  72.         switch (c) {
  73.         case LYX_META_MARGIN:
  74.             fs = "margin";
  75.             break;
  76.         case LYX_META_FIG:
  77.             fs = "fig";
  78.             break;
  79.         case LYX_META_TAB:
  80.             fs = "tab";
  81.             break;
  82.         case LYX_META_ALGORITHM:
  83.             fs = "alg";
  84.             break;
  85.         case LYX_META_WIDE_FIG:
  86.             fs = "wide-fig";
  87.             break;
  88.         case LYX_META_WIDE_TAB:
  89.             fs = "wide-tab";
  90.             break;
  91.         case LYX_META_FOOTNOTE:
  92.             fs = "foot";
  93.             break;
  94.         }
  95.         font.decSize();
  96.         font.decSize();
  97.         return font.stringWidth(fs);
  98.     } 
  99.    
  100.     else if (c == LYX_META_INSET) {
  101.         Inset *tmpinset=par->GetInset(pos);
  102.         if (tmpinset)
  103.             return par->GetInset(pos)->Width(font);
  104.         else
  105.             return 0;
  106.  
  107.     } else if (IsSeparatorChar(c))
  108.         c = ' ';
  109.     else if (IsNewlineChar(c))
  110.         c = 'n';
  111.     return font.width(c);
  112. }
  113.  
  114.  
  115. /* returns the paragraph position of the last character in the 
  116.  * specified row */
  117. int LyXText::RowLast(Row *row)
  118. {
  119.     if (row->next == NULL)
  120.         return row->par->Last()-1;
  121.     else if (row->next->par != row->par) 
  122.         return row->par->Last()-1;
  123.     else 
  124.         return row->next->pos - 1;
  125. }
  126.  
  127.  
  128. void LyXText::Draw(Row *row, int &pos, LyXScreen &scr, int offset, float &x)
  129. {
  130.     char c = row->par->GetChar(pos);
  131.  
  132.     if (IsNewlineChar(c)) {
  133.         pos++;
  134.         // Draw end-of-line marker
  135.  
  136.         LyXFont font = GetFont(row->par, pos);
  137.         int asc = font.maxAscent();
  138.         int wid = font.width('n');
  139.         int y = (offset + row->baseline);
  140.         XPoint p[3];
  141.         p[0].x = int(x + wid*0.375); p[0].y = int(y - 0.875*asc*0.75);
  142.         p[1].x = int(x);         p[1].y = int(y - 0.500*asc*0.75);
  143.         p[2].x = int(x + wid*0.375); p[2].y = int(y - 0.125*asc*0.75);
  144.         scr.drawLines(GetColorGC(LyXFont::RED),p, 3);
  145.         
  146.         p[0].x = int(x);         p[0].y = int(y - 0.500*asc*0.75);
  147.         p[1].x = int(x + wid);         p[1].y = int(y - 0.500*asc*0.75);
  148.         p[2].x = int(x + wid);         p[2].y = int(y - asc*0.75);
  149.         scr.drawLines(GetColorGC(LyXFont::RED),p, 3);
  150.         return;
  151.     }
  152.  
  153.     LyXFont font = GetFont(row->par, pos);
  154.     LyXFont font2 = font;
  155.  
  156.     if (c == LYX_META_FOOTNOTE ||
  157.         c == LYX_META_MARGIN ||
  158.         c == LYX_META_FIG ||
  159.         c == LYX_META_TAB ||
  160.         c == LYX_META_WIDE_FIG ||
  161.         c == LYX_META_WIDE_TAB ||
  162.         c == LYX_META_ALGORITHM) {
  163.         LString fs;
  164.         switch (c) {
  165.         case LYX_META_MARGIN:
  166.             fs = "margin";
  167.             /* draw a sign at the left margin! */ 
  168.             scr.drawText(font, "!", 1, offset + row->baseline,
  169.                      (LYX_PAPER_MARGIN - font.width('!'))/2);
  170.             break;
  171.         case LYX_META_FIG:
  172.             fs = "fig";
  173.             break;
  174.         case LYX_META_TAB:
  175.             fs = "tab";
  176.             break;
  177.         case LYX_META_ALGORITHM:
  178.             fs = "alg";
  179.             break;
  180.         case LYX_META_WIDE_FIG:
  181.             fs = "wide-fig";
  182.             break;
  183.         case LYX_META_WIDE_TAB:
  184.             fs = "wide-tab";
  185.             break;
  186.         case LYX_META_FOOTNOTE:
  187.             fs = "foot";
  188.             break;
  189.         }
  190.         font.decSize();
  191.         font.decSize();
  192.       
  193.         /* calculate the position of the footnotemark */
  194.         int y = (row->baseline - font2.maxAscent() 
  195.              + font.maxAscent());
  196.       
  197.         font.setColor(LyXFont::INSET);
  198.  
  199.         /* draw it and set new x position */
  200.         x += scr.drawString(font, fs, offset + y, int(x));
  201.       
  202.         pos++;
  203.         return;
  204.     } else if (c == LYX_META_INSET) {
  205.         Inset *tmpinset = row->par->GetInset(pos);
  206.         if (tmpinset) 
  207.             tmpinset->Draw(font, scr, offset + row->baseline, x);
  208.         pos++;
  209.         return;
  210.     }
  211.  
  212.     /* usual characters, no insets */
  213.  
  214.     // Collect character that we can draw in one command
  215.  
  216.     // This is dirty, but fast. Notice that it will never be too small.
  217.     // For the record, I'll note that Microsoft Word has a limit
  218.     // of 768 here. We have none :-) (Asger)
  219.     static char textstring[1024];
  220.  
  221.     int last = RowLast(row);
  222.     // Prevent crash in the extremely unlikely event
  223.     // that our array is too small
  224.     if (last > pos+1020) last = pos + 1020;
  225.  
  226.     textstring[0] = c;
  227.     pos++;
  228.  
  229.     int i = 1;
  230.  
  231.     while (pos <= last &&
  232.            (unsigned char) (c = row->par->GetChar(pos)) > ' ' &&
  233.            font2 == GetFont(row->par, pos)) {
  234.         textstring[i++] = c;
  235.         pos++;
  236.     }
  237.     textstring[i] = 0; 
  238.  
  239.     float tmpx = x;
  240.  
  241.     /* Draw text and set the new x position */ 
  242.     x += scr.drawText(font, textstring, i, offset + row->baseline, 
  243.               int(x));
  244.     /* what about underbars? */
  245.     if (font.underbar() == LyXFont::ON && font.latex() != LyXFont::ON) {
  246.         scr.drawLine(gc_copy, offset + row->baseline + 2,
  247.                  int(tmpx), int(x - tmpx));
  248.     }
  249.  
  250.     // If we want ulem.sty support, drawing
  251.     // routines should go here. (Asger)
  252.     // Why shouldn't LyXFont::drawText handle it internally?
  253. }
  254.  
  255.  
  256. /* Returns the left beginning of the text. 
  257. * This information cannot be taken from the layouts-objekt, because in 
  258. * LaTeX the beginning of the text fits in some cases (for example sections)
  259. * exactly the label-width. */
  260. int LyXText::LeftMargin(Row* row)
  261. {
  262.    int x;
  263.    LyXLayout *layout;
  264.    LyXFont labelfont;
  265.    LyXParagraph *newpar;
  266.    Row dummyrow;
  267.    layout = lyxstyle.Style(parameters->textclass, row->par->GetLayout());
  268.    
  269.    LString parindent = layout->parindent; 
  270.  
  271.    /* table stuff -- begin*/ 
  272.    if (row->par->table)
  273.       parindent.erase();
  274.    /* table stuff -- end*/       
  275.  
  276.    x = LYX_PAPER_MARGIN;
  277.  
  278.    x += lyxstyle.TextClass(parameters->textclass)->
  279.      defaultfont.signedStringWidth(lyxstyle.TextClass(parameters->textclass)->leftmargin);
  280.  
  281.    if (row->par->footnoteflag == LyXParagraph::OPEN_FOOTNOTE)  {
  282.     LyXFont font(LyXFont::ALL_SANE);
  283.     font.setSize(LyXFont::SIZE_SMALL);
  284.     x += font.textWidth("Mwide-figM", 10) + LYX_PAPER_MARGIN/2;
  285.    }
  286.  
  287.    /* this is the way, LyX handles the LaTeX-Environments.
  288.     * I have had this idea very late, so it seems to be a
  289.     * later added hack and this is true */ 
  290.    if (!row->par->GetDepth()) {
  291.       if (!row->par->GetLayout()) {
  292.      /* find the previous same level paragraph */
  293.      if (row->par->FirstPhysicalPar()->Previous()) {
  294.         newpar = row->par->DepthHook(row->par->GetDepth());
  295.         if (newpar && lyxstyle.Style(parameters->textclass, newpar->GetLayout())->nextnoindent)
  296.            parindent.erase();
  297.      }
  298.       }
  299.    }
  300.    else {
  301.       /* find the next level paragraph */ 
  302.       
  303.       newpar = row->par->DepthHook(row->par->GetDepth()-1);
  304.  
  305.       /* make a corresponding row. Needed to call LeftMargin() */
  306.       
  307.       /* check wether it is a sufficent paragraph */ 
  308.       if (newpar && newpar->footnoteflag == row->par->footnoteflag
  309.       && lyxstyle.Style(parameters->textclass, 
  310.                 newpar->GetLayout())->isEnvironment()) {
  311.          dummyrow.par = newpar;
  312.          dummyrow.pos = newpar->Last();
  313.          x = LeftMargin(&dummyrow);
  314.       }
  315.       else {
  316.      /* this is no longer an error, because this function is used
  317.       * to clear impossible depths after changing a layout. Since there
  318.       * is always a redo, LeftMargin() is always called */ 
  319.      
  320.      /* printf("LYX_ERROR (text, LeftMargin()) impossible depth \n");*/ 
  321.      row->par->FirstPhysicalPar()->depth = 0;
  322.       }
  323.       
  324.       if (newpar && !row->par->GetLayout()) {
  325.      if (newpar->FirstPhysicalPar()->noindent)
  326.         parindent.erase();
  327.      else
  328.         parindent = lyxstyle.Style(parameters->textclass, 
  329.                        newpar->GetLayout())->parindent;
  330.       }
  331.       
  332.    }
  333.    
  334.    labelfont = GetFont(row->par, -2);
  335.    switch (layout->margintype) {
  336.     case MARGIN_DYNAMIC:
  337.       if (!layout->leftmargin.empty()) {
  338.     x += lyxstyle.TextClass(parameters->textclass)->defaultfont.signedStringWidth(layout->leftmargin);
  339.       }
  340.       if (!row->par->GetLabelString().empty()) {
  341.         x += labelfont.signedStringWidth(layout->labelindent);
  342.         x += labelfont.stringWidth(row->par->GetLabelString());
  343.         x += labelfont.stringWidth(layout->labelsep);
  344.       }
  345.       break;
  346.     case MARGIN_MANUAL:
  347.       x += labelfont.signedStringWidth(layout->labelindent);
  348.       if (row->pos >= BeginningOfMainBody(row->par)) {
  349.      if (!row->par->GetLabelWidthString().empty()) {
  350.         x += labelfont.stringWidth(row->par->GetLabelWidthString());
  351.         x += labelfont.stringWidth(layout->labelsep);
  352.      }
  353.       }
  354.       break;
  355.     case MARGIN_STATIC:
  356.       x += ( lyxstyle.TextClass(parameters->textclass)->defaultfont.signedStringWidth(layout->leftmargin) * 4
  357.          / (row->par->GetDepth() + 4));
  358.       break;
  359.     case MARGIN_FIRST_DYNAMIC:
  360.       if (layout->labeltype == LABEL_MANUAL) {
  361.      if (row->pos >= BeginningOfMainBody(row->par)) {
  362.         x += labelfont.signedStringWidth(layout->leftmargin);
  363.      }
  364.      else {
  365.         x += labelfont.signedStringWidth(layout->labelindent);
  366.      }
  367.       }
  368.       else {
  369.      if (row->pos
  370.          // Special case to fix problems with theorems (JMarc)
  371.          || (layout->labeltype == LABEL_STATIC
  372.          && layout->latextype == LATEX_ENVIRONMENT
  373.          && ! row->par->IsFirstInSequence())){
  374.          x += labelfont.signedStringWidth(layout->leftmargin);
  375.      }
  376.      else if (layout->labeltype != LABEL_TOP_ENVIRONMENT
  377.           && layout->labeltype != LABEL_BIBLIO
  378.           && layout->labeltype != LABEL_CENTERED_TOP_ENVIRONMENT) {
  379.          x += labelfont.signedStringWidth(layout->labelindent);
  380.          x += labelfont.stringWidth(layout->labelsep);
  381.          x += labelfont.stringWidth(row->par->GetLabelString());
  382.      } 
  383.       }
  384.       break;
  385.       
  386.     case MARGIN_RIGHT_ADDRESS_BOX:
  387.     {
  388.       /* ok, a terrible hack. The left margin depends on the widest row
  389.        * in this paragraph. Do not care about footnotes, they are *NOT*
  390.        * allowed in the LaTeX realisation of this layout. */ 
  391.       
  392.       /* find the first row of this paragraph */ 
  393.       Row *tmprow = row;
  394.       while (tmprow->previous && tmprow->previous->par == row->par)
  395.           tmprow = tmprow->previous;
  396.       
  397.       int minfill = tmprow->fill;
  398.       while (tmprow-> next && tmprow->next->par == row->par) {
  399.      tmprow = tmprow->next;
  400.      if (tmprow->fill < minfill)
  401.        minfill = tmprow->fill;
  402.       }
  403.       
  404.       x += lyxstyle.TextClass(parameters->textclass)->defaultfont.signedStringWidth(layout->leftmargin);
  405.       x += minfill;
  406.     }
  407.       break;
  408.    }
  409.    if (row->par->pextra_type == PEXTRA_INDENT) {
  410.        if (!row->par->pextra_widthp.empty()) {
  411.            x += paperwidth * atoi(row->par->pextra_widthp.c_str()) / 100;
  412.        } else if (!row->par->pextra_width.empty()) {
  413.            int xx = VSpace(row->par->pextra_width).inPixels();
  414.  
  415.            if (xx > paperwidth)
  416.                xx = paperwidth * 80 / 100;
  417.            x += xx;
  418.        } else { // should not happen
  419.            LyXFont font(LyXFont::ALL_SANE);
  420.            x += font.stringWidth("XXXXXX");
  421.        }
  422.    }
  423.    
  424.    int align;
  425.    if (row->par->FirstPhysicalPar()->align == LYX_ALIGN_LAYOUT)
  426.      align = layout->align;
  427.    else
  428.      align = row->par->FirstPhysicalPar()->align;
  429.    
  430.    /* set the correct parindent */
  431.    if (row->pos == 0) {
  432.        if ((layout->labeltype == LABEL_NO_LABEL 
  433.         || layout->labeltype == LABEL_TOP_ENVIRONMENT 
  434.         || layout->labeltype == LABEL_CENTERED_TOP_ENVIRONMENT
  435.         || (layout->labeltype == LABEL_STATIC
  436.         && layout->latextype == LATEX_ENVIRONMENT
  437.         && ! row->par->IsFirstInSequence()))
  438.        && row->par == row->par->FirstPhysicalPar()
  439.        && align == LYX_ALIGN_BLOCK
  440.        && !row->par->noindent
  441.        && (row->par->layout ||
  442.            parameters->paragraph_separation == LYX_PARSEP_INDENT))
  443.      x += lyxstyle.TextClass(parameters->textclass)->defaultfont.stringWidth(parindent);
  444.        else 
  445.      if (layout->labeltype==LABEL_BIBLIO) { // ale970405 Right width for bibitems
  446.          x += bibitemMaxWidth(lyxstyle.TextClass(parameters->textclass)->defaultfont);
  447.      }
  448.    }
  449.  
  450.    return x;
  451. }
  452.     
  453.    
  454. int LyXText::RightMargin(Row *row)
  455. {
  456.    int  x;
  457.    LyXLayout* layout;
  458.    
  459.    LyXParagraph *newpar;
  460.    Row dummyrow;
  461.    layout = lyxstyle.Style(parameters->textclass, row->par->GetLayout());
  462.  
  463.    x = LYX_PAPER_MARGIN;
  464.  
  465.    x += lyxstyle.TextClass(parameters->textclass)->
  466.      defaultfont.signedStringWidth(lyxstyle.TextClass(parameters->textclass)->rightmargin);
  467.    if (row->par->footnoteflag == LyXParagraph::OPEN_FOOTNOTE)  {
  468.      x += LYX_PAPER_MARGIN/2;
  469.    }
  470.  
  471.     /* this is the way, LyX handles the LaTeX-Environments.
  472.     * I have had this idea very late, so it seems to be a
  473.     * later added hack and this is true */ 
  474.    if (row->par->GetDepth()) {
  475.       /* find the next level paragraph */ 
  476.       
  477.       newpar = row->par;
  478.       
  479.       do {
  480.         newpar = newpar->FirstPhysicalPar()->Previous();
  481.         if (newpar) 
  482.             newpar = newpar->FirstPhysicalPar();
  483.       } while (newpar && newpar->GetDepth() >= row->par->GetDepth()
  484.            && newpar->footnoteflag == row->par->footnoteflag);
  485.       
  486.       /* make a corresponding row. Needed to call LeftMargin() */
  487.  
  488.       /* check wether it is a sufficent paragraph */ 
  489.       if (newpar && newpar->footnoteflag == row->par->footnoteflag
  490.       && lyxstyle.Style(parameters->textclass,
  491.                 newpar->GetLayout())->isEnvironment()) {
  492.          dummyrow.par = newpar;
  493.          dummyrow.pos = 0;
  494.          x = RightMargin(&dummyrow);
  495.       }
  496.       else {
  497.      /* this is no longer an error, because this function is used
  498.       * to clear impossible depths after changing a layout. Since there
  499.       * is always a redo, LeftMargin() is always called */ 
  500.      
  501.      /* printf("LYX_ERROR (text, LeftMargin()) impossible depth \n");*/ 
  502.      row->par->FirstPhysicalPar()->depth = 0;
  503.       }
  504.    }
  505.  
  506.    //fprintf(stderr,"rightmargin: %s\n", layout->rightmargin.c_str());
  507.    //fflush(stderr);
  508.    x += (lyxstyle.TextClass(parameters->textclass)->defaultfont.signedStringWidth(layout->rightmargin) * 4
  509.      / (row->par->GetDepth() + 4));
  510.    return x;
  511.    
  512. }
  513.  
  514.  
  515. int LyXText::LabelEnd (Row *row)
  516. {
  517.    if (lyxstyle.Style(parameters->textclass, row->par->GetLayout())->margintype == MARGIN_MANUAL) {
  518.       Row tmprow;
  519.       tmprow = *row;
  520.       tmprow.pos = row->par->Last();
  521.       return LeftMargin(&tmprow);      /* just the beginning 
  522.                     * of the main body */
  523.    }
  524.    else
  525.      return 0;                   /* LabelEnd is only needed, if the  
  526.                     * layout fills a flushleft
  527.                     * label. */
  528. }
  529.  
  530.  
  531. /* table stuff -- begin*/ 
  532. int LyXText::NumberOfCell(LyXParagraph *par, int pos)
  533. {
  534.    int cell = 0;
  535.    int tmp_pos = 0;
  536.    while (tmp_pos < pos) {
  537.       if (par->IsNewline(tmp_pos))
  538.            cell++;
  539.       tmp_pos++;
  540.    }
  541.    return cell;
  542. }
  543.  
  544.  
  545. int LyXText::WidthOfCell(LyXParagraph *par, int &pos)
  546. {
  547.    int w = 0;
  548.    while (pos < par->Last() && !par->IsNewline(pos)) {
  549.       w += SingleWidth(par, pos);
  550.       pos++;
  551.    }
  552.    if (par->IsNewline(pos))
  553.       pos++;
  554.    return w;
  555. }
  556.  
  557.  
  558. char LyXText::HitInTable(Row* row, int x)
  559. {
  560.   float tmpx;
  561.   float fill_separator, fill_hfill, fill_label_hfill;
  562.   if (!row->par->table)
  563.     return 0;
  564.   PrepareToPrint(row, tmpx, fill_separator, fill_hfill, fill_label_hfill);
  565.   return (x > tmpx && x < tmpx + row->par->table->WidthOfTable());
  566. }
  567.  
  568.  
  569. bool LyXText::MouseHitInTable(int x, long y)
  570. {
  571.     Row *row = GetRowNearY(y);
  572.         return HitInTable(row, x);
  573. }
  574.  
  575.  
  576. /* table stuff -- end*/
  577.  
  578.  
  579. /* get the next breakpoint in a given paragraph */
  580. int LyXText::NextBreakPoint(Row* row, int width)
  581. {
  582.     int x = 0;
  583.     int last_separator = -1; /* position of the last possible breakpoint 
  584.                   * -1 isn't a suitable value, but a flag */
  585.     int i = 0;
  586.     int left_margin;
  587.     
  588.     LyXParagraph *par = row->par;
  589.     int pos = row->pos;
  590.     
  591.     /* table stuff -- begin*/ 
  592.     if (par->table) {
  593.         while (pos<par->last 
  594.                && (!par->IsNewline(pos) 
  595.                || !par->table->IsFirstCell(NumberOfCell(par, pos+1)))) {
  596.             if (par->GetChar(pos) == LYX_META_INSET &&
  597.                 par->GetInset(pos) && par->GetInset(pos)->Display()){
  598.                 par->GetInset(pos)->SetDisplay(false);
  599.             }
  600.             pos++;
  601.         }
  602.         return pos;
  603.     }
  604.     /* table stuff -- end*/ 
  605.     
  606.     left_margin = LabelEnd(row);
  607.     width -= RightMargin(row);
  608.     int main_body = BeginningOfMainBody(par);
  609.     LyXLayout* layout = lyxstyle.Style(parameters->textclass, par->GetLayout());
  610.     i = pos;
  611.     char c;
  612.     
  613.     if (layout->margintype == MARGIN_RIGHT_ADDRESS_BOX) {
  614.         /* special code for right address boxes, only newlines count */
  615.         while (i < par->Last()) {
  616.             if (par->IsNewline(i)) {
  617.                 last_separator = i;
  618.                 i = par->Last() - 1;/* this means break  */
  619.                 x = width;
  620.             } else if (par->GetChar(i) == LYX_META_INSET &&
  621.                    par->GetInset(i) && par->GetInset(i)->Display()){
  622.                 par->GetInset(i)->SetDisplay(false);
  623.             }
  624.             i++;
  625.         }
  626.     } else {
  627.         // Last position is an invariant
  628.         int const last = par->Last();
  629.         /* this is the usual handling */ 
  630.         x = LeftMargin(row);
  631.         while (x < width && i < last) {
  632.             c = par->GetChar(i);
  633.             if (IsNewlineChar(c)) {
  634.                 last_separator = i;
  635.                 x = width;               /* this means break  */
  636.             } else if (c == LYX_META_INSET &&
  637.                    par->GetInset(i) && par->GetInset(i)->Display()){
  638.                 /* check wether a Display() inset is valid here .
  639.                    if not, change it to non-display*/ 
  640.                 if (layout->isCommand()
  641.                     || (layout->labeltype == LABEL_MANUAL
  642.                     && i < BeginningOfMainBody(par))){
  643.                     /* display istn't allowd */ 
  644.                     par->GetInset(i)->SetDisplay(false);
  645.                     x += SingleWidth(par, i, c);
  646.                 } else {
  647.                     /* inset is display. So break the line here */ 
  648.                     if (i==pos){
  649.                         if (pos < last-1) {
  650.                             last_separator = i;
  651.                             if (IsLineSeparatorChar(par->GetChar(i+1)))
  652.                                 last_separator++;
  653.                         } else
  654.                             last_separator = last; // to avoid extra rows
  655.                     } else
  656.                         last_separator = i - 1;
  657.                     x = width;               /* this means break  */
  658.                 }
  659.             } else  {
  660.                 if (IsLineSeparatorChar(c))
  661.                     last_separator = i;
  662.                 x += SingleWidth(par, i, c);
  663.             }
  664.             i++;
  665.             if (i == main_body) {
  666.                 x += GetFont(par, -2).stringWidth(layout->labelsep);
  667.                 if (par->IsLineSeparator(i - 1))
  668.                     x-= SingleWidth(par, i - 1);
  669.                 if (x < left_margin)
  670.                     x = left_margin;
  671.             }
  672.         }
  673.         /* end of paragraph is always a suitable separator */
  674.         if (i == last && x < width)
  675.             last_separator = i;
  676.     }
  677.     
  678.     /* well, if last_separator is still 0, the line isn't breakable. 
  679.      * don't care and cut simply at the end */
  680.     if (last_separator < 0) {
  681.         last_separator = i;
  682.     }
  683.     
  684.     /* manual labels cannot be broken in LaTeX, do not care  */
  685.     if (main_body && last_separator < main_body)
  686.         last_separator = main_body - 1;
  687.     
  688.     return last_separator;
  689. }
  690.  
  691.  
  692. /* returns the minimum space a row needs on the screen in pixel */
  693. int LyXText::Fill(Row *row, int paperwidth)
  694. {
  695.    int w,i, last, fill, left_margin;
  696.    /* get the pure distance */
  697.    last = RowLast(row);
  698.    
  699.    /* table stuff -- begin*/
  700.    if (row->par->table) {
  701.       /* for tables FILL does calculate the widthes of each cell in 
  702.        * the row */ 
  703.       int pos = row->pos;
  704.       int cell = NumberOfCell(row->par, pos);
  705.       w = 0;
  706.       do {
  707.      row->par->table->SetWidthOfCell(cell, WidthOfCell(row->par, pos));
  708.      cell++;
  709.       } while (pos <= last && !row->par->table->IsFirstCell(cell));
  710.       /* don't forget the very last table cell without characters */
  711.       if (cell == row->par->table->GetNumberOfCells()-1)
  712.           row->par->table->SetWidthOfCell(cell, WidthOfCell(row->par, pos));
  713.       
  714.       return 0; /* width of table cannot be returned since
  715.          * we cannot guarantee its correct value at
  716.          * this point. */ 
  717.    }
  718.    /* table stuff -- end*/ 
  719.  
  720.    left_margin = LabelEnd(row);
  721.  
  722.      /* if the row ends with newline, this newline will not be relevant */ 
  723.      if (last >= 0 && row->par->IsNewline(last))
  724.        last--;
  725.      
  726.      /* if the row ends with a space, this space will not be relevant */ 
  727.      if (last >= 0 && row->par->IsLineSeparator(last))
  728.        last--;
  729.  
  730.    /* special handling of the right address boxes */ 
  731.    if (lyxstyle.Style(parameters->textclass, row->par->GetLayout())->margintype == MARGIN_RIGHT_ADDRESS_BOX) {
  732.       int tmpfill = row->fill;
  733.       row->fill = 0;                /* the minfill in MarginLeft()  */
  734.       w = LeftMargin(row);
  735.       row->fill = tmpfill;
  736.       
  737.       /* the old way, impossible when using environments: */ 
  738.       /*  w = LyXStringWidth(lyxstyle.Style(parameters->textclass, row->par->GetLayout())->font, */ 
  739.       /*              lyxstyle.Style(parameters->textclass, row->par->GetLayout())->leftmargin); */
  740.    }
  741.    else
  742.      w = LeftMargin(row);
  743.    
  744.    int main_body = BeginningOfMainBody(row->par);
  745.    LyXLayout *layout = lyxstyle.Style(parameters->textclass,
  746.                       row->par->GetLayout());
  747.    i = row->pos;
  748.    while (i<= last) {
  749.       w += SingleWidth(row->par, i);
  750.       i++;
  751.       if (i == main_body) {
  752.      w += GetFont(row->par, -2).stringWidth(layout->labelsep);
  753.      if (row->par->IsLineSeparator(i - 1))
  754.        w-= SingleWidth(row->par, i - 1);
  755.      if (w < left_margin)
  756.        w = left_margin;
  757.       }
  758.    }
  759.    
  760.    fill = paperwidth - w - RightMargin(row);
  761.    return fill;
  762. }
  763.  
  764.  
  765. /* returns the minimum space a manual label needs on the screen in pixel */ 
  766. int LyXText::LabelFill(Row *row)
  767. {
  768.    int w,i, last;
  769.    int fill=0;
  770.    
  771.    last = BeginningOfMainBody(row->par) - 1;
  772.    /* -1 because a label ends either with a space that is in the label, 
  773.     * or with the beginning of a footnote that is outside the label. */ 
  774.  
  775.    // I don't understand this code in depth, but sometimes "last" is less than
  776.    // 0 and this causes a crash. This fix seems to work correctly, but I
  777.    // bet the real error is elsewhere.  The bug is triggered when you have an 
  778.    // open footnote in a paragraph environment with a manual label. (Asger)
  779.    if (last<0) last = 0;
  780.  
  781.    if (row->par->IsLineSeparator(last))    /* a sepearator at this end 
  782.                     * does not count */
  783.      last--;
  784.    
  785.    w = 0;
  786.    i = row->pos;
  787.    while (i<= last) {
  788.       w += SingleWidth(row->par, i);
  789.       i++;
  790.    }
  791.    
  792.    if (!row->par->labelwidthstring.empty()) {
  793.       fill = GetFont(row->par, -2).stringWidth(row->par->labelwidthstring) - w;
  794.    }
  795.    
  796.    if (fill < 0)
  797.      fill = 0;
  798.    
  799.    return fill;
  800. }
  801.  
  802.  
  803. /* returns the number of separators in the specified row. The separator 
  804. * on the very last column doesnt count */ 
  805. int LyXText::NumberOfSeparators(Row *row)
  806. {
  807.    int n,p,last;
  808.    
  809.    last = RowLast(row);
  810.    n = 0;
  811.    p = row->pos;
  812.    int main_body = BeginningOfMainBody(row->par);
  813.    if (p < main_body)
  814.      p = main_body;
  815.    for (; p < last; p++) {
  816.       if (row->par->IsSeparator(p)) {
  817.      n++;
  818.       }
  819.    }
  820.    return n;
  821. }
  822.  
  823.  
  824. /* returns the number of hfills in the specified row. The LyX-Hfill is
  825. * a LaTeX \hfill so that the hfills at the beginning and at the end were 
  826. * ignored. This is *MUCH* more usefull than not to ignore!  */
  827. int LyXText::NumberOfHfills(Row *row)
  828. {
  829.    int n,p,last, first;
  830.    
  831.    last = RowLast(row);
  832.    first = row->pos;
  833.    if (first) {                   /* hfill *DO* count at the beginning 
  834.                     * of paragraphs! */
  835.      while(first <= last && row->par->IsHfill(first))
  836.        first++;
  837.    }
  838.  
  839.    n = 0;
  840.    int main_body = BeginningOfMainBody(row->par);
  841.    if (first < main_body)
  842.      first = main_body;
  843.    for (p = first; p <= last; p++) {    /* last, because the end is ignored!  */
  844.       if (row->par->IsHfill(p)) {
  845.      n++;
  846.       }
  847.    }
  848.    return n;
  849. }
  850.  
  851.  
  852. /* like NumberOfHfills, but only those in the manual label! */ 
  853. int LyXText::NumberOfLabelHfills(Row *row)
  854. {
  855.    int n,p,last, first;
  856.    
  857.    last = RowLast(row);
  858.    first = row->pos;
  859.    if (first) {                   /* hfill *DO* count at the beginning 
  860.                     * of paragraphs! */
  861.       while(first < last && row->par->IsHfill(first))
  862.           first++;
  863.    }
  864.  
  865.    n = 0;
  866.    int main_body = BeginningOfMainBody(row->par);
  867.    
  868.    if (last > main_body)
  869.      last = main_body;
  870.    
  871.    for (p = first; p < last; p++) {    /* last, because the end is ignored!  */
  872.       if (row->par->IsHfill(p)) {
  873.      n++;
  874.       }
  875.    }
  876.    return n;
  877. }
  878.  
  879.  
  880. /* returns true, if a expansion is needed.
  881.  * Rules are given by LaTeX */ 
  882. bool LyXText::HfillExpansion(Row *row_ptr, int pos)
  883. {
  884.    /* by the way, is it a hfill? */ 
  885.    if (!row_ptr->par->IsHfill(pos))
  886.      return false;
  887.    
  888.    /* at the end of a row it does not count */ 
  889.    if (pos >= RowLast(row_ptr))
  890.      return false;
  891.    
  892.    /* at the beginning of a row it does not count, if it is not 
  893.     * the first row of a paragaph */ 
  894.    if (!row_ptr->pos)
  895.      return true;
  896.    
  897.    /* in some labels  it does not count */ 
  898.    if ( lyxstyle.Style(parameters->textclass, row_ptr->par->GetLayout())->margintype != MARGIN_MANUAL &&
  899.        pos < BeginningOfMainBody(row_ptr->par))
  900.      return false; 
  901.    
  902.    /* if there is anything between the first char of the row and
  903.     * the sepcified position that is not a newline and not a hfill,
  904.     * the hfill will count, otherwise not */ 
  905.    
  906.    int i = row_ptr->pos;
  907.    while (i < pos && (row_ptr->par->IsNewline(i)
  908.               || row_ptr->par->IsHfill(i)))
  909.      i++;
  910.    
  911.    return (i != pos);
  912. }
  913.  
  914.  
  915. void LyXText::SetHeightOfRow(Row *row_ptr)
  916. {
  917.     /* get the maximum ascent and the maximum descent */
  918.    int asc, maxasc, desc, maxdesc, pos_end, pos, labeladdon;
  919.    float layoutasc = 0;
  920.    float layoutdesc = 0;
  921.    float tmptop = 0;
  922.    LyXParagraph *par, *firstpar;
  923.    LyXFont tmpfont;
  924.    Inset *tmpinset;
  925.  
  926.    /* this must not happen before the currentrow for clear reasons.
  927.       so the trick is just to set the current row onto this row */
  928.    long unused_y;
  929.    GetRow(row_ptr->par, row_ptr->pos, unused_y);
  930.  
  931.    /* ok , let us initialize the maxasc and maxdesc value. 
  932.     * This depends in LaTeX of the font of the last character
  933.     * in the paragraph. The hack below is necessary because
  934.     * of the possibility of open footnotes */
  935.  
  936.    /* Correction: only the fontsize count. The other properties
  937.       are taken from the layoutfont. Nicer on the screen :) */
  938.    
  939.    par = row_ptr->par->LastPhysicalPar();
  940.    firstpar = row_ptr->par->FirstPhysicalPar();
  941.    
  942.    LyXLayout *layout = lyxstyle.Style(parameters->textclass, firstpar->GetLayout());
  943.    
  944.    LyXFont font = GetFont(par, par->Last()-1);
  945.    LyXFont::FONT_SIZE size = font.size();
  946.    font = GetFont(par, -1);
  947.    font.setSize(size);
  948.  
  949.    LyXFont labelfont = GetFont(par, -2);
  950.  
  951.    maxasc = int(font.maxAscent() *
  952.            layout->spacing.getValue() *
  953.            parameters->spacing.getValue());
  954.    maxdesc = int(font.maxDescent() *
  955.             layout->spacing.getValue() *
  956.             parameters->spacing.getValue());
  957.  
  958.    pos_end = RowLast(row_ptr);
  959.    
  960.    labeladdon = 0;
  961.  
  962.    // Check if any insets are larger
  963.    for (pos = row_ptr->pos; pos <= pos_end; pos++) {
  964.       if (row_ptr->par->GetChar(pos) == LYX_META_INSET) {
  965.      tmpfont = GetFont(row_ptr->par, pos);
  966.          tmpinset = row_ptr->par->GetInset(pos);
  967.          if (tmpinset) {
  968.             asc = tmpinset->Ascent(tmpfont);
  969.             desc = tmpinset->Descent(tmpfont);
  970.         if (asc > maxasc) 
  971.           maxasc = asc;
  972.         if (desc > maxdesc)
  973.           maxdesc = desc;
  974.      }
  975.       }
  976.    }
  977.  
  978.    // Check if any custom fonts are larger (Asger)
  979.    // This is not completely correct, but we can live with the small,
  980.    // cosmetic error for now.
  981.    LyXFont::FONT_SIZE maxsize = row_ptr->par->HighestFontInRange(row_ptr->pos, pos_end);
  982.    if (maxsize > font.size()) {
  983.     font.setSize(maxsize);
  984.  
  985.     asc = font.maxAscent();
  986.     desc = font.maxDescent();
  987.     if (asc > maxasc) 
  988.         maxasc = asc;
  989.     if (desc > maxdesc)
  990.         maxdesc = desc;
  991.    }
  992.  
  993.    /* table stuff -- begin*/
  994.    if (row_ptr->par->table){
  995.      // stretch the rows a bit
  996.       maxasc += 1;
  997.       maxdesc +=1;
  998.    }
  999.    /* table stuff -- end*/
  1000.  
  1001.    // This is nicer with box insets:
  1002.    maxasc++;
  1003.    maxdesc++;
  1004.  
  1005.    row_ptr->ascent_of_text = maxasc;
  1006.    
  1007.    /* is it a top line? */ 
  1008.    if (row_ptr->pos == 0
  1009.        && row_ptr->par == firstpar) {
  1010.       
  1011.       /* some parksips VERY EASY IMPLEMENTATION */ 
  1012.       if (parameters->paragraph_separation == LYX_PARSEP_SKIP) {
  1013.      if (layout->isParagraph()
  1014.          && firstpar->GetDepth() == 0
  1015.          && firstpar->Previous())
  1016.         maxasc += parameters->getDefSkip().inPixels();
  1017.      else if (firstpar->Previous()
  1018.           && lyxstyle.Style(parameters->textclass,
  1019.                firstpar->Previous()->GetLayout())->isParagraph()
  1020.           && firstpar->Previous()->GetDepth() == 0)
  1021.        // is it right to use defskip here too? (AS)
  1022.        maxasc += parameters->getDefSkip().inPixels();
  1023.       }
  1024.       
  1025.       /* the paper margins */ 
  1026.       if (!row_ptr->par->previous)
  1027.            maxasc += LYX_PAPER_MARGIN;
  1028.       
  1029.       /* add the vertical spaces, that the user added */
  1030.       if (firstpar->added_space_top.kind() != VSpace::NONE)
  1031.            maxasc += int(firstpar->added_space_top.inPixels());
  1032.       
  1033.       /* do not forget the DTP-lines! 
  1034.        * there height depends on the font of the nearest character */
  1035.       if (firstpar->line_top)
  1036.            maxasc += 2 * GetFont(firstpar, 0).ascent('x');
  1037.       
  1038.       /* and now the pagebreaks */ 
  1039.       if (firstpar->pagebreak_top)
  1040.            maxasc += 3 * DefaultHeight();
  1041.       
  1042.       /*  this is special code for the chapter, since the label of this
  1043.        * layout is printed in an extra row */ 
  1044.       if (layout->labeltype == LABEL_COUNTER_CHAPTER
  1045.       && parameters->secnumdepth>=0) {
  1046.           labeladdon = int(labelfont.maxDescent() *
  1047.                   layout->spacing.getValue() *
  1048.                   parameters->spacing.getValue())
  1049.               + int(labelfont.maxAscent() *
  1050.                    layout->spacing.getValue() *
  1051.                    parameters->spacing.getValue());
  1052.       }
  1053.       
  1054.       /* sepcial code for the top label */ 
  1055.       if ((layout->labeltype == LABEL_TOP_ENVIRONMENT
  1056.        || layout->labeltype == LABEL_BIBLIO
  1057.        || layout->labeltype == LABEL_CENTERED_TOP_ENVIRONMENT)
  1058.       && row_ptr->par->IsFirstInSequence()) {
  1059.      labeladdon = int(
  1060.          (labelfont.maxAscent() *
  1061.           layout->spacing.getValue() *
  1062.           parameters->spacing.getValue())
  1063.          +(labelfont.maxDescent() *
  1064.            layout->spacing.getValue() *
  1065.            parameters->spacing.getValue())
  1066.          + layout->topsep * DefaultHeight()
  1067.          + layout->labelbottomsep *  DefaultHeight());
  1068.       }
  1069.    
  1070.       /* and now the layout spaces, for example before and after a section, 
  1071.        * or between the items of a itemize or enumerate environment */ 
  1072.       
  1073.       if (!firstpar->pagebreak_top) {
  1074.      LyXParagraph *prev = row_ptr->par->Previous();
  1075.      if (prev)
  1076.         prev = row_ptr->par->DepthHook(row_ptr->par->GetDepth());
  1077.      if (prev && prev->GetLayout() == firstpar->GetLayout()
  1078.          && prev->GetDepth() == firstpar->GetDepth()
  1079.          && prev->GetLabelWidthString() == firstpar->GetLabelWidthString())
  1080.        {
  1081.           layoutasc = (layout->itemsep * DefaultHeight());
  1082.        }
  1083.      else if (row_ptr->previous) {
  1084.         tmptop = layout->topsep;
  1085.         
  1086.         if (row_ptr->previous->par->GetDepth() >= row_ptr->par->GetDepth())
  1087.            tmptop-=lyxstyle.Style(parameters->textclass, row_ptr->previous->par->GetLayout())->bottomsep;
  1088.         
  1089.         if (tmptop > 0)
  1090.            layoutasc = (tmptop * DefaultHeight());
  1091.      }
  1092.      else if (row_ptr->par->line_top){
  1093.         tmptop = layout->topsep;
  1094.         
  1095.         if (tmptop > 0)
  1096.            layoutasc = (tmptop * DefaultHeight());
  1097.      }
  1098.      
  1099.      prev = row_ptr->par->DepthHook(row_ptr->par->GetDepth()-1);
  1100.      if (prev)  {
  1101.         maxasc += int(lyxstyle.Style(parameters->textclass,
  1102.                      prev->GetLayout())->parsep * DefaultHeight());
  1103.      }
  1104.      else {
  1105.         if (firstpar->Previous()
  1106.             && firstpar->Previous()->GetDepth() == 0
  1107.             && firstpar->Previous()->GetLayout() != firstpar->GetLayout()) {
  1108.            /* avoid parsep */ 
  1109.         }
  1110.         else if (firstpar->Previous()){
  1111.            maxasc += int(layout->parsep * DefaultHeight());
  1112.         }
  1113.      }
  1114.       }
  1115.    }
  1116.    
  1117.    /* is it a bottom line? */ 
  1118.    if (row_ptr->par->ParFromPos(RowLast(row_ptr) + 1) == par
  1119.        && (!row_ptr->next || row_ptr->next->par != row_ptr->par)) {     
  1120.       
  1121.       /* the paper margins */ 
  1122.       if (!par->next)
  1123.         maxdesc += LYX_PAPER_MARGIN;
  1124.     
  1125.       /* add the vertical spaces, that the user added */
  1126.       if (firstpar->added_space_bottom.kind() != VSpace::NONE)
  1127.         maxdesc += int(firstpar->added_space_bottom.inPixels());
  1128.       
  1129.       /* do not forget the DTP-lines! 
  1130.        * there height depends on the font of the nearest character */
  1131.       if (firstpar->line_bottom)
  1132.         maxdesc += 2 * (GetFont(par, par->Last()-1).ascent('x'));
  1133.       
  1134.       /* and now the pagebreaks */
  1135.       if (firstpar->pagebreak_bottom)
  1136.         maxdesc += 3 * DefaultHeight();
  1137.       
  1138.       /* and now the layout spaces, for example before and after a section, 
  1139.        * or between the items of a itemize or enumerate environment */
  1140.       if (!firstpar->pagebreak_bottom && row_ptr->par->Next()) {
  1141.          LyXParagraph *nextpar = row_ptr->par->Next();
  1142.          LyXParagraph *comparepar = row_ptr->par;
  1143.          float usual = 0;
  1144.          float  unusual = 0;
  1145.          
  1146.          if (comparepar->GetDepth() > nextpar->GetDepth()) {
  1147.         usual = (lyxstyle.Style(parameters->textclass, comparepar->GetLayout())->bottomsep * DefaultHeight());
  1148.         comparepar = comparepar->DepthHook(nextpar->GetDepth());
  1149.         if (comparepar->GetLayout()!=nextpar->GetLayout()
  1150.             || nextpar->GetLabelWidthString() != 
  1151.                 comparepar->GetLabelWidthString())
  1152.           unusual = (lyxstyle.Style(parameters->textclass, comparepar->GetLayout())->bottomsep * DefaultHeight());
  1153.         
  1154.         if (unusual > usual)
  1155.           layoutdesc = unusual;
  1156.         else
  1157.           layoutdesc = usual;
  1158.          }
  1159.          else if (comparepar->GetDepth() ==  nextpar->GetDepth()) {
  1160.         
  1161.         if (comparepar->GetLayout()!= nextpar->GetLayout()
  1162.             || nextpar->GetLabelWidthString() !=
  1163.             comparepar->GetLabelWidthString())
  1164.           layoutdesc = int(lyxstyle.Style(parameters->textclass, comparepar->GetLayout())->bottomsep * DefaultHeight());
  1165.          }
  1166.       }
  1167.        }
  1168.    
  1169.    /* incalculate the layout spaces */ 
  1170.    maxasc += int(layoutasc * 2 / (2 + firstpar->GetDepth()));
  1171.    maxdesc += int(layoutdesc * 2 / (2 + firstpar->GetDepth()));
  1172.  
  1173.    /* table stuff -- begin*/
  1174.    if (row_ptr->par->table){
  1175.       maxasc += row_ptr->par->table->
  1176.     AdditionalHeight(NumberOfCell(row_ptr->par, row_ptr->pos));
  1177.    }
  1178.    /* table stuff -- end*/
  1179.    
  1180.    /* calculate the new height of the text */ 
  1181.    height -= row_ptr->height;
  1182.    
  1183.    row_ptr->height=maxasc+maxdesc+labeladdon;
  1184.    row_ptr->baseline=maxasc+labeladdon;
  1185.    
  1186.    height += row_ptr->height;
  1187. }
  1188.  
  1189.  
  1190. /* Appends the implicit specified paragraph behind the specified row,
  1191.  * start at the implicit given position */
  1192. void LyXText::AppendParagraph(Row *row)
  1193. {
  1194.    int z;
  1195.    Row *tmprow;
  1196.    bool not_ready = true;
  1197.    
  1198.    // Get the width of the row
  1199.    z = row->pos;
  1200.  
  1201.    // The last character position of a paragraph is an invariant so we can 
  1202.    // safely get it here. (Asger)
  1203.    int lastposition = row->par->Last();
  1204.  
  1205.    do {
  1206.       // Get the next breakpoint
  1207.       z = NextBreakPoint(row, paperwidth);
  1208.       
  1209.       tmprow = row;
  1210.  
  1211.       // Insert the new row
  1212.       if (z < lastposition) {
  1213.      z++;
  1214.      InsertRow(row, row->par, z);
  1215.      row = row->next;
  1216.  
  1217.      row->height = 0;
  1218.       } else
  1219.      not_ready = false;
  1220.       
  1221.       // Set the dimensions of the row
  1222.       tmprow->fill = Fill(tmprow, paperwidth);
  1223.       SetHeightOfRow(tmprow);
  1224.  
  1225.    } while (not_ready);
  1226. }
  1227.  
  1228.  
  1229. void LyXText::BreakAgain(Row *row)
  1230. {
  1231.    int z;
  1232.    char not_ready;
  1233.    z = row->pos;
  1234.    Row *tmprow, *tmprow2;
  1235.    
  1236.    not_ready = 1;
  1237.    
  1238.    do  {
  1239.       /* get the next breakpoint */
  1240.       z = NextBreakPoint(row, paperwidth);
  1241.       
  1242.       tmprow = row;
  1243.       
  1244.       if (z < row->par->Last() ) {
  1245.      if (!row->next || (row->next && row->next->par != row->par)) {
  1246.         /* insert a new row */ 
  1247.         z++;
  1248.         InsertRow(row, row->par, z);
  1249.         row = row->next;
  1250.         row->height = 0;
  1251.      }
  1252.      else  {
  1253.         row=row->next;
  1254.         z++;
  1255.         if (row->pos == z)
  1256.           not_ready = 0;           /* the rest will not change  */
  1257.         else {
  1258.            row->pos = z;
  1259.         }
  1260.      }
  1261.       }
  1262.       else {
  1263.      /* if there are some rows too much, delete them */
  1264.      /* only if you broke the whole paragraph! */ 
  1265.      tmprow2 = row;
  1266.      while (tmprow2->next && tmprow2->next->par == row->par) {
  1267.         tmprow2 = tmprow2->next;
  1268.      }
  1269.      while (tmprow2 != row) {
  1270.         tmprow2 = tmprow2->previous;
  1271.         RemoveRow(tmprow2->next);
  1272.      }
  1273.      not_ready = 0;
  1274.       }
  1275.        
  1276.       /* set the dimensions of the row */ 
  1277.       tmprow->fill = Fill(tmprow, paperwidth);
  1278.       SetHeightOfRow(tmprow);
  1279.    } while (not_ready);
  1280. }
  1281.  
  1282.  
  1283. /* this is just a little changed version of break again */ 
  1284. void LyXText::BreakAgainOneRow(Row *row)
  1285. {
  1286.    int z;
  1287.    char not_ready;
  1288.    z = row->pos;
  1289.    Row *tmprow, *tmprow2;
  1290.    
  1291.    not_ready = 1;
  1292.    
  1293.    /* get the next breakpoint */
  1294.    z = NextBreakPoint(row, paperwidth);
  1295.    
  1296.    tmprow = row;
  1297.    
  1298.    if (z < row->par->Last() ) {
  1299.       if (!row->next || (row->next && row->next->par != row->par)) {
  1300.      /* insert a new row */ 
  1301.      z++;
  1302.      InsertRow(row, row->par, z);
  1303.      row = row->next;
  1304.      row->height = 0;
  1305.       }
  1306.       else  {
  1307.      row=row->next;
  1308.      z++;
  1309.      if (row->pos == z)
  1310.        not_ready = 0;           /* the rest will not change  */
  1311.      else {
  1312.         row->pos = z;
  1313.      }
  1314.       }
  1315.    }
  1316.    else {
  1317.       /* if there are some rows too much, delete them */
  1318.       /* only if you broke the whole paragraph! */ 
  1319.       tmprow2 = row;
  1320.       while (tmprow2->next && tmprow2->next->par == row->par) {
  1321.      tmprow2 = tmprow2->next;
  1322.       }
  1323.       while (tmprow2 != row) {
  1324.      tmprow2 = tmprow2->previous;
  1325.      RemoveRow(tmprow2->next);
  1326.       }
  1327.       not_ready = 0;
  1328.    }
  1329.    
  1330.    /* set the dimensions of the row */ 
  1331.    tmprow->fill = Fill(tmprow, paperwidth);
  1332.    SetHeightOfRow(tmprow);
  1333. }
  1334.  
  1335.  
  1336. void LyXText::BreakParagraph(char keep_layout)
  1337. {
  1338.    LyXLayout *layout = lyxstyle.Style(parameters->textclass,
  1339.                       cursor.par->GetLayout());
  1340.    
  1341.    /* table stuff -- begin*/
  1342.    if (cursor.par->table) {
  1343.        // breaking of tables is only allowed at the beginning or the end */
  1344.        if (cursor.pos && cursor.pos < cursor.par->last &&
  1345.            !cursor.par->table->ShouldBeVeryLastCell(NumberOfCell(cursor.par, cursor.pos)))
  1346.            return; /* no breaking of tables allowed */ 
  1347.    }
  1348.    /* table stuff -- end*/
  1349.  
  1350.    /* this is only allowed, if the current paragraph is not empty or caption*/ 
  1351.    if ((cursor.par->Last() <= 0 && !cursor.par->IsDummy())
  1352.        && 
  1353.        layout->labeltype!=LABEL_SENSITIVE)
  1354.      return;
  1355.  
  1356.    SetUndo(Undo::INSERT, 
  1357.        cursor.par->ParFromPos(cursor.pos)->previous, 
  1358.        cursor.par->ParFromPos(cursor.pos)->next); 
  1359.  
  1360.    /* table stuff -- begin*/
  1361.    if (cursor.par->table) {
  1362.        int cell = NumberOfCell(cursor.par, cursor.pos);
  1363.        if (cursor.par->table->ShouldBeVeryLastCell(cell))
  1364.            SetCursor(cursor.par,cursor.par->last);
  1365.    }
  1366.    /* table stuff -- end*/
  1367.    /* please break alway behind a space */ 
  1368.    if (cursor.pos < cursor.par->Last()
  1369.        && cursor.par->IsLineSeparator(cursor.pos))
  1370.      cursor.pos++;
  1371.    
  1372.    /* break the paragraph */
  1373.    if (keep_layout)
  1374.      keep_layout = 2;
  1375.    else    
  1376.      keep_layout = layout->isEnvironment();
  1377.    cursor.par->BreakParagraph(cursor.pos, keep_layout);
  1378.  
  1379.    /* table stuff -- begin*/
  1380.    if (cursor.par->table){
  1381.      // the table should stay with the contents
  1382.      if (!cursor.pos){
  1383.        cursor.par->Next()->table = cursor.par->table;
  1384.        cursor.par->table = NULL;
  1385.      }
  1386.    }
  1387.    /* table stuff -- end*/
  1388.  
  1389.    /* well this is the caption hack since one caption is really enough */
  1390.    if (layout->labeltype == LABEL_SENSITIVE){
  1391.      if (!cursor.pos)
  1392.        cursor.par->SetLayout(0); /* set the new paragraph to standard-layout */
  1393.      else
  1394.        cursor.par->Next()->SetLayout(0); /* set the new paragraph to standard-layout */
  1395.      
  1396.    }
  1397.    
  1398.    /* if the cursor is at the beginning of a row without prior newline, 
  1399.     *  move one row up! 
  1400.     * This touches only the screen-update. Otherwise we would may have
  1401.     * an empty row on the screen */
  1402.    if (cursor.pos && !cursor.row->par->IsNewline(cursor.row->pos -1) &&
  1403.        cursor.row->pos == cursor.pos) {
  1404.      CursorLeft();
  1405.    } 
  1406.    
  1407.    status = LyXText::NEED_MORE_REFRESH;
  1408.    refresh_row = cursor.row;
  1409.    refresh_y = cursor.y - cursor.row->baseline;
  1410.    
  1411.    /* Do not forget the special right address boxes */
  1412.    if (layout->margintype == MARGIN_RIGHT_ADDRESS_BOX) {
  1413.       while (refresh_row->previous &&
  1414.          refresh_row->previous->par == refresh_row->par) {
  1415.         refresh_row = refresh_row->previous;
  1416.         refresh_y -= refresh_row->height;
  1417.          }
  1418.    }
  1419.    RemoveParagraph(cursor.row);
  1420.    
  1421.    /* set the dimensions of the cursor row */
  1422.    cursor.row->fill = Fill(cursor.row, paperwidth);
  1423.  
  1424.    SetHeightOfRow(cursor.row);
  1425.    
  1426.    while (!cursor.par->Next()->table && cursor.par->Next()->Last()
  1427.       && cursor.par->Next()->IsNewline(0))
  1428.      cursor.par->Next()->Erase(0);
  1429.    
  1430.    InsertParagraph(cursor.par->Next(), cursor.row);
  1431.  
  1432.    UpdateCounters(cursor.row->previous);
  1433.    
  1434.    /* this check is necessary. Otherwise the new empty paragraph will
  1435.     * be deleted automatically. And it is more friendly for the user! */ 
  1436.    if (cursor.pos)
  1437.      SetCursor(cursor.par->Next(), 0);
  1438.    else
  1439.      SetCursor(cursor.par, 0);
  1440.    
  1441.    if (cursor.row->next)
  1442.      BreakAgain(cursor.row->next);
  1443.  
  1444.    need_break_row = NULL;
  1445. }
  1446.  
  1447.  
  1448. void LyXText::OpenFootnote()
  1449. {
  1450.    LyXParagraph *par, *endpar,*tmppar;
  1451.    Row *row;
  1452.    
  1453.    par = cursor.par->ParFromPos(cursor.pos);
  1454.    
  1455.    /* if there is no footnote in this paragraph, just return. */ 
  1456.    if (!par->next
  1457.        || par->next->footnoteflag != LyXParagraph::CLOSED_FOOTNOTE)
  1458.      return;
  1459.    
  1460.    /* ok, move the cursor right before the footnote */ 
  1461.    
  1462.    /* just a little faster than using CursorRight() */
  1463.    for (cursor.pos=0; cursor.par->ParFromPos(cursor.pos)!=par; cursor.pos++);
  1464.    /* now the cursor is at the beginning of the physical par */
  1465.    SetCursor(cursor.par, cursor.pos + cursor.par->ParFromPos(cursor.pos)->last);
  1466.    
  1467.    /* the cursor must be exactly before the footnote */ 
  1468.    par = cursor.par->ParFromPos(cursor.pos);
  1469.    
  1470.    status = LyXText::NEED_MORE_REFRESH;
  1471.    refresh_row = cursor.row;
  1472.    refresh_y = cursor.y - cursor.row->baseline;
  1473.    
  1474.    tmppar = cursor.par;
  1475.    endpar = cursor.par->Next();
  1476.    row = cursor.row;
  1477.    
  1478.    tmppar->OpenFootnote(cursor.pos);
  1479.    RemoveParagraph(row);
  1480.    /* set the dimensions of the cursor row */
  1481.    row->fill = Fill(row, paperwidth);
  1482.    SetHeightOfRow(row);
  1483.    tmppar = tmppar->Next();
  1484.    
  1485.    while (tmppar != endpar) {
  1486.       if (tmppar) {
  1487.      InsertParagraph(tmppar, row);
  1488.      while (row->next && row->next->par == tmppar)
  1489.        row = row->next;
  1490.      tmppar = tmppar->Next();
  1491.       }
  1492.    }
  1493.    SetCursor(par->next, 0);
  1494.    sel_cursor = cursor;
  1495. }
  1496.    
  1497.  
  1498. /* table stuff -- begin*/
  1499.  
  1500. void LyXText::TableFeatures(int feature, LString val)
  1501. {
  1502.     int
  1503.         actCell;
  1504.     
  1505.     if (!cursor.par->table)
  1506.         return; /* this should never happen */
  1507.   
  1508.     actCell = NumberOfCell(cursor.par, cursor.pos);
  1509.     SetUndo(Undo::FINISH, 
  1510.             cursor.par->ParFromPos(cursor.pos)->previous, 
  1511.             cursor.par->ParFromPos(cursor.pos)->next); 
  1512.  
  1513.     switch (feature){
  1514.       case LyXTable::SET_PWIDTH:
  1515.           cursor.par->table->SetPWidth(actCell,val);
  1516.           break;
  1517.       default:
  1518.           break;
  1519.     }
  1520.     RedoParagraph();
  1521. }
  1522.  
  1523.  
  1524. void LyXText::TableFeatures(int feature)
  1525. {
  1526.     int
  1527.         setLines = 0,
  1528.         setAlign = LYX_ALIGN_LEFT,
  1529.         lineSet,
  1530.         actCell;
  1531.     bool
  1532.         what;
  1533.     
  1534.     if (!cursor.par->table)
  1535.         return; /* this should never happen */
  1536.   
  1537.     actCell = NumberOfCell(cursor.par, cursor.pos);
  1538.     SetUndo(Undo::FINISH, 
  1539.             cursor.par->ParFromPos(cursor.pos)->previous, 
  1540.             cursor.par->ParFromPos(cursor.pos)->next); 
  1541.  
  1542.     switch (feature){
  1543.       case LyXTable::ALIGN_LEFT:
  1544.           setAlign=LYX_ALIGN_LEFT;
  1545.           break;
  1546.       case LyXTable::ALIGN_RIGHT:
  1547.           setAlign=LYX_ALIGN_RIGHT;
  1548.           break;
  1549.       case LyXTable::ALIGN_CENTER:
  1550.           setAlign=LYX_ALIGN_CENTER;
  1551.           break;
  1552.       default:
  1553.           break;
  1554.     }
  1555.     switch (feature){
  1556.       case LyXTable::APPEND_ROW: {
  1557.       int pos = cursor.pos;
  1558.           /* move to the next row */
  1559.           int cell_org = actCell;
  1560.           int cell = cell_org;
  1561.  
  1562.           // if there is a ContRow following this row I have to add
  1563.           // the row after the ContRow's
  1564.           if ((pos < cursor.par->Last()) &&
  1565.               cursor.par->table->RowHasContRow(cell_org)) {
  1566.               while((pos < cursor.par->Last()) &&
  1567.                     !cursor.par->table->IsContRow(cell)) {
  1568.                   while (pos < cursor.par->Last() &&
  1569.                          !cursor.par->IsNewline(pos))
  1570.                       pos++;
  1571.                   if (pos < cursor.par->Last())
  1572.                       pos++;
  1573.                   cell++;
  1574.               }
  1575.               while((pos < cursor.par->Last()) &&
  1576.                     cursor.par->table->IsContRow(cell)) {
  1577.                   while (pos < cursor.par->Last() &&
  1578.                          !cursor.par->IsNewline(pos))
  1579.                       pos++;
  1580.                   if (pos < cursor.par->Last())
  1581.                       pos++;
  1582.                   cell++;
  1583.               }
  1584.               cell_org = --cell;
  1585.               if (pos < cursor.par->Last())
  1586.                   pos--;
  1587.           }
  1588.           while (pos < cursor.par->Last() && 
  1589.                  (cell == cell_org || !cursor.par->table->IsFirstCell(cell))){
  1590.               while (pos < cursor.par->Last() && !cursor.par->IsNewline(pos))
  1591.                   pos++;
  1592.               if (pos < cursor.par->Last())
  1593.                   pos++;
  1594.               cell++;
  1595.           }
  1596.         
  1597.           /* insert the new cells */ 
  1598.           int number = cursor.par->table->NumberOfCellsInRow(cell_org);
  1599.           int i;
  1600.           for (i=0; i<number; i++)
  1601.               cursor.par->InsertChar(pos, LYX_META_NEWLINE);
  1602.         
  1603.           /* append the row into the table */
  1604.           cursor.par->table->AppendRow(cell_org);
  1605.           RedoParagraph();
  1606.           return;
  1607.       }
  1608.       case LyXTable::APPEND_CONT_ROW: {
  1609.           int pos = cursor.pos;
  1610.           /* move to the next row */
  1611.           int cell_org = actCell;
  1612.           int cell = cell_org;
  1613.  
  1614.           // if there is already a controw but not for this cell
  1615.           // the AppendContRow sets only the right values but does
  1616.           // not actually add a row
  1617.           if (cursor.par->table->RowHasContRow(cell_org) &&
  1618.               (cursor.par->table->CellHasContRow(cell_org)<0)) {
  1619.               cursor.par->table->AppendContRow(cell_org);
  1620.               RedoParagraph();
  1621.               return;
  1622.           }
  1623.           while (pos < cursor.par->Last() && 
  1624.                  (cell == cell_org
  1625.                   || !cursor.par->table->IsFirstCell(cell))){
  1626.               while (pos < cursor.par->Last() && !cursor.par->IsNewline(pos))
  1627.                   pos++;
  1628.               if (pos < cursor.par->Last())
  1629.                   pos++;
  1630.               cell++;
  1631.           }
  1632.         
  1633.           /* insert the new cells */ 
  1634.           int number = cursor.par->table->NumberOfCellsInRow(cell_org);
  1635.           int i;
  1636.           for (i=0; i<number; i++)
  1637.               cursor.par->InsertChar(pos, LYX_META_NEWLINE);
  1638.         
  1639.           /* append the row into the table */
  1640.           cursor.par->table->AppendContRow(cell_org);
  1641.           RedoParagraph();
  1642.           return;
  1643.       }
  1644.       case LyXTable::APPEND_COLUMN: { 
  1645.           int pos = 0;
  1646.           int cell_org = actCell;
  1647.           int cell = 0;
  1648.           do{
  1649.               if (pos && (cursor.par->IsNewline(pos-1))){
  1650.                   if (cursor.par->table->AppendCellAfterCell(cell_org, cell)){
  1651.                       cursor.par->InsertChar(pos, LYX_META_NEWLINE);
  1652.                       if (pos<=cursor.pos)
  1653.                           cursor.pos++;
  1654.                       pos++;
  1655.                   }
  1656.                   cell++;
  1657.               }
  1658.               pos++;
  1659.           } while (pos<= cursor.par->Last());
  1660.           /* remember that the very last cell doesn't end with a newline.
  1661.              This saves one byte memory per table ;-) */ 
  1662.           if (cursor.par->table->AppendCellAfterCell(cell_org, cell))
  1663.               cursor.par->InsertChar(cursor.par->Last(), LYX_META_NEWLINE);
  1664.         
  1665.           /* append the column into the table */ 
  1666.           cursor.par->table->AppendColumn(cell_org);
  1667.         
  1668.           RedoParagraph();
  1669.           return;
  1670.       }
  1671.       case LyXTable::DELETE_ROW:
  1672.           RemoveTableRow(&cursor);
  1673.           RedoParagraph();
  1674.           return;
  1675.     
  1676.       case LyXTable::DELETE_COLUMN: {
  1677.           int pos = 0;
  1678.           int cell_org = actCell;
  1679.           int cell = 0;
  1680.           do{
  1681.               if (!pos || (cursor.par->IsNewline(pos-1))){
  1682.                   if (cursor.par->table->DeleteCellIfColumnIsDeleted(cell, cell_org)){
  1683.                       // delete one cell
  1684.                       while (pos < cursor.par->Last() && !cursor.par->IsNewline(pos))
  1685.                           cursor.par->Erase(pos);
  1686.                       if (pos < cursor.par->Last())
  1687.                           cursor.par->Erase(pos);
  1688.                       else 
  1689.                           cursor.par->Erase(pos - 1); // the missing newline at the end of a table
  1690.                       pos--; // because of pos++ below
  1691.                   }   
  1692.                   cell++;
  1693.               }
  1694.               pos++;
  1695.           } while (pos<= cursor.par->Last());
  1696.         
  1697.           /* delete the column from the table */ 
  1698.           cursor.par->table->DeleteColumn(cell_org);
  1699.         
  1700.           /* set the cursor to the beginning of the table, where else? */ 
  1701.           cursor.pos = 0;
  1702.           RedoParagraph();
  1703.           return;
  1704.       }
  1705.       case LyXTable::TOGGLE_LINE_TOP:
  1706.           lineSet = !cursor.par->table->TopLine(actCell);
  1707.           if (!selection){
  1708.               cursor.par->table->SetTopLine(actCell,lineSet);
  1709.           } else {
  1710.               int i,n=-1,m=-2;
  1711.               for (i=sel_start_cursor.pos; i<=sel_end_cursor.pos; i++){
  1712.                   if ((n=NumberOfCell(sel_start_cursor.par,i)) != m) {
  1713.                       cursor.par->table->SetTopLine(n,lineSet);
  1714.                       m = n;
  1715.                   }
  1716.               }
  1717.           }
  1718.           RedoParagraph();
  1719.           return;
  1720.     
  1721.       case LyXTable::TOGGLE_LINE_BOTTOM:
  1722.           lineSet = !cursor.par->table->BottomLine(actCell);
  1723.           if (!selection){
  1724.               cursor.par->table->SetBottomLine(actCell,lineSet);
  1725.           } else {
  1726.               int i,n=-1,m=-2;
  1727.               for (i=sel_start_cursor.pos; i<=sel_end_cursor.pos; i++){
  1728.                   if ((n=NumberOfCell(sel_start_cursor.par,i)) != m) {
  1729.                       cursor.par->table->SetBottomLine(n,lineSet);
  1730.                       m = n;
  1731.                   }
  1732.               }
  1733.           }
  1734.           RedoParagraph();
  1735.           return;
  1736.         
  1737.       case LyXTable::TOGGLE_LINE_LEFT:
  1738.           lineSet = !cursor.par->table->LeftLine(actCell);
  1739.           if (!selection){
  1740.               cursor.par->table->SetLeftLine(actCell,lineSet);
  1741.           } else {
  1742.               int i,n=-1,m=-2;
  1743.               for (i=sel_start_cursor.pos; i<=sel_end_cursor.pos; i++){
  1744.                   if ((n=NumberOfCell(sel_start_cursor.par,i)) != m) {
  1745.                       cursor.par->table->SetLeftLine(n,lineSet);
  1746.                       m = n;
  1747.                   }
  1748.               }
  1749.           }
  1750.           RedoParagraph();
  1751.           return;
  1752.  
  1753.       case LyXTable::TOGGLE_LINE_RIGHT:
  1754.           lineSet = !cursor.par->table->RightLine(actCell);
  1755.           if (!selection){
  1756.               cursor.par->table->SetRightLine(actCell,lineSet);
  1757.           } else {
  1758.               int i,n=-1,m=-2;
  1759.               for (i=sel_start_cursor.pos; i<=sel_end_cursor.pos; i++){
  1760.                   if ((n=NumberOfCell(sel_start_cursor.par,i)) != m) {
  1761.                       cursor.par->table->SetRightLine(n,lineSet);
  1762.                       m = n;
  1763.                   }
  1764.               }
  1765.           }
  1766.           RedoParagraph();
  1767.           return;
  1768.     
  1769.       case LyXTable::ALIGN_LEFT:
  1770.       case LyXTable::ALIGN_RIGHT:
  1771.       case LyXTable::ALIGN_CENTER:
  1772.           if (!selection){
  1773.               cursor.par->table->SetAlignment(actCell,setAlign);
  1774.           } else {
  1775.               int i,n=-1,m=-2;
  1776.               for (i=sel_start_cursor.pos; i<=sel_end_cursor.pos; i++){
  1777.                   if ((n=NumberOfCell(sel_start_cursor.par,i)) != m) {
  1778.                       cursor.par->table->SetAlignment(n,setAlign);
  1779.                       m = n;
  1780.                   }
  1781.               }
  1782.           }
  1783.           RedoParagraph();
  1784.           return;
  1785.         
  1786.       case LyXTable::DELETE_TABLE:
  1787.           SetCursorIntern(cursor.par, 0);
  1788.           delete cursor.par->table;
  1789.           cursor.par->table = NULL;
  1790.           // temporary: Should put table in simple_cut_buffer (with before and after
  1791.           // dummy-paragraph !! 
  1792.           // not necessar anymore with UNDO :)
  1793.           int i;
  1794.           for (i = cursor.par->last-1; i>=0; i--)
  1795.           cursor.par->Erase(i);
  1796.           RedoParagraph();
  1797.           return;
  1798.         
  1799.       case LyXTable::MULTICOLUMN: {
  1800.           int number = 0;
  1801.           // check wether we are completly in a multicol
  1802.           int multicol = cursor.par->table->IsMultiColumn(actCell);
  1803.           if (multicol && selection && sel_start_cursor.row == sel_end_cursor.row){
  1804.           multicol = NumberOfCell(sel_start_cursor.par, sel_start_cursor.pos)
  1805.                   == NumberOfCell(sel_end_cursor.par, sel_end_cursor.pos);
  1806.           }
  1807.  
  1808.           if (multicol){
  1809.           int newlines = cursor.par->table->UnsetMultiColumn(actCell);
  1810.           int pos = cursor.pos;
  1811.           while (pos<cursor.par->Last() && !cursor.par->IsNewline(pos))
  1812.                   pos++;
  1813.           for (;newlines;newlines--)
  1814.                   cursor.par->InsertChar(pos, LYX_META_NEWLINE);
  1815.           RedoParagraph();
  1816.           return;
  1817.           }
  1818.           else {
  1819.           // selection must be in one row (or no selection)
  1820.           if (!selection){
  1821.                   cursor.par->table->SetMultiColumn(NumberOfCell(cursor.par,
  1822.                                                                  cursor.pos),
  1823.                                                     1);
  1824.                   RedoParagraph();
  1825.                   return;
  1826.           }
  1827.           else {
  1828.                   if (sel_start_cursor.row == sel_end_cursor.row){
  1829.                       int i;
  1830.                       number = 1;
  1831.                       for (i=sel_start_cursor.pos; i<sel_end_cursor.pos; i++){
  1832.                           if (sel_start_cursor.par->IsNewline(i)){
  1833.                               sel_start_cursor.par->Erase(i);
  1834.                               // check for double-blanks
  1835.                               if ((i && !sel_start_cursor.par->IsLineSeparator(i-1))
  1836.                                   &&
  1837.                                   (i<sel_start_cursor.par->Last() 
  1838.                                    && !sel_start_cursor.par->IsLineSeparator(i)))
  1839.                                   sel_start_cursor.par->InsertChar(i, ' ');
  1840.                               else {
  1841.                                   sel_end_cursor.pos--;
  1842.                                   i--;
  1843.                               }
  1844.                               number++;
  1845.                           }
  1846.                       }
  1847.                       cursor.par->table->
  1848.               SetMultiColumn(NumberOfCell(sel_start_cursor.par,
  1849.                               sel_start_cursor.pos),
  1850.                      number);
  1851.                       cursor.pos = sel_start_cursor.pos;
  1852.                       RedoParagraph();
  1853.                       return;
  1854.                   }
  1855.                   else {
  1856.                       WriteAlert(_("Impossible Operation!"), 
  1857.                                  _("Multicolumns can only be horizontally."), 
  1858.                                  _("Sorry."));
  1859.                   }
  1860.           }
  1861.           }
  1862.       break;
  1863.       }
  1864.       case LyXTable::SET_ALL_LINES:
  1865.           setLines = 1;
  1866.       case LyXTable::UNSET_ALL_LINES:
  1867.           if (!selection){
  1868.               cursor.par->table->SetAllLines(NumberOfCell(cursor.par,
  1869.                                                           cursor.pos),
  1870.                                              setLines);
  1871.           } else {
  1872.               int i,n=-1,m=-2;
  1873.               for (i=sel_start_cursor.pos; i<=sel_end_cursor.pos; i++){
  1874.                   if ((n=NumberOfCell(sel_start_cursor.par,i)) != m) {
  1875.                       cursor.par->table->SetAllLines(n,setLines);
  1876.                       m = n;
  1877.                   }
  1878.               }
  1879.           }
  1880.           RedoParagraph();
  1881.           return;
  1882.       case LyXTable::SET_LONGTABLE:
  1883.           cursor.par->table->SetLongTable(true);
  1884.           return;
  1885.       case LyXTable::UNSET_LONGTABLE:
  1886.           cursor.par->table->SetLongTable(false);
  1887.           return;
  1888.       case LyXTable::SET_ROTATE_TABLE:
  1889.           cursor.par->table->SetRotateTable(true);
  1890.           return;
  1891.       case LyXTable::UNSET_ROTATE_TABLE:
  1892.           cursor.par->table->SetRotateTable(false);
  1893.           return;
  1894.       case LyXTable::SET_ROTATE_CELL:
  1895.           if (!selection){
  1896.               cursor.par->table->SetRotateCell(actCell,true);
  1897.           } else {
  1898.               int i,n=-1,m=-2;
  1899.               for (i=sel_start_cursor.pos; i<=sel_end_cursor.pos; i++){
  1900.                   if ((n=NumberOfCell(sel_start_cursor.par,i)) != m) {
  1901.                       cursor.par->table->SetRotateCell(n,true);
  1902.                       m = n;
  1903.                   }
  1904.               }
  1905.           }
  1906.           return;
  1907.       case LyXTable::UNSET_ROTATE_CELL:
  1908.           if (!selection){
  1909.               cursor.par->table->SetRotateCell(actCell,false);
  1910.           } else {
  1911.               int i,n=-1,m=-2;
  1912.               for (i=sel_start_cursor.pos; i<=sel_end_cursor.pos; i++){
  1913.                   if ((n=NumberOfCell(sel_start_cursor.par,i)) != m) {
  1914.                       cursor.par->table->SetRotateCell(n,false);
  1915.                       m = n;
  1916.                   }
  1917.               }
  1918.           }
  1919.           return;
  1920.       case LyXTable::SET_LINEBREAKS:
  1921.           what = !cursor.par->table->Linebreaks(cursor.par->table->FirstVirtualCell(actCell));
  1922.           if (!selection){
  1923.               cursor.par->table->SetLinebreaks(actCell,what);
  1924.           } else {
  1925.               int i,n=-1,m=-2;
  1926.               for (i=sel_start_cursor.pos; i<=sel_end_cursor.pos; i++){
  1927.                   if ((n=NumberOfCell(sel_start_cursor.par,i)) != m) {
  1928.                       cursor.par->table->SetLinebreaks(n,what);
  1929.                       m = n;
  1930.                   }
  1931.               }
  1932.           }
  1933.           return;
  1934.       case LyXTable::SET_LTFIRSTHEAD:
  1935.           cursor.par->table->SetLTHead(actCell,true);
  1936.           return;
  1937.       case LyXTable::SET_LTHEAD:
  1938.           cursor.par->table->SetLTHead(actCell,false);
  1939.           return;
  1940.       case LyXTable::SET_LTFOOT:
  1941.           cursor.par->table->SetLTFoot(actCell,false);
  1942.           return;
  1943.       case LyXTable::SET_LTLASTFOOT:
  1944.           cursor.par->table->SetLTFoot(actCell,true);
  1945.           return;
  1946.       case LyXTable::SET_LTNEWPAGE:
  1947.           what = !cursor.par->table->LTNewPage(actCell);
  1948.           cursor.par->table->SetLTNewPage(actCell,what);
  1949.           return;
  1950.     }
  1951. }
  1952.     
  1953.  
  1954. void LyXText::InsertCharInTable(char c)
  1955. {
  1956.     Row *row;
  1957.     Row *tmprow;
  1958.     long y;
  1959.     bool jumped_over_space;
  1960.     
  1961.     /* first check, if there will be two blanks together or a blank at 
  1962.      * the beginning of a paragraph. 
  1963.      * I decided to handle blanks like normal characters, the main 
  1964.      * difference are the special checks when calculating the row.fill
  1965.      * (blank does not count at the end of a row) and the check here */ 
  1966.     
  1967.     LyXFont realtmpfont = real_current_font;
  1968.     LyXFont rawtmpfont = current_font; /* store the current font.
  1969.                         * This is because of the use
  1970.                         * of cursor movements. The moving
  1971.                         * cursor would refresh the 
  1972.                         * current font */
  1973.  
  1974.     // Get the font that is used to calculate the baselineskip
  1975.     int const lastpos = cursor.par->Last();
  1976.     LyXFont rawparfont = cursor.par->GetFontSettings(lastpos - 1);
  1977.  
  1978.     jumped_over_space = false;
  1979.     if (IsLineSeparatorChar(c)) {
  1980.         
  1981.         /* avoid double blanks but insert the new blank because
  1982.          * of a possible font change */
  1983.         if (cursor.pos < lastpos &&
  1984.             cursor.par->IsLineSeparator(cursor.pos))
  1985.         {
  1986.             cursor.par->Erase(cursor.pos);
  1987.             jumped_over_space = true;
  1988.         }
  1989.         else if ((cursor.pos > 0 && 
  1990.               cursor.par->IsLineSeparator(cursor.pos - 1))
  1991.              || (cursor.pos > 0 && cursor.par->IsNewline(cursor.pos - 1))
  1992.               || (cursor.pos == 0 &&
  1993.                   !(cursor.par->Previous()
  1994.                   && cursor.par->Previous()->footnoteflag
  1995.                   == LyXParagraph::OPEN_FOOTNOTE)))
  1996.             return;
  1997.     }
  1998.     else if (IsNewlineChar(c)) {
  1999.             if (!IsEmptyTableCell()) {
  2000.                 TableFeatures(LyXTable::APPEND_CONT_ROW);
  2001.                 CursorDown();
  2002.             }
  2003.       /* the newline character is the separator of the cells */
  2004.       // cursor.par->InsertChar(cursor.pos, c);
  2005.       // SetCharFont(cursor.par, cursor.pos, rawtmpfont);
  2006.       // RedoParagraphs(cursor, cursor.par->Next());
  2007.       // SetCursor(cursor.par, cursor.pos+1);
  2008.       return;
  2009.     }
  2010.    
  2011.     row = cursor.row;
  2012.     y = cursor.y - row->baseline;
  2013.     if (c != LYX_META_INSET)    /* in this case LyXText::InsertInset 
  2014.                      * already inserted the character */
  2015.         cursor.par->InsertChar(cursor.pos, c);
  2016.     SetCharFont(cursor.par, cursor.pos, rawtmpfont);
  2017.  
  2018.     if (!jumped_over_space) {
  2019.         /* refresh the positions */
  2020.         tmprow = row;
  2021.         while (tmprow->next && tmprow->next->par == row->par) {
  2022.             tmprow = tmprow->next;
  2023.             tmprow->pos++;
  2024.         }
  2025.     }
  2026.  
  2027.     cursor.pos++;
  2028.  
  2029.     CheckParagraphInTable(cursor.par, cursor.pos);
  2030.     
  2031.     current_font = rawtmpfont;
  2032.     real_current_font = realtmpfont;
  2033.     
  2034.     /* check, whether the last character's font has changed. */
  2035.     if (cursor.pos && cursor.pos == cursor.par->Last()
  2036.         && rawparfont != rawtmpfont)
  2037.         RedoHeightOfParagraph(cursor);
  2038. }
  2039.  
  2040.  
  2041. void LyXText::CheckParagraphInTable(LyXParagraph* par, int pos)
  2042. {
  2043.     Row *row;
  2044.     long y;
  2045.     
  2046.     if (par->GetChar(pos) == LYX_META_INSET &&
  2047.         par->GetInset(pos) && par->GetInset(pos)->Display()){
  2048.       par->GetInset(pos)->SetDisplay(false);
  2049.     }
  2050.  
  2051.     row = GetRow(par, pos, y);
  2052.     
  2053.     int tmpheight = row->height;
  2054.     SetHeightOfRow(row);
  2055.     
  2056.     int tmp_pos = pos;
  2057.     /* update the table information */
  2058.     while (tmp_pos && !par->IsNewline(tmp_pos - 1))
  2059.         tmp_pos--;
  2060.     if (par->table->SetWidthOfCell(NumberOfCell(par, pos),
  2061.                        WidthOfCell(par, tmp_pos))) {
  2062.         LyXCursor tmpcursor = cursor;
  2063.         SetCursorIntern(par, pos);
  2064.         /* make a complete redraw */
  2065.         RedoDrawingOfParagraph(cursor);
  2066.         cursor = tmpcursor;
  2067.     }
  2068.     else {
  2069.         /* redraw only the row */
  2070.         LyXCursor tmpcursor = cursor;
  2071.         SetCursorIntern(par, pos);
  2072.         refresh_y = y;
  2073.         refresh_x = cursor.x;
  2074.         refresh_row = row;
  2075.         refresh_pos = cursor.pos;
  2076.         cursor = tmpcursor;
  2077.         
  2078.         if (tmpheight == row->height)
  2079.             status = LyXText::NEED_VERY_LITTLE_REFRESH;
  2080.         else
  2081.             status = LyXText::NEED_MORE_REFRESH;
  2082.     }
  2083.         SetCursorIntern(cursor.par, cursor.pos);
  2084. }
  2085.  
  2086.  
  2087. void LyXText::BackspaceInTable()
  2088. {
  2089.     Row *tmprow, *row;
  2090.     long y;
  2091.     
  2092.     LyXFont rawtmpfont = current_font;
  2093.     LyXFont realtmpfont = real_current_font;
  2094.  
  2095.     // Get the font that is used to calculate the baselineskip
  2096.     int const lastpos = cursor.par->Last();
  2097.     LyXFont rawparfont = cursor.par->GetFontSettings(lastpos - 1);
  2098.     
  2099.     if (cursor.pos == 0) {
  2100.         /* no pasting of table paragraphs */
  2101.         
  2102.         CursorLeft();
  2103.     }
  2104.     else {
  2105.         /* this is the code for a normal backspace, not pasting
  2106.          * any paragraphs */ 
  2107.       SetUndo(Undo::DELETE, 
  2108.           cursor.par->ParFromPos(cursor.pos)->previous, 
  2109.           cursor.par->ParFromPos(cursor.pos)->next); 
  2110.       
  2111.         CursorLeftIntern();
  2112.         
  2113.         /* some insets are undeletable here */
  2114.         if (cursor.par->GetChar(cursor.pos)==LYX_META_INSET) {
  2115.             if (!cursor.par->GetInset(cursor.pos)->Deletable())
  2116.                 return;
  2117.         }
  2118.         
  2119.         row = cursor.row;
  2120.         y = cursor.y - row->baseline;
  2121.         
  2122.         /* some special code when deleting a newline. */
  2123.         if (cursor.par->IsNewline(cursor.pos)) {
  2124.             /* nothing :-) */
  2125.             return;
  2126.         }
  2127.         else {
  2128.             cursor.par->Erase(cursor.pos);
  2129.             
  2130.             /* refresh the positions */
  2131.             tmprow = row;
  2132.             while (tmprow->next && tmprow->next->par == row->par) {
  2133.                 tmprow = tmprow->next;
  2134.                 tmprow->pos--;
  2135.             }
  2136.             
  2137.             /* delete superfluous blanks */ 
  2138.             if (cursor.pos < cursor.par->Last() - 1 &&
  2139.             (cursor.par->IsLineSeparator(cursor.pos))) {
  2140.                 
  2141.                 if (cursor.pos == BeginningOfMainBody(cursor.par)
  2142.                 || !cursor.pos 
  2143.                 || cursor.par->IsLineSeparator(cursor.pos - 1)) {
  2144.                     cursor.par->Erase(cursor.pos);
  2145.                     /* refresh the positions */
  2146.                     tmprow = row;
  2147.                     while (tmprow->next && 
  2148.                            tmprow->next->par == row->par) {
  2149.                         tmprow = tmprow->next;
  2150.                         tmprow->pos--;
  2151.                     }
  2152.                     if (cursor.pos)   /* move one character left */
  2153.                         cursor.pos--;
  2154.                 }
  2155.             }
  2156.         }
  2157.       
  2158.         CheckParagraphInTable(cursor.par, cursor.pos);
  2159.       
  2160.         /* check, wether the last characters font has changed. */ 
  2161.         if (cursor.pos && cursor.pos == cursor.par->Last()
  2162.             && rawparfont != rawtmpfont)
  2163.             RedoHeightOfParagraph(cursor);
  2164.  
  2165.         /* restore the current font 
  2166.          * That is what a user expects! */
  2167.         current_font = rawtmpfont;
  2168.         real_current_font = realtmpfont;
  2169.     }
  2170.     SetCursorIntern(cursor.par, cursor.pos);
  2171. }
  2172.  
  2173. /* table stuff -- end*/
  2174.  
  2175.  
  2176. /* just a macro to make some thing easier. */ 
  2177. void LyXText::RedoParagraph()
  2178. {
  2179.   LyXCursor tmpcursor = cursor;
  2180.   ClearSelection();
  2181.   RedoParagraphs(cursor, cursor.par->Next());;
  2182.   SetCursorIntern(tmpcursor.par, tmpcursor.pos);
  2183. }
  2184.  
  2185.  
  2186. /* insert a character, moves all the following breaks in the 
  2187.  * same Paragraph one to the right and make a rebreak */
  2188. void  LyXText::InsertChar(char c)
  2189. {
  2190.     Row *row;
  2191.     Row *tmprow;
  2192.     int z;
  2193.     long y;
  2194.     bool jumped_over_space;
  2195.     LyXFont realtmpfont;
  2196.     LyXFont rawtmpfont;
  2197.     int lastpos;
  2198.     LyXFont rawparfont;
  2199.    
  2200.     SetUndo(Undo::INSERT, 
  2201.         cursor.par->ParFromPos(cursor.pos)->previous, 
  2202.         cursor.par->ParFromPos(cursor.pos)->next);
  2203.  
  2204.     /* When the free-spacing option is set for the current layout,
  2205.      * all spaces are converted to protected spaces. */
  2206.     bool freeSpacingBo =
  2207.         lyxstyle.Style(parameters->textclass,
  2208.                    cursor.row->par->GetLayout())->free_spacing;
  2209.     //
  2210.     // Is this wanted? There cannot be a line break between protected
  2211.     // separators. Therefore I suggest the way implemented below
  2212.     // (Matthias)
  2213.     //
  2214.     //   if ( freeSpacingBo && IsLineSeparatorChar(c) )
  2215.     //       c = LYX_META_PROTECTED_SEPARATOR;
  2216.    
  2217.     if (freeSpacingBo && IsLineSeparatorChar(c) 
  2218.         && (!cursor.pos || cursor.par->IsLineSeparator(cursor.pos-1))) 
  2219.         c = LYX_META_PROTECTED_SEPARATOR;
  2220.    
  2221.     /* table stuff -- begin*/
  2222.       if (cursor.par->table) {
  2223.         InsertCharInTable(c);
  2224.         goto out;
  2225.     }
  2226.     /* table stuff -- end*/
  2227.    
  2228.     /* first check, if there will be two blanks together or a blank at 
  2229.      * the beginning of a paragraph. 
  2230.      * I decided to handle blanks like normal characters, the main 
  2231.      * difference are the special checks when calculating the row.fill
  2232.      * (blank does not count at the end of a row) and the check here */ 
  2233.  
  2234.     realtmpfont = real_current_font;
  2235.     rawtmpfont = current_font;  /* store the current font.
  2236.                      * This is because of the use
  2237.                      * of cursor movements. The moving
  2238.                      * cursor would refresh the 
  2239.                      * current font */
  2240.  
  2241.     // Get the font that is used to calculate the baselineskip
  2242.     lastpos = cursor.par->Last();
  2243.     rawparfont = cursor.par->GetFontSettings(lastpos - 1);
  2244.  
  2245.     jumped_over_space = false;
  2246.    
  2247.     if (IsLineSeparatorChar(c)) {
  2248.        
  2249.         if (cursor.pos < lastpos
  2250.             && cursor.par->IsLineSeparator(cursor.pos)) {
  2251.             /* the user inserted a space before a space. So we
  2252.              * will just make a CursorRight. BUT: The font of this
  2253.              * space should be set to current font. That is why
  2254.              * we need to rebreak perhaps. If there is a protected
  2255.              * blank at the end of a row we have to force
  2256.              * a rebreak.*/ 
  2257.        
  2258.             if (cursor.pos == RowLast(cursor.row)
  2259.                 && !IsLineSeparatorChar(c))
  2260.                 cursor.row->fill = -1;    /* force rebreak  */
  2261.        
  2262.             cursor.par->Erase(cursor.pos);
  2263.             jumped_over_space = true;
  2264.        
  2265.         } else if ((cursor.pos > 0 
  2266.                 && cursor.par->IsLineSeparator(cursor.pos - 1))
  2267.                || (cursor.pos > 0
  2268.                    && cursor.par->IsNewline(cursor.pos - 1))
  2269.                || (cursor.pos == 0
  2270.                    && !(cursor.par->Previous()
  2271.                     && cursor.par->Previous()->footnoteflag
  2272.                     == LyXParagraph::OPEN_FOOTNOTE)))
  2273.             goto out;
  2274.     } else if (IsNewlineChar(c)) {
  2275.         if (cursor.par->FirstPhysicalPar() == cursor.par
  2276.             && cursor.pos <= BeginningOfMainBody(cursor.par))
  2277.             goto out;
  2278.         /* no newline at first position 
  2279.          * of a paragraph or behind labels. 
  2280.          * TeX does not allow that. */
  2281.         
  2282.         if (cursor.pos < cursor.par->Last() &&
  2283.             cursor.par->IsLineSeparator(cursor.pos))
  2284.             CursorRightIntern(); // newline always after a blank!
  2285.         cursor.row->fill = -1;           // to force a new break
  2286.     }
  2287.    
  2288.     /* the display inset stuff */ 
  2289.     if (cursor.row->par->GetChar(cursor.row->pos) == LYX_META_INSET
  2290.         && cursor.row->par->GetInset(cursor.row->pos)
  2291.         && cursor.row->par->GetInset(cursor.row->pos)->Display())
  2292.         cursor.row->fill = -1; // to force a new break  
  2293.  
  2294.     /* get the cursor row fist */
  2295.     /* this is a dumb solution, i will try to hold the cursor.row
  2296.        in future */ 
  2297.     /* row = GetRow(cursor.par, cursor.pos, y);*/
  2298.     /* ok, heres a better way: */ 
  2299.     row = cursor.row;
  2300.     y = cursor.y - row->baseline;
  2301.     if (c != LYX_META_INSET)  /* in this case LyXText::InsertInset 
  2302.                    * already insertet the character */
  2303.         cursor.par->InsertChar(cursor.pos, c);
  2304.     SetCharFont(cursor.par, cursor.pos, rawtmpfont);
  2305.  
  2306.     if (!jumped_over_space) {
  2307.         /* refresh the positions */
  2308.         tmprow = row;
  2309.         while (tmprow->next && tmprow->next->par == row->par) {
  2310.             tmprow = tmprow->next;
  2311.             tmprow->pos++;
  2312.         }
  2313.     }
  2314.    
  2315.     /* Is there a break one row above */ 
  2316.     if ((cursor.par->IsLineSeparator(cursor.pos)
  2317.          || cursor.par->IsNewline(cursor.pos)
  2318.          || cursor.row->fill == -1)
  2319.         && row->previous && row->previous->par == row->par) {
  2320.         z = NextBreakPoint(row->previous, paperwidth);
  2321.         if ( z >= row->pos) {
  2322.             row->pos = z + 1;
  2323.             
  2324.             /* set the dimensions of the row above  */ 
  2325.             row->previous->fill = Fill(row->previous, paperwidth);
  2326.  
  2327.             SetHeightOfRow(row->previous);
  2328.          
  2329.             y -= row->previous->height;
  2330.             refresh_y = y;
  2331.             refresh_row = row->previous;
  2332.             status = LyXText::NEED_MORE_REFRESH;
  2333.          
  2334.             BreakAgainOneRow(row);
  2335.             SetCursor(cursor.par, cursor.pos + 1);
  2336.             /* cursor MUST be in row now */
  2337.          
  2338.             if (row->next && row->next->par == row->par)
  2339.                 need_break_row = row->next;
  2340.             else
  2341.                 need_break_row = NULL;
  2342.  
  2343.             current_font = rawtmpfont;
  2344.             real_current_font = realtmpfont;
  2345.          
  2346.             // check, wether the last characters font has changed. 
  2347.             if (cursor.pos && cursor.pos == cursor.par->Last()
  2348.                 && rawparfont != rawtmpfont)
  2349.                 RedoHeightOfParagraph(cursor);
  2350.             
  2351.             goto out;
  2352.         }
  2353.     }
  2354.    
  2355.     /* recalculate the fill of the row */ 
  2356.     if (row->fill >= 0)  /* needed because a newline
  2357.                   * will set fill to -1. Otherwise
  2358.                   * we would not get a rebreak! */
  2359.         row->fill = Fill(row, paperwidth);
  2360.     if (row->fill < 0 ) {
  2361.         refresh_y = y;
  2362.         refresh_row = row; 
  2363.         refresh_x = cursor.x;
  2364.         refresh_pos = cursor.pos;
  2365.         status = LyXText::NEED_MORE_REFRESH;
  2366.         BreakAgainOneRow(row); 
  2367.         /* will the cursor be in another row now? */ 
  2368.         if (RowLast(row) <= cursor.pos + 1 && row->next) {
  2369.             if (row->next && row->next->par == row->par)
  2370.                 /* this should
  2371.                  * always be true */
  2372.                 row = row->next;
  2373.             BreakAgainOneRow(row);
  2374.         }
  2375.         SetCursor(cursor.par, cursor.pos + 1);
  2376.         if (row->next && row->next->par == row->par)
  2377.             need_break_row = row->next;
  2378.         else
  2379.             need_break_row = NULL;
  2380.         
  2381.         current_font = rawtmpfont;
  2382.         real_current_font = realtmpfont;
  2383.     } else {
  2384.         refresh_y = y;
  2385.         refresh_x = cursor.x;
  2386.         refresh_row = row;
  2387.         refresh_pos = cursor.pos;
  2388.         
  2389.         int tmpheight = row->height;
  2390.         SetHeightOfRow(row);
  2391.         if (tmpheight == row->height)
  2392.             status = LyXText::NEED_VERY_LITTLE_REFRESH;
  2393.         else
  2394.             status = LyXText::NEED_MORE_REFRESH;
  2395.             
  2396.         SetCursor(cursor.par, cursor.pos + 1);
  2397.         current_font = rawtmpfont;
  2398.         real_current_font = realtmpfont;
  2399.     }
  2400.  
  2401.     /* check, wether the last characters font has changed. */ 
  2402.     if (cursor.pos && cursor.pos == cursor.par->Last()
  2403.         && rawparfont != rawtmpfont) {
  2404.         RedoHeightOfParagraph(cursor);
  2405.     } else {
  2406.         /* now the special right address boxes */
  2407.         if (lyxstyle.Style(parameters->textclass,
  2408.                    cursor.par->GetLayout())->margintype
  2409.             == MARGIN_RIGHT_ADDRESS_BOX) {
  2410.             RedoDrawingOfParagraph(cursor); 
  2411.         }
  2412.     }
  2413.   out:
  2414.     // Here we could call FinishUndo for every 20 characters inserted.
  2415.     // This is from my experience how emacs does it.
  2416.     static unsigned short counter = 0;
  2417.     if (counter < 20) {
  2418.         ++counter;
  2419.     } else {
  2420.         FinishUndo();
  2421.         counter = 0;
  2422.     }
  2423.     return;
  2424. }
  2425.    
  2426.    
  2427. void LyXText::PrepareToPrint(Row *row, float &x, float &fill_separator, 
  2428.                  float &fill_hfill, float &fill_label_hfill)
  2429. {
  2430.     float w, nh, nlh, ns;
  2431.     
  2432.     w = row->fill;
  2433.     fill_hfill = 0;
  2434.     fill_label_hfill = 0;
  2435.     fill_separator = 0;
  2436.     fill_label_hfill = 0;
  2437.     
  2438.     x = LeftMargin(row);
  2439.     
  2440.     /* is there a manual margin with a manual label */ 
  2441.     if (lyxstyle.Style(parameters->textclass,
  2442.                row->par->GetLayout())->margintype == MARGIN_MANUAL
  2443.         && lyxstyle.Style(parameters->textclass,
  2444.                   row->par->GetLayout())->labeltype == LABEL_MANUAL) {
  2445.            
  2446.         nlh = NumberOfLabelHfills(row) + 1; /* one more since labels 
  2447.                             * are left aligned*/ 
  2448.         if (nlh && !row->par->GetLabelWidthString().empty()) {
  2449.             fill_label_hfill = LabelFill(row) / nlh;
  2450.         }
  2451.     }
  2452.         
  2453.     /* are there any hfills in the row? */ 
  2454.     nh = NumberOfHfills(row);
  2455.     
  2456. /* table stuff -- begin*/
  2457.     if (row->par->table) {
  2458.        w = paperwidth - row->par->table->WidthOfTable()
  2459.        - x - RightMargin(row);
  2460.        nh = 0; /* ignore hfills in tables */ 
  2461.     }
  2462. /* table stuff -- end*/
  2463.  
  2464.     if (nh)
  2465.       fill_hfill = w /nh;
  2466.     else  {
  2467.        /* is it block, flushleft or flushright? 
  2468.         * set x how you need it */
  2469.        int align;
  2470.        if (row->par->FirstPhysicalPar()->align == LYX_ALIGN_LAYOUT)
  2471.          align = lyxstyle.Style(parameters->textclass, row->par->GetLayout())->align;
  2472.        else
  2473.          align = row->par->FirstPhysicalPar()->align;
  2474.        
  2475.        /* center displayed insets */ 
  2476.        if (row->par->GetChar(row->pos) == LYX_META_INSET
  2477.            && row->par->GetInset(row->pos)
  2478.            && row->par->GetInset(row->pos)->Display())
  2479.          align = LYX_ALIGN_CENTER;
  2480.  
  2481.        switch (align) {
  2482.         case LYX_ALIGN_BLOCK:
  2483.           ns = NumberOfSeparators(row);
  2484.           if (ns && row->next && row->next->par == row->par &&
  2485.           !(row->next->par->IsNewline(row->next->pos-1))
  2486.           && !(row->next->par->GetChar(row->next->pos) == LYX_META_INSET
  2487.                && row->next->par->GetInset(row->next->pos)
  2488.                && row->next->par->GetInset(row->next->pos)->Display())
  2489.           )
  2490.               fill_separator = w / ns;
  2491.           break;
  2492.         case LYX_ALIGN_RIGHT:
  2493.           x += w;
  2494.           break;
  2495.         case LYX_ALIGN_CENTER:
  2496.           x += w / 2;
  2497.           break;
  2498.        }
  2499.     }
  2500.      }
  2501.  
  2502.       
  2503. /* important for the screen */
  2504.  
  2505.  
  2506. /* the cursor set functions have a special mechanism. When they
  2507. * realize, that you left an empty paragraph, they will delete it.
  2508. * They also delet the corresponding row */
  2509.  
  2510.  
  2511. void LyXText::CursorRightOneWord()
  2512. {
  2513.     // treat floats, HFills and Insets as words
  2514.     LyXCursor tmpcursor = cursor;
  2515.  
  2516.     if (tmpcursor.pos == tmpcursor.par->Last()
  2517.         && tmpcursor.par->Next())
  2518.     {
  2519.             tmpcursor.par = tmpcursor.par->Next();
  2520.             tmpcursor.pos = 0;
  2521.     } else {
  2522.         int steps = 0;
  2523.         while (tmpcursor.pos < tmpcursor.par->Last()
  2524.                && !tmpcursor.par->IsSeparator(tmpcursor.pos)
  2525.                && !tmpcursor.par->IsKomma(tmpcursor.pos)
  2526.                && !tmpcursor.par->IsHfill(tmpcursor.pos)
  2527.                && !tmpcursor.par->IsFloat(tmpcursor.pos)
  2528.                && !tmpcursor.par->IsInset(tmpcursor.pos))
  2529.         {
  2530.             tmpcursor.pos++;
  2531.             steps++;
  2532.         }
  2533.         while (tmpcursor.pos < tmpcursor.par->Last()
  2534.                && (tmpcursor.par->IsSeparator(tmpcursor.pos)
  2535.                || tmpcursor.par->IsKomma(tmpcursor.pos)
  2536.                || tmpcursor.par->IsHfill(tmpcursor.pos)
  2537.                || tmpcursor.par->IsFloat(tmpcursor.pos)
  2538.                || tmpcursor.par->IsInset(tmpcursor.pos)))
  2539.         {
  2540.             if ((tmpcursor.par->IsInset(tmpcursor.pos)
  2541.                  || tmpcursor.par->IsFloat(tmpcursor.pos)
  2542.                  || tmpcursor.par->IsHfill(tmpcursor.pos))
  2543.                 && steps)
  2544.                 break;
  2545.             tmpcursor.pos++;
  2546.         }
  2547.     }
  2548.     SetCursor(tmpcursor.par, tmpcursor.pos);
  2549. }
  2550.  
  2551.  
  2552. void LyXText::CursorTab()
  2553. {
  2554.     if (cursor.par->table) {
  2555.         int cell = NumberOfCell(cursor.par, cursor.pos);
  2556.         while(cursor.par->table->IsContRow(cell)) {
  2557.             CursorUp();
  2558.             cell = NumberOfCell(cursor.par, cursor.pos);
  2559.         }
  2560.         if (cursor.par->table->ShouldBeVeryLastCell(cell))
  2561.             TableFeatures(LyXTable::APPEND_ROW);
  2562.     }
  2563.     LyXCursor tmpcursor = cursor;
  2564.     while (tmpcursor.pos < tmpcursor.par->Last()
  2565.            && !tmpcursor.par->IsNewline(tmpcursor.pos))
  2566.         tmpcursor.pos++;
  2567.    
  2568.     if (tmpcursor.pos == tmpcursor.par->Last()){
  2569.         if (tmpcursor.par->Next()) {
  2570.             tmpcursor.par = tmpcursor.par->Next();
  2571.             tmpcursor.pos = 0;
  2572.         }
  2573.     }
  2574.     else
  2575.         tmpcursor.pos++;
  2576.     SetCursor(tmpcursor.par, tmpcursor.pos);
  2577.     if (cursor.par->table) {
  2578.         int cell = NumberOfCell(cursor.par, cursor.pos);
  2579.         while (cursor.par->table->IsContRow(cell) &&
  2580.                !cursor.par->table->ShouldBeVeryLastCell(cell)) {
  2581.             tmpcursor = cursor;
  2582.             while (tmpcursor.pos < tmpcursor.par->Last()
  2583.                    && !tmpcursor.par->IsNewline(tmpcursor.pos))
  2584.                 tmpcursor.pos++;
  2585.    
  2586.             if (tmpcursor.pos == tmpcursor.par->Last()){
  2587.                 if (tmpcursor.par->Next()) {
  2588.                     tmpcursor.par = tmpcursor.par->Next();
  2589.                     tmpcursor.pos = 0;
  2590.                 }
  2591.             }
  2592.             else
  2593.                 tmpcursor.pos++;
  2594.             SetCursor(tmpcursor.par, tmpcursor.pos);
  2595.             cell = NumberOfCell(cursor.par, cursor.pos);
  2596.         }
  2597.     }
  2598. }
  2599.  
  2600.  
  2601. /* -------> Skip initial whitespace at end of word and move cursor to *start*
  2602.             of prior word, not to end of next prior word. */
  2603.  
  2604. void LyXText::CursorLeftOneWord() 
  2605. {
  2606.     // treat HFills, floats and Insets as words
  2607.     LyXCursor tmpcursor = cursor;
  2608.     while (tmpcursor.pos 
  2609.            && (tmpcursor.par->IsSeparator(tmpcursor.pos - 1) 
  2610.            || tmpcursor.par->IsKomma(tmpcursor.pos - 1))
  2611.            && !(tmpcursor.par->IsHfill(tmpcursor.pos - 1)
  2612.                 || tmpcursor.par->IsFloat(tmpcursor.pos - 1)
  2613.             || tmpcursor.par->IsInset(tmpcursor.pos - 1)))
  2614.         tmpcursor.pos--;
  2615.  
  2616.     if (tmpcursor.pos
  2617.         && (tmpcursor.par->IsInset(tmpcursor.pos - 1)
  2618.             || tmpcursor.par->IsFloat(tmpcursor.pos - 1)
  2619.         || tmpcursor.par->IsHfill(tmpcursor.pos - 1))) {
  2620.         tmpcursor.pos--;
  2621.     } else if (!tmpcursor.pos) {
  2622.         if (tmpcursor.par->Previous()){
  2623.             tmpcursor.par = tmpcursor.par->Previous();
  2624.             tmpcursor.pos = tmpcursor.par->Last();
  2625.         }
  2626.     } else {
  2627.         while (tmpcursor.pos > 0 
  2628.                && !tmpcursor.par->IsSeparator(tmpcursor.pos-1)
  2629.                && !tmpcursor.par->IsKomma(tmpcursor.pos-1)
  2630.                && !tmpcursor.par->IsHfill(tmpcursor.pos-1)
  2631.                && !tmpcursor.par->IsFloat(tmpcursor.pos-1)
  2632.                && !tmpcursor.par->IsInset(tmpcursor.pos-1))
  2633.             tmpcursor.pos--;
  2634.     }
  2635.     SetCursor(tmpcursor.par, tmpcursor.pos);
  2636. }
  2637.  
  2638. /* -------> Select current word. This depeds on behaviour of CursorLeftOneWord(), so it is
  2639.             patched as well. */
  2640.  
  2641. void LyXText::SelectWord() 
  2642. {
  2643.     /* Move cursor to the beginning, when not already there. */
  2644.     if ( cursor.pos
  2645.          && !cursor.par->IsSeparator(cursor.pos-1)
  2646.          && !cursor.par->IsKomma(cursor.pos-1) )
  2647.         CursorLeftOneWord();
  2648.  
  2649.     /* set the sel cursor */
  2650.     sel_cursor = cursor;
  2651.  
  2652.     while ( cursor.pos < cursor.par->Last()
  2653.             && !cursor.par->IsSeparator(cursor.pos)
  2654.             && !cursor.par->IsKomma(cursor.pos) )
  2655.         cursor.pos++;
  2656.     SetCursor( cursor.par, cursor.pos );
  2657.     
  2658.     /* finally set the selection */ 
  2659.     SetSelection();
  2660. }
  2661.  
  2662.  
  2663. /* -------> Select the word currently under the cursor when:
  2664.             1: no selection is currently set,
  2665.             2: the cursor is not at the borders of the word. */
  2666.  
  2667. int LyXText::SelectWordWhenUnderCursor() 
  2668. {
  2669.     if ( selection ) return 0;
  2670.     if ( cursor.pos < cursor.par->Last()
  2671.          && !cursor.par->IsSeparator(cursor.pos)
  2672.          && !cursor.par->IsKomma(cursor.pos)
  2673.          && cursor.pos 
  2674.          && !cursor.par->IsSeparator(cursor.pos -1)
  2675.          && !cursor.par->IsKomma(cursor.pos -1) ) {
  2676.         SelectWord();
  2677.         return 1;
  2678.     }
  2679.     return 0;
  2680. }
  2681.  
  2682.  
  2683. // This function is only used by the spellchecker for NextWord().
  2684. // It doesn't handle LYX_ACCENTs and probably never will.
  2685. char* LyXText::SelectNextWord(float &value)
  2686. {
  2687.     LyXParagraph* tmppar = cursor.par;
  2688.     
  2689.     // If this is not the very first word, skip rest of
  2690.     // current word because we are probably in the middle
  2691.     // of a word if there is text here.
  2692.     if (cursor.pos || cursor.par->previous) {
  2693.         while (cursor.pos < cursor.par->Last()
  2694.                && cursor.par->IsLetter(cursor.pos))
  2695.             cursor.pos++;
  2696.     }
  2697.     // Now, skip until we have real text (will jump paragraphs)
  2698.     while ((cursor.par->Last() > cursor.pos
  2699.         && !cursor.par->IsLetter(cursor.pos))
  2700.            || (cursor.par->Last() == cursor.pos
  2701.            && cursor.par->Next())){
  2702.         if (cursor.pos == cursor.par->Last()) {
  2703.             cursor.par = cursor.par->Next();
  2704.             cursor.pos = 0;
  2705.         }
  2706.         else
  2707.             cursor.pos++;
  2708.     }
  2709.   
  2710.     // Update the value if we changed paragraphs
  2711.     if (cursor.par != tmppar){
  2712.         SetCursor(cursor.par, cursor.pos);
  2713.         value = float(cursor.y)/float(height);
  2714.     }
  2715.  
  2716.     /* Start the selection from here */
  2717.     sel_cursor = cursor;
  2718.    
  2719.     /* and find the end of the word */
  2720.     while (cursor.pos < cursor.par->Last()
  2721.            && cursor.par->IsLetter(cursor.pos))
  2722.         cursor.pos++;
  2723.  
  2724.     // Finally, we copy the word to a string and return it
  2725.     char* string = NULL;
  2726.  
  2727.     if (sel_cursor.pos < cursor.pos) {
  2728.         string = new char [cursor.pos - sel_cursor.pos + 2];
  2729.         int i,j;
  2730.         
  2731.         for (i=sel_cursor.pos, j=0; i<cursor.pos; i++)
  2732.             string[j++] = cursor.par->GetChar(i);
  2733.         string[j] = '\0';
  2734.     }
  2735.     return string;
  2736. }
  2737.  
  2738.  
  2739. // This one is also only for the spellchecker
  2740. void LyXText::SelectSelectedWord()
  2741. {
  2742.     /* move cursor to the beginning */
  2743.     SetCursor(sel_cursor.par, sel_cursor.pos);
  2744.     
  2745.     /* set the sel cursor */
  2746.     sel_cursor = cursor;
  2747.     
  2748.     /* now find the end of the word */
  2749.     while (cursor.pos < cursor.par->Last()
  2750.            && cursor.par->IsLetter(cursor.pos))
  2751.         cursor.pos++;
  2752.     
  2753.     SetCursor(cursor.par, cursor.pos);
  2754.     
  2755.     /* finally set the selection */ 
  2756.     SetSelection();
  2757. }
  2758.  
  2759.  
  2760. /* -------> Delete from cursor up to the end of the current or next word. */
  2761. void LyXText::DeleteWordForward()
  2762. {
  2763.     LyXCursor tmpcursor = cursor;
  2764.         
  2765.     if (!cursor.par->Last())
  2766.         CursorRight();
  2767.     else {
  2768.         /* -------> Skip initial non-word stuff. */
  2769.         while ( cursor.pos < cursor.par->Last() 
  2770.             && (cursor.par->IsSeparator(cursor.pos)
  2771.                 || cursor.par->IsKomma(cursor.pos)) )
  2772.             cursor.pos++;
  2773.         
  2774.         SetCursorIntern(cursor.par, cursor.pos);
  2775.         selection = True; // to avoid deletion 
  2776.         CursorRightOneWord();
  2777.         sel_cursor = cursor;
  2778.         cursor = tmpcursor;
  2779.         SetSelection(); 
  2780.         
  2781.         /* -----> Great, CutSelection() gets rid of multiple spaces. */
  2782.         CutSelection();
  2783.     }
  2784. }
  2785.  
  2786.  
  2787. /* -------> Delete from cursor to start of current or prior word. */
  2788. void LyXText::DeleteWordBackward()
  2789. {
  2790.        LyXCursor tmpcursor = cursor;
  2791.        if (!cursor.par->Last())
  2792.          CursorLeft();
  2793.        else{
  2794.          selection = True; // to avoid deletion 
  2795.          CursorLeftOneWord();
  2796.          sel_cursor = cursor;
  2797.          cursor = tmpcursor;
  2798.          SetSelection();
  2799.          CutSelection();
  2800.        }
  2801. }
  2802.  
  2803.  
  2804. /* -------> Kill to end of line. */
  2805. void LyXText::DeleteLineForward()
  2806. {
  2807.     LyXCursor tmpcursor = cursor;
  2808.     if (!cursor.par->Last())
  2809.         CursorRight();
  2810.     else {
  2811.         CursorEnd();
  2812.         sel_cursor = cursor;
  2813.         cursor = tmpcursor;
  2814.         SetSelection();
  2815.         if (selection == false) {
  2816.             DeleteWordForward();
  2817.         } else {
  2818.             CutSelection();
  2819.         }
  2820.     }
  2821. }
  2822.  
  2823.  
  2824. /* -------> Upcase characters from cursor to end of word. */
  2825. void LyXText::UpcaseWord() 
  2826. {
  2827.   SetUndo(Undo::FINISH, 
  2828.       cursor.par->ParFromPos(cursor.pos)->previous,
  2829.       cursor.par->ParFromPos(cursor.pos)->next); 
  2830.  
  2831.     while (cursor.pos < cursor.par->Last()
  2832.     && !cursor.par->IsSeparator(cursor.pos) 
  2833.     && !cursor.par->IsKomma(cursor.pos) ) {
  2834.          if (cursor.par->GetChar(cursor.pos) != LYX_META_INSET)
  2835.             cursor.par->text[cursor.pos] =
  2836.                 toupper((unsigned char) cursor.par->text[cursor.pos]);
  2837.         CursorRight();
  2838.     }
  2839.     CheckParagraph(cursor.par, cursor.pos);
  2840.     CursorRightOneWord();
  2841. }
  2842.  
  2843.  
  2844. /* -------> Lowcase characters from cursor to end of word. */
  2845. void LyXText::LowcaseWord() 
  2846. {
  2847.   SetUndo(Undo::FINISH, 
  2848.       cursor.par->ParFromPos(cursor.pos)->previous,
  2849.       cursor.par->ParFromPos(cursor.pos)->next); 
  2850.  
  2851.     while ( cursor.pos < cursor.par->Last()
  2852.     && !cursor.par->IsSeparator(cursor.pos) 
  2853.     && !cursor.par->IsKomma(cursor.pos) ) {
  2854.          if (cursor.par->GetChar(cursor.pos) != LYX_META_INSET)
  2855.            cursor.par->text[cursor.pos] =
  2856.                tolower((unsigned char) cursor.par->text[cursor.pos]);
  2857.         CursorRight();
  2858.     }
  2859.     CheckParagraph(cursor.par, cursor.pos);
  2860.     CursorRightOneWord();
  2861. }
  2862.  
  2863.  
  2864. /* -------> Capitalize characters from cursor to end of word. */
  2865. void LyXText::CapitalizeWord() 
  2866. {
  2867.   SetUndo(Undo::FINISH, 
  2868.       cursor.par->ParFromPos(cursor.pos)->previous,
  2869.       cursor.par->ParFromPos(cursor.pos)->next); 
  2870.  
  2871.     bool firstBo = true;
  2872.     while ( cursor.pos < cursor.par->Last()
  2873.     && !cursor.par->IsSeparator(cursor.pos) 
  2874.     && !cursor.par->IsKomma(cursor.pos) ) {
  2875.         if ( firstBo ){
  2876.               if (cursor.par->GetChar(cursor.pos) != LYX_META_INSET)
  2877.                 cursor.par->text[cursor.pos]
  2878.                     = toupper((unsigned char) cursor.par->text[cursor.pos]);
  2879.         }
  2880.         else{
  2881.               if (cursor.par->GetChar(cursor.pos) != LYX_META_INSET)
  2882.                 cursor.par->text[cursor.pos]
  2883.                   = tolower((unsigned char) cursor.par->text[cursor.pos]);
  2884.          }
  2885.         firstBo = false;
  2886.         CursorRight();
  2887.     }
  2888.     CheckParagraph(cursor.par, cursor.pos);
  2889.     CursorRightOneWord();
  2890. }
  2891.  
  2892.  
  2893. void  LyXText::Delete()
  2894. {
  2895.    LyXCursor old_cursor = cursor;
  2896.    LyXCursor tmpcursor;
  2897.    /* this is a very easy implementation*/ 
  2898.    
  2899.    /* just move to the right */ 
  2900.    CursorRightIntern();
  2901.    
  2902.    if (cursor.par->previous == old_cursor.par->previous
  2903.        && cursor.par != old_cursor.par)
  2904.      return; // delete-emty-paragraph-mechanism has done it
  2905.    
  2906.    /* if you had success make a backspace */ 
  2907.    if (old_cursor.par != cursor.par || old_cursor.pos != cursor.pos) {
  2908.      tmpcursor = cursor;
  2909.      cursor = old_cursor; // to make sure undo gets the right cursor position
  2910.      SetUndo(Undo::DELETE, 
  2911.          cursor.par->ParFromPos(cursor.pos)->previous, 
  2912.          cursor.par->ParFromPos(cursor.pos)->next); 
  2913.      cursor = tmpcursor;
  2914.      Backspace();
  2915.    }
  2916. }
  2917.  
  2918.  
  2919. void  LyXText::Backspace()
  2920. {
  2921.     LyXParagraph *tmppar;
  2922.     Row *tmprow, *row;
  2923.     long y;
  2924.     int tmpheight;
  2925.  
  2926.     /* table stuff -- begin*/
  2927.    
  2928.     if (cursor.par->table) {
  2929.         BackspaceInTable();
  2930.         return;
  2931.     }
  2932.     /* table stuff -- end*/
  2933.     
  2934.     LyXFont rawtmpfont = current_font;
  2935.     LyXFont realtmpfont = real_current_font;
  2936.    
  2937.     // Get the font that is used to calculate the baselineskip
  2938.     int const lastpos = cursor.par->Last();
  2939.     LyXFont rawparfont = cursor.par->GetFontSettings(lastpos - 1);
  2940.  
  2941.     if (cursor.pos == 0) {
  2942.         /* we may paste some paragraphs */
  2943.       
  2944.         /* is it an empty paragraph? */
  2945.       
  2946.         if ((lastpos == 0
  2947.              || (lastpos == 1 && cursor.par->IsSeparator(0)))
  2948.             && !(cursor.par->Next() 
  2949.              && cursor.par->footnoteflag ==
  2950.              LyXParagraph::NO_FOOTNOTE
  2951.              && cursor.par->Next()->footnoteflag ==
  2952.              LyXParagraph::OPEN_FOOTNOTE)) {
  2953.             
  2954.             if (cursor.par->previous) {
  2955.                 tmppar = cursor.par->previous->FirstPhysicalPar();
  2956.                 if (cursor.par->GetLayout() == tmppar->GetLayout()
  2957.                     && cursor.par->footnoteflag == tmppar->footnoteflag
  2958.                     && cursor.par->GetAlign() == tmppar->GetAlign()) {
  2959.                     
  2960.                     tmppar->line_bottom = cursor.par->line_bottom;
  2961.                     tmppar->added_space_bottom = cursor.par->added_space_bottom;
  2962.                     tmppar->pagebreak_bottom = cursor.par->pagebreak_bottom;
  2963.                 }
  2964.                 
  2965.                 CursorLeftIntern();
  2966.              
  2967.                 /* the layout things can change the height of a row ! */ 
  2968.                 tmpheight = cursor.row->height;
  2969.                 SetHeightOfRow(cursor.row);
  2970.                 if (cursor.row->height != tmpheight) {
  2971.                     refresh_y = cursor.y - cursor.row->baseline;
  2972.                     refresh_row = cursor.row;
  2973.                     status = LyXText::NEED_MORE_REFRESH;
  2974.                 }
  2975.                 return;
  2976.             }
  2977.         }
  2978.         if (cursor.par->ParFromPos(cursor.pos)->previous){
  2979.             SetUndo(Undo::DELETE, 
  2980.                 cursor.par->ParFromPos(cursor.pos)->previous->previous, 
  2981.                 cursor.par->ParFromPos(cursor.pos)->next); 
  2982.         }
  2983.         tmppar = cursor.par;
  2984.         tmprow = cursor.row;
  2985.         CursorLeftIntern();
  2986.         /* Pasting is not allowed, if the paragraphs have different layout.
  2987.          * I think it is a real bug of all other word processors to allow
  2988.          * it. It confuses the user. Even so with a footnote paragraph and
  2989.          * a non-footnote paragraph. I will not allow pasting in this case, 
  2990.          * because the user would be confused if the footnote behaves 
  2991.          * different wether it is open or closed.
  2992.          * 
  2993.          * Correction: Pasting is always allowed with standard-layout */
  2994.         if (cursor.par != tmppar
  2995.             && (cursor.par->GetLayout() == tmppar->GetLayout()
  2996.             || !tmppar->GetLayout())
  2997.             && cursor.par->footnoteflag == tmppar->footnoteflag
  2998.             /* table stuff -- begin*/
  2999.             && !cursor.par->table /* no pasting of tables */ 
  3000.             /* table stuff -- end*/
  3001.             && cursor.par->GetAlign() == tmppar->GetAlign()) {
  3002.             
  3003.             cursor.par->PasteParagraph();
  3004.             
  3005.             if (!(cursor.pos &&
  3006.                   cursor.par->IsSeparator(cursor.pos - 1)))
  3007.                 cursor.par->InsertChar(cursor.pos, ' ');
  3008.             else
  3009.                 if (cursor.pos)
  3010.                     cursor.pos--;
  3011.             
  3012.             status = LyXText::NEED_MORE_REFRESH;
  3013.             refresh_row = cursor.row;
  3014.             refresh_y = cursor.y - cursor.row->baseline;
  3015.             
  3016.             /* remove the lost paragraph */
  3017.             RemoveParagraph(tmprow);
  3018.             RemoveRow(tmprow);  
  3019.             
  3020.             /* break the paragraph again */ 
  3021.             /* BreakAgain(cursor.row); */ 
  3022.             
  3023.             AppendParagraph(cursor.row);
  3024.             UpdateCounters(cursor.row);
  3025.             
  3026.             /* the row may have changed, block, hfills etc. */ 
  3027.             SetCursor(cursor.par, cursor.pos);
  3028.         }
  3029.     } else  {
  3030.         /* this is the code for a normal backspace, not pasting
  3031.          * any paragraphs */ 
  3032.         SetUndo(Undo::DELETE, 
  3033.             cursor.par->ParFromPos(cursor.pos)->previous, 
  3034.             cursor.par->ParFromPos(cursor.pos)->next); 
  3035.         CursorLeftIntern();
  3036.         
  3037.         /* some insets are undeletable here */
  3038.         if (cursor.par->GetChar(cursor.pos)==LYX_META_INSET) {
  3039.             if (!cursor.par->GetInset(cursor.pos)->Deletable())
  3040.                 return; 
  3041.             /* force complete redo when erasing display insets */ 
  3042.             /* this is a cruel mathod but save..... Matthias */ 
  3043.             if (cursor.par->GetInset(cursor.pos)->Display()){
  3044.                 cursor.par->Erase(cursor.pos);
  3045.                 RedoParagraph();
  3046.                 return;
  3047.             }
  3048.         }
  3049.         
  3050.         row = cursor.row;
  3051.         y = cursor.y - row->baseline;
  3052.         int z;
  3053.         
  3054.         /* remember that a space at the end of a row doesnt count
  3055.          * when calculating the fill */ 
  3056.         if (cursor.pos < RowLast(row) ||
  3057.             !cursor.par->IsLineSeparator(cursor.pos)) {
  3058.             row->fill += SingleWidth(cursor.par, cursor.pos);
  3059.         }
  3060.         
  3061.         /* some special code when deleting a newline. This is similar
  3062.          * to the behavior when pasting paragraphs */ 
  3063.         if (cursor.pos && cursor.par->IsNewline(cursor.pos)) {
  3064.             cursor.par->Erase(cursor.pos);
  3065.             /* refresh the positions */
  3066.             tmprow = row;
  3067.             while (tmprow->next && tmprow->next->par == row->par) {
  3068.                 tmprow = tmprow->next;
  3069.                 tmprow->pos--;
  3070.             }
  3071.             if (cursor.par->IsLineSeparator(cursor.pos - 1))
  3072.                 cursor.pos--;
  3073.             
  3074.             if (cursor.pos < cursor.par->Last() && !cursor.par->IsSeparator(cursor.pos)) {
  3075.                 cursor.par->InsertChar(cursor.pos, ' ');
  3076.                 /* refresh the positions */
  3077.                 tmprow = row;
  3078.                 while (tmprow->next && tmprow->next->par == row->par) {
  3079.                     tmprow = tmprow->next;
  3080.                     tmprow->pos++;
  3081.                 }
  3082.             }
  3083.         } else {
  3084.             cursor.par->Erase(cursor.pos);
  3085.             
  3086.             /* refresh the positions */
  3087.             tmprow = row;
  3088.             while (tmprow->next && tmprow->next->par == row->par) {
  3089.                 tmprow = tmprow->next;
  3090.                 tmprow->pos--;
  3091.             }
  3092.             
  3093.             /* delete superfluous blanks */ 
  3094.             if (cursor.pos < cursor.par->Last() - 1 &&
  3095.                 (cursor.par->IsLineSeparator(cursor.pos))) {
  3096.                 
  3097.                 if (cursor.pos == BeginningOfMainBody(cursor.par)
  3098.                     || !cursor.pos 
  3099.                     || cursor.par->IsLineSeparator(cursor.pos - 1)) {
  3100.                     cursor.par->Erase(cursor.pos);
  3101.                     /* refresh the positions */
  3102.                     tmprow = row;
  3103.                     while (tmprow->next && 
  3104.                            tmprow->next->par == row->par) {
  3105.                         tmprow = tmprow->next;
  3106.                         tmprow->pos--;
  3107.                     }
  3108.                     if (cursor.pos)   /* move one character left */
  3109.                         cursor.pos--;
  3110.                 }
  3111.             }
  3112.             
  3113.             /* delete newlines at the beginning of paragraphs */ 
  3114.             while (cursor.par->Last() &&
  3115.                    cursor.par->IsNewline(cursor.pos) &&
  3116.                    cursor.pos == BeginningOfMainBody(cursor.par)
  3117.                 ) {
  3118.                 cursor.par->Erase(cursor.pos);
  3119.                 /* refresh the positions */
  3120.                 tmprow = row;
  3121.                 while (tmprow->next && 
  3122.                        tmprow->next->par == row->par) {
  3123.                     tmprow = tmprow->next;
  3124.                     tmprow->pos--;
  3125.                 }
  3126.             }
  3127.         }
  3128.         
  3129.         /* is there a break one row above */ 
  3130.         if (row->previous && row->previous->par == row->par) {
  3131.             z = NextBreakPoint(row->previous, paperwidth);
  3132.             if ( z >= row->pos) {
  3133.                 row->pos = z + 1;
  3134.                 
  3135.                 tmprow = row->previous;
  3136.                 
  3137.                 /* maybe the current row is now empty */ 
  3138.                 if (row->pos >= row->par->Last()) {
  3139.                     /* remove it */ 
  3140.                     RemoveRow(row);
  3141.                     need_break_row = NULL;
  3142.                 }
  3143.                 else  {
  3144.                     BreakAgainOneRow(row);
  3145.                     if (row->next && row->next->par == row->par)
  3146.                         need_break_row = row->next;
  3147.                     else
  3148.                         need_break_row = NULL;
  3149.                 }
  3150.                 
  3151.                 /* set the dimensions of the row above  */ 
  3152.                 y -= tmprow->height;
  3153.                 tmprow->fill = Fill(tmprow, paperwidth);
  3154.                 SetHeightOfRow(tmprow);
  3155.                 
  3156.                 refresh_y = y;
  3157.                 refresh_row = tmprow;
  3158.                 status = LyXText::NEED_MORE_REFRESH;
  3159.                 SetCursor(cursor.par, cursor.pos);
  3160.                 current_font = rawtmpfont;
  3161.                 real_current_font = realtmpfont;
  3162.                 /* check, whether the last character's font has changed. */
  3163.                 rawtmpfont = cursor.par->GetFontSettings(cursor.par->Last() - 1);
  3164.                 if (rawparfont != rawtmpfont)
  3165.                     RedoHeightOfParagraph(cursor);
  3166.                 return;
  3167.             }
  3168.         }
  3169.         
  3170.         /* break the cursor row again */ 
  3171.         z = NextBreakPoint(row, paperwidth);
  3172.         
  3173.         if ( z != RowLast(row) || 
  3174.              (row->next && row->next->par == row->par &&
  3175.               RowLast(row) == row->par->Last() - 1)){
  3176.             
  3177.             /* it can happen that a paragraph loses one row
  3178.              * without a real breakup. This is when a word
  3179.              * is to long to be broken. Well, I don t care this 
  3180.              * hack ;-) */ 
  3181.             if (row->next && row->next->par == row->par &&
  3182.                 RowLast(row) == row->par->Last() - 1)
  3183.                 RemoveRow(row->next);
  3184.             
  3185.             refresh_y = y;
  3186.             refresh_row = row;
  3187.             status = LyXText::NEED_MORE_REFRESH;
  3188.             
  3189.             BreakAgainOneRow(row);
  3190.             
  3191.             SetCursor(cursor.par, cursor.pos);
  3192.             /* cursor MUST be in row now */
  3193.             
  3194.             if (row->next && row->next->par == row->par)
  3195.                 need_break_row = row->next;
  3196.             else
  3197.                 need_break_row = NULL;
  3198.         } else  {
  3199.             /* set the dimensions of the row */ 
  3200.             row->fill = Fill(row, paperwidth);
  3201.             int tmpheight = row->height;
  3202.             SetHeightOfRow(row);
  3203.             if (tmpheight == row->height)
  3204.                 status = LyXText::NEED_VERY_LITTLE_REFRESH;
  3205.             else
  3206.                 status = LyXText::NEED_MORE_REFRESH;
  3207.             refresh_y = y;
  3208.             refresh_row = row;
  3209.             SetCursor(cursor.par, cursor.pos);
  3210.         }
  3211.     }
  3212.    
  3213.     /* restore the current font 
  3214.      * That is what a user expects! */
  3215.     current_font = rawtmpfont; 
  3216.     real_current_font = realtmpfont;
  3217.     
  3218.     /* check, wether the last characters font has changed. */
  3219.     rawtmpfont = cursor.par->GetFontSettings(cursor.par->Last() - 1);
  3220.     if (rawparfont != rawtmpfont) {
  3221.         RedoHeightOfParagraph(cursor);
  3222.     } else {
  3223.         /* now the special right address boxes */
  3224.         if (lyxstyle.Style(parameters->textclass,
  3225.                    cursor.par->GetLayout())->margintype == MARGIN_RIGHT_ADDRESS_BOX) {
  3226.             RedoDrawingOfParagraph(cursor); 
  3227.         }
  3228.     }
  3229. }
  3230.  
  3231.  
  3232. void LyXText::GetVisibleRow(LyXScreen &scr, int offset, 
  3233.                 Row *row_ptr, long y)
  3234. {
  3235.     /* returns a printed row */
  3236.     
  3237.     int pos, pos_end;
  3238.     float x, tmpx;
  3239.     int y_top, y_bottom;
  3240.     float fill_separator, fill_hfill, fill_label_hfill;
  3241.     LyXParagraph *par, *firstpar;
  3242.     int left_margin;
  3243.     LyXFont font;
  3244.     int maxdesc;
  3245.     if (row_ptr->height <= 0) {
  3246.         fprintf(stderr, "LYX_ERROR: row.height: %d \n",
  3247.             row_ptr->height);
  3248.         return;
  3249.     }
  3250.     left_margin = LabelEnd(row_ptr);
  3251.     PrepareToPrint(row_ptr, x, fill_separator,
  3252.                fill_hfill, fill_label_hfill);
  3253.     
  3254.     int main_body = BeginningOfMainBody(row_ptr->par);
  3255.     
  3256.     /* initialize the pixmap */
  3257.     
  3258.     scr.fillRectangle(gc_clear,
  3259.               0, offset, paperwidth, row_ptr->height);
  3260.     // check for NOT FAST SELECTION
  3261.     if (selection) {
  3262.         /* selection code */ 
  3263.         if (sel_start_cursor.row == row_ptr &&
  3264.             sel_end_cursor.row == row_ptr) {
  3265.             scr.fillRectangle(gc_selection, sel_start_cursor.x,
  3266.                       offset,
  3267.                       sel_end_cursor.x -
  3268.                       sel_start_cursor.x,
  3269.                       row_ptr->height);
  3270.         }
  3271.         else if (sel_start_cursor.row == row_ptr) {
  3272.             scr.fillRectangle(gc_selection, sel_start_cursor.x,
  3273.                       offset,
  3274.                       paperwidth - sel_start_cursor.x,
  3275.                       row_ptr->height);
  3276.         } else if (sel_end_cursor.row == row_ptr) {
  3277.             scr.fillRectangle(gc_selection,0, offset,
  3278.                       sel_end_cursor.x, row_ptr->height);
  3279.         } else if (y > sel_start_cursor.y && y < sel_end_cursor.y) {
  3280.             scr.fillRectangle(gc_selection, 0, offset,
  3281.                       paperwidth, row_ptr->height);
  3282.             
  3283.         }
  3284.     } // end of NOT FAST SELECTION code
  3285.     
  3286.     if (row_ptr->par->pextra_type == PEXTRA_MINIPAGE) {
  3287.         /* draw a marker at the left margin! */ 
  3288.         LyXFont font = GetFont(row_ptr->par, 0);
  3289.         int asc = font.maxAscent();
  3290.         int x = (LYX_PAPER_MARGIN - font.width('|')) / 2;
  3291.         int y1 = (offset + row_ptr->baseline);
  3292.         int y2 = (offset + row_ptr->baseline) - asc;
  3293.  
  3294.         scr.drawVerticalLine(gc_minipage, x, y1, y2);
  3295.     }       
  3296.     if (row_ptr->par->footnoteflag == LyXParagraph::OPEN_FOOTNOTE) {
  3297.         LyXFont font(LyXFont::ALL_SANE);
  3298.         font.setSize(LyXFont::SIZE_FOOTNOTE);
  3299.         font.setColor(LyXFont::RED);
  3300.         
  3301.         int box_x = LYX_PAPER_MARGIN;
  3302.         box_x += font.textWidth(" wide-tab ", 10);
  3303.         if (row_ptr->previous && 
  3304.             row_ptr->previous->par->footnoteflag != LyXParagraph::OPEN_FOOTNOTE){
  3305.             LString fs;
  3306.             switch (row_ptr->par->footnotekind) {
  3307.             case LyXParagraph::MARGIN:
  3308.                 fs = " margin";
  3309.                 break;
  3310.             case LyXParagraph::FIG:
  3311.                 fs = " fig";
  3312.                 break;
  3313.             case LyXParagraph::TAB:
  3314.                 fs = " tab";
  3315.                 break;
  3316.             case LyXParagraph::WIDE_FIG:
  3317.                 fs = " wide-fig";
  3318.                 break;
  3319.             case LyXParagraph::WIDE_TAB:
  3320.                 fs = " wide-tab";
  3321.                 break;
  3322.             case LyXParagraph::ALGORITHM:
  3323.                 fs = " alg";
  3324.                 break;
  3325.             case LyXParagraph::FOOTNOTE:
  3326.                 fs = " foot";
  3327.                 break;
  3328.             }
  3329.             
  3330.             // Determine background color.
  3331.             gc_type back = gc_lighted;
  3332.             scr.fillRectangle(back,LYX_PAPER_MARGIN, offset+1,
  3333.                       box_x - LYX_PAPER_MARGIN, 
  3334.                       int(font.maxAscent())+
  3335.                       int(font.maxDescent()));
  3336.             
  3337.             scr.drawLine(gc_foot,
  3338.                      offset,
  3339.                      LYX_PAPER_MARGIN,
  3340.                      paperwidth - 2*LYX_PAPER_MARGIN);
  3341.             
  3342.             scr.drawString(font, fs,
  3343.                        offset + int(font.maxAscent())+1,
  3344.                        LYX_PAPER_MARGIN);
  3345.             scr.drawVerticalLine(gc_foot,
  3346.                          LYX_PAPER_MARGIN,
  3347.                          offset,
  3348.                          offset
  3349.                          + int(font.maxAscent())+
  3350.                          int(font.maxDescent()));
  3351.             
  3352.             scr.drawLine(gc_foot,
  3353.                      offset
  3354.                      + int(font.maxAscent())
  3355.                      + int(font.maxDescent()) + 1,
  3356.                      LYX_PAPER_MARGIN, box_x - LYX_PAPER_MARGIN); 
  3357.         }
  3358.         
  3359.         /* draw the open floats in a red box */
  3360.         scr.drawVerticalLine(gc_foot,
  3361.                      box_x,
  3362.                      offset,  offset + row_ptr->height);
  3363.         
  3364.         scr.drawVerticalLine(gc_foot,
  3365.                      paperwidth - LYX_PAPER_MARGIN,
  3366.                      offset,
  3367.                      offset + row_ptr->height);
  3368.             
  3369.         
  3370.     } else  {
  3371.         if (row_ptr->previous &&
  3372.             row_ptr->previous->par->footnoteflag == LyXParagraph::OPEN_FOOTNOTE) {
  3373.             LyXFont font(LyXFont::ALL_SANE);
  3374.             font.setSize(LyXFont::SIZE_FOOTNOTE);
  3375.             
  3376.             int box_x = LYX_PAPER_MARGIN;
  3377.             box_x += font.textWidth(" wide-tab ", 10);
  3378.             
  3379.             scr.drawLine(gc_foot,
  3380.                      offset,
  3381.                      box_x,
  3382.                      paperwidth - LYX_PAPER_MARGIN - box_x);
  3383.         }
  3384.     }
  3385.     
  3386.     LyXLayout* layout = lyxstyle.Style(parameters->textclass,
  3387.                        row_ptr->par->GetLayout());
  3388.     firstpar = row_ptr->par->FirstPhysicalPar();
  3389.     
  3390.     y_top = 0;
  3391.     y_bottom = row_ptr->height;
  3392.     
  3393.     /* is it a first row? */ 
  3394.     if (row_ptr->pos == 0
  3395.         && row_ptr->par == firstpar) {
  3396.         
  3397.         /* think about the margins */ 
  3398.         if (!row_ptr->previous)
  3399.             y_top += LYX_PAPER_MARGIN;
  3400.         
  3401.         if (row_ptr->par->pagebreak_top){ /* draw a top pagebreak  */
  3402.             scr.drawOnOffLine(offset + y_top + 2 * DefaultHeight(),
  3403.                       0, paperwidth);
  3404.             y_top += 3 * DefaultHeight();
  3405.         }
  3406.         
  3407.         if (row_ptr->par->added_space_top.kind() == VSpace::VFILL) {
  3408.             /* draw a vfill top  */
  3409.             scr.drawLine(gc_fill, 
  3410.                      offset + 2 + y_top,
  3411.                      0, LYX_PAPER_MARGIN);
  3412.             scr.drawLine(gc_fill,
  3413.                      offset + y_top + 3 * DefaultHeight(),
  3414.                      0, LYX_PAPER_MARGIN);
  3415.             scr.drawVerticalOnOffLine(LYX_PAPER_MARGIN / 2, 
  3416.                           offset + 2 + y_top,
  3417.                           offset + y_top + 3 *
  3418.                           DefaultHeight());
  3419.             
  3420.             y_top += 3 * DefaultHeight();
  3421.         }
  3422.         
  3423.         /* think about user added space */ 
  3424.         y_top += int(row_ptr->par->added_space_top.inPixels());
  3425.         
  3426.         /* think about the parskip */ 
  3427.         /* some parskips VERY EASY IMPLEMENTATION */ 
  3428.         if (parameters->paragraph_separation == LYX_PARSEP_SKIP) {
  3429.             if (layout->latextype == LATEX_PARAGRAPH
  3430.                 && firstpar->GetDepth() == 0
  3431.                 && firstpar->Previous())
  3432.                 y_top += parameters->getDefSkip().inPixels();
  3433.             else if (firstpar->Previous()
  3434.                  && lyxstyle.Style(parameters->textclass,
  3435.                            firstpar->Previous()->GetLayout())->latextype == LATEX_PARAGRAPH
  3436.                  && firstpar->Previous()->GetDepth() == 0)
  3437.                 // is it right to use defskip here, too? (AS) 
  3438.                 y_top += parameters->getDefSkip().inPixels();
  3439.         }
  3440.         
  3441.         if (row_ptr->par->line_top) {      /* draw a top line  */
  3442.             y_top +=  GetFont(row_ptr->par, 0).ascent('x');
  3443.  
  3444.             scr.drawThickLine(offset + y_top,
  3445.                       0, paperwidth);
  3446.             y_top +=  GetFont(row_ptr->par, 0).ascent('x');
  3447.         }
  3448.         
  3449.         /* should we print a label? */ 
  3450.         if (layout->labeltype >= LABEL_STATIC
  3451.             && (layout->labeltype != LABEL_STATIC
  3452.             || layout->latextype != LATEX_ENVIRONMENT
  3453.             || row_ptr->par->IsFirstInSequence())) {
  3454.             font = GetFont(row_ptr->par, -2);
  3455.             if (!row_ptr->par->GetLabelString().empty()) {
  3456.                 tmpx = x;
  3457.                 LString tmpstring = row_ptr->par->GetLabelString();
  3458.                 
  3459.                 if (layout->labeltype == LABEL_COUNTER_CHAPTER) {
  3460.                     if (parameters->secnumdepth >=0){
  3461.                         /* this is special code for the chapter layout. This is printed in
  3462.                          * an extra row and has a pagebreak at the top. */
  3463.                         maxdesc = int(font.maxDescent() * layout->spacing.getValue() * parameters->spacing.getValue())
  3464.                             + int(layout->parsep) * DefaultHeight();
  3465.                         scr.drawString(font, tmpstring,
  3466.                                    offset + row_ptr->baseline
  3467.                                    - row_ptr->ascent_of_text - maxdesc,
  3468.                                    int(x));
  3469.                     }
  3470.                 } else {
  3471.                     x -= font.stringWidth( layout->labelsep);
  3472.                     x -= font.stringWidth( tmpstring);
  3473.                     /* draw it! */
  3474.                     scr.drawString(font, tmpstring,
  3475.                                offset + row_ptr->baseline, int(x));
  3476.                 }
  3477.                 x = tmpx;
  3478.             }
  3479.             /* the labels at the top of an environment. More or less for bibliography */ 
  3480.         } else if (layout->labeltype == LABEL_TOP_ENVIRONMENT ||
  3481.                layout->labeltype == LABEL_BIBLIO ||
  3482.                layout->labeltype == LABEL_CENTERED_TOP_ENVIRONMENT) {
  3483.             if (row_ptr->par->IsFirstInSequence()) {
  3484.                 font = GetFont(row_ptr->par, -2);
  3485.                 if (!row_ptr->par->GetLabelString().empty()) {
  3486.                     LString tmpstring = row_ptr->par->GetLabelString();
  3487.                     
  3488.                     maxdesc = int(font.maxDescent() * layout->spacing.getValue() * parameters->spacing.getValue()
  3489.                              + (layout->labelbottomsep * DefaultHeight()));
  3490.                     
  3491.                     int top_label_x = int(x);
  3492.                     if (layout->labeltype == LABEL_CENTERED_TOP_ENVIRONMENT){
  3493.                         top_label_x = int(x + (paperwidth - RightMargin(row_ptr) - x) / 2); 
  3494.                         top_label_x -= (font.stringWidth( tmpstring)/2);
  3495.                     }
  3496.                     
  3497.                     scr.drawString(font, tmpstring,
  3498.                                offset + row_ptr->baseline
  3499.                                - row_ptr->ascent_of_text - maxdesc,  
  3500.                                top_label_x);            
  3501.                 }
  3502.             }
  3503.         }
  3504.         if (layout->labeltype==LABEL_BIBLIO) { // ale970302
  3505.             if (row_ptr->par->bibkey) {
  3506.                 tmpx = x;
  3507.                 x -= font.stringWidth(layout->labelsep);
  3508.                 font = GetFont(row_ptr->par, -1);
  3509.                 x -= row_ptr->par->bibkey->Width(font);
  3510.                 row_ptr->par->bibkey->Draw(font, scr,
  3511.                                offset + row_ptr->baseline, 
  3512.                                x);
  3513.                 x = tmpx;
  3514.             }
  3515.         } 
  3516.     }
  3517.     
  3518.     /* is it a last row? */
  3519.     par = row_ptr->par->LastPhysicalPar();
  3520.     if (row_ptr->par->ParFromPos(RowLast(row_ptr) + 1) == par
  3521.         && (!row_ptr->next || row_ptr->next->par != row_ptr->par)) {     
  3522.         
  3523.         /* think about the margins */ 
  3524.         if (!row_ptr->next)
  3525.             y_bottom -= LYX_PAPER_MARGIN;
  3526.         
  3527.         /* draw a bottom pagebreak */ 
  3528.         if (firstpar->pagebreak_bottom) {
  3529.             scr.drawOnOffLine(offset + y_bottom - 2 *
  3530.                       DefaultHeight(),
  3531.                       0, paperwidth);
  3532.             y_bottom -= 3 * DefaultHeight();
  3533.         }
  3534.         
  3535.         if (firstpar->added_space_bottom.kind() == VSpace::VFILL) {
  3536.             /* draw a vfill bottom  */
  3537.             scr.drawLine(gc_fill,
  3538.                      offset + y_bottom - 3 * DefaultHeight(),
  3539.                      0, LYX_PAPER_MARGIN);
  3540.             scr.drawLine(gc_fill, offset + y_bottom - 2,
  3541.                      0, LYX_PAPER_MARGIN);
  3542.             scr.drawVerticalOnOffLine(LYX_PAPER_MARGIN / 2, 
  3543.                           offset + y_bottom - 3 * DefaultHeight(),
  3544.                           offset + y_bottom - 2
  3545.                 );        
  3546.             y_bottom -= 3* DefaultHeight();
  3547.         }
  3548.         
  3549.         /* think about user added space */ 
  3550.         y_bottom -= int(firstpar->added_space_bottom.inPixels());
  3551.         
  3552.         if (firstpar->line_bottom) {
  3553.             /* draw a bottom line */
  3554.             y_bottom -= GetFont(par, par->Last() - 1).ascent('x');
  3555.  
  3556.             scr.drawThickLine(offset + y_bottom,
  3557.                       0, paperwidth);        
  3558.             y_bottom -= GetFont(par, par->Last() - 1).ascent('x');
  3559.         }
  3560.     }
  3561.     
  3562.     /* draw the text in the pixmap */  
  3563.     pos_end = RowLast(row_ptr);
  3564.     
  3565.     pos = row_ptr->pos;
  3566.     /* table stuff -- begin*/
  3567.     if (row_ptr->par->table) {
  3568.         bool on_off;
  3569.         int cell = NumberOfCell(row_ptr->par, row_ptr->pos);
  3570.         float x_old = x;
  3571.         x += row_ptr->par->table->GetBeginningOfTextInCell(cell);
  3572.         
  3573.         while (pos <= pos_end)  {
  3574.             if (row_ptr->par->IsNewline(pos)) {
  3575.                 
  3576.                 x = x_old + row_ptr->par->table->WidthOfColumn(cell);
  3577.                 /* draw the table lines, still very simple */
  3578.                 on_off = !row_ptr->par->table->TopLine(cell);
  3579.                 if ((!on_off ||
  3580.                      !row_ptr->par->table->TopAlreadyDrawed(cell)) &&
  3581.                     !row_ptr->par->table->IsContRow(cell))
  3582.                     scr.drawTableLine(offset + row_ptr->baseline -
  3583.                               row_ptr->ascent_of_text,
  3584.                               int(x_old), int(x - x_old), on_off);
  3585.                 on_off = !row_ptr->par->table->BottomLine(cell);
  3586.                 if ((!on_off && !row_ptr->par->table->RowHasContRow(cell)) ||
  3587.                     row_ptr->par->table->VeryLastRow(cell))
  3588.                     scr.drawTableLine(offset + y_bottom - 1,
  3589.                               int(x_old), int(x - x_old), on_off);
  3590.                 on_off = !row_ptr->par->table->LeftLine(cell);
  3591.                 
  3592.                 scr.drawVerticalTableLine(int(x_old), 
  3593.                               offset + row_ptr->baseline -
  3594.                               row_ptr->ascent_of_text,
  3595.                               offset + y_bottom - 1,
  3596.                               on_off);
  3597.                 on_off = !row_ptr->par->table->RightLine(cell);
  3598.                 
  3599.                 scr.drawVerticalTableLine(int(x) -
  3600.                               row_ptr->par->table->AdditionalWidth(cell),
  3601.                               offset + row_ptr->baseline -
  3602.                               row_ptr->ascent_of_text,
  3603.                               offset + y_bottom - 1,
  3604.                               on_off);
  3605.                 x_old = x;
  3606.                 /* take care about the alignment and other spaces */
  3607.                 cell++;
  3608.                 x += row_ptr->par->table->GetBeginningOfTextInCell(cell);
  3609.                 if (row_ptr->par->table->IsFirstCell(cell))
  3610.                     cell--; // little hack, sorry
  3611.                 pos++;
  3612.             } else if (row_ptr->par->IsHfill(pos)) {
  3613.                 x += 1;
  3614.                 
  3615.                 scr.drawVerticalLine(gc_fill, int(x),  
  3616.                              offset + row_ptr->baseline - DefaultHeight()/2, 
  3617.                              offset + row_ptr->baseline);        
  3618.                 x += 2;
  3619.                 pos++;
  3620.             } else {
  3621.                 if (row_ptr->par->IsSeparator(pos)) {
  3622.                     tmpx = x;
  3623.                     x+=SingleWidth(row_ptr->par, pos);
  3624.                     /* -------> Only draw protected spaces when not in
  3625.                      * free-spacing mode. */
  3626.                     if (row_ptr->par->GetChar(pos)==LYX_META_PROTECTED_SEPARATOR && !layout->free_spacing) {
  3627.                         scr.drawVerticalLine(gc_fill, int(tmpx),
  3628.                                      offset + row_ptr->baseline - 3,
  3629.                                      offset + row_ptr->baseline - 1);
  3630.                         scr.drawLine(gc_fill,
  3631.                                  offset + row_ptr->baseline - 1,
  3632.                                  int(tmpx),
  3633.                                  int(x-tmpx-2));
  3634.                         scr.drawVerticalLine(gc_fill, int(x-2),
  3635.                                      offset + row_ptr->baseline - 3,
  3636.                                      offset + row_ptr->baseline - 1);            
  3637.                         /* what about underbars? */
  3638.                         font = GetFont(row_ptr->par, pos); 
  3639.                         if (font.underbar() == LyXFont::ON
  3640.                             && font.latex() != LyXFont::ON) {
  3641.                             scr.drawLine(gc_copy,
  3642.                                      offset +
  3643.                                      row_ptr->baseline + 2,
  3644.                                      int(tmpx),
  3645.                                      int(x - tmpx));                
  3646.                         }
  3647.                     }
  3648.                     pos++;
  3649.                 } else
  3650.                     Draw(row_ptr, pos, scr, offset, x);
  3651.             }
  3652.         }
  3653.         
  3654.         /* do not forget the very last cell. This has no NEWLINE so 
  3655.          * ignored by the code above*/ 
  3656.         if (cell == row_ptr->par->table->GetNumberOfCells()-1){
  3657.             x = x_old + row_ptr->par->table->WidthOfColumn(cell);
  3658.             on_off = !row_ptr->par->table->TopLine(cell);
  3659.             if ((!on_off ||
  3660.                  !row_ptr->par->table->TopAlreadyDrawed(cell)) &&
  3661.                 !row_ptr->par->table->IsContRow(cell))
  3662.                 
  3663.                 scr.drawTableLine(offset + row_ptr->baseline -
  3664.                           row_ptr->ascent_of_text,
  3665.                           int(x_old), int(x - x_old), on_off);        
  3666.             on_off = !row_ptr->par->table->BottomLine(cell);
  3667.             if ((!on_off && !row_ptr->par->table->RowHasContRow(cell)) ||
  3668.                 row_ptr->par->table->VeryLastRow(cell))
  3669.                 
  3670.                 scr.drawTableLine(offset + y_bottom - 1,
  3671.                           int(x_old), int(x - x_old), on_off);        
  3672.             on_off = !row_ptr->par->table->LeftLine(cell);
  3673.             
  3674.             scr.drawVerticalTableLine(int(x_old), 
  3675.                           offset + row_ptr->baseline -
  3676.                           row_ptr->ascent_of_text,
  3677.                           offset + y_bottom - 1,
  3678.                           on_off);        
  3679.             on_off = !row_ptr->par->table->RightLine(cell);
  3680.             
  3681.             scr.drawVerticalTableLine(int(x) -
  3682.                           row_ptr->par->table->AdditionalWidth(cell),
  3683.                           offset + row_ptr->baseline -
  3684.                           row_ptr->ascent_of_text,
  3685.                           offset + y_bottom - 1,
  3686.                           on_off);        
  3687.         }
  3688.     } else {
  3689.         /* table stuff -- end*/
  3690.         
  3691.         while (pos <= pos_end)  {
  3692.             
  3693.             if (row_ptr->par->IsHfill(pos)) {
  3694.                 x += 1;
  3695.                 scr.drawVerticalLine(gc_fill, int(x),  
  3696.                              offset + row_ptr->baseline - DefaultHeight()/2, 
  3697.                              offset + row_ptr->baseline);        
  3698.                 if (HfillExpansion(row_ptr,pos)) {
  3699.                     if (pos >= main_body) {
  3700.                         scr.drawOnOffLine(offset + row_ptr->baseline -
  3701.                                   DefaultHeight()/4,
  3702.                                   int(x),
  3703.                                   int(fill_hfill));            
  3704.                         x += fill_hfill;
  3705.                     } else {
  3706.                         scr.drawOnOffLine(offset + row_ptr->baseline -
  3707.                                   DefaultHeight()/4,
  3708.                                   int(x),
  3709.                                   int(fill_label_hfill));
  3710.                         x += fill_label_hfill;
  3711.                     }
  3712.                     scr.drawVerticalLine(gc_fill, int(x),
  3713.                                  offset + row_ptr->baseline -
  3714.                                  DefaultHeight()/2, 
  3715.                                  offset + row_ptr->baseline);
  3716.                 }
  3717.                 x += 2;
  3718.                 pos++;
  3719.             } else {
  3720.                 if (row_ptr->par->IsSeparator(pos)) {
  3721.                     tmpx = x;
  3722.                     x+=SingleWidth(row_ptr->par, pos);
  3723.                     if (pos >= main_body)
  3724.                         x+= fill_separator;
  3725.                     /* -------> Only draw protected spaces when not in
  3726.                      * free-spacing mode. */
  3727.                     if (row_ptr->par->GetChar(pos)==LYX_META_PROTECTED_SEPARATOR && !layout->free_spacing) {
  3728.                         
  3729.                         scr.drawVerticalLine(gc_fill, int(tmpx),
  3730.                                      offset + row_ptr->baseline - 3,
  3731.                                      offset + row_ptr->baseline - 1);
  3732.                         scr.drawLine(gc_fill,
  3733.                                  offset + row_ptr->baseline - 1,
  3734.                                  int(tmpx),
  3735.                                  int(x-tmpx-2));
  3736.                         scr.drawVerticalLine(gc_fill, int(x-2),
  3737.                                      offset + row_ptr->baseline - 3,
  3738.                                      offset + row_ptr->baseline - 1);            
  3739.                         /* what about underbars? */
  3740.                         font = GetFont(row_ptr->par, pos); 
  3741.                         if (font.underbar() == LyXFont::ON
  3742.                             && font.latex() != LyXFont::ON) {
  3743.                             scr.drawLine(gc_copy,
  3744.                          offset + row_ptr->baseline + 2,
  3745.                                      int(tmpx),
  3746.                                      int(x - tmpx));
  3747.                         }
  3748.                     }
  3749.                     pos++;
  3750.                 } else
  3751.                     Draw(row_ptr, pos, scr, offset, x);
  3752.             }
  3753.             if (pos == main_body) {
  3754.                 x += GetFont(row_ptr->par, -2).stringWidth(
  3755.                     layout->labelsep);
  3756.                 if (row_ptr->par->IsLineSeparator(pos - 1))
  3757.                     x-= SingleWidth(row_ptr->par, pos - 1);
  3758.                 if (x < left_margin)
  3759.                     x = left_margin;
  3760.             }
  3761.         }
  3762.     }
  3763. }
  3764.  
  3765.  
  3766. int LyXText::DefaultHeight()
  3767. {
  3768.     LyXFont font(LyXFont::ALL_SANE);
  3769.     return int(font.maxAscent() + font.maxDescent() * 1.5);
  3770. }
  3771.  
  3772.    
  3773. /* returns the column near the specified x-coordinate of the row 
  3774. * x is set to the real beginning of this column  */ 
  3775. int  LyXText::GetColumnNearX(Row *row, int& x)
  3776. {
  3777.     int c; 
  3778.     float tmpx;
  3779.     float fill_separator, fill_hfill, fill_label_hfill;
  3780.     int left_margin;
  3781.    
  3782.     left_margin = LabelEnd(row);
  3783.     PrepareToPrint(row, tmpx, fill_separator,
  3784.                fill_hfill, fill_label_hfill);
  3785.     int main_body = BeginningOfMainBody(row->par);
  3786.    
  3787.     c = row->pos;
  3788.  
  3789.     int last = RowLast(row);
  3790.     if (row->par->IsNewline(last))
  3791.         last--;
  3792.    
  3793.     LyXLayout *layout = lyxstyle.Style(parameters->textclass,
  3794.                        row->par->GetLayout());
  3795.     /* table stuff -- begin*/
  3796.     if (row->par->table) {
  3797.         if (!row->next || row->next->par != row->par)
  3798.        last = RowLast(row); /* the last row doesn't need a newline at the end*/
  3799.         int cell = NumberOfCell(row->par, row->pos);
  3800.         float x_old = tmpx;
  3801.         bool ready = false;
  3802.         tmpx += row->par->table->GetBeginningOfTextInCell(cell);
  3803.         while (c <= last
  3804.                && tmpx + SingleWidth(row->par, c)  <= x
  3805.                && !ready){
  3806.             if (row->par->IsNewline(c)) {
  3807.                 if (x_old + row->par->table->WidthOfColumn(cell) <= x){
  3808.                     tmpx = x_old + row->par->table->WidthOfColumn(cell);
  3809.                     x_old = tmpx;
  3810.                     cell++;
  3811.                     tmpx += row->par->table->GetBeginningOfTextInCell(cell);
  3812.                     c++;
  3813.                 } else
  3814.                     ready = true;
  3815.             } else {
  3816.                 tmpx += SingleWidth(row->par, c);
  3817.                 c++;
  3818.             }
  3819.         }
  3820.     } else
  3821.         /* table stuff -- end*/
  3822.  
  3823.         while (c <= last
  3824.                && tmpx + SingleWidth(row->par, c)  <= x) {
  3825.             
  3826.             if (c && c == main_body
  3827.                 && !row->par->IsLineSeparator(c - 1)) {
  3828.                 tmpx += GetFont(row->par, -2)
  3829.                     .stringWidth(layout->labelsep);
  3830.                 if (tmpx < left_margin)
  3831.                     tmpx = left_margin;
  3832.             }
  3833.          
  3834.             tmpx += SingleWidth(row->par, c);
  3835.             if (HfillExpansion(row, c)) {
  3836.                 if (c >= main_body)
  3837.                     tmpx += fill_hfill;
  3838.                 else
  3839.                     tmpx += fill_label_hfill;
  3840.             }
  3841.             else if (c >= main_body
  3842.                  && row->par->IsSeparator(c)) {
  3843.                 tmpx+= fill_separator;  
  3844.             }
  3845.             c++;
  3846.             if (c == main_body
  3847.                 && row->par->IsLineSeparator(c - 1)) {
  3848.                 tmpx += GetFont(row->par, -2)
  3849.                     .stringWidth(layout->labelsep);
  3850.                 tmpx-= SingleWidth(row->par, c - 1);
  3851.                 if (tmpx < left_margin)
  3852.                     tmpx = left_margin;
  3853.             }
  3854.         }
  3855.     /* make shure that a last space in a row doesnt count */
  3856.     if (c > 0 && c >= last
  3857.         && row->par->IsLineSeparator(c - 1)
  3858.         && !(!row->next || row->next->par != row->par)) {
  3859.         tmpx -= SingleWidth(row->par, c - 1);
  3860.         tmpx -= fill_separator;
  3861.     }
  3862.     c-=row->pos;
  3863.     
  3864.     x = int(tmpx);
  3865.     return c;
  3866. }
  3867.  
  3868.    
  3869. /* turn the selection into a new environment. If there is no selection,
  3870. * create an empty environment */ 
  3871. void LyXText::InsertFootnoteEnvironment(LyXParagraph::footnote_kind kind)
  3872. {
  3873.    /* no footnoteenvironment in a footnoteenvironment */ 
  3874.    if (cursor.par->footnoteflag != LyXParagraph::NO_FOOTNOTE) {
  3875.       WriteAlert(_("Impossible operation"), 
  3876.          _("You can't insert a float in a float!"), 
  3877.          _("Sorry."));
  3878.      return;
  3879.    }
  3880.    /* no marginpars in minipages */
  3881.    if (kind == LyXParagraph::MARGIN 
  3882.       && cursor.par->pextra_type == PEXTRA_MINIPAGE) {
  3883.       WriteAlert(_("Impossible operation"), 
  3884.          _("You can't insert a marginpar in a minipage!"), 
  3885.          _("Sorry."));
  3886.       return;
  3887.    }
  3888.    
  3889.    /* this doesnt make sense, if there is no selection */ 
  3890.    bool dummy_selection = false;
  3891.    if (!selection) {
  3892.       sel_start_cursor = cursor;       /* dummy selection  */
  3893.       sel_end_cursor = cursor;
  3894.       dummy_selection = true;
  3895.    }
  3896.    
  3897.    LyXParagraph *tmppar;
  3898.  
  3899.    if (sel_start_cursor.par->table || sel_end_cursor.par->table){
  3900.       WriteAlert(_("Impossible operation"), _("Cannot cut table."), _("Sorry."));
  3901.       return;
  3902.    }
  3903.      
  3904.    /* a test to make sure there is not already a footnote
  3905.     * in the selection. */
  3906.    
  3907.    tmppar = sel_start_cursor.par->ParFromPos(sel_start_cursor.pos);
  3908.    
  3909.    while (tmppar != sel_end_cursor.par->ParFromPos(sel_end_cursor.pos) && 
  3910.       tmppar->footnoteflag == LyXParagraph::NO_FOOTNOTE)
  3911.      tmppar = tmppar->next;
  3912.    
  3913.    if (tmppar != sel_end_cursor.par->ParFromPos(sel_end_cursor.pos)
  3914.        || tmppar->footnoteflag != LyXParagraph::NO_FOOTNOTE) {
  3915.       WriteAlert(_("Impossible operation"), 
  3916.          _("Float would include float!"), 
  3917.          _("Sorry."));
  3918.       return;
  3919.    }
  3920.    
  3921.    /* ok we have a selection. This is always between sel_start_cursor
  3922.     * and sel_end cursor */
  3923.  
  3924.    SetUndo(Undo::FINISH, 
  3925.        sel_start_cursor.par->ParFromPos(sel_start_cursor.pos)->previous, 
  3926.        sel_end_cursor.par->ParFromPos(sel_end_cursor.pos)->next); 
  3927.    
  3928.    if (sel_end_cursor.pos > 0 
  3929.        && sel_end_cursor.par->IsLineSeparator(sel_end_cursor.pos - 1))
  3930.      sel_end_cursor.pos--;           /* please break before a space at
  3931.                     * the end */
  3932.    if (sel_start_cursor.par == sel_end_cursor.par
  3933.        && sel_start_cursor.pos > sel_end_cursor.pos)
  3934.      sel_start_cursor.pos--;
  3935.  
  3936.    sel_end_cursor.par->BreakParagraphConservative(sel_end_cursor.pos);
  3937.    
  3938.    sel_end_cursor.par = sel_end_cursor.par->Next();
  3939.    sel_end_cursor.pos = 0;
  3940.    
  3941.    // don't forget to insert a dummy layout paragraph if necessary
  3942.    if (sel_start_cursor.par->GetLayout() != sel_end_cursor.par->layout){
  3943.      sel_end_cursor.par->BreakParagraphConservative(0);
  3944.      sel_end_cursor.par->layout = LYX_DUMMY_LAYOUT;
  3945.      sel_end_cursor.par = sel_end_cursor.par->next;
  3946.    }
  3947.    else
  3948.      sel_end_cursor.par->layout = LYX_DUMMY_LAYOUT;
  3949.  
  3950.    cursor = sel_end_cursor;
  3951.  
  3952.    /* please break behind a space, if there is one. The space should
  3953.     * be erased too */ 
  3954.    if (sel_start_cursor.pos > 0 
  3955.        && sel_start_cursor.par->IsLineSeparator(sel_start_cursor.pos - 1))
  3956.      sel_start_cursor.pos--;
  3957.    if (sel_start_cursor.par->IsLineSeparator(sel_start_cursor.pos)) {
  3958.       sel_start_cursor.par->Erase(sel_start_cursor.pos);
  3959.    }
  3960.    
  3961.    sel_start_cursor.par->BreakParagraphConservative(sel_start_cursor.pos);
  3962.    tmppar = sel_start_cursor.par->Next();
  3963.    
  3964.    if (dummy_selection) {
  3965.        tmppar->Clear();
  3966.        if (kind == LyXParagraph::TAB
  3967.            || kind == LyXParagraph::FIG 
  3968.                || kind == LyXParagraph::WIDE_TAB
  3969.            || kind == LyXParagraph::WIDE_FIG 
  3970.                || kind == LyXParagraph::ALGORITHM) {
  3971.            int lay = lyxstyle.NumberOfLayout(parameters->textclass,
  3972.                              "Caption");
  3973.            if (lay == -1) // layout not found
  3974.                // use default layout "Standard" (0)
  3975.                lay = 0;
  3976.            tmppar->SetLayout(lay);
  3977.        }
  3978.    }
  3979.    else {
  3980.      if (sel_start_cursor.pos > 0) {
  3981.        /* the footnote-environment should begin with a standard layout.
  3982.     * Imagine you insert a footnote within an enumeration, you 
  3983.     * certainly do not want an enumerated footnote! */ 
  3984.        tmppar->Clear();
  3985.      }
  3986.      else {
  3987.        /* this is a exception the user would sometimes expect, I hope */
  3988.        sel_start_cursor.par->Clear();
  3989.      }
  3990.    }
  3991.    
  3992.    while (tmppar != sel_end_cursor.par) {
  3993.       tmppar->footnoteflag = LyXParagraph::OPEN_FOOTNOTE;
  3994.       tmppar->footnotekind = kind;
  3995.       tmppar = tmppar->Next();
  3996.    } 
  3997.  
  3998.    RedoParagraphs(sel_start_cursor, sel_end_cursor.par->Next());
  3999.    
  4000.    SetCursor(sel_start_cursor.par->Next(), 0);
  4001.  
  4002.    ClearSelection();
  4003. }
  4004.    
  4005.  
  4006. /* returns pointer to a specified row */
  4007. Row* LyXText::GetRow(LyXParagraph *par, int pos, long &y)
  4008. {
  4009.    Row* tmprow;
  4010.  
  4011.    if (currentrow){
  4012.      if (par == currentrow->par || par == currentrow->par->Previous()){
  4013.        while (currentrow->previous &&
  4014.           currentrow->previous->par != par->previous){
  4015.      currentrow = currentrow->previous;
  4016.      currentrow_y -= currentrow->height;
  4017.        }
  4018.      }
  4019.      tmprow = currentrow;
  4020.      y = currentrow_y;
  4021.      /* find the first row of the specified paragraph */ 
  4022.      while (tmprow->next && (tmprow->par != par)) {
  4023.        y += tmprow->height;
  4024.        tmprow = tmprow->next;
  4025.      }
  4026.  
  4027.      if (tmprow->par == par){
  4028.        /* now find the wanted row */ 
  4029.        while (tmprow->pos < pos && tmprow->next && tmprow->next->par == par && 
  4030.           tmprow->next->pos <= pos) {
  4031.      y += tmprow->height;
  4032.        tmprow = tmprow->next;
  4033.        }
  4034.        currentrow = tmprow;
  4035.        currentrow_y = y;
  4036.        return tmprow;
  4037.      }
  4038.    }
  4039.    tmprow = firstrow;
  4040.    y = 0;
  4041.    /* find the first row of the specified paragraph */ 
  4042.    while (tmprow->next && (tmprow->par != par)) {
  4043.       y += tmprow->height;
  4044.       tmprow = tmprow->next;
  4045.    }
  4046.  
  4047.    /* now find the wanted row */ 
  4048.    while (tmprow->pos < pos && tmprow->next && tmprow->next->par == par && 
  4049.       tmprow->next->pos <= pos) {
  4050.          y += tmprow->height;
  4051.          tmprow = tmprow->next;
  4052.    }
  4053.    
  4054.    currentrow = tmprow;
  4055.    currentrow_y = y;
  4056.  
  4057.    return tmprow;
  4058. }
  4059.