#include "BufferParams.h"
#include "BufferView.h"
#include "Changes.h"
+#include "CompletionList.h"
#include "Cursor.h"
-#include "ParIterator.h"
#include "CutAndPaste.h"
#include "DispatchResult.h"
#include "Encoding.h"
#include "Paragraph.h"
#include "paragraph_funcs.h"
#include "ParagraphParameters.h"
+#include "ParIterator.h"
#include "TextClass.h"
#include "TextMetrics.h"
#include "VSpace.h"
#include "WordLangTuple.h"
+#include "WordList.h"
#include "insets/InsetText.h"
#include "insets/InsetBibitem.h"
#include "insets/InsetCaption.h"
-#include "insets/InsetHFill.h"
#include "insets/InsetLine.h"
#include "insets/InsetNewline.h"
#include "insets/InsetNewpage.h"
font = Font(inherit_font, bp.language);
change = Change(Change::UNCHANGED);
- TextClass const & tclass = bp.textClass();
+ DocumentClass const & tclass = bp.documentClass();
if (layoutname.empty())
layoutname = tclass.defaultLayoutName();
tclass.defaultLayoutName();
}
- par.setLayout(bp.textClass()[layoutname]);
+ par.setLayout(bp.documentClass()[layoutname]);
// Test whether the layout is obsolete.
- LayoutPtr const & layout = par.layout();
- if (!layout->obsoleted_by().empty())
- par.setLayout(bp.textClass()[layout->obsoleted_by()]);
+ Layout const & layout = par.layout();
+ if (!layout.obsoleted_by().empty())
+ par.setLayout(bp.documentClass()[layout.obsoleted_by()]);
par.params().read(lex);
} else if (token == "\\color") {
lex.next();
setLyXColor(lex.getString(), font.fontInfo());
- } else if (token == "\\InsetSpace" || token == "\\SpecialChar") {
-
- // Insets don't make sense in a free-spacing context! ---Kayvan
- if (par.isFreeSpacing()) {
- if (token == "\\InsetSpace")
- par.appendChar(' ', font, change);
- else if (lex.isOK()) {
- lex.next();
- string const next_token = lex.getString();
- if (next_token == "\\-")
- par.appendChar('-', font, change);
- else {
- lex.printError("Token `$$Token' "
- "is in free space "
- "paragraph layout!");
- }
- }
- } else {
+ } else if (token == "\\SpecialChar") {
auto_ptr<Inset> inset;
- if (token == "\\SpecialChar" )
- inset.reset(new InsetSpecialChar);
- else
- inset.reset(new InsetSpace);
- inset->read(buf, lex);
+ inset.reset(new InsetSpecialChar);
+ inset->read(lex);
par.insertInset(par.size(), inset.release(),
font, change);
- }
} else if (token == "\\backslash") {
par.appendChar('\\', font, change);
} else if (token == "\\linebreak") {
auto_ptr<Inset> inset(new InsetLinebreak);
- inset->read(buf, lex);
+ inset->read(lex);
par.insertInset(par.size(), inset.release(), font, change);
} else if (token == "\\newline") {
auto_ptr<Inset> inset(new InsetNewline);
- inset->read(buf, lex);
+ inset->read(lex);
par.insertInset(par.size(), inset.release(), font, change);
} else if (token == "\\LyXTable") {
auto_ptr<Inset> inset(new InsetTabular(buf));
- inset->read(buf, lex);
+ inset->read(lex);
par.insertInset(par.size(), inset.release(), font, change);
- } else if (token == "\\hfill") {
- par.insertInset(par.size(), new InsetHFill, font, change);
} else if (token == "\\lyxline") {
par.insertInset(par.size(), new InsetLine, font, change);
} else if (token == "\\newpage") {
} // namespace anon
+class TextCompletionList : public CompletionList
+{
+public:
+ ///
+ TextCompletionList(Cursor const & cur)
+ : buf_(cur.buffer()), pos_(0) {}
+ ///
+ virtual ~TextCompletionList() {}
+
+ ///
+ virtual bool sorted() const { return true; }
+ ///
+ virtual size_t size() const
+ {
+ return theWordList().size();
+ }
+ ///
+ virtual docstring const & data(size_t idx) const
+ {
+ return theWordList().word(idx);
+ }
+
+private:
+ ///
+ Buffer const & buf_;
+ ///
+ size_t pos_;
+};
+
bool Text::empty() const
{
return pars_.empty() || (pars_.size() == 1 && pars_[0].empty()
// FIXME: Should we consider the labeled type as empty too?
- && pars_[0].layout()->labeltype == LABEL_NO_LABEL);
+ && pars_[0].layout().labeltype == LABEL_NO_LABEL);
}
Paragraph & cpar = cur.paragraph();
pit_type cpit = cur.pit();
- TextClass const & tclass = cur.buffer().params().textClass();
- LayoutPtr const & layout = cpar.layout();
+ DocumentClass const & tclass = cur.buffer().params().documentClass();
+ Layout const & layout = cpar.layout();
// this is only allowed, if the current paragraph is not empty
// or caption and if it has not the keepempty flag active
if (cur.lastpos() == 0 && !cpar.allowEmpty() &&
- layout->labeltype != LABEL_SENSITIVE)
+ layout.labeltype != LABEL_SENSITIVE)
return;
// a layout change may affect also the following paragraph
// What should the layout for the new paragraph be?
bool keep_layout = inverse_logic ?
- !layout->isEnvironment()
- : layout->isEnvironment();
+ !layout.isEnvironment()
+ : layout.isEnvironment();
// We need to remember this before we break the paragraph, because
// that invalidates the layout variable
- bool sensitive = layout->labeltype == LABEL_SENSITIVE;
+ bool sensitive = layout.labeltype == LABEL_SENSITIVE;
// we need to set this before we insert the paragraph.
bool const isempty = cpar.allowEmpty() && cpar.empty();
// try to remove this
pit_type const pit = cur.pit();
- bool const freeSpacing = par.layout()->free_spacing ||
+ bool const freeSpacing = par.layout().free_spacing ||
par.isFreeSpacing();
if (lyxrc.auto_number) {
!(contains(number_seperators, c) &&
cur.pos() != 0 &&
cur.pos() != cur.lastpos() &&
- tm.getDisplayFont(pit, cur.pos()).fontInfo().number() == FONT_ON &&
- tm.getDisplayFont(pit, cur.pos() - 1).fontInfo().number() == FONT_ON)
+ tm.displayFont(pit, cur.pos()).fontInfo().number() == FONT_ON &&
+ tm.displayFont(pit, cur.pos() - 1).fontInfo().number() == FONT_ON)
)
number(cur); // Set current_font.number to OFF
} else if (isDigit(c) &&
tm.font_);
} else if (contains(number_seperators, c)
&& cur.pos() >= 2
- && tm.getDisplayFont(pit, cur.pos() - 2).fontInfo().number() == FONT_ON) {
+ && tm.displayFont(pit, cur.pos() - 2).fontInfo().number() == FONT_ON) {
setCharFont(buffer, pit, cur.pos() - 1, cur.current_font,
tm.font_);
}
if ((cur.pos() >= 2) && (par.isLineSeparator(cur.pos() - 1))) {
// get font in front and behind the space in question. But do NOT
// use getFont(cur.pos()) because the character c is not inserted yet
- Font const pre_space_font = tm.getDisplayFont(cur.pit(), cur.pos() - 2);
+ Font const pre_space_font = tm.displayFont(cur.pit(), cur.pos() - 2);
Font const & post_space_font = cur.real_current_font;
bool pre_space_rtl = pre_space_font.isVisibleRightToLeft();
bool post_space_rtl = post_space_font.isVisibleRightToLeft();
(pre_space_rtl == par.isRTL(buffer.params())) ?
pre_space_font.language() : post_space_font.language();
- Font space_font = tm.getDisplayFont(cur.pit(), cur.pos() - 1);
+ Font space_font = tm.displayFont(cur.pit(), cur.pos() - 1);
space_font.setLanguage(lang);
par.setFont(cur.pos() - 1, space_font);
}
&& !par.isLetter(cur.pos() - 1)) {
// get the word in front of cursor
BOOST_ASSERT(this == cur.text());
- CursorSlice focus = cur.top();
- focus.backwardPos();
- CursorSlice from = focus;
- CursorSlice to = focus;
- getWord(from, to, PREVIOUS_WORD);
- if (focus == from || to == from)
- return;
- docstring word
- = par.asString(cur.buffer(), from.pos(), to.pos(), false);
-
- // register words longer than 5 characters
- if (word.length() > 5)
- cur.buffer().registerWord(word);
+ cur.paragraph().updateWords(cur.top());
}
}
bool Text::handleBibitems(Cursor & cur)
{
- if (cur.paragraph().layout()->labeltype != LABEL_BIBLIO)
+ if (cur.paragraph().layout().labeltype != LABEL_BIBLIO)
return false;
if (cur.pos() != 0)
}
// otherwise reset to default
- if (par.useEmptyLayout())
- cur.paragraph().setLayout(bufparams.textClass().emptyLayout());
- else
- cur.paragraph().setLayout(bufparams.textClass().defaultLayout());
+ cur.paragraph().setEmptyOrDefaultLayout(bufparams.documentClass());
return true;
}
bool needsUpdate = false;
BufferParams const & bufparams = cur.buffer().params();
- TextClass const & tclass = bufparams.textClass();
+ DocumentClass const & tclass = bufparams.documentClass();
ParagraphList & plist = cur.text()->paragraphs();
Paragraph const & par = cur.paragraph();
Cursor prevcur = cur;
// Correction: Pasting is always allowed with standard-layout
// or the empty layout.
else if (par.layout() == prevpar.layout()
- || par.layout() == tclass.defaultLayout()
- || par.layout() == tclass.emptyLayout()) {
+ || tclass.isDefaultLayout(par.layout())
+ || tclass.isEmptyLayout(par.layout())) {
cur.recordUndo(ATOMIC_UNDO, prevcur.pit());
mergeParagraph(bufparams, plist, prevcur.pit());
needsUpdate = true;
for (; it != it_end; it++)
it->changeLanguage(b.params(), latex_language, b.language());
- pasteParagraphList(cur, plist, b.params().textClassIndex(),
+ pasteParagraphList(cur, plist, b.params().documentClassPtr(),
b.errorList("Paste"));
// restore position
cur.pit() = min(cur.lastpit(), spit);
void Text::getWord(CursorSlice & from, CursorSlice & to,
- word_location const loc)
+ word_location const loc) const
{
Paragraph const & from_par = pars_[from.pit()];
switch (loc) {
break;
}
to = from;
- Paragraph & to_par = pars_[to.pit()];
+ Paragraph const & to_par = pars_[to.pit()];
while (to.pos() < to_par.size() && to_par.isLetter(to.pos()))
++to.pos();
}
ParagraphList::const_iterator end = paragraphs().end();
depth_type dth = 0;
for (; pit != end; ++pit)
- pit->write(buf, os, buf.params(), dth);
+ pit->write(os, buf.params(), dth);
// Close begin_deeper
for(; dth > 0; --dth)
// not BufferParams
lyx::readParagraph(buf, pars_.back(), lex, errorList);
+ // register the words in the global word list
+ CursorSlice sl = CursorSlice(*insetPtr);
+ sl.pit() = pars_.size() - 1;
+ pars_.back().updateWords(sl);
} else if (token == "\\begin_deeper") {
++depth;
} else if (token == "\\end_deeper") {
{
pit_type pit = cur.pit();
- LayoutPtr layout = pars_[pit].layout();
+ Layout const * layout = &(pars_[pit].layout());
docstring text;
- docstring par_text = pars_[pit].asString(cur.buffer(), false);
+ docstring par_text = pars_[pit].asString(false);
string piece;
// the return string of math matrices might contain linebreaks
par_text = subst(par_text, '\n', '-');
// For section, subsection, etc...
if (layout->latextype == LATEX_PARAGRAPH && pit != 0) {
- LayoutPtr const & layout2 = pars_[pit - 1].layout();
+ Layout const * layout2 = &(pars_[pit - 1].layout());
if (layout2->latextype != LATEX_PARAGRAPH) {
--pit;
layout = layout2;
}
+docstring Text::previousWord(CursorSlice const & sl) const
+{
+ CursorSlice from = sl;
+ CursorSlice to = sl;
+ getWord(from, to, PREVIOUS_WORD);
+ if (sl == from || to == from)
+ return docstring();
+
+ Paragraph const & par = sl.paragraph();
+ return par.asString(from.pos(), to.pos(), false);
+}
+
+
+bool Text::completionSupported(Cursor const & cur) const
+{
+ Paragraph const & par = cur.paragraph();
+ return cur.pos() > 0
+ && (cur.pos() >= par.size() || !par.isLetter(cur.pos()))
+ && par.isLetter(cur.pos() - 1);
+}
+
+
+CompletionList const * Text::createCompletionList(Cursor const & cur) const
+{
+ return new TextCompletionList(cur);
+}
+
+
+bool Text::insertCompletion(Cursor & cur, docstring const & s, bool /*finished*/)
+{
+ BOOST_ASSERT(cur.bv().cursor() == cur);
+ cur.insert(s);
+ cur.bv().cursor() = cur;
+ if (!(cur.disp_.update() & Update::Force))
+ cur.updateFlags(cur.disp_.update() | Update::SinglePar);
+ return true;
+}
+
+
+docstring Text::completionPrefix(Cursor const & cur) const
+{
+ return previousWord(cur.top());
+}
+
} // namespace lyx
projects / lyx.git / blobdiff