![[tokkee]](http://tokkee.org/images/avatar.png){kind=avatar}
summary | shortlog | log | commit | commitdiff | tree
raw | patch | inline | side by side (parent: 6a2c421)
raw | patch | inline | side by side (parent: 6a2c421)
| author | ishmal <ishmal@users.sourceforge.net> | |
| Thu, 24 Apr 2008 21:12:18 +0000 (21:12 +0000) | ||
| committer | ishmal <ishmal@users.sourceforge.net> | |
| Thu, 24 Apr 2008 21:12:18 +0000 (21:12 +0000) |
| src/dom/smil.h | patch | blob | history | |
| src/dom/smilimpl.cpp | patch | blob | history | |
| src/dom/smilimpl.h | patch | blob | history | |
| src/dom/svgimpl.h | patch | blob | history |
diff --git a/src/dom/smil.h b/src/dom/smil.h
index a226dc65ba0c206f1f94f72c6d2519c9652781b2..fdeb0994df424465d15962306b9fb214d442a783 100644 (file)
--- a/src/dom/smil.h
+++ b/src/dom/smil.h
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * ===========================================================================
+ * NOTES
+ *
+ * http://www.w3.org/TR/smil-boston-dom
*/
class ElementTimeContainer;
class ElementTimeControl;
class ElementTimeManipulation;
+class Time;
+class TimeEvent;
+class TimeList;
+
class SMILAnimateColorElement;
+typedef Ptr<SMILAnimateColorElement> SMILAnimateColorElementPtr;
class SMILAnimateElement;
+typedef Ptr<SMILAnimateElement> SMILAnimateElementPtr;
class SMILAnimateMotionElement;
+typedef Ptr<SMILAnimateMotionElement> SMILAnimateMotionElementPtr;
class SMILAnimation;
+typedef Ptr<SMILAnimation> SMILAnimationPtr;
class SMILDocument;
+typedef Ptr<SMILDocument> SMILDocumentPtr;
class SMILElement;
+typedef Ptr<SMILElement> SMILElementPtr;
class SMILLayoutElement;
+typedef Ptr<SMILLayoutElement> SMILLayoutElementPtr;
class SMILMediaElement;
+typedef Ptr<SMILMediaElement> SMILMediaElementPtr;
class SMILRefElement;
+typedef Ptr<SMILRefElement> SMILRefElementPtr;
class SMILRegionElement;
+typedef Ptr<SMILRegionElement> SMILRegionElementPtr;
class SMILRegionInterface;
+typedef Ptr<SMILRegionInterface> SMILRegionInterfacePtr;
class SMILRootLayoutElement;
+typedef Ptr<SMILRootLayoutElement> SMILRootLayoutElementPtr;
class SMILSetElement;
+typedef Ptr<SMILSetElement> SMILSetElementPtr;
class SMILSwitchElement;
+typedef Ptr<SMILSwitchElement> SMILSwitchElementPtr;
class SMILTopLayoutElement;
-class Time;
-class TimeEvent;
-class TimeList;
+typedef Ptr<SMILTopLayoutElement> SMILTopLayoutElementPtr;
#########################################################################*/
/**
- *
+ * This interface is used by SMIL elements root-layout, top-layout and region.
*/
class ElementLayout
{
/**
- *
+ * Return the title of an item implementing this interface
*/
virtual DOMString getTitle()
{ return title; }
/**
- *
+ * Set the title of an item implementing this interface
*/
virtual void setTitle(const DOMString &val) throw(dom::DOMException)
{ title = val; }
/**
- *
+ * Return the background color of an item implementing this interface
*/
virtual DOMString getBackgroundColor()
{ return backgroundColor; }
/**
- *
+ * Set the background color of an item implementing this interface
*/
virtual void setBackgroundColor(const DOMString &val) throw(dom::DOMException)
{ backgroundColor = val; }
/**
- *
+ * Return the height of an item implementing this interface
*/
virtual long getHeight()
{ return height; }
/**
- *
+ * Set the height of an item implementing this interface
*/
virtual void setHeight(long val) throw(dom::DOMException)
{ height = val; }
/**
- *
+ * Return the width of an item implementing this interface
*/
virtual long getWidth()
{ return width; }
/**
- *
+ * Set the width of an item implementing this interface
*/
virtual void setWidth(long val) throw(dom::DOMException)
{ width = val; }
#########################################################################*/
/**
- *
+ * Declares rendering surface for an element. See the region attribute definition.
*/
class SMILRegionInterface
{
public:
/**
- *
+ * Gets an associated region element
*/
- virtual SMILRegionElement *getRegion()
+ virtual SMILRegionElementPtr getRegion()
{ return regionElement; }
+
/**
- *
+ * Sets an associated region element
*/
- virtual void setRegion(const SMILRegionElement *val)
- { regionElement = (SMILRegionElement *)val; }
+ virtual void setRegion(const SMILRegionElementPtr val)
+ { regionElement = val; }
//##################
//# Non-API methods
*
*/
SMILRegionInterface()
- { regionElement = NULL; }
+ { }
/**
*
SMILRegionInterface(const SMILRegionInterface &other)
{ regionElement = other.regionElement; }
+ /**
+ *
+ */
+ SMILRegionInterface& operator=(const SMILRegionInterface &other)
+ {
+ regionElement = other.regionElement;
+ return *this;
+ }
+
/**
*
*/
protected:
- SMILRegionElement *regionElement;
+ SMILRegionElementPtr regionElement;
};
#########################################################################*/
/**
- *
+ * The Time interface is a datatype that represents times within the timegraph.
+ * A Time has a type, key values to describe the time, and a boolean to
+ * indicate whether the values are currently unresolved.
*/
class Time
{
/**
- *
+ * A boolean indicating whether the current Time has been fully resolved to the
+ * document schedule. Note that for this to be true, the current Time must be
+ * defined (not indefinite), the syncbase and all Time's that the syncbase
+ * depends on must be defined (not indefinite), and the begin Time of all
+ * ascendent time containers of this element and all Time elements that this
+ * depends upon must be defined (not indefinite). If this Time is based upon an
+ * event, this Time will only be resolved once the specified event has happened,
+ * subject to the constraints of the time container. Note that this may change
+ * from true to false when the parent time container ends its simple duration
+ * (including when it repeats or restarts).
*/
virtual bool getResolved()
{ return resolved; }
/**
- *
+ * The clock value in seconds relative to the parent time container begin. This
+ * indicates the resolved time relationship to the parent time container. This is
+ * only valid if resolved is true.
*/
virtual double getResolvedOffset()
{ return resolvedOffset; }
+ /**
+ * An integer indicating the type of this time value.
+ */
typedef enum
{
SMIL_TIME_INDEFINITE = 0,
SMIL_TIME_EVENT_BASED = 3,
SMIL_TIME_WALLCLOCK = 4,
SMIL_TIME_MEDIA_MARKER = 5
- } TimeTypes;
+ } TimeType;
/**
- *
+ * A code representing the type of the underlying object, as defined above.
*/
virtual unsigned short getTimeType()
{ return timeType; }
/**
- *
+ * The clock value in seconds relative to the syncbase or eventbase.
+ * Default value is 0.
*/
virtual double getOffset()
{ return offset; }
/**
- *
+ * Set the value above
*/
virtual void setOffset(double val) throw (dom::DOMException)
{ offset = val; }
/**
- *
+ * Get the base element for a sync-based or event-based time.
*/
- virtual Element *getBaseElement()
+ virtual ElementPtr getBaseElement()
{ return baseElement; }
/**
- *
+ * Set the base element for a sync-based or event-based time.
*/
- virtual void setBaseElement(const Element *val) throw (dom::DOMException)
- { baseElement = (Element *)val; }
+ virtual void setBaseElement(const ElementPtr val) throw (dom::DOMException)
+ { baseElement = val; }
/**
- *
+ * If true, indicates that a sync-based time is relative to the begin of the
+ * baseElement. If false, indicates that a sync-based time is relative to the
+ * active end of the baseElement.
*/
virtual bool getBaseBegin()
{ return baseBegin; }
/**
- *
+ * Set the value above.
*/
virtual void setBaseBegin(bool val) throw (dom::DOMException)
{ baseBegin = val; }
/**
- *
+ * Get the name of the event for an event-based time. Default value is null.
*/
virtual DOMString getEvent()
{ return eventStr; }
/**
- *
+ * Set the name of the event for an event-based time. Default value is null.
*/
virtual void setEvent(const DOMString &val) throw (dom::DOMException)
{ eventStr = val; }
/**
- *
+ * Get the name of the marker from the media element, for media marker
+ * times. Default value is null.
*/
virtual DOMString getMarker()
{ return marker; }
/**
- *
+ * Set the name of the marker from the media element, for media marker
+ * times. Default value is null.
*/
virtual void setMarker(const DOMString &val) throw (dom::DOMException)
{ marker = val; }
resolvedOffset = 0.0;
timeType = SMIL_TIME_INDEFINITE;
offset = 0.0;
- baseElement = NULL;
+ //baseElement = NULL; //not necessary
baseBegin = false;
eventStr = "";
marker = "";
*
*/
Time(const Time &other)
- {
+ {
+ assign(other);
+ }
+
+ /**
+ *
+ */
+ Time &operator=(const Time &other)
+ {
+ assign(other);
+ return *this;
+ }
+
+ void assign(const Time &other)
+ {
resolved = other.resolved;
resolvedOffset = other.resolvedOffset;
timeType = other.timeType;
baseBegin = other.baseBegin;
eventStr = other.eventStr;
marker = other.marker;
- }
+ }
/**
*
double resolvedOffset;
unsigned short timeType;
double offset;
- Element * baseElement;
+ ElementPtr baseElement;
bool baseBegin;
DOMString eventStr;
DOMString marker;
#########################################################################*/
/**
- *
+ * The TimeList interface provides the abstraction of an ordered collection of
+ * times, without defining or constraining how this collection is implemented.
+ *
+ * The items in the TimeList are accessible via an integral index, starting from 0.
*/
class TimeList
{
public:
-
/**
- *
+ * Returns the indexth item in the collection. If index is greater than or equal
+ * to the number of times in the list, this returns null.
*/
virtual Time item(unsigned long index)
{
}
/**
- *
+ * The number of times in the list. The range of valid child time
+ * indices is 0 to length-1 inclusive.
*/
virtual unsigned long getLength()
{
return items.size();
}
+
+
//##################
//# Non-API methods
//##################
items = other.items;
}
+ /**
+ *
+ */
+ TimeList &operator=(const TimeList &other)
+ {
+ items = other.items;
+ return *this;
+ }
+
/**
*
*/
#########################################################################*/
/**
- *
+ * This interface defines the set of timing attributes that are common to
+ * all timed elements.
*/
class ElementTime
{
/**
- *
+ * Get the desired value (as a list of times) of the begin instant of this node.
*/
- virtual TimeList getBegin()
+ virtual TimeList &getBegin()
{ return beginTime; }
/**
- *
+ * Set the desired value (as a list of times) of the begin instant of this node.
*/
virtual void setBegin(const TimeList &val) throw(dom::DOMException)
{ beginTime = val; }
+
/**
- *
+ * Set the list of active ends for this node.
*/
- virtual TimeList getEnd()
+ virtual TimeList &getEnd()
{ return endTime; }
/**
- *
+ * Set the list of active ends for this node.
*/
virtual void setEnd(const TimeList &val) throw(dom::DOMException)
{ endTime = val; }
/**
- *
+ * Get the desired simple duration value of this node in seconds.
+ * Negative value means "indefinite".
*/
virtual double getDur()
{ return dur; }
/**
- *
+ * Set the desired simple duration value of this node in seconds.
+ * Negative value means "indefinite".
*/
virtual void setDur(double val) throw(dom::DOMException)
{ dur = val; }
+ /**
+ * An integer indicating the value of the restart attribute.
+ */
typedef enum
{
RESTART_ALWAYS = 0,
RESTART_NEVER = 1,
RESTART_WHEN_NOT_ACTIVE = 2
- } RestartTypes;
+ } RestartType;
/**
- *
+ * Get code representing the value of the restart attribute,
+ * as defined above. Default value is RESTART_ALWAYS.
*/
virtual unsigned short getRestart()
{ return restart; }
/**
- *
+ * Set code representing the value of the restart attribute,
+ * as defined above. Default value is RESTART_ALWAYS.
*/
virtual void setRestart(unsigned short val) throw (dom::DOMException)
{ restart = val; }
- // fillTypes
+ /**
+ * An integer indicating the value of the fill attribute.
+ */
typedef enum
{
FILL_REMOVE = 0,
FILL_FREEZE = 1
- } FillTypes;
+ } FillType;
/**
- *
+ * Get code representing the value of the fill attribute, as defined above.
+ * Default value is FILL_REMOVE.
*/
virtual unsigned short getFill()
{ return fill; }
/**
- *
+ * Set code representing the value of the fill attribute, as defined above.
*/
virtual void setFill(unsigned short val) throw (dom::DOMException)
{ fill = val; }
/**
- *
+ * The repeatCount attribute causes the element to play repeatedly (loop) for the
+ * specified number of times. A negative value repeat the element indefinitely.
+ * Default value is 0 (unspecified).
*/
virtual double getRepeatCount()
{ return repeatCount; }
/**
- *
+ * Set the value above.
*/
virtual void setRepeatCount(double val) throw (dom::DOMException)
{ repeatCount = val; }
/**
- *
+ * The repeatDur causes the element to play repeatedly (loop) for the specified
+ * duration in milliseconds. Negative means "indefinite".
*/
virtual double getRepeatDur()
{ return repeatDur; }
/**
- *
+ * Set the value above.
*/
virtual void setRepeatDur(double val) throw (dom::DOMException)
{ repeatDur = val; }
/**
- *
+ * Causes this element to begin the local timeline (subject to sync constraints).
*/
virtual bool beginElement()
{
}
/**
- *
+ * Causes this element to end the local timeline (subject to sync constraints).
*/
virtual bool endElement()
{
}
/**
- *
+ * Causes this element to pause the local timeline (subject to sync constraints).
*/
virtual void pauseElement()
{
}
/**
- *
+ * Causes this element to resume a paused local timeline.
*/
virtual void resumeElement()
{
}
/**
- *
+ * Seeks this element to the specified point on the local timeline (subject to
+ * sync constraints). If this is a timeline, this must seek the entire timeline
+ * (i.e. propagate to all timeChildren).
*/
virtual void seekElement(double &/*seekTo*/)
{
*
*/
ElementTime(const ElementTime &other)
+ {
+ assign(other);
+ }
+
+ /**
+ *
+ */
+ ElementTime &operator=(const ElementTime &other)
+ {
+ assign(other);
+ return *this;
+ }
+
+ /**
+ *
+ */
+ void assign(const ElementTime &other)
{
beginTime = other.beginTime;
endTime = other.endTime;
repeatCount = other.repeatCount;
repeatDur = other.repeatDur;
}
-
+
/**
*
*/
#########################################################################*/
/**
- *
+ * This interface support use-cases commonly associated with animation.
*/
class ElementTimeManipulation
{
public:
/**
- *
+ * Defines the playback speed of element time. The value is specified as a
+ * multiple of normal (parent time container) play speed. Legal values are signed
+ * floating point values. Zero values are not allowed. The default is 1.0 (no
+ * modification of speed).
*/
virtual double getSpeed()
{ return speed; }
+
/**
- *
+ * Sets the value above.
*/
virtual void setSpeed(double val) throw (dom::DOMException)
{ speed = val; }
+
/**
- *
+ * The percentage value of the simple acceleration of time for the element.
+ * Allowed values are from 0 to 100. Default value is 0 (no acceleration). The
+ * sum of the values for accelerate and decelerate must not exceed 100. If it
+ * does, the deceleration value will be reduced to make the sum legal.
*/
virtual double getAccelerate()
{ return accelerate; }
/**
- *
+ * Sets the value above.
*/
virtual void setAccelerate(double val) throw (dom::DOMException)
{ accelerate = val; }
/**
- *
+ * The percentage value of the simple decelerate of time for the element. Allowed
+ * values are from 0 to 100. Default value is 0 (no deceleration). The sum of the
+ * values for accelerate and decelerate must not exceed 100. If it does, the
+ * deceleration value will be reduced to make the sum legal.
*/
virtual double getDecelerate()
{ return decelerate; }
/**
- *
+ * Sets the value above.
*/
virtual void setDecelerate(double val) throw (dom::DOMException)
{ decelerate = val; }
/**
- *
+ * The autoReverse attribute controls the "play forwards then backwards"
+ * functionality. Default value is false.
*/
virtual bool getAutoReverse()
{ return autoReverse; }
/**
- *
+ * Sets the value above.
*/
virtual void setAutoReverse(bool val) throw (dom::DOMException)
{ autoReverse = val; }
*
*/
ElementTimeManipulation(const ElementTimeManipulation &other)
+ {
+ assign(other);
+ }
+
+ /**
+ *
+ */
+ ElementTimeManipulation &operator=(const ElementTimeManipulation &other)
+ {
+ assign(other);
+ return *this;
+ }
+
+ /**
+ *
+ */
+ void assign(const ElementTimeManipulation &other)
{
speed = other.speed;
accelerate = other.accelerate;
double speed;
double accelerate;
double decelerate;
- bool autoReverse;
+ bool autoReverse;
};
#########################################################################*/
/**
- *
+ * This is a placeholder - subject to change. This represents generic timelines.
*/
class ElementTimeContainer : public ElementTime
{
/**
- *
+ * A NodeList that contains all timed childrens of this node. If there
+ * are no timed children, the Nodelist is empty.
*/
virtual NodeList getTimeChildren()
{
}
/**
- *
+ * Returns a list of child elements active at the specified invocation.
*/
- virtual NodeList getActiveChildrenAt(double /*instant*/)
+ virtual NodeList getActiveChildrenAt(double /*instant_in_millis*/)
{
NodeList list;
return list;
#########################################################################*/
/**
- *
+ * The synchronization behavior extension.
*/
class ElementSyncBehavior
{
public:
/**
- *
+ * The runtime synchronization behavior for an element.
*/
virtual DOMString getSyncBehavior()
{ return syncBehavior; }
/**
- *
+ * The sync tolerance for the associated element. It has an effect only
+ * if the element has syncBehavior="locked".
*/
virtual double getSyncTolerance()
{ return syncTolerance; }
/**
- *
+ * Defines the default value for the runtime synchronization behavior
+ * for an element, and all descendents.
*/
virtual DOMString getDefaultSyncBehavior()
{ return defaultSyncBehavior; }
/**
- *
+ * Defines the default value for the sync tolerance for an element,
+ * and all descendents.
*/
virtual double getDefaultSyncTolerance()
{ return defaultSyncTolerance; }
/**
- *
+ * If set to true, forces the time container playback to sync to this element.
*/
virtual bool getSyncMaster()
{ return syncMaster; }
+
//##################
//# Non-API methods
//##################
*
*/
ElementSyncBehavior(const ElementSyncBehavior &other)
+ {
+ assign(other);
+ }
+
+ /**
+ *
+ */
+ ElementSyncBehavior &operator=(const ElementSyncBehavior &other)
+ {
+ assign(other);
+ return *this;
+ }
+
+ /**
+ *
+ */
+ void assign(const ElementSyncBehavior &other)
{
syncBehavior = other.syncBehavior;
syncTolerance = other.syncTolerance;
#########################################################################*/
/**
- *
+ * A parallel container defines a simple parallel time grouping in which multiple
+ * elements can play back at the same time.
*/
class ElementParallelTimeContainer : public ElementTimeContainer
{
public:
/**
- *
+ * Controls the end of the container.
*/
virtual DOMString getEndSync()
{ return endSync; }
/**
- *
+ * Controls the end of the container.
*/
virtual void setEndSync(const DOMString &val) throw (dom::DOMException)
{ endSync = val; }
/**
- *
+ * This method returns the implicit duration in seconds.
*/
virtual double getImplicitDuration()
{ return implicitDuration; }
ElementParallelTimeContainer(const ElementParallelTimeContainer &other)
: ElementTimeContainer(other)
{
+ assign(other);
+ }
+
+ /**
+ *
+ */
+ ElementParallelTimeContainer &operator=(const ElementParallelTimeContainer &other)
+ {
+ assign(other);
+ return *this;
+ }
+
+ /**
+ *
+ */
+ void assign(const ElementParallelTimeContainer &other)
+ {
endSync = other.endSync;
implicitDuration = other.implicitDuration;
}
#########################################################################*/
/**
- *
+ * A seq container defines a sequence of elements in which elements play
+ * one after the other.
*/
class ElementSequentialTimeContainer : public ElementTimeContainer
{
#########################################################################*/
/**
- *
+ * This interface defines a time container with semantics based upon par, but
+ * with the additional constraint that only one child element may play at a time.
*/
class ElementExclusiveTimeContainer : public ElementTimeContainer
{
public:
/**
- *
+ * Controls the end of the container.
*/
virtual DOMString getEndSync()
{ return endSync; }
/**
- *
+ * Controls the end of the container.
*/
virtual void setEndSync(const DOMString &val) throw (dom::DOMException)
{ endSync = val; }
/**
- *
+ * This should support another method to get the ordered collection of paused
+ * elements (the paused stack) at a given point in time.
*/
virtual NodeList getPausedElements()
{ return pausedElements; }
ElementExclusiveTimeContainer(const ElementExclusiveTimeContainer &other)
: ElementTimeContainer(other)
{
+ assign(other);
+ }
+
+ /**
+ *
+ */
+ ElementExclusiveTimeContainer &operator=(const ElementExclusiveTimeContainer &other)
+ {
+ assign(other);
+ return *this;
+ }
+
+ /**
+ *
+ */
+ void assign(const ElementExclusiveTimeContainer &other)
+ {
endSync = other.endSync;
pausedElements = other.pausedElements;
}
#########################################################################*/
/**
- *
+ * NOTE: need more info
*/
class ElementTimeControl
{
public:
/**
- *
+ * Causes this element to begin the local timeline (subject to sync constraints).
*/
virtual bool beginElement() throw(dom::DOMException)
{
}
/**
- *
+ * Causes this element to begin the local timeline (subject to sync constraints),
+ * at the passed offset from the current time when the method is called. If the
+ * offset is >= 0, the semantics are equivalent to an event-base begin with the
+ * specified offset. If the offset is < 0, the semantics are equivalent to
+ * beginElement(), but the element active duration is evaluated as though the
+ * element had begun at the passed (negative) offset from the current time when
+ * the method is called.
*/
virtual bool beginElementAt(double /*offset*/) throw(dom::DOMException)
{
}
/**
- *
+ * Causes this element to end the local timeline (subject to sync constraints).
*/
virtual bool endElement() throw(dom::DOMException)
{
}
/**
- *
+ * Causes this element to end the local timeline (subject to sync constraints) at
+ * the specified offset from the current time when the method is called.
*/
virtual bool endElementAt(double /*offset*/) throw(dom::DOMException)
{
#########################################################################*/
/**
- *
+ * This interface define the set of animation target extensions.
*/
class ElementTargetAttributes
{
/**
- *
+ * Get the name of the target attribute.
*/
virtual DOMString getAttributeName()
{ return attributeName; }
/**
- *
+ * Set the name of the target attribute.
*/
virtual void setAttributeName(const DOMString &val)
{ attributeName = val; }
+ /**
+ * A code representing the value of the attributeType attribute
+ */
typedef enum
{
ATTRIBUTE_TYPE_AUTO = 0,
ATTRIBUTE_TYPE_CSS = 1,
ATTRIBUTE_TYPE_XML = 2
- } AttributeTypes;
+ } AttributeType;
/**
- *
+ * Get the attribute type, as defined above.
*/
virtual unsigned short getAttributeType()
{ return attributeType; }
/**
- *
+ * Set the attribute type, as defined above.
*/
virtual void setAttributeType(unsigned short val)
{ attributeType = val; }
+
//##################
//# Non-API methods
//##################
*
*/
ElementTargetAttributes(const ElementTargetAttributes &other)
+ {
+ assign(other);
+ }
+
+ /**
+ *
+ */
+ ElementTargetAttributes &operator=(const ElementTargetAttributes &other)
+ {
+ assign(other);
+ return *this;
+ }
+
+ /**
+ *
+ */
+ void assign(const ElementTargetAttributes &other)
{
attributeName = other.attributeName;
attributeType = other.attributeType;
#########################################################################*/
/**
- *
+ * Defines the test attributes interface. See the Test attributes definition.
*/
class ElementTest
{
/**
- *
+ * Get the systemBitrate value.
*/
virtual long getSystemBitrate()
{ return systemBitrate; }
/**
- *
+ * Set the systemBitrate value.
*/
virtual void setSystemBitrate(long val) throw (dom::DOMException)
{ systemBitrate = val; }
/**
- *
+ * Get the systemCaptions value.
*/
virtual bool getSystemCaptions()
{ return systemCaptions; }
/**
- *
+ * Set the systemCaptions value.
*/
virtual void setSystemCaptions(bool val) throw (dom::DOMException)
{ systemCaptions = val; }
/**
- *
+ * Get the systemLanguage value.
*/
virtual DOMString getSystemLanguage()
{ return systemLanguage; }
/**
- *
+ * Set the systemLanguage value.
*/
virtual void setSystemLanguage(const DOMString &val) throw (dom::DOMException)
{ systemLanguage = val; }
/**
- *
+ * Get the systemRequired value.
*/
virtual bool getSystemRequired()
{ return systemRequired; }
/**
- *
+ * Get the systemScreenSize value.
*/
virtual bool getSystemScreenSize()
{ return systemScreenSize; }
/**
- *
+ * Get the systemScreenDepth value.
*/
virtual bool getSystemScreenDepth()
{ return systemScreenDepth; }
/**
- *
+ * Get the systemOverdubOrSubtitle value.
*/
virtual DOMString getSystemOverdubOrSubtitle()
{ return systemOverdubOrSubtitle; }
/**
- *
+ * Set the systemOverdubOrSubtitle value.
*/
virtual void setSystemOverdubOrSubtitle(const DOMString &val) throw (dom::DOMException)
{ systemOverdubOrSubtitle = val; }
/**
- *
+ * Get the systemAudioDesc value.
*/
virtual bool getSystemAudioDesc()
- { return systemBitrate; }
+ { return systemAudioDesc; }
/**
- *
+ * Set the systemOverdubOrSubtitle value.
*/
virtual void setSystemAudioDesc(bool val) throw (dom::DOMException)
{ systemAudioDesc = val; }
*/
ElementTest()
{
- systemBitrate = 0;
- systemCaptions = false;
- systemLanguage = "";
- systemRequired = false;
- systemScreenSize = false;
- systemScreenDepth = false;
- systemOverdubOrSubtitle = "";
- systemAudioDesc = false;
}
/**
*
*/
ElementTest(const ElementTest &other)
- {
+ {
+ assign(other);
+ }
+
+ /**
+ *
+ */
+ ElementTest &operator=(const ElementTest &other)
+ {
+ assign(other);
+ return *this;
+ }
+
+ /**
+ *
+ */
+ void assign(const ElementTest &other)
+ {
systemBitrate = other.systemBitrate;
systemCaptions = other.systemCaptions;
systemLanguage = other.systemLanguage;
systemScreenDepth = other.systemScreenDepth;
systemOverdubOrSubtitle = other.systemOverdubOrSubtitle;
systemAudioDesc = other.systemAudioDesc;
- }
+ }
/**
*
#########################################################################*/
/**
- *
+ * The TimeEvent interface provides specific contextual information associated
+ * with Time events.
*/
class TimeEvent : public events::Event
{
public:
/**
- *
+ * The view attribute identifies the AbstractView from which the event
+ * was generated.
*/
- virtual views::AbstractView getView()
+ virtual views::AbstractView &getView()
{ return view; }
/**
- *
+ * Specifies some detail information about the Event, depending on
+ * the type of event.
*/
virtual long getDetail()
{ return detail; }
/**
- *
+ * The initTimeEvent method is used to initialize the value of a TimeEvent
+ * created through the DocumentEvent interface. This method may only be called
+ * before the TimeEvent has been dispatched via the dispatchEvent method, though
+ * it may be called multiple times during that phase if necessary. If called
+ * multiple times, the final invocation takes precedence.
*/
virtual void initTimeEvent(const DOMString &/*typeArg*/,
const views::AbstractView */*viewArg*/,
*
*/
TimeEvent(const TimeEvent &other) : events::Event(other)
+ {
+ assign(other);
+ }
+
+ /**
+ *
+ */
+ TimeEvent &operator=(const TimeEvent &other)
+ {
+ assign(other);
+ return *this;
+ }
+
+ /**
+ *
+ */
+ void assign(const TimeEvent &other)
{
view = other.view;
detail = other.detail;
#########################################################################*/
/**
- *
+ * A SMIL document is the root of the SMIL Hierarchy and holds the entire
+ * content. Beside providing access to the hierarchy, it also provides some
+ * convenience methods for accessing certain sets of information from the document.
*/
class SMILDocument : virtual public Document,
public ElementSequentialTimeContainer
#########################################################################*/
/**
- *
+ * The SMILElement interface is the base for all SMIL element types. It follows
+ * the model of the HTMLElement in the HTML DOM, extending the base Element class
+ * to denote SMIL-specific elements.
*/
class SMILElement : virtual public Element
{
public:
/**
- *
+ * Get the unique ID
*/
virtual DOMString getId() =0;
/**
- *
+ * Set the unique ID
*/
virtual void setId(const DOMString &val) throw (dom::DOMException) =0;
#########################################################################*/
/**
- *
+ * Declares layout type for the document. See:
+ * http://www.w3.org/TR/2000/WD-smil-boston-20000225/layout.html#LayoutModuleNS-TheLayoutElement
*/
class SMILLayoutElement : virtual public SMILElement
{
public:
/**
- *
+ * The mime type of the layout langage used in this layout element.The default
+ * value of the type attribute is "text/smil-basic-layout".
*/
virtual DOMString getType() =0;
/**
- *
+ * true if the player can understand the mime type, false otherwise.
*/
virtual bool getResolved() =0;
#########################################################################*/
/**
- *
+ * Declares layout properties for the top-layout element. See:
+ * http://www.w3.org/TR/2000/WD-smil-boston-20000225/layout.html#LayoutModuleNS-TheTopLayoutElement
*/
class SMILTopLayoutElement : virtual public SMILElement,
virtual public ElementLayout
#########################################################################*/
/**
- *
+ * Declares layout properties for the root-layout element. See:
+ * http://www.w3.org/TR/2000/WD-smil-boston-20000225/layout.html#LayoutModuleNS-TheRootLayoutElement
*/
class SMILRootLayoutElement : virtual public SMILElement,
virtual public ElementLayout
#########################################################################*/
/**
- *
+ * Controls the position, size and scaling of media object elements. See:
+ * http://www.w3.org/TR/2000/WD-smil-boston-20000225/layout.html#LayoutModuleNS-TheRegionElement
*/
class SMILRegionElement : virtual public SMILElement,
virtual public ElementLayout
/**
- *
+ * Get the fit value
*/
virtual DOMString getFit() =0;
/**
- *
+ * Set the fit value
*/
virtual void setFit(const DOMString &val) throw (dom::DOMException) =0;
/**
- *
+ * Get the top value
*/
virtual DOMString getTop() =0;
/**
- *
+ * Set the top value
*/
virtual void setTop(const DOMString &val) throw (dom::DOMException) =0;
/**
- *
+ * Get the ZIndex value
*/
virtual long getZIndex() =0;
/**
- *
+ * Set the ZIndex value
*/
virtual void setZIndex(long val) throw (dom::DOMException) =0;
#########################################################################*/
/**
- *
+ * Declares media content.
*/
class SMILMediaElement : virtual public ElementTime,
virtual public SMILElement
/**
- *
+ * Get the "abstractAttr" value
*/
virtual DOMString getAbstractAttr() =0;
/**
- *
+ * Set the "abstractAttr" value
*/
virtual void setAbstractAttr(const DOMString &val) throw (dom::DOMException) =0;
/**
- *
+ * Get the "alt" value
*/
virtual DOMString getAlt() =0;
/**
- *
+ * Set the "alt" value
*/
virtual void setAlt(const DOMString &val) throw (dom::DOMException) =0;
/**
- *
+ * Get the "author" value
*/
virtual DOMString getAuthor() =0;
/**
- *
+ * Set the "author" value
*/
virtual void setAuthor(const DOMString &val) throw (dom::DOMException) =0;
/**
- *
+ * Get the "clipBegin" value
*/
virtual DOMString getClipBegin() =0;
/**
- *
+ * Set the "clipBegin" value
*/
virtual void setClipBegin(const DOMString &val) throw (dom::DOMException) =0;
/**
- *
+ * Get the "clipEnd" value
*/
virtual DOMString getClipEnd() =0;
/**
- *
+ * Set the "clipEnd" value
*/
virtual void setClipEnd(const DOMString &val) throw (dom::DOMException) =0;
/**
- *
+ * Get the "copyright" value
*/
virtual DOMString getCopyright() =0;
/**
- *
+ * Set the "copyright" value
*/
virtual void setCopyright(const DOMString &val) throw (dom::DOMException) =0;
/**
- *
+ * Get the "longdesc" value
*/
virtual DOMString getLongdesc() =0;
/**
- *
+ * Set the "longdesc" value
*/
virtual void setLongdesc(const DOMString &val) throw (dom::DOMException) =0;
/**
- *
+ * Get the "port" value
*/
virtual DOMString getPort() =0;
/**
- *
+ * Set the "port" value
*/
virtual void setPort(const DOMString &val) throw (dom::DOMException) =0;
/**
- *
+ * Get the "readIndex" value
*/
virtual DOMString getReadIndex() =0;
/**
- *
+ * Set the "readIndex" value
*/
virtual void setReadIndex(const DOMString &val) throw (dom::DOMException) =0;
/**
- *
+ * Get the "rtpFormat" value
*/
virtual DOMString getRtpformat() =0;
/**
- *
+ * Set the "readIndex" value
*/
virtual void setRtpformat(const DOMString &val) throw (dom::DOMException) =0;
/**
- *
+ * Get the "src" value
*/
virtual DOMString getSrc() =0;
/**
- *
+ * Set the "src" value
*/
virtual void setSrc(const DOMString &val) throw (dom::DOMException) =0;
/**
- *
+ * Get the "stripRepeat" value
*/
virtual DOMString getStripRepeat() =0;
/**
- *
+ * Set the "stripRepeat" value
*/
virtual void setStripRepeat(const DOMString &val) throw (dom::DOMException) =0;
/**
- *
+ * Get the "title" value
*/
virtual DOMString getTitle() =0;
/**
- *
+ * Set the "title" value
*/
virtual void setTitle(const DOMString &val) throw (dom::DOMException) =0;
/**
- *
+ * Get the "transport" value
*/
virtual DOMString getTransport() =0;
/**
- *
+ * Set the "transport" value
*/
virtual void setTransport(const DOMString &val) throw (dom::DOMException) =0;
/**
- *
+ * Get the "type" value
*/
virtual DOMString getType() =0;
/**
- *
+ * Set the "type" value
*/
virtual void setType(const DOMString &val) throw (dom::DOMException) =0;
#########################################################################*/
/**
- *
+ * Audio, video, etc
+ * NOTE: need more info
*/
class SMILRefElement : virtual public SMILMediaElement
{
#########################################################################*/
/**
- *
+ * This interface defines the set of animation extensions for SMIL.
*/
class SMILAnimation : virtual public SMILElement,
virtual public ElementTargetAttributes,
{
public:
+ /**
+ * Codes for the "additive" attribute
+ */
typedef enum
{
ADDITIVE_REPLACE = 0,
ADDITIVE_SUM = 1
- } AdditiveTypes;
+ } AdditiveType;
/**
- *
+ * A code representing the value of the additive attribute, as defined above.
+ * Default value is ADDITIVE_REPLACE.
*/
virtual unsigned short getAdditive() =0;
/**
- *
+ * Set the value above.
*/
virtual void setAdditive(unsigned short val) throw (dom::DOMException)=0;
+ /**
+ * Codes for the 'accumulate' attribute
+ */
typedef enum
{
ACCUMULATE_NONE = 0,
ACCUMULATE_SUM = 1
- } AccumulateTypes;
+ } AccumulateType;
/**
- *
+ * A code representing the value of the accumulate attribute, as defined above.
+ * Default value is ACCUMULATE_NONE.
*/
virtual unsigned short getAccumulate() =0;
/**
- *
+ * Set the value above
*/
virtual void setAccumulate(unsigned short val) throw (dom::DOMException)=0;
+ /**
+ * Codes for the "calcmode" attribute
+ */
typedef enum
{
CALCMODE_DISCRETE = 0,
CALCMODE_LINEAR = 1,
CALCMODE_PACED = 2,
CALCMODE_SPLINE = 3
- } CalcModeTypes;
+ } CalcModeType;
/**
- *
+ * A code representing the value of the calcMode attribute, as defined above.
*/
virtual unsigned short getCalcMode() =0;
/**
- *
+ * Set the value above.
*/
virtual void setCalcMode(unsigned short val) throw (dom::DOMException)=0;
/**
- *
+ * A DOMString representing the value of the keySplines attribute.
*/
virtual DOMString getKeySplines() =0;
/**
- *
+ * Set the value above.
*/
virtual void setKeySplines(const DOMString &val) throw (dom::DOMException)=0;
/**
- *
+ * Get a list of the time values of the keyTimes attribute.
*/
virtual TimeList getKeyTimes() =0;
/**
- *
+ * Set the list of the time value of the keyTimes attribute.
*/
virtual void setKeyTimes(const TimeList &val) throw (dom::DOMException)=0;
/**
- *
+ * Get a DOMString representing the value of the values attribute.
*/
virtual DOMString getValues() =0;
/**
- *
+ * Set the DOMString representing the value of the values attribute.
*/
virtual void setValues(const DOMString &val) throw (dom::DOMException)=0;
/**
- *
+ * Get a DOMString representing the value of the from attribute.
*/
virtual DOMString getFrom() =0;
/**
- *
+ * Set the DOMString representing the value of the from attribute.
*/
virtual void setFrom(const DOMString &val) throw (dom::DOMException)=0;
/**
- *
+ * Get a DOMString representing the value of the to attribute.
*/
virtual DOMString getTo() =0;
/**
- *
+ * Set the DOMString representing the value of the to attribute.
*/
virtual void setTo(const DOMString &val) throw (dom::DOMException)=0;
/**
- *
+ * Get a DOMString representing the value of the by attribute.
*/
virtual DOMString getBy() =0;
/**
- *
+ * Set the DOMString representing the value of the by attribute.
*/
virtual void setBy(const DOMString &val) throw (dom::DOMException)=0;
#########################################################################*/
/**
- *
+ * This interface represents the SMIL animate element.
*/
class SMILAnimateElement : virtual public SMILAnimation
{
#########################################################################*/
/**
- *
+ * This interface represents the set element.
*/
class SMILSetElement : virtual public ElementTimeControl,
virtual public ElementTime,
public:
/**
- *
+ * Specifies the value for the attribute during the duration of this element.
*/
virtual DOMString getTo() =0;
/**
- *
+ * Set the value above.
*/
virtual void setTo(const DOMString &val) =0;
#########################################################################*/
/**
- *
+ * This interface present the animationMotion element in SMIL.
*/
class SMILAnimateMotionElement : virtual public SMILAnimateElement
{
public:
/**
- *
+ * Specifies the curve that describes the attribute value as a function of time.
*/
virtual DOMString getPath() =0;
/**
- *
+ * Specifies the curve that describes the attribute value as a function of time.
*/
virtual void setPath(const DOMString &val) throw(dom::DOMException) =0;
/**
- *
+ * Specifies the origin of motion for the animation.
*/
virtual DOMString getOrigin() =0;
/**
- *
+ * Specifies the origin of motion for the animation.
*/
virtual void setOrigin(const DOMString &val) throw(dom::DOMException) =0;
#########################################################################*/
/**
- *
+ * This interface represents the SMIL animateColor element.
*/
class SMILAnimateColorElement : virtual public SMILAnimation
{
#########################################################################*/
/**
- *
+ * Defines a block of content control. See:
+ * http://www.w3.org/TR/2000/WD-smil-boston-20000225/content.html#ContentControlNS-SwitchElement
*/
class SMILSwitchElement : virtual public SMILElement
{
public:
/**
- *
+ * Returns the slected element at runtime. null if the selected element
+ * is not yet available.
*/
- virtual Element *getSelectedElement() =0;
+ virtual ElementPtr getSelectedElement() =0;
//##################
//# Non-API methods
diff --git a/src/dom/smilimpl.cpp b/src/dom/smilimpl.cpp
index d2f8278d6f98f1e248d29e18e86bdf316d8cd506..82bbe9d0ee7e6662fe96be60aa089125d9f0ca82 100644 (file)
--- a/src/dom/smilimpl.cpp
+++ b/src/dom/smilimpl.cpp
/**
*
*/
-void SMILElementImpl::setId(const DOMString &val) throw (dom::DOMException)
+void SMILElementImpl::setId(const DOMString &/*val*/) throw (dom::DOMException)
{
}
/**
*
*/
-void SMILRegionElementImpl::setFit(const DOMString &val) throw (dom::DOMException)
+void SMILRegionElementImpl::setFit(const DOMString &/*val*/) throw (dom::DOMException)
{
}
/**
*
*/
-void SMILRegionElementImpl::setTop(const DOMString &val) throw (dom::DOMException)
+void SMILRegionElementImpl::setTop(const DOMString &/*val*/) throw (dom::DOMException)
{
}
/**
*
*/
-void SMILRegionElementImpl::setZIndex(long val) throw (dom::DOMException)
+void SMILRegionElementImpl::setZIndex(long /*val*/) throw (dom::DOMException)
{
}
/**
*
*/
-void SMILMediaElementImpl::setAbstractAttr(const DOMString &val)
+void SMILMediaElementImpl::setAbstractAttr(const DOMString &/*val*/)
throw (dom::DOMException)
{
}
/**
*
*/
-void SMILMediaElementImpl::setAlt(const DOMString &val)
+void SMILMediaElementImpl::setAlt(const DOMString &/*val*/)
throw (dom::DOMException)
{
}
/**
*
*/
-void SMILMediaElementImpl::setAuthor(const DOMString &val)
+void SMILMediaElementImpl::setAuthor(const DOMString &/*val*/)
throw (dom::DOMException)
{
}
/**
*
*/
-void SMILMediaElementImpl::setClipBegin(const DOMString &val)
+void SMILMediaElementImpl::setClipBegin(const DOMString &/*val*/)
throw (dom::DOMException)
{
}
/**
*
*/
-void SMILMediaElementImpl::setClipEnd(const DOMString &val)
+void SMILMediaElementImpl::setClipEnd(const DOMString &/*val*/)
throw (dom::DOMException)
{
}
/**
*
*/
-void SMILMediaElementImpl::setCopyright(const DOMString &val)
+void SMILMediaElementImpl::setCopyright(const DOMString &/*val*/)
throw (dom::DOMException)
{
}
/**
*
*/
-void SMILMediaElementImpl::setLongdesc(const DOMString &val)
+void SMILMediaElementImpl::setLongdesc(const DOMString &/*val*/)
throw (dom::DOMException)
{
}
/**
*
*/
-void SMILMediaElementImpl::setPort(const DOMString &val)
+void SMILMediaElementImpl::setPort(const DOMString &/*val*/)
throw (dom::DOMException)
{
}
/**
*
*/
-void SMILMediaElementImpl::setReadIndex(const DOMString &val)
+void SMILMediaElementImpl::setReadIndex(const DOMString &/*val*/)
throw (dom::DOMException)
{
}
/**
*
*/
-void SMILMediaElementImpl::setRtpformat(const DOMString &val)
+void SMILMediaElementImpl::setRtpformat(const DOMString &/*val*/)
throw (dom::DOMException)
{
}
/**
*
*/
-void SMILMediaElementImpl::setSrc(const DOMString &val)
+void SMILMediaElementImpl::setSrc(const DOMString &/*val*/)
throw (dom::DOMException)
{
}
/**
*
*/
-void SMILMediaElementImpl::setStripRepeat(const DOMString &val)
+void SMILMediaElementImpl::setStripRepeat(const DOMString &/*val*/)
throw (dom::DOMException)
{
}
/**
*
*/
-void SMILMediaElementImpl::setTitle(const DOMString &val)
+void SMILMediaElementImpl::setTitle(const DOMString &/*val*/)
throw (dom::DOMException)
{
}
/**
*
*/
-void SMILMediaElementImpl::setTransport(const DOMString &val)
+void SMILMediaElementImpl::setTransport(const DOMString &/*val*/)
throw (dom::DOMException)
{
}
/**
*
*/
-void SMILMediaElementImpl::setType(const DOMString &val)
+void SMILMediaElementImpl::setType(const DOMString &/*val*/)
throw (dom::DOMException)
{
}
/**
*
*/
-void SMILAnimationImpl::setAdditive(unsigned short val)
+void SMILAnimationImpl::setAdditive(unsigned short /*val*/)
throw (dom::DOMException)
{
}
/**
*
*/
-void SMILAnimationImpl::setAccumulate(unsigned short val)
+void SMILAnimationImpl::setAccumulate(unsigned short /*val*/)
throw (dom::DOMException)
{
}
/**
*
*/
-void SMILAnimationImpl::setCalcMode(unsigned short val)
+void SMILAnimationImpl::setCalcMode(unsigned short /*val*/)
throw (dom::DOMException)
{
}
/**
*
*/
-void SMILAnimationImpl::setKeySplines(const DOMString &val)
+void SMILAnimationImpl::setKeySplines(const DOMString &/*val*/)
throw (dom::DOMException)
{
}
/**
*
*/
-void SMILAnimationImpl::setValues(const DOMString &val)
+void SMILAnimationImpl::setValues(const DOMString &/*val*/)
throw (dom::DOMException)
{
}
/**
*
*/
-void SMILAnimationImpl::setFrom(const DOMString &val)
+void SMILAnimationImpl::setFrom(const DOMString &/*val*/)
throw (dom::DOMException)
{
}
/**
*
*/
-void SMILAnimationImpl::setTo(const DOMString &val)
+void SMILAnimationImpl::setTo(const DOMString &/*val*/)
throw (dom::DOMException)
{
}
/**
*
*/
-void SMILAnimationImpl::setBy(const DOMString &val)
+void SMILAnimationImpl::setBy(const DOMString &/*val*/)
throw (dom::DOMException)
{
}
/**
*
*/
-void SMILSetElementImpl::setTo(const DOMString &val)
+void SMILSetElementImpl::setTo(const DOMString &/*val*/)
{
}
/**
*
*/
-void SMILAnimateMotionElementImpl::setPath(const DOMString &val)
+void SMILAnimateMotionElementImpl::setPath(const DOMString &/*val*/)
throw(dom::DOMException)
{
}
/**
*
*/
-void SMILAnimateMotionElementImpl::setOrigin(const DOMString &val)
+void SMILAnimateMotionElementImpl::setOrigin(const DOMString &/*val*/)
throw(dom::DOMException)
{
}
/**
*
*/
-Element *SMILSwitchElementImpl::getSelectedElement()
+ElementPtr SMILSwitchElementImpl::getSelectedElement()
{
- return NULL;
+ ElementPtr ptr;
+ return ptr;
}
//##################
diff --git a/src/dom/smilimpl.h b/src/dom/smilimpl.h
index 7c1a014dc6901aaa66a958d8eccea56e2a60216b..cb06eb5f58b3ab5cbaa07b716f049d387895b31a 100644 (file)
--- a/src/dom/smilimpl.h
+++ b/src/dom/smilimpl.h
/**
*
*/
- virtual Element *getSelectedElement();
+ virtual ElementPtr getSelectedElement();
//##################
//# Non-API methods
diff --git a/src/dom/svgimpl.h b/src/dom/svgimpl.h
index 5c2e78f1b9494343383bc7361935a6175bb74cbe..2ea09be3caeb49cdbda350302592a6e690bf7d49 100644 (file)
--- a/src/dom/svgimpl.h
+++ b/src/dom/svgimpl.h
* Authors:
* Bob Jamison
*
- * Copyright (C) 2006 Bob Jamison
+ * Copyright (C) 2006-2008 Bob Jamison
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public