#include <boost/noncopyable.hpp>
-#include <list>
#include <map>
#include <set>
#include <vector>
+#include <list>
namespace lyx {
/// Simple TextClass objects are not directly constructed in the main
/// LyX code---the constructor is protected. (That said, in tex2lyx
/// there are what amount to simple TextClass objects.)
+///
+/// A LayoutFile (see LayoutFile.{h,cpp}) represents a *.layout file.
+/// These are generally static objects---though they can be reloaded
+/// from disk via LFUN_LAYOUT_RELOAD, so one should not assume that
+/// they will never change.
+///
+/// A DocumentClass (see below) represents the layout information that
+/// is associated with a given Buffer. These are static, in the sense
+/// that they will not themselves change, but which DocumentClass is
+/// associated with a Buffer can change, as modules are loaded and
+/// unloaded, for example.
+///
class TextClass : protected ProtectCopy {
public:
///
// that was based upon the same DocumentClass. (Of course, if you
// really, REALLY want to make LayoutList a vector<Layout *>, then
// you can implement custom assignment and copy constructors.)
- typedef std::vector<Layout> LayoutList;
+ //
+ // NOTE: Layout pointers are directly assigned to paragraphs so a
+ // container that does not invalidate these pointers after insertion
+ // is needed.
+ typedef std::list<Layout> LayoutList;
/// The inset layouts available to this class
typedef std::map<docstring, InsetLayout> InsetLayouts;
///
///
bool isDefaultLayout(Layout const &) const;
///
- bool isEmptyLayout(Layout const &) const;
+ bool isPlainLayout(Layout const &) const;
/// returns a special layout for use when we don't really want one,
/// e.g., in table cells
- Layout const & emptyLayout() const
+ Layout const & plainLayout() const
{ return operator[](emptylayout_); };
- /// the name of the empty layout
- docstring const & emptyLayoutName() const
+ /// the name of the plain layout
+ docstring const & plainLayoutName() const
{ return emptylayout_; }
/// Enumerate the paragraph styles.
size_t layoutCount() const { return layoutlist_.size(); }
bool hasLayout(docstring const & name) const;
///
Layout const & operator[](docstring const & vname) const;
+ /// Inset layouts of this doc class
+ InsetLayouts const & insetLayouts() const { return insetlayoutlist_; };
///////////////////////////////////////////////////////////////////
// reading routines
enum ReadType {
BASECLASS, //>This is a base class, i.e., top-level layout file
MERGE, //>This is a file included in a layout file
- MODULE //>This is a layout module
+ MODULE, //>This is a layout module
+ VALIDATION //>We're just validating
};
+ /// return values for read()
+ enum ReturnValues {
+ OK,
+ ERROR,
+ FORMAT_MISMATCH
+ };
+
/// Performs the read of the layout file.
/// \return true on success.
bool read(support::FileName const & filename, ReadType rt = BASECLASS);
+ ///
+ bool read(std::string const & str, ReadType rt = BASECLASS);
+ ///
+ ReturnValues read(Lexer & lex, ReadType rt = BASECLASS);
+ /// validates the layout information passed in str
+ static bool validate(std::string const & str);
///////////////////////////////////////////////////////////////////
// loading
///////////////////////////////////////////////////////////////////
/// Sees to it the textclass structure has been loaded
+ /// This function will search for $classname.layout in default directories
+ /// and an optional path, but if path points to a file, it will be loaded
+ /// directly.
bool load(std::string const & path = std::string()) const;
/// Has this layout file been loaded yet?
/// Overridden by DocumentClass
TextClass();
///
Layout & operator[](docstring const & vname);
-
+ /// Create an new, empty layout for this textclass.
+ /** \param unknown Set to true if this layout is an empty layout used to
+ * represent an unknown layout
+ */
+ Layout createEmptyLayout(docstring const & name, bool unknown = false) const;
+
///////////////////////////////////////////////////////////////////
// non-const iterators
///////////////////////////////////////////////////////////////////
// members
///////////////////////////////////////////////////////////////////
/// Paragraph styles used in this layout
- LayoutList layoutlist_;
+ /// This variable is mutable because unknown layouts can be added
+ /// to const textclass.
+ mutable LayoutList layoutlist_;
/// Layout file name
std::string name_;
/// document class name
std::string class_header_;
///
docstring defaultlayout_;
- /// name of empty layout
+ /// name of plain layout
static const docstring emptylayout_;
/// preamble text to support layout styles
docstring preamble_;
std::set<std::string> provides_;
/// latex packages requested by document class.
std::set<std::string> requires_;
+ /// modules wanted by document class
+ std::set<std::string> usemod_;
///
unsigned int columns_;
///
///////////////////////////////////////////////////////////////////
///
bool deleteLayout(docstring const &);
+ ///
+ bool convertLayoutFormat(support::FileName const &, ReadType);
/// \return true for success.
- bool readStyle(Lexer &, Layout &);
+ bool readStyle(Lexer &, Layout &) const;
///
void readOutputType(Lexer &);
///
/// A DocumentClass represents the layout information associated with a
/// Buffer. It is based upon a LayoutFile, but may be modified by loading
-/// various Modules. It is thus a dynamic object, as opposed to LayoutFile's
-/// which are pretty much static.
-///
+/// various Modules.
+///
+/// In that regard, DocumentClass objects are "dynamic". But this is really
+/// an illusion, since DocumentClass objects are not (currently) changed
+/// when, say, a new Module is loaded. Rather, the old DocumentClass is
+/// discarded---actually, it's kept around in case something on the cut
+/// stack needs it---and a new one is created from scratch.
+///
/// In the main LyX code, DocumentClass objects are created only by
/// DocumentClassBundle, for which see below.
+///
class DocumentClass : public TextClass, boost::noncopyable {
public:
///
bool hasLaTeXLayout(std::string const & lay) const;
/// A DocumentClass nevers count as loaded, since it is dynamic
virtual bool loaded() { return false; }
- /// Inset layouts of this doc class
- InsetLayouts const & insetLayouts() const { return insetlayoutlist_; };
/// \return the layout object of an inset given by name. If the name
/// is not found as such, the part after the ':' is stripped off, and
/// searched again. In this way, an error fallback can be provided:
/// If that doesn't work either, an empty object returns (shouldn't
/// happen). -- Idea JMarc, comment MV
InsetLayout const & insetLayout(docstring const & name) const;
- /// an empty inset layout for use as a default
- static InsetLayout const & emptyInsetLayout() { return empty_insetlayout_; }
+ /// a plain inset layout for use as a default
+ static InsetLayout const & plainInsetLayout() { return empty_insetlayout_; }
+ /// add a new, empty layout \c name if it does not exist in layoutlist_
+ void addLayoutIfNeeded(docstring const & name) const;
///////////////////////////////////////////////////////////////////
// accessors
/// Constructs a DocumentClass based upon a LayoutFile.
DocumentClass(LayoutFile const & tc);
/// Needed in tex2lyx
- DocumentClass() {};
+ DocumentClass() {}
private:
/// The only class that can create a DocumentClass is
/// DocumentClassBundle, which calls the protected constructor.
private:
/// control instantiation
DocumentClassBundle() {}
+ /// clean up
+ ~DocumentClassBundle();
///
- std::list<DocumentClass *> tc_list_;
+ std::vector<DocumentClass *> documentClasses_;
};
projects / lyx.git / blobdiff