* Copyright 2002 the LyX Team
* Read the file COPYING
*
+ * \author Lars Gullik Bjønnes
* \author various
*/
using std::min;
using lyx::pos_type;
+using namespace lyx::support;
using namespace bv_funcs;
extern BufferList bufferlist;
void BufferView::Pimpl::addError(ErrorItem const & ei)
{
errorlist_.push_back(ei);
+}
+
+
+void BufferView::Pimpl::showReadonly(bool)
+{
+ owner_->updateWindowTitle();
+ owner_->getDialogs().updateBufferDependent(false);
+}
+
+
+void BufferView::Pimpl::connectBuffer(Buffer & buf)
+{
+ if (errorConnection_.connected())
+ disconnectBuffer();
+
+ errorConnection_ = buf.error.connect(boost::bind(&BufferView::Pimpl::addError, this, _1));
+ messageConnection_ = buf.message.connect(boost::bind(&LyXView::message, owner_, _1));
+ busyConnection_ = buf.busy.connect(boost::bind(&LyXView::busy, owner_, _1));
+ titleConnection_ = buf.updateTitles.connect(boost::bind(&LyXView::updateWindowTitle, owner_));
+ timerConnection_ = buf.resetAutosaveTimers.connect(boost::bind(&LyXView::resetAutosaveTimer, owner_));
+ readonlyConnection_ = buf.readonly.connect(boost::bind(&BufferView::Pimpl::showReadonly, this, _1));
+ closingConnection_ = buf.closing.connect(boost::bind(&BufferView::Pimpl::buffer, this, (Buffer *)0));
+}
+
+
+void BufferView::Pimpl::disconnectBuffer()
+{
+ errorConnection_.disconnect();
+ messageConnection_.disconnect();
+ busyConnection_.disconnect();
+ titleConnection_.disconnect();
+ timerConnection_.disconnect();
+ readonlyConnection_.disconnect();
+ closingConnection_.disconnect();
+}
+
+bool BufferView::Pimpl::newFile(string const & filename,
+ string const & tname,
+ bool isNamed)
+{
+ Buffer * b = ::newFile(filename, tname, isNamed);
+ buffer(b);
+ return true;
}
}
Buffer * b = bufferlist.newBuffer(s);
- //attach to the error signal in the buffer
- b->parseError.connect(boost::bind(&BufferView::Pimpl::addError,
- this, _1));
+ connectBuffer(*b);
- bool loaded = ::loadLyXFile(b, s);
-
- if (! loaded) {
+ if (! ::loadLyXFile(b, s)) {
bufferlist.release(b);
- string text = bformat(_("The document %1$s does "
- "not yet exist.\n\n"
- "Do you want to create "
+ string text = bformat(_("The document %1$s does not yet "
+ "exist.\n\nDo you want to create "
"a new document?"), s);
int const ret = Alert::prompt(_("Create new document?"),
text, 0, 1, _("&Create"), _("Cancel"));
- if (ret == 0)
- b = newFile(s, string(), true);
- else
+ if (ret != 0)
return false;
-
- }
+ }
buffer(b);
if (tolastfiles)
lastfiles->newFile(b->fileName());
- if (loaded)
- bv_->showErrorList(_("Parse"));
+ bv_->showErrorList(_("Parse"));
return true;
}
+
WorkArea & BufferView::Pimpl::workarea() const
{
return *workarea_.get();
lyxerr[Debug::INFO] << "Setting buffer in BufferView ("
<< b << ')' << endl;
if (buffer_) {
- buffer_->delUser(bv_);
-
+ disconnectBuffer();
// Put the old text into the TextCache, but
// only if the buffer is still loaded.
// Also set the owner of the test to 0
if (buffer_) {
lyxerr[Debug::INFO] << "Buffer addr: " << buffer_ << endl;
- buffer_->addUser(bv_);
+ connectBuffer(*buffer_);
// If we don't have a text object for this, we make one
if (bv_->text == 0) {
owner_->setLayout(layoutname);
}
- if (grfx::Previews::activated() && buffer_)
- grfx::Previews::get().generateBufferPreviews(*buffer_);
+ if (lyx::graphics::Previews::activated() && buffer_)
+ lyx::graphics::Previews::get().generateBufferPreviews(*buffer_);
}
selection = bv_->text->selection.set();
mark_set = bv_->text->selection.mark();
the_locking_inset = bv_->theLockingInset();
- buffer_->resizeInsets(bv_);
- // I don't think the delete and new are necessary here we
- // just could call only init! (Jug 20020419)
- delete bv_->text;
- bv_->text = new LyXText(bv_);
- bv_->text->init(bv_);
+ resizeInsets(bv_);
+ bv_->text->fullRebreak();
+ update();
} else {
+ lyxerr << "text not available!\n";
// See if we have a text in TextCache that fits
// the new buffer_ with the correct width.
bv_->text = textcache.findFit(buffer_, workarea().workWidth());
if (bv_->text) {
+ lyxerr << "text in cache!\n";
if (lyxerr.debugging()) {
lyxerr << "Found a LyXText that fits:\n";
textcache.show(lyxerr, make_pair(buffer_, make_pair(workarea().workWidth(), bv_->text)));
if (lyxerr.debugging())
textcache.show(lyxerr, "resizeCurrentBuffer");
- buffer_->resizeInsets(bv_);
+ resizeInsets(bv_);
} else {
+ lyxerr << "no text in cache!\n";
bv_->text = new LyXText(bv_);
+ resizeInsets(bv_);
bv_->text->init(bv_);
- //buffer_->resizeInsets(bv_);
}
par = bv_->text->ownerParagraphs().end();
textcache.show(lyxerr, "Expose delete all");
textcache.clear();
// FIXME: this is already done in resizeCurrentBuffer() ??
- buffer_->resizeInsets(bv_);
+ resizeInsets(bv_);
} else if (heightChange) {
// fitCursor() ensures we don't jump back
// to the start of the document on vertical
text->partialRebreak();
if (text->inset_owner) {
- text->inset_owner->setUpdateStatus(bv_, InsetText::NONE);
+ text->inset_owner->setUpdateStatus(InsetText::NONE);
updateInset(text->inset_owner);
} else {
update();
text->partialRebreak();
if (text->inset_owner) {
- text->inset_owner->setUpdateStatus(bv_, InsetText::NONE);
+ text->inset_owner->setUpdateStatus(InsetText::NONE);
updateInset(text->inset_owner);
} else {
update();
b = bufferlist.newBuffer(fname);
::loadLyXFile(b, fname); // don't ask, just load it
}
- if (b != 0)
+ if (b != 0)
buffer(b);
}
LyXText * text = bv_->getLyXText();
if (text->real_current_font.isRightToLeft()
&& !(bv_->theLockingInset()
- && bv_->theLockingInset()->lyxCode() == Inset::ERT_CODE))
+ && bv_->theLockingInset()->lyxCode() == InsetOld::ERT_CODE))
{
if (owner_->getIntl().keymap == Intl::PRIMARY)
owner_->getIntl().KeyMapSec();
*/
-Inset * BufferView::Pimpl::getInsetByCode(Inset::Code code)
+InsetOld * BufferView::Pimpl::getInsetByCode(InsetOld::Code code)
{
#if 0
LyXCursor cursor = bv_->getLyXText()->cursor;
string const disp_fn = MakeDisplayPath(filename);
owner_->message(bformat(_("Inserting document %1$s..."), disp_fn));
- bool const res = bv_->insertLyXFile(filename);
- if (res)
- owner_->message(bformat(_("Document %1$s inserted."), disp_fn));
+ if (bv_->insertLyXFile(filename))
+ owner_->message(bformat(_("Document %1$s inserted."),
+ disp_fn));
else
- owner_->message(bformat(_("Could not insert document %1$s"), disp_fn));
+ owner_->message(bformat(_("Could not insert document %1$s"),
+ disp_fn));
}
#warning changes FIXME
//moveCursorUpdate(false);
- bool found = lyxfind::findNextChange(bv_);
+ bool found = lyx::find::findNextChange(bv_);
if (found) {
owner_->getDialogs().show("changes");
return;
screen().hideCursor();
- bool const res = dispatch(ev_in);
+ // Make sure that the cached BufferView is correct.
+ FuncRequest ev = ev_in;
+ ev.setView(bv_);
+
+ bool const res = dispatch(ev);
// see workAreaKeyPress
cursor_timeout.restart();
string label = ev.argument;
if (label.empty()) {
InsetRef * inset =
- static_cast<InsetRef*>(getInsetByCode(Inset::REF_CODE));
+ static_cast<InsetRef*>(getInsetByCode(InsetOld::REF_CODE));
if (inset) {
label = inset->getContents();
savePosition(0);
break;
case LFUN_INSET_INSERT: {
- Inset * inset = createInset(ev);
+ InsetOld * inset = createInset(ev);
if (inset && insertInset(inset)) {
updateInset(inset);
case LFUN_FLOAT_LIST:
if (tclass.floats().typeExist(ev.argument)) {
- Inset * inset = new InsetFloatList(ev.argument);
+ InsetOld * inset = new InsetFloatList(ev.argument);
if (!insertInset(inset, tclass.defaultLayoutName()))
delete inset;
} else {
params2string(*par, data);
// Will the paragraph accept changes from the dialog?
- Inset * const inset = par->inInset();
+ InsetOld * const inset = par->inInset();
bool const accept =
!(inset && inset->forceDefaultParagraphs(inset));
// FIXME
if (arg.size() > 100 || arg.empty()) {
// Get word or selection
- bv_->getLyXText()->selectWordWhenUnderCursor(LyXText::WHOLE_WORD);
+ bv_->getLyXText()->selectWordWhenUnderCursor(lyx::WHOLE_WORD);
arg = bv_->getLyXText()->selectionAsString(buffer_, false);
// FIXME: where is getLyXText()->unselect(bv_) ?
}
#warning FIXME changes
//moveCursorUpdate(false);
- while (lyxfind::findNextChange(bv_)) {
+ while (lyx::find::findNextChange(bv_)) {
bv_->getLyXText()->acceptChange();
}
update(BufferView::SELECT);
#warning FIXME changes
//moveCursorUpdate(false);
- while (lyxfind::findNextChange(bv_)) {
+ while (lyx::find::findNextChange(bv_)) {
bv_->getLyXText()->rejectChange();
}
update(BufferView::SELECT);
}
-bool BufferView::Pimpl::insertInset(Inset * inset, string const & lout)
+bool BufferView::Pimpl::insertInset(InsetOld * inset, string const & lout)
{
// if we are in a locking inset we should try to insert the
// inset there otherwise this is a illegal function now
}
// not quite sure if we want this...
- setCursorParUndo(bv_);
+ recordUndo(bv_, Undo::ATOMIC);
freezeUndo();
beforeChange(bv_->text);
}
-void BufferView::Pimpl::updateInset(Inset * inset)
+void BufferView::Pimpl::updateInset(InsetOld * inset)
{
if (!inset || !available())
return;
// then check if the inset is a top_level inset (has no owner)
// if yes do the update as always otherwise we have to update the
// toplevel inset where this inset is inside
- Inset * tl_inset = inset;
+ InsetOld * tl_inset = inset;
while (tl_inset->owner())
tl_inset = tl_inset->owner();
if (tl_inset == inset) {
projects / lyx.git / blobdiff