#include <cctype>
#include <algorithm>
+#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 "gettext.h"
#include "bufferparams.h"
#include "buffer.h"
-#include "minibuffer.h"
#include "debug.h"
#include "lyxrc.h"
#include "LyXView.h"
-#include "lyxrow.h"
#include "Painter.h"
#include "tracer.h"
#include "font.h"
#include "encoding.h"
#include "lyxscreen.h"
+#include "bufferview_funcs.h"
+#include "language.h"
+#include "lyxfunc.h"
using std::max;
using std::min;
using std::endl;
using std::pair;
-static const int LYX_PAPER_MARGIN = 20;
+namespace {
+
+int const LYX_PAPER_MARGIN = 20;
+
+} // namespace anon
extern int bibitemMaxWidth(BufferView *, LyXFont const &);
int LyXText::workWidth(BufferView * bview) const
{
if (inset_owner) {
- return inset_owner->textWidth(bview->painter());
+ return inset_owner->textWidth(bview);
}
return bview->workWidth();
}
+int LyXText::GetRealCursorX(BufferView * bview) const
+{
+ 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 (!Encoding::is_arabic(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 prev_char = pos > 0 ? par->GetChar(pos-1) : ' ';
+ 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)
- if (!Encoding::IsComposeChar_arabic(par->GetChar(i))) {
+#else
+ for (LyXParagraph::size_type i = pos+1; i < par->size(); ++i)
+#endif
+ if (!Encodings::IsComposeChar_arabic(par->GetChar(i))) {
next_char = par->GetChar(i);
break;
}
- if (Encoding::is_arabic(next_char)) {
- if (Encoding::is_arabic(prev_char))
- return Encoding::TransformChar(c, Encoding::FORM_MEDIAL);
+ if (Encodings::is_arabic(next_char)) {
+ if (Encodings::is_arabic(prev_char))
+ return Encodings::TransformChar(c, Encodings::FORM_MEDIAL);
else
- return Encoding::TransformChar(c, Encoding::FORM_INITIAL);
+ return Encodings::TransformChar(c, Encodings::FORM_INITIAL);
} else {
- if (Encoding::is_arabic(prev_char))
- return Encoding::TransformChar(c, Encoding::FORM_FINAL);
+ if (Encodings::is_arabic(prev_char))
+ return Encodings::TransformChar(c, Encodings::FORM_FINAL);
else
- return Encoding::TransformChar(c, Encoding::FORM_ISOLATED);
+ return Encodings::TransformChar(c, Encodings::FORM_ISOLATED);
}
}
int LyXText::SingleWidth(BufferView * bview, LyXParagraph * par,
LyXParagraph::size_type pos, char c) const
{
- LyXFont font = GetFont(bview->buffer(), par, pos);
+ LyXFont const font = GetFont(bview->buffer(), par, pos);
// The most common case is handled first (Asger)
if (IsPrintable(c)) {
if (font.language()->lang() == "arabic" &&
(lyxrc.font_norm_type == LyXRC::ISO_8859_6_8 ||
lyxrc.font_norm_type == LyXRC::ISO_10646_1))
- if (Encoding::IsComposeChar_arabic(c))
+ if (Encodings::IsComposeChar_arabic(c))
return 0;
else
c = TransformChar(c, par, pos);
else if (font.language()->lang() == "hebrew" &&
- Encoding::IsComposeChar_hebrew(c))
+ Encodings::IsComposeChar_hebrew(c))
return 0;
}
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
{
+#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;
+#endif
}
LyXParagraph::size_type LyXText::RowLastPrintable(Row const * row) const
{
- LyXParagraph::size_type last = RowLast(row);
+ LyXParagraph::size_type const last = RowLast(row);
if (last >= row->pos()
&& row->next()
&& row->next()->par() == row->par()
log2vis_list[bidi_end + 1 - bidi_start] = -1;
LyXParagraph::size_type stack[2];
- bool rtl_par = row->par()->getParLanguage(buf->params)->RightToLeft();
+ bool const rtl_par =
+ row->par()->getParLanguage(buf->params)->RightToLeft();
int level = 0;
bool rtl = false;
bool rtl0 = false;
- LyXParagraph::size_type main_body = BeginningOfMainBody(buf, row->par());
+ 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 pos =
+ 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;
+ }
+
+
bool new_rtl = font.isVisibleRightToLeft();
bool new_rtl0 = font.isRightToLeft();
int new_level;
if (lpos == main_body - 1
&& row->pos() < main_body - 1
- && row->par()->IsLineSeparator(lpos)) {
+ && is_space) {
new_level = (rtl_par) ? 1 : 0;
new_rtl = new_rtl0 = rtl_par;
} else if (new_rtl0)
}
while (level > 0) {
- LyXParagraph::size_type old_lpos = stack[--level];
+ LyXParagraph::size_type const old_lpos = stack[--level];
int delta = bidi_end - old_lpos;
if (level % 2)
delta = -delta;
bool LyXText::IsBoundary(Buffer const * buf, LyXParagraph * par,
LyXParagraph::size_type pos) const
{
- if (!lyxrc.rtl_support)
- return false; // This is just for speedup
+ if (!lyxrc.rtl_support || pos == 0)
+ return false;
- if (!bidi_InRange(pos - 1))
+ 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 rtl2 = rtl;
- if (pos == par->Last())
- rtl2 = par->isRightToLeftPar(buf->params);
- else if (bidi_InRange(pos))
- rtl2 = bidi_level(pos) % 2;
+ bool const rtl2 = bidi_InRange(pos)
+ ? bidi_level(pos) % 2
+ : par->isRightToLeftPar(buf->params);
return rtl != rtl2;
}
return false; // This is just for speedup
bool const rtl = font.isVisibleRightToLeft();
- bool rtl2 = rtl;
- if (pos == par->Last())
- rtl2 = par->isRightToLeftPar(buf->params);
- else if (bidi_InRange(pos))
- rtl2 = bidi_level(pos) % 2;
+ bool const rtl2 = bidi_InRange(pos)
+ ? bidi_level(pos) % 2
+ : par->isRightToLeftPar(buf->params);
return rtl != rtl2;
}
if (IsNewlineChar(c)) {
++vpos;
// Draw end-of-line marker
- LyXFont font = GetFont(bview->buffer(), row->par(), pos);
- int wid = lyxfont::width('n', font);
- int asc = lyxfont::maxAscent(font);
- int y = offset + row->baseline();
- int xp[3], yp[3];
+ LyXFont const font = GetFont(bview->buffer(), row->par(), pos);
+ int const wid = lyxfont::width('n', font);
+ int const asc = lyxfont::maxAscent(font);
+ int const y = offset + row->baseline();
+ int xp[3];
+ int yp[3];
if (bidi_level(pos) % 2 == 0) {
xp[0] = int(x + wid * 0.375);
font.decSize();
// calculate the position of the footnotemark
- int y = (row->baseline() - lyxfont::maxAscent(font2)
- + lyxfont::maxAscent(font));
+ int const y = (row->baseline() - lyxfont::maxAscent(font2)
+ + lyxfont::maxAscent(font));
font.setColor(LColor::footnote);
// 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()->lang() != "default" &&
- font.language() != bview->buffer()->params.language_info) {
- int y = offset + row->height() - 1;
+ font.language() != bview->buffer()->params.language) {
+ int const y = offset + row->height() - 1;
pain.line(int(tmpx), y, int(x), y,
LColor::language);
}
textstring = c;
++vpos;
- LyXParagraph::size_type last = RowLastPrintable(row);
+ LyXParagraph::size_type const last = RowLastPrintable(row);
if (font.language()->lang() == "hebrew") {
- if (Encoding::IsComposeChar_hebrew(c)) {
- int width = lyxfont::width(c, font2);
+ 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 (!Encoding::IsComposeChar_hebrew(c)) {
+ if (!Encodings::IsComposeChar_hebrew(c)) {
if (IsPrintableNonspace(c)) {
- int width2 = SingleWidth(bview, row->par(), i, c);
+ int const width2 =
+ SingleWidth(bview,
+ row->par(),
+ i, c);
dx = (c == 'ø' || c == 'ã') // dalet / resh
? width2 - width : (width2 - width) / 2;
}
while (vpos <= last &&
(pos = vis2log(vpos)) >= 0
&& IsPrintableNonspace(c = row->par()->GetChar(pos))
- && !Encoding::IsComposeChar_hebrew(c)
+ && !Encodings::IsComposeChar_hebrew(c)
&& font2 == GetFont(bview->buffer(), row->par(), pos)) {
textstring += c;
++vpos;
} else if (font.language()->lang() == "arabic" &&
(lyxrc.font_norm_type == LyXRC::ISO_8859_6_8 ||
lyxrc.font_norm_type == LyXRC::ISO_10646_1)) {
- if (Encoding::IsComposeChar_arabic(c)) {
+ if (Encodings::IsComposeChar_arabic(c)) {
c = TransformChar(c, row->par(), pos);
textstring = c;
- int width = lyxfont::width(c, font2);
+ 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 (!Encoding::IsComposeChar_arabic(c)) {
+ if (!Encodings::IsComposeChar_arabic(c)) {
if (IsPrintableNonspace(c)) {
- int width2 = SingleWidth(bview, row->par(), i, c);
+ int const width2 =
+ SingleWidth(bview,
+ row->par(),
+ i, c);
dx = (width2 - width) / 2;
}
break;
while (vpos <= last &&
(pos = vis2log(vpos)) >= 0
&& IsPrintableNonspace(c = row->par()->GetChar(pos))
- && !Encoding::IsComposeChar_arabic(c)
+ && !Encodings::IsComposeChar_arabic(c)
&& font2 == GetFont(bview->buffer(), row->par(), pos)) {
c = TransformChar(c, row->par(), pos);
textstring += c;
}
if (lyxrc.mark_foreign_language &&
- font.language()->lang() != "default" &&
- font.language() != bview->buffer()->params.language_info) {
- int y = offset + row->height() - 1;
+ font.language() != bview->buffer()->params.language) {
+ int const y = offset + row->height() - 1;
pain.line(int(tmpx), y, int(x), y,
LColor::language);
}
if (!row->par()->GetLayout()) {
// find the previous same level paragraph
#ifndef NEW_INSETS
- if (row->par()->FirstPhysicalPar()->Previous()) {
+ if (row->par()->FirstPhysicalPar()->previous()) {
#else
- if (row->par()->Previous()) {
+ if (row->par()->previous()) {
#endif
LyXParagraph * newpar = row->par()
->DepthHook(row->par()->GetDepth());
newpar->GetLayout()).isEnvironment()) {
Row 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
// a layout. Since there is always a redo,
// LeftMargin() is always called
#ifndef NEW_INSETS
- row->par()->FirstPhysicalPar()->depth = 0;
+ row->par()->FirstPhysicalPar()->params.depth(0);
#else
- row->par()->depth = 0;
+ row->par()->params.depth(0);
#endif
}
if (newpar && !row->par()->GetLayout()) {
#ifndef NEW_INSETS
- if (newpar->FirstPhysicalPar()->noindent)
+ if (newpar->FirstPhysicalPar()->params.noindent())
#else
- if (newpar->noindent)
+ if (newpar->params.noindent())
#endif
parindent.erase();
else
}
break;
}
+#ifndef NO_PEXTRA
if ((workWidth(bview) > 0) &&
- (row->par()->pextra_type == LyXParagraph::PEXTRA_INDENT)) {
- if (!row->par()->pextra_widthp.empty()) {
+ (row->par()->params.pextraType() == LyXParagraph::PEXTRA_INDENT)) {
+ if (!row->par()->params.pextraWidthp().empty()) {
x += workWidth(bview) *
- lyx::atoi(row->par()->pextra_widthp) / 100;
- } else if (!row->par()->pextra_width.empty()) {
- int xx = VSpace(row->par()->pextra_width).inPixels(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;
x += lyxfont::width("XXXXXX", font);
}
}
+#endif
int align; // wrong type
#ifndef NEW_INSETS
- if (row->par()->FirstPhysicalPar()->align == LYX_ALIGN_LAYOUT)
+ 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()->align == LYX_ALIGN_LAYOUT)
+ if (row->par()->params.align() == LYX_ALIGN_LAYOUT)
align = layout.align;
else
- align = row->par()->align;
+ align = row->par()->params.align();
#endif
// set the correct parindent
if (row->pos() == 0) {
&& row->par() == row->par()->FirstPhysicalPar()
#endif
&& align == LYX_ALIGN_BLOCK
- && !row->par()->noindent
+ && !row->par()->params.noindent()
&& (row->par()->layout ||
bview->buffer()->params.paragraph_separation ==
BufferParams::PARSEP_INDENT))
#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);
#else
do {
- newpar = newpar->Previous();
+ newpar = newpar->previous();
} while (newpar
&& newpar->GetDepth() >= row->par()->GetDepth());
#endif
// a layout. Since there is always a redo,
// LeftMargin() is always called
#ifndef NEW_INSETS
- row->par()->FirstPhysicalPar()->depth = 0;
+ row->par()->FirstPhysicalPar()->params.depth(0);
#else
- row->par()->depth = 0;
+ row->par()->params.depth(0);
#endif
}
}
}
-int LyXText::LabelEnd (BufferView * bview, Row const * row) const
+int LyXText::LabelEnd(BufferView * bview, Row const * row) const
{
if (textclasslist.Style(bview->buffer()->params.textclass,
row->par()->GetLayout()).margintype
== MARGIN_MANUAL) {
Row tmprow;
tmprow = *row;
+#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
LyXText::NextBreakPoint(BufferView * bview, Row const * row, int width) const
{
LyXParagraph * par = row->par();
- LyXParagraph::size_type pos = row->pos();
if (width < 0)
+#ifndef NEW_INSETS
return par->Last();
+#else
+ return par->size();
+#endif
+
+ LyXParagraph::size_type const pos = row->pos();
+
// position of the last possible breakpoint
// -1 isn't a suitable value, but a flag
LyXParagraph::size_type last_separator = -1;
width -= RightMargin(bview->buffer(), row);
- LyXParagraph::size_type main_body = BeginningOfMainBody(bview->buffer(), par);
+ LyXParagraph::size_type const main_body =
+ BeginningOfMainBody(bview->buffer(), par);
LyXLayout const & layout =
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(bview, row);
bool doitonetime = true;
while (doitonetime || ((x < width) && (i < last))) {
doitonetime = false;
- char c = par->GetChar(i);
+ char const c = par->GetChar(i);
if (IsNewlineChar(c)) {
last_separator = i;
x = width; // this means break
// non-display
if (par->GetInset(i)->display() &&
(layout.isCommand() ||
- ((layout.labeltype == LABEL_MANUAL) &&
- (i < BeginningOfMainBody(bview->buffer(), par))))) {
+ (layout.labeltype == LABEL_MANUAL
+ && i < BeginningOfMainBody(bview->buffer(), par)))) {
// display istn't allowd
par->GetInset(i)->display(false);
x += SingleWidth(bview, par, i, c);
int LyXText::Fill(BufferView * bview, Row * row, int paper_width) const
{
if (paper_width < 0)
- return 0;
+ return 20;
int w;
// get the pure distance
- LyXParagraph::size_type last = RowLastPrintable(row);
+ LyXParagraph::size_type const last = RowLastPrintable(row);
// special handling of the right address boxes
if (textclasslist.Style(bview->buffer()->params.textclass,
row->par()->GetLayout()).margintype
== MARGIN_RIGHT_ADDRESS_BOX) {
- int tmpfill = row->fill();
+ int const tmpfill = row->fill();
row->fill(0); // the minfill in MarginLeft()
w = LeftMargin(bview, row);
row->fill(tmpfill);
LyXLayout const & layout = textclasslist.Style(bview->buffer()->params.textclass,
row->par()->GetLayout());
- LyXParagraph::size_type main_body =
+ LyXParagraph::size_type const main_body =
BeginningOfMainBody(bview->buffer(), row->par());
LyXParagraph::size_type i = row->pos();
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 left_margin = LabelEnd(bview, row);
+ int const left_margin = LabelEnd(bview, row);
if (w < left_margin)
w = left_margin;
}
int const fill = paper_width - w - RightMargin(bview->buffer(), row);
+ if (fill < 0)
+ return 0;
return fill;
}
}
int fill = 0;
- if (!row->par()->labelwidthstring.empty()) {
- fill = max(lyxfont::width(row->par()->labelwidthstring,
+ if (!row->par()->params.labelWidthString().empty()) {
+ fill = max(lyxfont::width(row->par()->params.labelWidthString(),
GetFont(bview->buffer(), row->par(), -2)) - w,
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;
+ int unused_y;
GetRow(row_ptr->par(), row_ptr->pos(), unused_y);
/* ok , let us initialize the maxasc and maxdesc value.
LyXLayout const & layout = textclasslist.Style(bview->buffer()->params.textclass,
firstpar->GetLayout());
-
+
+#ifndef NEW_INSETS
LyXFont font = GetFont(bview->buffer(), par, par->Last() - 1);
- LyXFont::FONT_SIZE size = font.size();
+#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(bview->buffer(), par, -2);
float spacing_val = 1.0;
- if (!row_ptr->par()->spacing.isDefault()) {
- spacing_val = row_ptr->par()->spacing.getValue();
+ if (!row_ptr->par()->params.spacing().isDefault()) {
+ spacing_val = row_ptr->par()->params.spacing().getValue();
} else {
spacing_val = bview->buffer()->params.spacing.getValue();
}
int maxdesc = int(lyxfont::maxDescent(font) *
layout.spacing.getValue() *
spacing_val);
- int pos_end = RowLast(row_ptr);
+ int const pos_end = RowLast(row_ptr);
int labeladdon = 0;
int maxwidth = 0;
tmpfont = GetFont(bview->buffer(), row_ptr->par(), pos);
tmpinset = row_ptr->par()->GetInset(pos);
if (tmpinset) {
- tmpinset->update(bview, tmpfont);
+// tmpinset->update(bview, tmpfont);
asc = tmpinset->ascent(bview, tmpfont);
desc = tmpinset->descent(bview, tmpfont);
maxwidth += tmpinset->width(bview, tmpfont);
// 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 =
+ LyXFont::FONT_SIZE const maxsize =
row_ptr->par()->HighestFontInRange(row_ptr->pos(),
pos_end);
if (maxsize > font.size()) {
row_ptr->ascent_of_text(maxasc);
- /* is it a top line? */
+ // is it a top line?
if (!row_ptr->pos() && (row_ptr->par() == firstpar)) {
- /* some parksips VERY EASY IMPLEMENTATION */
+ // some parksips VERY EASY IMPLEMENTATION
if (bview->buffer()->params.paragraph_separation ==
BufferParams::PARSEP_SKIP) {
if (layout.isParagraph()
&& firstpar->GetDepth() == 0
- && firstpar->Previous())
+ && firstpar->previous())
maxasc += bview->buffer()->params.getDefSkip().inPixels(bview);
- else if (firstpar->Previous()
+ else if (firstpar->previous()
&& textclasslist.Style(bview->buffer()->params.textclass,
- firstpar->Previous()->GetLayout()).isParagraph()
- && firstpar->Previous()->GetDepth() == 0)
+ firstpar->previous()->GetLayout()).isParagraph()
+ && firstpar->previous()->GetDepth() == 0)
// is it right to use defskip here too? (AS)
maxasc += bview->buffer()->params.getDefSkip().inPixels(bview);
}
- /* the paper margins */
- if (!row_ptr->par()->previous && bv_owner)
+ // 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(bview));
+ // 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)
+ // 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
&& bview->buffer()->params.secnumdepth >= 0) {
float spacing_val = 1.0;
- if (!row_ptr->par()->spacing.isDefault()) {
- spacing_val = row_ptr->par()->spacing.getValue();
+ if (!row_ptr->par()->params.spacing().isDefault()) {
+ spacing_val = row_ptr->par()->params.spacing().getValue();
} else {
spacing_val = bview->buffer()->params.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()->GetLabelstring().empty()) {
float spacing_val = 1.0;
- if (!row_ptr->par()->spacing.isDefault()) {
- spacing_val = row_ptr->par()->spacing.getValue();
+ if (!row_ptr->par()->params.spacing().isDefault()) {
+ spacing_val = row_ptr->par()->params.spacing().getValue();
} else {
spacing_val = bview->buffer()->params.spacing.getValue();
}
+ 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());
if (prev && prev->GetLayout() == firstpar->GetLayout()
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)
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? */
+ // 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())) {
+ && (!row_ptr->next() || row_ptr->next()->par() != row_ptr->par())) {
- /* the paper margins */
- if (!par->next && bv_owner)
+ // 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(bview));
+#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)
+ // 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();
+ // 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;
}
}
- /* incalculate the layout spaces */
+ // incalculate the layout spaces
maxasc += int(layoutasc * 2 / (2 + firstpar->GetDepth()));
maxdesc += int(layoutdesc * 2 / (2 + firstpar->GetDepth()));
- /* calculate the new height of the text */
+ // calculate the new height of the text
height -= row_ptr->height();
row_ptr->height(maxasc + maxdesc + labeladdon);
// The last character position of a paragraph is an invariant so we can
// safely get it here. (Asger)
+#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(bview, row, workWidth(bview));
bool not_ready = true;
do {
- /* get the next breakpoint */
+ // get the next breakpoint
LyXParagraph::size_type z = NextBreakPoint(bview, row, workWidth(bview));
Row * tmprow = row;
-
- if (z < row->par()->Last() ) {
+
+#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;
// get the next breakpoint
LyXParagraph::size_type z = NextBreakPoint(bview, row, workWidth(bview));
Row * tmprow = row;
-
- if (z < row->par()->Last() ) {
+
+#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 */
cursor.par()->GetLayout());
// this is only allowed, if the current paragraph is not empty or caption
- if ((cursor.par()->Last() <= 0
#ifndef NEW_INSETS
- && !cursor.par()->IsDummy()
-#endif
- )
- &&
- layout.labeltype!= LABEL_SENSITIVE)
- return;
+ if ((cursor.par()->Last() <= 0
+ && !cursor.par()->IsDummy())
+ && layout.labeltype!= LABEL_SENSITIVE)
+ return;
SetUndo(bview->buffer(), Undo::INSERT,
-#ifndef NEW_INSETS
- cursor.par()->ParFromPos(cursor.pos())->previous,
- cursor.par()->ParFromPos(cursor.pos())->next
+ cursor.par()->ParFromPos(cursor.pos())->previous_,
+ cursor.par()->ParFromPos(cursor.pos())->next_);
#else
- cursor.par()->previous,
- cursor.par()->next
+ if ((cursor.par()->size() <= 0)
+ && layout.labeltype!= LABEL_SENSITIVE)
+ return;
+
+ SetUndo(bview->buffer(), Undo::INSERT,
+ cursor.par()->previous(),
+ cursor.par()->next());
#endif
- );
- // please break always behind a space
+ // 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.pos(cursor.pos() + 1);
-
+ cursor.par()->Erase(cursor.pos());
+ // cursor.pos(cursor.pos() + 1);
+
// break the paragraph
if (keep_layout)
keep_layout = 2;
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
// set to standard-layout
- cursor.par()->Next()->SetLayout(bview->buffer()->params, 0);
+#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()) {
+ if (cursor.pos() && !cursor.row()->par()->IsNewline(cursor.row()->pos() - 1)
+ && cursor.row()->pos() == cursor.pos()) {
CursorLeft(bview);
}
cursor.row()->fill(Fill(bview, cursor.row(), workWidth(bview)));
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);
- while (cursor.par()->Next()->Last()
- && cursor.par()->Next()->IsNewline(0))
- cursor.par()->Next()->Erase(0);
-
- InsertParagraph(bview, cursor.par()->Next(), cursor.row());
+ InsertParagraph(bview, cursor.par()->next(), cursor.row());
UpdateCounters(bview, cursor.row()->previous());
/* This check is necessary. Otherwise the new empty paragraph will
* be deleted automatically. And it is more friendly for the user! */
if (cursor.pos())
- SetCursor(bview, cursor.par()->Next(), 0);
+ SetCursor(bview, cursor.par()->next(), 0);
else
SetCursor(bview, cursor.par(), 0);
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 */
refresh_y = cursor.y() - cursor.row()->baseline();
tmppar = cursor.par();
- endpar = cursor.par()->Next();
+ endpar = cursor.par()->next();
row = cursor.row();
tmppar->OpenFootnote(cursor.pos());
row->fill(Fill(bview, row, workWidth(bview)));
SetHeightOfRow(bview, row);
// CHECK See comment on top of text.C
- tmppar = tmppar->Next();
+ tmppar = tmppar->next();
while (tmppar != endpar) {
if (tmppar) {
InsertParagraph(bview, tmppar, row);
while (row->next() && row->next()->par() == tmppar)
row = row->next();
- tmppar = tmppar->Next();
+ tmppar = tmppar->next();
}
}
- SetCursor(bview, par->next, 0);
+ SetCursor(bview, par->next_, 0);
sel_cursor = cursor;
}
#endif
// Just a macro to make some thing easier.
void LyXText::RedoParagraph(BufferView * bview) const
{
- ClearSelection();
- RedoParagraphs(bview, cursor, cursor.par()->Next());
+ ClearSelection(bview);
+ RedoParagraphs(bview, cursor, cursor.par()->next());
SetCursorIntern(bview, cursor.par(), cursor.pos());
}
{
SetUndo(bview->buffer(), Undo::INSERT,
#ifndef NEW_INSETS
- cursor.par()->ParFromPos(cursor.pos())->previous,
- cursor.par()->ParFromPos(cursor.pos())->next
+ cursor.par()->ParFromPos(cursor.pos())->previous_,
+ cursor.par()->ParFromPos(cursor.pos())->next_
#else
- cursor.par()->previous,
- cursor.par()->next
+ cursor.par()->previous(),
+ cursor.par()->next()
#endif
);
// When the free-spacing option is set for the current layout,
// disable the double-space checking
- bool freeSpacing =
+ 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);
+ }
+ }
+ }
+ }
+
+
/* 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
* current font */
// Get the font that is used to calculate the baselineskip
- LyXParagraph::size_type lastpos = cursor.par()->Last();
+#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);
&& cursor.par()->IsNewline(cursor.pos() - 1))
|| (cursor.pos() == 0
#ifndef NEW_INSETS
- && !(cursor.par()->Previous()
- && cursor.par()->Previous()->footnoteflag
+ && !(cursor.par()->previous()
+ && cursor.par()->previous()->footnoteflag
== LyXParagraph::OPEN_FOOTNOTE)
#endif
)) {
if (cursor.pos() == 0 )
- bview->owner()->getMiniBuffer()->Set(_("You cannot insert a space at the beginning of a paragraph. Please read the Tutorial."));
+ bview->owner()->getLyXFunc()
+ ->Dispatch(LFUN_MESSAGE,
+ _("You cannot insert a space at the beginning of a paragraph. Please read the Tutorial."));
else
- bview->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;
}
/* No newline at first position
* of a paragraph or behind labels.
* TeX does not allow that. */
-
+
+#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);
// get the cursor row fist
Row * row = cursor.row();
- long y = cursor.y() - row->baseline();
+ 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);
LyXParagraph::size_type z = NextBreakPoint(bview,
row->previous(),
workWidth(bview));
- if ( z >= row->pos()) {
+ if (z >= row->pos()) {
row->pos(z + 1);
// set the dimensions of the row above
else
need_break_row = 0;
- // check, wether the last characters font has changed.
+ // 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(bview, cursor);
* will set fill to -1. Otherwise
* we would not get a rebreak! */
row->fill(Fill(bview, row, workWidth(bview)));
- if (row->fill() < 0 ) {
+ if (row->fill() < 0) {
refresh_y = y;
refresh_row = row;
refresh_x = cursor.x();
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
refresh_row = row;
refresh_pos = cursor.pos();
- int tmpheight = row->height();
+ int const tmpheight = row->height();
SetHeightOfRow(bview, row);
if (tmpheight == row->height())
status = LyXText::NEED_VERY_LITTLE_REFRESH;
}
// 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(bview, cursor);
} else {
fill_separator = 0;
fill_label_hfill = 0;
- bool is_rtl = row->par()->isRightToLeftPar(bview->buffer()->params);
-#ifndef NEW_INSETS
-
+ bool const is_rtl =
+ row->par()->isRightToLeftPar(bview->buffer()->params);
if (is_rtl) {
- x = RightMargin(bview->buffer(), row);
+ x = (workWidth(bview) > 0)
+ ? RightMargin(bview->buffer(), row) : 0;
+#ifndef NEW_INSETS
if (row->par()->footnoteflag == LyXParagraph::OPEN_FOOTNOTE) {
LyXFont font(LyXFont::ALL_SANE);
font.setSize(LyXFont::SIZE_SMALL);
x += lyxfont::width("Mwide-figM", font);
}
- } else
#endif
- if (workWidth(bview) > 0)
- x = LeftMargin(bview, row);
- else
- x = 0;
+ } else
+ x = (workWidth(bview) > 0) ? LeftMargin(bview, row) : 0;
// is there a manual margin with a manual label
if (textclasslist.Style(bview->buffer()->params.textclass,
// set x how you need it
int align;
#ifndef NEW_INSETS
- if (row->par()->FirstPhysicalPar()->align == LYX_ALIGN_LAYOUT)
+ 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()->align;
+ align = row->par()->FirstPhysicalPar()->params.align();
#else
- if (row->par()->align == LYX_ALIGN_LAYOUT)
+ if (row->par()->params.align() == LYX_ALIGN_LAYOUT)
align = textclasslist.Style(bview->buffer()->params.textclass, row->par()->GetLayout()).align;
else
- align = row->par()->align;
+ align = row->par()->params.align();
#endif
// center displayed insets
if (row->par()->GetChar(row->pos()) == LyXParagraph::META_INSET
&& (inset=row->par()->GetInset(row->pos()))
&& (inset->display())) // || (inset->scroll() < 0)))
- align = LYX_ALIGN_CENTER;
+ align = (inset->LyxCode() == Inset::MATHMACRO_CODE)
+ ? LYX_ALIGN_BLOCK : LYX_ALIGN_CENTER;
switch (align) {
case LYX_ALIGN_BLOCK:
LyXCursor tmpcursor = cursor;
// CHECK See comment on top of text.C
+#ifndef NEW_INSETS
if (tmpcursor.pos() == tmpcursor.par()->Last()
- && tmpcursor.par()->Next()) {
- tmpcursor.par(tmpcursor.par()->Next());
+#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() &&
+#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()) ;
++steps;
}
// Advance through word.
- while ( tmpcursor.pos() < tmpcursor.par()->Last() &&
+#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()) ;
void LyXText::CursorTab(BufferView * bview) const
{
LyXCursor tmpcursor = cursor;
+#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()){
- if (tmpcursor.par()->Next()) {
- tmpcursor.par(tmpcursor.par()->Next());
+#else
+ if (tmpcursor.pos() == tmpcursor.par()->size()){
+#endif
+ if (tmpcursor.par()->next()) {
+ tmpcursor.par(tmpcursor.par()->next());
tmpcursor.pos(0);
}
} else
|| tmpcursor.par()->IsHfill(tmpcursor.pos() - 1))) {
tmpcursor.pos(tmpcursor.pos() - 1);
} else if (!tmpcursor.pos()) {
- if (tmpcursor.par()->Previous()){
- tmpcursor.par(tmpcursor.par()->Previous());
+ 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 &&
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) )
+ if (cursor.pos()
+ && !cursor.par()->IsSeparator(cursor.pos()-1)
+ && !cursor.par()->IsKomma(cursor.pos()-1) )
CursorLeftOneWord(bview);
// set the sel cursor
sel_cursor = cursor;
- while ( cursor.pos() < cursor.par()->Last()
- && !cursor.par()->IsSeparator(cursor.pos())
- && !cursor.par()->IsKomma(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();
+ SetSelection(bview);
}
bool LyXText::SelectWordWhenUnderCursor(BufferView * bview)
{
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) ) {
+ && !cursor.par()->IsKomma(cursor.pos() -1)) {
SelectWord(bview);
return true;
}
// 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) {
+#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)
+#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))
- || (cursor.par()->Last() == cursor.pos()
- && cursor.par()->Next())){
+#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()) {
- cursor.par(cursor.par()->Next());
+#else
+ if (cursor.pos() == cursor.par()->size()) {
+#endif
+ cursor.par(cursor.par()->next());
cursor.pos(0);
} else
cursor.pos(cursor.pos() + 1);
// and find the end of the word
// (optional hyphens are part of a word)
+#ifndef NEW_INSETS
while (cursor.pos() < cursor.par()->Last()
+#else
+ 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
std::ostringstream latex;
// now find the end of the word
+#ifndef NEW_INSETS
while (cursor.pos() < cursor.par()->Last()
+#else
+ 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
SetCursor(bview, cursor.par(), cursor.pos());
// finally set the selection
- SetSelection();
+ SetSelection(bview);
}
/* -------> Delete from cursor up to the end of the current or next word. */
void LyXText::DeleteWordForward(BufferView * bview)
{
+#ifndef NEW_INSETS
if (!cursor.par()->Last())
+#else
+ if (!cursor.par()->size())
+#endif
CursorRight(bview);
else {
LyXCursor tmpcursor = cursor;
SetCursor(bview, tmpcursor, tmpcursor.par(), tmpcursor.pos());
sel_cursor = cursor;
cursor = tmpcursor;
- SetSelection();
+ SetSelection(bview);
/* -----> Great, CutSelection() gets rid of multiple spaces. */
CutSelection(bview);
/* -------> Delete from cursor to start of current or prior word. */
void LyXText::DeleteWordBackward(BufferView * bview)
{
+#ifndef NEW_INSETS
if (!cursor.par()->Last())
+#else
+ if (!cursor.par()->size())
+#endif
CursorLeft(bview);
else {
LyXCursor tmpcursor = cursor;
SetCursor(bview, tmpcursor, tmpcursor.par(), tmpcursor.pos());
sel_cursor = cursor;
cursor = tmpcursor;
- SetSelection();
+ SetSelection(bview);
CutSelection(bview);
}
}
/* -------> Kill to end of line. */
void LyXText::DeleteLineForward(BufferView * bview)
{
+#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 {
SetCursor(bview, tmpcursor, tmpcursor.par(), tmpcursor.pos());
sel_cursor = cursor;
cursor = tmpcursor;
- SetSelection();
+ SetSelection(bview);
// What is this test for ??? (JMarc)
if (!selection) {
DeleteWordForward(bview);
{
#ifndef NEW_INSETS
LyXParagraph * tmppar = cursor.par()->ParFromPos(cursor.pos());
-#else
- LyXParagraph * tmppar = cursor.par();
-#endif
- SetUndo(bview->buffer(),Undo::FINISH, tmppar->previous, tmppar->next);
+ SetUndo(bview->buffer(),Undo::FINISH,
+ tmppar->previous_, tmppar->next_);
-#ifndef NEW_INSETS
LyXParagraph::size_type tmppos =
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->GetChar(tmppos);
if (IsKommaChar(c) || IsLineSeparatorChar(c))
// 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
CursorRight(bview);
// 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 ((cursor.par()->previous ? cursor.par()->previous->id() : 0)
+ if (
+#ifndef NEW_INSETS
+ (cursor.par()->previous_ ? cursor.par()->previous_->id() : 0)
+#else
+ (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
cursor = old_cursor; // to make sure undo gets the right cursor position
SetUndo(bview->buffer(), Undo::DELETE,
#ifndef NEW_INSETS
- cursor.par()->ParFromPos(cursor.pos())->previous,
- cursor.par()->ParFromPos(cursor.pos())->next
+ cursor.par()->ParFromPos(cursor.pos())->previous_,
+ cursor.par()->ParFromPos(cursor.pos())->next_
#else
- cursor.par()->previous,
- cursor.par()->next
+ cursor.par()->previous(),
+ cursor.par()->next()
#endif
);
cursor = tmpcursor;
void LyXText::Backspace(BufferView * bview)
{
// Get the font that is used to calculate the baselineskip
+#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 ((lastpos == 0
|| (lastpos == 1 && cursor.par()->IsSeparator(0)))
#ifndef NEW_INSETS
- && !(cursor.par()->Next()
+ && !(cursor.par()->next()
&& cursor.par()->footnoteflag == LyXParagraph::NO_FOOTNOTE
- && cursor.par()->Next()->footnoteflag == LyXParagraph::OPEN_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) {
#ifndef NEW_INSETS
- LyXParagraph * tmppar = cursor.par()->previous->FirstPhysicalPar();
-#else
- LyXParagraph * tmppar = cursor.par()->previous;
-#endif
+ if (cursor.par()->previous_) {
+ LyXParagraph * tmppar = cursor.par()->previous_->FirstPhysicalPar();
if (cursor.par()->GetLayout() == tmppar->GetLayout()
-#ifndef NEW_INSETS
&& 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 botom DTD from the paragraph below.
+ // 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());
}
CursorLeft(bview);
// the layout things can change the height of a row !
- int tmpheight = cursor.row()->height();
+ int const tmpheight = cursor.row()->height();
SetHeightOfRow(bview, cursor.row());
if (cursor.row()->height() != tmpheight) {
refresh_y = cursor.y() - cursor.row()->baseline();
}
#ifndef NEW_INSETS
- if (cursor.par()->ParFromPos(cursor.pos())->previous){
+ 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);
+ cursor.par()->ParFromPos(cursor.pos())->previous_->previous_,
+ cursor.par()->ParFromPos(cursor.pos())->next_);
}
#else
- if (cursor.par()->previous) {
+ if (cursor.par()->previous()) {
SetUndo(bview->buffer(), Undo::DELETE,
- cursor.par()->previous->previous,
- cursor.par()->next);
+ cursor.par()->previous()->previous(),
+ cursor.par()->next());
}
#endif
// not a good idea since it triggers the auto-delete
// mechanism. So we do a CursorLeftIntern()-lite,
// without the dreaded mechanism. (JMarc)
- if (cursor.par()->Previous()) {
+ if (cursor.par()->previous()) {
// steps into the above paragraph.
- SetCursorIntern(bview, cursor.par()->Previous(),
- cursor.par()->Previous()->Last(), false);
+#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
* any paragraphs */
SetUndo(bview->buffer(), Undo::DELETE,
#ifndef NEW_INSETS
- cursor.par()->ParFromPos(cursor.pos())->previous,
- cursor.par()->ParFromPos(cursor.pos())->next
+ cursor.par()->ParFromPos(cursor.pos())->previous_,
+ cursor.par()->ParFromPos(cursor.pos())->next_
#else
- cursor.par()->previous,
- cursor.par()->next
+ cursor.par()->previous(),
+ cursor.par()->next()
#endif
);
// We used to do CursorLeftIntern() here, but it is
}
Row * row = cursor.row();
- long y = cursor.y() - row->baseline();
+ 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.par()->IsLineSeparator(cursor.pos() - 1))
cursor.pos(cursor.pos() - 1);
-
- if (cursor.pos() < cursor.par()->Last() && !cursor.par()->IsSeparator(cursor.pos())) {
+
+#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()) {
}
// delete newlines at the beginning of paragraphs
+#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())) {
if (row->previous() && row->previous()->par() == row->par()) {
z = NextBreakPoint(bview, row->previous(),
workWidth(bview));
- if ( z >= row->pos()) {
+ if (z >= row->pos()) {
row->pos(z + 1);
Row * tmprow = row->previous();
// maybe the current row is now empty
+#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;
//current_font = rawtmpfont;
//real_current_font = realtmpfont;
// check, whether the last character's font has changed.
+#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
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 ;-) */
+ * 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;
status = LyXText::NEED_MORE_REFRESH;
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());
- // cursor MUST be in row now
-
- need_break_row = row->next();
+
+ 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(bview, row, workWidth(bview)));
- int tmpheight = row->height();
+ int const tmpheight = row->height();
SetHeightOfRow(bview, row);
if (tmpheight == row->height())
status = LyXText::NEED_VERY_LITTLE_REFRESH;
// 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();
- if (cursor.pos() == lastpos) {
- if (IsBoundary(bview->buffer(), cursor.par(), cursor.pos()) != cursor.boundary())
- SetCursor(bview, cursor.par(), cursor.pos(), false, !cursor.boundary());
+#else
+ lastpos = cursor.par()->size();
+#endif
+ if (cursor.pos() == lastpos)
SetCurrentFont(bview);
- }
- // check, wether the last characters font has changed.
+ // check, whether the last characters font has changed.
if (rawparfont !=
cursor.par()->GetFontSettings(bview->buffer()->params, lastpos - 1)) {
RedoHeightOfParagraph(bview, cursor);
void LyXText::GetVisibleRow(BufferView * bview, int y_offset, int x_offset,
- Row * row_ptr, long y, bool cleared)
+ Row * row_ptr, int y, bool cleared)
{
- /* returns a printed row */
+ // returns a printed row
Painter & pain = bview->painter();
- bool is_rtl = row_ptr->par()->isRightToLeftPar(bview->buffer()->params);
- LyXParagraph::size_type last = RowLastPrintable(row_ptr);
+ 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;
- LyXParagraph::size_type vpos, pos;
- float x;
float tmpx;
- int y_top;
- int y_bottom;
LyXFont font(LyXFont::ALL_SANE);
int maxdesc;
return;
}
+ float x;
float fill_separator;
float fill_hfill;
float fill_label_hfill;
x += x_offset;
// clear the area where we want to paint/print
- int ww = bview->workWidth();
+ 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()))) {
+ 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) {
- int w = (inset_owner ? inset_owner->width(bview, font) : ww);
- pain.fillRectangle(x_offset, y_offset, w, row_ptr->height());
+#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 w = (inset_owner ?
+ 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 w = (inset_owner ?
+ int const w = (inset_owner ?
inset_owner->width(bview, font) : ww);
- pain.fillRectangle(x_offset,y_offset+h, w, row_ptr->height()-h);
+ pain.fillRectangle(x_offset, y_offset + h,
+ w, row_ptr->height() - h);
}
if (!inset_owner && !inset->display() && !inset->needFullRow())
{
- int w = inset->width(bview, font) + int(x);
+ int const w = inset->width(bview, font) + int(x);
pain.fillRectangle(w, y_offset, ww - w, row_ptr->height());
}
}
if (selection) {
- int w = (inset_owner ? inset_owner->width(bview, font) : ww);
- /* selection code */
+ int const w = (inset_owner ?
+ inset_owner->width(bview, font) : ww);
+ // selection code
if (bidi_same_direction) {
if (sel_start_cursor.row() == row_ptr &&
sel_end_cursor.row() == row_ptr) {
sel_end_cursor.x(),
row_ptr->height(),
LColor::selection);
- } else if (y > long(sel_start_cursor.y())
- && y < long(sel_end_cursor.y())) {
+ } else if (y > sel_start_cursor.y()
+ && y < sel_end_cursor.y()) {
pain.fillRectangle(x_offset, y_offset, w,
row_ptr->height(),
LColor::selection);
}
- } else if ( sel_start_cursor.row() != row_ptr &&
+ } else if (sel_start_cursor.row() != row_ptr &&
sel_end_cursor.row() != row_ptr &&
- y > long(sel_start_cursor.y())
- && y < long(sel_end_cursor.y())) {
+ 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) ||
+ 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),
for (vpos = row_ptr->pos(); vpos <= last; ++vpos) {
pos = vis2log(vpos);
- float old_tmpx = tmpx;
+ 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,
} else
tmpx += SingleWidth(bview, row_ptr->par(), pos);
- if ( (sel_start_cursor.row() != row_ptr ||
+ if ((sel_start_cursor.row() != row_ptr ||
sel_start_cursor.pos() <= pos) &&
(sel_end_cursor.row() != row_ptr ||
pos < sel_end_cursor.pos()) )
- pain.fillRectangle(x_offset + int(old_tmpx),
+ // 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) ||
+ 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,
// Draw appendix lines
LyXParagraph * p = row_ptr->par()->PreviousBeforeFootnote()->FirstPhysicalPar();
- if (p->appendix){
+ if (p->params.appendix()) {
pain.line(1, y_offset,
1, y_offset + row_ptr->height(),
LColor::appendixline);
LColor::appendixline);
}
+#ifndef NO_PEXTRA
// Draw minipage line
- bool minipage = p->pextra_type == LyXParagraph::PEXTRA_MINIPAGE;
+ 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 depth = p->GetDepth();
+ int const depth = p->GetDepth();
for (int i = 1; i <= depth; ++i) {
- int line_x = (LYX_PAPER_MARGIN / 5) * (i + minipage);
+ 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);
LyXFont font(LyXFont::ALL_SANE);
font.setSize(LyXFont::SIZE_FOOTNOTE);
- int box_x = LYX_PAPER_MARGIN;
- box_x += lyxfont::width(" wide-tab ", font);
+ int const box_x = LYX_PAPER_MARGIN
+ + lyxfont::width(" wide-tab ", font);
pain.line(box_x, y_offset,
workWidth(bview) - LYX_PAPER_MARGIN,
#else
LyXParagraph * firstpar = row_ptr->par();
#endif
- if (firstpar->appendix){
+ if (firstpar->params.appendix()) {
pain.line(1, y_offset,
1, y_offset + row_ptr->height(),
LColor::appendixline);
ww - 2, y_offset + row_ptr->height(),
LColor::appendixline);
}
-
+#ifndef NO_PEXTRA
// Draw minipage line
- bool minipage = firstpar->pextra_type == LyXParagraph::PEXTRA_MINIPAGE;
+ 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 depth = firstpar->GetDepth();
+ int const depth = firstpar->GetDepth();
if (depth > 0) {
int next_depth = 0;
int prev_depth = 0;
#endif
for (int i = 1; i <= depth; ++i) {
- int line_x = (LYX_PAPER_MARGIN / 5) * (i + minipage) + box_x;
+ 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);
textclasslist.Style(bview->buffer()->params.textclass,
row_ptr->par()->GetLayout());
- y_top = 0;
- y_bottom = row_ptr->height();
+ int y_top = 0;
+ int y_bottom = row_ptr->height();
- /* is it a first row? */
+ // is it a first row?
if (!row_ptr->pos() && (row_ptr->par() == firstpar)) {
- /* start of appendix? */
- if (row_ptr->par()->start_of_appendix){
+ // start of appendix?
+ if (row_ptr->par()->params.startOfAppendix()) {
pain.line(1, y_offset,
ww - 2, y_offset,
LColor::appendixline);
}
- /* think about the margins */
+ // think about the margins
if (!row_ptr->previous() && bv_owner)
y_top += LYX_PAPER_MARGIN;
- if (row_ptr->par()->pagebreak_top){ /* draw a top pagebreak */
+ // draw a top pagebreak
+ if (row_ptr->par()->params.pagebreakTop()) {
LyXFont pb_font;
pb_font.setColor(LColor::pagebreak).decSize();
- int w = 0, a = 0, d = 0;
+ 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(),
y_top += 3 * DefaultHeight();
}
- if (row_ptr->par()->added_space_top.kind() == VSpace::VFILL) {
- /* draw a vfill 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);
y_top += 3 * DefaultHeight();
}
- /* think about user added space */
- y_top += int(row_ptr->par()->added_space_top.inPixels(bview));
+ // think about user added space
+ y_top += int(row_ptr->par()->params.spaceTop().inPixels(bview));
- /* think about the parskip */
- /* some parskips VERY EASY IMPLEMENTATION */
+ // 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())
+ && firstpar->previous())
y_top += bview->buffer()->params.getDefSkip().inPixels(bview);
- else if (firstpar->Previous()
+ else if (firstpar->previous()
&& textclasslist.Style(bview->buffer()->params.textclass,
- firstpar->Previous()->GetLayout()).latextype == LATEX_PARAGRAPH
- && firstpar->Previous()->GetDepth() == 0)
+ firstpar->previous()->GetLayout()).latextype == LATEX_PARAGRAPH
+ && firstpar->previous()->GetDepth() == 0)
// is it right to use defskip here, too? (AS)
y_top += bview->buffer()->params.getDefSkip().inPixels(bview);
}
- if (row_ptr->par()->line_top) { /* draw a top line */
+ if (row_ptr->par()->params.lineTop()) {
+ // draw a top line
y_top += lyxfont::ascent('x',
GetFont(bview->buffer(),
row_ptr->par(), 0));
-
- pain.line(0, y_offset + y_top,
- ww, y_offset + y_top,
+ 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);
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
font = GetFont(bview->buffer(), row_ptr->par(), -2);
if (!row_ptr->par()->GetLabelstring().empty()) {
tmpx = x;
- string tmpstring = row_ptr->par()->GetLabelstring();
+ string const tmpstring =
+ row_ptr->par()->GetLabelstring();
if (layout.labeltype == LABEL_COUNTER_CHAPTER) {
if (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. */
+ // this is special code for
+ // the chapter layout. This is
+ // printed in an extra row
+ // and has a pagebreak at
+ // the top.
float spacing_val = 1.0;
- if (!row_ptr->par()->spacing.isDefault()) {
- spacing_val = row_ptr->par()->spacing.getValue();
+ if (!row_ptr->par()->params.spacing().isDefault()) {
+ spacing_val = row_ptr->par()->params.spacing().getValue();
} else {
spacing_val = bview->buffer()->params.spacing.getValue();
}
tmpx = x - lyxfont::width(layout.labelsep, font)
- lyxfont::width(tmpstring, font);
- /* draw it! */
+ // draw it!
pain.text(int(tmpx),
y_offset + row_ptr->baseline(),
tmpstring, font);
}
}
- /* the labels at the top of an environment. More or less for bibliography */
+ // 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) {
font = GetFont(bview->buffer(),
row_ptr->par(), -2);
if (!row_ptr->par()->GetLabelstring().empty()) {
- string tmpstring = row_ptr->par()->GetLabelstring();
+ string const tmpstring =
+ row_ptr->par()->GetLabelstring();
float spacing_val = 1.0;
- if (!row_ptr->par()->spacing.isDefault()) {
- spacing_val = row_ptr->par()->spacing.getValue();
+ if (!row_ptr->par()->params.spacing().isDefault()) {
+ spacing_val = row_ptr->par()->params.spacing().getValue();
} else {
spacing_val = bview->buffer()->params.spacing.getValue();
}
}
}
- /* is it a last row? */
+ // is it a last row?
#ifndef NEW_INSETS
LyXParagraph * par = row_ptr->par()->LastPhysicalPar();
#else
#endif
if (
#ifndef NEW_INSETS
- (row_ptr->par()->ParFromPos(last + 1) == par)
+ row_ptr->par()->ParFromPos(last + 1) == par
#else
- (row_ptr->par() == par)
+ row_ptr->par() == par
#endif
- && (!row_ptr->next() || (row_ptr->next()->par() != row_ptr->par())))
+ && (!row_ptr->next() || row_ptr->next()->par() != row_ptr->par()))
{
- /* think about the margins */
+ // think about the margins
if (!row_ptr->next() && bv_owner)
y_bottom -= LYX_PAPER_MARGIN;
- /* draw a bottom pagebreak */
- if (firstpar->pagebreak_bottom) {
+ // draw a bottom pagebreak
+ if (firstpar->params.pagebreakBottom()) {
LyXFont pb_font;
pb_font.setColor(LColor::pagebreak).decSize();
- int w = 0, a = 0, d = 0;
- pain.line(0,
- y_offset + y_bottom - 2 * DefaultHeight(),
- ww,
- y_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((ww - w) / 2,
- y_offset + y_top + 2 * DefaultHeight() + d,
+ pain.rectText((ww - w) / 2, y_place + d,
_("Page Break (bottom)"),
pb_font,
LColor::background,
y_bottom -= 3 * DefaultHeight();
}
- if (firstpar->added_space_bottom.kind() == VSpace::VFILL) {
- /* draw a vfill bottom */
- pain.line(0, y_offset + y_bottom - 3 * DefaultHeight(),
- LYX_PAPER_MARGIN,
- y_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, y_offset + y_bottom - 2,
LYX_PAPER_MARGIN,
y_offset + y_bottom - 2,
LColor::vfillline);
pain.line(LYX_PAPER_MARGIN / 2,
- y_offset + y_bottom - 3 * DefaultHeight(),
+ y_place,
LYX_PAPER_MARGIN / 2,
y_offset + y_bottom - 2,
LColor::vfillline);
y_bottom -= 3 * DefaultHeight();
}
- /* think about user added space */
- y_bottom -= int(firstpar->added_space_bottom.inPixels(bview));
+ // think about user added space
+ y_bottom -= int(firstpar->params.spaceBottom().inPixels(bview));
- if (firstpar->line_bottom) {
- /* draw a bottom line */
- y_bottom -= lyxfont::ascent('x', GetFont(bview->buffer(),
- par, par->Last() - 1));
- pain.line(0, y_offset + y_bottom,
- ww, y_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 -= lyxfont::ascent('x', GetFont(bview->buffer(),
- par, par->Last() - 1));
+#ifndef NEW_INSETS
+ y_bottom -= lyxfont::ascent('x',
+ GetFont(bview->buffer(),
+ par,
+ par->Last() - 1));
+#else
+ y_bottom -= lyxfont::ascent('x',
+ GetFont(bview->buffer(),
+ par,
+ par->size() - 1));
+#endif
}
// draw an endlabel
- int endlabel = row_ptr->par()->GetEndLabel(bview->buffer()->params);
+ int const endlabel =
+ row_ptr->par()->GetEndLabel(bview->buffer()->params);
switch (endlabel) {
case END_LABEL_BOX:
case END_LABEL_FILLED_BOX:
{
- LyXFont font = GetFont(bview->buffer(),
- row_ptr->par(), last);
- int size = int(0.75 * lyxfont::maxAscent(font));
- int y = (y_offset + row_ptr->baseline()) - size;
+ 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
case END_LABEL_STATIC:
{
LyXTextClass::LayoutList::size_type layout = row_ptr->par()->GetLayout();
- string tmpstring = textclasslist.Style(bview->buffer()->params.textclass,
- layout).endlabelstring();
+ string const tmpstring = textclasslist.
+ Style(bview->buffer()->params.textclass,
+ layout).endlabelstring();
font = GetFont(bview->buffer(), row_ptr->par(), -2);
- int tmpx = is_rtl ? int(x) - lyxfont::width(tmpstring, font)
+ 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;
}
}
- /* draw the text in the pixmap */
+ // draw the text in the pixmap
vpos = row_ptr->pos();
++vc;
}
- if (vc > row->pos() && (tmpx + last_tmpx) / 2 > x) {
+ if ((tmpx + last_tmpx) / 2 > x) {
tmpx = last_tmpx;
left_side = true;
}
vc = last + 1;
boundary = false;
-#if 0 // currently unused
- bool lastrow = (!row->next() || row->next()->par() != row->par());
- bool rtl = (lastrow)
+ 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;
-#endif
-
+ : 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();
-#warning This is wrong, please have a look Dekel (Jug)
-#if 0
else if (lastrow &&
- ( (rtl && vc == row->pos()&& x < tmpx - 5) ||
- (!rtl && vc == last + 1 && x > tmpx + 5) ))
+ ( ( rtl && left_side && vc == row->pos() && x < tmpx - 5) ||
+ (!rtl && !left_side && vc == last + 1 && x > tmpx + 5) ))
c = last + 1;
-#endif
else if (vc == row->pos()) {
c = vis2log(vc);
if (bidi_level(c) % 2 == 1)
++c;
} else {
c = vis2log(vc - 1);
- bool rtl = (bidi_level(c) % 2 == 1);
+ bool const rtl = (bidi_level(c) % 2 == 1);
if (left_side == rtl) {
++c;
boundary = IsBoundary(bview->buffer(), row->par(), c);
_("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) {
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())
|| tmppar->footnoteflag != LyXParagraph::NO_FOOTNOTE) {
* and sel_end cursor */
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);
+ 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.par()->BreakParagraphConservative(bview->buffer()->params, sel_end_cursor.pos());
- sel_end_cursor.par(sel_end_cursor.par()->Next());
+ 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(bview->buffer()->params, 0);
sel_end_cursor.par()->layout = LYX_DUMMY_LAYOUT;
- sel_end_cursor.par(sel_end_cursor.par()->next);
+ sel_end_cursor.par(sel_end_cursor.par()->next_);
}
else
sel_end_cursor.par()->layout = LYX_DUMMY_LAYOUT;
sel_start_cursor.par()->BreakParagraphConservative(bview->buffer()->params,
sel_start_cursor.pos());
- tmppar = sel_start_cursor.par()->Next();
+ tmppar = sel_start_cursor.par()->next();
if (dummy_selection) {
tmppar->Clear();
while (tmppar != sel_end_cursor.par()) {
tmppar->footnoteflag = LyXParagraph::OPEN_FOOTNOTE;
tmppar->footnotekind = kind;
- tmppar = tmppar->Next();
+ tmppar = tmppar->next();
}
- RedoParagraphs(bview, sel_start_cursor, sel_end_cursor.par()->Next());
+ RedoParagraphs(bview, sel_start_cursor, sel_end_cursor.par()->next());
- SetCursor(bview, 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
{
+ if (!firstrow)
+ return 0;
+
Row * tmprow = firstrow;
y = 0;