X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Ftext.C;h=0997ed241e06991a9c2f0843ee07a61b7de2a2ce;hb=664eb7ff45dbb4fabc22ec0b56798031a82335b1;hp=b584b3faf9b73770ad8253066e114361bdd9c6ab;hpb=7f1be334f16188342a7e37f5af92c916ba92309c;p=lyx.git diff --git a/src/text.C b/src/text.C index b584b3faf9..0997ed241e 100644 --- a/src/text.C +++ b/src/text.C @@ -11,134 +11,94 @@ #include #include #include +#include -#ifdef __GNUG__ -#pragma implementation "table.h" -#endif - +#include "lyxtext.h" #include "layout.h" #include "lyxparagraph.h" -#include "lyxtext.h" #include "support/textutils.h" #include "insets/insetbib.h" +#include "insets/insettext.h" #include "lyx_gui_misc.h" #include "gettext.h" #include "bufferparams.h" #include "buffer.h" -#include "minibuffer.h" #include "debug.h" #include "lyxrc.h" #include "LyXView.h" -#include "lyxrow.h" #include "Painter.h" #include "tracer.h" #include "font.h" +#include "encoding.h" +#include "lyxscreen.h" +#include "bufferview_funcs.h" +#include "language.h" +#include "lyxfunc.h" using std::max; using std::min; using std::endl; using std::pair; -static const int LYX_PAPER_MARGIN = 20; - - -// ale070405 -extern int bibitemMaxWidth(Painter &, LyXFont const &); - -#define FIX_DOUBLE_SPACE 1 - -static int iso885968x[] = { - 0xbc, // 0xa8 = fathatan - 0xbd, // 0xa9 = dammatan - 0xbe, // 0xaa = kasratan - 0xdb, // 0xab = fatha - 0xdc, // 0xac = damma - 0xdd, // 0xad = kasra - 0xde, // 0xae = shadda - 0xdf, // 0xaf = sukun - - 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // 0xb0-0xbf - - 0, // 0xc0 - 0xc1, // 0xc1 = hamza - 0xc2, // 0xc2 = ligature madda - 0xc3, // 0xc3 = ligature hamza on alef - 0xc4, // 0xc4 = ligature hamza on waw - 0xc5, // 0xc5 = ligature hamza under alef - 0xc0, // 0xc6 = ligature hamza on ya - 0xc7, // 0xc7 = alef - 0xeb, // 0xc8 = baa - 0xc9, // 0xc9 = taa marbuta - 0xec, // 0xca = taa - 0xed, // 0xcb = thaa - 0xee, // 0xcc = jeem - 0xef, // 0xcd = haa - 0xf0, // 0xce = khaa - 0xcf, // 0xcf = dal - - 0xd0, // 0xd0 = thal - 0xd1, // 0xd1 = ra - 0xd2, // 0xd2 = zain - 0xf1, // 0xd3 = seen - 0xf2, // 0xd4 = sheen - 0xf3, // 0xd5 = sad - 0xf4, // 0xd6 = dad - 0xd7, // 0xd7 = tah - 0xd8, // 0xd8 = zah - 0xf5, // 0xd9 = ain - 0xf6, // 0xda = ghain - 0,0,0,0,0, // 0xdb- 0xdf - - 0, // 0xe0 - 0xf7, // 0xe1 = fa - 0xf8, // 0xe2 = qaf - 0xf9, // 0xe3 = kaf - 0xfa, // 0xe4 = lam - 0xfb, // 0xe5 = meem - 0xfc, // 0xe6 = noon - 0xfd, // 0xe7 = ha - 0xe8, // 0xe8 = waw - 0xe9, // 0xe9 = alef maksura - 0xfe // 0xea = ya -}; - - -bool is_arabic(unsigned char c) +namespace { + +int const LYX_PAPER_MARGIN = 20; + +} // namespace anon + +extern int bibitemMaxWidth(BufferView *, LyXFont const &); + + +int LyXText::workWidth(BufferView * bview) const { - return 0xa8 <= c && c <= 0xea && iso885968x[c-0xa8]; + if (inset_owner) { + return inset_owner->textWidth(bview); + } + return bview->workWidth(); } -unsigned char LyXText::TransformChar(unsigned char c, Letter_Form form) const +int LyXText::GetRealCursorX(BufferView * bview) const { - if (is_arabic(c) && - (form == FORM_INITIAL || form == FORM_MEDIAL) ) - return iso885968x[c-0xa8]; - else - return c; + int x = cursor.x(); + if (the_locking_inset && (the_locking_inset->getLyXText(bview)!=this)) + x = the_locking_inset->getLyXText(bview)->GetRealCursorX(bview); + return x; } unsigned char LyXText::TransformChar(unsigned char c, LyXParagraph * par, LyXParagraph::size_type pos) const { - if (!is_arabic(c)) - if (isdigit(c)) + if (!Encodings::is_arabic(c)) + if (lyxrc.font_norm_type == LyXRC::ISO_8859_6_8 && isdigit(c)) return c + (0xb0 - '0'); else return c; - bool not_first = (pos > 0 && is_arabic(par->GetChar(pos-1))); - if (pos < par->Last()-1 && is_arabic(par->GetChar(pos+1))) - if (not_first) - return TransformChar(c,FORM_MEDIAL); + unsigned char const prev_char = pos > 0 ? par->GetChar(pos-1) : ' '; + unsigned char next_char = ' '; +#ifndef NEW_INSETS + for (LyXParagraph::size_type i = pos+1; i < par->Last(); ++i) +#else + for (LyXParagraph::size_type i = pos+1; i < par->size(); ++i) +#endif + if (!Encodings::IsComposeChar_arabic(par->GetChar(i))) { + next_char = par->GetChar(i); + break; + } + + if (Encodings::is_arabic(next_char)) { + if (Encodings::is_arabic(prev_char)) + return Encodings::TransformChar(c, Encodings::FORM_MEDIAL); else - return TransformChar(c,FORM_INITIAL); - else - if (not_first) - return TransformChar(c,FORM_FINAL); + return Encodings::TransformChar(c, Encodings::FORM_INITIAL); + } else { + if (Encodings::is_arabic(prev_char)) + return Encodings::TransformChar(c, Encodings::FORM_FINAL); else - return TransformChar(c,FORM_ISOLATED); + return Encodings::TransformChar(c, Encodings::FORM_ISOLATED); + } } // This is the comments that some of the warnings below refers to. @@ -166,29 +126,39 @@ unsigned char LyXText::TransformChar(unsigned char c, LyXParagraph * par, // // Lgb -int LyXText::SingleWidth(LyXParagraph * par, +int LyXText::SingleWidth(BufferView * bview, LyXParagraph * par, LyXParagraph::size_type pos) const { - char c = par->GetChar(pos); - return SingleWidth(par, pos, c); + char const c = par->GetChar(pos); + return SingleWidth(bview, par, pos, c); } -int LyXText::SingleWidth(LyXParagraph * par, +int LyXText::SingleWidth(BufferView * bview, LyXParagraph * par, LyXParagraph::size_type pos, char c) const { - LyXFont font = GetFont(par, pos); + LyXFont const font = GetFont(bview->buffer(), par, pos); // The most common case is handled first (Asger) if (IsPrintable(c)) { - if (font.language()->lang == "arabic" && - lyxrc.font_norm == "iso8859-6.8x") - c = TransformChar(c, par, pos); + if (font.language()->RightToLeft()) { + if (font.language()->lang() == "arabic" && + (lyxrc.font_norm_type == LyXRC::ISO_8859_6_8 || + lyxrc.font_norm_type == LyXRC::ISO_10646_1)) + if (Encodings::IsComposeChar_arabic(c)) + return 0; + else + c = TransformChar(c, par, pos); + else if (font.language()->lang() == "hebrew" && + Encodings::IsComposeChar_hebrew(c)) + return 0; + } return lyxfont::width(c, font); } else if (IsHfillChar(c)) { return 3; /* Because of the representation * as vertical lines */ +#ifndef NEW_INSETS } else if (c == LyXParagraph::META_FOOTNOTE || c == LyXParagraph::META_MARGIN || c == LyXParagraph::META_FIG || @@ -223,12 +193,13 @@ int LyXText::SingleWidth(LyXParagraph * par, font.decSize(); font.decSize(); return lyxfont::width(fs, font); +#endif } else if (c == LyXParagraph::META_INSET) { - Inset * tmpinset= par->GetInset(pos); - if (tmpinset) - return par->GetInset(pos)->width(owner_->painter(), - font); - else + Inset * tmpinset = par->GetInset(pos); + if (tmpinset) { + tmpinset->update(bview, font); + return tmpinset->width(bview, font); + } else return 0; } else if (IsSeparatorChar(c)) @@ -242,77 +213,100 @@ int LyXText::SingleWidth(LyXParagraph * par, // Returns the paragraph position of the last character in the specified row LyXParagraph::size_type LyXText::RowLast(Row const * row) const { - if (row->next == 0) - return row->par->Last() - 1; - else if (row->next->par != row->par) - return row->par->Last() - 1; +#ifndef NEW_INSETS + if (row->next() == 0) + return row->par()->Last() - 1; + else if (row->next()->par() != row->par()) + return row->par()->Last() - 1; + else + return row->next()->pos() - 1; +#else + if (row->next() == 0) + return row->par()->size() - 1; + else if (row->next()->par() != row->par()) + return row->par()->size() - 1; else - return row->next->pos - 1; + return row->next()->pos() - 1; +#endif } LyXParagraph::size_type LyXText::RowLastPrintable(Row const * row) const { - LyXParagraph::size_type last = RowLast(row); - if (last >= row->pos && row->next && row->next->par == row->par && - row->par->IsSeparator(last)) + LyXParagraph::size_type const last = RowLast(row); + if (last >= row->pos() + && row->next() + && row->next()->par() == row->par() + && row->par()->IsSeparator(last)) return last - 1; else return last; } -void LyXText::ComputeBidiTables(Row * row) const +void LyXText::ComputeBidiTables(Buffer const * buf, Row * row) const { bidi_same_direction = true; if (!lyxrc.rtl_support) { bidi_start = -1; return; } - LyXParagraph::size_type last = RowLastPrintable(row); - bidi_start = row->pos; - if (bidi_start > last) { + bidi_start = row->pos(); + bidi_end = RowLastPrintable(row); + + if (bidi_start > bidi_end) { bidi_start = -1; return; } - if (last + 2 - bidi_start > + if (bidi_end + 2 - bidi_start > static_cast(log2vis_list.size())) { LyXParagraph::size_type new_size = - (last + 2 - bidi_start < 500) ? - 500 : 2 * (last + 2 - bidi_start); + (bidi_end + 2 - bidi_start < 500) ? + 500 : 2 * (bidi_end + 2 - bidi_start); log2vis_list.resize(new_size); vis2log_list.resize(new_size); bidi_levels.resize(new_size); } - vis2log_list[last + 1 - bidi_start] = -1; - log2vis_list[last + 1 - bidi_start] = -1; + vis2log_list[bidi_end + 1 - bidi_start] = -1; + log2vis_list[bidi_end + 1 - bidi_start] = -1; LyXParagraph::size_type stack[2]; - bool rtl_par = row->par->getParLanguage()->RightToLeft; + bool const rtl_par = + row->par()->getParLanguage(buf->params)->RightToLeft(); int level = 0; bool rtl = false; bool rtl0 = false; - LyXParagraph::size_type main_body = BeginningOfMainBody(row->par); - - for (LyXParagraph::size_type lpos = bidi_start; lpos <= last; ++lpos) { - bool is_space = row->par->IsLineSeparator(lpos); - LyXParagraph::size_type pos = - (is_space && lpos+1 <= last && - (!row->par->table || !row->par->IsNewline(lpos+1)) ) + LyXParagraph::size_type const main_body = + BeginningOfMainBody(buf, row->par()); + + for (LyXParagraph::size_type lpos = bidi_start; + lpos <= bidi_end; ++lpos) { + bool is_space = row->par()->IsLineSeparator(lpos); + LyXParagraph::size_type const pos = + (is_space && lpos + 1 <= bidi_end && + !row->par()->IsLineSeparator(lpos + 1) && + !row->par()->IsNewline(lpos + 1)) ? lpos + 1 : lpos; - LyXFont font = row->par->GetFontSettings(pos); + LyXFont font = row->par()->GetFontSettings(buf->params, pos); + if (pos != lpos && 0 < lpos && rtl0 && font.isRightToLeft() && + font.number() == LyXFont::ON && + row->par()->GetFontSettings(buf->params, lpos-1).number() + == LyXFont::ON) { + font = row->par()->GetFontSettings(buf->params, lpos); + is_space = false; + } + + bool new_rtl = font.isVisibleRightToLeft(); bool new_rtl0 = font.isRightToLeft(); int new_level; - if (row->par->table && row->par->IsNewline(lpos)) { - new_level = 0; - new_rtl = new_rtl0 = false; - } else if (lpos == main_body - 1 && row->pos < main_body - 1 && - row->par->IsLineSeparator(lpos)) { + if (lpos == main_body - 1 + && row->pos() < main_body - 1 + && is_space) { new_level = (rtl_par) ? 1 : 0; new_rtl = new_rtl0 = rtl_par; } else if (new_rtl0) @@ -355,15 +349,16 @@ void LyXText::ComputeBidiTables(Row * row) const } while (level > 0) { - LyXParagraph::size_type old_lpos = stack[--level]; - int delta = last - old_lpos; + LyXParagraph::size_type const old_lpos = stack[--level]; + int delta = bidi_end - old_lpos; if (level % 2) delta = -delta; log2vis_list[old_lpos - bidi_start] += delta; } LyXParagraph::size_type vpos = bidi_start - 1; - for (LyXParagraph::size_type lpos = bidi_start; lpos <= last; ++lpos) { + for (LyXParagraph::size_type lpos = bidi_start; + lpos <= bidi_end; ++lpos) { vpos += log2vis_list[lpos - bidi_start]; vis2log_list[vpos - bidi_start] = lpos; log2vis_list[lpos - bidi_start] = vpos; @@ -371,23 +366,61 @@ void LyXText::ComputeBidiTables(Row * row) const } -void LyXText::draw(Row const * row, +// This method requires a previous call to ComputeBidiTables() +bool LyXText::IsBoundary(Buffer const * buf, LyXParagraph * par, + LyXParagraph::size_type pos) const +{ + if (!lyxrc.rtl_support || pos == 0) + return false; + + if (!bidi_InRange(pos - 1)) { + /// This can happen if pos is the first char of a row. + /// Returning false in this case is incorrect! + return false; + } + + bool const rtl = bidi_level(pos - 1) % 2; + bool const rtl2 = bidi_InRange(pos) + ? bidi_level(pos) % 2 + : par->isRightToLeftPar(buf->params); + return rtl != rtl2; +} + + +bool LyXText::IsBoundary(Buffer const * buf, LyXParagraph * par, + LyXParagraph::size_type pos, + LyXFont const & font) const +{ + if (!lyxrc.rtl_support) + return false; // This is just for speedup + + bool const rtl = font.isVisibleRightToLeft(); + bool const rtl2 = bidi_InRange(pos) + ? bidi_level(pos) % 2 + : par->isRightToLeftPar(buf->params); + return rtl != rtl2; +} + + +void LyXText::draw(BufferView * bview, Row const * row, LyXParagraph::size_type & vpos, - int offset, float & x) + int offset, float & x, bool cleared) { - Painter & pain = owner_->painter(); + Painter & pain = bview->painter(); LyXParagraph::size_type pos = vis2log(vpos); - char c = row->par->GetChar(pos); + char c = row->par()->GetChar(pos); + float tmpx = x; if (IsNewlineChar(c)) { ++vpos; // Draw end-of-line marker - LyXFont font = GetFont(row->par, pos); - int wid = lyxfont::width('n', font); - int asc = lyxfont::maxAscent(font); - int y = offset + row->baseline; - int xp[3], yp[3]; + LyXFont const font = GetFont(bview->buffer(), row->par(), pos); + int const wid = lyxfont::width('n', font); + int const asc = lyxfont::maxAscent(font); + int const y = offset + row->baseline(); + int xp[3]; + int yp[3]; if (bidi_level(pos) % 2 == 0) { xp[0] = int(x + wid * 0.375); @@ -438,9 +471,9 @@ void LyXText::draw(Row const * row, return; } - LyXFont font = GetFont(row->par, pos); + LyXFont font = GetFont(bview->buffer(), row->par(), pos); LyXFont font2 = font; - +#ifndef NEW_INSETS if (c == LyXParagraph::META_FOOTNOTE || c == LyXParagraph::META_MARGIN || c == LyXParagraph::META_FIG @@ -452,10 +485,6 @@ void LyXText::draw(Row const * row, switch (c) { case LyXParagraph::META_MARGIN: fs = "margin"; - // Draw a sign at the left margin! - owner_->painter() - .text((LYX_PAPER_MARGIN - lyxfont::width('!', font))/2, - offset + row->baseline, "!", 1, font); break; case LyXParagraph::META_FIG: fs = "fig"; @@ -480,30 +509,45 @@ void LyXText::draw(Row const * row, font.decSize(); // calculate the position of the footnotemark - int y = (row->baseline - lyxfont::maxAscent(font2) - + lyxfont::maxAscent(font)); + int const y = (row->baseline() - lyxfont::maxAscent(font2) + + lyxfont::maxAscent(font)); font.setColor(LColor::footnote); - float tmpx = x; - // draw it and set new x position pain.text(int(x), offset + y, fs, font); x += lyxfont::width(fs, font); - pain.line(int(tmpx), offset + row->baseline, - int(x), offset + row->baseline, + pain.line(int(tmpx), offset + row->baseline(), + int(x), offset + row->baseline(), LColor::footnote); ++vpos; return; - } else if (c == LyXParagraph::META_INSET) { - Inset * tmpinset = row->par->GetInset(pos); + } else +#endif + if (c == LyXParagraph::META_INSET) { + Inset * tmpinset = row->par()->GetInset(pos); if (tmpinset) { - tmpinset->draw(owner_->painter(), font, - offset + row->baseline, x); +// tmpinset->update(bview, font, false); + tmpinset->draw(bview, font, offset+row->baseline(), x, + cleared); +#ifdef SEEMS_TO_BE_NOT_NEEDED + if (status == CHANGED_IN_DRAW) { + UpdateInset(bview, tmpinset); + status = CHANGED_IN_DRAW; + } +#endif } ++vpos; + + if (lyxrc.mark_foreign_language && + font.language() != bview->buffer()->params.language) { + int const y = offset + row->height() - 1; + pain.line(int(tmpx), y, int(x), y, + LColor::language); + } + return; } @@ -520,37 +564,105 @@ void LyXText::draw(Row const * row, // So IMHO we should go with the easier and clearer implementation. // And even if 1024 is a large number here it might overflow, string // will only overflow if the machine is out of memory... - bool do_transform = - font2.language()->lang == "arabic" && - lyxrc.font_norm == "iso8859-6.8x"; - if (do_transform) - c = TransformChar(c, row->par, pos); static string textstring; textstring = c; ++vpos; - LyXParagraph::size_type last = RowLastPrintable(row); - - while (vpos <= last && - (pos = vis2log(vpos)) >= 0 - && static_cast(c = row->par->GetChar(pos)) > ' ' - && font2 == GetFont(row->par, pos)) { - if (do_transform) - c = TransformChar(c, row->par, pos); - textstring += c; - ++vpos; + LyXParagraph::size_type const last = RowLastPrintable(row); + + if (font.language()->lang() == "hebrew") { + if (Encodings::IsComposeChar_hebrew(c)) { + int const width = lyxfont::width(c, font2); + int dx = 0; + for (LyXParagraph::size_type i = pos-1; i >= 0; --i) { + c = row->par()->GetChar(i); + if (!Encodings::IsComposeChar_hebrew(c)) { + if (IsPrintableNonspace(c)) { + int const width2 = + SingleWidth(bview, + row->par(), + i, c); + dx = (c == 'ø' || c == 'ã') // dalet / resh + ? width2 - width : (width2 - width) / 2; + } + break; + } + } + // Draw nikud + pain.text(int(x) + dx, offset + row->baseline(), + textstring, font); + } else { + while (vpos <= last && + (pos = vis2log(vpos)) >= 0 + && IsPrintableNonspace(c = row->par()->GetChar(pos)) + && !Encodings::IsComposeChar_hebrew(c) + && font2 == GetFont(bview->buffer(), row->par(), pos)) { + textstring += c; + ++vpos; + } + // Draw text and set the new x position + pain.text(int(x), offset + row->baseline(), + textstring, font); + x += lyxfont::width(textstring, font); + } + } else if (font.language()->lang() == "arabic" && + (lyxrc.font_norm_type == LyXRC::ISO_8859_6_8 || + lyxrc.font_norm_type == LyXRC::ISO_10646_1)) { + if (Encodings::IsComposeChar_arabic(c)) { + c = TransformChar(c, row->par(), pos); + textstring = c; + int const width = lyxfont::width(c, font2); + int dx = 0; + for (LyXParagraph::size_type i = pos-1; i >= 0; --i) { + c = row->par()->GetChar(i); + if (!Encodings::IsComposeChar_arabic(c)) { + if (IsPrintableNonspace(c)) { + int const width2 = + SingleWidth(bview, + row->par(), + i, c); + dx = (width2 - width) / 2; + } + break; + } + } + // Draw nikud + pain.text(int(x) + dx, offset + row->baseline(), + textstring, font); + } else { + textstring = TransformChar(c, row->par(), pos); + while (vpos <= last && + (pos = vis2log(vpos)) >= 0 + && IsPrintableNonspace(c = row->par()->GetChar(pos)) + && !Encodings::IsComposeChar_arabic(c) + && font2 == GetFont(bview->buffer(), row->par(), pos)) { + c = TransformChar(c, row->par(), pos); + textstring += c; + ++vpos; + } + // Draw text and set the new x position + pain.text(int(x), offset + row->baseline(), + textstring, font); + x += lyxfont::width(textstring, font); + } + } else { + while (vpos <= last && + (pos = vis2log(vpos)) >= 0 + && IsPrintableNonspace(c = row->par()->GetChar(pos)) + && font2 == GetFont(bview->buffer(), row->par(), pos)) { + textstring += c; + ++vpos; + } + // Draw text and set the new x position + pain.text(int(x), offset + row->baseline(), textstring, font); + x += lyxfont::width(textstring, font); } - float tmpx = x; - // Draw text and set the new x position - pain.text(int(x), offset + row->baseline, textstring, font); - x += lyxfont::width(textstring, font); - - // what about underbars? - if (font.underbar() == LyXFont::ON && font.latex() != LyXFont::ON) { - pain.line(tmpx, offset + row->baseline + 2, - x, offset + row->baseline + 2); - + if (lyxrc.mark_foreign_language && + font.language() != bview->buffer()->params.language) { + int const y = offset + row->height() - 1; + pain.line(int(tmpx), y, int(x), y, + LColor::language); } // If we want ulem.sty support, drawing @@ -563,130 +675,150 @@ void LyXText::draw(Row const * row, // This information cannot be taken from the layouts-objekt, because in // LaTeX the beginning of the text fits in some cases (for example sections) // exactly the label-width. -int LyXText::LeftMargin(Row const * row) const +int LyXText::LeftMargin(BufferView * bview, Row const * row) const { - LyXLayout const & layout = textclasslist.Style(bparams->textclass, - row->par->GetLayout()); + LyXLayout const & layout = + textclasslist.Style(bview->buffer()->params.textclass, + row->par()->GetLayout()); string parindent = layout.parindent; - - /* table stuff -- begin */ - if (row->par->table) - parindent.clear(); - /* table stuff -- end */ - + int x = LYX_PAPER_MARGIN; x += lyxfont::signedWidth(textclasslist - .TextClass(bparams->textclass) + .TextClass(bview->buffer()->params.textclass) .leftmargin(), textclasslist - .TextClass(bparams->textclass) + .TextClass(bview->buffer()->params.textclass) .defaultfont()); - - if (row->par->footnoteflag == LyXParagraph::OPEN_FOOTNOTE) { +#ifndef NEW_INSETS + if (row->par()->footnoteflag == LyXParagraph::OPEN_FOOTNOTE) { LyXFont font(LyXFont::ALL_SANE); font.setSize(LyXFont::SIZE_SMALL); x += lyxfont::width("Mwide-figM", font) + LYX_PAPER_MARGIN/2; } - +#endif // this is the way, LyX handles the LaTeX-Environments. // I have had this idea very late, so it seems to be a // later added hack and this is true - if (!row->par->GetDepth()) { - if (!row->par->GetLayout()) { + if (!row->par()->GetDepth()) { + if (!row->par()->GetLayout()) { // find the previous same level paragraph - if (row->par->FirstPhysicalPar()->Previous()) { - LyXParagraph * newpar = row->par - ->DepthHook(row->par->GetDepth()); +#ifndef NEW_INSETS + if (row->par()->FirstPhysicalPar()->previous()) { +#else + if (row->par()->previous()) { +#endif + LyXParagraph * newpar = row->par() + ->DepthHook(row->par()->GetDepth()); if (newpar && - textclasslist.Style(bparams->textclass, + textclasslist.Style(bview->buffer()->params.textclass, newpar->GetLayout()) .nextnoindent) - parindent.clear(); + parindent.erase(); } } } else { // find the next level paragraph - LyXParagraph * newpar = row->par->DepthHook(row->par->GetDepth()-1); + LyXParagraph * newpar = + row->par()->DepthHook(row->par()->GetDepth()-1); // make a corresponding row. Needed to call LeftMargin() // check wether it is a sufficent paragraph - if (newpar && newpar->footnoteflag == row->par->footnoteflag + if (newpar +#ifndef NEW_INSETS + && newpar->footnoteflag == row->par()->footnoteflag +#endif && textclasslist - .Style(bparams->textclass, + .Style(bview->buffer()->params.textclass, newpar->GetLayout()).isEnvironment()) { Row dummyrow; - dummyrow.par = newpar; - dummyrow.pos = newpar->Last(); - x = LeftMargin(&dummyrow); + dummyrow.par(newpar); +#ifndef NEW_INSETS + dummyrow.pos(newpar->Last()); +#else + dummyrow.pos(newpar->size()); +#endif + x = LeftMargin(bview, &dummyrow); } else { // this is no longer an error, because this function // is used to clear impossible depths after changing // a layout. Since there is always a redo, // LeftMargin() is always called - row->par->FirstPhysicalPar()->depth = 0; +#ifndef NEW_INSETS + row->par()->FirstPhysicalPar()->params.depth(0); +#else + row->par()->params.depth(0); +#endif } - if (newpar && !row->par->GetLayout()) { - if (newpar->FirstPhysicalPar()->noindent) - parindent.clear(); + if (newpar && !row->par()->GetLayout()) { +#ifndef NEW_INSETS + if (newpar->FirstPhysicalPar()->params.noindent()) +#else + if (newpar->params.noindent()) +#endif + parindent.erase(); else parindent = textclasslist - .Style(bparams->textclass, + .Style(bview->buffer()->params.textclass, newpar->GetLayout()).parindent; } } - LyXFont labelfont = GetFont(row->par, -2); + LyXFont const labelfont = GetFont(bview->buffer(), row->par(), -2); switch (layout.margintype) { case MARGIN_DYNAMIC: if (!layout.leftmargin.empty()) { x += lyxfont::signedWidth(layout.leftmargin, textclasslist - .TextClass(bparams-> + .TextClass(bview->buffer()->params. textclass) .defaultfont()); } - if (!row->par->GetLabelstring().empty()) { + if (!row->par()->GetLabelstring().empty()) { x += lyxfont::signedWidth(layout.labelindent, labelfont); - x += lyxfont::width(row->par->GetLabelstring(), labelfont); + x += lyxfont::width(row->par()->GetLabelstring(), + labelfont); x += lyxfont::width(layout.labelsep, labelfont); } break; case MARGIN_MANUAL: x += lyxfont::signedWidth(layout.labelindent, labelfont); - if (row->pos >= BeginningOfMainBody(row->par)) { - if (!row->par->GetLabelWidthString().empty()) { - x += lyxfont::width(row->par->GetLabelWidthString(), + if (row->pos() >= BeginningOfMainBody(bview->buffer(), row->par())) { + if (!row->par()->GetLabelWidthString().empty()) { + x += lyxfont::width(row->par()->GetLabelWidthString(), labelfont); x += lyxfont::width(layout.labelsep, labelfont); } } break; case MARGIN_STATIC: - x += lyxfont::signedWidth(layout.leftmargin, textclasslist.TextClass(bparams->textclass).defaultfont()) * 4 - / (row->par->GetDepth() + 4); + x += lyxfont::signedWidth(layout.leftmargin, textclasslist.TextClass(bview->buffer()->params.textclass).defaultfont()) * 4 + / (row->par()->GetDepth() + 4); break; case MARGIN_FIRST_DYNAMIC: if (layout.labeltype == LABEL_MANUAL) { - if (row->pos >= BeginningOfMainBody(row->par)) { - x += lyxfont::signedWidth(layout.leftmargin, labelfont); + if (row->pos() >= BeginningOfMainBody(bview->buffer(), row->par())) { + x += lyxfont::signedWidth(layout.leftmargin, + labelfont); } else { - x += lyxfont::signedWidth(layout.labelindent, labelfont); + x += lyxfont::signedWidth(layout.labelindent, + labelfont); } - } else if (row->pos + } else if (row->pos() // Special case to fix problems with // theorems (JMarc) || (layout.labeltype == LABEL_STATIC && layout.latextype == LATEX_ENVIRONMENT - && ! row->par->IsFirstInSequence())) { - x += lyxfont::signedWidth(layout.leftmargin, labelfont); + && ! row->par()->IsFirstInSequence())) { + x += lyxfont::signedWidth(layout.leftmargin, + labelfont); } else if (layout.labeltype != LABEL_TOP_ENVIRONMENT && layout.labeltype != LABEL_BIBLIO && layout.labeltype != @@ -694,7 +826,8 @@ int LyXText::LeftMargin(Row const * row) const x += lyxfont::signedWidth(layout.labelindent, labelfont); x += lyxfont::width(layout.labelsep, labelfont); - x += lyxfont::width(row->par->GetLabelstring(), labelfont); + x += lyxfont::width(row->par()->GetLabelstring(), + labelfont); } break; @@ -706,147 +839,178 @@ int LyXText::LeftMargin(Row const * row) const // find the first row of this paragraph Row const * tmprow = row; - while (tmprow->previous && tmprow->previous->par == row->par) - tmprow = tmprow->previous; + while (tmprow->previous() + && tmprow->previous()->par() == row->par()) + tmprow = tmprow->previous(); - int minfill = tmprow->fill; - while (tmprow->next && tmprow->next->par == row->par) { - tmprow = tmprow->next; - if (tmprow->fill < minfill) - minfill = tmprow->fill; + int minfill = tmprow->fill(); + while (tmprow->next() && tmprow->next()->par() == row->par()) { + tmprow = tmprow->next(); + if (tmprow->fill() < minfill) + minfill = tmprow->fill(); } x += lyxfont::signedWidth(layout.leftmargin, textclasslist - .TextClass(bparams->textclass) + .TextClass(bview->buffer()->params.textclass) .defaultfont()); x += minfill; } break; } - if (row->par->pextra_type == LyXParagraph::PEXTRA_INDENT) { - if (!row->par->pextra_widthp.empty()) { - x += paperwidth * - atoi(row->par->pextra_widthp.c_str()) / 100; - } else if (!row->par->pextra_width.empty()) { - int xx = VSpace(row->par->pextra_width).inPixels(owner_); - - if (xx > paperwidth) - xx = paperwidth * 80 / 100; +#ifndef NO_PEXTRA + if ((workWidth(bview) > 0) && + (row->par()->params.pextraType() == LyXParagraph::PEXTRA_INDENT)) { + if (!row->par()->params.pextraWidthp().empty()) { + x += workWidth(bview) * + lyx::atoi(row->par()->params.pextraWidthp()) / 100; + } else if (!row->par()->params.pextraWidth().empty()) { + int xx = VSpace(row->par()->params.pextraWidth()).inPixels(bview); + if (xx > workWidth(bview)) + xx = workWidth(bview) * 80 / 100; x += xx; } else { // should not happen LyXFont font(LyXFont::ALL_SANE); x += lyxfont::width("XXXXXX", font); } } +#endif int align; // wrong type - if (row->par->FirstPhysicalPar()->align == LYX_ALIGN_LAYOUT) +#ifndef NEW_INSETS + if (row->par()->FirstPhysicalPar()->params.align() == LYX_ALIGN_LAYOUT) align = layout.align; else - align = row->par->FirstPhysicalPar()->align; - + align = row->par()->FirstPhysicalPar()->params.align(); +#else + if (row->par()->params.align() == LYX_ALIGN_LAYOUT) + align = layout.align; + else + align = row->par()->params.align(); +#endif // set the correct parindent - if (row->pos == 0) { + if (row->pos() == 0) { if ((layout.labeltype == LABEL_NO_LABEL || layout.labeltype == LABEL_TOP_ENVIRONMENT || layout.labeltype == LABEL_CENTERED_TOP_ENVIRONMENT || (layout.labeltype == LABEL_STATIC && layout.latextype == LATEX_ENVIRONMENT - && ! row->par->IsFirstInSequence())) - && row->par == row->par->FirstPhysicalPar() + && ! row->par()->IsFirstInSequence())) +#ifndef NEW_INSETS + && row->par() == row->par()->FirstPhysicalPar() +#endif && align == LYX_ALIGN_BLOCK - && !row->par->noindent - && (row->par->layout || - bparams->paragraph_separation == + && !row->par()->params.noindent() + && (row->par()->layout || + bview->buffer()->params.paragraph_separation == BufferParams::PARSEP_INDENT)) x += lyxfont::signedWidth(parindent, textclasslist - .TextClass(bparams - ->textclass) + .TextClass(bview->buffer()->params + .textclass) .defaultfont()); else if (layout.labeltype == LABEL_BIBLIO) { // ale970405 Right width for bibitems - x += bibitemMaxWidth(owner_->painter(), - textclasslist - .TextClass(bparams - ->textclass) + x += bibitemMaxWidth(bview,textclasslist + .TextClass(bview->buffer()->params + .textclass) .defaultfont()); } } return x; } - - -int LyXText::RightMargin(Row const * row) const + + +int LyXText::RightMargin(Buffer const * buf, Row const * row) const { LyXLayout const & layout = - textclasslist.Style(bparams->textclass, - row->par->GetLayout()); + textclasslist.Style(buf->params.textclass, + row->par()->GetLayout()); int x = LYX_PAPER_MARGIN + lyxfont::signedWidth(textclasslist - .TextClass(bparams->textclass) + .TextClass(buf->params.textclass) .rightmargin(), textclasslist - .TextClass(bparams->textclass) + .TextClass(buf->params.textclass) .defaultfont()); - - if (row->par->footnoteflag == LyXParagraph::OPEN_FOOTNOTE) { + +#ifndef NEW_INSETS + if (row->par()->footnoteflag == LyXParagraph::OPEN_FOOTNOTE) { x += LYX_PAPER_MARGIN / 2; } - +#endif // this is the way, LyX handles the LaTeX-Environments. // I have had this idea very late, so it seems to be a // later added hack and this is true - if (row->par->GetDepth()) { + if (row->par()->GetDepth()) { // find the next level paragraph - LyXParagraph * newpar = row->par; + LyXParagraph * newpar = row->par(); +#ifndef NEW_INSETS do { - newpar = newpar->FirstPhysicalPar()->Previous(); + newpar = newpar->FirstPhysicalPar()->previous(); if (newpar) newpar = newpar->FirstPhysicalPar(); - } while (newpar && newpar->GetDepth() >= row->par->GetDepth() - && newpar->footnoteflag == row->par->footnoteflag); + } while (newpar && newpar->GetDepth() >= row->par()->GetDepth() + && newpar->footnoteflag == row->par()->footnoteflag); +#else + do { + newpar = newpar->previous(); + } while (newpar + && newpar->GetDepth() >= row->par()->GetDepth()); +#endif // make a corresponding row. Needed to call LeftMargin() // check wether it is a sufficent paragraph - if (newpar && newpar->footnoteflag == row->par->footnoteflag - && textclasslist.Style(bparams->textclass, + if (newpar +#ifndef NEW_INSETS + && newpar->footnoteflag == row->par()->footnoteflag +#endif + && textclasslist.Style(buf->params.textclass, newpar->GetLayout()) .isEnvironment()) { Row dummyrow; - dummyrow.par = newpar; - dummyrow.pos = 0; - x = RightMargin(&dummyrow); + dummyrow.par(newpar); + dummyrow.pos(0); + x = RightMargin(buf, &dummyrow); } else { // this is no longer an error, because this function // is used to clear impossible depths after changing // a layout. Since there is always a redo, // LeftMargin() is always called - row->par->FirstPhysicalPar()->depth = 0; +#ifndef NEW_INSETS + row->par()->FirstPhysicalPar()->params.depth(0); +#else + row->par()->params.depth(0); +#endif } } //lyxerr << "rightmargin: " << layout->rightmargin << endl; - x += lyxfont::signedWidth(layout.rightmargin, textclasslist.TextClass(bparams->textclass).defaultfont()) * 4 - / (row->par->GetDepth() + 4); + x += lyxfont::signedWidth(layout.rightmargin, textclasslist + .TextClass(buf->params.textclass) + .defaultfont()) * 4 / (row->par()->GetDepth() + + 4); return x; } -int LyXText::LabelEnd (Row const * row) const +int LyXText::LabelEnd(BufferView * bview, Row const * row) const { - if (textclasslist.Style(bparams->textclass, - row->par->GetLayout()).margintype + if (textclasslist.Style(bview->buffer()->params.textclass, + row->par()->GetLayout()).margintype == MARGIN_MANUAL) { Row tmprow; tmprow = *row; - tmprow.pos = row->par->Last(); - return LeftMargin(&tmprow); /* just the beginning +#ifndef NEW_INSETS + tmprow.pos(row->par()->Last()); +#else + tmprow.pos(row->par()->size()); +#endif + return LeftMargin(bview, &tmprow); /* just the beginning of the main body */ } else return 0; /* LabelEnd is only needed, if the @@ -855,95 +1019,47 @@ int LyXText::LabelEnd (Row const * row) const } -/* table stuff -- begin*/ -int LyXText::NumberOfCell(LyXParagraph * par, - LyXParagraph::size_type pos) const -{ - int cell = 0; - LyXParagraph::size_type tmp_pos = 0; - while (tmp_pos < pos) { - if (par->IsNewline(tmp_pos)) - ++cell; - ++tmp_pos; - } - return cell; -} - - -int LyXText::WidthOfCell(LyXParagraph * par, - LyXParagraph::size_type & pos) const -{ - int w = 0; - while (pos < par->Last() && !par->IsNewline(pos)) { - w += SingleWidth(par, pos); - ++pos; - } - if (par->IsNewline(pos)) - ++pos; - return w; -} - - -bool LyXText::HitInTable(Row * row, int x) const -{ - float tmpx; - float fill_separator, fill_hfill, fill_label_hfill; - if (!row->par->table) - return false; - PrepareToPrint(row, tmpx, fill_separator, - fill_hfill, fill_label_hfill, false); - return (x > tmpx && x < tmpx + row->par->table->WidthOfTable()); -} - - -bool LyXText::MouseHitInTable(int x, long y) const +// get the next breakpoint in a given paragraph +LyXParagraph::size_type +LyXText::NextBreakPoint(BufferView * bview, Row const * row, int width) const { - Row * row = GetRowNearY(y); - return HitInTable(row, x); -} + LyXParagraph * par = row->par(); + if (width < 0) +#ifndef NEW_INSETS + return par->Last(); +#else + return par->size(); +#endif -/* table stuff -- end*/ + LyXParagraph::size_type const pos = row->pos(); -// get the next breakpoint in a given paragraph -LyXParagraph::size_type -LyXText::NextBreakPoint(Row const * row, int width) const -{ - LyXParagraph * par = row->par; - LyXParagraph::size_type pos = row->pos; - - /* table stuff -- begin*/ - if (par->table) { - while (pos < par->size() - && (!par->IsNewline(pos) - || !par->table->IsFirstCell(NumberOfCell(par, pos+1)))) { - if (par->GetChar(pos) == LyXParagraph::META_INSET && - par->GetInset(pos) && par->GetInset(pos)->display()){ - par->GetInset(pos)->display(false); - } - ++pos; - } - return pos; - } - /* table stuff -- end*/ - // position of the last possible breakpoint // -1 isn't a suitable value, but a flag LyXParagraph::size_type last_separator = -1; - width -= RightMargin(row); + width -= RightMargin(bview->buffer(), row); - LyXParagraph::size_type main_body = BeginningOfMainBody(par); + LyXParagraph::size_type const main_body = + BeginningOfMainBody(bview->buffer(), par); LyXLayout const & layout = - textclasslist.Style(bparams->textclass, par->GetLayout()); + textclasslist.Style(bview->buffer()->params.textclass, par->GetLayout()); LyXParagraph::size_type i = pos; if (layout.margintype == MARGIN_RIGHT_ADDRESS_BOX) { /* special code for right address boxes, only newlines count */ +#ifndef NEW_INSETS while (i < par->Last()) { +#else + while (i < par->size()) { +#endif if (par->IsNewline(i)) { last_separator = i; +#ifndef NEW_INSETS i = par->Last() - 1; // this means break +#else + i = par->size() - 1; // this means break +#endif //x = width; } else if (par->GetChar(i) == LyXParagraph::META_INSET && par->GetInset(i) && par->GetInset(i)->display()){ @@ -953,29 +1069,39 @@ LyXText::NextBreakPoint(Row const * row, int width) const } } else { // Last position is an invariant +#ifndef NEW_INSETS LyXParagraph::size_type const last = par->Last(); +#else + LyXParagraph::size_type const last = + par->size(); +#endif // this is the usual handling - int x = LeftMargin(row); - while (x < width && i < last) { - char c = par->GetChar(i); + int x = LeftMargin(bview, row); + bool doitonetime = true; + while (doitonetime || ((x < width) && (i < last))) { + doitonetime = false; + char const c = par->GetChar(i); if (IsNewlineChar(c)) { last_separator = i; x = width; // this means break } else if (c == LyXParagraph::META_INSET && - par->GetInset(i) && par->GetInset(i)->display()){ + par->GetInset(i)) { + // check wether a Display() inset is // valid here. if not, change it to // non-display - if (layout.isCommand() - || (layout.labeltype == LABEL_MANUAL - && i < BeginningOfMainBody(par))){ + if (par->GetInset(i)->display() && + (layout.isCommand() || + (layout.labeltype == LABEL_MANUAL + && i < BeginningOfMainBody(bview->buffer(), par)))) { // display istn't allowd par->GetInset(i)->display(false); - x += SingleWidth(par, i, c); - } else { - // inset is display. So break the line here - if (i == pos){ + x += SingleWidth(bview, par, i, c); + } else if (par->GetInset(i)->display() || + par->GetInset(i)->needFullRow()) { + // So break the line here + if (i == pos) { if (pos < last-1) { last_separator = i; if (IsLineSeparatorChar(par->GetChar(i+1))) @@ -985,19 +1111,26 @@ LyXText::NextBreakPoint(Row const * row, int width) const } else last_separator = i - 1; x = width; // this means break + } else { +#if 0 + last_separator = i; + x += width; +#else + x += SingleWidth(bview, par, i, c); +#endif } } else { if (IsLineSeparatorChar(c)) last_separator = i; - x += SingleWidth(par, i, c); + x += SingleWidth(bview, par, i, c); } ++i; if (i == main_body) { x += lyxfont::width(layout.labelsep, - GetFont(par, -2)); + GetFont(bview->buffer(), par, -2)); if (par->IsLineSeparator(i - 1)) - x-= SingleWidth(par, i - 1); - int left_margin = LabelEnd(row); + x-= SingleWidth(bview, par, i - 1); + int left_margin = LabelEnd(bview, row); if (x < left_margin) x = left_margin; } @@ -1022,83 +1155,64 @@ LyXText::NextBreakPoint(Row const * row, int width) const // returns the minimum space a row needs on the screen in pixel -int LyXText::Fill(Row const * row, int paper_width) const +int LyXText::Fill(BufferView * bview, Row * row, int paper_width) const { - int w, fill; - // get the pure distance - LyXParagraph::size_type last = RowLastPrintable(row); - /* table stuff -- begin */ - if (row->par->table) { - // for tables FILL does calculate the widthes of each cell in - // the row - LyXParagraph::size_type pos = row->pos; - int cell = NumberOfCell(row->par, pos); - w = 0; - do { - row->par->table->SetWidthOfCell(cell, - WidthOfCell(row->par, - pos)); - ++cell; - } while (pos <= last && !row->par->table->IsFirstCell(cell)); - // don't forget the very last table cell without characters - if (cell == row->par->table->GetNumberOfCells() - 1) - row->par->table->SetWidthOfCell(cell, - WidthOfCell(row->par, - pos)); - - return 0; /* width of table cannot be returned since - * we cannot guarantee its correct value at - * this point. */ - } - /* table stuff -- end*/ + if (paper_width < 0) + return 20; + int w; + // get the pure distance + LyXParagraph::size_type const last = RowLastPrintable(row); + // special handling of the right address boxes - if (textclasslist.Style(bparams->textclass, - row->par->GetLayout()).margintype + if (textclasslist.Style(bview->buffer()->params.textclass, + row->par()->GetLayout()).margintype == MARGIN_RIGHT_ADDRESS_BOX) { - int tmpfill = row->fill; - row->fill = 0; // the minfill in MarginLeft() - w = LeftMargin(row); - row->fill = tmpfill; + int const tmpfill = row->fill(); + row->fill(0); // the minfill in MarginLeft() + w = LeftMargin(bview, row); + row->fill(tmpfill); } else - w = LeftMargin(row); + w = LeftMargin(bview, row); - LyXLayout const & layout = textclasslist.Style(bparams->textclass, - row->par->GetLayout()); - LyXParagraph::size_type main_body = - BeginningOfMainBody(row->par); - LyXParagraph::size_type i = row->pos; + LyXLayout const & layout = textclasslist.Style(bview->buffer()->params.textclass, + row->par()->GetLayout()); + LyXParagraph::size_type const main_body = + BeginningOfMainBody(bview->buffer(), row->par()); + LyXParagraph::size_type i = row->pos(); while (i <= last) { if (main_body > 0 && i == main_body) { - w += lyxfont::width(layout.labelsep, GetFont(row->par, -2)); - if (row->par->IsLineSeparator(i - 1)) - w -= SingleWidth(row->par, i - 1); - int left_margin = LabelEnd(row); + w += lyxfont::width(layout.labelsep, GetFont(bview->buffer(), row->par(), -2)); + if (row->par()->IsLineSeparator(i - 1)) + w -= SingleWidth(bview, row->par(), i - 1); + int left_margin = LabelEnd(bview, row); if (w < left_margin) w = left_margin; } - w += SingleWidth(row->par, i); + w += SingleWidth(bview, row->par(), i); ++i; } if (main_body > 0 && main_body > last) { - w += lyxfont::width(layout.labelsep, GetFont(row->par, -2)); - if (last >= 0 && row->par->IsLineSeparator(last)) - w -= SingleWidth(row->par, last); - int left_margin = LabelEnd(row); + w += lyxfont::width(layout.labelsep, GetFont(bview->buffer(), row->par(), -2)); + if (last >= 0 && row->par()->IsLineSeparator(last)) + w -= SingleWidth(bview, row->par(), last); + int const left_margin = LabelEnd(bview, row); if (w < left_margin) w = left_margin; } - fill = paper_width - w - RightMargin(row); + int const fill = paper_width - w - RightMargin(bview->buffer(), row); + if (fill < 0) + return 0; return fill; } // returns the minimum space a manual label needs on the screen in pixel -int LyXText::LabelFill(Row const * row) const +int LyXText::LabelFill(BufferView * bview, Row const * row) const { - LyXParagraph::size_type last = BeginningOfMainBody(row->par) - 1; + LyXParagraph::size_type last = BeginningOfMainBody(bview->buffer(), row->par()) - 1; // -1 because a label ends either with a space that is in the label, // or with the beginning of a footnote that is outside the label. @@ -1109,21 +1223,21 @@ int LyXText::LabelFill(Row const * row) const // environment with a manual label. (Asger) if (last < 0) last = 0; - if (row->par->IsLineSeparator(last)) /* a sepearator at this end + if (row->par()->IsLineSeparator(last)) /* a sepearator at this end does not count */ --last; int w = 0; - int i = row->pos; + int i = row->pos(); while (i <= last) { - w += SingleWidth(row->par, i); + w += SingleWidth(bview, row->par(), i); ++i; } int fill = 0; - if (!row->par->labelwidthstring.empty()) { - fill = max(lyxfont::width(row->par->labelwidthstring, - GetFont(row->par, -2)) - w, + if (!row->par()->params.labelWidthString().empty()) { + fill = max(lyxfont::width(row->par()->params.labelWidthString(), + GetFont(bview->buffer(), row->par(), -2)) - w, 0); } @@ -1133,13 +1247,14 @@ int LyXText::LabelFill(Row const * row) const // returns the number of separators in the specified row. The separator // on the very last column doesnt count -int LyXText::NumberOfSeparators(Row const * row) const +int LyXText::NumberOfSeparators(Buffer const * buf, Row const * row) const { - int last = RowLast(row); - int p = max(row->pos, BeginningOfMainBody(row->par)); + LyXParagraph::size_type const last = RowLast(row); + LyXParagraph::size_type p = + max(row->pos(), BeginningOfMainBody(buf, row->par())); int n = 0; for (; p < last; ++p) { - if (row->par->IsSeparator(p)) { + if (row->par()->IsSeparator(p)) { ++n; } } @@ -1150,20 +1265,20 @@ int LyXText::NumberOfSeparators(Row const * row) const // returns the number of hfills in the specified row. The LyX-Hfill is // a LaTeX \hfill so that the hfills at the beginning and at the end were // ignored. This is *MUCH* more usefull than not to ignore! -int LyXText::NumberOfHfills(Row const * row) const +int LyXText::NumberOfHfills(Buffer const * buf, Row const * row) const { - int last = RowLast(row); - int first = row->pos; + LyXParagraph::size_type const last = RowLast(row); + LyXParagraph::size_type first = row->pos(); if (first) { /* hfill *DO* count at the beginning * of paragraphs! */ - while(first <= last && row->par->IsHfill(first)) + while(first <= last && row->par()->IsHfill(first)) ++first; } - first = max(first, BeginningOfMainBody(row->par)); + first = max(first, BeginningOfMainBody(buf, row->par())); int n = 0; for (int p = first; p <= last; ++p) { // last, because the end is ignored! - if (row->par->IsHfill(p)) { + if (row->par()->IsHfill(p)) { ++n; } } @@ -1172,21 +1287,21 @@ int LyXText::NumberOfHfills(Row const * row) const // like NumberOfHfills, but only those in the manual label! -int LyXText::NumberOfLabelHfills(Row const * row) const +int LyXText::NumberOfLabelHfills(Buffer const * buf, Row const * row) const { LyXParagraph::size_type last = RowLast(row); - LyXParagraph::size_type first = row->pos; + LyXParagraph::size_type first = row->pos(); if (first) { /* hfill *DO* count at the beginning * of paragraphs! */ - while(first < last && row->par->IsHfill(first)) + while(first < last && row->par()->IsHfill(first)) ++first; } - last = min(last, BeginningOfMainBody(row->par)); + last = min(last, BeginningOfMainBody(buf, row->par())); int n = 0; for (LyXParagraph::size_type p = first; p < last; ++p) { // last, because the end is ignored! - if (row->par->IsHfill(p)) { + if (row->par()->IsHfill(p)) { ++n; } } @@ -1196,11 +1311,11 @@ int LyXText::NumberOfLabelHfills(Row const * row) const // returns true, if a expansion is needed. // Rules are given by LaTeX -bool LyXText::HfillExpansion(Row const * row_ptr, +bool LyXText::HfillExpansion(Buffer const * buf, Row const * row_ptr, LyXParagraph::size_type pos) const { // by the way, is it a hfill? - if (!row_ptr->par->IsHfill(pos)) + if (!row_ptr->par()->IsHfill(pos)) return false; // at the end of a row it does not count @@ -1209,42 +1324,43 @@ bool LyXText::HfillExpansion(Row const * row_ptr, // at the beginning of a row it does not count, if it is not // the first row of a paragaph - if (!row_ptr->pos) + if (!row_ptr->pos()) return true; // in some labels it does not count - if (textclasslist.Style(bparams->textclass, - row_ptr->par->GetLayout()).margintype + if (textclasslist.Style(buf->params.textclass, + row_ptr->par()->GetLayout()).margintype != MARGIN_MANUAL - && pos < BeginningOfMainBody(row_ptr->par)) + && pos < BeginningOfMainBody(buf, row_ptr->par())) return false; // if there is anything between the first char of the row and // the sepcified position that is not a newline and not a hfill, // the hfill will count, otherwise not - LyXParagraph::size_type i = row_ptr->pos; - while (i < pos && (row_ptr->par->IsNewline(i) - || row_ptr->par->IsHfill(i))) + LyXParagraph::size_type i = row_ptr->pos(); + while (i < pos && (row_ptr->par()->IsNewline(i) + || row_ptr->par()->IsHfill(i))) ++i; return i != pos; } -void LyXText::SetHeightOfRow(Row * row_ptr) const +void LyXText::SetHeightOfRow(BufferView * bview, Row * row_ptr) const { /* get the maximum ascent and the maximum descent */ - int asc, desc, pos; + int asc = 0; + int desc = 0; float layoutasc = 0; float layoutdesc = 0; float tmptop = 0; LyXFont tmpfont; - Inset * tmpinset; + Inset * tmpinset = 0; /* this must not happen before the currentrow for clear reasons. so the trick is just to set the current row onto this row */ - long unused_y; - GetRow(row_ptr->par, row_ptr->pos, unused_y); + int unused_y; + GetRow(row_ptr->par(), row_ptr->pos(), unused_y); /* ok , let us initialize the maxasc and maxdesc value. * This depends in LaTeX of the font of the last character @@ -1253,25 +1369,33 @@ void LyXText::SetHeightOfRow(Row * row_ptr) const /* Correction: only the fontsize count. The other properties are taken from the layoutfont. Nicer on the screen :) */ +#ifndef NEW_INSETS + LyXParagraph * par = row_ptr->par()->LastPhysicalPar(); + LyXParagraph * firstpar = row_ptr->par()->FirstPhysicalPar(); +#else + LyXParagraph * par = row_ptr->par(); + LyXParagraph * firstpar = row_ptr->par(); +#endif - LyXParagraph * par = row_ptr->par->LastPhysicalPar(); - LyXParagraph * firstpar = row_ptr->par->FirstPhysicalPar(); - - LyXLayout const & layout = textclasslist.Style(bparams->textclass, + LyXLayout const & layout = textclasslist.Style(bview->buffer()->params.textclass, firstpar->GetLayout()); - - LyXFont font = GetFont(par, par->Last() - 1); - LyXFont::FONT_SIZE size = font.size(); - font = GetFont(par, -1); + +#ifndef NEW_INSETS + LyXFont font = GetFont(bview->buffer(), par, par->Last() - 1); +#else + LyXFont font = GetFont(bview->buffer(), par, par->size() - 1); +#endif + LyXFont::FONT_SIZE const size = font.size(); + font = GetFont(bview->buffer(), par, -1); font.setSize(size); - LyXFont labelfont = GetFont(par, -2); + LyXFont labelfont = GetFont(bview->buffer(), par, -2); float spacing_val = 1.0; - if (!row_ptr->par->spacing.isDefault()) { - spacing_val = row_ptr->par->spacing.getValue(); + if (!row_ptr->par()->params.spacing().isDefault()) { + spacing_val = row_ptr->par()->params.spacing().getValue(); } else { - spacing_val = bparams->spacing.getValue(); + spacing_val = bview->buffer()->params.spacing.getValue(); } //lyxerr << "spacing_val = " << spacing_val << endl; @@ -1281,32 +1405,34 @@ void LyXText::SetHeightOfRow(Row * row_ptr) const int maxdesc = int(lyxfont::maxDescent(font) * layout.spacing.getValue() * spacing_val); - - int pos_end = RowLast(row_ptr); - + int const pos_end = RowLast(row_ptr); int labeladdon = 0; + int maxwidth = 0; // Check if any insets are larger - for (pos = row_ptr->pos; pos <= pos_end; ++pos) { - if (row_ptr->par->GetChar(pos) == LyXParagraph::META_INSET) { - tmpfont = GetFont(row_ptr->par, pos); - tmpinset = row_ptr->par->GetInset(pos); - if (tmpinset) { - asc = tmpinset->ascent(owner_->painter(), tmpfont); - desc = tmpinset->descent(owner_->painter(), tmpfont); - if (asc > maxasc) - maxasc = asc; - if (desc > maxdesc) - maxdesc = desc; - } - } + for (int pos = row_ptr->pos(); pos <= pos_end; ++pos) { + if (row_ptr->par()->GetChar(pos) == LyXParagraph::META_INSET) { + tmpfont = GetFont(bview->buffer(), row_ptr->par(), pos); + tmpinset = row_ptr->par()->GetInset(pos); + if (tmpinset) { +// tmpinset->update(bview, tmpfont); + asc = tmpinset->ascent(bview, tmpfont); + desc = tmpinset->descent(bview, tmpfont); + maxwidth += tmpinset->width(bview, tmpfont); + maxasc = max(maxasc, asc); + maxdesc = max(maxdesc, desc); + } + } else { + maxwidth += SingleWidth(bview, row_ptr->par(), pos); + } } // Check if any custom fonts are larger (Asger) // This is not completely correct, but we can live with the small, // cosmetic error for now. - LyXFont::FONT_SIZE maxsize = row_ptr->par->HighestFontInRange(row_ptr->pos, - pos_end); + LyXFont::FONT_SIZE const maxsize = + row_ptr->par()->HighestFontInRange(row_ptr->pos(), + pos_end); if (maxsize > font.size()) { font.setSize(maxsize); @@ -1318,64 +1444,62 @@ void LyXText::SetHeightOfRow(Row * row_ptr) const maxdesc = desc; } - /* table stuff -- begin*/ - if (row_ptr->par->table){ - // stretch the rows a bit - maxasc += 1; - maxdesc += 1; - } - /* table stuff -- end*/ - // This is nicer with box insets: ++maxasc; ++maxdesc; - row_ptr->ascent_of_text = maxasc; + row_ptr->ascent_of_text(maxasc); - /* is it a top line? */ - if (row_ptr->pos == 0 - && row_ptr->par == firstpar) { + // is it a top line? + if (!row_ptr->pos() && (row_ptr->par() == firstpar)) { - /* some parksips VERY EASY IMPLEMENTATION */ - if (bparams->paragraph_separation == BufferParams::PARSEP_SKIP) { + // some parksips VERY EASY IMPLEMENTATION + if (bview->buffer()->params.paragraph_separation == + BufferParams::PARSEP_SKIP) { if (layout.isParagraph() && firstpar->GetDepth() == 0 - && firstpar->Previous()) - maxasc += bparams->getDefSkip().inPixels(owner_); - else if (firstpar->Previous() - && textclasslist.Style(bparams->textclass, - firstpar->Previous()->GetLayout()).isParagraph() - && firstpar->Previous()->GetDepth() == 0) + && firstpar->previous()) + maxasc += bview->buffer()->params.getDefSkip().inPixels(bview); + else if (firstpar->previous() + && textclasslist.Style(bview->buffer()->params.textclass, + firstpar->previous()->GetLayout()).isParagraph() + && firstpar->previous()->GetDepth() == 0) // is it right to use defskip here too? (AS) - maxasc += bparams->getDefSkip().inPixels(owner_); + maxasc += bview->buffer()->params.getDefSkip().inPixels(bview); } - /* the paper margins */ - if (!row_ptr->par->previous) + // the paper margins +#ifndef NEW_INSETS + if (!row_ptr->par()->previous_ && bv_owner) + maxasc += LYX_PAPER_MARGIN; +#else + if (!row_ptr->par()->previous() && bv_owner) maxasc += LYX_PAPER_MARGIN; +#endif - /* add the vertical spaces, that the user added */ - if (firstpar->added_space_top.kind() != VSpace::NONE) - maxasc += int(firstpar->added_space_top.inPixels(owner_)); + // add the vertical spaces, that the user added + if (firstpar->params.spaceTop().kind() != VSpace::NONE) + maxasc += int(firstpar->params.spaceTop().inPixels(bview)); - /* do not forget the DTP-lines! - * there height depends on the font of the nearest character */ - if (firstpar->line_top) - maxasc += 2 * lyxfont::ascent('x', GetFont(firstpar, 0)); + // do not forget the DTP-lines! + // there height depends on the font of the nearest character + if (firstpar->params.lineTop()) + maxasc += 2 * lyxfont::ascent('x', GetFont(bview->buffer(), + firstpar, 0)); - /* and now the pagebreaks */ - if (firstpar->pagebreak_top) + // and now the pagebreaks + if (firstpar->params.pagebreakTop()) maxasc += 3 * DefaultHeight(); - /* this is special code for the chapter, since the label of this - * layout is printed in an extra row */ + // This is special code for the chapter, since the label of this + // layout is printed in an extra row if (layout.labeltype == LABEL_COUNTER_CHAPTER - && bparams->secnumdepth>= 0) { + && bview->buffer()->params.secnumdepth >= 0) { float spacing_val = 1.0; - if (!row_ptr->par->spacing.isDefault()) { - spacing_val = row_ptr->par->spacing.getValue(); + if (!row_ptr->par()->params.spacing().isDefault()) { + spacing_val = row_ptr->par()->params.spacing().getValue(); } else { - spacing_val = bparams->spacing.getValue(); + spacing_val = bview->buffer()->params.spacing.getValue(); } labeladdon = int(lyxfont::maxDescent(labelfont) * @@ -1386,17 +1510,17 @@ void LyXText::SetHeightOfRow(Row * row_ptr) const spacing_val); } - /* special code for the top label */ + // special code for the top label if ((layout.labeltype == LABEL_TOP_ENVIRONMENT || layout.labeltype == LABEL_BIBLIO || layout.labeltype == LABEL_CENTERED_TOP_ENVIRONMENT) - && row_ptr->par->IsFirstInSequence() - && !row_ptr->par->GetLabelstring().empty()) { + && row_ptr->par()->IsFirstInSequence() + && !row_ptr->par()->GetLabelstring().empty()) { float spacing_val = 1.0; - if (!row_ptr->par->spacing.isDefault()) { - spacing_val = row_ptr->par->spacing.getValue(); + if (!row_ptr->par()->params.spacing().isDefault()) { + spacing_val = row_ptr->par()->params.spacing().getValue(); } else { - spacing_val = bparams->spacing.getValue(); + spacing_val = bview->buffer()->params.spacing.getValue(); } labeladdon = int( @@ -1410,89 +1534,110 @@ void LyXText::SetHeightOfRow(Row * row_ptr) const + layout.labelbottomsep * DefaultHeight()); } - /* and now the layout spaces, for example before and after a section, - * or between the items of a itemize or enumerate environment */ + // and now the layout spaces, for example before and after a section, + // or between the items of a itemize or enumerate environment - if (!firstpar->pagebreak_top) { - LyXParagraph * prev = row_ptr->par->Previous(); + if (!firstpar->params.pagebreakTop()) { + LyXParagraph * prev = row_ptr->par()->previous(); if (prev) - prev = row_ptr->par->DepthHook(row_ptr->par->GetDepth()); + prev = row_ptr->par()->DepthHook(row_ptr->par()->GetDepth()); if (prev && prev->GetLayout() == firstpar->GetLayout() && prev->GetDepth() == firstpar->GetDepth() && prev->GetLabelWidthString() == firstpar->GetLabelWidthString()) { layoutasc = (layout.itemsep * DefaultHeight()); } - else if (row_ptr->previous) { + else if (row_ptr->previous()) { tmptop = layout.topsep; - if (row_ptr->previous->par->GetDepth() >= row_ptr->par->GetDepth()) - tmptop-= textclasslist.Style(bparams->textclass, row_ptr->previous->par->GetLayout()).bottomsep; + if (row_ptr->previous()->par()->GetDepth() >= row_ptr->par()->GetDepth()) + tmptop -= textclasslist.Style(bview->buffer()->params.textclass, + row_ptr->previous()->par()-> + GetLayout()).bottomsep; if (tmptop > 0) layoutasc = (tmptop * DefaultHeight()); } - else if (row_ptr->par->line_top){ + else if (row_ptr->par()->params.lineTop()) { tmptop = layout.topsep; if (tmptop > 0) layoutasc = (tmptop * DefaultHeight()); } - prev = row_ptr->par->DepthHook(row_ptr->par->GetDepth()-1); + prev = row_ptr->par()->DepthHook(row_ptr->par()->GetDepth()-1); if (prev) { - maxasc += int(textclasslist.Style(bparams->textclass, + maxasc += int(textclasslist.Style(bview->buffer()->params.textclass, prev->GetLayout()).parsep * DefaultHeight()); } else { - if (firstpar->Previous() - && firstpar->Previous()->GetDepth() == 0 - && firstpar->Previous()->GetLayout() != firstpar->GetLayout()) { - /* avoid parsep */ + if (firstpar->previous() + && firstpar->previous()->GetDepth() == 0 + && firstpar->previous()->GetLayout() != firstpar->GetLayout()) { + // avoid parsep } - else if (firstpar->Previous()){ + else if (firstpar->previous()){ maxasc += int(layout.parsep * DefaultHeight()); } } } } - /* is it a bottom line? */ - if (row_ptr->par->ParFromPos(RowLast(row_ptr) + 1) == par - && (!row_ptr->next || row_ptr->next->par != row_ptr->par)) { + // is it a bottom line? + if ( +#ifndef NEW_INSETS + row_ptr->par()->ParFromPos(RowLast(row_ptr) + 1) == par +#else + row_ptr->par() == par +#endif + && (!row_ptr->next() || row_ptr->next()->par() != row_ptr->par())) { - /* the paper margins */ - if (!par->next) + // the paper margins +#ifndef NEW_INSETS + if (!par->next_ && bv_owner) maxdesc += LYX_PAPER_MARGIN; - - /* add the vertical spaces, that the user added */ - if (firstpar->added_space_bottom.kind() != VSpace::NONE) - maxdesc += int(firstpar->added_space_bottom.inPixels(owner_)); +#else + if (!par->next() && bv_owner) + maxdesc += LYX_PAPER_MARGIN; +#endif - /* do not forget the DTP-lines! - * there height depends on the font of the nearest character */ - if (firstpar->line_bottom) - maxdesc += 2 * lyxfont::ascent('x', GetFont(par, par->Last() - 1)); + // add the vertical spaces, that the user added + if (firstpar->params.spaceBottom().kind() != VSpace::NONE) + maxdesc += int(firstpar->params.spaceBottom().inPixels(bview)); - /* and now the pagebreaks */ - if (firstpar->pagebreak_bottom) + // do not forget the DTP-lines! + // there height depends on the font of the nearest character +#ifndef NEW_INSETS + if (firstpar->params.lineBottom()) + maxdesc += 2 * lyxfont::ascent('x', GetFont(bview->buffer(), + par, par->Last() - 1)); +#else + if (firstpar->params.lineBottom()) + maxdesc += 2 * lyxfont::ascent('x', + GetFont(bview->buffer(), + par, par->size() - 1)); +#endif + + // and now the pagebreaks + if (firstpar->params.pagebreakBottom()) maxdesc += 3 * DefaultHeight(); - /* and now the layout spaces, for example before and after a section, - * or between the items of a itemize or enumerate environment */ - if (!firstpar->pagebreak_bottom && row_ptr->par->Next()) { - LyXParagraph * nextpar = row_ptr->par->Next(); - LyXParagraph * comparepar = row_ptr->par; + // and now the layout spaces, for example before and after + // a section, or between the items of a itemize or enumerate + // environment + if (!firstpar->params.pagebreakBottom() && row_ptr->par()->next()) { + LyXParagraph * nextpar = row_ptr->par()->next(); + LyXParagraph * comparepar = row_ptr->par(); float usual = 0; - float unusual = 0; + float unusual = 0; if (comparepar->GetDepth() > nextpar->GetDepth()) { - usual = (textclasslist.Style(bparams->textclass, comparepar->GetLayout()).bottomsep * DefaultHeight()); + usual = (textclasslist.Style(bview->buffer()->params.textclass, comparepar->GetLayout()).bottomsep * DefaultHeight()); comparepar = comparepar->DepthHook(nextpar->GetDepth()); if (comparepar->GetLayout()!= nextpar->GetLayout() || nextpar->GetLabelWidthString() != comparepar->GetLabelWidthString()) - unusual = (textclasslist.Style(bparams->textclass, comparepar->GetLayout()).bottomsep * DefaultHeight()); + unusual = (textclasslist.Style(bview->buffer()->params.textclass, comparepar->GetLayout()).bottomsep * DefaultHeight()); if (unusual > usual) layoutdesc = unusual; @@ -1504,1061 +1649,424 @@ void LyXText::SetHeightOfRow(Row * row_ptr) const if (comparepar->GetLayout()!= nextpar->GetLayout() || nextpar->GetLabelWidthString() != comparepar->GetLabelWidthString()) - layoutdesc = int(textclasslist.Style(bparams->textclass, comparepar->GetLayout()).bottomsep * DefaultHeight()); + layoutdesc = int(textclasslist.Style(bview->buffer()->params.textclass, comparepar->GetLayout()).bottomsep * DefaultHeight()); } } } - /* incalculate the layout spaces */ + // incalculate the layout spaces maxasc += int(layoutasc * 2 / (2 + firstpar->GetDepth())); maxdesc += int(layoutdesc * 2 / (2 + firstpar->GetDepth())); - /* table stuff -- begin*/ - if (row_ptr->par->table){ - maxasc += row_ptr->par->table-> - AdditionalHeight(NumberOfCell(row_ptr->par, row_ptr->pos)); - } - /* table stuff -- end*/ + // calculate the new height of the text + height -= row_ptr->height(); - /* calculate the new height of the text */ - height -= row_ptr->height; + row_ptr->height(maxasc + maxdesc + labeladdon); + row_ptr->baseline(maxasc + labeladdon); - row_ptr->height = maxasc + maxdesc + labeladdon; - row_ptr->baseline = maxasc + labeladdon; - - height += row_ptr->height; + height += row_ptr->height(); + float x, dummy; + PrepareToPrint(bview, row_ptr, x, dummy, dummy, dummy, false); + row_ptr->width(int(maxwidth + x)); + if (inset_owner) { + Row * r = firstrow; + width = max(0,workWidth(bview)); + while(r) { + if (r->width() > width) + width = r->width(); + r = r->next(); + } + } } /* Appends the implicit specified paragraph behind the specified row, * start at the implicit given position */ -void LyXText::AppendParagraph(Row * row) const +void LyXText::AppendParagraph(BufferView * bview, Row * row) const { bool not_ready = true; // The last character position of a paragraph is an invariant so we can // safely get it here. (Asger) - int lastposition = row->par->Last(); - +#ifndef NEW_INSETS + int const lastposition = row->par()->Last(); +#else + int const lastposition = row->par()->size(); +#endif do { // Get the next breakpoint - int z = NextBreakPoint(row, paperwidth); + int z = NextBreakPoint(bview, row, workWidth(bview)); Row * tmprow = row; // Insert the new row if (z < lastposition) { ++z; - InsertRow(row, row->par, z); - row = row->next; + InsertRow(row, row->par(), z); + row = row->next(); - row->height = 0; + row->height(0); } else not_ready = false; // Set the dimensions of the row - tmprow->fill = Fill(tmprow, paperwidth); - SetHeightOfRow(tmprow); + tmprow->fill(Fill(bview, tmprow, workWidth(bview))); + SetHeightOfRow(bview, tmprow); } while (not_ready); } -void LyXText::BreakAgain(Row * row) const +void LyXText::BreakAgain(BufferView * bview, Row * row) const { bool not_ready = true; do { - /* get the next breakpoint */ - LyXParagraph::size_type z = - NextBreakPoint(row, paperwidth); + // get the next breakpoint + LyXParagraph::size_type z = NextBreakPoint(bview, row, workWidth(bview)); Row * tmprow = row; - - if (z < row->par->Last() ) { - if (!row->next || (row->next && row->next->par != row->par)) { + +#ifndef NEW_INSETS + if (z < row->par()->Last()) { +#else + if (z < row->par()->size()) { +#endif + if (!row->next() || (row->next() && row->next()->par() != row->par())) { // insert a new row ++z; - InsertRow(row, row->par, z); - row = row->next; - row->height = 0; + InsertRow(row, row->par(), z); + row = row->next(); + row->height(0); } else { - row = row->next; + row = row->next(); ++z; - if (row->pos == z) + if (row->pos() == z) not_ready = false; // the rest will not change else { - row->pos = z; + row->pos(z); } } } else { /* if there are some rows too much, delete them */ /* only if you broke the whole paragraph! */ Row * tmprow2 = row; - while (tmprow2->next && tmprow2->next->par == row->par) { - tmprow2 = tmprow2->next; + while (tmprow2->next() && tmprow2->next()->par() == row->par()) { + tmprow2 = tmprow2->next(); } while (tmprow2 != row) { - tmprow2 = tmprow2->previous; - RemoveRow(tmprow2->next); + tmprow2 = tmprow2->previous(); + RemoveRow(tmprow2->next()); } not_ready = false; } /* set the dimensions of the row */ - tmprow->fill = Fill(tmprow, paperwidth); - SetHeightOfRow(tmprow); + tmprow->fill(Fill(bview, tmprow, workWidth(bview))); + SetHeightOfRow(bview, tmprow); } while (not_ready); } -/* this is just a little changed version of break again */ -void LyXText::BreakAgainOneRow(Row * row) +// this is just a little changed version of break again +void LyXText::BreakAgainOneRow(BufferView * bview, Row * row) { - /* get the next breakpoint */ - LyXParagraph::size_type z = NextBreakPoint(row, paperwidth); - Row * tmprow = row; - - if (z < row->par->Last() ) { - if (!row->next || (row->next && row->next->par != row->par)) { - /* insert a new row */ - ++z; - InsertRow(row, row->par, z); - row = row->next; - row->height = 0; - } - else { - row= row->next; - ++z; - if (row->pos != z) - row->pos = z; - } - } - else { - /* if there are some rows too much, delete them */ - /* only if you broke the whole paragraph! */ - Row * tmprow2 = row; - while (tmprow2->next && tmprow2->next->par == row->par) { - tmprow2 = tmprow2->next; - } - while (tmprow2 != row) { - tmprow2 = tmprow2->previous; - RemoveRow(tmprow2->next); - } - } - - /* set the dimensions of the row */ - tmprow->fill = Fill(tmprow, paperwidth); - SetHeightOfRow(tmprow); + // get the next breakpoint + LyXParagraph::size_type z = NextBreakPoint(bview, row, workWidth(bview)); + Row * tmprow = row; + +#ifndef NEW_INSETS + if (z < row->par()->Last()) { +#else + if (z < row->par()->size()) { +#endif + if (!row->next() + || (row->next() && row->next()->par() != row->par())) { + /* insert a new row */ + ++z; + InsertRow(row, row->par(), z); + row = row->next(); + row->height(0); + } else { + row= row->next(); + ++z; + if (row->pos() != z) + row->pos(z); + } + } else { + // if there are some rows too much, delete them + // only if you broke the whole paragraph! + Row * tmprow2 = row; + while (tmprow2->next() + && tmprow2->next()->par() == row->par()) { + tmprow2 = tmprow2->next(); + } + while (tmprow2 != row) { + tmprow2 = tmprow2->previous(); + RemoveRow(tmprow2->next()); + } + } + + // set the dimensions of the row + tmprow->fill(Fill(bview, tmprow, workWidth(bview))); + SetHeightOfRow(bview, tmprow); } -void LyXText::BreakParagraph(char keep_layout) +void LyXText::BreakParagraph(BufferView * bview, char keep_layout) { - LyXLayout const & layout = textclasslist.Style(bparams->textclass, - cursor.par->GetLayout()); - - /* table stuff -- begin */ - if (cursor.par->table) { - // breaking of tables is only allowed at the beginning or the end */ - if (cursor.pos && cursor.pos < cursor.par->size() && - !cursor.par->table->ShouldBeVeryLastCell(NumberOfCell(cursor.par, cursor.pos))) - return; // no breaking of tables allowed - } - /* table stuff -- end */ + LyXLayout const & layout = + textclasslist.Style(bview->buffer()->params.textclass, + cursor.par()->GetLayout()); // this is only allowed, if the current paragraph is not empty or caption - if ((cursor.par->Last() <= 0 && !cursor.par->IsDummy()) - && - layout.labeltype!= LABEL_SENSITIVE) - return; +#ifndef NEW_INSETS + if ((cursor.par()->Last() <= 0 + && !cursor.par()->IsDummy()) + && layout.labeltype!= LABEL_SENSITIVE) + return; + + SetUndo(bview->buffer(), Undo::INSERT, + cursor.par()->ParFromPos(cursor.pos())->previous_, + cursor.par()->ParFromPos(cursor.pos())->next_); +#else + if ((cursor.par()->size() <= 0) + && layout.labeltype!= LABEL_SENSITIVE) + return; + + SetUndo(bview->buffer(), Undo::INSERT, + cursor.par()->previous(), + cursor.par()->next()); +#endif - SetUndo(Undo::INSERT, - cursor.par->ParFromPos(cursor.pos)->previous, - cursor.par->ParFromPos(cursor.pos)->next); + // Always break behind a space + // + // It is better to erase the space (Dekel) +#ifndef NEW_INSETS + if (cursor.pos() < cursor.par()->Last() +#else + if (cursor.pos() < cursor.par()->size() +#endif + && cursor.par()->IsLineSeparator(cursor.pos())) + cursor.par()->Erase(cursor.pos()); + // cursor.pos(cursor.pos() + 1); - /* table stuff -- begin */ - if (cursor.par->table) { - int cell = NumberOfCell(cursor.par, cursor.pos); - if (cursor.par->table->ShouldBeVeryLastCell(cell)) - SetCursor(cursor.par, cursor.par->size()); - } - /* table stuff -- end */ - - // please break always behind a space - if (cursor.pos < cursor.par->Last() - && cursor.par->IsLineSeparator(cursor.pos)) - cursor.pos++; - // break the paragraph if (keep_layout) keep_layout = 2; else keep_layout = layout.isEnvironment(); - cursor.par->BreakParagraph(cursor.pos, keep_layout); - - /* table stuff -- begin */ - if (cursor.par->table){ - // the table should stay with the contents - if (!cursor.pos){ - cursor.par->Next()->table = cursor.par->table; - cursor.par->table = 0; - } - } - /* table stuff -- end */ + cursor.par()->BreakParagraph(bview->buffer()->params, cursor.pos(), + keep_layout); // well this is the caption hack since one caption is really enough if (layout.labeltype == LABEL_SENSITIVE) { - if (!cursor.pos) - cursor.par->SetLayout(0); // set to standard-layout + if (!cursor.pos()) + // set to standard-layout +#ifndef NEW_INSETS + cursor.par()->SetLayout(bview->buffer()->params, 0); +#else + cursor.par()->SetLayout(0); +#endif else - cursor.par->Next()->SetLayout(0); // set to standard-layout + // set to standard-layout +#ifndef NEW_INSETS + cursor.par()->next()->SetLayout(bview->buffer()->params, 0); +#else + cursor.par()->next()->SetLayout(0); +#endif } /* if the cursor is at the beginning of a row without prior newline, * move one row up! * This touches only the screen-update. Otherwise we would may have * an empty row on the screen */ - if (cursor.pos && !cursor.row->par->IsNewline(cursor.row->pos -1) && - cursor.row->pos == cursor.pos) { - CursorLeft(); + if (cursor.pos() && !cursor.row()->par()->IsNewline(cursor.row()->pos() - 1) + && cursor.row()->pos() == cursor.pos()) { + CursorLeft(bview); } status = LyXText::NEED_MORE_REFRESH; - refresh_row = cursor.row; - refresh_y = cursor.y - cursor.row->baseline; + refresh_row = cursor.row(); + refresh_y = cursor.y() - cursor.row()->baseline(); // Do not forget the special right address boxes if (layout.margintype == MARGIN_RIGHT_ADDRESS_BOX) { - while (refresh_row->previous && - refresh_row->previous->par == refresh_row->par) { - refresh_row = refresh_row->previous; - refresh_y -= refresh_row->height; - } + while (refresh_row->previous() && + refresh_row->previous()->par() == refresh_row->par()) { + refresh_row = refresh_row->previous(); + refresh_y -= refresh_row->height(); + } } - RemoveParagraph(cursor.row); + RemoveParagraph(cursor.row()); // set the dimensions of the cursor row - cursor.row->fill = Fill(cursor.row, paperwidth); + cursor.row()->fill(Fill(bview, cursor.row(), workWidth(bview))); - SetHeightOfRow(cursor.row); - - while (!cursor.par->Next()->table && cursor.par->Next()->Last() - && cursor.par->Next()->IsNewline(0)) - cursor.par->Next()->Erase(0); - - InsertParagraph(cursor.par->Next(), cursor.row); + SetHeightOfRow(bview, cursor.row()); - UpdateCounters(cursor.row->previous); - +#ifndef NEW_INSETS + while (cursor.par()->next()->Last() +#else + while (cursor.par()->next()->size() +#endif + && cursor.par()->next()->IsNewline(0)) + cursor.par()->next()->Erase(0); + + InsertParagraph(bview, cursor.par()->next(), cursor.row()); + + UpdateCounters(bview, cursor.row()->previous()); + /* This check is necessary. Otherwise the new empty paragraph will * be deleted automatically. And it is more friendly for the user! */ - if (cursor.pos) - SetCursor(cursor.par->Next(), 0); + if (cursor.pos()) + SetCursor(bview, cursor.par()->next(), 0); else - SetCursor(cursor.par, 0); + SetCursor(bview, cursor.par(), 0); - if (cursor.row->next) - BreakAgain(cursor.row->next); + if (cursor.row()->next()) + BreakAgain(bview, cursor.row()->next()); need_break_row = 0; } -void LyXText::OpenFootnote() +#ifndef NEW_INSETS +void LyXText::OpenFootnote(BufferView * bview) { LyXParagraph * endpar,* tmppar; Row * row; - LyXParagraph * par = cursor.par->ParFromPos(cursor.pos); + LyXParagraph * par = cursor.par()->ParFromPos(cursor.pos()); /* if there is no footnote in this paragraph, just return. */ - if (!par->next - || par->next->footnoteflag != LyXParagraph::CLOSED_FOOTNOTE) + if (!par->next_ + || par->next_->footnoteflag != LyXParagraph::CLOSED_FOOTNOTE) return; /* ok, move the cursor right before the footnote */ /* just a little faster than using CursorRight() */ - for (cursor.pos = 0; - cursor.par->ParFromPos(cursor.pos) != par; cursor.pos++); + for (cursor.pos(0); + cursor.par()->ParFromPos(cursor.pos()) != par;) { + cursor.pos(cursor.pos() + 1); + } + /* now the cursor is at the beginning of the physical par */ - SetCursor(cursor.par, - cursor.pos + cursor.par->ParFromPos(cursor.pos)->size()); + SetCursor(bview, cursor.par(), + cursor.pos() + cursor.par()->ParFromPos(cursor.pos())->size()); /* the cursor must be exactly before the footnote */ - par = cursor.par->ParFromPos(cursor.pos); + par = cursor.par()->ParFromPos(cursor.pos()); status = LyXText::NEED_MORE_REFRESH; - refresh_row = cursor.row; - refresh_y = cursor.y - cursor.row->baseline; + refresh_row = cursor.row(); + refresh_y = cursor.y() - cursor.row()->baseline(); - tmppar = cursor.par; - endpar = cursor.par->Next(); - row = cursor.row; + tmppar = cursor.par(); + endpar = cursor.par()->next(); + row = cursor.row(); - tmppar->OpenFootnote(cursor.pos); + tmppar->OpenFootnote(cursor.pos()); RemoveParagraph(row); /* set the dimensions of the cursor row */ - row->fill = Fill(row, paperwidth); - SetHeightOfRow(row); -#warning See comment on top of text.C - tmppar = tmppar->Next(); + row->fill(Fill(bview, row, workWidth(bview))); + SetHeightOfRow(bview, row); + // CHECK See comment on top of text.C + tmppar = tmppar->next(); while (tmppar != endpar) { if (tmppar) { - InsertParagraph(tmppar, row); - while (row->next && row->next->par == tmppar) - row = row->next; - tmppar = tmppar->Next(); + InsertParagraph(bview, tmppar, row); + while (row->next() && row->next()->par() == tmppar) + row = row->next(); + tmppar = tmppar->next(); } } - SetCursor(par->next, 0); + SetCursor(bview, par->next_, 0); sel_cursor = cursor; } - - -/* table stuff -- begin*/ - -void LyXText::TableFeatures(int feature, string const & val) const -{ - if (!cursor.par->table) - return; /* this should never happen */ - - int actCell = NumberOfCell(cursor.par, cursor.pos); - SetUndo(Undo::FINISH, - cursor.par->ParFromPos(cursor.pos)->previous, - cursor.par->ParFromPos(cursor.pos)->next); - - switch (feature){ - case LyXTable::SET_PWIDTH: - cursor.par->table->SetPWidth(actCell, val); - break; - case LyXTable::SET_SPECIAL_COLUMN: - case LyXTable::SET_SPECIAL_MULTI: - cursor.par->table->SetAlignSpecial(actCell, val, feature); - break; - default: - break; - } - RedoParagraph(); -} - - -void LyXText::TableFeatures(int feature) const -{ - int setLines = 0; - int setAlign = LYX_ALIGN_LEFT; - int lineSet; - bool what; - - if (!cursor.par->table) - return; /* this should never happen */ - - int actCell = NumberOfCell(cursor.par, cursor.pos); - SetUndo(Undo::FINISH, - cursor.par->ParFromPos(cursor.pos)->previous, - cursor.par->ParFromPos(cursor.pos)->next); - - switch (feature){ - case LyXTable::ALIGN_LEFT: - setAlign= LYX_ALIGN_LEFT; - break; - case LyXTable::ALIGN_RIGHT: - setAlign= LYX_ALIGN_RIGHT; - break; - case LyXTable::ALIGN_CENTER: - setAlign= LYX_ALIGN_CENTER; - break; - default: - break; - } - switch (feature){ - case LyXTable::APPEND_ROW: { - LyXParagraph::size_type pos = cursor.pos; - - /* move to the next row */ - int cell_org = actCell; - int cell = cell_org; - - // if there is a ContRow following this row I have to add - // the row after the ContRow's - if ((pos < cursor.par->Last()) && - cursor.par->table->RowHasContRow(cell_org)) { - while((pos < cursor.par->Last()) && - !cursor.par->table->IsContRow(cell)) { - while (pos < cursor.par->Last() && - !cursor.par->IsNewline(pos)) - ++pos; - if (pos < cursor.par->Last()) - ++pos; - ++cell; - } - while((pos < cursor.par->Last()) && - cursor.par->table->IsContRow(cell)) { - while (pos < cursor.par->Last() && - !cursor.par->IsNewline(pos)) - ++pos; - if (pos < cursor.par->Last()) - ++pos; - ++cell; - } - cell_org = --cell; - if (pos < cursor.par->Last()) - --pos; - } - while (pos < cursor.par->Last() && - (cell == cell_org || !cursor.par->table->IsFirstCell(cell))){ - while (pos < cursor.par->Last() && !cursor.par->IsNewline(pos)) - ++pos; - if (pos < cursor.par->Last()) - ++pos; - ++cell; - } - - /* insert the new cells */ - int number = cursor.par->table->NumberOfCellsInRow(cell_org); - Language const * lang = cursor.par->getParLanguage(); - LyXFont font(LyXFont::ALL_INHERIT,lang); - for (int i = 0; i < number; ++i) { - cursor.par->InsertChar(pos, LyXParagraph::META_NEWLINE); - cursor.par->SetFont(pos, font); - } - - /* append the row into the table */ - cursor.par->table->AppendRow(cell_org); - RedoParagraph(); - return; - } - case LyXTable::APPEND_CONT_ROW: { - LyXParagraph::size_type pos = cursor.pos; - /* move to the next row */ - int cell_org = actCell; - int cell = cell_org; - - // if there is already a controw but not for this cell - // the AppendContRow sets only the right values but does - // not actually add a row - if (cursor.par->table->RowHasContRow(cell_org) && - (cursor.par->table->CellHasContRow(cell_org)<0)) { - cursor.par->table->AppendContRow(cell_org); - RedoParagraph(); - return; - } - while (pos < cursor.par->Last() && - (cell == cell_org - || !cursor.par->table->IsFirstCell(cell))){ - while (pos < cursor.par->Last() && !cursor.par->IsNewline(pos)) - ++pos; - if (pos < cursor.par->Last()) - ++pos; - ++cell; - } - - /* insert the new cells */ - int number = cursor.par->table->NumberOfCellsInRow(cell_org); - Language const * lang = cursor.par->getParLanguage(); - LyXFont font(LyXFont::ALL_INHERIT,lang); - for (int i = 0; i < number; ++i) { - cursor.par->InsertChar(pos, LyXParagraph::META_NEWLINE); - cursor.par->SetFont(pos, font); - } - - /* append the row into the table */ - cursor.par->table->AppendContRow(cell_org); - RedoParagraph(); - return; - } - case LyXTable::APPEND_COLUMN: { - LyXParagraph::size_type pos = 0; - int cell_org = actCell; - int cell = 0; - Language const * lang = cursor.par->getParLanguage(); - LyXFont font(LyXFont::ALL_INHERIT,lang); - do{ - if (pos && (cursor.par->IsNewline(pos-1))){ - if (cursor.par->table->AppendCellAfterCell(cell_org, cell)) { - cursor.par->InsertChar(pos, LyXParagraph::META_NEWLINE); - cursor.par->SetFont(pos, font); - if (pos <= cursor.pos) - cursor.pos++; - ++pos; - } - ++cell; - } - ++pos; - } while (pos <= cursor.par->Last()); - /* remember that the very last cell doesn't end with a newline. - This saves one byte memory per table ;-) */ - if (cursor.par->table->AppendCellAfterCell(cell_org, cell)) { - LyXParagraph::size_type last = cursor.par->Last(); - cursor.par->InsertChar(last, LyXParagraph::META_NEWLINE); - cursor.par->SetFont(last, font); - } - - /* append the column into the table */ - cursor.par->table->AppendColumn(cell_org); - - RedoParagraph(); - return; - } - case LyXTable::DELETE_ROW: - if (owner_->the_locking_inset) - owner_->unlockInset(owner_->the_locking_inset); - RemoveTableRow(&cursor); - RedoParagraph(); - return; - - case LyXTable::DELETE_COLUMN: { - LyXParagraph::size_type pos = 0; - int cell_org = actCell; - int cell = 0; - if (owner_->the_locking_inset) - owner_->unlockInset(owner_->the_locking_inset); - do { - if (!pos || (cursor.par->IsNewline(pos-1))){ - if (cursor.par->table->DeleteCellIfColumnIsDeleted(cell, cell_org)){ - // delete one cell - while (pos < cursor.par->Last() && !cursor.par->IsNewline(pos)) - cursor.par->Erase(pos); - if (pos < cursor.par->Last()) - cursor.par->Erase(pos); - else - cursor.par->Erase(pos - 1); // the missing newline at the end of a table - --pos; // because of pos++ below - } - ++cell; - } - ++pos; - } while (pos <= cursor.par->Last()); - - /* delete the column from the table */ - cursor.par->table->DeleteColumn(cell_org); - - /* set the cursor to the beginning of the table, where else? */ - cursor.pos = 0; - RedoParagraph(); - return; - } - case LyXTable::TOGGLE_LINE_TOP: - lineSet = !cursor.par->table->TopLine(actCell); - if (!selection){ - cursor.par->table->SetTopLine(actCell, lineSet); - } else { - LyXParagraph::size_type i; - int n = -1, m = -2; - for (i = sel_start_cursor.pos; i <= sel_end_cursor.pos; ++i){ - if ((n = NumberOfCell(sel_start_cursor.par, i)) != m) { - cursor.par->table->SetTopLine(n, lineSet); - m = n; - } - } - } - RedoParagraph(); - return; - - case LyXTable::TOGGLE_LINE_BOTTOM: - lineSet = !cursor.par->table->BottomLine(actCell); - if (!selection){ - cursor.par->table->SetBottomLine(actCell, lineSet); - } else { - LyXParagraph::size_type i; - int n = -1, m = -2; - for (i = sel_start_cursor.pos; i <= sel_end_cursor.pos; ++i) { - if ((n = NumberOfCell(sel_start_cursor.par, i)) != m) { - cursor.par->table->SetBottomLine(n, lineSet); - m = n; - } - } - } - RedoParagraph(); - return; - - case LyXTable::TOGGLE_LINE_LEFT: - lineSet = !cursor.par->table->LeftLine(actCell); - if (!selection){ - cursor.par->table->SetLeftLine(actCell, lineSet); - } else { - LyXParagraph::size_type i; - int n = -1, m = -2; - for (i = sel_start_cursor.pos; i <= sel_end_cursor.pos; ++i){ - if ((n= NumberOfCell(sel_start_cursor.par, i)) != m) { - cursor.par->table->SetLeftLine(n, lineSet); - m = n; - } - } - } - RedoParagraph(); - return; - - case LyXTable::TOGGLE_LINE_RIGHT: - lineSet = !cursor.par->table->RightLine(actCell); - if (!selection){ - cursor.par->table->SetRightLine(actCell, lineSet); - } else { - int n = -1, m = -2; - LyXParagraph::size_type i = sel_start_cursor.pos; - for (; i <= sel_end_cursor.pos; ++i) { - if ((n= NumberOfCell(sel_start_cursor.par, i)) != m) { - cursor.par->table->SetRightLine(n, lineSet); - m = n; - } - } - } - RedoParagraph(); - return; - - case LyXTable::ALIGN_LEFT: - case LyXTable::ALIGN_RIGHT: - case LyXTable::ALIGN_CENTER: - if (!selection){ - cursor.par->table->SetAlignment(actCell, setAlign); - } else { - int n = -1, m = -2; - LyXParagraph::size_type i = sel_start_cursor.pos; - for (; i <= sel_end_cursor.pos; ++i) { - if ((n= NumberOfCell(sel_start_cursor.par, i)) != m) { - cursor.par->table->SetAlignment(n, setAlign); - m = n; - } - } - } - RedoParagraph(); - return; - - case LyXTable::DELETE_TABLE: - SetCursorIntern(cursor.par, 0); - delete cursor.par->table; - cursor.par->table = 0; - // temporary: Should put table in simple_cut_buffer (with before and after - // dummy-paragraph !! - // not necessar anymore with UNDO :) - for (LyXParagraph::size_type i = - cursor.par->size() - 1; i >= 0; --i) - cursor.par->Erase(i); - RedoParagraph(); - return; - - case LyXTable::MULTICOLUMN: { - int number = 0; - // check wether we are completly in a multicol - int multicol = cursor.par->table->IsMultiColumn(actCell); - if (multicol && selection && sel_start_cursor.row == sel_end_cursor.row){ - multicol = NumberOfCell(sel_start_cursor.par, sel_start_cursor.pos) - == NumberOfCell(sel_end_cursor.par, sel_end_cursor.pos); - } - - if (multicol){ - int newlines = cursor.par->table->UnsetMultiColumn(actCell); - LyXParagraph::size_type pos = cursor.pos; - while (pos < cursor.par->Last() && !cursor.par->IsNewline(pos)) - ++pos; - for (; newlines; --newlines) - cursor.par->InsertChar(pos, LyXParagraph::META_NEWLINE); - RedoParagraph(); - return; - } - else { - // selection must be in one row (or no selection) - if (!selection){ - cursor.par->table->SetMultiColumn(NumberOfCell(cursor.par, - cursor.pos), - 1); - RedoParagraph(); - return; - } - else { - if (sel_start_cursor.row == sel_end_cursor.row){ - LyXParagraph::size_type i; - number = 1; - for (i = sel_start_cursor.pos; - i < sel_end_cursor.pos; ++i){ - if (sel_start_cursor.par->IsNewline(i)){ - sel_start_cursor.par->Erase(i); - // check for double-blanks - if ((i && !sel_start_cursor.par->IsLineSeparator(i-1)) - && - (i < sel_start_cursor.par->Last() - && !sel_start_cursor.par->IsLineSeparator(i))) - sel_start_cursor.par->InsertChar(i, ' '); - else { - sel_end_cursor.pos--; - --i; - } - ++number; - } - } - cursor.par->table-> - SetMultiColumn(NumberOfCell(sel_start_cursor.par, - sel_start_cursor.pos), - number); - cursor.pos = sel_start_cursor.pos; - RedoParagraph(); - return; - } - else { - WriteAlert(_("Impossible Operation!"), - _("Multicolumns can only be horizontally."), - _("Sorry.")); - } - } - } - break; - } - case LyXTable::SET_ALL_LINES: - setLines = 1; - case LyXTable::UNSET_ALL_LINES: - if (!selection){ - cursor.par->table->SetAllLines(NumberOfCell(cursor.par, - cursor.pos), - setLines); - } else { - LyXParagraph::size_type i; - int n = -1, m = -2; - for (i = sel_start_cursor.pos; i <= sel_end_cursor.pos; ++i) { - if ((n= NumberOfCell(sel_start_cursor.par, i)) != m) { - cursor.par->table->SetAllLines(n, setLines); - m = n; - } - } - } - RedoParagraph(); - return; - case LyXTable::SET_LONGTABLE: - cursor.par->table->SetLongTable(true); - return; - case LyXTable::UNSET_LONGTABLE: - cursor.par->table->SetLongTable(false); - return; - case LyXTable::SET_ROTATE_TABLE: - cursor.par->table->SetRotateTable(true); - return; - case LyXTable::UNSET_ROTATE_TABLE: - cursor.par->table->SetRotateTable(false); - return; - case LyXTable::SET_ROTATE_CELL: - if (!selection){ - cursor.par->table->SetRotateCell(actCell, true); - } else { - LyXParagraph::size_type i; - int n = -1, m = -2; - for (i = sel_start_cursor.pos; i <= sel_end_cursor.pos; ++i){ - if ((n = NumberOfCell(sel_start_cursor.par, i)) != m) { - cursor.par->table->SetRotateCell(n, true); - m = n; - } - } - } - return; - case LyXTable::UNSET_ROTATE_CELL: - if (!selection){ - cursor.par->table->SetRotateCell(actCell, false); - } else { - int n = -1, m = -2; - LyXParagraph::size_type i = sel_start_cursor.pos; - for (; i <= sel_end_cursor.pos; ++i) { - if ((n= NumberOfCell(sel_start_cursor.par, i)) != m) { - cursor.par->table->SetRotateCell(n, false); - m = n; - } - } - } - return; - case LyXTable::SET_LINEBREAKS: - what = !cursor.par->table->Linebreaks(cursor.par->table->FirstVirtualCell(actCell)); - if (!selection){ - cursor.par->table->SetLinebreaks(actCell, what); - } else { - LyXParagraph::size_type i; - int n = -1, m = -2; - for (i = sel_start_cursor.pos; i <= sel_end_cursor.pos; ++i) { - if ((n = NumberOfCell(sel_start_cursor.par, i)) != m) { - cursor.par->table->SetLinebreaks(n, what); - m = n; - } - } - } - return; - case LyXTable::SET_LTFIRSTHEAD: - cursor.par->table->SetLTHead(actCell, true); - return; - case LyXTable::SET_LTHEAD: - cursor.par->table->SetLTHead(actCell, false); - return; - case LyXTable::SET_LTFOOT: - cursor.par->table->SetLTFoot(actCell, false); - return; - case LyXTable::SET_LTLASTFOOT: - cursor.par->table->SetLTFoot(actCell, true); - return; - case LyXTable::SET_LTNEWPAGE: - what = !cursor.par->table->LTNewPage(actCell); - cursor.par->table->SetLTNewPage(actCell, what); - return; - } -} - - -void LyXText::InsertCharInTable(char c) -{ - Row * row; - Row * tmprow; - long y; - bool jumped_over_space; - - /* first check, if there will be two blanks together or a blank at - * the beginning of a paragraph. - * I decided to handle blanks like normal characters, the main - * difference are the special checks when calculating the row.fill - * (blank does not count at the end of a row) and the check here */ - - LyXFont realtmpfont = real_current_font; - LyXFont rawtmpfont = current_font; /* store the current font. - * This is because of the use - * of cursor movements. The moving - * cursor would refresh the - * current font */ - - // Get the font that is used to calculate the baselineskip - LyXParagraph::size_type const lastpos = - cursor.par->Last(); - LyXFont rawparfont = cursor.par->GetFontSettings(lastpos - 1); - - jumped_over_space = false; - if (IsLineSeparatorChar(c)) { - -#ifndef FIX_DOUBLE_SPACE - /* avoid double blanks but insert the new blank because - * of a possible font change */ - if (cursor.pos < lastpos && - cursor.par->IsLineSeparator(cursor.pos)) { - cursor.par->Erase(cursor.pos); - jumped_over_space = true; - } else #endif - if ((cursor.pos > 0 && - cursor.par->IsLineSeparator(cursor.pos - 1)) - || (cursor.pos > 0 && cursor.par->IsNewline(cursor.pos - 1)) - || (cursor.pos == 0 && - !(cursor.par->Previous() - && cursor.par->Previous()->footnoteflag - == LyXParagraph::OPEN_FOOTNOTE))) - return; - } else if (IsNewlineChar(c)) { - if (!IsEmptyTableCell()) { - TableFeatures(LyXTable::APPEND_CONT_ROW); - CursorDown(); - } - return; - } - - row = cursor.row; - y = cursor.y - row->baseline; - if (c != LyXParagraph::META_INSET) /* in this case LyXText::InsertInset - * already inserted the character */ - cursor.par->InsertChar(cursor.pos, c); - SetCharFont(cursor.par, cursor.pos, rawtmpfont); - - if (!jumped_over_space) { - /* refresh the positions */ - tmprow = row; - while (tmprow->next && tmprow->next->par == row->par) { - tmprow = tmprow->next; - tmprow->pos++; - } - } - cursor.pos++; - CheckParagraphInTable(cursor.par, cursor.pos); - - current_font = rawtmpfont; - real_current_font = realtmpfont; - - /* check, whether the last character's font has changed. */ - if (cursor.pos && cursor.pos == cursor.par->Last() - && rawparfont != rawtmpfont) - RedoHeightOfParagraph(cursor); -} - - -void LyXText::CheckParagraphInTable(LyXParagraph * par, - LyXParagraph::size_type pos) +// Just a macro to make some thing easier. +void LyXText::RedoParagraph(BufferView * bview) const { - - if (par->GetChar(pos) == LyXParagraph::META_INSET && - par->GetInset(pos) && par->GetInset(pos)->display()){ - par->GetInset(pos)->display(false); - } - - long y; - Row * row = GetRow(par, pos, y); - - int tmpheight = row->height; - SetHeightOfRow(row); - - LyXParagraph::size_type tmp_pos = pos; - /* update the table information */ - while (tmp_pos && !par->IsNewline(tmp_pos - 1)) - --tmp_pos; - if (par->table->SetWidthOfCell(NumberOfCell(par, pos), - WidthOfCell(par, tmp_pos))) { - LyXCursor tmpcursor = cursor; - SetCursorIntern(par, pos); - /* make a complete redraw */ - RedoDrawingOfParagraph(cursor); - cursor = tmpcursor; - } - else { - /* redraw only the row */ - LyXCursor tmpcursor = cursor; - SetCursorIntern(par, pos); -#warning See comment on top of text.C - refresh_y = y; - refresh_x = cursor.x; - refresh_row = row; - refresh_pos = cursor.pos; - cursor = tmpcursor; - - if (tmpheight == row->height) - status = LyXText::NEED_VERY_LITTLE_REFRESH; - else - status = LyXText::NEED_MORE_REFRESH; - } - SetCursorIntern(cursor.par, cursor.pos); + ClearSelection(bview); + RedoParagraphs(bview, cursor, cursor.par()->next()); + SetCursorIntern(bview, cursor.par(), cursor.pos()); } -void LyXText::BackspaceInTable() +/* insert a character, moves all the following breaks in the + * same Paragraph one to the right and make a rebreak */ +void LyXText::InsertChar(BufferView * bview, char c) { - Row * tmprow, * row; - long y; - - LyXFont rawtmpfont = current_font; - LyXFont realtmpfont = real_current_font; - - // Get the font that is used to calculate the baselineskip - int const lastpos = cursor.par->Last(); - LyXFont rawparfont = cursor.par->GetFontSettings(lastpos - 1); - - if (cursor.pos == 0) { - /* no pasting of table paragraphs */ - - CursorLeft(); - } else { - /* this is the code for a normal backspace, not pasting - * any paragraphs */ - SetUndo(Undo::DELETE, - cursor.par->ParFromPos(cursor.pos)->previous, - cursor.par->ParFromPos(cursor.pos)->next); - - CursorLeftIntern(); - - /* some insets are undeletable here */ - if (cursor.par->GetChar(cursor.pos) == LyXParagraph::META_INSET) { - if (!cursor.par->GetInset(cursor.pos)->Deletable()) - return; - } - - row = cursor.row; - y = cursor.y - row->baseline; - - /* some special code when deleting a newline. */ - if (cursor.par->IsNewline(cursor.pos)) { - /* nothing :-) */ - return; - } - else { - cursor.par->Erase(cursor.pos); - - /* refresh the positions */ - tmprow = row; - while (tmprow->next && tmprow->next->par == row->par) { - tmprow = tmprow->next; - tmprow->pos--; - } - -#ifndef FIX_DOUBLE_SPACE - /* delete superfluous blanks */ - if (cursor.pos < cursor.par->Last() - 1 && - (cursor.par->IsLineSeparator(cursor.pos))) { - - if (cursor.pos == BeginningOfMainBody(cursor.par) - || !cursor.pos - || cursor.par->IsLineSeparator(cursor.pos - 1)) { - cursor.par->Erase(cursor.pos); - /* refresh the positions */ - tmprow = row; - while (tmprow->next && - tmprow->next->par == row->par) { - tmprow = tmprow->next; - tmprow->pos--; - } - if (cursor.pos) /* move one character left */ - cursor.pos--; + SetUndo(bview->buffer(), Undo::INSERT, +#ifndef NEW_INSETS + cursor.par()->ParFromPos(cursor.pos())->previous_, + cursor.par()->ParFromPos(cursor.pos())->next_ +#else + cursor.par()->previous(), + cursor.par()->next() +#endif + ); + + // When the free-spacing option is set for the current layout, + // disable the double-space checking + + bool const freeSpacing = + textclasslist.Style(bview->buffer()->params.textclass, + cursor.row()->par()->GetLayout()).free_spacing; + + + if (lyxrc.auto_number) { + static string const number_operators = "+-/*"; + static string const number_unary_operators = "+-"; + static string const number_seperators = ".,:"; + + if (current_font.number() == LyXFont::ON) { + if (!isdigit(c) && !contains(number_operators, c) && + !(contains(number_seperators, c) && + cursor.pos() >= 1 && + cursor.pos() < cursor.par()->size() && + GetFont(bview->buffer(), + cursor.par(), + cursor.pos()).number() == LyXFont::ON && + GetFont(bview->buffer(), + cursor.par(), + cursor.pos()-1).number() == LyXFont::ON) + ) + Number(bview); // Set current_font.number to OFF + } else if (isdigit(c) && + real_current_font.isVisibleRightToLeft()) { + Number(bview); // Set current_font.number to ON + + if (cursor.pos() > 0) { + char const c = cursor.par()->GetChar(cursor.pos() - 1); + if (contains(number_unary_operators, c) && + (cursor.pos() == 1 || + cursor.par()->IsSeparator(cursor.pos() - 2) || + cursor.par()->IsNewline(cursor.pos() - 2) ) + ) { + SetCharFont(bview->buffer(), + cursor.par(), + cursor.pos() - 1, + current_font); + } else if (contains(number_seperators, c) && + cursor.pos() >= 2 && + GetFont(bview->buffer(), + cursor.par(), + cursor.pos()-2).number() == LyXFont::ON) { + SetCharFont(bview->buffer(), + cursor.par(), + cursor.pos() - 1, + current_font); } } -#endif } - - CheckParagraphInTable(cursor.par, cursor.pos); - - /* check, wether the last characters font has changed. */ - if (cursor.pos && cursor.pos == cursor.par->Last() - && rawparfont != rawtmpfont) - RedoHeightOfParagraph(cursor); - - /* restore the current font - * That is what a user expects! */ - current_font = rawtmpfont; - real_current_font = realtmpfont; } - SetCursorIntern(cursor.par, cursor.pos); -} - -/* table stuff -- end*/ - - -/* just a macro to make some thing easier. */ -void LyXText::RedoParagraph() const -{ -#if 1 - // I suspect this version will work - // also. - ClearSelection(); - RedoParagraphs(cursor, cursor.par->Next()); - SetCursorIntern(cursor.par, cursor.pos); -#else - LyXCursor tmpcursor = cursor; - ClearSelection(); - RedoParagraphs(cursor, cursor.par->Next()); - SetCursorIntern(tmpcursor.par, tmpcursor.pos); -#endif -} - - -/* insert a character, moves all the following breaks in the - * same Paragraph one to the right and make a rebreak */ -void LyXText::InsertChar(char c) -{ - SetUndo(Undo::INSERT, - cursor.par->ParFromPos(cursor.pos)->previous, - cursor.par->ParFromPos(cursor.pos)->next); - - /* When the free-spacing option is set for the current layout, - * disable the double-space checking */ - bool freeSpacing = - textclasslist.Style(bparams->textclass, - cursor.row->par->GetLayout()).free_spacing; - /* table stuff -- begin*/ - if (cursor.par->table) { - InsertCharInTable(c); - charInserted(); - return; - } - /* table stuff -- end*/ - /* First check, if there will be two blanks together or a blank at the beginning of a paragraph. I decided to handle blanks like normal characters, the main @@ -2568,9 +2076,7 @@ void LyXText::InsertChar(char c) // The bug is triggered when we type in a description environment: // The current_font is not changed when we go from label to main text // and it should (along with realtmpfont) when we type the space. -#ifdef WITH_WARNINGS -#warning There is a bug here! (Asger) -#endif + // CHECK There is a bug here! (Asger) LyXFont realtmpfont = real_current_font; LyXFont rawtmpfont = current_font; /* store the current font. @@ -2580,191 +2086,203 @@ void LyXText::InsertChar(char c) * current font */ // Get the font that is used to calculate the baselineskip - LyXParagraph::size_type lastpos = cursor.par->Last(); - LyXFont rawparfont = cursor.par->GetFontSettings(lastpos - 1); +#ifndef NEW_INSETS + LyXParagraph::size_type const lastpos = cursor.par()->Last(); +#else + LyXParagraph::size_type const lastpos = cursor.par()->size(); +#endif + LyXFont rawparfont = cursor.par()->GetFontSettings(bview->buffer()->params, + lastpos - 1); bool jumped_over_space = false; if (!freeSpacing && IsLineSeparatorChar(c)) { -#ifndef FIX_DOUBLE_SPACE - if (cursor.pos < lastpos - && cursor.par->IsLineSeparator(cursor.pos)) { - /* the user inserted a space before a space. So we - * will just make a CursorRight. BUT: The font of this - * space should be set to current font. That is why - * we need to rebreak perhaps. If there is a protected - * blank at the end of a row we have to force - * a rebreak.*/ - - owner_->owner()->getMiniBuffer() - ->Set(_("You cannot type two spaces this way. " - " Please read the Tutorial.")); -#if 1 - // How can this ever happen? - if (cursor.pos == RowLast(cursor.row) - && !IsLineSeparatorChar(c)) - cursor.row->fill = -1; // force rebreak - cursor.par->Erase(cursor.pos); - jumped_over_space = true; -#else - // Seems to me that this works just as well. - CursorRight(); - charInserted(); - return; + if ((cursor.pos() > 0 + && cursor.par()->IsLineSeparator(cursor.pos() - 1)) + || (cursor.pos() > 0 + && cursor.par()->IsNewline(cursor.pos() - 1)) + || (cursor.pos() == 0 +#ifndef NEW_INSETS + && !(cursor.par()->previous() + && cursor.par()->previous()->footnoteflag + == LyXParagraph::OPEN_FOOTNOTE) #endif - } else -#endif - if ((cursor.pos > 0 - && cursor.par->IsLineSeparator(cursor.pos - 1)) - || (cursor.pos > 0 - && cursor.par->IsNewline(cursor.pos - 1)) - || (cursor.pos == 0 - && !(cursor.par->Previous() - && cursor.par->Previous()->footnoteflag - == LyXParagraph::OPEN_FOOTNOTE))) { - if (cursor.pos == 0 ) - owner_->owner()->getMiniBuffer()->Set(_("You cannot insert a space at the beginning of a paragraph. Please read the Tutorial.")); + )) { + if (cursor.pos() == 0 ) + bview->owner()->getLyXFunc() + ->Dispatch(LFUN_MESSAGE, + _("You cannot insert a space at the beginning of a paragraph. Please read the Tutorial.")); else - owner_->owner()->getMiniBuffer()->Set(_("You cannot type two spaces this way. Please read the Tutorial.")); + bview->owner()->getLyXFunc() + ->Dispatch(LFUN_MESSAGE, + _("You cannot type two spaces this way. Please read the Tutorial.")); charInserted(); return; } } else if (IsNewlineChar(c)) { - if (cursor.par->FirstPhysicalPar() == cursor.par - && cursor.pos <= BeginningOfMainBody(cursor.par)) { +#ifndef NEW_INSETS + if (cursor.par()->FirstPhysicalPar() == cursor.par() +#else + if (cursor.par() == cursor.par() +#endif + && cursor.pos() <= BeginningOfMainBody(bview->buffer(), cursor.par())) { charInserted(); return; } /* No newline at first position * of a paragraph or behind labels. * TeX does not allow that. */ - - if (cursor.pos < cursor.par->Last() && - cursor.par->IsLineSeparator(cursor.pos)) - CursorRightIntern(); // newline always after a blank! - cursor.row->fill = -1; // to force a new break + +#ifndef NEW_INSETS + if (cursor.pos() < cursor.par()->Last() && +#else + if (cursor.pos() < cursor.par()->size() && +#endif + cursor.par()->IsLineSeparator(cursor.pos())) + // newline always after a blank! + CursorRight(bview); + cursor.row()->fill(-1); // to force a new break } // the display inset stuff - if (cursor.row->par->GetChar(cursor.row->pos) == LyXParagraph::META_INSET - && cursor.row->par->GetInset(cursor.row->pos) - && cursor.row->par->GetInset(cursor.row->pos)->display()) - cursor.row->fill = -1; // to force a new break + if (cursor.row()->par()->GetChar(cursor.row()->pos()) == LyXParagraph::META_INSET + && cursor.row()->par()->GetInset(cursor.row()->pos()) + && (cursor.row()->par()->GetInset(cursor.row()->pos())->display() || + cursor.row()->par()->GetInset(cursor.row()->pos())->needFullRow())) + cursor.row()->fill(-1); // to force a new break // get the cursor row fist - Row * row = cursor.row; - long y = cursor.y - row->baseline; + Row * row = cursor.row(); + int y = cursor.y() - row->baseline(); if (c != LyXParagraph::META_INSET) /* Here case LyXText::InsertInset * already insertet the character */ - cursor.par->InsertChar(cursor.pos, c); - SetCharFont(cursor.par, cursor.pos, rawtmpfont); + cursor.par()->InsertChar(cursor.pos(), c); + SetCharFont(bview->buffer(), cursor.par(), cursor.pos(), rawtmpfont); if (!jumped_over_space) { // refresh the positions Row * tmprow = row; - while (tmprow->next && tmprow->next->par == row->par) { - tmprow = tmprow->next; - tmprow->pos++; + while (tmprow->next() && tmprow->next()->par() == row->par()) { + tmprow = tmprow->next(); + tmprow->pos(tmprow->pos() + 1); } } // Is there a break one row above - if ((cursor.par->IsLineSeparator(cursor.pos) - || cursor.par->IsNewline(cursor.pos) - || cursor.row->fill == -1) - && row->previous && row->previous->par == row->par) { - LyXParagraph::size_type z = NextBreakPoint(row->previous, - paperwidth); - if ( z >= row->pos) { - row->pos = z + 1; + if ((cursor.par()->IsLineSeparator(cursor.pos()) + || cursor.par()->IsNewline(cursor.pos()) + || cursor.row()->fill() == -1) + && row->previous() && row->previous()->par() == row->par()) { + LyXParagraph::size_type z = NextBreakPoint(bview, + row->previous(), + workWidth(bview)); + if (z >= row->pos()) { + row->pos(z + 1); // set the dimensions of the row above - row->previous->fill = Fill(row->previous, paperwidth); + row->previous()->fill(Fill(bview, + row->previous(), + workWidth(bview))); - SetHeightOfRow(row->previous); + SetHeightOfRow(bview, row->previous()); - y -= row->previous->height; + y -= row->previous()->height(); refresh_y = y; - refresh_row = row->previous; + refresh_row = row->previous(); status = LyXText::NEED_MORE_REFRESH; - BreakAgainOneRow(row); + BreakAgainOneRow(bview, row); current_font = rawtmpfont; real_current_font = realtmpfont; - SetCursor(cursor.par, cursor.pos + 1, false); - /* cursor MUST be in row now */ + SetCursor(bview, cursor.par(), cursor.pos() + 1, + false, cursor.boundary()); + // cursor MUST be in row now. - if (row->next && row->next->par == row->par) - need_break_row = row->next; + if (row->next() && row->next()->par() == row->par()) + need_break_row = row->next(); else need_break_row = 0; - // check, wether the last characters font has changed. - if (cursor.pos && cursor.pos == cursor.par->Last() + // check, wether the last characters font has changed. +#ifndef NEW_INSETS + if (cursor.pos() && cursor.pos() == cursor.par()->Last() +#else + if (cursor.pos() && cursor.pos() == cursor.par()->size() +#endif && rawparfont != rawtmpfont) - RedoHeightOfParagraph(cursor); + RedoHeightOfParagraph(bview, cursor); charInserted(); return; } } - /* recalculate the fill of the row */ - if (row->fill >= 0) /* needed because a newline + // recalculate the fill of the row + if (row->fill() >= 0) /* needed because a newline * will set fill to -1. Otherwise * we would not get a rebreak! */ - row->fill = Fill(row, paperwidth); - if (row->fill < 0 ) { + row->fill(Fill(bview, row, workWidth(bview))); + if (row->fill() < 0) { refresh_y = y; refresh_row = row; - refresh_x = cursor.x; - refresh_pos = cursor.pos; + refresh_x = cursor.x(); + refresh_pos = cursor.pos(); status = LyXText::NEED_MORE_REFRESH; - BreakAgainOneRow(row); - /* will the cursor be in another row now? */ - if (RowLast(row) <= cursor.pos + 1 && row->next) { - if (row->next && row->next->par == row->par) - /* this should - * always be true */ - row = row->next; - BreakAgainOneRow(row); + BreakAgainOneRow(bview, row); + // will the cursor be in another row now? + if (RowLast(row) <= cursor.pos() + 1 && row->next()) { + if (row->next() && row->next()->par() == row->par()) + // this should always be true + row = row->next(); + BreakAgainOneRow(bview, row); } current_font = rawtmpfont; real_current_font = realtmpfont; - SetCursor(cursor.par, cursor.pos + 1, false); - if (row->next && row->next->par == row->par) - need_break_row = row->next; + + SetCursor(bview, cursor.par(), cursor.pos() + 1, false, + cursor.boundary()); + if (IsBoundary(bview->buffer(), cursor.par(), cursor.pos()) + != cursor.boundary()) + SetCursor(bview, cursor.par(), cursor.pos(), false, + !cursor.boundary()); + if (row->next() && row->next()->par() == row->par()) + need_break_row = row->next(); else need_break_row = 0; } else { refresh_y = y; - refresh_x = cursor.x; + refresh_x = cursor.x(); refresh_row = row; - refresh_pos = cursor.pos; + refresh_pos = cursor.pos(); - int tmpheight = row->height; - SetHeightOfRow(row); - if (tmpheight == row->height) + int const tmpheight = row->height(); + SetHeightOfRow(bview, row); + if (tmpheight == row->height()) status = LyXText::NEED_VERY_LITTLE_REFRESH; else status = LyXText::NEED_MORE_REFRESH; current_font = rawtmpfont; real_current_font = realtmpfont; - SetCursor(cursor.par, cursor.pos + 1, false); + SetCursor(bview, cursor.par(), cursor.pos() + 1, false, + cursor.boundary()); } - /* check, wether the last characters font has changed. */ - if (cursor.pos && cursor.pos == cursor.par->Last() + // check, wether the last characters font has changed. +#ifndef NEW_INSETS + if (cursor.pos() && cursor.pos() == cursor.par()->Last() +#else + if (cursor.pos() && cursor.pos() == cursor.par()->size() +#endif && rawparfont != rawtmpfont) { - RedoHeightOfParagraph(cursor); + RedoHeightOfParagraph(bview, cursor); } else { - /* now the special right address boxes */ - if (textclasslist.Style(bparams->textclass, - cursor.par->GetLayout()).margintype + // now the special right address boxes + if (textclasslist.Style(bview->buffer()->params.textclass, + cursor.par()->GetLayout()).margintype == MARGIN_RIGHT_ADDRESS_BOX) { - RedoDrawingOfParagraph(cursor); + RedoDrawingOfParagraph(bview, cursor); } } @@ -2785,81 +2303,87 @@ void LyXText::charInserted() } } -void LyXText::PrepareToPrint(Row * row, float & x, + +void LyXText::PrepareToPrint(BufferView * bview, + Row * row, float & x, float & fill_separator, float & fill_hfill, float & fill_label_hfill, bool bidi) const { - float nh, nlh, ns; + float nlh, ns; - float w = row->fill; + float w = row->fill(); fill_hfill = 0; fill_label_hfill = 0; fill_separator = 0; fill_label_hfill = 0; - bool is_rtl = row->par->isRightToLeftPar(); - + bool const is_rtl = + row->par()->isRightToLeftPar(bview->buffer()->params); if (is_rtl) { - x = RightMargin(row); - if (row->par->footnoteflag == LyXParagraph::OPEN_FOOTNOTE) { + x = (workWidth(bview) > 0) + ? RightMargin(bview->buffer(), row) : 0; +#ifndef NEW_INSETS + if (row->par()->footnoteflag == LyXParagraph::OPEN_FOOTNOTE) { LyXFont font(LyXFont::ALL_SANE); font.setSize(LyXFont::SIZE_SMALL); x += lyxfont::width("Mwide-figM", font); } +#endif } else - x = LeftMargin(row); + x = (workWidth(bview) > 0) ? LeftMargin(bview, row) : 0; - /* is there a manual margin with a manual label */ - if (textclasslist.Style(bparams->textclass, - row->par->GetLayout()).margintype == MARGIN_MANUAL - && textclasslist.Style(bparams->textclass, - row->par->GetLayout()).labeltype == LABEL_MANUAL) { + // is there a manual margin with a manual label + if (textclasslist.Style(bview->buffer()->params.textclass, + row->par()->GetLayout()).margintype == MARGIN_MANUAL + && textclasslist.Style(bview->buffer()->params.textclass, + row->par()->GetLayout()).labeltype == LABEL_MANUAL) { - nlh = NumberOfLabelHfills(row) + 1; /* one more since labels - * are left aligned*/ - if (nlh && !row->par->GetLabelWidthString().empty()) { - fill_label_hfill = LabelFill(row) / nlh; + /* one more since labels are left aligned */ + nlh = NumberOfLabelHfills(bview->buffer(), row) + 1; + if (nlh && !row->par()->GetLabelWidthString().empty()) { + fill_label_hfill = LabelFill(bview, row) / nlh; } } - /* are there any hfills in the row? */ - nh = NumberOfHfills(row); - -/* table stuff -- begin*/ - if (row->par->table) { - w = paperwidth - row->par->table->WidthOfTable() - - x - RightMargin(row); - nh = 0; /* ignore hfills in tables */ - } -/* table stuff -- end*/ + // are there any hfills in the row? + float const nh = NumberOfHfills(bview->buffer(), row); if (nh) - fill_hfill = w /nh; + fill_hfill = w / nh; else { - /* is it block, flushleft or flushright? - * set x how you need it */ + // is it block, flushleft or flushright? + // set x how you need it int align; - if (row->par->FirstPhysicalPar()->align == LYX_ALIGN_LAYOUT) - align = textclasslist.Style(bparams->textclass, row->par->GetLayout()).align; +#ifndef NEW_INSETS + if (row->par()->FirstPhysicalPar()->params.align() == LYX_ALIGN_LAYOUT) + align = textclasslist.Style(bview->buffer()->params.textclass, row->par()->GetLayout()).align; + else + align = row->par()->FirstPhysicalPar()->params.align(); +#else + if (row->par()->params.align() == LYX_ALIGN_LAYOUT) + align = textclasslist.Style(bview->buffer()->params.textclass, row->par()->GetLayout()).align; else - align = row->par->FirstPhysicalPar()->align; + align = row->par()->params.align(); +#endif - /* center displayed insets */ - if (row->par->GetChar(row->pos) == LyXParagraph::META_INSET - && row->par->GetInset(row->pos) - && row->par->GetInset(row->pos)->display()) - align = LYX_ALIGN_CENTER; + // center displayed insets + Inset * inset; + if (row->par()->GetChar(row->pos()) == LyXParagraph::META_INSET + && (inset=row->par()->GetInset(row->pos())) + && (inset->display())) // || (inset->scroll() < 0))) + align = (inset->LyxCode() == Inset::MATHMACRO_CODE) + ? LYX_ALIGN_BLOCK : LYX_ALIGN_CENTER; switch (align) { case LYX_ALIGN_BLOCK: - ns = NumberOfSeparators(row); - if (ns && row->next && row->next->par == row->par && - !(row->next->par->IsNewline(row->next->pos-1)) - && !(row->next->par->GetChar(row->next->pos) == LyXParagraph::META_INSET - && row->next->par->GetInset(row->next->pos) - && row->next->par->GetInset(row->next->pos)->display()) + ns = NumberOfSeparators(bview->buffer(), row); + if (ns && row->next() && row->next()->par() == row->par() && + !(row->next()->par()->IsNewline(row->next()->pos() - 1)) + && !(row->next()->par()->GetChar(row->next()->pos()) == LyXParagraph::META_INSET + && row->next()->par()->GetInset(row->next()->pos()) + && row->next()->par()->GetInset(row->next()->pos())->display()) ) fill_separator = w / ns; else if (is_rtl) @@ -2876,19 +2400,20 @@ void LyXText::PrepareToPrint(Row * row, float & x, if (!bidi) return; - ComputeBidiTables(row); + ComputeBidiTables(bview->buffer(), row); if (is_rtl) { LyXParagraph::size_type main_body = - BeginningOfMainBody(row->par); + BeginningOfMainBody(bview->buffer(), row->par()); LyXParagraph::size_type last = RowLast(row); if (main_body > 0 && (main_body-1 > last || - !row->par->IsLineSeparator(main_body-1))) { - LyXLayout const & layout = textclasslist.Style(bparams->textclass, - row->par->GetLayout()); + !row->par()->IsLineSeparator(main_body-1))) { + LyXLayout const & layout = + textclasslist.Style(bview->buffer()->params.textclass, + row->par()->GetLayout()); x += lyxfont::width(layout.labelsep, - GetFont(row->par, -2)); + GetFont(bview->buffer(), row->par(), -2)); if (main_body-1 <= last) x += fill_label_hfill; } @@ -2902,145 +2427,145 @@ void LyXText::PrepareToPrint(Row * row, float & x, * realize, that you left an empty paragraph, they will delete it. * They also delete the corresponding row */ -void LyXText::CursorRightOneWord() const +void LyXText::CursorRightOneWord(BufferView * bview) const { // treat floats, HFills and Insets as words LyXCursor tmpcursor = cursor; -#warning See comment on top of text.C + // CHECK See comment on top of text.C - if (tmpcursor.pos == tmpcursor.par->Last() - && tmpcursor.par->Next()) - { - tmpcursor.par = tmpcursor.par->Next(); - tmpcursor.pos = 0; +#ifndef NEW_INSETS + if (tmpcursor.pos() == tmpcursor.par()->Last() +#else + if (tmpcursor.pos() == tmpcursor.par()->size() +#endif + && tmpcursor.par()->next()) { + tmpcursor.par(tmpcursor.par()->next()); + tmpcursor.pos(0); } else { int steps = 0; // Skip through initial nonword stuff. - while ( tmpcursor.pos < tmpcursor.par->Last() && - ! tmpcursor.par->IsWord( tmpcursor.pos ) ) +#ifndef NEW_INSETS + while (tmpcursor.pos() < tmpcursor.par()->Last() && +#else + while (tmpcursor.pos() < tmpcursor.par()->size() && +#endif + ! tmpcursor.par()->IsWord( tmpcursor.pos() ) ) { - // printf("Current pos1 %d", tmpcursor.pos) ; - tmpcursor.pos++; + // printf("Current pos1 %d", tmpcursor.pos()) ; + tmpcursor.pos(tmpcursor.pos() + 1); ++steps; } // Advance through word. - while ( tmpcursor.pos < tmpcursor.par->Last() && - tmpcursor.par->IsWord( tmpcursor.pos ) ) +#ifndef NEW_INSETS + while (tmpcursor.pos() < tmpcursor.par()->Last() && +#else + while (tmpcursor.pos() < tmpcursor.par()->size() && +#endif + tmpcursor.par()->IsWord( tmpcursor.pos() ) ) { - // printf("Current pos2 %d", tmpcursor.pos) ; - tmpcursor.pos++; + // printf("Current pos2 %d", tmpcursor.pos()) ; + tmpcursor.pos(tmpcursor.pos() + 1); ++steps; } } - SetCursor(tmpcursor.par, tmpcursor.pos); + SetCursor(bview, tmpcursor.par(), tmpcursor.pos()); } -void LyXText::CursorTab() const +void LyXText::CursorTab(BufferView * bview) const { - if (cursor.par->table) { - int cell = NumberOfCell(cursor.par, cursor.pos); - while(cursor.par->table->IsContRow(cell)) { - CursorUp(); - cell = NumberOfCell(cursor.par, cursor.pos); - } - if (cursor.par->table->ShouldBeVeryLastCell(cell)) - TableFeatures(LyXTable::APPEND_ROW); - } LyXCursor tmpcursor = cursor; - while (tmpcursor.pos < tmpcursor.par->Last() - && !tmpcursor.par->IsNewline(tmpcursor.pos)) - tmpcursor.pos++; - - if (tmpcursor.pos == tmpcursor.par->Last()){ - if (tmpcursor.par->Next()) { - tmpcursor.par = tmpcursor.par->Next(); - tmpcursor.pos = 0; - } - } - else - tmpcursor.pos++; - SetCursor(tmpcursor.par, tmpcursor.pos); - if (cursor.par->table) { - int cell = NumberOfCell(cursor.par, cursor.pos); - while (cursor.par->table->IsContRow(cell) && - !cursor.par->table->ShouldBeVeryLastCell(cell)) { - tmpcursor = cursor; - while (tmpcursor.pos < tmpcursor.par->Last() - && !tmpcursor.par->IsNewline(tmpcursor.pos)) - tmpcursor.pos++; - - if (tmpcursor.pos == tmpcursor.par->Last()){ - if (tmpcursor.par->Next()) { - tmpcursor.par = tmpcursor.par->Next(); - tmpcursor.pos = 0; - } - } - else - tmpcursor.pos++; - SetCursor(tmpcursor.par, tmpcursor.pos); - cell = NumberOfCell(cursor.par, cursor.pos); +#ifndef NEW_INSETS + while (tmpcursor.pos() < tmpcursor.par()->Last() +#else + while (tmpcursor.pos() < tmpcursor.par()->size() +#endif + && !tmpcursor.par()->IsNewline(tmpcursor.pos())) + tmpcursor.pos(tmpcursor.pos() + 1); + +#ifndef NEW_INSETS + if (tmpcursor.pos() == tmpcursor.par()->Last()){ +#else + if (tmpcursor.pos() == tmpcursor.par()->size()){ +#endif + if (tmpcursor.par()->next()) { + tmpcursor.par(tmpcursor.par()->next()); + tmpcursor.pos(0); } - } + } else + tmpcursor.pos(tmpcursor.pos() + 1); + SetCursor(bview, tmpcursor.par(), tmpcursor.pos()); } /* -------> Skip initial whitespace at end of word and move cursor to *start* of prior word, not to end of next prior word. */ -void LyXText::CursorLeftOneWord() const +void LyXText::CursorLeftOneWord(BufferView * bview) const { // treat HFills, floats and Insets as words LyXCursor tmpcursor = cursor; - while (tmpcursor.pos - && (tmpcursor.par->IsSeparator(tmpcursor.pos - 1) - || tmpcursor.par->IsKomma(tmpcursor.pos - 1)) - && !(tmpcursor.par->IsHfill(tmpcursor.pos - 1) - || tmpcursor.par->IsFloat(tmpcursor.pos - 1) - || tmpcursor.par->IsInset(tmpcursor.pos - 1))) - tmpcursor.pos--; - - if (tmpcursor.pos - && (tmpcursor.par->IsInset(tmpcursor.pos - 1) - || tmpcursor.par->IsFloat(tmpcursor.pos - 1) - || tmpcursor.par->IsHfill(tmpcursor.pos - 1))) { - tmpcursor.pos--; - } else if (!tmpcursor.pos) { - if (tmpcursor.par->Previous()){ - tmpcursor.par = tmpcursor.par->Previous(); - tmpcursor.pos = tmpcursor.par->Last(); + while (tmpcursor.pos() + && (tmpcursor.par()->IsSeparator(tmpcursor.pos() - 1) + || tmpcursor.par()->IsKomma(tmpcursor.pos() - 1)) + && !(tmpcursor.par()->IsHfill(tmpcursor.pos() - 1) +#ifndef NEW_INSETS + || tmpcursor.par()->IsFloat(tmpcursor.pos() - 1) +#endif + || tmpcursor.par()->IsInset(tmpcursor.pos() - 1))) + tmpcursor.pos(tmpcursor.pos() - 1); + + if (tmpcursor.pos() + && (tmpcursor.par()->IsInset(tmpcursor.pos() - 1) +#ifndef NEW_INSETS + || tmpcursor.par()->IsFloat(tmpcursor.pos() - 1) +#endif + || tmpcursor.par()->IsHfill(tmpcursor.pos() - 1))) { + tmpcursor.pos(tmpcursor.pos() - 1); + } else if (!tmpcursor.pos()) { + if (tmpcursor.par()->previous()){ + tmpcursor.par(tmpcursor.par()->previous()); +#ifndef NEW_INSETS + tmpcursor.pos(tmpcursor.par()->Last()); +#else + tmpcursor.pos(tmpcursor.par()->size()); +#endif } } else { // Here, tmpcursor != 0 - while (tmpcursor.pos > 0 && - tmpcursor.par->IsWord(tmpcursor.pos-1) ) - tmpcursor.pos-- ; + while (tmpcursor.pos() > 0 && + tmpcursor.par()->IsWord(tmpcursor.pos()-1) ) + tmpcursor.pos(tmpcursor.pos() - 1); } - SetCursor(tmpcursor.par, tmpcursor.pos); + SetCursor(bview, tmpcursor.par(), tmpcursor.pos()); } /* -------> Select current word. This depends on behaviour of CursorLeftOneWord(), so it is patched as well. */ -void LyXText::SelectWord() +void LyXText::SelectWord(BufferView * bview) { - /* Move cursor to the beginning, when not already there. */ - if ( cursor.pos - && !cursor.par->IsSeparator(cursor.pos-1) - && !cursor.par->IsKomma(cursor.pos-1) ) - CursorLeftOneWord(); + // Move cursor to the beginning, when not already there. + if (cursor.pos() + && !cursor.par()->IsSeparator(cursor.pos()-1) + && !cursor.par()->IsKomma(cursor.pos()-1) ) + CursorLeftOneWord(bview); - /* set the sel cursor */ + // set the sel cursor sel_cursor = cursor; - while ( cursor.pos < cursor.par->Last() - && !cursor.par->IsSeparator(cursor.pos) - && !cursor.par->IsKomma(cursor.pos) ) - cursor.pos++; - SetCursor( cursor.par, cursor.pos ); +#ifndef NEW_INSETS + while (cursor.pos() < cursor.par()->Last() +#else + while (cursor.pos() < cursor.par()->size() +#endif + && !cursor.par()->IsSeparator(cursor.pos()) + && !cursor.par()->IsKomma(cursor.pos()) ) + cursor.pos(cursor.pos() + 1); + SetCursor(bview, cursor.par(), cursor.pos() ); - /* finally set the selection */ - SetSelection(); + // finally set the selection + SetSelection(bview); } @@ -3048,225 +2573,252 @@ void LyXText::SelectWord() 1: no selection is currently set, 2: the cursor is not at the borders of the word. */ -int LyXText::SelectWordWhenUnderCursor() +bool LyXText::SelectWordWhenUnderCursor(BufferView * bview) { - if ( selection ) return 0; - if ( cursor.pos < cursor.par->Last() - && !cursor.par->IsSeparator(cursor.pos) - && !cursor.par->IsKomma(cursor.pos) - && cursor.pos - && !cursor.par->IsSeparator(cursor.pos -1) - && !cursor.par->IsKomma(cursor.pos -1) ) { - SelectWord(); - return 1; + if (!selection && +#ifndef NEW_INSETS + cursor.pos() > 0 && cursor.pos() < cursor.par()->Last() +#else + cursor.pos() > 0 && cursor.pos() < cursor.par()->size() +#endif + && !cursor.par()->IsSeparator(cursor.pos()) + && !cursor.par()->IsKomma(cursor.pos()) + && !cursor.par()->IsSeparator(cursor.pos() -1) + && !cursor.par()->IsKomma(cursor.pos() -1)) { + SelectWord(bview); + return true; } - return 0; + return false; } // This function is only used by the spellchecker for NextWord(). // It doesn't handle LYX_ACCENTs and probably never will. -char * LyXText::SelectNextWord(float & value) +string const LyXText::SelectNextWord(BufferView * bview, + float & value) const { - LyXParagraph * tmppar = cursor.par; + LyXParagraph * tmppar = cursor.par(); // If this is not the very first word, skip rest of // current word because we are probably in the middle // of a word if there is text here. - if (cursor.pos || cursor.par->previous) { - while (cursor.pos < cursor.par->Last() - && cursor.par->IsLetter(cursor.pos)) - cursor.pos++; +#ifndef NEW_INSETS + if (cursor.pos() || cursor.par()->previous_) { + while (cursor.pos() < cursor.par()->Last() + && cursor.par()->IsLetter(cursor.pos())) + cursor.pos(cursor.pos() + 1); } +#else + if (cursor.pos() || cursor.par()->previous()) { + while (cursor.pos() < cursor.par()->size() + && cursor.par()->IsLetter(cursor.pos())) + cursor.pos(cursor.pos() + 1); + } +#endif + // Now, skip until we have real text (will jump paragraphs) - while ((cursor.par->Last() > cursor.pos - && (!cursor.par->IsLetter(cursor.pos) - || cursor.par->getFont(cursor.pos).latex() == LyXFont::ON)) - || (cursor.par->Last() == cursor.pos - && cursor.par->Next())){ - if (cursor.pos == cursor.par->Last()) { - cursor.par = cursor.par->Next(); - cursor.pos = 0; - } - else - cursor.pos++; +#ifndef NEW_INSETS + while ((cursor.par()->Last() > cursor.pos() +#else + while ((cursor.par()->size() > cursor.pos() +#endif + && (!cursor.par()->IsLetter(cursor.pos()) + || cursor.par()->getFont(bview->buffer()->params, cursor.pos()) + .latex() == LyXFont::ON)) +#ifndef NEW_INSETS + || (cursor.par()->Last() == cursor.pos() +#else + || (cursor.par()->size() == cursor.pos() +#endif + && cursor.par()->next())){ +#ifndef NEW_INSETS + if (cursor.pos() == cursor.par()->Last()) { +#else + if (cursor.pos() == cursor.par()->size()) { +#endif + cursor.par(cursor.par()->next()); + cursor.pos(0); + } else + cursor.pos(cursor.pos() + 1); } // Update the value if we changed paragraphs - if (cursor.par != tmppar){ - SetCursor(cursor.par, cursor.pos); - value = float(cursor.y)/float(height); + if (cursor.par() != tmppar){ + SetCursor(bview, cursor.par(), cursor.pos()); + value = float(cursor.y())/float(height); } - /* Start the selection from here */ + // Start the selection from here sel_cursor = cursor; -#ifdef HAVE_SSTREAM std::ostringstream latex; + + // and find the end of the word + // (optional hyphens are part of a word) +#ifndef NEW_INSETS + while (cursor.pos() < cursor.par()->Last() #else - ostrstream latex; + while (cursor.pos() < cursor.par()->size() #endif - /* and find the end of the word - (optional hyphens are part of a word) */ - while (cursor.pos < cursor.par->Last() - && (cursor.par->IsLetter(cursor.pos)) - || (cursor.par->GetChar(cursor.pos) == LyXParagraph::META_INSET - && cursor.par->GetInset(cursor.pos) != 0 - && cursor.par->GetInset(cursor.pos)->Latex(latex, 0, false) == 0 -#ifdef HAVE_SSTREAM + && (cursor.par()->IsLetter(cursor.pos())) + || (cursor.par()->GetChar(cursor.pos()) == LyXParagraph::META_INSET + && cursor.par()->GetInset(cursor.pos()) != 0 + && cursor.par()->GetInset(cursor.pos())->Latex(bview->buffer(), latex, false, false) == 0 && latex.str() == "\\-" -#else - && string(latex.str(), 3) == "\\-" // this is not nice at all -#endif )) - cursor.pos++; + cursor.pos(cursor.pos() + 1); -#ifndef HAVE_SSTREAM - delete [] latex.str(); -#endif // Finally, we copy the word to a string and return it - char * str = 0; - - if (sel_cursor.pos < cursor.pos) { - str = new char [cursor.pos - sel_cursor.pos + 2]; - LyXParagraph::size_type i, j; - for (i = sel_cursor.pos, j = 0; i < cursor.pos; ++i) { - if (cursor.par->GetChar(i) != LyXParagraph::META_INSET) - str[j++] = cursor.par->GetChar(i); + string str; + if (sel_cursor.pos() < cursor.pos()) { + LyXParagraph::size_type i; + for (i = sel_cursor.pos(); i < cursor.pos(); ++i) { + if (cursor.par()->GetChar(i) != LyXParagraph::META_INSET) + str += cursor.par()->GetChar(i); } - str[j] = '\0'; } return str; } // This one is also only for the spellchecker -void LyXText::SelectSelectedWord() +void LyXText::SelectSelectedWord(BufferView * bview) { - /* move cursor to the beginning */ - SetCursor(sel_cursor.par, sel_cursor.pos); + // move cursor to the beginning + SetCursor(bview, sel_cursor.par(), sel_cursor.pos()); - /* set the sel cursor */ + // set the sel cursor sel_cursor = cursor; -#ifdef HAVE_SSTREAM std::ostringstream latex; -#else - ostrstream latex; -#endif - /* now find the end of the word */ - while (cursor.pos < cursor.par->Last() - && (cursor.par->IsLetter(cursor.pos) - || (cursor.par->GetChar(cursor.pos) == LyXParagraph::META_INSET - && cursor.par->GetInset(cursor.pos) != 0 - && cursor.par->GetInset(cursor.pos)->Latex(latex, 0, false) == 0 -#ifdef HAVE_SSTREAM - && latex.str() == "\\-" + // now find the end of the word +#ifndef NEW_INSETS + while (cursor.pos() < cursor.par()->Last() #else - && string(latex.str(), 3) == "\\-" + while (cursor.pos() < cursor.par()->size() #endif + && (cursor.par()->IsLetter(cursor.pos()) + || (cursor.par()->GetChar(cursor.pos()) == LyXParagraph::META_INSET + && cursor.par()->GetInset(cursor.pos()) != 0 + && cursor.par()->GetInset(cursor.pos())->Latex(bview->buffer(), latex, false, false) == 0 + && latex.str() == "\\-" ))) - cursor.pos++; + cursor.pos(cursor.pos() + 1); -#ifndef HAVE_SSTREAM - delete [] latex.str(); -#endif - SetCursor(cursor.par, cursor.pos); + SetCursor(bview, cursor.par(), cursor.pos()); - /* finally set the selection */ - SetSelection(); + // finally set the selection + SetSelection(bview); } /* -------> Delete from cursor up to the end of the current or next word. */ -void LyXText::DeleteWordForward() +void LyXText::DeleteWordForward(BufferView * bview) { - LyXCursor tmpcursor = cursor; - - if (!cursor.par->Last()) - CursorRight(); -#warning See comment on top of text.C +#ifndef NEW_INSETS + if (!cursor.par()->Last()) +#else + if (!cursor.par()->size()) +#endif + CursorRight(bview); else { - /* -------> Skip initial non-word stuff. */ - while ( cursor.pos < cursor.par->Last() - && (cursor.par->IsSeparator(cursor.pos) - || cursor.par->IsKomma(cursor.pos)) ) - cursor.pos++; - - SetCursorIntern(cursor.par, cursor.pos); - selection = True; // to avoid deletion - CursorRightOneWord(); + LyXCursor tmpcursor = cursor; + tmpcursor.row(0); // ?? + selection = true; // to avoid deletion + CursorRightOneWord(bview); + SetCursor(bview, tmpcursor, tmpcursor.par(), tmpcursor.pos()); sel_cursor = cursor; cursor = tmpcursor; - SetSelection(); + SetSelection(bview); /* -----> Great, CutSelection() gets rid of multiple spaces. */ - CutSelection(); + CutSelection(bview); } } /* -------> Delete from cursor to start of current or prior word. */ -void LyXText::DeleteWordBackward() +void LyXText::DeleteWordBackward(BufferView * bview) { - LyXCursor tmpcursor = cursor; - if (!cursor.par->Last()) - CursorLeft(); -#warning See comment on top of text.C - else{ - selection = true; // to avoid deletion - CursorLeftOneWord(); - sel_cursor = cursor; - cursor = tmpcursor; - SetSelection(); - CutSelection(); +#ifndef NEW_INSETS + if (!cursor.par()->Last()) +#else + if (!cursor.par()->size()) +#endif + CursorLeft(bview); + else { + LyXCursor tmpcursor = cursor; + tmpcursor.row(0); // ?? + selection = true; // to avoid deletion + CursorLeftOneWord(bview); + SetCursor(bview, tmpcursor, tmpcursor.par(), tmpcursor.pos()); + sel_cursor = cursor; + cursor = tmpcursor; + SetSelection(bview); + CutSelection(bview); } } /* -------> Kill to end of line. */ -void LyXText::DeleteLineForward() +void LyXText::DeleteLineForward(BufferView * bview) { - LyXCursor tmpcursor = cursor; - if (!cursor.par->Last()) - CursorRight(); -#warning See comment on top of text.C +#ifndef NEW_INSETS + if (!cursor.par()->Last()) +#else + if (!cursor.par()->size()) +#endif + // Paragraph is empty, so we just go to the right + CursorRight(bview); else { - CursorEnd(); + LyXCursor tmpcursor = cursor; + // We can't store the row over a regular SetCursor + // so we set it to 0 and reset it afterwards. + tmpcursor.row(0); // ?? + selection = true; // to avoid deletion + CursorEnd(bview); + SetCursor(bview, tmpcursor, tmpcursor.par(), tmpcursor.pos()); sel_cursor = cursor; cursor = tmpcursor; - SetSelection(); - if (selection == false) { - DeleteWordForward(); + SetSelection(bview); + // What is this test for ??? (JMarc) + if (!selection) { + DeleteWordForward(bview); } else { - CutSelection(); + CutSelection(bview); } } } -// Change the case of a word at cursor position. The meaning of action -// is: -// 0 change to lowercase -// 1 capitalize word -// 2 change to uppercase +// Change the case of a word at cursor position. // This function directly manipulates LyXParagraph::text because there // is no LyXParagraph::SetChar currently. I did what I could to ensure // that it is correct. I guess part of it should be moved to // LyXParagraph, but it will have to change for 1.1 anyway. At least // it does not access outside of the allocated array as the older // version did. (JMarc) -void LyXText::ChangeWordCase(LyXText::TextCase action) +void LyXText::ChangeWordCase(BufferView * bview, LyXText::TextCase action) { - LyXParagraph * tmppar = cursor.par->ParFromPos(cursor.pos); +#ifndef NEW_INSETS + LyXParagraph * tmppar = cursor.par()->ParFromPos(cursor.pos()); - SetUndo(Undo::FINISH, tmppar->previous, tmppar->next); + SetUndo(bview->buffer(),Undo::FINISH, + tmppar->previous_, tmppar->next_); LyXParagraph::size_type tmppos = - cursor.par->PositionInParFromPos(cursor.pos); + cursor.par()->PositionInParFromPos(cursor.pos()); +#else + LyXParagraph * tmppar = cursor.par(); + + SetUndo(bview->buffer(),Undo::FINISH, + tmppar->previous(), tmppar->next()); + + LyXParagraph::size_type tmppos = cursor.pos(); +#endif + while (tmppos < tmppar->size()) { - //unsigned char c = tmppar->text[tmppos]; unsigned char c = tmppar->GetChar(tmppos); if (IsKommaChar(c) || IsLineSeparatorChar(c)) break; @@ -3289,128 +2841,157 @@ void LyXText::ChangeWordCase(LyXText::TextCase action) tmppar->SetChar(tmppos, c); ++tmppos; } - CheckParagraph(tmppar, tmppos); - CursorRightOneWord(); + CheckParagraph(bview, tmppar, tmppos); + CursorRightOneWord(bview); } -void LyXText::Delete() +void LyXText::Delete(BufferView * bview) { // this is a very easy implementation LyXCursor old_cursor = cursor; - int old_cur_par_id = old_cursor.par->id(); - int old_cur_par_prev_id = old_cursor.par->previous ? - old_cursor.par->previous->id() : 0; + int const old_cur_par_id = old_cursor.par()->id(); +#ifndef NEW_INSETS + int const old_cur_par_prev_id = old_cursor.par()->previous_ ? + old_cursor.par()->previous_->id() : 0; +#else + int const old_cur_par_prev_id = old_cursor.par()->previous() ? + old_cursor.par()->previous()->id() : 0; +#endif // just move to the right - CursorRightIntern(); + CursorRight(bview); -#warning Look at the comment here. + // CHECK Look at the comment here. // This check is not very good... // The CursorRightIntern calls DeleteEmptyParagrapgMechanism // and that can very well delete the par or par->previous in // old_cursor. Will a solution where we compare paragraph id's //work better? -#if 1 - if ((cursor.par->previous ? cursor.par->previous->id() : 0) - == old_cur_par_prev_id - && cursor.par->id() != old_cur_par_id) - return; // delete-empty-paragraph-mechanism has done it + if ( +#ifndef NEW_INSETS + (cursor.par()->previous_ ? cursor.par()->previous_->id() : 0) #else - if (cursor.par->previous == old_cursor.par->previous - && cursor.par != old_cursor.par) - return; // delete-empty-paragraph-mechanism has done it + (cursor.par()->previous() ? cursor.par()->previous()->id() : 0) #endif + == old_cur_par_prev_id + && cursor.par()->id() != old_cur_par_id) + return; // delete-empty-paragraph-mechanism has done it + // if you had success make a backspace - if (old_cursor.par != cursor.par || old_cursor.pos != cursor.pos) { + if (old_cursor.par() != cursor.par() || old_cursor.pos() != cursor.pos()) { LyXCursor tmpcursor = cursor; cursor = old_cursor; // to make sure undo gets the right cursor position - SetUndo(Undo::DELETE, - cursor.par->ParFromPos(cursor.pos)->previous, - cursor.par->ParFromPos(cursor.pos)->next); + SetUndo(bview->buffer(), Undo::DELETE, +#ifndef NEW_INSETS + cursor.par()->ParFromPos(cursor.pos())->previous_, + cursor.par()->ParFromPos(cursor.pos())->next_ +#else + cursor.par()->previous(), + cursor.par()->next() +#endif + ); cursor = tmpcursor; - Backspace(); + Backspace(bview); } } -void LyXText::Backspace() +void LyXText::Backspace(BufferView * bview) { - /* table stuff -- begin */ - if (cursor.par->table) { - BackspaceInTable(); - return; - } - /* table stuff -- end */ - - LyXFont rawtmpfont = current_font; - LyXFont realtmpfont = real_current_font; - // Get the font that is used to calculate the baselineskip - int const lastpos = cursor.par->Last(); - LyXFont rawparfont = cursor.par->GetFontSettings(lastpos - 1); +#ifndef NEW_INSETS + LyXParagraph::size_type lastpos = cursor.par()->Last(); +#else + LyXParagraph::size_type lastpos = cursor.par()->size(); +#endif + LyXFont rawparfont = cursor.par()->GetFontSettings(bview->buffer()->params, + lastpos - 1); - if (cursor.pos == 0) { - // The cursor is at the beginning of a paragraph, so the the backspace - // will collapse two paragraphs into one. + if (cursor.pos() == 0) { + // The cursor is at the beginning of a paragraph, + // so the the backspace will collapse two paragraphs into one. // we may paste some paragraphs // is it an empty paragraph? if ((lastpos == 0 - || (lastpos == 1 && cursor.par->IsSeparator(0))) - && !(cursor.par->Next() - && cursor.par->footnoteflag == LyXParagraph::NO_FOOTNOTE - && cursor.par->Next()->footnoteflag == LyXParagraph::OPEN_FOOTNOTE)) { + || (lastpos == 1 && cursor.par()->IsSeparator(0))) +#ifndef NEW_INSETS + && !(cursor.par()->next() + && cursor.par()->footnoteflag == LyXParagraph::NO_FOOTNOTE + && cursor.par()->next()->footnoteflag == LyXParagraph::OPEN_FOOTNOTE) +#endif + ) { // This is an empty paragraph and we delete it just by moving the cursor one step // left and let the DeleteEmptyParagraphMechanism handle the actual deletion // of the paragraph. - if (cursor.par->previous) { - LyXParagraph * tmppar = cursor.par->previous->FirstPhysicalPar(); - if (cursor.par->GetLayout() == tmppar->GetLayout() - && cursor.par->footnoteflag == tmppar->footnoteflag - && cursor.par->GetAlign() == tmppar->GetAlign()) { - // Inherit botom DTD from the paragraph below. +#ifndef NEW_INSETS + if (cursor.par()->previous_) { + LyXParagraph * tmppar = cursor.par()->previous_->FirstPhysicalPar(); + if (cursor.par()->GetLayout() == tmppar->GetLayout() + && cursor.par()->footnoteflag == tmppar->footnoteflag +#else + if (cursor.par()->previous()) { + LyXParagraph * tmppar = cursor.par()->previous(); + if (cursor.par()->GetLayout() == tmppar->GetLayout() +#endif + && cursor.par()->GetAlign() == tmppar->GetAlign()) { + // Inherit bottom DTD from the paragraph below. // (the one we are deleting) - tmppar->line_bottom = cursor.par->line_bottom; - tmppar->added_space_bottom = cursor.par->added_space_bottom; - tmppar->pagebreak_bottom = cursor.par->pagebreak_bottom; + tmppar->params.lineBottom(cursor.par()->params.lineBottom()); + tmppar->params.spaceBottom(cursor.par()->params.spaceBottom()); + tmppar->params.pagebreakBottom(cursor.par()->params.pagebreakBottom()); } - CursorLeftIntern(); + CursorLeft(bview); // the layout things can change the height of a row ! - int tmpheight = cursor.row->height; - SetHeightOfRow(cursor.row); - if (cursor.row->height != tmpheight) { - refresh_y = cursor.y - cursor.row->baseline; - refresh_row = cursor.row; + int const tmpheight = cursor.row()->height(); + SetHeightOfRow(bview, cursor.row()); + if (cursor.row()->height() != tmpheight) { + refresh_y = cursor.y() - cursor.row()->baseline(); + refresh_row = cursor.row(); status = LyXText::NEED_MORE_REFRESH; } return; } } - - if (cursor.par->ParFromPos(cursor.pos)->previous){ - SetUndo(Undo::DELETE, - cursor.par->ParFromPos(cursor.pos)->previous->previous, - cursor.par->ParFromPos(cursor.pos)->next); + +#ifndef NEW_INSETS + if (cursor.par()->ParFromPos(cursor.pos())->previous_) { + SetUndo(bview->buffer(), Undo::DELETE, + cursor.par()->ParFromPos(cursor.pos())->previous_->previous_, + cursor.par()->ParFromPos(cursor.pos())->next_); } +#else + if (cursor.par()->previous()) { + SetUndo(bview->buffer(), Undo::DELETE, + cursor.par()->previous()->previous(), + cursor.par()->next()); + } +#endif - LyXParagraph * tmppar = cursor.par; - Row * tmprow = cursor.row; + LyXParagraph * tmppar = cursor.par(); + Row * tmprow = cursor.row(); // We used to do CursorLeftIntern() here, but it is // not a good idea since it triggers the auto-delete // mechanism. So we do a CursorLeftIntern()-lite, // without the dreaded mechanism. (JMarc) - if (cursor.par->Previous()) { + if (cursor.par()->previous()) { // steps into the above paragraph. - SetCursorIntern(cursor.par->Previous(), - cursor.par->Previous()->Last()); +#ifndef NEW_INSETS + SetCursorIntern(bview, cursor.par()->previous(), + cursor.par()->previous()->Last(), false); +#else + SetCursorIntern(bview, cursor.par()->previous(), + cursor.par()->previous()->size(), + false); +#endif } /* Pasting is not allowed, if the paragraphs have different @@ -3423,31 +3004,30 @@ void LyXText::Backspace() Correction: Pasting is always allowed with standard-layout */ - if (cursor.par != tmppar - && (cursor.par->GetLayout() == tmppar->GetLayout() + if (cursor.par() != tmppar + && (cursor.par()->GetLayout() == tmppar->GetLayout() || tmppar->GetLayout() == 0 /*standard*/) - && cursor.par->footnoteflag == tmppar->footnoteflag - /* table stuff -- begin*/ - && !cursor.par->table /* no pasting of tables */ - /* table stuff -- end*/ - && cursor.par->GetAlign() == tmppar->GetAlign()) { +#ifndef NEW_INSETS + && cursor.par()->footnoteflag == tmppar->footnoteflag +#endif + && cursor.par()->GetAlign() == tmppar->GetAlign()) { RemoveParagraph(tmprow); RemoveRow(tmprow); - cursor.par->PasteParagraph(); + cursor.par()->PasteParagraph(bview->buffer()->params); - if (!cursor.pos || !cursor.par->IsSeparator(cursor.pos - 1)) - ; //cursor.par->InsertChar(cursor.pos, ' '); + if (!cursor.pos() || !cursor.par()->IsSeparator(cursor.pos() - 1)) + ; //cursor.par()->InsertChar(cursor.pos(), ' '); // strangely enough it seems that commenting out the line above removes // most or all of the segfaults. I will however also try to move the // two Remove... lines in front of the PasteParagraph too. else - if (cursor.pos) - cursor.pos--; + if (cursor.pos()) + cursor.pos(cursor.pos() - 1); status = LyXText::NEED_MORE_REFRESH; - refresh_row = cursor.row; - refresh_y = cursor.y - cursor.row->baseline; + refresh_row = cursor.row(); + refresh_y = cursor.y() - cursor.row()->baseline(); // remove the lost paragraph // This one is not safe, since the paragraph that the tmprow and the @@ -3457,406 +3037,467 @@ void LyXText::Backspace() //RemoveParagraph(tmprow); //RemoveRow(tmprow); - AppendParagraph(cursor.row); // This rebuilds the rows. - UpdateCounters(cursor.row); + // This rebuilds the rows. + AppendParagraph(bview, cursor.row()); + UpdateCounters(bview, cursor.row()); // the row may have changed, block, hfills etc. - SetCursor(cursor.par, cursor.pos); + SetCursor(bview, cursor.par(), cursor.pos(), false); } } else { /* this is the code for a normal backspace, not pasting * any paragraphs */ - SetUndo(Undo::DELETE, - cursor.par->ParFromPos(cursor.pos)->previous, - cursor.par->ParFromPos(cursor.pos)->next); + SetUndo(bview->buffer(), Undo::DELETE, +#ifndef NEW_INSETS + cursor.par()->ParFromPos(cursor.pos())->previous_, + cursor.par()->ParFromPos(cursor.pos())->next_ +#else + cursor.par()->previous(), + cursor.par()->next() +#endif + ); // We used to do CursorLeftIntern() here, but it is // not a good idea since it triggers the auto-delete // mechanism. So we do a CursorLeftIntern()-lite, // without the dreaded mechanism. (JMarc) - SetCursorIntern(cursor.par, cursor.pos - 1); + SetCursorIntern(bview, cursor.par(), cursor.pos()- 1, + false, cursor.boundary()); // some insets are undeletable here - if (cursor.par->GetChar(cursor.pos) == LyXParagraph::META_INSET) { - if (!cursor.par->GetInset(cursor.pos)->Deletable()) + if (cursor.par()->GetChar(cursor.pos()) == LyXParagraph::META_INSET) { + if (!cursor.par()->GetInset(cursor.pos())->Deletable()) return; // force complete redo when erasing display insets // this is a cruel method but safe..... Matthias - if (cursor.par->GetInset(cursor.pos)->display()){ - cursor.par->Erase(cursor.pos); - RedoParagraph(); + if (cursor.par()->GetInset(cursor.pos())->display() || + cursor.par()->GetInset(cursor.pos())->needFullRow()) { + cursor.par()->Erase(cursor.pos()); + RedoParagraph(bview); return; } } - Row * row = cursor.row; - long y = cursor.y - row->baseline; + Row * row = cursor.row(); + int y = cursor.y() - row->baseline(); LyXParagraph::size_type z; /* remember that a space at the end of a row doesnt count * when calculating the fill */ - if (cursor.pos < RowLast(row) || - !cursor.par->IsLineSeparator(cursor.pos)) { - row->fill += SingleWidth(cursor.par, cursor.pos); + if (cursor.pos() < RowLast(row) || + !cursor.par()->IsLineSeparator(cursor.pos())) { + row->fill(row->fill() + SingleWidth(bview, + cursor.par(), + cursor.pos())); } /* some special code when deleting a newline. This is similar * to the behavior when pasting paragraphs */ - if (cursor.pos && cursor.par->IsNewline(cursor.pos)) { - cursor.par->Erase(cursor.pos); + if (cursor.pos() && cursor.par()->IsNewline(cursor.pos())) { + cursor.par()->Erase(cursor.pos()); // refresh the positions Row * tmprow = row; - while (tmprow->next && tmprow->next->par == row->par) { - tmprow = tmprow->next; - tmprow->pos--; + while (tmprow->next() && tmprow->next()->par() == row->par()) { + tmprow = tmprow->next(); + tmprow->pos(tmprow->pos() - 1); } - if (cursor.par->IsLineSeparator(cursor.pos - 1)) - cursor.pos--; - - if (cursor.pos < cursor.par->Last() && !cursor.par->IsSeparator(cursor.pos)) { - cursor.par->InsertChar(cursor.pos, ' '); + if (cursor.par()->IsLineSeparator(cursor.pos() - 1)) + cursor.pos(cursor.pos() - 1); + +#ifndef NEW_INSETS + if (cursor.pos() < cursor.par()->Last() + && !cursor.par()->IsSeparator(cursor.pos())) { +#else + if (cursor.pos() < cursor.par()->size() + && !cursor.par()->IsSeparator(cursor.pos())) { +#endif + cursor.par()->InsertChar(cursor.pos(), ' '); + SetCharFont(bview->buffer(), cursor.par(), + cursor.pos(), current_font); // refresh the positions tmprow = row; - while (tmprow->next && tmprow->next->par == row->par) { - tmprow = tmprow->next; - tmprow->pos++; + while (tmprow->next() && tmprow->next()->par() == row->par()) { + tmprow = tmprow->next(); + tmprow->pos(tmprow->pos() + 1); } } } else { - cursor.par->Erase(cursor.pos); + cursor.par()->Erase(cursor.pos()); // refresh the positions Row * tmprow = row; - while (tmprow->next && tmprow->next->par == row->par) { - tmprow = tmprow->next; - tmprow->pos--; + while (tmprow->next() + && tmprow->next()->par() == row->par()) { + tmprow = tmprow->next(); + tmprow->pos(tmprow->pos() - 1); } -#ifndef FIX_DOUBLE_SPACE - // delete superfluous blanks - if (cursor.pos < cursor.par->Last() - 1 && - (cursor.par->IsLineSeparator(cursor.pos))) { - - if (cursor.pos == BeginningOfMainBody(cursor.par) - || !cursor.pos - || cursor.par->IsLineSeparator(cursor.pos - 1)) { - cursor.par->Erase(cursor.pos); - // refresh the positions - tmprow = row; - while (tmprow->next && - tmprow->next->par == row->par) { - tmprow = tmprow->next; - tmprow->pos--; - } - if (cursor.pos) // move one character left - cursor.pos--; - } - } -#endif - // delete newlines at the beginning of paragraphs - while (cursor.par->Last() && - cursor.par->IsNewline(cursor.pos) && - cursor.pos == BeginningOfMainBody(cursor.par)) { - cursor.par->Erase(cursor.pos); +#ifndef NEW_INSETS + while (cursor.par()->Last() && +#else + while (cursor.par()->size() && +#endif + cursor.par()->IsNewline(cursor.pos()) && + cursor.pos() == BeginningOfMainBody(bview->buffer(), + cursor.par())) { + cursor.par()->Erase(cursor.pos()); // refresh the positions tmprow = row; - while (tmprow->next && - tmprow->next->par == row->par) { - tmprow = tmprow->next; - tmprow->pos--; + while (tmprow->next() && + tmprow->next()->par() == row->par()) { + tmprow = tmprow->next(); + tmprow->pos(tmprow->pos() - 1); } } } // is there a break one row above - if (row->previous && row->previous->par == row->par) { - z = NextBreakPoint(row->previous, paperwidth); - if ( z >= row->pos) { - row->pos = z + 1; + if (row->previous() && row->previous()->par() == row->par()) { + z = NextBreakPoint(bview, row->previous(), + workWidth(bview)); + if (z >= row->pos()) { + row->pos(z + 1); - Row * tmprow = row->previous; + Row * tmprow = row->previous(); // maybe the current row is now empty - if (row->pos >= row->par->Last()) { +#ifndef NEW_INSETS + if (row->pos() >= row->par()->Last()) { +#else + if (row->pos() >= row->par()->size()) { +#endif // remove it RemoveRow(row); need_break_row = 0; } else { - BreakAgainOneRow(row); - if (row->next && row->next->par == row->par) - need_break_row = row->next; + BreakAgainOneRow(bview, row); + if (row->next() && row->next()->par() == row->par()) + need_break_row = row->next(); else need_break_row = 0; } // set the dimensions of the row above - y -= tmprow->height; - tmprow->fill = Fill(tmprow, paperwidth); - SetHeightOfRow(tmprow); + y -= tmprow->height(); + tmprow->fill(Fill(bview, tmprow, + workWidth(bview))); + SetHeightOfRow(bview, tmprow); refresh_y = y; refresh_row = tmprow; status = LyXText::NEED_MORE_REFRESH; - current_font = rawtmpfont; - real_current_font = realtmpfont; - SetCursor(cursor.par, cursor.pos, false); + SetCursor(bview, cursor.par(), cursor.pos(), + false, cursor.boundary()); + //current_font = rawtmpfont; + //real_current_font = realtmpfont; // check, whether the last character's font has changed. - rawtmpfont = cursor.par->GetFontSettings(cursor.par->Last() - 1); - if (rawparfont != rawtmpfont) - RedoHeightOfParagraph(cursor); +#ifndef NEW_INSETS + if (rawparfont != + cursor.par()->GetFontSettings(bview->buffer()->params, + cursor.par()->Last() - 1)) +#else + if (rawparfont != + cursor.par()->GetFontSettings(bview->buffer()->params, + cursor.par()->size() - 1)) +#endif + RedoHeightOfParagraph(bview, cursor); return; } } // break the cursor row again - z = NextBreakPoint(row, paperwidth); - - if (z != RowLast(row) || - (row->next && row->next->par == row->par && - RowLast(row) == row->par->Last() - 1)){ + if (row->next() && row->next()->par() == row->par() && +#ifndef NEW_INSETS + (RowLast(row) == row->par()->Last() - 1 || +#else + (RowLast(row) == row->par()->size() - 1 || +#endif + NextBreakPoint(bview, row, workWidth(bview)) != RowLast(row))) { /* it can happen that a paragraph loses one row * without a real breakup. This is when a word * is to long to be broken. Well, I don t care this - * hack ;-) */ - if (row->next && row->next->par == row->par && - RowLast(row) == row->par->Last() - 1) - RemoveRow(row->next); + * hack ;-) */ +#ifndef NEW_INSETS + if (RowLast(row) == row->par()->Last() - 1) +#else + if (RowLast(row) == row->par()->size() - 1) +#endif + RemoveRow(row->next()); refresh_y = y; refresh_row = row; status = LyXText::NEED_MORE_REFRESH; - BreakAgainOneRow(row); - current_font = rawtmpfont; - real_current_font = realtmpfont; - SetCursor(cursor.par, cursor.pos, false); - // cursor MUST be in row now - - if (row->next && row->next->par == row->par) - need_break_row = row->next; + BreakAgainOneRow(bview, row); + // will the cursor be in another row now? + if (row->next() && row->next()->par() == row->par() && + RowLast(row) <= cursor.pos()) { + row = row->next(); + BreakAgainOneRow(bview, row); + } + + SetCursor(bview, cursor.par(), cursor.pos(), false, cursor.boundary()); + + if (row->next() && row->next()->par() == row->par()) + need_break_row = row->next(); else need_break_row = 0; } else { // set the dimensions of the row - row->fill = Fill(row, paperwidth); - int tmpheight = row->height; - SetHeightOfRow(row); - if (tmpheight == row->height) + row->fill(Fill(bview, row, workWidth(bview))); + int const tmpheight = row->height(); + SetHeightOfRow(bview, row); + if (tmpheight == row->height()) status = LyXText::NEED_VERY_LITTLE_REFRESH; else status = LyXText::NEED_MORE_REFRESH; refresh_y = y; refresh_row = row; - current_font = rawtmpfont; - real_current_font = realtmpfont; - SetCursor(cursor.par, cursor.pos, false); + SetCursor(bview, cursor.par(), cursor.pos(), false, cursor.boundary()); } } - // restore the current font - // That is what a user expects! - current_font = rawtmpfont; - real_current_font = realtmpfont; + + // current_font = rawtmpfont; + // real_current_font = realtmpfont; + + if (IsBoundary(bview->buffer(), cursor.par(), cursor.pos()) + != cursor.boundary()) + SetCursor(bview, cursor.par(), cursor.pos(), false, + !cursor.boundary()); + +#ifndef NEW_INSETS + lastpos = cursor.par()->Last(); +#else + lastpos = cursor.par()->size(); +#endif + if (cursor.pos() == lastpos) + SetCurrentFont(bview); - // check, wether the last characters font has changed. - rawtmpfont = cursor.par->GetFontSettings(cursor.par->Last() - 1); - if (rawparfont != rawtmpfont) { - RedoHeightOfParagraph(cursor); + // check, whether the last characters font has changed. + if (rawparfont != + cursor.par()->GetFontSettings(bview->buffer()->params, lastpos - 1)) { + RedoHeightOfParagraph(bview, cursor); } else { // now the special right address boxes - if (textclasslist.Style(bparams->textclass, - cursor.par->GetLayout()).margintype == MARGIN_RIGHT_ADDRESS_BOX) { - RedoDrawingOfParagraph(cursor); + if (textclasslist.Style(bview->buffer()->params.textclass, + cursor.par()->GetLayout()).margintype == MARGIN_RIGHT_ADDRESS_BOX) { + RedoDrawingOfParagraph(bview, cursor); } } } -void LyXText::GetVisibleRow(int offset, Row * row_ptr, long y) +void LyXText::GetVisibleRow(BufferView * bview, int y_offset, int x_offset, + Row * row_ptr, int y, bool cleared) { - /* returns a printed row */ - Painter & pain = owner_->painter(); + // returns a printed row + Painter & pain = bview->painter(); + + bool const is_rtl = + row_ptr->par()->isRightToLeftPar(bview->buffer()->params); - bool is_rtl = row_ptr->par->isRightToLeftPar(); - LyXParagraph::size_type last = RowLastPrintable(row_ptr); + LyXParagraph::size_type const last = RowLastPrintable(row_ptr); - LyXParagraph::size_type vpos, pos; - float x, tmpx; - int y_top, y_bottom; - float fill_separator, fill_hfill, fill_label_hfill; - LyXParagraph * par, * firstpar; - LyXFont font; + LyXParagraph::size_type vpos; + LyXParagraph::size_type pos; + + float tmpx; + + LyXFont font(LyXFont::ALL_SANE); int maxdesc; - if (row_ptr->height <= 0) { - lyxerr << "LYX_ERROR: row.height: " << row_ptr->height << endl; + if (row_ptr->height() <= 0) { + lyxerr << "LYX_ERROR: row.height: " + << row_ptr->height() << endl; return; } - PrepareToPrint(row_ptr, x, fill_separator, + + float x; + float fill_separator; + float fill_hfill; + float fill_label_hfill; + PrepareToPrint(bview, row_ptr, x, fill_separator, fill_hfill, fill_label_hfill); - /* initialize the pixmap */ + if (inset_owner && (x < 0)) + x = 0; + x += x_offset; - pain.fillRectangle(0, offset, paperwidth, row_ptr->height); + // clear the area where we want to paint/print + int const ww = bview->workWidth(); + + bool clear_area = true; + Inset * inset = 0; + + if (!bview->screen()->forceClear() && last == row_ptr->pos() + && row_ptr->par()->GetChar(row_ptr->pos()) == LyXParagraph::META_INSET + && (inset = row_ptr->par()->GetInset(row_ptr->pos()))) { + clear_area = inset->doClearArea(); + } + // we don't need to clear it's already done!!! + if (cleared) { + clear_area = true; + } else if (clear_area) { +#ifdef WITH_WARNINGS +#warning Should be fixed with a lyxinset::clear_width(bv, font) function! (Jug) +#warning Should we not fix this in the Painter, please have a look Lars! (Jug) +#endif + int const y = y_offset < 0 ? 0 : y_offset; + int const h = y_offset < 0 ? + row_ptr->height() + y_offset : row_ptr->height(); + int const w = inset_owner ? + inset_owner->width(bview, font) - 2 : ww; + int const x = x_offset; + pain.fillRectangle(x, y, w, h); + } else if (inset != 0) { + int h = row_ptr->baseline() - inset->ascent(bview, font); + if (h > 0) { + int const w = (inset_owner ? + inset_owner->width(bview, font) : ww); + pain.fillRectangle(x_offset, y_offset, w, h); + } + h += inset->ascent(bview, font) + inset->descent(bview, font); + if ((row_ptr->height() - h) > 0) { + int const w = (inset_owner ? + inset_owner->width(bview, font) : ww); + pain.fillRectangle(x_offset, y_offset + h, + w, row_ptr->height() - h); + } + if (!inset_owner && !inset->display() && !inset->needFullRow()) + { + int const w = inset->width(bview, font) + int(x); + pain.fillRectangle(w, y_offset, ww - w, row_ptr->height()); + } + } if (selection) { - /* selection code */ + int const w = (inset_owner ? + inset_owner->width(bview, font) : ww); + // selection code if (bidi_same_direction) { - if (sel_start_cursor.row == row_ptr && - sel_end_cursor.row == row_ptr) { - if (sel_start_cursor.x < sel_end_cursor.x) - pain.fillRectangle(sel_start_cursor.x, offset, - sel_end_cursor.x - sel_start_cursor.x, - row_ptr->height, + if (sel_start_cursor.row() == row_ptr && + sel_end_cursor.row() == row_ptr) { + if (sel_start_cursor.x() < sel_end_cursor.x()) + pain.fillRectangle(x_offset + sel_start_cursor.x(), + y_offset, + sel_end_cursor.x() - sel_start_cursor.x(), + row_ptr->height(), LColor::selection); else - pain.fillRectangle(sel_end_cursor.x, offset, - sel_start_cursor.x - sel_end_cursor.x, - row_ptr->height, + pain.fillRectangle(x_offset + sel_end_cursor.x(), + y_offset, + sel_start_cursor.x() - sel_end_cursor.x(), + row_ptr->height(), LColor::selection); - } else if (sel_start_cursor.row == row_ptr) { + } else if (sel_start_cursor.row() == row_ptr) { if (is_rtl) - pain.fillRectangle(0, offset, - sel_start_cursor.x, - row_ptr->height, + pain.fillRectangle(x_offset, y_offset, + sel_start_cursor.x(), + row_ptr->height(), LColor::selection); else - pain.fillRectangle(sel_start_cursor.x, offset, - paperwidth - sel_start_cursor.x, - row_ptr->height, + pain.fillRectangle(x_offset + sel_start_cursor.x(), + y_offset, + w - sel_start_cursor.x(), + row_ptr->height(), LColor::selection); - } else if (sel_end_cursor.row == row_ptr) { + } else if (sel_end_cursor.row() == row_ptr) { if (is_rtl) - pain.fillRectangle(sel_end_cursor.x, offset, - paperwidth - sel_end_cursor.x, - row_ptr->height, + pain.fillRectangle(x_offset + sel_end_cursor.x(), + y_offset, + w - sel_end_cursor.x(), + row_ptr->height(), LColor::selection); else - pain.fillRectangle(0, offset, - sel_end_cursor.x, - row_ptr->height, + pain.fillRectangle(x_offset, y_offset, + sel_end_cursor.x(), + row_ptr->height(), LColor::selection); - } else if (y > sel_start_cursor.y && y < sel_end_cursor.y) { - pain.fillRectangle(0, offset, - paperwidth, row_ptr->height, + } else if (y > sel_start_cursor.y() + && y < sel_end_cursor.y()) { + pain.fillRectangle(x_offset, y_offset, w, + row_ptr->height(), LColor::selection); } - } else if ( sel_start_cursor.row != row_ptr && - sel_end_cursor.row != row_ptr && - y > sel_start_cursor.y && y < sel_end_cursor.y) { - pain.fillRectangle(0, offset, - paperwidth, row_ptr->height, + } else if (sel_start_cursor.row() != row_ptr && + sel_end_cursor.row() != row_ptr && + y > sel_start_cursor.y() + && y < sel_end_cursor.y()) { + pain.fillRectangle(x_offset, y_offset, w, + row_ptr->height(), LColor::selection); - } else if (sel_start_cursor.row == row_ptr || - sel_end_cursor.row == row_ptr) { + } else if (sel_start_cursor.row() == row_ptr || + sel_end_cursor.row() == row_ptr) { float tmpx = x; - int cell = 0; - if (row_ptr->par->table) { - cell = NumberOfCell(row_ptr->par, row_ptr->pos); - tmpx += row_ptr->par->table->GetBeginningOfTextInCell(cell); - } - if ( (sel_start_cursor.row != row_ptr && !is_rtl) || - (sel_end_cursor.row != row_ptr && is_rtl)) - pain.fillRectangle(0, offset, - tmpx, row_ptr->height, + if ((sel_start_cursor.row() != row_ptr && !is_rtl) || + (sel_end_cursor.row() != row_ptr && is_rtl)) + pain.fillRectangle(x_offset, y_offset, + int(tmpx), + row_ptr->height(), LColor::selection); - if (row_ptr->par->table) { - float x_old = x; - for (vpos = row_ptr->pos; vpos <= last; ++vpos) { - pos = vis2log(vpos); - float old_tmpx = tmpx; - if (row_ptr->par->IsNewline(pos)) { - tmpx = x_old + row_ptr->par->table->WidthOfColumn(cell); - x_old = tmpx; - ++cell; - tmpx += row_ptr->par->table->GetBeginningOfTextInCell(cell); - } else { - tmpx += SingleWidth(row_ptr->par, pos); - } - if ( (sel_start_cursor.row != row_ptr || - sel_start_cursor.pos <= pos) && - (sel_end_cursor.row != row_ptr || - pos < sel_end_cursor.pos) ) - pain.fillRectangle(old_tmpx, offset, - tmpx - old_tmpx + 1, - row_ptr->height, - LColor::selection); + LyXParagraph::size_type main_body = + BeginningOfMainBody(bview->buffer(), + row_ptr->par()); + + for (vpos = row_ptr->pos(); vpos <= last; ++vpos) { + pos = vis2log(vpos); + float const old_tmpx = tmpx; + if (main_body > 0 && pos == main_body-1) { + tmpx += fill_label_hfill + + lyxfont::width(textclasslist.Style(bview->buffer()->params.textclass, + row_ptr->par()->GetLayout()).labelsep, + GetFont(bview->buffer(),row_ptr->par(), -2)); + if (row_ptr->par()->IsLineSeparator(main_body-1)) + tmpx -= SingleWidth(bview, row_ptr->par(), main_body-1); } - } else { - LyXParagraph::size_type main_body = - BeginningOfMainBody(row_ptr->par); - - for (vpos = row_ptr->pos; vpos <= last; ++vpos) { - pos = vis2log(vpos); - float old_tmpx = tmpx; - if (main_body > 0 && pos == main_body-1) { - tmpx += fill_label_hfill + - lyxfont::width(textclasslist.Style(bparams->textclass, - row_ptr->par->GetLayout()).labelsep, - GetFont(row_ptr->par, -2)); - if (row_ptr->par->IsLineSeparator(main_body-1)) - tmpx -= SingleWidth(row_ptr->par, main_body-1); - } - if (HfillExpansion(row_ptr, pos)) { - tmpx += SingleWidth(row_ptr->par, pos); - if (pos >= main_body) - tmpx += fill_hfill; - else - tmpx += fill_label_hfill; - } - else if (row_ptr->par->IsSeparator(pos)) { - tmpx += SingleWidth(row_ptr->par, pos); - if (pos >= main_body) - tmpx += fill_separator; - } else - tmpx += SingleWidth(row_ptr->par, pos); - - if ( (sel_start_cursor.row != row_ptr || - sel_start_cursor.pos <= pos) && - (sel_end_cursor.row != row_ptr || - pos < sel_end_cursor.pos) ) - pain.fillRectangle(old_tmpx, offset, - tmpx - old_tmpx + 1, - row_ptr->height, - LColor::selection); + if (HfillExpansion(bview->buffer(), row_ptr, pos)) { + tmpx += SingleWidth(bview, row_ptr->par(), pos); + if (pos >= main_body) + tmpx += fill_hfill; + else + tmpx += fill_label_hfill; } + else if (row_ptr->par()->IsSeparator(pos)) { + tmpx += SingleWidth(bview, row_ptr->par(), pos); + if (pos >= main_body) + tmpx += fill_separator; + } else + tmpx += SingleWidth(bview, row_ptr->par(), pos); + + if ((sel_start_cursor.row() != row_ptr || + sel_start_cursor.pos() <= pos) && + (sel_end_cursor.row() != row_ptr || + pos < sel_end_cursor.pos()) ) + // Here we do not use x_offset as x_offset was + // added to x. + pain.fillRectangle(int(old_tmpx), + y_offset, + int(tmpx - old_tmpx + 1), + row_ptr->height(), + LColor::selection); } - if ( (sel_start_cursor.row != row_ptr && is_rtl) || - (sel_end_cursor.row != row_ptr && !is_rtl) ) - pain.fillRectangle(tmpx, offset, - paperwidth - tmpx, - row_ptr->height, + + if ((sel_start_cursor.row() != row_ptr && is_rtl) || + (sel_end_cursor.row() != row_ptr && !is_rtl) ) + pain.fillRectangle(x_offset + int(tmpx), + y_offset, + int(ww - tmpx), + row_ptr->height(), LColor::selection); } } - if (row_ptr->par->appendix){ - pain.line(1, offset, - 1, offset + row_ptr->height, - LColor::appendixline); - pain.line(paperwidth - 2, offset, - paperwidth - 2, offset + row_ptr->height, - LColor::appendixline); - } - - if (row_ptr->par->pextra_type == LyXParagraph::PEXTRA_MINIPAGE) { - /* draw a marker at the left margin! */ - LyXFont font = GetFont(row_ptr->par, 0); - int asc = lyxfont::maxAscent(font); - int x = (LYX_PAPER_MARGIN - lyxfont::width('|', font)) / 2; - int y1 = (offset + row_ptr->baseline); - int y2 = (offset + row_ptr->baseline) - asc; - pain.line(x, y1, x, y2, LColor::minipageline); - } - if (row_ptr->par->footnoteflag == LyXParagraph::OPEN_FOOTNOTE) { + int box_x = 0; +#ifndef NEW_INSETS + if (row_ptr->par()->footnoteflag == LyXParagraph::OPEN_FOOTNOTE) { LyXFont font(LyXFont::ALL_SANE); font.setSize(LyXFont::SIZE_FOOTNOTE); font.setColor(LColor::footnote); - int box_x = LYX_PAPER_MARGIN; - box_x += lyxfont::width(" wide-tab ", font); - if (row_ptr->previous && - row_ptr->previous->par->footnoteflag != LyXParagraph::OPEN_FOOTNOTE){ + box_x = LYX_PAPER_MARGIN + lyxfont::width(" wide-tab ", font); + if (row_ptr->previous() && + row_ptr->previous()->par()->footnoteflag != LyXParagraph::OPEN_FOOTNOTE){ string fs; - switch (row_ptr->par->footnotekind) { + switch (row_ptr->par()->footnotekind) { case LyXParagraph::MARGIN: fs = " margin"; break; @@ -3881,90 +3522,197 @@ void LyXText::GetVisibleRow(int offset, Row * row_ptr, long y) } pain.fillRectangle(LYX_PAPER_MARGIN, - offset + 1, + y_offset + 1, box_x - LYX_PAPER_MARGIN, int(lyxfont::maxAscent(font) + lyxfont::maxDescent(font)), LColor::footnotebg); - pain.line(LYX_PAPER_MARGIN, offset, - paperwidth - LYX_PAPER_MARGIN, offset, + pain.line(LYX_PAPER_MARGIN, y_offset, + workWidth(bview) - LYX_PAPER_MARGIN, y_offset, LColor::footnoteframe); pain.text(LYX_PAPER_MARGIN, - offset + int(lyxfont::maxAscent(font)) + 1, + y_offset + int(lyxfont::maxAscent(font)) + 1, fs, font); - pain.line(LYX_PAPER_MARGIN, offset, + pain.line(LYX_PAPER_MARGIN, y_offset, LYX_PAPER_MARGIN, - offset + int(lyxfont::maxAscent(font) + y_offset + int(lyxfont::maxAscent(font) + lyxfont::maxDescent(font)), LColor::footnoteframe); pain.line(LYX_PAPER_MARGIN, - offset + int(lyxfont::maxAscent(font) + y_offset + int(lyxfont::maxAscent(font) + lyxfont::maxDescent(font)) + 1, box_x, - offset + int(lyxfont::maxAscent(font) + y_offset + int(lyxfont::maxAscent(font) + lyxfont::maxDescent(font)) + 1, LColor::footnoteframe); } /* draw the open floats in a red box */ - pain.line(box_x, offset, - box_x, offset + row_ptr->height, + pain.line(box_x, y_offset, + box_x, y_offset + row_ptr->height(), LColor::footnoteframe); - pain.line(paperwidth - LYX_PAPER_MARGIN, - offset, - paperwidth - LYX_PAPER_MARGIN, - offset + row_ptr->height, + pain.line(workWidth(bview) - LYX_PAPER_MARGIN, + y_offset, + workWidth(bview) - LYX_PAPER_MARGIN, + y_offset + row_ptr->height(), LColor::footnoteframe); - } else if (row_ptr->previous && - row_ptr->previous->par->footnoteflag + + + // Draw appendix lines + LyXParagraph * p = row_ptr->par()->PreviousBeforeFootnote()->FirstPhysicalPar(); + if (p->params.appendix()) { + pain.line(1, y_offset, + 1, y_offset + row_ptr->height(), + LColor::appendixline); + pain.line(workWidth(bview) - 2, y_offset, + workWidth(bview) - 2, + y_offset + row_ptr->height(), + LColor::appendixline); + } + +#ifndef NO_PEXTRA + // Draw minipage line + bool const minipage = + (p->params.pextraType() == LyXParagraph::PEXTRA_MINIPAGE); + if (minipage) + pain.line(LYX_PAPER_MARGIN/5, y_offset, + LYX_PAPER_MARGIN/5, + y_offset + row_ptr->height() - 1, + LColor::minipageline); +#endif + // Draw depth lines + int const depth = p->GetDepth(); + for (int i = 1; i <= depth; ++i) { + int const line_x = (LYX_PAPER_MARGIN / 5) * + (i + minipage); + pain.line(line_x, y_offset, line_x, + y_offset + row_ptr->height() - 1, + LColor::depthbar); + } + } else if (row_ptr->previous() && + row_ptr->previous()->par()->footnoteflag == LyXParagraph::OPEN_FOOTNOTE) { LyXFont font(LyXFont::ALL_SANE); font.setSize(LyXFont::SIZE_FOOTNOTE); - int box_x = LYX_PAPER_MARGIN; - box_x += lyxfont::width(" wide-tab ", font); + int const box_x = LYX_PAPER_MARGIN + + lyxfont::width(" wide-tab ", font); + + pain.line(box_x, y_offset, + workWidth(bview) - LYX_PAPER_MARGIN, + y_offset, LColor::footnote); + } +#endif + // Draw appendix lines +#ifndef NEW_INSETS + LyXParagraph * firstpar = row_ptr->par()->FirstPhysicalPar(); +#else + LyXParagraph * firstpar = row_ptr->par(); +#endif + if (firstpar->params.appendix()) { + pain.line(1, y_offset, + 1, y_offset + row_ptr->height(), + LColor::appendixline); + pain.line(ww - 2, y_offset, + ww - 2, y_offset + row_ptr->height(), + LColor::appendixline); + } +#ifndef NO_PEXTRA + // Draw minipage line + bool const minipage = + (firstpar->params.pextraType() == LyXParagraph::PEXTRA_MINIPAGE); + if (minipage) + pain.line(LYX_PAPER_MARGIN/5 + box_x, y_offset, + LYX_PAPER_MARGIN/5 + box_x, + y_offset + row_ptr->height() - 1, + LColor::minipageline); +#endif + // Draw depth lines + int const depth = firstpar->GetDepth(); + if (depth > 0) { + int next_depth = 0; + int prev_depth = 0; + if (row_ptr->next()) +#ifndef NEW_INSETS + if (row_ptr->par()->footnoteflag == + row_ptr->next()->par()->footnoteflag) + next_depth = row_ptr->next()->par()->GetDepth(); + else if (row_ptr->par()->footnoteflag != LyXParagraph::OPEN_FOOTNOTE) + next_depth = depth; +#else + next_depth = row_ptr->next()->par()->GetDepth(); +#endif + if (row_ptr->previous()) +#ifndef NEW_INSETS + if (row_ptr->par()->footnoteflag == + row_ptr->previous()->par()->footnoteflag) + prev_depth = row_ptr->previous()->par()->GetDepth(); + else if (row_ptr->par()->footnoteflag != LyXParagraph::OPEN_FOOTNOTE) + prev_depth = depth; +#else + prev_depth = row_ptr->previous()->par()->GetDepth(); +#endif + + for (int i = 1; i <= depth; ++i) { + int const line_x = (LYX_PAPER_MARGIN / 5) * + (i +#ifndef NO_PEXTRA + + minipage +#endif + ) + box_x + x_offset; + pain.line(line_x, y_offset, line_x, + y_offset + row_ptr->height() - 1 - (i - next_depth - 1) * 3, + LColor::depthbar); - pain.line(box_x, offset, - paperwidth - LYX_PAPER_MARGIN, - offset, LColor::footnote); + if (i > prev_depth) + pain.fillRectangle(line_x, y_offset, LYX_PAPER_MARGIN / 5, 2, + LColor::depthbar); + if (i > next_depth) + pain.fillRectangle(line_x, + y_offset + row_ptr->height() - 2 - (i - next_depth - 1) * 3, + LYX_PAPER_MARGIN / 5, 2, + LColor::depthbar); + } } + LyXLayout const & layout = - textclasslist.Style(bparams->textclass, - row_ptr->par->GetLayout()); - firstpar = row_ptr->par->FirstPhysicalPar(); - - y_top = 0; - y_bottom = row_ptr->height; + textclasslist.Style(bview->buffer()->params.textclass, + row_ptr->par()->GetLayout()); + + int y_top = 0; + int y_bottom = row_ptr->height(); - /* is it a first row? */ - if (row_ptr->pos == 0 - && row_ptr->par == firstpar) { + // is it a first row? + if (!row_ptr->pos() && (row_ptr->par() == firstpar)) { - /* start of appendix? */ - if (row_ptr->par->start_of_appendix){ - pain.line(1, offset, - paperwidth - 2, offset, + // start of appendix? + if (row_ptr->par()->params.startOfAppendix()) { + pain.line(1, y_offset, + ww - 2, y_offset, LColor::appendixline); } - /* think about the margins */ - if (!row_ptr->previous) + // think about the margins + if (!row_ptr->previous() && bv_owner) y_top += LYX_PAPER_MARGIN; - if (row_ptr->par->pagebreak_top){ /* draw a top pagebreak */ + // draw a top pagebreak + if (row_ptr->par()->params.pagebreakTop()) { LyXFont pb_font; pb_font.setColor(LColor::pagebreak).decSize(); - int w = 0, a = 0, d = 0; - pain.line(0, offset + y_top + 2*DefaultHeight(), - paperwidth, - offset + y_top + 2*DefaultHeight(), + int w = 0; + int a = 0; + int d = 0; + pain.line(0, y_offset + y_top + 2*DefaultHeight(), + ww, + y_offset + y_top + 2 * DefaultHeight(), LColor::pagebreak, Painter::line_onoffdash) .rectText(0, @@ -3973,8 +3721,8 @@ void LyXText::GetVisibleRow(int offset, Row * row_ptr, long y) pb_font, LColor::background, LColor::background, false, w, a, d); - pain.rectText((paperwidth - w)/2, - offset +y_top + 2*DefaultHeight() +d, + pain.rectText((ww - w)/2, + y_offset + y_top + 2 * DefaultHeight() + d, _("Page Break (top)"), pb_font, LColor::background, @@ -3982,117 +3730,132 @@ void LyXText::GetVisibleRow(int offset, Row * row_ptr, long y) y_top += 3 * DefaultHeight(); } - if (row_ptr->par->added_space_top.kind() == VSpace::VFILL) { - /* draw a vfill top */ - pain.line(0, offset + 2 + y_top, - LYX_PAPER_MARGIN, offset + 2 + y_top, + if (row_ptr->par()->params.spaceTop().kind() == VSpace::VFILL) { + // draw a vfill top + pain.line(0, y_offset + 2 + y_top, + LYX_PAPER_MARGIN, y_offset + 2 + y_top, LColor::vfillline); - pain.line(0, offset + y_top + 3 * DefaultHeight(), + pain.line(0, y_offset + y_top + 3 * DefaultHeight(), LYX_PAPER_MARGIN, - offset + y_top + 3 * DefaultHeight(), + y_offset + y_top + 3 * DefaultHeight(), LColor::vfillline); - pain.line(LYX_PAPER_MARGIN / 2, offset + 2 + y_top, + pain.line(LYX_PAPER_MARGIN / 2, y_offset + 2 + y_top, LYX_PAPER_MARGIN / 2, - offset + y_top + 3 * DefaultHeight(), + y_offset + y_top + 3 * DefaultHeight(), LColor::vfillline); y_top += 3 * DefaultHeight(); } - /* think about user added space */ - y_top += int(row_ptr->par->added_space_top.inPixels(owner_)); + // think about user added space + y_top += int(row_ptr->par()->params.spaceTop().inPixels(bview)); - /* think about the parskip */ - /* some parskips VERY EASY IMPLEMENTATION */ - if (bparams->paragraph_separation == BufferParams::PARSEP_SKIP) { + // think about the parskip + // some parskips VERY EASY IMPLEMENTATION + if (bview->buffer()->params.paragraph_separation == BufferParams::PARSEP_SKIP) { if (layout.latextype == LATEX_PARAGRAPH && firstpar->GetDepth() == 0 - && firstpar->Previous()) - y_top += bparams->getDefSkip().inPixels(owner_); - else if (firstpar->Previous() - && textclasslist.Style(bparams->textclass, - firstpar->Previous()->GetLayout()).latextype == LATEX_PARAGRAPH - && firstpar->Previous()->GetDepth() == 0) + && firstpar->previous()) + y_top += bview->buffer()->params.getDefSkip().inPixels(bview); + else if (firstpar->previous() + && textclasslist.Style(bview->buffer()->params.textclass, + firstpar->previous()->GetLayout()).latextype == LATEX_PARAGRAPH + && firstpar->previous()->GetDepth() == 0) // is it right to use defskip here, too? (AS) - y_top += bparams->getDefSkip().inPixels(owner_); + y_top += bview->buffer()->params.getDefSkip().inPixels(bview); } - if (row_ptr->par->line_top) { /* draw a top line */ - y_top += lyxfont::ascent('x', GetFont(row_ptr->par, 0)); - - pain.line(0, offset + y_top, - paperwidth, offset + y_top, + if (row_ptr->par()->params.lineTop()) { + // draw a top line + y_top += lyxfont::ascent('x', + GetFont(bview->buffer(), + row_ptr->par(), 0)); + int const w = (inset_owner ? + inset_owner->width(bview, font) : ww); + int const xp = static_cast(inset_owner ? x : 0); + pain.line(xp, y_offset + y_top, + w, y_offset + y_top, LColor::topline, Painter::line_solid, Painter::line_thick); - y_top += lyxfont::ascent('x', GetFont(row_ptr->par, 0)); + y_top += lyxfont::ascent('x',GetFont(bview->buffer(), + row_ptr->par(), 0)); } - /* should we print a label? */ + // should we print a label? if (layout.labeltype >= LABEL_STATIC && (layout.labeltype != LABEL_STATIC || layout.latextype != LATEX_ENVIRONMENT - || row_ptr->par->IsFirstInSequence())) { - font = GetFont(row_ptr->par, -2); - if (!row_ptr->par->GetLabelstring().empty()) { + || row_ptr->par()->IsFirstInSequence())) { + font = GetFont(bview->buffer(), row_ptr->par(), -2); + if (!row_ptr->par()->GetLabelstring().empty()) { tmpx = x; - string tmpstring = row_ptr->par->GetLabelstring(); + string const tmpstring = + row_ptr->par()->GetLabelstring(); if (layout.labeltype == LABEL_COUNTER_CHAPTER) { - if (bparams->secnumdepth >= 0){ - /* this is special code for the chapter layout. This is printed in - * an extra row and has a pagebreak at the top. */ + if (bview->buffer()->params.secnumdepth >= 0) { + // this is special code for + // the chapter layout. This is + // printed in an extra row + // and has a pagebreak at + // the top. float spacing_val = 1.0; - if (!row_ptr->par->spacing.isDefault()) { - spacing_val = row_ptr->par->spacing.getValue(); + if (!row_ptr->par()->params.spacing().isDefault()) { + spacing_val = row_ptr->par()->params.spacing().getValue(); } else { - spacing_val = bparams->spacing.getValue(); + spacing_val = bview->buffer()->params.spacing.getValue(); } maxdesc = int(lyxfont::maxDescent(font) * layout.spacing.getValue() * spacing_val) + int(layout.parsep) * DefaultHeight(); if (is_rtl) - tmpx = paperwidth - LeftMargin(row_ptr) - + tmpx = ww - LeftMargin(bview, row_ptr) - lyxfont::width(tmpstring, font); pain.text(int(tmpx), - offset + row_ptr->baseline - row_ptr->ascent_of_text - maxdesc, + y_offset + row_ptr->baseline() - row_ptr->ascent_of_text() - maxdesc, tmpstring, font); } } else { if (is_rtl) { - tmpx = paperwidth - LeftMargin(row_ptr) + tmpx = ww - LeftMargin(bview, row_ptr) + lyxfont::width(layout.labelsep, font); - if (row_ptr->par->footnoteflag == LyXParagraph::OPEN_FOOTNOTE) { +#ifndef NEW_INSETS + if (row_ptr->par()->footnoteflag == LyXParagraph::OPEN_FOOTNOTE) { LyXFont font(LyXFont::ALL_SANE); font.setSize(LyXFont::SIZE_SMALL); tmpx += lyxfont::width("Mwide-fixM", font); } +#endif } else tmpx = x - lyxfont::width(layout.labelsep, font) - lyxfont::width(tmpstring, font); - /* draw it! */ + // draw it! pain.text(int(tmpx), - offset + row_ptr->baseline, + y_offset + row_ptr->baseline(), tmpstring, font); } } - /* the labels at the top of an environment. More or less for bibliography */ + // the labels at the top of an environment. + // More or less for bibliography } else if (layout.labeltype == LABEL_TOP_ENVIRONMENT || layout.labeltype == LABEL_BIBLIO || layout.labeltype == LABEL_CENTERED_TOP_ENVIRONMENT) { - if (row_ptr->par->IsFirstInSequence()) { - font = GetFont(row_ptr->par, -2); - if (!row_ptr->par->GetLabelstring().empty()) { - string tmpstring = row_ptr->par->GetLabelstring(); + if (row_ptr->par()->IsFirstInSequence()) { + font = GetFont(bview->buffer(), + row_ptr->par(), -2); + if (!row_ptr->par()->GetLabelstring().empty()) { + string const tmpstring = + row_ptr->par()->GetLabelstring(); float spacing_val = 1.0; - if (!row_ptr->par->spacing.isDefault()) { - spacing_val = row_ptr->par->spacing.getValue(); + if (!row_ptr->par()->params.spacing().isDefault()) { + spacing_val = row_ptr->par()->params.spacing().getValue(); } else { - spacing_val = bparams->spacing.getValue(); + spacing_val = bview->buffer()->params.spacing.getValue(); } maxdesc = int(lyxfont::maxDescent(font) * layout.spacing.getValue() * spacing_val @@ -4100,63 +3863,72 @@ void LyXText::GetVisibleRow(int offset, Row * row_ptr, long y) tmpx = x; if (layout.labeltype == LABEL_CENTERED_TOP_ENVIRONMENT){ - tmpx = ( (is_rtl ? LeftMargin(row_ptr) : x) - + paperwidth - RightMargin(row_ptr) ) / 2; + tmpx = ( (is_rtl ? LeftMargin(bview, row_ptr) : x) + + ww - RightMargin(bview->buffer(), row_ptr) ) / 2; tmpx -= lyxfont::width(tmpstring, font) / 2; } else if (is_rtl) - tmpx = paperwidth - LeftMargin(row_ptr) - + tmpx = ww - LeftMargin(bview, row_ptr) - lyxfont::width(tmpstring, font); pain.text(int(tmpx), - offset + row_ptr->baseline - - row_ptr->ascent_of_text + y_offset + row_ptr->baseline() + - row_ptr->ascent_of_text() - maxdesc, tmpstring, font); } } } - if (layout.labeltype == LABEL_BIBLIO && row_ptr->par->bibkey) { - font = GetFont(row_ptr->par, -1); + if (layout.labeltype == LABEL_BIBLIO && row_ptr->par()->bibkey) { + font = GetFont(bview->buffer(), row_ptr->par(), -1); if (is_rtl) - tmpx = paperwidth - LeftMargin(row_ptr) + tmpx = ww - LeftMargin(bview, row_ptr) + lyxfont::width(layout.labelsep, font); else tmpx = x - lyxfont::width(layout.labelsep, font) - - row_ptr->par->bibkey->width(owner_->painter(), font); - row_ptr->par->bibkey->draw(pain, - font, - offset + row_ptr->baseline, - tmpx); + - row_ptr->par()->bibkey->width(bview, font); + row_ptr->par()->bibkey->draw(bview, font, + y_offset + row_ptr->baseline(), + tmpx, clear_area); } } - /* is it a last row? */ - par = row_ptr->par->LastPhysicalPar(); - if (row_ptr->par->ParFromPos(last + 1) == par - && (!row_ptr->next || row_ptr->next->par != row_ptr->par)) { - - /* think about the margins */ - if (!row_ptr->next) + // is it a last row? +#ifndef NEW_INSETS + LyXParagraph * par = row_ptr->par()->LastPhysicalPar(); +#else + LyXParagraph * par = row_ptr->par(); +#endif + if ( +#ifndef NEW_INSETS + row_ptr->par()->ParFromPos(last + 1) == par +#else + row_ptr->par() == par +#endif + && (!row_ptr->next() || row_ptr->next()->par() != row_ptr->par())) + { + // think about the margins + if (!row_ptr->next() && bv_owner) y_bottom -= LYX_PAPER_MARGIN; - /* draw a bottom pagebreak */ - if (firstpar->pagebreak_bottom) { + // draw a bottom pagebreak + if (firstpar->params.pagebreakBottom()) { LyXFont pb_font; pb_font.setColor(LColor::pagebreak).decSize(); - int w = 0, a = 0, d = 0; - pain.line(0, - offset + y_bottom - 2 * DefaultHeight(), - paperwidth, - offset + y_bottom - 2 * DefaultHeight(), - LColor::pagebreak, - Painter::line_onoffdash) - .rectText(0, - 0, + int const y_place = y_offset + y_bottom + - 2 * DefaultHeight(); + + int w = 0; + int a = 0; + int d = 0; + pain + .line(0, y_place, ww, y_place, + LColor::pagebreak, + Painter::line_onoffdash) + .rectText(0, 0, _("Page Break (bottom)"), pb_font, LColor::background, LColor::background, false, w, a, d); - pain.rectText((paperwidth - w)/2, - offset +y_top + 2*DefaultHeight() +d, + pain.rectText((ww - w) / 2, y_place + d, _("Page Break (bottom)"), pb_font, LColor::background, @@ -4164,55 +3936,86 @@ void LyXText::GetVisibleRow(int offset, Row * row_ptr, long y) y_bottom -= 3 * DefaultHeight(); } - if (firstpar->added_space_bottom.kind() == VSpace::VFILL) { - /* draw a vfill bottom */ - pain.line(0, offset + y_bottom - 3 * DefaultHeight(), - LYX_PAPER_MARGIN, - offset + y_bottom - 3 * DefaultHeight(), + if (firstpar->params.spaceBottom().kind() == VSpace::VFILL) { + // draw a vfill bottom + int const y_place = y_offset + y_bottom + - 3 * DefaultHeight(); + + pain.line(0, y_place, + LYX_PAPER_MARGIN, y_place, LColor::vfillline); - pain.line(0, offset + y_bottom - 2, + pain.line(0, y_offset + y_bottom - 2, LYX_PAPER_MARGIN, - offset + y_bottom - 2, + y_offset + y_bottom - 2, LColor::vfillline); pain.line(LYX_PAPER_MARGIN / 2, - offset + y_bottom - 3 * DefaultHeight(), + y_place, LYX_PAPER_MARGIN / 2, - offset + y_bottom - 2, + y_offset + y_bottom - 2, LColor::vfillline); - y_bottom -= 3* DefaultHeight(); + y_bottom -= 3 * DefaultHeight(); } - /* think about user added space */ - y_bottom -= int(firstpar->added_space_bottom.inPixels(owner_)); + // think about user added space + y_bottom -= int(firstpar->params.spaceBottom().inPixels(bview)); - if (firstpar->line_bottom) { - /* draw a bottom line */ - y_bottom -= lyxfont::ascent('x', GetFont(par, par->Last() - 1)); - pain.line(0, offset + y_bottom, - paperwidth, offset + y_bottom, + if (firstpar->params.lineBottom()) { + // draw a bottom line +#ifndef NEW_INSETS + y_bottom -= lyxfont::ascent('x', + GetFont(bview->buffer(), + par, + par->Last() - 1)); +#else + y_bottom -= lyxfont::ascent('x', + GetFont(bview->buffer(), + par, + par->size() - 1)); +#endif + int const w = (inset_owner ? + inset_owner->width(bview, font) : ww); + int const xp = static_cast(inset_owner ? x : 0); + pain.line(xp, y_offset + y_bottom, + w, y_offset + y_bottom, LColor::topline, Painter::line_solid, Painter::line_thick); - y_bottom -= lyxfont::ascent('x', GetFont(par, par->Last() - 1)); +#ifndef NEW_INSETS + y_bottom -= lyxfont::ascent('x', + GetFont(bview->buffer(), + par, + par->Last() - 1)); +#else + y_bottom -= lyxfont::ascent('x', + GetFont(bview->buffer(), + par, + par->size() - 1)); +#endif } // draw an endlabel - int endlabel = row_ptr->par->GetEndLabel(); - if (endlabel == END_LABEL_BOX || - endlabel == END_LABEL_FILLED_BOX) { - LyXFont font = GetFont(row_ptr->par, last); - int size = int(0.75 * lyxfont::maxAscent(font)); - int y = (offset + row_ptr->baseline) - size; + int const endlabel = + row_ptr->par()->GetEndLabel(bview->buffer()->params); + switch (endlabel) { + case END_LABEL_BOX: + case END_LABEL_FILLED_BOX: + { + LyXFont const font = GetFont(bview->buffer(), + row_ptr->par(), last); + int const size = int(0.75 * lyxfont::maxAscent(font)); + int const y = (y_offset + row_ptr->baseline()) - size; int x = is_rtl ? LYX_PAPER_MARGIN - : paperwidth - LYX_PAPER_MARGIN - size; - if (row_ptr->par->footnoteflag == LyXParagraph::OPEN_FOOTNOTE) + : ww - LYX_PAPER_MARGIN - size; +#ifndef NEW_INSETS + if (row_ptr->par()->footnoteflag == LyXParagraph::OPEN_FOOTNOTE) if (is_rtl) { LyXFont font(LyXFont::ALL_SANE); font.setSize(LyXFont::SIZE_SMALL); x += lyxfont::width("Mwide-figM", font); } else x -= LYX_PAPER_MARGIN/2; - if (row_ptr->fill <= size) - x += (size - row_ptr->fill + 1) * (is_rtl ? -1 : 1); +#endif + if (row_ptr->fill() <= size) + x += (size - row_ptr->fill() + 1) * (is_rtl ? -1 : 1); if (endlabel == END_LABEL_BOX) { pain.line(x, y, x, y + size, LColor::eolmarker); @@ -4225,267 +4028,93 @@ void LyXText::GetVisibleRow(int offset, Row * row_ptr, long y) } else pain.fillRectangle(x, y, size, size, LColor::eolmarker); + break; + } + case END_LABEL_STATIC: + { + LyXTextClass::LayoutList::size_type layout = row_ptr->par()->GetLayout(); + string const tmpstring = textclasslist. + Style(bview->buffer()->params.textclass, + layout).endlabelstring(); + font = GetFont(bview->buffer(), row_ptr->par(), -2); + int const tmpx = is_rtl ? + int(x) - lyxfont::width(tmpstring, font) + : ww - RightMargin(bview->buffer(), row_ptr) - row_ptr->fill(); + pain.text( tmpx, y_offset + row_ptr->baseline(), tmpstring, font); + break; + } + case END_LABEL_NO_LABEL: + break; } } - /* draw the text in the pixmap */ + // draw the text in the pixmap - vpos = row_ptr->pos; - /* table stuff -- begin*/ - if (row_ptr->par->table) { - bool on_off; - int cell = NumberOfCell(row_ptr->par, row_ptr->pos); - float x_old = x; - x += row_ptr->par->table->GetBeginningOfTextInCell(cell); - - while (vpos <= last) { - pos = vis2log(vpos); - if (row_ptr->par->IsNewline(pos)) { - - x = x_old + row_ptr->par->table->WidthOfColumn(cell); - /* draw the table lines, still very simple */ - on_off = !row_ptr->par->table->TopLine(cell); - if ((!on_off || - !row_ptr->par->table->TopAlreadyDrawed(cell)) && - !row_ptr->par->table->IsContRow(cell)) - pain.line(int(x_old), - offset + row_ptr->baseline - row_ptr->ascent_of_text, - int(x), - offset + row_ptr->baseline - row_ptr->ascent_of_text, - LColor::tableline, - on_off ? Painter::line_onoffdash : Painter::line_solid); - - on_off = !row_ptr->par->table->BottomLine(cell); - if ((!on_off && !row_ptr->par->table->RowHasContRow(cell)) || - row_ptr->par->table->VeryLastRow(cell)) - - pain.line(int(x_old), - offset + y_bottom - 1, - int(x), - offset + y_bottom - 1, - LColor::tableline, - on_off ? Painter::line_onoffdash : Painter::line_solid); - - on_off = !row_ptr->par->table->LeftLine(cell); - - pain.line(int(x_old), - offset + row_ptr->baseline - row_ptr->ascent_of_text, - int(x_old), - offset + y_bottom - 1, - LColor::tableline, - on_off ? Painter::line_onoffdash : Painter::line_solid); - - on_off = !row_ptr->par->table->RightLine(cell); - - pain.line(int(x) - row_ptr->par->table->AdditionalWidth(cell), - offset + row_ptr->baseline - row_ptr->ascent_of_text, - int(x) - row_ptr->par->table->AdditionalWidth(cell), - offset + y_bottom - 1, - LColor::tableline, - on_off ? Painter::line_onoffdash : Painter::line_solid); - - x_old = x; - /* take care about the alignment and other spaces */ - ++cell; - x += row_ptr->par->table->GetBeginningOfTextInCell(cell); - if (row_ptr->par->table->IsFirstCell(cell)) - --cell; // little hack, sorry - ++vpos; - } else if (row_ptr->par->IsHfill(pos)) { - x += 1; - - pain.line(int(x), - offset + row_ptr->baseline - DefaultHeight() / 2, - int(x), - offset + row_ptr->baseline, - LColor::vfillline); - - x += 2; - ++vpos; - } else if (row_ptr->par->IsSeparator(pos)) { - tmpx = x; - x+= SingleWidth(row_ptr->par, pos); -#warning Think about this. -#if 0 - /* -------> Only draw protected spaces when - * not in free-spacing mode. */ - if (row_ptr->par->GetChar(pos) == LyXParagraph::META_PROTECTED_SEPARATOR && !layout.free_spacing) { - pain.line(int(tmpx), - offset + row_ptr->baseline - 3, - int(tmpx), - offset + row_ptr->baseline - 1, - LColor::vfillline); - - pain.line(int(tmpx), - offset + row_ptr->baseline - 1, - int(x - 2), - offset + row_ptr->baseline - 1, - LColor::vfillline); - - pain.line(int(x - 2), - offset + row_ptr->baseline - 3, - int(x - 2), - offset + row_ptr->baseline - 1, - LColor::vfillline); - - /* what about underbars? */ - font = GetFont(row_ptr->par, pos); - if (font.underbar() == LyXFont::ON - && font.latex() != LyXFont::ON) { - pain.line(int(tmpx), - offset + row_ptr->baseline + 2, - int(x - tmpx), - offset + row_ptr->baseline + 2); - } - } -#endif - ++vpos; - } else - draw(row_ptr, vpos, offset, x); - } - - /* do not forget the very last cell. This has no NEWLINE so - * ignored by the code above*/ - if (cell == row_ptr->par->table->GetNumberOfCells()-1){ - x = x_old + row_ptr->par->table->WidthOfColumn(cell); - on_off = !row_ptr->par->table->TopLine(cell); - if ((!on_off || - !row_ptr->par->table->TopAlreadyDrawed(cell)) && - !row_ptr->par->table->IsContRow(cell)) - - pain.line(int(x_old), - offset + row_ptr->baseline - row_ptr->ascent_of_text, - int(x), - offset + row_ptr->baseline - row_ptr->ascent_of_text, - LColor::tableline, - on_off ? Painter::line_onoffdash : Painter::line_solid); - on_off = !row_ptr->par->table->BottomLine(cell); - if ((!on_off && !row_ptr->par->table->RowHasContRow(cell)) || - row_ptr->par->table->VeryLastRow(cell)) - - pain.line(int(x_old), - offset + y_bottom - 1, - int(x), - offset + y_bottom - 1, - LColor::tableline, - on_off ? Painter::line_onoffdash : Painter::line_solid); - - on_off = !row_ptr->par->table->LeftLine(cell); - - pain.line(int(x_old), - offset + row_ptr->baseline - row_ptr->ascent_of_text, - int(x_old), - offset + y_bottom - 1, - LColor::tableline, - on_off ? Painter::line_onoffdash : Painter::line_solid); - - on_off = !row_ptr->par->table->RightLine(cell); - - pain.line(int(x) - row_ptr->par->table->AdditionalWidth(cell), - offset + row_ptr->baseline - row_ptr->ascent_of_text, - int(x) - row_ptr->par->table->AdditionalWidth(cell), - offset + y_bottom - 1, - LColor::tableline, - on_off ? Painter::line_onoffdash : Painter::line_solid); + vpos = row_ptr->pos(); + + LyXParagraph::size_type main_body = + BeginningOfMainBody(bview->buffer(), row_ptr->par()); + if (main_body > 0 && + (main_body-1 > last || + !row_ptr->par()->IsLineSeparator(main_body - 1))) + main_body = 0; + + while (vpos <= last) { + pos = vis2log(vpos); + if (main_body > 0 && pos == main_body - 1) { + x += fill_label_hfill + + lyxfont::width(layout.labelsep, + GetFont(bview->buffer(), + row_ptr->par(), -2)) + - SingleWidth(bview, + row_ptr->par(), + main_body - 1); } - } else { - /* table stuff -- end*/ - LyXParagraph::size_type main_body = - BeginningOfMainBody(row_ptr->par); - if (main_body > 0 && - (main_body-1 > last || - !row_ptr->par->IsLineSeparator(main_body-1))) - main_body = 0; - while (vpos <= last) { - pos = vis2log(vpos); - if (main_body > 0 && pos == main_body-1) { - x += fill_label_hfill - + lyxfont::width(layout.labelsep, GetFont(row_ptr->par, -2)) - - SingleWidth(row_ptr->par, main_body-1); - } + if (row_ptr->par() ->IsHfill(pos)) { + x += 1; + pain.line(int(x), + y_offset + row_ptr->baseline() - DefaultHeight() / 2, + int(x), + y_offset + row_ptr->baseline(), + LColor::vfillline); - if (row_ptr->par->IsHfill(pos)) { - x += 1; - pain.line(int(x), - offset + row_ptr->baseline - DefaultHeight() / 2, - int(x), - offset + row_ptr->baseline, - LColor::vfillline); - - if (HfillExpansion(row_ptr, pos)) { - if (pos >= main_body) { - pain.line(int(x), - offset + row_ptr->baseline - DefaultHeight() / 4, - int(x + fill_hfill), - offset + row_ptr->baseline - DefaultHeight() / 4, - LColor::vfillline, - Painter::line_onoffdash); - x += fill_hfill; - } else { - pain.line(int(x), - offset + row_ptr->baseline - DefaultHeight() / 4, - int(x + fill_label_hfill), - offset + row_ptr->baseline - DefaultHeight() / 4, - LColor::vfillline, - Painter::line_onoffdash); - - x += fill_label_hfill; - } + if (HfillExpansion(bview->buffer(), + row_ptr, pos)) { + if (pos >= main_body) { pain.line(int(x), - offset + row_ptr->baseline - DefaultHeight() / 2, - int(x), - offset + row_ptr->baseline, - LColor::vfillline); - } - x += 2; - ++vpos; - } else if (row_ptr->par->IsSeparator(pos)) { -#if 0 - tmpx = x; -#endif - x += SingleWidth(row_ptr->par, pos); - if (pos >= main_body) - x += fill_separator; -#warning Think about this -#if 0 - /* -------> Only draw protected spaces when - * not in free-spacing mode. */ - if (row_ptr->par->GetChar(pos) == LyXParagraph::META_PROTECTED_SEPARATOR && !layout.free_spacing) { - - pain.line(int(tmpx), - offset + row_ptr->baseline - 3, - int(tmpx), - offset + row_ptr->baseline - 1, - LColor::vfillline); - - pain.line(int(tmpx), - offset + row_ptr->baseline - 1, - int(x - 2), - offset + row_ptr->baseline - 1, - LColor::vfillline); - - pain.line(int(x - 2), - offset + row_ptr->baseline - 3, - int(x - 2), - offset + row_ptr->baseline - 1, - LColor::vfillline); + y_offset + row_ptr->baseline() - DefaultHeight() / 4, + int(x + fill_hfill), + y_offset + row_ptr->baseline() - DefaultHeight() / 4, + LColor::vfillline, + Painter::line_onoffdash); + x += fill_hfill; + } else { + pain.line(int(x), + y_offset + row_ptr->baseline() - DefaultHeight() / 4, + int(x + fill_label_hfill), + y_offset + row_ptr->baseline() - DefaultHeight() / 4, + LColor::vfillline, + Painter::line_onoffdash); - /* what about underbars? */ - font = GetFont(row_ptr->par, pos); - if (font.underbar() == LyXFont::ON - && font.latex() != LyXFont::ON) { - pain.line(int(tmpx), - offset + row_ptr->baseline + 2, - int(x - tmpx), - offset + row_ptr->baseline + 2); - } + x += fill_label_hfill; } -#endif - ++vpos; - } else - draw(row_ptr, vpos, offset, x); - } + pain.line(int(x), + y_offset + row_ptr->baseline() - DefaultHeight() / 2, + int(x), + y_offset + row_ptr->baseline(), + LColor::vfillline); + } + x += 2; + ++vpos; + } else if (row_ptr->par()->IsSeparator(pos)) { + x += SingleWidth(bview, + row_ptr->par(), pos); + if (pos >= main_body) + x += fill_separator; + ++vpos; + } else + draw(bview, row_ptr, vpos, y_offset, x, clear_area); } } @@ -4499,144 +4128,133 @@ int LyXText::DefaultHeight() const /* returns the column near the specified x-coordinate of the row * x is set to the real beginning of this column */ -int LyXText::GetColumnNearX(Row * row, int & x) const +int LyXText::GetColumnNearX(BufferView * bview, Row * row, int & x, + bool & boundary) const { float tmpx = 0.0; float fill_separator, fill_hfill, fill_label_hfill; - PrepareToPrint(row, tmpx, fill_separator, + PrepareToPrint(bview, row, tmpx, fill_separator, fill_hfill, fill_label_hfill); - LyXParagraph::size_type vc = row->pos; + LyXParagraph::size_type vc = row->pos(); LyXParagraph::size_type last = RowLastPrintable(row); LyXParagraph::size_type c = 0; - LyXLayout const & layout = textclasslist.Style(bparams->textclass, - row->par->GetLayout()); - /* table stuff -- begin */ - if (row->par->table) { - //the last row doesn't need a newline at the end - if (row->next && row->next->par == row->par - && row->par->IsNewline(last)) - last--; - int cell = NumberOfCell(row->par, row->pos); - float x_old = tmpx; - bool ready = false; - tmpx += row->par->table->GetBeginningOfTextInCell(cell); - while (vc <= last - && (c = vis2log(vc)) >= 0 - && tmpx + (SingleWidth(row->par, c)/2) <= x - && !ready){ - if (row->par->IsNewline(c)) { - if (x_old + row->par->table->WidthOfColumn(cell) <= x){ - tmpx = x_old + row->par->table->WidthOfColumn(cell); - x_old = tmpx; - ++cell; - tmpx += row->par->table->GetBeginningOfTextInCell(cell); - ++vc; - } else - ready = true; - } else { - tmpx += SingleWidth(row->par, c); - ++vc; - } - } - } else { - /* table stuff -- end*/ - LyXParagraph::size_type main_body = BeginningOfMainBody(row->par); - float last_tmpx = tmpx; + LyXLayout const & layout = + textclasslist.Style(bview->buffer()->params.textclass, + row->par()->GetLayout()); + bool left_side = false; - if (main_body > 0 && - (main_body-1 > last || - !row->par->IsLineSeparator(main_body-1))) - main_body = 0; - - while (vc <= last && tmpx <= x) { - c = vis2log(vc); - last_tmpx = tmpx; - if (main_body > 0 && c == main_body-1) { - tmpx += fill_label_hfill + - lyxfont::width(layout.labelsep, - GetFont(row->par, -2)); - if (row->par->IsLineSeparator(main_body-1)) - tmpx -= SingleWidth(row->par, main_body-1); - } - - if (HfillExpansion(row, c)) { - x += SingleWidth(row->par, c); - if (c >= main_body) - tmpx += fill_hfill; - else - tmpx += fill_label_hfill; - } - else if (row->par->IsSeparator(c)) { - tmpx += SingleWidth(row->par, c); - if (c >= main_body) - tmpx+= fill_separator; - } else - tmpx += SingleWidth(row->par, c); - ++vc; + LyXParagraph::size_type + main_body = BeginningOfMainBody(bview->buffer(), row->par()); + float last_tmpx = tmpx; + + if (main_body > 0 && + (main_body-1 > last || + !row->par()->IsLineSeparator(main_body - 1))) + main_body = 0; + + while (vc <= last && tmpx <= x) { + c = vis2log(vc); + last_tmpx = tmpx; + if (main_body > 0 && c == main_body-1) { + tmpx += fill_label_hfill + + lyxfont::width(layout.labelsep, + GetFont(bview->buffer(), row->par(), -2)); + if (row->par()->IsLineSeparator(main_body - 1)) + tmpx -= SingleWidth(bview, row->par(), main_body-1); } - - if (vc > row->pos && (tmpx+last_tmpx)/2 > x) { - vc--; - tmpx = last_tmpx; + + if (HfillExpansion(bview->buffer(), row, c)) { + x += SingleWidth(bview, row->par(), c); + if (c >= main_body) + tmpx += fill_hfill; + else + tmpx += fill_label_hfill; } + else if (row->par()->IsSeparator(c)) { + tmpx += SingleWidth(bview, row->par(), c); + if (c >= main_body) + tmpx+= fill_separator; + } else + tmpx += SingleWidth(bview, row->par(), c); + ++vc; + } + + if ((tmpx + last_tmpx) / 2 > x) { + tmpx = last_tmpx; + left_side = true; } if (vc > last + 1) // This shouldn't happen. - vc = last+1; - - if (row->pos > last) // Row is empty? - c = row->pos; - else if (vc > last || - (vc - 1 >= row->pos && - ( (row->par->IsSeparator(vis2log(vc)) && vis2log(vc) != last) - || (row->par->table && row->par->IsNewline(vc) ) - ))) { - c = vis2log(vc - 1); - if (bidi_level(c) % 2 == 0) - ++c; - } else { + vc = last + 1; + + boundary = false; + bool const lastrow = lyxrc.rtl_support // This is not needed, but gives + // some speedup if rtl_support=false + && (!row->next() || row->next()->par() != row->par()); + bool const rtl = (lastrow) + ? row->par()->isRightToLeftPar(bview->buffer()->params) + : false; // If lastrow is false, we don't need to compute + // the value of rtl. + + if (row->pos() > last) // Row is empty? + c = row->pos(); + else if (lastrow && + ( ( rtl && left_side && vc == row->pos() && x < tmpx - 5) || + (!rtl && !left_side && vc == last + 1 && x > tmpx + 5) )) + c = last + 1; + else if (vc == row->pos()) { c = vis2log(vc); if (bidi_level(c) % 2 == 1) ++c; + } else { + c = vis2log(vc - 1); + bool const rtl = (bidi_level(c) % 2 == 1); + if (left_side == rtl) { + ++c; + boundary = IsBoundary(bview->buffer(), row->par(), c); + } } - if (!row->par->table && row->pos <= last && c > last - && row->par->IsNewline(last)) { + if (row->pos() <= last && c > last + && row->par()->IsNewline(last)) { if (bidi_level(last) % 2 == 0) - tmpx -= SingleWidth(row->par, last); + tmpx -= SingleWidth(bview, row->par(), last); else - tmpx += SingleWidth(row->par, last); + tmpx += SingleWidth(bview, row->par(), last); c = last; } - c -= row->pos; + c -= row->pos(); x = int(tmpx); return c; } - + +#ifndef NEW_INSETS /* turn the selection into a new environment. If there is no selection, * create an empty environment */ -void LyXText::InsertFootnoteEnvironment(LyXParagraph::footnote_kind kind) +void LyXText::InsertFootnoteEnvironment(BufferView * bview, + LyXParagraph::footnote_kind kind) { /* no footnoteenvironment in a footnoteenvironment */ - if (cursor.par->footnoteflag != LyXParagraph::NO_FOOTNOTE) { + if (cursor.par()->footnoteflag != LyXParagraph::NO_FOOTNOTE) { WriteAlert(_("Impossible operation"), _("You can't insert a float in a float!"), _("Sorry.")); return; } +#ifndef NO_PEXTRA /* no marginpars in minipages */ if (kind == LyXParagraph::MARGIN - && cursor.par->pextra_type == LyXParagraph::PEXTRA_MINIPAGE) { + && cursor.par()->params.pextraType() == LyXParagraph::PEXTRA_MINIPAGE) { WriteAlert(_("Impossible operation"), _("You can't insert a marginpar in a minipage!"), _("Sorry.")); return; } - +#endif /* this doesnt make sense, if there is no selection */ bool dummy_selection = false; if (!selection) { @@ -4645,23 +4263,18 @@ void LyXText::InsertFootnoteEnvironment(LyXParagraph::footnote_kind kind) dummy_selection = true; } - LyXParagraph *tmppar; + LyXParagraph * tmppar; - if (sel_start_cursor.par->table || sel_end_cursor.par->table){ - WriteAlert(_("Impossible operation"), _("Cannot cut table."), _("Sorry.")); - return; - } - /* a test to make sure there is not already a footnote * in the selection. */ - tmppar = sel_start_cursor.par->ParFromPos(sel_start_cursor.pos); + tmppar = sel_start_cursor.par()->ParFromPos(sel_start_cursor.pos()); - while (tmppar != sel_end_cursor.par->ParFromPos(sel_end_cursor.pos) && + while (tmppar != sel_end_cursor.par()->ParFromPos(sel_end_cursor.pos()) && tmppar->footnoteflag == LyXParagraph::NO_FOOTNOTE) - tmppar = tmppar->next; + tmppar = tmppar->next_; - if (tmppar != sel_end_cursor.par->ParFromPos(sel_end_cursor.pos) + if (tmppar != sel_end_cursor.par()->ParFromPos(sel_end_cursor.pos()) || tmppar->footnoteflag != LyXParagraph::NO_FOOTNOTE) { WriteAlert(_("Impossible operation"), _("Float would include float!"), @@ -4672,45 +4285,46 @@ void LyXText::InsertFootnoteEnvironment(LyXParagraph::footnote_kind kind) /* ok we have a selection. This is always between sel_start_cursor * and sel_end cursor */ - SetUndo(Undo::FINISH, - sel_start_cursor.par->ParFromPos(sel_start_cursor.pos)->previous, - sel_end_cursor.par->ParFromPos(sel_end_cursor.pos)->next); + SetUndo(bview->buffer(), Undo::FINISH, + sel_start_cursor.par()->ParFromPos(sel_start_cursor.pos())->previous_, + sel_end_cursor.par()->ParFromPos(sel_end_cursor.pos())->next_); - if (sel_end_cursor.pos > 0 - && sel_end_cursor.par->IsLineSeparator(sel_end_cursor.pos - 1)) - sel_end_cursor.pos--; /* please break before a space at - * the end */ - if (sel_start_cursor.par == sel_end_cursor.par - && sel_start_cursor.pos > sel_end_cursor.pos) - sel_start_cursor.pos--; - - sel_end_cursor.par->BreakParagraphConservative(sel_end_cursor.pos); + if (sel_end_cursor.pos() > 0 + && sel_end_cursor.par()->IsLineSeparator(sel_end_cursor.pos() - 1)) + sel_end_cursor.pos(sel_end_cursor.pos() - 1); + /* please break before a space at the end */ + if (sel_start_cursor.par() == sel_end_cursor.par() + && sel_start_cursor.pos() > sel_end_cursor.pos()) + sel_start_cursor.pos(sel_start_cursor.pos() - 1); + + sel_end_cursor.par()->BreakParagraphConservative(bview->buffer()->params, sel_end_cursor.pos()); - sel_end_cursor.par = sel_end_cursor.par->Next(); - sel_end_cursor.pos = 0; + sel_end_cursor.par(sel_end_cursor.par()->next()); + sel_end_cursor.pos(0); // don't forget to insert a dummy layout paragraph if necessary - if (sel_start_cursor.par->GetLayout() != sel_end_cursor.par->layout){ - sel_end_cursor.par->BreakParagraphConservative(0); - sel_end_cursor.par->layout = LYX_DUMMY_LAYOUT; - sel_end_cursor.par = sel_end_cursor.par->next; + if (sel_start_cursor.par()->GetLayout() != sel_end_cursor.par()->layout){ + sel_end_cursor.par()->BreakParagraphConservative(bview->buffer()->params, 0); + sel_end_cursor.par()->layout = LYX_DUMMY_LAYOUT; + sel_end_cursor.par(sel_end_cursor.par()->next_); } else - sel_end_cursor.par->layout = LYX_DUMMY_LAYOUT; + sel_end_cursor.par()->layout = LYX_DUMMY_LAYOUT; cursor = sel_end_cursor; /* please break behind a space, if there is one. The space should * be erased too */ - if (sel_start_cursor.pos > 0 - && sel_start_cursor.par->IsLineSeparator(sel_start_cursor.pos - 1)) - sel_start_cursor.pos--; - if (sel_start_cursor.par->IsLineSeparator(sel_start_cursor.pos)) { - sel_start_cursor.par->Erase(sel_start_cursor.pos); + if (sel_start_cursor.pos() > 0 + && sel_start_cursor.par()->IsLineSeparator(sel_start_cursor.pos() - 1)) + sel_start_cursor.pos(sel_start_cursor.pos() - 1); + if (sel_start_cursor.par()->IsLineSeparator(sel_start_cursor.pos())) { + sel_start_cursor.par()->Erase(sel_start_cursor.pos()); } - sel_start_cursor.par->BreakParagraphConservative(sel_start_cursor.pos); - tmppar = sel_start_cursor.par->Next(); + sel_start_cursor.par()->BreakParagraphConservative(bview->buffer()->params, + sel_start_cursor.pos()); + tmppar = sel_start_cursor.par()->next(); if (dummy_selection) { tmppar->Clear(); @@ -4720,7 +4334,7 @@ void LyXText::InsertFootnoteEnvironment(LyXParagraph::footnote_kind kind) || kind == LyXParagraph::WIDE_FIG || kind == LyXParagraph::ALGORITHM) { pair lres = - textclasslist.NumberOfLayout(bparams->textclass, + textclasslist.NumberOfLayout(bview->buffer()->params.textclass, "Caption"); LyXTextClass::size_type lay; if (lres.first) { @@ -4730,107 +4344,59 @@ void LyXText::InsertFootnoteEnvironment(LyXParagraph::footnote_kind kind) // layout not found lay = 0; // use default layout "Standard" (0) } - tmppar->SetLayout(lay); + tmppar->SetLayout(bview->buffer()->params, lay); } - } - else { - if (sel_start_cursor.pos > 0) { + } else { + if (sel_start_cursor.pos() > 0) { /* the footnote-environment should begin with a standard layout. * Imagine you insert a footnote within an enumeration, you * certainly do not want an enumerated footnote! */ tmppar->Clear(); - } - else { + } else { /* this is a exception the user would sometimes expect, I hope */ - sel_start_cursor.par->Clear(); + sel_start_cursor.par()->Clear(); } } - while (tmppar != sel_end_cursor.par) { + while (tmppar != sel_end_cursor.par()) { tmppar->footnoteflag = LyXParagraph::OPEN_FOOTNOTE; tmppar->footnotekind = kind; - tmppar = tmppar->Next(); - } + tmppar = tmppar->next(); + } - RedoParagraphs(sel_start_cursor, sel_end_cursor.par->Next()); + RedoParagraphs(bview, sel_start_cursor, sel_end_cursor.par()->next()); - SetCursor(sel_start_cursor.par->Next(), 0); + SetCursor(bview, sel_start_cursor.par()->next(), 0); - ClearSelection(); + ClearSelection(bview); } - +#endif + // returns pointer to a specified row Row * LyXText::GetRow(LyXParagraph * par, - LyXParagraph::size_type pos, long & y) const + LyXParagraph::size_type pos, int & y) const { - Row * tmprow; - - if (currentrow) { - if (par == currentrow->par - || par == currentrow->par->Previous()) { - // do not dereference par, it may have been deleted - // already! (Matthias) - - // Walk backwards as long as the previous - // rows par is not par - while (currentrow->previous - && currentrow->previous->par != par) { - currentrow = currentrow->previous; - currentrow_y -= currentrow->height; - } - // Walk backwards as long as the previous - // rows par _is_ par - while (currentrow->previous - && currentrow->previous->par == par) { - currentrow = currentrow->previous; - currentrow_y -= currentrow->height; - } - } - - tmprow = currentrow; - y = currentrow_y; - // find the first row of the specified paragraph - while (tmprow->next - && tmprow->par != par) { - y += tmprow->height; - tmprow = tmprow->next; - } - - if (tmprow->par == par){ - // now find the wanted row - while (tmprow->pos < pos - && tmprow->next - && tmprow->next->par == par - && tmprow->next->pos <= pos) { - y += tmprow->height; - tmprow = tmprow->next; - } - currentrow = tmprow; - currentrow_y = y; - return tmprow; - } - } - - tmprow = firstrow; + if (!firstrow) + return 0; + + Row * tmprow = firstrow; y = 0; + // find the first row of the specified paragraph - while (tmprow->next && tmprow->par != par) { - y += tmprow->height; - tmprow = tmprow->next; + while (tmprow->next() && tmprow->par() != par) { + y += tmprow->height(); + tmprow = tmprow->next(); } // now find the wanted row - while (tmprow->pos < pos - && tmprow->next - && tmprow->next->par == par - && tmprow->next->pos <= pos) { - y += tmprow->height; - tmprow = tmprow->next; + while (tmprow->pos() < pos + && tmprow->next() + && tmprow->next()->par() == par + && tmprow->next()->pos() <= pos) { + y += tmprow->height(); + tmprow = tmprow->next(); } - currentrow = tmprow; - currentrow_y = y; - return tmprow; }