X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Ftext.C;h=46259d4d8b7b5f20dc52bf6fc9ba559670616bea;hb=2523638092e2024bac408eee98ad2094bc4e4089;hp=8e5d3ea8d41b499d9aa5ee4cda39c7b44b7810fd;hpb=fcb37cc69357d839ede582145c0538886d040e70;p=lyx.git diff --git a/src/text.C b/src/text.C index 8e5d3ea8d4..46259d4d8b 100644 --- a/src/text.C +++ b/src/text.C @@ -1,8 +1,8 @@ /* This file is part of - * ====================================================== - * + * ====================================================== + * * LyX, The Document Processor - * + * * Copyright 1995 Matthias Ettrich * Copyright 1995-2001 The LyX Team. * @@ -12,26 +12,26 @@ #include "lyxtext.h" #include "lyxrow.h" -#include "layout.h" #include "paragraph.h" -#include "lyx_gui_misc.h" #include "gettext.h" #include "bufferparams.h" #include "buffer.h" #include "debug.h" +#include "intl.h" #include "lyxrc.h" -#include "LyXView.h" -#include "Painter.h" -#include "tracer.h" -#include "font.h" #include "encoding.h" -#include "lyxscreen.h" +#include "frontends/LyXView.h" +#include "frontends/Painter.h" +#include "frontends/font_metrics.h" +#include "frontends/screen.h" +#include "frontends/WorkArea.h" #include "bufferview_funcs.h" #include "BufferView.h" #include "language.h" #include "ParagraphParameters.h" #include "undo_funcs.h" -#include "font.h" +#include "WordLangTuple.h" +#include "paragraph_funcs.h" #include "insets/insetbib.h" #include "insets/insettext.h" @@ -69,26 +69,33 @@ int LyXText::workWidth(BufferView * bview) const int LyXText::workWidth(BufferView * bview, Inset * inset) const { Paragraph * par = 0; - pos_type pos = 0; - - 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(); - break; + 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.Style(bview->buffer()->params.textclass, - par->getLayout()); - if (layout.margintype != MARGIN_RIGHT_ADDRESS_BOX) { + LyXLayout_ptr const & layout = 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) @@ -100,10 +107,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(); unsigned int maxw = 0; - while(frow->next() && frow->par() == frow->next()->par()) { + while (frow->next() && frow->par() == frow->next()->par()) { if ((frow != row) && (maxw < frow->width())) maxw = frow->width(); frow = frow->next(); @@ -128,7 +135,7 @@ unsigned char LyXText::transformChar(unsigned char c, Paragraph * par, 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; @@ -143,12 +150,14 @@ unsigned char LyXText::transformChar(unsigned char c, Paragraph * par, } if (Encodings::is_arabic(next_char)) { - if (Encodings::is_arabic(prev_char)) + if (Encodings::is_arabic(prev_char) && + !Encodings::is_arabic_special(prev_char)) return Encodings::TransformChar(c, Encodings::FORM_MEDIAL); else return Encodings::TransformChar(c, Encodings::FORM_INITIAL); } else { - if (Encodings::is_arabic(prev_char)) + if (Encodings::is_arabic(prev_char) && + !Encodings::is_arabic_special(prev_char)) return Encodings::TransformChar(c, Encodings::FORM_FINAL); else return Encodings::TransformChar(c, Encodings::FORM_ISOLATED); @@ -189,7 +198,7 @@ int LyXText::singleWidth(BufferView * bview, Paragraph * par, int LyXText::singleWidth(BufferView * bview, Paragraph * par, - pos_type pos, char c) const + pos_type pos, char c) const { LyXFont const font = getFont(bview->buffer(), par, pos); @@ -207,15 +216,18 @@ int LyXText::singleWidth(BufferView * bview, Paragraph * par, Encodings::IsComposeChar_hebrew(c)) return 0; } - return lyxfont::width(c, font); + return font_metrics::width(c, font); } else if (IsHfillChar(c)) { - return 3; /* Because of the representation - * as vertical lines */ + // Because of the representation as vertical lines + return 3; } 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); @@ -226,29 +238,39 @@ int LyXText::singleWidth(BufferView * bview, Paragraph * par, c = ' '; else if (IsNewlineChar(c)) c = 'n'; - return lyxfont::width(c, font); + return font_metrics::width(c, font); } // Returns the paragraph position of the last character in the specified row 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 + } else { return row->next()->pos() - 1; + } } pos_type LyXText::rowLastPrintable(Row const * row) const { pos_type const last = rowLast(row); + bool ignore_the_space_on_the_last_position = true; + Inset * ins; + // we have to consider a space on the last position in this case! + if (row->next() && row->par() == row->next()->par() && + row->next()->par()->getChar(last+1) == Paragraph::META_INSET && + (ins=row->next()->par()->getInset(last+1)) && + (ins->needFullRow() || ins->display())) + { + ignore_the_space_on_the_last_position = false; + } if (last >= row->pos() && row->next() && row->next()->par() == row->par() - && row->par()->isSeparator(last)) + && row->par()->isSeparator(last) + && ignore_the_space_on_the_last_position) return last - 1; else return last; @@ -263,6 +285,13 @@ void LyXText::computeBidiTables(Buffer const * buf, Row * row) const return; } + Inset * inset = row->par()->inInset(); + if (inset && inset->owner() && + inset->owner()->lyxCode() == Inset::ERT_CODE) { + bidi_start = -1; + return; + } + bidi_start = row->pos(); bidi_end = rowLastPrintable(row); @@ -273,7 +302,7 @@ void LyXText::computeBidiTables(Buffer const * buf, Row * row) const if (bidi_end + 2 - bidi_start > static_cast(log2vis_list.size())) { - pos_type new_size = + pos_type new_size = (bidi_end + 2 - bidi_start < 500) ? 500 : 2 * (bidi_end + 2 - bidi_start); log2vis_list.resize(new_size); @@ -286,14 +315,13 @@ void LyXText::computeBidiTables(Buffer const * buf, Row * row) const pos_type stack[2]; bool const rtl_par = - row->par()->getParLanguage(buf->params)->RightToLeft(); + row->par()->isRightToLeftPar(buf->params); int level = 0; bool rtl = false; bool rtl0 = false; pos_type const main_body = beginningOfMainBody(buf, row->par()); - for (pos_type lpos = bidi_start; - lpos <= bidi_end; ++lpos) { + for (pos_type lpos = bidi_start; lpos <= bidi_end; ++lpos) { bool is_space = row->par()->isLineSeparator(lpos); pos_type const pos = (is_space && lpos + 1 <= bidi_end && @@ -410,273 +438,305 @@ bool LyXText::isBoundary(Buffer const * buf, Paragraph * par, } -void LyXText::draw(BufferView * bview, Row const * row, - pos_type & vpos, int offset, float & x, bool cleared) +void LyXText::drawNewline(DrawRowParams & p, pos_type const pos) { - Painter & pain = bview->painter(); - - pos_type pos = vis2log(vpos); - char c = row->par()->getChar(pos); - float tmpx = x; + // Draw end-of-line marker + LyXFont const font = getFont(p.bv->buffer(), p.row->par(), pos); + int const wid = font_metrics::width('n', font); + int const asc = font_metrics::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); + } - 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; - return; + 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); } - LyXFont font = getFont(bview->buffer(), row->par(), pos); - LyXFont font2 = font; + p.pain->lines(xp, yp, 3, LColor::eolmarker); - 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); + p.x += wid; +} + + +bool LyXText::drawInset(DrawRowParams & p, pos_type const pos) +{ + Inset * inset = p.row->par()->getInset(pos); + + // FIXME: shouldn't happen + if (!inset) { + return true; + } + + LyXFont const & font = getFont(p.bv->buffer(), p.row->par(), pos); + // we need this here as the row pointer may be illegal + // at a later time (Jug20020502) + Row * prev = p.row->previous(); + + 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) { + 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 if (!prev) { + need_break_row = firstrow; + } else { + need_break_row = prev->next(); } - ++vpos; + setCursor(p.bv, cursor.par(), cursor.pos()); + return false; + } + return true; +} - 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::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; - } - // usual characters, no insets + int const y = p.yo + p.row->height() - 1; + p.pain->line(int(orig_x), y, int(p.x), y, LColor::language); +} - // Collect character that we can draw in one command - - // 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; - pos_type const last = rowLastPrintable(row); +void LyXText::drawHebrewComposeChar(DrawRowParams & p, pos_type & vpos) +{ + pos_type pos = vis2log(vpos); - if (font.language()->lang() == "hebrew") { - if (Encodings::IsComposeChar_hebrew(c)) { - int const width = lyxfont::width(c, font2); - int dx = 0; - for (pos_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 (pos_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; + 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 = font_metrics::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; } - // Draw text and set the new x position - pain.text(int(x), offset + row->baseline(), - textstring, font); - x += lyxfont::width(textstring, font); + break; } - } 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 nikud + p.pain->text(int(p.x) + dx, p.yo + p.row->baseline(), str, font); +} + + +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 = font_metrics::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 text and set the new x position - pain.text(int(x), offset + row->baseline(), textstring, font); - x += lyxfont::width(textstring, font); } + // Draw nikud + p.pain->text(int(p.x) + dx, p.yo + p.row->baseline(), str, font); +} -#ifdef INHERIT_LANGUAGE -#ifdef WITH_WARNINGS - if ((font.language() == inherit_language) || - (font.language() == ignore_language)) - 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); + +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; + + // 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 we want ulem.sty support, drawing - // routines should go here. (Asger) - // Why shouldn't LyXFont::drawText handle it internally? + if (orig_font != getFont(p.bv->buffer(), p.row->par(), pos)) + break; + + if (arabic) + c = transformChar(c, p.row->par(), pos); + 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 += font_metrics::width(str, orig_font); +} + + +bool LyXText::draw(DrawRowParams & p, pos_type & vpos) +{ + pos_type const pos = vis2log(vpos); + Paragraph * par = p.row->par(); + + LyXFont const & orig_font = getFont(p.bv->buffer(), par, pos); + + float const orig_x = p.x; + + char const c = par->getChar(pos); + + if (IsNewlineChar(c)) { + ++vpos; + drawNewline(p, pos); + return true; + } else if (IsInsetChar(c)) { + if (!drawInset(p, pos)) + return false; + ++vpos; + drawForeignMark(p, orig_x, orig_font); + return true; + } + + // 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, hebrew, arabic); + } else if (hebrew) { + drawHebrewComposeChar(p, vpos); + } else if (arabic) { + drawArabicComposeChar(p, vpos); + } + + drawForeignMark(p, orig_x, orig_font); + + return true; } -// Returns the left beginning of the text. -// This information cannot be taken from the layouts-objekt, because in -// LaTeX the beginning of the text fits in some cases (for example sections) -// exactly the label-width. int LyXText::leftMargin(BufferView * bview, Row const * row) const { + Inset * ins; + if ((row->par()->getChar(row->pos()) == Paragraph::META_INSET) && + (ins=row->par()->getInset(row->pos())) && + (ins->needFullRow() || ins->display())) + return LYX_PAPER_MARGIN; + LyXTextClass const & tclass = - textclasslist.TextClass(bview->buffer()->params.textclass); - LyXLayout const & layout = tclass[row->par()->getLayout()]; - - string parindent = layout.parindent; + bview->buffer()->params.getLyXTextClass(); + LyXLayout_ptr const & layout = row->par()->layout(); + + string parindent = layout->parindent; int x = LYX_PAPER_MARGIN; - - x += lyxfont::signedWidth(tclass.leftmargin(), tclass.defaultfont()); + + x += font_metrics::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.defaultLayout()) { // find the previous same level paragraph if (row->par()->previous()) { Paragraph * newpar = row->par() ->depthHook(row->par()->getDepth()); if (newpar && - tclass[newpar->getLayout()].nextnoindent) + newpar->layout()->nextnoindent) parindent.erase(); } } } else { // find the next level paragraph - - Paragraph * newpar = - row->par()->outerHook(); - + + Paragraph * newpar = row->par()->outerHook(); + // make a corresponding row. Needed to call LeftMargin() - - // check wether it is a sufficent paragraph - if (newpar && tclass[newpar->getLayout()].isEnvironment()) - { + + // check wether it is a sufficent paragraph + if (newpar && newpar->layout()->isEnvironment()) { Row dummyrow; dummyrow.par(newpar); dummyrow.pos(newpar->size()); @@ -688,139 +748,159 @@ 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.defaultLayout()) { if (newpar->params().noindent()) parindent.erase(); - else - parindent = tclass[newpar->getLayout()].parindent; + else { + parindent = newpar->layout()->parindent; + } + } - } - + LyXFont const labelfont = getLabelFont(bview->buffer(), row->par()); - switch (layout.margintype) { + switch (layout->margintype) { case MARGIN_DYNAMIC: - if (!layout.leftmargin.empty()) { - x += lyxfont::signedWidth(layout.leftmargin, + if (!layout->leftmargin.empty()) { + x += font_metrics::signedWidth(layout->leftmargin, tclass.defaultfont()); } if (!row->par()->getLabelstring().empty()) { - x += lyxfont::signedWidth(layout.labelindent, + x += font_metrics::signedWidth(layout->labelindent, labelfont); - x += lyxfont::width(row->par()->getLabelstring(), + x += font_metrics::width(row->par()->getLabelstring(), labelfont); - x += lyxfont::width(layout.labelsep, labelfont); + x += font_metrics::width(layout->labelsep, labelfont); } break; case MARGIN_MANUAL: - x += lyxfont::signedWidth(layout.labelindent, labelfont); + x += font_metrics::signedWidth(layout->labelindent, labelfont); if (row->pos() >= beginningOfMainBody(bview->buffer(), row->par())) { if (!row->par()->getLabelWidthString().empty()) { - x += lyxfont::width(row->par()->getLabelWidthString(), + x += font_metrics::width(row->par()->getLabelWidthString(), labelfont); - x += lyxfont::width(layout.labelsep, labelfont); + x += font_metrics::width(layout->labelsep, labelfont); } } break; case MARGIN_STATIC: - x += lyxfont::signedWidth(layout.leftmargin, tclass.defaultfont()) * 4 + x += font_metrics::signedWidth(layout->leftmargin, tclass.defaultfont()) * 4 / (row->par()->getDepth() + 4); break; case MARGIN_FIRST_DYNAMIC: - if (layout.labeltype == LABEL_MANUAL) { + if (layout->labeltype == LABEL_MANUAL) { if (row->pos() >= beginningOfMainBody(bview->buffer(), row->par())) { - x += lyxfont::signedWidth(layout.leftmargin, + x += font_metrics::signedWidth(layout->leftmargin, labelfont); } else { - x += lyxfont::signedWidth(layout.labelindent, + x += font_metrics::signedWidth(layout->labelindent, labelfont); } } else if (row->pos() // Special case to fix problems with // theorems (JMarc) - || (layout.labeltype == LABEL_STATIC - && layout.latextype == LATEX_ENVIRONMENT + || (layout->labeltype == LABEL_STATIC + && layout->latextype == LATEX_ENVIRONMENT && ! row->par()->isFirstInSequence())) { - x += lyxfont::signedWidth(layout.leftmargin, + x += font_metrics::signedWidth(layout->leftmargin, labelfont); - } else if (layout.labeltype != LABEL_TOP_ENVIRONMENT - && layout.labeltype != LABEL_BIBLIO - && layout.labeltype != + } else if (layout->labeltype != LABEL_TOP_ENVIRONMENT + && layout->labeltype != LABEL_BIBLIO + && layout->labeltype != LABEL_CENTERED_TOP_ENVIRONMENT) { - x += lyxfont::signedWidth(layout.labelindent, + x += font_metrics::signedWidth(layout->labelindent, labelfont); - x += lyxfont::width(layout.labelsep, labelfont); - x += lyxfont::width(row->par()->getLabelstring(), + x += font_metrics::width(layout->labelsep, labelfont); + x += font_metrics::width(row->par()->getLabelstring(), labelfont); - } + } break; - + case MARGIN_RIGHT_ADDRESS_BOX: { // ok, a terrible hack. The left margin depends on the widest // row in this paragraph. Do not care about footnotes, they // are *NOT* allowed in the LaTeX realisation of this layout. - + // find the first row of this paragraph Row const * tmprow = row; while (tmprow->previous() && tmprow->previous()->par() == row->par()) tmprow = tmprow->previous(); - + int minfill = tmprow->fill(); while (tmprow->next() && tmprow->next()->par() == row->par()) { tmprow = tmprow->next(); if (tmprow->fill() < minfill) minfill = tmprow->fill(); } - - x += lyxfont::signedWidth(layout.leftmargin, - tclass.defaultfont()); + + x += font_metrics::signedWidth(layout->leftmargin, + tclass.defaultfont()); x += minfill; } break; } - + + if ((workWidth(bview) > 0) && + !row->par()->params().leftIndent().zero()) + { + LyXLength const len = row->par()->params().leftIndent(); + int const tw = inset_owner ? + inset_owner->latexTextWidth(bview) : workWidth(bview); + x += len.inPixels(tw); + } + LyXAlignment align; // wrong type if (row->par()->params().align() == LYX_ALIGN_LAYOUT) - align = layout.align; + align = layout->align; else align = row->par()->params().align(); // set the correct parindent if (row->pos() == 0) { - if ((layout.labeltype == LABEL_NO_LABEL - || layout.labeltype == LABEL_TOP_ENVIRONMENT - || layout.labeltype == LABEL_CENTERED_TOP_ENVIRONMENT - || (layout.labeltype == LABEL_STATIC - && layout.latextype == LATEX_ENVIRONMENT + if ((layout->labeltype == LABEL_NO_LABEL + || layout->labeltype == LABEL_TOP_ENVIRONMENT + || layout->labeltype == LABEL_CENTERED_TOP_ENVIRONMENT + || (layout->labeltype == LABEL_STATIC + && layout->latextype == LATEX_ENVIRONMENT && ! row->par()->isFirstInSequence())) && 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.defaultLayout() || bview->buffer()->params.paragraph_separation == - BufferParams::PARSEP_INDENT)) - x += lyxfont::signedWidth(parindent, + BufferParams::PARSEP_INDENT)) { + x += font_metrics::signedWidth(parindent, tclass.defaultfont()); - else if (layout.labeltype == LABEL_BIBLIO) { + } else if (layout->labeltype == LABEL_BIBLIO) { // ale970405 Right width for bibitems x += bibitemMaxWidth(bview, tclass.defaultfont()); } } + return x; } int LyXText::rightMargin(Buffer const * buf, Row const * row) const { - LyXTextClass const & tclass = - textclasslist.TextClass(buf->params.textclass); - LyXLayout const & layout = tclass[row->par()->getLayout()]; - + Inset * ins; + if ((row->par()->getChar(row->pos()) == Paragraph::META_INSET) && + (ins=row->par()->getInset(row->pos())) && + (ins->needFullRow() || ins->display())) + return LYX_PAPER_MARGIN; + + LyXTextClass const & tclass = buf->params.getLyXTextClass(); + LyXLayout_ptr const & layout = row->par()->layout(); + int x = LYX_PAPER_MARGIN - + lyxfont::signedWidth(tclass.rightmargin(), + + font_metrics::signedWidth(tclass.rightmargin(), tclass.defaultfont()); // this is the way, LyX handles the LaTeX-Environments. @@ -828,19 +908,18 @@ int LyXText::rightMargin(Buffer const * buf, Row const * row) const // later added hack and this is true if (row->par()->getDepth()) { // find the next level paragraph - + Paragraph * newpar = row->par(); - + do { newpar = newpar->previous(); } while (newpar && newpar->getDepth() >= row->par()->getDepth()); - + // make a corresponding row. Needed to call LeftMargin() - + // check wether it is a sufficent paragraph - if (newpar - && tclass[newpar->getLayout()].isEnvironment()) { + if (newpar && newpar->layout()->isEnvironment()) { Row dummyrow; dummyrow.par(newpar); dummyrow.pos(0); @@ -853,9 +932,10 @@ int LyXText::rightMargin(Buffer const * buf, Row const * row) const row->par()->params().depth(0); } } - + //lyxerr << "rightmargin: " << layout->rightmargin << endl; - x += lyxfont::signedWidth(layout.rightmargin, tclass.defaultfont()) + x += font_metrics::signedWidth(layout->rightmargin, + tclass.defaultfont()) * 4 / (row->par()->getDepth() + 4); return x; } @@ -863,18 +943,17 @@ int LyXText::rightMargin(Buffer const * buf, Row const * row) const int LyXText::labelEnd(BufferView * bview, Row const * row) const { - if (textclasslist.Style(bview->buffer()->params.textclass, - row->par()->getLayout()).margintype - == MARGIN_MANUAL) { + if (row->par()->layout()->margintype == MARGIN_MANUAL) { Row tmprow; tmprow = *row; tmprow.pos(row->par()->size()); - return leftMargin(bview, &tmprow); /* just the beginning - of the main body */ - } else - return 0; /* LabelEnd is only needed, if the - layout fills a flushleft - label. */ + // just the beginning of the main body + return leftMargin(bview, &tmprow); + } else { + // LabelEnd is only needed, + // if the layout fills a flushleft label. + return 0; + } } @@ -889,26 +968,25 @@ LyXText::nextBreakPoint(BufferView * bview, Row const * row, int width) const pos_type const pos = row->pos(); - // position of the last possible breakpoint + // position of the last possible breakpoint // -1 isn't a suitable value, but a flag pos_type last_separator = -1; width -= rightMargin(bview->buffer(), row); - + pos_type const main_body = beginningOfMainBody(bview->buffer(), par); - LyXLayout const & layout = - textclasslist.Style(bview->buffer()->params.textclass, - par->getLayout()); + LyXLayout_ptr const & layout = par->layout(); + pos_type i = pos; - if (layout.margintype == MARGIN_RIGHT_ADDRESS_BOX) { - /* special code for right address boxes, only newlines count */ + if (layout->margintype == MARGIN_RIGHT_ADDRESS_BOX) { + // special code for right address boxes, only newlines count while (i < par->size()) { if (par->isNewline(i)) { last_separator = i; i = par->size() - 1; // this means break //x = width; - } else if (par->isInset(i) && par->getInset(i) + } else if (par->isInset(i) && par->getInset(i) && par->getInset(i)->display()) { par->getInset(i)->display(false); } @@ -916,37 +994,37 @@ LyXText::nextBreakPoint(BufferView * bview, Row const * row, int width) const } } else { // Last position is an invariant - pos_type const last = - par->size(); + pos_type const last = par->size(); // this is the usual handling int x = leftMargin(bview, row); bool doitonetime = true; 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() && - (layout.isCommand() || - (layout.labeltype == LABEL_MANUAL - && i < beginningOfMainBody(bview->buffer(), par)))) { + if (in->display() && + (layout->isCommand() || + (layout->labeltype == LABEL_MANUAL + && 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 @@ -955,15 +1033,25 @@ 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, + x += font_metrics::width(layout->labelsep, getLabelFont(bview->buffer(), par)); if (par->isLineSeparator(i - 1)) x-= singleWidth(bview, par, i - 1); @@ -972,21 +1060,25 @@ 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; } - - // well, if last_separator is still 0, the line isn't breakable. + + // well, if last_separator is still 0, the line isn't breakable. // don't care and cut simply at the end if (last_separator < 0) { last_separator = i; } - + // manual labels cannot be broken in LaTeX, do not care if (main_body && last_separator < main_body) last_separator = main_body - 1; - + return last_separator; } @@ -1000,28 +1092,25 @@ int LyXText::fill(BufferView * bview, Row * row, int paper_width) const int w; // get the pure distance 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 (row->par()->layout()->margintype == MARGIN_RIGHT_ADDRESS_BOX) { int const tmpfill = row->fill(); row->fill(0); // the minfill in MarginLeft() w = leftMargin(bview, row); row->fill(tmpfill); } else w = leftMargin(bview, row); - - LyXLayout const & layout = textclasslist.Style(bview->buffer()->params.textclass, - row->par()->getLayout()); - pos_type const main_body = + + LyXLayout_ptr const & layout = row->par()->layout(); + + pos_type const main_body = beginningOfMainBody(bview->buffer(), row->par()); pos_type i = row->pos(); while (i <= last) { if (main_body > 0 && i == main_body) { - w += lyxfont::width(layout.labelsep, getLabelFont(bview->buffer(), row->par())); + w += font_metrics::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); @@ -1032,22 +1121,15 @@ int LyXText::fill(BufferView * bview, Row * row, int paper_width) const ++i; } if (main_body > 0 && main_body > last) { - w += lyxfont::width(layout.labelsep, getLabelFont(bview->buffer(), row->par())); + w += font_metrics::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); if (w < left_margin) w = left_margin; } - + 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; } @@ -1056,7 +1138,7 @@ int LyXText::fill(BufferView * bview, Row * row, int paper_width) const int LyXText::labelFill(BufferView * bview, Row const * row) const { pos_type last = beginningOfMainBody(bview->buffer(), row->par()) - 1; - // -1 because a label ends either with a space that is in the label, + // -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. // I don't understand this code in depth, but sometimes "last" is @@ -1065,37 +1147,38 @@ int LyXText::labelFill(BufferView * bview, Row const * row) const // triggered when you have an open footnote in a paragraph // environment with a manual label. (Asger) if (last < 0) last = 0; - - if (row->par()->isLineSeparator(last)) /* a sepearator at this end - does not count */ + + // a separator at this end does not count + if (row->par()->isLineSeparator(last)) --last; - + int w = 0; pos_type i = row->pos(); while (i <= last) { w += singleWidth(bview, row->par(), i); ++i; } - + int fill = 0; if (!row->par()->params().labelWidthString().empty()) { - fill = max(lyxfont::width(row->par()->params().labelWidthString(), + fill = max(font_metrics::width(row->par()->params().labelWidthString(), getLabelFont(bview->buffer(), row->par())) - w, 0); } - + return fill; } -// returns the number of separators in the specified row. The separator +// returns the number of separators in the specified row. The separator // on the very last column doesnt count int LyXText::numberOfSeparators(Buffer const * buf, Row const * row) const { - pos_type const last = rowLast(row); + pos_type last = rowLastPrintable(row); pos_type p = max(row->pos(), beginningOfMainBody(buf, row->par())); + int n = 0; - for (; p < last; ++p) { + for (; p <= last; ++p) { if (row->par()->isSeparator(p)) { ++n; } @@ -1105,22 +1188,25 @@ int LyXText::numberOfSeparators(Buffer const * buf, Row const * row) const // returns the number of hfills in the specified row. The LyX-Hfill is -// a LaTeX \hfill so that the hfills at the beginning and at the end were +// a LaTeX \hfill so that the hfills at the beginning and at the end were // ignored. This is *MUCH* more usefull than not to ignore! int LyXText::numberOfHfills(Buffer const * buf, Row const * row) const { 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)) + + if (first) { + // hfill *DO* count at the beginning of paragraphs! + while (first <= last && row->par()->isHfill(first)) { ++first; + } } first = max(first, beginningOfMainBody(buf, row->par())); int n = 0; for (pos_type p = first; p <= last; ++p) { // last, because the end is ignored! + if (row->par()->isHfill(p)) { ++n; } @@ -1134,9 +1220,9 @@ int LyXText::numberOfLabelHfills(Buffer const * buf, Row const * row) const { 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)) + if (first) { + // hfill *DO* count at the beginning of paragraphs! + while (first < last && row->par()->isHfill(first)) ++first; } @@ -1155,28 +1241,34 @@ 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, - pos_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; - - // at the beginning of a row it does not count, if it is not + // 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 if (!row_ptr->pos()) return true; - + // in some labels it does not count - if (textclasslist.Style(buf->params.textclass, - row_ptr->par()->getLayout()).margintype - != MARGIN_MANUAL + if (row_ptr->par()->layout()->margintype != MARGIN_MANUAL && pos < beginningOfMainBody(buf, row_ptr->par())) - return false; - + return false; + // if there is anything between the first char of the row and // the sepcified position that is not a newline and not a hfill, // the hfill will count, otherwise not @@ -1184,7 +1276,7 @@ bool LyXText::hfillExpansion(Buffer const * buf, Row const * row_ptr, while (i < pos && (row_ptr->par()->isNewline(i) || row_ptr->par()->isHfill(i))) ++i; - + return i != pos; } @@ -1199,7 +1291,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; @@ -1208,18 +1300,17 @@ void LyXText::setHeightOfRow(BufferView * bview, Row * row_ptr) const 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 :) */ + // 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()); + + LyXLayout_ptr const & layout = 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 @@ -1239,13 +1330,14 @@ void LyXText::setHeightOfRow(BufferView * bview, Row * row_ptr) const 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 maxasc = int(font_metrics::maxAscent(font) * + layout->spacing.getValue() * + spacing_val); + int maxdesc = int(font_metrics::maxDescent(font) * + layout->spacing.getValue() * + spacing_val); + pos_type const pos_end = rowLast(row_ptr); int labeladdon = 0; int maxwidth = 0; @@ -1278,9 +1370,9 @@ void LyXText::setHeightOfRow(BufferView * bview, Row * row_ptr) const if (maxsize > font.size()) { font.setSize(maxsize); - asc = lyxfont::maxAscent(font); - desc = lyxfont::maxDescent(font); - if (asc > maxasc) + asc = font_metrics::maxAscent(font); + desc = font_metrics::maxDescent(font); + if (asc > maxasc) maxasc = asc; if (desc > maxdesc) maxdesc = desc; @@ -1291,51 +1383,48 @@ void LyXText::setHeightOfRow(BufferView * bview, Row * row_ptr) const ++maxdesc; 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() + 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) + firstpar->previous()->layout()->isParagraph() && + firstpar->previous()->getDepth() == 0) { // is it right to use defskip here too? (AS) maxasc += bview->buffer()->params.getDefSkip().inPixels(bview); } } - + // the paper margins if (!row_ptr->par()->previous() && bv_owner) 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()) - maxasc += 2 * lyxfont::ascent('x', getFont(bview->buffer(), - firstpar, 0)); - + + maxasc += 2 * font_metrics::ascent('x', getFont(bview->buffer(), + firstpar, 0)); // 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 + if (layout->labeltype == LABEL_COUNTER_CHAPTER && bview->buffer()->params.secnumdepth >= 0) { float spacing_val = 1.0; @@ -1344,19 +1433,19 @@ void LyXText::setHeightOfRow(BufferView * bview, Row * row_ptr) const } 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() * + + labeladdon = int(font_metrics::maxDescent(labelfont) * + layout->spacing.getValue() * + spacing_val) + + int(font_metrics::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) + 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()) { @@ -1366,65 +1455,62 @@ void LyXText::setHeightOfRow(BufferView * bview, Row * row_ptr) const } else { spacing_val = bview->buffer()->params.spacing.getValue(); } - + labeladdon = int( - (lyxfont::maxAscent(labelfont) * - layout.spacing.getValue() * + (font_metrics::maxAscent(labelfont) * + layout->spacing.getValue() * spacing_val) - +(lyxfont::maxDescent(labelfont) * - layout.spacing.getValue() * + +(font_metrics::maxDescent(labelfont) * + layout->spacing.getValue() * spacing_val) - + layout.topsep * defaultHeight() - + layout.labelbottomsep * defaultHeight()); + + layout->topsep * defaultHeight() + + layout->labelbottomsep * defaultHeight()); } - - // and now the layout spaces, for example before and after a section, + + // 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() && + if (prev && prev->layout() == firstpar->layout() && prev->getDepth() == firstpar->getDepth() && prev->getLabelWidthString() == firstpar->getLabelWidthString()) { - layoutasc = (layout.itemsep * defaultHeight()); + layoutasc = (layout->itemsep * defaultHeight()); } else if (row_ptr->previous()) { - tmptop = layout.topsep; - + 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; - + tmptop -= row_ptr->previous()->par()->layout()->bottomsep; + if (tmptop > 0) layoutasc = (tmptop * defaultHeight()); } else if (row_ptr->par()->params().lineTop()) { - tmptop = layout.topsep; - + tmptop = layout->topsep; + 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()); + maxasc += int(prev->layout()->parsep * defaultHeight()); } else { if (firstpar->previous() && firstpar->previous()->getDepth() == 0 && - firstpar->previous()->getLayout() != - firstpar->getLayout()) + firstpar->previous()->layout() != + firstpar->layout()) { // avoid parsep } else if (firstpar->previous()) { - maxasc += int(layout.parsep * defaultHeight()); + 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())) @@ -1432,79 +1518,78 @@ void LyXText::setHeightOfRow(BufferView * bview, Row * row_ptr) const // 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)); - + 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(), + maxdesc += 2 * font_metrics::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 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()) { + 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()); + usual = (comparepar->layout()->bottomsep * defaultHeight()); comparepar = comparepar->depthHook(nextpar->getDepth()); - if (comparepar->getLayout()!= nextpar->getLayout() - || nextpar->getLabelWidthString() != + if (comparepar->layout()!= nextpar->layout() + || nextpar->getLabelWidthString() != comparepar->getLabelWidthString()) { - unusual = (textclasslist.Style(bview->buffer()->params.textclass, - comparepar->getLayout()).bottomsep * defaultHeight()); + unusual = (comparepar->layout()->bottomsep * defaultHeight()); } if (unusual > usual) layoutdesc = unusual; else layoutdesc = usual; } else if (comparepar->getDepth() == nextpar->getDepth()) { - - if (comparepar->getLayout()!= nextpar->getLayout() - || nextpar->getLabelWidthString() != + + if (comparepar->layout() != nextpar->layout() + || nextpar->getLabelWidthString() != comparepar->getLabelWidthString()) - layoutdesc = int(textclasslist.Style(bview->buffer()->params.textclass, - comparepar->getLayout()).bottomsep * defaultHeight()); + layoutdesc = int(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) { + 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) { + while (r) { if (r->width() > width) width = r->width(); r = r->next(); @@ -1513,46 +1598,45 @@ void LyXText::setHeightOfRow(BufferView * bview, Row * row_ptr) const } -/* Appends the implicit specified paragraph behind the specified row, - * start at the implicit given position */ +// Appends the implicit specified paragraph behind the specified row, +// start at the implicit given position void LyXText::appendParagraph(BufferView * bview, Row * row) const { - bool not_ready = true; - - // The last character position of a paragraph is an invariant so we can - // safely get it here. (Asger) - pos_type const lastposition = row->par()->size(); - do { - // Get the next breakpoint - pos_type z = nextBreakPoint(bview, row, workWidth(bview)); - - Row * tmprow = row; - - // Insert the new row - if (z < lastposition) { - ++z; - insertRow(row, row->par(), z); - row = row->next(); - - 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); + bool not_ready = true; + + // 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; + + // Insert the new row + if (z < lastposition) { + ++z; + insertRow(row, row->par(), z); + row = row->next(); + + row->height(0); + } else + not_ready = false; - } while (not_ready); + // 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); } void LyXText::breakAgain(BufferView * bview, Row * row) const { bool not_ready = true; - + do { // get the next breakpoint pos_type z = nextBreakPoint(bview, row, workWidth(bview)); @@ -1575,8 +1659,8 @@ void LyXText::breakAgain(BufferView * bview, Row * row) const } } } else { - /* if there are some rows too much, delete them */ - /* only if you broke the whole paragraph! */ + // if there are some rows too much, delete them + // only if you broke the whole paragraph! Row * tmprow2 = row; while (tmprow2->next() && tmprow2->next()->par() == row->par()) { tmprow2 = tmprow2->next(); @@ -1587,8 +1671,8 @@ void LyXText::breakAgain(BufferView * bview, Row * row) const } not_ready = false; } - - /* set the dimensions of the row */ + + // set the dimensions of the row tmprow->fill(fill(bview, tmprow, workWidth(bview))); setHeightOfRow(bview, tmprow); } while (not_ready); @@ -1605,13 +1689,13 @@ void LyXText::breakAgainOneRow(BufferView * bview, Row * row) if (z < row->par()->size()) { if (!row->next() || (row->next() && row->next()->par() != row->par())) { - /* insert a new row */ + // insert a new row ++z; insertRow(row, row->par(), z); row = row->next(); row->height(0); } else { - row= row->next(); + row = row->next(); ++z; if (row->pos() != z) row->pos(z); @@ -1629,7 +1713,7 @@ void LyXText::breakAgainOneRow(BufferView * bview, Row * row) removeRow(tmprow2->next()); } } - + // set the dimensions of the row tmprow->fill(fill(bview, tmprow, workWidth(bview))); setHeightOfRow(bview, tmprow); @@ -1638,94 +1722,104 @@ 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()); - - // 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()); - - // Always break behind a space - // - // It is better to erase the space (Dekel) - if (cursor.pos() < cursor.par()->size() - && cursor.par()->isLineSeparator(cursor.pos())) + LyXTextClass const & tclass = + bview->buffer()->params.getLyXTextClass(); + LyXLayout_ptr const & layout = cursor.par()->layout(); + + // this is only allowed, if the current paragraph is not empty or caption + // and if it has not the keepempty flag aktive + if (cursor.par()->empty() + && layout->labeltype != LABEL_SENSITIVE + && !layout->keepempty) + return; + + setUndo(bview, Undo::FINISH, cursor.par(), cursor.par()->next()); + + // Always break behind a space + // + // It is better to erase the space (Dekel) + if (cursor.pos() < cursor.par()->size() + && cursor.par()->isLineSeparator(cursor.pos())) cursor.par()->erase(cursor.pos()); - // cursor.pos(cursor.pos() + 1); - - // break the paragraph - if (keep_layout) - keep_layout = 2; - else - keep_layout = layout.isEnvironment(); - cursor.par()->breakParagraph(bview->buffer()->params, cursor.pos(), - keep_layout); - - // well this is the caption hack since one caption is really enough - if (layout.labeltype == LABEL_SENSITIVE) { - if (!cursor.pos()) - // set to standard-layout - cursor.par()->setLayout(0); - else - // set to standard-layout - cursor.par()->next()->setLayout(0); - } - - /* if the cursor is at the beginning of a row without prior newline, - * move one row up! - * This touches only the screen-update. Otherwise we would may have - * an empty row on the screen */ - if (cursor.pos() && !cursor.row()->par()->isNewline(cursor.row()->pos() - 1) - && cursor.row()->pos() == cursor.pos()) { - cursorLeft(bview); - } - - status(bview, LyXText::NEED_MORE_REFRESH); - refresh_row = cursor.row(); - refresh_y = cursor.y() - cursor.row()->baseline(); - - // Do not forget the special right address boxes - if (layout.margintype == MARGIN_RIGHT_ADDRESS_BOX) { - while (refresh_row->previous() && - refresh_row->previous()->par() == refresh_row->par()) { - refresh_row = refresh_row->previous(); - refresh_y -= refresh_row->height(); - } - } - removeParagraph(cursor.row()); - - // set the dimensions of the cursor row - cursor.row()->fill(fill(bview, cursor.row(), workWidth(bview))); - - setHeightOfRow(bview, cursor.row()); - - while (cursor.par()->next()->size() + // cursor.pos(cursor.pos() + 1); + + // break the paragraph + if (keep_layout) + keep_layout = 2; + else + keep_layout = layout->isEnvironment(); + + // we need to set this before we insert the paragraph. IMO the + // breakParagraph call should return a bool if it inserts the + // paragraph before or behind and we should react on that one + // but we can fix this in 1.3.0 (Jug 20020509) + bool const isempty = (layout->keepempty && cursor.par()->empty()); + ::breakParagraph(bview->buffer()->params, cursor.par(), cursor.pos(), + keep_layout); + + // well this is the caption hack since one caption is really enough + if (layout->labeltype == LABEL_SENSITIVE) { + if (!cursor.pos()) + // set to standard-layout + cursor.par()->applyLayout(tclass.defaultLayout()); + else + // set to standard-layout + cursor.par()->next()->applyLayout(tclass.defaultLayout()); + } + + // if the cursor is at the beginning of a row without prior newline, + // move one row up! + // This touches only the screen-update. Otherwise we would may have + // an empty row on the screen + if (cursor.pos() && !cursor.row()->par()->isNewline(cursor.row()->pos() - 1) + && cursor.row()->pos() == cursor.pos()) + { + cursorLeft(bview); + } + + status(bview, LyXText::NEED_MORE_REFRESH); + refresh_row = cursor.row(); + refresh_y = cursor.y() - cursor.row()->baseline(); + + // Do not forget the special right address boxes + if (layout->margintype == MARGIN_RIGHT_ADDRESS_BOX) { + while (refresh_row->previous() && + refresh_row->previous()->par() == refresh_row->par()) + { + refresh_row = refresh_row->previous(); + refresh_y -= refresh_row->height(); + } + } + removeParagraph(cursor.row()); + + // set the dimensions of the cursor row + cursor.row()->fill(fill(bview, cursor.row(), workWidth(bview))); + + setHeightOfRow(bview, cursor.row()); + + while (!cursor.par()->next()->empty() && cursor.par()->next()->isNewline(0)) cursor.par()->next()->erase(0); - - insertParagraph(bview, cursor.par()->next(), cursor.row()); - updateCounters(bview, cursor.row()->previous()); - - /* This check is necessary. Otherwise the new empty paragraph will - * be deleted automatically. And it is more friendly for the user! */ - if (cursor.pos()) - setCursor(bview, cursor.par()->next(), 0); - else - setCursor(bview, cursor.par(), 0); - - if (cursor.row()->next()) - breakAgain(bview, cursor.row()->next()); + insertParagraph(bview, cursor.par()->next(), cursor.row()); + + updateCounters(bview); - need_break_row = 0; + // This check is necessary. Otherwise the new empty paragraph will + // be deleted automatically. And it is more friendly for the user! + if (cursor.pos() || isempty) + setCursor(bview, cursor.par()->next(), 0); + else + setCursor(bview, cursor.par(), 0); + + if (cursor.row()->next()) + breakAgain(bview, cursor.row()->next()); + + need_break_row = 0; } -// Just a macro to make some thing easier. +// Just a macro to make some thing easier. void LyXText::redoParagraph(BufferView * bview) const { clearSelection(); @@ -1734,29 +1828,25 @@ void LyXText::redoParagraph(BufferView * bview) const } -/* insert a character, moves all the following breaks in the - * same Paragraph one to the right and make a rebreak */ +// insert a character, moves all the following breaks in the +// same Paragraph one to the right and make a rebreak void LyXText::insertChar(BufferView * bview, char c) { - 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 || + bool const freeSpacing = cursor.row()->par()->layout()->free_spacing || cursor.row()->par()->isFreeSpacing(); - if (lyxrc.auto_number) { static string const number_operators = "+-/*"; static string const number_unary_operators = "+-"; static string const number_seperators = ".,:"; if (current_font.number() == LyXFont::ON) { - if (!isdigit(c) && !contains(number_operators, c) && + if (!IsDigit(c) && !contains(number_operators, c) && !(contains(number_seperators, c) && cursor.pos() >= 1 && cursor.pos() < cursor.par()->size() && @@ -1766,9 +1856,9 @@ void LyXText::insertChar(BufferView * bview, char c) getFont(bview->buffer(), cursor.par(), cursor.pos() - 1).number() == LyXFont::ON) - ) + ) number(bview); // Set current_font.number to OFF - } else if (isdigit(c) && + } else if (IsDigit(c) && real_current_font.isVisibleRightToLeft()) { number(bview); // Set current_font.number to ON @@ -1777,8 +1867,8 @@ void LyXText::insertChar(BufferView * bview, char c) 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, @@ -1798,23 +1888,21 @@ void LyXText::insertChar(BufferView * bview, char c) } - /* First check, if there will be two blanks together or a blank at - the beginning of a paragraph. - I decided to handle blanks like normal characters, the main - difference are the special checks when calculating the row.fill - (blank does not count at the end of a row) and the check here */ + // First check, if there will be two blanks together or a blank at + // the beginning of a paragraph. + // I decided to handle blanks like normal characters, the main + // difference are the special checks when calculating the row.fill + // (blank does not count at the end of a row) and the check here // The bug is triggered when we type in a description environment: // The current_font is not changed when we go from label to main text // and it should (along with realtmpfont) when we type the space. // CHECK There is a bug here! (Asger) - + LyXFont realtmpfont = real_current_font; - LyXFont rawtmpfont = current_font; /* store the current font. - * This is because of the use - * of cursor movements. The moving - * cursor would refresh the - * current font */ + LyXFont rawtmpfont = current_font; + // store the current font. This is because of the use of cursor + // movements. The moving cursor would refresh the current font // Get the font that is used to calculate the baselineskip pos_type const lastpos = cursor.par()->size(); @@ -1823,16 +1911,16 @@ void LyXText::insertChar(BufferView * bview, char c) lastpos - 1); bool jumped_over_space = false; - + if (!freeSpacing && IsLineSeparatorChar(c)) { - if ((cursor.pos() > 0 + if ((cursor.pos() > 0 && cursor.par()->isLineSeparator(cursor.pos() - 1)) || (cursor.pos() > 0 && cursor.par()->isNewline(cursor.pos() - 1)) || (cursor.pos() == 0)) { static bool sent_space_message = false; if (!sent_space_message) { - if (cursor.pos() == 0) + if (cursor.pos() == 0) bview->owner()->message(_("You cannot insert a space at the beginning of a paragraph. Please read the Tutorial.")); else bview->owner()->message(_("You cannot type two spaces this way. Please read the Tutorial.")); @@ -1842,14 +1930,14 @@ 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; } - /* No newline at first position - * of a paragraph or behind labels. - * TeX does not allow that. */ + // No newline at first position of a paragraph or behind labels. + // TeX does not allow that if (cursor.pos() < cursor.par()->size() && cursor.par()->isLineSeparator(cursor.pos())) @@ -1857,20 +1945,23 @@ void LyXText::insertChar(BufferView * bview, char c) cursorRight(bview); cursor.row()->fill(-1); // to force a new break } - + // the display inset stuff - if (cursor.row()->par()->isInset(cursor.row()->pos()) - && 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 */ + if (c != Paragraph::META_INSET) { + // Here case LyXText::InsertInset already insertet the character cursor.par()->insertChar(cursor.pos(), c); + } setCharFont(bview->buffer(), cursor.par(), cursor.pos(), rawtmpfont); if (!jumped_over_space) { @@ -1881,30 +1972,33 @@ void LyXText::insertChar(BufferView * bview, char c) tmprow->pos(tmprow->pos() + 1); } } - + // Is there a break one row above - if ((cursor.par()->isLineSeparator(cursor.pos()) - || cursor.par()->isNewline(cursor.pos()) - || cursor.row()->fill() == -1) - && row->previous() && row->previous()->par() == row->par()) { + if (row->previous() && row->previous()->par() == row->par() + && (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)) + { pos_type z = nextBreakPoint(bview, row->previous(), workWidth(bview)); if (z >= row->pos()) { row->pos(z + 1); - + // set the dimensions of the row above row->previous()->fill(fill(bview, row->previous(), workWidth(bview))); setHeightOfRow(bview, row->previous()); - + y -= row->previous()->height(); refresh_y = y; refresh_row = row->previous(); status(bview, LyXText::NEED_MORE_REFRESH); - + breakAgainOneRow(bview, row); current_font = rawtmpfont; @@ -1912,34 +2006,34 @@ void LyXText::insertChar(BufferView * bview, char c) setCursor(bview, cursor.par(), cursor.pos() + 1, false, cursor.boundary()); // cursor MUST be in row now. - + if (row->next() && row->next()->par() == row->par()) need_break_row = row->next(); else need_break_row = 0; - + // check, wether the last characters font has changed. if (cursor.pos() && cursor.pos() == cursor.par()->size() && rawparfont != rawtmpfont) redoHeightOfParagraph(bview, cursor); - + charInserted(); return; } } - + // 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! */ + if (row->fill() >= 0) { + // needed because a newline will set fill to -1. Otherwise + // we would not get a rebreak! row->fill(fill(bview, row, workWidth(bview))); - if (row->fill() < 0) { + } + + if (c == Paragraph::META_INSET || row->fill() < 0) { refresh_y = y; - refresh_row = row; - refresh_x = cursor.x(); - refresh_pos = cursor.pos(); + refresh_row = row; status(bview, LyXText::NEED_MORE_REFRESH); - breakAgainOneRow(bview, row); + breakAgainOneRow(bview, row); // will the cursor be in another row now? if (rowLast(row) <= cursor.pos() + 1 && row->next()) { if (row->next() && row->next()->par() == row->par()) @@ -1959,20 +2053,18 @@ void LyXText::insertChar(BufferView * bview, char c) if (row->next() && row->next()->par() == row->par()) need_break_row = row->next(); else - need_break_row = 0; + need_break_row = 0; } else { refresh_y = y; - refresh_x = cursor.x(); refresh_row = row; - refresh_pos = cursor.pos(); - + int const tmpheight = row->height(); setHeightOfRow(bview, row); if (tmpheight == row->height()) status(bview, LyXText::NEED_VERY_LITTLE_REFRESH); else status(bview, LyXText::NEED_MORE_REFRESH); - + current_font = rawtmpfont; real_current_font = realtmpfont; setCursor(bview, cursor.par(), cursor.pos() + 1, false, @@ -1985,16 +2077,15 @@ 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 (cursor.par()->layout()->margintype == MARGIN_RIGHT_ADDRESS_BOX) { - redoDrawingOfParagraph(bview, cursor); + redoDrawingOfParagraph(bview, cursor); } } charInserted(); } - + void LyXText::charInserted() { @@ -2011,74 +2102,84 @@ 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; - + float w = row->fill(); fill_hfill = 0; fill_label_hfill = 0; 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) ? rightMargin(bview->buffer(), row) : 0; } else - x = (workWidth(bview) > 0) ? leftMargin(bview, row) : 0; - + 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 */ + LyXLayout_ptr const & layout = 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; } } - + // are there any hfills in the row? float const nh = numberOfHfills(bview->buffer(), row); if (nh) { if (w > 0) fill_hfill = w / nh; - } else { - // is it block, flushleft or flushright? + // 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; + align = layout->align; } else { align = row->par()->params().align(); } - - // center displayed insets + + // 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; - + ? 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()->isInset(row->next()->pos()) - && row->next()->par()->getInset(row->next()->pos()) - && row->next()->par()->getInset(row->next()->pos())->display()) + && row->next()->par()->getInset(row->next()->pos()) + && row->next()->par()->getInset(row->next()->pos())->display()) ) { fill_separator = w / ns; @@ -2099,30 +2200,28 @@ void LyXText::prepareToPrint(BufferView * bview, computeBidiTables(bview->buffer(), row); if (is_rtl) { - pos_type main_body = + pos_type main_body = beginningOfMainBody(bview->buffer(), row->par()); 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()); - x += lyxfont::width(layout.labelsep, + (main_body - 1 > last || + !row->par()->isLineSeparator(main_body - 1))) { + x += font_metrics::width(layout->labelsep, getLabelFont(bview->buffer(), row->par())); - if (main_body-1 <= last) + if (main_body - 1 <= last) x += fill_label_hfill; } } } - -/* important for the screen */ -/* the cursor set functions have a special mechanism. When they -* realize, that you left an empty paragraph, they will delete it. -* They also delete the corresponding row */ +// important for the screen + + +// the cursor set functions have a special mechanism. When they +// realize, that you left an empty paragraph, they will delete it. +// They also delete the corresponding row void LyXText::cursorRightOneWord(BufferView * bview) const { @@ -2146,7 +2245,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; @@ -2158,25 +2257,24 @@ void LyXText::cursorRightOneWord(BufferView * bview) const void LyXText::cursorTab(BufferView * bview) const { - LyXCursor tmpcursor = cursor; - while (tmpcursor.pos() < tmpcursor.par()->size() - && !tmpcursor.par()->isNewline(tmpcursor.pos())) - tmpcursor.pos(tmpcursor.pos() + 1); + LyXCursor tmpcursor = cursor; + while (tmpcursor.pos() < tmpcursor.par()->size() + && !tmpcursor.par()->isNewline(tmpcursor.pos())) + tmpcursor.pos(tmpcursor.pos() + 1); - if (tmpcursor.pos() == tmpcursor.par()->size()){ - if (tmpcursor.par()->next()) { - tmpcursor.par(tmpcursor.par()->next()); - tmpcursor.pos(0); - } - } else - tmpcursor.pos(tmpcursor.pos() + 1); - setCursor(bview, tmpcursor.par(), tmpcursor.pos()); + if (tmpcursor.pos() == tmpcursor.par()->size()) { + if (tmpcursor.par()->next()) { + tmpcursor.par(tmpcursor.par()->next()); + tmpcursor.pos(0); + } + } else + tmpcursor.pos(tmpcursor.pos() + 1); + setCursor(bview, tmpcursor.par(), tmpcursor.pos()); } -/* -------> Skip initial whitespace at end of word and move cursor to *start* - of prior word, not to end of next prior word. */ - +// Skip initial whitespace at end of word and move cursor to *start* +// of prior word, not to end of next prior word. void LyXText::cursorLeftOneWord(BufferView * bview) const { LyXCursor tmpcursor = cursor; @@ -2184,12 +2282,13 @@ void LyXText::cursorLeftOneWord(BufferView * bview) const setCursor(bview, tmpcursor.par(), tmpcursor.pos()); } -void LyXText::cursorLeftOneWord(LyXCursor & cur) const + +void LyXText::cursorLeftOneWord(LyXCursor & cur) const { // treat HFills, floats and Insets as words cur = cursor; - while (cur.pos() - && (cur.par()->isSeparator(cur.pos() - 1) + while (cur.pos() + && (cur.par()->isSeparator(cur.pos() - 1) || cur.par()->isKomma(cur.pos() - 1)) && !(cur.par()->isHfill(cur.pos() - 1) || cur.par()->isInset(cur.pos() - 1))) @@ -2200,36 +2299,37 @@ 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 + } 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); } } -/* -------> Select current word. This depends on behaviour of -CursorLeftOneWord(), so it is patched as well. */ -void LyXText::getWord(LyXCursor & from, LyXCursor & to, + +// Select current word. This depends on behaviour of +// CursorLeftOneWord(), so it is patched as well. +void LyXText::getWord(LyXCursor & from, LyXCursor & to, word_location const loc) const { // 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()) || cursor.par()->isKomma(cursor.pos()) - || cursor.par()->isSeparator(cursor.pos() -1) - || cursor.par()->isKomma(cursor.pos() -1)) { + || cursor.par()->isSeparator(cursor.pos() - 1) + || cursor.par()->isKomma(cursor.pos() - 1)) { to = from; return; } // no break here, we go to the next - + case WHOLE_WORD: // Move cursor to the beginning, when not already there. if (from.pos() && !from.par()->isSeparator(from.pos() - 1) @@ -2250,14 +2350,15 @@ 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.par()->isInset(to.pos())) { to.pos(to.pos() + 1); } } -void LyXText::selectWord(BufferView * bview, word_location const loc) +void LyXText::selectWord(BufferView * bview, word_location const loc) { LyXCursor from; LyXCursor to; @@ -2267,15 +2368,15 @@ 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); } -/* -------> Select the word currently under the cursor when no - selection is currently set */ -bool LyXText::selectWordWhenUnderCursor(BufferView * bview, - word_location const loc) +// Select the word currently under the cursor when no +// selection is currently set +bool LyXText::selectWordWhenUnderCursor(BufferView * bview, + word_location const loc) { if (!selection.set()) { selectWord(bview, loc); @@ -2287,28 +2388,27 @@ 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::selectNextWordToSpellcheck(BufferView * bview, - float & value) const +WordLangTuple const +LyXText::selectNextWordToSpellcheck(BufferView * bview, float & value) const { if (the_locking_inset) { - 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) -#warning DEKEL! - // we have to go on checking so move cusor to the right + WordLangTuple word = the_locking_inset->selectNextWordToSpellcheck(bview, value); + if (!word.word().empty()) { + value += float(cursor.y()); + value /= float(height); + return word; + } + // we have to go on checking so move cursor to the next char if (cursor.pos() == cursor.par()->size()) { if (!cursor.par()->next()) - return str; + return word; cursor.par(cursor.par()->next()); cursor.pos(0); } else cursor.pos(cursor.pos() + 1); } Paragraph * tmppar = cursor.par(); - + // If this is not the very first word, skip rest of // current word because we are probably in the middle // of a word if there is text here. @@ -2317,7 +2417,7 @@ string const LyXText::selectNextWordToSpellcheck(BufferView * bview, && cursor.par()->isLetter(cursor.pos())) cursor.pos(cursor.pos() + 1); } - + // Now, skip until we have real text (will jump paragraphs) while ((cursor.par()->size() > cursor.pos() && (!cursor.par()->isLetter(cursor.pos())) @@ -2325,7 +2425,7 @@ string const LyXText::selectNextWordToSpellcheck(BufferView * bview, !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); @@ -2342,21 +2442,24 @@ string const LyXText::selectNextWordToSpellcheck(BufferView * bview, // now call us again to do the above trick // but obviously we have to start from down below ;) 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); } // Start the selection from here selection.cursor = cursor; - + + string lang_code( + getFont(bview->buffer(), cursor.par(), cursor.pos()) + .language()->code()); // 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()))) + && (cursor.par()->isLetter(cursor.pos()))) cursor.pos(cursor.pos() + 1); // Finally, we copy the word to a string and return it @@ -2368,7 +2471,7 @@ string const LyXText::selectNextWordToSpellcheck(BufferView * bview, str += cursor.par()->getChar(i); } } - return str; + return WordLangTuple(str, lang_code); } @@ -2381,26 +2484,26 @@ void LyXText::selectSelectedWord(BufferView * bview) } // move cursor to the beginning setCursor(bview, selection.cursor.par(), selection.cursor.pos()); - + // set the sel cursor selection.cursor = cursor; - + // now find the end of the word while (cursor.pos() < cursor.par()->size() && (cursor.par()->isLetter(cursor.pos()))) cursor.pos(cursor.pos() + 1); - + setCursor(bview, cursor.par(), cursor.pos()); - + // finally set the selection setSelection(bview); } -/* -------> Delete from cursor up to the end of the current or next word. */ +// Delete from cursor up to the end of the current or next word. void LyXText::deleteWordForward(BufferView * bview) { - if (!cursor.par()->size()) + if (cursor.par()->empty()) cursorRight(bview); else { LyXCursor tmpcursor = cursor; @@ -2411,36 +2514,36 @@ void LyXText::deleteWordForward(BufferView * bview) selection.cursor = cursor; cursor = tmpcursor; setSelection(bview); - - /* -----> Great, CutSelection() gets rid of multiple spaces. */ + + // Great, CutSelection() gets rid of multiple spaces. cutSelection(bview, true, false); } } -/* -------> Delete from cursor to start of current or prior word. */ +// Delete from cursor to start of current or prior word. void LyXText::deleteWordBackward(BufferView * bview) { - if (!cursor.par()->size()) - cursorLeft(bview); - else { - LyXCursor tmpcursor = cursor; - tmpcursor.row(0); // ?? - selection.set(true); // to avoid deletion - cursorLeftOneWord(bview); - setCursor(bview, tmpcursor, tmpcursor.par(), tmpcursor.pos()); - selection.cursor = cursor; - cursor = tmpcursor; - setSelection(bview); - cutSelection(bview, true, false); - } + if (cursor.par()->empty()) + cursorLeft(bview); + else { + LyXCursor tmpcursor = cursor; + tmpcursor.row(0); // ?? + selection.set(true); // to avoid deletion + cursorLeftOneWord(bview); + setCursor(bview, tmpcursor, tmpcursor.par(), tmpcursor.pos()); + selection.cursor = cursor; + cursor = tmpcursor; + setSelection(bview); + cutSelection(bview, true, false); + } } -/* -------> Kill to end of line. */ +// Kill to end of line. void LyXText::deleteLineForward(BufferView * bview) { - if (!cursor.par()->size()) + if (cursor.par()->empty()) // Paragraph is empty, so we just go to the right cursorRight(bview); else { @@ -2464,13 +2567,13 @@ void LyXText::deleteLineForward(BufferView * bview) } -// Change the case of a word at cursor position. +// Change the case of a word at cursor position. // This function directly manipulates Paragraph::text because there // is no Paragraph::SetChar currently. I did what I could to ensure // that it is correct. I guess part of it should be moved to // Paragraph, but it will have to change for 1.1 anyway. At least // it does not access outside of the allocated array as the older -// version did. (JMarc) +// version did. (JMarc) void LyXText::changeCase(BufferView * bview, LyXText::TextCase action) { LyXCursor from; @@ -2494,14 +2597,18 @@ void LyXText::changeRegionCase(BufferView * bview, LyXText::TextCase action) { lyx::Assert(from <= to); - - setUndo(bview, Undo::FINISH, - from.par(), to.par()->next()); + + setUndo(bview, Undo::FINISH, from.par(), to.par()->next()); pos_type pos = from.pos(); Paragraph * par = from.par(); while (par && (pos != to.pos() || par != to.par())) { + if (pos == par->size()) { + par = par->next(); + pos = 0; + continue; + } unsigned char c = par->getChar(pos); if (!IsInsetChar(c) && !IsHfillChar(c)) { switch (action) { @@ -2521,10 +2628,6 @@ void LyXText::changeRegionCase(BufferView * bview, checkParagraph(bview, par, pos); ++pos; - if (pos == par->size()) { - par = par->next(); - pos = 0; - } } if (to.row() != from.row()) { refresh_y = from.y() - from.row()->baseline(); @@ -2538,8 +2641,7 @@ void LyXText::transposeChars(BufferView & bview) { Paragraph * tmppar = cursor.par(); - setUndo(&bview, Undo::FINISH, - tmppar, tmppar->next()); + setUndo(&bview, Undo::FINISH, tmppar, tmppar->next()); pos_type tmppos = cursor.pos(); @@ -2573,7 +2675,7 @@ void LyXText::Delete(BufferView * bview) int const old_cur_par_id = old_cursor.par()->id(); int const old_cur_par_prev_id = old_cursor.par()->previous() ? old_cursor.par()->previous()->id() : 0; - + // just move to the right cursorRight(bview); @@ -2596,7 +2698,7 @@ void LyXText::Delete(BufferView * bview) // 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); } @@ -2614,20 +2716,20 @@ void LyXText::backspace(BufferView * bview) if (cursor.pos() == 0) { // The cursor is at the beginning of a paragraph, // so the the backspace will collapse two paragraphs into one. - + // we may paste some paragraphs - + // is it an empty paragraph? - + if ((lastpos == 0 || (lastpos == 1 && cursor.par()->isSeparator(0)))) { // This is an empty paragraph and we delete it just by moving the cursor one step // left and let the DeleteEmptyParagraphMechanism handle the actual deletion // of the paragraph. - + if (cursor.par()->previous()) { 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) @@ -2635,9 +2737,9 @@ void LyXText::backspace(BufferView * bview) tmppar->params().spaceBottom(cursor.par()->params().spaceBottom()); tmppar->params().pagebreakBottom(cursor.par()->params().pagebreakBottom()); } - + cursorLeft(bview); - + // the layout things can change the height of a row ! int const tmpheight = cursor.row()->height(); setHeightOfRow(bview, cursor.row()); @@ -2652,42 +2754,43 @@ 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(); - Row * tmprow = cursor.row(); + + Paragraph * tmppar = cursor.par(); + Row * tmprow = cursor.row(); // We used to do cursorLeftIntern() here, but it is // not a good idea since it triggers the auto-delete // mechanism. So we do a cursorLeftIntern()-lite, // without the dreaded mechanism. (JMarc) - if (cursor.par()->previous()) { + if (cursor.par()->previous()) { // steps into the above paragraph. setCursorIntern(bview, cursor.par()->previous(), - cursor.par()->previous()->size(), - false); - } - - /* Pasting is not allowed, if the paragraphs have different - layout. I think it is a real bug of all other - word processors to allow it. It confuses the user. - Even so with a footnote paragraph and a non-footnote - paragraph. I will not allow pasting in this case, - because the user would be confused if the footnote behaves - different wether it is open or closed. - - Correction: Pasting is always allowed with standard-layout - */ + cursor.par()->previous()->size(), + false); + } + + // Pasting is not allowed, if the paragraphs have different + // layout. I think it is a real bug of all other + // word processors to allow it. It confuses the user. + // Even so with a footnote paragraph and a non-footnote + // paragraph. I will not allow pasting in this case, + // because the user would be confused if the footnote behaves + // different wether it is open or closed. + + // Correction: Pasting is always allowed with standard-layout + LyXTextClass const & tclass = + bview->buffer()->params.getLyXTextClass(); + if (cursor.par() != tmppar - && (cursor.par()->getLayout() == tmppar->getLayout() - || tmppar->getLayout() == 0 /*standard*/) - && cursor.par()->getAlign() == tmppar->getAlign()) - { + && (cursor.par()->layout() == tmppar->layout() + || tmppar->layout() == tclass.defaultLayout()) + && cursor.par()->getAlign() == tmppar->getAlign()) { removeParagraph(tmprow); removeRow(tmprow); - cursor.par()->pasteParagraph(bview->buffer()->params); - + mergeParagraph(bview->buffer()->params, cursor.par()); + if (!cursor.pos() || !cursor.par()->isSeparator(cursor.pos() - 1)) ; //cursor.par()->insertChar(cursor.pos(), ' '); // strangely enough it seems that commenting out the line above removes @@ -2696,44 +2799,44 @@ void LyXText::backspace(BufferView * bview) else if (cursor.pos()) cursor.pos(cursor.pos() - 1); - + status(bview, LyXText::NEED_MORE_REFRESH); refresh_row = cursor.row(); refresh_y = cursor.y() - cursor.row()->baseline(); - + // remove the lost paragraph // This one is not safe, since the paragraph that the tmprow and the // following rows belong to has been deleted by the PasteParagraph // above. The question is... could this be moved in front of the // PasteParagraph? //RemoveParagraph(tmprow); - //RemoveRow(tmprow); - + //RemoveRow(tmprow); + // This rebuilds the rows. appendParagraph(bview, cursor.row()); - updateCounters(bview, cursor.row()); - + updateCounters(bview); + // the row may have changed, block, hfills etc. setCursor(bview, cursor.par(), cursor.pos(), false); } } else { - /* this is the code for a normal backspace, not pasting - * any paragraphs */ + // 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()->isInset(cursor.pos())) { if (!cursor.par()->getInset(cursor.pos())->deletable()) - return; + return; // force complete redo when erasing display insets - // this is a cruel method but safe..... Matthias + // this is a cruel method but safe..... Matthias if (cursor.par()->getInset(cursor.pos())->display() || cursor.par()->getInset(cursor.pos())->needFullRow()) { cursor.par()->erase(cursor.pos()); @@ -2741,21 +2844,21 @@ void LyXText::backspace(BufferView * bview) return; } } - + Row * row = cursor.row(); int y = cursor.y() - row->baseline(); pos_type z; - /* remember that a space at the end of a row doesnt count - * when calculating the fill */ + // 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 - * to the behavior when pasting paragraphs */ + + // some special code when deleting a newline. This is similar + // to the behavior when pasting paragraphs if (cursor.pos() && cursor.par()->isNewline(cursor.pos())) { cursor.par()->erase(cursor.pos()); // refresh the positions @@ -2770,7 +2873,7 @@ void LyXText::backspace(BufferView * bview) if (cursor.pos() < cursor.par()->size() && !cursor.par()->isSeparator(cursor.pos())) { cursor.par()->insertChar(cursor.pos(), ' '); - setCharFont(bview->buffer(), cursor.par(), + setCharFont(bview->buffer(), cursor.par(), cursor.pos(), current_font); // refresh the positions tmprow = row; @@ -2781,7 +2884,7 @@ void LyXText::backspace(BufferView * bview) } } else { cursor.par()->erase(cursor.pos()); - + // refresh the positions Row * tmprow = row; while (tmprow->next() @@ -2791,30 +2894,30 @@ void LyXText::backspace(BufferView * bview) } // delete newlines at the beginning of paragraphs - while (cursor.par()->size() && + while (!cursor.par()->empty() && cursor.par()->isNewline(cursor.pos()) && cursor.pos() == beginningOfMainBody(bview->buffer(), cursor.par())) { cursor.par()->erase(cursor.pos()); // refresh the positions tmprow = row; - while (tmprow->next() && + while (tmprow->next() && tmprow->next()->par() == row->par()) { tmprow = tmprow->next(); tmprow->pos(tmprow->pos() - 1); } } } - + // is there a break one row above if (row->previous() && row->previous()->par() == row->par()) { z = nextBreakPoint(bview, row->previous(), workWidth(bview)); if (z >= row->pos()) { row->pos(z + 1); - + Row * tmprow = row->previous(); - + // maybe the current row is now empty if (row->pos() >= row->par()->size()) { // remove it @@ -2827,13 +2930,13 @@ void LyXText::backspace(BufferView * bview) else need_break_row = 0; } - + // set the dimensions of the row above y -= tmprow->height(); tmprow->fill(fill(bview, tmprow, workWidth(bview))); setHeightOfRow(bview, tmprow); - + refresh_y = y; refresh_row = tmprow; status(bview, LyXText::NEED_MORE_REFRESH); @@ -2849,23 +2952,23 @@ void LyXText::backspace(BufferView * bview) return; } } - + // break the cursor row again if (row->next() && row->next()->par() == row->par() && (rowLast(row) == row->par()->size() - 1 || nextBreakPoint(bview, row, workWidth(bview)) != rowLast(row))) { - - /* it can happen that a paragraph loses one row - * without a real breakup. This is when a word - * is to long to be broken. Well, I don t care this - * hack ;-) */ + + // it can happen that a paragraph loses one row + // without a real breakup. This is when a word + // is to long to be broken. Well, I don t care this + // hack ;-) if (rowLast(row) == row->par()->size() - 1) removeRow(row->next()); - + refresh_y = y; refresh_row = row; status(bview, LyXText::NEED_MORE_REFRESH); - + breakAgainOneRow(bview, row); // will the cursor be in another row now? if (row->next() && row->next()->par() == row->par() && @@ -2906,16 +3009,16 @@ void LyXText::backspace(BufferView * bview) lastpos = cursor.par()->size(); if (cursor.pos() == lastpos) setCurrentFont(bview); - + // check, whether the last characters font has changed. - if (rawparfont != + if (rawparfont != cursor.par()->getFontSettings(bview->buffer()->params, lastpos - 1)) { 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) { - redoDrawingOfParagraph(bview, cursor); + if (cursor.par()->layout()->margintype + == MARGIN_RIGHT_ADDRESS_BOX) { + redoDrawingOfParagraph(bview, cursor); } } } @@ -2929,18 +3032,18 @@ bool LyXText::paintRowBackground(DrawRowParams & p) pos_type const last = rowLastPrintable(p.row); - if (!p.bv->screen()->forceClear() && last == p.row->pos() + 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; @@ -2948,12 +3051,12 @@ bool LyXText::paintRowBackground(DrawRowParams & p) 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()); @@ -2962,7 +3065,7 @@ bool LyXText::paintRowBackground(DrawRowParams & p) // 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.pain->fillRectangle(p.xo, p.yo + h, p.width, p.row->height() - h, backgroundColor()); } @@ -2974,7 +3077,7 @@ bool LyXText::paintRowBackground(DrawRowParams & p) p.row->height(), backgroundColor()); } } - + return false; } @@ -2990,15 +3093,15 @@ void LyXText::paintRowSelection(DrawRowParams & p) 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; @@ -3022,50 +3125,44 @@ void LyXText::paintRowSelection(DrawRowParams & p) } return; } else if (startrow != row && endrow != row) { - int w = p.width; - int h = row->height(); if (p.y > starty && p.y < endy) { + int w = p.width; + int h = row->height(); p.pain->fillRectangle(p.xo, p.yo, w, h, LColor::selection); } return; } - - 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); - + + if ((startrow != row && !is_rtl) || (endrow != row && is_rtl)) + 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); - + float tmpx = p.x; + 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, - par->getLayout()); + LyXLayout_ptr const & layout = par->layout(); LyXFont const lfont = getLabelFont(buffer, par); - - - tmpx += p.label_hfill + lyxfont::width(layout.labelsep, lfont); + + tmpx += p.label_hfill + font_metrics::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 + else tmpx += p.label_hfill; } - + else if (par->isSeparator(pos)) { tmpx += singleWidth(p.bv, par, pos); if (pos >= main_body) @@ -3073,7 +3170,7 @@ void LyXText::paintRowSelection(DrawRowParams & p) } else { tmpx += singleWidth(p.bv, par, pos); } - + 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. @@ -3081,15 +3178,15 @@ void LyXText::paintRowSelection(DrawRowParams & p) 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 ((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); } } - + void LyXText::paintRowAppendix(DrawRowParams & p) { @@ -3103,11 +3200,11 @@ void LyXText::paintRowAppendix(DrawRowParams & p) } } - + void LyXText::paintRowDepthBar(DrawRowParams & p) { Paragraph::depth_type const depth = p.row->par()->getDepth(); - + if (depth <= 0) return; @@ -3121,11 +3218,11 @@ void LyXText::paintRowDepthBar(DrawRowParams & p) 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); } @@ -3135,147 +3232,204 @@ void LyXText::paintRowDepthBar(DrawRowParams & p) } } - + +int LyXText::getLengthMarkerHeight(BufferView * bv, VSpace const & vsp) const +{ + int const arrow_size = 4; + int const space_size = int(vsp.inPixels(bv)); + + if (vsp.kind() != VSpace::LENGTH) { + return space_size; + } + + LyXFont font; + font.decSize(); + int const min_size = max(3 * arrow_size, + font_metrics::maxAscent(font) + + font_metrics::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(); + font_metrics::rectText(str, font, w, a, d); + + p.pain->rectText(leftx + 2 * arrow_size + 5, + start + ((end - start) / 2) + d, + str, font); + + // 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; +} + + +int LyXText::paintPageBreak(string const & label, int y, DrawRowParams & p) +{ + LyXFont pb_font; + pb_font.setColor(LColor::pagebreak).decSize(); + + int w = 0; + int a = 0; + int d = 0; + font_metrics::rectText(label, pb_font, w, a, d); + + int const text_start = p.xo + ((p.width - w) / 2); + int const text_end = text_start + w; + + p.pain->rectText(text_start, y + d, label, pb_font); + + p.pain->line(p.xo, y, text_start, y, + LColor::pagebreak, Painter::line_onoffdash); + p.pain->line(text_end, y, p.xo + p.width, y, + LColor::pagebreak, Painter::line_onoffdash); + + return 3 * defaultHeight(); +} + + void LyXText::paintFirstRow(DrawRowParams & p) { - Paragraph * par = p.row->par(); + 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; - + // 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(); - } - - // draw a vfill top - if (parparams.spaceTop().kind() == VSpace::VFILL) { - 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::added_space); - - 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::added_space); - - y_top += 3 * defaultHeight(); - } else if (parparams.spaceTop().kind() == VSpace::LENGTH) { - string str = string(_("Space above")) + " (" - + parparams.spaceTop().asLyXCommand() - + ")"; - - int const space = int(parparams.spaceTop().inPixels(p.bv)); - int const y = p.yo + y_top + space / 2; - - p.pain->line(p.xo, y, p.xo + p.width, y, - LColor::added_space, Painter::line_onoffdash); - - int w = 0; - int a = 0; - int d = 0; - - LyXFont pb_font; - pb_font.setColor(LColor::added_space).decSize(); - lyxfont::rectText(str, pb_font, w, a, d); - - // don't draw if it won't fit - if (a + d + 4 < space) { - p.pain->rectText(p.xo + (p.width - w)/2, y + d, - str, pb_font, - backgroundColor(), - backgroundColor()); - } - } - - y_top += int(parparams.spaceTop().inPixels(p.bv)); - + y_top += paintPageBreak(_("Page Break (top)"), + p.yo + y_top + 2 * defaultHeight(), p); + } + + // draw the additional space if needed: + y_top += drawLengthMarker(p, _("Space above"), + parparams.spaceTop(), p.yo + y_top); + Buffer const * buffer = p.bv->buffer(); - - LyXLayout const & layout = - textclasslist.Style(buffer->params.textclass, par->getLayout()); + + LyXLayout_ptr const & layout = 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 + if (layout->latextype == LATEX_PARAGRAPH && !par->getDepth()) { y_top += buffer->params.getDefSkip().inPixels(p.bv); } else { - LyXLayout const & playout = - textclasslist.Style(buffer->params.textclass, - par->previous()->getLayout()); - if (playout.latextype == LATEX_PARAGRAPH + LyXLayout_ptr const & playout = + par->previous()->layout(); + if (playout->latextype == LATEX_PARAGRAPH && !par->previous()->getDepth()) { - // is it right to use defskip here, too? (AS) + // 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)); - + int const asc = font_metrics::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.x : 0); - p.pain->line(xp, p.yo + y_top, w, p.yo + y_top, + 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); - + 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 + 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(); - + // 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 (layout->labeltype == LABEL_COUNTER_CHAPTER) { if (buffer->params.secnumdepth >= 0) { float spacing_val = 1.0; if (!parparams.spacing().isDefault()) { @@ -3283,28 +3437,29 @@ void LyXText::paintFirstRow(DrawRowParams & p) } else { spacing_val = buffer->params.spacing.getValue(); } - - int const maxdesc = - int(lyxfont::maxDescent(font) * layout.spacing.getValue() * spacing_val) - + int(layout.parsep) * defaultHeight(); - + + int const maxdesc = + int(font_metrics::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); + x = ww - leftMargin(p.bv, p.row) - + font_metrics::width(str, font); } - - p.pain->text(int(x), p.yo + - p.yo + p.row->baseline() - + + 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); + + font_metrics::width(layout->labelsep, font); + } else { + x = p.x - font_metrics::width(layout->labelsep, font) + - font_metrics::width(str, font); + } p.pain->text(int(x), p.yo + p.row->baseline(), str, font); } @@ -3312,9 +3467,9 @@ void LyXText::paintFirstRow(DrawRowParams & p) // 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)) { + (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(); @@ -3324,172 +3479,121 @@ void LyXText::paintFirstRow(DrawRowParams & p) } else { spacing_val = buffer->params.spacing.getValue(); } - - int maxdesc = - int(lyxfont::maxDescent(font) * layout.spacing.getValue() * spacing_val - + (layout.labelbottomsep * defaultHeight())); - + + int maxdesc = + int(font_metrics::maxDescent(font) * layout->spacing.getValue() * spacing_val + + (layout->labelbottomsep * defaultHeight())); + float x = p.x; - if (layout.labeltype == LABEL_CENTERED_TOP_ENVIRONMENT) { + 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; + + ww - rightMargin(buffer, p.row)) / 2; + x -= font_metrics::width(str, font) / 2; } else if (is_rtl) { - x = ww - leftMargin(p.bv, p.row) - - lyxfont::width(str, font); + x = ww - leftMargin(p.bv, p.row) - + font_metrics::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) { + + 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); + + font_metrics::width(layout->labelsep, font); } else { - x = p.x - lyxfont::width(layout.labelsep, font) + x = p.x - font_metrics::width(layout->labelsep, font) - par->bibkey->width(p.bv, font); } par->bibkey->draw(p.bv, font, p.yo + p.row->baseline(), x, p.cleared); } } - - + + void LyXText::paintLastRow(DrawRowParams & p) { Paragraph * par = p.row->par(); ParagraphParameters const & parparams = par->params(); - int y_bottom = p.row->height(); - + 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 a vfill bottom - if (parparams.spaceBottom().kind() == VSpace::VFILL) { - int const x = LYX_PAPER_MARGIN / 2; - int const x2 = LYX_PAPER_MARGIN; - 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::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(); - } else if (parparams.spaceBottom().kind() == VSpace::LENGTH) { - string str = string(_("Space below")) - + " (" - + parparams.spaceBottom().asLyXCommand() - + ")"; - - int const space = int(parparams.spaceBottom().inPixels(p.bv)); - int const y = p.yo + y_bottom - space / 2; - - p.pain->line(p.xo, y, p.xo + p.width, y, - LColor::added_space, Painter::line_onoffdash); - - int w = 0; - int a = 0; - int d = 0; - - LyXFont pb_font; - pb_font.setColor(LColor::added_space).decSize(); - lyxfont::rectText(str, pb_font, w, a, d); - - // don't draw if it won't fit - if (a + d + 4 < space) { - p.pain->rectText(p.xo + (p.width - w) / 2, y + d, - str, pb_font, - backgroundColor(), - backgroundColor()); - } - } - - // think about user added space - y_bottom -= int(parparams.spaceBottom().inPixels(p.bv)); - + y_bottom -= paintPageBreak(_("Page Break (bottom)"), + p.yo + y_bottom - 2 * defaultHeight(), p); + } + + // 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); + Buffer const * buffer = p.bv->buffer(); - + // draw a bottom line if (parparams.lineBottom()) { LyXFont font(LyXFont::ALL_SANE); - int const asc = lyxfont::ascent('x', + int const asc = font_metrics::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.x : 0); - int const y = p.yo + y_bottom; - p.pain->line(xp, y, w, y, LColor::topline, Painter::line_solid, + 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; } - 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); - + int const endlabel = par->getEndLabel(); + // draw an endlabel switch (endlabel) { case END_LABEL_BOX: case END_LABEL_FILLED_BOX: { - LyXFont const font = getFont(buffer, par, last); - int const size = int(0.75 * lyxfont::maxAscent(font)); + LyXFont const font = getLabelFont(buffer, par); + int const size = int(0.75 * font_metrics::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->line(x, y, x, y + size, LColor::eolmarker); - p.pain->line(x + size, y, x + size , y + size, LColor::eolmarker); - p.pain->line(x, y, x + size, y, LColor::eolmarker); - p.pain->line(x, y + size, x + size, y + size, LColor::eolmarker); + p.pain->rectangle(x, y, size, size, LColor::eolmarker); } else { - p.pain->fillRectangle(x, y, size, size, LColor::eolmarker); + p.pain->fillRectangle(x, y, size, size, + LColor::eolmarker); } break; } case END_LABEL_STATIC: { +#if 0 LyXFont font(LyXFont::ALL_SANE); - LyXTextClass::LayoutList::size_type layout = par->getLayout(); - string const str = textclasslist. - Style(buffer->params.textclass, layout).endlabelstring(); font = getLabelFont(buffer, par); +#else + LyXFont font = getLabelFont(buffer, par); +#endif + string const & str = par->layout()->endlabelstring(); int const x = is_rtl ? - int(p.x) - lyxfont::width(str, font) + int(p.x) - font_metrics::width(str, font) : ww - rightMargin(buffer, p.row) - p.row->fill(); p.pain->text(x, p.yo + p.row->baseline(), str, font); break; @@ -3499,34 +3603,41 @@ void LyXText::paintLastRow(DrawRowParams & p) } } + void LyXText::paintRowText(DrawRowParams & p) { Paragraph * par = p.row->par(); - Buffer const * buffer = p.bv->buffer(); - + Buffer const * buffer = p.bv->buffer(); + pos_type const last = rowLastPrintable(p.row); - pos_type main_body = + pos_type main_body = beginningOfMainBody(buffer, par); - if (main_body > 0 && - (main_body - 1 > last || + if (main_body > 0 && + (main_body - 1 > last || !par->isLineSeparator(main_body - 1))) { main_body = 0; } - - LyXLayout const & layout = - textclasslist.Style(buffer->params.textclass, par->getLayout()); + + LyXLayout_ptr const & layout = par->layout(); pos_type vpos = p.row->pos(); while (vpos <= last) { + if (p.x > p.bv->workWidth()) + break; pos_type pos = vis2log(vpos); + if (p.x + singleWidth(p.bv, par, pos) < 0) { + p.x += singleWidth(p.bv, par, pos); + ++vpos; + continue; + } if (main_body > 0 && pos == main_body - 1) { - int const lwidth = lyxfont::width(layout.labelsep, + int const lwidth = font_metrics::width(layout->labelsep, getLabelFont(buffer, par)); p.x += p.label_hfill + lwidth - singleWidth(p.bv, par, main_body - 1); } - + if (par->isHfill(pos)) { p.x += 1; @@ -3535,10 +3646,10 @@ void LyXText::paintRowText(DrawRowParams & p) p.pain->line(int(p.x), y1, int(p.x), y0, LColor::added_space); - + 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, @@ -3564,14 +3675,15 @@ void LyXText::paintRowText(DrawRowParams & p) p.x += p.separator; ++vpos; } else { - draw(p.bv, p.row, vpos, p.yo, p.x, p.cleared); + if (!draw(p, vpos)) + break; } } } void LyXText::getVisibleRow(BufferView * bv, int y_offset, int x_offset, - Row * row, int y, bool cleared) + Row * row, int y, bool cleared) { if (row->height() <= 0) { lyxerr << "LYX_ERROR: row.height: " @@ -3594,7 +3706,7 @@ void LyXText::getVisibleRow(BufferView * bv, int y_offset, int x_offset, p.y = y; p.width = inset_owner ? inset_owner->textWidth(bv, true) : bv->workWidth(); p.cleared = cleared; - + // start painting // clear to background if necessary @@ -3610,7 +3722,7 @@ void LyXText::getVisibleRow(BufferView * bv, int y_offset, int x_offset, // environment depth brackets paintRowDepthBar(p); - + // draw any stuff wanted for a first row of a paragraph if (!row->pos()) { paintFirstRow(p); @@ -3619,22 +3731,23 @@ void LyXText::getVisibleRow(BufferView * bv, int y_offset, int x_offset, // 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); + paintRowText(p); } - + int LyXText::defaultHeight() const { LyXFont font(LyXFont::ALL_SANE); - return int(lyxfont::maxAscent(font) + lyxfont::maxDescent(font) * 1.5); + return int(font_metrics::maxAscent(font) + + font_metrics::maxDescent(font) * 1.5); } - -/* returns the column near the specified x-coordinate of the row -* x is set to the real beginning of this column */ + +// returns the column near the specified x-coordinate of the row +// x is set to the real beginning of this column pos_type LyXText::getColumnNearX(BufferView * bview, Row * row, int & x, bool & boundary) const @@ -3643,39 +3756,39 @@ LyXText::getColumnNearX(BufferView * bview, Row * row, int & x, float fill_separator; float fill_hfill; float fill_label_hfill; - + prepareToPrint(bview, row, tmpx, fill_separator, fill_hfill, fill_label_hfill); 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()); + + LyXLayout_ptr const & layout = row->par()->layout(); + bool left_side = false; pos_type main_body = beginningOfMainBody(bview->buffer(), row->par()); float last_tmpx = tmpx; - + if (main_body > 0 && - (main_body - 1 > last || + (main_body - 1 > last || !row->par()->isLineSeparator(main_body - 1))) main_body = 0; - + while (vc <= last && tmpx <= x) { c = vis2log(vc); last_tmpx = tmpx; if (main_body > 0 && c == main_body-1) { tmpx += fill_label_hfill + - lyxfont::width(layout.labelsep, + font_metrics::width(layout->labelsep, getLabelFont(bview->buffer(), row->par())); if (row->par()->isLineSeparator(main_body - 1)) tmpx -= singleWidth(bview, row->par(), main_body-1); } - + if (hfillExpansion(bview->buffer(), row, c)) { - x += singleWidth(bview, row->par(), c); + tmpx += singleWidth(bview, row->par(), c); if (c >= main_body) tmpx += fill_hfill; else @@ -3689,7 +3802,7 @@ LyXText::getColumnNearX(BufferView * bview, Row * row, int & x, tmpx += singleWidth(bview, row->par(), c); ++vc; } - + if ((tmpx + last_tmpx) / 2 > x) { tmpx = last_tmpx; left_side = true; @@ -3700,18 +3813,18 @@ LyXText::getColumnNearX(BufferView * bview, Row * row, int & x, boundary = false; bool const lastrow = lyxrc.rtl_support // This is not needed, but gives - // some speedup if rtl_support=false + // some speedup if rtl_support=false && (!row->next() || row->next()->par() != row->par()); bool const rtl = (lastrow) ? row->par()->isRightToLeftPar(bview->buffer()->params) : false; // If lastrow is false, we don't need to compute - // the value of rtl. + // the value of rtl. if (row->pos() > last) // Row is empty? c = row->pos(); else if (lastrow && - ( ( rtl && left_side && vc == row->pos() && x < tmpx - 5) || - (!rtl && !left_side && vc == last + 1 && x > tmpx + 5) )) + ((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); @@ -3739,23 +3852,23 @@ LyXText::getColumnNearX(BufferView * bview, Row * row, int & x, x = int(tmpx); return c; } - + // returns pointer to a specified row Row * LyXText::getRow(Paragraph * par, pos_type pos, int & y) const { if (!firstrow) return 0; - + Row * tmprow = firstrow; y = 0; - + // find the first row of the specified paragraph while (tmprow->next() && tmprow->par() != par) { y += tmprow->height(); tmprow = tmprow->next(); } - + // now find the wanted row while (tmprow->pos() < pos && tmprow->next() @@ -3764,24 +3877,64 @@ Row * LyXText::getRow(Paragraph * par, pos_type pos, int & y) const y += tmprow->height(); tmprow = tmprow->next(); } - + 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; + do { + tmpy -= tmprow->height(); + tmprow = tmprow->previous(); + } while (tmprow && tmpy - tmprow->height() >= y); + } 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 }