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