#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,
+bool findNextInset(DocIterator & dit, vector<InsetCode> const & codes,
string const & contents)
{
DocIterator tmpdit = dit;
/// Looks for next inset with one of the the given code
-bool findInset(DocIterator & dit, vector<Inset_code> const & codes,
+bool findInset(DocIterator & dit, vector<InsetCode> const & codes,
bool same_content)
{
string contents;
/// 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) {
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;
}
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
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();
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();
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
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.");
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