#include "LyXFunc.h"
#include "BranchList.h"
-#include "Buffer.h"
#include "buffer_funcs.h"
+#include "Buffer.h"
#include "BufferList.h"
#include "BufferParams.h"
#include "BufferView.h"
-#include "bufferview_funcs.h"
+#include "callback.h"
+#include "Color.h"
#include "Cursor.h"
#include "CutAndPaste.h"
#include "debug.h"
#include "Intl.h"
#include "KeyMap.h"
#include "Language.h"
-#include "Color.h"
-#include "Session.h"
-#include "LyX.h"
-#include "callback.h"
+#include "Lexer.h"
#include "LyXAction.h"
#include "lyxfind.h"
-#include "Lexer.h"
+#include "LyX.h"
#include "LyXRC.h"
-#include "Row.h"
-#include "Server.h"
-#include "TextClassList.h"
#include "LyXVC.h"
#include "Paragraph.h"
-#include "ParIterator.h"
#include "ParagraphParameters.h"
+#include "ParIterator.h"
+#include "Row.h"
+#include "Server.h"
+#include "Session.h"
+#include "TextClassList.h"
+#include "ToolbarBackend.h"
#include "Undo.h"
#include "insets/InsetBox.h"
#include "frontends/Gui.h"
#include "frontends/KeySymbol.h"
#include "frontends/LyXView.h"
-#include "frontends/Menubar.h"
-#include "frontends/Toolbars.h"
#include "frontends/Selection.h"
+#include "frontends/WorkArea.h"
#include "support/environment.h"
#include "support/FileFilterList.h"
namespace lyx {
-using bv_funcs::freefont2string;
-
using frontend::LyXView;
using support::absolutePath;
namespace {
-bool getLocalStatus(Cursor cursor,
- FuncRequest const & cmd, FuncStatus & status)
+bool getLocalStatus(Cursor cursor, FuncRequest const & cmd, FuncStatus & status)
{
// Try to fix cursor in case it is broken.
cursor.fixIfBroken();
}
+
LyXFunc::LyXFunc()
- : lyx_view_(0),
- encoded_last_key(0),
- meta_fake_bit(key_modifier::none)
+ : lyx_view_(0), encoded_last_key(0), meta_fake_bit(key_modifier::none)
{
}
void LyXFunc::initKeySequences(KeyMap * kb)
{
- keyseq.reset(new KeySequence(kb, kb));
- cancel_meta_seq.reset(new KeySequence(kb, kb));
+ keyseq = KeySequence(kb, kb);
+ cancel_meta_seq = KeySequence(kb, kb);
}
void LyXFunc::setLyXView(LyXView * lv)
{
- if (!quitting && lyx_view_ && lyx_view_ != lv)
+ if (!quitting && lyx_view_ && lyx_view_->view() && lyx_view_ != lv)
// save current selection to the selection buffer to allow
// middle-button paste in another window
cap::saveSelection(lyx_view_->view()->cursor());
{
char_type c = encoded_last_key;
- if (keyseq->length())
+ if (keyseq.length())
c = 0;
BOOST_ASSERT(lyx_view_ && lyx_view_->view());
c, get_accent(action).accent, view()->cursor().innerText(), view()->cursor());
// Need to clear, in case the minibuffer calls these
// actions
- keyseq->clear();
+ keyseq.clear();
// copied verbatim from do_accent_char
view()->cursor().resetAnchor();
view()->update();
return;
}
// open may fail, so we need to test it again
- if (theBufferList().exists(file)) {
- // if the current buffer is not that one, switch to it.
- if (lyx_view_->buffer()->fileName() != file) {
- if (switchToBuffer)
- dispatch(FuncRequest(LFUN_BUFFER_SWITCH, file));
- else
- return;
- }
- // moveToPosition use par_id, and par_pit and return new par_id.
- pit_type new_pit;
- pos_type new_pos;
- int new_id;
- boost::tie(new_pit, new_pos, new_id) = view()->moveToPosition(bm.bottom_pit, bm.bottom_pos, bm.top_id, bm.top_pos);
- // if bottom_pit, bottom_pos or top_id has been changed, update bookmark
- // see http://bugzilla.lyx.org/show_bug.cgi?id=3092
- if (bm.bottom_pit != new_pit || bm.bottom_pos != new_pos || bm.top_id != new_id )
- const_cast<BookmarksSection::Bookmark &>(bm).updatePos(new_pit, new_pos, new_id);
+ if (!theBufferList().exists(file))
+ return;
+
+ // if the current buffer is not that one, switch to it.
+ if (lyx_view_->buffer()->fileName() != file) {
+ if (!switchToBuffer)
+ return;
+ dispatch(FuncRequest(LFUN_BUFFER_SWITCH, file));
+ }
+ // moveToPosition try paragraph id first and then paragraph (pit, pos).
+ if (!view()->moveToPosition(bm.bottom_pit, bm.bottom_pos,
+ bm.top_id, bm.top_pos))
+ return;
+
+ // Cursor jump succeeded!
+ Cursor const & cur = view()->cursor();
+ pit_type new_pit = cur.pit();
+ pos_type new_pos = cur.pos();
+ int new_id = cur.paragraph().id();
+
+ // if bottom_pit, bottom_pos or top_id has been changed, update bookmark
+ // see http://bugzilla.lyx.org/show_bug.cgi?id=3092
+ if (bm.bottom_pit != new_pit || bm.bottom_pos != new_pos
+ || bm.top_id != new_id) {
+ const_cast<BookmarksSection::Bookmark &>(bm).updatePos(
+ new_pit, new_pos, new_id);
}
}
-void LyXFunc::processKeySym(KeySymbolPtr keysym, key_modifier::state state)
+void LyXFunc::processKeySym(KeySymbol const & keysym,
+ key_modifier::state state)
{
- LYXERR(Debug::KEY) << "KeySym is " << keysym->getSymbolName() << endl;
+ LYXERR(Debug::KEY) << "KeySym is " << keysym.getSymbolName() << endl;
// Do nothing if we have nothing (JMarc)
- if (!keysym->isOK()) {
+ if (!keysym.isOK()) {
LYXERR(Debug::KEY) << "Empty kbd action (probably composing)"
<< endl;
return;
}
- if (keysym->isModifier()) {
+ if (keysym.isModifier()) {
LYXERR(Debug::KEY) << "isModifier true" << endl;
return;
}
//Encoding const * encoding = view()->cursor().getEncoding();
- //encoded_last_key = keysym->getISOEncoded(encoding ? encoding->name() : "");
+ //encoded_last_key = keysym.getISOEncoded(encoding ? encoding->name() : "");
// FIXME: encoded_last_key shadows the member variable of the same
// name. Is that intended?
- char_type encoded_last_key = keysym->getUCSEncoded();
+ char_type encoded_last_key = keysym.getUCSEncoded();
// Do a one-deep top-level lookup for
// cancel and meta-fake keys. RVDK_PATCH_5
- cancel_meta_seq->reset();
+ cancel_meta_seq.reset();
- FuncRequest func = cancel_meta_seq->addkey(keysym, state);
+ FuncRequest func = cancel_meta_seq.addkey(keysym, state);
LYXERR(Debug::KEY) << BOOST_CURRENT_FUNCTION
<< " action first set to [" << func.action << ']'
<< endl;
// Mostly, meta_fake_bit = key_modifier::none. RVDK_PATCH_5.
if ((func.action != LFUN_CANCEL) && (func.action != LFUN_META_PREFIX)) {
// remove Caps Lock and Mod2 as a modifiers
- func = keyseq->addkey(keysym, (state | meta_fake_bit));
+ func = keyseq.addkey(keysym, (state | meta_fake_bit));
LYXERR(Debug::KEY) << BOOST_CURRENT_FUNCTION
<< "action now set to ["
<< func.action << ']' << endl;
LYXERR(Debug::KEY) << BOOST_CURRENT_FUNCTION
<< " Key [action="
<< func.action << "]["
- << to_utf8(keyseq->print(false)) << ']'
+ << to_utf8(keyseq.print(false)) << ']'
<< endl;
// already here we know if it any point in going further
// why not return already here if action == -1 and
// num_bytes == 0? (Lgb)
- if (keyseq->length() > 1) {
- lyx_view_->message(keyseq->print(true));
+ if (keyseq.length() > 1) {
+ lyx_view_->message(keyseq.print(true));
}
if (func.action == LFUN_UNKNOWN_ACTION &&
state == key_modifier::shift) {
LYXERR(Debug::KEY) << "Trying without shift" << endl;
- func = keyseq->addkey(keysym, key_modifier::none);
+ func = keyseq.addkey(keysym, key_modifier::none);
LYXERR(Debug::KEY) << "Action now " << func.action << endl;
}
// Hmm, we didn't match any of the keysequences. See
// if it's normal insertable text not already covered
// by a binding
- if (keysym->isText() && keyseq->length() == 1) {
+ if (keysym.isText() && keyseq.length() == 1) {
LYXERR(Debug::KEY) << "isText() is true, inserting." << endl;
func = FuncRequest(LFUN_SELF_INSERT,
FuncRequest::KEYBOARD);
} else {
dispatch(func);
}
+
+ /* When we move around, or type, it's nice to be able to see
+ * the cursor immediately after the keypress.
+ */
+ if (lyx_view_ && lyx_view_->currentWorkArea())
+ lyx_view_->currentWorkArea()->startBlinkingCursor();
}
break;
case LFUN_TOOLBAR_TOGGLE: {
- bool const current = lyx_view_->getToolbars().visible(cmd.getArg(0));
+ bool const current = lyx_view_->isToolbarVisible(cmd.getArg(0));
flag.setOnOff(current);
break;
}
case LFUN_BUFFER_WRITE_AS:
case LFUN_BUFFER_UPDATE:
case LFUN_BUFFER_VIEW:
+ case LFUN_MASTER_BUFFER_UPDATE:
+ case LFUN_MASTER_BUFFER_VIEW:
case LFUN_BUFFER_IMPORT:
case LFUN_BUFFER_AUTO_SAVE:
case LFUN_RECONFIGURE:
case LFUN_TEXTCLASS_LOAD:
case LFUN_BUFFER_SAVE_AS_DEFAULT:
case LFUN_BUFFER_PARAMS_APPLY:
+ case LFUN_LAYOUT_MODULES_CLEAR:
+ case LFUN_LAYOUT_MODULE_ADD:
+ case LFUN_LAYOUT_RELOAD:
case LFUN_LYXRC_APPLY:
case LFUN_BUFFER_NEXT:
case LFUN_BUFFER_PREVIOUS:
bool LyXFunc::ensureBufferClean(BufferView * bv)
{
- Buffer & buf = *bv->buffer();
+ Buffer & buf = bv->buffer();
if (buf.isClean())
return true;
}
-void loadTextclass(string const & name)
+void loadTextClass(string const & name)
{
std::pair<bool, textclass_type> const tc_pair =
textclasslist.numberOfClass(name);
textclass_type const tc = tc_pair.second;
if (!textclasslist[tc].load()) {
- docstring s = bformat(_("The document could not be converted\n"
- "into the document class %1$s."),
+ docstring s = bformat(_("The document class %1$s."
+ "could not be loaded."),
from_utf8(textclasslist[tc].name()));
- Alert::error(_("Could not change class"), s);
+ Alert::error(_("Could not load class"), s);
}
}
case LFUN_COMMAND_PREFIX:
BOOST_ASSERT(lyx_view_);
- lyx_view_->message(keyseq->printOptions(true));
+ lyx_view_->message(keyseq.printOptions(true));
break;
case LFUN_COMMAND_EXECUTE:
BOOST_ASSERT(lyx_view_);
- lyx_view_->getToolbars().display("minibuffer", true);
- lyx_view_->focus_command_buffer();
+ lyx_view_->showMiniBuffer(true);
break;
case LFUN_CANCEL:
BOOST_ASSERT(lyx_view_ && lyx_view_->view());
- keyseq->reset();
+ keyseq.reset();
meta_fake_bit = key_modifier::none;
if (lyx_view_->buffer())
// cancel any selection
case LFUN_META_PREFIX:
meta_fake_bit = key_modifier::alt;
- setMessage(keyseq->print(true));
+ setMessage(keyseq.print(true));
break;
case LFUN_BUFFER_TOGGLE_READ_ONLY:
// --- Menus -----------------------------------------------
case LFUN_BUFFER_NEW:
menuNew(argument, false);
+ updateFlags = Update::None;
break;
case LFUN_BUFFER_NEW_TEMPLATE:
menuNew(argument, true);
+ updateFlags = Update::None;
break;
case LFUN_BUFFER_CLOSE:
closeBuffer();
- view()->update();
+ updateFlags = Update::None;
break;
case LFUN_BUFFER_WRITE:
Exporter::preview(lyx_view_->buffer(), argument);
break;
+ case LFUN_MASTER_BUFFER_UPDATE:
+ BOOST_ASSERT(lyx_view_ && lyx_view_->buffer() && lyx_view_->buffer()->getMasterBuffer());
+ Exporter::Export(lyx_view_->buffer()->getMasterBuffer(), argument, true);
+ break;
+
+ case LFUN_MASTER_BUFFER_VIEW:
+ BOOST_ASSERT(lyx_view_ && lyx_view_->buffer() && lyx_view_->buffer()->getMasterBuffer());
+ Exporter::preview(lyx_view_->buffer()->getMasterBuffer(), argument);
+ break;
+
case LFUN_BUILD_PROGRAM:
BOOST_ASSERT(lyx_view_ && lyx_view_->buffer());
Exporter::Export(lyx_view_->buffer(), "program", true);
case LFUN_RECONFIGURE:
BOOST_ASSERT(lyx_view_);
- reconfigure(*lyx_view_);
+ // argument is any additional parameter to the configure.py command
+ reconfigure(*lyx_view_, argument);
break;
case LFUN_HELP_OPEN: {
}
lyx_view_->message(bformat(_("Opening help file %1$s..."),
makeDisplayPath(fname.absFilename())));
- lyx_view_->loadLyXFile(fname, false);
+ Buffer * buf = lyx_view_->loadLyXFile(fname, false);
+ if (buf) {
+ updateLabels(*buf);
+ lyx_view_->setBuffer(buf);
+ lyx_view_->showErrorList("Parse");
+ }
+ updateFlags = Update::None;
break;
}
case LFUN_BUFFER_SWITCH:
BOOST_ASSERT(lyx_view_);
lyx_view_->setBuffer(theBufferList().getBuffer(argument));
- updateFlags = Update::Force;
+ updateFlags = Update::None;
break;
case LFUN_BUFFER_NEXT:
BOOST_ASSERT(lyx_view_);
lyx_view_->setBuffer(theBufferList().next(lyx_view_->buffer()));
- updateFlags = Update::Force;
+ updateFlags = Update::None;
break;
case LFUN_BUFFER_PREVIOUS:
BOOST_ASSERT(lyx_view_);
lyx_view_->setBuffer(theBufferList().previous(lyx_view_->buffer()));
- updateFlags = Update::Force;
+ updateFlags = Update::None;
break;
case LFUN_FILE_NEW:
BOOST_ASSERT(lyx_view_);
newFile(*lyx_view_, argument);
+ updateFlags = Update::None;
break;
case LFUN_FILE_OPEN:
BOOST_ASSERT(lyx_view_);
open(argument);
+ updateFlags = Update::None;
break;
case LFUN_DROP_LAYOUTS_CHOICE:
BOOST_ASSERT(lyx_view_);
- lyx_view_->getToolbars().openLayoutList();
+ lyx_view_->openLayoutList();
break;
case LFUN_MENU_OPEN:
BOOST_ASSERT(lyx_view_);
- lyx_view_->getMenubar().openByName(from_utf8(argument));
+ lyx_view_->openMenu(from_utf8(argument));
break;
// --- lyxserver commands ----------------------------
break;
case LFUN_SERVER_NOTIFY:
- dispatch_buffer = keyseq->print(false);
+ dispatch_buffer = keyseq.print(false);
theServer().notifyClient(to_utf8(dispatch_buffer));
break;
int row;
istringstream is(argument);
is >> file_name >> row;
- if (prefixIs(file_name, package().temp_dir().absFilename())) {
+ Buffer * buf = 0;
+ bool loaded = false;
+ if (prefixIs(file_name, package().temp_dir().absFilename()))
// Needed by inverse dvi search. If it is a file
// in tmpdir, call the apropriated function
- lyx_view_->setBuffer(theBufferList().getBufferFromTmp(file_name));
- } else {
+ buf = theBufferList().getBufferFromTmp(file_name);
+ else {
// Must replace extension of the file to be .lyx
// and get full path
FileName const s = fileSearch(string(), changeExtension(file_name, ".lyx"), "lyx");
// Either change buffer or load the file
- if (theBufferList().exists(s.absFilename())) {
- lyx_view_->setBuffer(theBufferList().getBuffer(s.absFilename()));
- } else {
- lyx_view_->loadLyXFile(s);
+ if (theBufferList().exists(s.absFilename()))
+ buf = theBufferList().getBuffer(s.absFilename());
+ else {
+ buf = lyx_view_->loadLyXFile(s);
+ loaded = true;
}
}
- view()->setCursorFromRow(row);
+ if (!buf) {
+ updateFlags = Update::None;
+ break;
+ }
+ updateLabels(*buf);
+ lyx_view_->setBuffer(buf);
+ view()->setCursorFromRow(row);
+ if (loaded)
+ lyx_view_->showErrorList("Parse");
updateFlags = Update::FitCursor;
break;
}
InsetBranchParams p;
data = InsetBranchMailer::params2string(p);
} else if (name == "citation") {
- InsetCommandParams p("cite");
+ InsetCommandParams p("citation");
data = InsetCommandMailer::params2string(name, p);
} else if (name == "ert") {
data = InsetERTMailer::params2string(InsetCollapsable::Open);
arg = token(argument, '|', 0);
opt1 = token(argument, '|', 1);
}
- InsetCommandParams icp("cite");
+ InsetCommandParams icp("citation");
icp["key"] = from_utf8(arg);
if (!opt1.empty())
icp["before"] = from_utf8(opt1);
}
case LFUN_BUFFER_CHILD_OPEN: {
- // takes an optional argument, "|bool", at the end
- // indicating whether this file is being opened automatically
- // by LyX itself, in which case we will not want to switch
- // buffers after opening. The default is false, so in practice
- // it is used only when true.
- BOOST_ASSERT(lyx_view_);
- int const arglength = argument.length();
- FileName filename;
- bool autoOpen = false;
- if (argument.substr(arglength - 5, 5) == "|true") {
- autoOpen = true;
- filename = makeAbsPath(argument.substr(0, arglength - 5),
- lyx_view_->buffer()->filePath());
- } else if (argument.substr(arglength - 6, 6) == "|false") {
- filename = makeAbsPath(argument.substr(0, arglength - 6),
- lyx_view_->buffer()->filePath());
- } else filename =
- makeAbsPath(argument, lyx_view_->buffer()->filePath());
+ BOOST_ASSERT(lyx_view_ && lyx_view_->buffer());
+ Buffer * parent = lyx_view_->buffer();
+ FileName filename = makeAbsPath(argument, parent->filePath());
view()->saveBookmark(false);
+ Buffer * child = 0;
+ bool parsed = false;
if (theBufferList().exists(filename.absFilename())) {
- Buffer * buf = theBufferList().getBuffer(filename.absFilename());
- if (!autoOpen)
- lyx_view_->setBuffer(buf, true);
- else
- buf->setParentName(lyx_view_->buffer()->fileName());
- } else
- lyx_view_->loadLyXFile(filename, true, true, autoOpen);
+ child = theBufferList().getBuffer(filename.absFilename());
+ } else {
+ setMessage(bformat(_("Opening child document %1$s..."),
+ makeDisplayPath(filename.absFilename())));
+ child = lyx_view_->loadLyXFile(filename, true);
+ parsed = true;
+ }
+ if (child) {
+ // Set the parent name of the child document.
+ // This makes insertion of citations and references in the child work,
+ // when the target is in the parent or another child document.
+ child->setParentName(parent->fileName());
+ updateLabels(*child->getMasterBuffer());
+ lyx_view_->setBuffer(child);
+ if (parsed)
+ lyx_view_->showErrorList("Parse");
+ }
// If a screen update is required (in case where auto_open is false),
- // loadLyXFile() would have taken care of it already. Otherwise we shall
+ // setBuffer() would have taken care of it already. Otherwise we shall
// reset the update flag because it can cause a circular problem.
// See bug 3970.
updateFlags = Update::None;
case LFUN_BUFFER_PARAMS_APPLY: {
BOOST_ASSERT(lyx_view_);
- biblio::CiteEngine const engine =
- lyx_view_->buffer()->params().getEngine();
+ biblio::CiteEngine const oldEngine =
+ lyx_view_->buffer()->params().getEngine();
+
+ Buffer * buffer = lyx_view_->buffer();
+ TextClassPtr oldClass = buffer->params().getTextClassPtr();
+ recordUndoFullDocument(view());
+
istringstream ss(argument);
Lexer lex(0,0);
lex.setStream(ss);
- int const unknown_tokens =
- lyx_view_->buffer()->readHeader(lex);
+ int const unknown_tokens = buffer->readHeader(lex);
if (unknown_tokens != 0) {
lyxerr << "Warning in LFUN_BUFFER_PARAMS_APPLY!\n"
- << unknown_tokens << " unknown token"
- << (unknown_tokens == 1 ? "" : "s")
- << endl;
+ << unknown_tokens << " unknown token"
+ << (unknown_tokens == 1 ? "" : "s")
+ << endl;
}
- if (engine == lyx_view_->buffer()->params().getEngine())
- break;
-
- Cursor & cur = view()->cursor();
- FuncRequest fr(LFUN_INSET_REFRESH);
-
- Inset & inset = lyx_view_->buffer()->inset();
- InsetIterator it = inset_iterator_begin(inset);
- InsetIterator const end = inset_iterator_end(inset);
- for (; it != end; ++it)
- if (it->lyxCode() == Inset::CITE_CODE)
- it->dispatch(cur, fr);
+
+ updateLayout(oldClass, buffer);
+
+ biblio::CiteEngine const newEngine =
+ lyx_view_->buffer()->params().getEngine();
+
+ if (oldEngine != newEngine) {
+ Cursor & cur = view()->cursor();
+ FuncRequest fr(LFUN_INSET_REFRESH);
+
+ Inset & inset = lyx_view_->buffer()->inset();
+ InsetIterator it = inset_iterator_begin(inset);
+ InsetIterator const end = inset_iterator_end(inset);
+ for (; it != end; ++it)
+ if (it->lyxCode() == Inset::CITE_CODE)
+ it->dispatch(cur, fr);
+ }
+
+ updateFlags = Update::Force | Update::FitCursor;
+ break;
+ }
+
+ case LFUN_LAYOUT_MODULES_CLEAR: {
+ BOOST_ASSERT(lyx_view_);
+ Buffer * buffer = lyx_view_->buffer();
+ TextClassPtr oldClass = buffer->params().getTextClassPtr();
+ recordUndoFullDocument(view());
+ buffer->params().clearLayoutModules();
+ updateLayout(oldClass, buffer);
+ updateFlags = Update::Force | Update::FitCursor;
+ break;
+ }
+
+ case LFUN_LAYOUT_MODULE_ADD: {
+ BOOST_ASSERT(lyx_view_);
+ Buffer * buffer = lyx_view_->buffer();
+ TextClassPtr oldClass = buffer->params().getTextClassPtr();
+ recordUndoFullDocument(view());
+ buffer->params().addLayoutModule(argument);
+ updateLayout(oldClass, buffer);
+ updateFlags = Update::Force | Update::FitCursor;
break;
}
BOOST_ASSERT(lyx_view_);
Buffer * buffer = lyx_view_->buffer();
- textclass_type const old_class =
- buffer->params().textclass;
-
- loadTextclass(argument);
+ loadTextClass(argument);
std::pair<bool, textclass_type> const tc_pair =
textclasslist.numberOfClass(argument);
if (!tc_pair.first)
break;
+ textclass_type const old_class = buffer->params().getBaseClass();
textclass_type const new_class = tc_pair.second;
+
if (old_class == new_class)
// nothing to do
break;
- lyx_view_->message(_("Converting document to new document class..."));
+ //Save the old, possibly modular, layout for use in conversion.
+ TextClassPtr oldClass = buffer->params().getTextClassPtr();
recordUndoFullDocument(view());
- buffer->params().textclass = new_class;
- StableDocIterator backcur(view()->cursor());
- ErrorList & el = buffer->errorList("Class Switch");
- cap::switchBetweenClasses(
- old_class, new_class,
- static_cast<InsetText &>(buffer->inset()), el);
-
- view()->setCursor(backcur.asDocIterator(&(buffer->inset())));
-
- buffer->errors("Class Switch");
- updateLabels(*buffer);
+ buffer->params().setBaseClass(new_class);
+ updateLayout(oldClass, buffer);
+ updateFlags = Update::Force | Update::FitCursor;
+ break;
+ }
+
+ case LFUN_LAYOUT_RELOAD: {
+ BOOST_ASSERT(lyx_view_);
+ Buffer * buffer = lyx_view_->buffer();
+ TextClassPtr oldClass = buffer->params().getTextClassPtr();
+ textclass_type const tc = buffer->params().getBaseClass();
+ textclasslist.reset(tc);
+ buffer->params().setBaseClass(tc);
+ updateLayout(oldClass, buffer);
updateFlags = Update::Force | Update::FitCursor;
break;
}
case LFUN_TEXTCLASS_LOAD:
- loadTextclass(argument);
+ loadTextClass(argument);
break;
case LFUN_LYXRC_APPLY: {
}
}
if (!quitting && lyx_view_) {
- lyx_view_->updateMenubar();
lyx_view_->updateToolbars();
// Some messages may already be translated, so we cannot use _()
sendDispatchMessage(translateIfPossible(getMessage()), cmd);
}
Buffer * const b = newFile(filename, templname, !name.empty());
- if (b) {
- //updateLabels(*b);
+ if (b)
lyx_view_->setBuffer(b);
- }
}
lyx_view_->message(bformat(_("Opening document %1$s..."), disp_fn));
docstring str2;
- if (lyx_view_->loadLyXFile(fullname)) {
+ Buffer * buf = lyx_view_->loadLyXFile(fullname);
+ if (buf) {
+ updateLabels(*buf);
+ lyx_view_->setBuffer(buf);
+ lyx_view_->showErrorList("Parse");
str2 = bformat(_("Document %1$s opened."), disp_fn);
} else {
str2 = bformat(_("Could not open document %1$s"), disp_fn);
void LyXFunc::reloadBuffer()
{
FileName filename(lyx_view_->buffer()->fileName());
+ docstring const disp_fn = makeDisplayPath(filename.absFilename());
+ docstring str;
closeBuffer();
- lyx_view_->loadLyXFile(filename);
+ Buffer * buf = lyx_view_->loadLyXFile(filename);
+ if (buf) {
+ updateLabels(*buf);
+ lyx_view_->setBuffer(buf);
+ lyx_view_->showErrorList("Parse");
+ str = bformat(_("Document %1$s reloaded."), disp_fn);
+ } else {
+ str = bformat(_("Could not reload document %1$s"), disp_fn);
+ }
+ lyx_view_->message(str);
}
// Each "lyx_view_" should have it's own message method. lyxview and
{
// When meta-fake key is pressed, show the key sequence so far + "M-".
if (wasMetaKey())
- return keyseq->print(true) + "M-";
+ return keyseq.print(true) + "M-";
// Else, when a non-complete key sequence is pressed,
// show the available options.
- if (keyseq->length() > 0 && !keyseq->deleted())
- return keyseq->printOptions(true);
+ if (keyseq.length() > 0 && !keyseq.deleted())
+ return keyseq.printOptions(true);
BOOST_ASSERT(lyx_view_);
if (!lyx_view_->buffer())
}
+void LyXFunc::updateLayout(TextClassPtr const & oldlayout,
+ Buffer * buffer)
+{
+ lyx_view_->message(_("Converting document to new document class..."));
+
+ StableDocIterator backcur(view()->cursor());
+ ErrorList & el = buffer->errorList("Class Switch");
+ cap::switchBetweenClasses(
+ oldlayout, buffer->params().getTextClassPtr(),
+ static_cast<InsetText &>(buffer->inset()), el);
+
+ view()->setCursor(backcur.asDocIterator(&(buffer->inset())));
+
+ buffer->errors("Class Switch");
+ updateLabels(*buffer);
+}
+
+
namespace {
void actOnUpdatedPrefs(LyXRC const & lyxrc_orig, LyXRC const & lyxrc_new)