#include "BufferView.h"
#include "Bullet.h"
#include "counters.h"
+#include "coordcache.h"
#include "cursor.h"
#include "CutAndPaste.h"
#include "debug.h"
#include "support/lstrings.h"
#include "support/textutils.h"
#include "support/tostr.h"
-#include "support/std_sstream.h"
+
+#include <sstream>
using lyx::par_type;
using lyx::pos_type;
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();
}
}
+// takes absolute x,y coordinates
+InsetBase * LyXText::checkInsetHit(int x, int y) const
+{
+ par_type pit;
+ par_type end;
+
+ getParsInRange(paragraphs(),
+ bv()->top_y() - yo_,
+ bv()->top_y() - yo_ + bv()->workHeight(),
+ pit, end);
+
+ // convert to screen-absolute y coordinate
+ y -= bv()->top_y();
+ lyxerr << "checkInsetHit: x: " << x << " y: " << y << endl;
+ lyxerr << " pit: " << pit << " end: " << end << endl;
+ for (; pit != end; ++pit) {
+ InsetList::const_iterator iit = pars_[pit].insetlist.begin();
+ InsetList::const_iterator iend = pars_[pit].insetlist.end();
+ for (; iit != iend; ++iit) {
+ InsetBase * inset = iit->inset;
+#if 1
+ lyxerr << "examining inset " << inset << endl;
+ if (theCoords.insets_.has(inset))
+ lyxerr
+ << " xo: " << inset->xo() << "..." << inset->xo() + inset->width()
+ << " yo: " << inset->yo() - inset->ascent() << "..."
+ << inset->yo() + inset->descent() << endl;
+ else
+ lyxerr << " inset has no cached position";
+#endif
+ if (inset->covers(x, y)) {
+ lyxerr << "Hit inset: " << inset << endl;
+ return inset;
+ }
+ }
+ }
+ lyxerr << "No inset hit. " << endl;
+ return 0;
+}
+
+
+
// Gets the fully instantiated font at a given position in a paragraph
// Basically the same routine as Paragraph::getFont() in paragraph.C.
// 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 pit, pos_type pos) const
+LyXFont LyXText::getFont(Paragraph const & par, pos_type const pos) const
{
BOOST_ASSERT(pos >= 0);
- LyXLayout_ptr const & layout = pars_[pit].layout();
+ LyXLayout_ptr const & layout = par.layout();
#ifdef WITH_WARNINGS
#warning broken?
#endif
BufferParams const & params = bv()->buffer()->params();
- pos_type const body_pos = pars_[pit].beginOfBody();
+ pos_type const body_pos = par.beginOfBody();
// We specialize the 95% common case:
- if (!pars_[pit].getDepth()) {
- LyXFont f = pars_[pit].getFontSettings(params, pos);
+ if (!par.getDepth()) {
+ LyXFont f = par.getFontSettings(params, pos);
if (!isMainText())
f.realize(font_);
if (layout->labeltype == LABEL_MANUAL && pos < body_pos)
else
layoutfont = layout->font;
- LyXFont font = pars_[pit].getFontSettings(params, pos);
+ LyXFont font = par.getFontSettings(params, pos);
font.realize(layoutfont);
if (!isMainText())
font.realize(font_);
// Realize with the fonts of lesser depth.
- //font.realize(outerFont(pit, paragraphs()));
font.realize(defaultfont_);
return font;
}
-LyXFont LyXText::getLayoutFont(par_type pit) const
+LyXFont LyXText::getLayoutFont(par_type const pit) const
{
LyXLayout_ptr const & layout = pars_[pit].layout();
}
-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;
LyXLayout_ptr const & lyxlayout = params.getLyXTextClass()[layout];
if (lyxlayout->is_environment) {
// move everything in a new environment inset
- lyxerr << "setting layout " << layout << endl;
+ lyxerr[Debug::DEBUG] << "setting layout " << layout << endl;
bv.owner()->dispatch(FuncRequest(LFUN_HOME));
bv.owner()->dispatch(FuncRequest(LFUN_ENDSEL));
bv.owner()->dispatch(FuncRequest(LFUN_CUT));
LyXFont layoutfont;
par_type pit = cur.par();
if (cur.pos() < pars_[pit].beginOfBody())
- layoutfont = getLabelFont(pit);
+ layoutfont = getLabelFont(pars_[pit]);
else
layoutfont = getLayoutFont(pit);
par_type const beg = cur.selBegin().par();
par_type const end = cur.selEnd().par();
- DocIterator pos = cur.selectionBegin();
- DocIterator posend = cur.selectionEnd();
-
- lyxerr << "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);
}
}
// set the counter of a paragraph. This includes the labels
void LyXText::setCounter(Buffer const & buf, par_type pit)
{
+ Paragraph & par = pars_[pit];
BufferParams const & bufparams = buf.params();
LyXTextClass const & textclass = bufparams.getLyXTextClass();
- LyXLayout_ptr const & layout = pars_[pit].layout();
- par_type first_pit = 0;
+ LyXLayout_ptr const & layout = par.layout();
Counters & counters = textclass.counters();
// Always reset
- pars_[pit].itemdepth = 0;
+ par.itemdepth = 0;
- if (pit == first_pit) {
- pars_[pit].params().appendix(pars_[pit].params().startOfAppendix());
+ if (pit == 0) {
+ par.params().appendix(par.params().startOfAppendix());
} else {
- pars_[pit].params().appendix(pars_[pit - 1].params().appendix());
- if (!pars_[pit].params().appendix() &&
- pars_[pit].params().startOfAppendix()) {
- pars_[pit].params().appendix(true);
+ par.params().appendix(pars_[pit - 1].params().appendix());
+ if (!par.params().appendix() &&
+ par.params().startOfAppendix()) {
+ par.params().appendix(true);
textclass.counters().reset();
}
// Maybe we have to increment the item depth.
- incrementItemDepth(pars_, pit, first_pit);
+ incrementItemDepth(pars_, pit, 0);
}
// erase what was there before
- pars_[pit].params().labelString(string());
+ par.params().labelString(string());
if (layout->margintype == MARGIN_MANUAL) {
- if (pars_[pit].params().labelWidthString().empty())
- pars_[pit].setLabelWidthString(layout->labelstring());
+ if (par.params().labelWidthString().empty())
+ par.setLabelWidthString(layout->labelstring());
} else {
- pars_[pit].setLabelWidthString(string());
+ par.setLabelWidthString(string());
}
// is it a layout that has an automatic label?
BufferParams const & bufparams = buf.params();
LyXTextClass const & textclass = bufparams.getLyXTextClass();
counters.step(layout->counter);
- string label = expandLabel(textclass, layout, pars_[pit].params().appendix());
- pars_[pit].params().labelString(label);
+ string label = expandLabel(textclass, layout, par.params().appendix());
+ par.params().labelString(label);
} else if (layout->labeltype == LABEL_ITEMIZE) {
// At some point of time we should do something more
// clever here, like:
- // pars_[pit].params().labelString(
- // bufparams.user_defined_bullet(pars_[pit].itemdepth).getText());
+ // par.params().labelString(
+ // bufparams.user_defined_bullet(par.itemdepth).getText());
// for now, use a simple hardcoded label
string itemlabel;
- switch (pars_[pit].itemdepth) {
+ switch (par.itemdepth) {
case 0:
itemlabel = "*";
break;
break;
}
- pars_[pit].params().labelString(itemlabel);
+ par.params().labelString(itemlabel);
} else if (layout->labeltype == LABEL_ENUMERATE) {
// Maybe we have to reset the enumeration counter.
- resetEnumCounterIfNeeded(pars_, pit, first_pit, counters);
+ resetEnumCounterIfNeeded(pars_, pit, 0, counters);
// FIXME
// Yes I know this is a really, really! bad solution
// (Lgb)
string enumcounter = "enum";
- switch (pars_[pit].itemdepth) {
+ switch (par.itemdepth) {
case 2:
enumcounter += 'i';
case 1:
counters.step(enumcounter);
- pars_[pit].params().labelString(counters.enumLabel(enumcounter));
+ par.params().labelString(counters.enumLabel(enumcounter));
} else if (layout->labeltype == LABEL_BIBLIO) {// ale970302
counters.step("bibitem");
int number = counters.value("bibitem");
- if (pars_[pit].bibitem()) {
- pars_[pit].bibitem()->setCounter(number);
- pars_[pit].params().labelString(layout->labelstring());
+ if (par.bibitem()) {
+ par.bibitem()->setCounter(number);
+ par.params().labelString(layout->labelstring());
}
// In biblio should't be following counters but...
} else {
in->lyxCode() == InsetBase::WRAP_CODE) {
isOK = true;
break;
- } else {
+ }
+#ifdef WITH_WARNINGS
+#warning replace this code by something that works
+// This code does not work because we have currently no way to move up
+// in the hierarchy of insets (JMarc 16/08/2004)
+#endif
+#if 0
+/* I think this code is supposed to be useful when one has a caption
+ * in a minipage in a figure inset. We need to go up to be able to see
+ * that the caption sould use "Figure" as label
+ */
+ else {
Paragraph const * owner = &ownerPar(buf, in);
- tmppit = first_pit;
+ tmppit = 0;
for ( ; tmppit != end; ++tmppit)
if (&pars_[tmppit] == owner)
break;
}
+#endif
}
if (isOK) {
s = _("Senseless: ");
}
}
- pars_[pit].params().labelString(s);
+ par.params().labelString(s);
}
}
setCounter(*bv()->buffer(), pit);
string const & newLabel = pars_[pit].params().labelString();
if (oldLabel != newLabel) {
- //lyxerr << "changing labels: old: " << oldLabel << " new: "
+ //lyxerr[Debug::DEBUG] << "changing labels: old: " << oldLabel << " new: "
// << newLabel << endl;
redoParagraphInternal(pit);
update_pos = true;
}
+// this really should just insert the inset and not move the cursor.
void LyXText::insertInset(LCursor & cur, InsetBase * inset)
{
BOOST_ASSERT(this == cur.text());
{
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;
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)
}
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);
// 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
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;
}
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)))
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;
}
}
+// y is relative to this LyXText's top
+// this is only used in the two functions below
+Row const & LyXText::getRowNearY(int y, par_type & pit) const
+{
+ BOOST_ASSERT(!paragraphs().empty());
+ BOOST_ASSERT(!paragraphs().begin()->rows.empty());
+ par_type const pend = paragraphs().size() - 1;
+ pit = 0;
+ while (int(pars_[pit].y + pars_[pit].height) < y && pit != pend)
+ ++pit;
+
+ RowList::iterator rit = pars_[pit].rows.end();
+ RowList::iterator const rbegin = pars_[pit].rows.begin();
+ do {
+ --rit;
+ } while (rit != rbegin && int(pars_[pit].y + rit->y_offset()) > y);
+
+ return *rit;
+}
+
+
// x,y are absolute coordinates
+// sets cursor only within this LyXText
void LyXText::setCursorFromCoordinates(LCursor & cur, int x, int y)
{
x -= xo_;
y -= yo_;
par_type pit;
Row const & row = getRowNearY(y, pit);
- lyxerr << "setCursorFromCoordinates:: hit row at: " << row.pos() << endl;
+ lyxerr[Debug::DEBUG] << "setCursorFromCoordinates:: hit row at: "
+ << row.pos() << endl;
bool bound = false;
int xx = x + xo_; // getRowNearX get absolute x coords
pos_type const pos = row.pos() + getColumnNearX(pit, row, xx, bound);
// x,y are absolute screen coordinates
-InsetBase * LyXText::editXY(LCursor & cur, int x, int y)
+// sets cursor recursively descending into nested editable insets
+InsetBase * LyXText::editXY(LCursor & cur, int x, int y) const
{
par_type pit;
Row const & row = getRowNearY(y - yo_, pit);
if (cur.selection())
return false;
- //lyxerr << "DEPM: cur:\n" << cur << "old:\n" << old << endl;
+ //lyxerr[Debug::DEBUG] << "DEPM: cur:\n" << cur << "old:\n" << old << endl;
Paragraph const & oldpar = pars_[old.par()];
// We allow all kinds of "mumbo-jumbo" when freespacing.
projects / lyx.git / blobdiff