smlelem.h

linux下的一款播放器

    // browser, or a truly external (OS default) browser:
    CHXString         m_sendTo;
    // /These are used for timing solely for the purposes of keeping track of
    // when the link is active (clickable) and NOT for the purposes of
    // constraining or otherwise affecting the times of child elements:
    INT32             m_lAnchorBeginOffset;
    INT32             m_lAnchorEndOffset;
    ULONG32           m_ulAnchorDuration;
    ULONG32           m_ulAnchorMinActiveDur;
    ULONG32           m_ulAnchorMaxActiveDur;
    // ONLY HX_BITFIELD MEMBERS SHOULD GO BELOW THIS LINE!
    // ALL OTHER MEMBER TYPES SHOULD GO ABOVE THIS LINE!
    HX_BITFIELD       m_bExternal : 1; // /(true|false) default is false.
    // /This is TRUE if target="x" and "x" is the id of a region in the
    // current presentation:
    HX_BITFIELD       m_bTargetIsARegion : 1;
    HX_BITFIELD       m_bAnchorBeginOffsetSet : 1;
    HX_BITFIELD       m_bAnchorEndOffsetSet : 1;
    HX_BITFIELD       m_bTimeValueSet : 1;
};

class CSmilAnchorVertex
{
public:
    CSmilAnchorVertex() {m_lX=m_lY=0; m_bXIsPercent=m_bYIsPercent=FALSE;}
    ~CSmilAnchorVertex() {};

    INT32       m_lX;
    INT32       m_lY;
    // ONLY HX_BITFIELD MEMBERS SHOULD GO BELOW THIS LINE!
    // ALL OTHER MEMBER TYPES SHOULD GO ABOVE THIS LINE!
    HX_BITFIELD m_bXIsPercent : 1;
    HX_BITFIELD m_bYIsPercent : 1;
};

class CSmilAnchorElement: public CSmilAAnchorElement
{
public:
    CSmilAnchorElement(SMILNode* pNode);
    virtual ~CSmilAnchorElement();

    virtual BOOL isCurrentLink(UINT32 ulTime,
	    UINT32  ulXOffset, UINT32 ulYOffset, HXxRect regionRect,
	    BOOL bResizeBehaviorIsZoom,
	    double dZoomX, double dZoomY);
    // /Tells whether the link is active at the current time (but doesn't
    // do any spatial bounds checking):
    virtual BOOL isLinkActiveAtTime(UINT32 ulTimeOffset,
	    REF(ULONG32)rulAnchorRelativeStartTime);

    virtual void rescale(double dXScale, double dYScale,
                         BOOL bResetOriginalCoords);

    virtual BOOL isAAnchor() {return FALSE;}

    // /This handles conversion of string of points ("0,0, 20,10, ...") to
    // array of CSmilAnchorVertex's (vertices) in m_pVertexArray:
    HX_RESULT convertRawPolyData(const char* pData);

    // /This is for handling hit-testing in a "poly" (polygon) shape:
    BOOL isPointInPolygon(INT32 lXOffset, INT32 lYOffset,
	    HXxRect regionRect,
	    double dZoomX, double dZoomY);

    void deleteVertexArrays();

    // /XXXEH- TODO: make these points be unsigned values because shapes
    // can stick out of frame, and thus can be negative in places:
    UINT32             m_ulLeftX;
    UINT32             m_ulOriginalLeftX;
    UINT32             m_ulTopY;
    UINT32             m_ulOriginalTopY;
    UINT32             m_ulRightX;
    UINT32             m_ulOriginalRightX;
    UINT32             m_ulBottomY;
    UINT32             m_ulOriginalBottomY;
    UINT32             m_ulRadius;
    UINT32             m_ulOriginalRadius;
    // /XXXEH- TODO: use these points for rectangles, too (but don't use the
    // hit-test code for them as it is slower for rectangles):
    // /The following three are for handling shape="poly":
    CSmilAnchorVertex* m_pVertexArray;
    CSmilAnchorVertex* m_pOriginalVertexArray;
    UINT16	       m_uiNumPoints;
    CHXString          m_shape;
    CHXString          m_fragmentID;
    INT32              m_zIndex;
    // ONLY HX_BITFIELD MEMBERS SHOULD GO BELOW THIS LINE!
    // ALL OTHER MEMBER TYPES SHOULD GO ABOVE THIS LINE!
    HX_BITFIELD        m_bCoordsSet : 1;
    HX_BITFIELD        m_bLeftXIsPercent : 1;
    HX_BITFIELD        m_bTopYIsPercent : 1;
    HX_BITFIELD        m_bRightXIsPercent : 1;
    HX_BITFIELD        m_bBottomYIsPercent : 1;
    HX_BITFIELD        m_bRadiusIsPercent : 1;
};

enum
{
    kCalcModeDiscrete,
    kCalcModeLinear,
    kCalcModePaced
#if defined(XXXMEH_SPLINE_ANIMATION)
    ,kCalcModeSpline
#endif
};

enum
{
    kAccumulateSum,
    kAccumulateNone
};

enum
{
    kAdditiveSum,
    kAdditiveReplace
};

enum
{
    kAnimTypeValues,
    kAnimTypeFromTo,
    kAnimTypeFromBy,
    kAnimTypeBy,
    kAnimTypeTo
};

#if defined(XXXMEH_SPLINE_ANIMATION)

struct KeySpline
{
    double x1;
    double y1;
    double x2;
    double y2;
};

typedef enum
{
    PathCmdTypeUnknown,
    PathCmdTypeMoveTo,
    PathCmdTypeLineTo,
    PathCmdTypeHorzLineTo,
    PathCmdTypeVertLineTo,
    PathCmdTypeClosePath,
    PathCmdTypeCubicBezierCurveTo
} PathCmdType;

class PathCmd
{
public:
    PathCmd();
    ~PathCmd();

    PathCmdType m_eType;
    BOOL        m_bRelative;
    UINT32      m_ulNumCoords;
    double*     m_pdCoord;
};

inline PathCmd::PathCmd()
{
    m_eType       = PathCmdTypeUnknown;
    m_bRelative   = FALSE;
    m_ulNumCoords = 0;
    m_pdCoord     = NULL;
}

inline PathCmd::~PathCmd()
{
    HX_VECTOR_DELETE(m_pdCoord);
}

#endif

#if defined(HELIX_FEATURE_SMIL2_ANIMATION)

class CSmilAnimateElement : public CSmilElement
{
public:
    CSmilAnimateElement(SMILNode* pNode);
    virtual ~CSmilAnimateElement();

    virtual HX_RESULT handleElement();
    // We override this since we handle repeat
    // differently than sources do.
    virtual HX_RESULT getCurrentScheduledStopTime(REF(ULONG32) ulActualStopTime);

    UINT32      m_ulSimpleDuration;
    UINT32      m_ulActiveDuration;
    UINT32      m_ulADNoSpeed;
    CHXString*  m_pTargetElementID;
    SMILNodeTag m_eTargetElementTag;
    UINT32      m_ulNumValues;
    CAttr**     m_ppValue;
    BYTE        m_ucAttributeName;
    BYTE        m_ucCalcMode;
    BYTE        m_ucAccumulate;
    BYTE        m_ucAdditive;
    BYTE        m_ucAnimationType;
    double      m_dRepeatCount;
    UINT32      m_ulRepeatDur;
    double      m_dAccelerate;
    double      m_dDecelerate;
    double      m_dSpeed;
#if defined(XXXMEH_SPLINE_ANIMATION)
    UINT32      m_ulNumKeyTimes;
    double*     m_pdKeyTime;
    UINT32      m_ulNumKeySplines;
    KeySpline*  m_pKeySpline;
    UINT32      m_ulNumPathCmds;
    PathCmd**   m_ppPathCmd;
    UINT32      m_ulNumPathPoints;
#endif
    // ONLY HX_BITFIELD MEMBERS SHOULD GO BELOW THIS LINE!
    // ALL OTHER MEMBER TYPES SHOULD GO ABOVE THIS LINE!
    HX_BITFIELD m_bRepeatDurIsIndefinite : 1;
    HX_BITFIELD m_bAutoReverse : 1;
    HX_BITFIELD m_bIndefiniteSimpleDuration : 1;
    HX_BITFIELD m_bIndefiniteActiveDuration : 1;
    HX_BITFIELD m_bCancelAnimation : 1;
};

#endif /* #if defined(HELIX_FEATURE_SMIL2_ANIMATION) */

class CSmilParamElement : public CSmilElement
{
public:
    CSmilParamElement(SMILNode* pNode);
    virtual ~CSmilParamElement();

    IHXBuffer*   m_pName;
    IHXBuffer*   m_pValue;
    ParamDelivery m_eDelivery;
};

class CSmilParElement: public CSmilElement
{
public:
    CSmilParElement(SMILNode* pNode);
    virtual ~CSmilParElement();
};

class CSmilSeqElement: public CSmilElement
{
public:
    CSmilSeqElement(SMILNode* pNode);
    virtual ~CSmilSeqElement();
};

class CSmilExclElement: public CSmilElement
{
public:
    CSmilExclElement(SMILNode* pNode);
    virtual ~CSmilExclElement();

    CHXStack* m_pPauseStack;
};

#if defined(HELIX_FEATURE_SMIL2_TRANSITIONS)

class CSmilTransition: public CSmilElement
{
public:
    CSmilTransition(SMILNode* pNode);
    virtual ~CSmilTransition();

    virtual HX_RESULT handleElement();

    CHXString              m_Type;
    CHXString              m_SubType;
    double                 m_dStartProgress;
    double                 m_dEndProgress;
    TransitionDirection    m_eDirection;
    UINT32                 m_ulFadeColor;
    UINT32                 m_ulHorzRepeat;
    UINT32                 m_ulVertRepeat;
    UINT32                 m_ulBorderWidth;
    UINT32                 m_ulBorderColor;
    // ONLY HX_BITFIELD MEMBERS SHOULD GO BELOW THIS LINE!
    // ALL OTHER MEMBER TYPES SHOULD GO ABOVE THIS LINE!
    HX_BITFIELD            m_bBlendBorder : 1;
};

#endif /* #if defined(HELIX_FEATURE_SMIL2_TRANSITIONS) */

class CSmilBodyElement : public CSmilElement
{
public:
    CSmilBodyElement(SMILNode* pNode);
    virtual ~CSmilBodyElement();
};

#endif