X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Ftext.C;h=f96bd6408944550d04dc6a6f847e7cc5eb916754;hb=b2f4586c984226bcc945d93891f3d0736d6ffb43;hp=211f2f315cc336c0bcc043800d5a0b82fe8c2b62;hpb=a622bb6efa81e5eb894ab92dd8424852d1c2a4a8;p=lyx.git diff --git a/src/text.C b/src/text.C index 211f2f315c..f96bd64089 100644 --- a/src/text.C +++ b/src/text.C @@ -9,20 +9,11 @@ * ====================================================== */ #include -#include -#include -#include #include "lyxtext.h" -#include "layout.h" +#include "lyxrow.h" +#include "lyxtextclasslist.h" #include "paragraph.h" -#include "support/textutils.h" -#include "support/LAssert.h" -#include "support/lstrings.h" -#include "insets/insetbib.h" -#include "insets/insettext.h" -#include "insets/insetspecialchar.h" -#include "lyx_gui_misc.h" #include "gettext.h" #include "bufferparams.h" #include "buffer.h" @@ -41,10 +32,20 @@ #include "undo_funcs.h" #include "font.h" +#include "insets/insetbib.h" +#include "insets/insettext.h" + +#include "support/textutils.h" +#include "support/LAssert.h" +#include "support/lstrings.h" + +#include + using std::max; using std::min; using std::endl; using std::pair; +using lyx::pos_type; namespace { @@ -64,6 +65,63 @@ int LyXText::workWidth(BufferView * bview) const } +int LyXText::workWidth(BufferView * bview, Inset * inset) const +{ + Paragraph * par = 0; + pos_type pos = -1; + + par = inset->parOwner(); + if (par) + pos = par->getPositionOfInset(inset); + + if (!par || pos == -1) { + lyxerr << "LyXText::workWidth: something is wrong," + " fall back to the brute force method" << endl; + Buffer::inset_iterator it = bview->buffer()->inset_iterator_begin(); + Buffer::inset_iterator end = bview->buffer()->inset_iterator_end(); + for (; it != end; ++it) { + if (*it == inset) { + par = it.getPar(); + pos = it.getPos(); + break; + } + } + } + + if (!par) { + return workWidth(bview); + } + + LyXLayout const & layout = + textclasslist[bview->buffer()->params.textclass][par->layout()]; + + if (layout.margintype != MARGIN_RIGHT_ADDRESS_BOX) { + // Optimization here: in most cases, the real row is + // not needed, but only the par/pos values. So we just + // construct a dummy row for leftMargin. (JMarc) + Row dummyrow; + dummyrow.par(par); + dummyrow.pos(pos); + return workWidth(bview) - leftMargin(bview, &dummyrow); + } else { + int dummy_y; + Row * row = getRow(par, pos, dummy_y); + Row * frow = row; + while (frow->previous() && frow->par() == frow->previous()->par()) + frow = frow->previous(); + unsigned int maxw = 0; + while (frow->next() && frow->par() == frow->next()->par()) { + if ((frow != row) && (maxw < frow->width())) + maxw = frow->width(); + frow = frow->next(); + } + if (maxw) + return maxw; + } + return workWidth(bview); +} + + int LyXText::getRealCursorX(BufferView * bview) const { int x = cursor.x(); @@ -74,10 +132,10 @@ int LyXText::getRealCursorX(BufferView * bview) const unsigned char LyXText::transformChar(unsigned char c, Paragraph * par, - Paragraph::size_type pos) const + pos_type pos) const { if (!Encodings::is_arabic(c)) - if (lyxrc.font_norm_type == LyXRC::ISO_8859_6_8 && isdigit(c)) + if (lyxrc.font_norm_type == LyXRC::ISO_8859_6_8 && IsDigit(c)) return c + (0xb0 - '0'); else return c; @@ -85,7 +143,7 @@ unsigned char LyXText::transformChar(unsigned char c, Paragraph * par, unsigned char const prev_char = pos > 0 ? par->getChar(pos-1) : ' '; unsigned char next_char = ' '; - for (Paragraph::size_type i = pos+1; i < par->size(); ++i) + for (pos_type i = pos+1; i < par->size(); ++i) if (!Encodings::IsComposeChar_arabic(par->getChar(i))) { next_char = par->getChar(i); break; @@ -130,7 +188,7 @@ unsigned char LyXText::transformChar(unsigned char c, Paragraph * par, // Lgb int LyXText::singleWidth(BufferView * bview, Paragraph * par, - Paragraph::size_type pos) const + pos_type pos) const { char const c = par->getChar(pos); return singleWidth(bview, par, pos, c); @@ -138,7 +196,7 @@ int LyXText::singleWidth(BufferView * bview, Paragraph * par, int LyXText::singleWidth(BufferView * bview, Paragraph * par, - Paragraph::size_type pos, char c) const + pos_type pos, char c) const { LyXFont const font = getFont(bview->buffer(), par, pos); @@ -164,7 +222,10 @@ int LyXText::singleWidth(BufferView * bview, Paragraph * par, } else if (c == Paragraph::META_INSET) { Inset * tmpinset = par->getInset(pos); if (tmpinset) { -#if 0 // seems not to be needed, but ... +#if 1 + // this IS needed otherwise on initialitation we don't get the fill + // of the row right (ONLY on initialization if we read a file!) + // should be changed! (Jug 20011204) tmpinset->update(bview, font); #endif return tmpinset->width(bview, font); @@ -180,20 +241,19 @@ int LyXText::singleWidth(BufferView * bview, Paragraph * par, // Returns the paragraph position of the last character in the specified row -Paragraph::size_type LyXText::rowLast(Row const * row) const +pos_type LyXText::rowLast(Row const * row) const { - if (row->next() == 0) + if (!row->next() || row->next()->par() != row->par()) { return row->par()->size() - 1; - else if (row->next()->par() != row->par()) - return row->par()->size() - 1; - else + } else { return row->next()->pos() - 1; + } } -Paragraph::size_type LyXText::rowLastPrintable(Row const * row) const +pos_type LyXText::rowLastPrintable(Row const * row) const { - Paragraph::size_type const last = rowLast(row); + pos_type const last = rowLast(row); if (last >= row->pos() && row->next() && row->next()->par() == row->par() @@ -221,8 +281,8 @@ void LyXText::computeBidiTables(Buffer const * buf, Row * row) const } if (bidi_end + 2 - bidi_start > - static_cast(log2vis_list.size())) { - Paragraph::size_type new_size = + static_cast(log2vis_list.size())) { + pos_type new_size = (bidi_end + 2 - bidi_start < 500) ? 500 : 2 * (bidi_end + 2 - bidi_start); log2vis_list.resize(new_size); @@ -233,19 +293,18 @@ void LyXText::computeBidiTables(Buffer const * buf, Row * row) const vis2log_list[bidi_end + 1 - bidi_start] = -1; log2vis_list[bidi_end + 1 - bidi_start] = -1; - Paragraph::size_type stack[2]; + pos_type stack[2]; bool const rtl_par = row->par()->getParLanguage(buf->params)->RightToLeft(); int level = 0; bool rtl = false; bool rtl0 = false; - Paragraph::size_type const main_body = - beginningOfMainBody(buf, row->par()); + pos_type const main_body = beginningOfMainBody(buf, row->par()); - for (Paragraph::size_type lpos = bidi_start; + for (pos_type lpos = bidi_start; lpos <= bidi_end; ++lpos) { bool is_space = row->par()->isLineSeparator(lpos); - Paragraph::size_type const pos = + pos_type const pos = (is_space && lpos + 1 <= bidi_end && !row->par()->isLineSeparator(lpos + 1) && !row->par()->isNewline(lpos + 1)) @@ -253,7 +312,7 @@ void LyXText::computeBidiTables(Buffer const * buf, Row * row) const 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() + row->par()->getFontSettings(buf->params, lpos - 1).number() == LyXFont::ON) { font = row->par()->getFontSettings(buf->params, lpos); is_space = false; @@ -296,8 +355,7 @@ void LyXText::computeBidiTables(Buffer const * buf, Row * row) const bidi_levels[lpos - bidi_start] = new_level; while (level > new_level2) { - Paragraph::size_type old_lpos = - stack[--level]; + pos_type old_lpos = stack[--level]; int delta = lpos - old_lpos - 1; if (level % 2) delta = -delta; @@ -309,15 +367,15 @@ void LyXText::computeBidiTables(Buffer const * buf, Row * row) const } while (level > 0) { - Paragraph::size_type const old_lpos = stack[--level]; + pos_type const old_lpos = stack[--level]; int delta = bidi_end - old_lpos; if (level % 2) delta = -delta; log2vis_list[old_lpos - bidi_start] += delta; } - Paragraph::size_type vpos = bidi_start - 1; - for (Paragraph::size_type lpos = bidi_start; + pos_type vpos = bidi_start - 1; + for (pos_type lpos = bidi_start; lpos <= bidi_end; ++lpos) { vpos += log2vis_list[lpos - bidi_start]; vis2log_list[vpos - bidi_start] = lpos; @@ -328,7 +386,7 @@ void LyXText::computeBidiTables(Buffer const * buf, Row * row) const // This method requires a previous call to ComputeBidiTables() bool LyXText::isBoundary(Buffer const * buf, Paragraph * par, - Paragraph::size_type pos) const + pos_type pos) const { if (!lyxrc.rtl_support || pos == 0) return false; @@ -348,8 +406,7 @@ bool LyXText::isBoundary(Buffer const * buf, Paragraph * par, bool LyXText::isBoundary(Buffer const * buf, Paragraph * par, - Paragraph::size_type pos, - LyXFont const & font) const + pos_type pos, LyXFont const & font) const { if (!lyxrc.rtl_support) return false; // This is just for speedup @@ -361,226 +418,258 @@ bool LyXText::isBoundary(Buffer const * buf, Paragraph * par, return rtl != rtl2; } +void LyXText::drawNewline(DrawRowParams & p, pos_type const pos) +{ + // Draw end-of-line marker + LyXFont const font = getFont(p.bv->buffer(), p.row->par(), pos); + int const wid = lyxfont::width('n', font); + int const asc = lyxfont::maxAscent(font); + int const y = p.yo + p.row->baseline(); + int xp[3]; + int yp[3]; + + yp[0] = int(y - 0.875 * asc * 0.75); + yp[1] = int(y - 0.500 * asc * 0.75); + yp[2] = int(y - 0.125 * asc * 0.75); + + if (bidi_level(pos) % 2 == 0) { + xp[0] = int(p.x + wid * 0.375); + xp[1] = int(p.x); + xp[2] = int(p.x + wid * 0.375); + } else { + xp[0] = int(p.x + wid * 0.625); + xp[1] = int(p.x + wid); + xp[2] = int(p.x + wid * 0.625); + } + + p.pain->lines(xp, yp, 3, LColor::eolmarker); + + yp[0] = int(y - 0.500 * asc * 0.75); + yp[1] = int(y - 0.500 * asc * 0.75); + yp[2] = int(y - asc * 0.75); + + if (bidi_level(pos) % 2 == 0) { + xp[0] = int(p.x); + xp[1] = int(p.x + wid); + xp[2] = int(p.x + wid); + } else { + xp[0] = int(p.x + wid); + xp[1] = int(p.x); + xp[2] = int(p.x); + } + + p.pain->lines(xp, yp, 3, LColor::eolmarker); -void LyXText::draw(BufferView * bview, Row const * row, - Paragraph::size_type & vpos, - int offset, float & x, bool cleared) + p.x += wid; +} + + +void LyXText::drawInset(DrawRowParams & p, pos_type const pos) { - Painter & pain = bview->painter(); - - Paragraph::size_type pos = vis2log(vpos); - char c = row->par()->getChar(pos); - float tmpx = x; + Inset * inset = p.row->par()->getInset(pos); - if (IsNewlineChar(c)) { - ++vpos; - // Draw end-of-line marker - 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); - yp[0] = int(y - 0.875 * asc * 0.75); - - xp[1] = int(x); - yp[1] = int(y - 0.500 * asc * 0.75); - - xp[2] = int(x + wid * 0.375); - yp[2] = int(y - 0.125 * asc * 0.75); - - pain.lines(xp, yp, 3, LColor::eolmarker); - - xp[0] = int(x); - yp[0] = int(y - 0.500 * asc * 0.75); - - xp[1] = int(x + wid); - yp[1] = int(y - 0.500 * asc * 0.75); - - xp[2] = int(x + wid); - yp[2] = int(y - asc * 0.75); - - pain.lines(xp, yp, 3, LColor::eolmarker); + // FIXME: shouldn't happen + if (!inset) { + return; + } + + LyXFont const & font = getFont(p.bv->buffer(), p.row->par(), pos); + + inset->update(p.bv, font, false); + inset->draw(p.bv, font, p.yo + p.row->baseline(), p.x, p.cleared); + + if (!need_break_row && !inset_owner + && p.bv->text->status() == CHANGED_IN_DRAW) { + Row * prev = p.row->previous(); + if (prev && prev->par() == p.row->par()) { + breakAgainOneRow(p.bv, prev); + if (prev->next() != p.row) { + // breakAgainOneRow() has removed p.row + p.row = 0; // see what this breaks + need_break_row = prev; + } else { + need_break_row = p.row; + } } else { - xp[0] = int(x + wid * 0.625); - yp[0] = int(y - 0.875 * asc * 0.75); - - xp[1] = int(x + wid); - yp[1] = int(y - 0.500 * asc * 0.75); - - xp[2] = int(x + wid * 0.625); - yp[2] = int(y - 0.125 * asc * 0.75); - - pain.lines(xp, yp, 3, LColor::eolmarker); - - xp[0] = int(x + wid); - yp[0] = int(y - 0.500 * asc * 0.75); - - xp[1] = int(x); - yp[1] = int(y - 0.500 * asc * 0.75); - - xp[2] = int(x); - yp[2] = int(y - asc * 0.75); - - pain.lines(xp, yp, 3, LColor::eolmarker); + need_break_row = p.row; } - x += wid; - return; + setCursor(p.bv, cursor.par(), cursor.pos()); } +} - LyXFont font = getFont(bview->buffer(), row->par(), pos); - LyXFont font2 = font; - if (c == Paragraph::META_INSET) { - Inset * tmpinset = row->par()->getInset(pos); - if (tmpinset) { - 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(bview, CHANGED_IN_DRAW); +void LyXText::drawForeignMark(DrawRowParams & p, float const orig_x, LyXFont const & orig_font) +{ + if (!lyxrc.mark_foreign_language) + return; + if (orig_font.language() == latex_language) + return; + if (orig_font.language() == p.bv->buffer()->params.language) + return; + + int const y = p.yo + p.row->height() - 1; + p.pain->line(int(orig_x), y, int(p.x), y, LColor::language); +} + + +void LyXText::drawHebrewComposeChar(DrawRowParams & p, pos_type & vpos) +{ + pos_type pos = vis2log(vpos); + + string str; + + // first char + char c = p.row->par()->getChar(pos); + str += c; + ++vpos; + + LyXFont const & font = getFont(p.bv->buffer(), p.row->par(), pos); + int const width = lyxfont::width(c, font); + int dx = 0; + + for (pos_type i = pos-1; i >= 0; --i) { + c = p.row->par()->getChar(i); + if (!Encodings::IsComposeChar_hebrew(c)) { + if (IsPrintableNonspace(c)) { + int const width2 = + singleWidth(p.bv, p.row->par(), i, c); + // dalet / resh + dx = (c == 'ø' || c == 'ã') + ? width2 - width + : (width2 - width) / 2; } -#endif + break; } - ++vpos; + } + + // Draw nikud + p.pain->text(int(p.x) + dx, p.yo + p.row->baseline(), str, font); +} - if (lyxrc.mark_foreign_language && - font.language() != ignore_language && - font.language() != bview->buffer()->params.language) { - int const y = offset + row->height() - 1; - pain.line(int(tmpx), y, int(x), y, LColor::language); + +void LyXText::drawArabicComposeChar(DrawRowParams & p, pos_type & vpos) +{ + pos_type pos = vis2log(vpos); + string str; + + // first char + char c = p.row->par()->getChar(pos); + c = transformChar(c, p.row->par(), pos); + str +=c; + ++vpos; + + LyXFont const & font = getFont(p.bv->buffer(), p.row->par(), pos); + int const width = lyxfont::width(c, font); + int dx = 0; + + for (pos_type i = pos-1; i >= 0; --i) { + c = p.row->par()->getChar(i); + if (!Encodings::IsComposeChar_arabic(c)) { + if (IsPrintableNonspace(c)) { + int const width2 = + singleWidth(p.bv, p.row->par(), i, c); + dx = (width2 - width) / 2; + } + break; } + } + // Draw nikud + p.pain->text(int(p.x) + dx, p.yo + p.row->baseline(), str, font); +} + + +void LyXText::drawChars(DrawRowParams & p, pos_type & vpos, + bool hebrew, bool arabic) +{ + pos_type pos = vis2log(vpos); + pos_type const last = rowLastPrintable(p.row); + LyXFont const & orig_font = getFont(p.bv->buffer(), p.row->par(), pos); + + // first character + string str; + str += p.row->par()->getChar(pos); + if (arabic) { + unsigned char c = str[0]; + str[0] = transformChar(c, p.row->par(), pos); + } + ++vpos; - return; + // collect as much similar chars as we can + while (vpos <= last && (pos = vis2log(vpos)) >= 0) { + char c = p.row->par()->getChar(pos); + + if (!IsPrintableNonspace(c)) + break; + + if (arabic && Encodings::IsComposeChar_arabic(c)) + break; + if (hebrew && Encodings::IsComposeChar_hebrew(c)) + break; + + if (orig_font != getFont(p.bv->buffer(), p.row->par(), pos)) + break; + + str += c; + ++vpos; } + + // Draw text and set the new x position + p.pain->text(int(p.x), p.yo + p.row->baseline(), str, orig_font); + p.x += lyxfont::width(str, orig_font); +} - /* usual characters, no insets */ + +void LyXText::draw(DrawRowParams & p, pos_type & vpos) +{ + pos_type const pos = vis2log(vpos); + Paragraph * par = p.row->par(); - // Collect character that we can draw in one command + LyXFont const & orig_font = getFont(p.bv->buffer(), par, pos); - // This is dirty, but fast. Notice that it will never be too small. - // For the record, I'll note that Microsoft Word has a limit - // of 768 here. We have none :-) (Asger) - // Ok. I am the first to admit that the use of std::string will be - // a tiny bit slower than using a POD char array. However, I claim - // that this slowdown is so small that it is close to inperceptive. - // 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... - static string textstring; - textstring = c; - ++vpos; + float const orig_x = p.x; + + char const c = par->getChar(pos); + + if (IsNewlineChar(c)) { + ++vpos; + drawNewline(p, pos); + return; + } else if (IsInsetChar(c)) { + drawInset(p, pos); + ++vpos; + drawForeignMark(p, orig_x, orig_font); + return; + } - Paragraph::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 (Paragraph::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 (Paragraph::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); + // usual characters, no insets + + // special case languages + bool const hebrew = (orig_font.language()->lang() == "hebrew"); + bool const arabic = + orig_font.language()->lang() == "arabic" && + (lyxrc.font_norm_type == LyXRC::ISO_8859_6_8 || + lyxrc.font_norm_type == LyXRC::ISO_10646_1); + + // draw as many chars as we can + if ((!hebrew && !arabic) + || (hebrew && !Encodings::IsComposeChar_hebrew(c)) + || (arabic && !Encodings::IsComposeChar_arabic(c))) { + drawChars(p, vpos, true, false); + } else if (hebrew) { + drawHebrewComposeChar(p, vpos); + } else if (arabic) { + drawArabicComposeChar(p, vpos); } + drawForeignMark(p, orig_x, orig_font); + +#ifdef INHERIT_LANGUAGE #ifdef WITH_WARNINGS if ((font.language() == inherit_language) || (font.language() == ignore_language)) lyxerr << "No this shouldn't happen!\n"; #endif - 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 - // routines should go here. (Asger) - // Why shouldn't LyXFont::drawText handle it internally? +#endif } @@ -590,34 +679,27 @@ void LyXText::draw(BufferView * bview, Row const * row, // exactly the label-width. int LyXText::leftMargin(BufferView * bview, Row const * row) const { - LyXLayout const & layout = - textclasslist.Style(bview->buffer()->params.textclass, - row->par()->getLayout()); + LyXTextClass const & tclass = + textclasslist[bview->buffer()->params.textclass]; + LyXLayout const & layout = tclass[row->par()->layout()]; string parindent = layout.parindent; int x = LYX_PAPER_MARGIN; - x += lyxfont::signedWidth(textclasslist - .TextClass(bview->buffer()->params.textclass) - .leftmargin(), - textclasslist - .TextClass(bview->buffer()->params.textclass) - .defaultfont()); + x += lyxfont::signedWidth(tclass.leftmargin(), tclass.defaultfont()); // 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()->layout() == tclass.defaultLayoutName()) { // find the previous same level paragraph if (row->par()->previous()) { Paragraph * newpar = row->par() ->depthHook(row->par()->getDepth()); if (newpar && - textclasslist.Style(bview->buffer()->params.textclass, - newpar->getLayout()) - .nextnoindent) + tclass[newpar->layout()].nextnoindent) parindent.erase(); } } @@ -629,11 +711,8 @@ int LyXText::leftMargin(BufferView * bview, Row const * row) const // make a corresponding row. Needed to call LeftMargin() - // check wether it is a sufficent paragraph - if (newpar - && textclasslist - .Style(bview->buffer()->params.textclass, - newpar->getLayout()).isEnvironment()) { + // check wether it is a sufficent paragraph + if (newpar && tclass[newpar->layout()].isEnvironment()) { Row dummyrow; dummyrow.par(newpar); dummyrow.pos(newpar->size()); @@ -645,27 +724,21 @@ int LyXText::leftMargin(BufferView * bview, Row const * row) const // LeftMargin() is always called row->par()->params().depth(0); } - - if (newpar && !row->par()->getLayout()) { + + if (newpar && row->par()->layout() == tclass.defaultLayoutName()) { if (newpar->params().noindent()) parindent.erase(); else - parindent = textclasslist - .Style(bview->buffer()->params.textclass, - newpar->getLayout()).parindent; + parindent = tclass[newpar->layout()].parindent; } - } - LyXFont const labelfont = getFont(bview->buffer(), row->par(), -2); + LyXFont const labelfont = getLabelFont(bview->buffer(), row->par()); switch (layout.margintype) { case MARGIN_DYNAMIC: if (!layout.leftmargin.empty()) { x += lyxfont::signedWidth(layout.leftmargin, - textclasslist - .TextClass(bview->buffer()->params. - textclass) - .defaultfont()); + tclass.defaultfont()); } if (!row->par()->getLabelstring().empty()) { x += lyxfont::signedWidth(layout.labelindent, @@ -686,7 +759,7 @@ int LyXText::leftMargin(BufferView * bview, Row const * row) const } break; case MARGIN_STATIC: - x += lyxfont::signedWidth(layout.leftmargin, textclasslist.TextClass(bview->buffer()->params.textclass).defaultfont()) * 4 + x += lyxfont::signedWidth(layout.leftmargin, tclass.defaultfont()) * 4 / (row->par()->getDepth() + 4); break; case MARGIN_FIRST_DYNAMIC: @@ -738,15 +811,13 @@ int LyXText::leftMargin(BufferView * bview, Row const * row) const } x += lyxfont::signedWidth(layout.leftmargin, - textclasslist - .TextClass(bview->buffer()->params.textclass) - .defaultfont()); + tclass.defaultfont()); x += minfill; } break; } - int align; // wrong type + LyXAlignment align; // wrong type if (row->par()->params().align() == LYX_ALIGN_LAYOUT) align = layout.align; @@ -763,39 +834,33 @@ int LyXText::leftMargin(BufferView * bview, Row const * row) const && ! row->par()->isFirstInSequence())) && align == LYX_ALIGN_BLOCK && !row->par()->params().noindent() - && (row->par()->layout || + // in tabulars and ert paragraphs are never indented! + && (!row->par()->inInset() || !row->par()->inInset()->owner() || + (row->par()->inInset()->owner()->lyxCode() != Inset::TABULAR_CODE && + row->par()->inInset()->owner()->lyxCode() != Inset::ERT_CODE)) + && (row->par()->layout() != tclass.defaultLayoutName() || bview->buffer()->params.paragraph_separation == - BufferParams::PARSEP_INDENT)) + BufferParams::PARSEP_INDENT)) { x += lyxfont::signedWidth(parindent, - textclasslist - .TextClass(bview->buffer()->params - .textclass) - .defaultfont()); - else if (layout.labeltype == LABEL_BIBLIO) { + tclass.defaultfont()); + } else if (layout.labeltype == LABEL_BIBLIO) { // ale970405 Right width for bibitems - x += bibitemMaxWidth(bview,textclasslist - .TextClass(bview->buffer()->params - .textclass) - .defaultfont()); + x += bibitemMaxWidth(bview, tclass.defaultfont()); } } + return x; } int LyXText::rightMargin(Buffer const * buf, Row const * row) const { - LyXLayout const & layout = - textclasslist.Style(buf->params.textclass, - row->par()->getLayout()); + LyXTextClass const & tclass = textclasslist[buf->params.textclass]; + LyXLayout const & layout = tclass[row->par()->layout()]; int x = LYX_PAPER_MARGIN - + lyxfont::signedWidth(textclasslist - .TextClass(buf->params.textclass) - .rightmargin(), - textclasslist - .TextClass(buf->params.textclass) - .defaultfont()); + + lyxfont::signedWidth(tclass.rightmargin(), + tclass.defaultfont()); // this is the way, LyX handles the LaTeX-Environments. // I have had this idea very late, so it seems to be a @@ -813,10 +878,7 @@ int LyXText::rightMargin(Buffer const * buf, Row const * row) const // make a corresponding row. Needed to call LeftMargin() // check wether it is a sufficent paragraph - if (newpar - && textclasslist.Style(buf->params.textclass, - newpar->getLayout()) - .isEnvironment()) { + if (newpar && tclass[newpar->layout()].isEnvironment()) { Row dummyrow; dummyrow.par(newpar); dummyrow.pos(0); @@ -831,18 +893,15 @@ int LyXText::rightMargin(Buffer const * buf, Row const * row) const } //lyxerr << "rightmargin: " << layout->rightmargin << endl; - x += lyxfont::signedWidth(layout.rightmargin, textclasslist - .TextClass(buf->params.textclass) - .defaultfont()) * 4 / (row->par()->getDepth() - + 4); + x += lyxfont::signedWidth(layout.rightmargin, tclass.defaultfont()) + * 4 / (row->par()->getDepth() + 4); return x; } int LyXText::labelEnd(BufferView * bview, Row const * row) const { - if (textclasslist.Style(bview->buffer()->params.textclass, - row->par()->getLayout()).margintype + if (textclasslist[bview->buffer()->params.textclass][row->par()->layout()].margintype == MARGIN_MANUAL) { Row tmprow; tmprow = *row; @@ -857,7 +916,7 @@ int LyXText::labelEnd(BufferView * bview, Row const * row) const // get the next breakpoint in a given paragraph -Paragraph::size_type +pos_type LyXText::nextBreakPoint(BufferView * bview, Row const * row, int width) const { Paragraph * par = row->par(); @@ -865,20 +924,19 @@ LyXText::nextBreakPoint(BufferView * bview, Row const * row, int width) const if (width < 0) return par->size(); - Paragraph::size_type const pos = row->pos(); - + pos_type const pos = row->pos(); // position of the last possible breakpoint // -1 isn't a suitable value, but a flag - Paragraph::size_type last_separator = -1; + pos_type last_separator = -1; width -= rightMargin(bview->buffer(), row); - Paragraph::size_type const main_body = + pos_type const main_body = beginningOfMainBody(bview->buffer(), par); LyXLayout const & layout = - textclasslist.Style(bview->buffer()->params.textclass, par->getLayout()); - Paragraph::size_type i = pos; - + textclasslist[bview->buffer()->params.textclass][par->layout()]; + pos_type i = pos; + if (layout.margintype == MARGIN_RIGHT_ADDRESS_BOX) { /* special code for right address boxes, only newlines count */ while (i < par->size()) { @@ -886,15 +944,15 @@ LyXText::nextBreakPoint(BufferView * bview, Row const * row, int width) const last_separator = i; i = par->size() - 1; // this means break //x = width; - } else if (par->getChar(i) == Paragraph::META_INSET && - par->getInset(i) && par->getInset(i)->display()){ + } else if (par->isInset(i) && par->getInset(i) + && par->getInset(i)->display()) { par->getInset(i)->display(false); } ++i; } } else { // Last position is an invariant - Paragraph::size_type const last = + pos_type const last = par->size(); // this is the usual handling int x = leftMargin(bview, row); @@ -902,29 +960,30 @@ LyXText::nextBreakPoint(BufferView * bview, Row const * row, int width) const while (doitonetime || ((x < width) && (i < last))) { doitonetime = false; char const c = par->getChar(i); + Inset * in = 0; + if (c == Paragraph::META_INSET) + in = par->getInset(i); if (IsNewlineChar(c)) { last_separator = i; x = width; // this means break - } else if (c == Paragraph::META_INSET && - par->getInset(i)) { - + } else if (in && !in->isChar()) { // check wether a Display() inset is // valid here. if not, change it to // non-display - if (par->getInset(i)->display() && + if (in->display() && (layout.isCommand() || (layout.labeltype == LABEL_MANUAL - && i < beginningOfMainBody(bview->buffer(), par)))) { + && i < beginningOfMainBody(bview->buffer(), par)))) + { // display istn't allowd - par->getInset(i)->display(false); + in->display(false); x += singleWidth(bview, par, i, c); - } else if (par->getInset(i)->display() || - par->getInset(i)->needFullRow()) { + } else if (in->display() || in->needFullRow()) { // So break the line here if (i == pos) { if (pos < last-1) { last_separator = i; - if (IsLineSeparatorChar(par->getChar(i+1))) + if (par->isLineSeparator(i+1)) ++last_separator; } else last_separator = last; // to avoid extra rows @@ -933,16 +992,26 @@ LyXText::nextBreakPoint(BufferView * bview, Row const * row, int width) const x = width; // this means break } else { x += singleWidth(bview, par, i, c); + // we have to check this separately as we could have a + // lineseparator and then the algorithm below would prefer + // that which IS wrong! We should always break on an inset + // if it's too long and not on the last separator. + // Maybe the only exeption is insets used as chars but + // then we would have to have a special function inside + // the inset to tell us this. Till then we leave it as + // it is now. (Jug 20020106) + if (pos < i && x >= width && last_separator >= 0) + last_separator = i - 1; } } else { - if (IsLineSeparatorChar(c)) + if (par->isLineSeparator(i)) last_separator = i; x += singleWidth(bview, par, i, c); } ++i; if (i == main_body) { x += lyxfont::width(layout.labelsep, - getFont(bview->buffer(), par, -2)); + getLabelFont(bview->buffer(), par)); if (par->isLineSeparator(i - 1)) x-= singleWidth(bview, par, i - 1); int left_margin = labelEnd(bview, row); @@ -950,8 +1019,12 @@ LyXText::nextBreakPoint(BufferView * bview, Row const * row, int width) const x = left_margin; } } + if ((pos+1 < i) && (last_separator < 0) && (x >= width)) + last_separator = i - 2; + else if ((pos < i) && (last_separator < 0) && (x >= width)) + last_separator = i - 1; // end of paragraph is always a suitable separator - if (i == last && x < width) + else if (i == last && x < width) last_separator = i; } @@ -973,16 +1046,16 @@ LyXText::nextBreakPoint(BufferView * bview, Row const * row, int width) const int LyXText::fill(BufferView * bview, Row * row, int paper_width) const { if (paper_width < 0) - return 20; + return 0; int w; // get the pure distance - Paragraph::size_type const last = rowLastPrintable(row); + pos_type const last = rowLastPrintable(row); // special handling of the right address boxes - if (textclasslist.Style(bview->buffer()->params.textclass, - row->par()->getLayout()).margintype - == MARGIN_RIGHT_ADDRESS_BOX) { + if (textclasslist[bview->buffer()->params.textclass][row->par()->layout()].margintype + == MARGIN_RIGHT_ADDRESS_BOX) + { int const tmpfill = row->fill(); row->fill(0); // the minfill in MarginLeft() w = leftMargin(bview, row); @@ -990,15 +1063,14 @@ int LyXText::fill(BufferView * bview, Row * row, int paper_width) const } else w = leftMargin(bview, row); - LyXLayout const & layout = textclasslist.Style(bview->buffer()->params.textclass, - row->par()->getLayout()); - Paragraph::size_type const main_body = + LyXLayout const & layout = textclasslist[bview->buffer()->params.textclass][row->par()->layout()]; + pos_type const main_body = beginningOfMainBody(bview->buffer(), row->par()); - Paragraph::size_type i = row->pos(); + pos_type i = row->pos(); while (i <= last) { if (main_body > 0 && i == main_body) { - w += lyxfont::width(layout.labelsep, getFont(bview->buffer(), row->par(), -2)); + w += lyxfont::width(layout.labelsep, getLabelFont(bview->buffer(), row->par())); if (row->par()->isLineSeparator(i - 1)) w -= singleWidth(bview, row->par(), i - 1); int left_margin = labelEnd(bview, row); @@ -1009,7 +1081,7 @@ int LyXText::fill(BufferView * bview, Row * row, int paper_width) const ++i; } if (main_body > 0 && main_body > last) { - w += lyxfont::width(layout.labelsep, getFont(bview->buffer(), row->par(), -2)); + w += lyxfont::width(layout.labelsep, getLabelFont(bview->buffer(), row->par())); if (last >= 0 && row->par()->isLineSeparator(last)) w -= singleWidth(bview, row->par(), last); int const left_margin = labelEnd(bview, row); @@ -1018,13 +1090,6 @@ int LyXText::fill(BufferView * bview, Row * row, int paper_width) const } int const fill = paper_width - w - rightMargin(bview->buffer(), row); -#ifdef WITH_WARNINGS -#warning Please fix me (Jug!) -#endif -#if 0 - if (fill < 0) - return 0; -#endif return fill; } @@ -1032,7 +1097,7 @@ int LyXText::fill(BufferView * bview, Row * row, int paper_width) const // returns the minimum space a manual label needs on the screen in pixel int LyXText::labelFill(BufferView * bview, Row const * row) const { - Paragraph::size_type last = beginningOfMainBody(bview->buffer(), row->par()) - 1; + pos_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. @@ -1048,7 +1113,7 @@ int LyXText::labelFill(BufferView * bview, Row const * row) const --last; int w = 0; - int i = row->pos(); + pos_type i = row->pos(); while (i <= last) { w += singleWidth(bview, row->par(), i); ++i; @@ -1057,7 +1122,7 @@ int LyXText::labelFill(BufferView * bview, Row const * row) const int fill = 0; if (!row->par()->params().labelWidthString().empty()) { fill = max(lyxfont::width(row->par()->params().labelWidthString(), - getFont(bview->buffer(), row->par(), -2)) - w, + getLabelFont(bview->buffer(), row->par())) - w, 0); } @@ -1069,9 +1134,8 @@ int LyXText::labelFill(BufferView * bview, Row const * row) const // on the very last column doesnt count int LyXText::numberOfSeparators(Buffer const * buf, Row const * row) const { - Paragraph::size_type const last = rowLast(row); - Paragraph::size_type p = - max(row->pos(), beginningOfMainBody(buf, row->par())); + pos_type const last = rowLast(row); + pos_type p = max(row->pos(), beginningOfMainBody(buf, row->par())); int n = 0; for (; p < last; ++p) { if (row->par()->isSeparator(p)) { @@ -1087,17 +1151,21 @@ int LyXText::numberOfSeparators(Buffer const * buf, Row const * row) const // ignored. This is *MUCH* more usefull than not to ignore! int LyXText::numberOfHfills(Buffer const * buf, Row const * row) const { - Paragraph::size_type const last = rowLast(row); - Paragraph::size_type first = row->pos(); + pos_type const last = rowLast(row); + pos_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(buf, row->par())); int n = 0; - for (int p = first; p <= last; ++p) { // last, because the end is ignored! + for (pos_type p = first; p <= last; ++p) { + // last, because the end is ignored! + if (row->par()->isHfill(p)) { ++n; } @@ -1109,18 +1177,18 @@ int LyXText::numberOfHfills(Buffer const * buf, Row const * row) const // like NumberOfHfills, but only those in the manual label! int LyXText::numberOfLabelHfills(Buffer const * buf, Row const * row) const { - Paragraph::size_type last = rowLast(row); - Paragraph::size_type first = row->pos(); + pos_type last = rowLast(row); + pos_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(buf, row->par())); int n = 0; - for (Paragraph::size_type p = first; - p < last; ++p) { // last, because the end is ignored! + for (pos_type p = first; p < last; ++p) { + // last, because the end is ignored! if (row->par()->isHfill(p)) { ++n; } @@ -1132,15 +1200,23 @@ int LyXText::numberOfLabelHfills(Buffer const * buf, Row const * row) const // returns true, if a expansion is needed. // Rules are given by LaTeX bool LyXText::hfillExpansion(Buffer const * buf, Row const * row_ptr, - Paragraph::size_type pos) const + pos_type pos) const { // by the way, is it a hfill? if (!row_ptr->par()->isHfill(pos)) return false; // at the end of a row it does not count - if (pos >= rowLast(row_ptr)) - return false; + // unless another hfill exists on the line + if (pos >= rowLast(row_ptr)) { + pos_type i = row_ptr->pos(); + while (i < pos && !row_ptr->par()->isHfill(i)) { + ++i; + } + if (i == pos) { + return false; + } + } // at the beginning of a row it does not count, if it is not // the first row of a paragaph @@ -1148,8 +1224,7 @@ bool LyXText::hfillExpansion(Buffer const * buf, Row const * row_ptr, return true; // in some labels it does not count - if (textclasslist.Style(buf->params.textclass, - row_ptr->par()->getLayout()).margintype + if (textclasslist[buf->params.textclass][row_ptr->par()->layout()].margintype != MARGIN_MANUAL && pos < beginningOfMainBody(buf, row_ptr->par())) return false; @@ -1157,7 +1232,7 @@ bool LyXText::hfillExpansion(Buffer const * buf, Row const * row_ptr, // 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 - Paragraph::size_type i = row_ptr->pos(); + pos_type i = row_ptr->pos(); while (i < pos && (row_ptr->par()->isNewline(i) || row_ptr->par()->isHfill(i))) ++i; @@ -1176,308 +1251,309 @@ LColor::color LyXText::backgroundColor() void LyXText::setHeightOfRow(BufferView * bview, Row * row_ptr) const { - /* get the maximum ascent and the maximum descent */ - int asc = 0; - int desc = 0; - float layoutasc = 0; - float layoutdesc = 0; - float tmptop = 0; - LyXFont tmpfont; - 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 */ - 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 - * in the paragraph. The hack below is necessary because - * of the possibility of open footnotes */ - - /* Correction: only the fontsize count. The other properties - are taken from the layoutfont. Nicer on the screen :) */ - Paragraph * par = row_ptr->par(); - Paragraph * firstpar = row_ptr->par(); + /* get the maximum ascent and the maximum descent */ + int asc = 0; + int desc = 0; + float layoutasc = 0; + float layoutdesc = 0; + float tmptop = 0; + LyXFont tmpfont; + Inset * tmpinset = 0; + + /* ok , let us initialize the maxasc and maxdesc value. + * This depends in LaTeX of the font of the last character + * in the paragraph. The hack below is necessary because + * of the possibility of open footnotes */ + + /* Correction: only the fontsize count. The other properties + are taken from the layoutfont. Nicer on the screen :) */ + Paragraph * par = row_ptr->par(); + Paragraph * firstpar = row_ptr->par(); - LyXLayout const & layout = textclasslist.Style(bview->buffer()->params.textclass, - firstpar->getLayout()); - - LyXFont font = getFont(bview->buffer(), par, par->size() - 1); - LyXFont::FONT_SIZE const size = font.size(); - font = getFont(bview->buffer(), par, -1); - font.setSize(size); - - LyXFont labelfont = getFont(bview->buffer(), par, -2); - - float spacing_val = 1.0; - if (!row_ptr->par()->params().spacing().isDefault()) { - spacing_val = row_ptr->par()->params().spacing().getValue(); - } else { - spacing_val = bview->buffer()->params.spacing.getValue(); - } - //lyxerr << "spacing_val = " << spacing_val << endl; + LyXLayout const & layout = textclasslist[bview->buffer()->params.textclass][firstpar->layout()]; + + // as max get the first character of this row then it can increes but not + // decrees the height. Just some point to start with so we don't have to + // do the assignment below too often. + LyXFont font = getFont(bview->buffer(), par, row_ptr->pos()); + LyXFont::FONT_SIZE const tmpsize = font.size(); + font = getLayoutFont(bview->buffer(), par); + LyXFont::FONT_SIZE const size = font.size(); + font.setSize(tmpsize); + + LyXFont labelfont = getLabelFont(bview->buffer(), par); + + float spacing_val = 1.0; + if (!row_ptr->par()->params().spacing().isDefault()) { + spacing_val = row_ptr->par()->params().spacing().getValue(); + } else { + spacing_val = bview->buffer()->params.spacing.getValue(); + } + //lyxerr << "spacing_val = " << spacing_val << endl; - int maxasc = int(lyxfont::maxAscent(font) * - layout.spacing.getValue() * - spacing_val); - int maxdesc = int(lyxfont::maxDescent(font) * - layout.spacing.getValue() * - spacing_val); - int const pos_end = rowLast(row_ptr); - int labeladdon = 0; - int maxwidth = 0; - - // Check if any insets are larger - for (int pos = row_ptr->pos(); pos <= pos_end; ++pos) { - if (row_ptr->par()->getChar(pos) == Paragraph::META_INSET) { - tmpfont = getFont(bview->buffer(), row_ptr->par(), pos); - tmpinset = row_ptr->par()->getInset(pos); - if (tmpinset) { + int maxasc = int(lyxfont::maxAscent(font) * + layout.spacing.getValue() * + spacing_val); + int maxdesc = int(lyxfont::maxDescent(font) * + layout.spacing.getValue() * + spacing_val); + pos_type const pos_end = rowLast(row_ptr); + int labeladdon = 0; + int maxwidth = 0; + + // Check if any insets are larger + for (pos_type pos = row_ptr->pos(); pos <= pos_end; ++pos) { + if (row_ptr->par()->isInset(pos)) { + tmpfont = getFont(bview->buffer(), row_ptr->par(), pos); + tmpinset = row_ptr->par()->getInset(pos); + if (tmpinset) { #if 1 // this is needed for deep update on initialitation - tmpinset->update(bview, tmpfont); + tmpinset->update(bview, tmpfont); #endif - 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); - } - } + 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 const maxsize = - row_ptr->par()->highestFontInRange(row_ptr->pos(), - pos_end); - if (maxsize > font.size()) { - font.setSize(maxsize); - - asc = lyxfont::maxAscent(font); - desc = lyxfont::maxDescent(font); - if (asc > maxasc) - maxasc = asc; - if (desc > maxdesc) - maxdesc = desc; - } + // 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, size); + if (maxsize > font.size()) { + font.setSize(maxsize); + + asc = lyxfont::maxAscent(font); + desc = lyxfont::maxDescent(font); + if (asc > maxasc) + maxasc = asc; + if (desc > maxdesc) + maxdesc = desc; + } - // This is nicer with box insets: - ++maxasc; - ++maxdesc; + // 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() && (row_ptr->par() == firstpar)) { - - // some parksips VERY EASY IMPLEMENTATION - if (bview->buffer()->params.paragraph_separation == - BufferParams::PARSEP_SKIP) { - if (layout.isParagraph() - && firstpar->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 += bview->buffer()->params.getDefSkip().inPixels(bview); - } + // is it a top line? + if (!row_ptr->pos() && (row_ptr->par() == firstpar)) { - // the paper margins - if (!row_ptr->par()->previous() && bv_owner) - maxasc += LYX_PAPER_MARGIN; + // some parksips VERY EASY IMPLEMENTATION + if (bview->buffer()->params.paragraph_separation == + BufferParams::PARSEP_SKIP) + { + if (layout.isParagraph() + && firstpar->getDepth() == 0 + && firstpar->previous()) + { + maxasc += bview->buffer()->params.getDefSkip().inPixels(bview); + } else if (firstpar->previous() && + textclasslist[bview->buffer()->params.textclass][firstpar->previous()->layout()].isParagraph() && + firstpar->previous()->getDepth() == 0) + { + // is it right to use defskip here too? (AS) + maxasc += bview->buffer()->params.getDefSkip().inPixels(bview); + } + } - // add the vertical spaces, that the user added - if (firstpar->params().spaceTop().kind() != VSpace::NONE) - maxasc += int(firstpar->params().spaceTop().inPixels(bview)); + // the paper margins + if (!row_ptr->par()->previous() && bv_owner) + maxasc += LYX_PAPER_MARGIN; - // 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)); + // add the vertical spaces, that the user added + maxasc += getLengthMarkerHeight(bview, firstpar->params().spaceTop()); + + // 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->params().pagebreakTop()) - maxasc += 3 * defaultHeight(); + // 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 - if (layout.labeltype == LABEL_COUNTER_CHAPTER - && bview->buffer()->params.secnumdepth >= 0) { - float spacing_val = 1.0; - if (!row_ptr->par()->params().spacing().isDefault()) { - spacing_val = row_ptr->par()->params().spacing().getValue(); - } else { - spacing_val = bview->buffer()->params.spacing.getValue(); - } + // 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 + && bview->buffer()->params.secnumdepth >= 0) + { + float spacing_val = 1.0; + if (!row_ptr->par()->params().spacing().isDefault()) { + spacing_val = row_ptr->par()->params().spacing().getValue(); + } else { + spacing_val = bview->buffer()->params.spacing.getValue(); + } - labeladdon = int(lyxfont::maxDescent(labelfont) * - layout.spacing.getValue() * - spacing_val) - + int(lyxfont::maxAscent(labelfont) * - layout.spacing.getValue() * - spacing_val); - } + labeladdon = int(lyxfont::maxDescent(labelfont) * + layout.spacing.getValue() * + spacing_val) + + int(lyxfont::maxAscent(labelfont) * + layout.spacing.getValue() * + spacing_val); + } - // 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()) { - float spacing_val = 1.0; - if (!row_ptr->par()->params().spacing().isDefault()) { - spacing_val = row_ptr->par()->params().spacing().getValue(); - } else { - spacing_val = bview->buffer()->params.spacing.getValue(); - } + // 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()) + { + float spacing_val = 1.0; + if (!row_ptr->par()->params().spacing().isDefault()) { + spacing_val = row_ptr->par()->params().spacing().getValue(); + } else { + spacing_val = bview->buffer()->params.spacing.getValue(); + } - labeladdon = int( - (lyxfont::maxAscent(labelfont) * - layout.spacing.getValue() * - spacing_val) - +(lyxfont::maxDescent(labelfont) * - layout.spacing.getValue() * - spacing_val) - + layout.topsep * defaultHeight() - + layout.labelbottomsep * defaultHeight()); - } + labeladdon = int( + (lyxfont::maxAscent(labelfont) * + layout.spacing.getValue() * + spacing_val) + +(lyxfont::maxDescent(labelfont) * + layout.spacing.getValue() * + spacing_val) + + layout.topsep * defaultHeight() + + 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->params().pagebreakTop()) { - Paragraph * prev = row_ptr->par()->previous(); - if (prev) - 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()) { - tmptop = layout.topsep; + if (!firstpar->params().pagebreakTop()) { + Paragraph * prev = row_ptr->par()->previous(); + if (prev) + prev = row_ptr->par()->depthHook(row_ptr->par()->getDepth()); + if (prev && prev->layout() == firstpar->layout() && + prev->getDepth() == firstpar->getDepth() && + prev->getLabelWidthString() == firstpar->getLabelWidthString()) + { + layoutasc = (layout.itemsep * defaultHeight()); + } else if (row_ptr->previous()) { + tmptop = layout.topsep; - if (row_ptr->previous()->par()->getDepth() >= row_ptr->par()->getDepth()) - tmptop -= textclasslist.Style(bview->buffer()->params.textclass, - row_ptr->previous()->par()-> - getLayout()).bottomsep; + if (row_ptr->previous()->par()->getDepth() >= row_ptr->par()->getDepth()) + tmptop -= textclasslist[bview->buffer()->params.textclass][row_ptr->previous()->par()->layout()].bottomsep; - if (tmptop > 0) - layoutasc = (tmptop * defaultHeight()); - } - else if (row_ptr->par()->params().lineTop()) { - tmptop = layout.topsep; + if (tmptop > 0) + layoutasc = (tmptop * defaultHeight()); + } else if (row_ptr->par()->params().lineTop()) { + tmptop = layout.topsep; - if (tmptop > 0) - layoutasc = (tmptop * defaultHeight()); - } + if (tmptop > 0) + layoutasc = (tmptop * defaultHeight()); + } - prev = row_ptr->par()->outerHook(); - if (prev) { - 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 - } - else if (firstpar->previous()){ - maxasc += int(layout.parsep * defaultHeight()); - } - } - } - } + prev = row_ptr->par()->outerHook(); + if (prev) { + maxasc += int(textclasslist[bview->buffer()->params.textclass][prev->layout()].parsep * defaultHeight()); + } else { + if (firstpar->previous() && + firstpar->previous()->getDepth() == 0 && + firstpar->previous()->layout() != + firstpar->layout()) + { + // avoid parsep + } else if (firstpar->previous()) { + maxasc += int(layout.parsep * defaultHeight()); + } + } + } + } - // is it a bottom line? - if (row_ptr->par() == par - && (!row_ptr->next() || row_ptr->next()->par() != row_ptr->par())) { - - // the paper margins - if (!par->next() && bv_owner) - maxdesc += LYX_PAPER_MARGIN; + // is it a bottom line? + if (row_ptr->par() == par + && (!row_ptr->next() || row_ptr->next()->par() != row_ptr->par())) + { + // the paper margins + if (!par->next() && bv_owner) + maxdesc += LYX_PAPER_MARGIN; - // add the vertical spaces, that the user added - if (firstpar->params().spaceBottom().kind() != VSpace::NONE) - maxdesc += int(firstpar->params().spaceBottom().inPixels(bview)); + // add the vertical spaces, that the user added + maxdesc += getLengthMarkerHeight(bview, firstpar->params().spaceBottom()); - // do not forget the DTP-lines! - // there height depends on the font of the nearest character - if (firstpar->params().lineBottom()) - maxdesc += 2 * lyxfont::ascent('x', - getFont(bview->buffer(), - par, par->size() - 1)); + // do not forget the DTP-lines! + // there height depends on the font of the nearest character + if (firstpar->params().lineBottom()) + maxdesc += 2 * lyxfont::ascent('x', + getFont(bview->buffer(), + par, + max(pos_type(0), par->size() - 1))); - // and now the pagebreaks - if (firstpar->params().pagebreakBottom()) - maxdesc += 3 * defaultHeight(); + // 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->params().pagebreakBottom() && row_ptr->par()->next()) { - Paragraph * nextpar = row_ptr->par()->next(); - Paragraph * comparepar = row_ptr->par(); - float usual = 0; - float unusual = 0; + // 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()) { + Paragraph * nextpar = row_ptr->par()->next(); + Paragraph * comparepar = row_ptr->par(); + float usual = 0; + float unusual = 0; - if (comparepar->getDepth() > nextpar->getDepth()) { - 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(bview->buffer()->params.textclass, comparepar->getLayout()).bottomsep * defaultHeight()); - - if (unusual > usual) - layoutdesc = unusual; - else - layoutdesc = usual; - } - else if (comparepar->getDepth() == nextpar->getDepth()) { - - if (comparepar->getLayout()!= nextpar->getLayout() - || nextpar->getLabelWidthString() != - comparepar->getLabelWidthString()) - layoutdesc = int(textclasslist.Style(bview->buffer()->params.textclass, comparepar->getLayout()).bottomsep * defaultHeight()); - } - } - } - - // incalculate the layout spaces - maxasc += int(layoutasc * 2 / (2 + firstpar->getDepth())); - maxdesc += int(layoutdesc * 2 / (2 + firstpar->getDepth())); - - // calculate the new height of the text - height -= row_ptr->height(); - - row_ptr->height(maxasc + maxdesc + labeladdon); - row_ptr->baseline(maxasc + labeladdon); - - height += row_ptr->height(); - float x; - float 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(); - } - } + if (comparepar->getDepth() > nextpar->getDepth()) { + usual = (textclasslist[bview->buffer()->params.textclass][comparepar->layout()].bottomsep * defaultHeight()); + comparepar = comparepar->depthHook(nextpar->getDepth()); + if (comparepar->layout()!= nextpar->layout() + || nextpar->getLabelWidthString() != + comparepar->getLabelWidthString()) + { + unusual = (textclasslist[bview->buffer()->params.textclass][comparepar->layout()].bottomsep * defaultHeight()); + } + if (unusual > usual) + layoutdesc = unusual; + else + layoutdesc = usual; + } else if (comparepar->getDepth() == nextpar->getDepth()) { + + if (comparepar->layout() != nextpar->layout() + || nextpar->getLabelWidthString() != + comparepar->getLabelWidthString()) + layoutdesc = int(textclasslist[bview->buffer()->params.textclass][comparepar->layout()].bottomsep * defaultHeight()); + } + } + } + + // incalculate the layout spaces + maxasc += int(layoutasc * 2 / (2 + firstpar->getDepth())); + maxdesc += int(layoutdesc * 2 / (2 + firstpar->getDepth())); + + // calculate the new height of the text + height -= row_ptr->height(); + + row_ptr->height(maxasc + maxdesc + labeladdon); + row_ptr->baseline(maxasc + labeladdon); + + height += row_ptr->height(); + float x = 0; + if (layout.margintype != MARGIN_RIGHT_ADDRESS_BOX) { + float dummy; + // this IS needed + row_ptr->width(maxwidth); + 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(); + } + } } @@ -1485,35 +1561,34 @@ void LyXText::setHeightOfRow(BufferView * bview, Row * row_ptr) const * start at the implicit given position */ void LyXText::appendParagraph(BufferView * bview, Row * row) const { - bool not_ready = true; + bool not_ready = true; - // The last character position of a paragraph is an invariant so we can - // safely get it here. (Asger) - int const lastposition = row->par()->size(); - do { - // Get the next breakpoint - int z = nextBreakPoint(bview, row, workWidth(bview)); + // The last character position of a paragraph is an invariant so we can + // safely get it here. (Asger) + pos_type const lastposition = row->par()->size(); + do { + // Get the next breakpoint + pos_type z = nextBreakPoint(bview, row, workWidth(bview)); - Row * tmprow = row; + Row * tmprow = row; - // Insert the new row - if (z < lastposition) { - ++z; - insertRow(row, row->par(), z); - row = row->next(); + // Insert the new row + if (z < lastposition) { + ++z; + insertRow(row, row->par(), z); + row = row->next(); - row->height(0); - } else - not_ready = false; + row->height(0); + } else + not_ready = false; - // Set the dimensions of the row -#ifdef WITH_WARNINGS -#warning Something is rotten here! (Jug) -#endif - tmprow->fill(fill(bview, tmprow, workWidth(bview))); - setHeightOfRow(bview, tmprow); + // Set the dimensions of the row + // fixed fill setting now by calling inset->update() in + // SingleWidth when needed! + tmprow->fill(fill(bview, tmprow, workWidth(bview))); + setHeightOfRow(bview, tmprow); - } while (not_ready); + } while (not_ready); } @@ -1523,7 +1598,7 @@ void LyXText::breakAgain(BufferView * bview, Row * row) const do { // get the next breakpoint - Paragraph::size_type z = nextBreakPoint(bview, row, workWidth(bview)); + pos_type z = nextBreakPoint(bview, row, workWidth(bview)); Row * tmprow = row; if (z < row->par()->size()) { @@ -1567,7 +1642,7 @@ void LyXText::breakAgain(BufferView * bview, Row * row) const void LyXText::breakAgainOneRow(BufferView * bview, Row * row) { // get the next breakpoint - Paragraph::size_type z = nextBreakPoint(bview, row, workWidth(bview)); + pos_type z = nextBreakPoint(bview, row, workWidth(bview)); Row * tmprow = row; if (z < row->par()->size()) { @@ -1579,7 +1654,7 @@ void LyXText::breakAgainOneRow(BufferView * bview, Row * row) row = row->next(); row->height(0); } else { - row= row->next(); + row = row->next(); ++z; if (row->pos() != z) row->pos(z); @@ -1606,16 +1681,16 @@ void LyXText::breakAgainOneRow(BufferView * bview, Row * row) void LyXText::breakParagraph(BufferView * bview, char keep_layout) { - LyXLayout const & layout = - textclasslist.Style(bview->buffer()->params.textclass, - cursor.par()->getLayout()); + LyXTextClass const & tclass = + textclasslist[bview->buffer()->params.textclass]; + LyXLayout const & layout = tclass[cursor.par()->layout()]; // this is only allowed, if the current paragraph is not empty or caption if ((cursor.par()->size() <= 0) && layout.labeltype!= LABEL_SENSITIVE) return; - setUndo(bview, Undo::INSERT,cursor.par(),cursor.par()->next()); + setUndo(bview, Undo::FINISH, cursor.par(), cursor.par()->next()); // Always break behind a space // @@ -1637,10 +1712,10 @@ void LyXText::breakParagraph(BufferView * bview, char keep_layout) if (layout.labeltype == LABEL_SENSITIVE) { if (!cursor.pos()) // set to standard-layout - cursor.par()->setLayout(0); + cursor.par()->applyLayout(tclass.defaultLayoutName()); else // set to standard-layout - cursor.par()->next()->setLayout(0); + cursor.par()->next()->applyLayout(tclass.defaultLayoutName()); } /* if the cursor is at the beginning of a row without prior newline, @@ -1696,7 +1771,7 @@ void LyXText::breakParagraph(BufferView * bview, char keep_layout) // Just a macro to make some thing easier. void LyXText::redoParagraph(BufferView * bview) const { - clearSelection(bview); + clearSelection(); redoParagraphs(bview, cursor, cursor.par()->next()); setCursorIntern(bview, cursor.par(), cursor.pos()); } @@ -1706,16 +1781,14 @@ void LyXText::redoParagraph(BufferView * bview) const * same Paragraph one to the right and make a rebreak */ void LyXText::insertChar(BufferView * bview, char c) { - setUndo(bview, Undo::INSERT, - cursor.par(), cursor.par()->next()); + setUndo(bview, Undo::INSERT, cursor.par(), cursor.par()->next()); // 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; - + textclasslist[bview->buffer()->params.textclass][cursor.row()->par()->layout()].free_spacing || + cursor.row()->par()->isFreeSpacing(); if (lyxrc.auto_number) { static string const number_operators = "+-/*"; @@ -1723,7 +1796,7 @@ void LyXText::insertChar(BufferView * bview, char c) static string const number_seperators = ".,:"; if (current_font.number() == LyXFont::ON) { - if (!isdigit(c) && !contains(number_operators, c) && + if (!IsDigit(c) && !contains(number_operators, c) && !(contains(number_seperators, c) && cursor.pos() >= 1 && cursor.pos() < cursor.par()->size() && @@ -1732,20 +1805,20 @@ void LyXText::insertChar(BufferView * bview, char c) 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) && + 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 + 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) ) - ) { + cursor.par()->isNewline(cursor.pos() - 2)) + ) { setCharFont(bview->buffer(), cursor.par(), cursor.pos() - 1, @@ -1754,7 +1827,7 @@ void LyXText::insertChar(BufferView * bview, char c) cursor.pos() >= 2 && getFont(bview->buffer(), cursor.par(), - cursor.pos()-2).number() == LyXFont::ON) { + cursor.pos() - 2).number() == LyXFont::ON) { setCharFont(bview->buffer(), cursor.par(), cursor.pos() - 1, @@ -1784,7 +1857,7 @@ void LyXText::insertChar(BufferView * bview, char c) * current font */ // Get the font that is used to calculate the baselineskip - Paragraph::size_type const lastpos = cursor.par()->size(); + pos_type const lastpos = cursor.par()->size(); LyXFont rawparfont = cursor.par()->getFontSettings(bview->buffer()->params, lastpos - 1); @@ -1809,8 +1882,8 @@ void LyXText::insertChar(BufferView * bview, char c) return; } } else if (IsNewlineChar(c)) { - if (cursor.par() == cursor.par() - && cursor.pos() <= beginningOfMainBody(bview->buffer(), cursor.par())) { + if (cursor.pos() <= beginningOfMainBody(bview->buffer(), + cursor.par())) { charInserted(); return; } @@ -1826,17 +1899,19 @@ void LyXText::insertChar(BufferView * bview, char c) } // the display inset stuff - if (cursor.row()->par()->getChar(cursor.row()->pos()) == Paragraph::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 + if (cursor.row()->par()->isInset(cursor.row()->pos())) { + Inset * inset = cursor.row()->par()->getInset(cursor.row()->pos()); + if (inset && (inset->display() || inset->needFullRow())) { + // force a new break + cursor.row()->fill(-1); // to force a new break + } + } // get the cursor row fist Row * row = cursor.row(); int y = cursor.y() - row->baseline(); if (c != Paragraph::META_INSET) /* Here case LyXText::InsertInset - * already insertet the character */ + * already insertet the character */ cursor.par()->insertChar(cursor.pos(), c); setCharFont(bview->buffer(), cursor.par(), cursor.pos(), rawtmpfont); @@ -1852,9 +1927,12 @@ void LyXText::insertChar(BufferView * bview, char c) // Is there a break one row above if ((cursor.par()->isLineSeparator(cursor.pos()) || cursor.par()->isNewline(cursor.pos()) + || ((cursor.pos() < cursor.par()->size()) && + cursor.par()->isInset(cursor.pos()+1)) || cursor.row()->fill() == -1) - && row->previous() && row->previous()->par() == row->par()) { - Paragraph::size_type z = nextBreakPoint(bview, + && row->previous() && row->previous()->par() == row->par()) + { + pos_type z = nextBreakPoint(bview, row->previous(), workWidth(bview)); if (z >= row->pos()) { @@ -1897,8 +1975,8 @@ void LyXText::insertChar(BufferView * bview, char c) // 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! */ + * will set fill to -1. Otherwise + * we would not get a rebreak! */ row->fill(fill(bview, row, workWidth(bview))); if (row->fill() < 0) { refresh_y = y; @@ -1952,8 +2030,7 @@ void LyXText::insertChar(BufferView * bview, char c) redoHeightOfParagraph(bview, cursor); } else { // now the special right address boxes - if (textclasslist.Style(bview->buffer()->params.textclass, - cursor.par()->getLayout()).margintype + if (textclasslist[bview->buffer()->params.textclass][cursor.par()->layout()].margintype == MARGIN_RIGHT_ADDRESS_BOX) { redoDrawingOfParagraph(bview, cursor); } @@ -1978,11 +2055,11 @@ void LyXText::charInserted() void LyXText::prepareToPrint(BufferView * bview, - Row * row, float & x, - float & fill_separator, - float & fill_hfill, - float & fill_label_hfill, - bool bidi) const + Row * row, float & x, + float & fill_separator, + float & fill_hfill, + float & fill_label_hfill, + bool bidi) const { float nlh; float ns; @@ -1993,7 +2070,7 @@ void LyXText::prepareToPrint(BufferView * bview, fill_separator = 0; fill_label_hfill = 0; - bool const is_rtl = + bool const is_rtl = row->par()->isRightToLeftPar(bview->buffer()->params); if (is_rtl) { x = (workWidth(bview) > 0) @@ -2002,12 +2079,12 @@ void LyXText::prepareToPrint(BufferView * bview, x = (workWidth(bview) > 0) ? leftMargin(bview, row) : 0; // 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) { - - /* one more since labels are left aligned */ + LyXTextClass const & tclass = textclasslist[bview->buffer()->params.textclass]; + LyXLayout const & layout = tclass[row->par()->layout()]; + + if (layout.margintype == MARGIN_MANUAL + && layout.labeltype == LABEL_MANUAL) { + // 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; @@ -2017,64 +2094,75 @@ void LyXText::prepareToPrint(BufferView * bview, // are there any hfills in the row? float const nh = numberOfHfills(bview->buffer(), row); - if (nh) - fill_hfill = w / nh; - else { + if (nh) { + if (w > 0) + fill_hfill = w / nh; + // we don't have to look at the alignment if it is ALIGN_LEFT and + // if the row is already larger then the permitted width as then + // we force the LEFT_ALIGN'edness! + } else if (static_cast(row->width()) < workWidth(bview)) { // is it block, flushleft or flushright? // set x how you need it - int align; - if (row->par()->params().align() == LYX_ALIGN_LAYOUT) - align = textclasslist.Style(bview->buffer()->params.textclass, row->par()->getLayout()).align; - else - align = row->par()->params().align(); - - // center displayed insets - Inset * inset; - if (row->par()->getChar(row->pos()) == Paragraph::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) { + int align; + if (row->par()->params().align() == LYX_ALIGN_LAYOUT) { + align = layout.align; + } else { + align = row->par()->params().align(); + } + + // center displayed insets + Inset * inset; + if (row->par()->isInset(row->pos()) + && (inset=row->par()->getInset(row->pos())) + && (inset->display())) // || (inset->scroll() < 0))) + align = (inset->lyxCode() == Inset::MATHMACRO_CODE) + ? LYX_ALIGN_BLOCK : LYX_ALIGN_CENTER; + // ERT insets should always be LEFT ALIGNED on screen + inset = row->par()->inInset(); + if (inset && inset->owner() && + inset->owner()->lyxCode() == Inset::ERT_CODE) + { + align = LYX_ALIGN_LEFT; + } + + switch (align) { case LYX_ALIGN_BLOCK: - 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()) == Paragraph::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) - x += w; - break; + 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()->isInset(row->next()->pos()) + && row->next()->par()->getInset(row->next()->pos()) + && row->next()->par()->getInset(row->next()->pos())->display()) + ) + { + fill_separator = w / ns; + } else if (is_rtl) { + x += w; + } + break; case LYX_ALIGN_RIGHT: - x += w; - break; + x += w; + break; case LYX_ALIGN_CENTER: - x += w / 2; - break; - } + x += w / 2; + break; + } } if (!bidi) return; computeBidiTables(bview->buffer(), row); if (is_rtl) { - Paragraph::size_type main_body = + pos_type main_body = beginningOfMainBody(bview->buffer(), row->par()); - Paragraph::size_type last = rowLast(row); + pos_type last = rowLast(row); if (main_body > 0 && - (main_body-1 > last || - !row->par()->isLineSeparator(main_body-1))) { - LyXLayout const & layout = - textclasslist.Style(bview->buffer()->params.textclass, - row->par()->getLayout()); + (main_body - 1 > last || + !row->par()->isLineSeparator(main_body - 1))) { x += lyxfont::width(layout.labelsep, - getFont(bview->buffer(), row->par(), -2)); - if (main_body-1 <= last) + getLabelFont(bview->buffer(), row->par())); + if (main_body - 1 <= last) x += fill_label_hfill; } } @@ -2109,7 +2197,7 @@ void LyXText::cursorRightOneWord(BufferView * bview) const } // Advance through word. while (tmpcursor.pos() < tmpcursor.par()->size() && - tmpcursor.par()->isWord( tmpcursor.pos())) { + tmpcursor.par()->isWord(tmpcursor.pos())) { // printf("Current pos2 %d", tmpcursor.pos()) ; tmpcursor.pos(tmpcursor.pos() + 1); ++steps; @@ -2126,7 +2214,7 @@ void LyXText::cursorTab(BufferView * bview) const && !tmpcursor.par()->isNewline(tmpcursor.pos())) tmpcursor.pos(tmpcursor.pos() + 1); - if (tmpcursor.pos() == tmpcursor.par()->size()){ + if (tmpcursor.pos() == tmpcursor.par()->size()) { if (tmpcursor.par()->next()) { tmpcursor.par(tmpcursor.par()->next()); tmpcursor.pos(0); @@ -2163,13 +2251,13 @@ void LyXText::cursorLeftOneWord(LyXCursor & cur) const || cur.par()->isHfill(cur.pos() - 1))) { cur.pos(cur.pos() - 1); } else if (!cur.pos()) { - if (cur.par()->previous()){ + if (cur.par()->previous()) { cur.par(cur.par()->previous()); cur.pos(cur.par()->size()); } } else { // Here, cur != 0 while (cur.pos() > 0 && - cur.par()->isWord(cur.pos()-1) ) + cur.par()->isWord(cur.pos()-1)) cur.pos(cur.pos() - 1); } } @@ -2181,7 +2269,7 @@ void LyXText::getWord(LyXCursor & from, LyXCursor & to, { // first put the cursor where we wana start to select the word from = cursor; - switch(loc) { + switch (loc) { case WHOLE_WORD_STRICT: if (cursor.pos() == 0 || cursor.pos() == cursor.par()->size() || cursor.par()->isSeparator(cursor.pos()) @@ -2213,7 +2301,7 @@ void LyXText::getWord(LyXCursor & from, LyXCursor & to, while (to.pos() < to.par()->size() && !to.par()->isSeparator(to.pos()) && !to.par()->isKomma(to.pos()) - && !to.par()->isHfill(to.pos()) ) + && !to.par()->isHfill(to.pos())) { to.pos(to.pos() + 1); } @@ -2230,7 +2318,7 @@ void LyXText::selectWord(BufferView * bview, word_location const loc) if (to == from) return; selection.cursor = cursor; - setCursor(bview, to.par(), to.pos() ); + setCursor(bview, to.par(), to.pos()); setSelection(bview); } @@ -2250,17 +2338,16 @@ bool LyXText::selectWordWhenUnderCursor(BufferView * bview, // This function is only used by the spellchecker for NextWord(). // It doesn't handle LYX_ACCENTs and probably never will. -string const LyXText::selectNextWord(BufferView * bview, - float & value) const +string const LyXText::selectNextWordToSpellcheck(BufferView * bview, + float & value) const { if (the_locking_inset) { - string str = the_locking_inset->selectNextWord(bview, value); + string str = the_locking_inset->selectNextWordToSpellcheck(bview, value); if (!str.empty()) { value += float(cursor.y())/float(height); return str; } -#warning Dekel please have a look on this one RTL? (Jug) - // we have to go on checking so move cusor to the right + // we have to go on checking so move cusor to the next char if (cursor.pos() == cursor.par()->size()) { if (!cursor.par()->next()) return str; @@ -2282,17 +2369,12 @@ string const LyXText::selectNextWord(BufferView * bview, // Now, skip until we have real text (will jump paragraphs) while ((cursor.par()->size() > cursor.pos() - && (!cursor.par()->isLetter(cursor.pos()) -#ifndef NO_LATEX - || cursor.par()->getFont(bview->buffer()->params, cursor.pos()) - .latex() == LyXFont::ON -#endif - ) + && (!cursor.par()->isLetter(cursor.pos())) && (!cursor.par()->isInset(cursor.pos()) || - !cursor.par()->getInset(cursor.pos())->isTextInset())) + !cursor.par()->getInset(cursor.pos())->allowSpellcheck())) || (cursor.par()->size() == cursor.pos() && cursor.par()->next())) - { + { if (cursor.pos() == cursor.par()->size()) { cursor.par(cursor.par()->next()); cursor.pos(0); @@ -2302,17 +2384,17 @@ string const LyXText::selectNextWord(BufferView * bview, // now check if we hit an inset so it has to be a inset containing text! if (cursor.pos() < cursor.par()->size() && - cursor.par()->isInset(cursor.pos())) + cursor.par()->isInset(cursor.pos())) { // lock the inset! cursor.par()->getInset(cursor.pos())->edit(bview); // now call us again to do the above trick // but obviously we have to start from down below ;) - return bview->text->selectNextWord(bview, value); + return bview->text->selectNextWordToSpellcheck(bview, value); } // Update the value if we changed paragraphs - if (cursor.par() != tmppar){ + if (cursor.par() != tmppar) { setCursor(bview, cursor.par(), cursor.pos()); value = float(cursor.y())/float(height); } @@ -2320,26 +2402,18 @@ string const LyXText::selectNextWord(BufferView * bview, // Start the selection from here selection.cursor = cursor; - Inset * inset; - - // and find the end of the word - // (optional hyphens are part of a word) + // and find the end of the word (insets like optional hyphens + // and ligature break are part of a word) while (cursor.pos() < cursor.par()->size() - && (cursor.par()->isLetter(cursor.pos())) - // assignment is intentional here - || ((inset = getInset()) - && inset->lyxCode() == Inset::SPECIALCHAR_CODE - && static_cast(inset)->kind() - == InsetSpecialChar::HYPHENATION - )) + && (cursor.par()->isLetter(cursor.pos()))) cursor.pos(cursor.pos() + 1); // Finally, we copy the word to a string and return it string str; if (selection.cursor.pos() < cursor.pos()) { - Paragraph::size_type i; + pos_type i; for (i = selection.cursor.pos(); i < cursor.pos(); ++i) { - if (cursor.par()->getChar(i) != Paragraph::META_INSET) + if (!cursor.par()->isInset(i)) str += cursor.par()->getChar(i); } } @@ -2359,17 +2433,10 @@ void LyXText::selectSelectedWord(BufferView * bview) // set the sel cursor selection.cursor = cursor; - Inset * inset; // now find the end of the word while (cursor.pos() < cursor.par()->size() - && (cursor.par()->isLetter(cursor.pos()) - // assignment is intentional here - || ((inset = getInset()) - && inset->lyxCode() == Inset::SPECIALCHAR_CODE - && static_cast(inset)->kind() - == InsetSpecialChar::HYPHENATION - ))) + && (cursor.par()->isLetter(cursor.pos()))) cursor.pos(cursor.pos() + 1); setCursor(bview, cursor.par(), cursor.pos()); @@ -2392,10 +2459,10 @@ void LyXText::deleteWordForward(BufferView * bview) setCursor(bview, tmpcursor, tmpcursor.par(), tmpcursor.pos()); selection.cursor = cursor; cursor = tmpcursor; - setSelection(bview); + setSelection(bview); /* -----> Great, CutSelection() gets rid of multiple spaces. */ - cutSelection(bview); + cutSelection(bview, true, false); } } @@ -2414,7 +2481,7 @@ void LyXText::deleteWordBackward(BufferView * bview) selection.cursor = cursor; cursor = tmpcursor; setSelection(bview); - cutSelection(bview); + cutSelection(bview, true, false); } } @@ -2440,7 +2507,7 @@ void LyXText::deleteLineForward(BufferView * bview) if (!selection.set()) { deleteWordForward(bview); } else { - cutSelection(bview); + cutSelection(bview, true, false); } } } @@ -2477,10 +2544,9 @@ void LyXText::changeRegionCase(BufferView * bview, { lyx::Assert(from <= to); - setUndo(bview, Undo::FINISH, - from.par(), to.par()->next()); + setUndo(bview, Undo::FINISH, from.par(), to.par()->next()); - Paragraph::size_type pos = from.pos(); + pos_type pos = from.pos(); Paragraph * par = from.par(); while (par && (pos != to.pos() || par != to.par())) { @@ -2488,14 +2554,14 @@ void LyXText::changeRegionCase(BufferView * bview, if (!IsInsetChar(c) && !IsHfillChar(c)) { switch (action) { case text_lowercase: - c = tolower(c); + c = lowercase(c); break; case text_capitalization: - c = toupper(c); + c = uppercase(c); action = text_lowercase; break; case text_uppercase: - c = toupper(c); + c = uppercase(c); break; } } @@ -2520,10 +2586,9 @@ void LyXText::transposeChars(BufferView & bview) { Paragraph * tmppar = cursor.par(); - setUndo(&bview, Undo::FINISH, - tmppar, tmppar->next()); + setUndo(&bview, Undo::FINISH, tmppar, tmppar->next()); - Paragraph::size_type tmppos = cursor.pos(); + pos_type tmppos = cursor.pos(); // First decide if it is possible to transpose at all @@ -2567,15 +2632,18 @@ void LyXText::Delete(BufferView * bview) //work better? 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 + && cursor.par()->id() != old_cur_par_id) { + // delete-empty-paragraph-mechanism has done it + return; + } // if you had success make a backspace 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 + // to make sure undo gets the right cursor position + cursor = old_cursor; setUndo(bview, Undo::DELETE, - cursor.par(), cursor.par()->next()); + cursor.par(), cursor.par()->next()); cursor = tmpcursor; backspace(bview); } @@ -2585,7 +2653,7 @@ void LyXText::Delete(BufferView * bview) void LyXText::backspace(BufferView * bview) { // Get the font that is used to calculate the baselineskip - Paragraph::size_type lastpos = cursor.par()->size(); + pos_type lastpos = cursor.par()->size(); LyXFont rawparfont = cursor.par()->getFontSettings(bview->buffer()->params, lastpos - 1); @@ -2606,7 +2674,7 @@ void LyXText::backspace(BufferView * bview) if (cursor.par()->previous()) { Paragraph * tmppar = cursor.par()->previous(); - if (cursor.par()->getLayout() == tmppar->getLayout() + if (cursor.par()->layout() == tmppar->layout() && cursor.par()->getAlign() == tmppar->getAlign()) { // Inherit bottom DTD from the paragraph below. // (the one we are deleting) @@ -2631,8 +2699,7 @@ void LyXText::backspace(BufferView * bview) if (cursor.par()->previous()) { setUndo(bview, Undo::DELETE, - cursor.par()->previous(), - cursor.par()->next()); + cursor.par()->previous(), cursor.par()->next()); } Paragraph * tmppar = cursor.par(); @@ -2645,8 +2712,8 @@ void LyXText::backspace(BufferView * bview) if (cursor.par()->previous()) { // steps into the above paragraph. setCursorIntern(bview, cursor.par()->previous(), - cursor.par()->previous()->size(), - false); + cursor.par()->previous()->size(), + false); } /* Pasting is not allowed, if the paragraphs have different @@ -2659,11 +2726,12 @@ void LyXText::backspace(BufferView * bview) Correction: Pasting is always allowed with standard-layout */ + LyXTextClass const & tclass = textclasslist[bview->buffer()->params.textclass]; + if (cursor.par() != tmppar - && (cursor.par()->getLayout() == tmppar->getLayout() - || tmppar->getLayout() == 0 /*standard*/) + && (cursor.par()->layout() == tmppar->layout() + || tmppar->layout() == tclass.defaultLayoutName()) && cursor.par()->getAlign() == tmppar->getAlign()) { - removeParagraph(tmprow); removeRow(tmprow); cursor.par()->pasteParagraph(bview->buffer()->params); @@ -2700,16 +2768,16 @@ void LyXText::backspace(BufferView * bview) /* this is the code for a normal backspace, not pasting * any paragraphs */ setUndo(bview, Undo::DELETE, - cursor.par(), cursor.par()->next()); + cursor.par(), cursor.par()->next()); // 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(bview, cursor.par(), cursor.pos()- 1, - false, cursor.boundary()); + false, cursor.boundary()); // some insets are undeletable here - if (cursor.par()->getChar(cursor.pos()) == Paragraph::META_INSET) { + if (cursor.par()->isInset(cursor.pos())) { if (!cursor.par()->getInset(cursor.pos())->deletable()) return; // force complete redo when erasing display insets @@ -2724,14 +2792,14 @@ void LyXText::backspace(BufferView * bview) Row * row = cursor.row(); int y = cursor.y() - row->baseline(); - Paragraph::size_type z; + pos_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(row->fill() + singleWidth(bview, - cursor.par(), - cursor.pos())); + cursor.par(), + cursor.pos())); } /* some special code when deleting a newline. This is similar @@ -2893,658 +2961,733 @@ void LyXText::backspace(BufferView * bview) redoHeightOfParagraph(bview, cursor); } else { // now the special right address boxes - if (textclasslist.Style(bview->buffer()->params.textclass, - cursor.par()->getLayout()).margintype == MARGIN_RIGHT_ADDRESS_BOX) { + if (textclasslist + [bview->buffer()->params.textclass] + [cursor.par()->layout()].margintype == MARGIN_RIGHT_ADDRESS_BOX) { redoDrawingOfParagraph(bview, cursor); } } } -void LyXText::getVisibleRow(BufferView * bview, int y_offset, int x_offset, - Row * row_ptr, int y, bool cleared) +bool LyXText::paintRowBackground(DrawRowParams & p) { - // returns a printed row - Painter & pain = bview->painter(); - - bool const is_rtl = - row_ptr->par()->isRightToLeftPar(bview->buffer()->params); - - Paragraph::size_type const last = rowLastPrintable(row_ptr); + bool clear_area = true; + Inset * inset = 0; + LyXFont font(LyXFont::ALL_SANE); - Paragraph::size_type vpos; - Paragraph::size_type pos; + pos_type const last = rowLastPrintable(p.row); - float tmpx; + if (!p.bv->screen()->forceClear() && last == p.row->pos() + && p.row->par()->isInset(p.row->pos())) { + inset = p.row->par()->getInset(p.row->pos()); + if (inset) { + clear_area = inset->doClearArea(); + } + } + + if (p.cleared) { + return true; + } + + if (clear_area) { + int const x = p.xo; + int const y = p.yo < 0 ? 0 : p.yo; + int const h = p.yo < 0 ? p.row->height() + p.yo : p.row->height(); + p.pain->fillRectangle(x, y, p.width, h, backgroundColor()); + return true; + } + + if (inset == 0) + return false; + + int h = p.row->baseline() - inset->ascent(p.bv, font); + + // first clear the whole row above the inset! + if (h > 0) { + p.pain->fillRectangle(p.xo, p.yo, p.width, h, backgroundColor()); + } - LyXFont font(LyXFont::ALL_SANE); - int maxdesc; - if (row_ptr->height() <= 0) { - lyxerr << "LYX_ERROR: row.height: " - << row_ptr->height() << endl; - return; + // clear the space below the inset! + h += inset->ascent(p.bv, font) + inset->descent(p.bv, font); + if ((p.row->height() - h) > 0) { + p.pain->fillRectangle(p.xo, p.yo + h, + p.width, p.row->height() - h, backgroundColor()); } - float x; - float fill_separator; - float fill_hfill; - float fill_label_hfill; - prepareToPrint(bview, row_ptr, x, fill_separator, - fill_hfill, fill_label_hfill); - - if (inset_owner && (x < 0)) - x = 0; - x += x_offset; - - // clear the area where we want to paint/print - int const ww = bview->workWidth(); + // clear the space behind the inset, if needed + if (!inset->display() && !inset->needFullRow()) { + int const xp = int(p.x) + inset->width(p.bv, font); + if (p.width - xp > 0) { + p.pain->fillRectangle(xp, p.yo, p.width - xp, + p.row->height(), backgroundColor()); + } + } + + return false; +} - bool clear_area = true; - Inset * inset = 0; - if (!bview->screen()->forceClear() && last == row_ptr->pos() - && row_ptr->par()->getChar(row_ptr->pos()) == Paragraph::META_INSET - && (inset = row_ptr->par()->getInset(row_ptr->pos()))) { - clear_area = inset->doClearArea(); +void LyXText::paintRowSelection(DrawRowParams & p) +{ + bool const is_rtl = p.row->par()->isRightToLeftPar(p.bv->buffer()->params); + + // the current selection + int const startx = selection.start.x(); + int const endx = selection.end.x(); + int const starty = selection.start.y(); + int const endy = selection.end.y(); + Row const * startrow = selection.start.row(); + Row const * endrow = selection.end.row(); + + Row * row = p.row; + + if (bidi_same_direction) { + int x; + int y = p.yo; + int w; + int h = row->height(); + + if (startrow == row && endrow == row) { + if (startx < endx) { + x = p.xo + startx; + w = endx - startx; + p.pain->fillRectangle(x, y, w, h, LColor::selection); + } else { + x = p.xo + endx; + w = startx - endx; + p.pain->fillRectangle(x, y, w, h, LColor::selection); + } + } else if (startrow == row) { + int const x = (is_rtl) ? p.xo : (p.xo + startx); + int const w = (is_rtl) ? startx : (p.width - startx); + p.pain->fillRectangle(x, y, w, h, LColor::selection); + } else if (endrow == row) { + int const x = (is_rtl) ? (p.xo + endx) : p.xo; + int const w = (is_rtl) ? (p.width - endx) : endx; + p.pain->fillRectangle(x, y, w, h, LColor::selection); + } else if (p.y > starty && p.y < endy) { + p.pain->fillRectangle(p.xo, y, p.width, h, LColor::selection); + } + return; + } else if (startrow != row && endrow != row) { + int w = p.width; + int h = row->height(); + if (p.y > starty && p.y < endy) { + p.pain->fillRectangle(p.xo, p.yo, w, h, LColor::selection); + } + return; } - // 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, backgroundColor()); - } else if (inset != 0) { - int h = row_ptr->baseline() - inset->ascent(bview, font); - // first clear the whole row above the inset! - if (h > 0) { -#if 0 - int const w = (inset_owner ? - inset_owner->width(bview, font) : ww); -#endif - pain.fillRectangle(x_offset, y_offset, ww, h, - backgroundColor()); + + if (!((startrow != row && !is_rtl) || (endrow != row && is_rtl))) { + return; + } + + float tmpx = p.x; + + p.pain->fillRectangle(p.xo, p.yo, int(p.x), row->height(), LColor::selection); + + Buffer const * buffer = p.bv->buffer(); + Paragraph * par = row->par(); + pos_type main_body = beginningOfMainBody(buffer, par); + pos_type const last = rowLastPrintable(row); + + for (pos_type vpos = row->pos(); vpos <= last; ++vpos) { + pos_type pos = vis2log(vpos); + float const old_tmpx = tmpx; + if (main_body > 0 && pos == main_body - 1) { + LyXLayout const & layout = + textclasslist + [buffer->params.textclass] + [par->layout()]; + LyXFont const lfont = getLabelFont(buffer, par); + + + tmpx += p.label_hfill + lyxfont::width(layout.labelsep, lfont); + + if (par->isLineSeparator(main_body - 1)) + tmpx -= singleWidth(p.bv, par, main_body - 1); + } + + if (hfillExpansion(buffer, row, pos)) { + tmpx += singleWidth(p.bv, par, pos); + if (pos >= main_body) + tmpx += p.hfill; + else + tmpx += p.label_hfill; } - h += inset->ascent(bview, font) + inset->descent(bview, font); - // clear the space below the inset! - if ((row_ptr->height() - h) > 0) { -#if 0 - int const w = (inset_owner ? - inset_owner->width(bview, font) : ww); -#endif - pain.fillRectangle(x_offset, y_offset + h, - ww, row_ptr->height() - h, - backgroundColor()); + + else if (par->isSeparator(pos)) { + tmpx += singleWidth(p.bv, par, pos); + if (pos >= main_body) + tmpx += p.separator; + } else { + tmpx += singleWidth(p.bv, par, pos); } - // clear the space behind the inset, if needed - 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(), - backgroundColor()); + + if ((startrow != row || selection.start.pos() <= pos) && + (endrow != row || pos < selection.end.pos())) { + // Here we do not use p.x as p.xo was added to p.x. + p.pain->fillRectangle(int(old_tmpx), p.yo, + int(tmpx - old_tmpx + 1), + row->height(), LColor::selection); + } + + if ((startrow != row && is_rtl) || (endrow != row && !is_rtl)) { + p.pain->fillRectangle(p.xo + int(tmpx), + p.yo, int(p.bv->workWidth() - tmpx), + row->height(), LColor::selection); } } +} + - if (selection.set()) { - int const w = (inset_owner ? - inset_owner->width(bview, font) : ww); - // selection code - if (bidi_same_direction) { - if (selection.start.row() == row_ptr && - selection.end.row() == row_ptr) { - if (selection.start.x() < selection.end.x()) - pain.fillRectangle(x_offset + selection.start.x(), - y_offset, - selection.end.x() - selection.start.x(), - row_ptr->height(), - LColor::selection); - else - pain.fillRectangle(x_offset + selection.end.x(), - y_offset, - selection.start.x() - selection.end.x(), - row_ptr->height(), - LColor::selection); - } else if (selection.start.row() == row_ptr) { - if (is_rtl) - pain.fillRectangle(x_offset, y_offset, - selection.start.x(), - row_ptr->height(), - LColor::selection); - else - pain.fillRectangle(x_offset + selection.start.x(), - y_offset, - w - selection.start.x(), - row_ptr->height(), - LColor::selection); - } else if (selection.end.row() == row_ptr) { - if (is_rtl) - pain.fillRectangle(x_offset + selection.end.x(), - y_offset, - w - selection.end.x(), - row_ptr->height(), - LColor::selection); - else - pain.fillRectangle(x_offset, y_offset, - selection.end.x(), - row_ptr->height(), - LColor::selection); - } else if (y > selection.start.y() - && y < selection.end.y()) { - pain.fillRectangle(x_offset, y_offset, w, - row_ptr->height(), - LColor::selection); - } - } else if (selection.start.row() != row_ptr && - selection.end.row() != row_ptr && - y > selection.start.y() - && y < selection.end.y()) { - pain.fillRectangle(x_offset, y_offset, w, - row_ptr->height(), - LColor::selection); - } else if (selection.start.row() == row_ptr || - selection.end.row() == row_ptr) { - float tmpx = x; - if ((selection.start.row() != row_ptr && !is_rtl) || - (selection.end.row() != row_ptr && is_rtl)) - pain.fillRectangle(x_offset, y_offset, - int(tmpx), - row_ptr->height(), - LColor::selection); - Paragraph::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); - } - 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 ((selection.start.row() != row_ptr || - selection.start.pos() <= pos) && - (selection.end.row() != row_ptr || - pos < selection.end.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); - } +void LyXText::paintRowAppendix(DrawRowParams & p) +{ + // FIXME: can be just p.width ? + int const ww = p.bv->workWidth(); + Paragraph * firstpar = p.row->par(); - if ((selection.start.row() != row_ptr && is_rtl) || - (selection.end.row() != row_ptr && !is_rtl) ) - pain.fillRectangle(x_offset + int(tmpx), - y_offset, - int(ww - tmpx), - row_ptr->height(), - LColor::selection); + if (firstpar->params().appendix()) { + p.pain->line(1, p.yo, 1, p.yo + p.row->height(), LColor::appendixline); + p.pain->line(ww - 2, p.yo, ww - 2, p.yo + p.row->height(), LColor::appendixline); + } +} + + +void LyXText::paintRowDepthBar(DrawRowParams & p) +{ + Paragraph::depth_type const depth = p.row->par()->getDepth(); + + if (depth <= 0) + return; + + Paragraph::depth_type prev_depth = 0; + if (p.row->previous()) + prev_depth = p.row->previous()->par()->getDepth(); + Paragraph::depth_type next_depth = 0; + if (p.row->next()) + next_depth = p.row->next()->par()->getDepth(); + + for (Paragraph::depth_type i = 1; i <= depth; ++i) { + int const x = (LYX_PAPER_MARGIN / 5) * i + p.xo; + int const h = p.yo + p.row->height() - 1 - (i - next_depth - 1) * 3; + + p.pain->line(x, p.yo, x, h, LColor::depthbar); + + int const w = LYX_PAPER_MARGIN / 5; + + if (i > prev_depth) { + p.pain->fillRectangle(x, p.yo, w, 2, LColor::depthbar); + } + if (i > next_depth) { + p.pain->fillRectangle(x, h, w, 2, LColor::depthbar); } } +} - int box_x = 0; - // Draw appendix lines - Paragraph * firstpar = row_ptr->par(); +int LyXText::getLengthMarkerHeight(BufferView * bv, VSpace const & vsp) const +{ + int const arrow_size = 4; + int const space_size = int(vsp.inPixels(bv)); - 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); - } - - // Draw depth lines - Paragraph::depth_type const depth = firstpar->getDepth(); - if (depth > 0) { - Paragraph::depth_type next_depth = 0; - Paragraph::depth_type prev_depth = 0; - if (row_ptr->next()) - next_depth = row_ptr->next()->par()->getDepth(); - if (row_ptr->previous()) - prev_depth = row_ptr->previous()->par()->getDepth(); - - for (Paragraph::depth_type i = 1; i <= depth; ++i) { - int const line_x = (LYX_PAPER_MARGIN / 5) * - i + 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); - - 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); - } + if (vsp.kind() != VSpace::LENGTH) { + return space_size; } + + LyXFont font; + font.decSize(); + int const min_size = max(3 * arrow_size, + lyxfont::maxAscent(font) + + lyxfont::maxDescent(font)); + + if (vsp.length().len().value() < 0.0) + return min_size; + else + return max(min_size, space_size); +} + + +int LyXText::drawLengthMarker(DrawRowParams & p, string const & prefix, + VSpace const & vsp, int start) +{ + int const arrow_size = 4; + int const size = getLengthMarkerHeight(p.bv, vsp); + int const end = start + size; + // the label to display (if any) + string str; + // y-values for top arrow + int ty1, ty2; + // y-values for bottom arrow + int by1, by2; + switch (vsp.kind()) { + case VSpace::LENGTH: + { + str = prefix + " (" + vsp.asLyXCommand() + ")"; + // adding or removing space + bool const added = !(vsp.length().len().value() < 0.0); + ty1 = added ? (start + arrow_size) : start; + ty2 = added ? start : (start + arrow_size); + by1 = added ? (end - arrow_size) : end; + by2 = added ? end : (end - arrow_size); + break; + } + case VSpace:: VFILL: + str = prefix + " (vertical fill)"; + ty1 = ty2 = start; + by1 = by2 = end; + break; + default: + // nothing to draw here + return size; + } + + int const leftx = p.xo + leftMargin(p.bv, p.row); + int const midx = leftx + arrow_size; + int const rightx = midx + arrow_size; + + // first the string + int w = 0; + int a = 0; + int d = 0; + + LyXFont font; + font.setColor(LColor::added_space).decSize(); + lyxfont::rectText(str, font, w, a, d); + + p.pain->rectText(leftx + 2 * arrow_size + 5, + start + ((end - start) / 2) + d, + str, font, + backgroundColor(), + backgroundColor()); - LyXLayout const & layout = - textclasslist.Style(bview->buffer()->params.textclass, - row_ptr->par()->getLayout()); + // top arrow + p.pain->line(leftx, ty1, midx, ty2, LColor::added_space); + p.pain->line(midx, ty2, rightx, ty1, LColor::added_space); + + // bottom arrow + p.pain->line(leftx, by1, midx, by2, LColor::added_space); + p.pain->line(midx, by2, rightx, by1, LColor::added_space); + // joining line + p.pain->line(midx, ty2, midx, by2, LColor::added_space); + + return size; +} + + +void LyXText::paintFirstRow(DrawRowParams & p) +{ + Paragraph * par = p.row->par(); + ParagraphParameters const & parparams = par->params(); + + // start of appendix? + if (parparams.startOfAppendix()) { + p.pain->line(1, p.yo, p.width - 2, p.yo, LColor::appendixline); + } + int y_top = 0; - int y_bottom = row_ptr->height(); + + // think about the margins + if (!p.row->previous() && bv_owner) + y_top += LYX_PAPER_MARGIN; + + // draw a top pagebreak + if (parparams.pagebreakTop()) { + int const y = p.yo + y_top + 2*defaultHeight(); + p.pain->line(p.xo, y, p.xo + p.width, y, + LColor::pagebreak, Painter::line_onoffdash); + + int w = 0; + int a = 0; + int d = 0; + + LyXFont pb_font; + pb_font.setColor(LColor::pagebreak).decSize(); + lyxfont::rectText(_("Page Break (top)"), pb_font, w, a, d); + p.pain->rectText((p.width - w)/2, y + d, + _("Page Break (top)"), pb_font, + backgroundColor(), + backgroundColor()); + y_top += 3 * defaultHeight(); + } - // is it a first row? - if (!row_ptr->pos() && (row_ptr->par() == firstpar)) { - - // 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() && bv_owner) - y_top += LYX_PAPER_MARGIN; - - // draw a top pagebreak - if (row_ptr->par()->params().pagebreakTop()) { - LyXFont pb_font; - pb_font.setColor(LColor::pagebreak).decSize(); - 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); - lyxfont::rectText(_("Page Break (top)"), pb_font, - w, a, d); - pain.rectText((ww - w)/2, - y_offset + y_top + 2 * defaultHeight() + d, - _("Page Break (top)"), - pb_font, - backgroundColor(), - backgroundColor()); - y_top += 3 * defaultHeight(); - } - - 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, y_offset + y_top + 3 * defaultHeight(), - LYX_PAPER_MARGIN, - y_offset + y_top + 3 * defaultHeight(), - LColor::vfillline); - - pain.line(LYX_PAPER_MARGIN / 2, y_offset + 2 + y_top, - LYX_PAPER_MARGIN / 2, - y_offset + y_top + 3 * defaultHeight(), - LColor::vfillline); - - y_top += 3 * defaultHeight(); - } - - // 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 (bview->buffer()->params.paragraph_separation == BufferParams::PARSEP_SKIP) { + // draw the additional space if needed: + y_top += drawLengthMarker(p, _("Space above"), + parparams.spaceTop(), p.yo + y_top); + + Buffer const * buffer = p.bv->buffer(); + + LyXTextClass const & tclass = textclasslist[buffer->params.textclass]; + LyXLayout const & layout = tclass[par->layout()]; + + // think about the parskip + // some parskips VERY EASY IMPLEMENTATION + if (buffer->params.paragraph_separation == BufferParams::PARSEP_SKIP) { + if (par->previous()) { if (layout.latextype == LATEX_PARAGRAPH - && firstpar->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 += bview->buffer()->params.getDefSkip().inPixels(bview); + && !par->getDepth()) { + y_top += buffer->params.getDefSkip().inPixels(p.bv); + } else { + LyXLayout const & playout = + tclass[par->previous()->layout()]; + if (playout.latextype == LATEX_PARAGRAPH + && !par->previous()->getDepth()) { + // is it right to use defskip here, too? (AS) + y_top += buffer->params.getDefSkip().inPixels(p.bv); + } + } } + } + + int const ww = p.bv->workWidth(); + + // draw a top line + if (parparams.lineTop()) { + LyXFont font(LyXFont::ALL_SANE); + int const asc = lyxfont::ascent('x', getFont(buffer, par, 0)); + + y_top += asc; + + int const w = (inset_owner ? inset_owner->width(p.bv, font) : ww); + int const xp = static_cast(inset_owner ? p.xo : 0); + p.pain->line(xp, p.yo + y_top, xp + w, p.yo + y_top, + LColor::topline, Painter::line_solid, + Painter::line_thick); - 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 += asc; + } + + bool const is_rtl = p.row->par()->isRightToLeftPar(p.bv->buffer()->params); + + // should we print a label? + if (layout.labeltype >= LABEL_STATIC + && (layout.labeltype != LABEL_STATIC + || layout.latextype != LATEX_ENVIRONMENT + || par->isFirstInSequence())) { + + LyXFont font = getLabelFont(buffer, par); + if (!par->getLabelstring().empty()) { + float x = p.x; + string const str = par->getLabelstring(); - y_top += lyxfont::ascent('x',getFont(bview->buffer(), - row_ptr->par(), 0)); - } - - // should we print a label? - if (layout.labeltype >= LABEL_STATIC - && (layout.labeltype != LABEL_STATIC - || layout.latextype != LATEX_ENVIRONMENT - || row_ptr->par()->isFirstInSequence())) { - font = getFont(bview->buffer(), row_ptr->par(), -2); - if (!row_ptr->par()->getLabelstring().empty()) { - tmpx = x; - string const tmpstring = - row_ptr->par()->getLabelstring(); - - if (layout.labeltype == LABEL_COUNTER_CHAPTER) { - 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()->params().spacing().isDefault()) { - spacing_val = row_ptr->par()->params().spacing().getValue(); - } else { - 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 = ww - leftMargin(bview, row_ptr) - - lyxfont::width(tmpstring, font); - pain.text(int(tmpx), - y_offset + row_ptr->baseline() - row_ptr->ascent_of_text() - maxdesc, - tmpstring, font); - } - } else { - if (is_rtl) { - tmpx = ww - leftMargin(bview, row_ptr) - + lyxfont::width(layout.labelsep, font); - } else - tmpx = x - lyxfont::width(layout.labelsep, font) - - lyxfont::width(tmpstring, font); - - // draw it! - pain.text(int(tmpx), - y_offset + row_ptr->baseline(), - tmpstring, font); - } - } - // 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(bview->buffer(), - row_ptr->par(), -2); - if (!row_ptr->par()->getLabelstring().empty()) { - string const tmpstring = - row_ptr->par()->getLabelstring(); + // this is special code for the chapter layout. This is + // printed in an extra row and has a pagebreak at + // the top. + if (layout.labeltype == LABEL_COUNTER_CHAPTER) { + if (buffer->params.secnumdepth >= 0) { float spacing_val = 1.0; - if (!row_ptr->par()->params().spacing().isDefault()) { - spacing_val = row_ptr->par()->params().spacing().getValue(); + if (!parparams.spacing().isDefault()) { + spacing_val = parparams.spacing().getValue(); } else { - spacing_val = bview->buffer()->params.spacing.getValue(); + spacing_val = buffer->params.spacing.getValue(); } - - maxdesc = int(lyxfont::maxDescent(font) * layout.spacing.getValue() * spacing_val - + (layout.labelbottomsep * defaultHeight())); - - tmpx = x; - if (layout.labeltype == LABEL_CENTERED_TOP_ENVIRONMENT){ - 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 = ww - leftMargin(bview, row_ptr) - - lyxfont::width(tmpstring, font); - pain.text(int(tmpx), - y_offset + row_ptr->baseline() - - row_ptr->ascent_of_text() - - maxdesc, - tmpstring, font); + + int const maxdesc = + int(lyxfont::maxDescent(font) * layout.spacing.getValue() * spacing_val) + + int(layout.parsep) * defaultHeight(); + + if (is_rtl) { + x = ww - leftMargin(p.bv, p.row) - + lyxfont::width(str, font); + } + + p.pain->text(int(x), + p.yo + p.row->baseline() - + p.row->ascent_of_text() - maxdesc, + str, font); + } + } else { + if (is_rtl) { + x = ww - leftMargin(p.bv, p.row) + + lyxfont::width(layout.labelsep, font); + } else { + x = p.x - lyxfont::width(layout.labelsep, font) + - lyxfont::width(str, font); } + + p.pain->text(int(x), p.yo + p.row->baseline(), str, font); } } - if (layout.labeltype == LABEL_BIBLIO && row_ptr->par()->bibkey) { - font = getFont(bview->buffer(), row_ptr->par(), -1); - if (is_rtl) - tmpx = ww - leftMargin(bview, row_ptr) - + lyxfont::width(layout.labelsep, font); - else - tmpx = x - lyxfont::width(layout.labelsep, font) - - row_ptr->par()->bibkey->width(bview, font); - row_ptr->par()->bibkey->draw(bview, font, - y_offset + row_ptr->baseline(), - tmpx, clear_area); + // the labels at the top of an environment. + // More or less for bibliography + } else if (par->isFirstInSequence() && + (layout.labeltype == LABEL_TOP_ENVIRONMENT || + layout.labeltype == LABEL_BIBLIO || + layout.labeltype == LABEL_CENTERED_TOP_ENVIRONMENT)) { + LyXFont font = getLabelFont(buffer, par); + if (!par->getLabelstring().empty()) { + string const str = par->getLabelstring(); + float spacing_val = 1.0; + if (!parparams.spacing().isDefault()) { + spacing_val = parparams.spacing().getValue(); + } else { + spacing_val = buffer->params.spacing.getValue(); + } + + int maxdesc = + int(lyxfont::maxDescent(font) * layout.spacing.getValue() * spacing_val + + (layout.labelbottomsep * defaultHeight())); + + float x = p.x; + if (layout.labeltype == LABEL_CENTERED_TOP_ENVIRONMENT) { + x = ((is_rtl ? leftMargin(p.bv, p.row) : p.x) + + ww - rightMargin(buffer, p.row)) / 2; + x -= lyxfont::width(str, font) / 2; + } else if (is_rtl) { + x = ww - leftMargin(p.bv, p.row) - + lyxfont::width(str, font); + } + p.pain->text(int(x), p.yo + p.row->baseline() + - p.row->ascent_of_text() - maxdesc, + str, font); + } + } + + if (layout.labeltype == LABEL_BIBLIO && par->bibkey) { + LyXFont font = getLayoutFont(buffer, par); + float x; + if (is_rtl) { + x = ww - leftMargin(p.bv, p.row) + + lyxfont::width(layout.labelsep, font); + } else { + x = p.x - lyxfont::width(layout.labelsep, font) + - par->bibkey->width(p.bv, font); } + par->bibkey->draw(p.bv, font, p.yo + p.row->baseline(), x, p.cleared); } +} - // is it a last row? - Paragraph * par = row_ptr->par(); - if (row_ptr->par() == par - && (!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->params().pagebreakBottom()) { - LyXFont pb_font; - pb_font.setColor(LColor::pagebreak).decSize(); - 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); - lyxfont::rectText(_("Page Break (bottom)"), pb_font, - w, a, d); - pain.rectText((ww - w) / 2, y_place + d, - _("Page Break (bottom)"), - pb_font, - backgroundColor(), - backgroundColor()); - 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, y_offset + y_bottom - 2, - LYX_PAPER_MARGIN, - y_offset + y_bottom - 2, - LColor::vfillline); - pain.line(LYX_PAPER_MARGIN / 2, - y_place, - LYX_PAPER_MARGIN / 2, - y_offset + y_bottom - 2, - LColor::vfillline); - y_bottom -= 3 * defaultHeight(); - } - - // think about user added space - y_bottom -= int(firstpar->params().spaceBottom().inPixels(bview)); - - if (firstpar->params().lineBottom()) { - // draw a bottom line - y_bottom -= lyxfont::ascent('x', - getFont(bview->buffer(), - par, - par->size() - 1)); - 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(bview->buffer(), - par, - par->size() - 1)); - } - - // draw an endlabel - 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 - : ww - LYX_PAPER_MARGIN - size; - - 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); - pain.line(x + size, y, x + size , y + size, - LColor::eolmarker); - pain.line(x, y, x + size, y, - LColor::eolmarker); - pain.line(x, y + size, x + size, y + size, - LColor::eolmarker); - } 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; - } + +void LyXText::paintLastRow(DrawRowParams & p) +{ + Paragraph * par = p.row->par(); + ParagraphParameters const & parparams = par->params(); + int y_bottom = p.row->height() - 1; + + // think about the margins + if (!p.row->next() && bv_owner) + y_bottom -= LYX_PAPER_MARGIN; + + int const ww = p.bv->workWidth(); + + // draw a bottom pagebreak + if (parparams.pagebreakBottom()) { + LyXFont pb_font; + pb_font.setColor(LColor::pagebreak).decSize(); + int const y = p.yo + y_bottom - 2 * defaultHeight(); + + p.pain->line(p.xo, y, p.xo + p.width, y, LColor::pagebreak, + Painter::line_onoffdash); + + int w = 0; + int a = 0; + int d = 0; + lyxfont::rectText(_("Page Break (bottom)"), pb_font, w, a, d); + p.pain->rectText((ww - w) / 2, y + d, + _("Page Break (bottom)"), + pb_font, backgroundColor(), backgroundColor()); + + y_bottom -= 3 * defaultHeight(); } - // draw the text in the pixmap + // draw the additional space if needed: + int const height = getLengthMarkerHeight(p.bv, + parparams.spaceBottom()); + y_bottom -= drawLengthMarker(p, _("Space below"), + parparams.spaceBottom(), + p.yo + y_bottom - height); - vpos = row_ptr->pos(); + Buffer const * buffer = p.bv->buffer(); + + // draw a bottom line + if (parparams.lineBottom()) { + LyXFont font(LyXFont::ALL_SANE); + int const asc = lyxfont::ascent('x', + getFont(buffer, par, + max(pos_type(0), par->size() - 1))); + + y_bottom -= asc; + + int const w = (inset_owner ? inset_owner->width(p.bv, font) : ww); + int const xp = static_cast(inset_owner ? p.xo : 0); + int const y = p.yo + y_bottom; + p.pain->line(xp, y, xp + w, y, LColor::topline, Painter::line_solid, + Painter::line_thick); + + y_bottom -= asc; + } + + bool const is_rtl = p.row->par()->isRightToLeftPar(p.bv->buffer()->params); + int const endlabel = par->getEndLabel(buffer->params); + + // draw an endlabel + switch (endlabel) { + case END_LABEL_BOX: + case END_LABEL_FILLED_BOX: + { + LyXFont const font = getLabelFont(buffer, par); + int const size = int(0.75 * lyxfont::maxAscent(font)); + int const y = (p.yo + p.row->baseline()) - size; + int x = is_rtl ? LYX_PAPER_MARGIN : ww - LYX_PAPER_MARGIN - size; + + if (p.row->fill() <= size) + x += (size - p.row->fill() + 1) * (is_rtl ? -1 : 1); + + if (endlabel == END_LABEL_BOX) { + p.pain->rectangle(x, y, size, size, LColor::eolmarker); + } else { + p.pain->fillRectangle(x, y, size, size, + LColor::eolmarker); + } + break; + } + case END_LABEL_STATIC: + { + LyXFont font(LyXFont::ALL_SANE); + string const & layout = par->layout(); + string const str = textclasslist[buffer->params.textclass][layout].endlabelstring(); + font = getLabelFont(buffer, par); + int const x = is_rtl ? + int(p.x) - lyxfont::width(str, font) + : ww - rightMargin(buffer, p.row) - p.row->fill(); + p.pain->text(x, p.yo + p.row->baseline(), str, font); + break; + } + case END_LABEL_NO_LABEL: + break; + } +} - Paragraph::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))) +void LyXText::paintRowText(DrawRowParams & p) +{ + Paragraph * par = p.row->par(); + Buffer const * buffer = p.bv->buffer(); + + pos_type const last = rowLastPrintable(p.row); + pos_type main_body = + beginningOfMainBody(buffer, par); + if (main_body > 0 && + (main_body - 1 > last || + !par->isLineSeparator(main_body - 1))) { main_body = 0; + } - while (vpos <= last) { - pos = vis2log(vpos); + LyXLayout const & layout = + textclasslist[buffer->params.textclass][par->layout()]; + + pos_type vpos = p.row->pos(); + while (vpos <= last) { + pos_type 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); + int const lwidth = lyxfont::width(layout.labelsep, + getLabelFont(buffer, par)); + + p.x += p.label_hfill + lwidth + - singleWidth(p.bv, 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 (par->isHfill(pos)) { + p.x += 1; + + int const y0 = p.yo + p.row->baseline(); + int const y1 = y0 - defaultHeight() / 2; + + p.pain->line(int(p.x), y1, int(p.x), y0, + LColor::added_space); - if (hfillExpansion(bview->buffer(), - row_ptr, pos)) { + if (hfillExpansion(buffer, p.row, pos)) { + int const y2 = (y0 + y1) / 2; + if (pos >= main_body) { - pain.line(int(x), - y_offset + row_ptr->baseline() - defaultHeight() / 4, - int(x + fill_hfill), - y_offset + row_ptr->baseline() - defaultHeight() / 4, - LColor::vfillline, + p.pain->line(int(p.x), y2, + int(p.x + p.hfill), y2, + LColor::added_space, Painter::line_onoffdash); - x += fill_hfill; + p.x += p.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, + p.pain->line(int(p.x), y2, + int(p.x + p.label_hfill), y2, + LColor::added_space, Painter::line_onoffdash); - - x += fill_label_hfill; + p.x += p.label_hfill; } - pain.line(int(x), - y_offset + row_ptr->baseline() - defaultHeight() / 2, - int(x), - y_offset + row_ptr->baseline(), - LColor::vfillline); + p.pain->line(int(p.x), y1, + int(p.x), y0, + LColor::added_space); } - x += 2; + p.x += 2; ++vpos; - } else if (row_ptr->par()->isSeparator(pos)) { - x += singleWidth(bview, - row_ptr->par(), pos); + } else if (par->isSeparator(pos)) { + p.x += singleWidth(p.bv, par, pos); if (pos >= main_body) - x += fill_separator; + p.x += p.separator; ++vpos; - } else - draw(bview, row_ptr, vpos, y_offset, x, clear_area); + } else { + draw(p, vpos); + } } } +void LyXText::getVisibleRow(BufferView * bv, int y_offset, int x_offset, + Row * row, int y, bool cleared) +{ + if (row->height() <= 0) { + lyxerr << "LYX_ERROR: row.height: " + << row->height() << endl; + return; + } + + DrawRowParams p; + + // set up drawing parameters + p.bv = bv; + p.pain = &bv->painter(); + p.row = row; + p.xo = x_offset; + p.yo = y_offset; + prepareToPrint(bv, row, p.x, p.separator, p.hfill, p.label_hfill); + if (inset_owner && (p.x < 0)) + p.x = 0; + p.x += p.xo; + p.y = y; + p.width = inset_owner ? inset_owner->textWidth(bv, true) : bv->workWidth(); + p.cleared = cleared; + + // start painting + + // clear to background if necessary + p.cleared = paintRowBackground(p); + + // paint the selection background + if (selection.set()) { + paintRowSelection(p); + } + + // vertical lines for appendix + paintRowAppendix(p); + + // environment depth brackets + paintRowDepthBar(p); + + // draw any stuff wanted for a first row of a paragraph + if (!row->pos()) { + paintFirstRow(p); + } + + // draw any stuff wanted for the last row of a paragraph + if (!row->next() || (row->next()->par() != row->par())) { + paintLastRow(p); + } + + // paint text + paintRowText(p); +} + + int LyXText::defaultHeight() const { LyXFont font(LyXFont::ALL_SANE); @@ -3554,8 +3697,9 @@ 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(BufferView * bview, Row * row, int & x, - bool & boundary) const +pos_type +LyXText::getColumnNearX(BufferView * bview, Row * row, int & x, + bool & boundary) const { float tmpx = 0.0; float fill_separator; @@ -3565,16 +3709,15 @@ int LyXText::getColumnNearX(BufferView * bview, Row * row, int & x, prepareToPrint(bview, row, tmpx, fill_separator, fill_hfill, fill_label_hfill); - Paragraph::size_type vc = row->pos(); - Paragraph::size_type last = rowLastPrintable(row); - Paragraph::size_type c = 0; + pos_type vc = row->pos(); + pos_type last = rowLastPrintable(row); + pos_type c = 0; LyXLayout const & layout = - textclasslist.Style(bview->buffer()->params.textclass, - row->par()->getLayout()); + textclasslist[bview->buffer()->params.textclass][ + row->par()->layout()]; bool left_side = false; - Paragraph::size_type - main_body = beginningOfMainBody(bview->buffer(), row->par()); + pos_type main_body = beginningOfMainBody(bview->buffer(), row->par()); float last_tmpx = tmpx; if (main_body > 0 && @@ -3588,7 +3731,7 @@ int LyXText::getColumnNearX(BufferView * bview, Row * row, int & x, if (main_body > 0 && c == main_body-1) { tmpx += fill_label_hfill + lyxfont::width(layout.labelsep, - getFont(bview->buffer(), row->par(), -2)); + getLabelFont(bview->buffer(), row->par())); if (row->par()->isLineSeparator(main_body - 1)) tmpx -= singleWidth(bview, row->par(), main_body-1); } @@ -3629,8 +3772,8 @@ int LyXText::getColumnNearX(BufferView * bview, Row * row, int & x, 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) )) + ((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); @@ -3658,11 +3801,10 @@ int LyXText::getColumnNearX(BufferView * bview, Row * row, int & x, x = int(tmpx); return c; } - + // returns pointer to a specified row -Row * LyXText::getRow(Paragraph * par, - Paragraph::size_type pos, int & y) const +Row * LyXText::getRow(Paragraph * par, pos_type pos, int & y) const { if (!firstrow) return 0; @@ -3687,3 +3829,72 @@ Row * LyXText::getRow(Paragraph * par, return tmprow; } + + +Row * LyXText::getRowNearY(int & y) const +{ +#if 1 + // If possible we should optimize this method. (Lgb) + Row * tmprow = firstrow; + int tmpy = 0; + + while (tmprow->next() && tmpy + tmprow->height() <= y) { + tmpy += tmprow->height(); + tmprow = tmprow->next(); + } + + y = tmpy; // return the real y + + //lyxerr << "returned y = " << y << endl; + + return tmprow; +#else + // Search from the current cursor position. + + Row * tmprow = cursor.row(); + int tmpy = cursor.y() - tmprow->baseline(); + + lyxerr << "cursor.y() = " << tmpy << endl; + lyxerr << "tmprow->height() = " << tmprow->height() << endl; + lyxerr << "tmprow->baseline() = " << tmprow->baseline() << endl; + lyxerr << "first = " << first << endl; + lyxerr << "y = " << y << endl; + + if (y < tmpy) { + lyxerr << "up" << endl; +#if 0 + while (tmprow && tmpy - tmprow->height() >= y) { + tmpy -= tmprow->height(); + tmprow = tmprow->previous(); + } +#else + do { + tmpy -= tmprow->height(); + tmprow = tmprow->previous(); + } while (tmprow && tmpy - tmprow->height() >= y); +#endif + } else if (y > tmpy) { + lyxerr << "down" << endl; + + while (tmprow->next() && tmpy + tmprow->height() <= y) { + tmpy += tmprow->height(); + tmprow = tmprow->next(); + } + } else { + lyxerr << "equal" << endl; + } + + y = tmpy; // return the real y + + lyxerr << "returned y = " << y << endl; + + return tmprow; + +#endif +} + + +int LyXText::getDepth() const +{ + return cursor.par()->getDepth(); +}