mi32/htmlstyle.h

Go to the documentation of this file.

/*****************************************************************************
 *
 * \file mi32/htmlstyle.h
 * \brief HTML::STYLE and support classes
 *
 * $Log: htmlstyle.h_v $
 * Revision 1.9  2011/10/26 17:45:05  mju
 * Revert.
 *
 * Revision 1.7  2008/09/10 21:56:54  mju
 * Fix doxygen warning.
 *
 * Revision 1.6  2007/09/07 16:24:28  dwilliss
 * Made some private methods return bool instead of void
 *
 * Revision 1.5  2007/08/31 20:15:35  dwilliss
 * added some members
 *
 * Revision 1.4  2007/08/29 21:05:09  dwilliss
 * added more style things
 *
 * Revisi1.3  2007/08/29 15:54:20  dwilliss
 * copy/paste error in an enum name
 *
 * Revision 1.2  2007/08/29 15:45:05  dwilliss
 * got rid of include files we didn't need any more
 *
 * Revision 1.1  2007/08/29 15:42:24  dwilliss
 * Initial revision
 *
 *
 * Splitting up htmldoc.h and pulling style into its own include file
 *
 **/

#ifndef INC_MI32_HTMLSTYLE_H
#define INC_MI32_HTMLSTYLE_H

#ifndef INC_MI32_CSSPROPERTIES_H
#include <mi32/cssproperties.h>
#endif

#ifndef INC_MI32_ELEMSTYL_H
#include <mi32/elemstyl.h>
#endif

#ifndef INC_MI32_MISTRING_H
#include <mi32/mistring.h>
#endif

#ifndef INC_MI32_SCRNUNIT_H
#include <mi32/scrnunit.h>
#endif

#ifndef INC_MGUI_CURSORID_H
#include <mgui/cursorid.h>
#endif

#ifndef INC_MI32_HTMLMEASUREMENT_H
#include <mi32/htmlmeasurement.h>
#endif

#ifndef INC_MI32_ENUM_H
#include <mi32/htmlenum.h>
#endif


class STRUTF8;
namespace MGD {
   class CONTEXT;
   }

namespace HTML {
   class STYLE;
   class ELEMENT;

#ifndef GENERATING_DOXYGEN_OUTPUT
class STYLESHEET;
struct INLINE_POS;
#endif

   class BORDER {
      public:
         enum TYPE {
            TYPE_None = 0,
            TYPE_Dotted,
            TYPE_Dashed,
            TYPE_Solid,
            TYPE_Double,
            TYPE_Groove,
            TYPE_Ridge,
            TYPE_Inset,
            TYPE_Outset
            };

         enum SIDE {
            SIDE_Top,
            SIDE_Bottom,
            SIDE_Left,
            SIDE_Right
            };

         BORDER();
         BORDER(const BORDER&);

         bool operator==(const BORDER& rhs) const;
         bool operator!=(const BORDER& rhs) const;

         void Combine (
            const BORDER& rhs
            );

         void Draw (
            MGD::CONTEXT* gc,
            SIDE side,
            INT32 x1,
            INT32 y1,
            INT32 x2,
            INT32 y2,
            const ELEMENT* Element,
            const BORDER& PrevBorder,
            const BORDER& NextBorder
            ) const;

         const COLOR& GetColor (
            ) const { return m_Color; }

         const MEASUREMENT& GetWidth (
            ) const { return m_Width; }

         const ENUM<TYPE>& GetType (
            ) const { return m_Type; }

         bool IsColorSet (
            ) const { return m_bColorSet; }

         bool IsSet (
            ) const { return (m_Type.IsSet() || IsColorSet() || m_Width.IsSet()); }

#ifndef GENERATING_DOXYGEN_OUTPUT
      private:
         friend class STYLE;

         void Parse (
            const char* value,
            bool bWidth,
            bool bType,
            bool bColor
            );

         COLOR m_Color;
         MEASUREMENT m_Width;
         ENUM<TYPE> m_Type;
         bool m_bColorSet;

#endif
      };


   class STYLE {
      public: 

         enum PSEUDO {
            PSEUDO_None = 0,        
            PSEUDO_CurrentState,    
            PSEUDO_FirstChild,      
            PSEUDO_Hover,           
            PSEUDO_Active,          
            PSEUDO_Link,            
            PSEUDO_Visited,         
            PSEUDO_Before,          
            PSEUDO_After,           
            PSEUDO_FirstLine,       
            PSEUDO_FirstLetter,     
            PSEUDO_NUMPSEUDO
            };

         enum BORDER_COLLAPSE {
            BORDER_COLLAPSE_Separate = 0,
            BORDER_COLLAPSE_Collapse = 1
            };

         enum EMPTY_CELLS {
            EMPTY_CELLS_Hide = 0,
            EMPTY_CELLS_Show = 1
            };

         enum BACKGROUND_REPEAT {
            BACKGROUND_Repeat = 0,
            BACKGROUND_NoRepeat,
            BACKGROUND_RepeatX,
            BACKGROUND_RepeatY
            };

         enum BACKGROUND_POS {
            BACKGROUND_POS_Numeric = 0,   //
            BACKGROUND_POS_Top,
            BACKGROUND_POS_Bottom,
            BACKGROUND_POS_Left,
            BACKGROUND_POS_Right,
            BACKGROUND_POS_Center
            };

         enum DISPLAY {
            DISPLAY_Inline = 0,        
            DISPLAY_Block,             
            DISPLAY_None,              
            DISPLAY_InlineBlock,       
            DISPLAY_ListItem,
            DISPLAY_Table,
            DISPLAY_TableRow,
            DISPLAY_TableHeaderGroup,
            DISPLAY_TableRowGroup,
            DISPLAY_TableFooterGroup,
            DISPLAY_TableColumn,
            DISPLAY_TableColumnGroup,
            DISPLAY_TableCell,
            DISPLAY_TableCaption,
            DISPLAY_Marker
            };

         enum LISTPOSITION {
            LISTPOSITION_Outside = 0,
            LISTPOSITION_Inside
            };

         enum LISTTYPE {
            LISTTYPE_None = 0,      
            LISTTYPE_Disc,          
            LISTTYPE_Circle,        
            LISTTYPE_Square,        
            LISTTYPE_Decimal,       
            LISTTYPE_LowerRoman,    
            LISTTYPE_UpperRoman,    
            LISTTYPE_LowerAlpha,    
            LISTTYPE_UpperAlpha     
            };

         enum CSSOVERFLOW {
            OVERFLOW_Visible = 0,      
            OVERFLOW_Hidden            
            };
            

         enum POSITION {
            POSITION_Static = 0,       
            POSITION_Absolute,         
            POSITION_Relative          
            };

         enum VISIBILITY {
            VISIBILITY_Inherit = 0,    
            VISIBILITY_Visible = 1,    
            VISIBILITY_Hidden          
            };

         enum WHITESPACE {
            WHITESPACE_Normal = 0,     
            WHITESPACE_NoWrap,         
            WHITESPACE_Pre             
            };

         enum CLEAR {
            CLEAR_None = 0,   // default
            CLEAR_Left,       // object is moved below any floating objects on left
            CLEAR_Right,      // object is moved below any floating objects on right
            CLEAR_Both        // object is moved below any floating objects
            };

         enum TEXT_TRANSFORM {
            TEXT_TRANSFORM_None = 0,
            TEXT_TRANSFORM_Capitalize,
            TEXT_TRANSFORM_UpperCase,
            TEXT_TRANSFORM_LowerCase
            };

         enum FLOAT {
            FLOAT_None = 0,
            FLOAT_Left,
            FLOAT_Right
            };

         enum VALIGN {
            VALIGN_Baseline = 0,
            VALIGN_Auto,            
            VALIGN_Sub,
            VALIGN_Super,
            VALIGN_Top,
            VALIGN_Middle,
            VALIGN_Bottom,
            VALIGN_TextTop,
            VALIGN_TextBottom,
            VALIGN_Numeric       
            };

         class EDGE {
            public:
               EDGE(BORDER::SIDE side);
               EDGE(const EDGE&);

               // Combine the styles of another EDGE style with this one.
               void Combine (
                  const EDGE&
                  );

               // Get the border settings for this edge.
               const BORDER& GetBorder (
                  ) const { return m_Border; }

               // Get the margin settings for this edge.
               const MEASUREMENT& GetMargin (
                  ) const { return m_Margin; }

               // Get the offset settings for absolute or relative positioning.
               const MEASUREMENT& GetOffset (
                  ) const { return m_Offset; }

               // Get the padding settings for this edge.
               const MEASUREMENT& GetPadding (
                  ) const { return m_Padding; }

               double GetWidth (
                  MGD::CONTEXT* gc,
                  const ELEMENT*
                  ) const;

               bool IsInheritable (
                  ) const;

               bool CompareSize (
                  const EDGE& other
                  ) const;

#ifndef GENERATING_DOXYGEN_OUTPUT
            private:
               friend class STYLE;
               BORDER m_Border;
               MEASUREMENT m_Margin;
               MEASUREMENT m_Padding;
               MEASUREMENT m_Offset;
#endif

            };

         class SELECTOR {
            public:
               SELECTOR();
               SELECTOR(const MISTRING&);
               SELECTOR(const SELECTOR&);
               SELECTOR& operator=(const SELECTOR&rhs);
               bool operator==(const SELECTOR& rhs) const;
               bool operator!=(const SELECTOR& rhs) const;
               ~SELECTOR();

               void GetText (
                  MISTRING& str
                  ) const;

               bool IsValid (
                  ) const;

               STYLE::PSEUDO GetPseudo (
                  ) const;
#ifndef GENERATING_DOXYGEN_OUTPUT
            private:
               friend class STYLESHEET;
               class PRIV;
               PRIV* m_priv;
#endif
            };

         STYLE(const char* selector = 0, const char* css = 0);
         STYLE(const STYLE&);

         void AddRef (
            );

         void Combine (
            const STYLE& rhs
            );

         bool IsInheritable (
            ) const;


         void GenerateCSS (
            MISTRING& css,
            bool bInline = true,
            char quote = '\''
            ) const;

         // Get the border spacing for tables
         const MEASUREMENT& GetBorderSpacing (
            ) const { return m_BorderSpacing; }

         const MEASUREMENT& GetMeasurement (
            CSS_PROPERTY property
            ) const;

         const TEXTSTYLEDIFF& GetTextStyle (
            ) const { return m_TextStyle; }


         void GetTextStyle (
            TEXTSTYLE& TextStyle,
            MGD::CONTEXT* gc,
            const ELEMENT* Element
            ) const;

         void Combine (
            const EDGE& rhs
            );

         bool CompareSize (
            const STYLE& other
            ) const;

         // Get an edge.
         // This is useful when you want to loop through all 4 edges
         const EDGE& GetEdge (
            int num  
            ) const;

         // Get an edge.
         // This is useful when you want to loop through all 4 edges
         EDGE& GetEdge (
            int num  
            );

         const EDGE& GetLeftEdge (
            ) const { return m_Left; }

         const EDGE& GetRightEdge (
            ) const { return m_Right; }

         const EDGE& GetTopEdge (
            ) const { return m_Top; }

         const EDGE& GetBottomEdge (
            ) const { return m_Bottom; }
         
         const MEASUREMENT& GetHeight (
            ) const { return m_Height; }

         const MEASUREMENT& GetWidth (
            ) const { return m_Width; }

         const MEASUREMENT& GetVAlignNum (
            ) const { return m_VAlignNum; }

         // overide of size in m_TextStyle
         const MEASUREMENT& GetFontSize (
            ) const { return m_FontSize;  }

         const MEASUREMENT& GetLineHeight (
            ) const { return m_LineHeight;   }

         // Get the Text Indent
         const MEASUREMENT& GetIndent (
            ) const { return m_Indent; }

         INT32 GetTabStop (
            ) const { return m_TabStop; }

         INT32 GetZIndex (
            ) const { return m_ZIndex; }

         const MISTRING& GetBackgroundImage (
            ) const { return m_BackgroundImage; }

         const MISTRING& GetListStyleImage (
            ) const { return m_ListStyleImage; }

         const COLOR& GetBGColor (
            ) const { return m_BGColor; }

         const ENUM<BACKGROUND_POS>& GetBackgroundPosX (
            ) const { return m_BackgroundPosX; }

         const MEASUREMENT& GetBackgroundPosNumX (
            ) const { return m_BackgroundPosNumX; }

         const ENUM<BACKGROUND_POS>& GetBackgroundPosY (
            ) const { return m_BackgroundPosY; }

         const MEASUREMENT& GetBackgroundPosNumY (
            ) const { return m_BackgroundPosNumY; }

         const ENUM<BACKGROUND_REPEAT>& GetBackgroundRepeat (
            ) const { return m_BackgroundRepeat; }

         const ENUM<TEXT_TRANSFORM>& GetTextTransform (
            ) const { return m_TextTransform; }

         const ENUM<BORDER_COLLAPSE>& GetBorderCollapse (
            ) const { return m_BorderCollapse; }

         const ENUM<CLEAR>& GetClear (
            ) const { return m_Clear; }

         const MISTRING& GetContent (
            ) const { return m_Content; }

         const MISTRING& GetCounterIncrement (
            ) const { return m_CounterIncrement; }

         const MISTRING& GetCounterReset (
            ) const { return m_CounterReset; }

#ifdef USE_MGUI
         const ENUM<MGUI::CURSORID>& GetCursor (
            ) const { return m_Cursor; }
#endif

         const ENUM<DISPLAY>& GetDisplay (
            ) const { return m_Display; }

         const ENUM<EMPTY_CELLS>& GetEmptyCells (
            ) const { return m_EmptyCells; }

         const ENUM<FLOAT>& GetFloat (
            ) const { return m_Float; }

         const ENUM<LISTPOSITION>& GetListPosition (
            ) const { return m_ListPosition; }

         const ENUM<LISTTYPE>& GetListType (
            ) const { return m_ListType; }

         const MEASUREMENT& GetMarkerOffset (
            ) const { return m_MarkerOffset; }

         bool GetMinimizeWidth (
            ) const { return m_bMinimizeWidth; }

         const MISTRING& GetOpenTypeFeatures (
            ) const { return m_OpenTypeFeatures; }

         const ENUM<CSSOVERFLOW>& GetOverflow (
            ) const { return m_Overflow; }

         const ENUM<POSITION>& GetPosition (
            ) const { return m_Position; }

         const MISTRING& GetQuotes (
            ) const { return m_Quotes; }

         const SELECTOR& GetSelector (
            ) const { return m_selector; }

         const ENUM<VALIGN>& GetVAlign (
            ) const { return m_VAlign; }

         const ENUM<VISIBILITY>& GetVisibility (
            ) const { return m_Visibility; }

         const ENUM<WHITESPACE>& GetWhitespace (
            ) const { return m_Whitespace; }

         bool IsBGColorSet (
            ) const { return m_bBGColorSet; }

         bool IsMinimizeWidthSet (
            ) const { return m_bMinimizeWidthSet; }

         bool IsShared (
            ) const { return m_bIsShared; }

         bool IsSpecialState (
            ) const { return m_bSpecialState; }

         void Parse(const MISTRING& str);

         void ParseTildeCodes (
            const MISTRING& codes,
            MISTRING& UnhandledCodes
            );

         void Release (
            );

         void SetBGColor (
            const COLOR& color
            ) {
            m_BGColor = color;
            m_bBGColorSet = true;
            }

         void SetTextStyle (
            const TEXTSTYLE& TextStyle
            ) { 
            m_TextStyle = TextStyle; 
            m_FontSize.Set(TextStyle.Height, static_cast<SCREENUNIT>(TextStyle.HeightUnits));
            m_LineHeight.Set(TextStyle.LineSpace, static_cast<SCREENUNIT>(TextStyle.SpaceUnits));
            }

         bool ParseFontSize (
            const STRUTF8& str
            );

         bool ParseFontStyle (
            const STRUTF8& str
            );

         bool ParseFontVariant (
            const STRUTF8& str
            );

         bool ParseFontWeight (
            const STRUTF8& str
            );

         void ParseLineHeight (
            const STRUTF8& str
            );

         bool ParseFont (
            const MISTRING& mistr
            );

#ifndef GENERATING_DOXYGEN_OUTPUT
      private:
         friend class STYLESHEET;
         friend class HTMLDOC;

         INT32 m_RefCount;
         bool m_bIsShared; // True if it's in a style sheet

         SELECTOR m_selector;
         TEXTSTYLEDIFF m_TextStyle;

         EDGE m_Left;
         EDGE m_Right;
         EDGE m_Top;
         EDGE m_Bottom;
         MEASUREMENT m_Height;
         MEASUREMENT m_Width;
         MEASUREMENT m_VAlignNum;
         MEASUREMENT m_Indent;

         MEASUREMENT m_FontSize; // overide of size in m_TextStyle
         MEASUREMENT m_LineHeight;  // overide of size in m_TextStyle
         MEASUREMENT m_BorderSpacing;
         INT32 m_ZIndex;
         INT32 m_TabStop;

         ENUM<BACKGROUND_POS> m_BackgroundPosX;
         MEASUREMENT m_BackgroundPosNumX;
         ENUM<BACKGROUND_POS> m_BackgroundPosY;
         MEASUREMENT m_BackgroundPosNumY;
         ENUM<BACKGROUND_REPEAT> m_BackgroundRepeat;
         ENUM<CLEAR> m_Clear;
#ifdef USE_MGUI
         ENUM<MGUI::CURSORID> m_Cursor;
#endif
         ENUM<DISPLAY> m_Display;
         ENUM<EMPTY_CELLS> m_EmptyCells;
         ENUM<FLOAT> m_Float;
         ENUM<LISTPOSITION> m_ListPosition;
         ENUM<LISTTYPE> m_ListType;
         ENUM<CSSOVERFLOW> m_Overflow;
         ENUM<BORDER_COLLAPSE> m_BorderCollapse;
         bool m_bMinimizeWidth;
         bool m_bMinimizeWidthSet;
         ENUM<POSITION> m_Position;
         ENUM<TEXT_TRANSFORM> m_TextTransform;
         ENUM<VALIGN> m_VAlign;
         ENUM<VISIBILITY> m_Visibility;
         ENUM<WHITESPACE> m_Whitespace;
         COLOR m_BGColor;
         bool m_bBGColorSet;
         MISTRING m_BackgroundImage;   // just a "url"
         MISTRING m_ListStyleImage;    // just a "url"
         bool m_bSpecialState;

         MISTRING m_CounterIncrement;
         MISTRING m_CounterReset;
         MISTRING m_Content;
         MISTRING m_Quotes;
         MISTRING m_OpenTypeFeatures;
         MEASUREMENT m_MarkerOffset;

         // This one can only be called from STYLESHEET::FindStyle.
         // It copy constructs a style but only copies the parts which can
         // be inherited.  The bool parameter is ignored.  It's just there to
         // force it to call this ctor rather than the normal copy ctor
         STYLE(const STYLE&, bool bInheritable);

         void ParseFontStyleFlag (
            const char* value,
            const char* expected,
            UINT32 flag
            );

         void SetSelector (
            const SELECTOR& selector
            );

         ~STYLE();   
#endif // doxygen
      };

   } // end of HTML namespace


#endif

---