#include "lyxrow.h"
#include "Painter.h"
#include "tracer.h"
+#include "font.h"
using std::max;
using std::min;
using std::endl;
+using std::pair;
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
0xfe // 0xea = ya
};
+
bool is_arabic(unsigned char c)
{
return 0xa8 <= c && c <= 0xea && iso885968x[c-0xa8];
}
+
unsigned char LyXText::TransformChar(unsigned char c, Letter_Form form) const
{
if (is_arabic(c) &&
return c;
}
+
unsigned char LyXText::TransformChar(unsigned char c, LyXParagraph * par,
LyXParagraph::size_type pos) const
{
if (!is_arabic(c))
- return c;
+ if (isdigit(c))
+ return c + (0xb0 - '0');
+ else
+ return c;
bool not_first = (pos > 0 && is_arabic(par->GetChar(pos-1)));
if (pos < par->Last()-1 && is_arabic(par->GetChar(pos+1)))
// The most common case is handled first (Asger)
if (IsPrintable(c)) {
- if (lyxrc.rtl_support && lyxrc.font_norm == "iso8859-6.8x")
+ if (font.language()->lang == "arabic" &&
+ lyxrc.font_norm == "iso8859-6.8x")
c = TransformChar(c, par, pos);
- return font.width(c);
+ return lyxfont::width(c, font);
} else if (IsHfillChar(c)) {
return 3; /* Because of the representation
}
font.decSize();
font.decSize();
- return font.stringWidth(fs);
+ return lyxfont::width(fs, font);
} else if (c == LyXParagraph::META_INSET) {
Inset * tmpinset= par->GetInset(pos);
if (tmpinset)
c = ' ';
else if (IsNewlineChar(c))
c = 'n';
- return font.width(c);
+ return lyxfont::width(c, font);
}
}
-
+LyXParagraph::size_type LyXText::RowLastPrintable(Row const * row) const
+{
+ LyXParagraph::size_type 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
{
-
+ bidi_same_direction = true;
if (!lyxrc.rtl_support) {
bidi_start = -1;
return;
}
- LyXParagraph::size_type last = RowLast(row);
+ LyXParagraph::size_type last = RowLastPrintable(row);
bidi_start = row->pos;
if (bidi_start > last) {
500 : 2 * (last + 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 stack[2];
+ bool rtl_par = row->par->getParLanguage()->RightToLeft;
+ int level = 0;
+ bool rtl = false;
+ bool rtl0 = false;
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);
- }
- } else
- ComputeBidiTablesFromTo(row, bidi_start, last, 0);
-}
+ for (LyXParagraph::size_type lpos = bidi_start; lpos <= last; ++lpos) {
+ bool is_space = row->par->IsLineSeparator(lpos);
+ LyXParagraph::size_type pos =
+ (is_space && lpos+1 <= last &&
+ (!row->par->table || !row->par->IsNewline(lpos+1)) )
+ ? lpos + 1 : lpos;
+ LyXFont font = row->par->GetFontSettings(pos);
+ bool new_rtl = font.isVisibleRightToLeft();
+ bool new_rtl0 = font.isRightToLeft();
+ int new_level;
+
+ if (row->par->table && row->par->IsNewline(lpos)) {
+ new_level = 0;
+ new_rtl = new_rtl0 = false;
+ } else if (lpos == main_body - 1 && row->pos < main_body - 1 &&
+ row->par->IsLineSeparator(lpos)) {
+ 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;
-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;
+ if (is_space && new_level >= level) {
+ new_level = level;
+ new_rtl = rtl;
+ new_rtl0 = rtl0;
+ }
- 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);
+ 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 old_lpos = stack[--level];
+ int delta = last - 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 <= last; ++lpos) {
vpos += log2vis_list[lpos - bidi_start];
vis2log_list[vpos - bidi_start] = lpos;
log2vis_list[lpos - bidi_start] = vpos;
++vpos;
// Draw end-of-line marker
LyXFont font = GetFont(row->par, pos);
- int wid = font.width('n');
- int asc = font.maxAscent();
+ int wid = lyxfont::width('n', font);
+ int asc = lyxfont::maxAscent(font);
int y = offset + row->baseline;
int xp[3], 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);
fs = "margin";
// Draw a sign at the left margin!
owner_->painter()
- .text((LYX_PAPER_MARGIN - font.width('!'))/2,
+ .text((LYX_PAPER_MARGIN - lyxfont::width('!', font))/2,
offset + row->baseline, "!", 1, font);
break;
case LyXParagraph::META_FIG:
font.decSize();
// calculate the position of the footnotemark
- int y = (row->baseline - font2.maxAscent()
- + font.maxAscent());
+ int y = (row->baseline - lyxfont::maxAscent(font2)
+ + lyxfont::maxAscent(font));
font.setColor(LColor::footnote);
// draw it and set new x position
pain.text(int(x), offset + y, fs, font);
- x += pain.width(fs, font);
+ x += lyxfont::width(fs, font);
pain.line(int(tmpx), offset + row->baseline,
int(x), offset + row->baseline,
LColor::footnote);
// 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");
+ bool do_transform =
+ font2.language()->lang == "arabic" &&
+ 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);
+ LyXParagraph::size_type last = RowLastPrintable(row);
while (vpos <= last &&
(pos = vis2log(vpos)) >= 0
// Draw text and set the new x position
pain.text(int(x), offset + row->baseline, textstring, font);
- x += pain.width(textstring, font);
+ x += lyxfont::width(textstring, font);
// what about underbars?
if (font.underbar() == LyXFont::ON && font.latex() != LyXFont::ON) {
// exactly the label-width.
int LyXText::LeftMargin(Row const * row) const
{
- LyXLayout const & layout = textclasslist.Style(parameters->textclass,
- row->par->GetLayout());
+ LyXLayout const & layout =
+ textclasslist.Style(buffer->params.textclass,
+ row->par->GetLayout());
string parindent = layout.parindent;
/* table stuff -- begin */
if (row->par->table)
- parindent.clear();
+ parindent.erase();
/* table stuff -- end */
int x = LYX_PAPER_MARGIN;
- x += textclasslist.TextClass(parameters->textclass)
- .defaultfont()
- .signedStringWidth(textclasslist
- .TextClass(parameters->textclass)
- .leftmargin());
+ x += lyxfont::signedWidth(textclasslist
+ .TextClass(buffer->params.textclass)
+ .leftmargin(),
+ textclasslist
+ .TextClass(buffer->params.textclass)
+ .defaultfont());
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;
}
// this is the way, LyX handles the LaTeX-Environments.
LyXParagraph * newpar = row->par
->DepthHook(row->par->GetDepth());
if (newpar &&
- textclasslist.Style(parameters->textclass,
+ textclasslist.Style(buffer->params.textclass,
newpar->GetLayout())
.nextnoindent)
- parindent.clear();
+ parindent.erase();
}
}
} else {
// check wether it is a sufficent paragraph
if (newpar && newpar->footnoteflag == row->par->footnoteflag
&& textclasslist
- .Style(parameters->textclass,
+ .Style(buffer->params.textclass,
newpar->GetLayout()).isEnvironment()) {
Row dummyrow;
dummyrow.par = newpar;
if (newpar && !row->par->GetLayout()) {
if (newpar->FirstPhysicalPar()->noindent)
- parindent.clear();
+ parindent.erase();
else
parindent = textclasslist
- .Style(parameters->textclass,
+ .Style(buffer->params.textclass,
newpar->GetLayout()).parindent;
}
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(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);
+ x += lyxfont::signedWidth(layout.labelindent, labelfont);
if (row->pos >= BeginningOfMainBody(row->par)) {
if (!row->par->GetLabelWidthString().empty()) {
- x += labelfont
- .stringWidth(row->par
- ->GetLabelWidthString());
- x += labelfont.stringWidth(layout.labelsep);
+ 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
+ x += lyxfont::signedWidth(layout.leftmargin, textclasslist.TextClass(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);
+ x += lyxfont::signedWidth(layout.leftmargin, labelfont);
} else {
- x += labelfont
- .signedStringWidth(layout.labelindent);
+ x += lyxfont::signedWidth(layout.labelindent, labelfont);
}
} else if (row->pos
// Special case to fix problems with
|| (layout.labeltype == LABEL_STATIC
&& layout.latextype == LATEX_ENVIRONMENT
&& ! row->par->IsFirstInSequence())) {
- x += labelfont.signedStringWidth(layout.leftmargin);
+ 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;
minfill = tmprow->fill;
}
- x += textclasslist.TextClass(parameters->textclass)
- .defaultfont().signedStringWidth(layout.leftmargin);
+ x += lyxfont::signedWidth(layout.leftmargin,
+ textclasslist
+ .TextClass(buffer->params.textclass)
+ .defaultfont());
x += minfill;
}
break;
x += xx;
} else { // should not happen
LyXFont font(LyXFont::ALL_SANE);
- x += font.stringWidth("XXXXXX");
+ x += lyxfont::width("XXXXXX", font);
}
}
&& align == LYX_ALIGN_BLOCK
&& !row->par->noindent
&& (row->par->layout ||
- parameters->paragraph_separation ==
+ buffer->params.paragraph_separation ==
BufferParams::PARSEP_INDENT))
- x += textclasslist.TextClass(parameters->textclass)
- .defaultfont().signedStringWidth(parindent);
+ x += lyxfont::signedWidth(parindent,
+ textclasslist
+ .TextClass(buffer->params
+ .textclass)
+ .defaultfont());
else if (layout.labeltype == LABEL_BIBLIO) {
// ale970405 Right width for bibitems
x += bibitemMaxWidth(owner_->painter(),
textclasslist
- .TextClass(parameters
- ->textclass)
+ .TextClass(buffer->params
+ .textclass)
.defaultfont());
}
}
return x;
}
-
-
+
+
int LyXText::RightMargin(Row const * row) const
{
LyXLayout const & layout =
- textclasslist.Style(parameters->textclass,
+ textclasslist.Style(buffer->params.textclass,
row->par->GetLayout());
int x = LYX_PAPER_MARGIN
- + textclasslist
- .TextClass(parameters->textclass)
- .defaultfont()
- .signedStringWidth(textclasslist
- .TextClass(parameters->textclass)
- .rightmargin());
+ + lyxfont::signedWidth(textclasslist
+ .TextClass(buffer->params.textclass)
+ .rightmargin(),
+ textclasslist
+ .TextClass(buffer->params.textclass)
+ .defaultfont());
if (row->par->footnoteflag == LyXParagraph::OPEN_FOOTNOTE) {
x += LYX_PAPER_MARGIN / 2;
// check wether it is a sufficent paragraph
if (newpar && newpar->footnoteflag == row->par->footnoteflag
- && textclasslist.Style(parameters->textclass,
+ && textclasslist.Style(buffer->params.textclass,
newpar->GetLayout())
.isEnvironment()) {
Row dummyrow;
}
//lyxerr << "rightmargin: " << layout->rightmargin << endl;
- x += textclasslist.TextClass(parameters->textclass)
- .defaultfont()
- .signedStringWidth(layout.rightmargin) * 4
+ x += lyxfont::signedWidth(layout.rightmargin, textclasslist.TextClass(buffer->params.textclass).defaultfont()) * 4
/ (row->par->GetDepth() + 4);
return x;
}
int LyXText::LabelEnd (Row const * row) const
{
- if (textclasslist.Style(parameters->textclass,
+ if (textclasslist.Style(buffer->params.textclass,
row->par->GetLayout()).margintype
== MARGIN_MANUAL) {
Row tmprow;
LyXParagraph::size_type main_body = BeginningOfMainBody(par);
LyXLayout const & layout =
- textclasslist.Style(parameters->textclass, par->GetLayout());
+ textclasslist.Style(buffer->params.textclass, par->GetLayout());
LyXParagraph::size_type i = pos;
if (layout.margintype == MARGIN_RIGHT_ADDRESS_BOX) {
}
++i;
if (i == main_body) {
- x += GetFont(par, -2).stringWidth(layout.labelsep);
+ x += lyxfont::width(layout.labelsep,
+ GetFont(par, -2));
if (par->IsLineSeparator(i - 1))
x-= SingleWidth(par, i - 1);
int left_margin = LabelEnd(row);
{
int w, fill;
// get the pure distance
- LyXParagraph::size_type last = RowLast(row);
+ LyXParagraph::size_type last = RowLastPrintable(row);
/* table stuff -- begin */
if (row->par->table) {
// for tables FILL does calculate the widthes of each cell in
* 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;
-
+
// special handling of the right address boxes
- if (textclasslist.Style(parameters->textclass,
+ if (textclasslist.Style(buffer->params.textclass,
row->par->GetLayout()).margintype
== MARGIN_RIGHT_ADDRESS_BOX) {
int tmpfill = row->fill;
} else
w = LeftMargin(row);
- LyXLayout const & layout = textclasslist.Style(parameters->textclass,
+ LyXLayout const & layout = textclasslist.Style(buffer->params.textclass,
row->par->GetLayout());
LyXParagraph::size_type main_body =
BeginningOfMainBody(row->par);
while (i <= last) {
if (main_body > 0 && i == main_body) {
- w += GetFont(row->par, -2).
- stringWidth(layout.labelsep);
+ w += lyxfont::width(layout.labelsep, GetFont(row->par, -2));
if (row->par->IsLineSeparator(i - 1))
w -= SingleWidth(row->par, i - 1);
int left_margin = LabelEnd(row);
++i;
}
if (main_body > 0 && main_body > last) {
- w += GetFont(row->par, -2).stringWidth(layout.labelsep);
+ w += lyxfont::width(layout.labelsep, GetFont(row->par, -2));
if (last >= 0 && row->par->IsLineSeparator(last))
w -= SingleWidth(row->par, last);
int left_margin = LabelEnd(row);
int fill = 0;
if (!row->par->labelwidthstring.empty()) {
- fill = GetFont(row->par, -2)
- .stringWidth(row->par->labelwidthstring) - w;
+ fill = max(lyxfont::width(row->par->labelwidthstring,
+ GetFont(row->par, -2)) - w,
+ 0);
}
- if (fill < 0)
- fill = 0;
-
return fill;
}
return true;
// in some labels it does not count
- if (textclasslist.Style(parameters->textclass,
+ if (textclasslist.Style(buffer->params.textclass,
row_ptr->par->GetLayout()).margintype
!= MARGIN_MANUAL
&& pos < BeginningOfMainBody(row_ptr->par))
LyXParagraph * par = row_ptr->par->LastPhysicalPar();
LyXParagraph * firstpar = row_ptr->par->FirstPhysicalPar();
- LyXLayout const & layout = textclasslist.Style(parameters->textclass,
+ LyXLayout const & layout = textclasslist.Style(buffer->params.textclass,
firstpar->GetLayout());
- LyXFont font = GetFont(par, par->Last()-1);
+ LyXFont font = GetFont(par, par->Last() - 1);
LyXFont::FONT_SIZE size = font.size();
font = GetFont(par, -1);
font.setSize(size);
LyXFont labelfont = GetFont(par, -2);
- int maxasc = int(font.maxAscent() *
+ float spacing_val = 1.0;
+ if (!row_ptr->par->spacing.isDefault()) {
+ spacing_val = row_ptr->par->spacing.getValue();
+ } else {
+ spacing_val = 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());
+ spacing_val);
int pos_end = RowLast(row_ptr);
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)
&& row_ptr->par == firstpar) {
/* some parksips VERY EASY IMPLEMENTATION */
- if (parameters->paragraph_separation == BufferParams::PARSEP_SKIP) {
+ if (buffer->params.paragraph_separation == BufferParams::PARSEP_SKIP) {
if (layout.isParagraph()
&& firstpar->GetDepth() == 0
&& firstpar->Previous())
- maxasc += parameters->getDefSkip().inPixels(owner_);
+ maxasc += buffer->params.getDefSkip().inPixels(owner_);
else if (firstpar->Previous()
- && textclasslist.Style(parameters->textclass,
+ && textclasslist.Style(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 += buffer->params.getDefSkip().inPixels(owner_);
}
/* the paper margins */
/* 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');
+ maxasc += 2 * lyxfont::ascent('x', GetFont(firstpar, 0));
/* and now the pagebreaks */
if (firstpar->pagebreak_top)
/* 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() *
+ && buffer->params.secnumdepth >= 0) {
+ float spacing_val = 1.0;
+ if (!row_ptr->par->spacing.isDefault()) {
+ spacing_val = row_ptr->par->spacing.getValue();
+ } else {
+ spacing_val = 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 */
|| 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->GetLabelstring().empty()) {
+ float spacing_val = 1.0;
+ if (!row_ptr->par->spacing.isDefault()) {
+ spacing_val = row_ptr->par->spacing.getValue();
+ } else {
+ spacing_val = 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,
tmptop = layout.topsep;
if (row_ptr->previous->par->GetDepth() >= row_ptr->par->GetDepth())
- tmptop-= textclasslist.Style(parameters->textclass, row_ptr->previous->par->GetLayout()).bottomsep;
+ tmptop-= textclasslist.Style(buffer->params.textclass, row_ptr->previous->par->GetLayout()).bottomsep;
if (tmptop > 0)
layoutasc = (tmptop * DefaultHeight());
prev = row_ptr->par->DepthHook(row_ptr->par->GetDepth()-1);
if (prev) {
- maxasc += int(textclasslist.Style(parameters->textclass,
+ maxasc += int(textclasslist.Style(buffer->params.textclass,
prev->GetLayout()).parsep * DefaultHeight());
}
else {
/* 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'));
+ maxdesc += 2 * lyxfont::ascent('x', GetFont(par, par->Last() - 1));
/* and now the pagebreaks */
if (firstpar->pagebreak_bottom)
float unusual = 0;
if (comparepar->GetDepth() > nextpar->GetDepth()) {
- usual = (textclasslist.Style(parameters->textclass, comparepar->GetLayout()).bottomsep * DefaultHeight());
+ usual = (textclasslist.Style(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(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(buffer->params.textclass, comparepar->GetLayout()).bottomsep * DefaultHeight());
}
}
}
void LyXText::BreakParagraph(char keep_layout)
{
- LyXLayout const & layout = textclasslist.Style(parameters->textclass,
+ LyXLayout const & layout = textclasslist.Style(buffer->params.textclass,
cursor.par->GetLayout());
/* table stuff -- begin */
/* table stuff -- end */
// well this is the caption hack since one caption is really enough
- if (layout.labeltype == LABEL_SENSITIVE){
+ if (layout.labeltype == LABEL_SENSITIVE) {
if (!cursor.pos)
cursor.par->SetLayout(0); // set to standard-layout
else
/* set the dimensions of the cursor row */
row->fill = Fill(row, paperwidth);
SetHeightOfRow(row);
-#warning See comment on top of text.C
+ // CHECK See comment on top of text.C
tmppar = tmppar->Next();
while (tmppar != endpar) {
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)))
+ 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()) {
/* redraw only the row */
LyXCursor tmpcursor = cursor;
SetCursorIntern(par, pos);
-#warning See comment on top of text.C
+ //CHECK See comment on top of text.C
refresh_y = y;
refresh_x = cursor.x;
refresh_row = row;
if (cursor.par->IsNewline(cursor.pos)) {
/* nothing :-) */
return;
- }
- else {
+ } else {
cursor.par->Erase(cursor.pos);
/* refresh the positions */
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--;
- }
- }
-#endif
}
CheckParagraphInTable(cursor.par, cursor.pos);
/* 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
}
* disable the double-space checking */
bool freeSpacing =
- textclasslist.Style(parameters->textclass,
+ textclasslist.Style(buffer->params.textclass,
cursor.row->par->GetLayout()).free_spacing;
/* table stuff -- begin*/
// 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.
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;
-#endif
- } else
-#endif
if ((cursor.pos > 0
&& cursor.par->IsLineSeparator(cursor.pos - 1))
|| (cursor.pos > 0
RedoHeightOfParagraph(cursor);
} else {
/* now the special right address boxes */
- if (textclasslist.Style(parameters->textclass,
+ if (textclasslist.Style(buffer->params.textclass,
cursor.par->GetLayout()).margintype
== MARGIN_RIGHT_ADDRESS_BOX) {
RedoDrawingOfParagraph(cursor);
fill_separator = 0;
fill_label_hfill = 0;
- LyXDirection direction = row->par->getParDirection();
+ bool is_rtl = row->par->isRightToLeftPar();
- if (direction == LYX_DIR_RIGHT_TO_LEFT) {
+ if (is_rtl) {
x = RightMargin(row);
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
+ } else
x = LeftMargin(row);
/* is there a manual margin with a manual label */
- if (textclasslist.Style(parameters->textclass,
+ if (textclasslist.Style(buffer->params.textclass,
row->par->GetLayout()).margintype == MARGIN_MANUAL
- && textclasslist.Style(parameters->textclass,
+ && textclasslist.Style(buffer->params.textclass,
row->par->GetLayout()).labeltype == LABEL_MANUAL) {
nlh = NumberOfLabelHfills(row) + 1; /* one more since labels
* 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;
+ align = textclasslist.Style(buffer->params.textclass, row->par->GetLayout()).align;
else
align = row->par->FirstPhysicalPar()->align;
&& 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:
return;
ComputeBidiTables(row);
- if (direction == LYX_DIR_RIGHT_TO_LEFT) {
+ if (is_rtl) {
LyXParagraph::size_type main_body =
BeginningOfMainBody(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,
+ if (main_body > 0 &&
+ (main_body-1 > last ||
+ !row->par->IsLineSeparator(main_body-1))) {
+ LyXLayout const & layout = textclasslist.Style(buffer->params.textclass,
row->par->GetLayout());
- x += GetFont(row->par, -2).stringWidth(layout.labelsep);
+ x += lyxfont::width(layout.labelsep,
+ GetFont(row->par, -2));
if (main_body-1 <= last)
x += fill_label_hfill;
}
{
// 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())
1: no selection is currently set,
2: the cursor is not at the borders of the word. */
-int LyXText::SelectWordWhenUnderCursor()
+bool LyXText::SelectWordWhenUnderCursor()
{
- 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) ) {
+ if (!selection &&
+ cursor.pos > 0 && cursor.pos < cursor.par->Last()
+ && !cursor.par->IsSeparator(cursor.pos)
+ && !cursor.par->IsKomma(cursor.pos)
+ && !cursor.par->IsSeparator(cursor.pos -1)
+ && !cursor.par->IsKomma(cursor.pos -1) ) {
SelectWord();
- return 1;
+ return true;
}
- return 0;
+ return false;
}
sel_cursor = cursor;
#ifdef HAVE_SSTREAM
- ostringstream latex;
+ std::ostringstream latex;
#else
ostrstream latex;
#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(latex, 0, false) == 0
+ && cursor.par->GetInset(cursor.pos)->Latex(latex, false, false) == 0
#ifdef HAVE_SSTREAM
&& latex.str() == "\\-"
#else
sel_cursor = cursor;
#ifdef HAVE_SSTREAM
- ostringstream latex;
+ std::ostringstream latex;
#else
ostrstream latex;
#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(latex, 0, false) == 0
+ && cursor.par->GetInset(cursor.pos)->Latex(latex, false, false) == 0
#ifdef HAVE_SSTREAM
&& latex.str() == "\\-"
#else
if (!cursor.par->Last())
CursorRight();
-#warning See comment on top of text.C
+ // CHECK See comment on top of text.C
else {
/* -------> Skip initial non-word stuff. */
while ( cursor.pos < cursor.par->Last()
LyXCursor tmpcursor = cursor;
if (!cursor.par->Last())
CursorLeft();
-#warning See comment on top of text.C
+ // CHECK See comment on top of text.C
else{
selection = true; // to avoid deletion
CursorLeftOneWord();
LyXCursor tmpcursor = cursor;
if (!cursor.par->Last())
CursorRight();
-#warning See comment on top of text.C
+ // CHECK See comment on top of text.C
else {
CursorEnd();
sel_cursor = cursor;
LyXParagraph::size_type tmppos =
cursor.par->PositionInParFromPos(cursor.pos);
while (tmppos < tmppar->size()) {
- //unsigned char c = tmppar->text[tmppos];
unsigned char c = tmppar->GetChar(tmppos);
if (IsKommaChar(c) || IsLineSeparatorChar(c))
break;
// just move to the right
CursorRightIntern();
-#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
-#else
- if (cursor.par->previous == old_cursor.par->previous
- && cursor.par != old_cursor.par)
- return; // delete-empty-paragraph-mechanism has done it
-#endif
+
// if you had success make a backspace
if (old_cursor.par != cursor.par || old_cursor.pos != cursor.pos) {
LyXCursor tmpcursor = cursor;
void LyXText::Backspace()
{
- DebugTracer trc1("LyXText::Backspace");
-
/* table stuff -- begin */
if (cursor.par->table) {
BackspaceInTable();
LyXFont rawparfont = cursor.par->GetFontSettings(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.
&& !(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
+ // 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) {
// not a good idea since it triggers the auto-delete
// mechanism. So we do a CursorLeftIntern()-lite,
// without the dreaded mechanism. (JMarc)
- if (cursor.pos > 0) {
- SetCursorIntern(cursor.par, cursor.pos - 1);
- }
- else if (cursor.par->Previous()) {
+ if (cursor.par->Previous()) {
// steps into the above paragraph.
SetCursorIntern(cursor.par->Previous(),
cursor.par->Previous()->Last());
}
-
-#warning See comment on top of text.C
/* 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.
SetCursor(cursor.par, cursor.pos);
}
} else {
- DebugTracer trc("LyXText::Backspace normal backspace");
-
/* this is the code for a normal backspace, not pasting
* any paragraphs */
SetUndo(Undo::DELETE,
// not a good idea since it triggers the auto-delete
// mechanism. So we do a CursorLeftIntern()-lite,
// without the dreaded mechanism. (JMarc)
- if (cursor.pos > 0) {
- SetCursorIntern(cursor.par, cursor.pos - 1);
- }
- else if (cursor.par->Previous()) {
- // steps into the above paragraph.
- SetCursorIntern(cursor.par->Previous(),
- cursor.par->Previous()->Last());
- }
-// CursorLeftIntern();
+ SetCursorIntern(cursor.par, cursor.pos - 1);
// some insets are undeletable here
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
+ // this is a cruel method but safe..... Matthias
if (cursor.par->GetInset(cursor.pos)->display()){
cursor.par->Erase(cursor.pos);
RedoParagraph();
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--;
- }
- }
-#endif
-
// delete newlines at the beginning of paragraphs
while (cursor.par->Last() &&
cursor.par->IsNewline(cursor.pos) &&
SetCursor(cursor.par, cursor.pos, false);
}
}
- DebugTracer trc2("LyXText::Backspace wrap up");
-
// restore the current font
// That is what a user expects!
current_font = rawtmpfont;
RedoHeightOfParagraph(cursor);
} else {
// now the special right address boxes
- if (textclasslist.Style(parameters->textclass,
+ if (textclasslist.Style(buffer->params.textclass,
cursor.par->GetLayout()).margintype == MARGIN_RIGHT_ADDRESS_BOX) {
RedoDrawingOfParagraph(cursor);
}
}
-void LyXText::GetVisibleRow(int offset,
- Row * row_ptr, long y)
+void LyXText::GetVisibleRow(int offset, Row * row_ptr, long y)
{
/* returns a printed row */
Painter & pain = owner_->painter();
- LyXDirection direction = row_ptr->par->getParDirection();
- LyXParagraph::size_type vpos, pos, pos_end;
+ bool is_rtl = row_ptr->par->isRightToLeftPar();
+ LyXParagraph::size_type last = RowLastPrintable(row_ptr);
+
+ LyXParagraph::size_type vpos, pos;
float x, tmpx;
int y_top, y_bottom;
float fill_separator, fill_hfill, fill_label_hfill;
PrepareToPrint(row_ptr, x, fill_separator,
fill_hfill, fill_label_hfill);
- /* initialize the pixmap */
-
+ // clear the area where we want to paint/print
pain.fillRectangle(0, offset, paperwidth, 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
+ /* 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(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 (is_rtl)
+ pain.fillRectangle(0, offset,
+ sel_start_cursor.x,
+ row_ptr->height,
+ LColor::selection);
+ else
+ pain.fillRectangle(sel_start_cursor.x, offset,
+ paperwidth - sel_start_cursor.x,
+ row_ptr->height,
+ LColor::selection);
+ } else if (sel_end_cursor.row == row_ptr) {
+ if (is_rtl)
+ pain.fillRectangle(sel_end_cursor.x, offset,
+ paperwidth - sel_end_cursor.x,
+ row_ptr->height,
+ LColor::selection);
+ else
+ pain.fillRectangle(0, offset,
+ sel_end_cursor.x,
+ row_ptr->height,
+ LColor::selection);
+ } else if (y > long(sel_start_cursor.y)
+ && y < long(sel_end_cursor.y)) {
pain.fillRectangle(0, offset,
- sel_start_cursor.x,
- row_ptr->height,
+ paperwidth, row_ptr->height,
LColor::selection);
- } else if (sel_end_cursor.row == row_ptr) {
- if (direction == LYX_DIR_LEFT_TO_RIGHT)
+ }
+ } 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)) {
+ pain.fillRectangle(0, offset,
+ paperwidth, row_ptr->height,
+ LColor::selection);
+ } else if (sel_start_cursor.row == row_ptr ||
+ sel_end_cursor.row == row_ptr) {
+ float tmpx = x;
+ int cell = 0;
+ if (row_ptr->par->table) {
+ cell = NumberOfCell(row_ptr->par, row_ptr->pos);
+ tmpx += row_ptr->par->table->GetBeginningOfTextInCell(cell);
+ }
+ if ( (sel_start_cursor.row != row_ptr && !is_rtl) ||
+ (sel_end_cursor.row != row_ptr && is_rtl))
pain.fillRectangle(0, offset,
- sel_end_cursor.x,
- row_ptr->height,
+ tmpx, row_ptr->height,
LColor::selection);
- else
- pain.fillRectangle(sel_end_cursor.x, offset,
- paperwidth - sel_end_cursor.x,
+ if (row_ptr->par->table) {
+ float x_old = x;
+ for (vpos = row_ptr->pos; vpos <= last; ++vpos) {
+ pos = vis2log(vpos);
+ float old_tmpx = tmpx;
+ if (row_ptr->par->IsNewline(pos)) {
+ tmpx = x_old + row_ptr->par->table->WidthOfColumn(cell);
+ x_old = tmpx;
+ ++cell;
+ tmpx += row_ptr->par->table->GetBeginningOfTextInCell(cell);
+ } else {
+ tmpx += SingleWidth(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) )
+ pain.fillRectangle(old_tmpx, offset,
+ tmpx - old_tmpx + 1,
+ row_ptr->height,
+ LColor::selection);
+ }
+ } else {
+ LyXParagraph::size_type main_body =
+ BeginningOfMainBody(row_ptr->par);
+
+ for (vpos = row_ptr->pos; vpos <= last; ++vpos) {
+ pos = vis2log(vpos);
+ float old_tmpx = tmpx;
+ if (main_body > 0 && pos == main_body-1) {
+ tmpx += fill_label_hfill +
+ lyxfont::width(textclasslist.Style(buffer->params.textclass,
+ row_ptr->par->GetLayout()).labelsep,
+ GetFont(row_ptr->par, -2));
+ if (row_ptr->par->IsLineSeparator(main_body-1))
+ tmpx -= SingleWidth(row_ptr->par, main_body-1);
+ }
+ if (HfillExpansion(row_ptr, pos)) {
+ tmpx += SingleWidth(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(row_ptr->par, pos);
+ if (pos >= main_body)
+ tmpx += fill_separator;
+ } else
+ tmpx += SingleWidth(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) )
+ pain.fillRectangle(old_tmpx, offset,
+ 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(tmpx, offset,
+ paperwidth - tmpx,
row_ptr->height,
LColor::selection);
-
- } else if (y > sel_start_cursor.y && y < sel_end_cursor.y) {
- pain.fillRectangle(0, offset,
- paperwidth, row_ptr->height,
- LColor::selection);
}
}
-
+
if (row_ptr->par->appendix){
pain.line(1, offset,
1, offset + row_ptr->height,
paperwidth - 2, offset + row_ptr->height,
LColor::appendixline);
}
+
+ int depth = row_ptr->par->GetDepth();
+ if (depth > 0) {
+ int next_depth = (row_ptr->next)
+ ? next_depth = row_ptr->next->par->GetDepth() : 0;
+ int prev_depth = (row_ptr->previous)
+ ? row_ptr->previous->par->GetDepth() : 0;
+
+ for (int i = 1; i <= depth; ++i)
+ pain.line(4*i, offset,
+ 4*i, offset + row_ptr->height - 1 - (i-next_depth-1)*3,
+ LColor::depthbar);
+
+ for (int i = prev_depth + 1; i <= depth; ++i)
+ pain.fillRectangle(4*i, offset,
+ 4, 2,
+ LColor::depthbar);
+
+ for (int i = next_depth + 1; i <= depth; ++i)
+ pain.fillRectangle(4*i, offset + row_ptr->height - 2 - (i-next_depth-1)*3,
+ 4, 2,
+ LColor::depthbar);
+ }
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 asc = lyxfont::maxAscent(font);
+ int x = (LYX_PAPER_MARGIN - lyxfont::width('|', font)) / 2;
int y1 = (offset + row_ptr->baseline);
int y2 = (offset + row_ptr->baseline) - asc;
pain.line(x, y1, x, y2, LColor::minipageline);
font.setColor(LColor::footnote);
int box_x = LYX_PAPER_MARGIN;
- box_x += font.textWidth(" wide-tab ", 10);
+ box_x += lyxfont::width(" wide-tab ", font);
if (row_ptr->previous &&
row_ptr->previous->par->footnoteflag != LyXParagraph::OPEN_FOOTNOTE){
string fs;
pain.fillRectangle(LYX_PAPER_MARGIN,
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,
LColor::footnoteframe);
pain.text(LYX_PAPER_MARGIN,
- offset + int(font.maxAscent()) + 1,
+ offset + int(lyxfont::maxAscent(font)) + 1,
fs, font);
pain.line(LYX_PAPER_MARGIN, offset,
LYX_PAPER_MARGIN,
- offset + int(font.maxAscent()
- + font.maxDescent()),
+ offset + int(lyxfont::maxAscent(font)
+ + lyxfont::maxDescent(font)),
LColor::footnoteframe);
pain.line(LYX_PAPER_MARGIN,
- offset + int(font.maxAscent()
- + font.maxDescent()) + 1,
+ offset + int(lyxfont::maxAscent(font)
+ + lyxfont::maxDescent(font)) + 1,
box_x,
- offset + int(font.maxAscent()
- + font.maxDescent()) + 1,
+ offset + int(lyxfont::maxAscent(font)
+ + lyxfont::maxDescent(font)) + 1,
LColor::footnoteframe);
}
font.setSize(LyXFont::SIZE_FOOTNOTE);
int box_x = LYX_PAPER_MARGIN;
- box_x += font.textWidth(" wide-tab ", 10);
+ box_x += lyxfont::width(" wide-tab ", font);
pain.line(box_x, offset,
paperwidth - LYX_PAPER_MARGIN,
}
LyXLayout const & layout =
- textclasslist.Style(parameters->textclass,
+ textclasslist.Style(buffer->params.textclass,
row_ptr->par->GetLayout());
firstpar = row_ptr->par->FirstPhysicalPar();
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
LyXFont pb_font;
pb_font.setColor(LColor::pagebreak).decSize();
int w = 0, a = 0, d = 0;
pb_font,
LColor::background,
LColor::background);
-#endif
y_top += 3 * DefaultHeight();
}
/* think about the parskip */
/* some parskips VERY EASY IMPLEMENTATION */
- if (parameters->paragraph_separation == BufferParams::PARSEP_SKIP) {
+ if (buffer->params.paragraph_separation == BufferParams::PARSEP_SKIP) {
if (layout.latextype == LATEX_PARAGRAPH
&& firstpar->GetDepth() == 0
&& firstpar->Previous())
- y_top += parameters->getDefSkip().inPixels(owner_);
+ y_top += buffer->params.getDefSkip().inPixels(owner_);
else if (firstpar->Previous()
- && textclasslist.Style(parameters->textclass,
+ && textclasslist.Style(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 += buffer->params.getDefSkip().inPixels(owner_);
}
if (row_ptr->par->line_top) { /* draw a top line */
- y_top += GetFont(row_ptr->par, 0).ascent('x');
+ y_top += lyxfont::ascent('x', GetFont(row_ptr->par, 0));
pain.line(0, offset + y_top,
paperwidth, offset + y_top,
Painter::line_solid,
Painter::line_thick);
- y_top += GetFont(row_ptr->par, 0).ascent('x');
+ y_top += lyxfont::ascent('x', GetFont(row_ptr->par, 0));
}
/* should we print a label? */
|| layout.latextype != LATEX_ENVIRONMENT
|| row_ptr->par->IsFirstInSequence())) {
font = GetFont(row_ptr->par, -2);
- if (!row_ptr->par->GetLabestring().empty()) {
+ if (!row_ptr->par->GetLabelstring().empty()) {
tmpx = x;
- string tmpstring = row_ptr->par->GetLabestring();
+ string tmpstring = row_ptr->par->GetLabelstring();
if (layout.labeltype == LABEL_COUNTER_CHAPTER) {
- if (parameters->secnumdepth >= 0){
+ if (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. */
- maxdesc = int(font.maxDescent() * layout.spacing.getValue() * parameters->spacing.getValue())
+ float spacing_val = 1.0;
+ if (!row_ptr->par->spacing.isDefault()) {
+ spacing_val = row_ptr->par->spacing.getValue();
+ } else {
+ spacing_val = 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)
+ if (is_rtl)
tmpx = paperwidth - LeftMargin(row_ptr) -
- font.stringWidth(tmpstring);
+ lyxfont::width(tmpstring, font);
pain.text(int(tmpx),
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 {
+ if (is_rtl) {
tmpx = paperwidth - LeftMargin(row_ptr)
- + font.stringWidth(layout.labelsep);
+ + lyxfont::width(layout.labelsep, font);
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);
}
- }
+ } else
+ tmpx = x - lyxfont::width(layout.labelsep, font)
+ - lyxfont::width(tmpstring, font);
+
/* draw it! */
pain.text(int(tmpx),
offset + row_ptr->baseline,
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->GetLabelstring().empty()) {
+ string tmpstring = row_ptr->par->GetLabelstring();
+ float spacing_val = 1.0;
+ if (!row_ptr->par->spacing.isDefault()) {
+ spacing_val = row_ptr->par->spacing.getValue();
+ } else {
+ spacing_val = buffer->params.spacing.getValue();
+ }
+
+ maxdesc = int(lyxfont::maxDescent(font) * layout.spacing.getValue() * spacing_val
+ (layout.labelbottomsep * DefaultHeight()));
tmpx = x;
if (layout.labeltype == LABEL_CENTERED_TOP_ENVIRONMENT){
- tmpx = ( ((direction == LYX_DIR_LEFT_TO_RIGHT)
- ? x : LeftMargin(row_ptr) )
+ tmpx = ( (is_rtl ? LeftMargin(row_ptr) : x)
+ paperwidth - RightMargin(row_ptr) ) / 2;
- tmpx -= (font.stringWidth(tmpstring)/2);
- } else if (direction == LYX_DIR_RIGHT_TO_LEFT)
+ tmpx -= lyxfont::width(tmpstring, font) / 2;
+ } else if (is_rtl)
tmpx = paperwidth - LeftMargin(row_ptr) -
- font.stringWidth(tmpstring);
+ lyxfont::width(tmpstring, font);
pain.text(int(tmpx),
offset + row_ptr->baseline
- row_ptr->ascent_of_text
}
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);
- else
+ if (is_rtl)
tmpx = paperwidth - LeftMargin(row_ptr)
- + font.stringWidth(layout.labelsep);
- row_ptr->par->bibkey->draw(owner_->painter(),
+ + lyxfont::width(layout.labelsep, font);
+ else
+ tmpx = x - lyxfont::width(layout.labelsep, font)
+ - row_ptr->par->bibkey->width(owner_->painter(), font);
+ row_ptr->par->bibkey->draw(pain,
font,
offset + row_ptr->baseline,
tmpx);
/* is it a last row? */
par = row_ptr->par->LastPhysicalPar();
- if (row_ptr->par->ParFromPos(RowLast(row_ptr) + 1) == par
+ if (row_ptr->par->ParFromPos(last + 1) == par
&& (!row_ptr->next || row_ptr->next->par != row_ptr->par)) {
/* think about the margins */
/* 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
LyXFont pb_font;
pb_font.setColor(LColor::pagebreak).decSize();
int w = 0, a = 0, d = 0;
pb_font,
LColor::background,
LColor::background);
-#endif
y_bottom -= 3 * DefaultHeight();
}
if (firstpar->line_bottom) {
/* draw a bottom line */
- y_bottom -= GetFont(par, par->Last() - 1).ascent('x');
+ y_bottom -= lyxfont::ascent('x', GetFont(par, par->Last() - 1));
pain.line(0, offset + y_bottom,
paperwidth, offset + y_bottom,
LColor::topline, Painter::line_solid,
Painter::line_thick);
- y_bottom -= GetFont(par, par->Last() - 1).ascent('x');
+ y_bottom -= lyxfont::ascent('x', GetFont(par, par->Last() - 1));
}
// 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());
+ LyXFont font = GetFont(row_ptr->par, last);
+ int size = int(0.75 * lyxfont::maxAscent(font));
int y = (offset + row_ptr->baseline) - size;
- int x = (direction == LYX_DIR_LEFT_TO_RIGHT)
- ? paperwidth - LYX_PAPER_MARGIN - size
- : LYX_PAPER_MARGIN;
+ int x = is_rtl ? LYX_PAPER_MARGIN
+ : paperwidth - LYX_PAPER_MARGIN - size;
if (row_ptr->par->footnoteflag == LyXParagraph::OPEN_FOOTNOTE)
- if (direction == LYX_DIR_LEFT_TO_RIGHT)
- x -= LYX_PAPER_MARGIN/2;
- else {
+ if (is_rtl) {
LyXFont font(LyXFont::ALL_SANE);
font.setSize(LyXFont::SIZE_SMALL);
- x += font.textWidth("Mwide-figM", 10);
- }
+ x += lyxfont::width("Mwide-figM", font);
+ } else
+ x -= LYX_PAPER_MARGIN/2;
if (row_ptr->fill <= size)
- x += (size - row_ptr->fill + 1) * direction;
+ x += (size - row_ptr->fill + 1) * (is_rtl ? -1 : 1);
if (endlabel == END_LABEL_BOX) {
pain.line(x, y, x, y + size,
LColor::eolmarker);
}
/* draw the text in the pixmap */
- pos_end = RowLast(row_ptr);
vpos = row_ptr->pos;
/* table stuff -- begin*/
float x_old = x;
x += row_ptr->par->table->GetBeginningOfTextInCell(cell);
- while (vpos <= pos_end) {
+ while (vpos <= last) {
pos = vis2log(vpos);
if (row_ptr->par->IsNewline(pos)) {
} 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);
LyXParagraph::size_type main_body =
BeginningOfMainBody(row_ptr->par);
if (main_body > 0 &&
- (main_body-1 > pos_end ||
+ (main_body-1 > last ||
!row_ptr->par->IsLineSeparator(main_body-1)))
main_body = 0;
- while (vpos <= pos_end) {
+ while (vpos <= last) {
pos = vis2log(vpos);
if (main_body > 0 && pos == main_body-1) {
x += fill_label_hfill
- + GetFont(row_ptr->par, -2).stringWidth(layout.labelsep)
+ + lyxfont::width(layout.labelsep, GetFont(row_ptr->par, -2))
- SingleWidth(row_ptr->par, main_body-1);
}
x += 2;
++vpos;
} else if (row_ptr->par->IsSeparator(pos)) {
- tmpx = x;
- x+= SingleWidth(row_ptr->par, pos);
+ 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);
-
- /* 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
+ x += fill_separator;
++vpos;
} else
draw(row_ptr, vpos, offset, x);
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);
}
PrepareToPrint(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 last = RowLastPrintable(row);
LyXParagraph::size_type c = 0;
-
- LyXLayout const & layout = textclasslist.Style(parameters->textclass,
+ LyXLayout const & layout = textclasslist.Style(buffer->params.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
+ //the last row doesn't need a newline at the end
+ if (row->next && row->next->par == row->par
&& row->par->IsNewline(last))
last--;
int cell = NumberOfCell(row->par, row->pos);
last_tmpx = tmpx;
if (main_body > 0 && c == main_body-1) {
tmpx += fill_label_hfill +
- GetFont(row->par, -2).stringWidth(layout.labelsep);
+ lyxfont::width(layout.labelsep,
+ GetFont(row->par, -2));
if (row->par->IsLineSeparator(main_body-1))
tmpx -= SingleWidth(row->par, main_body-1);
}
- tmpx += SingleWidth(row->par, c);
if (HfillExpansion(row, c)) {
+ x += SingleWidth(row->par, 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;
- }
+ else if (row->par->IsSeparator(c)) {
+ tmpx += SingleWidth(row->par, c);
+ if (c >= main_body)
+ tmpx+= fill_separator;
+ } else
+ tmpx += SingleWidth(row->par, c);
++vc;
}
tmpx = last_tmpx;
}
}
- /* 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 (vc > last + 1) // This shouldn't happen.
+ vc = last+1;
+
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)
+ (vc - 1 >= row->pos &&
+ ( (row->par->IsSeparator(vis2log(vc)) && vis2log(vc) != last)
+ || (row->par->table && row->par->IsNewline(vc) )
+ ))) {
+ c = vis2log(vc - 1);
+ if (bidi_level(c) % 2 == 0)
++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)
+ if (bidi_level(c) % 2 == 1)
++c;
}
if (!row->par->table && row->pos <= last && c > last
&& row->par->IsNewline(last)) {
- if (row->par->getLetterDirection(last) == LYX_DIR_LEFT_TO_RIGHT)
+ if (bidi_level(last) % 2 == 0)
tmpx -= SingleWidth(row->par, last);
else
tmpx += SingleWidth(row->par, last);
|| kind == LyXParagraph::WIDE_FIG
|| kind == LyXParagraph::ALGORITHM) {
pair<bool, LyXTextClass::size_type> lres =
- textclasslist.NumberOfLayout(parameters->textclass,
+ textclasslist.NumberOfLayout(buffer->params.textclass,
"Caption");
LyXTextClass::size_type lay;
if (lres.first) {
Row * LyXText::GetRow(LyXParagraph * par,
LyXParagraph::size_type pos, long & 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;
+ 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;
}
- currentrow = tmprow;
- currentrow_y = y;
-
return tmprow;
}
projects / features.git / blobdiff