#include "insets/insetcommand.h" // ChangeRefs
#include "insets/updatableinset.h"
+#include "insets/insettext.h"
#include "support/filetools.h"
#include "support/lyxalgo.h" // lyx_count
}
-void BufferView::buffer(Buffer * b)
+void BufferView::setBuffer(Buffer * b)
{
- pimpl_->buffer(b);
+ pimpl_->setBuffer(b);
}
-bool BufferView::newFile(string const & fn, string const & tn, bool named)
+void BufferView::newFile(string const & fn, string const & tn, bool named)
{
- return pimpl_->newFile(fn, tn, named);
+ pimpl_->newFile(fn, tn, named);
}
LyXText * BufferView::getLyXText() const
{
- return cursor().innerText();
+ LyXText * text = cursor().innerText();
+ BOOST_ASSERT(text);
+ return text;
}
}
-Encoding const * BufferView::getEncoding() const
-{
- LyXText * t = getLyXText();
- if (!t)
- return 0;
- CursorSlice const & cur = cursor().innerTextSlice();
- return t->getPar(cur.par())->getFont(
- buffer()->params(), cur.pos(),
- outerFont(t->getPar(cur.par()), t->paragraphs())
- ).language()->encoding();
-}
-
-
void BufferView::haveSelection(bool sel)
{
pimpl_->workarea().haveSelection(sel);
LyXText * BufferView::text() const
{
- return pimpl_->buffer_ ? &pimpl_->buffer_->text() : 0;
+ return buffer() ? &buffer()->text() : 0;
}
-void BufferView::setCursor(ParIterator const & par,
- lyx::pos_type pos)
+void BufferView::setCursor(ParIterator const & par, lyx::pos_type pos)
{
LCursor & cur = cursor();
cur.reset();
+ cur.push(buffer()->inset());
ParIterator::PosHolder const & positions = par.positions();
int const last = par.size() - 1;
for (int i = 0; i < last; ++i)
(*positions[i].it)->inset->edit(cur, true);
cur.resetAnchor();
- LyXText * lt = par.text(*buffer());
- lt->setCursor(cur, lt->parOffset(par.pit()), pos);
+ LyXText * text = par.text(*buffer());
+ text->setCursor(cur, text->parOffset(par.pit()), pos);
}
~BufferView();
/// set the buffer we are viewing
- void buffer(Buffer * b);
+ void setBuffer(Buffer * b);
/// return the buffer being viewed
Buffer * buffer() const;
/// reload the contained buffer
void reload();
/// create a new buffer based on template
- bool newFile(std::string const & fname, std::string const & tname,
+ void newFile(std::string const & fname, std::string const & tname,
bool named = true);
/// load a buffer into the view
bool loadLyXFile(std::string const & name, bool tolastfiles = true);
/// return the lyxtext we are using
LyXText * getLyXText() const;
- /// return the current encoding at the cursor
- Encoding const * getEncoding() const;
-
/// return the parent language of the given inset
Language const * getParentLanguage(InsetOld * inset) const;
#include "vspace.h"
#include "insets/insetref.h"
+#include "insets/insettext.h"
#include "frontends/Alert.h"
#include "frontends/Dialogs.h"
disconnectBuffer();
errorConnection_ =
- buf.error.connect(boost::bind(&BufferView::Pimpl::addError, this, _1));
+ buf.error.connect(
+ boost::bind(&BufferView::Pimpl::addError, this, _1));
+
messageConnection_ =
- buf.message.connect(boost::bind(&LyXView::message, owner_, _1));
+ buf.message.connect(
+ boost::bind(&LyXView::message, owner_, _1));
+
busyConnection_ =
- buf.busy.connect(boost::bind(&LyXView::busy, owner_, _1));
+ buf.busy.connect(
+ boost::bind(&LyXView::busy, owner_, _1));
+
titleConnection_ =
- buf.updateTitles.connect(boost::bind(&LyXView::updateWindowTitle, owner_));
+ buf.updateTitles.connect(
+ boost::bind(&LyXView::updateWindowTitle, owner_));
+
timerConnection_ =
- buf.resetAutosaveTimers.connect(boost::bind(&LyXView::resetAutosaveTimer, owner_));
+ buf.resetAutosaveTimers.connect(
+ boost::bind(&LyXView::resetAutosaveTimer, owner_));
+
readonlyConnection_ =
- buf.readonly.connect(boost::bind(&BufferView::Pimpl::showReadonly, this, _1));
+ buf.readonly.connect(
+ boost::bind(&BufferView::Pimpl::showReadonly, this, _1));
+
closingConnection_ =
- buf.closing.connect(boost::bind(&BufferView::Pimpl::buffer, this, (Buffer *)0));
+ buf.closing.connect(
+ boost::bind(&BufferView::Pimpl::setBuffer, this, (Buffer *)0));
}
}
-bool BufferView::Pimpl::newFile(string const & filename,
- string const & tname,
- bool isNamed)
+void BufferView::Pimpl::newFile(string const & filename, string const & tname,
+ bool isNamed)
{
- Buffer * b = ::newFile(filename, tname, isNamed);
- buffer(b);
- return true;
+ setBuffer(::newFile(filename, tname, isNamed));
}
text, 0, 1, _("&Revert"), _("&Switch to document"));
if (ret != 0) {
- buffer(bufferlist.getBuffer(s));
+ setBuffer(bufferlist.getBuffer(s));
return true;
- } else {
- // FIXME: should be LFUN_REVERT
- if (!bufferlist.close(bufferlist.getBuffer(s), false))
- return false;
- // Fall through to new load. (Asger)
}
+ // FIXME: should be LFUN_REVERT
+ if (!bufferlist.close(bufferlist.getBuffer(s), false))
+ return false;
+ // Fall through to new load. (Asger)
}
Buffer * b;
return false;
}
- buffer(b);
+ setBuffer(b);
bv_->showErrorList(_("Parse"));
if (tolastfiles)
}
-void BufferView::Pimpl::buffer(Buffer * b)
+void BufferView::Pimpl::setBuffer(Buffer * b)
{
lyxerr[Debug::INFO] << "Setting buffer in BufferView ("
<< b << ')' << endl;
- if (buffer_) {
+ if (buffer_)
disconnectBuffer();
- //delete bv_->text();
- //bv_->setText(0);
- }
-
- // reset old cursor
- cursor_.reset();
// set current buffer
buffer_ = b;
+ // reset old cursor
top_y_ = 0;
+ cursor_ = LCursor(*bv_);
// if we're quitting lyx, don't bother updating stuff
if (quitting)
return;
- // if we are closing the buffer, use the first buffer as current
- if (!buffer_)
- buffer_ = bufferlist.first();
-
if (buffer_) {
lyxerr[Debug::INFO] << "Buffer addr: " << buffer_ << endl;
connectBuffer(*buffer_);
+ cursor_.push(buffer_->inset());
+ cursor_.resetAnchor();
buffer_->text().init(bv_);
// If we don't have a text object for this, we make one
- if (bv_->text() == 0)
- resizeCurrentBuffer();
+ //if (bv_->text() == 0)
+ // resizeCurrentBuffer();
// Buffer-dependent dialogs should be updated or
// hidden. This should go here because some dialogs (eg ToC)
// require bv_->text.
owner_->getDialogs().updateBufferDependent(true);
+ owner_->setLayout(bv_->text()->getPar(0)->layout()->name());
} else {
lyxerr[Debug::INFO] << " No Buffer!" << endl;
+ // we are closing the buffer, use the first buffer as current
+ buffer_ = bufferlist.first();
owner_->getDialogs().hideBufferDependent();
}
owner_->updateLayoutChoice();
owner_->updateWindowTitle();
- // Don't forget to update the Layout
- if (buffer_)
- owner_->setLayout(bv_->text()->getPar(0)->layout()->name());
-
if (lyx::graphics::Previews::activated() && buffer_)
lyx::graphics::Previews::get().generateBufferPreviews(*buffer_);
}
bool BufferView::Pimpl::fitCursor()
{
- if (screen().fitCursor(bv_)) {
- updateScrollbar();
- return true;
- }
- return false;
+ if (!screen().fitCursor(bv_))
+ return false;
+ updateScrollbar();
+ return true;
}
{
if (!bv_->text()) {
lyxerr[Debug::GUI] << "no text in updateScrollbar" << endl;
+ lyxerr << "no text in updateScrollbar" << endl;
workarea().setScrollbarParams(0, 0, 0);
return;
}
LyXText const & t = *bv_->text();
- lyxerr[Debug::GUI] << "Updating scrollbar: h" << t.height()
- << ", top_y()" << top_y() << ", default height "
- << defaultRowHeight() << endl;
+ lyxerr[Debug::GUI]
+ << "Updating scrollbar: height: " << t.height()
+ << " top_y: " << top_y()
+ << " default height " << defaultRowHeight() << endl;
workarea().setScrollbarParams(t.height(), top_y(), defaultRowHeight());
}
void BufferView::Pimpl::update()
{
- //lyxerr << "BufferView::update()" << endl;
+ //lyxerr << "BufferView::Pimpl::update(), buffer: " << buffer_ << endl;
// fix cursor coordinate cache in case something went wrong
// check needed to survive LyX startup
- if (bv_->getLyXText()) {
+ if (buffer_) {
// update all 'visible' paragraphs
ParagraphList::iterator beg;
ParagraphList::iterator end;
::loadLyXFile(b, fname); // don't ask, just load it
}
if (b)
- buffer(b);
+ setBuffer(b);
}
ParIterator par = buffer_->getParFromID(saved_positions[i].par_id);
cmd.y += bv_->top_y();
//lyxerr << "*** workAreaDispatch: request: " << cmd << std::endl;
LCursor cur(*bv_);
+ cur.push(bv_->buffer()->inset());
+ cur.resetAnchor();
cur.selection() = bv_->cursor().selection();
switch (cmd.action) {
if (!available())
return false;
FuncRequest cmd1 = cmd;
- InsetBase * inset = cur.inset();
- DispatchResult res;
- if (inset) {
- res = inset->dispatch(cur, cmd);
- } else {
- res = bv_->text()->dispatch(cur, cmd);
- }
-
+ DispatchResult res = cur.inset().dispatch(cur, cmd);
if (fitCursor() || res.update()) {
update();
cur.updatePos();
bv_->center();
break;
+ case LFUN_BEGINNINGBUFSEL:
+ bv_->cursor().reset();
+ if (!cur.selection())
+ cur.resetAnchor();
+ bv_->text()->cursorTop(cur);
+ finishUndo();
+ break;
+
+ case LFUN_ENDBUFSEL:
+ bv_->cursor().reset();
+ if (!cur.selection())
+ cur.resetAnchor();
+ bv_->text()->cursorBottom(cur);
+ finishUndo();
+ break;
+
default:
return false;
}
/// return the screen for this bview
LyXScreen & screen() const;
///
- void buffer(Buffer *);
+ void setBuffer(Buffer * buf);
/// Return true if the cursor was fitted.
bool fitCursor();
///
void resizeCurrentBuffer();
///
void update();
- /**
- * Repaint pixmap. Used for when we've made a visible
- * change but don't need the full update() logic
- */
///
- bool newFile(std::string const &, std::string const &, bool);
+ void newFile(std::string const &, std::string const &, bool);
///
bool loadLyXFile(std::string const &, bool);
///
*/
bool file_fully_loaded;
- /// our text
- LyXText text;
+ /// our LyXText that should be wrapped in an InsetText
+ InsetText inset;
};
Buffer::Impl::Impl(Buffer & parent, string const & file, bool readonly_)
: lyx_clean(true), bak_clean(true), unnamed(false), read_only(readonly_),
filename(file), filepath(OnlyPath(file)), file_fully_loaded(false),
- text(0, 0)
+ inset(params)
{
lyxvc.buffer(&parent);
temppath = createBufferTmpDir();
: pimpl_(new Impl(*this, file, ronly))
{
lyxerr[Debug::INFO] << "Buffer::Buffer()" << endl;
+ lyxerr << "Buffer::Buffer()" << endl;
}
LyXText & Buffer::text() const
{
- return const_cast<LyXText &>(pimpl_->text);
+ return const_cast<LyXText &>(pimpl_->inset.text_);
+}
+
+
+InsetBase & Buffer::inset() const
+{
+ return const_cast<InsetText &>(pimpl_->inset);
}
ParagraphList & Buffer::paragraphs()
{
- return pimpl_->text.paragraphs();
+ return text().paragraphs();
}
ParagraphList const & Buffer::paragraphs() const
{
- return pimpl_->text.paragraphs();
+ return text().paragraphs();
}
}
-// candidate for move to BufferView
-// (at least some parts in the beginning of the func)
-//
// Uwe C. Schroeder
// changed to be public and have one parameter
-// if par = 0 normal behavior
-// else insert behavior
// Returns false if "\end_document" is not read (Asger)
bool Buffer::readBody(LyXLex & lex)
{
params().compressed = true;
}
- bool ret = readFile(filename, paragraphs().begin());
+ // remove dummy empty par
+ paragraphs().clear();
+ bool ret = readFile(filename, paragraphs().end());
// After we have read a file, we must ensure that the buffer
// language is set and used in the gui.
bool the_end = readBody(lex);
params().setPaperStuff();
+#warning Look here!
+#if 0
+ if (token == "\\end_document")
+ the_end_read = true;
+
if (!the_end) {
Alert::error(_("Document format failure"),
bformat(_("%1$s ended unexpectedly, which means"
" that it is probably corrupted."),
filename));
}
+#endif
pimpl_->file_fully_loaded = true;
return true;
}
class ErrorItem;
class FuncRequest;
class InsetBase;
+class InsetText;
class LyXFont;
class LyXLex;
class LyXRC;
///
LyXText & text() const;
+ ///
+ InsetBase & inset() const;
private:
/** Inserts a file into a document
string const text = bformat(_("The specified document template\n%1$s\ncould not be read."), file);
Alert::error(_("Could not read template"), text);
// no template, start with empty buffer
- b->paragraphs().push_back(Paragraph());
- b->paragraphs().begin()->layout(b->params().getLyXTextClass().defaultLayout());
}
- } else { // start with empty buffer
- b->paragraphs().push_back(Paragraph());
- b->paragraphs().begin()->layout(b->params().getLyXTextClass().defaultLayout());
}
if (!isNamed) {
#include <config.h>
-#include "buffer.h"
#include "BufferView.h"
+#include "buffer.h"
#include "cursor.h"
#include "debug.h"
#include "dispatchresult.h"
+#include "encoding.h"
#include "funcrequest.h"
#include "iterators.h"
+#include "language.h"
#include "lfuns.h"
+#include "lyxfont.h"
#include "lyxfunc.h" // only for setMessage()
#include "lyxrc.h"
#include "lyxrow.h"
#include "lyxtext.h"
#include "paragraph.h"
+#include "paragraph_funcs.h"
#include "insets/updatableinset.h"
#include "insets/insettabular.h"
LCursor::LCursor(BufferView & bv)
- : DocumentIterator(bv), anchor_(bv),
+ : DocumentIterator(), bv_(&bv), anchor_(),
cached_y_(0), x_target_(-1), selection_(false), mark_(false)
{}
DispatchResult LCursor::dispatch(FuncRequest const & cmd0)
{
+ if (empty())
+ return DispatchResult();
+
//lyxerr << "\nLCursor::dispatch: cmd: " << cmd0 << endl << *this << endl;
- BOOST_ASSERT(pos() <= lastpos());
- BOOST_ASSERT(idx() <= lastidx());
- BOOST_ASSERT(par() <= lastpar());
FuncRequest cmd = cmd0;
nopop_ = false;
- DocumentIterator orig = *this;
- disp_.update(true);
- disp_.val(NONE);
- while (size() != 1) {
- // the inset's dispatch() is supposed to reset the update and
- // val flags if necessary
- inset()->dispatch(*this, cmd);
-
- // "Mutate" the request for semi-handled requests that need
- // additional handling in outer levels.
- switch (disp_.val()) {
- case NONE:
- // the inset handled the event fully
- return DispatchResult(true, true);
- case FINISHED_LEFT:
- // the inset handled the event partially
- cmd = FuncRequest(LFUN_FINISHED_LEFT);
- break;
- case FINISHED_RIGHT:
- cmd = FuncRequest(LFUN_FINISHED_RIGHT);
- break;
- case FINISHED_UP:
- cmd = FuncRequest(LFUN_FINISHED_UP);
- break;
- case FINISHED_DOWN:
- cmd = FuncRequest(LFUN_FINISHED_DOWN);
- break;
- default:
- //lyxerr << "not handled on level " << depth()
- // << " val: " << disp_.val() << endl;
- break;
- }
- pop();
+ DocumentIterator safe = *this;
+
+ for ( ; size(); pop_back()) {
+ lyxerr << "\nLCursor::dispatch: cmd: " << cmd0 << endl << *this << endl;
+ BOOST_ASSERT(pos() <= lastpos());
+ BOOST_ASSERT(idx() <= lastidx());
+ BOOST_ASSERT(par() <= lastpar());
+
+ // The common case is 'LFUN handled, need update', so make the
+ // LFUN handler's life easier by assuming this as default value.
+ // The handler can reset the update and val flags if necessary.
+ disp_.update(true);
+ disp_.dispatched(true);
+ inset().dispatch(*this, cmd);
+ if (disp_.dispatched())
+ break;
}
- bv().text()->dispatch(*this, cmd);
- if (nopop_)
- setCursor(orig, false);
- //lyxerr << " result: " << res.val() << endl;
+ // it completely to get a 'bomb early' behaviour in case this
+ // object will be used again.
+ if (nopop_ || !disp_.dispatched())
+ DocumentIterator::operator=(safe);
return disp_;
}
bool LCursor::getStatus(FuncRequest const & cmd, FuncStatus & status)
{
lyxerr << "\nLCursor::getStatus: cmd: " << cmd << endl << *this << endl;
- DocumentIterator orig = *this;
- BOOST_ASSERT(pos() <= lastpos());
- BOOST_ASSERT(idx() <= lastidx());
- BOOST_ASSERT(par() <= lastpar());
- for ( ; size() != 0; pop_back()) {
- // the inset's getStatus() will return 'true' if it made
+ DocumentIterator safe = *this;
+ for ( ; size(); pop_back()) {
+ BOOST_ASSERT(pos() <= lastpos());
+ BOOST_ASSERT(idx() <= lastidx());
+ BOOST_ASSERT(par() <= lastpar());
+
+ // The inset's getStatus() will return 'true' if it made
// a definitive decision on whether it want to handle the
// request or not. The result of this decision is put into
// the 'status' parameter.
- bool const res = inset()->getStatus(*this, cmd, status);
- if (res) {
- setCursor(orig, false);
- return true;
- }
+ if (inset().getStatus(*this, cmd, status))
+ break;
}
- bool const res = bv().text()->getStatus(*this, cmd, status);
- setCursor(orig, false);
- return res;
+ DocumentIterator::operator=(safe);
+ return true;
}
BufferView & LCursor::bv() const
{
- return DocumentIterator::bv();
+ return *bv_;
}
-/*
-void LCursor::pop(int depth)
-{
- while (int(size()) > depth + 1)
- pop();
- lyxerr << "LCursor::pop() result: " << *this << endl;
-}
-*/
-
-
void LCursor::pop()
{
BOOST_ASSERT(size() >= 1);
}
-void LCursor::push(InsetBase * p)
+void LCursor::push(InsetBase & p)
{
push_back(CursorSlice(p));
}
-void LCursor::pushLeft(InsetBase * p)
+void LCursor::pushLeft(InsetBase & p)
{
BOOST_ASSERT(!empty());
//lyxerr << "Entering inset " << t << " left" << endl;
push(p);
- p->idxFirst(*this);
+ p.idxFirst(*this);
}
//lyxerr << "Leaving inset to the left" << endl;
if (depth() <= 1) {
if (depth() == 1)
- inset()->notifyCursorLeaves(idx());
+ inset().notifyCursorLeaves(idx());
return false;
}
- inset()->notifyCursorLeaves(idx());
+ inset().notifyCursorLeaves(idx());
pop();
return true;
}
//lyxerr << "Leaving inset to the right" << endl;
if (depth() <= 1) {
if (depth() == 1)
- inset()->notifyCursorLeaves(idx());
+ inset().notifyCursorLeaves(idx());
return false;
}
- inset()->notifyCursorLeaves(idx());
+ inset().notifyCursorLeaves(idx());
pop();
++pos();
return true;
{
BOOST_ASSERT(!empty());
for (int i = size() - 1; i >= 1; --i) {
- int res = operator[](i).inset()->currentMode();
+ int res = operator[](i).inset().currentMode();
if (res != MathInset::UNDECIDED_MODE)
return res;
}
{
BOOST_ASSERT(!empty());
if (size() > 1)
- cached_y_ = bv().top_y() + back().inset()->yo();
- //cached_y_ = back().inset()->yo();
+ cached_y_ = bv().top_y() + back().inset().yo();
+ //cached_y_ = back().inset().yo();
}
void LCursor::getDim(int & asc, int & des) const
{
- BOOST_ASSERT(!empty());
if (inMathed()) {
- BOOST_ASSERT(inset());
- BOOST_ASSERT(inset()->asMathInset());
- //inset()->asMathInset()->getCursorDim(asc, des);
+ BOOST_ASSERT(inset().asMathInset());
+ //inset().asMathInset()->getCursorDim(asc, des);
asc = 10;
des = 10;
- } else {
+ } else if (inTexted()) {
Row const & row = textRow();
asc = row.baseline();
des = row.height() - asc;
+ } else {
+ lyxerr << "should this happen?" << endl;
+ asc = 10;
+ des = 10;
}
}
void LCursor::getPos(int & x, int & y) const
{
- BOOST_ASSERT(!empty());
x = 0;
y = 0;
- if (size() == 1) {
- x = bv().text()->cursorX(front());
- y = bv().text()->cursorY(front());
- } else {
- if (!inset()) {
- lyxerr << "#### LCursor::getPos: " << *this << endl;
- BOOST_ASSERT(inset());
- }
- inset()->getCursorPos(back(), x, y);
- // getCursorPos gives _screen_ coordinates. We need to add
- // top_y to get document coordinates. This is hidden in cached_y_.
- //y += cached_y_ - inset()->yo();
- // The rest is non-obvious. The reason we have to have these
- // extra computation is that the getCursorPos() calls rely
- // on the inset's own knowledge of its screen position.
- // If we scroll up or down in a big enough increment,
- // inset->draw() is not called: this doesn't update
- // inset.yo_, so getCursor() returns an old value.
- // Ugly as you like.
- }
- //lyxerr << "#### LCursor::getPos: " << *this
- // << " x: " << x << " y: " << y << endl;
+ if (!empty())
+ inset().getCursorPos(back(), x, y);
+ // getCursorPos gives _screen_ coordinates. We need to add
+ // top_y to get document coordinates. This is hidden in cached_y_.
+ //y += cached_y_ - inset().yo();
+ // The rest is non-obvious. The reason we have to have these
+ // extra computation is that the getCursorPos() calls rely
+ // on the inset's own knowledge of its screen position.
+ // If we scroll up or down in a big enough increment,
+ // inset->draw() is not called: this doesn't update
+ // inset.yo_, so getCursor() returns an old value.
+ // Ugly as you like.
}
void LCursor::info(std::ostream & os) const
{
for (int i = 1, n = depth(); i < n; ++i) {
- operator[](i).inset()->infoize(os);
+ operator[](i).inset().infoize(os);
os << " ";
}
if (pos() != 0)
LCursor::row_type & r1, LCursor::row_type & r2,
LCursor::col_type & c1, LCursor::col_type & c2)
{
- InsetBase * p = i1.inset();
- c1 = p->col(i1.idx_);
- c2 = p->col(i2.idx_);
+ InsetBase & p = i1.inset();
+ c1 = p.col(i1.idx_);
+ c2 = p.col(i2.idx_);
if (c1 > c2)
swap(c1, c2);
- r1 = p->row(i1.idx_);
- r2 = p->row(i2.idx_);
+ r1 = p.row(i1.idx_);
+ r2 = p.row(i2.idx_);
if (r1 > r2)
swap(r1, r2);
}
CursorSlice i2 = selEnd();
if (i1.idx_ == i2.idx_) {
- if (i1.inset()->asMathInset()) {
+ if (i1.inset().asMathInset()) {
MathArray::const_iterator it = i1.cell().begin();
return asString(MathArray(it + i1.pos_, it + i2.pos_));
} else {
region(i1, i2, r1, r2, c1, c2);
string data;
- if (i1.inset()->asMathInset()) {
+ if (i1.inset().asMathInset()) {
for (row_type row = r1; row <= r2; ++row) {
if (row > r1)
data += "\\\\";
CursorSlice const & i1 = selBegin();
CursorSlice const & i2 = selEnd();
#warning FIXME
- if (i1.inset()->asMathInset()) {
+ if (i1.inset().asMathInset()) {
if (i1.idx_ == i2.idx_) {
i1.cell().erase(i1.pos_, i2.pos_);
} else {
bool LCursor::isInside(InsetBase const * p)
{
for (unsigned i = 0; i < depth(); ++i)
- if (operator[](i).inset() == p)
+ if (&operator[](i).inset() == p)
return true;
return false;
}
// we can't move into anything new during selection
if (depth() == anchor_.size())
return false;
- if (!ptr_cmp(t.nucleus(), anchor_[depth()].inset()))
+ if (!ptr_cmp(t.nucleus(), &anchor_[depth()].inset()))
return false;
return true;
// anchor might be deeper, should have same path then
for (size_t i = 0; i < cursor.size(); ++i)
- if (cursor[i].inset() != anchor[i].inset())
+ if (&cursor[i].inset() != &anchor[i].inset())
return false;
// position should be ok.
void LCursor::insert(string const & str)
{
lyxerr << "LCursor::insert str '" << str << "'" << endl;
- selClearOrDel();
-#if 0
for (string::const_iterator it = str.begin(); it != str.end(); ++it)
- plainInsert(MathAtom(new MathCharInset(*it)));
-#else
- MathArray ar;
- asArray(str, ar);
- insert(ar);
-#endif
+ insert(*it);
}
void LCursor::insert(char c)
{
//lyxerr << "LCursor::insert char '" << c << "'" << endl;
- selClearOrDel();
- plainInsert(MathAtom(new MathCharInset(c)));
+ BOOST_ASSERT(!empty());
+ if (inMathed()) {
+ selClearOrDel();
+ plainInsert(MathAtom(new MathCharInset(c)));
+ } else {
+ text()->insertChar(*this, c);
+ }
}
posLeft();
// be careful here: don't use 'pushLeft(t)' as this we need to
// push the clone, not the original
- pushLeft(nextAtom().nucleus());
+ pushLeft(*nextInset());
paste(safe);
}
}
}
if (pos() == 0) {
- if (inset()->nargs() == 1 && depth() == 1 && lastpos() == 0)
+ if (inset().nargs() == 1 && depth() == 1 && lastpos() == 0)
return false;
pullArg();
return true;
}
// delete empty cells if possible
- if (pos() == lastpos() && inset()->idxDelete(idx()))
+ if (pos() == lastpos() && inset().idxDelete(idx()))
return true;
// special behaviour when in last position of cell
if (pos() == lastpos()) {
- bool one_cell = inset()->nargs() == 1;
+ bool one_cell = inset().nargs() == 1;
if (one_cell && depth() == 1 && lastpos() == 0)
return false;
// remove markup
if (one_cell)
pullArg();
else
- inset()->idxGlue(idx());
+ inset().idxGlue(idx());
return true;
}
- if (pos() != lastpos() && inset()->nargs() > 0) {
+ if (pos() != lastpos() && inset().nargs() > 0) {
selection() = true;
++pos();
} else {
asArray(grabAndEraseSelection(), t.nucleus()->cell(c));
insert(t);
posLeft();
- pushLeft(nextAtom().nucleus());
+ pushLeft(*nextInset());
}
MathHullInset * LCursor::formula() const
{
for (int i = size() - 1; i >= 1; --i) {
- MathInset * inset = operator[](i).inset()->asMathInset();
+ MathInset * inset = operator[](i).inset().asMathInset();
if (inset && inset->asHullInset())
return static_cast<MathHullInset *>(inset);
}
MathGridInset * LCursor::enclosingGrid(idx_type & idx) const
{
for (MathInset::difference_type i = depth() - 1; i >= 0; --i) {
- MathInset * m = operator[](i).inset()->asMathInset();
+ MathInset * m = operator[](i).inset().asMathInset();
if (!m)
return 0;
MathGridInset * p = m->asGridInset();
if (idx() >= nargs()) {
lyxerr << "this should not really happen - 1: "
<< idx() << ' ' << nargs()
- << " in: " << inset() << endl;
+ << " in: " << &inset() << endl;
}
idx() = min(idx(), lastidx());
<< pos() << ' ' << lastpos() << " in idx: " << idx()
<< " in atom: '";
WriteStream wi(lyxerr, false, true);
- inset()->asMathInset()->write(wi);
+ inset().asMathInset()->write(wi);
lyxerr << endl;
}
pos() = min(pos(), lastpos());
}
// try current cell for e.g. text insets
- if (inset()->idxUpDown2(*this, up))
+ if (inset().idxUpDown2(*this, up))
return true;
//xarray().boundingBox(xlow, xhigh, ylow, yhigh);
// try to find an inset that knows better then we
while (1) {
- //lyxerr << "updown: We are in " << inset() << " idx: " << idx() << endl;
+ //lyxerr << "updown: We are in " << &inset() << " idx: " << idx() << endl;
// ask inset first
- if (inset()->idxUpDown(*this, up)) {
+ if (inset().idxUpDown(*this, up)) {
// try to find best position within this inset
if (!selection())
bruteFind2(xo, yo);
bool LCursor::bruteFind(int x, int y, int xlow, int xhigh, int ylow, int yhigh)
{
- DocumentIterator best_cursor(bv());
+ DocumentIterator best_cursor;
double best_dist = 1e10;
- DocumentIterator it = bufferBegin(bv());
- DocumentIterator et = bufferEnd();
+ DocumentIterator it = insetBegin(bv().buffer()->inset());
+ DocumentIterator et = insetEnd();
while (1) {
// avoid invalid nesting when selecting
if (!selection() || positionable(it, anchor_)) {
int xo, yo;
CursorSlice & cur = it.back();
- cur.inset()->getCursorPos(cur, xo, yo);
+ cur.inset().getCursorPos(cur, xo, yo);
if (xlow <= xo && xo <= xhigh && ylow <= yo && yo <= yhigh) {
double d = (x - xo) * (x - xo) + (y - yo) * (y - yo);
//lyxerr << "x: " << x << " y: " << y << " d: " << endl;
for (int i = 0; ; ++i) {
int xo, yo;
CursorSlice & cur = it.back();
- cur.inset()->getCursorPos(cur, xo, yo);
+ cur.inset().getCursorPos(cur, xo, yo);
double d = (x - xo) * (x - xo) + (y - yo) * (y - yo);
// '<=' in order to take the last possible position
// this is important for clicking behind \sum in e.g. '\sum_i a'
return result;
}
-#warning an mathed?
+#warning and mathed?
return string();
}
info(os);
return os.str();
}
- return text() ? text()->currentState(*this) : string();
+
+ if (inTexted())
+ return text()->currentState(*this);
+
+ return string();
}
}
-void LCursor::undispatched()
+Encoding const * LCursor::getEncoding() const
{
- disp_.dispatched(false);
+ if (empty())
+ return 0;
+ if (!bv().buffer())
+ return 0;
+ int s = 0;
+ // go up until first non-0 text is hit
+ // (innermost text is 0 in mathed)
+ for (s = size() - 1; s >= 0; --s)
+ if (operator[](s).text())
+ break;
+ CursorSlice const & sl = operator[](s);
+ LyXText & text = *sl.text();
+ ParagraphList::iterator pit = text.getPar(sl.par());
+ LyXFont font = pit->getFont(
+ bv().buffer()->params(), sl.pos(), outerFont(pit, text.paragraphs()));
+ return font.language()->encoding();
}
-void LCursor::dispatched(dispatch_result_t res)
+void LCursor::undispatched()
{
- disp_.val(res);
+ disp_.dispatched(false);
}
{
disp_.update(false);
}
-
-
-void LCursor::noPop()
-{
- nopop_ = true;
-}
#include <iosfwd>
#include <vector>
-class UpdatableInset;
-class DispatchResult;
+class BufferView;
class FuncStatus;
class FuncRequest;
-class InsetTabular;
// these should go
class MathHullInset;
class MathUnknownInset;
class MathGridInset;
+class Encoding;
/// The cursor class describes the position of a cursor within a document.
// (or maybe private inheritance) at some point of time.
class LCursor : public DocumentIterator {
public:
-
/// create the cursor of a BufferView
explicit LCursor(BufferView & bv);
+
/// dispatch from innermost inset upwards
DispatchResult dispatch(FuncRequest const & cmd);
/// are we willing to handle this event?
bool getStatus(FuncRequest const & cmd, FuncStatus & flag);
/// add a new cursor slice
- void push(InsetBase * inset);
+ void push(InsetBase & inset);
/// add a new cursor slice, place cursor on left end
- void pushLeft(InsetBase * inset);
+ void pushLeft(InsetBase & inset);
/// pop one level off the cursor
void pop();
/// pop one slice off the cursor stack and go left
void replaceWord(std::string const & replacestring);
/// update our view
void update();
- /// set dispatch result
- void dispatched(dispatch_result_t res);
- /// assume event was not (yet) dispatched
+ /// the event was not (yet) dispatched
void undispatched();
/// don't call update() when done
void noUpdate();
/// output
friend std::ostream & operator<<(std::ostream & os, LCursor const & cur);
+
public:
+ ///
+ BufferView * bv_;
//private:
/// the anchor position
DocumentIterator anchor_;
* shorter than x()
*/
int x_target_;
- // do we have a selection?
+ /// do we have a selection?
bool selection_;
- // are we on the way to get one?
+ /// are we on the way to get one?
bool mark_;
- ///
+ /// Reset cursor to the value it had at the beginning of the latest
+ // dispatch() once the event is fully handled.
bool nopop_;
//
int macroNamePos();
/// can we enter the inset?
bool openable(MathAtom const &) const;
+ ///
+ Encoding const * getEncoding() const;
};
#endif // LYXCURSOR_H
{}
-CursorSlice::CursorSlice(InsetBase * p)
- : inset_(p), idx_(0), par_(0), pos_(0), boundary_(false)
+CursorSlice::CursorSlice(InsetBase & p)
+ : inset_(&p), idx_(0), par_(0), pos_(0), boundary_(false)
{
///BOOST_ASSERT(inset_);
}
CursorSlice::pos_type CursorSlice::lastpos() const
{
- return (inset_ && inset_->asMathInset()) ? cell().size() : paragraph().size();
+ BOOST_ASSERT(inset_);
+ return inset_->asMathInset() ? cell().size() : paragraph().size();
}
MathInset * CursorSlice::asMathInset() const
{
- return inset_ ? inset_->asMathInset() : 0;
+ BOOST_ASSERT(inset_);
+ return inset_->asMathInset();
}
UpdatableInset * CursorSlice::asUpdatableInset() const
{
- return inset_ ? inset_->asUpdatableInset() : 0;
+ BOOST_ASSERT(inset_);
+ return inset_->asUpdatableInset();
}
LyXText * CursorSlice::text() const
{
- return inset_ ? inset_->getText(idx_) : 0;
+ BOOST_ASSERT(inset_);
+ return inset_->getText(idx_);
}
std::ostream & operator<<(std::ostream & os, CursorSlice const & item)
{
- os
+ return os
<< "inset: " << item.inset_
// << " text: " << item.text()
<< " idx: " << item.idx_
// << " x: " << item.inset_->x()
// << " y: " << item.inset_->y()
;
- return os;
}
///
CursorSlice();
///
- explicit CursorSlice(InsetBase *);
+ explicit CursorSlice(InsetBase &);
/// the current inset
- InsetBase * inset() const { return inset_; }
+ InsetBase & inset() const { return *inset_; }
/// return the cell this cursor is in
idx_type idx() const;
/// return the cell this cursor is in
#ifndef DISPATCH_RESULT_H
#define DISPATCH_RESULT_H
-/** Dispatch result codes
- NONE = no special action required
- FINISHED_LEFT = the cursor leaves the inset to the LEFT
- as consequence of this action
- FINISHED_RIGHT = FINISHED, but move the cursor RIGHT from
- the inset.
- FINISHED_UP = FINISHED, but move the cursor UP from
- the inset.
- FINISHED_DOWN = FINISHED, but move the cursor DOWN from
- the inset.
-*/
-enum dispatch_result_t {
- NONE = 0,
- FINISHED_LEFT,
- FINISHED_RIGHT,
- FINISHED_UP,
- FINISHED_DOWN
-};
-
-
-/** \c DispatchResult is a wrapper for dispatch_result_t.
- * It can be forward-declared and passed as a function argument without
- * having to expose insetbase.h.
- */
+/// Maybe this can go entirely
class DispatchResult {
public:
- DispatchResult()
- : dispatched_(false), val_(NONE) {}
- explicit
- DispatchResult(bool dis)
- : dispatched_(dis), update_(false), val_(NONE) {}
- DispatchResult(bool dis, bool update)
- : dispatched_(dis), update_(update), val_(NONE) {}
- DispatchResult(bool dis, dispatch_result_t val)
- : dispatched_(dis), update_(true), val_(val) {}
- dispatch_result_t val() const { return val_; }
- void val(dispatch_result_t drt) {
- val_ = drt;
- }
- bool dispatched() const {
- return dispatched_;
- }
- void dispatched(bool dis) {
- dispatched_ = dis;
- }
- bool update() const {
- return update_;
- }
- void update(bool up) {
- update_ = up;
- }
+ ///
+ DispatchResult() : dispatched_(false), update_(false) {}
+ ///
+ DispatchResult(bool disp, bool upd) : dispatched_(disp), update_(upd) {}
+ //
+ bool dispatched() const { return dispatched_; }
+ ///
+ void dispatched(bool disp) { dispatched_ = disp; }
+ ///
+ bool update() const { return update_; }
+ ///
+ void update(bool up) { update_ = up; }
private:
+ /// was the event fully dispatched?
bool dispatched_;
+ /// do we need to redraw the screen afterwards?
bool update_;
- dispatch_result_t val_;
};
-
-inline
-bool operator==(DispatchResult const & lhs, DispatchResult const & rhs)
-{
- return lhs.dispatched() == rhs.dispatched() && lhs.val() == rhs.val();
-}
-
-
-inline
-bool operator!=(DispatchResult const & lhs, DispatchResult const & rhs)
-{
- return !(lhs == rhs);
-}
-
#endif // DISPATCH_RESULT_H
#include "dociterator.h"
-#include "BufferView.h"
#include "debug.h"
#include "lyxtext.h"
#include "lyxrow.h"
#include <boost/assert.hpp>
-
-DocumentIterator::DocumentIterator()
- : bv_(0)
-{}
-
-
-DocumentIterator::DocumentIterator(BufferView & bv)
- : std::vector<CursorSlice>(1), bv_(&bv)
-{}
-
-
InsetBase * DocumentIterator::nextInset()
{
if (pos() == lastpos())
LyXText * DocumentIterator::text() const
{
- return size() > 1 ? top().text() : bv().text();
+ return top().text();
}
Paragraph & DocumentIterator::paragraph()
{
BOOST_ASSERT(inTexted());
- return size() > 1 ? top().paragraph() : *bv().text()->getPar(par());
+ return top().paragraph();
}
Paragraph const & DocumentIterator::paragraph() const
{
BOOST_ASSERT(inTexted());
- return size() > 1 ? top().paragraph() : *bv().text()->getPar(par());
+ return top().paragraph();
}
DocumentIterator::idx_type DocumentIterator::lastidx() const
{
- return size() > 1 ? top().lastidx() : 0;
+ return top().lastidx();
}
size_t DocumentIterator::nargs() const
{
// assume 1x1 grid for main text
- return size() > 1 ? top().nargs() : 1;
+ return top().nargs();
}
size_t DocumentIterator::ncols() const
{
// assume 1x1 grid for main text
- return size() > 1 ? top().ncols() : 1;
+ return top().ncols();
}
size_t DocumentIterator::nrows() const
{
// assume 1x1 grid for main text
- return size() > 1 ? top().nrows() : 1;
+ return top().nrows();
}
DocumentIterator::row_type DocumentIterator::row() const
{
- return size() > 1 ? top().row() : 0;
+ return top().row();
}
DocumentIterator::col_type DocumentIterator::col() const
{
- return size() > 1 ? top().col() : 0;
+ return top().col();
}
MathArray const & DocumentIterator::cell() const
{
- BOOST_ASSERT(size() > 1);
+ BOOST_ASSERT(inMathed());
return top().cell();
}
MathArray & DocumentIterator::cell()
{
- BOOST_ASSERT(size() > 1);
+ BOOST_ASSERT(inMathed());
return top().cell();
}
bool DocumentIterator::inMathed() const
{
- return size() > 1 && inset()->inMathed();
+ return !empty() && inset().inMathed();
}
bool DocumentIterator::inTexted() const
{
- return !inMathed();
+ return !empty() && !inset().inMathed();
}
LyXText * DocumentIterator::innerText() const
{
BOOST_ASSERT(!empty());
- if (size() > 1) {
- // go up until first non-0 text is hit
- // (innermost text is 0 in mathed)
- for (int i = size() - 1; i >= 1; --i)
- if (operator[](i).text())
- return operator[](i).text();
- }
- return bv().text();
-}
-
-
-CursorSlice const & DocumentIterator::innerTextSlice() const
-{
- BOOST_ASSERT(!empty());
- if (size() > 1) {
- // go up until first non-0 text is hit
- // (innermost text is 0 in mathed)
- for (int i = size() - 1; i >= 1; --i)
- if (operator[](i).text())
- return operator[](i);
- }
- return operator[](0);
+ // go up until first non-0 text is hit
+ // (innermost text is 0 in mathed)
+ for (int i = size() - 1; i >= 0; --i)
+ if (operator[](i).text())
+ return operator[](i).text();
+ return 0;
}
InsetBase * DocumentIterator::innerInsetOfType(int code) const
{
- for (int i = size() - 1; i >= 1; --i)
+ for (int i = size() - 1; i >= 0; --i)
if (operator[](i).inset_->lyxCode() == code)
return operator[](i).inset_;
return 0;
if (n && n->isActive()) {
//lyxerr << "... descend" << std::endl;
- push_back(CursorSlice(n));
+ push_back(CursorSlice(*n));
return;
}
++top.idx();
top.par() = 0;
top.pos() = 0;
- if (top.inset() && top.inset()->validCell(top.idx())) {
+ if (top.inset().validCell(top.idx())) {
//lyxerr << " ... ok" << std::endl;
return;
}
if (n && n->isActive()) {
lyxerr << "... descend" << std::endl;
- push_back(CursorSlice(n));
+ push_back(CursorSlice(*n));
return;
}
++top.idx();
top.par() = 0;
top.pos() = 0;
- if (top.inset() && top.inset()->validCell(top.idx())) {
+ if (top.inset().validCell(top.idx())) {
lyxerr << " ... ok" << std::endl;
return;
}
}
-DocumentIterator bufferBegin(BufferView & bv)
-{
- return DocumentIterator(bv);
-}
-
-
-DocumentIterator bufferEnd()
-{
- return DocumentIterator();
-}
-
-
-DocumentIterator insetBegin(BufferView & bv, InsetBase * p)
+DocumentIterator insetBegin(InsetBase & inset)
{
- DocumentIterator it(bv);
- it.back() = CursorSlice(p);
+ DocumentIterator it;
+ it.push_back(CursorSlice(inset));
return it;
}
std::ostream & operator<<(std::ostream & os, DocumentIterator const & dit)
{
- os << "bv: " << &dit.bv() << "\n";
for (size_t i = 0, n = dit.size(); i != n; ++i)
os << " " << dit.operator[](i) << "\n";
return os;
DocumentIterator
-StableDocumentIterator::asDocumentIterator(BufferView & bv) const
+StableDocumentIterator::asDocumentIterator(InsetBase * inset) const
{
// this function re-creates the cache of inset pointers
//lyxerr << "converting:\n" << *this << std::endl;
- DocumentIterator dit(bv);
- dit.clear();
- InsetBase * inset = 0;
+ DocumentIterator dit;
for (size_t i = 0, n = data_.size(); i != n; ++i) {
dit.push_back(data_[i]);
dit.back().inset_ = inset;
#include <vector>
#include <iosfwd>
-class BufferView;
-class MathAtom;
class LyXText;
+class MathAtom;
class Paragraph;
class Row;
typedef CursorSlice::col_type col_type;
public:
- ///
- DocumentIterator();
- ///
- explicit DocumentIterator(BufferView & bv);
- ///
- BufferView & bv() const { return *bv_; }
-
//
// access to slice at tip
//
/// how many nested insets do we have?
size_t depth() const { return size(); }
/// the containing inset
- InsetBase * inset() const { return back().inset(); }
+ InsetBase & inset() const { return back().inset(); }
/// return the cell of the inset this cursor is in
idx_type idx() const { return back().idx(); }
/// return the cell of the inset this cursor is in
///
LyXText * text() const;
///
- CursorSlice const & innerTextSlice() const;
- ///
InsetBase * innerInsetOfType(int code) const;
///
LyXText * innerText() const;
/// output
friend std::ostream &
operator<<(std::ostream & os, DocumentIterator const & cur);
-
-private:
- ///
- BufferView * bv_;
};
///
-DocumentIterator bufferBegin(BufferView & bv);
-///
-DocumentIterator bufferEnd();
-///
-DocumentIterator insetBegin(BufferView & bv, InsetBase * inset);
+DocumentIterator insetBegin(InsetBase & inset);
///
DocumentIterator insetEnd();
/// non-explicit intended
StableDocumentIterator(const DocumentIterator & it);
///
- DocumentIterator asDocumentIterator(BufferView & bv) const;
+ DocumentIterator asDocumentIterator(InsetBase * start) const;
///
size_t size() const { return data_.size(); }
///
return 0;
case LFUN_INSET_CAPTION: {
- UpdatableInset * up = bv->cursor().inset()
- ? bv->cursor().inset()->asUpdatableInset() : 0;
+ UpdatableInset * up = bv->cursor().inset().asUpdatableInset();
if (!up) {
auto_ptr<InsetCaption> inset(new InsetCaption(params));
inset->setOwner(up);
// maybe we have to clear the screen at the bottom
int const y2 = workarea().workHeight();
- if (y < y2 && !bv.text()->isInInset()) {
+ if (y < y2 && bv.text()->isMainText()) {
workarea().getPainter().fillRectangle(0, y,
workarea().workWidth(), y2 - y,
LColor::bottomarea);
-void InsetBase::dispatch(LCursor & cur, FuncRequest const & cmd)
+void InsetBase::dispatch(LCursor & cur, FuncRequest & cmd)
{
priv_dispatch(cur, cmd);
}
-void InsetBase::priv_dispatch(LCursor & cur, FuncRequest const &)
+void InsetBase::priv_dispatch(LCursor & cur, FuncRequest &)
{
cur.noUpdate();
cur.undispatched();
virtual bool inMathed() const { return false; }
// the real dispatcher
- void dispatch(LCursor & cur, FuncRequest const & cmd);
+ void dispatch(LCursor & cur, FuncRequest & cmd);
/// do we want to handle this event?
virtual bool getStatus(LCursor & cur, FuncRequest const & cmd,
FuncStatus & status);
virtual void addPreview(lyx::graphics::PreviewLoader &) const {}
protected:
// the real dispatcher
- virtual void priv_dispatch(LCursor & cur, FuncRequest const & cmd);
+ virtual void priv_dispatch(LCursor & cur, FuncRequest & cmd);
public:
/// returns LyX code associated with the inset. Used for TOC, ...)
virtual Code lyxCode() const { return NO_CODE; }
}
-void InsetBibitem::priv_dispatch(LCursor & cur, FuncRequest const & cmd)
+void InsetBibitem::priv_dispatch(LCursor & cur, FuncRequest & cmd)
{
switch (cmd.action) {
std::string const getBibLabel() const;
protected:
///
- virtual void priv_dispatch(LCursor & cur, FuncRequest const & cmd);
+ virtual void priv_dispatch(LCursor & cur, FuncRequest & cmd);
private:
///
int counter;
}
-void InsetBibtex::priv_dispatch(LCursor & cur, FuncRequest const & cmd)
+void InsetBibtex::priv_dispatch(LCursor & cur, FuncRequest & cmd)
{
switch (cmd.action) {
bool delDatabase(std::string const &);
protected:
///
- virtual void priv_dispatch(LCursor & cur, FuncRequest const & cmd);
+ virtual void priv_dispatch(LCursor & cur, FuncRequest & cmd);
};
#endif // INSET_BIBTEX_H
}
-void InsetBox::priv_dispatch(LCursor & cur, FuncRequest const & cmd)
+void InsetBox::priv_dispatch(LCursor & cur, FuncRequest & cmd)
{
switch (cmd.action) {
};
protected:
///
- virtual void priv_dispatch(LCursor & cur, FuncRequest const & cmd);
+ virtual void priv_dispatch(LCursor & cur, FuncRequest & cmd);
private:
friend class InsetBoxParams;
}
-void InsetBranch::priv_dispatch(LCursor & cur, FuncRequest const & cmd)
+void InsetBranch::priv_dispatch(LCursor & cur, FuncRequest & cmd)
{
switch (cmd.action) {
case LFUN_INSET_MODIFY: {
protected:
///
- virtual void priv_dispatch(LCursor & cur, FuncRequest const & cmd);
+ virtual void priv_dispatch(LCursor & cur, FuncRequest & cmd);
private:
friend class InsetBranchParams;
}
-void InsetCharStyle::priv_dispatch(LCursor & cur, FuncRequest const & cmd)
+void InsetCharStyle::priv_dispatch(LCursor & cur, FuncRequest & cmd)
{
setStatus(Inlined);
switch (cmd.action) {
protected:
///
- virtual void priv_dispatch(LCursor & cur, FuncRequest const & cmd);
+ virtual void priv_dispatch(LCursor & cur, FuncRequest & cmd);
private:
friend class InsetCharStyleParams;
}
-void InsetCollapsable::lfunMouseRelease(LCursor & cur, FuncRequest const & cmd)
+void InsetCollapsable::lfunMouseRelease(LCursor & cur, FuncRequest & cmd)
{
if (cmd.button() == mouse_button::button3) {
showInsetDialog(&cur.bv());
if (hitButton(cmd1)) {
lyxerr << "InsetCollapsable::lfunMouseRelease 2" << endl;
setStatus(Collapsed);
- cur.dispatched(FINISHED_RIGHT);
+ cmd = FuncRequest(LFUN_FINISHED_RIGHT);
break;
}
lyxerr << "InsetCollapsable::lfunMouseRelease 3" << endl;
}
-bool InsetCollapsable::hitButton(FuncRequest const & cmd) const
+bool InsetCollapsable::hitButton(FuncRequest & cmd) const
{
return button_dim.contains(cmd.x, cmd.y);
}
void InsetCollapsable::edit(LCursor & cur, bool left)
{
//lyxerr << "InsetCollapsable: edit left/right" << endl;
- cur.push(this);
+ cur.push(*this);
inset.edit(cur, left);
open();
}
InsetBase * InsetCollapsable::editXY(LCursor & cur, int x, int y)
{
- cur.push(this);
+ cur.push(*this);
//lyxerr << "InsetCollapsable: edit xy" << endl;
if (status_ == Collapsed) {
setStatus(Open);
}
-void InsetCollapsable::priv_dispatch(LCursor & cur, FuncRequest const & cmd)
+void InsetCollapsable::priv_dispatch(LCursor & cur, FuncRequest & cmd)
{
//lyxerr << "\nInsetCollapsable::priv_dispatch (begin): cmd: " << cmd
// << " button y: " << button_dim.y2 << endl;
break;
}
setStatus(Collapsed);
- cur.dispatched(FINISHED_RIGHT);
+ cmd = FuncRequest(LFUN_FINISHED_RIGHT);
break;
default:
///
void drawSelection(PainterInfo & pi, int x, int y) const;
///
- bool hitButton(FuncRequest const &) const;
+ bool hitButton(FuncRequest &) const;
///
std::string const getNewLabel(std::string const & l) const;
///
protected:
///
- void priv_dispatch(LCursor & cur, FuncRequest const & cmd);
+ void priv_dispatch(LCursor & cur, FuncRequest & cmd);
///
void dimension_collapsed(Dimension &) const;
///
private:
///
- void lfunMouseRelease(LCursor & cur, FuncRequest const & cmd);
+ void lfunMouseRelease(LCursor & cur, FuncRequest & cmd);
public:
///
}
-void InsetCommand::priv_dispatch(LCursor & cur, FuncRequest const & cmd)
+void InsetCommand::priv_dispatch(LCursor & cur, FuncRequest & cmd)
{
switch (cmd.action) {
case LFUN_INSET_MODIFY: {
protected:
///
- void priv_dispatch(LCursor & cur, FuncRequest const & cmd);
+ void priv_dispatch(LCursor & cur, FuncRequest & cmd);
///
std::string const getCommand() const { return p_.getCommand(); }
///
}
-void InsetERT::priv_dispatch(LCursor & cur, FuncRequest const & cmd)
+void InsetERT::priv_dispatch(LCursor & cur, FuncRequest & cmd)
{
//lyxerr << "\nInsetERT::priv_dispatch (begin): cmd: " << cmd << endl;
switch (cmd.action) {
bool forceDefaultParagraphs(InsetBase const *) const { return true; }
protected:
///
- virtual void priv_dispatch(LCursor & cur, FuncRequest const & cmd);
+ virtual void priv_dispatch(LCursor & cur, FuncRequest & cmd);
private:
///
void init();
}
-void InsetExternal::priv_dispatch(LCursor & cur, FuncRequest const & cmd)
+void InsetExternal::priv_dispatch(LCursor & cur, FuncRequest & cmd)
{
switch (cmd.action) {
protected:
///
- void priv_dispatch(LCursor & cur, FuncRequest const & cmd);
+ void priv_dispatch(LCursor & cur, FuncRequest & cmd);
private:
/** This method is connected to the graphics loader, so we are
* informed when the image has been loaded.
}
-void InsetFloat::priv_dispatch(LCursor & cur, FuncRequest const & cmd)
+void InsetFloat::priv_dispatch(LCursor & cur, FuncRequest & cmd)
{
switch (cmd.action) {
///
InsetFloatParams const & params() const { return params_; }
protected:
- virtual void priv_dispatch(LCursor & cur, FuncRequest const & cmd);
+ virtual void priv_dispatch(LCursor & cur, FuncRequest & cmd);
private:
///
InsetFloatParams params_;
}
-void InsetGraphics::priv_dispatch(LCursor & cur, FuncRequest const & cmd)
+void InsetGraphics::priv_dispatch(LCursor & cur, FuncRequest & cmd)
{
switch (cmd.action) {
case LFUN_INSET_MODIFY: {
void edit(LCursor & cur, bool left);
protected:
///
- void priv_dispatch(LCursor & cur, FuncRequest const & cmd);
+ void priv_dispatch(LCursor & cur, FuncRequest & cmd);
private:
///
friend class InsetGraphicsMailer;
}
-void InsetInclude::priv_dispatch(LCursor & cur, FuncRequest const & cmd)
+void InsetInclude::priv_dispatch(LCursor & cur, FuncRequest & cmd)
{
switch (cmd.action) {
void addPreview(lyx::graphics::PreviewLoader &) const;
protected:
///
- virtual void priv_dispatch(LCursor & cur, FuncRequest const & cmd);
+ virtual void priv_dispatch(LCursor & cur, FuncRequest & cmd);
private:
/// Slot receiving a signal that the preview is ready to display.
void statusChanged() const;
} // namespace anon
-void InsetLabel::priv_dispatch(LCursor & cur, FuncRequest const & cmd)
+void InsetLabel::priv_dispatch(LCursor & cur, FuncRequest & cmd)
{
switch (cmd.action) {
OutputParams const &) const;
protected:
///
- virtual void priv_dispatch(LCursor & cur, FuncRequest const & cmd);
+ virtual void priv_dispatch(LCursor & cur, FuncRequest & cmd);
};
#endif
}
-void InsetNote::priv_dispatch(LCursor & cur, FuncRequest const & cmd)
+void InsetNote::priv_dispatch(LCursor & cur, FuncRequest & cmd)
{
switch (cmd.action) {
InsetNoteParams const & params() const { return params_; }
protected:
///
- virtual void priv_dispatch(LCursor & cur, FuncRequest const & cmd);
+ virtual void priv_dispatch(LCursor & cur, FuncRequest & cmd);
private:
friend class InsetNoteParams;
{}
-void InsetRef::priv_dispatch(LCursor & cur, FuncRequest const & cmd)
+void InsetRef::priv_dispatch(LCursor & cur, FuncRequest & cmd)
{
switch (cmd.action) {
case LFUN_MOUSE_PRESS:
void validate(LaTeXFeatures & features) const;
protected:
///
- void priv_dispatch(LCursor & cur, FuncRequest const & cmd);
+ void priv_dispatch(LCursor & cur, FuncRequest & cmd);
private:
///
bool isLatex;
cur.selection() = false;
resetPos(cur);
cur.bv().fitCursor();
- cur.push(this);
+ cur.push(*this);
cur.idx() = cell;
}
{
//lyxerr << "InsetTabular::editXY: " << this << endl;
cur.selection() = false;
- cur.push(this);
+ cur.push(*this);
return setPos(cur, x, y);
//int xx = cursorx_ - xo_ + tabular.getBeginningOfTextInCell(actcell);
}
-void InsetTabular::priv_dispatch(LCursor & cur, FuncRequest const & cmd)
+void InsetTabular::priv_dispatch(LCursor & cur, FuncRequest & cmd)
{
lyxerr << "# InsetTabular::dispatch: cmd: " << cmd << endl;
//lyxerr << " cur:\n" << cur << endl;
case LFUN_RIGHTSEL:
case LFUN_RIGHT:
cell(cur.idx()).dispatch(cur, cmd);
- cur.dispatched(NONE); // override the cell's result
if (sl == cur.top())
isRightToLeft(cur) ? movePrevCell(cur) : moveNextCell(cur);
- if (sl == cur.top())
- cur.dispatched(FINISHED_RIGHT);
+ if (sl == cur.top()) {
+ cmd = FuncRequest(LFUN_FINISHED_RIGHT);
+ cur.undispatched();
+ }
break;
case LFUN_LEFTSEL:
case LFUN_LEFT:
cell(cur.idx()).dispatch(cur, cmd);
- cur.dispatched(NONE); // override the cell's result
if (sl == cur.top())
isRightToLeft(cur) ? moveNextCell(cur) : movePrevCell(cur);
- if (sl == cur.top())
- cur.dispatched(FINISHED_LEFT);
+ if (sl == cur.top()) {
+ cmd = FuncRequest(LFUN_FINISHED_LEFT);
+ cur.undispatched();
+ }
break;
case LFUN_DOWNSEL:
case LFUN_DOWN:
cell(cur.idx()).dispatch(cur, cmd);
- cur.dispatched(NONE); // override the cell's result
if (sl == cur.top())
if (tabular.row_of_cell(cur.idx()) != tabular.rows() - 1) {
cur.idx() = tabular.getCellBelow(cur.idx());
cur.pos() = 0;
resetPos(cur);
}
- if (sl == cur.top())
- cur.dispatched(FINISHED_DOWN);
+ if (sl == cur.top()) {
+ cmd = FuncRequest(LFUN_FINISHED_DOWN);
+ cur.undispatched();
+ }
break;
case LFUN_UPSEL:
case LFUN_UP:
cell(cur.idx()).dispatch(cur, cmd);
- cur.dispatched(NONE); // override the cell's result
if (sl == cur.top())
if (tabular.row_of_cell(cur.idx()) != 0) {
cur.idx() = tabular.getCellAbove(cur.idx());
cur.pos() = cur.lastpos();
resetPos(cur);
}
- if (sl == cur.top())
- cur.dispatched(FINISHED_UP);
+ if (sl == cur.top()) {
+ cmd = FuncRequest(LFUN_FINISHED_UP);
+ cur.undispatched();
+ }
break;
case LFUN_NEXT: {
protected:
///
- void priv_dispatch(LCursor & cur, FuncRequest const & cmd);
+ void priv_dispatch(LCursor & cur, FuncRequest & cmd);
private:
///
void drawCellLines(Painter &, int x, int baseline,
InsetText::InsetText(BufferParams const & bp)
: autoBreakRows_(false), drawFrame_(NEVER),
- frame_color_(LColor::insetframe), text_(0, true)
+ frame_color_(LColor::insetframe), text_(0)
{
paragraphs().push_back(Paragraph());
- paragraphs().begin()->layout(bp.getLyXTextClass().defaultLayout());
+ paragraphs().back().layout(bp.getLyXTextClass().defaultLayout());
if (bp.tracking_changes)
- paragraphs().begin()->trackChanges();
+ paragraphs().back().trackChanges();
init();
}
InsetText::InsetText(InsetText const & in)
- : UpdatableInset(in), text_(in.text_.bv_owner, true)
+ : UpdatableInset(in), text_(in.text_.bv_owner)
{
// this is ugly...
operator=(in);
autoBreakRows_ = in.autoBreakRows_;
drawFrame_ = in.drawFrame_;
frame_color_ = in.frame_color_;
- text_ = LyXText(in.text_.bv_owner, true);
+ text_ = LyXText(in.text_.bv_owner);
text_.paragraphs() = in.text_.paragraphs();
init();
}
finishUndo();
sanitizeEmptyText(cur.bv());
updateLocal(cur);
- dispatch(cur, FuncRequest(LFUN_PARAGRAPH_UPDATE));
}
return text_.editXY(cur, x, y);
//sanitizeEmptyText(cur.bv());
//updateLocal(cur);
- //dispatch(cur, FuncRequest(LFUN_PARAGRAPH_UPDATE));
}
-void InsetText::priv_dispatch(LCursor & cur, FuncRequest const & cmd)
+void InsetText::priv_dispatch(LCursor & cur, FuncRequest & cmd)
{
//lyxerr << "InsetText::priv_dispatch (begin), act: "
// << cmd.action << " " << endl;
// to allow us to call the owner's insetAllowed
// without stack overflow, which can happen
// when the owner uses InsetCollapsable::insetAllowed()
- bool ret = true;
if (in_insetAllowed)
- return ret;
+ return true;
in_insetAllowed = true;
- if (owner())
- ret = owner()->insetAllowed(code);
+ bool const ret = owner() && owner()->insetAllowed(code);
in_insetAllowed = false;
return ret;
}
private:
///
- void priv_dispatch(LCursor & cur, FuncRequest const & cmd);
+ void priv_dispatch(LCursor & cur, FuncRequest & cmd);
///
void updateLocal(LCursor &);
///
}
-void InsetVSpace::priv_dispatch(LCursor & cur, FuncRequest const & cmd)
+void InsetVSpace::priv_dispatch(LCursor & cur, FuncRequest & cmd)
{
switch (cmd.action) {
protected:
///
- virtual void priv_dispatch(LCursor & cur, FuncRequest const & cmd);
+ virtual void priv_dispatch(LCursor & cur, FuncRequest & cmd);
private:
///
}
-void InsetWrap::priv_dispatch(LCursor & cur, FuncRequest const & cmd)
+void InsetWrap::priv_dispatch(LCursor & cur, FuncRequest & cmd)
{
switch (cmd.action) {
case LFUN_INSET_MODIFY: {
InsetWrapParams const & params() const { return params_; }
protected:
///
- virtual void priv_dispatch(LCursor & cur, FuncRequest const & cmd);
+ virtual void priv_dispatch(LCursor & cur, FuncRequest & cmd);
private:
///
InsetWrapParams params_;
}
-void UpdatableInset::priv_dispatch(LCursor & cur, FuncRequest const & cmd)
+void UpdatableInset::priv_dispatch(LCursor & cur, FuncRequest & cmd)
{
switch (cmd.action) {
//case LFUN_MOUSE_RELEASE:
protected:
/// An updatable inset could handle lyx editing commands
- void priv_dispatch(LCursor & cur, FuncRequest const & cmd);
+ void priv_dispatch(LCursor & cur, FuncRequest & cmd);
/// scrolls to absolute position in bufferview-workwidth * sx units
void scroll(BufferView &, float sx) const;
/// scrolls offset pixels
return;
}
- Encoding const * encoding = view()->getEncoding();
+ Encoding const * encoding = view()->cursor().getEncoding();
encoded_last_key = keysym->getISOEncoded(encoding ? encoding->Name() : "");
}
}
- UpdatableInset * tli = cur.inset() ? cur.inset()->asUpdatableInset() : 0;
-
// I would really like to avoid having this switch and rather try to
// encode this in the function itself.
bool disable = false;
case LFUN_LAYOUT:
case LFUN_LAYOUT_PARAGRAPH:
- disable = cur.inset()
- && cur.inset()->forceDefaultParagraphs(cur.inset());
+ disable = cur.inset().forceDefaultParagraphs(&cur.inset());
break;
case LFUN_INSET_OPTARG:
} else {
disable = true;
- char align = mathcursor::halign();
+ char const align = mathcursor::halign();
if (align == '\0') {
disable = true;
break;
break;
}
- if (tli) {
+ if (!cur.empty() && cur.inset().asUpdatableInset()) {
FuncStatus ret;
//ret.disabled(true);
InsetTabular * tab = static_cast<InsetTabular *>
case LFUN_INSET_SETTINGS: {
disable = true;
- if (!cur.inset())
- break;
- UpdatableInset * inset = cur.inset()->asUpdatableInset();
+ UpdatableInset * inset = cur.inset().asUpdatableInset();
if (!inset)
break;
case LFUN_DIALOG_SHOW: {
string const name = cmd.getArg(0);
- if (!buf) {
+ if (!buf)
disable = !(name == "aboutlyx" ||
name == "file" ||
name == "preferences" ||
name == "texinfo");
- break;
- }
-
- if (name == "print") {
+ else if (name == "print")
disable = !Exporter::IsExportable(*buf, "dvi") ||
lyxrc.print_command == "none";
- } else if (name == "character") {
- InsetBase * inset = cur.inset();
- disable = inset && inset->lyxCode() == InsetOld::ERT_CODE;
- } else if (name == "vclog") {
+ else if (name == "character")
+ disable = cur.inset().lyxCode() == InsetOld::ERT_CODE;
+ else if (name == "vclog")
disable = !buf->lyxvc().inUse();
- } else if (name == "latexlog") {
+ else if (name == "latexlog")
disable = !IsFileReadable(buf->getLogName().second);
- }
break;
}
default:
break;
}
- if (code != InsetOld::NO_CODE && tli && !tli->insetAllowed(code))
+
+ if (code != InsetOld::NO_CODE
+ && (cur.empty() || !cur.inset().insetAllowed(code)))
disable = true;
if (disable)
void LyXFunc::dispatch(FuncRequest const & cmd, bool verbose)
{
- string argument = cmd.argument;
- kb_action action = cmd.action;
+ string const argument = cmd.argument;
+ kb_action const action = cmd.action;
lyxerr[Debug::ACTION] << "LyXFunc::dispatch: cmd: " << cmd << endl;
//lyxerr << "LyXFunc::dispatch: cmd: " << cmd << endl;
// --- buffers ----------------------------------------
case LFUN_SWITCHBUFFER:
- view()->buffer(bufferlist.getBuffer(argument));
+ view()->setBuffer(bufferlist.getBuffer(argument));
break;
case LFUN_FILE_NEW:
if (prefixIs(file_name, getTmpDir())) {
// Needed by inverse dvi search. If it is a file
// in tmpdir, call the apropriated function
- view()->buffer(bufferlist.getBufferFromTmp(file_name));
+ view()->setBuffer(bufferlist.getBufferFromTmp(file_name));
} else {
// Must replace extension of the file to be .lyx
// and get full path
string const s = ChangeExtension(file_name, ".lyx");
// Either change buffer or load the file
if (bufferlist.exists(s)) {
- view()->buffer(bufferlist.getBuffer(s));
+ view()->setBuffer(bufferlist.getBuffer(s));
} else {
view()->loadLyXFile(s);
}
case LFUN_DIALOG_SHOW_NEXT_INSET:
break;
- case LFUN_INSET_DIALOG_SHOW: {
- InsetBase * inset = view()->cursor().nextInset();
- if (inset)
- inset->dispatch(view()->cursor(), FuncRequest(LFUN_INSET_DIALOG_SHOW));
- break;
- }
-
case LFUN_DIALOG_UPDATE: {
string const & name = argument;
// Can only update a dialog connected to an existing inset
view()->savePosition(0);
string const parentfilename = owner->buffer()->fileName();
if (bufferlist.exists(filename))
- view()->buffer(bufferlist.getBuffer(filename));
+ view()->setBuffer(bufferlist.getBuffer(filename));
else
view()->loadLyXFile(filename);
// Set the parent name of the child document.
case LFUN_REPEAT: {
// repeat command
string countstr;
- argument = split(argument, countstr, ' ');
+ string rest = split(argument, countstr, ' ');
istringstream is(countstr);
int count = 0;
is >> count;
- lyxerr << "repeat: count: " << count << " cmd: " << argument << endl;
+ lyxerr << "repeat: count: " << count << " cmd: " << rest << endl;
for (int i = 0; i < count; ++i)
- dispatch(lyxaction.lookupFunc(argument));
+ dispatch(lyxaction.lookupFunc(rest));
break;
}
// argument contains ';'-terminated commands
while (!argument.empty()) {
string first;
- argument = split(argument, first, ';');
- dispatch(lyxaction.lookupFunc(first));
+ string rest = split(argument, first, ';');
+ dispatch(lyxaction.lookupFunc(rest));
}
break;
owner->getDialogs().toggleTooltips();
break;
- case LFUN_EXTERNAL_EDIT:
- InsetExternal().dispatch(view()->cursor(), FuncRequest(action, argument));
+ case LFUN_EXTERNAL_EDIT: {
+ FuncRequest fr(action, argument);
+ InsetExternal().dispatch(view()->cursor(), fr);
break;
+ }
- default:
+ default: {
DispatchResult res = view()->cursor().dispatch(cmd);
if (!res.dispatched());
view()->dispatch(cmd);
break;
}
+ }
}
- if (view()->cursor().inTexted())
- view()->owner()->updateLayoutChoice();
-
if (view()->available()) {
view()->fitCursor();
view()->update();
view()->buffer()->markDirty();
}
- if (view()->cursor().inTexted())
+ if (view()->cursor().inTexted()) {
+ view()->owner()->updateLayoutChoice();
sendDispatchMessage(getMessage(), cmd, verbose);
+ }
}
// since there's no current buffer
owner->getDialogs().hideBufferDependent();
} else {
- view()->buffer(bufferlist.first());
+ view()->setBuffer(bufferlist.first());
}
}
}
typedef lyx::paroffset_type par_type;
/// constructor
- LyXText(BufferView *, bool ininset);
+ explicit LyXText(BufferView *);
///
void init(BufferView *);
int dist(int x, int y) const;
/// try to handle that request
- void dispatch(LCursor & cur, FuncRequest const & cmd);
+ void dispatch(LCursor & cur, FuncRequest & cmd);
/// do we want to handle this event?
bool getStatus(LCursor & cur, FuncRequest const & cmd, FuncStatus & status);
/// access to our paragraphs
ParagraphList & paragraphs() const;
- /// return true if this is owned by an inset.
- bool isInInset() const;
+ /// return true if this is the main text
+ bool isMainText() const;
/// return first row of text
RowList::iterator firstRow() const;
///
mutable Bidi bidi;
///
- bool in_inset_;
- ///
ParagraphList paragraphs_;
/// absolute document pixel coordinates of this LyXText
}
-void MathGridInset::priv_dispatch(LCursor & cur, FuncRequest const & cmd)
+void MathGridInset::priv_dispatch(LCursor & cur, FuncRequest & cmd)
{
//lyxerr << "*** MathGridInset: request: " << cmd << endl;
switch (cmd.action) {
cur.idx() = cur.lastpos();
//mathcursor->normalize();
- cur.dispatched(FINISHED_LEFT);
+ cmd = FuncRequest(LFUN_FINISHED_LEFT);
return;
}
else if (cur.idx() != 0)
cur.idx() = 0;
else
- cur.dispatched(FINISHED_LEFT);
+ cmd = FuncRequest(LFUN_FINISHED_LEFT);
break;
case LFUN_WORDRIGHTSEL:
else if (cur.idx() != cur.lastidx())
cur.idx() = cur.lastidx();
else
- cur.dispatched(FINISHED_RIGHT);
+ cmd = FuncRequest(LFUN_FINISHED_RIGHT);
break;
default:
protected:
///
- void priv_dispatch(LCursor & cur, FuncRequest const & cmd);
+ void priv_dispatch(LCursor & cur, FuncRequest & cmd);
/// returns x offset of cell compared to inset
int cellXOffset(idx_type idx) const;
/// returns y offset of cell compared to inset
#include "lyxrc.h"
#include "outputparams.h"
#include "textpainter.h"
+#include "undo.h"
#include "frontends/Alert.h"
}
-void MathHullInset::doExtern(LCursor & cur, FuncRequest const & func)
+void MathHullInset::doExtern(LCursor & cur, FuncRequest & func)
{
string lang;
string extra;
}
-void MathHullInset::priv_dispatch(LCursor & cur, FuncRequest const & cmd)
+void MathHullInset::priv_dispatch(LCursor & cur, FuncRequest & cmd)
{
//lyxerr << "*** MathHullInset: request: " << cmd << endl;
switch (cmd.action) {
case LFUN_MATH_NUMBER:
//lyxerr << "toggling all numbers" << endl;
if (display()) {
- ////recordUndo(cur, Undo::INSERT);
+ recordUndo(cur);
bool old = numberedType();
if (type_ == "multline")
numbered(nrows() - 1, !old);
case LFUN_MATH_NONUMBER:
if (display()) {
row_type r = (type_ == "multline") ? nrows() - 1 : cur.row();
- ////recordUndo(cur, Undo::INSERT);
+ recordUndo(cur);
bool old = numbered(r);
cur.message(old ? _("No number") : _("Number"));
numbered(r, !old);
}
-void MathHullInset::handleFont
- (LCursor & cur, string const & arg, string const & font)
+void MathHullInset::handleFont(LCursor & cur, string const & arg,
+ string const & font)
{
// this whole function is a hack and won't work for incremental font
// changes...
- //recordUndo(cur, Undo::ATOMIC);
-
- if (cur.inset()->asMathInset()->name() == font)
+ recordUndo(cur);
+ if (cur.inset().asMathInset()->name() == font)
cur.handleFont(font);
else {
cur.handleNest(createMathInset(font));
void MathHullInset::handleFont2(LCursor & cur, string const & arg)
{
- //recordUndo(cur, Undo::ATOMIC);
+ recordUndo(cur);
LyXFont font;
bool b;
bv_funcs::string2font(arg, font, b);
protected:
///
- void priv_dispatch(LCursor & cur, FuncRequest const & cmd);
+ void priv_dispatch(LCursor & cur, FuncRequest & cmd);
///
std::string eolString(row_type row, bool fragile) const;
///
std::string nicelabel(row_type row) const;
///
- void doExtern(LCursor & cur, FuncRequest const & func);
+ void doExtern(LCursor & cur, FuncRequest & func);
///
void glueall();
///
virtual void insetUnlock(BufferView & bv);
/// To allow transparent use of math editing functions
- //virtual void status(FuncRequest const &);
+ //virtual void status(FuncRequest &);
///
virtual bool searchForward(BufferView *, std::string const &,
// We don't really want to mess around with mathed stuff outside mathed.
// So do it here.
-void mathDispatch(LCursor & cur, FuncRequest const & cmd);
+void mathDispatch(LCursor & cur, FuncRequest & cmd);
#endif
MathMBoxInset::MathMBoxInset(BufferView & bv)
- : text_(&bv, true), bv_(&bv)
+ : text_(&bv), bv_(&bv)
{
text_.paragraphs().push_back(Paragraph());
text_.paragraphs().back().
}
-void MathMBoxInset::priv_dispatch(LCursor & cur, FuncRequest const & cmd)
+void MathMBoxInset::priv_dispatch(LCursor & cur, FuncRequest & cmd)
{
text_.dispatch(cur, cmd);
}
/// draw according to cached metrics
void draw(PainterInfo &, int x, int y) const;
///
- void priv_dispatch(LCursor & cur, FuncRequest const & cmd);
+ void priv_dispatch(LCursor & cur, FuncRequest & cmd);
///
void write(WriteStream & os) const;
void MathNestInset::getCursorPos(CursorSlice const & cur,
int & x, int & y) const
{
- BOOST_ASSERT(ptr_cmp(cur.inset(), this));
+ BOOST_ASSERT(ptr_cmp(&cur.inset(), this));
MathArray const & ar = cur.cell();
x = ar.xo() + ar.pos2x(cur.pos());
y = ar.yo();
bool MathNestInset::idxNext(LCursor & cur) const
{
- BOOST_ASSERT(ptr_cmp(cur.inset(), this));
+ BOOST_ASSERT(ptr_cmp(&cur.inset(), this));
if (cur.idx() == cur.lastidx())
return false;
++cur.idx();
bool MathNestInset::idxPrev(LCursor & cur) const
{
- BOOST_ASSERT(ptr_cmp(cur.inset(), this));
+ BOOST_ASSERT(ptr_cmp(&cur.inset(), this));
if (cur.idx() == 0)
return false;
--cur.idx();
bool MathNestInset::idxFirst(LCursor & cur) const
{
- BOOST_ASSERT(ptr_cmp(cur.inset(), this));
+ BOOST_ASSERT(ptr_cmp(&cur.inset(), this));
if (nargs() == 0)
return false;
cur.idx() = 0;
bool MathNestInset::idxLast(LCursor & cur) const
{
- BOOST_ASSERT(ptr_cmp(cur.inset(), this));
+ BOOST_ASSERT(ptr_cmp(&cur.inset(), this));
if (nargs() == 0)
return false;
cur.idx() = cur.lastidx();
LCursor & cur = pi.base.bv->cursor();
if (!cur.selection())
return;
- if (!ptr_cmp(cur.inset(), this))
+ if (!ptr_cmp(&cur.inset(), this))
return;
CursorSlice & s1 = cur.selBegin();
CursorSlice & s2 = cur.selEnd();
// changes...
recordUndo(cur, Undo::ATOMIC);
- if (cur.inset()->asMathInset()->name() == font)
+ if (cur.inset().asMathInset()->name() == font)
cur.handleFont(font);
else {
cur.handleNest(createMathInset(font));
}
-void MathNestInset::priv_dispatch(LCursor & cur, FuncRequest const & cmd)
+void MathNestInset::priv_dispatch(LCursor & cur, FuncRequest & cmd)
{
lyxerr << "MathNestInset: request: " << cmd << std::endl;
//CursorSlice sl = cur.current();
switch (cmd.action) {
+ case LFUN_PASTESELECTION: {
+ MathArray ar;
+ mathed_parse_cell(ar, cur.bv().getClipboard());
+ cur.cell().insert(cur.pos(), ar);
+ cur.pos() += ar.size();
+ break;
+ }
+
case LFUN_PASTE:
if (!cmd.argument.empty()) {
MathArray ar;
}
*/
- case LFUN_PASTESELECTION:
- dispatch(cur, FuncRequest(LFUN_PASTE, cur.bv().getClipboard()));
- break;
-
case LFUN_MOUSE_PRESS:
lfunMousePress(cur, cmd);
break;
lfunMouseRelease(cur, cmd);
break;
- case LFUN_MOUSE_DOUBLE:
- case LFUN_MOUSE_TRIPLE:
- //lyxerr << "Mouse double" << endl;
- //lyxerr << "Mouse triple" << endl;
- dispatch(cur, FuncRequest(LFUN_WORDSEL));
- break;
-
case LFUN_FINISHED_LEFT:
cur.bv().cursor() = cur;
break;
if (cur.inMacroMode())
cur.macroModeClose();
else if (cur.pos() != cur.lastpos() && cur.openable(cur.nextAtom())) {
- cur.pushLeft(cur.nextAtom().nucleus());
- cur.inset()->idxFirst(cur);
+ cur.pushLeft(*cur.nextAtom().nucleus());
+ cur.inset().idxFirst(cur);
} else if (cur.posRight() || idxRight(cur)
|| cur.popRight() || cur.selection())
;
else
- cur.dispatched(FINISHED_RIGHT);
+ cmd = FuncRequest(LFUN_FINISHED_RIGHT);
lyxerr << "mathnest RIGHT: to:\n" << cur << endl;
break;
cur.macroModeClose();
else if (cur.pos() != 0 && cur.openable(cur.prevAtom())) {
cur.posLeft();
- cur.push(cur.nextAtom().nucleus());
- cur.inset()->idxLast(cur);
+ cur.push(*cur.nextAtom().nucleus());
+ cur.inset().idxLast(cur);
} else if (cur.posLeft() || idxLeft(cur)
|| cur.popLeft() || cur.selection())
;
else
- cur.dispatched(FINISHED_LEFT);
+ cmd = FuncRequest(LFUN_FINISHED_LEFT);
break;
case LFUN_UPSEL:
case LFUN_UP:
cur.selHandle(cmd.action == LFUN_UPSEL);
if (!cur.up())
- cur.dispatched(FINISHED_UP);
+ cmd = FuncRequest(LFUN_FINISHED_UP);
break;
case LFUN_DOWNSEL:
case LFUN_DOWN:
cur.selHandle(cmd.action == LFUN_DOWNSEL);
if (!cur.down())
- cur.dispatched(FINISHED_DOWN);
+ cmd = FuncRequest(LFUN_FINISHED_DOWN);
break;
+ case LFUN_MOUSE_DOUBLE:
+ case LFUN_MOUSE_TRIPLE:
case LFUN_WORDSEL:
cur.pos() = 0;
cur.idx() = 0;
cur.idx() = 0;
cur.pos() = 0;
} else {
- cur.dispatched(FINISHED_LEFT);
+ cmd = FuncRequest(LFUN_FINISHED_LEFT);
}
break;
cur.idx() = cur.lastidx();
cur.pos() = cur.lastpos();
} else {
- cur.dispatched(FINISHED_RIGHT);
+ cmd = FuncRequest(LFUN_FINISHED_RIGHT);
}
break;
case LFUN_PRIOR:
case LFUN_BEGINNINGBUFSEL:
case LFUN_BEGINNINGBUF:
- cur.dispatched(FINISHED_LEFT);
+ cmd = FuncRequest(LFUN_FINISHED_LEFT);
break;
case LFUN_NEXTSEL:
case LFUN_NEXT:
case LFUN_ENDBUFSEL:
case LFUN_ENDBUF:
- cur.dispatched(FINISHED_RIGHT);
+ cmd = FuncRequest(LFUN_FINISHED_RIGHT);
break;
case LFUN_CELL_FORWARD:
- cur.inset()->idxNext(cur);
+ cur.inset().idxNext(cur);
break;
case LFUN_CELL_BACKWARD:
- cur.inset()->idxPrev(cur);
+ cur.inset().idxPrev(cur);
break;
case LFUN_DELETE_WORD_BACKWARD:
case LFUN_DELETE:
recordUndo(cur, Undo::ATOMIC);
cur.erase();
- cur.dispatched(FINISHED_LEFT);
+ cmd = FuncRequest(LFUN_FINISHED_LEFT);
break;
case LFUN_ESCAPE:
if (cur.selection())
cur.selClear();
else
- cur.dispatched(FINISHED_LEFT);
+ cmd = FuncRequest(LFUN_FINISHED_LEFT);
break;
case LFUN_INSET_TOGGLE:
case LFUN_SELFINSERT:
if (cmd.argument.empty()) {
- cur.dispatched(FINISHED_RIGHT);
+ cmd = FuncRequest(LFUN_FINISHED_RIGHT);
break;
}
recordUndo(cur, Undo::ATOMIC);
break;
}
if (!interpret(cur, cmd.argument[0]))
- cur.dispatched(FINISHED_RIGHT);
+ cmd = FuncRequest(LFUN_FINISHED_RIGHT);
break;
#if 0
cur.selClearOrDel();
cur.plainInsert(MathAtom(new MathMBoxInset(cur.bv())));
cur.posLeft();
- cur.pushLeft(cur.nextInset());
+ cur.pushLeft(*cur.nextInset());
#else
if (currentMode() == InsetBase::TEXT_MODE)
cur.niceInsert(MathAtom(new MathHullInset("simple")));
InsetBase * base = cur.bv().owner()->getDialogs().getOpenInset(name);
if (base) {
- base->dispatch(cur, FuncRequest(LFUN_INSET_MODIFY, cmd.argument));
+ FuncRequest fr(LFUN_INSET_MODIFY, cmd.argument);
+ base->dispatch(cur, fr);
break;
}
MathArray ar;
void MathNestInset::edit(LCursor & cur, bool left)
{
- cur.push(this);
+ cur.push(*this);
cur.idx() = left ? 0 : cur.lastidx();
cur.pos() = left ? 0 : cur.lastpos();
cur.resetAnchor();
}
}
MathArray & ar = cell(idx_min);
- cur.push(this);
+ cur.push(*this);
cur.idx() = idx_min;
cur.pos() = ar.x2pos(x - ar.xo());
lyxerr << "found cell : " << idx_min << " pos: " << cur.pos() << endl;
}
-void MathNestInset::lfunMouseRelease(LCursor & cur, FuncRequest const & cmd)
+void MathNestInset::lfunMouseRelease(LCursor & cur, FuncRequest & cmd)
{
//lyxerr << "lfunMouseRelease: buttons: " << cmd.button() << endl;
}
-void MathNestInset::lfunMousePress(LCursor & cur, FuncRequest const & cmd)
+void MathNestInset::lfunMousePress(LCursor & cur, FuncRequest & cmd)
{
lyxerr << "lfunMousePress: buttons: " << cmd.button() << endl;
if (cmd.button() == mouse_button::button1) {
}
if (cmd.button() == mouse_button::button2) {
- priv_dispatch(cur, FuncRequest(LFUN_PASTESELECTION));
+ cur.dispatch(FuncRequest(LFUN_PASTESELECTION));
}
}
-void MathNestInset::lfunMouseMotion(LCursor & cur, FuncRequest const & cmd)
+void MathNestInset::lfunMouseMotion(LCursor & cur, FuncRequest & cmd)
{
// only select with button 1
if (cmd.button() != mouse_button::button1)
} else if (cur.pos() != 0 && cur.prevAtom()->asScriptInset()) {
--cur.pos();
cur.nextAtom().nucleus()->asScriptInset()->ensure(up);
- cur.push(cur.nextInset());
+ cur.push(*cur.nextInset());
cur.idx() = up;
cur.pos() = cur.lastpos();
} else if (cur.pos() != 0) {
--cur.pos();
cur.cell()[cur.pos()] = MathAtom(new MathScriptInset(cur.nextAtom(), up));
- cur.push(cur.nextInset());
+ cur.push(*cur.nextInset());
cur.idx() = up;
cur.pos() = 0;
} else {
cur.plainInsert(MathAtom(new MathScriptInset(up)));
--cur.pos();
cur.nextAtom().nucleus()->asScriptInset()->ensure(up);
- cur.push(cur.nextInset());
+ cur.push(*cur.nextInset());
cur.idx() = up;
cur.pos() = 0;
}
protected:
///
- void priv_dispatch(LCursor & cur, FuncRequest const & cmd);
+ void priv_dispatch(LCursor & cur, FuncRequest & cmd);
///
void handleFont(LCursor & cur,
std::string const & arg, std::string const & font);
private:
/// lfun handler
- void lfunMousePress(LCursor &, FuncRequest const &);
+ void lfunMousePress(LCursor &, FuncRequest &);
///
- void lfunMouseRelease(LCursor &, FuncRequest const &);
+ void lfunMouseRelease(LCursor &, FuncRequest &);
///
- void lfunMouseMotion(LCursor &, FuncRequest const &);
+ void lfunMouseMotion(LCursor &, FuncRequest &);
protected:
/// we store the cells in a vector
}
-void MathScriptInset::priv_dispatch(LCursor & cur, FuncRequest const & cmd)
+void MathScriptInset::priv_dispatch(LCursor & cur, FuncRequest & cmd)
{
//lyxerr << "MathScriptInset: request: " << cmd << std::endl;
void infoize2(std::ostream & os) const;
protected:
///
- void priv_dispatch(LCursor & cur, FuncRequest const & cmd);
+ void priv_dispatch(LCursor & cur, FuncRequest & cmd);
private:
/// returns x offset for main part
int dxx() const;
}
-void RefInset::priv_dispatch(LCursor & cur, FuncRequest const & cmd)
+void RefInset::priv_dispatch(LCursor & cur, FuncRequest & cmd)
{
switch (cmd.action) {
case LFUN_INSET_MODIFY:
int docbook(std::ostream & os, OutputParams const &) const;
/// small wrapper for the time being
- DispatchResult localDispatch(FuncRequest const & cmd);
+ DispatchResult localDispatch(FuncRequest & cmd);
struct ref_type_info {
///
static std::string const & getName(int type);
protected:
///
- void priv_dispatch(LCursor & cur, FuncRequest const & cmd);
+ void priv_dispatch(LCursor & cur, FuncRequest & cmd);
};
#endif
// Is this really needed ? (Dekel)
// We do not need to use to change the font for the last paragraph
// or for a command.
- LyXFont const outerfont(outerFont(pit, paragraphs));
+ LyXFont const outerfont = outerFont(pit, paragraphs);
LyXFont const font =
(pit->empty()
for (end = beg ; end != endpar && end->y <= yend; ++end)
;
}
-
if (token.empty())
continue;
- if (in_inset_) {
-
- if (token == "\\end_inset") {
- the_end_read = true;
- break;
- }
-
- if (token == "\\end_document") {
- lex.printError("\\end_document read in inset! Error in document!");
- return false;
- }
-
- } else {
-
- if (token == "\\end_document") {
- the_end_read = true;
- continue;
- }
+ if (token == "\\end_inset") {
+ the_end_read = true;
+ break;
+ }
+ if (token == "\\end_document") {
+#warning Look here!
+#if 0
+ lex.printError("\\end_document read in inset! Error in document!");
+#endif
+ return false;
}
// FIXME: ugly.
par.params().depth(depth);
if (buf.params().tracking_changes)
par.trackChanges();
- LyXFont f(LyXFont::ALL_INHERIT, buf.params().language);
- par.setFont(0, f);
+ par.setFont(0, LyXFont(LyXFont::ALL_INHERIT, buf.params().language));
// insert after
if (pit != paragraphs().end())
using std::string;
-LyXText::LyXText(BufferView * bv, bool in_inset)
+LyXText::LyXText(BufferView * bv)
: width_(0), maxwidth_(bv ? bv->workWidth() : 100), height_(0),
background_color_(LColor::background),
- bv_owner(bv), in_inset_(in_inset), xo_(0), yo_(0)
+ bv_owner(bv), xo_(0), yo_(0)
{}
}
+bool LyXText::isMainText() const
+{
+ return &bv()->buffer()->text() == this;
+}
+
+
// 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
// We specialize the 95% common case:
if (!pit->getDepth()) {
LyXFont f = pit->getFontSettings(params, pos);
- if (in_inset_)
+ if (!isMainText())
f.realize(font_);
if (layout->labeltype == LABEL_MANUAL && pos < body_pos)
return f.realize(layout->reslabelfont);
LyXFont font = pit->getFontSettings(params, pos);
font.realize(layoutfont);
- if (in_inset_)
+ if (!isMainText())
font.realize(font_);
// Realize with the fonts of lesser depth.
}
-bool LyXText::isInInset() const
-{
- return in_inset_;
-}
-
-
bool LyXText::toggleInset(LCursor & cur)
{
InsetBase * inset = cur.nextInset();
lyxerr << "selection is: '" << sel << "'" << endl;
if (sel.empty()) {
- cur.insert(new MathHullInset); // activates inset
+ cur.insert(new MathHullInset);
+ cur.dispatch(FuncRequest(LFUN_RIGHT));
cur.dispatch(FuncRequest(LFUN_MATH_MUTATE, "simple"));
// don't do that also for LFUN_MATH_MODE unless you want end up with
// always changing to mathrm when opening an inlined inset
// create a macro if we see "\\newcommand" somewhere, and an ordinary
// formula otherwise
text->cutSelection(cur, true, true);
- if (sel.find("\\newcommand") == string::npos &&
- sel.find("\\def") == string::npos)
+ if (sel.find("\\newcommand") == string::npos
+ && sel.find("\\def") == string::npos)
{
cur.insert(new MathHullInset);
+ cur.dispatch(FuncRequest(LFUN_RIGHT));
cur.dispatch(FuncRequest(LFUN_MATH_MUTATE, "simple"));
cur.dispatch(FuncRequest(LFUN_INSERT_MATH, sel));
} else {
cur.insert(new InsetFormulaMacro(sel));
+ cur.dispatch(FuncRequest(LFUN_RIGHT));
}
}
cur.message(N_("Math editor mode"));
}
-void LyXText::dispatch(LCursor & cur, FuncRequest const & cmd)
+void LyXText::dispatch(LCursor & cur, FuncRequest & cmd)
{
lyxerr[Debug::ACTION] << "LyXText::dispatch: cmd: " << cmd << endl;
//lyxerr << "*** LyXText::dispatch: cmd: " << cmd << endl;
else
cursorRight(cur);
if (sl == cur.top())
- cur.dispatched(FINISHED_RIGHT);
+ cmd = FuncRequest(LFUN_FINISHED_RIGHT);
break;
case LFUN_LEFT:
else
cursorLeft(cur);
if (sl == cur.top())
- cur.dispatched(FINISHED_LEFT);
+ cmd = FuncRequest(LFUN_FINISHED_LEFT);
break;
case LFUN_UP:
cur.selHandle(cmd.action == LFUN_UPSEL);
cursorUp(cur);
if (sl == cur.top())
- cur.dispatched(FINISHED_UP);
+ cmd = FuncRequest(LFUN_FINISHED_UP);
break;
case LFUN_DOWN:
cur.selHandle(cmd.action == LFUN_DOWNSEL);
cursorDown(cur);
if (sl == cur.top())
- cur.dispatched(FINISHED_DOWN);
+ cmd = FuncRequest(LFUN_FINISHED_DOWN);
break;
case LFUN_UP_PARAGRAPHSEL:
cur.clearSelection();
finishChange(cur, false);
if (cur.par() == 0 && cur.textRow().pos() == 0)
- cur.dispatched(FINISHED_UP);
+ cmd = FuncRequest(LFUN_FINISHED_UP);
else
cursorPrevious(cur);
break;
finishChange(cur, false);
if (cur.par() == cur.lastpar()
&& cur.textRow().endpos() == cur.lastpos())
- cur.dispatched(FINISHED_DOWN);
+ cmd = FuncRequest(LFUN_FINISHED_DOWN);
else
cursorNext(cur);
break;
case LFUN_INSET_APPLY: {
string const name = cmd.getArg(0);
InsetBase * inset = bv->owner()->getDialogs().getOpenInset(name);
- if (inset)
- inset->dispatch(cur, FuncRequest(LFUN_INSET_MODIFY, cmd.argument));
- else
- dispatch(cur, FuncRequest(LFUN_INSET_INSERT, cmd.argument));
+ if (inset) {
+ FuncRequest fr(LFUN_INSET_MODIFY, cmd.argument);
+ inset->dispatch(cur, fr);
+ } else {
+ FuncRequest fr(LFUN_INSET_INSERT, cmd.argument);
+ dispatch(cur, fr);
+ }
break;
}
}
case LFUN_INSET_SETTINGS:
- if (cur.inset() && cur.inset()->asUpdatableInset())
- cur.inset()->asUpdatableInset()->showInsetDialog(bv);
+ if (cur.inset().asUpdatableInset())
+ cur.inset().asUpdatableInset()->showInsetDialog(bv);
break;
case LFUN_INSET_TOGGLE:
cur.message(_("Copy"));
break;
- case LFUN_BEGINNINGBUFSEL:
- if (in_inset_) {
- cur.undispatched();
- } else {
- if (!cur.selection())
- cur.resetAnchor();
- cursorTop(cur);
- finishChange(cur, true);
- }
- break;
-
- case LFUN_ENDBUFSEL:
- if (in_inset_) {
- cur.undispatched();
- } else {
- if (!cur.selection())
- cur.resetAnchor();
- cursorBottom(cur);
- finishChange(cur, true);
- }
- break;
-
case LFUN_GETXY:
cur.message(tostr(cursorX(cur.top())) + ' '
+ tostr(cursorY(cur.top())));
InsetQuotes::DoubleQ));
else
cur.insert(new InsetQuotes(c, bufparams));
- }
+ }
else
bv->owner()->dispatch(FuncRequest(LFUN_SELFINSERT, "\""));
break;
// This is to allow jumping over large insets
// FIXME: shouldn't be top-text-specific
- if (!in_inset_ && cur.top() == old) {
+ if (isMainText() && cur.top() == old) {
if (cmd.y - bv->top_y() >= bv->workHeight())
cursorDown(cur);
else if (cmd.y - bv->top_y() < 0)
params2string(cur.paragraph(), data);
// Will the paragraph accept changes from the dialog?
- InsetBase * const inset = cur.inset();
- bool const accept =
- !(inset && inset->forceDefaultParagraphs(inset));
+ InsetBase & inset = cur.inset();
+ bool const accept = !inset.forceDefaultParagraphs(&inset);
data = "update " + tostr(accept) + '\n' + data;
bv->owner()->getDialogs().update("paragraph", data);
break;
}
+ case LFUN_INSET_DIALOG_SHOW: {
+ InsetBase * inset = cur.nextInset();
+ if (inset) {
+ FuncRequest fr(LFUN_INSET_DIALOG_SHOW);
+ inset->dispatch(cur, fr);
+ }
+ break;
+ }
+
case LFUN_ESCAPE:
if (cur.selection())
cur.selection() = false;
else
- cur.dispatched(FINISHED_LEFT);
+ cmd = FuncRequest(LFUN_FINISHED_LEFT);
break;
default:
{
LCursor & cur = bv.cursor();
lyxerr << "undo, performing: " << undo << std::endl;
- cur.setCursor(undo.cursor.asDocumentIterator(bv), false);
+ cur.setCursor(undo.cursor.asDocumentIterator(&bv.buffer()->inset()), false);
if (cur.inMathed()) {
// We stored the full cell here as there is not much to be
// this implements redo
if (!undo_frozen) {
otherstack.push(undo);
- DocumentIterator dit = undo.cursor.asDocumentIterator(bv);
+ DocumentIterator dit =
+ undo.cursor.asDocumentIterator(&bv.buffer()->inset());
if (dit.inMathed()) {
// not much to be done
} else {
projects / features.git / commitdiff