#include "CutAndPaste.h"
#include "debug.h"
#include "DispatchResult.h"
+#include "EmbeddedFiles.h"
#include "ErrorList.h"
#include "factory.h"
#include "FloatList.h"
#include "TextClass.h"
#include "TextMetrics.h"
#include "TexRow.h"
-#include "Undo.h"
#include "VSpace.h"
#include "WordLangTuple.h"
using support::FileFilterList;
using support::FileName;
using support::fileSearch;
-using support::isDirWriteable;
-using support::isFileReadable;
using support::makeDisplayPath;
using support::makeAbsPath;
using support::package;
/// Return an inset of this class if it exists at the current cursor position
template <class T>
-T * getInsetByCode(Cursor const & cur, Inset::Code code)
+T * getInsetByCode(Cursor const & cur, InsetCode code)
{
DocIterator it = cur;
Inset * inset = it.nextInset();
}
-bool findInset(DocIterator & dit, vector<Inset_code> const & codes,
+bool findInset(DocIterator & dit, vector<InsetCode> const & codes,
bool same_content);
-bool findNextInset(DocIterator & dit, vector<Inset_code> const & codes,
- string const & contents)
+bool findNextInset(DocIterator & dit, vector<InsetCode> const & codes,
+ docstring const & contents)
{
DocIterator tmpdit = dit;
if (inset
&& find(codes.begin(), codes.end(), inset->lyxCode()) != codes.end()
&& (contents.empty() ||
- static_cast<InsetCommand const *>(inset)->getContents() == contents)) {
+ static_cast<InsetCommand const *>(inset)->getFirstNonOptParam() == contents)) {
dit = tmpdit;
return true;
}
}
-/// Looks for next inset with one of the the given code
-bool findInset(DocIterator & dit, vector<Inset_code> const & codes,
+/// Looks for next inset with one of the given codes.
+bool findInset(DocIterator & dit, vector<InsetCode> const & codes,
bool same_content)
{
- string contents;
+ docstring contents;
DocIterator tmpdit = dit;
tmpdit.forwardInset();
if (!tmpdit)
Inset const * inset = tmpdit.nextInset();
if (inset
&& find(codes.begin(), codes.end(), inset->lyxCode()) != codes.end()) {
- contents = static_cast<InsetCommand const *>(inset)->getContents();
+ contents = static_cast<InsetCommand const *>(inset)->getFirstNonOptParam();
}
}
/// Looks for next inset with the given code
-void findInset(DocIterator & dit, Inset_code code, bool same_content)
+void findInset(DocIterator & dit, InsetCode code, bool same_content)
{
- findInset(dit, vector<Inset_code>(1, code), same_content);
+ findInset(dit, vector<InsetCode>(1, code), same_content);
}
/// Moves cursor to the next inset with one of the given codes.
-void gotoInset(BufferView * bv, vector<Inset_code> const & codes,
+void gotoInset(BufferView * bv, vector<InsetCode> const & codes,
bool same_content)
{
Cursor tmpcur = bv->cursor();
/// Moves cursor to the next inset with given code.
-void gotoInset(BufferView * bv, Inset_code code, bool same_content)
+void gotoInset(BufferView * bv, InsetCode code, bool same_content)
{
- gotoInset(bv, vector<Inset_code>(1, code), same_content);
+ gotoInset(bv, vector<InsetCode>(1, code), same_content);
}
pit_type const newpit = std::distance(bgn, dest);
pit_type const len = std::distance(start, finish);
pit_type const deletepit = pit + len;
- recordUndo(cur, Undo::ATOMIC, newpit, deletepit - 1);
+ buf.undo().recordUndo(cur, ATOMIC_UNDO, newpit, deletepit - 1);
pars.insert(dest, start, finish);
start = boost::next(pars.begin(), deletepit);
pit = newpit;
// One such was found:
pit_type newpit = std::distance(bgn, dest);
pit_type const len = std::distance(start, finish);
- recordUndo(cur, Undo::ATOMIC, pit, newpit - 1);
+ buf.undo().recordUndo(cur, ATOMIC_UNDO, pit, newpit - 1);
pars.insert(dest, start, finish);
start = boost::next(bgn, pit);
pit = newpit - len;
break;
}
case OutlineIn:
- recordUndo(cur);
+ buf.undo().recordUndo(cur);
for (; lit != lend; ++lit) {
if ((*lit)->toclevel == thistoclevel + 1 &&
start->layout()->labeltype == (*lit)->labeltype) {
}
break;
case OutlineOut:
- recordUndo(cur);
+ buf.undo().recordUndo(cur);
for (; lit != lend; ++lit) {
if ((*lit)->toclevel == thistoclevel - 1 &&
start->layout()->labeltype == (*lit)->labeltype) {
// That is to say, if a cursor is in a nested inset, it will be
// restore to the left of the top level inset.
LyX::ref().session().lastFilePos().save(
- support::FileName(buffer_.fileName()),
+ support::FileName(buffer_.absFileName()),
boost::tie(d->cursor_.bottom().pit(), d->cursor_.bottom().pos()) );
delete d;
{
if (cursorStatus(d->cursor_) == CUR_INSIDE) {
frontend::FontMetrics const & fm =
- theFontMetrics(d->cursor_.getFont());
+ theFontMetrics(d->cursor_.getFont().fontInfo());
int const asc = fm.maxAscent();
int const des = fm.maxDescent();
Point const p = getPos(d->cursor_, d->cursor_.boundary());
// pit and pos will be updated with bottom level pit/pos
// when lyx exits.
LyX::ref().session().bookmarks().save(
- FileName(buffer_.fileName()),
+ FileName(buffer_.absFileName()),
d->cursor_.bottom().pit(),
d->cursor_.bottom().pos(),
d->cursor_.paragraph().id(),
switch (cmd.action) {
case LFUN_UNDO:
- flag.enabled(!buffer_.undostack().empty());
+ flag.enabled(buffer_.undo().hasUndoStack());
break;
case LFUN_REDO:
- flag.enabled(!buffer_.redostack().empty());
+ flag.enabled(buffer_.undo().hasRedoStack());
break;
case LFUN_FILE_INSERT:
case LFUN_FILE_INSERT_PLAINTEXT_PARA:
case LFUN_LABEL_GOTO: {
flag.enabled(!cmd.argument().empty()
- || getInsetByCode<InsetRef>(cur, Inset::REF_CODE));
+ || getInsetByCode<InsetRef>(cur, REF_CODE));
break;
}
flag.setOnOff(buffer_.params().compressed);
break;
}
+
+ case LFUN_BUFFER_TOGGLE_EMBEDDING: {
+ flag.setOnOff(buffer_.params().embedded);
+ break;
+ }
case LFUN_SCREEN_UP:
case LFUN_SCREEN_DOWN:
break;
case LFUN_LAYOUT_TABULAR:
- flag.enabled(cur.innerInsetOfType(Inset::TABULAR_CODE));
+ flag.enabled(cur.innerInsetOfType(TABULAR_CODE));
break;
case LFUN_LAYOUT:
break;
case LFUN_INSET_SETTINGS: {
- Inset::Code code = cur.inset().lyxCode();
+ InsetCode code = cur.inset().lyxCode();
bool enable = false;
switch (code) {
- case Inset::TABULAR_CODE:
+ case TABULAR_CODE:
enable = cmd.argument() == "tabular";
break;
- case Inset::ERT_CODE:
+ case ERT_CODE:
enable = cmd.argument() == "ert";
break;
- case Inset::FLOAT_CODE:
+ case FLOAT_CODE:
enable = cmd.argument() == "float";
break;
- case Inset::WRAP_CODE:
+ case WRAP_CODE:
enable = cmd.argument() == "wrap";
break;
- case Inset::NOTE_CODE:
+ case NOTE_CODE:
enable = cmd.argument() == "note";
break;
- case Inset::BRANCH_CODE:
+ case BRANCH_CODE:
enable = cmd.argument() == "branch";
break;
- case Inset::BOX_CODE:
+ case BOX_CODE:
enable = cmd.argument() == "box";
break;
- case Inset::LISTINGS_CODE:
+ case LISTINGS_CODE:
enable = cmd.argument() == "listings";
break;
default:
}
case LFUN_DIALOG_SHOW_NEW_INSET:
- flag.enabled(cur.inset().lyxCode() != Inset::ERT_CODE &&
- cur.inset().lyxCode() != Inset::LISTINGS_CODE);
- if (cur.inset().lyxCode() == Inset::CAPTION_CODE) {
+ flag.enabled(cur.inset().lyxCode() != ERT_CODE &&
+ cur.inset().lyxCode() != LISTINGS_CODE);
+ if (cur.inset().lyxCode() == CAPTION_CODE) {
FuncStatus flag;
if (cur.inset().getStatus(cur, cmd, flag))
return flag;
case LFUN_UNDO:
cur.message(_("Undo"));
cur.clearSelection();
- if (!textUndo(*this)) {
+ if (!cur.textUndo()) {
cur.message(_("No further undo information"));
updateFlags = Update::None;
}
case LFUN_REDO:
cur.message(_("Redo"));
cur.clearSelection();
- if (!textRedo(*this)) {
+ if (!cur.textRedo()) {
cur.message(_("No further redo information"));
updateFlags = Update::None;
}
if (label.empty()) {
InsetRef * inset =
getInsetByCode<InsetRef>(d->cursor_,
- Inset::REF_CODE);
+ REF_CODE);
if (inset) {
label = inset->getParam("reference");
// persistent=false: use temp_bookmark
LYXERR(Debug::INFO)
<< "Paragraph " << par->id()
<< " found in buffer `"
- << b->fileName() << "'." << endl;
+ << b->absFileName() << "'." << endl;
if (b == &buffer_) {
// Set the cursor
} else {
// Switch to other buffer view and resend cmd
theLyXFunc().dispatch(FuncRequest(
- LFUN_BUFFER_SWITCH, b->fileName()));
+ LFUN_BUFFER_SWITCH, b->absFileName()));
theLyXFunc().dispatch(cmd);
updateFlags = Update::None;
}
break;
case LFUN_NOTE_NEXT:
- gotoInset(this, Inset::NOTE_CODE, false);
+ gotoInset(this, NOTE_CODE, false);
break;
case LFUN_REFERENCE_NEXT: {
- vector<Inset_code> tmp;
- tmp.push_back(Inset::LABEL_CODE);
- tmp.push_back(Inset::REF_CODE);
+ vector<InsetCode> tmp;
+ tmp.push_back(LABEL_CODE);
+ tmp.push_back(REF_CODE);
gotoInset(this, tmp, true);
break;
}
case LFUN_BIBTEX_DATABASE_ADD: {
Cursor tmpcur = d->cursor_;
- findInset(tmpcur, Inset::BIBTEX_CODE, false);
+ findInset(tmpcur, BIBTEX_CODE, false);
InsetBibtex * inset = getInsetByCode<InsetBibtex>(tmpcur,
- Inset::BIBTEX_CODE);
+ BIBTEX_CODE);
if (inset) {
if (inset->addDatabase(to_utf8(cmd.argument())))
buffer_.updateBibfilesCache();
case LFUN_BIBTEX_DATABASE_DEL: {
Cursor tmpcur = d->cursor_;
- findInset(tmpcur, Inset::BIBTEX_CODE, false);
+ findInset(tmpcur, BIBTEX_CODE, false);
InsetBibtex * inset = getInsetByCode<InsetBibtex>(tmpcur,
- Inset::BIBTEX_CODE);
+ BIBTEX_CODE);
if (inset) {
if (inset->delDatabase(to_utf8(cmd.argument())))
buffer_.updateBibfilesCache();
// turn compression on/off
buffer_.params().compressed = !buffer_.params().compressed;
break;
+
+ case LFUN_BUFFER_TOGGLE_EMBEDDING:
+ // turn embedding on/off
+ buffer_.embeddedFiles().enable(!buffer_.params().embedded);
+ break;
case LFUN_NEXT_INSET_TOGGLE: {
// this is the real function we want to invoke
cur.reset(buffer_.inset());
d->text_metrics_[&buffer_.text()].editXY(cur, p.x_, p.y_);
//FIXME: what to do with cur.x_target()?
- finishUndo();
+ cur.finishUndo();
// The metrics are already up to date. see scroll()
updateFlags = Update::None;
break;
// FIXME: We need to verify if the cursor stayed within an inset...
//cur.reset(buffer_.inset());
d->text_metrics_[&buffer_.text()].editXY(cur, p.x_, p.y_);
- finishUndo();
+ cur.finishUndo();
while (cur.depth() > initial_depth) {
cur.forwardInset();
}
else
d->cursor_.clearSelection();
- finishUndo();
+ d->cursor_.finishUndo();
+ d->cursor_.setCurrentFont();
return update;
}
string initpath = lyxrc.document_path;
string const trypath = buffer_.filePath();
// If directory is writeable, use this as default.
- if (isDirWriteable(FileName(trypath)))
+ if (FileName(trypath).isDirWritable())
initpath = trypath;
// FIXME UNICODE
- FileDialog fileDlg(_("Select LyX document to insert"),
- LFUN_FILE_INSERT,
- make_pair(_("Documents|#o#O"), from_utf8(lyxrc.document_path)),
- make_pair(_("Examples|#E#e"),
- from_utf8(addPath(package().system_support().absFilename(),
- "examples"))));
+ FileDialog dlg(_("Select LyX document to insert"), LFUN_FILE_INSERT);
+ dlg.setButton1(_("Documents|#o#O"), from_utf8(lyxrc.document_path));
+ dlg.setButton2(_("Examples|#E#e"),
+ from_utf8(addPath(package().system_support().absFilename(),
+ "examples")));
FileDialog::Result result =
- fileDlg.open(from_utf8(initpath),
+ dlg.open(from_utf8(initpath),
FileFilterList(_("LyX Documents (*.lyx)")),
docstring());
docstring res;
Buffer buf("", false);
- if (lyx::loadLyXFile(&buf, FileName(filename))) {
+ if (buf.loadLyXFile(FileName(filename))) {
ErrorList & el = buffer_.errorList("Parse");
// Copy the inserted document error list into the current buffer one.
el = buf.errorList("Parse");
- recordUndo(d->cursor_);
+ buffer_.undo().recordUndo(d->cursor_);
cap::pasteParagraphList(d->cursor_, buf.paragraphs(),
buf.params().getTextClassPtr(), el);
res = _("Document %1$s inserted.");
- } else
+ } else {
res = _("Could not insert document %1$s");
+ }
// emit message signal.
message(bformat(res, disp_fn));
// lyxerr << "par ascent: " << text.getPar(d->metrics_info_.p1).ascent() << endl;
if (d->metrics_info_.y1 > 0
&& d->metrics_info_.update_strategy == FullScreenUpdate)
- pain.fillRectangle(0, 0, width_, d->metrics_info_.y1, Color::bottomarea);
+ pain.fillRectangle(0, 0, width_, d->metrics_info_.y1, Color_bottomarea);
// and possibly grey out below
// lyxerr << "par descent: " << text.getPar(d->metrics_info_.p1).ascent() << endl;
if (d->metrics_info_.y2 < height_
&& d->metrics_info_.update_strategy == FullScreenUpdate)
pain.fillRectangle(0, d->metrics_info_.y2, width_,
- height_ - d->metrics_info_.y2, Color::bottomarea);
+ height_ - d->metrics_info_.y2, Color_bottomarea);
}
FileName fname(f);
if (fname.empty()) {
- FileDialog fileDlg(_("Select file to insert"),
+ FileDialog dlg(_("Select file to insert"),
( asParagraph
? LFUN_FILE_INSERT_PLAINTEXT_PARA
: LFUN_FILE_INSERT_PLAINTEXT) );
FileDialog::Result result =
- fileDlg.open(from_utf8(buffer().filePath()),
+ dlg.open(from_utf8(buffer().filePath()),
FileFilterList(), docstring());
if (result.first == FileDialog::Later)
Cursor & cur = cursor();
cap::replaceSelection(cur);
- recordUndo(cur);
+ buffer_.undo().recordUndo(cur);
if (asParagraph)
cur.innerText()->insertStringAsParagraphs(cur, tmpstr);
else
cur.innerText()->insertStringAsLines(cur, tmpstr);
}
-
} // namespace lyx