mi32/htmlelement.h

Go to the documentation of this file.

/*****************************************************************************
 *
 * \file mi32/htmlelement.h
 * \brief HTML::ELEMENT class
 *
 * $Log: htmlelement.h_v $
 * Revision 1.6  2011/10/25 21:30:02  mju
 * Remove redundant hdrs.
 *
 * Revision 1.5  2011/04/21 22:15:29  bcolombe
 * Add STATE_Link
 *
 * Revision 1.3  2009/03/18 19:00:04  ldyas
 * added errvalue responses to do_layouts.
 *
 * Revision 1.2  2007/08/29 21:05:17  dwilliss
 * Added support for keeping track of counters
 *
 * Revision 1.1  2007/08/29 15:42:35  dwilliss
 * Initial revision
 **/

#ifndef INC_MI32_HTMLELEMENT_H
#define INC_MI32_HTMLELEMENT_H

#ifndef INC_MI32_RECT_H
#include <mi32/rect.h>
#endif

#ifndef INC_MI32_HTMLSTYLE_H
#include <mi32/htmlstyle.h>
#endif

#ifndef INC_MAP
#define INC_MAP
#include <map>
#endif

#ifndef GENERATING_DOXYGEN_OUTPUT
class MISTRING;
class STRUTF8;
class XMLNODE;
class REGION2D;
class TRANS2D_AFFINE;
namespace MGD {
   class DEVICE;
   class CONTEXT;
   }
namespace HTML {
   class HTMLDOC;
   class STYLESHEET;
   struct INLINE_POS;
   }
#endif

namespace HTML {

   class ELEMENT {
      public:

         enum STATE {
            STATE_Normal = 0,
            STATE_Hover,
            STATE_Active,
            STATE_Link,
            STATE_NUMSTATES
            };

         ELEMENT (
            HTMLDOC* doc,
            XMLNODE* node
            );

         virtual ~ELEMENT();

         ERRVALUE DoLayout (
            MGD::CONTEXT* gc,
            double MaxWidth,        
            DPOINT2D& pt,           
            REGION2D& Container,    
            DRECT2D& Extents        
            );

         void DoLayoutPass2 (
            MGD::CONTEXT* gc,
            DPOINT2D& AbsPos
            );

         void Draw (
            MGD::CONTEXT* gc,
            const DPOINT2D& pos,
            const DRECT2D* clip = 0
            );


         void AddToRegion (
            REGION2D& region,
            const DPOINT2D& pos,
            bool bOnlyIfDirty
            );

         ELEMENT* FindChild (
            const DPOINT2D& pt
            );

         const DRECT2D& GetExtents (
            ) const { return m_Extents; }

         double GetIntrinsicHeight (
            ) const { return v_GetIntrinsicHeight(); }

         double GetIntrinsicWidth (
            ) const { return v_GetIntrinsicWidth(); }

         double GetHeight (
            ) const { return m_Height; }

         XMLNODE* GetNode (
            ) const { return m_node; }

         double GetWidth (
            ) const { return m_Width; }

         // Get the position of the element relative to the upper-left corner
         // of the parent element (in pixels)
         const DPOINT2D& GetPos (
            ) const { return m_Pos; }

         // Return the extents of the element as a region
         void GetRegion (
            REGION2D& region,
            bool bRootRelative = true
            );

         const STYLE* GetStyle (
            STYLE::PSEUDO pseudo = STYLE::PSEUDO_CurrentState
            ) const;

         const ELEMENT* GetParent() const;
         ELEMENT* GetParent();
         const ELEMENT* GetFirstChild() const;
         ELEMENT* GetFirstChild();

         const ELEMENT* GetNext() const;
         ELEMENT* GetNext();

         bool IsEmpty (
            ) const;

         bool IsHidden (
            ) const { return v_IsHidden(); }

         void SetStyle (
            STYLE* style
            );

         void SetState (
            STATE state
            );

#ifndef GENERATING_DOXYGEN_OUTPUT
         // These methods are used by the layout process and need to be
         // public so derived classes can call them on children, but
         // the outside world should not see them
         
         const HTMLDOC* GetDoc (
            ) const { return m_Doc; }

         void SetHeight (
            double height
            ) { m_Height = height; }

         void SetWidth (
            double width
            ) { m_Width = width; }

         void SetPos (
            const DPOINT2D& pt
            ) { m_Pos = pt; }

         // Used to shrink the width to eliminate unnecessary
         // whitespace on the right of the documnet
         void ShrinkWidth (
            double WidthDelta
            );

         void ShrinkToNaturalWidth (
            double LayoutWidth   // the width we used on the main DoLayout
            );

         // Mark the element as needing to be redrawn
         // All children will be marked as well
         void SetNeedRedraw (
            );

         // Get the value of a specific counter.
         // If no such counter exists, it will add it and initialize it to 1
         INT32 GetCounter (
            const MISTRING& name
            );

         void IncrementCounter (
            const MISTRING& name
            );

         void ResetCounter (
            const MISTRING& name
            );
#endif

#ifndef GENERATING_DOXYGEN_OUTPUT
      protected:
#ifdef DEBUG
         // The following two are to simplify debugging so that we don't have 
         // to expand things 3 levels deep just to see which element we're 
         // looking at
         const char* m_tag;         // set by ctor to m_node->_xmlNode->name
         const MIUNICODE* m_content;   // Points to the text of the node if it's a text node
#endif
         double m_Height;
         double m_Width;
         STATE m_State;

         const MGD::DEVICE* LoadImage (
            const MISTRING& src
            );

         // Take the value of a tag attribute and convert it to the CSS
         // equivilant, applying it to the elements's style
         void AttributeToCSS (
            const char* cssname,
            const STRUTF8& value
            );
         
         // should return true if the element contains a given point.
         // The point is relative to the upper-left of the parent element
         bool ContainsPoint (
            const DPOINT2D& pt
            ) const { return v_ContainsPoint(pt); }


         // Make sure the container region is at least Height.  Expands it
         // vertically if not.  Note: If it does have to expand the container,
         // it may make it taller than needed to avoid having to expand it again
         // later.
         //
         ERRVALUE ExpandContainer (
            REGION2D& Container,
            MGD::CONTEXT* gc,
            double Width,
            double Height
            );

         void FillBackground (
            MGD::CONTEXT* context,
            const DRECT2D& rect
            );

         ERRVALUE GetAvailableRect (
            REGION2D& Region,
            MGD::CONTEXT* gc,
            double MaxWidth,        // Width of Region if we need to expand it
            const DRECT2D& DesiredRect,
            DRECT2D& AvailableRect,
            bool bWidestPossible = true
            );

         void GetInlinePos (
            SIMPLE_ARRAY<INLINE_POS*>& positions
            ) { v_GetInlinePos(positions); }

         double GetRotAngle (
            ) const;

         const TRANS2D_AFFINE& GetTransAffine (
            ) const;

         void SetState (
            STATE state,
            bool bPropagateToParent,
            bool bPropagateToChildren
            );

         // should return true if the element contains a given point.
         // The point is relative to the upper-left of the parent element
         virtual bool v_ContainsPoint (
            const DPOINT2D& pt
            ) const;

         virtual ERRVALUE v_DoLayout (
            MGD::CONTEXT* gc,
            double MaxWidth,        
            DPOINT2D& pt,           
            REGION2D& Container,    
            DRECT2D& Extents        
            );

         // Should draw just this element.  Child elements will be drawn
         // by the caller
         virtual void v_Draw (
            MGD::CONTEXT* gc,
            const DPOINT2D& pos     // Absolute position to draw at
            );

         virtual bool v_IsHidden (
            ) const;


      private:
         friend class HTMLDOC;

         XMLNODE* m_node;
         HTMLDOC* m_Doc;   // Pointer to parent document
         mutable STYLE* m_Styles[STATE_NUMSTATES][STYLE::PSEUDO_NUMPSEUDO];
         DPOINT2D m_Pos;
         DPOINT2D m_ChildOffset; // Precomputed distance from Pos to where our children start
         DRECT2D m_Extents;   // Extents of this element in absolute coordinates
         bool m_bNeedRedraw;
         bool m_bHasBackground;  // Set by DoLayoutPass2
         INT32 m_ElemNum;        // For sorting top-down

         typedef std::map<MISTRING, INT32> COUNTERMAP;
         COUNTERMAP m_Counters;

         static int CompareZOrder (ELEMENT**, ELEMENT**, void*);
#endif

         virtual void v_GetInlinePos (
            SIMPLE_ARRAY<INLINE_POS*>& positions
            );

         virtual double v_GetIntrinsicHeight (
            ) const;

         virtual double v_GetIntrinsicWidth (
            ) const;

      };
   
   } // end of HTML namespace


#endif

---