#include "Language.h"
#include "LaTeXFeatures.h"
#include "Color.h"
+#include "Layout.h"
#include "Length.h"
#include "Font.h"
#include "LyXRC.h"
namespace lyx {
using support::contains;
+using support::prefixIs;
using support::suffixIs;
using support::rsplit;
+using support::rtrim;
/////////////////////////////////////////////////////////////////////
unsigned int & column,
Font const & font,
Layout const & style);
+ /// Output consecutive known unicode chars, belonging to the same
+ /// language as specified by \p preamble, to \p os starting from \p c.
+ /// \return the number of characters written.
+ int knownLangChars(odocstream & os, value_type c, string & preamble,
+ Change &, Encoding const &, pos_type &);
///
void simpleTeXSpecialChars(Buffer const &, BufferParams const &,
odocstream &,
if (style.pass_thru)
return false;
- if (i < size() - 1) {
+ if (i + 1 < size()) {
char_type next = getChar(i + 1);
if (Encodings::isCombiningChar(next)) {
// This space has an accent, so we must always output it.
&& column > lyxrc.plaintext_linelen
&& i
&& getChar(i - 1) != ' '
- && (i < size() - 1)
+ && (i + 1 < size())
// same in FreeSpacing mode
&& !owner_->isFreeSpacing()
// In typewriter mode, we want to avoid
}
+int Paragraph::Pimpl::knownLangChars(odocstream & os,
+ value_type c,
+ string & preamble,
+ Change & runningChange,
+ Encoding const & encoding,
+ pos_type & i)
+{
+ // When the character is marked by the proper language, we simply
+ // get its code point in some encoding, otherwise we get the
+ // translation specified in the unicodesymbols file, which is
+ // something like "\textLANG{<spec>}". So, we have to retain
+ // "\textLANG{<spec>" for the first char but only "<spec>" for
+ // all subsequent chars.
+ docstring const latex1 = rtrim(encoding.latexChar(c), "}");
+ int length = latex1.length();
+ os << latex1;
+ while (i + 1 < size()) {
+ char_type next = getChar(i + 1);
+ // Stop here if next character belongs to another
+ // language or there is a change tracking status.
+ if (!Encodings::isKnownLangChar(next, preamble) ||
+ runningChange != lookupChange(i + 1))
+ break;
+ Font prev_font;
+ bool found = false;
+ FontList::const_iterator cit = fontlist.begin();
+ FontList::const_iterator end = fontlist.end();
+ for (; cit != end; ++cit) {
+ if (cit->pos() >= i && !found) {
+ prev_font = cit->font();
+ found = true;
+ }
+ if (cit->pos() >= i + 1)
+ break;
+ }
+ // Stop here if there is a font attribute change.
+ if (found && cit != end && prev_font != cit->font())
+ break;
+ docstring const latex = rtrim(encoding.latexChar(next), "}");
+ docstring::size_type const j =
+ latex.find_first_of(from_ascii("{"));
+ if (j == docstring::npos) {
+ os << latex;
+ length += latex.length();
+ } else {
+ os << latex.substr(j + 1);
+ length += latex.substr(j + 1).length();
+ }
+ ++i;
+ }
+ // When the proper language is set, we are simply passed a code
+ // point, so we should not try to close the \textLANG command.
+ if (prefixIs(latex1, from_ascii("\\" + preamble))) {
+ os << '}';
+ ++length;
+ }
+ return length;
+}
+
+
bool Paragraph::Pimpl::isTextAt(string const & str, pos_type pos) const
{
pos_type const len = str.length();
break;
// FIXME: move this to InsetNewline::latex
- if (inset->lyxCode() == Inset::NEWLINE_CODE) {
+ if (inset->lyxCode() == NEWLINE_CODE) {
// newlines are handled differently here than
// the default in simpleTeXSpecialChars().
if (!style.newline_allowed) {
bool close = false;
odocstream::pos_type const len = os.tellp();
- if ((inset->lyxCode() == Inset::GRAPHICS_CODE
- || inset->lyxCode() == Inset::MATH_CODE
- || inset->lyxCode() == Inset::URL_CODE)
+ if ((inset->lyxCode() == GRAPHICS_CODE
+ || inset->lyxCode() == MATH_CODE
+ || inset->lyxCode() == HYPERLINK_CODE)
&& running_font.isRightToLeft()) {
if (running_font.language()->lang() == "farsi")
os << "\\beginL{}";
if (pnr == phrases_nr && c != '\0') {
Encoding const & encoding = *(runparams.encoding);
- if (i < size() - 1) {
+ if (i + 1 < size()) {
char_type next = getChar(i + 1);
if (Encodings::isCombiningChar(next)) {
column += latexSurrogatePair(os, c, next, encoding) - 1;
break;
}
}
+ string preamble;
+ if (Encodings::isKnownLangChar(c, preamble)) {
+ column +=
+ knownLangChars(os, c, preamble,
+ running_change,
+ encoding, i) - 1;
+ break;
+ }
docstring const latex = encoding.latexChar(c);
if (latex.length() > 1 &&
latex[latex.length() - 1] != '}') {
if (icit->inset) {
icit->inset->validate(features);
if (layout.needprotect &&
- icit->inset->lyxCode() == Inset::FOOT_CODE)
+ icit->inset->lyxCode() == FOOT_CODE)
features.require("NeedLyXFootnoteCode");
}
}
}
-bool Paragraph::insetAllowed(Inset_code code)
+bool Paragraph::insetAllowed(InsetCode code)
{
return !pimpl_->inset_owner || pimpl_->inset_owner->insetAllowed(code);
}
// the next two functions are for the manual labels
docstring const Paragraph::getLabelWidthString() const
{
- if (!params().labelWidthString().empty())
+ if (layout()->margintype == MARGIN_MANUAL)
return params().labelWidthString();
else
return _("Senseless with this layout!");
size_t const j = fmt.find('@', i + 1);
if (j != docstring::npos) {
docstring parent(fmt, i + 1, j - i - 1);
- docstring label = expandLabel(tclass[parent], bparams,
+ docstring label = from_ascii("??");
+ if (tclass.hasLayout(parent))
+ docstring label = expandLabel(tclass[parent], bparams,
process_appendix);
fmt = docstring(fmt, 0, i) + label
+ docstring(fmt, j + 1, docstring::npos);
{
if (!insetlist.empty()) {
Inset * inset = insetlist.begin()->inset;
- if (inset->lyxCode() == Inset::BIBITEM_CODE)
+ if (inset->lyxCode() == BIBITEM_CODE)
return static_cast<InsetBibitem *>(inset);
}
return 0;
// paragraphs inside floats need different alignment tags to avoid
// unwanted space
-bool noTrivlistCentering(Inset::Code code)
+bool noTrivlistCentering(InsetCode code)
{
- return code == Inset::FLOAT_CODE || code == Inset::WRAP_CODE;
+ return code == FLOAT_CODE || code == WRAP_CODE;
}
string const corrected_env(string const & suffix, string const & env,
- Inset::Code code)
+ InsetCode code)
{
string output = suffix + "{";
if (noTrivlistCentering(code))
for (pos_type i = 0; i < size(); ++i) {
if (isInset(i)) {
Inset const * inset = getInset(i);
- Inset::Code lyx_code = inset->lyxCode();
- if (lyx_code != Inset::TOC_CODE &&
- lyx_code != Inset::INCLUDE_CODE &&
- lyx_code != Inset::GRAPHICS_CODE &&
- lyx_code != Inset::ERT_CODE &&
- lyx_code != Inset::LISTINGS_CODE &&
- lyx_code != Inset::FLOAT_CODE &&
- lyx_code != Inset::TABULAR_CODE) {
+ InsetCode lyx_code = inset->lyxCode();
+ if (lyx_code != TOC_CODE &&
+ lyx_code != INCLUDE_CODE &&
+ lyx_code != GRAPHICS_CODE &&
+ lyx_code != ERT_CODE &&
+ lyx_code != LISTINGS_CODE &&
+ lyx_code != FLOAT_CODE &&
+ lyx_code != TABULAR_CODE) {
return false;
}
} else {
for (pos_type i = 0; i < size(); ++i) {
if (isInset(i)) {
Inset const * inset = getInset(i);
- Inset::Code lyx_code = inset->lyxCode();
- if (lyx_code == Inset::LABEL_CODE) {
+ InsetCode lyx_code = inset->lyxCode();
+ if (lyx_code == LABEL_CODE) {
string const id = static_cast<InsetCommand const *>(inset)->getContents();
return "id='" + to_utf8(sgml::cleanID(buf, runparams, from_utf8(id))) + "'";
}
}
+bool Paragraph::isHfill(pos_type pos) const
+{
+ return isInset(pos)
+ && getInset(pos)->lyxCode() == HFILL_CODE;
+}
+
+
bool Paragraph::isNewline(pos_type pos) const
{
return isInset(pos)
- && getInset(pos)->lyxCode() == Inset::NEWLINE_CODE;
+ && getInset(pos)->lyxCode() == NEWLINE_CODE;
}
{
return lyxrc.rtl_support
&& getParLanguage(bparams)->rightToLeft()
- && ownerCode() != Inset::ERT_CODE
- && ownerCode() != Inset::LISTINGS_CODE;
+ && ownerCode() != ERT_CODE
+ && ownerCode() != LISTINGS_CODE;
}
}
-Inset::Code Paragraph::ownerCode() const
+InsetCode Paragraph::ownerCode() const
{
return pimpl_->inset_owner
- ? pimpl_->inset_owner->lyxCode() : Inset::NO_CODE;
+ ? pimpl_->inset_owner->lyxCode() : NO_CODE;
}
// for now we just need this, later should we need this in some
// other way we can always add a function to Inset too.
- return ownerCode() == Inset::ERT_CODE || ownerCode() == Inset::LISTINGS_CODE;
+ return ownerCode() == ERT_CODE || ownerCode() == LISTINGS_CODE;
}
{
if (layout()->keepempty)
return true;
- return ownerCode() == Inset::ERT_CODE || ownerCode() == Inset::LISTINGS_CODE;
+ return ownerCode() == ERT_CODE || ownerCode() == LISTINGS_CODE;
}
bool hasbibitem = !insetlist.empty()
// Insist on it being in pos 0
&& getChar(0) == Paragraph::META_INSET
- && insetlist.begin()->inset->lyxCode() == Inset::BIBITEM_CODE;
+ && insetlist.begin()->inset->lyxCode() == BIBITEM_CODE;
docstring oldkey;
docstring oldlabel;
InsetList::iterator it = insetlist.begin();
InsetList::iterator end = insetlist.end();
for (; it != end; ++it)
- if (it->inset->lyxCode() == Inset::BIBITEM_CODE
+ if (it->inset->lyxCode() == BIBITEM_CODE
&& it->pos > 0) {
InsetBibitem * olditem = static_cast<InsetBibitem *>(it->inset);
oldkey = olditem->getParam("key");