-/* This file is part of
- * ======================================================
+/**
+ * \file lyxtextclass.C
+ * This file is part of LyX, the document processor.
+ * Licence details can be found in the file COPYING.
*
- * LyX, The Document Processor
+ * \author Lars Gullik Bjønnes
+ * \author Jean-Marc Lasgouttes
+ * \author Angus Leeming
+ * \author John Levon
+ * \author André Pönitz
*
- * Copyright 1995 Matthias Ettrich
- * Copyright 1995-2001 The LyX Team.
- *
- * ======================================================
+ * Full author contact details are available in file CREDITS.
*/
#include <config.h>
#include "debug.h"
#include "lyxlex.h"
#include "counters.h"
+#include "Floating.h"
#include "FloatList.h"
#include "support/lstrings.h"
-#include "support/LAssert.h"
-#include "support/lyxfunctional.h"
#include "support/filetools.h"
-#include <algorithm>
+using lyx::support::LibFileSearch;
+using lyx::support::MakeDisplayPath;
+using lyx::support::rtrim;
+using lyx::support::subst;
using std::endl;
using std::find_if;
using std::remove_if;
+using std::string;
using std::ostream;
-namespace { // anon
-struct compare_name {
+namespace {
- compare_name(string const & name)
+class LayoutNamesEqual : public std::unary_function<LyXLayout_ptr, bool> {
+public:
+ LayoutNamesEqual(string const & name)
: name_(name)
{}
-
- bool operator()(boost::shared_ptr<LyXLayout> const & c)
+ bool operator()(LyXLayout_ptr const & c) const
{
return c->name() == name_;
}
-
+private:
string name_;
-
};
-} // anon
+} // namespace anon
LyXTextClass::LyXTextClass(string const & fn, string const & cln,
string const & desc, bool texClassAvail )
: name_(fn), latexname_(cln), description_(desc),
- floatlist_(new FloatList), ctrs_(new Counters), texClassAvail_(texClassAvail)
+ floatlist_(new FloatList), ctrs_(new Counters),
+ texClassAvail_(texClassAvail)
{
outputType_ = LATEX;
columns_ = 1;
secnumdepth_ = 3;
tocdepth_ = 3;
pagestyle_ = "default";
- maxcounter_ = LABEL_COUNTER_CHAPTER;
defaultfont_ = LyXFont(LyXFont::ALL_SANE);
opt_fontsize_ = "10|11|12";
opt_pagestyle_ = "empty|plain|headings|fancy";
provides_ = nothing;
titletype_ = TITLE_COMMAND_AFTER;
titlename_ = "maketitle";
- loaded = false;
+ loaded_ = false;
}
TC_INPUT,
TC_STYLE,
TC_DEFAULTSTYLE,
+ TC_CHARSTYLE,
TC_ENVIRONMENT,
TC_NOSTYLE,
TC_COLUMNS,
TC_SIDES,
TC_PAGESTYLE,
TC_DEFAULTFONT,
- TC_MAXCOUNTER,
TC_SECNUMDEPTH,
TC_TOCDEPTH,
TC_CLASSOPTIONS,
bool LyXTextClass::Read(string const & filename, bool merge)
{
keyword_item textClassTags[] = {
+ { "charstyle", TC_CHARSTYLE },
{ "classoptions", TC_CLASSOPTIONS },
{ "columns", TC_COLUMNS },
{ "counter", TC_COUNTER },
{ "float", TC_FLOAT },
{ "input", TC_INPUT },
{ "leftmargin", TC_LEFTMARGIN },
- { "maxcounter", TC_MAXCOUNTER },
{ "nofloat", TC_NOFLOAT },
{ "nostyle", TC_NOSTYLE },
{ "outputtype", TC_OUTPUTTYPE },
}
break;
+ case TC_ENVIRONMENT:
case TC_STYLE:
if (lexrc.next()) {
string const name = subst(lexrc.getString(),
} else {
LyXLayout lay;
lay.setName(name);
+ if (le == TC_ENVIRONMENT)
+ lay.is_environment = true;
if (!(error = do_readStyle(lexrc, lay)))
- layoutlist_.push_back
- (boost::shared_ptr<LyXLayout>(new LyXLayout(lay)));
+ layoutlist_.push_back(
+ boost::shared_ptr<LyXLayout>(new LyXLayout(lay))
+ );
+
if (defaultlayout_.empty()) {
// We do not have a default
// layout yet, so we choose
}
break;
- case TC_ENVIRONMENT:
- if (lexrc.next()) {
- string const name = subst(lexrc.getString(),
- '_', ' ');
- if (hasLayout(name)) {
- LyXLayout * lay = operator[](name).get();
- error = do_readStyle(lexrc, *lay);
- } else {
- LyXLayout lay;
- lay.setName(name);
- if (!(error = do_readStyle(lexrc, lay)))
- envlist_.push_back
- (boost::shared_ptr<LyXLayout>(new LyXLayout(lay)));
- else
- lexrc.printError("Problems reading environment: `$$Token'.");
- }
- }
- else {
- lexrc.printError("No name given for style: `$$Token'.");
- error = true;
- }
- break;
-
case TC_NOSTYLE:
if (lexrc.next()) {
string const style = subst(lexrc.getString(),
}
break;
- case TC_MAXCOUNTER:
- readMaxCounter(lexrc);
- break;
-
case TC_SECNUMDEPTH:
lexrc.next();
secnumdepth_ = lexrc.getInteger();
if (lexrc.next())
rightmargin_ = lexrc.getString();
break;
+ case TC_CHARSTYLE:
+ if (lexrc.next()) {
+ string const name = subst(lexrc.getString(), '_', ' ');
+ readCharStyle(lexrc, name);
+ }
+ break;
case TC_FLOAT:
readFloat(lexrc);
break;
};
-void LyXTextClass::readMaxCounter(LyXLex & lexrc)
-{
- keyword_item maxCounterTags[] = {
- {"counter_chapter", MC_COUNTER_CHAPTER },
- {"counter_enumi", MC_COUNTER_ENUMI },
- {"counter_enumii", MC_COUNTER_ENUMII },
- {"counter_enumiii", MC_COUNTER_ENUMIII },
- {"counter_enumiv", MC_COUNTER_ENUMIV },
- {"counter_paragraph", MC_COUNTER_PARAGRAPH },
- {"counter_section", MC_COUNTER_SECTION },
- {"counter_subparagraph", MC_COUNTER_SUBPARAGRAPH },
- {"counter_subsection", MC_COUNTER_SUBSECTION },
- {"counter_subsubsection", MC_COUNTER_SUBSUBSECTION }
- };
-
- pushpophelper pph(lexrc, maxCounterTags, MC_COUNTER_ENUMIV);
-
- int le = lexrc.lex();
- switch (le) {
- case LyXLex::LEX_UNDEF:
- lexrc.printError("Unknown MaxCounter tag `$$Token'");
- return;
- default:
- break;
- }
-
- switch (static_cast<MaxCounterTags>(le)) {
- case MC_COUNTER_CHAPTER:
- maxcounter_ = LABEL_COUNTER_CHAPTER;
- break;
- case MC_COUNTER_SECTION:
- maxcounter_ = LABEL_COUNTER_SECTION;
- break;
- case MC_COUNTER_SUBSECTION:
- maxcounter_ = LABEL_COUNTER_SUBSECTION;
- break;
- case MC_COUNTER_SUBSUBSECTION:
- maxcounter_ = LABEL_COUNTER_SUBSUBSECTION;
- break;
- case MC_COUNTER_PARAGRAPH:
- maxcounter_ = LABEL_COUNTER_PARAGRAPH;
- break;
- case MC_COUNTER_SUBPARAGRAPH:
- maxcounter_ = LABEL_COUNTER_SUBPARAGRAPH;
- break;
- case MC_COUNTER_ENUMI:
- maxcounter_ = LABEL_COUNTER_ENUMI;
- break;
- case MC_COUNTER_ENUMII:
- maxcounter_ = LABEL_COUNTER_ENUMII;
- break;
- case MC_COUNTER_ENUMIII:
- maxcounter_ = LABEL_COUNTER_ENUMIII;
- break;
- case MC_COUNTER_ENUMIV:
- maxcounter_ = LABEL_COUNTER_ENUMIV;
- break;
- }
-}
-
-
enum ClassOptionsTags {
CO_FONTSIZE = 1,
CO_PAGESTYLE,
CO_OTHER,
+ CO_HEADER,
CO_END
};
keyword_item classOptionsTags[] = {
{"end", CO_END },
{"fontsize", CO_FONTSIZE },
+ {"header", CO_HEADER },
{"other", CO_OTHER },
{"pagestyle", CO_PAGESTYLE }
};
lexrc.next();
options_ = lexrc.getString();
break;
+ case CO_HEADER:
+ lexrc.next();
+ class_header_ = subst(lexrc.getString(), """, "\"");
+ break;
case CO_END:
getout = true;
break;
lexrc.popTable();
}
+enum CharStyleTags {
+ CS_FONT = 1,
+ CS_LABELFONT,
+ CS_LATEXTYPE,
+ CS_LATEXNAME,
+ CS_LATEXPARAM,
+ CS_PREAMBLE,
+ CS_END
+};
+
+
+void LyXTextClass::readCharStyle(LyXLex & lexrc, string const & name)
+{
+ keyword_item elementTags[] = {
+ { "end", CS_END },
+ { "font", CS_FONT },
+ { "labelfont", CS_LABELFONT },
+ { "latexname", CS_LATEXNAME },
+ { "latexparam", CS_LATEXPARAM },
+ { "latextype", CS_LATEXTYPE },
+ { "preamble", CS_PREAMBLE}
+ };
+
+ lexrc.pushTable(elementTags, CS_END);
+
+ string latextype;
+ string latexname;
+ string latexparam;
+ LyXFont font(LyXFont::ALL_INHERIT);
+ LyXFont labelfont(LyXFont::ALL_INHERIT);
+ string preamble;
+
+ bool getout = false;
+ while (!getout && lexrc.isOK()) {
+ int le = lexrc.lex();
+ switch (le) {
+ case LyXLex::LEX_UNDEF:
+ lexrc.printError("Unknown ClassOption tag `$$Token'");
+ continue;
+ default: break;
+ }
+ switch (static_cast<CharStyleTags>(le)) {
+ case CS_LATEXTYPE:
+ lexrc.next();
+ latextype = lexrc.getString();
+ break;
+ case CS_LATEXNAME:
+ lexrc.next();
+ latexname = lexrc.getString();
+ break;
+ case CS_LATEXPARAM:
+ lexrc.next();
+ latexparam = subst(lexrc.getString(), """, "\"");
+ break;
+ case CS_LABELFONT:
+ labelfont.lyxRead(lexrc);
+ break;
+ case CS_FONT:
+ font.lyxRead(lexrc);
+ labelfont = font;
+ break;
+ case CS_PREAMBLE:
+ preamble = lexrc.getLongString("EndPreamble");
+ break;
+ case CS_END:
+ getout = true;
+ break;
+ }
+ }
+
+ //
+ // Here add element to list if getout == true
+ if (getout) {
+ CharStyle cs;
+ cs.name = name;
+ cs.latextype = latextype;
+ cs.latexname = latexname;
+ cs.latexparam = latexparam;
+ cs.font = font;
+ cs.labelfont = labelfont;
+ cs.preamble = preamble;
+ charstyles().push_back(cs);
+ }
+
+ lexrc.popTable();
+}
+
enum FloatTags {
FT_TYPE = 1,
FT_END
};
+
void LyXTextClass::readFloat(LyXLex & lexrc)
{
keyword_item floatTags[] = {
}
}
- // Here if have a full float if getout == true
+ // Here if have a full counter if getout == true
if (getout) {
if (within.empty()) {
ctrs_->newCounter(name);
string const name = (n.empty() ? defaultLayoutName() : n);
return find_if(layoutlist_.begin(), layoutlist_.end(),
- compare_name(name))
+ LayoutNamesEqual(name))
!= layoutlist_.end();
}
-LyXLayout_ptr const & LyXTextClass::operator[](string const & n) const
-{
- lyx::Assert(!n.empty());
-
- if (n.empty())
- lyxerr << "LyXTextClass::operator[] called with empty n" << endl;
-
- string const name = (n.empty() ? defaultLayoutName() : n);
-
- static string lastLayoutName;
- static LayoutList::difference_type lastLayoutIndex;
- if (name == lastLayoutName)
- return layoutlist_[lastLayoutIndex];
+LyXLayout_ptr const & LyXTextClass::operator[](string const & name) const
+{
+ BOOST_ASSERT(!name.empty());
LayoutList::const_iterator cit =
find_if(layoutlist_.begin(),
layoutlist_.end(),
- compare_name(name));
+ LayoutNamesEqual(name));
if (cit == layoutlist_.end()) {
lyxerr << "We failed to find the layout '" << name
<< "' in the layout list. You MUST investigate!"
<< endl;
+ for (LayoutList::const_iterator it = layoutlist_.begin();
+ it != layoutlist_.end(); ++it)
+ lyxerr << " " << it->get()->name() << endl;
// we require the name to exist
- lyx::Assert(false);
+ BOOST_ASSERT(false);
}
- lastLayoutName = name;
- lastLayoutIndex = std::distance(layoutlist_.begin(), cit);
-
return (*cit);
}
-LyXLayout_ptr const & LyXTextClass::getEnv(string const & name) const
-{
- lyx::Assert(!name.empty());
-
- if (name.empty())
- lyxerr << "LyXTextClass::getEnv() called with empty n" << endl;
-
- LayoutList::const_iterator cit =
- find_if(envlist_.begin(), envlist_.end(), compare_name(name));
-
- if (cit == envlist_.end()) {
- lyxerr << "We failed to find the environment '" << name
- << "' in the layout list. You MUST investigate!"
- << endl;
- // we require the name to exist
- lyx::Assert(false);
- }
-
- return *cit;
-}
-
bool LyXTextClass::delete_layout(string const & name)
{
LayoutList::iterator it =
remove_if(layoutlist_.begin(), layoutlist_.end(),
- compare_name(name));
+ LayoutNamesEqual(name));
LayoutList::iterator end = layoutlist_.end();
bool const ret = (it != end);
// Load textclass info if not loaded yet
bool LyXTextClass::load() const
{
- if (loaded)
+ if (loaded_)
return true;
// Read style-file
string const real_file = LibFileSearch("layouts", name_, "layout");
+ loaded_ = const_cast<LyXTextClass*>(this)->Read(real_file) == 0;
- if (const_cast<LyXTextClass*>(this)->Read(real_file)) {
+ if (!loaded_) {
lyxerr << "Error reading `"
<< MakeDisplayPath(real_file)
<< "'\n(Check `" << name_
<< "')\nCheck your installation and "
"try Options/Reconfigure..." << endl;
- loaded = false;
}
- loaded = true;
- return loaded;
+
+ return loaded_;
}
}
+CharStyles::iterator LyXTextClass::charstyle(string const & s) const
+{
+ CharStyles::iterator cs = charstyles().begin();
+ CharStyles::iterator csend = charstyles().end();
+ for (; cs != csend; ++cs) {
+ if (cs->name == s)
+ return cs;
+ }
+ return csend;
+}
+
+
string const & LyXTextClass::defaultLayoutName() const
{
// This really should come from the actual layout... (Lgb)
}
+string const & LyXTextClass::class_header() const
+{
+ return class_header_;
+}
+
+
string const & LyXTextClass::pagestyle() const
{
return pagestyle_;
}
-int LyXTextClass::maxcounter() const
-{
- return maxcounter_;
-}
-
-
LYX_TITLE_LATEX_TYPES LyXTextClass::titletype() const
{
return titletype_;
}
-
-
-
int LyXTextClass::size() const
{
return layoutlist_.size();
projects / lyx.git / blobdiff