#include "bufferlist.h"
#include "bufferparams.h"
#include "BufferView.h"
+#include "bufferview_funcs.h"
#include "cursor.h"
#include "CutAndPaste.h"
#include "debug.h"
#include "exporter.h"
#include "format.h"
#include "funcrequest.h"
+#include "FuncStatus.h"
#include "gettext.h"
#include "importer.h"
#include "insetiterator.h"
#include "kbmap.h"
#include "language.h"
#include "LColor.h"
+#include "session.h"
+#include "lyx_main.h"
#include "lyx_cb.h"
#include "LyXAction.h"
#include "lyxfind.h"
#include "insets/insetexternal.h"
#include "insets/insetfloat.h"
#include "insets/insetgraphics.h"
+#include "insets/insetinclude.h"
#include "insets/insetnote.h"
#include "insets/insettabular.h"
#include "insets/insetvspace.h"
#include "insets/insetwrap.h"
+#include "frontends/Application.h"
#include "frontends/Alert.h"
#include "frontends/Dialogs.h"
#include "frontends/FileDialog.h"
-#include "frontends/lyx_gui.h"
+#include "frontends/FontLoader.h"
+#include "frontends/Gui.h"
#include "frontends/LyXKeySym.h"
#include "frontends/LyXView.h"
#include "frontends/Menubar.h"
#include <sstream>
+
+namespace lyx {
+
using bv_funcs::freefont2string;
-using lyx::support::AbsolutePath;
-using lyx::support::AddName;
-using lyx::support::AddPath;
-using lyx::support::bformat;
-using lyx::support::ChangeExtension;
-using lyx::support::contains;
-using lyx::support::FileFilterList;
-using lyx::support::FileSearch;
-using lyx::support::ForkedcallsController;
-using lyx::support::i18nLibFileSearch;
-using lyx::support::IsDirWriteable;
-using lyx::support::IsFileReadable;
-using lyx::support::isStrInt;
-using lyx::support::MakeAbsPath;
-using lyx::support::MakeDisplayPath;
-using lyx::support::package;
-using lyx::support::Path;
-using lyx::support::QuoteName;
-using lyx::support::rtrim;
-using lyx::support::split;
-using lyx::support::subst;
-using lyx::support::Systemcall;
-using lyx::support::token;
-using lyx::support::trim;
-using lyx::support::prefixIs;
+using support::absolutePath;
+using support::addName;
+using support::addPath;
+using support::bformat;
+using support::changeExtension;
+using support::contains;
+using support::FileFilterList;
+using support::FileName;
+using support::fileSearch;
+using support::ForkedcallsController;
+using support::i18nLibFileSearch;
+using support::isDirWriteable;
+using support::isFileReadable;
+using support::isStrInt;
+using support::makeAbsPath;
+using support::makeDisplayPath;
+using support::package;
+using support::quoteName;
+using support::rtrim;
+using support::split;
+using support::subst;
+using support::Systemcall;
+using support::token;
+using support::trim;
+using support::prefixIs;
using std::endl;
using std::make_pair;
using std::pair;
using std::string;
using std::istringstream;
+using std::ostringstream;
-namespace biblio = lyx::biblio;
+namespace Alert = frontend::Alert;
namespace fs = boost::filesystem;
-extern BufferList bufferlist;
-extern LyXServer * lyxserver;
-
-extern boost::scoped_ptr<kb_keymap> toplevel_keymap;
-
// (alkis)
extern tex_accent_struct get_accent(kb_action action);
namespace {
-bool getStatus(LCursor cursor,
+bool getLocalStatus(LCursor cursor,
FuncRequest const & cmd, FuncStatus & status)
{
// Try to fix cursor in case it is broken.
return res;
}
+
+/** Return the change status at cursor position, taking in account the
+ * status at each level of the document iterator (a table in a deleted
+ * footnote is deleted).
+ * When \param outer is true, the top slice is not looked at.
+ */
+Change::Type lookupChangeType(DocIterator const & dit, bool outer = false)
+{
+ size_t const depth = dit.depth() - (outer ? 1 : 0);
+
+ for (size_t i = 0 ; i < depth ; ++i) {
+ CursorSlice const & slice = dit[i];
+ if (!slice.inset().inMathed()
+ && slice.pos() < slice.paragraph().size()) {
+ Change::Type const ch = slice.paragraph().lookupChange(slice.pos()).type;
+ if (ch != Change::UNCHANGED)
+ return ch;
+ }
+ }
+ return Change::UNCHANGED;
}
-LyXFunc::LyXFunc(LyXView * lv)
- : owner(lv),
+}
+
+LyXFunc::LyXFunc()
+ : lyx_view_(0),
encoded_last_key(0),
- keyseq(toplevel_keymap.get(), toplevel_keymap.get()),
- cancel_meta_seq(toplevel_keymap.get(), toplevel_keymap.get()),
meta_fake_bit(key_modifier::none)
{
}
+void LyXFunc::initKeySequences(kb_keymap * kb)
+{
+ keyseq.reset(new kb_sequence(kb, kb));
+ cancel_meta_seq.reset(new kb_sequence(kb, kb));
+}
+
+
+void LyXFunc::setLyXView(LyXView * lv)
+{
+ lyx_view_ = lv;
+}
+
+
void LyXFunc::handleKeyFunc(kb_action action)
{
- char c = encoded_last_key;
+ char_type c = encoded_last_key;
- if (keyseq.length()) {
+ if (keyseq->length())
c = 0;
- }
- owner->getIntl().getTransManager()
- .deadkey(c, get_accent(action).accent, view()->getLyXText());
+ lyx_view_->view()->getIntl().getTransManager().deadkey(
+ 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();
}
+void LyXFunc::gotoBookmark(unsigned int idx, bool openFile, bool switchToBuffer)
+{
+ BOOST_ASSERT(lyx_view_);
+ if (!LyX::ref().session().bookmarks().isValid(idx))
+ return;
+ BookmarksSection::Bookmark const & bm = LyX::ref().session().bookmarks().bookmark(idx);
+ BOOST_ASSERT(!bm.filename.empty());
+ string const file = bm.filename.absFilename();
+ // if the file is not opened, open it.
+ if (!theBufferList().exists(file)) {
+ if (openFile)
+ dispatch(FuncRequest(LFUN_FILE_OPEN, file));
+ else
+ 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;
+ int new_id;
+ boost::tie(new_pit, new_id) = view()->moveToPosition(bm.par_pit, bm.par_id, bm.par_pos);
+ // if par_id or pit has been changed, reset par_pit and par_id
+ // see http://bugzilla.lyx.org/show_bug.cgi?id=3092
+ if (bm.par_pit != new_pit || bm.par_id != new_id)
+ const_cast<BookmarksSection::Bookmark &>(bm).setPos(new_pit, new_id);
+ }
+}
+
+
void LyXFunc::processKeySym(LyXKeySymPtr keysym, key_modifier::state state)
{
lyxerr[Debug::KEY] << "KeySym is " << keysym->getSymbolName() << endl;
return;
}
- Encoding const * encoding = view()->cursor().getEncoding();
-
- encoded_last_key = keysym->getISOEncoded(encoding ? encoding->Name() : "");
+ //Encoding const * encoding = view()->cursor().getEncoding();
+ //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();
// 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;
// When not cancel or meta-fake, do the normal lookup.
// Note how the meta_fake Mod1 bit is OR-ed in and reset afterwards.
// Mostly, meta_fake_bit = key_modifier::none. RVDK_PATCH_5.
- if ((func.action != LFUN_CANCEL) && (func.action != LFUN_META_FAKE)) {
+ 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;
// Can this happen now ?
if (func.action == LFUN_NOACTION) {
- func = FuncRequest(LFUN_PREFIX);
+ func = FuncRequest(LFUN_COMMAND_PREFIX);
}
if (lyxerr.debugging(Debug::KEY)) {
lyxerr << BOOST_CURRENT_FUNCTION
<< " Key [action="
<< func.action << "]["
- << keyseq.print() << ']'
+ << to_utf8(keyseq->print(false)) << ']'
<< endl;
}
// why not return already here if action == -1 and
// num_bytes == 0? (Lgb)
- if (keyseq.length() > 1) {
- owner->message(keyseq.print());
+ 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_SELFINSERT);
+ func = FuncRequest(LFUN_SELF_INSERT,
+ FuncRequest::KEYBOARD);
} else {
lyxerr[Debug::KEY] << "Unknown, !isText() - giving up" << endl;
- owner->message(_("Unknown function."));
+ lyx_view_->message(_("Unknown function."));
return;
}
}
- if (func.action == LFUN_SELFINSERT) {
+ if (func.action == LFUN_SELF_INSERT) {
if (encoded_last_key != 0) {
- string const arg(1, encoded_last_key);
- dispatch(FuncRequest(LFUN_SELFINSERT, arg));
+ docstring const arg(1, encoded_last_key);
+ dispatch(FuncRequest(LFUN_SELF_INSERT, arg,
+ FuncRequest::KEYBOARD));
lyxerr[Debug::KEY]
- << "SelfInsert arg[`" << arg << "']" << endl;
+ << "SelfInsert arg[`" << to_utf8(arg) << "']" << endl;
}
} else {
dispatch(func);
{
//lyxerr << "LyXFunc::getStatus: cmd: " << cmd << endl;
FuncStatus flag;
+
LCursor & cur = view()->cursor();
/* In LyX/Mac, when a dialog is open, the menus of the
application can still be accessed without giving focus to
the main window. In this case, we want to disable the menu
entries that are buffer-related.
+
+ Note that this code is not perfect, as bug 1941 attests:
+ http://bugzilla.lyx.org/show_bug.cgi?id=1941#c4
*/
- Buffer * buf;
- if (cmd.origin == FuncRequest::UI && !owner->hasFocus())
+ Buffer * buf = lyx_view_? lyx_view_->buffer() : 0;
+ if (lyx_view_ && cmd.origin == FuncRequest::MENU && !lyx_view_->hasFocus())
buf = 0;
- else
- buf = owner->buffer();
if (cmd.action == LFUN_NOACTION) {
- flag.message(N_("Nothing to do"));
+ flag.message(from_utf8(N_("Nothing to do")));
flag.enabled(false);
return flag;
}
flag.unknown(true);
flag.enabled(false);
break;
+
default:
- flag |= lyx_gui::getStatus(cmd);
+ break;
}
if (flag.unknown()) {
- flag.message(N_("Unknown action"));
+ flag.message(from_utf8(N_("Unknown action")));
return flag;
}
if (!flag.enabled()) {
if (flag.message().empty())
- flag.message(N_("Command disabled"));
+ flag.message(from_utf8(N_("Command disabled")));
return flag;
}
// Check whether we need a buffer
if (!lyxaction.funcHasFlag(cmd.action, LyXAction::NoBuffer) && !buf) {
// no, exit directly
- flag.message(N_("Command not allowed with"
- "out any document open"));
+ flag.message(from_utf8(N_("Command not allowed with"
+ "out any document open")));
flag.enabled(false);
return flag;
}
// to handle (Andre')
bool enable = true;
switch (cmd.action) {
- case LFUN_TOOLTIPS_TOGGLE:
- flag.setOnOff(owner->getDialogs().tooltipsEnabled());
- break;
-
- case LFUN_READ_ONLY_TOGGLE:
+ case LFUN_BUFFER_TOGGLE_READ_ONLY:
flag.setOnOff(buf->isReadonly());
break;
- case LFUN_SWITCHBUFFER:
+ case LFUN_BUFFER_SWITCH:
// toggle on the current buffer, but do not toggle off
// the other ones (is that a good idea?)
- if (cmd.argument == buf->fileName())
+ if (to_utf8(cmd.argument()) == buf->fileName())
flag.setOnOff(true);
break;
- case LFUN_EXPORT:
- enable = cmd.argument == "custom"
- || Exporter::IsExportable(*buf, cmd.argument);
- break;
- case LFUN_CUT:
- case LFUN_COPY:
- enable = cur.selection();
+ case LFUN_BUFFER_EXPORT:
+ enable = cmd.argument() == "custom"
+ || Exporter::isExportable(*buf, to_utf8(cmd.argument()));
break;
- case LFUN_RUNCHKTEX:
- enable = buf->isLatex() && lyxrc.chktex_command != "none";
+ case LFUN_BUFFER_CHKTEX:
+ enable = buf->isLatex() && !lyxrc.chktex_command.empty();
break;
- case LFUN_BUILDPROG:
- enable = Exporter::IsExportable(*buf, "program");
+ case LFUN_BUILD_PROGRAM:
+ enable = Exporter::isExportable(*buf, "program");
break;
case LFUN_LAYOUT_TABULAR:
case LFUN_LAYOUT:
case LFUN_LAYOUT_PARAGRAPH:
- enable = !cur.inset().forceDefaultParagraphs(&cur.inset());
+ enable = !cur.inset().forceDefaultParagraphs(cur.idx());
break;
case LFUN_VC_REGISTER:
enable = !buf->lyxvc().inUse();
break;
- case LFUN_VC_CHECKIN:
+ case LFUN_VC_CHECK_IN:
enable = buf->lyxvc().inUse() && !buf->isReadonly();
break;
- case LFUN_VC_CHECKOUT:
+ case LFUN_VC_CHECK_OUT:
enable = buf->lyxvc().inUse() && buf->isReadonly();
break;
case LFUN_VC_REVERT:
- case LFUN_VC_UNDO:
+ case LFUN_VC_UNDO_LAST:
enable = buf->lyxvc().inUse();
break;
- case LFUN_MENURELOAD:
+ case LFUN_BUFFER_RELOAD:
enable = !buf->isUnnamed() && !buf->isClean();
break;
enable = false;
if (!cur)
break;
- UpdatableInset * inset = cur.inset().asUpdatableInset();
- lyxerr << "inset: " << inset << endl;
- if (!inset)
- break;
-
- InsetBase::Code code = inset->lyxCode();
+ InsetBase::Code code = cur.inset().lyxCode();
switch (code) {
case InsetBase::TABULAR_CODE:
- enable = cmd.argument == "tabular";
+ enable = cmd.argument() == "tabular";
break;
case InsetBase::ERT_CODE:
- enable = cmd.argument == "ert";
+ enable = cmd.argument() == "ert";
break;
case InsetBase::FLOAT_CODE:
- enable = cmd.argument == "float";
+ enable = cmd.argument() == "float";
break;
case InsetBase::WRAP_CODE:
- enable = cmd.argument == "wrap";
+ enable = cmd.argument() == "wrap";
break;
case InsetBase::NOTE_CODE:
- enable = cmd.argument == "note";
+ enable = cmd.argument() == "note";
break;
case InsetBase::BRANCH_CODE:
- enable = cmd.argument == "branch";
+ enable = cmd.argument() == "branch";
break;
case InsetBase::BOX_CODE:
- enable = cmd.argument == "box";
+ enable = cmd.argument() == "box";
break;
default:
break;
case LFUN_INSET_APPLY: {
string const name = cmd.getArg(0);
- InsetBase * inset = owner->getDialogs().getOpenInset(name);
+ InsetBase * inset = lyx_view_->getDialogs().getOpenInset(name);
if (inset) {
- FuncRequest fr(LFUN_INSET_MODIFY, cmd.argument);
+ FuncRequest fr(LFUN_INSET_MODIFY, cmd.argument());
FuncStatus fs;
- bool const success = inset->getStatus(cur, fr, fs);
- // Every inset is supposed to handle this
- BOOST_ASSERT(success);
+ if (!inset->getStatus(cur, fr, fs)) {
+ // Every inset is supposed to handle this
+ BOOST_ASSERT(false);
+ }
flag |= fs;
} else {
- FuncRequest fr(LFUN_INSET_INSERT, cmd.argument);
+ FuncRequest fr(LFUN_INSET_INSERT, cmd.argument());
flag |= getStatus(fr);
}
enable = flag.enabled();
|| name == "prefs"
|| name == "texinfo";
else if (name == "print")
- enable = Exporter::IsExportable(*buf, "dvi")
+ enable = Exporter::isExportable(*buf, "dvi")
&& lyxrc.print_command != "none";
else if (name == "character" || name == "mathpanel")
enable = cur.inset().lyxCode() != InsetBase::ERT_CODE;
else if (name == "latexlog")
- enable = IsFileReadable(buf->getLogName().second);
+ enable = isFileReadable(FileName(buf->getLogName().second));
#if !defined (USE_ASPELL) && !defined (USE_ISPELL) && !defined (USE_PSPELL)
else if (name == "spellchecker")
enable = false;
#endif
else if (name == "vclog")
enable = buf->lyxvc().inUse();
+ else if (name == "view-source")
+ enable = buf;
break;
}
case LFUN_DIALOG_SHOW_NEW_INSET:
enable = cur.inset().lyxCode() != InsetBase::ERT_CODE;
+ if (cur.inset().lyxCode() == InsetBase::CAPTION_CODE) {
+ FuncStatus flag;
+ if (cur.inset().getStatus(cur, cmd, flag))
+ return flag;
+ }
break;
case LFUN_DIALOG_UPDATE: {
break;
}
+ case LFUN_CITATION_INSERT: {
+ FuncRequest fr(LFUN_INSET_INSERT, "citation");
+ enable = getStatus(fr).enabled();
+ break;
+ }
+
+ case LFUN_BUFFER_WRITE: {
+ enable = view()->buffer()->isUnnamed()
+ || !view()->buffer()->isClean();
+ break;
+ }
+
+ case LFUN_BOOKMARK_GOTO: {
+ const unsigned int num = convert<unsigned int>(to_utf8(cmd.argument()));
+ enable = LyX::ref().session().bookmarks().isValid(num);
+ break;
+ }
+
+ case LFUN_BOOKMARK_CLEAR:
+ enable = LyX::ref().session().bookmarks().size() > 0;
+ break;
+
+ case LFUN_TOOLBAR_TOGGLE_STATE: {
+ ToolbarBackend::Flags flags = lyx_view_->getToolbarState(to_utf8(cmd.argument()));
+ if (!(flags & ToolbarBackend::AUTO))
+ flag.setOnOff(flags & ToolbarBackend::ON);
+ break;
+ }
+
// this one is difficult to get right. As a half-baked
// solution, we consider only the first action of the sequence
- case LFUN_SEQUENCE: {
+ case LFUN_COMMAND_SEQUENCE: {
// argument contains ';'-terminated commands
- string const firstcmd = token(cmd.argument, ';', 0);
+ string const firstcmd = token(to_utf8(cmd.argument()), ';', 0);
FuncRequest func(lyxaction.lookupFunc(firstcmd));
func.origin = cmd.origin;
flag = getStatus(func);
}
- case LFUN_MENUNEW:
- case LFUN_MENUNEWTMPLT:
- case LFUN_WORDFINDFORWARD:
- case LFUN_WORDFINDBACKWARD:
- case LFUN_PREFIX:
- case LFUN_EXEC_COMMAND:
+ case LFUN_BUFFER_NEW:
+ case LFUN_BUFFER_NEW_TEMPLATE:
+ case LFUN_WORD_FIND_FORWARD:
+ case LFUN_WORD_FIND_BACKWARD:
+ case LFUN_COMMAND_PREFIX:
+ case LFUN_COMMAND_EXECUTE:
case LFUN_CANCEL:
- case LFUN_META_FAKE:
- case LFUN_CLOSEBUFFER:
- case LFUN_MENUWRITE:
- case LFUN_WRITEAS:
- case LFUN_UPDATE:
- case LFUN_PREVIEW:
- case LFUN_IMPORT:
- case LFUN_QUIT:
- case LFUN_TOCVIEW:
- case LFUN_AUTOSAVE:
+ case LFUN_META_PREFIX:
+ case LFUN_BUFFER_CLOSE:
+ case LFUN_BUFFER_WRITE_AS:
+ case LFUN_BUFFER_UPDATE:
+ case LFUN_BUFFER_VIEW:
+ case LFUN_BUFFER_IMPORT:
+ case LFUN_TOC_VIEW:
+ case LFUN_BUFFER_AUTO_SAVE:
case LFUN_RECONFIGURE:
case LFUN_HELP_OPEN:
case LFUN_FILE_NEW:
case LFUN_FILE_OPEN:
case LFUN_DROP_LAYOUTS_CHOICE:
- case LFUN_MENU_OPEN_BY_NAME:
- case LFUN_GETNAME:
- case LFUN_NOTIFY:
- case LFUN_GOTOFILEROW:
- case LFUN_DIALOG_SHOW_NEXT_INSET:
+ case LFUN_MENU_OPEN:
+ case LFUN_SERVER_GET_NAME:
+ case LFUN_SERVER_NOTIFY:
+ case LFUN_SERVER_GOTO_FILE_ROW:
case LFUN_DIALOG_HIDE:
case LFUN_DIALOG_DISCONNECT_INSET:
- case LFUN_CHILDOPEN:
- case LFUN_TOGGLECURSORFOLLOW:
- case LFUN_KMAP_OFF:
- case LFUN_KMAP_PRIM:
- case LFUN_KMAP_SEC:
- case LFUN_KMAP_TOGGLE:
+ case LFUN_BUFFER_CHILD_OPEN:
+ case LFUN_TOGGLE_CURSOR_FOLLOWS_SCROLLBAR:
+ case LFUN_KEYMAP_OFF:
+ case LFUN_KEYMAP_PRIMARY:
+ case LFUN_KEYMAP_SECONDARY:
+ case LFUN_KEYMAP_TOGGLE:
case LFUN_REPEAT:
- case LFUN_EXPORT_CUSTOM:
- case LFUN_PRINT:
- case LFUN_SAVEPREFERENCES:
+ case LFUN_BUFFER_EXPORT_CUSTOM:
+ case LFUN_BUFFER_PRINT:
+ case LFUN_PREFERENCES_SAVE:
case LFUN_SCREEN_FONT_UPDATE:
case LFUN_SET_COLOR:
case LFUN_MESSAGE:
case LFUN_EXTERNAL_EDIT:
case LFUN_GRAPHICS_EDIT:
case LFUN_ALL_INSETS_TOGGLE:
- case LFUN_LANGUAGE_BUFFER:
+ case LFUN_BUFFER_LANGUAGE:
case LFUN_TEXTCLASS_APPLY:
case LFUN_TEXTCLASS_LOAD:
- case LFUN_SAVE_AS_DEFAULT:
- case LFUN_BUFFERPARAMS_APPLY:
+ case LFUN_BUFFER_SAVE_AS_DEFAULT:
+ case LFUN_BUFFER_PARAMS_APPLY:
case LFUN_LYXRC_APPLY:
- case LFUN_NEXTBUFFER:
- case LFUN_PREVIOUSBUFFER:
+ case LFUN_BUFFER_NEXT:
+ case LFUN_BUFFER_PREVIOUS:
+ case LFUN_WINDOW_NEW:
+ case LFUN_WINDOW_CLOSE:
+ case LFUN_LYX_QUIT:
// these are handled in our dispatch()
break;
default:
-
- if (!::getStatus(cur, cmd, flag))
+ if (!getLocalStatus(cur, cmd, flag))
flag = view()->getStatus(cmd);
}
if (buf && buf->isReadonly()
&& !lyxaction.funcHasFlag(cmd.action, LyXAction::ReadOnly)
&& !lyxaction.funcHasFlag(cmd.action, LyXAction::NoBuffer)) {
- flag.message(N_("Document is read-only"));
+ flag.message(from_utf8(N_("Document is read-only")));
+ flag.enabled(false);
+ }
+
+ // Are we in a DELETED change-tracking region?
+ if (buf && lookupChangeType(cur, true) == Change::DELETED
+ && !lyxaction.funcHasFlag(cmd.action, LyXAction::ReadOnly)
+ && !lyxaction.funcHasFlag(cmd.action, LyXAction::NoBuffer)) {
+ flag.message(from_utf8(N_("This portion of the document is deleted.")));
flag.enabled(false);
}
// the default error message if we disable the command
if (!flag.enabled() && flag.message().empty())
- flag.message(N_("Command disabled"));
+ flag.message(from_utf8(N_("Command disabled")));
return flag;
}
-namespace {
-
-bool ensureBufferClean(BufferView * bv)
+bool LyXFunc::ensureBufferClean(BufferView * bv)
{
Buffer & buf = *bv->buffer();
if (buf.isClean())
return true;
- string const file = MakeDisplayPath(buf.fileName(), 30);
- string text = bformat(_("The document %1$s has unsaved "
- "changes.\n\nDo you want to save "
- "the document?"), file);
+ docstring const file = makeDisplayPath(buf.fileName(), 30);
+ docstring text = bformat(_("The document %1$s has unsaved "
+ "changes.\n\nDo you want to save "
+ "the document?"), file);
int const ret = Alert::prompt(_("Save changed document?"),
text, 0, 1, _("&Save"),
_("&Cancel"));
if (ret == 0)
- bv->owner()->dispatch(FuncRequest(LFUN_MENUWRITE));
+ dispatch(FuncRequest(LFUN_BUFFER_WRITE));
return buf.isClean();
}
+namespace {
+
void showPrintError(string const & name)
{
- string str = bformat(_("Could not print the document %1$s.\n"
- "Check that your printer is set up correctly."),
- MakeDisplayPath(name, 50));
+ docstring str = bformat(_("Could not print the document %1$s.\n"
+ "Check that your printer is set up correctly."),
+ makeDisplayPath(name, 50));
Alert::error(_("Print document failed"), str);
}
void loadTextclass(string const & name)
{
- std::pair<bool, lyx::textclass_type> const tc_pair =
- textclasslist.NumberOfClass(name);
+ std::pair<bool, textclass_type> const tc_pair =
+ textclasslist.numberOfClass(name);
if (!tc_pair.first) {
lyxerr << "Document class \"" << name
return;
}
- lyx::textclass_type const tc = tc_pair.second;
+ textclass_type const tc = tc_pair.second;
if (!textclasslist[tc].load()) {
- string s = bformat(_("The document could not be converted\n"
- "into the document class %1$s."),
- textclasslist[tc].name());
+ docstring s = bformat(_("The document could not be converted\n"
+ "into the document class %1$s."),
+ from_utf8(textclasslist[tc].name()));
Alert::error(_("Could not change class"), s);
}
}
void LyXFunc::dispatch(FuncRequest const & cmd)
{
- BOOST_ASSERT(view());
- string const argument = cmd.argument;
+ string const argument = to_utf8(cmd.argument());
kb_action const action = cmd.action;
- lyxerr[Debug::ACTION] << "LyXFunc::dispatch: cmd: " << cmd << endl;
+ lyxerr[Debug::ACTION] << endl << "LyXFunc::dispatch: cmd: " << cmd << endl;
//lyxerr << "LyXFunc::dispatch: cmd: " << cmd << endl;
// we have not done anything wrong yet.
errorstat = false;
dispatch_buffer.erase();
- bool update = false;
+ // redraw the screen at the end (first of the two drawing steps).
+ //This is done unless explicitely requested otherwise
+ Update::flags updateFlags = Update::FitCursor;
FuncStatus const flag = getStatus(cmd);
if (!flag.enabled()) {
<< endl;
setErrorMessage(flag.message());
} else {
-
- if (view()->available())
- view()->hideCursor();
-
switch (action) {
- case LFUN_WORDFINDFORWARD:
- case LFUN_WORDFINDBACKWARD: {
- static string last_search;
- string searched_string;
+ case LFUN_WORD_FIND_FORWARD:
+ case LFUN_WORD_FIND_BACKWARD: {
+ BOOST_ASSERT(lyx_view_ && lyx_view_->view());
+ static docstring last_search;
+ docstring searched_string;
- if (!argument.empty()) {
- last_search = argument;
- searched_string = argument;
+ if (!cmd.argument().empty()) {
+ last_search = cmd.argument();
+ searched_string = cmd.argument();
} else {
searched_string = last_search;
}
if (searched_string.empty())
break;
- bool const fw = action == LFUN_WORDFINDFORWARD;
- string const data =
- lyx::find::find2string(searched_string, true, false, fw);
- lyx::find::find(view(), FuncRequest(LFUN_WORD_FIND, data));
+ bool const fw = action == LFUN_WORD_FIND_FORWARD;
+ docstring const data =
+ find2string(searched_string, true, false, fw);
+ find(view(), FuncRequest(LFUN_WORD_FIND, data));
break;
}
- case LFUN_PREFIX:
- owner->message(keyseq.printOptions());
+ case LFUN_COMMAND_PREFIX:
+ BOOST_ASSERT(lyx_view_);
+ lyx_view_->message(keyseq->printOptions(true));
break;
- case LFUN_EXEC_COMMAND:
- owner->getToolbars().display("minibuffer", true);
- owner->focus_command_buffer();
+ case LFUN_COMMAND_EXECUTE:
+ BOOST_ASSERT(lyx_view_);
+ lyx_view_->getToolbars().display("minibuffer", true);
+ lyx_view_->focus_command_buffer();
break;
case LFUN_CANCEL:
- keyseq.reset();
+ BOOST_ASSERT(lyx_view_ && lyx_view_->view());
+ keyseq->reset();
meta_fake_bit = key_modifier::none;
- if (view()->available())
+ if (view()->buffer())
// cancel any selection
dispatch(FuncRequest(LFUN_MARK_OFF));
- setMessage(N_("Cancel"));
+ setMessage(from_ascii(N_("Cancel")));
break;
- case LFUN_META_FAKE:
+ case LFUN_META_PREFIX:
meta_fake_bit = key_modifier::alt;
- setMessage(keyseq.print());
+ setMessage(keyseq->print(true));
break;
- case LFUN_READ_ONLY_TOGGLE:
- if (owner->buffer()->lyxvc().inUse())
- owner->buffer()->lyxvc().toggleReadOnly();
+ case LFUN_BUFFER_TOGGLE_READ_ONLY:
+ BOOST_ASSERT(lyx_view_ && lyx_view_->view() && lyx_view_->buffer());
+ if (lyx_view_->buffer()->lyxvc().inUse())
+ lyx_view_->buffer()->lyxvc().toggleReadOnly();
else
- owner->buffer()->setReadonly(
- !owner->buffer()->isReadonly());
+ lyx_view_->buffer()->setReadonly(
+ !lyx_view_->buffer()->isReadonly());
break;
// --- Menus -----------------------------------------------
- case LFUN_MENUNEW:
+ case LFUN_BUFFER_NEW:
menuNew(argument, false);
break;
- case LFUN_MENUNEWTMPLT:
+ case LFUN_BUFFER_NEW_TEMPLATE:
menuNew(argument, true);
break;
- case LFUN_CLOSEBUFFER:
+ case LFUN_BUFFER_CLOSE:
closeBuffer();
+ view()->update();
break;
- case LFUN_MENUWRITE:
- if (!owner->buffer()->isUnnamed()) {
- string const str = bformat(_("Saving document %1$s..."),
- MakeDisplayPath(owner->buffer()->fileName()));
- owner->message(str);
- MenuWrite(owner->buffer());
- owner->message(str + _(" done."));
- } else
- WriteAs(owner->buffer());
+ case LFUN_BUFFER_WRITE:
+ BOOST_ASSERT(lyx_view_ && lyx_view_->buffer());
+ if (!lyx_view_->buffer()->isUnnamed()) {
+ docstring const str = bformat(_("Saving document %1$s..."),
+ makeDisplayPath(lyx_view_->buffer()->fileName()));
+ lyx_view_->message(str);
+ menuWrite(lyx_view_->buffer());
+ lyx_view_->message(str + _(" done."));
+ } else {
+ writeAs(lyx_view_->buffer());
+ }
+ updateFlags = Update::None;
break;
- case LFUN_WRITEAS:
- WriteAs(owner->buffer(), argument);
+ case LFUN_BUFFER_WRITE_AS:
+ BOOST_ASSERT(lyx_view_ && lyx_view_->buffer());
+ writeAs(lyx_view_->buffer(), argument);
+ updateFlags = Update::None;
break;
- case LFUN_MENURELOAD: {
- string const file = MakeDisplayPath(view()->buffer()->fileName(), 20);
- string text = bformat(_("Any changes will be lost. Are you sure "
- "you want to revert to the saved version of the document %1$s?"), file);
+ case LFUN_BUFFER_RELOAD: {
+ BOOST_ASSERT(lyx_view_ && lyx_view_->buffer());
+ docstring const file = makeDisplayPath(view()->buffer()->fileName(), 20);
+ docstring text = bformat(_("Any changes will be lost. Are you sure "
+ "you want to revert to the saved version of the document %1$s?"), file);
int const ret = Alert::prompt(_("Revert to saved document?"),
text, 0, 1, _("&Revert"), _("&Cancel"));
if (ret == 0)
- view()->reload();
+ reloadBuffer();
break;
}
- case LFUN_UPDATE:
- Exporter::Export(owner->buffer(), argument, true);
- view()->showErrorList(BufferFormat(*owner->buffer()));
+ case LFUN_BUFFER_UPDATE:
+ BOOST_ASSERT(lyx_view_ && lyx_view_->buffer());
+ Exporter::Export(lyx_view_->buffer(), argument, true);
break;
- case LFUN_PREVIEW:
- Exporter::Preview(owner->buffer(), argument);
- view()->showErrorList(BufferFormat(*owner->buffer()));
+ case LFUN_BUFFER_VIEW:
+ BOOST_ASSERT(lyx_view_ && lyx_view_->buffer());
+ Exporter::preview(lyx_view_->buffer(), argument);
break;
- case LFUN_BUILDPROG:
- Exporter::Export(owner->buffer(), "program", true);
- view()->showErrorList(_("Build"));
+ case LFUN_BUILD_PROGRAM:
+ BOOST_ASSERT(lyx_view_ && lyx_view_->buffer());
+ Exporter::Export(lyx_view_->buffer(), "program", true);
break;
- case LFUN_RUNCHKTEX:
- owner->buffer()->runChktex();
- view()->showErrorList(_("ChkTeX"));
+ case LFUN_BUFFER_CHKTEX:
+ BOOST_ASSERT(lyx_view_ && lyx_view_->buffer());
+ lyx_view_->buffer()->runChktex();
break;
- case LFUN_EXPORT:
+ case LFUN_BUFFER_EXPORT:
+ BOOST_ASSERT(lyx_view_ && lyx_view_->buffer());
if (argument == "custom")
- owner->getDialogs().show("sendto");
+ lyx_view_->getDialogs().show("sendto");
else {
- Exporter::Export(owner->buffer(), argument, false);
- view()->showErrorList(BufferFormat(*owner->buffer()));
+ Exporter::Export(lyx_view_->buffer(), argument, false);
}
break;
- case LFUN_EXPORT_CUSTOM: {
+ case LFUN_BUFFER_EXPORT_CUSTOM: {
+ BOOST_ASSERT(lyx_view_ && lyx_view_->buffer());
string format_name;
string command = split(argument, format_name, ' ');
Format const * format = formats.getFormat(format_name);
break;
}
- Buffer * buffer = owner->buffer();
+ Buffer * buffer = lyx_view_->buffer();
// The name of the file created by the conversion process
string filename;
if (format->name() == "lyx") {
string const latexname =
buffer->getLatexName(false);
- filename = ChangeExtension(latexname,
+ filename = changeExtension(latexname,
format->extension());
- filename = AddName(buffer->temppath(), filename);
+ filename = addName(buffer->temppath(), filename);
- if (!buffer->writeFile(filename))
+ if (!buffer->writeFile(FileName(filename)))
break;
} else {
- Exporter::Export(buffer, format_name, true,
- filename);
+ Exporter::Export(buffer, format_name, true, filename);
}
// Substitute $$FName for filename
break;
}
- case LFUN_PRINT: {
+ case LFUN_BUFFER_PRINT: {
+ BOOST_ASSERT(lyx_view_ && lyx_view_->buffer());
string target;
string target_name;
string command = split(split(argument, target, ' '),
break;
}
- Buffer * buffer = owner->buffer();
+ Buffer * buffer = lyx_view_->buffer();
if (!Exporter::Export(buffer, "dvi", true)) {
showPrintError(buffer->fileName());
// Push directory path.
string const path = buffer->temppath();
- Path p(path);
+ support::Path p(path);
// there are three cases here:
// 1. we print to a file
Systemcall one;
int res = 0;
string const dviname =
- ChangeExtension(buffer->getLatexName(true),
+ changeExtension(buffer->getLatexName(true),
"dvi");
if (target == "printer") {
if (!lyxrc.print_spool_command.empty()) {
// case 3: print using a spool
string const psname =
- ChangeExtension(dviname,".ps");
+ changeExtension(dviname,".ps");
command += lyxrc.print_to_file
- + QuoteName(psname)
+ + quoteName(psname)
+ ' '
- + QuoteName(dviname);
+ + quoteName(dviname);
string command2 =
lyxrc.print_spool_command +' ';
+ target_name
+ ' ';
}
- command2 += QuoteName(psname);
+ command2 += quoteName(psname);
// First run dvips.
// If successful, then spool command
res = one.startscript(
// case 2: print directly to a printer
res = one.startscript(
Systemcall::DontWait,
- command + QuoteName(dviname));
+ command + quoteName(dviname));
}
} else {
// case 1: print to a file
+ FileName const filename(makeAbsPath(target_name, path));
+ if (fs::exists(filename.toFilesystemEncoding())) {
+ docstring text = bformat(
+ _("The file %1$s already exists.\n\n"
+ "Do you want to over-write that file?"),
+ makeDisplayPath(filename.absFilename()));
+ if (Alert::prompt(_("Over-write file?"),
+ text, 0, 1, _("&Over-write"), _("&Cancel")) != 0)
+ break;
+ }
command += lyxrc.print_to_file
- + QuoteName(MakeAbsPath(target_name,
- path))
+ + quoteName(filename.toFilesystemEncoding())
+ ' '
- + QuoteName(dviname);
+ + quoteName(dviname);
res = one.startscript(Systemcall::DontWait,
command);
}
break;
}
- case LFUN_IMPORT:
+ case LFUN_BUFFER_IMPORT:
doImport(argument);
break;
- case LFUN_QUIT:
- QuitLyX();
+ case LFUN_LYX_QUIT:
+ // quitting is triggered by the gui code
+ // (leaving the event loop).
+ lyx_view_->message(from_utf8(N_("Exiting.")));
+ if (theBufferList().quitWriteAll())
+ theApp()->gui().closeAllViews();
break;
- case LFUN_TOCVIEW: {
+ case LFUN_TOC_VIEW: {
+ BOOST_ASSERT(lyx_view_);
InsetCommandParams p("tableofcontents");
string const data = InsetCommandMailer::params2string("toc", p);
- owner->getDialogs().show("toc", data, 0);
+ lyx_view_->getDialogs().show("toc", data, 0);
break;
}
- case LFUN_AUTOSAVE:
- AutoSave(view());
+ case LFUN_BUFFER_AUTO_SAVE:
+ autoSave(view());
break;
case LFUN_RECONFIGURE:
- Reconfigure(view());
+ BOOST_ASSERT(lyx_view_);
+ reconfigure(*lyx_view_);
break;
case LFUN_HELP_OPEN: {
+ BOOST_ASSERT(lyx_view_);
string const arg = argument;
if (arg.empty()) {
- setErrorMessage(N_("Missing argument"));
+ setErrorMessage(from_ascii(N_("Missing argument")));
break;
}
- string const fname = i18nLibFileSearch("doc", arg, "lyx");
+ FileName const fname = i18nLibFileSearch("doc", arg, "lyx");
if (fname.empty()) {
lyxerr << "LyX: unable to find documentation file `"
<< arg << "'. Bad installation?" << endl;
break;
}
- owner->message(bformat(_("Opening help file %1$s..."),
- MakeDisplayPath(fname)));
- view()->loadLyXFile(fname, false);
+ lyx_view_->message(bformat(_("Opening help file %1$s..."),
+ makeDisplayPath(fname.absFilename())));
+ lyx_view_->loadLyXFile(fname, false);
break;
}
// --- version control -------------------------------
case LFUN_VC_REGISTER:
+ BOOST_ASSERT(lyx_view_ && lyx_view_->buffer());
if (!ensureBufferClean(view()))
break;
- if (!owner->buffer()->lyxvc().inUse()) {
- owner->buffer()->lyxvc().registrer();
- view()->reload();
+ if (!lyx_view_->buffer()->lyxvc().inUse()) {
+ lyx_view_->buffer()->lyxvc().registrer();
+ reloadBuffer();
}
+ updateFlags = Update::Force;
break;
- case LFUN_VC_CHECKIN:
+ case LFUN_VC_CHECK_IN:
+ BOOST_ASSERT(lyx_view_ && lyx_view_->buffer());
if (!ensureBufferClean(view()))
break;
- if (owner->buffer()->lyxvc().inUse()
- && !owner->buffer()->isReadonly()) {
- owner->buffer()->lyxvc().checkIn();
- view()->reload();
+ if (lyx_view_->buffer()->lyxvc().inUse()
+ && !lyx_view_->buffer()->isReadonly()) {
+ lyx_view_->buffer()->lyxvc().checkIn();
+ reloadBuffer();
}
break;
- case LFUN_VC_CHECKOUT:
+ case LFUN_VC_CHECK_OUT:
+ BOOST_ASSERT(lyx_view_ && lyx_view_->buffer());
if (!ensureBufferClean(view()))
break;
- if (owner->buffer()->lyxvc().inUse()
- && owner->buffer()->isReadonly()) {
- owner->buffer()->lyxvc().checkOut();
- view()->reload();
+ if (lyx_view_->buffer()->lyxvc().inUse()
+ && lyx_view_->buffer()->isReadonly()) {
+ lyx_view_->buffer()->lyxvc().checkOut();
+ reloadBuffer();
}
break;
case LFUN_VC_REVERT:
- owner->buffer()->lyxvc().revert();
- view()->reload();
+ BOOST_ASSERT(lyx_view_ && lyx_view_->buffer());
+ lyx_view_->buffer()->lyxvc().revert();
+ reloadBuffer();
break;
- case LFUN_VC_UNDO:
- owner->buffer()->lyxvc().undoLast();
- view()->reload();
+ case LFUN_VC_UNDO_LAST:
+ BOOST_ASSERT(lyx_view_ && lyx_view_->buffer());
+ lyx_view_->buffer()->lyxvc().undoLast();
+ reloadBuffer();
break;
// --- buffers ----------------------------------------
- case LFUN_SWITCHBUFFER:
- view()->setBuffer(bufferlist.getBuffer(argument));
+ case LFUN_BUFFER_SWITCH:
+ BOOST_ASSERT(lyx_view_);
+ lyx_view_->setBuffer(theBufferList().getBuffer(argument));
break;
- case LFUN_NEXTBUFFER:
- view()->setBuffer(bufferlist.next(view()->buffer()));
+ case LFUN_BUFFER_NEXT:
+ BOOST_ASSERT(lyx_view_);
+ lyx_view_->setBuffer(theBufferList().next(view()->buffer()));
break;
- case LFUN_PREVIOUSBUFFER:
- view()->setBuffer(bufferlist.previous(view()->buffer()));
+ case LFUN_BUFFER_PREVIOUS:
+ BOOST_ASSERT(lyx_view_);
+ lyx_view_->setBuffer(theBufferList().previous(view()->buffer()));
break;
case LFUN_FILE_NEW:
- NewFile(view(), argument);
+ BOOST_ASSERT(lyx_view_);
+ newFile(view(), argument);
break;
case LFUN_FILE_OPEN:
+ BOOST_ASSERT(lyx_view_);
open(argument);
break;
case LFUN_DROP_LAYOUTS_CHOICE:
- owner->getToolbars().openLayoutList();
+ BOOST_ASSERT(lyx_view_);
+ lyx_view_->getToolbars().openLayoutList();
break;
- case LFUN_MENU_OPEN_BY_NAME:
- owner->getMenubar().openByName(argument);
+ case LFUN_MENU_OPEN:
+ BOOST_ASSERT(lyx_view_);
+ lyx_view_->getMenubar().openByName(from_utf8(argument));
break;
// --- lyxserver commands ----------------------------
- case LFUN_GETNAME:
- setMessage(owner->buffer()->fileName());
+ case LFUN_SERVER_GET_NAME:
+ BOOST_ASSERT(lyx_view_ && lyx_view_->buffer());
+ setMessage(from_utf8(lyx_view_->buffer()->fileName()));
lyxerr[Debug::INFO] << "FNAME["
- << owner->buffer()->fileName()
+ << lyx_view_->buffer()->fileName()
<< "] " << endl;
break;
- case LFUN_NOTIFY:
- dispatch_buffer = keyseq.print();
- lyxserver->notifyClient(dispatch_buffer);
+ case LFUN_SERVER_NOTIFY:
+ dispatch_buffer = keyseq->print(false);
+ theLyXServer().notifyClient(to_utf8(dispatch_buffer));
break;
- case LFUN_GOTOFILEROW: {
+ case LFUN_SERVER_GOTO_FILE_ROW: {
+ BOOST_ASSERT(lyx_view_);
string file_name;
int row;
istringstream is(argument);
if (prefixIs(file_name, package().temp_dir())) {
// Needed by inverse dvi search. If it is a file
// in tmpdir, call the apropriated function
- view()->setBuffer(bufferlist.getBufferFromTmp(file_name));
+ lyx_view_->setBuffer(theBufferList().getBufferFromTmp(file_name));
} else {
// Must replace extension of the file to be .lyx
// and get full path
- string const s = ChangeExtension(file_name, ".lyx");
+ FileName const s = fileSearch(string(), changeExtension(file_name, ".lyx"), "lyx");
// Either change buffer or load the file
- if (bufferlist.exists(s)) {
- view()->setBuffer(bufferlist.getBuffer(s));
+ if (theBufferList().exists(s.absFilename())) {
+ lyx_view_->setBuffer(theBufferList().getBuffer(s.absFilename()));
} else {
- view()->loadLyXFile(s);
+ lyx_view_->loadLyXFile(s);
}
}
view()->setCursorFromRow(row);
- view()->center();
- // see BufferView_pimpl::center()
- view()->updateScrollbar();
+ updateFlags = Update::FitCursor;
break;
}
case LFUN_DIALOG_SHOW: {
+ BOOST_ASSERT(lyx_view_);
string const name = cmd.getArg(0);
- string data = trim(cmd.argument.substr(name.size()));
+ string data = trim(to_utf8(cmd.argument()).substr(name.size()));
if (name == "character") {
data = freefont2string();
if (!data.empty())
- owner->getDialogs().show("character", data);
- }
-
- else if (name == "latexlog") {
+ lyx_view_->getDialogs().show("character", data);
+ } else if (name == "latexlog") {
pair<Buffer::LogType, string> const logfile =
- owner->buffer()->getLogName();
+ lyx_view_->buffer()->getLogName();
switch (logfile.first) {
case Buffer::latexlog:
data = "latex ";
data = "literate ";
break;
}
- data += logfile.second;
- owner->getDialogs().show("log", data);
- }
- else if (name == "vclog") {
+ data += LyXLex::quoteString(logfile.second);
+ lyx_view_->getDialogs().show("log", data);
+ } else if (name == "vclog") {
string const data = "vc " +
- owner->buffer()->lyxvc().getLogFile();
- owner->getDialogs().show("log", data);
- }
- else
- owner->getDialogs().show(name, data);
+ LyXLex::quoteString(lyx_view_->buffer()->lyxvc().getLogFile());
+ lyx_view_->getDialogs().show("log", data);
+ } else
+ lyx_view_->getDialogs().show(name, data);
break;
}
case LFUN_DIALOG_SHOW_NEW_INSET: {
+ BOOST_ASSERT(lyx_view_);
string const name = cmd.getArg(0);
- string data = trim(cmd.argument.substr(name.size()));
+ string data = trim(to_utf8(cmd.argument()).substr(name.size()));
if (name == "bibitem" ||
name == "bibtex" ||
- name == "include" ||
name == "index" ||
name == "label" ||
+ name == "nomenclature" ||
name == "ref" ||
name == "toc" ||
name == "url") {
InsetCommandParams p(name);
data = InsetCommandMailer::params2string(name, p);
+ } else if (name == "include") {
+ // data is the include type: one of "include",
+ // "input", "verbatiminput" or "verbatiminput*"
+ if (data.empty())
+ // default type is requested
+ data = "include";
+ InsetCommandParams p(data);
+ data = InsetIncludeMailer::params2string(p);
} else if (name == "box") {
// \c data == "Boxed" || "Frameless" etc
InsetBoxParams p(data);
data = InsetERTMailer::params2string(InsetCollapsable::Open);
} else if (name == "external") {
InsetExternalParams p;
- Buffer const & buffer = *owner->buffer();
+ Buffer const & buffer = *lyx_view_->buffer();
data = InsetExternalMailer::params2string(p, buffer);
} else if (name == "float") {
InsetFloatParams p;
data = InsetFloatMailer::params2string(p);
} else if (name == "graphics") {
InsetGraphicsParams p;
- Buffer const & buffer = *owner->buffer();
+ Buffer const & buffer = *lyx_view_->buffer();
data = InsetGraphicsMailer::params2string(p, buffer);
} else if (name == "note") {
InsetNoteParams p;
InsetWrapParams p;
data = InsetWrapMailer::params2string(p);
}
- owner->getDialogs().show(name, data, 0);
+ lyx_view_->getDialogs().show(name, data, 0);
break;
}
- case LFUN_DIALOG_SHOW_NEXT_INSET:
- break;
-
case LFUN_DIALOG_UPDATE: {
+ BOOST_ASSERT(lyx_view_);
string const & name = argument;
// Can only update a dialog connected to an existing inset
- InsetBase * inset = owner->getDialogs().getOpenInset(name);
+ InsetBase * inset = lyx_view_->getDialogs().getOpenInset(name);
if (inset) {
- FuncRequest fr(LFUN_INSET_DIALOG_UPDATE, cmd.argument);
+ FuncRequest fr(LFUN_INSET_DIALOG_UPDATE, cmd.argument());
inset->dispatch(view()->cursor(), fr);
} else if (name == "paragraph") {
dispatch(FuncRequest(LFUN_PARAGRAPH_UPDATE));
} else if (name == "prefs") {
- owner->getDialogs().update(name, string());
+ lyx_view_->getDialogs().update(name, string());
}
break;
}
break;
case LFUN_DIALOG_DISCONNECT_INSET:
- owner->getDialogs().disconnect(argument);
- break;
-
- case LFUN_CHILDOPEN: {
- string const filename =
- MakeAbsPath(argument, owner->buffer()->filePath());
- setMessage(N_("Opening child document ") +
- MakeDisplayPath(filename) + "...");
- view()->savePosition(0);
- string const parentfilename = owner->buffer()->fileName();
- if (bufferlist.exists(filename))
- view()->setBuffer(bufferlist.getBuffer(filename));
+ BOOST_ASSERT(lyx_view_);
+ lyx_view_->getDialogs().disconnect(argument);
+ break;
+
+
+ case LFUN_CITATION_INSERT: {
+ BOOST_ASSERT(lyx_view_);
+ if (!argument.empty()) {
+ // we can have one optional argument, delimited by '|'
+ // citation-insert <key>|<text_before>
+ // this should be enhanced to also support text_after
+ // and citation style
+ string arg = argument;
+ string opt1;
+ if (contains(argument, "|")) {
+ arg = token(argument, '|', 0);
+ opt1 = '[' + token(argument, '|', 1) + ']';
+ }
+ std::ostringstream os;
+ os << "citation LatexCommand\n"
+ << "\\cite" << opt1 << "{" << arg << "}\n"
+ << "\\end_inset";
+ FuncRequest fr(LFUN_INSET_INSERT, os.str());
+ dispatch(fr);
+ } else
+ dispatch(FuncRequest(LFUN_DIALOG_SHOW, "citation"));
+ break;
+ }
+
+ case LFUN_BUFFER_CHILD_OPEN: {
+ BOOST_ASSERT(lyx_view_);
+ FileName const filename =
+ makeAbsPath(argument, lyx_view_->buffer()->filePath());
+ setMessage(bformat(_("Opening child document %1$s..."),
+ makeDisplayPath(filename.absFilename())));
+ view()->saveBookmark(false);
+ string const parentfilename = lyx_view_->buffer()->fileName();
+ if (theBufferList().exists(filename.absFilename()))
+ lyx_view_->setBuffer(theBufferList().getBuffer(filename.absFilename()));
else
- view()->loadLyXFile(filename);
+ lyx_view_->loadLyXFile(filename);
// 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.
- owner->buffer()->setParentName(parentfilename);
+ lyx_view_->buffer()->setParentName(parentfilename);
break;
}
- case LFUN_TOGGLECURSORFOLLOW:
+ case LFUN_TOGGLE_CURSOR_FOLLOWS_SCROLLBAR:
+ BOOST_ASSERT(lyx_view_);
lyxrc.cursor_follows_scrollbar = !lyxrc.cursor_follows_scrollbar;
break;
- case LFUN_KMAP_OFF:
- owner->getIntl().KeyMapOn(false);
+ case LFUN_KEYMAP_OFF:
+ BOOST_ASSERT(lyx_view_);
+ lyx_view_->view()->getIntl().keyMapOn(false);
break;
- case LFUN_KMAP_PRIM:
- owner->getIntl().KeyMapPrim();
+ case LFUN_KEYMAP_PRIMARY:
+ BOOST_ASSERT(lyx_view_);
+ lyx_view_->view()->getIntl().keyMapPrim();
break;
- case LFUN_KMAP_SEC:
- owner->getIntl().KeyMapSec();
+ case LFUN_KEYMAP_SECONDARY:
+ BOOST_ASSERT(lyx_view_);
+ lyx_view_->view()->getIntl().keyMapSec();
break;
- case LFUN_KMAP_TOGGLE:
- owner->getIntl().ToggleKeyMap();
+ case LFUN_KEYMAP_TOGGLE:
+ BOOST_ASSERT(lyx_view_);
+ lyx_view_->view()->getIntl().toggleKeyMap();
break;
case LFUN_REPEAT: {
break;
}
- case LFUN_SEQUENCE: {
+ case LFUN_COMMAND_SEQUENCE: {
// argument contains ';'-terminated commands
string arg = argument;
while (!arg.empty()) {
break;
}
- case LFUN_SAVEPREFERENCES: {
- Path p(package().user_support());
- lyxrc.write("preferences", false);
+ case LFUN_PREFERENCES_SAVE: {
+ lyxrc.write(makeAbsPath("preferences",
+ package().user_support()),
+ false);
break;
}
case LFUN_SCREEN_FONT_UPDATE:
+ BOOST_ASSERT(lyx_view_);
// handle the screen font changes.
lyxrc.set_font_norm_type();
- lyx_gui::update_fonts();
- // All visible buffers will need resize
- view()->resize();
+ theFontLoader().update();
+ /// FIXME: only the current view will be updated. the Gui
+ /// class is able to furnish the list of views.
+ updateFlags = Update::Force;
break;
case LFUN_SET_COLOR: {
string lyx_name;
string const x11_name = split(argument, lyx_name, ' ');
if (lyx_name.empty() || x11_name.empty()) {
- setErrorMessage(N_("Syntax: set-color <lyx_name>"
- " <x11_name>"));
+ setErrorMessage(from_ascii(N_(
+ "Syntax: set-color <lyx_name>"
+ " <x11_name>")));
break;
}
if (!lcolor.setColor(lyx_name, x11_name)) {
setErrorMessage(
- bformat(_("Set-color \"%1$s\" failed "
- "- color is undefined or "
- "may not be redefined"), lyx_name));
+ bformat(_("Set-color \"%1$s\" failed "
+ "- color is undefined or "
+ "may not be redefined"),
+ from_utf8(lyx_name)));
break;
}
- lyx_gui::update_color(lcolor.getFromLyXName(lyx_name));
+ theApp()->updateColor(lcolor.getFromLyXName(lyx_name));
if (graphicsbg_changed) {
#ifdef WITH_WARNINGS
#warning FIXME!! The graphics cache no longer has a changeDisplay method.
#endif
#if 0
- lyx::graphics::GCache::get().changeDisplay(true);
+ graphics::GCache::get().changeDisplay(true);
#endif
}
break;
}
case LFUN_MESSAGE:
- owner->message(argument);
- break;
-
- case LFUN_TOOLTIPS_TOGGLE:
- owner->getDialogs().toggleTooltips();
+ BOOST_ASSERT(lyx_view_);
+ lyx_view_->message(from_utf8(argument));
break;
case LFUN_EXTERNAL_EDIT: {
+ BOOST_ASSERT(lyx_view_);
FuncRequest fr(action, argument);
InsetExternal().dispatch(view()->cursor(), fr);
break;
}
case LFUN_INSET_APPLY: {
+ BOOST_ASSERT(lyx_view_);
string const name = cmd.getArg(0);
- InsetBase * inset = owner->getDialogs().getOpenInset(name);
+ InsetBase * inset = lyx_view_->getDialogs().getOpenInset(name);
if (inset) {
FuncRequest fr(LFUN_INSET_MODIFY, argument);
inset->dispatch(view()->cursor(), fr);
FuncRequest fr(LFUN_INSET_INSERT, argument);
dispatch(fr);
}
+ // ideally, the update flag should be set by the insets,
+ // but this is not possible currently
+ updateFlags = Update::Force | Update::FitCursor;
break;
}
case LFUN_ALL_INSETS_TOGGLE: {
+ BOOST_ASSERT(lyx_view_);
string action;
string const name = split(argument, action, ' ');
InsetBase::Code const inset_code =
LCursor & cur = view()->cursor();
FuncRequest fr(LFUN_INSET_TOGGLE, action);
- InsetBase & inset = owner->buffer()->inset();
+ InsetBase & inset = lyx_view_->buffer()->inset();
InsetIterator it = inset_iterator_begin(inset);
InsetIterator const end = inset_iterator_end(inset);
for (; it != end; ++it) {
if (inset_code == InsetBase::NO_CODE
- || inset_code == it->lyxCode())
- it->dispatch(cur, fr);
+ || inset_code == it->lyxCode()) {
+ LCursor tmpcur = cur;
+ tmpcur.pushLeft(*it);
+ it->dispatch(tmpcur, fr);
+ }
}
+ updateFlags = Update::Force | Update::FitCursor;
break;
}
- case LFUN_LANGUAGE_BUFFER: {
- Buffer & buffer = *owner->buffer();
+ case LFUN_BUFFER_LANGUAGE: {
+ BOOST_ASSERT(lyx_view_);
+ Buffer & buffer = *lyx_view_->buffer();
Language const * oldL = buffer.params().language;
Language const * newL = languages.getLanguage(argument);
if (!newL || oldL == newL)
break;
- if (oldL->RightToLeft() == newL->RightToLeft()
+ if (oldL->rightToLeft() == newL->rightToLeft()
&& !buffer.isMultiLingual())
buffer.changeLanguage(oldL, newL);
else
break;
}
- case LFUN_SAVE_AS_DEFAULT: {
+ case LFUN_BUFFER_SAVE_AS_DEFAULT: {
string const fname =
- AddName(AddPath(package().user_support(), "templates/"),
+ addName(addPath(package().user_support(), "templates/"),
"defaults.lyx");
Buffer defaults(fname);
int const unknown_tokens = defaults.readHeader(lex);
if (unknown_tokens != 0) {
- lyxerr << "Warning in LFUN_SAVE_AS_DEFAULT!\n"
+ lyxerr << "Warning in LFUN_BUFFER_SAVE_AS_DEFAULT!\n"
<< unknown_tokens << " unknown token"
<< (unknown_tokens == 1 ? "" : "s")
<< endl;
}
- if (defaults.writeFile(defaults.fileName()))
- setMessage(_("Document defaults saved in ")
- + MakeDisplayPath(fname));
+ if (defaults.writeFile(FileName(defaults.fileName())))
+ setMessage(bformat(_("Document defaults saved in %1$s"),
+ makeDisplayPath(fname)));
else
- setErrorMessage(_("Unable to save document defaults"));
+ setErrorMessage(from_ascii(N_("Unable to save document defaults")));
break;
}
- case LFUN_BUFFERPARAMS_APPLY: {
+ case LFUN_BUFFER_PARAMS_APPLY: {
+ BOOST_ASSERT(lyx_view_);
biblio::CiteEngine const engine =
- owner->buffer()->params().cite_engine;
+ lyx_view_->buffer()->params().cite_engine;
istringstream ss(argument);
LyXLex lex(0,0);
lex.setStream(ss);
int const unknown_tokens =
- owner->buffer()->readHeader(lex);
+ lyx_view_->buffer()->readHeader(lex);
if (unknown_tokens != 0) {
- lyxerr << "Warning in LFUN_BUFFERPARAMS_APPLY!\n"
+ lyxerr << "Warning in LFUN_BUFFER_PARAMS_APPLY!\n"
<< unknown_tokens << " unknown token"
<< (unknown_tokens == 1 ? "" : "s")
<< endl;
}
- if (engine == owner->buffer()->params().cite_engine)
+ if (engine == lyx_view_->buffer()->params().cite_engine)
break;
LCursor & cur = view()->cursor();
FuncRequest fr(LFUN_INSET_REFRESH);
- InsetBase & inset = owner->buffer()->inset();
+ InsetBase & inset = lyx_view_->buffer()->inset();
InsetIterator it = inset_iterator_begin(inset);
InsetIterator const end = inset_iterator_end(inset);
for (; it != end; ++it)
}
case LFUN_TEXTCLASS_APPLY: {
- Buffer * buffer = owner->buffer();
+ BOOST_ASSERT(lyx_view_);
+ Buffer * buffer = lyx_view_->buffer();
- lyx::textclass_type const old_class =
+ textclass_type const old_class =
buffer->params().textclass;
loadTextclass(argument);
- std::pair<bool, lyx::textclass_type> const tc_pair =
- textclasslist.NumberOfClass(argument);
+ std::pair<bool, textclass_type> const tc_pair =
+ textclasslist.numberOfClass(argument);
if (!tc_pair.first)
break;
- lyx::textclass_type const new_class = tc_pair.second;
+ textclass_type const new_class = tc_pair.second;
if (old_class == new_class)
// nothing to do
break;
- owner->message(_("Converting document to new document class..."));
- ErrorList el;
- lyx::cap::SwitchBetweenClasses(
+ lyx_view_->message(_("Converting document to new document class..."));
+ recordUndoFullDocument(view());
+ buffer->params().textclass = new_class;
+ StableDocIterator backcur(view()->cursor());
+ ErrorList & el = buffer->errorList("Class Switch");
+ cap::switchBetweenClasses(
old_class, new_class,
- buffer->paragraphs(), el);
+ static_cast<InsetText &>(buffer->inset()), el);
- bufferErrors(*buffer, el);
- view()->showErrorList(_("Class switch"));
- updateCounters(*buffer);
- update = true;
+ view()->setCursor(backcur.asDocIterator(&(buffer->inset())));
+
+ buffer->errors("Class Switch");
+ updateLabels(*buffer);
+ updateFlags = Update::Force | Update::FitCursor;
break;
}
}
actOnUpdatedPrefs(lyxrc_orig, lyxrc);
+
+ /// We force the redraw in any case because there might be
+ /// some screen font changes.
+ /// FIXME: only the current view will be updated. the Gui
+ /// class is able to furnish the list of views.
+ updateFlags = Update::Force;
break;
}
+ case LFUN_WINDOW_NEW:
+ LyX::ref().newLyXView();
+ break;
+
+ case LFUN_WINDOW_CLOSE:
+ BOOST_ASSERT(lyx_view_);
+ BOOST_ASSERT(theApp());
+ // update bookmark pit of the current buffer before window close
+ for (size_t i = 0; i < LyX::ref().session().bookmarks().size(); ++i)
+ gotoBookmark(i+1, false, false);
+ // ask the user for saving changes or cancel quit
+ if (!theBufferList().quitWriteAll())
+ break;
+ lyx_view_->close();
+ return;
+
+ case LFUN_BOOKMARK_GOTO:
+ // go to bookmark, open unopened file and switch to buffer if necessary
+ gotoBookmark(convert<unsigned int>(to_utf8(cmd.argument())), true, true);
+ break;
+
+ case LFUN_BOOKMARK_CLEAR:
+ LyX::ref().session().bookmarks().clear();
+ break;
+
+ case LFUN_TOOLBAR_TOGGLE_STATE:
+ lyx_view_->toggleToolbarState(argument);
+ break;
+
default: {
+ BOOST_ASSERT(lyx_view_);
view()->cursor().dispatch(cmd);
- update |= view()->cursor().result().update();
- if (!view()->cursor().result().dispatched()) {
- update |= view()->dispatch(cmd);
- }
-
+ updateFlags = view()->cursor().result().update();
+ if (!view()->cursor().result().dispatched())
+ updateFlags = view()->dispatch(cmd);
break;
}
}
- if (view()->available()) {
- // Redraw screen unless explicitly told otherwise.
- // This also initializes the position cache for all insets
- // in (at least partially) visible top-level paragraphs.
- view()->update(true, update);
+ if (lyx_view_ && view()->buffer()) {
+ // BufferView::update() updates the ViewMetricsInfo and
+ // also initializes the position cache for all insets in
+ // (at least partially) visible top-level paragraphs.
+ // We will redraw the screen only if needed.
+ if (view()->update(updateFlags)) {
+ // Buffer::changed() signals that a repaint is needed.
+ // The frontend (WorkArea) knows which area to repaint
+ // thanks to the ViewMetricsInfo updated above.
+ view()->buffer()->changed();
+ }
+
+ lyx_view_->updateStatusBar();
// if we executed a mutating lfun, mark the buffer as dirty
- // FIXME: Why not use flag.enabled() but call getStatus again?
- if (getStatus(cmd).enabled()
- && !lyxaction.funcHasFlag(cmd.action, LyXAction::NoBuffer)
- && !lyxaction.funcHasFlag(cmd.action, LyXAction::ReadOnly))
+ if (flag.enabled()
+ && !lyxaction.funcHasFlag(action, LyXAction::NoBuffer)
+ && !lyxaction.funcHasFlag(action, LyXAction::ReadOnly))
view()->buffer()->markDirty();
- }
- if (view()->cursor().inTexted()) {
- view()->owner()->updateLayoutChoice();
+ if (view()->cursor().inTexted()) {
+ lyx_view_->updateLayoutChoice();
+ }
}
}
- sendDispatchMessage(_(getMessage()), cmd);
+ if (!quitting) {
+ lyx_view_->updateMenubar();
+ lyx_view_->updateToolbars();
+ // Some messages may already be translated, so we cannot use _()
+ sendDispatchMessage(translateIfPossible(getMessage()), cmd);
+ }
}
-void LyXFunc::sendDispatchMessage(string const & msg, FuncRequest const & cmd)
+void LyXFunc::sendDispatchMessage(docstring const & msg, FuncRequest const & cmd)
{
- owner->updateMenubar();
- owner->updateToolbars();
-
- const bool verbose = (cmd.origin == FuncRequest::UI
+ const bool verbose = (cmd.origin == FuncRequest::MENU
+ || cmd.origin == FuncRequest::TOOLBAR
|| cmd.origin == FuncRequest::COMMANDBUFFER);
- if (cmd.action == LFUN_SELFINSERT || !verbose) {
- lyxerr[Debug::ACTION] << "dispatch msg is " << msg << endl;
+ if (cmd.action == LFUN_SELF_INSERT || !verbose) {
+ lyxerr[Debug::ACTION] << "dispatch msg is " << to_utf8(msg) << endl;
if (!msg.empty())
- owner->message(msg);
+ lyx_view_->message(msg);
return;
}
- string dispatch_msg = msg;
+ docstring dispatch_msg = msg;
if (!dispatch_msg.empty())
dispatch_msg += ' ';
- string comname = lyxaction.getActionName(cmd.action);
+ docstring comname = from_utf8(lyxaction.getActionName(cmd.action));
bool argsadded = false;
- if (!cmd.argument.empty()) {
+ if (!cmd.argument().empty()) {
if (cmd.action != LFUN_UNKNOWN_ACTION) {
- comname += ' ' + cmd.argument;
+ comname += ' ' + cmd.argument();
argsadded = true;
}
}
- string const shortcuts = toplevel_keymap->printbindings(cmd);
+ docstring const shortcuts = theTopLevelKeymap().printbindings(cmd);
- if (!shortcuts.empty()) {
+ if (!shortcuts.empty())
comname += ": " + shortcuts;
- } else if (!argsadded && !cmd.argument.empty()) {
- comname += ' ' + cmd.argument;
- }
+ else if (!argsadded && !cmd.argument().empty())
+ comname += ' ' + cmd.argument();
if (!comname.empty()) {
comname = rtrim(comname);
- dispatch_msg += '(' + comname + ')';
+ dispatch_msg += '(' + rtrim(comname) + ')';
}
- lyxerr[Debug::ACTION] << "verbose dispatch msg " << dispatch_msg << endl;
+ lyxerr[Debug::ACTION] << "verbose dispatch msg "
+ << to_utf8(dispatch_msg) << endl;
if (!dispatch_msg.empty())
- owner->message(dispatch_msg);
-}
-
-
-void LyXFunc::setupLocalKeymap()
-{
- keyseq.stdmap = toplevel_keymap.get();
- keyseq.curmap = toplevel_keymap.get();
- cancel_meta_seq.stdmap = toplevel_keymap.get();
- cancel_meta_seq.curmap = toplevel_keymap.get();
+ lyx_view_->message(dispatch_msg);
}
void LyXFunc::menuNew(string const & name, bool fromTemplate)
{
+ // FIXME: initpath is not used. What to do?
string initpath = lyxrc.document_path;
string filename(name);
- if (view()->available()) {
- string const trypath = owner->buffer()->filePath();
+ if (view()->buffer()) {
+ string const trypath = lyx_view_->buffer()->filePath();
// If directory is writeable, use this as default.
- if (IsDirWriteable(trypath))
+ if (isDirWriteable(FileName(trypath)))
initpath = trypath;
}
static int newfile_number;
if (filename.empty()) {
- filename = AddName(lyxrc.document_path,
+ filename = addName(lyxrc.document_path,
"newfile" + convert<string>(++newfile_number) + ".lyx");
- while (bufferlist.exists(filename) || fs::is_readable(filename)) {
+ while (theBufferList().exists(filename) ||
+ fs::is_readable(FileName(filename).toFilesystemEncoding())) {
++newfile_number;
- filename = AddName(lyxrc.document_path,
+ filename = addName(lyxrc.document_path,
"newfile" + convert<string>(newfile_number) +
".lyx");
}
if (fromTemplate) {
FileDialog fileDlg(_("Select template file"),
LFUN_SELECT_FILE_SYNC,
- make_pair(string(_("Documents|#o#O")),
- string(lyxrc.document_path)),
- make_pair(string(_("Templates|#T#t")),
- string(lyxrc.template_path)));
+ make_pair(_("Documents|#o#O"), from_utf8(lyxrc.document_path)),
+ make_pair(_("Templates|#T#t"), from_utf8(lyxrc.template_path)));
FileDialog::Result result =
- fileDlg.open(lyxrc.template_path,
+ fileDlg.open(from_utf8(lyxrc.template_path),
FileFilterList(_("LyX Documents (*.lyx)")),
- string());
+ docstring());
if (result.first == FileDialog::Later)
return;
if (result.second.empty())
return;
- templname = result.second;
+ templname = to_utf8(result.second);
}
- view()->newFile(filename, templname, !name.empty());
+ Buffer * const b = newFile(filename, templname, !name.empty());
+ if (b)
+ lyx_view_->setBuffer(b);
}
{
string initpath = lyxrc.document_path;
- if (view()->available()) {
- string const trypath = owner->buffer()->filePath();
+ if (view()->buffer()) {
+ string const trypath = lyx_view_->buffer()->filePath();
// If directory is writeable, use this as default.
- if (IsDirWriteable(trypath))
+ if (isDirWriteable(FileName(trypath)))
initpath = trypath;
}
if (fname.empty()) {
FileDialog fileDlg(_("Select document to open"),
LFUN_FILE_OPEN,
- make_pair(string(_("Documents|#o#O")),
- string(lyxrc.document_path)),
- make_pair(string(_("Examples|#E#e")),
- string(AddPath(package().system_support(), "examples"))));
+ make_pair(_("Documents|#o#O"), from_utf8(lyxrc.document_path)),
+ make_pair(_("Examples|#E#e"), from_utf8(addPath(package().system_support(), "examples"))));
FileDialog::Result result =
- fileDlg.open(initpath,
+ fileDlg.open(from_utf8(initpath),
FileFilterList(_("LyX Documents (*.lyx)")),
- string());
+ docstring());
if (result.first == FileDialog::Later)
return;
- filename = result.second;
+ filename = to_utf8(result.second);
// check selected filename
if (filename.empty()) {
- owner->message(_("Canceled."));
+ lyx_view_->message(_("Canceled."));
return;
}
} else
// get absolute path of file and add ".lyx" to the filename if
// necessary
- string const fullpath = FileSearch(string(), filename, "lyx");
- if (!fullpath.empty()) {
- filename = fullpath;
- }
-
- string const disp_fn(MakeDisplayPath(filename));
+ FileName const fullname = fileSearch(string(), filename, "lyx");
+ if (!fullname.empty())
+ filename = fullname.absFilename();
// if the file doesn't exist, let the user create one
- if (!fs::exists(filename)) {
- // the user specifically chose this name. Believe them.
- view()->newFile(filename, "", true);
+ if (!fs::exists(fullname.toFilesystemEncoding())) {
+ // the user specifically chose this name. Believe him.
+ Buffer * const b = newFile(filename, string(), true);
+ if (b)
+ lyx_view_->setBuffer(b);
return;
}
- owner->message(bformat(_("Opening document %1$s..."), disp_fn));
+ docstring const disp_fn = makeDisplayPath(filename);
+ lyx_view_->message(bformat(_("Opening document %1$s..."), disp_fn));
- string str2;
- if (view()->loadLyXFile(filename)) {
+ docstring str2;
+ if (lyx_view_->loadLyXFile(fullname)) {
str2 = bformat(_("Document %1$s opened."), disp_fn);
} else {
str2 = bformat(_("Could not open document %1$s"), disp_fn);
}
- owner->message(str2);
+ lyx_view_->message(str2);
}
if (filename.empty()) {
string initpath = lyxrc.document_path;
- if (view()->available()) {
- string const trypath = owner->buffer()->filePath();
+ if (view()->buffer()) {
+ string const trypath = lyx_view_->buffer()->filePath();
// If directory is writeable, use this as default.
- if (IsDirWriteable(trypath))
+ if (isDirWriteable(FileName(trypath)))
initpath = trypath;
}
- string const text = bformat(_("Select %1$s file to import"),
+ docstring const text = bformat(_("Select %1$s file to import"),
formats.prettyName(format));
FileDialog fileDlg(text,
- LFUN_IMPORT,
- make_pair(string(_("Documents|#o#O")),
- string(lyxrc.document_path)),
- make_pair(string(_("Examples|#E#e")),
- string(AddPath(package().system_support(), "examples"))));
+ LFUN_BUFFER_IMPORT,
+ make_pair(_("Documents|#o#O"), from_utf8(lyxrc.document_path)),
+ make_pair(_("Examples|#E#e"),
+ from_utf8(addPath(package().system_support(), "examples"))));
- string const filter = formats.prettyName(format)
- + " (*." + formats.extension(format) + ')';
+ docstring filter = formats.prettyName(format);
+ filter += " (*.";
+ // FIXME UNICODE
+ filter += from_utf8(formats.extension(format));
+ filter += ')';
FileDialog::Result result =
- fileDlg.open(initpath,
+ fileDlg.open(from_utf8(initpath),
FileFilterList(filter),
- string());
+ docstring());
if (result.first == FileDialog::Later)
return;
- filename = result.second;
+ filename = to_utf8(result.second);
// check selected filename
if (filename.empty())
- owner->message(_("Canceled."));
+ lyx_view_->message(_("Canceled."));
}
if (filename.empty())
return;
// get absolute path of file
- filename = MakeAbsPath(filename);
+ FileName const fullname(makeAbsPath(filename));
- string const lyxfile = ChangeExtension(filename, ".lyx");
+ FileName const lyxfile(changeExtension(fullname.absFilename(), ".lyx"));
// Check if the document already is open
- if (lyx_gui::use_gui && bufferlist.exists(lyxfile)) {
- if (!bufferlist.close(bufferlist.getBuffer(lyxfile), true)) {
- owner->message(_("Canceled."));
+ if (use_gui && theBufferList().exists(lyxfile.absFilename())) {
+ if (!theBufferList().close(theBufferList().getBuffer(lyxfile.absFilename()), true)) {
+ lyx_view_->message(_("Canceled."));
return;
}
}
// if the file exists already, and we didn't do
// -i lyx thefile.lyx, warn
- if (fs::exists(lyxfile) && filename != lyxfile) {
- string const file = MakeDisplayPath(lyxfile, 30);
+ if (fs::exists(lyxfile.toFilesystemEncoding()) && fullname != lyxfile) {
+ docstring const file = makeDisplayPath(lyxfile.absFilename(), 30);
- string text = bformat(_("The document %1$s already exists.\n\n"
- "Do you want to over-write that document?"), file);
+ docstring text = bformat(_("The document %1$s already exists.\n\n"
+ "Do you want to over-write that document?"), file);
int const ret = Alert::prompt(_("Over-write document?"),
text, 0, 1, _("&Over-write"), _("&Cancel"));
if (ret == 1) {
- owner->message(_("Canceled."));
+ lyx_view_->message(_("Canceled."));
return;
}
}
- Importer::Import(owner, filename, format);
+ ErrorList errorList;
+ Importer::Import(lyx_view_, fullname, format, errorList);
+ // FIXME (Abdel 12/08/06): Is there a need to display the error list here?
}
void LyXFunc::closeBuffer()
{
- if (bufferlist.close(owner->buffer(), true) && !quitting) {
- if (bufferlist.empty()) {
+ // save current cursor position
+ LyX::ref().session().lastFilePos().save(FileName(lyx_view_->buffer()->fileName()),
+ boost::tie(view()->cursor().pit(), view()->cursor().pos()) );
+ // goto bookmark to update bookmark pit.
+ for (size_t i = 0; i < LyX::ref().session().bookmarks().size(); ++i)
+ gotoBookmark(i+1, false, false);
+ if (theBufferList().close(lyx_view_->buffer(), true) && !quitting) {
+ if (theBufferList().empty()) {
// need this otherwise SEGV may occur while
// trying to set variables that don't exist
// since there's no current buffer
- owner->getDialogs().hideBufferDependent();
+ lyx_view_->getDialogs().hideBufferDependent();
} else {
- view()->setBuffer(bufferlist.first());
+ lyx_view_->setBuffer(theBufferList().first());
}
}
}
-// Each "owner" should have it's own message method. lyxview and
+void LyXFunc::reloadBuffer()
+{
+ FileName filename(lyx_view_->buffer()->fileName());
+ closeBuffer();
+ lyx_view_->loadLyXFile(filename);
+}
+
+// Each "lyx_view_" should have it's own message method. lyxview and
// the minibuffer would use the minibuffer, but lyxserver would
// send an ERROR signal to its client. Alejandro 970603
// This function is bit problematic when it comes to NLS, to make the
// lyx servers client be language indepenent we must not translate
// strings sent to this func.
-void LyXFunc::setErrorMessage(string const & m) const
+void LyXFunc::setErrorMessage(docstring const & m) const
{
dispatch_buffer = m;
errorstat = true;
}
-void LyXFunc::setMessage(string const & m) const
+void LyXFunc::setMessage(docstring const & m) const
{
dispatch_buffer = m;
}
-string const LyXFunc::viewStatusMessage()
+docstring const LyXFunc::viewStatusMessage()
{
// When meta-fake key is pressed, show the key sequence so far + "M-".
if (wasMetaKey())
- return keyseq.print() + "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();
+ if (keyseq->length() > 0 && !keyseq->deleted())
+ return keyseq->printOptions(true);
- if (!view()->available())
+ if (!view()->buffer())
return _("Welcome to LyX!");
return view()->cursor().currentState();
BufferView * LyXFunc::view() const
{
- BOOST_ASSERT(owner);
- return owner->view().get();
+ BOOST_ASSERT(lyx_view_);
+ return lyx_view_->view();
}
switch (tag) {
case LyXRC::RC_ACCEPT_COMPOUND:
case LyXRC::RC_ALT_LANG:
- case LyXRC::RC_ASCIIROFF_COMMAND:
- case LyXRC::RC_ASCII_LINELEN:
+ case LyXRC::RC_PLAINTEXT_ROFF_COMMAND:
+ case LyXRC::RC_PLAINTEXT_LINELEN:
case LyXRC::RC_AUTOREGIONDELETE:
case LyXRC::RC_AUTORESET_OPTIONS:
case LyXRC::RC_AUTOSAVE:
case LyXRC::RC_BIBTEX_COMMAND:
case LyXRC::RC_BINDFILE:
case LyXRC::RC_CHECKLASTFILES:
+ case LyXRC::RC_USELASTFILEPOS:
+ case LyXRC::RC_LOADSESSION:
case LyXRC::RC_CHKTEX_COMMAND:
case LyXRC::RC_CONVERTER:
+ case LyXRC::RC_CONVERTER_CACHE_MAXAGE:
case LyXRC::RC_COPIER:
case LyXRC::RC_CURSOR_FOLLOWS_SCROLLBAR:
case LyXRC::RC_CUSTOM_EXPORT_COMMAND:
case LyXRC::RC_CUSTOM_EXPORT_FORMAT:
- case LyXRC::RC_CYGWIN_PATH_FIX:
- if (lyxrc_orig.cygwin_path_fix != lyxrc_new.cygwin_path_fix) {
- namespace os = lyx::support::os;
- os::cygwin_path_fix(lyxrc_new.cygwin_path_fix);
- }
case LyXRC::RC_DATE_INSERT_FORMAT:
case LyXRC::RC_DEFAULT_LANGUAGE:
case LyXRC::RC_DEFAULT_PAPERSIZE:
case LyXRC::RC_DISPLAY_GRAPHICS:
case LyXRC::RC_DOCUMENTPATH:
if (lyxrc_orig.document_path != lyxrc_new.document_path) {
- if (fs::exists(lyxrc_new.document_path) &&
- fs::is_directory(lyxrc_new.document_path)) {
- using lyx::support::package;
- package().document_dir() = lyxrc.document_path;
- }
+ string const encoded = FileName(
+ lyxrc_new.document_path).toFilesystemEncoding();
+ if (fs::exists(encoded) && fs::is_directory(encoded))
+ support::package().document_dir() = lyxrc.document_path;
}
case LyXRC::RC_ESC_CHARS:
case LyXRC::RC_FONT_ENCODING:
case LyXRC::RC_LANGUAGE_GLOBAL_OPTIONS:
case LyXRC::RC_LANGUAGE_PACKAGE:
case LyXRC::RC_LANGUAGE_USE_BABEL:
- case LyXRC::RC_LASTFILES:
case LyXRC::RC_MAKE_BACKUP:
case LyXRC::RC_MARK_FOREIGN_LANGUAGE:
case LyXRC::RC_NUMLASTFILES:
case LyXRC::RC_PATH_PREFIX:
if (lyxrc_orig.path_prefix != lyxrc_new.path_prefix) {
- using lyx::support::prependEnvPath;
- prependEnvPath("PATH", lyxrc.path_prefix);
+ support::prependEnvPath("PATH", lyxrc.path_prefix);
}
case LyXRC::RC_PERS_DICT:
case LyXRC::RC_POPUP_BOLD_FONT:
case LyXRC::RC_SCREEN_FONT_SIZES:
case LyXRC::RC_SCREEN_FONT_TYPEWRITER:
case LyXRC::RC_SCREEN_FONT_TYPEWRITER_FOUNDRY:
+ case LyXRC::RC_SCREEN_GEOMETRY_HEIGHT:
+ case LyXRC::RC_SCREEN_GEOMETRY_WIDTH:
+ case LyXRC::RC_SCREEN_GEOMETRY_XYSAVED:
case LyXRC::RC_SCREEN_ZOOM:
case LyXRC::RC_SERVERPIPE:
case LyXRC::RC_SET_COLOR:
case LyXRC::RC_TEMPDIRPATH:
case LyXRC::RC_TEMPLATEPATH:
case LyXRC::RC_TEX_ALLOWS_SPACES:
+ case LyXRC::RC_TEX_EXPECTS_WINDOWS_PATHS:
+ if (lyxrc_orig.windows_style_tex_paths != lyxrc_new.windows_style_tex_paths) {
+ support::os::windows_style_tex_paths(lyxrc_new.windows_style_tex_paths);
+ }
case LyXRC::RC_UIFILE:
case LyXRC::RC_USER_EMAIL:
case LyXRC::RC_USER_NAME:
case LyXRC::RC_USETEMPDIR:
case LyXRC::RC_USE_ALT_LANG:
+ case LyXRC::RC_USE_CONVERTER_CACHE:
case LyXRC::RC_USE_ESC_CHARS:
case LyXRC::RC_USE_INP_ENC:
case LyXRC::RC_USE_PERS_DICT:
case LyXRC::RC_USE_SPELL_LIB:
case LyXRC::RC_VIEWDVI_PAPEROPTION:
case LyXRC::RC_VIEWER:
- case LyXRC::RC_WHEEL_JUMP:
case LyXRC::RC_LAST:
break;
}
}
} // namespace anon
+
+
+} // namespace lyx
projects / lyx.git / blobdiff