* Licence details can be found in the file COPYING.
*
* \author Asger Alstrup
- * \author Lars Gullik Bjønnes
+ * \author Lars Gullik Bjønnes
* \author Jean-Marc Lasgouttes
* \author Angus Leeming
* \author John Levon
- * \author André Pönitz
+ * \author André Pönitz
* \author Dekel Tsur
- * \author Jürgen Vigna
+ * \author Jürgen Vigna
*
* Full author contact details are available in file CREDITS.
*/
#include "output_latex.h"
#include "paragraph_funcs.h"
#include "ParagraphParameters.h"
+#include "SpellChecker.h"
#include "sgml.h"
#include "TextClass.h"
#include "TexRow.h"
#include "Text.h"
#include "VSpace.h"
+#include "WordLangTuple.h"
#include "WordList.h"
#include "frontends/alert.h"
#include "insets/InsetLabel.h"
#include "support/lassert.h"
-#include "support/convert.h"
#include "support/debug.h"
#include "support/ExceptionMessage.h"
#include "support/gettext.h"
}
+bool Paragraph::isFullyDeleted(pos_type start, pos_type end) const
+{
+ LASSERT(start >= 0 && start <= size(), /**/);
+ LASSERT(end > start && end <= size() + 1, /**/);
+
+ return d->changes_.isFullyDeleted(start, end);
+}
+
+
bool Paragraph::isChanged(pos_type start, pos_type end) const
{
LASSERT(start >= 0 && start <= size(), /**/);
}
bool close = false;
- odocstringstream ods;
+ odocstream::pos_type const len = os.tellp();
if (inset->forceLTR()
&& running_font.isRightToLeft()
// ERT is an exception, it should be output with no decorations at all
&& inset->lyxCode() != ERT_CODE) {
if (running_font.language()->lang() == "farsi")
- ods << "\\beginL{}";
+ os << "\\beginL{}";
else
- ods << "\\L{";
+ os << "\\L{";
close = true;
}
if (open_font && inset->noFontChange()) {
bool closeLanguage = arabtex
|| basefont.isRightToLeft() == running_font.isRightToLeft();
- unsigned int count = running_font.latexWriteEndChanges(ods,
+ unsigned int count = running_font.latexWriteEndChanges(os,
bparams, runparams, basefont, basefont, closeLanguage);
column += count;
// if any font properties were closed, update the running_font,
int tmp;
try {
- tmp = inset->latex(ods, runparams);
+ tmp = inset->latex(os, runparams);
} catch (EncodingException & e) {
// add location information and throw again.
e.par_id = id_;
if (close) {
if (running_font.language()->lang() == "farsi")
- ods << "\\endL{}";
+ os << "\\endL{}";
else
- ods << '}';
+ os << '}';
}
- os << ods.str();
-
if (tmp) {
for (int j = 0; j < tmp; ++j)
texrow.newline();
texrow.start(owner_->id(), i + 1);
column = 0;
} else {
- column += ods.str().size();
+ column += os.tellp() - len;
}
if (owner_->lookupChange(i).type == Change::DELETED)
return;
}
- if (lyxrc.fontenc == "T1" && latexSpecialT1(c, os, i, column))
+ // If T1 font encoding is used, use the special
+ // characters it provides.
+ // NOTE: some languages reset the font encoding
+ // internally
+ if (!running_font.language()->internalFontEncoding()
+ && lyxrc.fontenc == "T1" && latexSpecialT1(c, os, i, column))
return;
+ // \tt font needs special treatment
if (running_font.fontInfo().family() == TYPEWRITER_FAMILY
&& latexSpecialTypewriter(c, os, i, column))
return;
column += 17;
break;
- case '*': case '[':
+ case '*':
+ case '[':
+ case ']':
// avoid being mistaken for optional arguments
os << '{';
os.put(c);
d->text_.append(s);
// FIXME: Optimize this!
- for (pos_type i = oldsize; i != newsize; ++i) {
+ for (size_t i = oldsize; i != newsize; ++i) {
// track change
d->changes_.insert(change, i);
}
// the next two functions are for the manual labels
docstring const Paragraph::getLabelWidthString() const
{
- if (d->layout_->margintype == MARGIN_MANUAL)
+ if (d->layout_->margintype == MARGIN_MANUAL
+ || d->layout_->latextype == LATEX_BIB_ENVIRONMENT)
return d->params_.labelWidthString();
else
return _("Senseless with this layout!");
if (fmt.empty() && layout.labeltype == LABEL_COUNTER
&& !layout.counter.empty())
- fmt = "\\the" + layout.counter;
+ return tclass.counters().theCounter(layout.counter);
// handle 'inherited level parts' in 'fmt',
// i.e. the stuff between '@' in '@Section@.\arabic{subsection}'
// This one spits out the text of the paragraph
bool Paragraph::latex(BufferParams const & bparams,
- Font const & outerfont,
- odocstream & os, TexRow & texrow,
- OutputParams const & runparams) const
+ Font const & outerfont,
+ odocstream & os, TexRow & texrow,
+ OutputParams const & runparams,
+ int start_pos, int end_pos) const
{
LYXERR(Debug::LATEX, "Paragraph::latex... " << this);
os << fontchange;
}
- if (c == ' ') {
+ // FIXME: think about end_pos implementation...
+ if (c == ' ' && i >= start_pos && (end_pos == -1 || i < end_pos)) {
// FIXME: integrate this case in latexSpecialChar
// Do not print the separation of the optional argument
// if style.pass_thru is false. This works because
// Two major modes: LaTeX or plain
// Handle here those cases common to both modes
// and then split to handle the two modes separately.
- if (c == META_INSET)
- d->latexInset(bparams, os,
- texrow, rp, running_font,
- basefont, outerfont, open_font,
- runningChange, style, i, column);
- else {
- try {
- d->latexSpecialChar(os, rp, running_font, runningChange,
- style, i, column);
- } catch (EncodingException & e) {
+ if (c == META_INSET) {
+ if (i >= start_pos && (end_pos == -1 || i < end_pos)) {
+ d->latexInset(bparams, os,
+ texrow, rp, running_font,
+ basefont, outerfont, open_font,
+ runningChange, style, i, column);
+ }
+ } else {
+ if (i >= start_pos && (end_pos == -1 || i < end_pos)) {
+ try {
+ d->latexSpecialChar(os, rp, running_font, runningChange,
+ style, i, column);
+ } catch (EncodingException & e) {
if (runparams.dryrun) {
os << "<" << _("LyX Warning: ")
<< _("uncodable character") << " '";
}
}
}
+ }
// Set the encoding to that returned from latexSpecialChar (see
// comment for encoding member in OutputParams.h)
if (Inset const * inset = getInset(pos))
return inset->isLetter();
char_type const c = d->text_[pos];
- return isLetterChar(c) || isDigit(c);
+ // We want to pass the ' and escape chars to the spellchecker
+ static docstring const quote = from_utf8(lyxrc.spellchecker_esc_chars + '\'');
+ return (isLetterChar(c) || isDigit(c) || contains(quote, c))
+ && (!d->inset_owner_ || d->inset_owner_->allowSpellCheck())
+ && pos != size()
+ && !isDeleted(pos);
}
|| (c == '\n' && options & AS_STR_NEWLINES))
os.put(c);
else if (c == META_INSET && options & AS_STR_INSETS)
- getInset(i)->textString(os);
+ getInset(i)->tocString(os);
+ }
+
+ return os.str();
+}
+
+
+docstring Paragraph::stringify(pos_type beg, pos_type end, int options, OutputParams & runparams) const
+{
+ odocstringstream os;
+
+ if (beg == 0
+ && options & AS_STR_LABEL
+ && !d->params_.labelString().empty())
+ os << d->params_.labelString() << ' ';
+
+ for (pos_type i = beg; i < end; ++i) {
+ char_type const c = d->text_[i];
+ if (isPrintable(c) || c == '\t'
+ || (c == '\n' && options & AS_STR_NEWLINES))
+ os.put(c);
+ else if (c == META_INSET && options & AS_STR_INSETS) {
+ getInset(i)->plaintext(os, runparams);
+ }
}
return os.str();
Inset const & Paragraph::inInset() const
{
LASSERT(d->inset_owner_, throw ExceptionMessage(BufferException,
- _("Memory problem"), _("Paragraph not properly initiliazed")));
+ _("Memory problem"), _("Paragraph not properly initialized")));
return *d->inset_owner_;
}
}
-void Paragraph::collectWords(CursorSlice const & sl)
+void Paragraph::locateWord(pos_type & from, pos_type & to,
+ word_location const loc) const
{
- // find new words
- bool inword = false;
+ switch (loc) {
+ case WHOLE_WORD_STRICT:
+ if (from == 0 || from == size()
+ || !isLetter(from)
+ || !isLetter(from - 1)) {
+ to = from;
+ return;
+ }
+ // no break here, we go to the next
+
+ case WHOLE_WORD:
+ // If we are already at the beginning of a word, do nothing
+ if (!from || !isLetter(from - 1))
+ break;
+ // no break here, we go to the next
+
+ case PREVIOUS_WORD:
+ // always move the cursor to the beginning of previous word
+ while (from && isLetter(from - 1))
+ --from;
+ break;
+ case NEXT_WORD:
+ LYXERR0("Paragraph::locateWord: NEXT_WORD not implemented yet");
+ break;
+ case PARTIAL_WORD:
+ // no need to move the 'from' cursor
+ break;
+ }
+ to = from;
+ while (to < size() && isLetter(to))
+ ++to;
+}
+
+
+void Paragraph::collectWords()
+{
+ SpellChecker * speller = theSpellChecker();
//lyxerr << "Words: ";
pos_type n = size();
- for (pos_type pos = 0; pos != n; ++pos) {
- if (isDeleted(pos))
+ for (pos_type pos = 0; pos < n; ++pos) {
+ if (!isLetter(pos))
continue;
-
- if (!isLetter(pos)) {
- inword = false;
+ pos_type from = pos;
+ locateWord(from, pos, WHOLE_WORD);
+ if (!lyxrc.spellcheck_continuously && pos - from < 6)
continue;
- }
- if (inword)
- continue;
+ docstring word = asString(from, pos, false);
+ if (pos - from >= 6)
+ d->words_.insert(word);
- inword = true;
- CursorSlice from = sl;
- CursorSlice to = sl;
- from.pos() = pos;
- to.pos() = pos;
- from.text()->getWord(from, to, WHOLE_WORD);
- if (to.pos() - from.pos() < 6)
+ if (!lyxrc.spellcheck_continuously || !speller)
continue;
- docstring word = asString(from.pos(), to.pos(), false);
- d->words_.insert(word);
+
+ string lang_code = lyxrc.spellchecker_use_alt_lang
+ ? lyxrc.spellchecker_alt_lang
+ : getFontSettings(d->inset_owner_->buffer().params(), from).language()->code();
+ WordLangTuple wl(word, lang_code);
+ SpellChecker::Result res = speller->check(wl);
+ // ... just ignore any error that the spellchecker reports.
+ if (!speller->error().empty())
+ continue;
+ bool const misspelled = res != SpellChecker::OK
+ && res != SpellChecker::IGNORED_WORD;
+ d->fontlist_.setMisspelled(from, pos, misspelled);
+
//lyxerr << word << " ";
}
//lyxerr << std::endl;
}
-void Paragraph::updateWords(CursorSlice const & sl)
+void Paragraph::updateWords()
{
- LASSERT(&sl.paragraph() == this, /**/);
deregisterWords();
- collectWords(sl);
+ collectWords();
registerWords();
}
+
+bool Paragraph::isMisspelled(pos_type pos) const
+{
+ SpellChecker * speller = theSpellChecker();
+ pos_type from = pos;
+ pos_type to = pos;
+ locateWord(from, to, WHOLE_WORD);
+ docstring word = asString(from, to, false);
+ if (!speller)
+ return false;
+
+ string lang_code = lyxrc.spellchecker_use_alt_lang
+ ? lyxrc.spellchecker_alt_lang
+ : getFontSettings(d->inset_owner_->buffer().params(), from).language()->code();
+ WordLangTuple wl(word, lang_code);
+ SpellChecker::Result res = speller->check(wl);
+ // ... just ignore any error that the spellchecker reports.
+ if (!speller->error().empty())
+ return false;
+
+ bool const misspelled = res != SpellChecker::OK
+ && res != SpellChecker::IGNORED_WORD;
+ if (lyxrc.spellcheck_continuously)
+ d->fontlist_.setMisspelled(from, pos, misspelled);
+ return misspelled;
+}
+
+
} // namespace lyx
projects / lyx.git / blobdiff