-/* 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>
-#ifdef __GNUG__
-#pragma implementation
-#endif
-
#include "lyxtextclass.h"
#include "debug.h"
#include "lyxlex.h"
+#include "counters.h"
+#include "FloatList.h"
#include "support/lstrings.h"
#include "support/LAssert.h"
#include <algorithm>
+using namespace lyx::support;
+
using std::endl;
using std::find_if;
using std::remove_if;
namespace { // anon
struct compare_name {
+
compare_name(string const & name)
- : name_(name) {}
- template <class C>
- bool operator()(C & c) {
+ : name_(name)
+ {}
+
+ bool operator()(boost::shared_ptr<LyXLayout> const & c)
+ {
return c->name() == name_;
}
+
string name_;
+
};
} // anon
LyXTextClass::LyXTextClass(string const & fn, string const & cln,
- string const & desc)
- : name_(fn), latexname_(cln), description_(desc)
+ string const & desc, bool texClassAvail )
+ : name_(fn), latexname_(cln), description_(desc),
+ floatlist_(new FloatList), ctrs_(new Counters), texClassAvail_(texClassAvail)
{
outputType_ = LATEX;
columns_ = 1;
opt_fontsize_ = "10|11|12";
opt_pagestyle_ = "empty|plain|headings|fancy";
provides_ = nothing;
+ titletype_ = TITLE_COMMAND_AFTER;
+ titlename_ = "maketitle";
loaded = false;
}
+bool LyXTextClass::isTeXClassAvailable() const
+{
+ return texClassAvail_;
+}
+
+
bool LyXTextClass::do_readStyle(LyXLex & lexrc, LyXLayout & lay)
{
lyxerr[Debug::TCLASS] << "Reading style " << lay.name() << endl;
if (!lay.Read(lexrc, *this)) {
// Resolve fonts
lay.resfont = lay.font;
-#ifndef INHERIT_LANGUAGE
lay.resfont.realize(defaultfont());
lay.reslabelfont = lay.labelfont;
lay.reslabelfont.realize(defaultfont());
-#else
- lay.resfont.realize(defaultfont(), default_language);
- lay.reslabelfont = lay.labelfont;
- lay.reslabelfont.realize(defaultfont(), default_language);
-#endif
return false; // no errors
}
- lyxerr << "Error parsing style `" << lay.name() << "'" << endl;
+ lyxerr << "Error parsing style `" << lay.name() << '\'' << endl;
return true;
}
TC_INPUT,
TC_STYLE,
TC_DEFAULTSTYLE,
+ TC_ENVIRONMENT,
TC_NOSTYLE,
TC_COLUMNS,
TC_SIDES,
TC_PROVIDESURL,
TC_LEFTMARGIN,
TC_RIGHTMARGIN,
- TC_FLOAT
+ TC_FLOAT,
+ TC_COUNTER,
+ TC_NOFLOAT,
+ TC_TITLELATEXNAME,
+ TC_TITLELATEXTYPE
};
-
// Reads a textclass structure from file.
bool LyXTextClass::Read(string const & filename, bool merge)
{
keyword_item textClassTags[] = {
{ "classoptions", TC_CLASSOPTIONS },
{ "columns", TC_COLUMNS },
+ { "counter", TC_COUNTER },
{ "defaultfont", TC_DEFAULTFONT },
{ "defaultstyle", TC_DEFAULTSTYLE },
+ { "environment", TC_ENVIRONMENT },
{ "float", TC_FLOAT },
{ "input", TC_INPUT },
{ "leftmargin", TC_LEFTMARGIN },
{ "maxcounter", TC_MAXCOUNTER },
+ { "nofloat", TC_NOFLOAT },
{ "nostyle", TC_NOSTYLE },
{ "outputtype", TC_OUTPUTTYPE },
{ "pagestyle", TC_PAGESTYLE },
{ "secnumdepth", TC_SECNUMDEPTH },
{ "sides", TC_SIDES },
{ "style", TC_STYLE },
+ { "titlelatexname", TC_TITLELATEXNAME },
+ { "titlelatextype", TC_TITLELATEXTYPE },
{ "tocdepth", TC_TOCDEPTH }
};
<< MakeDisplayPath(filename)
<< endl;
- LyXLex lexrc(textClassTags, TC_FLOAT);
+ LyXLex lexrc(textClassTags,
+ sizeof(textClassTags) / sizeof(textClassTags[0]));
bool error = false;
lexrc.setFile(filename);
// parsing
while (lexrc.isOK() && !error) {
int le = lexrc.lex();
+
switch (le) {
case LyXLex::LEX_FEOF:
continue;
lexrc.printError("Unknown TextClass tag `$$Token'");
error = true;
continue;
- default: break;
+
+ default:
+ break;
}
+
switch (static_cast<TextClassTags>(le)) {
+
case TC_OUTPUTTYPE: // output type definition
readOutputType(lexrc);
break;
}
break;
+ case TC_ENVIRONMENT:
case TC_STYLE:
if (lexrc.next()) {
string const name = subst(lexrc.getString(),
'_', ' ');
if (hasLayout(name)) {
- LyXLayout * lay =
- operator[](name).get();
+ LyXLayout * lay = operator[](name).get();
error = do_readStyle(lexrc, *lay);
} 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
string const style = subst(lexrc.getString(),
'_', ' ');
if (!delete_layout(style))
- lyxerr << "Cannot delete style `" << style << "'" << endl;
+ lyxerr << "Cannot delete style `"
+ << style << '\'' << endl;
// lexrc.printError("Cannot delete style"
// " `$$Token'");
}
if (!defaultfont_.resolved()) {
lexrc.printError("Warning: defaultfont should "
"be fully instantiated!");
-#ifndef INHERIT_LANGUAGE
defaultfont_.realize(LyXFont(LyXFont::ALL_SANE));
-#else
- defaultfont_.realize(LyXFont(LyXFont::ALL_SANE),
- default_language);
-#endif
}
break;
case TC_FLOAT:
readFloat(lexrc);
break;
+ case TC_COUNTER:
+ readCounter(lexrc);
+ break;
+ case TC_TITLELATEXTYPE:
+ readTitleType(lexrc);
+ break;
+ case TC_TITLELATEXNAME:
+ if (lexrc.next())
+ titlename_ = lexrc.getString();
+ break;
+ case TC_NOFLOAT:
+ if (lexrc.next()) {
+ string const nofloat = lexrc.getString();
+ floatlist_->erase(nofloat);
+ }
+ break;
}
}
}
+void LyXTextClass::readTitleType(LyXLex & lexrc)
+{
+ keyword_item titleTypeTags[] = {
+ { "commandafter", TITLE_COMMAND_AFTER },
+ { "environment", TITLE_ENVIRONMENT }
+ };
+
+ pushpophelper pph(lexrc, titleTypeTags, TITLE_ENVIRONMENT);
+
+ int le = lexrc.lex();
+ switch (le) {
+ case LyXLex::LEX_UNDEF:
+ lexrc.printError("Unknown output type `$$Token'");
+ return;
+ case TITLE_COMMAND_AFTER:
+ case TITLE_ENVIRONMENT:
+ titletype_ = static_cast<LYX_TITLE_LATEX_TYPES>(le);
+ break;
+ default:
+ lyxerr << "Unhandled value " << le
+ << " in LyXTextClass::readTitleType." << endl;
+
+ break;
+ }
+}
+
+
void LyXTextClass::readOutputType(LyXLex & lexrc)
{
keyword_item outputTypeTags[] = {
};
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;
+ default:
+ break;
}
+
switch (static_cast<MaxCounterTags>(le)) {
case MC_COUNTER_CHAPTER:
maxcounter_ = LABEL_COUNTER_CHAPTER;
if (getout) {
Floating newfloat(type, placement, ext, within,
style, name, listname, builtin);
- floatlist_.newFloat(newfloat);
+ floatlist_->newFloat(newfloat);
+ }
+
+ lexrc.popTable();
+}
+
+
+enum CounterTags {
+ CT_NAME = 1,
+ CT_WITHIN,
+ CT_END
+};
+
+void LyXTextClass::readCounter(LyXLex & lexrc)
+{
+ keyword_item counterTags[] = {
+ { "end", CT_END },
+ { "name", CT_NAME },
+ { "within", CT_WITHIN }
+ };
+
+ lexrc.pushTable(counterTags, CT_END);
+
+ string name;
+ string within;
+
+ 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<CounterTags>(le)) {
+ case CT_NAME:
+ lexrc.next();
+ name = lexrc.getString();
+ break;
+ case CT_WITHIN:
+ lexrc.next();
+ within = lexrc.getString();
+ if (within == "none")
+ within.erase();
+ break;
+ case CT_END:
+ getout = true;
+ break;
+ }
+ }
+
+ // Here if have a full float if getout == true
+ if (getout) {
+ if (within.empty()) {
+ ctrs_->newCounter(name);
+ } else {
+ ctrs_->newCounter(name, within);
+ }
}
lexrc.popTable();
}
-LyXLayout_ptr const & LyXTextClass::operator[](string const & n) const
-{
- lyx::Assert(!n.empty());
-
- if (n.empty())
- lyxerr << "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
+{
+ Assert(!name.empty());
LayoutList::const_iterator cit =
find_if(layoutlist_.begin(),
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);
+ Assert(false);
}
- lastLayoutName = name;
- lastLayoutIndex = std::distance(layoutlist_.begin(), cit);
-
return (*cit);
}
+
bool LyXTextClass::delete_layout(string const & name)
{
if (name == defaultLayoutName())
FloatList & LyXTextClass::floats()
{
- return floatlist_;
+ return *floatlist_.get();
}
FloatList const & LyXTextClass::floats() const
{
- return floatlist_;
+ return *floatlist_.get();
}
-string const LyXTextClass::defaultLayoutName() const
+Counters & LyXTextClass::counters() const
+{
+ return *ctrs_.get();
+}
+
+
+string const & LyXTextClass::defaultLayoutName() const
{
// This really should come from the actual layout... (Lgb)
return defaultlayout_;
}
+LYX_TITLE_LATEX_TYPES LyXTextClass::titletype() const
+{
+ return titletype_;
+}
+
+
+string const & LyXTextClass::titlename() const
+{
+ return titlename_;
+}
+
+
+
+
+
int LyXTextClass::size() const
{
return layoutlist_.size();
{
switch (p) {
case LyXTextClass::OneSide:
- os << "1";
+ os << '1';
break;
case LyXTextClass::TwoSides:
- os << "2";
+ os << '2';
break;
}
return os;
projects / lyx.git / blobdiff