}
-pit_type depthHook(pit_type pit, ParagraphList const & pars, depth_type depth)
+pit_type Text::depthHook(pit_type pit, depth_type depth) const
{
pit_type newpit = pit;
if (newpit != 0)
--newpit;
- while (newpit != 0 && pars[newpit].getDepth() > depth)
+ while (newpit != 0 && pars_[newpit].getDepth() > depth)
--newpit;
- if (pars[newpit].getDepth() > depth)
+ if (pars_[newpit].getDepth() > depth)
return pit;
return newpit;
}
-pit_type outerHook(pit_type par_offset, ParagraphList const & pars)
+pit_type Text::outerHook(pit_type par_offset) const
{
- Paragraph const & par = pars[par_offset];
+ Paragraph const & par = pars_[par_offset];
if (par.getDepth() == 0)
- return pars.size();
- return depthHook(par_offset, pars, depth_type(par.getDepth() - 1));
+ return pars_.size();
+ return depthHook(par_offset, depth_type(par.getDepth() - 1));
}
-bool isFirstInSequence(pit_type par_offset, ParagraphList const & pars)
+bool Text::isFirstInSequence(pit_type par_offset) const
{
- Paragraph const & par = pars[par_offset];
+ Paragraph const & par = pars_[par_offset];
- pit_type dhook_offset = depthHook(par_offset, pars, par.getDepth());
+ pit_type dhook_offset = depthHook(par_offset, par.getDepth());
if (dhook_offset == par_offset)
return true;
- Paragraph const & dhook = pars[dhook_offset];
+ Paragraph const & dhook = pars_[dhook_offset];
return dhook.layout() != par.layout()
|| dhook.getDepth() != par.getDepth();
}
-void setLabelWidthStringToSequence(pit_type const par_offset,
- ParagraphList & pars, docstring const & s)
+Font const Text::outerFont(pit_type par_offset) const
{
- pit_type offset = par_offset;
- // Find first of same layout in sequence
- while (!isFirstInSequence(offset, pars)) {
- offset = depthHook(offset, pars, pars[offset].getDepth());
- }
-
- // now apply label width string to every par
- // in sequence
- pit_type const end = pars.size();
- depth_type const depth = pars[offset].getDepth();
- Layout const & layout = pars[offset].layout();
- for (pit_type pit = offset; pit != end; ++pit) {
- while (pars[pit].getDepth() > depth)
- ++pit;
- if (pars[pit].getDepth() < depth)
- return;
- if (pars[pit].layout() != layout)
- return;
- pars[pit].setLabelWidthString(s);
- }
-}
-
-
-int getEndLabel(pit_type p, ParagraphList const & pars)
-{
- pit_type pit = p;
- depth_type par_depth = pars[p].getDepth();
- while (pit != pit_type(pars.size())) {
- Layout const & layout = pars[pit].layout();
- int const endlabeltype = layout.endlabeltype;
-
- if (endlabeltype != END_LABEL_NO_LABEL) {
- if (p + 1 == pit_type(pars.size()))
- return endlabeltype;
-
- depth_type const next_depth =
- pars[p + 1].getDepth();
- if (par_depth > next_depth ||
- (par_depth == next_depth && layout != pars[p + 1].layout()))
- return endlabeltype;
- break;
- }
- if (par_depth == 0)
- break;
- pit = outerHook(pit, pars);
- if (pit != pit_type(pars.size()))
- par_depth = pars[pit].getDepth();
- }
- return END_LABEL_NO_LABEL;
-}
-
-
-Font const outerFont(pit_type par_offset, ParagraphList const & pars)
-{
- depth_type par_depth = pars[par_offset].getDepth();
+ depth_type par_depth = pars_[par_offset].getDepth();
FontInfo tmpfont = inherit_font;
// Resolve against environment font information
- while (par_offset != pit_type(pars.size())
+ while (par_offset != pit_type(pars_.size())
&& par_depth
&& !tmpfont.resolved()) {
- par_offset = outerHook(par_offset, pars);
- if (par_offset != pit_type(pars.size())) {
- tmpfont.realize(pars[par_offset].layout().font);
- par_depth = pars[par_offset].getDepth();
+ par_offset = outerHook(par_offset);
+ if (par_offset != pit_type(pars_.size())) {
+ tmpfont.realize(pars_[par_offset].layout().font);
+ par_depth = pars_[par_offset].getDepth();
}
}
}
-bool isFullyDeleted(ParagraphList const & pars)
-{
- pit_type const pars_size = static_cast<pit_type>(pars.size());
-
- // check all paragraphs
- for (pit_type pit = 0; pit < pars_size; ++pit) {
- if (!pars[pit].empty()) // prevent assertion failure
- if (!pars[pit].isDeleted(0, pars[pit].size()))
- return false;
- }
- return true;
-}
-
-
void acceptChanges(ParagraphList & pars, BufferParams const & bparams)
{
pit_type pars_size = static_cast<pit_type>(pars.size());
void Text::readParToken(Paragraph & par, Lexer & lex,
string const & token, Font & font, Change & change, ErrorList & errorList)
{
- Buffer const & buf = owner_->buffer();
- BufferParams const & bp = buf.params();
+ Buffer * buf = const_cast<Buffer *>(&owner_->buffer());
+ BufferParams const & bp = buf->params();
if (token[0] != '\\') {
docstring dstr = lex.getDocString();
}
} else if (token == "\\numeric") {
lex.next();
- font.fontInfo().setNumber(font.setLyXMisc(lex.getString()));
+ font.fontInfo().setNumber(setLyXMisc(lex.getString()));
} else if (token == "\\emph") {
lex.next();
- font.fontInfo().setEmph(font.setLyXMisc(lex.getString()));
+ font.fontInfo().setEmph(setLyXMisc(lex.getString()));
} else if (token == "\\bar") {
lex.next();
string const tok = lex.getString();
"`$$Token'");
} else if (token == "\\strikeout") {
lex.next();
- font.fontInfo().setStrikeout(font.setLyXMisc(lex.getString()));
+ font.fontInfo().setStrikeout(setLyXMisc(lex.getString()));
} else if (token == "\\uuline") {
lex.next();
- font.fontInfo().setUuline(font.setLyXMisc(lex.getString()));
+ font.fontInfo().setUuline(setLyXMisc(lex.getString()));
} else if (token == "\\uwave") {
lex.next();
- font.fontInfo().setUwave(font.setLyXMisc(lex.getString()));
+ font.fontInfo().setUwave(setLyXMisc(lex.getString()));
} else if (token == "\\noun") {
lex.next();
- font.fontInfo().setNoun(font.setLyXMisc(lex.getString()));
+ font.fontInfo().setNoun(setLyXMisc(lex.getString()));
} else if (token == "\\color") {
lex.next();
setLyXColor(lex.getString(), font.fontInfo());
} else if (token == "\\SpecialChar") {
- auto_ptr<Inset> inset;
- inset.reset(new InsetSpecialChar);
- inset->read(lex);
- par.insertInset(par.size(), inset.release(),
- font, change);
+ auto_ptr<Inset> inset;
+ inset.reset(new InsetSpecialChar);
+ inset->read(lex);
+ inset->setBuffer(*buf);
+ par.insertInset(par.size(), inset.release(), font, change);
} else if (token == "\\backslash") {
par.appendChar('\\', font, change);
} else if (token == "\\LyXTable") {
- auto_ptr<Inset> inset(new InsetTabular(const_cast<Buffer &>(buf)));
+ auto_ptr<Inset> inset(new InsetTabular(buf));
inset->read(lex);
par.insertInset(par.size(), inset.release(), font, change);
} else if (token == "\\lyxline") {
- par.insertInset(par.size(), new InsetLine, font, change);
+ auto_ptr<Inset> inset;
+ inset.reset(new InsetLine);
+ inset->setBuffer(*buf);
+ par.insertInset(par.size(), inset.release(), font, change);
} else if (token == "\\change_unchanged") {
change = Change(Change::UNCHANGED);
} else if (token == "\\change_inserted" || token == "\\change_deleted") {
{
public:
///
- TextCompletionList(Cursor const & cur)
- : buffer_(cur.buffer()), pos_(0)
+ TextCompletionList(Cursor const & cur, WordList const * list)
+ : buffer_(cur.buffer()), pos_(0), list_(list)
{}
///
virtual ~TextCompletionList() {}
///
virtual size_t size() const
{
- return theWordList().size();
+ return list_->size();
}
///
virtual docstring const & data(size_t idx) const
{
- return theWordList().word(idx);
+ return list_->word(idx);
}
private:
Buffer const * buffer_;
///
size_t pos_;
+ ///
+ WordList const * list_;
};
* keep_layout == false
* - keep current depth and layout when keep_layout == true
*/
-static void breakParagraph(BufferParams const & bparams,
- ParagraphList & pars, pit_type par_offset, pos_type pos,
+static void breakParagraph(Text & text, pit_type par_offset, pos_type pos,
bool keep_layout)
{
+ BufferParams const & bparams = text.inset().buffer().params();
+ ParagraphList & pars = text.paragraphs();
// create a new paragraph, and insert into the list
ParagraphList::iterator tmp =
pars.insert(boost::next(pars.begin(), par_offset + 1),
tmp->setLabelWidthString(par.params().labelWidthString());
tmp->params().depth(par.params().depth());
} else if (par.params().depth() > 0) {
- Paragraph const & hook = pars[outerHook(par_offset, pars)];
+ Paragraph const & hook = pars[text.outerHook(par_offset)];
tmp->setLayout(hook.layout());
// not sure the line below is useful
tmp->setLabelWidthString(par.params().labelWidthString());
// we need to set this before we insert the paragraph.
bool const isempty = cpar.allowEmpty() && cpar.empty();
- lyx::breakParagraph(cur.buffer()->params(), paragraphs(), cpit,
- cur.pos(), keep_layout);
+ lyx::breakParagraph(*this, cpit, cur.pos(), keep_layout);
// After this, neither paragraph contains any rows!
Paragraph & par = pars_[pit];
if (*cit == '\n') {
if (autoBreakRows_ && (!par.empty() || par.allowEmpty())) {
- lyx::breakParagraph(bparams, pars_, pit, pos,
- par.layout().isEnvironment());
+ lyx::breakParagraph(*this, pit, pos,
+ par.layout().isEnvironment());
++pit;
pos = 0;
space_inserted = true;
cur.checkBufferStructure();
// cur.updateFlags(Update::Force);
- bool boundary = tm.isRTLBoundary(cur.pit(), cur.pos() + 1);
+ bool boundary = cur.boundary()
+ || tm.isRTLBoundary(cur.pit(), cur.pos() + 1);
setCursor(cur, cur.pit(), cur.pos() + 1, false, boundary);
charInserted(cur);
}
// Here we call finishUndo for every 20 characters inserted.
// This is from my experience how emacs does it. (Lgb)
- static unsigned int counter;
- if (counter < 20) {
- ++counter;
+ if (undo_counter_ < 20) {
+ ++undo_counter_;
} else {
cur.finishUndo();
- counter = 0;
+ undo_counter_ = 0;
}
// register word if a non-letter was entered
setCursor(cur, from.pit(), from.pos());
if (to == from)
return;
- cur.resetAnchor();
+ if (!cur.selection())
+ cur.resetAnchor();
setCursor(cur, to.pit(), to.pos());
cur.setSelection();
+ cur.setWordSelection(true);
}
// this is the least that needs to be done (bug 6003)
// in the above case, pasteParagraphList handles this
cur.buffer()->updateLabels();
+
+ // Ensure the current language is set correctly (bug 6292)
+ cur.text()->setCursor(cur, cur.pit(), cur.pos());
cur.clearSelection();
cur.resetAnchor();
return true;
readParagraph(pars_.back(), lex, errorList);
// register the words in the global word list
- CursorSlice sl = CursorSlice(*insetPtr);
- sl.pit() = pars_.size() - 1;
pars_.back().updateWords();
} else if (token == "\\begin_deeper") {
++depth;
CompletionList const * Text::createCompletionList(Cursor const & cur) const
{
- return new TextCompletionList(cur);
+ WordList const * list = theWordList(*cur.getFont().language());
+ return new TextCompletionList(cur, list);
}
projects / lyx.git / blobdiff