2003-02-14 00:41:44 +00:00
|
|
|
/**
|
2007-04-26 04:41:58 +00:00
|
|
|
* \file Row.cpp
|
2003-02-14 00:41:44 +00:00
|
|
|
* This file is part of LyX, the document processor.
|
|
|
|
* Licence details can be found in the file COPYING.
|
2002-03-21 17:27:08 +00:00
|
|
|
*
|
2008-11-14 15:58:50 +00:00
|
|
|
* \author Lars Gullik Bjønnes
|
2003-08-23 00:17:00 +00:00
|
|
|
* \author John Levon
|
2008-11-14 15:58:50 +00:00
|
|
|
* \author André Pönitz
|
|
|
|
* \author Jürgen Vigna
|
2013-07-17 22:25:08 +00:00
|
|
|
* \author Jean-Marc Lasgouttes
|
2002-03-21 17:27:08 +00:00
|
|
|
*
|
2003-08-23 00:17:00 +00:00
|
|
|
* Full author contact details are available in file CREDITS.
|
2000-06-08 23:16:16 +00:00
|
|
|
*
|
2003-02-14 00:41:44 +00:00
|
|
|
* Metrics for an on-screen text row.
|
|
|
|
*/
|
2000-06-08 23:16:16 +00:00
|
|
|
|
2000-06-15 15:54:05 +00:00
|
|
|
#include <config.h>
|
|
|
|
|
2007-04-26 04:41:58 +00:00
|
|
|
#include "Row.h"
|
2008-02-18 07:14:42 +00:00
|
|
|
|
Patch by Vincent that solves a number of problems related to the painting of a selection:
1. When a listing is inserted in a bit of text, the line above the listing is not drawn over the full width like it is done for lines above other insets. This is because InsetListing has a AlignLeft alignment. Now, if you start selecting downwards with the mouse in this empty area, strange selection drawings appear (see attachment).
This is caused by the fact that starting your selection at such a place, causes beg.boundary() to be true in TextMetrics::drawRowSelection(..). This is correct, but this value is true for _all_ selected lines. Now, the selection acts as if it is RTL text. Therefore, just like for end.boundary, this value needs to be reset for every line.
2. Starting your selection in an end margin often causes the selection in this end margin to be painted later. This is because when starting your selection in an end margin, you may have set a (possible empty) selection before really selecting the end margin. The problem is that the checksum (computed later) is the same for this empty selection and for the end margin selection. Therfore, we need a call to cur.setSelection() before evaluating cur.selection().
3. In the following two lines, it is assumed that there is only an end margin to be painted if the selection extends to the next paragraph. This is not true for the above described case of an AlignLeft Inset. Then, the margin has also be drawn within a paragraph
4. The end and begin margins are only painted when the selection extends into the following or previous paragraph. This difference is not resembled in the checksum if you first select a row completely and then procede to the next or previous paragraph as the selection remains at the end of a row. This also holds for the AlignLeft case. Therefore I added a term to the checksum to monitor whether the end and begin margins need to be drawn.
git-svn-id: svn://svn.lyx.org/lyx/lyx-devel/trunk@26399 a592a061-630c-0410-9148-cb99ea01b6c8
2008-09-14 14:32:40 +00:00
|
|
|
#include "DocIterator.h"
|
2019-05-14 20:44:29 +00:00
|
|
|
#include "Language.h"
|
Patch by Vincent that solves a number of problems related to the painting of a selection:
1. When a listing is inserted in a bit of text, the line above the listing is not drawn over the full width like it is done for lines above other insets. This is because InsetListing has a AlignLeft alignment. Now, if you start selecting downwards with the mouse in this empty area, strange selection drawings appear (see attachment).
This is caused by the fact that starting your selection at such a place, causes beg.boundary() to be true in TextMetrics::drawRowSelection(..). This is correct, but this value is true for _all_ selected lines. Now, the selection acts as if it is RTL text. Therefore, just like for end.boundary, this value needs to be reset for every line.
2. Starting your selection in an end margin often causes the selection in this end margin to be painted later. This is because when starting your selection in an end margin, you may have set a (possible empty) selection before really selecting the end margin. The problem is that the checksum (computed later) is the same for this empty selection and for the end margin selection. Therfore, we need a call to cur.setSelection() before evaluating cur.selection().
3. In the following two lines, it is assumed that there is only an end margin to be painted if the selection extends to the next paragraph. This is not true for the above described case of an AlignLeft Inset. Then, the margin has also be drawn within a paragraph
4. The end and begin margins are only painted when the selection extends into the following or previous paragraph. This difference is not resembled in the checksum if you first select a row completely and then procede to the next or previous paragraph as the selection remains at the end of a row. This also holds for the AlignLeft case. Therefore I added a term to the checksum to monitor whether the end and begin margins need to be drawn.
git-svn-id: svn://svn.lyx.org/lyx/lyx-devel/trunk@26399 a592a061-630c-0410-9148-cb99ea01b6c8
2008-09-14 14:32:40 +00:00
|
|
|
|
2013-06-25 12:57:09 +00:00
|
|
|
#include "frontends/FontMetrics.h"
|
|
|
|
|
2007-11-29 07:04:28 +00:00
|
|
|
#include "support/debug.h"
|
2013-07-17 22:25:08 +00:00
|
|
|
#include "support/lassert.h"
|
2015-07-18 23:22:10 +00:00
|
|
|
#include "support/lstrings.h"
|
2020-11-26 20:10:45 +00:00
|
|
|
#include "support/lyxlib.h"
|
2022-07-11 21:56:35 +00:00
|
|
|
#include "support/textutils.h"
|
2000-06-08 23:16:16 +00:00
|
|
|
|
2020-10-20 08:36:59 +00:00
|
|
|
#include <algorithm>
|
2013-06-25 12:57:09 +00:00
|
|
|
#include <ostream>
|
|
|
|
|
|
|
|
using namespace std;
|
2006-10-21 00:16:43 +00:00
|
|
|
|
|
|
|
namespace lyx {
|
2003-02-14 00:41:44 +00:00
|
|
|
|
2013-07-17 22:25:08 +00:00
|
|
|
using frontend::FontMetrics;
|
|
|
|
|
2015-07-18 23:22:10 +00:00
|
|
|
|
2016-08-13 18:03:02 +00:00
|
|
|
// Maximum length that a space can be stretched when justifying text
|
|
|
|
static double const MAX_SPACE_STRETCH = 1.5; //em
|
|
|
|
|
|
|
|
|
|
|
|
int Row::Element::countExpanders() const
|
|
|
|
{
|
|
|
|
if (type != STRING)
|
|
|
|
return 0;
|
2022-04-08 09:51:53 +00:00
|
|
|
return support::countExpanders(str);
|
2016-08-13 18:03:02 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
int Row::Element::expansionAmount() const
|
|
|
|
{
|
|
|
|
if (type != STRING)
|
|
|
|
return 0;
|
|
|
|
return countExpanders() * theFontMetrics(font).em();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void Row::Element::setExtra(double extra_per_em)
|
|
|
|
{
|
|
|
|
if (type != STRING)
|
|
|
|
return;
|
|
|
|
extra = extra_per_em * theFontMetrics(font).em();
|
2015-07-18 23:22:10 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-07-17 22:25:08 +00:00
|
|
|
double Row::Element::pos2x(pos_type const i) const
|
|
|
|
{
|
2014-05-14 15:46:43 +00:00
|
|
|
// This can happen with inline completion when clicking on the
|
|
|
|
// row after the completion.
|
|
|
|
if (i < pos || i > endpos)
|
|
|
|
return 0;
|
2013-10-18 15:55:30 +00:00
|
|
|
|
2014-07-28 07:46:13 +00:00
|
|
|
double w = 0;
|
2013-10-18 15:55:30 +00:00
|
|
|
//handle first the two bounds of the element
|
2016-04-21 21:44:14 +00:00
|
|
|
if (i == endpos && type != VIRTUAL)
|
2015-09-18 14:42:24 +00:00
|
|
|
w = isRTL() ? 0 : full_width();
|
2014-07-28 20:03:57 +00:00
|
|
|
else if (i == pos || type != STRING)
|
2015-09-18 14:42:24 +00:00
|
|
|
w = isRTL() ? full_width() : 0;
|
2013-10-18 15:55:30 +00:00
|
|
|
else {
|
|
|
|
FontMetrics const & fm = theFontMetrics(font);
|
2015-09-18 14:42:24 +00:00
|
|
|
w = fm.pos2x(str, i - pos, isRTL(), extra);
|
2013-10-18 15:55:30 +00:00
|
|
|
}
|
2013-07-17 22:25:08 +00:00
|
|
|
|
2014-05-14 15:46:43 +00:00
|
|
|
return w;
|
2013-07-17 22:25:08 +00:00
|
|
|
}
|
|
|
|
|
2000-06-08 23:16:16 +00:00
|
|
|
|
2017-04-01 11:09:23 +00:00
|
|
|
pos_type Row::Element::x2pos(int &x) const
|
2013-07-21 18:22:32 +00:00
|
|
|
{
|
|
|
|
//lyxerr << "x2pos: x=" << x << " w=" << width() << " " << *this;
|
2014-03-19 13:44:53 +00:00
|
|
|
size_t i = 0;
|
2014-05-14 15:46:43 +00:00
|
|
|
|
2014-03-21 10:56:42 +00:00
|
|
|
switch (type) {
|
|
|
|
case STRING: {
|
|
|
|
FontMetrics const & fm = theFontMetrics(font);
|
2015-09-18 14:42:24 +00:00
|
|
|
i = fm.x2pos(str, x, isRTL(), extra);
|
2014-03-21 10:56:42 +00:00
|
|
|
break;
|
|
|
|
}
|
2014-05-14 15:46:43 +00:00
|
|
|
case VIRTUAL:
|
|
|
|
// those elements are actually empty (but they have a width)
|
|
|
|
i = 0;
|
2015-09-18 14:42:24 +00:00
|
|
|
x = isRTL() ? int(full_width()) : 0;
|
2014-05-14 15:46:43 +00:00
|
|
|
break;
|
2014-03-21 10:56:42 +00:00
|
|
|
case INSET:
|
2017-04-01 11:09:23 +00:00
|
|
|
case SPACE:
|
2022-01-17 10:58:49 +00:00
|
|
|
case MARGINSPACE:
|
2014-05-14 15:46:43 +00:00
|
|
|
// those elements contain only one position. Round to
|
|
|
|
// the closest side.
|
2017-04-10 09:21:29 +00:00
|
|
|
if (x > (full_width() + 1) / 2) {
|
2014-12-22 09:36:53 +00:00
|
|
|
x = int(full_width());
|
2015-09-18 14:42:24 +00:00
|
|
|
i = !isRTL();
|
2014-05-14 15:46:43 +00:00
|
|
|
} else {
|
|
|
|
x = 0;
|
2015-09-18 14:42:24 +00:00
|
|
|
i = isRTL();
|
2014-05-14 15:46:43 +00:00
|
|
|
}
|
|
|
|
}
|
2013-12-20 13:02:31 +00:00
|
|
|
//lyxerr << "=> p=" << pos + i << " x=" << x << endl;
|
2013-07-21 18:22:32 +00:00
|
|
|
return pos + i;
|
2013-07-21 18:22:32 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2021-09-06 12:52:42 +00:00
|
|
|
bool Row::Element::splitAt(int const width, int next_width, bool force,
|
|
|
|
Row::Elements & tail)
|
2014-05-19 09:35:15 +00:00
|
|
|
{
|
2021-09-06 12:52:42 +00:00
|
|
|
// Not a string or already OK.
|
|
|
|
if (type != STRING || (dim.wid > 0 && dim.wid < width))
|
|
|
|
return false;
|
2014-05-19 09:35:15 +00:00
|
|
|
|
2015-07-18 23:22:10 +00:00
|
|
|
FontMetrics const & fm = theFontMetrics(font);
|
2021-09-06 12:52:42 +00:00
|
|
|
|
|
|
|
// A a string that is not breakable
|
|
|
|
if (!(row_flags & CanBreakInside)) {
|
|
|
|
// has width been computed yet?
|
|
|
|
if (dim.wid == 0)
|
|
|
|
dim.wid = fm.width(str);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool const wrap_any = !font.language()->wordWrap();
|
|
|
|
FontMetrics::Breaks breaks = fm.breakString(str, width, next_width,
|
|
|
|
isRTL(), wrap_any | force);
|
|
|
|
|
|
|
|
// if breaking did not really work, give up
|
2022-09-23 16:31:10 +00:00
|
|
|
if (!force && breaks.front().nspc_wid > width) {
|
2021-09-06 12:52:42 +00:00
|
|
|
if (dim.wid == 0)
|
|
|
|
dim.wid = fm.width(str);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
Element first_e(STRING, pos, font, change);
|
|
|
|
// should next element eventually replace *this?
|
|
|
|
bool first = true;
|
|
|
|
docstring::size_type i = 0;
|
|
|
|
for (FontMetrics::Break const & brk : breaks) {
|
2021-12-09 15:43:16 +00:00
|
|
|
/* For some reason breakString can decide to break before the
|
|
|
|
* first character (normally we use a 0-width nbsp to prevent
|
|
|
|
* that). Skip leading empty elements, they are never wanted.
|
|
|
|
*/
|
|
|
|
if (first && brk.len == 0 && breaks.size() > 1)
|
|
|
|
continue;
|
2021-09-06 12:52:42 +00:00
|
|
|
Element e(STRING, pos + i, font, change);
|
|
|
|
e.str = str.substr(i, brk.len);
|
|
|
|
e.endpos = e.pos + brk.len;
|
|
|
|
e.dim.wid = brk.wid;
|
2021-12-28 19:56:57 +00:00
|
|
|
e.nspc_wid = brk.nspc_wid;
|
2021-09-06 12:52:42 +00:00
|
|
|
e.row_flags = CanBreakInside | BreakAfter;
|
|
|
|
if (first) {
|
|
|
|
// this element eventually goes to *this
|
|
|
|
e.row_flags |= row_flags & ~AfterFlags;
|
|
|
|
first_e = e;
|
|
|
|
first = false;
|
|
|
|
} else
|
|
|
|
tail.push_back(e);
|
|
|
|
i += brk.len;
|
2015-07-18 23:22:10 +00:00
|
|
|
}
|
2016-01-18 14:32:07 +00:00
|
|
|
|
2021-09-06 12:52:42 +00:00
|
|
|
if (!tail.empty()) {
|
|
|
|
// Avoid having a last empty element. This happens when
|
|
|
|
// breaking at the trailing space of string
|
|
|
|
if (tail.back().str.empty())
|
|
|
|
tail.pop_back();
|
|
|
|
else {
|
|
|
|
// Copy the after flags of the original element to the last one.
|
|
|
|
tail.back().row_flags &= ~BreakAfter;
|
|
|
|
tail.back().row_flags |= row_flags & AfterFlags;
|
|
|
|
}
|
|
|
|
// first_e row should be broken after the original element
|
|
|
|
first_e.row_flags |= BreakAfter;
|
|
|
|
} else {
|
|
|
|
// Restore the after flags of the original element.
|
|
|
|
first_e.row_flags &= ~BreakAfter;
|
|
|
|
first_e.row_flags |= row_flags & AfterFlags;
|
|
|
|
}
|
|
|
|
|
|
|
|
// update ourselves
|
|
|
|
swap(first_e, *this);
|
|
|
|
return true;
|
2014-05-19 09:35:15 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2021-08-31 17:23:55 +00:00
|
|
|
void Row::Element::rtrim()
|
|
|
|
{
|
2022-07-11 21:56:35 +00:00
|
|
|
if (type != STRING || str.empty() || !isSpace(str.back()))
|
2021-08-31 17:23:55 +00:00
|
|
|
return;
|
|
|
|
/* This is intended for strings that have been created by splitAt.
|
2022-07-11 21:56:35 +00:00
|
|
|
* If There is a trailing space, we remove it and decrease endpos,
|
|
|
|
* since spaces at row break are invisible.
|
2021-08-31 17:23:55 +00:00
|
|
|
*/
|
2022-07-11 21:56:35 +00:00
|
|
|
str.pop_back();
|
2021-08-31 17:23:55 +00:00
|
|
|
endpos = pos + str.length();
|
2021-12-28 19:56:57 +00:00
|
|
|
dim.wid = nspc_wid;
|
2021-08-31 17:23:55 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2017-12-14 15:00:00 +00:00
|
|
|
bool Row::isMarginSelected(bool left, DocIterator const & beg,
|
2008-09-14 22:09:10 +00:00
|
|
|
DocIterator const & end) const
|
Patch by Vincent that solves a number of problems related to the painting of a selection:
1. When a listing is inserted in a bit of text, the line above the listing is not drawn over the full width like it is done for lines above other insets. This is because InsetListing has a AlignLeft alignment. Now, if you start selecting downwards with the mouse in this empty area, strange selection drawings appear (see attachment).
This is caused by the fact that starting your selection at such a place, causes beg.boundary() to be true in TextMetrics::drawRowSelection(..). This is correct, but this value is true for _all_ selected lines. Now, the selection acts as if it is RTL text. Therefore, just like for end.boundary, this value needs to be reset for every line.
2. Starting your selection in an end margin often causes the selection in this end margin to be painted later. This is because when starting your selection in an end margin, you may have set a (possible empty) selection before really selecting the end margin. The problem is that the checksum (computed later) is the same for this empty selection and for the end margin selection. Therfore, we need a call to cur.setSelection() before evaluating cur.selection().
3. In the following two lines, it is assumed that there is only an end margin to be painted if the selection extends to the next paragraph. This is not true for the above described case of an AlignLeft Inset. Then, the margin has also be drawn within a paragraph
4. The end and begin margins are only painted when the selection extends into the following or previous paragraph. This difference is not resembled in the checksum if you first select a row completely and then procede to the next or previous paragraph as the selection remains at the end of a row. This also holds for the AlignLeft case. Therefore I added a term to the checksum to monitor whether the end and begin margins need to be drawn.
git-svn-id: svn://svn.lyx.org/lyx/lyx-devel/trunk@26399 a592a061-630c-0410-9148-cb99ea01b6c8
2008-09-14 14:32:40 +00:00
|
|
|
{
|
2017-12-14 15:00:00 +00:00
|
|
|
pos_type const sel_pos = left ? sel_beg : sel_end;
|
|
|
|
pos_type const margin_pos = left ? pos_ : end_;
|
Patch by Vincent that solves a number of problems related to the painting of a selection:
1. When a listing is inserted in a bit of text, the line above the listing is not drawn over the full width like it is done for lines above other insets. This is because InsetListing has a AlignLeft alignment. Now, if you start selecting downwards with the mouse in this empty area, strange selection drawings appear (see attachment).
This is caused by the fact that starting your selection at such a place, causes beg.boundary() to be true in TextMetrics::drawRowSelection(..). This is correct, but this value is true for _all_ selected lines. Now, the selection acts as if it is RTL text. Therefore, just like for end.boundary, this value needs to be reset for every line.
2. Starting your selection in an end margin often causes the selection in this end margin to be painted later. This is because when starting your selection in an end margin, you may have set a (possible empty) selection before really selecting the end margin. The problem is that the checksum (computed later) is the same for this empty selection and for the end margin selection. Therfore, we need a call to cur.setSelection() before evaluating cur.selection().
3. In the following two lines, it is assumed that there is only an end margin to be painted if the selection extends to the next paragraph. This is not true for the above described case of an AlignLeft Inset. Then, the margin has also be drawn within a paragraph
4. The end and begin margins are only painted when the selection extends into the following or previous paragraph. This difference is not resembled in the checksum if you first select a row completely and then procede to the next or previous paragraph as the selection remains at the end of a row. This also holds for the AlignLeft case. Therefore I added a term to the checksum to monitor whether the end and begin margins need to be drawn.
git-svn-id: svn://svn.lyx.org/lyx/lyx-devel/trunk@26399 a592a061-630c-0410-9148-cb99ea01b6c8
2008-09-14 14:32:40 +00:00
|
|
|
|
2018-01-15 15:14:21 +00:00
|
|
|
// Is there a selection and is the chosen margin selected ?
|
|
|
|
if (!selection() || sel_pos != margin_pos)
|
|
|
|
return false;
|
|
|
|
else if (beg.pos() == end.pos())
|
|
|
|
// This is a special case in which the space between after
|
|
|
|
// pos i-1 and before pos i is selected, i.e. the margins
|
|
|
|
// (see DocIterator::boundary_).
|
|
|
|
return beg.boundary() && !end.boundary();
|
|
|
|
else if (end.pos() == margin_pos)
|
|
|
|
// If the selection ends around the margin, it is only
|
|
|
|
// drawn if the cursor is after the margin.
|
|
|
|
return !end.boundary();
|
|
|
|
else if (beg.pos() == margin_pos)
|
|
|
|
// If the selection begins around the margin, it is
|
|
|
|
// only drawn if the cursor is before the margin.
|
|
|
|
return beg.boundary();
|
|
|
|
else
|
|
|
|
return true;
|
Patch by Vincent that solves a number of problems related to the painting of a selection:
1. When a listing is inserted in a bit of text, the line above the listing is not drawn over the full width like it is done for lines above other insets. This is because InsetListing has a AlignLeft alignment. Now, if you start selecting downwards with the mouse in this empty area, strange selection drawings appear (see attachment).
This is caused by the fact that starting your selection at such a place, causes beg.boundary() to be true in TextMetrics::drawRowSelection(..). This is correct, but this value is true for _all_ selected lines. Now, the selection acts as if it is RTL text. Therefore, just like for end.boundary, this value needs to be reset for every line.
2. Starting your selection in an end margin often causes the selection in this end margin to be painted later. This is because when starting your selection in an end margin, you may have set a (possible empty) selection before really selecting the end margin. The problem is that the checksum (computed later) is the same for this empty selection and for the end margin selection. Therfore, we need a call to cur.setSelection() before evaluating cur.selection().
3. In the following two lines, it is assumed that there is only an end margin to be painted if the selection extends to the next paragraph. This is not true for the above described case of an AlignLeft Inset. Then, the margin has also be drawn within a paragraph
4. The end and begin margins are only painted when the selection extends into the following or previous paragraph. This difference is not resembled in the checksum if you first select a row completely and then procede to the next or previous paragraph as the selection remains at the end of a row. This also holds for the AlignLeft case. Therefore I added a term to the checksum to monitor whether the end and begin margins need to be drawn.
git-svn-id: svn://svn.lyx.org/lyx/lyx-devel/trunk@26399 a592a061-630c-0410-9148-cb99ea01b6c8
2008-09-14 14:32:40 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-06-25 12:57:09 +00:00
|
|
|
void Row::setSelectionAndMargins(DocIterator const & beg,
|
2008-09-14 22:09:10 +00:00
|
|
|
DocIterator const & end) const
|
Patch by Vincent that solves a number of problems related to the painting of a selection:
1. When a listing is inserted in a bit of text, the line above the listing is not drawn over the full width like it is done for lines above other insets. This is because InsetListing has a AlignLeft alignment. Now, if you start selecting downwards with the mouse in this empty area, strange selection drawings appear (see attachment).
This is caused by the fact that starting your selection at such a place, causes beg.boundary() to be true in TextMetrics::drawRowSelection(..). This is correct, but this value is true for _all_ selected lines. Now, the selection acts as if it is RTL text. Therefore, just like for end.boundary, this value needs to be reset for every line.
2. Starting your selection in an end margin often causes the selection in this end margin to be painted later. This is because when starting your selection in an end margin, you may have set a (possible empty) selection before really selecting the end margin. The problem is that the checksum (computed later) is the same for this empty selection and for the end margin selection. Therfore, we need a call to cur.setSelection() before evaluating cur.selection().
3. In the following two lines, it is assumed that there is only an end margin to be painted if the selection extends to the next paragraph. This is not true for the above described case of an AlignLeft Inset. Then, the margin has also be drawn within a paragraph
4. The end and begin margins are only painted when the selection extends into the following or previous paragraph. This difference is not resembled in the checksum if you first select a row completely and then procede to the next or previous paragraph as the selection remains at the end of a row. This also holds for the AlignLeft case. Therefore I added a term to the checksum to monitor whether the end and begin margins need to be drawn.
git-svn-id: svn://svn.lyx.org/lyx/lyx-devel/trunk@26399 a592a061-630c-0410-9148-cb99ea01b6c8
2008-09-14 14:32:40 +00:00
|
|
|
{
|
|
|
|
setSelection(beg.pos(), end.pos());
|
2013-06-25 12:57:09 +00:00
|
|
|
|
2018-01-15 15:14:21 +00:00
|
|
|
change(end_margin_sel, isMarginSelected(false, beg, end));
|
|
|
|
change(begin_margin_sel, isMarginSelected(true, beg, end));
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void Row::clearSelectionAndMargins() const
|
|
|
|
{
|
|
|
|
change(sel_beg, -1);
|
|
|
|
change(sel_end, -1);
|
|
|
|
change(end_margin_sel, false);
|
|
|
|
change(begin_margin_sel, false);
|
Patch by Vincent that solves a number of problems related to the painting of a selection:
1. When a listing is inserted in a bit of text, the line above the listing is not drawn over the full width like it is done for lines above other insets. This is because InsetListing has a AlignLeft alignment. Now, if you start selecting downwards with the mouse in this empty area, strange selection drawings appear (see attachment).
This is caused by the fact that starting your selection at such a place, causes beg.boundary() to be true in TextMetrics::drawRowSelection(..). This is correct, but this value is true for _all_ selected lines. Now, the selection acts as if it is RTL text. Therefore, just like for end.boundary, this value needs to be reset for every line.
2. Starting your selection in an end margin often causes the selection in this end margin to be painted later. This is because when starting your selection in an end margin, you may have set a (possible empty) selection before really selecting the end margin. The problem is that the checksum (computed later) is the same for this empty selection and for the end margin selection. Therfore, we need a call to cur.setSelection() before evaluating cur.selection().
3. In the following two lines, it is assumed that there is only an end margin to be painted if the selection extends to the next paragraph. This is not true for the above described case of an AlignLeft Inset. Then, the margin has also be drawn within a paragraph
4. The end and begin margins are only painted when the selection extends into the following or previous paragraph. This difference is not resembled in the checksum if you first select a row completely and then procede to the next or previous paragraph as the selection remains at the end of a row. This also holds for the AlignLeft case. Therefore I added a term to the checksum to monitor whether the end and begin margins need to be drawn.
git-svn-id: svn://svn.lyx.org/lyx/lyx-devel/trunk@26399 a592a061-630c-0410-9148-cb99ea01b6c8
2008-09-14 14:32:40 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-03-03 11:03:47 +00:00
|
|
|
void Row::setSelection(pos_type beg, pos_type end) const
|
2007-09-05 13:04:05 +00:00
|
|
|
{
|
|
|
|
if (pos_ >= beg && pos_ <= end)
|
2017-11-29 10:16:09 +00:00
|
|
|
change(sel_beg, pos_);
|
2007-09-05 13:04:05 +00:00
|
|
|
else if (beg > pos_ && beg <= end_)
|
2017-11-29 10:16:09 +00:00
|
|
|
change(sel_beg, beg);
|
2007-09-05 13:04:05 +00:00
|
|
|
else
|
2017-11-29 10:16:09 +00:00
|
|
|
change(sel_beg, -1);
|
2007-09-05 13:04:05 +00:00
|
|
|
|
|
|
|
if (end_ >= beg && end_ <= end)
|
2017-11-29 10:16:09 +00:00
|
|
|
change(sel_end,end_);
|
2007-09-05 13:04:05 +00:00
|
|
|
else if (end < end_ && end >= pos_)
|
2017-11-29 10:16:09 +00:00
|
|
|
change(sel_end, end);
|
2007-09-05 13:04:05 +00:00
|
|
|
else
|
2017-11-29 10:16:09 +00:00
|
|
|
change(sel_end, -1);
|
2007-09-05 13:04:05 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
Patch by Vincent that solves a number of problems related to the painting of a selection:
1. When a listing is inserted in a bit of text, the line above the listing is not drawn over the full width like it is done for lines above other insets. This is because InsetListing has a AlignLeft alignment. Now, if you start selecting downwards with the mouse in this empty area, strange selection drawings appear (see attachment).
This is caused by the fact that starting your selection at such a place, causes beg.boundary() to be true in TextMetrics::drawRowSelection(..). This is correct, but this value is true for _all_ selected lines. Now, the selection acts as if it is RTL text. Therefore, just like for end.boundary, this value needs to be reset for every line.
2. Starting your selection in an end margin often causes the selection in this end margin to be painted later. This is because when starting your selection in an end margin, you may have set a (possible empty) selection before really selecting the end margin. The problem is that the checksum (computed later) is the same for this empty selection and for the end margin selection. Therfore, we need a call to cur.setSelection() before evaluating cur.selection().
3. In the following two lines, it is assumed that there is only an end margin to be painted if the selection extends to the next paragraph. This is not true for the above described case of an AlignLeft Inset. Then, the margin has also be drawn within a paragraph
4. The end and begin margins are only painted when the selection extends into the following or previous paragraph. This difference is not resembled in the checksum if you first select a row completely and then procede to the next or previous paragraph as the selection remains at the end of a row. This also holds for the AlignLeft case. Therefore I added a term to the checksum to monitor whether the end and begin margins need to be drawn.
git-svn-id: svn://svn.lyx.org/lyx/lyx-devel/trunk@26399 a592a061-630c-0410-9148-cb99ea01b6c8
2008-09-14 14:32:40 +00:00
|
|
|
bool Row::selection() const
|
|
|
|
{
|
|
|
|
return sel_beg != -1 && sel_end != -1;
|
|
|
|
}
|
|
|
|
|
2013-07-17 22:25:08 +00:00
|
|
|
|
|
|
|
ostream & operator<<(ostream & os, Row::Element const & e)
|
|
|
|
{
|
2015-09-18 14:42:24 +00:00
|
|
|
if (e.isRTL())
|
2013-07-17 22:25:08 +00:00
|
|
|
os << e.endpos << "<<" << e.pos << " ";
|
|
|
|
else
|
|
|
|
os << e.pos << ">>" << e.endpos << " ";
|
|
|
|
|
|
|
|
switch (e.type) {
|
2013-07-21 18:22:32 +00:00
|
|
|
case Row::STRING:
|
2015-07-22 22:39:27 +00:00
|
|
|
os << "STRING: `" << to_utf8(e.str) << "' ("
|
2016-08-13 18:03:02 +00:00
|
|
|
<< e.countExpanders() << " expanders.), ";
|
2013-07-17 22:25:08 +00:00
|
|
|
break;
|
2013-07-21 18:22:32 +00:00
|
|
|
case Row::VIRTUAL:
|
2014-03-21 10:56:42 +00:00
|
|
|
os << "VIRTUAL: `" << to_utf8(e.str) << "', ";
|
2013-07-17 22:25:08 +00:00
|
|
|
break;
|
2013-07-21 18:22:32 +00:00
|
|
|
case Row::INSET:
|
2014-03-21 10:56:42 +00:00
|
|
|
os << "INSET: " << to_utf8(e.inset->layoutName()) << ", ";
|
2013-07-17 22:25:08 +00:00
|
|
|
break;
|
2013-07-21 18:22:32 +00:00
|
|
|
case Row::SPACE:
|
2014-03-21 10:56:42 +00:00
|
|
|
os << "SPACE: ";
|
2022-01-17 10:58:49 +00:00
|
|
|
break;
|
|
|
|
case Row::MARGINSPACE:
|
|
|
|
os << "MARGINSPACE: ";
|
2013-07-17 22:25:08 +00:00
|
|
|
}
|
2021-08-31 13:58:56 +00:00
|
|
|
os << "width=" << e.full_width() << ", row_flags=" << e.row_flags;
|
2013-07-17 22:25:08 +00:00
|
|
|
return os;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2021-09-20 15:32:18 +00:00
|
|
|
ostream & operator<<(ostream & os, Row::Elements const & elts)
|
|
|
|
{
|
|
|
|
double x = 0;
|
|
|
|
for (Row::Element const & e : elts) {
|
|
|
|
os << "x=" << x << " => " << e << endl;
|
|
|
|
x += e.full_width();
|
|
|
|
}
|
|
|
|
return os;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-06-25 12:57:09 +00:00
|
|
|
ostream & operator<<(ostream & os, Row const & row)
|
|
|
|
{
|
|
|
|
os << " pos: " << row.pos_ << " end: " << row.end_
|
2014-12-22 09:36:53 +00:00
|
|
|
<< " left_margin: " << row.left_margin
|
2013-06-25 12:57:09 +00:00
|
|
|
<< " width: " << row.dim_.wid
|
2014-03-19 13:44:53 +00:00
|
|
|
<< " right_margin: " << row.right_margin
|
2013-06-25 12:57:09 +00:00
|
|
|
<< " ascent: " << row.dim_.asc
|
2013-07-17 22:25:08 +00:00
|
|
|
<< " descent: " << row.dim_.des
|
|
|
|
<< " separator: " << row.separator
|
2017-07-03 17:53:14 +00:00
|
|
|
<< " label_hfill: " << row.label_hfill
|
2022-07-16 16:13:47 +00:00
|
|
|
<< " end_boundary: " << row.end_boundary()
|
2021-12-28 19:56:57 +00:00
|
|
|
<< " flushed: " << row.flushed() << "\n";
|
2021-09-20 15:32:18 +00:00
|
|
|
// We cannot use the operator above, unfortunately
|
2014-12-22 09:36:53 +00:00
|
|
|
double x = row.left_margin;
|
2021-09-20 15:32:18 +00:00
|
|
|
for (Row::Element const & e : row.elements_) {
|
|
|
|
os << "x=" << x << " => " << e << endl;
|
|
|
|
x += e.full_width();
|
2013-06-25 12:57:09 +00:00
|
|
|
}
|
|
|
|
return os;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2015-10-25 22:58:58 +00:00
|
|
|
int Row::left_x() const
|
|
|
|
{
|
|
|
|
double x = left_margin;
|
|
|
|
const_iterator const end = elements_.end();
|
|
|
|
const_iterator cit = elements_.begin();
|
|
|
|
while (cit != end && cit->isVirtual()) {
|
|
|
|
x += cit->full_width();
|
|
|
|
++cit;
|
|
|
|
}
|
2020-11-26 20:10:45 +00:00
|
|
|
return support::iround(x);
|
2015-10-25 22:58:58 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
int Row::right_x() const
|
|
|
|
{
|
|
|
|
double x = dim_.wid;
|
|
|
|
const_iterator const begin = elements_.begin();
|
|
|
|
const_iterator cit = elements_.end();
|
|
|
|
while (cit != begin) {
|
|
|
|
--cit;
|
|
|
|
if (cit->isVirtual())
|
|
|
|
x -= cit->full_width();
|
|
|
|
else
|
|
|
|
break;
|
|
|
|
}
|
2020-11-26 20:10:45 +00:00
|
|
|
return support::iround(x);
|
2015-10-25 22:58:58 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2016-08-13 18:03:02 +00:00
|
|
|
bool Row::setExtraWidth(int w)
|
2015-07-18 23:22:10 +00:00
|
|
|
{
|
2016-08-13 18:03:02 +00:00
|
|
|
if (w < 0)
|
|
|
|
// this is not expected to happen (but it does)
|
|
|
|
return false;
|
|
|
|
// amount of expansion: number of expanders time the em value for each
|
|
|
|
// string element
|
|
|
|
int exp_amount = 0;
|
2021-01-06 17:14:49 +00:00
|
|
|
for (Element const & e : elements_)
|
2016-08-13 18:03:02 +00:00
|
|
|
exp_amount += e.expansionAmount();
|
2016-11-21 11:09:48 +00:00
|
|
|
if (!exp_amount)
|
|
|
|
return false;
|
2016-08-13 18:03:02 +00:00
|
|
|
// extra length per expander per em
|
|
|
|
double extra_per_em = double(w) / exp_amount;
|
|
|
|
if (extra_per_em > MAX_SPACE_STRETCH)
|
|
|
|
// do not stretch more than MAX_SPACE_STRETCH em per expander
|
|
|
|
return false;
|
|
|
|
// add extra length to each element proportionally to its em.
|
2021-01-06 17:14:49 +00:00
|
|
|
for (Element & e : elements_)
|
|
|
|
if (e.type == STRING)
|
2016-08-13 18:03:02 +00:00
|
|
|
e.setExtra(extra_per_em);
|
|
|
|
// update row dimension
|
|
|
|
dim_.wid += w;
|
|
|
|
return true;
|
2015-07-18 23:22:10 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-06-25 12:57:09 +00:00
|
|
|
bool Row::sameString(Font const & f, Change const & ch) const
|
|
|
|
{
|
|
|
|
if (elements_.empty())
|
|
|
|
return false;
|
|
|
|
Element const & elt = elements_.back();
|
2013-07-21 18:22:32 +00:00
|
|
|
return elt.type == STRING && !elt.final
|
2013-06-25 12:57:09 +00:00
|
|
|
&& elt.font == f && elt.change == ch;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void Row::finalizeLast()
|
|
|
|
{
|
|
|
|
if (elements_.empty())
|
|
|
|
return;
|
|
|
|
Element & elt = elements_.back();
|
|
|
|
if (elt.final)
|
|
|
|
return;
|
|
|
|
elt.final = true;
|
2017-11-11 10:57:39 +00:00
|
|
|
if (elt.change.changed())
|
|
|
|
changebar_ = true;
|
2013-06-25 12:57:09 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-07-16 22:59:34 +00:00
|
|
|
void Row::add(pos_type const pos, Inset const * ins, Dimension const & dim,
|
2021-07-11 22:07:59 +00:00
|
|
|
Font const & f, Change const & ch)
|
2013-06-25 12:57:09 +00:00
|
|
|
{
|
|
|
|
finalizeLast();
|
2013-07-21 18:22:32 +00:00
|
|
|
Element e(INSET, pos, f, ch);
|
2013-06-25 12:57:09 +00:00
|
|
|
e.inset = ins;
|
|
|
|
e.dim = dim;
|
2021-07-11 22:07:59 +00:00
|
|
|
e.row_flags = ins->rowFlags();
|
2013-06-25 12:57:09 +00:00
|
|
|
elements_.push_back(e);
|
|
|
|
dim_.wid += dim.wid;
|
2020-01-11 20:21:34 +00:00
|
|
|
changebar_ |= ins->isChanged();
|
2013-06-25 12:57:09 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-07-16 22:59:34 +00:00
|
|
|
void Row::add(pos_type const pos, char_type const c,
|
2022-01-17 16:33:21 +00:00
|
|
|
Font const & f, Change const & ch)
|
2013-06-25 12:57:09 +00:00
|
|
|
{
|
2013-07-16 22:59:34 +00:00
|
|
|
if (!sameString(f, ch)) {
|
2013-06-25 12:57:09 +00:00
|
|
|
finalizeLast();
|
2013-07-21 18:22:32 +00:00
|
|
|
Element e(STRING, pos, f, ch);
|
2022-01-17 16:33:21 +00:00
|
|
|
e.row_flags = CanBreakInside;
|
2013-06-25 12:57:09 +00:00
|
|
|
elements_.push_back(e);
|
|
|
|
}
|
2021-07-17 21:16:15 +00:00
|
|
|
back().str += c;
|
|
|
|
back().endpos = pos + 1;
|
2013-06-25 12:57:09 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-07-21 18:22:32 +00:00
|
|
|
void Row::addVirtual(pos_type const pos, docstring const & s,
|
|
|
|
Font const & f, Change const & ch)
|
2013-06-25 12:57:09 +00:00
|
|
|
{
|
2013-07-17 22:25:08 +00:00
|
|
|
finalizeLast();
|
2013-07-21 18:22:32 +00:00
|
|
|
Element e(VIRTUAL, pos, f, ch);
|
2013-07-17 22:25:08 +00:00
|
|
|
e.str = s;
|
2014-03-20 10:00:14 +00:00
|
|
|
e.dim.wid = theFontMetrics(f).width(s);
|
|
|
|
dim_.wid += e.dim.wid;
|
2013-07-17 22:25:08 +00:00
|
|
|
e.endpos = pos;
|
2021-07-11 22:07:59 +00:00
|
|
|
// Copy after* flags from previous elements, forbid break before element
|
|
|
|
int const prev_row_flags = elements_.empty() ? Inline : elements_.back().row_flags;
|
|
|
|
int const can_inherit = AfterFlags & ~AlwaysBreakAfter;
|
|
|
|
e.row_flags = (prev_row_flags & can_inherit) | NoBreakBefore;
|
2013-07-17 22:25:08 +00:00
|
|
|
elements_.push_back(e);
|
|
|
|
finalizeLast();
|
2013-06-25 12:57:09 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-07-16 22:59:34 +00:00
|
|
|
void Row::addSpace(pos_type const pos, int const width,
|
|
|
|
Font const & f, Change const & ch)
|
2013-06-25 12:57:09 +00:00
|
|
|
{
|
|
|
|
finalizeLast();
|
2013-07-21 18:22:32 +00:00
|
|
|
Element e(SPACE, pos, f, ch);
|
2013-06-25 12:57:09 +00:00
|
|
|
e.dim.wid = width;
|
|
|
|
elements_.push_back(e);
|
|
|
|
dim_.wid += e.dim.wid;
|
|
|
|
}
|
|
|
|
|
Patch by Vincent that solves a number of problems related to the painting of a selection:
1. When a listing is inserted in a bit of text, the line above the listing is not drawn over the full width like it is done for lines above other insets. This is because InsetListing has a AlignLeft alignment. Now, if you start selecting downwards with the mouse in this empty area, strange selection drawings appear (see attachment).
This is caused by the fact that starting your selection at such a place, causes beg.boundary() to be true in TextMetrics::drawRowSelection(..). This is correct, but this value is true for _all_ selected lines. Now, the selection acts as if it is RTL text. Therefore, just like for end.boundary, this value needs to be reset for every line.
2. Starting your selection in an end margin often causes the selection in this end margin to be painted later. This is because when starting your selection in an end margin, you may have set a (possible empty) selection before really selecting the end margin. The problem is that the checksum (computed later) is the same for this empty selection and for the end margin selection. Therfore, we need a call to cur.setSelection() before evaluating cur.selection().
3. In the following two lines, it is assumed that there is only an end margin to be painted if the selection extends to the next paragraph. This is not true for the above described case of an AlignLeft Inset. Then, the margin has also be drawn within a paragraph
4. The end and begin margins are only painted when the selection extends into the following or previous paragraph. This difference is not resembled in the checksum if you first select a row completely and then procede to the next or previous paragraph as the selection remains at the end of a row. This also holds for the AlignLeft case. Therefore I added a term to the checksum to monitor whether the end and begin margins need to be drawn.
git-svn-id: svn://svn.lyx.org/lyx/lyx-devel/trunk@26399 a592a061-630c-0410-9148-cb99ea01b6c8
2008-09-14 14:32:40 +00:00
|
|
|
|
2022-01-17 10:58:49 +00:00
|
|
|
void Row::addMarginSpace(pos_type const pos, int const width,
|
|
|
|
Font const & f, Change const & ch)
|
|
|
|
{
|
|
|
|
finalizeLast();
|
|
|
|
Element e(MARGINSPACE, pos, f, ch);
|
|
|
|
e.dim.wid = width;
|
|
|
|
e.row_flags = NoBreakBefore;
|
|
|
|
elements_.push_back(e);
|
|
|
|
dim_.wid += e.dim.wid;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2021-07-11 13:33:33 +00:00
|
|
|
void Row::push_back(Row::Element const & e)
|
|
|
|
{
|
|
|
|
dim_.wid += e.dim.wid;
|
|
|
|
elements_.push_back(e);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-06-25 12:57:09 +00:00
|
|
|
void Row::pop_back()
|
2003-08-01 14:12:04 +00:00
|
|
|
{
|
2013-06-25 12:57:09 +00:00
|
|
|
dim_.wid -= elements_.back().dim.wid;
|
|
|
|
elements_.pop_back();
|
2003-08-01 14:12:04 +00:00
|
|
|
}
|
2006-10-21 00:16:43 +00:00
|
|
|
|
|
|
|
|
2021-07-19 22:07:13 +00:00
|
|
|
namespace {
|
|
|
|
|
2021-09-06 12:52:42 +00:00
|
|
|
// Move stuff after \c it from \c from and the end of \c to.
|
|
|
|
void moveElements(Row::Elements & from, Row::Elements::iterator const & it,
|
|
|
|
Row::Elements & to)
|
2021-07-19 22:07:13 +00:00
|
|
|
{
|
2021-09-06 12:52:42 +00:00
|
|
|
to.insert(to.end(), it, from.end());
|
|
|
|
from.erase(it, from.end());
|
|
|
|
if (!from.empty())
|
2022-01-23 19:55:18 +00:00
|
|
|
from.back().row_flags = (from.back().row_flags & ~AfterFlags) | AlwaysBreakAfter;
|
2021-07-19 22:07:13 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
Row::Elements Row::shortenIfNeeded(int const w, int const next_width)
|
2013-06-25 12:57:09 +00:00
|
|
|
{
|
2021-07-19 22:07:13 +00:00
|
|
|
// FIXME: performance: if the last element is a string, we would
|
|
|
|
// like to avoid computing its length.
|
|
|
|
finalizeLast();
|
2014-05-19 09:35:15 +00:00
|
|
|
if (empty() || width() <= w)
|
2021-07-19 22:07:13 +00:00
|
|
|
return Elements();
|
2015-07-22 22:39:27 +00:00
|
|
|
|
2014-05-19 09:35:15 +00:00
|
|
|
Elements::iterator const beg = elements_.begin();
|
|
|
|
Elements::iterator const end = elements_.end();
|
2014-12-22 09:36:53 +00:00
|
|
|
int wid = left_margin;
|
2014-10-15 15:34:56 +00:00
|
|
|
|
2015-07-22 22:39:27 +00:00
|
|
|
// Search for the first element that goes beyond right margin
|
2014-10-15 15:34:56 +00:00
|
|
|
Elements::iterator cit = beg;
|
|
|
|
for ( ; cit != end ; ++cit) {
|
2015-07-22 09:05:02 +00:00
|
|
|
if (wid + cit->dim.wid > w)
|
2014-10-15 15:34:56 +00:00
|
|
|
break;
|
2014-12-22 09:36:53 +00:00
|
|
|
wid += cit->dim.wid;
|
2013-06-25 12:57:09 +00:00
|
|
|
}
|
|
|
|
|
2014-10-15 15:34:56 +00:00
|
|
|
if (cit == end) {
|
|
|
|
// This should not happen since the row is too long.
|
2021-07-19 22:07:13 +00:00
|
|
|
LYXERR0("Something is wrong, cannot shorten row: " << *this);
|
|
|
|
return Elements();
|
2014-10-15 15:34:56 +00:00
|
|
|
}
|
|
|
|
|
2015-07-22 22:39:27 +00:00
|
|
|
// Iterate backwards over breakable elements and try to break them
|
|
|
|
Elements::iterator cit_brk = cit;
|
|
|
|
int wid_brk = wid + cit_brk->dim.wid;
|
|
|
|
++cit_brk;
|
2021-09-06 12:52:42 +00:00
|
|
|
Elements tail;
|
2015-07-22 22:39:27 +00:00
|
|
|
while (cit_brk != beg) {
|
|
|
|
--cit_brk;
|
2015-07-23 09:59:51 +00:00
|
|
|
// make a copy of the element to work on it.
|
|
|
|
Element brk = *cit_brk;
|
2020-06-23 21:34:49 +00:00
|
|
|
/* If the current element is an inset that allows breaking row
|
2021-07-11 22:07:59 +00:00
|
|
|
* after itself, and if the row is already short enough after
|
2022-06-09 19:27:43 +00:00
|
|
|
* this element, then cut right after it.
|
2020-06-23 21:34:49 +00:00
|
|
|
*/
|
2021-07-11 22:07:59 +00:00
|
|
|
if (wid_brk <= w && brk.row_flags & CanBreakAfter) {
|
2020-06-23 21:34:49 +00:00
|
|
|
end_ = brk.endpos;
|
|
|
|
dim_.wid = wid_brk;
|
2021-09-06 12:52:42 +00:00
|
|
|
moveElements(elements_, cit_brk + 1, tail);
|
|
|
|
return tail;
|
2020-06-23 21:34:49 +00:00
|
|
|
}
|
|
|
|
// assume now that the current element is not there
|
2015-07-22 22:39:27 +00:00
|
|
|
wid_brk -= brk.dim.wid;
|
2022-06-09 19:27:43 +00:00
|
|
|
/* If the current element is an inset that allows breaking row
|
|
|
|
* before itself, and if the row is already short enough before
|
|
|
|
* this element, then cut right before it.
|
|
|
|
*/
|
|
|
|
if (wid_brk <= w && brk.row_flags & CanBreakBefore && cit_brk != beg) {
|
|
|
|
end_ = (cit_brk -1)->endpos;
|
|
|
|
dim_.wid = wid_brk;
|
|
|
|
moveElements(elements_, cit_brk, tail);
|
|
|
|
return tail;
|
|
|
|
}
|
2015-07-22 22:39:27 +00:00
|
|
|
/* We have found a suitable separable element. This is the common case.
|
2021-09-06 12:52:42 +00:00
|
|
|
* Try to break it cleanly at a length that is both
|
2015-07-22 22:39:27 +00:00
|
|
|
* - less than the available space on the row
|
|
|
|
* - shorter than the natural width of the element, in order to enforce
|
|
|
|
* break-up.
|
|
|
|
*/
|
2021-09-06 12:52:42 +00:00
|
|
|
if (brk.splitAt(min(w - wid_brk, brk.dim.wid - 2), next_width, false, tail)) {
|
2015-07-23 09:59:51 +00:00
|
|
|
/* if this element originally did not cause a row overflow
|
|
|
|
* in itself, and the remainder of the row would still be
|
|
|
|
* too large after breaking, then we will have issues in
|
|
|
|
* next row. Thus breaking does not help.
|
|
|
|
*/
|
|
|
|
if (wid_brk + cit_brk->dim.wid < w
|
2017-01-26 13:10:23 +00:00
|
|
|
&& dim_.wid - (wid_brk + brk.dim.wid) >= next_width) {
|
2021-12-15 10:19:18 +00:00
|
|
|
tail.clear();
|
2015-07-23 09:59:51 +00:00
|
|
|
break;
|
|
|
|
}
|
2015-07-22 22:39:27 +00:00
|
|
|
end_ = brk.endpos;
|
2015-07-23 09:59:51 +00:00
|
|
|
*cit_brk = brk;
|
2015-07-22 22:39:27 +00:00
|
|
|
dim_.wid = wid_brk + brk.dim.wid;
|
|
|
|
// If there are other elements, they should be removed.
|
2021-09-06 12:52:42 +00:00
|
|
|
moveElements(elements_, cit_brk + 1, tail);
|
|
|
|
return tail;
|
2015-07-22 22:39:27 +00:00
|
|
|
}
|
2021-09-06 12:52:42 +00:00
|
|
|
LATTEST(tail.empty());
|
2015-07-22 22:39:27 +00:00
|
|
|
}
|
|
|
|
|
2021-07-19 22:07:13 +00:00
|
|
|
if (cit != beg && cit->row_flags & NoBreakBefore) {
|
|
|
|
// It is not possible to separate this element from the
|
|
|
|
// previous one. (e.g. VIRTUAL)
|
2014-05-19 09:35:15 +00:00
|
|
|
--cit;
|
2014-12-22 09:36:53 +00:00
|
|
|
wid -= cit->dim.wid;
|
2013-06-25 12:57:09 +00:00
|
|
|
}
|
2014-05-19 09:35:15 +00:00
|
|
|
|
|
|
|
if (cit != beg) {
|
2015-07-22 22:39:27 +00:00
|
|
|
// There is no usable separator, but several elements have
|
|
|
|
// been added. We can cut right here.
|
2014-10-15 15:34:56 +00:00
|
|
|
end_ = cit->pos;
|
2014-12-22 09:36:53 +00:00
|
|
|
dim_.wid = wid;
|
2021-09-06 12:52:42 +00:00
|
|
|
moveElements(elements_, cit, tail);
|
|
|
|
return tail;
|
2013-07-21 18:22:32 +00:00
|
|
|
}
|
2014-05-19 09:35:15 +00:00
|
|
|
|
2015-07-18 23:22:10 +00:00
|
|
|
/* If we are here, it means that we have not found a separator to
|
2021-09-06 12:52:42 +00:00
|
|
|
* shorten the row. Let's try to break it again, but force
|
|
|
|
* splitting this time.
|
2014-05-19 09:35:15 +00:00
|
|
|
*/
|
2021-09-06 12:52:42 +00:00
|
|
|
if (cit->splitAt(w - wid, next_width, true, tail)) {
|
2014-10-15 15:34:56 +00:00
|
|
|
end_ = cit->endpos;
|
2015-07-18 23:22:10 +00:00
|
|
|
dim_.wid = wid + cit->dim.wid;
|
2014-05-19 09:35:15 +00:00
|
|
|
// If there are other elements, they should be removed.
|
2021-09-06 12:52:42 +00:00
|
|
|
moveElements(elements_, cit + 1, tail);
|
|
|
|
return tail;
|
2014-05-19 09:35:15 +00:00
|
|
|
}
|
2021-09-06 12:52:42 +00:00
|
|
|
|
2022-01-23 19:55:18 +00:00
|
|
|
// cit == beg; remove all elements after the first one.
|
|
|
|
moveElements(elements_, cit + 1, tail);
|
|
|
|
return tail;
|
2013-06-25 12:57:09 +00:00
|
|
|
}
|
|
|
|
|
2013-07-16 22:59:34 +00:00
|
|
|
|
2021-09-22 11:17:46 +00:00
|
|
|
void Row::reverseRTL()
|
2013-07-16 22:59:34 +00:00
|
|
|
{
|
|
|
|
pos_type i = 0;
|
|
|
|
pos_type const end = elements_.size();
|
|
|
|
while (i < end) {
|
2014-03-19 13:44:31 +00:00
|
|
|
// gather a sequence of elements with the same direction
|
2015-09-18 14:42:24 +00:00
|
|
|
bool const rtl = elements_[i].isRTL();
|
2013-07-16 22:59:34 +00:00
|
|
|
pos_type j = i;
|
2015-09-18 14:42:24 +00:00
|
|
|
while (j < end && elements_[j].isRTL() == rtl)
|
2013-07-16 22:59:34 +00:00
|
|
|
++j;
|
2014-03-19 13:44:31 +00:00
|
|
|
// if the direction is not the same as the paragraph
|
|
|
|
// direction, the sequence has to be reverted.
|
2021-09-22 11:17:46 +00:00
|
|
|
if (rtl != rtl_)
|
2014-03-19 13:44:31 +00:00
|
|
|
reverse(elements_.begin() + i, elements_.begin() + j);
|
2013-07-16 22:59:34 +00:00
|
|
|
i = j;
|
|
|
|
}
|
2014-03-19 13:44:31 +00:00
|
|
|
// If the paragraph itself is RTL, reverse everything
|
2021-09-22 11:17:46 +00:00
|
|
|
if (rtl_)
|
2014-03-19 13:44:31 +00:00
|
|
|
reverse(elements_.begin(), elements_.end());
|
2013-07-16 22:59:34 +00:00
|
|
|
}
|
|
|
|
|
2017-02-02 14:23:20 +00:00
|
|
|
Row::const_iterator const
|
|
|
|
Row::findElement(pos_type const pos, bool const boundary, double & x) const
|
|
|
|
{
|
|
|
|
/**
|
|
|
|
* When boundary is true, position i is in the row element (pos, endpos)
|
|
|
|
* if
|
|
|
|
* pos < i <= endpos
|
|
|
|
* whereas, when boundary is false, the test is
|
|
|
|
* pos <= i < endpos
|
|
|
|
* The correction below allows to handle both cases.
|
|
|
|
*/
|
|
|
|
int const boundary_corr = (boundary && pos) ? -1 : 0;
|
|
|
|
|
|
|
|
x = left_margin;
|
|
|
|
|
|
|
|
/** Early return in trivial cases
|
|
|
|
* 1) the row is empty
|
|
|
|
* 2) the position is the left-most position of the row; there
|
|
|
|
* is a quirk here however: if the first element is virtual
|
|
|
|
* (end-of-par marker for example), then we have to look
|
|
|
|
* closer
|
|
|
|
*/
|
|
|
|
if (empty()
|
|
|
|
|| (pos == begin()->left_pos() && !boundary
|
|
|
|
&& !begin()->isVirtual()))
|
|
|
|
return begin();
|
|
|
|
|
2021-01-06 17:14:49 +00:00
|
|
|
const_iterator cit = begin();
|
2017-02-02 14:23:20 +00:00
|
|
|
for ( ; cit != end() ; ++cit) {
|
2021-01-06 17:49:41 +00:00
|
|
|
/** Look whether the cursor is inside the element's span. Note
|
|
|
|
* that it is necessary to take the boundary into account, and
|
|
|
|
* to accept virtual elements, in which case the position
|
|
|
|
* will be before the virtual element.
|
2017-02-02 14:23:20 +00:00
|
|
|
*/
|
2021-01-06 17:49:41 +00:00
|
|
|
if (cit->isVirtual() && pos + boundary_corr == cit->pos)
|
|
|
|
break;
|
|
|
|
else if (pos + boundary_corr >= cit->pos
|
|
|
|
&& pos + boundary_corr < cit->endpos) {
|
|
|
|
x += cit->pos2x(pos);
|
|
|
|
break;
|
2017-02-02 14:23:20 +00:00
|
|
|
}
|
|
|
|
x += cit->full_width();
|
|
|
|
}
|
|
|
|
|
|
|
|
if (cit == end())
|
|
|
|
--cit;
|
|
|
|
|
|
|
|
return cit;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2006-10-21 00:16:43 +00:00
|
|
|
} // namespace lyx
|