X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Ftext.C;h=f4da5dd0b847fee8702d772a1c9c17ff3f022c79;hb=5702f22ef0ea3d167fc5f327002d7006eef657b4;hp=f219950b13eb7c2bdc107cb72fa07ff1bbdb2eb9;hpb=9d0ba3ddf295225939fcb04ffc11d6de509abdc8;p=lyx.git diff --git a/src/text.C b/src/text.C index f219950b13..f4da5dd0b8 100644 --- a/src/text.C +++ b/src/text.C @@ -9,19 +9,11 @@ * ====================================================== */ #include -//#include //these two do not seem useful anymore (JMarc) -//#include -#include #include "lyxtext.h" +#include "lyxrow.h" #include "layout.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" @@ -41,10 +33,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 { @@ -66,14 +68,12 @@ int LyXText::workWidth(BufferView * bview) const int LyXText::workWidth(BufferView * bview, Inset * inset) const { - Buffer::inset_iterator it; Paragraph * par = 0; - Paragraph::size_type pos = 0; + pos_type pos = 0; - for(it=bview->buffer()->inset_iterator_begin(); - it != bview->buffer()->inset_iterator_end(); - ++it) - { + Buffer::inset_iterator it = bview->buffer()->inset_iterator_begin(); + + for (; it != bview->buffer()->inset_iterator_end(); ++it) { if (*it == inset) { par = it.getPar(); pos = it.getPos(); @@ -100,10 +100,10 @@ int LyXText::workWidth(BufferView * bview, Inset * inset) const int dummy_y; Row * row = getRow(par, pos, dummy_y); Row * frow = row; - while(frow->previous() && frow->par() == frow->previous()->par()) + while (frow->previous() && frow->par() == frow->previous()->par()) frow = frow->previous(); - int maxw = 0; - while(frow->next() && frow->par() == frow->next()->par()) { + unsigned int maxw = 0; + while (frow->next() && frow->par() == frow->next()->par()) { if ((frow != row) && (maxw < frow->width())) maxw = frow->width(); frow = frow->next(); @@ -125,7 +125,7 @@ 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)) @@ -136,7 +136,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; @@ -181,7 +181,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); @@ -189,7 +189,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); @@ -215,7 +215,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); @@ -231,20 +234,18 @@ 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) - return row->par()->size() - 1; - else if (row->next()->par() != row->par()) + if (!row->next() || row->next()->par() != row->par()) return row->par()->size() - 1; 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() @@ -272,8 +273,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); @@ -284,19 +285,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)) @@ -347,8 +347,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; @@ -360,15 +359,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; @@ -379,7 +378,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; @@ -399,8 +398,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 @@ -412,213 +410,243 @@ 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); - } 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); - } - x += wid; + // 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); + } + setCursor(p.bv, cursor.par(), cursor.pos()); + need_break_row = p.row; + } +} - 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); - if (!need_break_row && !inset_owner && - bview->text->status() == CHANGED_IN_DRAW) - { - if (row->previous() && row->previous()->par() == row->par()) - breakAgainOneRow(bview, row->previous()); - setCursor(bview, cursor.par(), cursor.pos()); - need_break_row = const_cast(row); +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; } + 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() != latex_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) || @@ -626,17 +654,6 @@ void LyXText::draw(BufferView * bview, Row const * row, lyxerr << "No this shouldn't happen!\n"; #endif #endif - if (lyxrc.mark_foreign_language && - font.language() != latex_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? } @@ -883,7 +900,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(); @@ -891,20 +908,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; + pos_type i = pos; if (layout.margintype == MARGIN_RIGHT_ADDRESS_BOX) { /* special code for right address boxes, only newlines count */ @@ -913,15 +929,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); @@ -1004,7 +1020,7 @@ int LyXText::fill(BufferView * bview, Row * row, int paper_width) const 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, @@ -1020,9 +1036,9 @@ int LyXText::fill(BufferView * bview, Row * row, int paper_width) const LyXLayout const & layout = textclasslist.Style(bview->buffer()->params.textclass, row->par()->getLayout()); - Paragraph::size_type const main_body = + 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) { @@ -1046,13 +1062,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; } @@ -1060,7 +1069,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. @@ -1076,7 +1085,7 @@ int LyXText::labelFill(BufferView * bview, Row const * row) const --last; int w = 0; - Paragraph::size_type i = row->pos(); + pos_type i = row->pos(); while (i <= last) { w += singleWidth(bview, row->par(), i); ++i; @@ -1097,9 +1106,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)) { @@ -1115,18 +1123,18 @@ 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 (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; } @@ -1138,18 +1146,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; } @@ -1161,15 +1169,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 @@ -1186,7 +1202,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; @@ -1205,7 +1221,7 @@ LColor::color LyXText::backgroundColor() void LyXText::setHeightOfRow(BufferView * bview, Row * row_ptr) const { - /* get the maximum ascent and the maximum descent */ + /* get the maximum ascent and the maximum descent */ int asc = 0; int desc = 0; float layoutasc = 0; @@ -1214,11 +1230,6 @@ void LyXText::setHeightOfRow(BufferView * bview, Row * row_ptr) const 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 @@ -1257,13 +1268,13 @@ void LyXText::setHeightOfRow(BufferView * bview, Row * row_ptr) const int maxdesc = int(lyxfont::maxDescent(font) * layout.spacing.getValue() * spacing_val); - Paragraph::size_type const pos_end = rowLast(row_ptr); + pos_type const pos_end = rowLast(row_ptr); int labeladdon = 0; int maxwidth = 0; // Check if any insets are larger - for (Paragraph::size_type pos = row_ptr->pos(); pos <= pos_end; ++pos) { - if (row_ptr->par()->getChar(pos) == Paragraph::META_INSET) { + 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) { @@ -1331,9 +1342,8 @@ void LyXText::setHeightOfRow(BufferView * bview, Row * row_ptr) const maxasc += LYX_PAPER_MARGIN; // add the vertical spaces, that the user added - if (firstpar->params().spaceTop().kind() != VSpace::NONE) - maxasc += int(firstpar->params().spaceTop().inPixels(bview)); - + 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()) @@ -1445,8 +1455,7 @@ void LyXText::setHeightOfRow(BufferView * bview, Row * row_ptr) const 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)); + maxdesc += getLengthMarkerHeight(bview, firstpar->params().spaceBottom()); // do not forget the DTP-lines! // there height depends on the font of the nearest character @@ -1454,7 +1463,7 @@ void LyXText::setHeightOfRow(BufferView * bview, Row * row_ptr) const maxdesc += 2 * lyxfont::ascent('x', getFont(bview->buffer(), par, - max(Paragraph::size_type(0), par->size() - 1))); + max(pos_type(0), par->size() - 1))); // and now the pagebreaks if (firstpar->params().pagebreakBottom()) @@ -1515,7 +1524,7 @@ void LyXText::setHeightOfRow(BufferView * bview, Row * row_ptr) const if (inset_owner) { Row * r = firstrow; width = max(0,workWidth(bview)); - while(r) { + while (r) { if (r->width() > width) width = r->width(); r = r->next(); @@ -1528,35 +1537,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) - Paragraph::size_type const lastposition = row->par()->size(); - do { - // Get the next breakpoint - Paragraph::size_type 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); } @@ -1566,7 +1574,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()) { @@ -1610,7 +1618,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()) { @@ -1757,7 +1765,8 @@ void LyXText::insertChar(BufferView * bview, char c) bool const freeSpacing = textclasslist.Style(bview->buffer()->params.textclass, - cursor.row()->par()->getLayout()).free_spacing; + cursor.row()->par()->getLayout()).free_spacing || + cursor.row()->par()->isFreeSpacing(); if (lyxrc.auto_number) { @@ -1827,7 +1836,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); @@ -1869,11 +1878,13 @@ 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(); @@ -1897,7 +1908,7 @@ void LyXText::insertChar(BufferView * bview, char c) || cursor.par()->isNewline(cursor.pos()) || cursor.row()->fill() == -1) && row->previous() && row->previous()->par() == row->par()) { - Paragraph::size_type z = nextBreakPoint(bview, + pos_type z = nextBreakPoint(bview, row->previous(), workWidth(bview)); if (z >= row->pos()) { @@ -2075,7 +2086,7 @@ void LyXText::prepareToPrint(BufferView * bview, // center displayed insets Inset * inset; - if (row->par()->getChar(row->pos()) == Paragraph::META_INSET + if (row->par()->isInset(row->pos()) && (inset=row->par()->getInset(row->pos())) && (inset->display())) // || (inset->scroll() < 0))) align = (inset->lyxCode() == Inset::MATHMACRO_CODE) @@ -2086,7 +2097,7 @@ void LyXText::prepareToPrint(BufferView * bview, 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()->isInset(row->next()->pos()) && row->next()->par()->getInset(row->next()->pos()) && row->next()->par()->getInset(row->next()->pos())->display()) ) @@ -2109,9 +2120,9 @@ void LyXText::prepareToPrint(BufferView * bview, 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 || @@ -2363,26 +2374,18 @@ string const LyXText::selectNextWordToSpellcheck(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); } } @@ -2402,17 +2405,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()); @@ -2523,7 +2519,7 @@ void LyXText::changeRegionCase(BufferView * bview, 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())) { @@ -2566,7 +2562,7 @@ void LyXText::transposeChars(BufferView & bview) 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 @@ -2610,15 +2606,16 @@ 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 = tmpcursor; @@ -2630,7 +2627,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); @@ -2753,7 +2750,7 @@ void LyXText::backspace(BufferView * bview) 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 @@ -2768,7 +2765,7 @@ 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) || @@ -2951,10 +2948,10 @@ bool LyXText::paintRowBackground(DrawRowParams & p) Inset * inset = 0; LyXFont font(LyXFont::ALL_SANE); - Paragraph::size_type const last = rowLastPrintable(p.row); + pos_type const last = rowLastPrintable(p.row); if (!p.bv->screen()->forceClear() && last == p.row->pos() - && isMetaInset(p.row->par(), p.row->pos())) { + && p.row->par()->isInset(p.row->pos())) { inset = p.row->par()->getInset(p.row->pos()); if (inset) { clear_area = inset->doClearArea(); @@ -3064,11 +3061,11 @@ void LyXText::paintRowSelection(DrawRowParams & p) Buffer const * buffer = p.bv->buffer(); Paragraph * par = row->par(); - Paragraph::size_type main_body = beginningOfMainBody(buffer, par); - Paragraph::size_type const last = rowLastPrintable(row); + pos_type main_body = beginningOfMainBody(buffer, par); + pos_type const last = rowLastPrintable(row); - for (Paragraph::size_type vpos = row->pos(); vpos <= last; ++vpos) { - Paragraph::size_type pos = vis2log(vpos); + 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.Style(buffer->params.textclass, @@ -3159,6 +3156,80 @@ void LyXText::paintRowDepthBar(DrawRowParams & p) } } + +int LyXText::getLengthMarkerHeight(BufferView * bv, VSpace const & vsp) const +{ + if (vsp.kind() != VSpace::LENGTH) { + return int(vsp.inPixels(bv)); + } + + int const space_size = int(vsp.inPixels(bv)); + int const arrow_size = 10; + + LyXFont font; + font.decSize(); + int const min_size = 2 * arrow_size + 10 + + lyxfont::maxAscent(font) + + lyxfont::maxDescent(font); + + return std::max(min_size, space_size); +} + + +int LyXText::drawLengthMarker(DrawRowParams & p, string const & prefix, + VSpace const & vsp, int start) +{ + string const str(prefix + + " (" + vsp.asLyXCommand() + ")"); + + int const arrow_size = 10; + + int const size = getLengthMarkerHeight(p.bv, vsp); + + // 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); + + int const end = start + size; + + p.pain->rectText(p.xo + 2 * arrow_size + 5, + start + ((end - start) / 2) + d, + str, font, + backgroundColor(), + backgroundColor()); + + // adding or removing space + bool const added = !(vsp.length().len().value() < 0.0); + + int const leftx = p.xo; + int const midx = leftx + arrow_size; + int const rightx = midx + arrow_size; + + // top arrow + int const ty1 = added ? (start + arrow_size) : start; + int const ty2 = added ? start : (start + arrow_size); + + p.pain->line(leftx, ty1, midx, ty2, LColor::added_space); + p.pain->line(midx, ty2, rightx, ty1, LColor::added_space); + + // bottom arrow + int const by1 = added ? (end - arrow_size) : end; + int const by2 = added ? end : (end - arrow_size); + + 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) { @@ -3171,7 +3242,7 @@ void LyXText::paintFirstRow(DrawRowParams & p) } int y_top = 0; - + // think about the margins if (!p.row->previous() && bv_owner) y_top += LYX_PAPER_MARGIN; @@ -3179,7 +3250,8 @@ void LyXText::paintFirstRow(DrawRowParams & p) // draw a top pagebreak if (parparams.pagebreakTop()) { int const y = p.yo + y_top + 2*defaultHeight(); - p.pain->line(0, y, p.width, y, LColor::pagebreak, Painter::line_onoffdash); + p.pain->line(p.xo, y, p.xo + p.width, y, + LColor::pagebreak, Painter::line_onoffdash); int w = 0; int a = 0; @@ -3200,20 +3272,23 @@ void LyXText::paintFirstRow(DrawRowParams & p) int const y1 = p.yo + y_top + 3 * defaultHeight(); int const y2 = p.yo + 2 + y_top; - p.pain->line(0, y1, LYX_PAPER_MARGIN, y1, LColor::vfillline); + p.pain->line(0, y1, LYX_PAPER_MARGIN, y1, LColor::added_space); - p.pain->line(0, y2, LYX_PAPER_MARGIN, y2, LColor::vfillline); + p.pain->line(0, y2, LYX_PAPER_MARGIN, y2, LColor::added_space); int const x = LYX_PAPER_MARGIN / 2; - p.pain->line(x, y2, x, y1, LColor::vfillline); + p.pain->line(x, y2, x, y1, LColor::added_space); y_top += 3 * defaultHeight(); + y_top += int(parparams.spaceTop().inPixels(p.bv)); + } else if (parparams.spaceTop().kind() == VSpace::LENGTH) { + y_top += drawLengthMarker(p, _("Space above"), + parparams.spaceTop(), p.yo + y_top); + } else { + y_top += int(parparams.spaceTop().inPixels(p.bv)); } - // think about user added space - y_top += int(parparams.spaceTop().inPixels(p.bv)); - Buffer const * buffer = p.bv->buffer(); LyXLayout const & layout = @@ -3291,7 +3366,7 @@ void LyXText::paintFirstRow(DrawRowParams & p) lyxfont::width(str, font); } - p.pain->text(int(x), p.yo + + p.pain->text(int(x), p.yo + p.row->baseline() - p.row->ascent_of_text() - maxdesc, str, font); @@ -3300,9 +3375,10 @@ void LyXText::paintFirstRow(DrawRowParams & p) if (is_rtl) { x = ww - leftMargin(p.bv, p.row) + lyxfont::width(layout.labelsep, font); - } else + } 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); } @@ -3375,7 +3451,7 @@ void LyXText::paintLastRow(DrawRowParams & p) pb_font.setColor(LColor::pagebreak).decSize(); int const y = p.yo + y_bottom - 2 * defaultHeight(); - p.pain->line(0, y, ww, y, LColor::pagebreak, Painter::line_onoffdash); + p.pain->line(p.xo, y, p.xo + p.width, y, LColor::pagebreak, Painter::line_onoffdash); int w = 0; int a = 0; @@ -3395,16 +3471,22 @@ void LyXText::paintLastRow(DrawRowParams & p) int const y = p.yo + y_bottom - 3 * defaultHeight(); int const y2 = p.yo + y_bottom - 2; - p.pain->line(0, y, x2, y, LColor::vfillline); - p.pain->line(0, y2, x2, y2, LColor::vfillline); - p.pain->line(x, y, x, y2, LColor::vfillline); + p.pain->line(0, y, x2, y, LColor::added_space); + p.pain->line(0, y2, x2, y2, LColor::added_space); + p.pain->line(x, y, x, y2, LColor::added_space); y_bottom -= 3 * defaultHeight(); + y_bottom -= int(parparams.spaceBottom().inPixels(p.bv)); + } else if (parparams.spaceBottom().kind() == VSpace::LENGTH) { + int const height = getLengthMarkerHeight(p.bv, parparams.spaceBottom()); + y_bottom -= drawLengthMarker(p, _("Space below"), + parparams.spaceBottom(), + p.yo + y_bottom - height); + + } else { + y_bottom -= int(parparams.spaceBottom().inPixels(p.bv)); } - // think about user added space - y_bottom -= int(parparams.spaceBottom().inPixels(p.bv)); - Buffer const * buffer = p.bv->buffer(); // draw a bottom line @@ -3412,7 +3494,7 @@ void LyXText::paintLastRow(DrawRowParams & p) LyXFont font(LyXFont::ALL_SANE); int const asc = lyxfont::ascent('x', getFont(buffer, par, - max(Paragraph::size_type(0), par->size() - 1))); + max(pos_type(0), par->size() - 1))); y_bottom -= asc; @@ -3425,7 +3507,7 @@ void LyXText::paintLastRow(DrawRowParams & p) y_bottom -= asc; } - Paragraph::size_type const last = rowLastPrintable(p.row); + pos_type const last = rowLastPrintable(p.row); bool const is_rtl = p.row->par()->isRightToLeftPar(p.bv->buffer()->params); int const endlabel = par->getEndLabel(buffer->params); @@ -3475,8 +3557,8 @@ void LyXText::paintRowText(DrawRowParams & p) Paragraph * par = p.row->par(); Buffer const * buffer = p.bv->buffer(); - Paragraph::size_type const last = rowLastPrintable(p.row); - Paragraph::size_type main_body = + pos_type const last = rowLastPrintable(p.row); + pos_type main_body = beginningOfMainBody(buffer, par); if (main_body > 0 && (main_body - 1 > last || @@ -3487,9 +3569,9 @@ void LyXText::paintRowText(DrawRowParams & p) LyXLayout const & layout = textclasslist.Style(buffer->params.textclass, par->getLayout()); - Paragraph::size_type vpos = p.row->pos(); + pos_type vpos = p.row->pos(); while (vpos <= last) { - Paragraph::size_type pos = vis2log(vpos); + pos_type pos = vis2log(vpos); if (main_body > 0 && pos == main_body - 1) { int const lwidth = lyxfont::width(layout.labelsep, getLabelFont(buffer, par)); @@ -3501,30 +3583,31 @@ void LyXText::paintRowText(DrawRowParams & p) if (par->isHfill(pos)) { p.x += 1; - int const y1 = p.yo + p.row->baseline() - defaultHeight() / 2; - - p.pain->line(int(p.x), y1, int(p.x), p.yo + p.row->baseline(), - LColor::vfillline); + 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); - int const y2 = y1 / 2; - if (hfillExpansion(buffer, p.row, pos)) { + int const y2 = (y0 + y1) / 2; + if (pos >= main_body) { p.pain->line(int(p.x), y2, int(p.x + p.hfill), y2, - LColor::vfillline, + LColor::added_space, Painter::line_onoffdash); p.x += p.hfill; } else { p.pain->line(int(p.x), y2, int(p.x + p.label_hfill), y2, - LColor::vfillline, + LColor::added_space, Painter::line_onoffdash); p.x += p.label_hfill; } p.pain->line(int(p.x), y1, - int(p.x), p.yo + p.row->baseline(), - LColor::vfillline); + int(p.x), y0, + LColor::added_space); } p.x += 2; ++vpos; @@ -3534,7 +3617,7 @@ void LyXText::paintRowText(DrawRowParams & p) p.x += p.separator; ++vpos; } else { - draw(p.bv, p.row, vpos, p.yo, p.x, p.cleared); + draw(p, vpos); } } } @@ -3594,7 +3677,7 @@ void LyXText::getVisibleRow(BufferView * bv, int y_offset, int x_offset, // paint text paintRowText(p); } - + int LyXText::defaultHeight() const { @@ -3605,7 +3688,7 @@ 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 */ -Paragraph::size_type +pos_type LyXText::getColumnNearX(BufferView * bview, Row * row, int & x, bool & boundary) const { @@ -3617,16 +3700,15 @@ 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()); 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 && @@ -3710,11 +3792,10 @@ 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; @@ -3739,3 +3820,25 @@ Row * LyXText::getRow(Paragraph * par, return tmprow; } + + +Row * LyXText::getRowNearY(int & y) const +{ + // 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 + return tmprow; +} + + +int LyXText::getDepth() const +{ + return cursor.par()->getDepth(); +}