anne/lyx_mirror
1
0
Fork 0
mirror of https://git.lyx.org/repos/lyx.git synced 2024-12-23 05:25:26 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

change a few par_type args in LyXText::* to Paragrpah & to speed things

Browse Source 
up


git-svn-id: svn://svn.lyx.org/lyx/lyx-devel/trunk@8940 a592a061-630c-0410-9148-cb99ea01b6c8
This commit is contained in:
André Pönitz 2004-08-15 00:01:45 +00:00
parent 0fe5cc3913
commit 93430a89da
7 changed files with 223 additions and 211 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
src/ChangeLog
View File

@ -1,3 +1,11 @@
2004-08-14 André Pönitz <poenitz@gmx.net>
* text.C:
* text2.C:
* rowpainter.C:
* lyxtext.h (several functions): use a Paragraph & argument
instead of par_type
2004-08-15 Jean-Marc Lasgouttes <lasgouttes@lyx.org>
* metricsinfo.h: add a new field ltr_pos to PainterInfo

4
src/FontIterator.C
View File

@ -21,7 +21,7 @@
FontIterator::FontIterator(LyXText const & text, lyx::par_type pit,
lyx::pos_type pos)
: text_(text), pit_(pit), pos_(pos),
font_(text.getFont(pit, pos)),
font_(text.getFont(text.getPar(pit), pos)),
endspan_(text.getPar(pit).getEndPosOfFontSpan(pos)),
bodypos_(text.getPar(pit).beginOfBody())
{}
@ -43,7 +43,7 @@ FontIterator & FontIterator::operator++()
{
++pos_;
if (pos_ > endspan_ || pos_ == bodypos_) {
font_ = text_.getFont(pit_, pos_);
font_ = text_.getFont(text_.getPar(pit_), pos_);
endspan_ = text_.getPar(pit_).getEndPosOfFontSpan(pos_);
}
return *this;

9
src/insets/insettabular.C
View File

@ -1693,7 +1693,8 @@ bool InsetTabular::insertAsciiString(BufferView & bv, string const & buf,
// we can only set this if we are not too far right
if (cols < columns) {
InsetText & inset = loctab->getCellInset(cell);
LyXFont const font = inset.text_.getFont(0, 0);
Paragraph & par = inset.text_.getPar(0);
LyXFont const font = inset.text_.getFont(par, 0);
inset.setText(buf.substr(op, p - op), font);
++cols;
++cell;
@ -1703,7 +1704,8 @@ bool InsetTabular::insertAsciiString(BufferView & bv, string const & buf,
// we can only set this if we are not too far right
if (cols < columns) {
InsetText & inset = tabular.getCellInset(cell);
LyXFont const font = inset.text_.getFont(0, 0);
Paragraph & par = inset.text_.getPar(0);
LyXFont const font = inset.text_.getFont(par, 0);
inset.setText(buf.substr(op, p - op), font);
}
cols = ocol;
@ -1718,7 +1720,8 @@ bool InsetTabular::insertAsciiString(BufferView & bv, string const & buf,
// check for the last cell if there is no trailing '\n'
if (cell < cells && op < len) {
InsetText & inset = loctab->getCellInset(cell);
LyXFont const font = inset.text_.getFont(0, 0);
Paragraph & par = inset.text_.getPar(0);
LyXFont const font = inset.text_.getFont(par, 0);
inset.setText(buf.substr(op, len - op), font);
}
return true;

10
src/lyxtext.h
View File

@ -59,11 +59,11 @@ public:
/// update y coordinate cache of all paragraphs
void updateParPositions();
///
LyXFont getFont(par_type pit, pos_type pos) const;
LyXFont getFont(Paragraph const & par, pos_type pos) const;
///
LyXFont getLayoutFont(par_type pit) const;
///
LyXFont getLabelFont(par_type pit) const;
LyXFont getLabelFont(Paragraph const & par) const;
///
void setCharFont(par_type pit, pos_type pos, LyXFont const & font);
///
@ -271,9 +271,9 @@ public:
InsetBase * checkInsetHit(int x, int y) const;
///
int singleWidth(par_type pit, pos_type pos) const;
int singleWidth(Paragraph const & par, pos_type pos) const;
///
int singleWidth(par_type pit,
int singleWidth(Paragraph const & par,
pos_type pos, char c, LyXFont const & Font) const;
/// return the color of the canvas
@ -399,7 +399,7 @@ private:
/// sets row.width to the minimum space a row needs on the screen in pixel
void setRowWidth(par_type pit, Row & row) const;
/// the minimum space a manual label needs on the screen in pixels
int labelFill(par_type pit, Row const & row) const;
int labelFill(Paragraph const & par, Row const & row) const;
/// FIXME
int labelEnd(par_type pit) const;

117
src/rowpainter.C
View File

@ -104,7 +104,8 @@ private:
Row & row_;
/// Row's paragraph
mutable par_type pit_;
par_type const pit_;
Paragraph const & par_;
// Looks ugly - is
double xo_;
@ -120,12 +121,12 @@ private:
RowPainter::RowPainter(BufferView const & bv, Painter & pain,
LyXText const & text, par_type pit, RowList::iterator rit, int y)
: bv_(bv), pain_(pain), text_(text), pars_(text.paragraphs()),
rit_(rit), row_(*rit), pit_(pit),
rit_(rit), row_(*rit), pit_(pit), par_(text.paragraphs()[pit]),
xo_(text_.xo_), yo_(y), width_(text_.width())
{
//lyxerr << "RowPainter: x: " << x_ << " xo: " << xo << " yo: " << yo
// << " pit->y: " << pit_->y
// << " row: " << (pars_[pit_].size() ? pars_[pit_].getChar(row_.pos()) : 'X') << endl;
// << " row: " << (par_.size() ? par_.getChar(row_.pos()) : 'X') << endl;
RowMetrics m = text_.computeRowMetrics(pit, row_);
x_ = m.x + xo_;
@ -154,7 +155,7 @@ RowPainter::RowPainter(BufferView const & bv, Painter & pain,
if (row_.pos() == 0)
paintFirst();
if (row_.endpos() >= pars_[pit_].size())
if (row_.endpos() >= par_.size())
paintLast();
// paint text
@ -165,26 +166,26 @@ RowPainter::RowPainter(BufferView const & bv, Painter & pain,
/// "temporary"
LyXFont const RowPainter::getFont(pos_type pos) const
{
return text_.getFont(pit_, pos);
return text_.getFont(par_, pos);
}
int RowPainter::singleWidth(lyx::pos_type pos) const
{
return text_.singleWidth(pit_, pos);
return text_.singleWidth(par_, pos);
}
int RowPainter::singleWidth(lyx::pos_type pos, char c) const
{
LyXFont const & font = text_.getFont(pit_, pos);
return text_.singleWidth(pit_, pos, c, font);
LyXFont const & font = text_.getFont(par_, pos);
return text_.singleWidth(par_, pos, c, font);
}
LyXFont const RowPainter::getLabelFont() const
{
return text_.getLabelFont(pit_);
return text_.getLabelFont(par_);
}
@ -196,7 +197,7 @@ int RowPainter::leftMargin() const
void RowPainter::paintInset(pos_type const pos)
{
InsetBase const * inset = pars_[pit_].getInset(pos);
InsetBase const * inset = par_.getInset(pos);
BOOST_ASSERT(inset);
PainterInfo pi(const_cast<BufferView *>(&bv_), pain_);
pi.base.font = getFont(pos);
@ -215,7 +216,7 @@ void RowPainter::paintHebrewComposeChar(pos_type & vpos)
string str;
// first char
char c = pars_[pit_].getChar(pos);
char c = par_.getChar(pos);
str += c;
++vpos;
@ -224,7 +225,7 @@ void RowPainter::paintHebrewComposeChar(pos_type & vpos)
int dx = 0;
for (pos_type i = pos - 1; i >= 0; --i) {
c = pars_[pit_].getChar(i);
c = par_.getChar(i);
if (!Encodings::IsComposeChar_hebrew(c)) {
if (IsPrintableNonspace(c)) {
int const width2 = singleWidth(i, c);
@ -248,8 +249,8 @@ void RowPainter::paintArabicComposeChar(pos_type & vpos)
string str;
// first char
char c = pars_[pit_].getChar(pos);
c = pars_[pit_].transformChar(c, pos);
char c = par_.getChar(pos);
c = par_.transformChar(c, pos);
str += c;
++vpos;
@ -258,7 +259,7 @@ void RowPainter::paintArabicComposeChar(pos_type & vpos)
int dx = 0;
for (pos_type i = pos - 1; i >= 0; --i) {
c = pars_[pit_].getChar(i);
c = par_.getChar(i);
if (!Encodings::IsComposeChar_arabic(c)) {
if (IsPrintableNonspace(c)) {
int const width2 = singleWidth(i, c);
@ -280,26 +281,26 @@ void RowPainter::paintChars(pos_type & vpos, bool hebrew, bool arabic)
// first character
string str;
str += pars_[pit_].getChar(pos);
str += par_.getChar(pos);
if (arabic) {
unsigned char c = str[0];
str[0] = pars_[pit_].transformChar(c, pos);
str[0] = par_.transformChar(c, pos);
}
bool prev_struckout = isDeletedText(pars_[pit_], pos);
bool prev_newtext = isInsertedText(pars_[pit_], pos);
bool prev_struckout = isDeletedText(par_, pos);
bool prev_newtext = isInsertedText(par_, pos);
// collect as much similar chars as we can
for (++vpos; vpos < end && (pos = text_.bidi.vis2log(vpos)) >= 0; ++vpos) {
char c = pars_[pit_].getChar(pos);
char c = par_.getChar(pos);
if (!IsPrintableNonspace(c))
break;
if (prev_struckout != isDeletedText(pars_[pit_], pos))
if (prev_struckout != isDeletedText(par_, pos))
break;
if (prev_newtext != isInsertedText(pars_[pit_], pos))
if (prev_newtext != isInsertedText(par_, pos))
break;
if (arabic && Encodings::IsComposeChar_arabic(c))
@ -312,7 +313,7 @@ void RowPainter::paintChars(pos_type & vpos, bool hebrew, bool arabic)
break;
if (arabic)
c = pars_[pit_].transformChar(c, pos);
c = par_.transformChar(c, pos);
str += c;
}
@ -352,7 +353,7 @@ void RowPainter::paintFromPos(pos_type & vpos)
double const orig_x = x_;
char const c = pars_[pit_].getChar(pos);
char const c = par_.getChar(pos);
if (c == Paragraph::META_INSET) {
paintInset(pos);
@ -396,7 +397,7 @@ void RowPainter::paintBackground()
void RowPainter::paintSelection()
{
bool const is_rtl = text_.isRTL(pars_[pit_]);
bool const is_rtl = text_.isRTL(par_);
// the current selection
LCursor const & cur = bv_.cursor();
@ -408,7 +409,7 @@ void RowPainter::paintSelection()
RowList::iterator endrow = pars_[endpit].getRow(cur.selEnd().pos());
int const h = row_.height();
int const row_y = text_.yo_ + pars_[pit_].y + row_.y_offset();
int const row_y = text_.yo_ + par_.y + row_.y_offset();
bool const sel_starts_here = startpit == pit_ && startrow == rit_;
bool const sel_ends_here = endpit == pit_ && endrow == rit_;
@ -442,7 +443,7 @@ void RowPainter::paintSelection()
pain_.fillRectangle(int(xo_), yo_,
int(x_), h, LColor::selection);
pos_type const body_pos = pars_[pit_].beginOfBody();
pos_type const body_pos = par_.beginOfBody();
pos_type const end = row_.endpos();
double tmpx = x_;
@ -450,24 +451,24 @@ void RowPainter::paintSelection()
pos_type pos = text_.bidi.vis2log(vpos);
double const old_tmpx = tmpx;
if (body_pos > 0 && pos == body_pos - 1) {
LyXLayout_ptr const & layout = pars_[pit_].layout();
LyXLayout_ptr const & layout = par_.layout();
LyXFont const lfont = getLabelFont();
tmpx += label_hfill_ + font_metrics::width(layout->labelsep, lfont);
if (pars_[pit_].isLineSeparator(body_pos - 1))
if (par_.isLineSeparator(body_pos - 1))
tmpx -= singleWidth(body_pos - 1);
}
tmpx += singleWidth(pos);
if (hfillExpansion(pars_[pit_], row_, pos)) {
if (hfillExpansion(par_, row_, pos)) {
if (pos >= body_pos)
tmpx += hfill_;
else
tmpx += label_hfill_;
} else {
if (pars_[pit_].isSeparator(pos) && pos >= body_pos)
if (par_.isSeparator(pos) && pos >= body_pos)
tmpx += separator_;
}
@ -494,7 +495,7 @@ void RowPainter::paintChangeBar()
pos_type const start = row_.pos();
pos_type const end = row_.endpos();
if (start == end || !pars_[pit_].isChanged(start, end - 1))
if (start == end || !par_.isChanged(start, end - 1))
return;
int const height = text_.isLastRow(pit_, row_)
@ -507,12 +508,12 @@ void RowPainter::paintChangeBar()
void RowPainter::paintAppendix()
{
if (!pars_[pit_].params().appendix())
if (!par_.params().appendix())
return;
int y = yo_;
if (pars_[pit_].params().startOfAppendix())
if (par_.params().startOfAppendix())
y += 2 * defaultRowHeight();
pain_.line(1, y, 1, yo_ + row_.height(), LColor::appendix);
@ -522,7 +523,7 @@ void RowPainter::paintAppendix()
void RowPainter::paintDepthBar()
{
Paragraph::depth_type const depth = pars_[pit_].getDepth();
Paragraph::depth_type const depth = par_.getDepth();
if (depth <= 0)
return;
@ -588,7 +589,7 @@ int RowPainter::paintAppendixStart(int y)
void RowPainter::paintFirst()
{
ParagraphParameters const & parparams = pars_[pit_].params();
ParagraphParameters const & parparams = par_.params();
int y_top = 0;
@ -598,12 +599,12 @@ void RowPainter::paintFirst()
Buffer const & buffer = *bv_.buffer();
LyXLayout_ptr const & layout = pars_[pit_].layout();
LyXLayout_ptr const & layout = par_.layout();
if (buffer.params().paragraph_separation == BufferParams::PARSEP_SKIP) {
if (pit_ != 0) {
if (layout->latextype == LATEX_PARAGRAPH
&& !pars_[pit_].getDepth()) {
&& !par_.getDepth()) {
y_top += buffer.params().getDefSkip().inPixels(bv_);
} else {
LyXLayout_ptr const & playout = pars_[pit_ - 1].layout();
@ -616,9 +617,9 @@ void RowPainter::paintFirst()
}
}
bool const is_rtl = text_.isRTL(pars_[pit_]);
bool const is_rtl = text_.isRTL(par_);
bool const is_seq = isFirstInSequence(pit_, text_.paragraphs());
//lyxerr << "paintFirst: " << pars_[pit_].id() << " is_seq: " << is_seq << std::endl;
//lyxerr << "paintFirst: " << par_.id() << " is_seq: " << is_seq << std::endl;
// should we print a label?
if (layout->labeltype >= LABEL_STATIC
@ -627,9 +628,9 @@ void RowPainter::paintFirst()
|| is_seq)) {
LyXFont font = getLabelFont();
if (!pars_[pit_].getLabelstring().empty()) {
if (!par_.getLabelstring().empty()) {
double x = x_;
string const str = pars_[pit_].getLabelstring();
string const str = par_.getLabelstring();
// this is special code for the chapter layout. This is
// printed in an extra row and has a pagebreak at
@ -677,8 +678,8 @@ void RowPainter::paintFirst()
layout->labeltype == LABEL_BIBLIO ||
layout->labeltype == LABEL_CENTERED_TOP_ENVIRONMENT)) {
LyXFont font = getLabelFont();
if (!pars_[pit_].getLabelstring().empty()) {
string const str = pars_[pit_].getLabelstring();
if (!par_.getLabelstring().empty()) {
string const str = par_.getLabelstring();
float spacing_val = 1.0;
if (!parparams.spacing().isDefault()) {
spacing_val = parparams.spacing().getValue();
@ -693,7 +694,7 @@ void RowPainter::paintFirst()
double x = x_;
if (layout->labeltype == LABEL_CENTERED_TOP_ENVIRONMENT) {
x = ((is_rtl ? leftMargin() : x_)
+ width_ - text_.rightMargin(pars_[pit_])) / 2;
+ width_ - text_.rightMargin(par_)) / 2;
x -= font_metrics::width(str, font) / 2;
} else if (is_rtl) {
x = width_ - leftMargin() -
@ -709,7 +710,7 @@ void RowPainter::paintFirst()
void RowPainter::paintLast()
{
bool const is_rtl = text_.isRTL(pars_[pit_]);
bool const is_rtl = text_.isRTL(par_);
int const endlabel = getEndLabel(pit_, text_.paragraphs());
// draw an endlabel
@ -733,10 +734,10 @@ void RowPainter::paintLast()
case END_LABEL_STATIC: {
LyXFont font = getLabelFont();
string const & str = pars_[pit_].layout()->endlabelstring();
string const & str = par_.layout()->endlabelstring();
double const x = is_rtl ?
x_ - font_metrics::width(str, font)
: - text_.rightMargin(pars_[pit_]) - row_.width();
: - text_.rightMargin(par_) - row_.width();
pain_.text(int(x), yo_ + row_.baseline(), str, font);
break;
}
@ -750,13 +751,13 @@ void RowPainter::paintLast()
void RowPainter::paintText()
{
pos_type const end = row_.endpos();
pos_type body_pos = pars_[pit_].beginOfBody();
pos_type body_pos = par_.beginOfBody();
if (body_pos > 0 &&
(body_pos > end || !pars_[pit_].isLineSeparator(body_pos - 1))) {
(body_pos > end || !par_.isLineSeparator(body_pos - 1))) {
body_pos = 0;
}
LyXLayout_ptr const & layout = pars_[pit_].layout();
LyXLayout_ptr const & layout = par_.layout();
bool running_strikeout = false;
bool is_struckout = false;
@ -768,7 +769,7 @@ void RowPainter::paintText()
pos_type pos = text_.bidi.vis2log(vpos);
if (pos >= pars_[pit_].size()) {
if (pos >= par_.size()) {
++vpos;
continue;
}
@ -779,15 +780,15 @@ void RowPainter::paintText()
continue;
}
is_struckout = isDeletedText(pars_[pit_], pos);
is_struckout = isDeletedText(par_, pos);
if (is_struckout && !running_strikeout) {
running_strikeout = true;
last_strikeout_x = int(x_);
}
bool const highly_editable_inset = pars_[pit_].isInset(pos)
&& isHighlyEditableInset(pars_[pit_].getInset(pos));
bool const highly_editable_inset = par_.isInset(pos)
&& isHighlyEditableInset(par_.getInset(pos));
// if we reach the end of a struck out range, paint it
// we also don't paint across things like tables
@ -805,7 +806,7 @@ void RowPainter::paintText()
x_ += label_hfill_ + lwidth - singleWidth(body_pos - 1);
}
if (pars_[pit_].isHfill(pos)) {
if (par_.isHfill(pos)) {
x_ += 1;
int const y0 = yo_ + row_.baseline();
@ -813,7 +814,7 @@ void RowPainter::paintText()
pain_.line(int(x_), y1, int(x_), y0, LColor::added_space);
if (hfillExpansion(pars_[pit_], row_, pos)) {
if (hfillExpansion(par_, row_, pos)) {
int const y2 = (y0 + y1) / 2;
if (pos >= body_pos) {
@ -831,7 +832,7 @@ void RowPainter::paintText()
}
x_ += 2;
++vpos;
} else if (pars_[pit_].isSeparator(pos)) {
} else if (par_.isSeparator(pos)) {
x_ += singleWidth(pos);
if (pos >= body_pos)
x_ += separator_;

205
src/text.C
View File

@ -439,17 +439,15 @@ int LyXText::height() const
}
int LyXText::singleWidth(par_type par, pos_type pos) const
int LyXText::singleWidth(Paragraph const & par, pos_type pos) const
{
char const c = pars_[par].getChar(pos);
return singleWidth(par, pos, c, getFont(par, pos));
return singleWidth(par, pos, par.getChar(pos), getFont(par, pos));
}
int LyXText::singleWidth(par_type const pit,
int LyXText::singleWidth(Paragraph const & par,
pos_type pos, char c, LyXFont const & font) const
{
Paragraph const & par = pars_[pit];
if (pos >= par.size()) {
lyxerr << "in singleWidth(), pos: " << pos << endl;
BOOST_ASSERT(false);
@ -520,7 +518,7 @@ int LyXText::leftMargin(par_type const pit, pos_type const pos) const
}
}
LyXFont const labelfont = getLabelFont(pit);
LyXFont const labelfont = getLabelFont(par);
switch (layout->margintype) {
case MARGIN_DYNAMIC:
if (!layout->leftmargin.empty())
@ -730,13 +728,13 @@ void LyXText::rowBreakPoint(par_type const pit, Row & row) const
char const c = par.getChar(i);
{
int thiswidth = singleWidth(pit, i, c, *fi);
int thiswidth = singleWidth(par, i, c, *fi);
// add the auto-hfill from label end to the body
if (body_pos && i == body_pos) {
int add = font_metrics::width(layout->labelsep, getLabelFont(pit));
if (pars_[pit].isLineSeparator(i - 1))
add -= singleWidth(pit, i - 1);
int add = font_metrics::width(layout->labelsep, getLabelFont(par));
if (par.isLineSeparator(i - 1))
add -= singleWidth(par, i - 1);
add = std::max(add, labelEnd(pit) - x);
thiswidth += add;
@ -818,20 +816,20 @@ void LyXText::setRowWidth(par_type const pit, Row & row) const
FontIterator fi = FontIterator(*this, pit, i);
for ( ; i < end; ++i, ++fi) {
if (body_pos > 0 && i == body_pos) {
w += font_metrics::width(labelsep, getLabelFont(pit));
w += font_metrics::width(labelsep, getLabelFont(par));
if (par.isLineSeparator(i - 1))
w -= singleWidth(pit, i - 1);
w -= singleWidth(par, i - 1);
w = max(w, labelEnd(pit));
}
char const c = par.getChar(i);
w += singleWidth(pit, i, c, *fi);
w += singleWidth(par, i, c, *fi);
}
}
if (body_pos > 0 && body_pos >= end) {
w += font_metrics::width(labelsep, getLabelFont(pit));
w += font_metrics::width(labelsep, getLabelFont(par));
if (end > 0 && par.isLineSeparator(end - 1))
w -= singleWidth(pit, end - 1);
w -= singleWidth(par, end - 1);
w = max(w, labelEnd(pit));
}
@ -840,9 +838,9 @@ void LyXText::setRowWidth(par_type const pit, Row & row) const
// returns the minimum space a manual label needs on the screen in pixel
int LyXText::labelFill(par_type pit, Row const & row) const
int LyXText::labelFill(Paragraph const & par, Row const & row) const
{
pos_type last = pars_[pit].beginOfBody();
pos_type last = par.beginOfBody();
BOOST_ASSERT(last > 0);
@ -850,18 +848,18 @@ int LyXText::labelFill(par_type pit, Row const & row) const
--last;
// a separator at this end does not count
if (pars_[pit].isLineSeparator(last))
if (par.isLineSeparator(last))
--last;
int w = 0;
for (pos_type i = row.pos(); i <= last; ++i)
w += singleWidth(pit, i);
w += singleWidth(par, i);
string const & label = pars_[pit].params().labelWidthString();
string const & label = par.params().labelWidthString();
if (label.empty())
return 0;
return max(0, font_metrics::width(label, getLabelFont(pit)) - w);
return max(0, font_metrics::width(label, getLabelFont(par)) - w);
}
@ -871,8 +869,9 @@ LColor_color LyXText::backgroundColor() const
}
void LyXText::setHeightOfRow(par_type pit, Row & row)
void LyXText::setHeightOfRow(par_type const pit, Row & row)
{
Paragraph const & par = pars_[pit];
// get the maximum ascent and the maximum descent
double layoutasc = 0;
double layoutdesc = 0;
@ -881,30 +880,29 @@ void LyXText::setHeightOfRow(par_type pit, Row & row)
// ok, let us initialize the maxasc and maxdesc value.
// Only the fontsize count. The other properties
// are taken from the layoutfont. Nicer on the screen :)
LyXLayout_ptr const & layout = pars_[pit].layout();
LyXLayout_ptr const & layout = par.layout();
// as max get the first character of this row then it can
// increase but not decrease the height. Just some point to
// start with so we don't have to do the assignment below too
// often.
LyXFont font = getFont(pit, row.pos());
LyXFont font = getFont(par, row.pos());
LyXFont::FONT_SIZE const tmpsize = font.size();
font = getLayoutFont(pit);
LyXFont::FONT_SIZE const size = font.size();
font.setSize(tmpsize);
LyXFont labelfont = getLabelFont(pit);
LyXFont labelfont = getLabelFont(par);
// these are minimum values
double const spacing_val =
layout->spacing.getValue() * spacing(pars_[pit]);
double const spacing_val = layout->spacing.getValue() * spacing(par);
//lyxerr << "spacing_val = " << spacing_val << endl;
int maxasc = int(font_metrics::maxAscent(font) * spacing_val);
int maxdesc = int(font_metrics::maxDescent(font) * spacing_val);
// insets may be taller
InsetList::const_iterator ii = pars_[pit].insetlist.begin();
InsetList::const_iterator iend = pars_[pit].insetlist.end();
InsetList::const_iterator ii = par.insetlist.begin();
InsetList::const_iterator iend = par.insetlist.end();
for ( ; ii != iend; ++ii) {
if (ii->pos >= row.pos() && ii->pos < row.endpos()) {
maxasc = max(maxasc, ii->inset->ascent());
@ -919,7 +917,7 @@ void LyXText::setHeightOfRow(par_type pit, Row & row)
pos_type const pos_end = row.endpos();
LyXFont::FONT_SIZE maxsize =
pars_[pit].highestFontInRange(row.pos(), pos_end, size);
par.highestFontInRange(row.pos(), pos_end, size);
if (maxsize > font.size()) {
font.setSize(maxsize);
maxasc = max(maxasc, font_metrics::maxAscent(font));
@ -939,7 +937,7 @@ void LyXText::setHeightOfRow(par_type pit, Row & row)
if (bv()->buffer()->params().paragraph_separation
== BufferParams::PARSEP_SKIP
&& pit != 0
&& ((layout->isParagraph() && pars_[pit].getDepth() == 0)
&& ((layout->isParagraph() && par.getDepth() == 0)
|| (pars_[pit - 1].layout()->isParagraph()
&& pars_[pit - 1].getDepth() == 0)))
{
@ -954,7 +952,7 @@ void LyXText::setHeightOfRow(par_type pit, Row & row)
if (layout->counter == "chapter" && bufparams.secnumdepth >= 0) {
labeladdon = int(font_metrics::maxHeight(labelfont)
* layout->spacing.getValue()
* spacing(pars_[pit]));
* spacing(par));
}
// special code for the top label
@ -962,12 +960,12 @@ void LyXText::setHeightOfRow(par_type pit, Row & row)
|| layout->labeltype == LABEL_BIBLIO
|| layout->labeltype == LABEL_CENTERED_TOP_ENVIRONMENT)
&& isFirstInSequence(pit, paragraphs())
&& !pars_[pit].getLabelstring().empty())
&& !par.getLabelstring().empty())
{
labeladdon = int(
font_metrics::maxHeight(labelfont)
* layout->spacing.getValue()
* spacing(pars_[pit])
* spacing(par)
+ (layout->topsep + layout->labelbottomsep) * dh);
}
@ -975,11 +973,11 @@ void LyXText::setHeightOfRow(par_type pit, Row & row)
// a section, or between the items of a itemize or enumerate
// environment.
par_type prev = depthHook(pit, pars_, pars_[pit].getDepth());
par_type prev = depthHook(pit, pars_, par.getDepth());
if (prev != pit
&& pars_[prev].layout() == layout
&& pars_[prev].getDepth() == pars_[pit].getDepth()
&& pars_[prev].getLabelWidthString() == pars_[pit].getLabelWidthString())
&& pars_[prev].getDepth() == par.getDepth()
&& pars_[prev].getLabelWidthString() == par.getLabelWidthString())
{
layoutasc = layout->itemsep * dh;
} else if (pit != 0 || row.pos() != 0) {
@ -999,7 +997,7 @@ void LyXText::setHeightOfRow(par_type pit, Row & row)
}
// is it a bottom line?
if (row.endpos() >= pars_[pit].size()) {
if (row.endpos() >= par.size()) {
// add the layout spaces, for example before and after
// a section, or between the items of a itemize or enumerate
// environment
@ -1036,6 +1034,10 @@ void LyXText::setHeightOfRow(par_type pit, Row & row)
}
namespace {
}
void LyXText::breakParagraph(LCursor & cur, char keep_layout)
{
BOOST_ASSERT(this == cur.text());
@ -1083,7 +1085,7 @@ void LyXText::breakParagraph(LCursor & cur, char keep_layout)
// well this is the caption hack since one caption is really enough
if (layout->labeltype == LABEL_SENSITIVE) {
if (!cur.pos())
if (cur.pos() == 0)
// set to standard-layout
pars_[cpit].applyLayout(tclass.defaultLayout());
else
@ -1138,7 +1140,7 @@ void LyXText::insertChar(LCursor & cur, char c)
Paragraph & par = cur.paragraph();
// try to remove this
par_type pit = cur.par();
par_type const pit = cur.par();
bool const freeSpacing = par.layout()->free_spacing ||
par.isFreeSpacing();
@ -1153,8 +1155,8 @@ void LyXText::insertChar(LCursor & cur, char c)
!(contains(number_seperators, c) &&
cur.pos() != 0 &&
cur.pos() != cur.lastpos() &&
getFont(pit, cur.pos()).number() == LyXFont::ON &&
getFont(pit, cur.pos() - 1).number() == LyXFont::ON)
getFont(par, cur.pos()).number() == LyXFont::ON &&
getFont(par, cur.pos() - 1).number() == LyXFont::ON)
)
number(cur); // Set current_font.number to OFF
} else if (IsDigit(c) &&
@ -1171,7 +1173,7 @@ void LyXText::insertChar(LCursor & cur, char c)
setCharFont(pit, cur.pos() - 1, current_font);
} else if (contains(number_seperators, c)
&& cur.pos() >= 2
&& getFont(pit, cur.pos() - 2).number() == LyXFont::ON) {
&& getFont(par, cur.pos() - 2).number() == LyXFont::ON) {
setCharFont(pit, cur.pos() - 1, current_font);
}
}
@ -1243,40 +1245,41 @@ void LyXText::charInserted()
}
RowMetrics LyXText::computeRowMetrics(par_type pit, Row const & row) const
RowMetrics LyXText::computeRowMetrics(par_type const pit, Row const & row) const
{
RowMetrics result;
Paragraph const & par = pars_[pit];
double w = width_ - row.width();
bool const is_rtl = isRTL(pars_[pit]);
bool const is_rtl = isRTL(par);
if (is_rtl)
result.x = rightMargin(pars_[pit]);
result.x = rightMargin(par);
else
result.x = leftMargin(pit, row.pos());
// is there a manual margin with a manual label
LyXLayout_ptr const & layout = pars_[pit].layout();
LyXLayout_ptr const & layout = par.layout();
if (layout->margintype == MARGIN_MANUAL
&& layout->labeltype == LABEL_MANUAL) {
/// We might have real hfills in the label part
int nlh = numberOfLabelHfills(pars_[pit], row);
int nlh = numberOfLabelHfills(par, row);
// A manual label par (e.g. List) has an auto-hfill
// between the label text and the body of the
// paragraph too.
// But we don't want to do this auto hfill if the par
// is empty.
if (!pars_[pit].empty())
if (!par.empty())
++nlh;
if (nlh && !pars_[pit].getLabelWidthString().empty())
result.label_hfill = labelFill(pit, row) / double(nlh);
if (nlh && !par.getLabelWidthString().empty())
result.label_hfill = labelFill(par, row) / double(nlh);
}
// are there any hfills in the row?
int const nh = numberOfHfills(pars_[pit], row);
int const nh = numberOfHfills(par, row);
if (nh) {
if (w > 0)
@ -1288,28 +1291,28 @@ RowMetrics LyXText::computeRowMetrics(par_type pit, Row const & row) const
// is it block, flushleft or flushright?
// set x how you need it
int align;
if (pars_[pit].params().align() == LYX_ALIGN_LAYOUT)
if (par.params().align() == LYX_ALIGN_LAYOUT)
align = layout->align;
else
align = pars_[pit].params().align();
align = par.params().align();
// Display-style insets should always be on a centred row
// The test on pars_[pit].size() is to catch zero-size pars, which
// The test on par.size() is to catch zero-size pars, which
// would trigger the assert in Paragraph::getInset().
//inset = pars_[pit].size() ? pars_[pit].getInset(row.pos()) : 0;
if (!pars_[pit].empty()
&& pars_[pit].isInset(row.pos())
&& pars_[pit].getInset(row.pos())->display())
//inset = par.size() ? par.getInset(row.pos()) : 0;
if (!par.empty()
&& par.isInset(row.pos())
&& par.getInset(row.pos())->display())
{
align = LYX_ALIGN_CENTER;
}
switch (align) {
case LYX_ALIGN_BLOCK: {
int const ns = numberOfSeparators(pars_[pit], row);
int const ns = numberOfSeparators(par, row);
bool disp_inset = false;
if (row.endpos() < pars_[pit].size()) {
InsetBase const * in = pars_[pit].getInset(row.endpos());
if (row.endpos() < par.size()) {
InsetBase const * in = par.getInset(row.endpos());
if (in)
disp_inset = in->display();
}
@ -1317,8 +1320,8 @@ RowMetrics LyXText::computeRowMetrics(par_type pit, Row const & row) const
// par, does not end in newline, and is not row above a
// display inset... then stretch it
if (ns
&& row.endpos() < pars_[pit].size()
&& !pars_[pit].isNewline(row.endpos() - 1)
&& row.endpos() < par.size()
&& !par.isNewline(row.endpos() - 1)
&& !disp_inset
) {
result.separator = w / ns;
@ -1336,15 +1339,15 @@ RowMetrics LyXText::computeRowMetrics(par_type pit, Row const & row) const
}
}
bidi.computeTables(pars_[pit], *bv()->buffer(), row);
bidi.computeTables(par, *bv()->buffer(), row);
if (is_rtl) {
pos_type body_pos = pars_[pit].beginOfBody();
pos_type body_pos = par.beginOfBody();
pos_type end = row.endpos();
if (body_pos > 0
&& (body_pos > end || !pars_[pit].isLineSeparator(body_pos - 1)))
&& (body_pos > end || !par.isLineSeparator(body_pos - 1)))
{
result.x += font_metrics::width(layout->labelsep, getLabelFont(pit));
result.x += font_metrics::width(layout->labelsep, getLabelFont(par));
if (body_pos <= end)
result.x += result.label_hfill;
}
@ -1687,43 +1690,44 @@ Row const & LyXText::firstRow() const
}
void LyXText::redoParagraphInternal(par_type pit)
void LyXText::redoParagraphInternal(par_type const pit)
{
// remove rows of paragraph, keep track of height changes
height_ -= pars_[pit].height;
Paragraph & par = pars_[pit];
height_ -= par.height;
// clear old data
pars_[pit].rows.clear();
pars_[pit].height = 0;
pars_[pit].width = 0;
par.rows.clear();
par.height = 0;
par.width = 0;
// redo insets
InsetList::iterator ii = pars_[pit].insetlist.begin();
InsetList::iterator iend = pars_[pit].insetlist.end();
InsetList::iterator ii = par.insetlist.begin();
InsetList::iterator iend = par.insetlist.end();
for (; ii != iend; ++ii) {
Dimension dim;
int const w = maxwidth_ - leftMargin(pit) - rightMargin(pars_[pit]);
MetricsInfo mi(bv(), getFont(pit, ii->pos), w);
int const w = maxwidth_ - leftMargin(pit) - rightMargin(par);
MetricsInfo mi(bv(), getFont(par, ii->pos), w);
ii->inset->metrics(mi, dim);
}
// rebreak the paragraph
pars_[pit].setBeginOfBody();
par.setBeginOfBody();
pos_type z = 0;
do {
Row row(z);
rowBreakPoint(pit, row);
setRowWidth(pit, row);
setHeightOfRow(pit, row);
row.y_offset(pars_[pit].height);
pars_[pit].rows.push_back(row);
pars_[pit].width = std::max(pars_[pit].width, row.width());
pars_[pit].height += row.height();
row.y_offset(par.height);
par.rows.push_back(row);
par.width = std::max(par.width, row.width());
par.height += row.height();
z = row.endpos();
} while (z < pars_[pit].size());
} while (z < par.size());
height_ += pars_[pit].height;
//lyxerr << "redoParagraph: " << pars_[pit].rows.size() << " rows\n";
height_ += par.height;
//lyxerr << "redoParagraph: " << par.rows.size() << " rows\n";
}
@ -1919,11 +1923,12 @@ int LyXText::descent() const
int LyXText::cursorX(CursorSlice const & cur) const
{
par_type pit = cur.par();
if (pars_[pit].rows.empty())
par_type const pit = cur.par();
Paragraph const & par = pars_[pit];
if (par.rows.empty())
return xo_;
Row const & row = *pars_[pit].getRow(cur.pos());
Row const & row = *par.getRow(cur.pos());
pos_type pos = cur.pos();
pos_type cursor_vpos = 0;
@ -1937,7 +1942,7 @@ int LyXText::cursorX(CursorSlice const & cur) const
if (end <= row_pos)
cursor_vpos = row_pos;
else if (pos >= end)
cursor_vpos = isRTL(pars_[pit]) ? row_pos : end;
cursor_vpos = isRTL(par) ? row_pos : end;
else if (pos > row_pos && pos >= end)
// Place cursor after char at (logical) position pos - 1
cursor_vpos = (bidi.level(pos - 1) % 2 == 0)
@ -1947,33 +1952,33 @@ int LyXText::cursorX(CursorSlice const & cur) const
cursor_vpos = (bidi.level(pos) % 2 == 0)
? bidi.log2vis(pos) : bidi.log2vis(pos) + 1;
pos_type body_pos = pars_[pit].beginOfBody();
pos_type body_pos = par.beginOfBody();
if (body_pos > 0 &&
(body_pos > end || !pars_[pit].isLineSeparator(body_pos - 1)))
(body_pos > end || !par.isLineSeparator(body_pos - 1)))
body_pos = 0;
for (pos_type vpos = row_pos; vpos < cursor_vpos; ++vpos) {
pos_type pos = bidi.vis2log(vpos);
if (body_pos > 0 && pos == body_pos - 1) {
x += m.label_hfill
+ font_metrics::width(pars_[pit].layout()->labelsep,
getLabelFont(pit));
if (pars_[pit].isLineSeparator(body_pos - 1))
x -= singleWidth(pit, body_pos - 1);
+ font_metrics::width(par.layout()->labelsep,
getLabelFont(par));
if (par.isLineSeparator(body_pos - 1))
x -= singleWidth(par, body_pos - 1);
}
if (hfillExpansion(pars_[pit], row, pos)) {
x += singleWidth(pit, pos);
if (hfillExpansion(par, row, pos)) {
x += singleWidth(par, pos);
if (pos >= body_pos)
x += m.hfill;
else
x += m.label_hfill;
} else if (pars_[pit].isSeparator(pos)) {
x += singleWidth(pit, pos);
} else if (par.isSeparator(pos)) {
x += singleWidth(par, pos);
if (pos >= body_pos)
x += m.separator;
} else
x += singleWidth(pit, pos);
x += singleWidth(par, pos);
}
return xo_ + int(x);
}

81
src/text2.C
View File

@ -90,7 +90,7 @@ void LyXText::init(BufferView * bv)
for (par_type pit = 0; pit != end; ++pit)
pars_[pit].rows.clear();
current_font = getFont(0, 0);
current_font = getFont(pars_[0], 0);
redoParagraphs(0, end);
updateCounters();
}
@ -149,11 +149,10 @@ InsetBase * LyXText::checkInsetHit(int x, int y) const
// The difference is that this one is used for displaying, and thus we
// are allowed to make cosmetic improvements. For instance make footnotes
// smaller. (Asger)
LyXFont LyXText::getFont(par_type const pit, pos_type const pos) const
LyXFont LyXText::getFont(Paragraph const & par, pos_type const pos) const
{
BOOST_ASSERT(pos >= 0);
Paragraph const & par = pars_[pit];
LyXLayout_ptr const & layout = par.layout();
#ifdef WITH_WARNINGS
#warning broken?
@ -186,7 +185,6 @@ LyXFont LyXText::getFont(par_type const pit, pos_type const pos) const
font.realize(font_);
// Realize with the fonts of lesser depth.
//font.realize(outerFont(pit, paragraphs()));
font.realize(defaultfont_);
return font;
@ -209,16 +207,15 @@ LyXFont LyXText::getLayoutFont(par_type const pit) const
}
LyXFont LyXText::getLabelFont(par_type pit) const
LyXFont LyXText::getLabelFont(Paragraph const & par) const
{
LyXLayout_ptr const & layout = pars_[pit].layout();
LyXLayout_ptr const & layout = par.layout();
if (!pars_[pit].getDepth())
if (!par.getDepth())
return layout->reslabelfont;
LyXFont font = layout->labelfont;
// Realize with the fonts of lesser depth.
font.realize(outerFont(pit, paragraphs()));
font.realize(defaultfont_);
return font;
@ -436,7 +433,7 @@ void LyXText::setFont(LCursor & cur, LyXFont const & font, bool toggleall)
LyXFont layoutfont;
par_type pit = cur.par();
if (cur.pos() < pars_[pit].beginOfBody())
layoutfont = getLabelFont(pit);
layoutfont = getLabelFont(pars_[pit]);
else
layoutfont = getLayoutFont(pit);
@ -460,21 +457,18 @@ void LyXText::setFont(LCursor & cur, LyXFont const & font, bool toggleall)
par_type const beg = cur.selBegin().par();
par_type const end = cur.selEnd().par();
DocIterator pos = cur.selectionBegin();
DocIterator posend = cur.selectionEnd();
lyxerr[Debug::DEBUG] << "pos: " << pos << " posend: " << posend
<< endl;
DocIterator dit = cur.selectionBegin();
DocIterator ditend = cur.selectionEnd();
BufferParams const & params = cur.buffer().params();
// Don't use forwardChar here as posend might have
// Don't use forwardChar here as ditend might have
// pos() == lastpos() and forwardChar would miss it.
for (; pos != posend; pos.forwardPos()) {
if (pos.pos() != pos.lastpos()) {
LyXFont f = getFont(pos.par(), pos.pos());
for (; dit != ditend; dit.forwardPos()) {
if (dit.pos() != dit.lastpos()) {
LyXFont f = getFont(dit.paragraph(), dit.pos());
f.update(font, params.language, toggleall);
setCharFont(pos.par(), pos.pos(), f);
setCharFont(dit.par(), dit.pos(), f);
}
}
@ -1028,7 +1022,7 @@ void LyXText::setCurrentFont(LCursor & cur)
{
BOOST_ASSERT(this == cur.text());
pos_type pos = cur.pos();
par_type pit = cur.par();
Paragraph & par = cur.paragraph();
if (cur.boundary() && pos > 0)
--pos;
@ -1037,7 +1031,7 @@ void LyXText::setCurrentFont(LCursor & cur)
if (pos == cur.lastpos())
--pos;
else // potentional bug... BUG (Lgb)
if (pars_[pit].isSeparator(pos)) {
if (par.isSeparator(pos)) {
if (pos > cur.textRow().pos() &&
bidi.level(pos) % 2 ==
bidi.level(pos - 1) % 2)
@ -1048,13 +1042,13 @@ void LyXText::setCurrentFont(LCursor & cur)
}
BufferParams const & bufparams = cur.buffer().params();
current_font = pars_[pit].getFontSettings(bufparams, pos);
real_current_font = getFont(pit, pos);
current_font = par.getFontSettings(bufparams, pos);
real_current_font = getFont(par, pos);
if (cur.pos() == cur.lastpos()
&& bidi.isBoundary(cur.buffer(), pars_[pit], cur.pos())
&& bidi.isBoundary(cur.buffer(), par, cur.pos())
&& !cur.boundary()) {
Language const * lang = pars_[pit].getParLanguage(bufparams);
Language const * lang = par.getParLanguage(bufparams);
current_font.setLanguage(lang);
current_font.setNumber(LyXFont::OFF);
real_current_font.setLanguage(lang);
@ -1066,26 +1060,27 @@ void LyXText::setCurrentFont(LCursor & cur)
// x is an absolute screen coord
// returns the column near the specified x-coordinate of the row
// x is set to the real beginning of this column
pos_type LyXText::getColumnNearX(par_type pit,
pos_type LyXText::getColumnNearX(par_type const pit,
Row const & row, int & x, bool & boundary) const
{
x -= xo_;
RowMetrics const r = computeRowMetrics(pit, row);
Paragraph const & par = pars_[pit];
pos_type vc = row.pos();
pos_type end = row.endpos();
pos_type c = 0;
LyXLayout_ptr const & layout = pars_[pit].layout();
LyXLayout_ptr const & layout = par.layout();
bool left_side = false;
pos_type body_pos = pars_[pit].beginOfBody();
pos_type body_pos = par.beginOfBody();
double tmpx = r.x;
double last_tmpx = tmpx;
if (body_pos > 0 &&
(body_pos > end || !pars_[pit].isLineSeparator(body_pos - 1)))
(body_pos > end || !par.isLineSeparator(body_pos - 1)))
body_pos = 0;
// check for empty row
@ -1099,23 +1094,23 @@ pos_type LyXText::getColumnNearX(par_type pit,
last_tmpx = tmpx;
if (body_pos > 0 && c == body_pos - 1) {
tmpx += r.label_hfill +
font_metrics::width(layout->labelsep, getLabelFont(pit));
if (pars_[pit].isLineSeparator(body_pos - 1))
tmpx -= singleWidth(pit, body_pos - 1);
font_metrics::width(layout->labelsep, getLabelFont(par));
if (par.isLineSeparator(body_pos - 1))
tmpx -= singleWidth(par, body_pos - 1);
}
if (hfillExpansion(pars_[pit], row, c)) {
tmpx += singleWidth(pit, c);
if (hfillExpansion(par, row, c)) {
tmpx += singleWidth(par, c);
if (c >= body_pos)
tmpx += r.hfill;
else
tmpx += r.label_hfill;
} else if (pars_[pit].isSeparator(c)) {
tmpx += singleWidth(pit, c);
} else if (par.isSeparator(c)) {
tmpx += singleWidth(par, c);
if (c >= body_pos)
tmpx += r.separator;
} else {
tmpx += singleWidth(pit, c);
tmpx += singleWidth(par, c);
}
++vc;
}
@ -1130,11 +1125,11 @@ pos_type LyXText::getColumnNearX(par_type pit,
boundary = false;
// This (rtl_support test) is not needed, but gives
// some speedup if rtl_support == false
bool const lastrow = lyxrc.rtl_support && row.endpos() == pars_[pit].size();
bool const lastrow = lyxrc.rtl_support && row.endpos() == par.size();
// If lastrow is false, we don't need to compute
// the value of rtl.
bool const rtl = lastrow ? isRTL(pars_[pit]) : false;
bool const rtl = lastrow ? isRTL(par) : false;
if (lastrow &&
((rtl && left_side && vc == row.pos() && x < tmpx - 5) ||
(!rtl && !left_side && vc == end && x > tmpx + 5)))
@ -1148,15 +1143,15 @@ pos_type LyXText::getColumnNearX(par_type pit,
bool const rtl = (bidi.level(c) % 2 == 1);
if (left_side == rtl) {
++c;
boundary = bidi.isBoundary(*bv()->buffer(), pars_[pit], c);
boundary = bidi.isBoundary(*bv()->buffer(), par, c);
}
}
if (row.pos() < end && c >= end && pars_[pit].isNewline(end - 1)) {
if (row.pos() < end && c >= end && par.isNewline(end - 1)) {
if (bidi.level(end -1) % 2 == 0)
tmpx -= singleWidth(pit, end - 1);
tmpx -= singleWidth(par, end - 1);
else
tmpx += singleWidth(pit, end - 1);
tmpx += singleWidth(par, end - 1);
c = end - 1;
}