Element.h

# ifndef Conjecture_Element_h
# define Conjecture_Element_h Conjecture_Element_h

// Insert SVN header substitution variable here
// Class Champion: wade

// C++ Dependencies
# include "Root.h"        // parent
# include <list>          // field 'parts'
# include <vector>        // method 'allGlyphs'
# include <iostream>      // cerr
# include "Coord.h"       // Coord
# include "ImageArgs.h"

// Declaration
namespace Conjecture {
    // Forward declarations
    class Page;
    class Region;
    class Line;
    class Word;
    class Glyph;
    class Image;
    
    // Types of Elements
    typedef enum ElementType {
        ELEMENT_PAGE,
        ELEMENT_REGION,
        ELEMENT_LINE,
        ELEMENT_WORD,
        ELEMENT_GLYPH
    };
    
    class Element : public Root {
      public:
        // Types
        typedef std::list<Element*> ElementList;
        
        Element(Element* parent, const Coord& topleft, const Coord& size);
        virtual ~Element();

        inline void markInvisible(bool invisible = true) { this->invisibleIs(invisible); }
        
         virtual int type() const;
        
         void registerElement(Element* part);
         Element* firstElement() const { return ( this->parts().empty() ) ? NULL : this->parts().front(); }
         Element* lastElement() const  { return ( this->parts().empty() ) ? NULL : this->parts().back();  }
         
         Coord size() const { return Coord( this->width(), this->height() ); }

         void allGlyphs(std::vector<Glyph*>& glyphs);
         void allGlyphs(std::vector<const Glyph*>& glyphs) const;
        
        Page* containingPage() const;
        
        virtual const Image* pageImage() const;

        virtual void writeText(std::ostream& os) const;

        void writeImage(const std::string& filebase, const ImageArgs& config);
        
        virtual Page*   asPage()   { return NULL; }
        virtual Region* asRegion() { return NULL; }
        virtual Line*   asLine()   { return NULL; }
        virtual Word*   asWord()   { return NULL; }
        virtual Glyph*  asGlyph()  { return NULL; }
        
        virtual const Page*   asPage()   const { return NULL; }
        virtual const Region* asRegion() const { return NULL; }
        virtual const Line*   asLine()   const { return NULL; }
        virtual const Word*   asWord()   const { return NULL; }
        virtual const Glyph*  asGlyph()  const { return NULL; }
        
        inline int height() const { return this->bottomright().y - this->topleft().y + 1; }

        inline int width()  const { return this->bottomright().x - this->topleft().x + 1; }


        u2 topY()    const  { return this->topleft().y;     }
        u2 bottomY() const  { return this->bottomright().y; }
        u2 leftX()   const  { return this->topleft().x;     }
        u2 rightX()  const  { return this->bottomright().x; }
        
        // **********************************************************
        // Debugging methods
        // **********************************************************
        
        void printStructure(std::ostream& os = std::cerr, const std::string& indent = "") const;
        
        virtual void printSummary(std::ostream& os = std::cerr, const std::string& indent = "", int index = -1) const;

        void writeGlyphs(const std::string& dir, const ImageArgs& adj) const;
        
        virtual std::string id() const;

        int findIndex(const Element* image) const;

        static void test(int argc = 0, const char* argv[] = NULL);
        
        inline ElementList & partsRef() { return this->_parts; }
        
        // Accessors
        inline const Coord &   topleft() const { return this->_topleft; }
        inline const Coord &   bottomright() const { return this->_bottomright; }
        inline const ElementList& parts() const { return this->_parts; }
        inline const Element*    parent() const { return this->_parent; }
        inline bool  invisible() const { return this->_invisible; }
        
      protected:
        // Accessors
        inline void            topleftIs(const Coord & topleft) { this->_topleft = topleft; }
        inline Coord &         topleftRef() { return this->_topleft; }
        inline void            bottomrightIs(const Coord & bottomright) { this->_bottomright = bottomright; }
        inline Coord &         bottomrightRef() { return this->_bottomright; }
        inline void            partsIs(const ElementList & parts) { this->_parts = parts; }
        inline void            parentIs(Element* parent) { this->_parent = parent; }
        inline Element* &      parentRef() { return this->_parent; }
        inline void            invisibleIs(bool invisible) { this->_invisible = invisible; }
        
        // Methods
        
        // Fields
        static char* ClassName[6];
        
      private:
        // Accessors
        inline bool& invisibleRef() { return this->_invisible; }
        
        // Methods
        
        // *******************
        // State

        Coord           _topleft;
        
        Coord           _bottomright;
        
        Element*          _parent;

        ElementList _parts;
        
        bool            _invisible;
    };
};

# endif // Conjecture_Element_h

---