* LyX, The Document Processor
*
* Copyright 1995 Matthias Ettrich
- * Copyright 1995-1999 The LyX Team.
+ * Copyright 1995-2000 The LyX Team.
*
- * ====================================================== */
+ * ======================================================
+ */
#include <config.h>
#endif
#include <algorithm>
-using std::make_pair;
-using std::sort;
#include "layout.h"
#include "lyxlex.h"
#include "debug.h"
#include "gettext.h"
#include "support/LAssert.h"
+#include "support/lyxfunctional.h"
+using std::pair;
+using std::make_pair;
+using std::sort;
+using std::endl;
+using std::find_if;
+using std::remove_if;
// Global variable: textclass table.
LyXTextClassList textclasslist;
LT_LABELSEP,
LT_LABELSTRING,
LT_LABELSTRING_APPENDIX,
- LT_LABELTYPE,
+ LT_LABELTYPE,
+ LT_ENDLABELSTRING,
+ LT_ENDLABELTYPE,
LT_LATEXNAME,
LT_LATEXPARAM,
LT_LATEXTYPE,
};
-// This table is sorted alphabetically [asierra 30March96]
-static keyword_item layoutTags[] = {
- { "align", LT_ALIGN },
- { "alignpossible", LT_ALIGNPOSSIBLE },
- { "bottomsep", LT_BOTTOMSEP },
- { "copystyle", LT_COPYSTYLE },
- { "end", LT_END },
- { "fill_bottom", LT_FILL_BOTTOM },
- { "fill_top", LT_FILL_TOP },
- { "font", LT_FONT },
- { "freespacing", LT_FREE_SPACING },
- { "intitle", LT_INTITLE },
- { "itemsep", LT_ITEMSEP },
- { "keepempty", LT_KEEPEMPTY },
- { "labelbottomsep", LT_LABEL_BOTTOMSEP },
- { "labelfont", LT_LABELFONT },
- { "labelindent", LT_LABELINDENT },
- { "labelsep", LT_LABELSEP },
- { "labelstring", LT_LABELSTRING },
- { "labelstringappendix", LT_LABELSTRING_APPENDIX },
- { "labeltype", LT_LABELTYPE },
- { "latexname", LT_LATEXNAME },
- { "latexparam", LT_LATEXPARAM },
- { "latextype", LT_LATEXTYPE },
- { "leftmargin", LT_LEFTMARGIN },
- { "margin", LT_MARGIN },
- { "needprotect", LT_NEED_PROTECT },
- { "newline", LT_NEWLINE },
- { "nextnoindent", LT_NEXTNOINDENT },
- { "obsoletedby", LT_OBSOLETEDBY },
- { "parindent", LT_PARINDENT },
- { "parsep", LT_PARSEP },
- { "parskip", LT_PARSKIP },
- { "preamble", LT_PREAMBLE },
- { "rightmargin", LT_RIGHTMARGIN },
- { "spacing", LT_SPACING },
- { "textfont", LT_TEXTFONT },
- { "topsep", LT_TOPSEP }
-};
-
-
/////////////////////
// Constructor for layout
align = LYX_ALIGN_BLOCK;
alignpossible = LYX_ALIGN_BLOCK;
labeltype = LABEL_NO_LABEL;
+ endlabeltype = END_LABEL_NO_LABEL;
// Should or should not. That is the question.
// spacing.set(Spacing::OneHalf);
fill_top = false;
// Reads a layout definition from file
bool LyXLayout::Read (LyXLex & lexrc, LyXTextClass const & tclass)
{
+ // This table is sorted alphabetically [asierra 30March96]
+ keyword_item layoutTags[] = {
+ { "align", LT_ALIGN },
+ { "alignpossible", LT_ALIGNPOSSIBLE },
+ { "bottomsep", LT_BOTTOMSEP },
+ { "copystyle", LT_COPYSTYLE },
+ { "end", LT_END },
+ { "endlabelstring", LT_ENDLABELSTRING },
+ { "endlabeltype", LT_ENDLABELTYPE },
+ { "fill_bottom", LT_FILL_BOTTOM },
+ { "fill_top", LT_FILL_TOP },
+ { "font", LT_FONT },
+ { "freespacing", LT_FREE_SPACING },
+ { "intitle", LT_INTITLE },
+ { "itemsep", LT_ITEMSEP },
+ { "keepempty", LT_KEEPEMPTY },
+ { "labelbottomsep", LT_LABEL_BOTTOMSEP },
+ { "labelfont", LT_LABELFONT },
+ { "labelindent", LT_LABELINDENT },
+ { "labelsep", LT_LABELSEP },
+ { "labelstring", LT_LABELSTRING },
+ { "labelstringappendix", LT_LABELSTRING_APPENDIX },
+ { "labeltype", LT_LABELTYPE },
+ { "latexname", LT_LATEXNAME },
+ { "latexparam", LT_LATEXPARAM },
+ { "latextype", LT_LATEXTYPE },
+ { "leftmargin", LT_LEFTMARGIN },
+ { "margin", LT_MARGIN },
+ { "needprotect", LT_NEED_PROTECT },
+ { "newline", LT_NEWLINE },
+ { "nextnoindent", LT_NEXTNOINDENT },
+ { "obsoletedby", LT_OBSOLETEDBY },
+ { "parindent", LT_PARINDENT },
+ { "parsep", LT_PARSEP },
+ { "parskip", LT_PARSKIP },
+ { "preamble", LT_PREAMBLE },
+ { "rightmargin", LT_RIGHTMARGIN },
+ { "spacing", LT_SPACING },
+ { "textfont", LT_TEXTFONT },
+ { "topsep", LT_TOPSEP }
+ };
+
bool error = false;
bool finished = false;
lexrc.pushTable(layoutTags, LT_INTITLE);
while (!finished && lexrc.IsOK() && !error) {
int le = lexrc.lex();
// See comment in lyxrc.C.
- switch(le) {
+ switch (le) {
case LyXLex::LEX_FEOF:
continue;
continue;
default: break;
}
- switch(static_cast<LayoutTags>(le)) {
+ switch (static_cast<LayoutTags>(le)) {
case LT_END: // end of structure
finished = true;
break;
case LT_LABELTYPE:
readLabelType(lexrc);
break;
+
+ case LT_ENDLABELTYPE:
+ readEndLabelType(lexrc);
+ break;
case LT_LEFTMARGIN: // left margin type
if (lexrc.next())
labelstring_ = lexrc.GetString();
break;
+ case LT_ENDLABELSTRING: // endlabel string definition
+ if (lexrc.next())
+ endlabelstring_ = lexrc.GetString();
+ break;
+
case LT_LABELSTRING_APPENDIX: // label string appendix definition
if (lexrc.next())
labelstring_appendix_ = lexrc.GetString();
};
-static keyword_item alignTags[] = {
- { "block", AT_BLOCK },
- { "center", AT_CENTER },
- { "layout", AT_LAYOUT },
- { "left", AT_LEFT },
- { "right", AT_RIGHT }
-};
-
-
void LyXLayout::readAlign(LyXLex & lexrc)
{
+ keyword_item alignTags[] = {
+ { "block", AT_BLOCK },
+ { "center", AT_CENTER },
+ { "layout", AT_LAYOUT },
+ { "left", AT_LEFT },
+ { "right", AT_RIGHT }
+ };
+
pushpophelper pph(lexrc, alignTags, AT_LAYOUT);
int le = lexrc.lex();
switch (le) {
case LyXLex::LEX_UNDEF:
lexrc.printError("Unknown alignment `$$Token'");
- return; break;
+ return;
default: break;
};
- switch(static_cast<AlignTags>(le)) {
+ switch
(static_cast<AlignTags>(le)) {
case AT_BLOCK:
align = LYX_ALIGN_BLOCK;
break;
void LyXLayout::readAlignPossible(LyXLex & lexrc)
{
+ keyword_item alignTags[] = {
+ { "block", AT_BLOCK },
+ { "center", AT_CENTER },
+ { "layout", AT_LAYOUT },
+ { "left", AT_LEFT },
+ { "right", AT_RIGHT }
+ };
+
lexrc.pushTable(alignTags, AT_LAYOUT);
alignpossible = LYX_ALIGN_NONE;
int lineno = lexrc.GetLineNo();
};
-static keyword_item labelTypeTags[] = {
+void LyXLayout::readLabelType(LyXLex & lexrc)
+{
+ keyword_item labelTypeTags[] = {
{ "bibliography", LA_BIBLIO },
{ "centered_top_environment", LA_CENTERED_TOP_ENVIRONMENT },
{ "counter_chapter", LA_COUNTER_CHAPTER },
{ "top_environment", LA_TOP_ENVIRONMENT }
};
-
-void LyXLayout::readLabelType(LyXLex & lexrc)
-{
pushpophelper pph(lexrc, labelTypeTags, LA_BIBLIO);
int le = lexrc.lex();
switch (le) {
case LyXLex::LEX_UNDEF:
lexrc.printError("Unknown labeltype tag `$$Token'");
- return; break;
+ return;
default: break;
}
switch (static_cast<LabelTypeTags>(le)) {
}
-enum MarginTags {
- MT_STATIC = 1,
- MT_MANUAL,
- MT_DYNAMIC,
- MT_FIRST_DYNAMIC,
- MT_RIGHT_ADDRESS_BOX
-};
+namespace {
-
-static keyword_item marginTags[] = {
- { "dynamic", MT_DYNAMIC },
- { "first_dynamic", MT_FIRST_DYNAMIC },
- { "manual", MT_MANUAL },
- { "right_address_box", MT_RIGHT_ADDRESS_BOX },
- { "static", MT_STATIC }
+keyword_item endlabelTypeTags[] = {
+ { "box", END_LABEL_BOX },
+ { "filled_box", END_LABEL_FILLED_BOX },
+ { "no_label", END_LABEL_NO_LABEL },
+ { "static", END_LABEL_STATIC }
};
+} // namespace anon
-void LyXLayout::readMargin(LyXLex & lexrc)
+
+void LyXLayout::readEndLabelType(LyXLex & lexrc)
{
- pushpophelper pph(lexrc, marginTags, MT_RIGHT_ADDRESS_BOX);
+ pushpophelper pph(lexrc, endlabelTypeTags,
+ END_LABEL_ENUM_LAST-END_LABEL_ENUM_FIRST+1);
int le = lexrc.lex();
- switch(le) {
+ switch (le) {
case LyXLex::LEX_UNDEF:
- lexrc.printError("Unknown margin type tag `$$Token'");
- return; break;
- default: break;
- }
- switch(static_cast<MarginTags>(le)) {
- case MT_STATIC:
- margintype = MARGIN_STATIC;
- break;
- case MT_MANUAL:
- margintype = MARGIN_MANUAL;
- break;
- case MT_DYNAMIC:
- margintype = MARGIN_DYNAMIC;
+ lexrc.printError("Unknown labeltype tag `$$Token'");
break;
- case MT_FIRST_DYNAMIC:
- margintype = MARGIN_FIRST_DYNAMIC;
+ case END_LABEL_STATIC:
+ case END_LABEL_BOX:
+ case END_LABEL_FILLED_BOX:
+ case END_LABEL_NO_LABEL:
+ endlabeltype = static_cast<LYX_END_LABEL_TYPES>(le);
break;
- case MT_RIGHT_ADDRESS_BOX:
- margintype = MARGIN_RIGHT_ADDRESS_BOX;
+ default:
+ lyxerr << "Unhandled value " << le
+ << " in LyXLayout::readEndLabelType." << endl;
break;
}
}
-enum LatexTypeTags {
- LX_PARAGRAPH = 1,
- LX_COMMAND,
- LX_ENVIRONMENT,
- LX_ITEM_ENVIRONMENT,
- LX_LIST_ENVIRONMENT
-};
+void LyXLayout::readMargin(LyXLex & lexrc)
+{
+ keyword_item marginTags[] = {
+ { "dynamic", MARGIN_DYNAMIC },
+ { "first_dynamic", MARGIN_FIRST_DYNAMIC },
+ { "manual", MARGIN_MANUAL },
+ { "right_address_box", MARGIN_RIGHT_ADDRESS_BOX },
+ { "static", MARGIN_STATIC }
+ };
+ pushpophelper pph(lexrc, marginTags, MARGIN_RIGHT_ADDRESS_BOX);
-static keyword_item latexTypeTags[] = {
- { "command", LX_COMMAND },
- { "environment", LX_ENVIRONMENT },
- { "item_environment", LX_ITEM_ENVIRONMENT },
- { "list_environment", LX_LIST_ENVIRONMENT },
- { "paragraph", LX_PARAGRAPH }
-};
+ int le = lexrc.lex();
+ switch (le) {
+ case LyXLex::LEX_UNDEF:
+ lexrc.printError("Unknown margin type tag `$$Token'");
+ return;
+ case MARGIN_STATIC:
+ case MARGIN_MANUAL:
+ case MARGIN_DYNAMIC:
+ case MARGIN_FIRST_DYNAMIC:
+ case MARGIN_RIGHT_ADDRESS_BOX:
+ margintype = static_cast<LYX_MARGIN_TYPE>(le);
+ break;
+ default:
+ lyxerr << "Unhandled value " << le
+ << " in LyXLayout::readMargin." << endl;
+ break;
+ }
+}
void LyXLayout::readLatexType(LyXLex & lexrc)
{
- pushpophelper pph(lexrc, latexTypeTags, LX_LIST_ENVIRONMENT);
+ keyword_item latexTypeTags[] = {
+ { "command", LATEX_COMMAND },
+ { "environment", LATEX_ENVIRONMENT },
+ { "item_environment", LATEX_ITEM_ENVIRONMENT },
+ { "list_environment", LATEX_LIST_ENVIRONMENT },
+ { "paragraph", LATEX_PARAGRAPH }
+ };
+
+ pushpophelper pph(lexrc, latexTypeTags, LATEX_LIST_ENVIRONMENT);
int le = lexrc.lex();
switch (le) {
case LyXLex::LEX_UNDEF:
lexrc.printError("Unknown latextype tag `$$Token'");
- return; break;
- default: break;
- }
- switch (static_cast<LatexTypeTags>(le)) {
- case LX_PARAGRAPH:
- latextype= LATEX_PARAGRAPH;
- break;
- case LX_COMMAND:
- latextype= LATEX_COMMAND;
- break;
- case LX_ENVIRONMENT:
- latextype= LATEX_ENVIRONMENT;
- break;
- case LX_ITEM_ENVIRONMENT:
- latextype= LATEX_ITEM_ENVIRONMENT;
+ return;
+ case LATEX_PARAGRAPH:
+ case LATEX_COMMAND:
+ case LATEX_ENVIRONMENT:
+ case LATEX_ITEM_ENVIRONMENT:
+ case LATEX_LIST_ENVIRONMENT:
+ latextype = static_cast<LYX_LATEX_TYPES>(le);
break;
- case LX_LIST_ENVIRONMENT:
- latextype= LATEX_LIST_ENVIRONMENT;
+ default:
+ lyxerr << "Unhandled value " << le
+ << " in LyXLayout::readLatexType." << endl;
break;
}
}
};
-static keyword_item spacingTags[] = {
- {"double", ST_SPACING_DOUBLE },
- {"onehalf", ST_SPACING_ONEHALF },
- {"other", ST_OTHER },
- {"single", ST_SPACING_SINGLE }
-};
-
-
void LyXLayout::readSpacing(LyXLex & lexrc)
{
+ keyword_item spacingTags[] = {
+ {"double", ST_SPACING_DOUBLE },
+ {"onehalf", ST_SPACING_ONEHALF },
+ {"other", ST_OTHER },
+ {"single", ST_SPACING_SINGLE }
+ };
+
pushpophelper pph(lexrc, spacingTags, ST_OTHER);
int le = lexrc.lex();
- switch(le) {
+ switch (le) {
case LyXLex::LEX_UNDEF:
lexrc.printError("Unknown spacing token `$$Token'");
- return; break;
+ return;
default: break;
}
- switch(static_cast<SpacingTags>(le)) {
+ switch (static_cast<SpacingTags>(le)) {
case ST_SPACING_SINGLE:
spacing.set(Spacing::Single);
break;
};
-static keyword_item textClassTags[] = {
- { "classoptions", TC_CLASSOPTIONS },
- { "columns", TC_COLUMNS },
- { "defaultfont", TC_DEFAULTFONT },
- { "input", TC_INPUT },
- { "leftmargin", TC_LEFTMARGIN },
- { "maxcounter", TC_MAXCOUNTER },
- { "nostyle", TC_NOSTYLE },
- { "outputtype", TC_OUTPUTTYPE },
- { "pagestyle", TC_PAGESTYLE },
- { "preamble", TC_PREAMBLE },
- { "providesamsmath", TC_PROVIDESAMSMATH },
- { "providesmakeidx", TC_PROVIDESMAKEIDX },
- { "providesurl", TC_PROVIDESURL },
- { "rightmargin", TC_RIGHTMARGIN },
- { "secnumdepth", TC_SECNUMDEPTH },
- { "sides", TC_SIDES },
- { "style", TC_STYLE },
- { "tocdepth", TC_TOCDEPTH }
-};
-
-
// Reads a textclass structure from file.
bool LyXTextClass::Read(string const & filename, bool merge)
{
+ keyword_item textClassTags[] = {
+ { "classoptions", TC_CLASSOPTIONS },
+ { "columns", TC_COLUMNS },
+ { "defaultfont", TC_DEFAULTFONT },
+ { "input", TC_INPUT },
+ { "leftmargin", TC_LEFTMARGIN },
+ { "maxcounter", TC_MAXCOUNTER },
+ { "nostyle", TC_NOSTYLE },
+ { "outputtype", TC_OUTPUTTYPE },
+ { "pagestyle", TC_PAGESTYLE },
+ { "preamble", TC_PREAMBLE },
+ { "providesamsmath", TC_PROVIDESAMSMATH },
+ { "providesmakeidx", TC_PROVIDESMAKEIDX },
+ { "providesurl", TC_PROVIDESURL },
+ { "rightmargin", TC_RIGHTMARGIN },
+ { "secnumdepth", TC_SECNUMDEPTH },
+ { "sides", TC_SIDES },
+ { "style", TC_STYLE },
+ { "tocdepth", TC_TOCDEPTH }
+ };
+
if (!merge)
lyxerr[Debug::TCLASS] << "Reading textclass "
<< MakeDisplayPath(filename)
// parsing
while (lexrc.IsOK() && !error) {
int le = lexrc.lex();
- switch(le) {
+ switch (le) {
case LyXLex::LEX_FEOF:
continue;
continue;
default: break;
}
- switch(static_cast<TextClassTags>(le)) {
+ switch (static_cast<TextClassTags>(le)) {
case TC_OUTPUTTYPE: // output type definition
readOutputType(lexrc);
break;
error = do_readStyle(lexrc, lay);
} else {
LyXLayout lay;
- lay.name(name);
+ lay.setName(name);
if (!(error = do_readStyle(lexrc, lay)))
layoutlist.push_back(lay);
}
case TC_SIDES:
if (lexrc.next()) {
- switch(lexrc.GetInteger()) {
+ switch (lexrc.GetInteger()) {
case 1: sides_ = OneSide; break;
case 2: sides_ = TwoSides; break;
default:
if (!defaultfont_.resolved()) {
lexrc.printError("Warning: defaultfont should "
"be fully instantiated!");
- defaultfont_.realize(LyXFont::ALL_SANE);
+ defaultfont_.realize(LyXFont(LyXFont::ALL_SANE));
}
break;
}
-enum OutputTypeTags {
- OT_OTLATEX = 1,
- OT_OTLINUXDOC,
- OT_OTDOCBOOK,
- OT_OTLITERATE
-};
-
-
-static keyword_item outputTypeTags[] = {
- { "docbook", OT_OTDOCBOOK },
- { "latex", OT_OTLATEX },
- { "linuxdoc", OT_OTLINUXDOC },
- { "literate", OT_OTLITERATE }
-};
-
-
void LyXTextClass::readOutputType(LyXLex & lexrc)
{
- pushpophelper pph(lexrc, outputTypeTags, OT_OTLITERATE);
+ keyword_item outputTypeTags[] = {
+ { "docbook", DOCBOOK },
+ { "latex", LATEX },
+ { "linuxdoc", LINUXDOC },
+ { "literate", LITERATE }
+ };
+
+ pushpophelper pph(lexrc, outputTypeTags, LITERATE);
+
int le = lexrc.lex();
- switch(le) {
+ switch (le) {
case LyXLex::LEX_UNDEF:
lexrc.printError("Unknown output type `$$Token'");
- return; break;
- default: break;
- }
- switch(static_cast<OutputTypeTags>(le)) {
- case OT_OTLATEX:
- outputType_ = LATEX;
- break;
- case OT_OTLINUXDOC:
- outputType_ = LINUXDOC;
- break;
- case OT_OTDOCBOOK:
- outputType_ = DOCBOOK;
+ return;
+ case LATEX:
+ case LINUXDOC:
+ case DOCBOOK:
+ case LITERATE:
+ outputType_ = static_cast<OutputType>(le);
break;
- case OT_OTLITERATE:
- outputType_ = LITERATE;
+ default:
+ lyxerr << "Unhandled value " << le
+ << " in LyXTextClass::readOutputType." << endl;
+
break;
}
}
};
-static 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 }
-};
-
-
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) {
+ switch (le) {
case LyXLex::LEX_UNDEF:
lexrc.printError("Unknown MaxCounter tag `$$Token'");
- return; break;
+ return;
default: break;
}
switch (static_cast<MaxCounterTags>(le)) {
};
-static keyword_item classOptionsTags[] = {
- {"end", CO_END },
- {"fontsize", CO_FONTSIZE },
- {"other", CO_OTHER },
- {"pagestyle", CO_PAGESTYLE }
-};
-
-
void LyXTextClass::readClassOptions(LyXLex & lexrc)
{
+ keyword_item classOptionsTags[] = {
+ {"end", CO_END },
+ {"fontsize", CO_FONTSIZE },
+ {"other", CO_OTHER },
+ {"pagestyle", CO_PAGESTYLE }
+ };
+
lexrc.pushTable(classOptionsTags, CO_END);
bool getout = false;
while (!getout && lexrc.IsOK()) {
bool LyXTextClass::hasLayout(string const & name) const
{
- for (LayoutList::const_iterator cit = layoutlist.begin();
- cit != layoutlist.end(); ++cit) {
- if ((*cit).name() == name)
- return true;
- }
- return false;
+ return find_if(layoutlist.begin(), layoutlist.end(),
+ compare_memfun(&LyXLayout::name, name))
+ != layoutlist.end();
}
LyXLayout const & LyXTextClass::GetLayout (string const & name) const
{
- for (LayoutList::const_iterator cit = layoutlist.begin();
- cit != layoutlist.end(); ++cit) {
- if ((*cit).name() == name)
- return (*cit);
- }
- Assert(false); // we actually require the name to exist.
- return layoutlist.front();
+ LayoutList::const_iterator cit =
+ find_if(layoutlist.begin(),
+ layoutlist.end(),
+ compare_memfun(&LyXLayout::name, name));
+ Assert(cit != layoutlist.end()); // we require the name to exist
+ return (*cit);
}
LyXLayout & LyXTextClass::GetLayout(string const & name)
{
- for (LayoutList::iterator it = layoutlist.begin();
- it != layoutlist.end(); ++it) {
- if ((*it).name() == name)
- return (*it);
- }
- Assert(false); // we actually require the name to exist.
- return layoutlist.front();
+ LayoutList::iterator it =
+ find_if(layoutlist.begin(),
+ layoutlist.end(),
+ compare_memfun(&LyXLayout::name, name));
+ Assert(it != layoutlist.end()); // we require the name to exist
+ return (*it);
}
-bool LyXTextClass::delete_layout (string const & name)
+bool LyXTextClass::delete_layout(string const & name)
{
- for(LayoutList::iterator it = layoutlist.begin();
- it != layoutlist.end(); ++it) {
- if ((*it).name() == name) {
- layoutlist.erase(it);
- return true;
- }
- }
- return false;
+ LayoutList::iterator it =
+ remove_if(layoutlist.begin(), layoutlist.end(),
+ compare_memfun(&LyXLayout::name, name));
+ LayoutList::iterator end = layoutlist.end();
+ bool const ret = (it != end);
+ layoutlist.erase(it, end);
+ return ret;
}
if (loaded) return;
// Read style-file
- string real_file = LibFileSearch("layouts", name_, "layout");
+ string const real_file = LibFileSearch("layouts", name_, "layout");
if (Read(real_file)) {
lyxerr << "Error reading `"
//////////////////////////////////////////
// Gets textclass number from name
-pair<bool, LyXTextClassList::ClassList::size_type>
+pair<bool, LyXTextClassList::size_type> const
LyXTextClassList::NumberOfClass(string const & textclass) const
{
- for (ClassList::const_iterator cit = classlist.begin();
- cit != classlist.end(); ++cit) {
- if ((*cit).name() == textclass)
- return make_pair(true, cit - classlist.begin());
- }
- return make_pair(false, 0);
+ ClassList::const_iterator cit =
+ find_if(classlist.begin(), classlist.end(),
+ compare_memfun(&LyXTextClass::name, textclass));
+ return cit != classlist.end() ?
+ make_pair(true, size_type(cit - classlist.begin())) :
+ make_pair(false, size_type(0));
}
// Gets layout structure from style number and textclass number
LyXLayout const &
-LyXTextClassList::Style(LyXTextClassList::ClassList::size_type textclass,
- LyXTextClass::LayoutList::size_type layout) const
+LyXTextClassList::Style(LyXTextClassList::size_type textclass,
+ LyXTextClass::size_type layout) const
{
classlist[textclass].load();
if (layout < classlist[textclass].numLayouts())
// Gets layout number from name and textclass number
-pair<bool, LyXTextClass::LayoutList::size_type>
-LyXTextClassList::NumberOfLayout(LyXTextClassList::ClassList::size_type textclass, string const & name) const
+pair<bool, LyXTextClass::size_type> const
+LyXTextClassList::NumberOfLayout(LyXTextClassList::size_type textclass,
+ string const & name) const
{
classlist[textclass].load();
- for(unsigned int i = 0; i < classlist[textclass].numLayouts(); ++i) {
+ for (unsigned int i = 0; i < classlist[textclass].numLayouts(); ++i) {
if (classlist[textclass][i].name() == name)
return make_pair(true, i);
}
if (name == "dummy")
- return make_pair(true, LYX_DUMMY_LAYOUT);
- return make_pair(false, 0); // not found
+ return make_pair(true, LyXTextClassList::size_type(LYX_DUMMY_LAYOUT));
+ return make_pair(false, LyXTextClass::size_type(0)); // not found
}
// Gets a layout (style) name from layout number and textclass number
string const &
-LyXTextClassList::NameOfLayout(LyXTextClassList::ClassList::size_type textclass,
- LyXTextClass::LayoutList::size_type layout) const
+LyXTextClassList::NameOfLayout(LyXTextClassList::size_type textclass,
+ LyXTextClass::size_type layout) const
{
static string dummy("dummy");
- static string end("@@end@@");
classlist[textclass].load();
if (layout < classlist[textclass].numLayouts())
return classlist[textclass][layout].name();
- else if (layout == LYX_DUMMY_LAYOUT)
- return dummy;
- else
- return end;
+ return dummy;
}
// Gets a textclass name from number
string const &
-LyXTextClassList::NameOfClass(LyXTextClassList::ClassList::size_type number) const
+LyXTextClassList::NameOfClass(LyXTextClassList::size_type number) const
{
static string dummy("dummy");
- static string end("@@end@@");
if (classlist.size() == 0) {
- if (number == 0) return dummy;
- else return end;
+ return dummy;
}
- if (number < classlist.size())
- return classlist[number].name();
- else
- return end;
+ Assert(number < classlist.size());
+ return classlist[number].name();
}
// Gets a textclass latexname from number
string const &
-LyXTextClassList::LatexnameOfClass(LyXTextClassList::ClassList::size_type number) const
+LyXTextClassList::LatexnameOfClass(LyXTextClassList::size_type number) const
{
static string dummy("dummy");
- static string end("@@end@@");
classlist[number].load();
if (classlist.size() == 0) {
- if (number == 0) return dummy;
- else return end;
+ return dummy;
}
- if (number < classlist.size())
- return classlist[number].latexname();
- else
- return end;
+ Assert(number < classlist.size());
+ return classlist[number].latexname();
}
// Gets a textclass description from number
string const &
-LyXTextClassList::DescOfClass(LyXTextClassList::ClassList::size_type number) const
+LyXTextClassList::DescOfClass(LyXTextClassList::size_type number) const
{
static string dummy("dummy");
- static string end("@@end@@");
if (classlist.size() == 0) {
- if (number == 0) return dummy;
- else return end;
+ return dummy;
}
- if (number < classlist.size())
- return classlist[number].description();
- else
- return end;
+ Assert(number < classlist.size());
+ return classlist[number].description();
}
// Gets a textclass structure from number
LyXTextClass const &
-LyXTextClassList::TextClass(LyXTextClassList::ClassList::size_type textclass) const
+LyXTextClassList::TextClass(LyXTextClassList::size_type textclass) const
{
classlist[textclass].load();
if (textclass < classlist.size())
{
LyXLex lex(0, 0);
string real_file = LibFileSearch("", "textclass.lst");
- lyxerr[Debug::TCLASS] << "Reading textclasses from "
- << real_file << endl;
+ lyxerr[Debug::TCLASS] << "Reading textclasses from `"
+ << real_file << "'" << endl;
if (real_file.empty()) {
lyxerr << "LyXTextClassList::Read: unable to find "
// This causes LyX to end... Not a desirable behaviour. Lgb
// What do you propose? That the user gets a file dialog
// and is allowed to hunt for the file? (Asger)
+ // more that we have a layout for minimal.cls statically
+ // compiled in... (Lgb)
}
- lex.setFile(real_file);
+ if (!lex.setFile(real_file)) {
+ lyxerr << "LyXTextClassList::Read: "
+ "lyxlex was not able to set file: "
+ << real_file << endl;
+ }
if (!lex.IsOK()) {
lyxerr << "LyXTextClassList::Read: unable to open "
bool finished = false;
string fname, clname, desc;
// Parse config-file
+ lyxerr[Debug::TCLASS] << "Starting parsing of textclass.lst" << endl;
while (lex.IsOK() && !finished) {
+ lyxerr[Debug::TCLASS] << "\tline by line" << endl;
switch (lex.lex()) {
case LyXLex::LEX_FEOF:
finished = true;
}
}
}
-
+ lyxerr[Debug::TCLASS] << "End of parsing of textclass.lst" << endl;
+
if (classlist.size() == 0) {
- lyxerr << "LyXTextClassList::Read: no textclass found!"
+ lyxerr << "LyXTextClassList::Read: no textclasses found!"
<< endl;
WriteAlert(_("LyX wasn't able to find any layout description!"),
_("Check the contents of the file \"textclass.lst\""),
Returns false if this fails
*/
bool
-LyXTextClassList::Load (LyXTextClassList::ClassList::size_type number) const
+LyXTextClassList::Load (LyXTextClassList::size_type number) const
{
bool result = true;
if (number < classlist.size()) {
}
return result;
}
+
+
+std::ostream & operator<<(std::ostream & os, LyXTextClass::PageSides p)
+{
+ switch (p) {
+ case LyXTextClass::OneSide:
+ os << "1";
+ break;
+ case LyXTextClass::TwoSides:
+ os << "2";
+ break;
+ }
+ return os;
+}
+
projects / lyx.git / blobdiff