From 87b809585b4f9d888e504f36d2794891bb9c78d0 Mon Sep 17 00:00:00 2001 From: ishmal Date: Mon, 16 Jun 2008 16:58:11 +0000 Subject: [PATCH] Merge interfaces and element types --- src/dom/svg2.h | 6901 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 6901 insertions(+) diff --git a/src/dom/svg2.h b/src/dom/svg2.h index 0da3d861d..4f9b78ecb 100644 --- a/src/dom/svg2.h +++ b/src/dom/svg2.h @@ -92,6 +92,6907 @@ typedef Ptr SVGElementPtr; class SVGDocument; typedef Ptr SVGDocumentPtr; +//######################################################################## +//######################################################################## +//######################################################################## +//# I N T E R F A C E S +//######################################################################## +//######################################################################## +//######################################################################## + + + +/*######################################################################### +## SVGMatrix +#########################################################################*/ + +/** + * In SVG, a Matrix is defined like this: + * + * | a c e | + * | b d f | + * | 0 0 1 | + * + */ +class SVGMatrix +{ +public: + + + /** + * + */ + virtual double getA() + { return a; } + + /** + * + */ + virtual void setA(double val) throw (DOMException) + { a = val; } + + /** + * + */ + virtual double getB() + { return b; } + + /** + * + */ + virtual void setB(double val) throw (DOMException) + { b = val; } + + /** + * + */ + virtual double getC() + { return c; } + + /** + * + */ + virtual void setC(double val) throw (DOMException) + { c = val; } + + /** + * + */ + virtual double getD() + { return d; } + + /** + * + */ + virtual void setD(double val) throw (DOMException) + { d = val; } + /** + * + */ + virtual double getE() + { return e; } + + /** + * + */ + virtual void setE(double val) throw (DOMException) + { e = val; } + /** + * + */ + virtual double getF() + { return f; } + + /** + * + */ + virtual void setF(double val) throw (DOMException) + { f = val; } + + + /** + * Return the result of postmultiplying this matrix with another. + */ + virtual SVGMatrix multiply(const SVGMatrix &other) + { + SVGMatrix result; + result.a = a * other.a + c * other.b; + result.b = b * other.a + d * other.b; + result.c = a * other.c + c * other.d; + result.d = b * other.c + d * other.d; + result.e = a * other.e + c * other.f + e; + result.f = b * other.e + d * other.f + f; + return result; + } + + /** + * Calculate the inverse of this matrix + * + */ + virtual SVGMatrix inverse( ) throw( SVGException ) + { + /*########################################### + The determinant of a 3x3 matrix E + (let's use our own notation for a bit) + + A B C + D E F + G H I + is + AEI - AFH - BDI + BFG + CDH - CEG + + Since in our affine transforms, G and H==0 and I==1, + this reduces to: + AE - BD + In SVG's naming scheme, that is: a * d - c * b . SIMPLE! + + In a similar method of attack, SVG's adjunct matrix is: + + d -c cf-ed + -b a eb-af + 0 0 ad-cb + + To get the inverse matrix, we divide the adjunct matrix by + the determinant. Notice that (ad-cb)/(ad-cb)==1. Very cool. + So what we end up with is this: + + a = d/(ad-cb) c = -c/(ad-cb) e = (cf-ed)/(ad-cb) + b = -b/(ad-cb) d = a/(ad-cb) f = (eb-af)/(ad-cb) + + (Since this would be in all SVG-DOM implementations, + somebody needed to document this! ^^ ) + #############################################*/ + + SVGMatrix result; + double determinant = a * d - c * b; + if (determinant < 1.0e-18)//invertible? + { + result.identity();//cop out + return result; + } + + double idet = 1.0 / determinant; + result.a = d * idet; + result.b = -b * idet; + result.c = -c * idet; + result.d = a * idet; + result.e = (c*f - e*d) * idet; + result.f = (e*b - a*f) * idet; + return result; + } + + /** + * Equivalent to multiplying by: + * | 1 0 x | + * | 0 1 y | + * | 0 0 1 | + * + */ + virtual SVGMatrix translate(double x, double y ) + { + SVGMatrix result; + result.a = a; + result.b = b; + result.c = c; + result.d = d; + result.e = a * x + c * y + e; + result.f = b * x + d * y + f; + return result; + } + + /** + * Equivalent to multiplying by: + * | scale 0 0 | + * | 0 scale 0 | + * | 0 0 1 | + * + */ + virtual SVGMatrix scale(double scale) + { + SVGMatrix result; + result.a = a * scale; + result.b = b * scale; + result.c = c * scale; + result.d = d * scale; + result.e = e; + result.f = f; + return result; + } + + /** + * Equivalent to multiplying by: + * | scaleX 0 0 | + * | 0 scaleY 0 | + * | 0 0 1 | + * + */ + virtual SVGMatrix scaleNonUniform(double scaleX, + double scaleY ) + { + SVGMatrix result; + result.a = a * scaleX; + result.b = b * scaleX; + result.c = c * scaleY; + result.d = d * scaleY; + result.e = e; + result.f = f; + return result; + } + + /** + * Equivalent to multiplying by: + * | cos(a) -sin(a) 0 | + * | sin(a) cos(a) 0 | + * | 0 0 1 | + * + */ + virtual SVGMatrix rotate (double angle) + { + double sina = sin(angle); + double msina = -sina; + double cosa = cos(angle); + SVGMatrix result; + result.a = a * cosa + c * sina; + result.b = b * cosa + d + sina; + result.c = a * msina + c * cosa; + result.d = b * msina + d * cosa; + result.e = e; + result.f = f; + return result; + } + + /** + * Equivalent to multiplying by: + * | cos(a) -sin(a) 0 | + * | sin(a) cos(a) 0 | + * | 0 0 1 | + * In this case, angle 'a' is computed as the artangent + * of the slope y/x . It is negative if the slope is negative. + */ + virtual SVGMatrix rotateFromVector(double x, double y) + throw( SVGException ) + { + double angle = atan(y / x); + if (y < 0.0) + angle = -angle; + SVGMatrix result; + double sina = sin(angle); + double msina = -sina; + double cosa = cos(angle); + result.a = a * cosa + c * sina; + result.b = b * cosa + d + sina; + result.c = a * msina + c * cosa; + result.d = b * msina + d * cosa; + result.e = e; + result.f = f; + return result; + } + + /** + * Equivalent to multiplying by: + * | -1 0 0 | + * | 0 1 0 | + * | 0 0 1 | + * + */ + virtual SVGMatrix flipX( ) + { + SVGMatrix result; + result.a = -a; + result.b = -b; + result.c = c; + result.d = d; + result.e = e; + result.f = f; + return result; + } + + /** + * Equivalent to multiplying by: + * | 1 0 0 | + * | 0 -1 0 | + * | 0 0 1 | + * + */ + virtual SVGMatrix flipY( ) + { + SVGMatrix result; + result.a = a; + result.b = b; + result.c = -c; + result.d = -d; + result.e = e; + result.f = f; + return result; + } + + /** + * | 1 tan(a) 0 | + * | 0 1 0 | + * | 0 0 1 | + * + */ + virtual SVGMatrix skewX(double angle) + { + double tana = tan(angle); + SVGMatrix result; + result.a = a; + result.b = b; + result.c = a * tana + c; + result.d = b * tana + d; + result.e = e; + result.f = f; + return result; + } + + /** + * Equivalent to multiplying by: + * | 1 0 0 | + * | tan(a) 1 0 | + * | 0 0 1 | + * + */ + virtual SVGMatrix skewY(double angle) + { + double tana = tan(angle); + SVGMatrix result; + result.a = a + c * tana; + result.b = b + d * tana; + result.c = c; + result.d = d; + result.e = e; + result.f = f; + return result; + } + + + + //################## + //# Non-API methods + //################## + + /** + * + */ + SVGMatrix() + { + identity(); + } + + /** + * + */ + SVGMatrix(double aArg, double bArg, double cArg, + double dArg, double eArg, double fArg ) + { + a = aArg; b = bArg; c = cArg; + d = dArg; e = eArg; f = fArg; + } + + /** + * Copy constructor + */ + SVGMatrix(const SVGMatrix &other) + { + a = other.a; + b = other.b; + c = other.c; + d = other.d; + e = other.e; + f = other.f; + } + + + + /** + * + */ + virtual ~SVGMatrix() {} + +protected: + +friend class SVGTransform; + + /* + * Set to the identify matrix + */ + void identity() + { + a = 1.0; + b = 0.0; + c = 0.0; + d = 1.0; + e = 0.0; + f = 0.0; + } + + double a, b, c, d, e, f; + +}; + + +/*######################################################################### +## SVGTransform +#########################################################################*/ + +/** + * + */ +class SVGTransform +{ +public: + + /** + * Transform Types + */ + typedef enum + { + SVG_TRANSFORM_UNKNOWN = 0, + SVG_TRANSFORM_MATRIX = 1, + SVG_TRANSFORM_TRANSLATE = 2, + SVG_TRANSFORM_SCALE = 3, + SVG_TRANSFORM_ROTATE = 4, + SVG_TRANSFORM_SKEWX = 5, + SVG_TRANSFORM_SKEWY = 6, + } TransformType; + + /** + * + */ + virtual unsigned short getType() + { return type; } + + + /** + * + */ + virtual SVGMatrix getMatrix() + { + return matrix; + } + + /** + * + */ + virtual double getAngle() + { + return angle; + } + + + /** + * + */ + virtual void setMatrix(const SVGMatrix &matrixArg) + { + type = SVG_TRANSFORM_MATRIX; + matrix = matrixArg; + } + + /** + * + */ + virtual void setTranslate (double tx, double ty ) + { + type = SVG_TRANSFORM_TRANSLATE; + matrix.setA(1.0); + matrix.setB(0.0); + matrix.setC(0.0); + matrix.setD(1.0); + matrix.setE(tx); + matrix.setF(ty); + } + + /** + * + */ + virtual void setScale (double sx, double sy ) + { + type = SVG_TRANSFORM_SCALE; + matrix.setA(sx); + matrix.setB(0.0); + matrix.setC(0.0); + matrix.setD(sy); + matrix.setE(0.0); + matrix.setF(0.0); + } + + /** + * + */ + virtual void setRotate (double angleArg, double cx, double cy) + { + angle = angleArg; + setTranslate(cx, cy); + type = SVG_TRANSFORM_ROTATE; + matrix.rotate(angle); + } + + /** + * + */ + virtual void setSkewX (double angleArg) + { + angle = angleArg; + type = SVG_TRANSFORM_SKEWX; + matrix.identity(); + matrix.skewX(angle); + } + + /** + * + */ + virtual void setSkewY (double angleArg) + { + angle = angleArg; + type = SVG_TRANSFORM_SKEWY; + matrix.identity(); + matrix.skewY(angle); + } + + + //################## + //# Non-API methods + //################## + + /** + * + */ + SVGTransform() + { + type = SVG_TRANSFORM_UNKNOWN; + angle = 0.0; + } + + /** + * + */ + SVGTransform(const SVGTransform &other) + { + type = other.type; + angle = other.angle; + matrix = other.matrix; + } + + /** + * + */ + virtual ~SVGTransform() + {} + +protected: + + int type; + double angle; + + SVGMatrix matrix; +}; + + + + + + +/*######################################################################### +## SVGTransformList +#########################################################################*/ + +/** + * + */ +class SVGTransformList +{ +public: + + + /** + * + */ + virtual unsigned long getNumberOfItems() + { return items.size(); } + + + /** + * + */ + virtual void clear( ) throw( DOMException ) + { items.clear(); } + + /** + * + */ + virtual SVGTransform initialize (const SVGTransform &newItem) + throw( DOMException, SVGException ) + { + items.clear(); + items.push_back(newItem); + return newItem; + } + + /** + * + */ + virtual SVGTransform getItem (unsigned long index ) + throw( DOMException ) + { + if (index>=items.size()) + { + SVGTransform transform; + return transform; + } + return items[index]; + } + + /** + * + */ + virtual SVGTransform insertItemBefore (const SVGTransform &newItem, + unsigned long index ) + throw( DOMException, SVGException ) + { + if (index > items.size()) + items.push_back(newItem); + else + { + std::vector::iterator iter = items.begin() + index; + items.insert(iter, newItem); + } + return newItem; + } + + /** + * + */ + virtual SVGTransform replaceItem (const SVGTransform &newItem, + unsigned long index ) + throw( DOMException, SVGException ) + { + if (index>=items.size()) + { + SVGTransform transform; + return transform; + } + else + { + std::vector::iterator iter = items.begin() + index; + *iter = newItem; + } + return newItem; + } + + /** + * + */ + virtual SVGTransform removeItem (unsigned long index ) + throw( DOMException ) + { + if (index>=items.size()) + { + SVGTransform transform; + return transform; + } + std::vector::iterator iter = items.begin() + index; + SVGTransform oldItem = *iter; + items.erase(iter); + return oldItem; + } + + /** + * + */ + virtual SVGTransform appendItem (const SVGTransform &newItem) + throw( DOMException, SVGException ) + { + items.push_back(newItem); + return newItem; + } + + /** + * + */ + virtual SVGTransform createSVGTransformFromMatrix(const SVGMatrix &matrix) + { + SVGTransform transform; + transform.setMatrix(matrix); + return transform; + } + + /** + * + */ + virtual SVGTransform consolidate() + { + SVGMatrix matrix; + for (unsigned int i=0 ; i items; + +}; + + + + + + +/*######################################################################### +## SVGAnimatedTransformList +#########################################################################*/ + +/** + * + */ +class SVGAnimatedTransformList +{ +public: + + /** + * + */ + virtual SVGTransformList getBaseVal() + { return baseVal; } + + /** + * + */ + virtual SVGTransformList getAnimVal() + { return animVal; } + + + + //################## + //# Non-API methods + //################## + + /** + * + */ + SVGAnimatedTransformList() + {} + + /** + * + */ + SVGAnimatedTransformList(const SVGAnimatedTransformList &other) + { + baseVal = other.baseVal; + animVal = other.animVal; + } + + /** + * + */ + virtual ~SVGAnimatedTransformList() {} + +protected: + + SVGTransformList baseVal; + SVGTransformList animVal; + +}; + + + + +/*######################################################################### +## SVGAnimatedBoolean +#########################################################################*/ + +/** + * + */ +class SVGAnimatedBoolean +{ +public: + + /** + * + */ + virtual bool getBaseVal() + { + return baseVal; + } + + /** + * + */ + virtual void setBaseVal(bool val) throw (DOMException) + { + baseVal = val; + } + + /** + * + */ + virtual bool getAnimVal() + { + return animVal; + } + + + //################## + //# Non-API methods + //################## + + /** + * + */ + SVGAnimatedBoolean() + { + baseVal = animVal = false; + } + + /** + * + */ + SVGAnimatedBoolean(const SVGAnimatedBoolean &other) + { + baseVal = other.baseVal; + animVal = other.animVal; + } + + /** + * + */ + virtual ~SVGAnimatedBoolean() {} + +protected: + + bool baseVal, animVal; + +}; + + + + +/*######################################################################### +## SVGAnimatedString +#########################################################################*/ + +/** + * + */ +class SVGAnimatedString +{ +public: + + /** + * + */ + virtual DOMString getBaseVal() + { + return baseVal; + } + + /** + * + */ + virtual void setBaseVal(const DOMString &val) + throw (DOMException) + { + baseVal = val; + } + + /** + * + */ + virtual DOMString getAnimVal() + { + return animVal; + } + + + //################## + //# Non-API methods + //################## + + + /** + * + */ + SVGAnimatedString() + { + baseVal = ""; + animVal = ""; + } + + /** + * + */ + SVGAnimatedString(const SVGAnimatedString &other) + { + baseVal = other.baseVal; + animVal = other.animVal; + } + + /** + * + */ + virtual ~SVGAnimatedString() {} + +protected: + + DOMString baseVal, animVal; + +}; + + + + + +/*######################################################################### +## SVGStringList +#########################################################################*/ + +/** + * + */ +class SVGStringList +{ +public: + + + /** + * + */ + virtual unsigned long getNumberOfItems() + { + return items.size(); + } + + /** + * + */ + virtual void clear () throw( DOMException ) + { + items.clear(); + } + + /** + * + */ + virtual DOMString initialize ( const DOMString& newItem ) + throw( DOMException, SVGException ) + { + items.clear(); + items.push_back(newItem); + return newItem; + } + + /** + * + */ + virtual DOMString getItem ( unsigned long index ) + throw( DOMException ) + { + if (index >= items.size()) + return ""; + return items[index]; + } + + /** + * + */ + virtual DOMString insertItemBefore ( const DOMString& newItem, + unsigned long index ) + throw( DOMException, SVGException ) + { + if (index>=items.size()) + { + items.push_back(newItem); + } + else + { + std::vector::iterator iter = items.begin() + index; + items.insert(iter, newItem); + } + return newItem; + } + + /** + * + */ + virtual DOMString replaceItem ( const DOMString& newItem, + unsigned long index ) + throw( DOMException, SVGException ) + { + if (index>=items.size()) + return ""; + std::vector::iterator iter = items.begin() + index; + *iter = newItem; + return newItem; + } + + /** + * + */ + virtual DOMString removeItem ( unsigned long index ) + throw( DOMException ) + { + if (index>=items.size()) + return ""; + std::vector::iterator iter = items.begin() + index; + DOMString oldstr = *iter; + items.erase(iter); + return oldstr; + } + + /** + * + */ + virtual DOMString appendItem ( const DOMString& newItem ) + throw( DOMException, SVGException ) + { + items.push_back(newItem); + return newItem; + } + + + + //################## + //# Non-API methods + //################## + + /** + * + */ + SVGStringList() {} + + /** + * + */ + SVGStringList(const SVGStringList &other) + { + items = other.items; + } + + /** + * + */ + virtual ~SVGStringList() {} + +protected: + + std::vectoritems; + +}; + + + + + +/*######################################################################### +## SVGAnimatedEnumeration +#########################################################################*/ + +/** + * + */ +class SVGAnimatedEnumeration +{ +public: + + /** + * + */ + virtual unsigned short getBaseVal() + { + return baseVal; + } + + /** + * + */ + virtual void setBaseVal(unsigned short val) + throw (DOMException) + { + baseVal = val; + } + + /** + * + */ + virtual unsigned short getAnimVal() + { + return animVal; + } + + + + //################## + //# Non-API methods + //################## + + + /** + * + */ + SVGAnimatedEnumeration() + { + baseVal = animVal = 0; + } + + /** + * + */ + SVGAnimatedEnumeration(const SVGAnimatedEnumeration &other) + { + baseVal = other.baseVal; + animVal = other.animVal; + } + + /** + * + */ + virtual ~SVGAnimatedEnumeration() {} + +protected: + + int baseVal, animVal; + +}; + + + + + +/*######################################################################### +## SVGAnimatedInteger +#########################################################################*/ + +/** + * + */ +class SVGAnimatedInteger +{ +public: + + + /** + * + */ + virtual long getBaseVal() + { + return baseVal; + } + + /** + * + */ + virtual void setBaseVal(long val) throw (DOMException) + { + baseVal = val; + } + + /** + * + */ + virtual long getAnimVal() + { + return animVal; + } + + + + //################## + //# Non-API methods + //################## + + + /** + * + */ + SVGAnimatedInteger() + { baseVal = animVal = 0L;} + + + /** + * + */ + SVGAnimatedInteger(long value) + { + baseVal = value; + animVal = 0L; + } + + /** + * + */ + SVGAnimatedInteger(long baseValArg, long animValArg) + { + baseVal = baseValArg; + animVal = animValArg; + } + + + /** + * + */ + SVGAnimatedInteger(const SVGAnimatedInteger &other) + { + baseVal = other.baseVal; + animVal = other.animVal; + } + + /** + * + */ + virtual ~SVGAnimatedInteger() {} + +protected: + + long baseVal, animVal; + +}; + + + + + +/*######################################################################### +## SVGNumber +#########################################################################*/ + +/** + * + */ +class SVGNumber +{ +public: + + + /** + * + */ + virtual double getValue() + { + return value; + } + + /** + * + */ + virtual void setValue(double val) throw (DOMException) + { + value = val; + } + + + //################## + //# Non-API methods + //################## + + /** + * + */ + SVGNumber() + { + value = 0.0; + } + + /** + * + */ + SVGNumber(const SVGNumber &other) + { + value = other.value; + } + + /** + * + */ + virtual ~SVGNumber() {} + +protected: + + double value; + +}; + + + + + +/*######################################################################### +## SVGAnimatedNumber +#########################################################################*/ + +/** + * + */ +class SVGAnimatedNumber +{ +public: + + + + /** + * + */ + virtual double getBaseVal() + { + return baseVal; + } + + /** + * + */ + virtual void setBaseVal(double val) throw (DOMException) + { + baseVal = val; + } + + /** + * + */ + virtual double getAnimVal() + { + return animVal; + } + + + + //################## + //# Non-API methods + //################## + + /** + * + */ + SVGAnimatedNumber() + { + baseVal = animVal = 0.0; + } + + + /** + * + */ + SVGAnimatedNumber(double val) + { + baseVal = val; + animVal = 0.0; + } + + + /** + * + */ + SVGAnimatedNumber(double baseValArg, double animValArg) + { + baseVal = baseValArg; + animVal = animValArg; + } + + /** + * + */ + SVGAnimatedNumber(const SVGAnimatedNumber &other) + { + baseVal = other.baseVal; + animVal = other.animVal; + } + + /** + * + */ + virtual ~SVGAnimatedNumber() {} + +protected: + + double baseVal, animVal; + +}; + + + + + +/*######################################################################### +## SVGNumberList +#########################################################################*/ + +/** + * + */ +class SVGNumberList +{ +public: + + /** + * + */ + virtual unsigned long getNumberOfItems() + { + return items.size(); + } + + + /** + * + */ + virtual void clear() throw( DOMException ) + { + items.clear(); + } + + /** + * + */ + virtual SVGNumber initialize (const SVGNumber &newItem) + throw( DOMException, SVGException ) + { + items.clear(); + items.push_back(newItem); + return newItem; + } + + /** + * + */ + virtual SVGNumber getItem ( unsigned long index ) + throw( DOMException ) + { + if (index>=items.size()) + { + SVGNumber num; + return num; + } + return items[index]; + } + + /** + * + */ + virtual SVGNumber insertItemBefore ( const SVGNumber &newItem, + unsigned long index ) + throw( DOMException, SVGException ) + { + if (index>=items.size()) + { + items.push_back(newItem); + } + else + { + std::vector::iterator iter = items.begin() + index; + items.insert(iter, newItem); + } + return newItem; + } + + /** + * + */ + virtual SVGNumber replaceItem ( const SVGNumber &newItem, + unsigned long index ) + throw( DOMException, SVGException ) + { + if (index>=items.size()) + { + SVGNumber num; + return num; + } + std::vector::iterator iter = items.begin() + index; + *iter = newItem; + return newItem; + } + + /** + * + */ + virtual SVGNumber removeItem ( unsigned long index ) + throw( DOMException ) + { + if (index>=items.size()) + { + SVGNumber num; + return num; + } + std::vector::iterator iter = items.begin() + index; + SVGNumber oldval = *iter; + items.erase(iter); + return oldval; + } + + /** + * + */ + virtual SVGNumber appendItem ( const SVGNumber &newItem ) + throw( DOMException, SVGException ) + { + items.push_back(newItem); + return newItem; + } + + + //################## + //# Non-API methods + //################## + + /** + * + */ + SVGNumberList() {} + + /** + * + */ + SVGNumberList(const SVGNumberList &other) + { + items = other.items; + } + + /** + * + */ + virtual ~SVGNumberList() {} + +protected: + + std::vectoritems; + +}; + + + + + +/*######################################################################### +## SVGAnimatedNumberList +#########################################################################*/ + +/** + * + */ +class SVGAnimatedNumberList +{ +public: + + + /** + * + */ + virtual SVGNumberList &getBaseVal() + { + return baseVal; + } + + /** + * + */ + virtual SVGNumberList &getAnimVal() + { + return animVal; + } + + + + //################## + //# Non-API methods + //################## + + /** + * + */ + SVGAnimatedNumberList() {} + + /** + * + */ + SVGAnimatedNumberList(const SVGAnimatedNumberList &other) + { + baseVal = other.baseVal; + animVal = other.animVal; + } + + /** + * + */ + virtual ~SVGAnimatedNumberList() {} + +protected: + + SVGNumberList baseVal; + SVGNumberList animVal; + +}; + + + + + + +/*######################################################################### +## SVGLength +#########################################################################*/ + +/** + * + */ +class SVGLength +{ +public: + + /** + * Length Unit Types + */ + typedef enum + { + SVG_LENGTHTYPE_UNKNOWN = 0, + SVG_LENGTHTYPE_NUMBER = 1, + SVG_LENGTHTYPE_PERCENTAGE = 2, + SVG_LENGTHTYPE_EMS = 3, + SVG_LENGTHTYPE_EXS = 4, + SVG_LENGTHTYPE_PX = 5, + SVG_LENGTHTYPE_CM = 6, + SVG_LENGTHTYPE_MM = 7, + SVG_LENGTHTYPE_IN = 8, + SVG_LENGTHTYPE_PT = 9, + SVG_LENGTHTYPE_PC = 10 + } LengthUnitType; + + + /** + * + */ + virtual unsigned short getUnitType( ) + { + return unitType; + } + + /** + * + */ + virtual double getValue( ) + { + return value; + } + + /** + * + */ + virtual void setValue( double val ) throw (DOMException) + { + value = val; + } + + /** + * + */ + virtual double getValueInSpecifiedUnits( ) + { + double result = 0.0; + //fill this in + return result; + } + + /** + * + */ + virtual void setValueInSpecifiedUnits( double /*val*/ ) + throw (DOMException) + { + //fill this in + } + + /** + * + */ + virtual DOMString getValueAsString( ) + { + DOMString ret; + char buf[32]; + snprintf(buf, 31, "%f", value); + ret.append(buf); + return ret; + } + + /** + * + */ + virtual void setValueAsString( const DOMString& /*val*/ ) + throw (DOMException) + { + } + + + /** + * + */ + virtual void newValueSpecifiedUnits ( unsigned short /*unitType*/, double /*val*/ ) + { + } + + /** + * + */ + virtual void convertToSpecifiedUnits ( unsigned short /*unitType*/ ) + { + } + + + + //################## + //# Non-API methods + //################## + + /** + * + */ + SVGLength() + { + unitType = SVG_LENGTHTYPE_UNKNOWN; + value = 0.0; + } + + + /** + * + */ + SVGLength(const SVGLength &other) + { + unitType = other.unitType; + value = other.value; + } + + /** + * + */ + virtual ~SVGLength() {} + +protected: + + int unitType; + + double value; + +}; + + + + + + +/*######################################################################### +## SVGAnimatedLength +#########################################################################*/ + +/** + * + */ +class SVGAnimatedLength +{ +public: + + /** + * + */ + virtual SVGLength &getBaseVal() + { + return baseVal; + } + + /** + * + */ + virtual SVGLength &getAnimVal() + { + return animVal; + } + + + + //################## + //# Non-API methods + //################## + + /** + * + */ + SVGAnimatedLength() {} + + /** + * + */ + SVGAnimatedLength(const SVGAnimatedLength &other) + { + baseVal = other.baseVal; + animVal = other.animVal; + } + + /** + * + */ + virtual ~SVGAnimatedLength() {} + +protected: + + SVGLength baseVal, animVal; + +}; + + + + + + +/*######################################################################### +## SVGLengthList +#########################################################################*/ + +/** + * + */ +class SVGLengthList +{ +public: + + /** + * + */ + virtual unsigned long getNumberOfItems() + { + return items.size(); + } + + + /** + * + */ + virtual void clear ( ) throw( DOMException ) + { + items.clear(); + } + + /** + * + */ + virtual SVGLength initialize (const SVGLength &newItem ) + throw( DOMException, SVGException ) + { + items.clear(); + items.push_back(newItem); + return newItem; + } + + /** + * + */ + virtual SVGLength getItem (unsigned long index) + throw( DOMException ) + { + if (index>=items.size()) + { + SVGLength ret; + return ret; + } + return items[index]; + } + + /** + * + */ + virtual SVGLength insertItemBefore (const SVGLength &newItem, + unsigned long index ) + throw( DOMException, SVGException ) + { + if (index>=items.size()) + { + items.push_back(newItem); + } + else + { + std::vector::iterator iter = items.begin() + index; + items.insert(iter, newItem); + } + return newItem; + } + + /** + * + */ + virtual SVGLength replaceItem (const SVGLength &newItem, + unsigned long index ) + throw( DOMException, SVGException ) + { + if (index>=items.size()) + { + SVGLength ret; + return ret; + } + std::vector::iterator iter = items.begin() + index; + *iter = newItem; + return newItem; + } + + /** + * + */ + virtual SVGLength removeItem (unsigned long index ) + throw( DOMException ) + { + if (index>=items.size()) + { + SVGLength ret; + return ret; + } + std::vector::iterator iter = items.begin() + index; + SVGLength oldval = *iter; + items.erase(iter); + return oldval; + } + + /** + * + */ + virtual SVGLength appendItem (const SVGLength &newItem ) + throw( DOMException, SVGException ) + { + items.push_back(newItem); + return newItem; + } + + + //################## + //# Non-API methods + //################## + + /** + * + */ + SVGLengthList() {} + + /** + * + */ + SVGLengthList(const SVGLengthList &other) + { + items = other.items; + } + + /** + * + */ + virtual ~SVGLengthList() {} + +protected: + + std::vectoritems; + +}; + + + + + + +/*######################################################################### +## SVGAnimatedLengthList +#########################################################################*/ + +/** + * + */ +class SVGAnimatedLengthList +{ +public: + + /** + * + */ + virtual SVGLengthList &getBaseVal() + { + return baseVal; + } + + /** + * + */ + virtual SVGLengthList &getAnimVal() + { + return animVal; + } + + + + //################## + //# Non-API methods + //################## + + /** + * + */ + SVGAnimatedLengthList() {} + + /** + * + */ + SVGAnimatedLengthList(const SVGAnimatedLengthList &other) + { + baseVal = other.baseVal; + animVal = other.animVal; + } + + /** + * + */ + virtual ~SVGAnimatedLengthList() {} + +protected: + + SVGLengthList baseVal, animVal; + +}; + + + + + + +/*######################################################################### +## SVGAngle +#########################################################################*/ + +/** + * + */ +class SVGAngle +{ +public: + + /** + * Angle Unit Types + */ + typedef enum + { + SVG_ANGLETYPE_UNKNOWN = 0, + SVG_ANGLETYPE_UNSPECIFIED = 1, + SVG_ANGLETYPE_DEG = 2, + SVG_ANGLETYPE_RAD = 3, + SVG_ANGLETYPE_GRAD = 4 + } AngleUnitType; + + + + /** + * + */ + virtual unsigned short getUnitType() + { + return unitType; + } + + /** + * + */ + virtual double getValue() + { + return value; + } + + /** + * + */ + virtual void setValue(double val) throw (DOMException) + { + value = val; + } + + /** + * + */ + virtual double getValueInSpecifiedUnits() + { + double result = 0.0; + //convert here + return result; + } + + /** + * + */ + virtual void setValueInSpecifiedUnits(double /*val*/) + throw (DOMException) + { + //do conversion + } + + /** + * + */ + virtual DOMString getValueAsString() + { + DOMString result; + char buf[32]; + snprintf(buf, 31, "%f", value); + result.append(buf); + return result; + } + + /** + * + */ + virtual void setValueAsString(const DOMString &/*val*/) + throw (DOMException) + { + //convert here + } + + + /** + * + */ + virtual void newValueSpecifiedUnits (unsigned short /*unitType*/, + double /*valueInSpecifiedUnits*/ ) + { + //convert here + } + + /** + * + */ + virtual void convertToSpecifiedUnits (unsigned short /*unitType*/ ) + { + //convert here + } + + + + //################## + //# Non-API methods + //################## + + /** + * + */ + SVGAngle() + { + unitType = SVG_ANGLETYPE_UNKNOWN; + value = 0.0; + } + + /** + * + */ + SVGAngle(const SVGAngle &other) + { + unitType = other.unitType; + value = other.value; + } + + /** + * + */ + virtual ~SVGAngle() {} + +protected: + + int unitType; + + double value; + +}; + + + + + + +/*######################################################################### +## SVGAnimatedAngle +#########################################################################*/ + +/** + * + */ +class SVGAnimatedAngle +{ +public: + + /** + * + */ + virtual SVGAngle getBaseVal() + { + return baseVal; + } + + /** + * + */ + virtual SVGAngle getAnimVal() + { + return animVal; + } + + //################## + //# Non-API methods + //################## + + /** + * + */ + SVGAnimatedAngle() {} + + /** + * + */ + SVGAnimatedAngle(const SVGAngle &angle) + { baseVal = angle; } + + /** + * + */ + SVGAnimatedAngle(const SVGAnimatedAngle &other) + { + baseVal = other.baseVal; + animVal = other.animVal; + } + + /** + * + */ + virtual ~SVGAnimatedAngle() {} + +protected: + + SVGAngle baseVal, animVal; + +}; + + + + + + +/*######################################################################### +## SVGICCColor +#########################################################################*/ + +/** + * + */ +class SVGICCColor +{ +public: + + /** + * + */ + virtual DOMString getColorProfile() + { + return colorProfile; + } + + /** + * + */ + virtual void setColorProfile(const DOMString &val) throw (DOMException) + { + colorProfile = val; + } + + /** + * + */ + virtual SVGNumberList &getColors() + { + return colors; + } + + + + //################## + //# Non-API methods + //################## + + /** + * + */ + SVGICCColor() {} + + /** + * + */ + SVGICCColor(const SVGICCColor &other) + { + colorProfile = other.colorProfile; + colors = other.colors; + } + + /** + * + */ + virtual ~SVGICCColor() {} + +protected: + + DOMString colorProfile; + + SVGNumberList colors; + +}; + + +/*######################################################################### +## SVGColor +#########################################################################*/ + +/** + * + */ +class SVGColor : virtual public css::CSSValue +{ +public: + + + /** + * Color Types + */ + typedef enum + { + SVG_COLORTYPE_UNKNOWN = 0, + SVG_COLORTYPE_RGBCOLOR = 1, + SVG_COLORTYPE_RGBCOLOR_ICCCOLOR = 2, + SVG_COLORTYPE_CURRENTCOLOR = 3 + } ColorType; + + + /** + * + */ + virtual unsigned short getColorType() + { + return colorType; + } + + /** + * + */ + virtual css::RGBColor getRgbColor() + { + css::RGBColor col; + return col; + } + + /** + * + */ + virtual SVGICCColor getIccColor() + { + SVGICCColor col; + return col; + } + + + /** + * + */ + virtual void setRGBColor (const DOMString& /*rgbColor*/ ) + throw( SVGException ) + { + } + + /** + * + */ + virtual void setRGBColorICCColor (const DOMString& /*rgbColor*/, + const DOMString& /*iccColor*/ ) + throw( SVGException ) + { + } + + /** + * + */ + virtual void setColor (unsigned short /*colorType*/, + const DOMString& /*rgbColor*/, + const DOMString& /*iccColor*/ ) + throw( SVGException ) + { + } + + + + //################## + //# Non-API methods + //################## + + /** + * + */ + SVGColor() + { + colorType = SVG_COLORTYPE_UNKNOWN; + } + + /** + * + */ + SVGColor(const SVGColor &other) : css::CSSValue(other) + { + colorType = other.colorType; + } + + /** + * + */ + virtual ~SVGColor() {} + +protected: + + int colorType; + +}; + + + + + + + + + + +/*######################################################################### +## SVGRect +#########################################################################*/ + +/** + * + */ +class SVGRect +{ +public: + + /** + * + */ + virtual double getX() + { + return x; + } + + /** + * + */ + virtual void setX(double val) throw (DOMException) + { + x = val; + } + + /** + * + */ + virtual double getY() + { + return y; + } + + /** + * + */ + virtual void setY(double val) throw (DOMException) + { + y = val; + } + + /** + * + */ + virtual double getWidth() + { + return width; + } + + /** + * + */ + virtual void setWidth(double val) throw (DOMException) + { + width = val; + } + + /** + * + */ + virtual double getHeight() + { + return height; + } + + /** + * + */ + virtual void setHeight(double val) throw (DOMException) + { + height = val; + } + + + //################## + //# Non-API methods + //################## + + /** + * + */ + SVGRect() + { + x = y = width = height = 0.0; + } + + /** + * + */ + SVGRect(const SVGRect &other) + { + x = other.x; + y = other.y; + width = other.width; + height = other.height; + } + + /** + * + */ + virtual ~SVGRect() {} + +protected: + + double x, y, width, height; + +}; + + + + + + +/*######################################################################### +## SVGAnimatedRect +#########################################################################*/ + +/** + * + */ +class SVGAnimatedRect +{ +public: + + /** + * + */ + virtual SVGRect &getBaseVal() + { + return baseVal; + } + + /** + * + */ + virtual SVGRect &getAnimVal() + { + return animVal; + } + + + + //################## + //# Non-API methods + //################## + + /** + * + */ + SVGAnimatedRect() + { + } + + /** + * + */ + SVGAnimatedRect(const SVGAnimatedRect &other) + { + baseVal = other.baseVal; + animVal = other.animVal; + } + + /** + * + */ + virtual ~SVGAnimatedRect() {} + +protected: + + SVGRect baseVal, animVal; + +}; + + + +/*######################################################################### +## SVGPoint +#########################################################################*/ + +/** + * + */ +class SVGPoint +{ +public: + + + + /** + * + */ + virtual double getX() + { return x; } + + /** + * + */ + virtual void setX(double val) throw (DOMException) + { x = val; } + + /** + * + */ + virtual double getY() + { return y; } + + /** + * + */ + virtual void setY(double val) throw (DOMException) + { y = val; } + + /** + * + */ + virtual SVGPoint matrixTransform(const SVGMatrix &/*matrix*/) + { + SVGPoint point; + return point; + } + + + + //################## + //# Non-API methods + //################## + + /** + * + */ + SVGPoint() + { x = y = 0; } + + /** + * + */ + SVGPoint(const SVGPoint &other) + { + x = other.x; + y = other.y; + } + + /** + * + */ + virtual ~SVGPoint() {} + +protected: + + double x, y; +}; + + + + + + +/*######################################################################### +## SVGPointList +#########################################################################*/ + +/** + * + */ +class SVGPointList +{ +public: + + /** + * + */ + virtual unsigned long getNumberOfItems() + { return items.size(); } + + /** + * + */ + virtual void clear() throw( DOMException ) + { items.clear(); } + + /** + * + */ + virtual SVGPoint initialize(const SVGPoint &newItem) + throw( DOMException, SVGException ) + { + items.clear(); + items.push_back(newItem); + return newItem; + } + + /** + * + */ + virtual SVGPoint getItem(unsigned long index ) + throw( DOMException ) + { + if (index >= items.size()) + { + SVGPoint point; + return point; + } + return items[index]; + } + + /** + * + */ + virtual SVGPoint insertItemBefore(const SVGPoint &newItem, + unsigned long index ) + throw( DOMException, SVGException ) + { + if (index >= items.size()) + items.push_back(newItem); + else + { + std::vector::iterator iter = items.begin() + index; + items.insert(iter, newItem); + } + return newItem; + } + + /** + * + */ + virtual SVGPoint replaceItem(const SVGPoint &newItem, + unsigned long index ) + throw( DOMException, SVGException ) + { + if (index >= items.size()) + { + SVGPoint point; + return point; + } + std::vector::iterator iter = items.begin() + index; + *iter = newItem; + return newItem; + } + + /** + * + */ + virtual SVGPoint removeItem(unsigned long index ) + throw( DOMException ) + { + if (index >= items.size()) + { + SVGPoint point; + return point; + } + std::vector::iterator iter = items.begin() + index; + SVGPoint oldItem = *iter; + items.erase(iter); + return oldItem; + } + + /** + * + */ + virtual SVGPoint appendItem(const SVGPoint &newItem) + throw( DOMException, SVGException ) + { + items.push_back(newItem); + return newItem; + } + + + //################## + //# Non-API methods + //################## + + /** + * + */ + SVGPointList() {} + + + /** + * + */ + SVGPointList(const SVGPointList &other) + { + items = other.items; + } + + + /** + * + */ + virtual ~SVGPointList() {} + +protected: + + std::vector items; + +}; + + + + +/*######################################################################### +## SVGUnitTypes +#########################################################################*/ + +/** + * + */ +class SVGUnitTypes +{ +public: + + /** + * Unit Types + */ + typedef enum + { + SVG_UNIT_TYPE_UNKNOWN = 0, + SVG_UNIT_TYPE_USERSPACEONUSE = 1, + SVG_UNIT_TYPE_OBJECTBOUNDINGBOX = 2 + } UnitType; + + + + //################## + //# Non-API methods + //################## + + /** + * + */ + SVGUnitTypes() {} + + /** + * + */ + virtual ~SVGUnitTypes() {} + +}; + + + + + + +/*######################################################################### +## SVGStylable +#########################################################################*/ + +/** + * + */ +class SVGStylable +{ +public: + + /** + * + */ + virtual SVGAnimatedString getClassName() + { + return className; + } + + /** + * + */ + virtual css::CSSStyleDeclaration getStyle() + { + return style; + } + + + /** + * + */ + virtual css::CSSValue getPresentationAttribute (const DOMString& /*name*/ ) + { + css::CSSValue val; + //perform a lookup + return val; + } + + + //################## + //# Non-API methods + //################## + + /** + * + */ + SVGStylable() {} + + /** + * + */ + SVGStylable(const SVGStylable &other) + { + className = other.className; + style = other.style; + } + + /** + * + */ + virtual ~SVGStylable() {} + +protected: + + SVGAnimatedString className; + css::CSSStyleDeclaration style; + +}; + + +/*######################################################################### +## SVGLocatable +#########################################################################*/ + +/** + * + */ +class SVGLocatable +{ +public: + + /** + * + */ + virtual SVGElementPtr getNearestViewportElement() + { + SVGElementPtr result; + return result; + } + + /** + * + */ + virtual SVGElementPtr getFarthestViewportElement() + { + SVGElementPtr result; + return result; + } + + /** + * + */ + virtual SVGRect getBBox ( ) + { + return bbox; + } + + /** + * + */ + virtual SVGMatrix getCTM ( ) + { + return ctm; + } + + /** + * + */ + virtual SVGMatrix getScreenCTM ( ) + { + return screenCtm; + } + + /** + * + */ + virtual SVGMatrix getTransformToElement (const SVGElement &/*element*/) + throw( SVGException ) + { + SVGMatrix result; + //do calculations + return result; + } + + + + //################## + //# Non-API methods + //################## + + /** + * + */ + SVGLocatable() {} + + /** + * + */ + SVGLocatable(const SVGLocatable &/*other*/) + { + } + + /** + * + */ + virtual ~SVGLocatable() {} + +protected: + + SVGRect bbox; + SVGMatrix ctm; + SVGMatrix screenCtm; + +}; + + + + + + +/*######################################################################### +## SVGTransformable +#########################################################################*/ + +/** + * + */ +class SVGTransformable : public SVGLocatable +{ +public: + + + /** + * + */ + virtual SVGAnimatedTransformList &getTransform() + { + return transforms; + } + + + + //################## + //# Non-API methods + //################## + + /** + * + */ + SVGTransformable() {} + + /** + * + */ + SVGTransformable(const SVGTransformable &other) : SVGLocatable(other) + { + transforms = other.transforms; + } + + /** + * + */ + virtual ~SVGTransformable() {} + +protected: + + SVGAnimatedTransformList transforms; +}; + + + + + + +/*######################################################################### +## SVGTests +#########################################################################*/ + +/** + * + */ +class SVGTests +{ +public: + + + /** + * + */ + virtual SVGStringList &getRequiredFeatures() + { + return requiredFeatures; + } + + /** + * + */ + virtual SVGStringList &getRequiredExtensions() + { + return requiredExtensions; + } + + /** + * + */ + virtual SVGStringList &getSystemLanguage() + { + return systemLanguage; + } + + + /** + * + */ + virtual bool hasExtension (const DOMString& /*extension*/ ) + { + return false; + } + + + + //################## + //# Non-API methods + //################## + + /** + * + */ + SVGTests() {} + + /** + * + */ + SVGTests(const SVGTests &other) + { + requiredFeatures = other.requiredFeatures; + requiredExtensions = other.requiredExtensions; + systemLanguage = other.systemLanguage; + } + + /** + * + */ + virtual ~SVGTests() {} + +protected: + + SVGStringList requiredFeatures; + SVGStringList requiredExtensions; + SVGStringList systemLanguage; + +}; + + + + + + +/*######################################################################### +## SVGLangSpace +#########################################################################*/ + +/** + * + */ +class SVGLangSpace +{ +public: + + + /** + * + */ + virtual DOMString getXmllang() + { + return xmlLang; + } + + /** + * + */ + virtual void setXmllang(const DOMString &val) + throw (DOMException) + { + xmlLang = val; + } + + /** + * + */ + virtual DOMString getXmlspace() + { + return xmlSpace; + } + + /** + * + */ + virtual void setXmlspace(const DOMString &val) + throw (DOMException) + { + xmlSpace = val; + } + + + + //################## + //# Non-API methods + //################## + + /** + * + */ + SVGLangSpace() {} + + /** + * + */ + SVGLangSpace(const SVGLangSpace &other) + { + xmlLang = other.xmlLang; + xmlSpace = other.xmlSpace; + } + + /** + * + */ + virtual ~SVGLangSpace() {} + +protected: + + DOMString xmlLang; + DOMString xmlSpace; + +}; + + + + + + +/*######################################################################### +## SVGExternalResourcesRequired +#########################################################################*/ + +/** + * + */ +class SVGExternalResourcesRequired +{ +public: + + + /** + * + */ + virtual SVGAnimatedBoolean getExternalResourcesRequired() + { return required; } + + + + //################## + //# Non-API methods + //################## + + /** + * + */ + SVGExternalResourcesRequired() + { } + + + /** + * + */ + SVGExternalResourcesRequired(const SVGExternalResourcesRequired &other) + { + required = other.required; + } + + /** + * + */ + virtual ~SVGExternalResourcesRequired() {} + +protected: + + SVGAnimatedBoolean required; + +}; + + + + + + +/*######################################################################### +## SVGPreserveAspectRatio +#########################################################################*/ + +/** + * + */ +class SVGPreserveAspectRatio +{ +public: + + + /** + * Alignment Types + */ + typedef enum + { + SVG_PRESERVEASPECTRATIO_UNKNOWN = 0, + SVG_PRESERVEASPECTRATIO_NONE = 1, + SVG_PRESERVEASPECTRATIO_XMINYMIN = 2, + SVG_PRESERVEASPECTRATIO_XMIDYMIN = 3, + SVG_PRESERVEASPECTRATIO_XMAXYMIN = 4, + SVG_PRESERVEASPECTRATIO_XMINYMID = 5, + SVG_PRESERVEASPECTRATIO_XMIDYMID = 6, + SVG_PRESERVEASPECTRATIO_XMAXYMID = 7, + SVG_PRESERVEASPECTRATIO_XMINYMAX = 8, + SVG_PRESERVEASPECTRATIO_XMIDYMAX = 9, + SVG_PRESERVEASPECTRATIO_XMAXYMAX = 10 + } AlignmentType; + + + /** + * Meet-or-slice Types + */ + typedef enum + { + SVG_MEETORSLICE_UNKNOWN = 0, + SVG_MEETORSLICE_MEET = 1, + SVG_MEETORSLICE_SLICE = 2 + } MeetOrSliceType; + + + /** + * + */ + virtual unsigned short getAlign() + { return align; } + + /** + * + */ + virtual void setAlign(unsigned short val) throw (DOMException) + { align = val; } + + /** + * + */ + virtual unsigned short getMeetOrSlice() + { return meetOrSlice; } + + /** + * + */ + virtual void setMeetOrSlice(unsigned short val) throw (DOMException) + { meetOrSlice = val; } + + + + //################## + //# Non-API methods + //################## + + /** + * + */ + SVGPreserveAspectRatio() + { + align = SVG_PRESERVEASPECTRATIO_UNKNOWN; + meetOrSlice = SVG_MEETORSLICE_UNKNOWN; + } + + /** + * + */ + SVGPreserveAspectRatio(const SVGPreserveAspectRatio &other) + { + align = other.align; + meetOrSlice = other.meetOrSlice; + } + + /** + * + */ + virtual ~SVGPreserveAspectRatio() {} + +protected: + + unsigned short align; + unsigned short meetOrSlice; + +}; + + + + + + +/*######################################################################### +## SVGAnimatedPreserveAspectRatio +#########################################################################*/ + +/** + * + */ +class SVGAnimatedPreserveAspectRatio +{ +public: + + + /** + * + */ + virtual SVGPreserveAspectRatio getBaseVal() + { return baseVal; } + + /** + * + */ + virtual SVGPreserveAspectRatio getAnimVal() + { return animVal; } + + + + //################## + //# Non-API methods + //################## + + /** + * + */ + SVGAnimatedPreserveAspectRatio() {} + + /** + * + */ + SVGAnimatedPreserveAspectRatio(const SVGAnimatedPreserveAspectRatio &other) + { + baseVal = other.baseVal; + baseVal = other.animVal; + } + + /** + * + */ + virtual ~SVGAnimatedPreserveAspectRatio() {} + +protected: + + SVGPreserveAspectRatio baseVal; + SVGPreserveAspectRatio animVal; + +}; + + + + +/*######################################################################### +## SVGFitToViewBox +#########################################################################*/ + +/** + * + */ +class SVGFitToViewBox +{ +public: + + /** + * + */ + virtual SVGAnimatedRect getViewBox() + { return viewBox; } + + /** + * + */ + virtual SVGAnimatedPreserveAspectRatio getPreserveAspectRatio() + { return preserveAspectRatio; } + + + + //################## + //# Non-API methods + //################## + + /** + * + */ + SVGFitToViewBox() + {} + + /** + * + */ + + SVGFitToViewBox(const SVGFitToViewBox &other) + { + viewBox = other.viewBox; + preserveAspectRatio = other.preserveAspectRatio; + } + + /** + * + */ + virtual ~SVGFitToViewBox() {} + +protected: + + SVGAnimatedRect viewBox; + + SVGAnimatedPreserveAspectRatio preserveAspectRatio; + +}; + + +/*######################################################################### +## SVGZoomAndPan +#########################################################################*/ + +/** + * + */ +class SVGZoomAndPan +{ +public: + + + /** + * Zoom and Pan Types + */ + typedef enum + { + SVG_ZOOMANDPAN_UNKNOWN = 0, + SVG_ZOOMANDPAN_DISABLE = 1, + SVG_ZOOMANDPAN_MAGNIFY = 2 + } ZoomAndPanType; + + + /** + * + */ + virtual unsigned short getZoomAndPan() + { return zoomAndPan; } + + /** + * + */ + virtual void setZoomAndPan(unsigned short val) throw (DOMException) + { zoomAndPan = val; } + + + //################## + //# Non-API methods + //################## + + /** + * + */ + SVGZoomAndPan() + { zoomAndPan = SVG_ZOOMANDPAN_UNKNOWN; } + + /** + * + */ + SVGZoomAndPan(const SVGZoomAndPan &other) + { zoomAndPan = other.zoomAndPan; } + + /** + * + */ + virtual ~SVGZoomAndPan() {} + +protected: + + unsigned short zoomAndPan; + +}; + + + + + + +/*######################################################################### +## SVGViewSpec +#########################################################################*/ + +/** + * + */ +class SVGViewSpec : public SVGZoomAndPan, + public SVGFitToViewBox +{ +public: + + /** + * + */ + virtual SVGTransformList getTransform() + { return transform; } + + /** + * + */ + virtual SVGElementPtr getViewTarget() + { return viewTarget; } + + /** + * + */ + virtual DOMString getViewBoxString() + { + DOMString ret; + return ret; + } + + /** + * + */ + virtual DOMString getPreserveAspectRatioString() + { + DOMString ret; + return ret; + } + + /** + * + */ + virtual DOMString getTransformString() + { + DOMString ret; + return ret; + } + + /** + * + */ + virtual DOMString getViewTargetString() + { + DOMString ret; + return ret; + } + + + + //################## + //# Non-API methods + //################## + + /** + * + */ + SVGViewSpec() + { + viewTarget = NULL; + } + + /** + * + */ + SVGViewSpec(const SVGViewSpec &other) : SVGZoomAndPan(other), SVGFitToViewBox(other) + { + viewTarget = other.viewTarget; + transform = other.transform; + } + + /** + * + */ + virtual ~SVGViewSpec() {} + +protected: + + SVGElementPtr viewTarget; + SVGTransformList transform; +}; + + + + + + +/*######################################################################### +## SVGURIReference +#########################################################################*/ + +/** + * + */ +class SVGURIReference +{ +public: + + /** + * + */ + virtual SVGAnimatedString getHref() + { return href; } + + + + //################## + //# Non-API methods + //################## + + /** + * + */ + SVGURIReference() {} + + /** + * + */ + SVGURIReference(const SVGURIReference &other) + { + href = other.href; + } + + /** + * + */ + virtual ~SVGURIReference() {} + +protected: + + SVGAnimatedString href; + +}; + + + + + + +/*######################################################################### +## SVGCSSRule +#########################################################################*/ + +/** + * + */ +class SVGCSSRule : public css::CSSRule +{ +public: + + + /** + * Additional CSS RuleType to support ICC color specifications + */ + typedef enum + { + COLOR_PROFILE_RULE = 7 + } ColorProfileRuleType; + + //################## + //# Non-API methods + //################## + + /** + * + */ + SVGCSSRule() + { type = COLOR_PROFILE_RULE; } + + /** + * + */ + SVGCSSRule(const SVGCSSRule &other) : css::CSSRule(other) + { type = COLOR_PROFILE_RULE; } + + /** + * + */ + virtual ~SVGCSSRule() {} + +}; + + + +/*######################################################################### +## SVGRenderingIntent +#########################################################################*/ + +/** + * + */ +class SVGRenderingIntent +{ +public: + + /** + * Rendering Intent Types + */ + typedef enum + { + RENDERING_INTENT_UNKNOWN = 0, + RENDERING_INTENT_AUTO = 1, + RENDERING_INTENT_PERCEPTUAL = 2, + RENDERING_INTENT_RELATIVE_COLORIMETRIC = 3, + RENDERING_INTENT_SATURATION = 4, + RENDERING_INTENT_ABSOLUTE_COLORIMETRIC = 5 + } RenderingIntentType; + + + + //################## + //# Non-API methods + //################## + + /** + * + */ + SVGRenderingIntent() + { + renderingIntentType = RENDERING_INTENT_UNKNOWN; + } + + /** + * + */ + SVGRenderingIntent(const SVGRenderingIntent &other) + { + renderingIntentType = other.renderingIntentType; + } + + /** + * + */ + virtual ~SVGRenderingIntent() {} + +protected: + + unsigned short renderingIntentType; +}; + + + + + + + +/*######################################################################### +########################################################################### +## P A T H S E G M E N T S +########################################################################### +#########################################################################*/ + +static char const *const pathSegLetters[] = +{ + "@", // PATHSEG_UNKNOWN, + "z", // PATHSEG_CLOSEPATH + "M", // PATHSEG_MOVETO_ABS + "m", // PATHSEG_MOVETO_REL, + "L", // PATHSEG_LINETO_ABS + "l", // PATHSEG_LINETO_REL + "C", // PATHSEG_CURVETO_CUBIC_ABS + "c", // PATHSEG_CURVETO_CUBIC_REL + "Q", // PATHSEG_CURVETO_QUADRATIC_ABS, + "q", // PATHSEG_CURVETO_QUADRATIC_REL + "A", // PATHSEG_ARC_ABS + "a", // PATHSEG_ARC_REL, + "H", // PATHSEG_LINETO_HORIZONTAL_ABS, + "h", // PATHSEG_LINETO_HORIZONTAL_REL + "V", // PATHSEG_LINETO_VERTICAL_ABS + "v", // PATHSEG_LINETO_VERTICAL_REL + "S", // PATHSEG_CURVETO_CUBIC_SMOOTH_ABS + "s", // PATHSEG_CURVETO_CUBIC_SMOOTH_REL + "T", // PATHSEG_CURVETO_QUADRATIC_SMOOTH_ABS + "t" // PATHSEG_CURVETO_QUADRATIC_SMOOTH_REL +}; + +/*######################################################################### +## SVGPathSeg +#########################################################################*/ + +/** + * + */ +class SVGPathSeg +{ +public: + + + + /** + * Path Segment Types + */ + typedef enum + { + PATHSEG_UNKNOWN = 0, + PATHSEG_CLOSEPATH = 1, + PATHSEG_MOVETO_ABS = 2, + PATHSEG_MOVETO_REL = 3, + PATHSEG_LINETO_ABS = 4, + PATHSEG_LINETO_REL = 5, + PATHSEG_CURVETO_CUBIC_ABS = 6, + PATHSEG_CURVETO_CUBIC_REL = 7, + PATHSEG_CURVETO_QUADRATIC_ABS = 8, + PATHSEG_CURVETO_QUADRATIC_REL = 9, + PATHSEG_ARC_ABS = 10, + PATHSEG_ARC_REL = 11, + PATHSEG_LINETO_HORIZONTAL_ABS = 12, + PATHSEG_LINETO_HORIZONTAL_REL = 13, + PATHSEG_LINETO_VERTICAL_ABS = 14, + PATHSEG_LINETO_VERTICAL_REL = 15, + PATHSEG_CURVETO_CUBIC_SMOOTH_ABS = 16, + PATHSEG_CURVETO_CUBIC_SMOOTH_REL = 17, + PATHSEG_CURVETO_QUADRATIC_SMOOTH_ABS = 18, + PATHSEG_CURVETO_QUADRATIC_SMOOTH_REL = 19 + } PathSegmentType; + + /** + * + */ + virtual unsigned short getPathSegType() + { return type; } + + /** + * + */ + virtual DOMString getPathSegTypeAsLetter() + { + int typ = type; + if (typ<0 || typ>PATHSEG_CURVETO_QUADRATIC_SMOOTH_REL) + typ = PATHSEG_UNKNOWN; + char const *ch = pathSegLetters[typ]; + DOMString letter = ch; + return letter; + } + + + + //################## + //# Non-API methods + //################## + + /** + * + */ + SVGPathSeg() + { type = PATHSEG_UNKNOWN; } + + /** + * + */ + SVGPathSeg(const SVGPathSeg &other) + { + type = other.type; + } + + /** + * + */ + virtual ~SVGPathSeg() {} + +protected: + + int type; + +}; + + + + + + +/*######################################################################### +## SVGPathSegClosePath +#########################################################################*/ + +/** + * + */ +class SVGPathSegClosePath : public SVGPathSeg +{ +public: + + //################## + //# Non-API methods + //################## + + /** + * + */ + SVGPathSegClosePath() + { + type = PATHSEG_CLOSEPATH; + } + + /** + * + */ + SVGPathSegClosePath(const SVGPathSegClosePath &other) : SVGPathSeg(other) + { + type = PATHSEG_CLOSEPATH; + } + + /** + * + */ + virtual ~SVGPathSegClosePath() {} + +}; + + + + +/*######################################################################### +## SVGPathSegMovetoAbs +#########################################################################*/ + +/** + * + */ +class SVGPathSegMovetoAbs : public SVGPathSeg +{ +public: + + /** + * + */ + virtual double getX() + { return x; } + + /** + * + */ + virtual void setX(double val) throw (DOMException) + { x = val; } + + /** + * + */ + virtual double getY() + { return y; } + + /** + * + */ + virtual void setY(double val) throw (DOMException) + { y = val; } + + //################## + //# Non-API methods + //################## + + /** + * + */ + SVGPathSegMovetoAbs() + { + type = PATHSEG_MOVETO_ABS; + x = y = 0.0; + } + + /** + * + */ + SVGPathSegMovetoAbs(double xArg, double yArg) + { + type = PATHSEG_MOVETO_ABS; + x = xArg; y = yArg; + } + + /** + * + */ + SVGPathSegMovetoAbs(const SVGPathSegMovetoAbs &other) : SVGPathSeg(other) + { + type = PATHSEG_MOVETO_ABS; + x = other.x; y = other.y; + } + + /** + * + */ + virtual ~SVGPathSegMovetoAbs() {} + +protected: + + double x,y; + +}; + + + + + + +/*######################################################################### +## SVGPathSegMovetoRel +#########################################################################*/ + +/** + * + */ +class SVGPathSegMovetoRel : public SVGPathSeg +{ +public: + + /** + * + */ + virtual double getX() + { return x; } + + /** + * + */ + virtual void setX(double val) throw (DOMException) + { x = val; } + + /** + * + */ + virtual double getY() + { return y; } + + /** + * + */ + virtual void setY(double val) throw (DOMException) + { y = val; } + + //################## + //# Non-API methods + //################## + + /** + * + */ + SVGPathSegMovetoRel() + { + type = PATHSEG_MOVETO_REL; + x = y = 0.0; + } + + + /** + * + */ + SVGPathSegMovetoRel(double xArg, double yArg) + { + type = PATHSEG_MOVETO_REL; + x = xArg; y = yArg; + } + + /** + * + */ + SVGPathSegMovetoRel(const SVGPathSegMovetoRel &other) : SVGPathSeg(other) + { + type = PATHSEG_MOVETO_REL; + x = other.x; y = other.y; + } + + /** + * + */ + virtual ~SVGPathSegMovetoRel() {} + +protected: + + double x,y; +}; + + + + + + +/*######################################################################### +## SVGPathSegLinetoAbs +#########################################################################*/ + +/** + * + */ +class SVGPathSegLinetoAbs : public SVGPathSeg +{ +public: + + /** + * + */ + virtual double getX() + { return x; } + + /** + * + */ + virtual void setX(double val) throw (DOMException) + { x = val; } + + /** + * + */ + virtual double getY() + { return y; } + + /** + * + */ + virtual void setY(double val) throw (DOMException) + { y = val; } + + //################## + //# Non-API methods + //################## + + /** + * + */ + SVGPathSegLinetoAbs() + { + type = PATHSEG_LINETO_ABS; + x = y = 0.0; + } + + + /** + * + */ + SVGPathSegLinetoAbs(double xArg, double yArg) + { + type = PATHSEG_LINETO_ABS; + x = xArg; y = yArg; + } + + /** + * + */ + SVGPathSegLinetoAbs(const SVGPathSegLinetoAbs &other) : SVGPathSeg(other) + { + type = PATHSEG_LINETO_ABS; + x = other.x; y = other.y; + } + + /** + * + */ + virtual ~SVGPathSegLinetoAbs() {} + +protected: + + double x,y; +}; + + + + + + +/*######################################################################### +## SVGPathSegLinetoRel +#########################################################################*/ + +/** + * + */ +class SVGPathSegLinetoRel : public SVGPathSeg +{ +public: + + /** + * + */ + virtual double getX() + { return x; } + + /** + * + */ + virtual void setX(double val) throw (DOMException) + { x = val; } + + /** + * + */ + virtual double getY() + { return y; } + + /** + * + */ + virtual void setY(double val) throw (DOMException) + { y = val; } + + //################## + //# Non-API methods + //################## + + /** + * + */ + SVGPathSegLinetoRel() + { + type = PATHSEG_LINETO_REL; + x = y = 0.0; + } + + + /** + * + */ + SVGPathSegLinetoRel(double xArg, double yArg) + { + type = PATHSEG_LINETO_REL; + x = xArg; y = yArg; + } + + /** + * + */ + SVGPathSegLinetoRel(const SVGPathSegLinetoRel &other) : SVGPathSeg(other) + { + type = PATHSEG_LINETO_REL; + x = other.x; y = other.y; + } + + /** + * + */ + virtual ~SVGPathSegLinetoRel() {} + +protected: + + double x,y; +}; + + + + + + +/*######################################################################### +## SVGPathSegCurvetoCubicAbs +#########################################################################*/ + +/** + * + */ +class SVGPathSegCurvetoCubicAbs : public SVGPathSeg +{ +public: + + /** + * + */ + virtual double getX() + { return x; } + + /** + * + */ + virtual void setX(double val) throw (DOMException) + { x = val; } + + /** + * + */ + virtual double getY() + { return y; } + + /** + * + */ + virtual void setY(double val) throw (DOMException) + { y = val; } + + /** + * + */ + virtual double getX1() + { return x1; } + + /** + * + */ + virtual void setX1(double val) throw (DOMException) + { x1 = val; } + + /** + * + */ + virtual double getY1() + { return y1; } + + /** + * + */ + virtual void setY1(double val) throw (DOMException) + { y1 = val; } + + + /** + * + */ + virtual double getX2() + { return x2; } + + /** + * + */ + virtual void setX2(double val) throw (DOMException) + { x2 = val; } + + /** + * + */ + virtual double getY2() + { return y2; } + + /** + * + */ + virtual void setY2(double val) throw (DOMException) + { y2 = val; } + + + //################## + //# Non-API methods + //################## + + + /** + * + */ + SVGPathSegCurvetoCubicAbs() + { + type = PATHSEG_CURVETO_CUBIC_ABS; + x = y = x1 = y1 = x2 = y2 = 0.0; + } + + /** + * + */ + SVGPathSegCurvetoCubicAbs(double xArg, double yArg, + double x1Arg, double y1Arg, + double x2Arg, double y2Arg) + { + type = PATHSEG_CURVETO_CUBIC_ABS; + x = xArg; y = yArg; + x1 = x1Arg; y1 = y1Arg; + x2 = x2Arg; y2 = y2Arg; + } + + /** + * + */ + SVGPathSegCurvetoCubicAbs(const SVGPathSegCurvetoCubicAbs &other) + : SVGPathSeg(other) + { + type = PATHSEG_CURVETO_CUBIC_ABS; + x = other.x; y = other.y; + x1 = other.x1; y1 = other.y1; + x2 = other.x2; y2 = other.y2; + } + + /** + * + */ + virtual ~SVGPathSegCurvetoCubicAbs() {} + +protected: + + double x, y, x1, y1, x2, y2; + +}; + + + + + + +/*######################################################################### +## SVGPathSegCurvetoCubicRel +#########################################################################*/ + +/** + * + */ +class SVGPathSegCurvetoCubicRel : public SVGPathSeg +{ +public: + + /** + * + */ + virtual double getX() + { return x; } + + /** + * + */ + virtual void setX(double val) throw (DOMException) + { x = val; } + + /** + * + */ + virtual double getY() + { return y; } + + /** + * + */ + virtual void setY(double val) throw (DOMException) + { y = val; } + + /** + * + */ + virtual double getX1() + { return x1; } + + /** + * + */ + virtual void setX1(double val) throw (DOMException) + { x1 = val; } + + /** + * + */ + virtual double getY1() + { return y1; } + + /** + * + */ + virtual void setY1(double val) throw (DOMException) + { y1 = val; } + + + /** + * + */ + virtual double getX2() + { return x2; } + + /** + * + */ + virtual void setX2(double val) throw (DOMException) + { x2 = val; } + + /** + * + */ + virtual double getY2() + { return y2; } + + /** + * + */ + virtual void setY2(double val) throw (DOMException) + { y2 = val; } + + + //################## + //# Non-API methods + //################## + + + /** + * + */ + SVGPathSegCurvetoCubicRel() + { + type = PATHSEG_CURVETO_CUBIC_REL; + x = y = x1 = y1 = x2 = y2 = 0.0; + } + + + /** + * + */ + SVGPathSegCurvetoCubicRel(double xArg, double yArg, + double x1Arg, double y1Arg, + double x2Arg, double y2Arg) + { + type = PATHSEG_CURVETO_CUBIC_REL; + x = xArg; y = yArg; + x1 = x1Arg; y1 = y1Arg; + x2 = x2Arg; y2 = y2Arg; + } + + /** + * + */ + SVGPathSegCurvetoCubicRel(const SVGPathSegCurvetoCubicRel &other) + : SVGPathSeg(other) + { + type = PATHSEG_CURVETO_CUBIC_REL; + x = other.x; y = other.y; + x1 = other.x1; y1 = other.y1; + x2 = other.x2; y2 = other.y2; + } + + /** + * + */ + virtual ~SVGPathSegCurvetoCubicRel() {} + +protected: + + double x, y, x1, y1, x2, y2; + +}; + + + + + + +/*######################################################################### +## SVGPathSegCurvetoQuadraticAbs +#########################################################################*/ + +/** + * + */ +class SVGPathSegCurvetoQuadraticAbs : public SVGPathSeg +{ +public: + + /** + * + */ + virtual double getX() + { return x; } + + /** + * + */ + virtual void setX(double val) throw (DOMException) + { x = val; } + + /** + * + */ + virtual double getY() + { return y; } + + /** + * + */ + virtual void setY(double val) throw (DOMException) + { y = val; } + + /** + * + */ + virtual double getX1() + { return x1; } + + /** + * + */ + virtual void setX1(double val) throw (DOMException) + { x1 = val; } + + /** + * + */ + virtual double getY1() + { return y1; } + + /** + * + */ + virtual void setY1(double val) throw (DOMException) + { y1 = val; } + + + //################## + //# Non-API methods + //################## + + + /** + * + */ + SVGPathSegCurvetoQuadraticAbs() + { + type = PATHSEG_CURVETO_QUADRATIC_ABS; + x = y = x1 = y1 = 0.0; + } + + /** + * + */ + SVGPathSegCurvetoQuadraticAbs(double xArg, double yArg, + double x1Arg, double y1Arg) + { + type = PATHSEG_CURVETO_QUADRATIC_ABS; + x = xArg; y = yArg; + x1 = x1Arg; y1 = y1Arg; + } + + /** + * + */ + SVGPathSegCurvetoQuadraticAbs(const SVGPathSegCurvetoQuadraticAbs &other) + : SVGPathSeg(other) + { + type = PATHSEG_CURVETO_QUADRATIC_ABS; + x = other.x; y = other.y; + x1 = other.x1; y1 = other.y1; + } + + /** + * + */ + virtual ~SVGPathSegCurvetoQuadraticAbs() {} + +protected: + + double x, y, x1, y1; + +}; + + + + + + +/*######################################################################### +## SVGPathSegCurvetoQuadraticRel +#########################################################################*/ + +/** + * + */ +class SVGPathSegCurvetoQuadraticRel : public SVGPathSeg +{ +public: + + /** + * + */ + virtual double getX() + { return x; } + + /** + * + */ + virtual void setX(double val) throw (DOMException) + { x = val; } + + /** + * + */ + virtual double getY() + { return y; } + + /** + * + */ + virtual void setY(double val) throw (DOMException) + { y = val; } + + /** + * + */ + virtual double getX1() + { return x1; } + + /** + * + */ + virtual void setX1(double val) throw (DOMException) + { x1 = val; } + + /** + * + */ + virtual double getY1() + { return y1; } + + /** + * + */ + virtual void setY1(double val) throw (DOMException) + { y1 = val; } + + + //################## + //# Non-API methods + //################## + + + /** + * + */ + SVGPathSegCurvetoQuadraticRel() + { + type = PATHSEG_CURVETO_QUADRATIC_REL; + x = y = x1 = y1 = 0.0; + } + + + /** + * + */ + SVGPathSegCurvetoQuadraticRel(double xArg, double yArg, + double x1Arg, double y1Arg) + { + type = PATHSEG_CURVETO_QUADRATIC_REL; + x = xArg; y = yArg; + x1 = x1Arg; y1 = y1Arg; + } + + /** + * + */ + SVGPathSegCurvetoQuadraticRel(const SVGPathSegCurvetoQuadraticRel &other) + : SVGPathSeg(other) + { + type = PATHSEG_CURVETO_QUADRATIC_REL; + x = other.x; y = other.y; + x1 = other.x1; y1 = other.y1; + } + + /** + * + */ + virtual ~SVGPathSegCurvetoQuadraticRel() {} + +protected: + + double x, y, x1, y1; + +}; + + + + + + +/*######################################################################### +## SVGPathSegArcAbs +#########################################################################*/ + +/** + * + */ +class SVGPathSegArcAbs : public SVGPathSeg +{ +public: + + /** + * + */ + virtual double getX() + { return x; } + + /** + * + */ + virtual void setX(double val) throw (DOMException) + { x = val; } + + /** + * + */ + virtual double getY() + { return y; } + + /** + * + */ + virtual void setY(double val) throw (DOMException) + { y = val; } + + /** + * + */ + virtual double getR1() + { return r1; } + + /** + * + */ + virtual void setR1(double val) throw (DOMException) + { r1 = val; } + + /** + * + */ + virtual double getR2() + { return r2; } + + /** + * + */ + virtual void setR2(double val) throw (DOMException) + { r2 = val; } + + /** + * + */ + virtual double getAngle() + { return angle; } + + /** + * + */ + virtual void setAngle(double val) throw (DOMException) + { angle = val; } + + /** + * + */ + virtual bool getLargeArcFlag() + { return largeArcFlag; } + + /** + * + */ + virtual void setLargeArcFlag(bool val) throw (DOMException) + { largeArcFlag = val; } + + /** + * + */ + virtual bool getSweepFlag() + { return sweepFlag; } + + /** + * + */ + virtual void setSweepFlag(bool val) throw (DOMException) + { sweepFlag = val; } + + //################## + //# Non-API methods + //################## + + + /** + * + */ + SVGPathSegArcAbs() + { + type = PATHSEG_ARC_ABS; + x = y = r1 = r2 = angle = 0.0; + largeArcFlag = sweepFlag = false; + } + + /** + * + */ + SVGPathSegArcAbs(double xArg, double yArg, + double r1Arg, double r2Arg, + double angleArg, + bool largeArcFlagArg, + bool sweepFlagArg ) + + { + type = PATHSEG_ARC_ABS; + x = xArg; y = yArg; + r1 = r1Arg; r2 = r2Arg; + angle = angleArg; + largeArcFlag = largeArcFlagArg; + sweepFlag = sweepFlagArg; + } + + /** + * + */ + SVGPathSegArcAbs(const SVGPathSegArcAbs &other) + : SVGPathSeg(other) + { + type = PATHSEG_ARC_ABS; + x = other.x; y = other.y; + r1 = other.r1; r2 = other.r2; + angle = other.angle; + largeArcFlag = other.largeArcFlag; + sweepFlag = other.sweepFlag; + } + + /** + * + */ + virtual ~SVGPathSegArcAbs() {} + +protected: + + double x, y, r1, r2, angle; + bool largeArcFlag; + bool sweepFlag; + +}; + + + +/*######################################################################### +## SVGPathSegArcRel +#########################################################################*/ + +/** + * + */ +class SVGPathSegArcRel : public SVGPathSeg +{ +public: + + /** + * + */ + virtual double getX() + { return x; } + + /** + * + */ + virtual void setX(double val) throw (DOMException) + { x = val; } + + /** + * + */ + virtual double getY() + { return y; } + + /** + * + */ + virtual void setY(double val) throw (DOMException) + { y = val; } + + /** + * + */ + virtual double getR1() + { return r1; } + + /** + * + */ + virtual void setR1(double val) throw (DOMException) + { r1 = val; } + + /** + * + */ + virtual double getR2() + { return r2; } + + /** + * + */ + virtual void setR2(double val) throw (DOMException) + { r2 = val; } + + /** + * + */ + virtual double getAngle() + { return angle; } + + /** + * + */ + virtual void setAngle(double val) throw (DOMException) + { angle = val; } + + /** + * + */ + virtual bool getLargeArcFlag() + { return largeArcFlag; } + + /** + * + */ + virtual void setLargeArcFlag(bool val) throw (DOMException) + { largeArcFlag = val; } + + /** + * + */ + virtual bool getSweepFlag() + { return sweepFlag; } + + /** + * + */ + virtual void setSweepFlag(bool val) throw (DOMException) + { sweepFlag = val; } + + //################## + //# Non-API methods + //################## + + + /** + * + */ + SVGPathSegArcRel() + { + type = PATHSEG_ARC_REL; + x = y = r1 = r2 = angle = 0.0; + largeArcFlag = sweepFlag = false; + } + + + /** + * + */ + SVGPathSegArcRel(double xArg, double yArg, + double r1Arg, double r2Arg, + double angleArg, + bool largeArcFlagArg, + bool sweepFlagArg ) + + { + type = PATHSEG_ARC_REL; + x = xArg; y = yArg; + r1 = r1Arg; r2 = r2Arg; + angle = angleArg; + largeArcFlag = largeArcFlagArg; + sweepFlag = sweepFlagArg; + } + + /** + * + */ + SVGPathSegArcRel(const SVGPathSegArcRel &other) + : SVGPathSeg(other) + { + type = PATHSEG_ARC_REL; + x = other.x; y = other.y; + r1 = other.r1; r2 = other.r2; + angle = other.angle; + largeArcFlag = other.largeArcFlag; + sweepFlag = other.sweepFlag; + } + + /** + * + */ + virtual ~SVGPathSegArcRel() {} + +protected: + + double x, y, r1, r2, angle; + bool largeArcFlag; + bool sweepFlag; + +}; + + + + + + +/*######################################################################### +## SVGPathSegLinetoHorizontalAbs +#########################################################################*/ + +/** + * + */ +class SVGPathSegLinetoHorizontalAbs : public SVGPathSeg +{ +public: + + /** + * + */ + virtual double getX() + { return x; } + + /** + * + */ + virtual void setX(double val) throw (DOMException) + { x = val; } + + //################## + //# Non-API methods + //################## + + /** + * + */ + SVGPathSegLinetoHorizontalAbs() + { + type = PATHSEG_LINETO_HORIZONTAL_ABS; + x = 0.0; + } + + + /** + * + */ + SVGPathSegLinetoHorizontalAbs(double xArg) + { + type = PATHSEG_LINETO_HORIZONTAL_ABS; + x = xArg; + } + + /** + * + */ + SVGPathSegLinetoHorizontalAbs(const SVGPathSegLinetoHorizontalAbs &other) + : SVGPathSeg(other) + { + type = PATHSEG_LINETO_HORIZONTAL_ABS; + x = other.x; + } + + /** + * + */ + virtual ~SVGPathSegLinetoHorizontalAbs() {} + +protected: + + double x; + +}; + + + + + + +/*######################################################################### +## SVGPathSegLinetoHorizontalRel +#########################################################################*/ + +/** + * + */ +class SVGPathSegLinetoHorizontalRel : public SVGPathSeg +{ +public: + + /** + * + */ + virtual double getX() + { return x; } + + /** + * + */ + virtual void setX(double val) throw (DOMException) + { x = val; } + + //################## + //# Non-API methods + //################## + + /** + * + */ + SVGPathSegLinetoHorizontalRel() + { + type = PATHSEG_LINETO_HORIZONTAL_REL; + x = 0.0; + } + + + /** + * + */ + SVGPathSegLinetoHorizontalRel(double xArg) + { + type = PATHSEG_LINETO_HORIZONTAL_REL; + x = xArg; + } + + /** + * + */ + SVGPathSegLinetoHorizontalRel(const SVGPathSegLinetoHorizontalRel &other) + : SVGPathSeg(other) + { + type = PATHSEG_LINETO_HORIZONTAL_REL; + x = other.x; + } + + /** + * + */ + virtual ~SVGPathSegLinetoHorizontalRel() {} + +protected: + + double x; + +}; + + + +/*######################################################################### +## SVGPathSegLinetoVerticalAbs +#########################################################################*/ + +/** + * + */ +class SVGPathSegLinetoVerticalAbs : public SVGPathSeg +{ +public: + + /** + * + */ + virtual double getY() + { return y; } + + /** + * + */ + virtual void setY(double val) throw (DOMException) + { y = val; } + + //################## + //# Non-API methods + //################## + + /** + * + */ + SVGPathSegLinetoVerticalAbs() + { + type = PATHSEG_LINETO_VERTICAL_ABS; + y = 0.0; + } + + + /** + * + */ + SVGPathSegLinetoVerticalAbs(double yArg) + { + type = PATHSEG_LINETO_VERTICAL_ABS; + y = yArg; + } + + /** + * + */ + SVGPathSegLinetoVerticalAbs(const SVGPathSegLinetoVerticalAbs &other) + : SVGPathSeg(other) + { + type = PATHSEG_LINETO_VERTICAL_ABS; + y = other.y; + } + + /** + * + */ + virtual ~SVGPathSegLinetoVerticalAbs() {} + +protected: + + double y; + +}; + + + +/*######################################################################### +## SVGPathSegLinetoVerticalRel +#########################################################################*/ + +/** + * + */ +class SVGPathSegLinetoVerticalRel : public SVGPathSeg +{ +public: + + /** + * + */ + virtual double getY() + { return y; } + + /** + * + */ + virtual void setY(double val) throw (DOMException) + { y = val; } + + //################## + //# Non-API methods + //################## + + /** + * + */ + SVGPathSegLinetoVerticalRel() + { + type = PATHSEG_LINETO_VERTICAL_REL; + y = 0.0; + } + + + /** + * + */ + SVGPathSegLinetoVerticalRel(double yArg) + { + type = PATHSEG_LINETO_VERTICAL_REL; + y = yArg; + } + + /** + * + */ + SVGPathSegLinetoVerticalRel(const SVGPathSegLinetoVerticalRel &other) + : SVGPathSeg(other) + { + type = PATHSEG_LINETO_VERTICAL_REL; + y = other.y; + } + + /** + * + */ + virtual ~SVGPathSegLinetoVerticalRel() {} + +protected: + + double y; + +}; + + + + + + +/*######################################################################### +## SVGPathSegCurvetoCubicSmoothAbs +#########################################################################*/ + +/** + * + */ +class SVGPathSegCurvetoCubicSmoothAbs : public SVGPathSeg +{ +public: + + /** + * + */ + virtual double getX() + { return x; } + + /** + * + */ + virtual void setX(double val) throw (DOMException) + { x = val; } + + /** + * + */ + virtual double getY() + { return y; } + + /** + * + */ + virtual void setY(double val) throw (DOMException) + { y = val; } + + /** + * + */ + virtual double getX2() + { return x2; } + + /** + * + */ + virtual void setX2(double val) throw (DOMException) + { x2 = val; } + + /** + * + */ + virtual double getY2() + { return y2; } + + /** + * + */ + virtual void setY2(double val) throw (DOMException) + { y2 = val; } + + + //################## + //# Non-API methods + //################## + + /** + * + */ + SVGPathSegCurvetoCubicSmoothAbs() + { + type = PATHSEG_CURVETO_CUBIC_SMOOTH_ABS; + x = y = x2 = y2 = 0.0; + } + + + /** + * + */ + SVGPathSegCurvetoCubicSmoothAbs(double xArg, double yArg, + double x2Arg, double y2Arg) + { + type = PATHSEG_CURVETO_CUBIC_SMOOTH_ABS; + x = xArg; y = yArg; + x2 = x2Arg; y2 = y2Arg; + } + + /** + * + */ + SVGPathSegCurvetoCubicSmoothAbs(const SVGPathSegCurvetoCubicSmoothAbs &other) + : SVGPathSeg(other) + { + type = PATHSEG_CURVETO_CUBIC_SMOOTH_ABS; + x = other.x; y = other.y; + x2 = other.x2; y2 = other.y2; + } + + /** + * + */ + virtual ~SVGPathSegCurvetoCubicSmoothAbs() {} + +protected: + + double x, y, x2, y2; + +}; + + + +/*######################################################################### +## SVGPathSegCurvetoCubicSmoothRel +#########################################################################*/ + +/** + * + */ +class SVGPathSegCurvetoCubicSmoothRel : public SVGPathSeg +{ +public: + + /** + * + */ + virtual double getX() + { return x; } + + /** + * + */ + virtual void setX(double val) throw (DOMException) + { x = val; } + + /** + * + */ + virtual double getY() + { return y; } + + /** + * + */ + virtual void setY(double val) throw (DOMException) + { y = val; } + + /** + * + */ + virtual double getX2() + { return x2; } + + /** + * + */ + virtual void setX2(double val) throw (DOMException) + { x2 = val; } + + /** + * + */ + virtual double getY2() + { return y2; } + + /** + * + */ + virtual void setY2(double val) throw (DOMException) + { y2 = val; } + + + //################## + //# Non-API methods + //################## + + /** + * + */ + SVGPathSegCurvetoCubicSmoothRel() + { + type = PATHSEG_CURVETO_CUBIC_SMOOTH_REL; + x = y = x2 = y2 = 0.0; + } + + + /** + * + */ + SVGPathSegCurvetoCubicSmoothRel(double xArg, double yArg, + double x2Arg, double y2Arg) + { + type = PATHSEG_CURVETO_CUBIC_SMOOTH_REL; + x = xArg; y = yArg; + x2 = x2Arg; y2 = y2Arg; + } + + /** + * + */ + SVGPathSegCurvetoCubicSmoothRel(const SVGPathSegCurvetoCubicSmoothRel &other) + : SVGPathSeg(other) + { + type = PATHSEG_CURVETO_CUBIC_SMOOTH_REL; + x = other.x; y = other.y; + x2 = other.x2; y2 = other.y2; + } + + /** + * + */ + virtual ~SVGPathSegCurvetoCubicSmoothRel() {} + +protected: + + double x, y, x2, y2; + +}; + + + + + + +/*######################################################################### +## SVGPathSegCurvetoQuadraticSmoothAbs +#########################################################################*/ + +/** + * + */ +class SVGPathSegCurvetoQuadraticSmoothAbs : public SVGPathSeg +{ +public: + + /** + * + */ + virtual double getX() + { return x; } + + /** + * + */ + virtual void setX(double val) throw (DOMException) + { x = val; } + + /** + * + */ + virtual double getY() + { return y; } + + /** + * + */ + virtual void setY(double val) throw (DOMException) + { y = val; } + + + + //################## + //# Non-API methods + //################## + + /** + * + */ + SVGPathSegCurvetoQuadraticSmoothAbs() + { + type = PATHSEG_CURVETO_QUADRATIC_SMOOTH_ABS; + x = y = 0.0; + } + + + /** + * + */ + SVGPathSegCurvetoQuadraticSmoothAbs(double xArg, double yArg) + { + type = PATHSEG_CURVETO_QUADRATIC_SMOOTH_ABS; + x = xArg; y = yArg; + } + + /** + * + */ + SVGPathSegCurvetoQuadraticSmoothAbs(const SVGPathSegCurvetoQuadraticSmoothAbs &other) + : SVGPathSeg(other) + { + type = PATHSEG_CURVETO_QUADRATIC_SMOOTH_ABS; + x = y = 0.0; + } + + /** + * + */ + virtual ~SVGPathSegCurvetoQuadraticSmoothAbs() {} + +protected: + + double x, y; + +}; + + + + + + +/*######################################################################### +## SVGPathSegCurvetoQuadraticSmoothRel +#########################################################################*/ + +/** + * + */ +class SVGPathSegCurvetoQuadraticSmoothRel : public SVGPathSeg +{ +public: + + /** + * + */ + virtual double getX() + { return x; } + + /** + * + */ + virtual void setX(double val) throw (DOMException) + { x = val; } + + /** + * + */ + virtual double getY() + { return y; } + + /** + * + */ + virtual void setY(double val) throw (DOMException) + { y = val; } + + + + //################## + //# Non-API methods + //################## + + /** + * + */ + SVGPathSegCurvetoQuadraticSmoothRel() + { + type = PATHSEG_CURVETO_QUADRATIC_SMOOTH_REL; + x = y = 0.0; + } + + + /** + * + */ + SVGPathSegCurvetoQuadraticSmoothRel(double xArg, double yArg) + { + type = PATHSEG_CURVETO_QUADRATIC_SMOOTH_REL; + x = xArg; y = yArg; + } + + /** + * + */ + SVGPathSegCurvetoQuadraticSmoothRel(const SVGPathSegCurvetoQuadraticSmoothRel &other) + : SVGPathSeg(other) + { + type = PATHSEG_CURVETO_QUADRATIC_SMOOTH_REL; + x = y = 0.0; + } + + /** + * + */ + virtual ~SVGPathSegCurvetoQuadraticSmoothRel() {} + +protected: + + double x, y; + +}; + + + + + + +/*######################################################################### +## SVGPathSegList +#########################################################################*/ + +/** + * + */ +class SVGPathSegList +{ +public: + + /** + * + */ + virtual unsigned long getNumberOfItems() + { return items.size(); } + + + /** + * + */ + virtual void clear () throw( DOMException ) + { items.clear(); } + + /** + * + */ + virtual SVGPathSeg initialize (const SVGPathSeg &newItem) + throw( DOMException, SVGException ) + { + items.clear(); + items.push_back(newItem); + return newItem; + } + + /** + * + */ + virtual SVGPathSeg getItem (unsigned long index) + throw( DOMException ) + { + if (index >= items.size()) + { + SVGPathSeg seg; + return seg; + } + return items[index]; + } + + /** + * + */ + virtual SVGPathSeg insertItemBefore(const SVGPathSeg &newItem, + unsigned long index ) + throw( DOMException, SVGException ) + { + if (index >= items.size()) + items.push_back(newItem); + else + { + std::vector::iterator iter = items.begin() + index; + items.insert(iter, newItem); + } + return newItem; + } + + /** + * + */ + virtual SVGPathSeg replaceItem(const SVGPathSeg &newItem, + unsigned long index ) + throw( DOMException, SVGException ) + { + if (index >= items.size()) + { + SVGPathSeg seg; + return seg; + } + std::vector::iterator iter = items.begin() + index; + *iter = newItem; + return newItem; + } + + /** + * + */ + virtual SVGPathSeg removeItem (unsigned long index) + throw (DOMException) + { + if (index >= items.size()) + { + SVGPathSeg seg; + return seg; + } + std::vector::iterator iter = items.begin() + index; + SVGPathSeg olditem = *iter; + items.erase(iter); + return olditem; + } + + /** + * + */ + virtual SVGPathSeg appendItem (const SVGPathSeg &newItem) + throw( DOMException, SVGException ) + { + items.push_back(newItem); + return newItem; + } + + + + //################## + //# Non-API methods + //################## + + /** + * + */ + SVGPathSegList() {} + + + /** + * + */ + SVGPathSegList(const SVGPathSegList &other) + { + items = other.items; + } + + + /** + * + */ + virtual ~SVGPathSegList() {} + +protected: + + std::vector items; + +}; + + + + + + +/*######################################################################### +## SVGAnimatedPathData +#########################################################################*/ + +/** + * + */ +class SVGAnimatedPathData +{ +public: + + /** + * + */ + virtual SVGPathSegList getPathSegList() + { + SVGPathSegList list; + return list; + } + + /** + * + */ + virtual SVGPathSegList getNormalizedPathSegList() + { + SVGPathSegList list; + return list; + } + + /** + * + */ + virtual SVGPathSegList getAnimatedPathSegList() + { + SVGPathSegList list; + return list; + } + + /** + * + */ + virtual SVGPathSegList getAnimatedNormalizedPathSegList() + { + SVGPathSegList list; + return list; + } + + + + //################## + //# Non-API methods + //################## + + /** + * + */ + SVGAnimatedPathData() + {} + + /** + * + */ + SVGAnimatedPathData(const SVGAnimatedPathData &/*other*/) + { + } + + /** + * + */ + virtual ~SVGAnimatedPathData() {} + +}; + + + + + + +/*######################################################################### +## SVGAnimatedPoints +#########################################################################*/ + +/** + * + */ +class SVGAnimatedPoints +{ +public: + + /** + * + */ + virtual SVGPointList getPoints() + { return points; } + + /** + * + */ + virtual SVGPointList getAnimatedPoints() + { return animatedPoints; } + + + + //################## + //# Non-API methods + //################## + + /** + * + */ + SVGAnimatedPoints() {} + + /** + * + */ + SVGAnimatedPoints(const SVGAnimatedPoints &other) + { + points = other.points; + animatedPoints = other.animatedPoints; + } + + /** + * + */ + virtual ~SVGAnimatedPoints() {} + +protected: + + SVGPointList points; + SVGPointList animatedPoints; + +}; + + + + + +/*######################################################################### +## SVGPaint +#########################################################################*/ + +/** + * + */ +class SVGPaint : public SVGColor +{ +public: + + + /** + * Paint Types + */ + typedef enum + { + SVG_PAINTTYPE_UNKNOWN = 0, + SVG_PAINTTYPE_RGBCOLOR = 1, + SVG_PAINTTYPE_RGBCOLOR_ICCCOLOR = 2, + SVG_PAINTTYPE_NONE = 101, + SVG_PAINTTYPE_CURRENTCOLOR = 102, + SVG_PAINTTYPE_URI_NONE = 103, + SVG_PAINTTYPE_URI_CURRENTCOLOR = 104, + SVG_PAINTTYPE_URI_RGBCOLOR = 105, + SVG_PAINTTYPE_URI_RGBCOLOR_ICCCOLOR = 106, + SVG_PAINTTYPE_URI = 107 + } PaintType; + + + /** + * + */ + virtual unsigned short getPaintType() + { return paintType; } + + /** + * + */ + virtual DOMString getUri() + { return uri; } + + /** + * + */ + virtual void setUri (const DOMString& uriArg ) + { uri = uriArg; } + + /** + * + */ + virtual void setPaint (unsigned short paintTypeArg, + const DOMString& uriArg, + const DOMString& /*rgbColor*/, + const DOMString& /*iccColor*/ ) + throw( SVGException ) + { + paintType = paintTypeArg; + uri = uriArg; + //do something with rgbColor + //do something with iccColor; + } + + + + //################## + //# Non-API methods + //################## + + /** + * + */ + SVGPaint() + { + uri = ""; + paintType = SVG_PAINTTYPE_UNKNOWN; + } + + /** + * + */ + SVGPaint(const SVGPaint &other) : css::CSSValue(other), SVGColor(other) + { + uri = ""; + paintType = SVG_PAINTTYPE_UNKNOWN; + } + + /** + * + */ + virtual ~SVGPaint() {} + +protected: + + unsigned int paintType; + DOMString uri; + +}; + + + + +/*######################################################################### +## SVGColorProfileRule +#########################################################################*/ + +/** + * + */ +class SVGColorProfileRule : public SVGCSSRule, + public SVGRenderingIntent +{ + +public: + /** + * + */ + virtual DOMString getSrc() + { return src; } + + /** + * + */ + virtual void setSrc(const DOMString &val) throw (DOMException) + { src = val; } + + /** + * + */ + virtual DOMString getName() + { return name; } + + /** + * + */ + virtual void setName(const DOMString &val) throw (DOMException) + { name = val; } + + /** + * + */ + virtual unsigned short getRenderingIntent() + { return renderingIntent; } + + /** + * + */ + virtual void setRenderingIntent(unsigned short val) throw (DOMException) + { renderingIntent = val; } + + + //################## + //# Non-API methods + //################## + + /** + * + */ + SVGColorProfileRule() {} + + /** + * + */ + SVGColorProfileRule(const SVGColorProfileRule &other) + : SVGCSSRule(other), SVGRenderingIntent(other) + { + renderingIntent = other.renderingIntent; + src = other.src; + name = other.name; + } + + /** + * + */ + virtual ~SVGColorProfileRule() {} + +protected: + + unsigned short renderingIntent; + DOMString src; + DOMString name; + +}; + + + +/*######################################################################### +## SVGFilterPrimitiveStandardAttributes +#########################################################################*/ + +/** + * + */ +class SVGFilterPrimitiveStandardAttributes : public SVGStylable +{ +public: + + + + /** + * + */ + virtual SVGAnimatedLength getX() + { return x; } + + /** + * + */ + virtual SVGAnimatedLength getY() + { return y; } + + /** + * + */ + virtual SVGAnimatedLength getWidth() + { return width; } + + /** + * + */ + virtual SVGAnimatedLength getHeight() + { return height; } + + /** + * + */ + virtual SVGAnimatedString getResult() + { return result; } + + + + //################## + //# Non-API methods + //################## + + + /** + * + */ + SVGFilterPrimitiveStandardAttributes() + {} + + /** + * + */ + SVGFilterPrimitiveStandardAttributes(const SVGFilterPrimitiveStandardAttributes &other) + : SVGStylable(other) + { + x = other.x; + y = other.y; + width = other.width; + height = other.height; + result = other.result; + } + + /** + * + */ + virtual ~SVGFilterPrimitiveStandardAttributes() {} + +protected: + + SVGAnimatedLength x; + SVGAnimatedLength y; + SVGAnimatedLength width; + SVGAnimatedLength height; + SVGAnimatedString result; + +}; + + + + + + + + + + + +/*######################################################################### +## SVGEvent +#########################################################################*/ + +/** + * + */ +class SVGEvent : events::Event +{ +public: + + //################## + //# Non-API methods + //################## + + /** + * + */ + SVGEvent() {} + + /** + * + */ + SVGEvent(const SVGEvent &other) : events::Event(other) + {} + + /** + * + */ + virtual ~SVGEvent() {} + +}; + + + + +/*######################################################################### +## SVGZoomEvent +#########################################################################*/ + +/** + * + */ +class SVGZoomEvent : events::UIEvent +{ +public: + + /** + * + */ + virtual SVGRect getZoomRectScreen() + { return zoomRectScreen; } + + /** + * + */ + virtual double getPreviousScale() + { return previousScale; } + + /** + * + */ + virtual SVGPoint getPreviousTranslate() + { return previousTranslate; } + + /** + * + */ + virtual double getNewScale() + { return newScale; } + + /** + * + */ + virtual SVGPoint getNewTranslate() + { return newTranslate; } + + + + //################## + //# Non-API methods + //################## + + /** + * + */ + SVGZoomEvent() + {} + + /** + * + */ + SVGZoomEvent(const SVGZoomEvent &other) : events::Event(other), + events::UIEvent(other) + { + zoomRectScreen = other.zoomRectScreen; + previousScale = other.previousScale; + previousTranslate = other.previousTranslate; + newScale = other.newScale; + newTranslate = other.newTranslate; + } + + /** + * + */ + virtual ~SVGZoomEvent() {} + +protected: + + SVGRect zoomRectScreen; + double previousScale; + SVGPoint previousTranslate; + double newScale; + SVGPoint newTranslate; + +}; + + + +/*######################################################################### +## SVGElementInstance +#########################################################################*/ + +/** + * + */ +class SVGElementInstance : public events::EventTarget +{ +public: + + /** + * + */ + virtual SVGElementPtr getCorrespondingElement() + { return correspondingElement; } + + /** + * + */ + virtual SVGUseElementPtr getCorrespondingUseElement() + { return correspondingUseElement; } + + /** + * + */ + virtual SVGElementInstance getParentNode() + { + SVGElementInstance ret; + return ret; + } + + /** + * Since we are using stack types and this is a circular definition, + * we will instead implement this as a global function below: + * SVGElementInstanceList getChildNodes(const SVGElementInstance instance); + */ + //virtual SVGElementInstanceList getChildNodes(); + + /** + * + */ + virtual SVGElementInstance getFirstChild() + { + SVGElementInstance ret; + return ret; + } + + /** + * + */ + virtual SVGElementInstance getLastChild() + { + SVGElementInstance ret; + return ret; + } + + /** + * + */ + virtual SVGElementInstance getPreviousSibling() + { + SVGElementInstance ret; + return ret; + } + + /** + * + */ + virtual SVGElementInstance getNextSibling() + { + SVGElementInstance ret; + return ret; + } + + + //################## + //# Non-API methods + //################## + + /** + * + */ + SVGElementInstance() {} + + /** + * + */ + SVGElementInstance(const SVGElementInstance &other) + : events::EventTarget(other) + { + } + + /** + * + */ + virtual ~SVGElementInstance() {} + +protected: + + SVGElementPtr correspondingElement; + SVGUseElementPtr correspondingUseElement; + +}; + + + + + + +/*######################################################################### +## SVGElementInstanceList +#########################################################################*/ + +/** + * + */ +class SVGElementInstanceList +{ +public: + + + /** + * + */ + virtual unsigned long getLength() + { return items.size(); } + + /** + * + */ + virtual SVGElementInstance item (unsigned long index ) + { + if (index >= items.size()) + { + SVGElementInstance ret; + return ret; + } + return items[index]; + } + + /** + * This static method replaces the circular definition of: + * SVGElementInstanceList SVGElementInstance::getChildNodes() + * + */ + static SVGElementInstanceList getChildNodes(const SVGElementInstance &/*instance*/) + { + SVGElementInstanceList list; + return list; + } + + + //################## + //# Non-API methods + //################## + + /** + * + */ + SVGElementInstanceList() {} + + /** + * + */ + SVGElementInstanceList(const SVGElementInstanceList &other) + { + items = other.items; + } + + /** + * + */ + virtual ~SVGElementInstanceList() {} + +protected: + + std::vector items; + + +}; + + +/** + * This is a helper class that will hold several types of data. It will + * be used in those situations where methods are common to different + * interfaces, except for the data type. + */ +class SVGValue +{ +public: + + typedef enum + { + SVG_DOUBLE, + SVG_INT, + SVG_STRING + }SVGValueType; + + SVGValue(long v) + { + init(); + ival = d; + type = SVG_INT; + } + + SVGValue(double v) + { + init(); + dval = v; + type = SVG_DOUBLE; + } + + SVGValue(const DOMString &v) + { + init(); + sval = v; + type = SVG_STRING; + } + + SVGValue(const SVGValue &other) + { + assign(other); + } + + SVGValue &operator=(const SVGValue &other) + { + assign(other); + return *this; + } + + SVGValue &operator=(long v) + { + init(); + ival = v; + type = SVG_INT; + return *this; + } + + SVGValue &operator=(double v) + { + init(); + ival = v; + type = SVG_DOUBLE; + return *this; + } + + SVGValue &operator=(const DOMString &v) + { + init(); + sval = v; + type = SVG_STRING; + return *this; + } + + ~SVGValue() + {} + + long intValue() + { return ival; } + + double doubleValue() + { return ival; } + + DOMString &stringValue() + { return sval; } + + +private: + + void init() + { + type = SVG_DOUBLE; + ival = 0; + dval = 0.0; + sval = ""; + } + + void assign(const SVGValue &other) + { + type = other.type; + ival = other.ival; + dval = other.dval; + sval = other.sval; + } + + int type; + double dval; + long ival; + DOMString sval; + +}; + + + +//######################################################################## +//######################################################################## +//######################################################################## +//# D O M +//######################################################################## +//######################################################################## +//######################################################################## + + + + + /*######################################################################### ## Types #########################################################################*/ -- 2.30.2