3 * This file is part of LyX, the document processor.
4 * Licence details can be found in the file COPYING.
6 * \author Asger Alstrup
7 * \author Lars Gullik Bjønnes
8 * \author Jean-Marc Lasgouttes
9 * \author Angus Leeming
11 * \author André Pönitz
13 * \author Jürgen Vigna
15 * Full author contact details are available in file CREDITS.
20 #include "Paragraph.h"
22 #include "LayoutFile.h"
24 #include "BufferParams.h"
28 #include "InsetList.h"
30 #include "LaTeXFeatures.h"
36 #include "OutputParams.h"
37 #include "output_latex.h"
38 #include "output_xhtml.h"
39 #include "paragraph_funcs.h"
40 #include "ParagraphParameters.h"
41 #include "SpellChecker.h"
43 #include "TextClass.h"
47 #include "WordLangTuple.h"
50 #include "frontends/alert.h"
52 #include "insets/InsetBibitem.h"
53 #include "insets/InsetLabel.h"
55 #include "support/lassert.h"
56 #include "support/debug.h"
57 #include "support/ExceptionMessage.h"
58 #include "support/gettext.h"
59 #include "support/lstrings.h"
60 #include "support/Messages.h"
61 #include "support/textutils.h"
67 using namespace lyx::support
;
72 /// Inset identifier (above 0x10ffff, for ucs-4)
73 char_type
const META_INSET
= 0x200001;
76 /////////////////////////////////////////////////////////////////////
80 /////////////////////////////////////////////////////////////////////
82 class Paragraph::Private
86 Private(Paragraph
* owner
, Layout
const & layout
);
87 /// "Copy constructor"
88 Private(Private
const &, Paragraph
* owner
);
89 /// Copy constructor from \p beg to \p end
90 Private(Private
const &, Paragraph
* owner
, pos_type beg
, pos_type end
);
93 void insertChar(pos_type pos
, char_type c
, Change
const & change
);
95 /// Output the surrogate pair formed by \p c and \p next to \p os.
96 /// \return the number of characters written.
97 int latexSurrogatePair(odocstream
& os
, char_type c
, char_type next
,
100 /// Output a space in appropriate formatting (or a surrogate pair
101 /// if the next character is a combining character).
102 /// \return whether a surrogate pair was output.
103 bool simpleTeXBlanks(OutputParams
const &,
104 odocstream
&, TexRow
& texrow
,
106 unsigned int & column
,
108 Layout
const & style
);
110 /// Output consecutive unicode chars, belonging to the same script as
111 /// specified by the latex macro \p ltx, to \p os starting from \p i.
112 /// \return the number of characters written.
113 int writeScriptChars(odocstream
& os
, docstring
const & ltx
,
114 Change
const &, Encoding
const &, pos_type
& i
);
116 /// This could go to ParagraphParameters if we want to.
117 int startTeXParParams(BufferParams
const &, odocstream
&, TexRow
&,
118 OutputParams
const &) const;
120 /// This could go to ParagraphParameters if we want to.
121 int endTeXParParams(BufferParams
const &, odocstream
&, TexRow
&,
122 OutputParams
const &) const;
125 void latexInset(BufferParams
const &,
127 TexRow
& texrow
, OutputParams
&,
130 Font
const & outerfont
,
132 Change
& running_change
,
133 Layout
const & style
,
135 unsigned int & column
);
138 void latexSpecialChar(
140 OutputParams
const & runparams
,
141 Font
const & running_font
,
142 Change
const & running_change
,
143 Layout
const & style
,
145 unsigned int & column
);
152 unsigned int & column
);
154 bool latexSpecialTypewriter(
158 unsigned int & column
);
160 bool latexSpecialPhrase(
163 unsigned int & column
,
164 OutputParams
const & runparams
);
167 void validate(LaTeXFeatures
& features
,
168 Layout
const & layout
) const;
170 /// Checks if the paragraph contains only text and no inset or font change.
171 bool onlyText(Buffer
const & buf
, Font
const & outerfont
,
172 pos_type initial
) const;
174 /// match a string against a particular point in the paragraph
175 bool isTextAt(string
const & str
, pos_type pos
) const;
177 /// Which Paragraph owns us?
181 Inset
const * inset_owner_
;
189 static unsigned int paragraph_id
;
191 ParagraphParameters params_
;
193 /// for recording and looking up changes
197 InsetList insetlist_
;
200 pos_type begin_of_body_
;
202 typedef docstring TextContainer
;
206 typedef std::set
<docstring
> Words
;
210 Layout
const * layout_
;
214 // Initialization of the counter for the paragraph id's,
215 unsigned int Paragraph::Private::paragraph_id
= 0;
219 struct special_phrase
{
225 special_phrase
const special_phrases
[] = {
226 { "LyX", from_ascii("\\LyX{}"), false },
227 { "TeX", from_ascii("\\TeX{}"), true },
228 { "LaTeX2e", from_ascii("\\LaTeXe{}"), true },
229 { "LaTeX", from_ascii("\\LaTeX{}"), true },
232 size_t const phrases_nr
= sizeof(special_phrases
)/sizeof(special_phrase
);
237 Paragraph::Private::Private(Paragraph
* owner
, Layout
const & layout
)
238 : owner_(owner
), inset_owner_(0), begin_of_body_(0), layout_(&layout
)
240 id_
= paragraph_id
++;
245 Paragraph::Private::Private(Private
const & p
, Paragraph
* owner
)
246 : owner_(owner
), inset_owner_(p
.inset_owner_
), fontlist_(p
.fontlist_
),
247 params_(p
.params_
), changes_(p
.changes_
), insetlist_(p
.insetlist_
),
248 begin_of_body_(p
.begin_of_body_
), text_(p
.text_
), words_(p
.words_
),
251 id_
= paragraph_id
++;
255 Paragraph::Private::Private(Private
const & p
, Paragraph
* owner
,
256 pos_type beg
, pos_type end
)
257 : owner_(owner
), inset_owner_(p
.inset_owner_
),
258 params_(p
.params_
), changes_(p
.changes_
),
259 insetlist_(p
.insetlist_
, beg
, end
),
260 begin_of_body_(p
.begin_of_body_
), words_(p
.words_
),
263 id_
= paragraph_id
++;
264 if (beg
>= pos_type(p
.text_
.size()))
266 text_
= p
.text_
.substr(beg
, end
- beg
);
268 FontList::const_iterator fcit
= fontlist_
.begin();
269 FontList::const_iterator fend
= fontlist_
.end();
270 for (; fcit
!= fend
; ++fcit
) {
271 if (fcit
->pos() < beg
)
273 if (fcit
->pos() >= end
) {
274 // Add last entry in the fontlist_.
275 fontlist_
.set(text_
.size() - 1, fcit
->font());
278 // Add a new entry in the fontlist_.
279 fontlist_
.set(fcit
->pos() - beg
, fcit
->font());
284 void Paragraph::addChangesToToc(DocIterator
const & cdit
,
285 Buffer
const & buf
) const
287 d
->changes_
.addToToc(cdit
, buf
);
291 bool Paragraph::isFullyDeleted(pos_type start
, pos_type end
) const
293 LASSERT(start
>= 0 && start
<= size(), /**/);
294 LASSERT(end
> start
&& end
<= size() + 1, /**/);
296 return d
->changes_
.isFullyDeleted(start
, end
);
300 bool Paragraph::isChanged(pos_type start
, pos_type end
) const
302 LASSERT(start
>= 0 && start
<= size(), /**/);
303 LASSERT(end
> start
&& end
<= size() + 1, /**/);
305 return d
->changes_
.isChanged(start
, end
);
309 bool Paragraph::isMergedOnEndOfParDeletion(bool trackChanges
) const
311 // keep the logic here in sync with the logic of eraseChars()
315 Change
const change
= d
->changes_
.lookup(size());
316 return change
.type
== Change::INSERTED
&& change
.author
== 0;
320 void Paragraph::setChange(Change
const & change
)
322 // beware of the imaginary end-of-par character!
323 d
->changes_
.set(change
, 0, size() + 1);
326 * Propagate the change recursively - but not in case of DELETED!
328 * Imagine that your co-author makes changes in an existing inset. He
329 * sends your document to you and you come to the conclusion that the
330 * inset should go completely. If you erase it, LyX must not delete all
331 * text within the inset. Otherwise, the change tracked insertions of
332 * your co-author get lost and there is no way to restore them later.
334 * Conclusion: An inset's content should remain untouched if you delete it
337 if (change
.type
!= Change::DELETED
) {
338 for (pos_type pos
= 0; pos
< size(); ++pos
) {
339 if (Inset
* inset
= getInset(pos
))
340 inset
->setChange(change
);
346 void Paragraph::setChange(pos_type pos
, Change
const & change
)
348 LASSERT(pos
>= 0 && pos
<= size(), /**/);
349 d
->changes_
.set(change
, pos
);
351 // see comment in setChange(Change const &) above
352 if (change
.type
!= Change::DELETED
&& pos
< size())
353 if (Inset
* inset
= getInset(pos
))
354 inset
->setChange(change
);
358 Change
const & Paragraph::lookupChange(pos_type pos
) const
360 LASSERT(pos
>= 0 && pos
<= size(), /**/);
361 return d
->changes_
.lookup(pos
);
365 void Paragraph::acceptChanges(BufferParams
const & bparams
, pos_type start
,
368 LASSERT(start
>= 0 && start
<= size(), /**/);
369 LASSERT(end
> start
&& end
<= size() + 1, /**/);
371 for (pos_type pos
= start
; pos
< end
; ++pos
) {
372 switch (lookupChange(pos
).type
) {
373 case Change::UNCHANGED
:
374 // accept changes in nested inset
375 if (Inset
* inset
= getInset(pos
))
376 inset
->acceptChanges(bparams
);
379 case Change::INSERTED
:
380 d
->changes_
.set(Change(Change::UNCHANGED
), pos
);
381 // also accept changes in nested inset
382 if (Inset
* inset
= getInset(pos
))
383 inset
->acceptChanges(bparams
);
386 case Change::DELETED
:
387 // Suppress access to non-existent
388 // "end-of-paragraph char"
390 eraseChar(pos
, false);
401 void Paragraph::rejectChanges(BufferParams
const & bparams
,
402 pos_type start
, pos_type end
)
404 LASSERT(start
>= 0 && start
<= size(), /**/);
405 LASSERT(end
> start
&& end
<= size() + 1, /**/);
407 for (pos_type pos
= start
; pos
< end
; ++pos
) {
408 switch (lookupChange(pos
).type
) {
409 case Change::UNCHANGED
:
410 // reject changes in nested inset
411 if (Inset
* inset
= getInset(pos
))
412 inset
->rejectChanges(bparams
);
415 case Change::INSERTED
:
416 // Suppress access to non-existent
417 // "end-of-paragraph char"
419 eraseChar(pos
, false);
425 case Change::DELETED
:
426 d
->changes_
.set(Change(Change::UNCHANGED
), pos
);
428 // Do NOT reject changes within a deleted inset!
429 // There may be insertions of a co-author inside of it!
437 void Paragraph::Private::insertChar(pos_type pos
, char_type c
,
438 Change
const & change
)
440 LASSERT(pos
>= 0 && pos
<= int(text_
.size()), /**/);
443 changes_
.insert(change
, pos
);
445 // This is actually very common when parsing buffers (and
446 // maybe inserting ascii text)
447 if (pos
== pos_type(text_
.size())) {
448 // when appending characters, no need to update tables
453 text_
.insert(text_
.begin() + pos
, c
);
455 // Update the font table.
456 fontlist_
.increasePosAfterPos(pos
);
459 insetlist_
.increasePosAfterPos(pos
);
463 bool Paragraph::insertInset(pos_type pos
, Inset
* inset
,
464 Change
const & change
)
466 LASSERT(inset
, /**/);
467 LASSERT(pos
>= 0 && pos
<= size(), /**/);
469 // Paragraph::insertInset() can be used in cut/copy/paste operation where
470 // d->inset_owner_ is not set yet.
471 if (d
->inset_owner_
&& !d
->inset_owner_
->insetAllowed(inset
->lyxCode()))
474 d
->insertChar(pos
, META_INSET
, change
);
475 LASSERT(d
->text_
[pos
] == META_INSET
, /**/);
477 // Add a new entry in the insetlist_.
478 d
->insetlist_
.insert(inset
, pos
);
483 bool Paragraph::eraseChar(pos_type pos
, bool trackChanges
)
485 LASSERT(pos
>= 0 && pos
<= size(), return false);
487 // keep the logic here in sync with the logic of isMergedOnEndOfParDeletion()
490 Change change
= d
->changes_
.lookup(pos
);
492 // set the character to DELETED if
493 // a) it was previously unchanged or
494 // b) it was inserted by a co-author
496 if (change
.type
== Change::UNCHANGED
||
497 (change
.type
== Change::INSERTED
&& change
.author
!= 0)) {
498 setChange(pos
, Change(Change::DELETED
));
502 if (change
.type
== Change::DELETED
)
506 // Don't physically access the imaginary end-of-paragraph character.
507 // eraseChar() can only mark it as DELETED. A physical deletion of
508 // end-of-par must be handled externally.
514 d
->changes_
.erase(pos
);
516 // if it is an inset, delete the inset entry
517 if (d
->text_
[pos
] == META_INSET
)
518 d
->insetlist_
.erase(pos
);
520 d
->text_
.erase(d
->text_
.begin() + pos
);
522 // Update the fontlist_
523 d
->fontlist_
.erase(pos
);
525 // Update the insetlist_
526 d
->insetlist_
.decreasePosAfterPos(pos
);
532 int Paragraph::eraseChars(pos_type start
, pos_type end
, bool trackChanges
)
534 LASSERT(start
>= 0 && start
<= size(), /**/);
535 LASSERT(end
>= start
&& end
<= size() + 1, /**/);
538 for (pos_type count
= end
- start
; count
; --count
) {
539 if (!eraseChar(i
, trackChanges
))
546 int Paragraph::Private::latexSurrogatePair(odocstream
& os
, char_type c
,
547 char_type next
, Encoding
const & encoding
)
549 // Writing next here may circumvent a possible font change between
550 // c and next. Since next is only output if it forms a surrogate pair
551 // with c we can ignore this:
552 // A font change inside a surrogate pair does not make sense and is
553 // hopefully impossible to input.
554 // FIXME: change tracking
555 // Is this correct WRT change tracking?
556 docstring
const latex1
= encoding
.latexChar(next
);
557 docstring
const latex2
= encoding
.latexChar(c
);
558 if (docstring(1, next
) == latex1
) {
559 // the encoding supports the combination
560 os
<< latex2
<< latex1
;
561 return latex1
.length() + latex2
.length();
563 os
<< latex1
<< '{' << latex2
<< '}';
564 return latex1
.length() + latex2
.length() + 2;
568 bool Paragraph::Private::simpleTeXBlanks(OutputParams
const & runparams
,
569 odocstream
& os
, TexRow
& texrow
,
571 unsigned int & column
,
573 Layout
const & style
)
575 if (style
.pass_thru
|| runparams
.verbatim
)
578 if (i
+ 1 < int(text_
.size())) {
579 char_type next
= text_
[i
+ 1];
580 if (Encodings::isCombiningChar(next
)) {
581 Encoding
const & encoding
= *(runparams
.encoding
);
582 // This space has an accent, so we must always output it.
583 column
+= latexSurrogatePair(os
, ' ', next
, encoding
) - 1;
588 if (lyxrc
.plaintext_linelen
> 0
589 && column
> lyxrc
.plaintext_linelen
591 && text_
[i
- 1] != ' '
592 && (i
+ 1 < int(text_
.size()))
593 // same in FreeSpacing mode
594 && !owner_
->isFreeSpacing()
595 // In typewriter mode, we want to avoid
596 // ! . ? : at the end of a line
597 && !(font
.fontInfo().family() == TYPEWRITER_FAMILY
598 && (text_
[i
- 1] == '.'
599 || text_
[i
- 1] == '?'
600 || text_
[i
- 1] == ':'
601 || text_
[i
- 1] == '!'))) {
604 texrow
.start(owner_
->id(), i
+ 1);
606 } else if (style
.free_spacing
) {
615 int Paragraph::Private::writeScriptChars(odocstream
& os
,
616 docstring
const & ltx
,
617 Change
const & runningChange
,
618 Encoding
const & encoding
,
621 // FIXME: modifying i here is not very nice...
623 // We only arrive here when a proper language for character text_[i] has
624 // not been specified (i.e., it could not be translated in the current
625 // latex encoding) or its latex translation has been forced, and it
626 // belongs to a known script.
627 // Parameter ltx contains the latex translation of text_[i] as specified
628 // in the unicodesymbols file and is something like "\textXXX{<spec>}".
629 // The latex macro name "textXXX" specifies the script to which text_[i]
630 // belongs and we use it in order to check whether characters from the
631 // same script immediately follow, such that we can collect them in a
632 // single "\textXXX" macro. So, we have to retain "\textXXX{<spec>"
633 // for the first char but only "<spec>" for all subsequent chars.
634 docstring::size_type
const brace1
= ltx
.find_first_of(from_ascii("{"));
635 docstring::size_type
const brace2
= ltx
.find_last_of(from_ascii("}"));
636 string script
= to_ascii(ltx
.substr(1, brace1
- 1));
639 bool closing_brace
= true;
640 if (script
== "textgreek" && encoding
.latexName() == "iso-8859-7") {
641 // Correct encoding is being used, so we can avoid \textgreek.
644 closing_brace
= false;
646 os
<< ltx
.substr(pos
, length
);
647 int size
= text_
.size();
648 while (i
+ 1 < size
) {
649 char_type
const next
= text_
[i
+ 1];
650 // Stop here if next character belongs to another script
651 // or there is a change in change tracking status.
652 if (!Encodings::isKnownScriptChar(next
, script
) ||
653 runningChange
!= owner_
->lookupChange(i
+ 1))
657 FontList::const_iterator cit
= fontlist_
.begin();
658 FontList::const_iterator end
= fontlist_
.end();
659 for (; cit
!= end
; ++cit
) {
660 if (cit
->pos() >= i
&& !found
) {
661 prev_font
= cit
->font();
664 if (cit
->pos() >= i
+ 1)
667 // Stop here if there is a font attribute or encoding change.
668 if (found
&& cit
!= end
&& prev_font
!= cit
->font())
670 docstring
const latex
= encoding
.latexChar(next
);
671 docstring::size_type
const b1
=
672 latex
.find_first_of(from_ascii("{"));
673 docstring::size_type
const b2
=
674 latex
.find_last_of(from_ascii("}"));
675 int const len
= b2
- b1
- 1;
676 os
<< latex
.substr(b1
+ 1, len
);
688 bool Paragraph::Private::isTextAt(string
const & str
, pos_type pos
) const
690 pos_type
const len
= str
.length();
692 // is the paragraph large enough?
693 if (pos
+ len
> int(text_
.size()))
696 // does the wanted text start at point?
697 for (string::size_type i
= 0; i
< str
.length(); ++i
) {
698 // Caution: direct comparison of characters works only
699 // because str is pure ASCII.
700 if (str
[i
] != text_
[pos
+ i
])
704 return fontlist_
.hasChangeInRange(pos
, len
);
708 void Paragraph::Private::latexInset(
709 BufferParams
const & bparams
,
712 OutputParams
& runparams
,
715 Font
const & outerfont
,
717 Change
& running_change
,
718 Layout
const & style
,
720 unsigned int & column
)
722 Inset
* inset
= owner_
->getInset(i
);
723 LASSERT(inset
, /**/);
725 if (style
.pass_thru
) {
726 inset
->plaintext(os
, runparams
);
730 // FIXME: move this to InsetNewline::latex
731 if (inset
->lyxCode() == NEWLINE_CODE
) {
732 // newlines are handled differently here than
733 // the default in simpleTeXSpecialChars().
734 if (!style
.newline_allowed
) {
738 column
+= running_font
.latexWriteEndChanges(
739 os
, bparams
, runparams
,
744 if (running_font
.fontInfo().family() == TYPEWRITER_FAMILY
)
747 basefont
= owner_
->getLayoutFont(bparams
, outerfont
);
748 running_font
= basefont
;
750 if (runparams
.moving_arg
)
755 texrow
.start(owner_
->id(), i
+ 1);
759 if (owner_
->lookupChange(i
).type
== Change::DELETED
) {
760 if( ++runparams
.inDeletedInset
== 1)
761 runparams
.changeOfDeletedInset
= owner_
->lookupChange(i
);
764 if (inset
->canTrackChanges()) {
765 column
+= Changes::latexMarkChange(os
, bparams
, running_change
,
766 Change(Change::UNCHANGED
));
767 running_change
= Change(Change::UNCHANGED
);
771 odocstream::pos_type
const len
= os
.tellp();
773 if (inset
->forceLTR()
774 && running_font
.isRightToLeft()
775 // ERT is an exception, it should be output with no decorations at all
776 && inset
->lyxCode() != ERT_CODE
) {
777 if (running_font
.language()->lang() == "farsi")
784 // FIXME: Bug: we can have an empty font change here!
785 // if there has just been a font change, we are going to close it
786 // right now, which means stupid latex code like \textsf{}. AFAIK,
787 // this does not harm dvi output. A minor bug, thus (JMarc)
789 // Some insets cannot be inside a font change command.
790 // However, even such insets *can* be placed in \L or \R
791 // or their equivalents (for RTL language switches), so we don't
792 // close the language in those cases.
793 // ArabTeX, though, cannot handle this special behavior, it seems.
794 bool arabtex
= basefont
.language()->lang() == "arabic_arabtex"
795 || running_font
.language()->lang() == "arabic_arabtex";
796 if (open_font
&& inset
->noFontChange()) {
797 bool closeLanguage
= arabtex
798 || basefont
.isRightToLeft() == running_font
.isRightToLeft();
799 unsigned int count
= running_font
.latexWriteEndChanges(os
,
800 bparams
, runparams
, basefont
, basefont
, closeLanguage
);
802 // if any font properties were closed, update the running_font,
803 // making sure, however, to leave the language as it was
805 // FIXME: probably a better way to keep track of the old
806 // language, than copying the entire font?
807 Font
const copy_font(running_font
);
808 basefont
= owner_
->getLayoutFont(bparams
, outerfont
);
809 running_font
= basefont
;
811 running_font
.setLanguage(copy_font
.language());
812 // leave font open if language is still open
813 open_font
= (running_font
.language() == basefont
.language());
815 runparams
.local_font
= &basefont
;
822 tmp
= inset
->latex(os
, runparams
);
823 } catch (EncodingException
& e
) {
824 // add location information and throw again.
831 if (running_font
.language()->lang() == "farsi")
838 for (int j
= 0; j
< tmp
; ++j
)
841 texrow
.start(owner_
->id(), i
+ 1);
844 column
+= os
.tellp() - len
;
847 if (owner_
->lookupChange(i
).type
== Change::DELETED
)
848 --runparams
.inDeletedInset
;
852 void Paragraph::Private::latexSpecialChar(
854 OutputParams
const & runparams
,
855 Font
const & running_font
,
856 Change
const & running_change
,
857 Layout
const & style
,
859 unsigned int & column
)
861 char_type
const c
= text_
[i
];
863 if (style
.pass_thru
) {
865 // FIXME UNICODE: This can fail if c cannot
866 // be encoded in the current encoding.
871 if (runparams
.verbatim
) {
872 // FIXME UNICODE: This can fail if c cannot
873 // be encoded in the current encoding.
878 // If T1 font encoding is used, use the special
879 // characters it provides.
880 // NOTE: some languages reset the font encoding
882 if (!running_font
.language()->internalFontEncoding()
883 && lyxrc
.fontenc
== "T1" && latexSpecialT1(c
, os
, i
, column
))
886 // \tt font needs special treatment
887 if (running_font
.fontInfo().family() == TYPEWRITER_FAMILY
888 && latexSpecialTypewriter(c
, os
, i
, column
))
891 // Otherwise, we use what LaTeX provides us.
894 os
<< "\\textbackslash{}";
898 os
<< "\\textless{}";
902 os
<< "\\textgreater{}";
913 os
<< "\\char`\\\"{}";
918 case '%': case '#': case '{':
926 os
<< "\\textasciitilde{}";
931 os
<< "\\textasciicircum{}";
938 // avoid being mistaken for optional arguments
946 // Blanks are printed before font switching.
947 // Sure? I am not! (try nice-latex)
948 // I am sure it's correct. LyX might be smarter
949 // in the future, but for now, nothing wrong is
955 if (latexSpecialPhrase(os
, i
, column
, runparams
))
961 Encoding
const & encoding
= *(runparams
.encoding
);
962 if (i
+ 1 < int(text_
.size())) {
963 char_type next
= text_
[i
+ 1];
964 if (Encodings::isCombiningChar(next
)) {
965 column
+= latexSurrogatePair(os
, c
, next
, encoding
) - 1;
971 docstring
const latex
= encoding
.latexChar(c
);
972 if (Encodings::isKnownScriptChar(c
, script
)
973 && prefixIs(latex
, from_ascii("\\" + script
)))
974 column
+= writeScriptChars(os
, latex
,
975 running_change
, encoding
, i
) - 1;
976 else if (latex
.length() > 1 && latex
[latex
.length() - 1] != '}') {
977 // Prevent eating of a following
978 // space or command corruption by
979 // following characters
980 column
+= latex
.length() + 1;
983 column
+= latex
.length() - 1;
991 bool Paragraph::Private::latexSpecialT1(char_type
const c
, odocstream
& os
,
992 pos_type i
, unsigned int & column
)
998 // In T1 encoding, these characters exist
999 // but we should avoid ligatures
1000 if (i
+ 1 >= int(text_
.size()) || text_
[i
+ 1] != c
)
1002 os
<< "\\textcompwordmark{}";
1009 // soul.sty breaks with \char`\"
1010 os
<< "\\textquotedbl{}";
1019 bool Paragraph::Private::latexSpecialTypewriter(char_type
const c
, odocstream
& os
,
1020 pos_type i
, unsigned int & column
)
1024 // within \ttfamily, "--" is merged to "-" (no endash)
1025 // so we avoid this rather irritating ligature
1026 if (i
+ 1 < int(text_
.size()) && text_
[i
+ 1] == '-') {
1033 // everything else has to be checked separately
1034 // (depending on the encoding)
1041 bool Paragraph::Private::latexSpecialPhrase(odocstream
& os
, pos_type
& i
,
1042 unsigned int & column
, OutputParams
const & runparams
)
1044 // FIXME: if we have "LaTeX" with a font
1045 // change in the middle (before the 'T', then
1046 // the "TeX" part is still special cased.
1047 // Really we should only operate this on
1048 // "words" for some definition of word
1050 for (size_t pnr
= 0; pnr
< phrases_nr
; ++pnr
) {
1051 if (!isTextAt(special_phrases
[pnr
].phrase
, i
))
1053 if (runparams
.moving_arg
)
1055 os
<< special_phrases
[pnr
].macro
;
1056 i
+= special_phrases
[pnr
].phrase
.length() - 1;
1057 column
+= special_phrases
[pnr
].macro
.length() - 1;
1064 void Paragraph::Private::validate(LaTeXFeatures
& features
,
1065 Layout
const & layout
) const
1067 // check the params.
1068 if (!params_
.spacing().isDefault())
1069 features
.require("setspace");
1072 features
.useLayout(layout
.name());
1075 fontlist_
.validate(features
);
1077 // then the indentation
1078 if (!params_
.leftIndent().zero())
1079 features
.require("ParagraphLeftIndent");
1082 InsetList::const_iterator icit
= insetlist_
.begin();
1083 InsetList::const_iterator iend
= insetlist_
.end();
1084 for (; icit
!= iend
; ++icit
) {
1086 icit
->inset
->validate(features
);
1087 if (layout
.needprotect
&&
1088 icit
->inset
->lyxCode() == FOOT_CODE
)
1089 features
.require("NeedLyXFootnoteCode");
1093 // then the contents
1094 for (pos_type i
= 0; i
< int(text_
.size()) ; ++i
) {
1095 for (size_t pnr
= 0; pnr
< phrases_nr
; ++pnr
) {
1096 if (!special_phrases
[pnr
].builtin
1097 && isTextAt(special_phrases
[pnr
].phrase
, i
)) {
1098 features
.require(special_phrases
[pnr
].phrase
);
1102 Encodings::validate(text_
[i
], features
);
1106 /////////////////////////////////////////////////////////////////////
1110 /////////////////////////////////////////////////////////////////////
1113 Layout
const emptyParagraphLayout
;
1116 Paragraph::Paragraph()
1117 : d(new Paragraph::Private(this, emptyParagraphLayout
))
1124 Paragraph::Paragraph(Paragraph
const & par
)
1125 : itemdepth(par
.itemdepth
),
1126 d(new Paragraph::Private(*par
.d
, this))
1132 Paragraph::Paragraph(Paragraph
const & par
, pos_type beg
, pos_type end
)
1133 : itemdepth(par
.itemdepth
),
1134 d(new Paragraph::Private(*par
.d
, this, beg
, end
))
1140 Paragraph
& Paragraph::operator=(Paragraph
const & par
)
1142 // needed as we will destroy the private part before copying it
1144 itemdepth
= par
.itemdepth
;
1148 d
= new Private(*par
.d
, this);
1155 Paragraph::~Paragraph()
1162 void Paragraph::write(ostream
& os
, BufferParams
const & bparams
,
1163 depth_type
& dth
) const
1165 // The beginning or end of a deeper (i.e. nested) area?
1166 if (dth
!= d
->params_
.depth()) {
1167 if (d
->params_
.depth() > dth
) {
1168 while (d
->params_
.depth() > dth
) {
1169 os
<< "\n\\begin_deeper";
1173 while (d
->params_
.depth() < dth
) {
1174 os
<< "\n\\end_deeper";
1180 // First write the layout
1181 os
<< "\n\\begin_layout " << to_utf8(d
->layout_
->name()) << '\n';
1183 d
->params_
.write(os
);
1185 Font
font1(inherit_font
, bparams
.language
);
1187 Change running_change
= Change(Change::UNCHANGED
);
1190 for (pos_type i
= 0; i
<= size(); ++i
) {
1192 Change change
= lookupChange(i
);
1193 Changes::lyxMarkChange(os
, column
, running_change
, change
);
1194 running_change
= change
;
1199 // Write font changes
1200 Font
const & font2
= getFontSettings(bparams
, i
);
1201 if (font2
!= font1
) {
1202 font2
.lyxWriteChanges(font1
, os
);
1207 char_type
const c
= d
->text_
[i
];
1210 if (Inset
const * inset
= getInset(i
)) {
1211 if (inset
->directWrite()) {
1212 // international char, let it write
1213 // code directly so it's shorter in
1219 os
<< "\\begin_inset ";
1221 os
<< "\n\\end_inset\n\n";
1227 os
<< "\n\\backslash\n";
1231 if (i
+ 1 < size() && d
->text_
[i
+ 1] == ' ') {
1238 if ((column
> 70 && c
== ' ')
1243 // this check is to amend a bug. LyX sometimes
1244 // inserts '\0' this could cause problems.
1246 os
<< to_utf8(docstring(1, c
));
1248 LYXERR0("NUL char in structure.");
1254 os
<< "\n\\end_layout\n";
1258 void Paragraph::validate(LaTeXFeatures
& features
) const
1260 d
->validate(features
, *d
->layout_
);
1264 void Paragraph::insert(pos_type start
, docstring
const & str
,
1265 Font
const & font
, Change
const & change
)
1267 for (size_t i
= 0, n
= str
.size(); i
!= n
; ++i
)
1268 insertChar(start
+ i
, str
[i
], font
, change
);
1272 void Paragraph::appendChar(char_type c
, Font
const & font
,
1273 Change
const & change
)
1276 d
->changes_
.insert(change
, d
->text_
.size());
1277 // when appending characters, no need to update tables
1278 d
->text_
.push_back(c
);
1279 setFont(d
->text_
.size() - 1, font
);
1283 void Paragraph::appendString(docstring
const & s
, Font
const & font
,
1284 Change
const & change
)
1286 pos_type end
= s
.size();
1287 size_t oldsize
= d
->text_
.size();
1288 size_t newsize
= oldsize
+ end
;
1289 size_t capacity
= d
->text_
.capacity();
1290 if (newsize
>= capacity
)
1291 d
->text_
.reserve(max(capacity
+ 100, newsize
));
1293 // when appending characters, no need to update tables
1296 // FIXME: Optimize this!
1297 for (size_t i
= oldsize
; i
!= newsize
; ++i
) {
1299 d
->changes_
.insert(change
, i
);
1301 d
->fontlist_
.set(oldsize
, font
);
1302 d
->fontlist_
.set(newsize
- 1, font
);
1306 void Paragraph::insertChar(pos_type pos
, char_type c
,
1309 d
->insertChar(pos
, c
, Change(trackChanges
?
1310 Change::INSERTED
: Change::UNCHANGED
));
1314 void Paragraph::insertChar(pos_type pos
, char_type c
,
1315 Font
const & font
, bool trackChanges
)
1317 d
->insertChar(pos
, c
, Change(trackChanges
?
1318 Change::INSERTED
: Change::UNCHANGED
));
1323 void Paragraph::insertChar(pos_type pos
, char_type c
,
1324 Font
const & font
, Change
const & change
)
1326 d
->insertChar(pos
, c
, change
);
1331 bool Paragraph::insertInset(pos_type pos
, Inset
* inset
,
1332 Font
const & font
, Change
const & change
)
1334 bool const success
= insertInset(pos
, inset
, change
);
1335 // Set the font/language of the inset...
1341 void Paragraph::resetFonts(Font
const & font
)
1343 d
->fontlist_
.clear();
1344 d
->fontlist_
.set(0, font
);
1345 d
->fontlist_
.set(d
->text_
.size() - 1, font
);
1348 // Gets uninstantiated font setting at position.
1349 Font
const & Paragraph::getFontSettings(BufferParams
const & bparams
,
1353 LYXERR0("pos: " << pos
<< " size: " << size());
1354 LASSERT(pos
<= size(), /**/);
1357 FontList::const_iterator cit
= d
->fontlist_
.fontIterator(pos
);
1358 if (cit
!= d
->fontlist_
.end())
1361 if (pos
== size() && !empty())
1362 return getFontSettings(bparams
, pos
- 1);
1364 // Optimisation: avoid a full font instantiation if there is no
1365 // language change from previous call.
1366 static Font previous_font
;
1367 static Language
const * previous_lang
= 0;
1368 Language
const * lang
= getParLanguage(bparams
);
1369 if (lang
!= previous_lang
) {
1370 previous_lang
= lang
;
1371 previous_font
= Font(inherit_font
, lang
);
1373 return previous_font
;
1377 FontSpan
Paragraph::fontSpan(pos_type pos
) const
1379 LASSERT(pos
<= size(), /**/);
1382 FontList::const_iterator cit
= d
->fontlist_
.begin();
1383 FontList::const_iterator end
= d
->fontlist_
.end();
1384 for (; cit
!= end
; ++cit
) {
1385 if (cit
->pos() >= pos
) {
1386 if (pos
>= beginOfBody())
1387 return FontSpan(max(start
, beginOfBody()),
1390 return FontSpan(start
,
1391 min(beginOfBody() - 1,
1394 start
= cit
->pos() + 1;
1397 // This should not happen, but if so, we take no chances.
1398 // LYXERR0("Paragraph::getEndPosOfFontSpan: This should not happen!");
1399 return FontSpan(pos
, pos
);
1403 // Gets uninstantiated font setting at position 0
1404 Font
const & Paragraph::getFirstFontSettings(BufferParams
const & bparams
) const
1406 if (!empty() && !d
->fontlist_
.empty())
1407 return d
->fontlist_
.begin()->font();
1409 // Optimisation: avoid a full font instantiation if there is no
1410 // language change from previous call.
1411 static Font previous_font
;
1412 static Language
const * previous_lang
= 0;
1413 if (bparams
.language
!= previous_lang
) {
1414 previous_lang
= bparams
.language
;
1415 previous_font
= Font(inherit_font
, bparams
.language
);
1418 return previous_font
;
1422 // Gets the fully instantiated font at a given position in a paragraph
1423 // This is basically the same function as Text::GetFont() in text2.cpp.
1424 // The difference is that this one is used for generating the LaTeX file,
1425 // and thus cosmetic "improvements" are disallowed: This has to deliver
1426 // the true picture of the buffer. (Asger)
1427 Font
const Paragraph::getFont(BufferParams
const & bparams
, pos_type pos
,
1428 Font
const & outerfont
) const
1430 LASSERT(pos
>= 0, /**/);
1432 Font font
= getFontSettings(bparams
, pos
);
1434 pos_type
const body_pos
= beginOfBody();
1435 FontInfo
& fi
= font
.fontInfo();
1437 fi
.realize(d
->layout_
->labelfont
);
1439 fi
.realize(d
->layout_
->font
);
1441 fi
.realize(outerfont
.fontInfo());
1442 fi
.realize(bparams
.getFont().fontInfo());
1448 Font
const Paragraph::getLabelFont
1449 (BufferParams
const & bparams
, Font
const & outerfont
) const
1451 FontInfo tmpfont
= d
->layout_
->labelfont
;
1452 tmpfont
.realize(outerfont
.fontInfo());
1453 tmpfont
.realize(bparams
.getFont().fontInfo());
1454 return Font(tmpfont
, getParLanguage(bparams
));
1458 Font
const Paragraph::getLayoutFont
1459 (BufferParams
const & bparams
, Font
const & outerfont
) const
1461 FontInfo tmpfont
= d
->layout_
->font
;
1462 tmpfont
.realize(outerfont
.fontInfo());
1463 tmpfont
.realize(bparams
.getFont().fontInfo());
1464 return Font(tmpfont
, getParLanguage(bparams
));
1468 /// Returns the height of the highest font in range
1469 FontSize
Paragraph::highestFontInRange
1470 (pos_type startpos
, pos_type endpos
, FontSize def_size
) const
1472 return d
->fontlist_
.highestInRange(startpos
, endpos
, def_size
);
1476 char_type
Paragraph::getUChar(BufferParams
const & bparams
, pos_type pos
) const
1478 char_type c
= d
->text_
[pos
];
1479 if (!lyxrc
.rtl_support
)
1509 if (uc
!= c
&& getFontSettings(bparams
, pos
).isRightToLeft())
1515 void Paragraph::setFont(pos_type pos
, Font
const & font
)
1517 LASSERT(pos
<= size(), /**/);
1519 // First, reduce font against layout/label font
1520 // Update: The setCharFont() routine in text2.cpp already
1521 // reduces font, so we don't need to do that here. (Asger)
1523 d
->fontlist_
.set(pos
, font
);
1527 void Paragraph::makeSameLayout(Paragraph
const & par
)
1529 d
->layout_
= par
.d
->layout_
;
1530 d
->params_
= par
.d
->params_
;
1534 bool Paragraph::stripLeadingSpaces(bool trackChanges
)
1536 if (isFreeSpacing())
1542 while (pos
< size() && (isNewline(pos
) || isLineSeparator(pos
))) {
1543 if (eraseChar(pos
, trackChanges
))
1549 return count
> 0 || pos
> 0;
1553 bool Paragraph::hasSameLayout(Paragraph
const & par
) const
1555 return par
.d
->layout_
== d
->layout_
1556 && d
->params_
.sameLayout(par
.d
->params_
);
1560 depth_type
Paragraph::getDepth() const
1562 return d
->params_
.depth();
1566 depth_type
Paragraph::getMaxDepthAfter() const
1568 if (d
->layout_
->isEnvironment())
1569 return d
->params_
.depth() + 1;
1571 return d
->params_
.depth();
1575 char Paragraph::getAlign() const
1577 if (d
->params_
.align() == LYX_ALIGN_LAYOUT
)
1578 return d
->layout_
->align
;
1580 return d
->params_
.align();
1584 docstring
const & Paragraph::labelString() const
1586 return d
->params_
.labelString();
1590 // the next two functions are for the manual labels
1591 docstring
const Paragraph::getLabelWidthString() const
1593 if (d
->layout_
->margintype
== MARGIN_MANUAL
1594 || d
->layout_
->latextype
== LATEX_BIB_ENVIRONMENT
)
1595 return d
->params_
.labelWidthString();
1597 return _("Senseless with this layout!");
1601 void Paragraph::setLabelWidthString(docstring
const & s
)
1603 d
->params_
.labelWidthString(s
);
1607 docstring
const Paragraph::translateIfPossible(docstring
const & s
,
1608 BufferParams
const & bparams
) const
1610 if (!isAscii(s
) || s
.empty()) {
1611 // This must be a user defined layout. We cannot translate
1612 // this, since gettext accepts only ascii keys.
1615 // Probably standard layout, try to translate
1616 Messages
& m
= getMessages(getParLanguage(bparams
)->code());
1617 return m
.get(to_ascii(s
));
1621 docstring
Paragraph::expandLabel(Layout
const & layout
,
1622 BufferParams
const & bparams
, bool process_appendix
) const
1624 DocumentClass
const & tclass
= bparams
.documentClass();
1627 if (process_appendix
&& d
->params_
.appendix())
1628 fmt
= translateIfPossible(layout
.labelstring_appendix(),
1631 fmt
= translateIfPossible(layout
.labelstring(), bparams
);
1633 if (fmt
.empty() && layout
.labeltype
== LABEL_COUNTER
1634 && !layout
.counter
.empty())
1635 return tclass
.counters().theCounter(layout
.counter
);
1637 // handle 'inherited level parts' in 'fmt',
1638 // i.e. the stuff between '@' in '@Section@.\arabic{subsection}'
1639 size_t const i
= fmt
.find('@', 0);
1640 if (i
!= docstring::npos
) {
1641 size_t const j
= fmt
.find('@', i
+ 1);
1642 if (j
!= docstring::npos
) {
1643 docstring
parent(fmt
, i
+ 1, j
- i
- 1);
1644 docstring label
= from_ascii("??");
1645 if (tclass
.hasLayout(parent
))
1646 docstring label
= expandLabel(tclass
[parent
], bparams
,
1648 fmt
= docstring(fmt
, 0, i
) + label
1649 + docstring(fmt
, j
+ 1, docstring::npos
);
1653 return tclass
.counters().counterLabel(fmt
);
1657 void Paragraph::applyLayout(Layout
const & new_layout
)
1659 d
->layout_
= &new_layout
;
1660 LyXAlignment
const oldAlign
= d
->params_
.align();
1662 if (!(oldAlign
& d
->layout_
->alignpossible
)) {
1663 frontend::Alert::warning(_("Alignment not permitted"),
1664 _("The new layout does not permit the alignment previously used.\nSetting to default."));
1665 d
->params_
.align(LYX_ALIGN_LAYOUT
);
1670 pos_type
Paragraph::beginOfBody() const
1672 return d
->begin_of_body_
;
1676 void Paragraph::setBeginOfBody()
1678 if (d
->layout_
->labeltype
!= LABEL_MANUAL
) {
1679 d
->begin_of_body_
= 0;
1683 // Unroll the first two cycles of the loop
1684 // and remember the previous character to
1685 // remove unnecessary getChar() calls
1687 pos_type end
= size();
1688 if (i
< end
&& !isNewline(i
)) {
1690 char_type previous_char
= 0;
1693 previous_char
= d
->text_
[i
];
1694 if (!isNewline(i
)) {
1696 while (i
< end
&& previous_char
!= ' ') {
1701 previous_char
= temp
;
1707 d
->begin_of_body_
= i
;
1711 bool Paragraph::forcePlainLayout() const
1713 return inInset().forcePlainLayout();
1717 bool Paragraph::allowParagraphCustomization() const
1719 return inInset().allowParagraphCustomization();
1723 bool Paragraph::usePlainLayout() const
1725 return inInset().usePlainLayout();
1731 // paragraphs inside floats need different alignment tags to avoid
1734 bool noTrivlistCentering(InsetCode code
)
1736 return code
== FLOAT_CODE
1737 || code
== WRAP_CODE
1738 || code
== CELL_CODE
;
1742 string
correction(string
const & orig
)
1744 if (orig
== "flushleft")
1745 return "raggedright";
1746 if (orig
== "flushright")
1747 return "raggedleft";
1748 if (orig
== "center")
1754 string
const corrected_env(string
const & suffix
, string
const & env
,
1755 InsetCode code
, bool const lastpar
)
1757 string output
= suffix
+ "{";
1758 if (noTrivlistCentering(code
)) {
1760 // the last paragraph in non-trivlist-aligned
1761 // context is special (to avoid unwanted whitespace)
1762 if (suffix
== "\\begin")
1763 return "\\" + correction(env
) + "{}";
1766 output
+= correction(env
);
1770 if (suffix
== "\\begin")
1776 void adjust_row_column(string
const & str
, TexRow
& texrow
, int & column
)
1778 if (!contains(str
, "\n"))
1779 column
+= str
.size();
1783 column
= rsplit(str
, tmp
, '\n').size();
1790 int Paragraph::Private::startTeXParParams(BufferParams
const & bparams
,
1791 odocstream
& os
, TexRow
& texrow
,
1792 OutputParams
const & runparams
) const
1796 if (params_
.noindent()) {
1797 os
<< "\\noindent ";
1801 LyXAlignment
const curAlign
= params_
.align();
1803 if (curAlign
== layout_
->align
)
1807 case LYX_ALIGN_NONE
:
1808 case LYX_ALIGN_BLOCK
:
1809 case LYX_ALIGN_LAYOUT
:
1810 case LYX_ALIGN_SPECIAL
:
1812 case LYX_ALIGN_LEFT
:
1813 case LYX_ALIGN_RIGHT
:
1814 case LYX_ALIGN_CENTER
:
1815 if (runparams
.moving_arg
) {
1822 string
const begin_tag
= "\\begin";
1823 InsetCode code
= owner_
->ownerCode();
1824 bool const lastpar
= runparams
.isLastPar
;
1827 case LYX_ALIGN_NONE
:
1828 case LYX_ALIGN_BLOCK
:
1829 case LYX_ALIGN_LAYOUT
:
1830 case LYX_ALIGN_SPECIAL
:
1832 case LYX_ALIGN_LEFT
: {
1834 if (owner_
->getParLanguage(bparams
)->babel() != "hebrew")
1835 output
= corrected_env(begin_tag
, "flushleft", code
, lastpar
);
1837 output
= corrected_env(begin_tag
, "flushright", code
, lastpar
);
1838 os
<< from_ascii(output
);
1839 adjust_row_column(output
, texrow
, column
);
1841 } case LYX_ALIGN_RIGHT
: {
1843 if (owner_
->getParLanguage(bparams
)->babel() != "hebrew")
1844 output
= corrected_env(begin_tag
, "flushright", code
, lastpar
);
1846 output
= corrected_env(begin_tag
, "flushleft", code
, lastpar
);
1847 os
<< from_ascii(output
);
1848 adjust_row_column(output
, texrow
, column
);
1850 } case LYX_ALIGN_CENTER
: {
1852 output
= corrected_env(begin_tag
, "center", code
, lastpar
);
1853 os
<< from_ascii(output
);
1854 adjust_row_column(output
, texrow
, column
);
1863 int Paragraph::Private::endTeXParParams(BufferParams
const & bparams
,
1864 odocstream
& os
, TexRow
& texrow
,
1865 OutputParams
const & runparams
) const
1869 switch (params_
.align()) {
1870 case LYX_ALIGN_NONE
:
1871 case LYX_ALIGN_BLOCK
:
1872 case LYX_ALIGN_LAYOUT
:
1873 case LYX_ALIGN_SPECIAL
:
1875 case LYX_ALIGN_LEFT
:
1876 case LYX_ALIGN_RIGHT
:
1877 case LYX_ALIGN_CENTER
:
1878 if (runparams
.moving_arg
) {
1885 string
const end_tag
= "\n\\par\\end";
1886 InsetCode code
= owner_
->ownerCode();
1887 bool const lastpar
= runparams
.isLastPar
;
1889 switch (params_
.align()) {
1890 case LYX_ALIGN_NONE
:
1891 case LYX_ALIGN_BLOCK
:
1892 case LYX_ALIGN_LAYOUT
:
1893 case LYX_ALIGN_SPECIAL
:
1895 case LYX_ALIGN_LEFT
: {
1897 if (owner_
->getParLanguage(bparams
)->babel() != "hebrew")
1898 output
= corrected_env(end_tag
, "flushleft", code
, lastpar
);
1900 output
= corrected_env(end_tag
, "flushright", code
, lastpar
);
1901 os
<< from_ascii(output
);
1902 adjust_row_column(output
, texrow
, column
);
1904 } case LYX_ALIGN_RIGHT
: {
1906 if (owner_
->getParLanguage(bparams
)->babel() != "hebrew")
1907 output
= corrected_env(end_tag
, "flushright", code
, lastpar
);
1909 output
= corrected_env(end_tag
, "flushleft", code
, lastpar
);
1910 os
<< from_ascii(output
);
1911 adjust_row_column(output
, texrow
, column
);
1913 } case LYX_ALIGN_CENTER
: {
1915 output
= corrected_env(end_tag
, "center", code
, lastpar
);
1916 os
<< from_ascii(output
);
1917 adjust_row_column(output
, texrow
, column
);
1926 // This one spits out the text of the paragraph
1927 bool Paragraph::latex(BufferParams
const & bparams
,
1928 Font
const & outerfont
,
1929 odocstream
& os
, TexRow
& texrow
,
1930 OutputParams
const & runparams
,
1931 int start_pos
, int end_pos
) const
1933 LYXERR(Debug::LATEX
, "Paragraph::latex... " << this);
1935 bool return_value
= false;
1937 bool const allowcust
= allowParagraphCustomization();
1939 // FIXME This check should not be needed. Perhaps issue an
1940 // error if it triggers.
1941 Layout
const & style
= forcePlainLayout() ?
1942 bparams
.documentClass().plainLayout() : *d
->layout_
;
1944 // Current base font for all inherited font changes, without any
1945 // change caused by an individual character, except for the language:
1946 // It is set to the language of the first character.
1947 // As long as we are in the label, this font is the base font of the
1948 // label. Before the first body character it is set to the base font
1952 // Maybe we have to create a optional argument.
1953 pos_type body_pos
= beginOfBody();
1954 unsigned int column
= 0;
1957 // the optional argument is kept in curly brackets in
1958 // case it contains a ']'
1961 basefont
= getLabelFont(bparams
, outerfont
);
1963 basefont
= getLayoutFont(bparams
, outerfont
);
1966 // Which font is currently active?
1967 Font
running_font(basefont
);
1968 // Do we have an open font change?
1969 bool open_font
= false;
1971 Change runningChange
= Change(Change::UNCHANGED
);
1973 texrow
.start(id(), 0);
1975 // if the paragraph is empty, the loop will not be entered at all
1977 if (style
.isCommand()) {
1982 column
+= d
->startTeXParParams(bparams
, os
, texrow
,
1986 for (pos_type i
= 0; i
< size(); ++i
) {
1987 // First char in paragraph or after label?
1988 if (i
== body_pos
) {
1991 column
+= running_font
.latexWriteEndChanges(
1992 os
, bparams
, runparams
,
1993 basefont
, basefont
);
1996 basefont
= getLayoutFont(bparams
, outerfont
);
1997 running_font
= basefont
;
1999 column
+= Changes::latexMarkChange(os
, bparams
,
2000 runningChange
, Change(Change::UNCHANGED
));
2001 runningChange
= Change(Change::UNCHANGED
);
2006 if (style
.isCommand()) {
2012 column
+= d
->startTeXParParams(bparams
, os
,
2017 Change
const & change
= runparams
.inDeletedInset
? runparams
.changeOfDeletedInset
2020 if (bparams
.outputChanges
&& runningChange
!= change
) {
2022 column
+= running_font
.latexWriteEndChanges(
2023 os
, bparams
, runparams
, basefont
, basefont
);
2026 basefont
= getLayoutFont(bparams
, outerfont
);
2027 running_font
= basefont
;
2029 column
+= Changes::latexMarkChange(os
, bparams
, runningChange
, change
);
2030 runningChange
= change
;
2033 // do not output text which is marked deleted
2034 // if change tracking output is disabled
2035 if (!bparams
.outputChanges
&& change
.type
== Change::DELETED
) {
2041 // Fully instantiated font
2042 Font
const font
= getFont(bparams
, i
, outerfont
);
2044 Font
const last_font
= running_font
;
2046 // Do we need to close the previous font?
2048 (font
!= running_font
||
2049 font
.language() != running_font
.language()))
2051 column
+= running_font
.latexWriteEndChanges(
2052 os
, bparams
, runparams
, basefont
,
2053 (i
== body_pos
-1) ? basefont
: font
);
2054 running_font
= basefont
;
2058 // close babel's font environment before opening CJK.
2059 if (!running_font
.language()->babel().empty() &&
2060 font
.language()->encoding()->package() == Encoding::CJK
) {
2061 string end_tag
= subst(lyxrc
.language_command_end
,
2063 running_font
.language()->babel());
2064 os
<< from_ascii(end_tag
);
2065 column
+= end_tag
.length();
2068 // Switch file encoding if necessary (and allowed)
2069 if (!runparams
.verbatim
&&
2070 runparams
.encoding
->package() != Encoding::none
&&
2071 font
.language()->encoding()->package() != Encoding::none
) {
2072 pair
<bool, int> const enc_switch
= switchEncoding(os
, bparams
,
2073 runparams
, *(font
.language()->encoding()));
2074 if (enc_switch
.first
) {
2075 column
+= enc_switch
.second
;
2076 runparams
.encoding
= font
.language()->encoding();
2080 char_type
const c
= d
->text_
[i
];
2082 // Do we need to change font?
2083 if ((font
!= running_font
||
2084 font
.language() != running_font
.language()) &&
2087 odocstringstream ods
;
2088 column
+= font
.latexWriteStartChanges(ods
, bparams
,
2089 runparams
, basefont
,
2091 running_font
= font
;
2093 docstring fontchange
= ods
.str();
2094 // check if the fontchange ends with a trailing blank
2095 // (like "\small " (see bug 3382)
2096 if (suffixIs(fontchange
, ' ') && c
== ' ')
2097 os
<< fontchange
.substr(0, fontchange
.size() - 1)
2098 << from_ascii("{}");
2103 // FIXME: think about end_pos implementation...
2104 if (c
== ' ' && i
>= start_pos
&& (end_pos
== -1 || i
< end_pos
)) {
2105 // FIXME: integrate this case in latexSpecialChar
2106 // Do not print the separation of the optional argument
2107 // if style.pass_thru is false. This works because
2108 // latexSpecialChar ignores spaces if
2109 // style.pass_thru is false.
2110 if (i
!= body_pos
- 1) {
2111 if (d
->simpleTeXBlanks(
2112 runparams
, os
, texrow
,
2113 i
, column
, font
, style
)) {
2114 // A surrogate pair was output. We
2115 // must not call latexSpecialChar
2116 // in this iteration, since it would output
2117 // the combining character again.
2124 OutputParams rp
= runparams
;
2125 rp
.free_spacing
= style
.free_spacing
;
2126 rp
.local_font
= &font
;
2127 rp
.intitle
= style
.intitle
;
2129 // Two major modes: LaTeX or plain
2130 // Handle here those cases common to both modes
2131 // and then split to handle the two modes separately.
2132 if (c
== META_INSET
) {
2133 if (i
>= start_pos
&& (end_pos
== -1 || i
< end_pos
)) {
2134 d
->latexInset(bparams
, os
,
2135 texrow
, rp
, running_font
,
2136 basefont
, outerfont
, open_font
,
2137 runningChange
, style
, i
, column
);
2140 if (i
>= start_pos
&& (end_pos
== -1 || i
< end_pos
)) {
2142 d
->latexSpecialChar(os
, rp
, running_font
, runningChange
,
2144 } catch (EncodingException
& e
) {
2145 if (runparams
.dryrun
) {
2146 os
<< "<" << _("LyX Warning: ")
2147 << _("uncodable character") << " '";
2151 // add location information and throw again.
2160 // Set the encoding to that returned from latexSpecialChar (see
2161 // comment for encoding member in OutputParams.h)
2162 runparams
.encoding
= rp
.encoding
;
2165 // If we have an open font definition, we have to close it
2167 #ifdef FIXED_LANGUAGE_END_DETECTION
2170 .latexWriteEndChanges(os
, bparams
, runparams
,
2172 next_
->getFont(bparams
, 0, outerfont
));
2174 running_font
.latexWriteEndChanges(os
, bparams
,
2175 runparams
, basefont
, basefont
);
2178 //FIXME: For now we ALWAYS have to close the foreign font settings if they are
2179 //FIXME: there as we start another \selectlanguage with the next paragraph if
2180 //FIXME: we are in need of this. This should be fixed sometime (Jug)
2181 running_font
.latexWriteEndChanges(os
, bparams
, runparams
,
2182 basefont
, basefont
);
2186 column
+= Changes::latexMarkChange(os
, bparams
, runningChange
, Change(Change::UNCHANGED
));
2188 // Needed if there is an optional argument but no contents.
2189 if (body_pos
> 0 && body_pos
== size()) {
2191 return_value
= false;
2195 column
+= d
->endTeXParParams(bparams
, os
, texrow
,
2199 LYXERR(Debug::LATEX
, "Paragraph::latex... done " << this);
2200 return return_value
;
2204 bool Paragraph::emptyTag() const
2206 for (pos_type i
= 0; i
< size(); ++i
) {
2207 if (Inset
const * inset
= getInset(i
)) {
2208 InsetCode lyx_code
= inset
->lyxCode();
2209 if (lyx_code
!= TOC_CODE
&&
2210 lyx_code
!= INCLUDE_CODE
&&
2211 lyx_code
!= GRAPHICS_CODE
&&
2212 lyx_code
!= ERT_CODE
&&
2213 lyx_code
!= LISTINGS_CODE
&&
2214 lyx_code
!= FLOAT_CODE
&&
2215 lyx_code
!= TABULAR_CODE
) {
2219 char_type c
= d
->text_
[i
];
2220 if (c
!= ' ' && c
!= '\t')
2228 string
Paragraph::getID(Buffer
const & buf
, OutputParams
const & runparams
)
2231 for (pos_type i
= 0; i
< size(); ++i
) {
2232 if (Inset
const * inset
= getInset(i
)) {
2233 InsetCode lyx_code
= inset
->lyxCode();
2234 if (lyx_code
== LABEL_CODE
) {
2235 InsetLabel
const * const il
= static_cast<InsetLabel
const *>(inset
);
2236 docstring
const & id
= il
->getParam("name");
2237 return "id='" + to_utf8(sgml::cleanID(buf
, runparams
, id
)) + "'";
2245 pos_type
Paragraph::firstWordDocBook(odocstream
& os
, OutputParams
const & runparams
)
2249 for (i
= 0; i
< size(); ++i
) {
2250 if (Inset
const * inset
= getInset(i
)) {
2251 inset
->docbook(os
, runparams
);
2253 char_type c
= d
->text_
[i
];
2256 os
<< sgml::escapeChar(c
);
2263 pos_type
Paragraph::firstWordLyXHTML(odocstream
& os
, OutputParams
const & runparams
)
2267 for (i
= 0; i
< size(); ++i
) {
2268 if (Inset
const * inset
= getInset(i
)) {
2269 inset
->xhtml(os
, runparams
);
2271 char_type c
= d
->text_
[i
];
2274 os
<< html::escapeChar(c
);
2281 bool Paragraph::Private::onlyText(Buffer
const & buf
, Font
const & outerfont
, pos_type initial
) const
2284 pos_type size
= text_
.size();
2285 for (pos_type i
= initial
; i
< size
; ++i
) {
2286 Font font
= owner_
->getFont(buf
.params(), i
, outerfont
);
2287 if (text_
[i
] == META_INSET
)
2289 if (i
!= initial
&& font
!= font_old
)
2298 void Paragraph::simpleDocBookOnePar(Buffer
const & buf
,
2300 OutputParams
const & runparams
,
2301 Font
const & outerfont
,
2302 pos_type initial
) const
2304 bool emph_flag
= false;
2306 Layout
const & style
= *d
->layout_
;
2308 style
.labeltype
== LABEL_MANUAL
? style
.labelfont
: style
.font
;
2310 if (style
.pass_thru
&& !d
->onlyText(buf
, outerfont
, initial
))
2313 // parsing main loop
2314 for (pos_type i
= initial
; i
< size(); ++i
) {
2315 Font font
= getFont(buf
.params(), i
, outerfont
);
2317 // handle <emphasis> tag
2318 if (font_old
.emph() != font
.fontInfo().emph()) {
2319 if (font
.fontInfo().emph() == FONT_ON
) {
2322 } else if (i
!= initial
) {
2323 os
<< "</emphasis>";
2328 if (Inset
const * inset
= getInset(i
)) {
2329 inset
->docbook(os
, runparams
);
2331 char_type c
= d
->text_
[i
];
2333 if (style
.pass_thru
)
2336 os
<< sgml::escapeChar(c
);
2338 font_old
= font
.fontInfo();
2342 os
<< "</emphasis>";
2345 if (style
.free_spacing
)
2347 if (style
.pass_thru
&& !d
->onlyText(buf
, outerfont
, initial
))
2352 void Paragraph::simpleLyXHTMLOnePar(Buffer
const & buf
,
2354 OutputParams
const & runparams
,
2355 Font
const & outerfont
,
2356 pos_type initial
) const
2358 // FIXME We really need to manage the tag nesting here.
2359 // Probably in the same sort of way as in output_xhtml.
2360 bool emph_flag
= false;
2361 bool bold_flag
= false;
2362 std::string closing_tag
;
2364 Layout
const & style
= *d
->layout_
;
2366 style
.labeltype
== LABEL_MANUAL
? style
.labelfont
: style
.font
;
2368 //if (style.pass_thru && !d->onlyText(buf, outerfont, initial))
2371 // parsing main loop
2372 for (pos_type i
= initial
; i
< size(); ++i
) {
2373 Font font
= getFont(buf
.params(), i
, outerfont
);
2376 if (font_old
.emph() != font
.fontInfo().emph()) {
2377 if (font
.fontInfo().emph() == FONT_ON
) {
2380 } else if (emph_flag
&& i
!= initial
) {
2386 if (font_old
.series() != font
.fontInfo().series()) {
2387 if (font
.fontInfo().series() == BOLD_SERIES
) {
2390 } else if (bold_flag
&& i
!= initial
) {
2395 // FIXME Other such tags?
2397 if (Inset
const * inset
= getInset(i
)) {
2398 inset
->xhtml(os
, runparams
);
2400 char_type c
= d
->text_
[i
];
2402 if (style
.pass_thru
)
2404 else if (c
== '-') {
2407 if (j
< size() && d
->text_
[j
] == '-') {
2409 if (j
< size() && d
->text_
[j
] == '-') {
2410 str
+= from_ascii("—");
2413 str
+= from_ascii("–");
2421 os
<< html::escapeChar(c
);
2423 font_old
= font
.fontInfo();
2426 // FIXME This could be out of order. See above.
2432 // if (style.free_spacing)
2434 // if (style.pass_thru && !d->onlyText(buf, outerfont, initial))
2435 // os << "<![CDATA[";
2439 bool Paragraph::isHfill(pos_type pos
) const
2441 Inset
const * inset
= getInset(pos
);
2442 return inset
&& (inset
->lyxCode() == SPACE_CODE
&&
2443 inset
->isStretchableSpace());
2447 bool Paragraph::isNewline(pos_type pos
) const
2449 Inset
const * inset
= getInset(pos
);
2450 return inset
&& inset
->lyxCode() == NEWLINE_CODE
;
2454 bool Paragraph::isLineSeparator(pos_type pos
) const
2456 char_type
const c
= d
->text_
[pos
];
2457 if (isLineSeparatorChar(c
))
2459 Inset
const * inset
= getInset(pos
);
2460 return inset
&& inset
->isLineSeparator();
2464 /// Used by the spellchecker
2465 bool Paragraph::isLetter(pos_type pos
) const
2467 if (Inset
const * inset
= getInset(pos
))
2468 return inset
->isLetter();
2469 char_type
const c
= d
->text_
[pos
];
2470 // We want to pass the ' and escape chars to the spellchecker
2471 static docstring
const quote
= from_utf8(lyxrc
.spellchecker_esc_chars
+ '\'');
2472 return (isLetterChar(c
) || isDigit(c
) || contains(quote
, c
))
2473 && (!d
->inset_owner_
|| d
->inset_owner_
->allowSpellCheck())
2479 bool Paragraph::isChar(pos_type pos
) const
2481 if (Inset
const * inset
= getInset(pos
))
2482 return inset
->isChar();
2483 char_type
const c
= d
->text_
[pos
];
2484 return !isLetterChar(c
) && !isDigit(c
) && !lyx::isSpace(c
);
2488 bool Paragraph::isSpace(pos_type pos
) const
2490 if (Inset
const * inset
= getInset(pos
))
2491 return inset
->isSpace();
2492 char_type
const c
= d
->text_
[pos
];
2493 return lyx::isSpace(c
);
2498 Paragraph::getParLanguage(BufferParams
const & bparams
) const
2501 return getFirstFontSettings(bparams
).language();
2502 // FIXME: we should check the prev par as well (Lgb)
2503 return bparams
.language
;
2507 bool Paragraph::isRTL(BufferParams
const & bparams
) const
2509 return lyxrc
.rtl_support
2510 && getParLanguage(bparams
)->rightToLeft()
2511 && ownerCode() != ERT_CODE
2512 && ownerCode() != LISTINGS_CODE
;
2516 void Paragraph::changeLanguage(BufferParams
const & bparams
,
2517 Language
const * from
, Language
const * to
)
2519 // change language including dummy font change at the end
2520 for (pos_type i
= 0; i
<= size(); ++i
) {
2521 Font font
= getFontSettings(bparams
, i
);
2522 if (font
.language() == from
) {
2523 font
.setLanguage(to
);
2530 bool Paragraph::isMultiLingual(BufferParams
const & bparams
) const
2532 Language
const * doc_language
= bparams
.language
;
2533 FontList::const_iterator cit
= d
->fontlist_
.begin();
2534 FontList::const_iterator end
= d
->fontlist_
.end();
2536 for (; cit
!= end
; ++cit
)
2537 if (cit
->font().language() != ignore_language
&&
2538 cit
->font().language() != latex_language
&&
2539 cit
->font().language() != doc_language
)
2545 docstring
Paragraph::asString(int options
) const
2547 return asString(0, size(), options
);
2551 docstring
Paragraph::asString(pos_type beg
, pos_type end
, int options
) const
2553 odocstringstream os
;
2556 && options
& AS_STR_LABEL
2557 && !d
->params_
.labelString().empty())
2558 os
<< d
->params_
.labelString() << ' ';
2560 for (pos_type i
= beg
; i
< end
; ++i
) {
2561 char_type
const c
= d
->text_
[i
];
2562 if (isPrintable(c
) || c
== '\t'
2563 || (c
== '\n' && options
& AS_STR_NEWLINES
))
2565 else if (c
== META_INSET
&& options
& AS_STR_INSETS
)
2566 getInset(i
)->tocString(os
);
2573 docstring
Paragraph::stringify(pos_type beg
, pos_type end
, int options
, OutputParams
& runparams
) const
2575 odocstringstream os
;
2578 && options
& AS_STR_LABEL
2579 && !d
->params_
.labelString().empty())
2580 os
<< d
->params_
.labelString() << ' ';
2582 for (pos_type i
= beg
; i
< end
; ++i
) {
2583 char_type
const c
= d
->text_
[i
];
2584 if (isPrintable(c
) || c
== '\t'
2585 || (c
== '\n' && options
& AS_STR_NEWLINES
))
2587 else if (c
== META_INSET
&& options
& AS_STR_INSETS
) {
2588 getInset(i
)->plaintext(os
, runparams
);
2596 void Paragraph::setInsetOwner(Inset
const * inset
)
2598 d
->inset_owner_
= inset
;
2602 int Paragraph::id() const
2608 Layout
const & Paragraph::layout() const
2614 void Paragraph::setLayout(Layout
const & layout
)
2616 d
->layout_
= &layout
;
2620 void Paragraph::setDefaultLayout(DocumentClass
const & tc
)
2622 setLayout(tc
.defaultLayout());
2626 void Paragraph::setPlainLayout(DocumentClass
const & tc
)
2628 setLayout(tc
.plainLayout());
2632 void Paragraph::setPlainOrDefaultLayout(DocumentClass
const & tclass
)
2634 if (usePlainLayout())
2635 setPlainLayout(tclass
);
2637 setDefaultLayout(tclass
);
2641 Inset
const & Paragraph::inInset() const
2643 LASSERT(d
->inset_owner_
, throw ExceptionMessage(BufferException
,
2644 _("Memory problem"), _("Paragraph not properly initialized")));
2645 return *d
->inset_owner_
;
2649 InsetCode
Paragraph::ownerCode() const
2651 return d
->inset_owner_
? d
->inset_owner_
->lyxCode() : NO_CODE
;
2655 ParagraphParameters
& Paragraph::params()
2661 ParagraphParameters
const & Paragraph::params() const
2667 bool Paragraph::isFreeSpacing() const
2669 if (d
->layout_
->free_spacing
)
2671 return d
->inset_owner_
&& d
->inset_owner_
->isFreeSpacing();
2675 bool Paragraph::allowEmpty() const
2677 if (d
->layout_
->keepempty
)
2679 return d
->inset_owner_
&& d
->inset_owner_
->allowEmpty();
2683 char_type
Paragraph::transformChar(char_type c
, pos_type pos
) const
2685 if (!Encodings::isArabicChar(c
))
2688 char_type prev_char
= ' ';
2689 char_type next_char
= ' ';
2691 for (pos_type i
= pos
- 1; i
>= 0; --i
) {
2692 char_type
const par_char
= d
->text_
[i
];
2693 if (!Encodings::isArabicComposeChar(par_char
)) {
2694 prev_char
= par_char
;
2699 for (pos_type i
= pos
+ 1, end
= size(); i
< end
; ++i
) {
2700 char_type
const par_char
= d
->text_
[i
];
2701 if (!Encodings::isArabicComposeChar(par_char
)) {
2702 next_char
= par_char
;
2707 if (Encodings::isArabicChar(next_char
)) {
2708 if (Encodings::isArabicChar(prev_char
) &&
2709 !Encodings::isArabicSpecialChar(prev_char
))
2710 return Encodings::transformChar(c
, Encodings::FORM_MEDIAL
);
2712 return Encodings::transformChar(c
, Encodings::FORM_INITIAL
);
2714 if (Encodings::isArabicChar(prev_char
) &&
2715 !Encodings::isArabicSpecialChar(prev_char
))
2716 return Encodings::transformChar(c
, Encodings::FORM_FINAL
);
2718 return Encodings::transformChar(c
, Encodings::FORM_ISOLATED
);
2723 int Paragraph::checkBiblio(Buffer
const & buffer
)
2726 // This is getting more and more a mess. ...We really should clean
2727 // up this bibitem issue for 1.6. See also bug 2743.
2729 // Add bibitem insets if necessary
2730 if (d
->layout_
->labeltype
!= LABEL_BIBLIO
)
2733 bool hasbibitem
= !d
->insetlist_
.empty()
2734 // Insist on it being in pos 0
2735 && d
->text_
[0] == META_INSET
2736 && d
->insetlist_
.begin()->inset
->lyxCode() == BIBITEM_CODE
;
2738 bool track_changes
= buffer
.params().trackChanges
;
2743 // remove a bibitem in pos != 0
2744 // restore it later in pos 0 if necessary
2745 // (e.g. if a user inserts contents _before_ the item)
2746 // we're assuming there's only one of these, which there
2748 int erasedInsetPosition
= -1;
2749 InsetList::iterator it
= d
->insetlist_
.begin();
2750 InsetList::iterator end
= d
->insetlist_
.end();
2751 for (; it
!= end
; ++it
)
2752 if (it
->inset
->lyxCode() == BIBITEM_CODE
2754 InsetBibitem
* olditem
= static_cast<InsetBibitem
*>(it
->inset
);
2755 oldkey
= olditem
->getParam("key");
2756 oldlabel
= olditem
->getParam("label");
2757 erasedInsetPosition
= it
->pos
;
2758 eraseChar(erasedInsetPosition
, track_changes
);
2762 // There was an InsetBibitem at the beginning, and we didn't
2763 // have to erase one.
2764 if (hasbibitem
&& erasedInsetPosition
< 0)
2767 // There was an InsetBibitem at the beginning and we did have to
2768 // erase one. So we give its properties to the beginning inset.
2770 InsetBibitem
* inset
=
2771 static_cast<InsetBibitem
*>(d
->insetlist_
.begin()->inset
);
2772 if (!oldkey
.empty())
2773 inset
->setParam("key", oldkey
);
2774 inset
->setParam("label", oldlabel
);
2775 return -erasedInsetPosition
;
2778 // There was no inset at the beginning, so we need to create one with
2779 // the key and label of the one we erased.
2780 InsetBibitem
* inset
=
2781 new InsetBibitem(buffer
, InsetCommandParams(BIBITEM_CODE
));
2782 // restore values of previously deleted item in this par.
2783 if (!oldkey
.empty())
2784 inset
->setParam("key", oldkey
);
2785 inset
->setParam("label", oldlabel
);
2786 insertInset(0, static_cast<Inset
*>(inset
),
2787 Change(track_changes
? Change::INSERTED
: Change::UNCHANGED
));
2793 void Paragraph::checkAuthors(AuthorList
const & authorList
)
2795 d
->changes_
.checkAuthors(authorList
);
2799 bool Paragraph::isUnchanged(pos_type pos
) const
2801 return lookupChange(pos
).type
== Change::UNCHANGED
;
2805 bool Paragraph::isInserted(pos_type pos
) const
2807 return lookupChange(pos
).type
== Change::INSERTED
;
2811 bool Paragraph::isDeleted(pos_type pos
) const
2813 return lookupChange(pos
).type
== Change::DELETED
;
2817 InsetList
const & Paragraph::insetList() const
2819 return d
->insetlist_
;
2823 void Paragraph::setBuffer(Buffer
& b
)
2825 d
->insetlist_
.setBuffer(b
);
2829 Inset
* Paragraph::releaseInset(pos_type pos
)
2831 Inset
* inset
= d
->insetlist_
.release(pos
);
2832 /// does not honour change tracking!
2833 eraseChar(pos
, false);
2838 Inset
* Paragraph::getInset(pos_type pos
)
2840 return (pos
< pos_type(d
->text_
.size()) && d
->text_
[pos
] == META_INSET
)
2841 ? d
->insetlist_
.get(pos
) : 0;
2845 Inset
const * Paragraph::getInset(pos_type pos
) const
2847 return (pos
< pos_type(d
->text_
.size()) && d
->text_
[pos
] == META_INSET
)
2848 ? d
->insetlist_
.get(pos
) : 0;
2852 void Paragraph::changeCase(BufferParams
const & bparams
, pos_type pos
,
2853 pos_type
& right
, TextCase action
)
2855 // process sequences of modified characters; in change
2856 // tracking mode, this approach results in much better
2857 // usability than changing case on a char-by-char basis
2860 bool const trackChanges
= bparams
.trackChanges
;
2862 bool capitalize
= true;
2864 for (; pos
< right
; ++pos
) {
2865 char_type oldChar
= d
->text_
[pos
];
2866 char_type newChar
= oldChar
;
2868 // ignore insets and don't play with deleted text!
2869 if (oldChar
!= META_INSET
&& !isDeleted(pos
)) {
2871 case text_lowercase
:
2872 newChar
= lowercase(oldChar
);
2874 case text_capitalization
:
2876 newChar
= uppercase(oldChar
);
2880 case text_uppercase
:
2881 newChar
= uppercase(oldChar
);
2886 if (!isLetter(pos
) || isDeleted(pos
)) {
2887 // permit capitalization again
2891 if (oldChar
!= newChar
)
2894 if (oldChar
== newChar
|| pos
== right
- 1) {
2895 if (oldChar
!= newChar
) {
2896 // step behind the changing area
2899 int erasePos
= pos
- changes
.size();
2900 for (size_t i
= 0; i
< changes
.size(); i
++) {
2901 insertChar(pos
, changes
[i
],
2902 getFontSettings(bparams
,
2905 if (!eraseChar(erasePos
, trackChanges
)) {
2908 ++right
; // expand selection
2917 bool Paragraph::find(docstring
const & str
, bool cs
, bool mw
,
2918 pos_type pos
, bool del
) const
2920 int const strsize
= str
.length();
2922 pos_type
const parsize
= d
->text_
.size();
2923 for (i
= 0; pos
+ i
< parsize
; ++i
) {
2926 if (cs
&& str
[i
] != d
->text_
[pos
+ i
])
2928 if (!cs
&& uppercase(str
[i
]) != uppercase(d
->text_
[pos
+ i
]))
2930 if (!del
&& isDeleted(pos
+ i
))
2937 // if necessary, check whether string matches word
2939 if (pos
> 0 && isLetter(pos
- 1))
2941 if (pos
+ strsize
< parsize
2942 && isLetter(pos
+ strsize
))
2950 char_type
Paragraph::getChar(pos_type pos
) const
2952 return d
->text_
[pos
];
2956 pos_type
Paragraph::size() const
2958 return d
->text_
.size();
2962 bool Paragraph::empty() const
2964 return d
->text_
.empty();
2968 bool Paragraph::isInset(pos_type pos
) const
2970 return d
->text_
[pos
] == META_INSET
;
2974 bool Paragraph::isSeparator(pos_type pos
) const
2976 //FIXME: Are we sure this can be the only separator?
2977 return d
->text_
[pos
] == ' ';
2981 void Paragraph::deregisterWords()
2983 Private::Words::const_iterator it
;
2984 WordList
& wl
= theWordList();
2985 for (it
= d
->words_
.begin(); it
!= d
->words_
.end(); ++it
)
2991 void Paragraph::locateWord(pos_type
& from
, pos_type
& to
,
2992 word_location
const loc
) const
2995 case WHOLE_WORD_STRICT
:
2996 if (from
== 0 || from
== size()
2998 || !isLetter(from
- 1)) {
3002 // no break here, we go to the next
3005 // If we are already at the beginning of a word, do nothing
3006 if (!from
|| !isLetter(from
- 1))
3008 // no break here, we go to the next
3011 // always move the cursor to the beginning of previous word
3012 while (from
&& isLetter(from
- 1))
3016 LYXERR0("Paragraph::locateWord: NEXT_WORD not implemented yet");
3019 // no need to move the 'from' cursor
3023 while (to
< size() && isLetter(to
))
3028 void Paragraph::collectWords()
3030 SpellChecker
* speller
= theSpellChecker();
3032 //lyxerr << "Words: ";
3033 pos_type n
= size();
3034 for (pos_type pos
= 0; pos
< n
; ++pos
) {
3037 pos_type from
= pos
;
3038 locateWord(from
, pos
, WHOLE_WORD
);
3039 if (!lyxrc
.spellcheck_continuously
&& pos
- from
< 6)
3042 docstring word
= asString(from
, pos
, false);
3043 if (pos
- from
>= 6)
3044 d
->words_
.insert(word
);
3046 if (!lyxrc
.spellcheck_continuously
|| !speller
)
3049 string lang_code
= lyxrc
.spellchecker_use_alt_lang
3050 ? lyxrc
.spellchecker_alt_lang
3051 : getFontSettings(d
->inset_owner_
->buffer().params(), from
).language()->code();
3052 WordLangTuple
wl(word
, lang_code
);
3053 SpellChecker::Result res
= speller
->check(wl
);
3054 // ... just ignore any error that the spellchecker reports.
3055 if (!speller
->error().empty())
3057 bool const misspelled
= res
!= SpellChecker::OK
3058 && res
!= SpellChecker::IGNORED_WORD
;
3059 d
->fontlist_
.setMisspelled(from
, pos
, misspelled
);
3061 //lyxerr << word << " ";
3063 //lyxerr << std::endl;
3067 void Paragraph::registerWords()
3069 Private::Words::const_iterator it
;
3070 WordList
& wl
= theWordList();
3071 for (it
= d
->words_
.begin(); it
!= d
->words_
.end(); ++it
)
3076 void Paragraph::updateWords()
3084 bool Paragraph::isMisspelled(pos_type pos
) const
3086 SpellChecker
* speller
= theSpellChecker();
3087 pos_type from
= pos
;
3089 locateWord(from
, to
, WHOLE_WORD
);
3090 docstring word
= asString(from
, to
, false);
3094 string lang_code
= lyxrc
.spellchecker_use_alt_lang
3095 ? lyxrc
.spellchecker_alt_lang
3096 : getFontSettings(d
->inset_owner_
->buffer().params(), from
).language()->code();
3097 WordLangTuple
wl(word
, lang_code
);
3098 SpellChecker::Result res
= speller
->check(wl
);
3099 // ... just ignore any error that the spellchecker reports.
3100 if (!speller
->error().empty())
3103 bool const misspelled
= res
!= SpellChecker::OK
3104 && res
!= SpellChecker::IGNORED_WORD
;
3105 if (lyxrc
.spellcheck_continuously
)
3106 d
->fontlist_
.setMisspelled(from
, pos
, misspelled
);