#include "Author.h"
#include "Buffer.h"
-#include "buffer_funcs.h"
#include "BufferParams.h"
#include "BufferView.h"
#include "Changes.h"
#include "CompletionList.h"
#include "Cursor.h"
+#include "CursorSlice.h"
#include "CutAndPaste.h"
-#include "DispatchResult.h"
#include "Encoding.h"
#include "ErrorList.h"
-#include "FuncRequest.h"
#include "factory.h"
-#include "InsetList.h"
+#include "Font.h"
+#include "FuncRequest.h"
#include "Language.h"
#include "Layout.h"
#include "Lexer.h"
#include "LyXRC.h"
#include "Paragraph.h"
#include "ParagraphParameters.h"
-#include "ParIterator.h"
#include "TextClass.h"
#include "TextMetrics.h"
-#include "WordLangTuple.h"
#include "WordList.h"
+#include "insets/Inset.h"
#include "insets/InsetText.h"
-#include "insets/InsetBibitem.h"
#include "insets/InsetCaption.h"
-#include "insets/InsetNewline.h"
-#include "insets/InsetNewpage.h"
-#include "insets/InsetArgument.h"
#include "insets/InsetIPAMacro.h"
-#include "insets/InsetSpace.h"
#include "insets/InsetSpecialChar.h"
#include "insets/InsetTabular.h"
#include "support/convert.h"
#include "support/debug.h"
#include "support/docstream.h"
+#include "support/docstring.h"
#include "support/gettext.h"
#include "support/lassert.h"
-#include "support/Length.h"
#include "support/lstrings.h"
-#include "support/lyxalgo.h"
#include "support/lyxtime.h"
#include "support/textutils.h"
#include "support/unique_ptr.h"
if (par.getDepth() == 0)
return pars_.size();
- return depthHook(par_offset, depth_type(par.getDepth() - 1));
+ return depthHook(par_offset, par.getDepth() - 1);
}
void Text::readParToken(Paragraph & par, Lexer & lex,
string const & token, Font & font, Change & change, ErrorList & errorList)
{
- Buffer * buf = const_cast<Buffer *>(&owner_->buffer());
+ Buffer * buf = &owner_->buffer();
BufferParams & bp = buf->params();
if (token[0] != '\\') {
pos_type pos = cur.pos();
// The special chars we handle
- map<wchar_t, InsetSpecialChar::Kind> specialchars;
- specialchars[0x200c] = InsetSpecialChar::LIGATURE_BREAK;
- specialchars[0x200b] = InsetSpecialChar::ALLOWBREAK;
- specialchars[0x2026] = InsetSpecialChar::LDOTS;
- specialchars[0x2011] = InsetSpecialChar::NOBREAKDASH;
+ static map<wchar_t, InsetSpecialChar::Kind> specialchars = {
+ { 0x200c, InsetSpecialChar::LIGATURE_BREAK },
+ { 0x200b, InsetSpecialChar::ALLOWBREAK },
+ { 0x2026, InsetSpecialChar::LDOTS },
+ { 0x2011, InsetSpecialChar::NOBREAKDASH }
+ };
// insert the string, don't insert doublespace
bool space_inserted = true;
++pos;
space_inserted = true;
}
- } else if (specialchars.find(ch) != specialchars.end()) {
- par.insertInset(pos, new InsetSpecialChar(specialchars.find(ch)->second),
- font, bparams.track_changes ?
- Change(Change::INSERTED)
- : Change(Change::UNCHANGED));
+ } else if (specialchars.find(ch) != specialchars.end()
+ && (par.insertInset(pos, new InsetSpecialChar(specialchars.find(ch)->second),
+ font, bparams.track_changes
+ ? Change(Change::INSERTED)
+ : Change(Change::UNCHANGED)))) {
++pos;
space_inserted = false;
} else if (!isPrintable(ch)) {
&& par.isWordSeparator(cur.pos() - 1)) {
// get the word in front of cursor
LBUFERR(this == cur.text());
- cur.paragraph().updateWords();
+ par.updateWords();
}
}
}
+void Text::expandWordSel(Cursor & cur)
+{
+ // get selection of word around cur
+ Cursor c = cur;
+ c.selection(false);
+ c.text()->selectWord(c, WHOLE_WORD);
+ // use the correct word boundary, depending on selection direction
+ if (cur.top() > cur.normalAnchor())
+ cur.pos() = c.selEnd().pos();
+ else
+ cur.pos() = c.selBegin().pos();
+}
+
+
void Text::selectAll(Cursor & cur)
{
LBUFERR(this == cur.text());
}
// finally, invoke the DEPM
- deleteEmptyParagraphMechanism(begPit, endPit, cur.buffer()->params().track_changes);
+ deleteEmptyParagraphMechanism(begPit, endPit, begPos, endPos,
+ cur.buffer()->params().track_changes);
cur.finishUndo();
cur.clearSelection();
Cursor prev_cur = cur;
--prev_cur.pit();
- if (cur.paragraph().size() > 0
+ if (!cur.paragraph().empty()
&& !prev_cur.paragraph().isMergedOnEndOfParDeletion(cur.buffer()->params().track_changes)) {
cur.recordUndo(prev_cur.pit(), prev_cur.pit());
prev_cur.paragraph().setChange(prev_cur.lastpos(), Change(Change::DELETED));
*/
DocumentClass const & tclass = cur.buffer()->params().documentClass();
if (inset_it.lastpos() == 1
- && !tclass.isPlainLayout(plist[0].layout())
- && !tclass.isDefaultLayout(plist[0].layout()))
- cur.paragraph().makeSameLayout(plist[0]);
+ && !tclass.isPlainLayout(plist[0].layout())
+ && !tclass.isDefaultLayout(plist[0].layout())) {
+ // Copy all parameters except depth.
+ Paragraph & par = cur.paragraph();
+ par.setLayout(plist[0].layout());
+ depth_type const dpth = par.getDepth();
+ par.params() = plist[0].params();
+ par.params().depth(dpth);
+ }
pasteParagraphList(cur, plist, b.params().documentClassPtr(),
+ b.params().authors(),
b.errorList("Paste"));
}
}
+bool Text::splitInset(Cursor & cur)
+{
+ LASSERT(this == cur.text(), return false);
+
+ if (isMainText() || cur.inset().nargs() != 1)
+ return false;
+
+ cur.recordUndo();
+ if (cur.selection()) {
+ // start from selection begin
+ setCursor(cur, cur.selBegin().pit(), cur.selBegin().pos());
+ cur.clearSelection();
+ }
+ // save split position inside inset
+ // (we need to copy the whole inset first)
+ pos_type spos = cur.pos();
+ pit_type spit = cur.pit();
+ // some things only need to be done if the inset has content
+ bool const inset_non_empty = cur.lastpit() != 0 || cur.lastpos() != 0;
+
+ // move right before the inset
+ cur.popBackward();
+ cur.resetAnchor();
+ // remember position outside inset
+ pos_type ipos = cur.pos();
+ pit_type ipit = cur.pit();
+ // select inset ...
+ ++cur.pos();
+ cur.setSelection();
+ // ... and copy
+ cap::copySelectionToTemp(cur);
+ cur.clearSelection();
+ cur.resetAnchor();
+ // paste copied inset
+ cap::pasteFromTemp(cur, cur.buffer()->errorList("Paste"));
+ cur.forceBufferUpdate();
+
+ // if the inset has text, cut after split position
+ // and paste to new inset
+ if (inset_non_empty) {
+ // go back to first inset
+ cur.text()->setCursor(cur, ipit, ipos);
+ cur.forwardPos();
+ setCursor(cur, spit, spos);
+ cur.resetAnchor();
+ setCursor(cur, cur.lastpit(), getPar(cur.lastpit()).size());
+ cur.setSelection();
+ cap::cutSelectionToTemp(cur);
+ cur.setMark(false);
+ cur.selHandle(false);
+ cur.resetAnchor();
+ bool atlastpos = false;
+ if (cur.pos() == 0 && cur.pit() > 0) {
+ // if we are at par start, remove this par
+ cur.text()->backspace(cur);
+ cur.forceBufferUpdate();
+ } else if (cur.pos() == cur.lastpos())
+ atlastpos = true;
+ // Move out of and jump over inset
+ cur.popBackward();
+ ++cur.pos();
+
+ // enter new inset
+ cur.forwardPos();
+ cur.setCursor(cur);
+ cur.resetAnchor();
+ cur.text()->selectAll(cur);
+ cutSelection(cur, false);
+ cap::pasteFromTemp(cur, cur.buffer()->errorList("Paste"));
+ cur.text()->setCursor(cur, 0, 0);
+ if (atlastpos && cur.paragraph().isFreeSpacing() && cur.paragraph().empty()) {
+ // We started from par end, remove extra empty par in free spacing insets
+ cur.text()->erase(cur);
+ cur.forceBufferUpdate();
+ }
+ }
+
+ cur.finishUndo();
+ return true;
+}
+
+
void Text::getWord(CursorSlice & from, CursorSlice & to,
word_location const loc) const
{
// Custom text style
InsetLayout const & layout = cur.inset().getLayout();
- if (layout.lyxtype() == InsetLayout::CHARSTYLE)
+ if (layout.lyxtype() == InsetLyXType::CHARSTYLE)
os << _(", Style: ") << translateIfPossible(layout.labelstring());
if (devel_mode) {
if (!par.empty() && cur.pos() < par.size()) {
// Force output of code point, not character
size_t const c = par.getChar(cur.pos());
- os << _(", Char: 0x") << hex << c;
+ if (c == META_INSET)
+ os << ", Char: INSET";
+ else
+ os << _(", Char: 0x") << hex << c;
}
os << _(", Boundary: ") << cur.boundary();
// Row & row = cur.textRow();
bool Text::completionSupported(Cursor const & cur) const
{
Paragraph const & par = cur.paragraph();
- return !cur.selection()
+ return !cur.buffer()->isReadonly()
+ && !cur.selection()
&& cur.pos() > 0
&& (cur.pos() >= par.size() || par.isWordSeparator(cur.pos()))
&& !par.isWordSeparator(cur.pos() - 1);
}
-bool Text::insertCompletion(Cursor & cur, docstring const & s, bool /*finished*/)
+bool Text::insertCompletion(Cursor & cur, docstring const & s)
{
LBUFERR(cur.bv().cursor() == cur);
+ if (cur.buffer()->isReadonly())
+ return false;
+ cur.recordUndo();
cur.insert(s);
cur.bv().cursor() = cur;
if (!(cur.result().screenUpdate() & Update::Force))
projects / features.git / blobdiff