inset_owner(0), the_locking_inset(0), bv_owner(bv)
{
anchor_row_ = rows().end();
- need_break_row = rows().end();
need_refresh_ = true;
}
inset_owner(inset), the_locking_inset(0), bv_owner(bv)
{
anchor_row_ = rows().end();
- need_break_row = rows().end();
need_refresh_ = true;
}
bv_owner = bview;
rowlist_.clear();
- need_break_row = rows().end();
width = height = 0;
need_refresh_ = true;
ParagraphList::iterator pit = ownerParagraphs().begin();
ParagraphList::iterator end = ownerParagraphs().end();
- current_font = getFont(bview->buffer(), pit, 0);
+ current_font = getFont(pit, 0);
for (; pit != end; ++pit)
insertParagraph(pit, rowlist_.end());
// smaller. (Asger)
// If position is -1, we get the layout font of the paragraph.
// If position is -2, we get the font of the manual label of the paragraph.
-LyXFont const LyXText::getFont(Buffer const * buf, ParagraphList::iterator pit,
- pos_type pos) const
+LyXFont LyXText::getFont(ParagraphList::iterator pit, pos_type pos) const
{
Assert(pos >= 0);
LyXLayout_ptr const & layout = pit->layout();
+#warning broken?
+ BufferParams const & params = bv()->buffer()->params;
// We specialize the 95% common case:
if (!pit->getDepth()) {
if (layout->labeltype == LABEL_MANUAL
&& pos < pit->beginningOfBody()) {
// 1% goes here
- LyXFont f = pit->getFontSettings(buf->params, pos);
+ LyXFont f = pit->getFontSettings(params, pos);
if (pit->inInset())
pit->inInset()->getDrawFont(f);
return f.realize(layout->reslabelfont);
} else {
- LyXFont f = pit->getFontSettings(buf->params, pos);
+ LyXFont f = pit->getFontSettings(params, pos);
if (pit->inInset())
pit->inInset()->getDrawFont(f);
return f.realize(layout->resfont);
layoutfont = layout->font;
}
- LyXFont tmpfont = pit->getFontSettings(buf->params, pos);
+ LyXFont tmpfont = pit->getFontSettings(params, pos);
tmpfont.realize(layoutfont);
if (pit->inInset())
// Realize with the fonts of lesser depth.
tmpfont.realize(outerFont(pit, ownerParagraphs()));
+ //tmpfont.realize(defaultfont_);
- return realizeFont(tmpfont, buf->params);
+ return tmpfont;
}
-LyXFont const LyXText::getLayoutFont(Buffer const * buf,
- ParagraphList::iterator pit) const
+LyXFont LyXText::getLayoutFont(ParagraphList::iterator pit) const
{
LyXLayout_ptr const & layout = pit->layout();
return layout->resfont;
}
- LyXFont font(layout->font);
+ LyXFont font = layout->font;
// Realize with the fonts of lesser depth.
font.realize(outerFont(pit, ownerParagraphs()));
+ //font.realize(defaultfont_);
- return realizeFont(font, buf->params);
+ return font;
}
-LyXFont const LyXText::getLabelFont(Buffer const * buf,
- ParagraphList::iterator pit) const
+LyXFont LyXText::getLabelFont(ParagraphList::iterator pit) const
{
LyXLayout_ptr const & layout = pit->layout();
return layout->reslabelfont;
}
- LyXFont font(layout->labelfont);
+ LyXFont font = layout->labelfont;
// Realize with the fonts of lesser depth.
font.realize(outerFont(pit, ownerParagraphs()));
+ //font.realize(defaultfont_);
- return realizeFont(layout->labelfont, buf->params);
+ return font;
}
pos_type pos, LyXFont const & fnt,
bool toggleall)
{
- Buffer const * buf = bv()->buffer();
- LyXFont font = getFont(buf, pit, pos);
- font.update(fnt, buf->params.language, toggleall);
+ BufferParams const & params = bv()->buffer()->params;
+ LyXFont font = getFont(pit, pos);
+ font.update(fnt, params.language, toggleall);
// Let the insets convert their font
if (pit->isInset(pos)) {
- Inset * inset = pit->getInset(pos);
+ InsetOld * inset = pit->getInset(pos);
if (isEditableInset(inset)) {
- UpdatableInset * uinset =
- static_cast<UpdatableInset *>(inset);
- uinset->setFont(bv(), fnt, toggleall, true);
+ static_cast<UpdatableInset *>(inset)
+ ->setFont(bv(), fnt, toggleall, true);
}
}
- // Plug thru to version below:
- setCharFont(buf, pit, pos, font);
+ // Plug through to version below:
+ setCharFont(pit, pos, font);
}
-void LyXText::setCharFont(Buffer const * buf, ParagraphList::iterator pit,
- pos_type pos, LyXFont const & fnt)
+void LyXText::setCharFont(
+ ParagraphList::iterator pit, pos_type pos, LyXFont const & fnt)
{
- LyXFont font(fnt);
-
- LyXTextClass const & tclass = buf->params.getLyXTextClass();
+ LyXFont font = fnt;
LyXLayout_ptr const & layout = pit->layout();
// Get concrete layout font to reduce against
}
}
- layoutfont.realize(tclass.defaultfont());
+ //layoutfont.realize(defaultfont_);
// Now, reduce font against full layout font
font.reduce(layoutfont);
}
-Inset * LyXText::getInset() const
+InsetOld * LyXText::getInset() const
{
ParagraphList::iterator pit = cursor.par();
pos_type const pos = cursor.pos();
void LyXText::toggleInset()
{
- Inset * inset = getInset();
+ InsetOld * inset = getInset();
// is there an editable inset at cursor position?
if (!isEditableInset(inset)) {
// No, try to see if we are inside a collapsable inset
// do we want to keep this?? (JMarc)
if (!isHighlyEditableInset(inset))
- setCursorParUndo(bv());
+ recordUndo(bv(), Undo::ATOMIC);
if (inset->isOpen()) {
inset->close(bv());
/* used in setlayout */
// Asger is not sure we want to do this...
-void LyXText::makeFontEntriesLayoutSpecific(Buffer const & buf,
+void LyXText::makeFontEntriesLayoutSpecific(BufferParams const & params,
Paragraph & par)
{
LyXLayout_ptr const & layout = par.layout();
else
layoutfont = layout->font;
- LyXFont tmpfont = par.getFontSettings(buf.params, pos);
+ LyXFont tmpfont = par.getFontSettings(params, pos);
tmpfont.reduce(layoutfont);
par.setFont(pos, tmpfont);
}
++endpit;
}
- setUndo(bv(), Undo::EDIT, sstart_cur.par(), boost::prior(undoendpit));
+ recordUndo(bv(), Undo::ATOMIC, sstart_cur.par(), boost::prior(undoendpit));
// ok we have a selection. This is always between sstart_cur
// and sel_end cursor
do {
pit->applyLayout(lyxlayout);
- makeFontEntriesLayoutSpecific(*bv()->buffer(), *pit);
+ makeFontEntriesLayoutSpecific(bv()->buffer()->params, *pit);
ParagraphList::iterator fppit = pit;
fppit->params().spaceTop(lyxlayout->fill_top ?
VSpace(VSpace::VFILL)
bv()->owner()->dispatch(FuncRequest(LFUN_HOME));
bv()->owner()->dispatch(FuncRequest(LFUN_ENDSEL));
bv()->owner()->dispatch(FuncRequest(LFUN_CUT));
- Inset * inset = new InsetEnvironment(params, layout);
+ InsetOld * inset = new InsetEnvironment(params, layout);
if (bv()->insertInset(inset)) {
//inset->edit(bv());
//bv()->owner()->dispatch(FuncRequest(LFUN_PASTE));
ParagraphList::iterator pastend = boost::next(end);
if (!test_only)
- setUndo(bv(), Undo::EDIT, start, end);
+ recordUndo(bv(), Undo::ATOMIC, start, end);
bool changed = false;
// Determine basis font
LyXFont layoutfont;
if (cursor.pos() < cursor.par()->beginningOfBody()) {
- layoutfont = getLabelFont(bv()->buffer(),
- cursor.par());
+ layoutfont = getLabelFont(cursor.par());
} else {
- layoutfont = getLayoutFont(bv()->buffer(),
- cursor.par());
+ layoutfont = getLayoutFont(cursor.par());
}
// Update current font
real_current_font.update(font,
// ok we have a selection. This is always between sel_start_cursor
// and sel_end cursor
- setUndo(bv(), Undo::EDIT, selection.start.par(), selection.end.par());
+ recordUndo(bv(), Undo::ATOMIC, selection.start.par(), selection.end.par());
freezeUndo();
cursor = selection.start;
while (cursor.par() != selection.end.par() ||
// rebuild row cache
rowlist_.clear();
- need_break_row = rows().end();
width = height = 0;
anchor_row_ = rows().end();
ParagraphList::iterator end = ownerParagraphs().end();
for (; pit != end; ++pit) {
- // compute inset metrics
- for (int pos = 0; pos != pit->size(); ++pos) {
- if (pit->isInset(pos)) {
- Dimension dim;
- MetricsInfo m = mi;
- pit->getInset(pos)->metrics(m, dim);
- }
+ InsetList::iterator ii = pit->insetlist.begin();
+ InsetList::iterator iend = pit->insetlist.end();
+ for (; ii != iend; ++ii) {
+ Dimension dim;
+ MetricsInfo m = mi;
+ ii->inset->metrics(m, dim);
}
// insert a new row, starting at position 0
init(bv());
return;
}
-
- RowList::iterator rows_end = rows().end();
-
- if (need_break_row != rows_end) {
- breakAgain(need_break_row);
- need_break_row = rows_end;
- return;
- }
+ breakAgain(rows().begin());
}
++endpit;
}
- setUndo(bv(), Undo::EDIT, selection.start.par(),
+ recordUndo(bv(), Undo::ATOMIC, selection.start.par(),
boost::prior(undoendpit));
// the caption hack:
if (layout->labeltype == LABEL_SENSITIVE) {
ParagraphList::iterator tmppit = pit;
- Inset * in = 0;
+ InsetOld * in = 0;
bool isOK = false;
while (tmppit != ownerParagraphs().end() &&
tmppit->inInset()
// the single '=' is intended below
&& (in = tmppit->inInset()->owner())) {
- if (in->lyxCode() == Inset::FLOAT_CODE ||
- in->lyxCode() == Inset::WRAP_CODE) {
+ if (in->lyxCode() == InsetOld::FLOAT_CODE ||
+ in->lyxCode() == InsetOld::WRAP_CODE) {
isOK = true;
break;
} else {
if (isOK) {
string type;
- if (in->lyxCode() == Inset::FLOAT_CODE)
+ if (in->lyxCode() == InsetOld::FLOAT_CODE)
type = static_cast<InsetFloat*>(in)->params().type;
- else if (in->lyxCode() == Inset::WRAP_CODE)
+ else if (in->lyxCode() == InsetOld::WRAP_CODE)
type = static_cast<InsetWrap*>(in)->params().type;
else
Assert(0);
}
-void LyXText::insertInset(Inset * inset)
+void LyXText::insertInset(InsetOld * inset)
{
if (!cursor.par()->insetAllowed(inset->lyxCode()))
return;
- setUndo(bv(), Undo::FINISH, cursor.par());
+ recordUndo(bv(), Undo::ATOMIC, cursor.par());
freezeUndo();
cursor.par()->insertInset(cursor.pos(), inset);
// Just to rebreak and refresh correctly.
++endpit;
}
- setUndo(bv(), Undo::DELETE, selection.start.par(),
+ recordUndo(bv(), Undo::DELETE, selection.start.par(),
boost::prior(undoendpit));
if (!CutAndPaste::checkPastePossible())
return;
- setUndo(bv(), Undo::INSERT, cursor.par());
+ recordUndo(bv(), Undo::INSERT, cursor.par());
ParagraphList::iterator endpit;
PitPosPair ppp;
// simple replacing. The font of the first selected character is used
void LyXText::replaceSelectionWithString(string const & str)
{
- setCursorParUndo(bv());
+ recordUndo(bv(), Undo::ATOMIC);
freezeUndo();
if (!selection.set()) { // create a dummy selection
pos_type pos = cursor.pos();
ParagraphList::iterator endpit = boost::next(cursor.par());
- setCursorParUndo(bv());
+ recordUndo(bv(), Undo::ATOMIC);
// only to be sure, should not be neccessary
clearSelection();
void LyXText::checkParagraph(ParagraphList::iterator pit, pos_type pos)
{
- LyXCursor tmpcursor;
-
- pos_type z;
- RowList::iterator row = getRow(pit, pos);
- RowList::iterator beg = rows().begin();
-
- // is there a break one row above
- if (row != beg && boost::prior(row)->par() == row->par()) {
- z = rowBreakPoint(*boost::prior(row));
- if (z >= row->pos()) {
- // set the dimensions of the row above
- postPaint();
-
- breakAgain(boost::prior(row));
-
- // set the cursor again. Otherwise
- // dangling pointers are possible
- setCursor(cursor.par(), cursor.pos(),
- false, cursor.boundary());
- selection.cursor = cursor;
- return;
- }
- }
-
- breakAgain(row);
+ breakAgain(getRow(pit, pos));
postPaint();
-
- // set the cursor again. Otherwise dangling pointers are possible
- // also set the selection
-
- if (selection.set()) {
- tmpcursor = cursor;
- setCursorIntern(selection.cursor.par(), selection.cursor.pos(),
- false, selection.cursor.boundary());
- selection.cursor = cursor;
- setCursorIntern(selection.start.par(),
- selection.start.pos(),
- false, selection.start.boundary());
- selection.start = cursor;
- setCursorIntern(selection.end.par(),
- selection.end.pos(),
- false, selection.end.boundary());
- selection.end = cursor;
- setCursorIntern(last_sel_cursor.par(),
- last_sel_cursor.pos(),
- false, last_sel_cursor.boundary());
- last_sel_cursor = cursor;
- cursor = tmpcursor;
- }
- setCursorIntern(cursor.par(), cursor.pos(),
- false, cursor.boundary());
+ setCursorIntern(cursor.par(), cursor.pos(), false, cursor.boundary());
}
// returns false if inset wasn't found
-bool LyXText::updateInset(Inset * inset)
+bool LyXText::updateInset(InsetOld * inset)
{
// first check the current paragraph
int pos = cursor.par()->getPositionOfInset(inset);
}
// check every paragraph
-
ParagraphList::iterator par = ownerParagraphs().begin();
ParagraphList::iterator end = ownerParagraphs().end();
for (; par != end; ++par) {
checkParagraph(par, pos);
return true;
}
- };
+ }
return false;
}
boost::prior(row)->par() == row->par() &&
pos < pit->size() &&
pit->getChar(pos) == Paragraph::META_INSET) {
- Inset * ins = pit->getInset(pos);
+ InsetOld * ins = pit->getInset(pos);
if (ins && (ins->needFullRow() || ins->display())) {
--row;
y -= row->height();
if (body_pos > 0 && pos == body_pos - 1) {
x += fill_label_hfill +
font_metrics::width(
- rit_par->layout()->labelsep,
- getLabelFont(bv()->buffer(), rit_par));
+ rit_par->layout()->labelsep, getLabelFont(rit_par));
if (rit_par->isLineSeparator(body_pos - 1))
x -= singleWidth(rit_par, body_pos - 1);
}
}
}
- current_font =
- pit->getFontSettings(bv()->buffer()->params, pos);
- real_current_font = getFont(bv()->buffer(), pit, pos);
+ current_font = pit->getFontSettings(bv()->buffer()->params, pos);
+ real_current_font = getFont(pit, pos);
if (cursor.pos() == pit->size() &&
isBoundary(bv()->buffer(), *pit, cursor.pos()) &&
last_tmpx = tmpx;
if (body_pos > 0 && c == body_pos - 1) {
tmpx += fill_label_hfill +
- font_metrics::width(layout->labelsep,
- getLabelFont(bv()->buffer(), rit_par));
+ font_metrics::width(layout->labelsep, getLabelFont(rit_par));
if (rit_par->isLineSeparator(body_pos - 1))
tmpx -= singleWidth(rit_par, body_pos - 1);
}
|| !cur.par()->isInset(cur.pos()))
return false;
- Inset const * inset = cur.par()->getInset(cur.pos());
+ InsetOld const * inset = cur.par()->getInset(cur.pos());
if (inset->needFullRow() || inset->display())
return true;
int y1 = cursor.iy() - topy;
int y2 = y1;
y -= topy;
- Inset * inset_hit = checkInsetHit(x, y1);
+ InsetOld * inset_hit = checkInsetHit(x, y1);
if (inset_hit && isHighlyEditableInset(inset_hit)) {
inset_hit->localDispatch(
FuncRequest(bv(), LFUN_INSET_EDIT, x, y - (y2 - y1), mouse_button::none));
int y1 = cursor.iy() - topy;
int y2 = y1;
y -= topy;
- Inset * inset_hit = checkInsetHit(x, y1);
+ InsetOld * inset_hit = checkInsetHit(x, y1);
if (inset_hit && isHighlyEditableInset(inset_hit)) {
FuncRequest cmd(bv(), LFUN_INSET_EDIT, x, y - (y2 - y1), mouse_button::none);
inset_hit->localDispatch(cmd);
++endpit;
}
- setUndo(bv(), Undo::DELETE, old_cursor.par(),
+ recordUndo(bv(), Undo::DELETE, old_cursor.par(),
boost::prior(endpit));
cursor = tmpcursor;
++endpit;
}
- setUndo(bv(), Undo::DELETE, old_cursor.par(), boost::prior(endpit));
+ recordUndo(bv(), Undo::DELETE, old_cursor.par(), boost::prior(endpit));
cursor = tmpcursor;
// delete old row